From 2b046829ac4c09b7e62acfd4242af31f3535c055 Mon Sep 17 00:00:00 2001 From: EhsannKh Date: Fri, 21 May 2021 07:09:17 +0200 Subject: [PATCH 01/76] New message for the combined commit --- .vscode/launch.json | 14 + Artery.py | 8 +- Atrium.py | 336 ++++++++++ Dataset.csv | 220 +++++++ Parabolic.py | 220 +++++++ .../automatedPreProcessing.py | 2 +- .../automatedPreProcessing_test.py | 599 ++++++++++++++++++ postprocessing/compute_wss.py | 7 +- postprocessing/postprocessing_common.py | 3 +- test/Case_test_atrium_07/case_test_at_07.vtp | 51 ++ test/processed_model.png | Bin 192857 -> 0 bytes test/test_pre_processing.py | 36 -- 12 files changed, 1449 insertions(+), 47 deletions(-) create mode 100644 .vscode/launch.json create mode 100755 Atrium.py create mode 100644 Dataset.csv create mode 100644 Parabolic.py create mode 100644 automatedPreProcessing/automatedPreProcessing_test.py create mode 100644 test/Case_test_atrium_07/case_test_at_07.vtp delete mode 100644 test/processed_model.png delete mode 100644 test/test_pre_processing.py diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 00000000..d01f4381 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,14 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Python: Attach using Process Id", + "type": "python", + "request": "attach", + "processId": "${command:pickProcess}" + } + ] +} \ No newline at end of file diff --git a/Artery.py b/Artery.py index c90f3b78..0d9fdbb3 100755 --- a/Artery.py +++ b/Artery.py @@ -34,7 +34,7 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n dump_stats=100, store_data=5, store_data_tstep=10000, # Start storing data at 2nd cycle - save_step=10000, + save_step=200, checkpoint=500, print_intermediate_info=100, folder="results_artery", @@ -240,13 +240,11 @@ def temporal_hook(u_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, id_in, def beta(err, p): """ Adjusted choice of beta from - Gin and Steinman et al., A Dual-Pressure Boundary Condition doi:10.1115/1.1504446  + Gin and Steinman et al., A Dual-Pressure Boundary Condition doi:10.1115/1.1504446 Ramped up to desired value if flow rate error (err) increases - Args: err (float): Flow split error p (float): Pressure value - Returns: beta (float): Variable factor in flow split method """ @@ -307,4 +305,4 @@ def update_pressure_condition(NS_expressions, area_ratio, boundary, id_in, id_ou else: NS_expressions[out_id].p = p_old * beta(R_err, p_old) * M_err ** E - return Q_ideals, Q_in, Q_outs + return Q_ideals, Q_in, Q_outs \ No newline at end of file diff --git a/Atrium.py b/Atrium.py new file mode 100755 index 00000000..4a57ce62 --- /dev/null +++ b/Atrium.py @@ -0,0 +1,336 @@ +import json +import os +import pickle +from os import path, makedirs +import csv + +import numpy as np +from numpy.core.fromnumeric import mean +from Womersley import make_womersley_bcs, compute_boundary_geometry_acrn +#from Parabolic import make_parabolic_bcs, compute_boundary_geometry_acrn + +from fenicstools import Probes +from oasis.problems.NSfracStep import * + +set_log_level(50) + + +def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_namespace): + if "restart_folder" in commandline_kwargs.keys(): + restart_folder = commandline_kwargs["restart_folder"] + f = open(path.join(restart_folder, 'params.dat'), 'rb') + NS_parameters.update(pickle.load(f)) + NS_parameters['restart_folder'] = restart_folder + else: + # Override some problem specific parameters + # parameters are in mm and ms + NS_parameters.update( + # Fluid parameters + nu=3.5e-3, # Viscosity + # Geometry parameters + id_in=[], # Inlet boundary ID + id_out=[], # Outlet boundary IDs + area_ratio=[], + # Simulation parameters + T=1045, # Run simulation for 1 cardiac cycles [ms] + dt=0.1, # 10 000 steps per cycle [ms] + no_of_cycles=1, + dump_stats=100, + store_data=5, + store_data_tstep=1000, # Start storing data at 2nd cycle + save_step=200, + checkpoint=5000, + print_intermediate_info=100, + folder="results_atrium", + mesh_path=commandline_kwargs["mesh_path"], + # Solver parameters + velocity_degree=1, + pressure_degree=1, + use_krylov_solvers=True, + krylov_solvers=dict(monitor_convergence=False), + dim_MV = [], + dim_PV = [] + ) + + mesh_file = NS_parameters["mesh_path"].split("/")[-1] + case_name = mesh_file.split(".")[0] + NS_parameters["folder"] = path.join(NS_parameters["folder"], case_name) + + +def mesh(mesh_path, **NS_namespace): + # Read mesh + return Mesh(mesh_path) + + +def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, id_out, pressure_degree, **NS_namespace): + # Mesh function + boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) + boundary.set_values(boundary.array() + 1) + + id_in = [2,3,5,6] # Hardcoded. FIXIT: automated prepocessing + id_out = [4] + + # Read case parameters + info_path = mesh_path.split(".")[0] + ".json" + with open(info_path) as f: + info = json.load(f) + + # Extract flow split ratios and inlet/outlet IDs + id_info = info['idFileLine'].split() + #id_out.append(int(id_info[1])) + #id_in[:] = [int(p) for p in id_info[2].split(",")] + area_ratio[:] = [float(p) for p in info['areaRatioLine'].split()[-1].split(",")] + + area_in = np.array([info['outlet0_area'],info['outlet1_area'],info['outlet2_area'],info['outlet3_area']]) + area_out = np.array([info['inlet_area']]) + dim_MV = np.sqrt(4*area_in.max()/np.pi) #[mm] + dim_PV = np.sqrt(4*area_out/np.pi) + NS_parameters['dim_MV'] = dim_MV + NS_parameters['dim_PV'] = dim_PV + + Q_mean = 20 # [ml] + t_values, Q_ = np.load(path.join(path.dirname(path.abspath(__file__)), "ICA_values")) + Q_values = Q_mean * Q_ + t_values *= 1000 + + # t_values , V_values = [], [] + # try: + # with open(path.join(path.dirname(path.abspath(__file__)), "Dataset.csv")) as csvfile: + # csvReader = csv.reader(csvfile) + # for row in csvReader: + # t_values.append(float(row[0])*1000) #convert to ms + # V_values.append(float(row[1])) + # except ValueError: + # raise + + bc_inlets = {} + for i, ID in enumerate(id_in): + tmp_area, tmp_center, tmp_radius, tmp_normal = compute_boundary_geometry_acrn(mesh, id_in[i], boundary) + inlet = make_womersley_bcs(t_values, Q_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element()) + #inlet = make_parabolic_bcs(t_values, V_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element(),coeffstype="V") + NS_expressions[ID] = inlet + bc_inlet = [DirichletBC(V, inlet[i], boundary, ID) for i in range(3)] + bc_inlets[ID] = bc_inlet + # Set start time equal to t_0 + for uc in inlet: + uc.set_t(t) + + bc_p = [] + for i, ID in enumerate(id_out): + bc = DirichletBC(Q, Constant(0.0), boundary, ID) + bc_p.append(bc) + NS_expressions['P'] = bc + + # No slip condition at wall + wall = Constant(0.0) + # Create Boundary conditions for the wall + bc_wall = DirichletBC(V, wall, boundary, 1) + + # Need to be updated if there are more than four inlets + return dict(u0=[bc_inlets[id_in[0]][0], bc_inlets[id_in[1]][0], bc_inlets[id_in[2]][0], bc_inlets[id_in[3]][0], bc_wall], + u1=[bc_inlets[id_in[0]][1], bc_inlets[id_in[1]][1], bc_inlets[id_in[2]][1], bc_inlets[id_in[3]][1], bc_wall], + u2=[bc_inlets[id_in[0]][2], bc_inlets[id_in[1]][2], bc_inlets[id_in[2]][2], bc_inlets[id_in[3]][2], bc_wall], + p=bc_p) + + +def get_file_paths(folder): + # Create folder where data and solutions (velocity, mesh, pressure) is stored + common_path = path.join(folder, "VTK") + if MPI.rank(MPI.comm_world) == 0: + if not path.exists(common_path): + makedirs(common_path) + + file_p = path.join(common_path, "p.h5") + file_u = [path.join(common_path, "u{}.h5".format(i)) for i in range(3)] + file_mesh = path.join(common_path, "mesh.h5") + files = {"u": file_u, "p": file_p, "mesh": file_mesh} + + return files + + +def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, **NS_namespace): + # Create point for evaluation + boundary = MeshFunction("size_t", mesh, 2, mesh.domains()) + n = FacetNormal(mesh) + eval_dict = {} + rel_path = mesh_path.split(".")[0] + "_probe_point" + probe_points = np.load(rel_path, encoding='latin1', fix_imports=True, allow_pickle=True) + + # Store points file in checkpoint + if MPI.rank(MPI.comm_world) == 0: + probe_points.dump(path.join(newfolder, "Checkpoint", "points")) + + eval_dict["centerline_u_x_probes"] = Probes(probe_points.flatten(), V) + eval_dict["centerline_u_y_probes"] = Probes(probe_points.flatten(), V) + eval_dict["centerline_u_z_probes"] = Probes(probe_points.flatten(), V) + eval_dict["centerline_p_probes"] = Probes(probe_points.flatten(), Q) + + if restart_folder is None: + # Get files to store results + files = get_file_paths(newfolder) + NS_parameters.update(dict(files=files)) + else: + files = NS_namespace["files"] + + # Save mesh as HDF5 file + with HDF5File(MPI.comm_world, files["mesh"], "w") as mesh_file: + mesh_file.write(mesh, "mesh") + + h = EdgeLength(mesh) + + return dict(eval_dict=eval_dict, boundary=boundary, n=n, h=h) + + +def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, id_in, id_out, boundary, n, store_data, + NS_parameters, NS_expressions, area_ratio, dt, t, store_data_tstep, **NS_namespace): + + boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) + boundary.set_values(boundary.array() + 1) + + id_in = [2,3,5,6] # Hardcoded. FIXIT: automated prepocessing + id_out = [4] + + # Update boundary condition + for i, in_id in enumerate(id_in): + for uc in NS_expressions[in_id]: + uc.set_t(t) + + # Compute flux and update pressure condition + if tstep > 2: + Q_ideals, Q_in, Q_ins, Q_out, V_out, V_ins = compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh, n, + tstep, u_, newfolder, t) + + DG = FunctionSpace(mesh, "DG", 0) + U = project(sqrt(inner(u_, u_)), DG) + + cfl = U.vector().get_local() * dt / h #Check the used unit in calculating cfl before running simulation + + max_cfl = cfl.max() + min_cfl = cfl.min() + + dim_MV = NS_parameters['dim_MV'] + dim_PV = NS_parameters['dim_PV'] + + # Re = U.vector().get_local() * dim_MV / NS_parameters['nu'] + # Re_MV = Re.max()*1000 + # Re_ = U.vector().get_local() * dim_PV / NS_parameters['nu'] + # Re_PV = Re_.max()*1000 + + if MPI.rank(MPI.comm_world) == 0 and tstep % 10 == 0: + print("=" * 10, tstep, "=" * 10) + print() + # info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}, Re_PV={0:2.4e}, Re_MV={0:2.4e}' + # .format(t, tstep, max_cfl, min_cfl, Re_PV, Re_MV)) + info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}' + .format(t, tstep, max_cfl, min_cfl)) + print("Sum of Q_in = {:0.4f} Q_out = {:0.4f}".format(sum(Q_ins), Q_out)) + #for i, in_id in enumerate(id_in): + # print(("({:d}) New pressure {:0.4f}").format(out_id, NS_expressions[out_id].p)) + # for i, in_id in enumerate(id_out): + # print(("({:d}) area ratio {:0.4f}, ideal: {:0.4f} actual:" + + # " {:0.4f}").format(in_id, area_ratio[i], Q_ideals[i], Q_ins[i])) + print() + + + if MPI.rank(MPI.comm_world) == 0 and tstep > 2: + velocity_path = path.join(newfolder, "Timeseries", "velocity.txt") + if not path.isdir(path.join(newfolder, "Timeseries")): + os.mkdir(path.join(newfolder, "Timeseries")) + with open(velocity_path, 'a') as filename: + filename.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, V_out, V_ins[0], V_ins[1], V_ins[2], V_ins[3])) + + # Sample velocity in points + eval_dict["centerline_u_x_probes"](u_[0]) + eval_dict["centerline_u_y_probes"](u_[1]) + eval_dict["centerline_u_z_probes"](u_[2]) + eval_dict["centerline_p_probes"](p_) + + # Store sampled velocity + if tstep % dump_stats == 0: + filepath = path.join(newfolder, "Stats") + if MPI.rank(MPI.comm_world) == 0: + if not path.exists(filepath): + makedirs(filepath) + + arr_u_x = eval_dict["centerline_u_x_probes"].array() + arr_u_y = eval_dict["centerline_u_y_probes"].array() + arr_u_z = eval_dict["centerline_u_z_probes"].array() + arr_p = eval_dict["centerline_p_probes"].array() + + #Dump stats + if MPI.rank(MPI.comm_world) == 0: + arr_u_x.dump(path.join(filepath, "u_x_%s.probes" % str(tstep))) + arr_u_y.dump(path.join(filepath, "u_y_%s.probes" % str(tstep))) + arr_u_z.dump(path.join(filepath, "u_z_%s.probes" % str(tstep))) + arr_p.dump(path.join(filepath, "p_%s.probes" % str(tstep))) + + #Clear stats + MPI.barrier(MPI.comm_world) + eval_dict["centerline_u_x_probes"].clear() + eval_dict["centerline_u_y_probes"].clear() + eval_dict["centerline_u_z_probes"].clear() + eval_dict["centerline_p_probes"].clear() + + # Save velocity and pressure + if tstep % store_data == 0 and tstep >= store_data_tstep: + # Name functions + u_[0].rename("u0", "velocity-x") + u_[1].rename("u1", "velocity-y") + u_[2].rename("u2", "velocity-z") + p_.rename("p", "pressure") + + # Get save paths + files = NS_parameters['files'] + file_mode = "w" if tstep == store_data_tstep else "a" + p_path = files['p'] + + # Save + viz_p = HDF5File(MPI.comm_world, p_path, file_mode=file_mode) + viz_p.write(p_, "/pressure", tstep) + viz_p.close() + + for i in range(3): + u_path = files['u'][i] + viz_u = HDF5File(MPI.comm_world, u_path, file_mode=file_mode) + viz_u.write(u_[i], "/velocity", tstep) + viz_u.close() + + +def compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh, n, tstep, u_, newfolder,t): + + V = FunctionSpace(mesh, "DG", 1) + f = Function(V) + f.vector()[:] = 1. + + Q_out = abs(assemble(dot(u_, n) * ds(id_out[0], domain=mesh, subdomain_data=boundary))) + dso = assemble(f*ds(id_out[0], domain=mesh, subdomain_data=boundary)) + V_out = Q_out/ dso + + f.vector()[:] = 1. + Q_ins = [] + Q_ideals = [] + V_ins = [] + for i, in_id in enumerate(id_in): + Q_in = abs(assemble(dot(u_, n) * ds(in_id, domain=mesh, subdomain_data=boundary))) + dsi = assemble(f*ds(in_id, domain=mesh, subdomain_data=boundary)) + V_in = Q_in / dsi + Q_ins.append(Q_in) + V_ins.append(V_in) + Q_ideal = area_ratio[i] * Q_in #FIXIT: area_ratio + Q_ideals.append(Q_ideal) + + return Q_ideals, Q_in, Q_ins, Q_out, V_out, V_ins + +def EdgeLength(mesh): + # Compute edge length + DG = FunctionSpace(mesh, "DG", 0) + circumradius = Circumradius(mesh) + circumradius_DG = project(circumradius, DG).vector()[:] + + if mesh.geometry().dim() == 2: + edge_length = circumradius_DG * 2 + elif mesh.geometry().dim() == 3: + edge_length = circumradius_DG * sqrt(8 / 3) + + return edge_length + diff --git a/Dataset.csv b/Dataset.csv new file mode 100644 index 00000000..50c13c51 --- /dev/null +++ b/Dataset.csv @@ -0,0 +1,220 @@ +0.001140250855188,0.168889733519152 +0.010262257696693,0.171118712783479 +0.013683010262258,0.171861987415009 +0.017103762827822,0.17334600278728 +0.020524515393387,0.174830018159551 +0.025085518814139,0.176314878162085 +0.028506271379704,0.178539634275096 +0.033067274800456,0.181505975759111 +0.036488027366021,0.182989991131382 +0.039908779931585,0.185214747244394 +0.042189281641961,0.187438658727142 +0.046750285062714,0.191145740951898 +0.050171037628278,0.194111237805651 +0.053591790193843,0.197817475400144 +0.058152793614595,0.200783816884159 +0.06157354618016,0.204490054478652 +0.064994298745724,0.209677773554626 +0.0672748004561,0.213383166518856 +0.071835803876853,0.217830989484353 +0.075256556442417,0.222277967819587 +0.07981755986317,0.225985050044343 +0.083238312428734,0.232654250601799 +0.088939566704675,0.240806621901263 +0.091220068415051,0.246734237087715 +0.096921322690992,0.254145867646438 +0.100342075256556,0.258592845981672 +0.101482326111745,0.260815912834157 +0.103762827822121,0.263039824316905 +0.106043329532497,0.267485958021876 +0.108323831242873,0.270450610245365 +0.11060433295325,0.273415262468854 +0.115165336374002,0.280085307656573 +0.118586088939567,0.283791545251066 +0.119726339794755,0.287496093585033 +0.123147092360319,0.289720849698045 +0.125427594070696,0.292685501921534 +0.12884834663626,0.297132480256768 +0.132269099201824,0.300838717851261 +0.136830102622577,0.306027281557498 +0.14139110604333,0.311956586004477 +0.144811858608894,0.31640356433971 +0.150513112884835,0.322333713416952 +0.156214367160775,0.326782381012712 +0.15963511972634,0.329747877866464 +0.163055872291904,0.332713374720216 +0.166476624857469,0.336419612314709 +0.171037628278221,0.339385953798725 +0.175598631698974,0.340870813801259 +0.180159635119726,0.343837155285274 +0.184720638540479,0.345322015287808 +0.19042189281642,0.346807719920605 +0.19612314709236,0.34681194307192 +0.202964652223489,0.346817010853499 +0.210946408209806,0.3460821825246 +0.217787913340935,0.344605768824697 +0.224629418472064,0.343129355124794 +0.230330672748005,0.338689133831665 +0.234891676168757,0.335729549389755 +0.23945267958951,0.333510705688585 +0.24515393386545,0.329811225136197 +0.248574686431015,0.325369314582541 +0.253135689851767,0.320187507918409 +0.255416191562144,0.315744752734491 +0.261117445838084,0.310563790700621 +0.264538198403649,0.307603361628447 +0.266818700114025,0.301679124963047 +0.271379703534778,0.297978799780396 +0.27594070695553,0.292796993116263 +0.280501710376283,0.287615186452131 +0.285062713797035,0.282433379787998 +0.287343215507412,0.279472106085561 +0.290763968072976,0.274289454791165 +0.291904218928164,0.270586595717725 +0.295324971493729,0.265403944423329 +0.299885974914481,0.258740656277714 +0.305587229190422,0.254300434984585 +0.307867730900798,0.248376198319186 +0.312428734321551,0.242453650914312 +0.316989737742303,0.237271844250179 +0.320410490307868,0.231348452215043 +0.326111744583808,0.225426749440432 +0.330672748004561,0.217281979813337 +0.334093500570125,0.212840069259682 +0.339794754846066,0.207659107225812 +0.346636259977195,0.200256767599983 +0.353477765108324,0.195076650196377 +0.356898517673888,0.191375480383462 +0.361459521094641,0.186193673719329 +0.367160775370582,0.183234933907682 +0.372862029646522,0.180276194096034 +0.377423033067275,0.175835128172642 +0.381984036488027,0.174357025212213 +0.385404789053592,0.17213733688078 +0.388825541619156,0.170658389290088 +0.392246294184721,0.169179441699396 +0.394526795895097,0.169181130959922 +0.397947548460661,0.169183664850712 +0.399087799315849,0.170665990962456 +0.403648802736602,0.17215085096499 +0.40478905359179,0.173633177076735 +0.407069555302166,0.171412644115039 +0.411630558722919,0.171416022636091 +0.416191562143672,0.169937919675662 +0.424173318129989,0.169943832087504 +0.431014823261117,0.170689640609823 +0.436716077537058,0.17217534524262 +0.442417331812999,0.173661049875417 +0.450399087799316,0.176629925250222 +0.458380843785633,0.181080282106508 +0.462941847206385,0.185528105072005 +0.467502850627138,0.189975928037502 +0.470923603192702,0.192200684150513 +0.475484606613455,0.197389247856751 +0.480045610034208,0.201837070822248 +0.483466362599772,0.207765530638963 +0.485746864310148,0.213693145825415 +0.490307867730901,0.217400228050171 +0.493728620296465,0.221847206385405 +0.500570125427594,0.230000422315132 +0.503990877993159,0.235928882131847 +0.508551881413911,0.241858186578825 +0.513112884834664,0.247046750285063 +0.51539338654504,0.250752143249293 +0.518814139110604,0.258162084547489 +0.522234891676169,0.266312766586427 +0.52793614595211,0.272242915663668 +0.532497149372862,0.278912960851387 +0.538198403648803,0.287065332150851 +0.541619156214367,0.295956754930529 +0.545039908779932,0.301885214747244 +0.548460661345496,0.310035896786182 +0.555302166476625,0.320411334938131 +0.561003420752566,0.329304446978335 +0.567844925883694,0.336716922167321 +0.573546180159635,0.344869293466785 +0.578107183580388,0.353761560876726 +0.583808437856328,0.36191393217619 +0.590649942987457,0.368585666624435 +0.59521094640821,0.375255711812154 +0.600912200684151,0.381185860889396 +0.604332953249715,0.385632839224629 +0.612314709236032,0.390823936821656 +0.616875712656785,0.396753241268635 +0.624857468643101,0.401203598124921 +0.63169897377423,0.404912369610203 +0.640820980615735,0.40714134887453 +0.652223489167617,0.407890535917902 +0.661345496009122,0.408638033700747 +0.670467502850627,0.404941087039149 +0.678449258836944,0.401243295747287 +0.685290763968073,0.39606317834368 +0.692132269099202,0.389401579458592 +0.696693272519954,0.383479032053718 +0.702394526795895,0.377557329279108 +0.709236031927024,0.371636471134761 +0.716077537058153,0.36275265002745 +0.721778791334094,0.355349465771359 +0.727480045610034,0.347205540774526 +0.732041049030787,0.339801511888171 +0.736602052451539,0.333138223742557 +0.74230330672748,0.322772076523502 +0.746864310148233,0.314627306896406 +0.753705815279361,0.306484226529837 +0.758266818700114,0.296857975421259 +0.763968072976055,0.288714050424427 +0.770809578107184,0.276867266354153 +0.775370581527936,0.268722496727058 +0.781071835803877,0.261319312470966 +0.784492588369441,0.253914438954348 +0.789053591790194,0.246510410067993 +0.795895096921323,0.237626588960682 +0.800456100342075,0.230963300815068 +0.807297605473204,0.221338738967017 +0.811858608893957,0.213193969339921 +0.818700114025086,0.206532370454833 +0.824401368301026,0.198388445458001 +0.830102622576967,0.19172600194265 +0.835803876852908,0.187285780649521 +0.843785632839225,0.182106507876177 +0.847206385404789,0.178405338063263 +0.851767388825542,0.173964272139871 +0.855188141391106,0.170263102326956 +0.859749144811858,0.165822036403564 +0.864310148232611,0.160640229739432 +0.872291904218928,0.153979475484607 +0.876852907639681,0.142131002153807 +0.882554161915622,0.12954263271253 +0.88939566704675,0.116955107901516 +0.892816419612315,0.107328012162676 +0.896237172177879,0.099182397905317 +0.899657924743443,0.090296042907217 +0.903078677309008,0.082150428649859 +0.904218928164196,0.072521643650492 +0.908779931584949,0.063636133282656 +0.911060433295325,0.054748933654293 +0.914481185860889,0.047344060137675 +0.919042189281642,0.036236327547616 +0.925883694412771,0.025130284218084 +0.930444697833523,0.015504033109506 +0.937286202964652,0.008842434224418 +0.941847206385405,0.005142109041767 +0.948688711516533,0.003665695341864 +0.956670467502851,0.005893829975928 +0.962371721778791,0.010342497571688 +0.968072976054732,0.014791165167448 +0.973774230330673,0.024425017948393 +0.980615735461802,0.034800456100342 +0.982896237172178,0.045913256471979 +0.988597491448118,0.059250812956628 +0.992018244013683,0.072586680180751 +0.998859749144812,0.080739896110478 +1.00456100342075,0.096299674817349 +1.00684150513113,0.105190252966764 +1.01254275940707,0.117787068710672 +1.01596351197263,0.12667849149035 +1.01710376282782,0.136308965750243 +1.0285062713797,0.149650745386207 +1.03420752565564,0.157803116685671 +1.03990877993159,0.163733265762912 +1.04446978335234,0.168181088728409 diff --git a/Parabolic.py b/Parabolic.py new file mode 100644 index 00000000..8e464072 --- /dev/null +++ b/Parabolic.py @@ -0,0 +1,220 @@ +# This file is modified and simplified from Womersely + + +from dolfin import (UserExpression, Mesh, MeshFunction, SubsetIterator, MPI, ds, +assemble, Constant, sqrt, FacetNormal, as_vector, SpatialCoordinate) + +import numpy as np + +from scipy.interpolate import UnivariateSpline +from scipy.integrate import simps, romberg +from scipy.special import jn +import math + +def x_to_r2(x, c, n): + """Compute r**2 from a coordinate x, center point c, and normal vector n. + + r is defined as the distance from c to x', where x' is + the projection of x onto the plane defined by c and n. + """ + # Steps: + # rv = x - c + # rvn = rv . n + # rp = rv - (rv . n) n + # r2 = ||rp||**2 + + rv = x-c + rvn = rv.dot(n) + rp = rv - rvn*n + r2 = rp.dot(rp) + + return r2 + +def compute_radius(mesh, facet_domains, ind, center): + d = len(center) + it = SubsetIterator(facet_domains, ind) + geom = mesh.geometry() + #maxr2 = -1.0 + maxr2 = 0 + for i, facet in enumerate(it): + ent = facet.entities(0) + for v in ent: + p = geom.point(v) + r2 = sum((p[j] - center[j])**2 for j in range(d)) + maxr2 = max(maxr2, r2) + r = MPI.max(MPI.comm_world, sqrt(maxr2)) + return r + + +def compute_boundary_geometry_acrn(mesh, ind, facet_domains): + # Some convenient variables + assert facet_domains is not None + dsi = ds(ind, domain=mesh, subdomain_data=facet_domains) + + d = mesh.geometry().dim() + x = SpatialCoordinate(mesh) + + # Compute area of boundary tesselation by integrating 1.0 over all facets + A = assemble(Constant(1.0, name="one")*dsi) + #assert A > 0.0, "Expecting positive area, probably mismatch between mesh and markers!" + if A == 0: + return None + + # Compute barycenter by integrating x components over all facets + c = [assemble(x[i]*dsi) / A for i in range(d)] + + # Compute average normal (assuming boundary is actually flat) + n = FacetNormal(mesh) + ni = np.array([assemble(n[i]*dsi) for i in range(d)]) + n_len = np.sqrt(sum([ni[i]**2 for i in range(d)])) # Should always be 1!? + normal = ni/n_len + + # Compute radius by taking max radius of boundary points + # (assuming boundary points are on exact geometry) + # r = compute_radius(mesh, facet_domains, ind, c) + # This old estimate is a few % lower because of boundary discretization errors + r = np.sqrt(A / math.pi) + + return A, c, r, normal + + +def compute_area(mesh, ind, facet_domains): + # Some convenient variables + assert facet_domains is not None + dsi = ds(ind, domain=mesh, subdomain_data=facet_domains) + + # Compute area of boundary tesselation by integrating 1.0 over all facets + A = assemble(Constant(1.0, name="one")*dsi) + assert A > 0.0, "Expecting positive area, probably mismatch between mesh and markers!" + return A + + +def fourier_coefficients(x, y, T, N): + '''From x-array and y-spline and period T, calculate N complex Fourier coefficients.''' + omega = 2*np.pi/T + ck = [] + ck.append(1/T*simps(y(x), x)) + for n in range(1,N): + c = 1/T*simps(y(x)*np.exp(-1j*n*omega*x), x) + + # Clamp almost zero real and imag components to zero + if 1: + cr = c.real + ci = c.imag + if abs(cr) < 1e-14: cr = 0.0 + if abs(ci) < 1e-14: ci = 0.0 + c = cr + ci*1j + + ck.append(2*c) + return ck + + +class ParabolicComponent(UserExpression): + # Subclassing the expression class restricts the number of arguments, args + # is therefore a dict of arguments. + def __init__(self, radius, center, normal, normal_component, period, nu, element, Q=None, + V=None): + # Spatial args + self.radius = radius + self.center = center + self.normal = normal + self.normal_component = normal_component + + # Temporal args + self.period = period + if Q is not None: + assert V is None, "Cannot provide both Q and V!" + self.Qn = Q + self.N = len(self.Qn) + elif V is not None: + self.Vn = V + self.N = len(self.Vn) + else: + raise ValueError("Invalid transient data type, missing argument 'Q' or 'V'.") + + self.ns = np.arange(1, self.N) + self.omega = 2 * np.pi / self.period + + # Physical args + self.nu = nu + + # Internal state + self.t = None + self.scale_value = 1.0 + + # Precomputation + #self._precompute_bessel_functions() + self._all_r_dependent_coeffs = {} + + super().__init__(element=element) + + def _precompute_r_dependent_coeffs(self, y): #y ? + pir2 = np.pi * self.radius**2 + # Compute intermediate terms for womersley function + #r_dependent_coeffs = np.zeros(self.N, dtype=np.complex) + r_dependent_coeffs = np.zeros(self.N) + if hasattr(self, 'Vn'): + #r_dependent_coeffs[0] = (self.Vn[0]/2.0) * (1 - y**2) + r_dependent_coeffs[0] = self.Vn[0] * (1 - y**2) + for n in self.ns: + r_dependent_coeffs[n] = self.Vn[n] + elif hasattr(self, 'Qn'): + r_dependent_coeffs[0] = (2*self.Qn[0]/pir2) * (1 - y**2) + for n in self.ns: + r_dependent_coeffs[n] = self.Qn[n] + else: + raise ValueError("Missing Vn or Qn!") + return r_dependent_coeffs + + def _get_r_dependent_coeffs(self, y): + "Look for cached coeffs." + key = y + r_dependent_coeffs = self._all_r_dependent_coeffs.get(key) + if r_dependent_coeffs is None: + # Cache miss! Compute coeffs for this coordinate the first time. + r_dependent_coeffs = self._precompute_r_dependent_coeffs(y) + self._all_r_dependent_coeffs[key] = r_dependent_coeffs + return r_dependent_coeffs + + def set_t(self, t): + self.t = float(t) % self.period + self._expnt = np.exp((self.omega * self.t * 1j) * self.ns) + + def eval(self, value, x): + # Compute or get cached complex coefficients that only depend on r + y = np.sqrt(x_to_r2(x, self.center, self.normal)) / self.radius + coeffs = self._get_r_dependent_coeffs(y) + + # Multiply complex coefficients for x with complex exponential functions in time + par = (coeffs[0] + np.dot(coeffs[1:], self._expnt)).real + + # Scale by negative normal direction and scale_value + value[0] = -self.normal_component * self.scale_value * par + +def make_parabolic_bcs(t, Q, mesh, nu, area, center, radius, normal, + element, scale_to=None, coeffstype="Q", + N=1001, num_fourier_coefficients=20, **NS_namespace): + """Generate a list of expressions for the components of a profile.""" + # Compute transient profile as interpolation of given coefficients + period = max(t) + transient_profile = UnivariateSpline(t, Q, s=0, k=1) + + # Compute fourier coefficients of transient profile + timedisc = np.linspace(0, period, N) + + Cn = fourier_coefficients(timedisc, transient_profile, period, num_fourier_coefficients) + + # Create Expressions for each direction + expressions = [] + for ncomp in normal: + if coeffstype == "Q": + Q = Cn + V = None + elif coeffstype == "V": + V = Cn + Q = None + expressions.append(ParabolicComponent(radius, center, normal, ncomp, period, nu, + element, Q=Q, V=V)) + + return expressions + diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index b793bdfa..afec3ebe 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -236,7 +236,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if create_flow_extensions: if not path.isfile(file_name_model_flow_ext): print("--- Adding flow extensions") - extension = 5 + extension = 4 #5 extender = vmtkscripts.vmtkFlowExtensions() extender.Surface = surface diff --git a/automatedPreProcessing/automatedPreProcessing_test.py b/automatedPreProcessing/automatedPreProcessing_test.py new file mode 100644 index 00000000..09ad0e84 --- /dev/null +++ b/automatedPreProcessing/automatedPreProcessing_test.py @@ -0,0 +1,599 @@ +# Python 2 / 3 support +from __future__ import print_function + +import argparse + +import ImportData +import ToolRepairSTL +from NetworkBoundaryConditions import FlowSplitting +# Local imports +from common import * +from simulate import run_simulation +from visualize import visualize + + +def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, smooth_aneurysm, + meshing_method, aneurysm_present, create_flow_extensions, viz, config_path, number_of_sac_points, + coarsening_factor, compress_mesh=True): + """ + Automatically generate mesh of surface model in .vtu and .xml format, including prescribed + flow rates at inlet and outlet based on flow network model. + + Runs simulation of meshed case on a remote ssh server if server configuration is provided. + + Args: + filename_model (str): Name of case + verbose_print (bool): Toggles verbose mode + smoothing_method (str): Method for surface smoothing + smoothing_factor (float): Smoothing parameter + smooth_aneurysm (bool): Toggles smoothing of aneurysm (if present) + meshing_method (str): Method for meshing + aneurysm_present (bool): Determines if aneurysm is present + create_flow_extensions (bool): Adds flow extensions to mesh if True + viz (bool): Visualize resulting surface model with flow rates + config_path (str): Path to configuration file for remote simulation + number_of_sac_points (int): Number of sac points to evaluate (inside aneurysm) + coarsening_factor (float): Refine or coarsen the standard mesh size with given factor + compress_mesh (bool): Compresses finalized mesh if True + """ + # Get paths + abs_path = path.abspath(path.dirname(__file__)) + case_name = filename_model.rsplit(path.sep, 1)[-1].rsplit('.')[0] + dir_path = filename_model.rsplit(path.sep, 1)[0] + + # Naming conventions + file_name_centerlines = path.join(dir_path, case_name + "_centerlines.vtp") + file_name_aneurysm_centerlines = path.join(dir_path, case_name + "_aneurysm_centerline.vtp") + file_name_sac_centerlines = path.join(dir_path, case_name + "_sac_centerline_{}.vtp") + file_name_distance_to_sphere_diam = path.join(dir_path, case_name + "_distance_to_sphere_diam.vtp") + file_name_distance_to_sphere_curv = path.join(dir_path, case_name + "_distance_to_sphere_curv.vtp") + file_name_probe_points = path.join(dir_path, case_name + "_probe_point") + file_name_voronoi = path.join(dir_path, case_name + "_voronoi.vtp") + file_name_voronoi_smooth = path.join(dir_path, case_name + "_voronoi_smooth.vtp") + file_name_surface_smooth = path.join(dir_path, case_name + "_smooth.vtp") + file_name_model_flow_ext = path.join(dir_path, case_name + "_flowext.vtp") + file_name_clipped_model = path.join(dir_path, case_name + "_clippedmodel.vtp") + file_name_flow_centerlines = path.join(dir_path, case_name + "_flow_cl.vtp") + file_name_surface_name = path.join(dir_path, case_name + "_remeshed_surface.vtp") + file_name_xml_mesh = path.join(dir_path, case_name + ".xml") + file_name_vtu_mesh = path.join(dir_path, case_name + ".vtu") + file_name_run_script = path.join(dir_path, case_name + ".sh") + + print("\n--- Working on case:", case_name, "\n") + + # Open the surface file. + print("--- Load model file\n") + surface = ReadPolyData(filename_model) + + if not is_surface_capped and smoothing_method != "voronoi": + print("--- Clipping the models inlet and outlets.\n") + if not path.isfile(file_name_clipped_model): + # TODO: Check if this is a valid call to this method + centerline = compute_centerlines([], [], None, surface, method="pickpoint") + surface = uncapp_surface(surface, centerline, filename=None) + else: + surface = ReadPolyData(file_name_clipped_model) + + parameters = get_parameters(path.join(dir_path, case_name)) + + if "check_surface" not in parameters.keys(): + surface = surface_cleaner(surface) + surface = triangulate_surface(surface) + + # Check the mesh if there is redundant nodes or NaN triangles. + ToolRepairSTL.surfaceOverview(surface) + ToolRepairSTL.foundAndDeleteNaNTriangles(surface) + surface = ToolRepairSTL.cleanTheSurface(surface) + foundNaN = ToolRepairSTL.foundAndDeleteNaNTriangles(surface) + if foundNaN: + raise RuntimeError(("There is an issue with the surface. " + "Nan coordinates or some other shenanigans.")) + else: + parameters["check_surface"] = True + write_parameters(parameters, path.join(dir_path, case_name)) + + # Capp surface if open + if not compute_centers(surface, test_capped=True): + capped_surface = capp_surface(surface) + else: + capped_surface = surface + + # Get centerlines + print("--- Get centerlines\n") + inlet, outlets = get_centers(surface, path.join(dir_path, case_name)) + centerlines = compute_centerlines(inlet, outlets, file_name_centerlines, + capped_surface, resampling=0.1, end_point=0) + tol = get_tolerance(centerlines) + + if aneurysm_present: + aneurysms = get_aneurysm_dome(capped_surface, path.join(dir_path, case_name)) + centerlineAnu = compute_centerlines(inlet, aneurysms, file_name_aneurysm_centerlines, + capped_surface, resampling=0.1) + + # Extract the aneurysm centerline + sac_centerline = [] + info = get_parameters(path.join(dir_path, case_name)) + num_anu = info["number_of_aneurysms"] + + # Compute mean distance between points + for i in range(num_anu): + if not path.isfile(file_name_sac_centerlines.format(i)): + line = ExtractSingleLine(centerlineAnu, i) + locator = get_locator(centerlines) + for j in range(line.GetNumberOfPoints() - 1, 0, -1): + point = line.GetPoints().GetPoint(j) + ID = locator.FindClosestPoint(point) + tmp_point = centerlines.GetPoints().GetPoint(ID) + dist = np.sqrt(np.sum((np.asarray(point) - np.asarray(tmp_point)) ** 2)) + if dist <= tol: + break + + tmp = ExtractSingleLine(line, 0, start_id=j) + WritePolyData(tmp, file_name_sac_centerlines.format(i)) + + # List of VtkPolyData sac(s) centerline + sac_centerline.append(tmp) + + else: + sac_centerline.append(ReadPolyData(file_name_sac_centerlines.format(i))) + + else: + num_anu = 0 + + # Get 'center' and 'radius' of the aneurysm(s) + sac_center = [] + misr_max = [] + + if aneurysm_present: + # Merge the sac centerline + sac_centerlines = merge_data(sac_centerline) + + for sac in sac_centerline: + sac_center.append(sac.GetPoints().GetPoint(sac.GetNumberOfPoints() // 2)) + tmp_misr = get_array(radiusArrayName, sac) + misr_max.append(tmp_misr.max()) + + # Smooth surface + if smoothing_method == "voronoi": + print("--- Smooth surface: Voronoi smoothing\n") + if not path.isfile(file_name_surface_smooth): + # Get Voronoi diagram + if not path.isfile(file_name_voronoi): + voronoi = makeVoronoiDiagram(surface, file_name_voronoi) + WritePolyData(voronoi, file_name_voronoi) + else: + voronoi = ReadPolyData(file_name_voronoi) + + # Get smooth Voronoi diagram + if not path.isfile(file_name_voronoi_smooth): + if aneurysm_present: + smooth_voronoi = SmoothVoronoiDiagram(voronoi, centerlines, smoothing_factor, sac_centerlines) + else: + smooth_voronoi = SmoothVoronoiDiagram(voronoi, centerlines, smoothing_factor) + + WritePolyData(smooth_voronoi, file_name_voronoi_smooth) + else: + smooth_voronoi = ReadPolyData(file_name_voronoi_smooth) + + # Envelope the smooth surface + surface = create_new_surface(smooth_voronoi) + + # Uncapp the surface + surface_uncapped = uncapp_surface(surface, centerlines, filename=None) + + # Check if there has been added new outlets + num_outlets = centerlines.GetNumberOfLines() + num_outlets_after = compute_centers(surface_uncapped, test_capped=True)[1] + + if num_outlets != num_outlets_after: + surface = vmtkSmoother(surface, "laplace", iterations=200) + WritePolyData(surface, file_name_surface_smooth) + print(("ERROR: Automatic clipping failed. You have to open {} and " + + "manually clipp the branch which still is capped. " + + "Overwrite the current {} and restart the script.").format( + file_name_surface_smooth, file_name_surface_smooth)) + sys.exit(0) + + surface = surface_uncapped + + # Smoothing to improve the quality of the elements + # Consider to add a subdivision here as well. + surface = vmtkSmoother(surface, "laplace", iterations=200) + + # Write surface + WritePolyData(surface, file_name_surface_smooth) + + else: + surface = ReadPolyData(file_name_surface_smooth) + + + elif smoothing_method == "laplace": + print("--- Smooth surface: Laplacian smoothing\n") + if not path.isfile(file_name_surface_smooth): + surface = vmtkSmoother(surface, smoothing_method) + + # Save the smoothed surface + WritePolyData(surface, file_name_surface_smooth) + + else: + surface = ReadPolyData(file_name_surface_smooth) + + elif smoothing_method == "taubin": + print("--- Smooth surface: Taubin smoothing\n") + if not path.isfile(file_name_surface_smooth): + surface = vmtkSmoother(surface, smoothing_method) + + # Save the smoothed surface + WritePolyData(surface, file_name_surface_smooth) + + else: + surface = ReadPolyData(file_name_surface_smooth) + + elif smoothing_method == "no_smooth" or None: + print("--- No smoothing of surface\n") + + # Add flow extensions + if create_flow_extensions: + if not path.isfile(file_name_model_flow_ext): + print("--- Adding flow extensions") + extension = 4 #5 + + extender = vmtkscripts.vmtkFlowExtensions() + extender.Surface = surface + extender.AdaptiveExtensionLength = 1 + extender.ExtensionRatio = extension + extender.Centerlines = centerlines + extender.ExtensionMode = "boundarynormal" + extender.CenterlineNormalEstimationDistanceRatio = 1.0 + extender.Interactive = 0 + extender.Execute() + + surface = extender.Surface + surface = vmtkSmoother(surface, "laplace", iterations=200) + WritePolyData(surface, file_name_model_flow_ext) + + else: + surface = ReadPolyData(file_name_model_flow_ext) + + # Capp surface with flow extensions + capped_surface = capp_surface(surface) + + # Get new centerlines with the flow extensions + if not path.isfile(file_name_flow_centerlines): + print("--- Compute the model centerlines with flow extension.") + # Compute the centerlines. + inlet, outlets = get_centers(surface, path.join(dir_path, case_name), flowext=True) + centerlines = compute_centerlines(inlet, outlets, file_name_flow_centerlines, capped_surface, resampling=0.5) + + else: + centerlines = ReadPolyData(file_name_flow_centerlines) + + # Choose input for the mesh + print("--- Computing distance to sphere") + if meshing_method == "curvature": + if not path.isfile(file_name_distance_to_sphere_curv): + distance_to_sphere = dist_sphere_curv(surface, centerlines, + sac_center, misr_max, + file_name_distance_to_sphere_curv, + coarsening_factor) + else: + distance_to_sphere = ReadPolyData(file_name_distance_to_sphere_curv) + else: + if not path.isfile(file_name_distance_to_sphere_diam): + distance_to_sphere = dist_sphere_diam(surface, centerlines, + sac_center, misr_max, + file_name_distance_to_sphere_diam, + coarsening_factor) + else: + distance_to_sphere = ReadPolyData(file_name_distance_to_sphere_diam) + + # Compute mesh + if not path.isfile(file_name_vtu_mesh): + try: + print("--- Computing mesh\n") + mesh, remeshed_surface = generate_mesh(distance_to_sphere) + assert remeshed_surface.GetNumberOfPoints() > 0, \ + "No points in surface mesh, try to remesh" + assert mesh.GetNumberOfPoints() > 0, "No points in mesh, try to remesh" + + except: + distance_to_sphere = mesh_alternative(distance_to_sphere) + mesh, remeshed_surface = generate_mesh(distance_to_sphere) + assert mesh.GetNumberOfPoints() > 0, "No points in mesh, after remeshing" + assert remeshed_surface.GetNumberOfPoints() > 0, \ + "No points in surface mesh, try to remesh" + + # Write mesh in VTU format + WritePolyData(remeshed_surface, file_name_surface_name) + WritePolyData(mesh, file_name_vtu_mesh) + + # Write mesh to FEniCS to format + meshWriter = vmtkscripts.vmtkMeshWriter() + meshWriter.CellEntityIdsArrayName = "CellEntityIds" + meshWriter.Mesh = mesh + meshWriter.Mode = "ascii" + meshWriter.Compressed = compress_mesh + meshWriter.OutputFileName = file_name_xml_mesh + meshWriter.Execute() + polyDataVolMesh = mesh + + else: + polyDataVolMesh = ReadPolyData(file_name_vtu_mesh) + + # Set the network object used in the scripts for + # boundary conditions and probes. + network = ImportData.Network() + centerlinesBranches = ImportData.SetNetworkStructure(centerlines, network, verbose_print) + + if not path.isfile(file_name_probe_points): + # Get the list of coordinates for the probe points along the network centerline. + listProbePoints = ImportData.GetListProbePoints(centerlinesBranches, network, verbose_print) + listProbePoints += sac_center + + # Add points randomly in the sac. + # FIXME: This is not robust enough. Suggestion to fix: Extract the + # second half of the sac centerline, then get all points from the + # voronoi diagram which is closest to that part compared to any ther + # centerlines. Then randomly chose among those points. For now, simply + # add just one point (sac_center). + # numberOfPoints = numberOfSacPoints + # for k in range(num_anu): + # u = np.random.uniform(0.0, 1.0, (numberOfPoints, 1)) + # theta = np.random.uniform(0., 1., (numberOfPoints, 1)) * np.pi + # phi = np.arccos(1 - 2 * np.random.uniform(0.0, 1., (numberOfPoints, 1))) + # radius = misr_max[k] * u**(0.3333) + # x = radius * np.sin(theta) * np.cos(phi) + # y = radius * np.sin(theta) * np.sin(phi) + # z = radius * np.cos(theta) + # for i in range(len(x)): + # listProbePoints.append([np.array(misr_max_center[k][0] + x[i]).tolist()[0], + # np.array(misr_max_center[k][1] + y[i]).tolist()[0], + # np.array(misr_max_center[k][2] + z[i]).tolist()[0]]) + + print("--- Saving probes points in: ", file_name_probe_points) + probe_points = np.array(listProbePoints) + probe_points.dump(file_name_probe_points) + else: + probe_points = np.load(file_name_probe_points, allow_pickle=True) + + # Set the flow split and inlet boundary condition + # Compute the outlet boundary condition percentages. + flowSplitting = FlowSplitting() + flowSplitting.ComputeAlphas(network, verbose_print) + flowSplitting.ComputeBetas(network, verbose_print) + flowSplitting.CheckTotalFlowRate(network, verbose_print) + + # BSL method for mean inlet flow rate. + parameters = get_parameters(path.join(dir_path, case_name)) + mean_inflow_rate = 0.27 * parameters["inlet_area"] + + # Extract the surface mesh of the wall + wallMesh = threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) + + boundaryReferenceSystems = vmtkscripts.vmtkBoundaryReferenceSystems() + boundaryReferenceSystems.Surface = wallMesh + boundaryReferenceSystems.Execute() + refSystem = boundaryReferenceSystems.ReferenceSystems + cellEntityIdsArray = get_vtk_array('CellEntityIds', 0, refSystem.GetNumberOfPoints()) + refSystem.GetPointData().AddArray(cellEntityIdsArray) + + # Extract the surface mesh of the end caps + boundarySurface = threshold(polyDataVolMesh, "CellEntityIds", upper=1.5, type="upper") + + pointCells = vtk.vtkIdList() + surfaceCellEntityIdsArray = vtk.vtkIntArray() + surfaceCellEntityIdsArray.DeepCopy(boundarySurface.GetCellData().GetArray('CellEntityIds')) + + # Find the corresponding couple (mesh outlet ID, network ID). + ids = [] + for i in range(refSystem.GetNumberOfPoints()): + distancePoints = 10000000 + pointId = boundarySurface.FindPoint(refSystem.GetPoint(i)) + boundarySurface.GetPointCells(pointId, pointCells) + cellId = pointCells.GetId(0) + cellEntityId = surfaceCellEntityIdsArray.GetValue(cellId) + cellEntityIdsArray.SetValue(i, cellEntityId) + + meshPoint = refSystem.GetPoint(i) + for element in network.elements: + if element.IsAnOutlet(): + networkPoint = element.GetOutPointsx1()[0] + if element.IsAnInlet(): + networkPoint = element.GetInPointsx0()[0] + if vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) < distancePoints: + distancePoints = vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) + closest = element.GetId() + if network.elements[closest].IsAnInlet(): + verbose_print('I am the inlet, Sup?') + verbose_print(network.elements[closest].GetInPointsx0()[0]) + ids.insert(0, [cellEntityId, mean_inflow_rate]) + else: + beta = network.elements[closest].GetBeta() + ids.append([cellEntityId, beta]) + verbose_print(beta) + verbose_print(network.elements[closest].GetOutPointsx1()[0]) + verbose_print('CellEntityId: %d\n' % cellEntityId) + verbose_print('meshPoint: %f, %f, %f\n' % (meshPoint[0], meshPoint[1], meshPoint[2])) + verbose_print(ids) + + # Store information for the solver. + idFileLine = case_name + ' ' + repr(ids[0][0] - 1) + ' ' + areaRatioLine = case_name + ' ' + for k in range(1, refSystem.GetNumberOfPoints() - 1): + idFileLine += repr(ids[k][0] - 1) + ',' + areaRatioLine += repr(ids[k][1]) + ',' + idFileLine += repr(ids[-1][0] - 1) + ' ' + repr(ids[0][1]) + areaRatioLine += repr(ids[-1][1]) + info = {"inlet_area": parameters["inlet_area"], + "idFileLine": str(idFileLine), + "areaRatioLine": str(areaRatioLine) + } + write_parameters(info, path.join(dir_path, case_name)) + + # Display the flow split at the outlets, inlet flow rate, and probes. + if viz: + print("--- Visualizing flow split at outlets, inlet flow rate, and probes in VTK render window. ") + print("--- Press 'q' inside the render window to exit.") + visualize(network.elements, probe_points, surface, mean_inflow_rate) + + # Start simulation though ssh, without password + if config_path is not None: + + # Set up simulation script + if not path.exists(file_name_run_script): + run_script_sample = open(path.join(abs_path, "run_script.sh"), "r").read() + config = json.load(open(config_path)) + run_dict = dict(mesh_name=case_name, + num_nodes=1, + hours=120, + account="nn9249k", + remoteFolder=config["remoteFolder"], + results_folder="results") + run_script = run_script_sample.format(**run_dict) + + # Write script + script_file = open(file_name_run_script, "w") + script_file.write(run_script) + script_file.close() + + run_simulation(config_path, dir_path, case_name) + + +def str2bool(arg): + """ + Convert a string to boolean. + + Args: + arg (str): Input string. + + Returns: + return (bool): Converted string. + """ + if arg.lower() in ('yes', 'true', 't', 'y', '1'): + return True + elif arg.lower() in ('no', 'false', 'f', 'n', '0'): + return False + else: + raise argparse.ArgumentTypeError('Boolean value expected.') + + +def read_command_line(): + """ + Read arguments from commandline and return all values in a dictionary. + """ + '''Command-line arguments.''' + parser = argparse.ArgumentParser( + description="Automatic pre-processing for FEniCS.") + + parser.add_argument('-v', '--verbosity', + dest='verbosity', + type=str2bool, + default=False, + help="Activates the verbose mode.") + + parser.add_argument('-i', '--inputModel', + type=str, + required=False, + dest='fileNameModel', + default='example/surface.vtp', + help="Input file containing the 3D model.") + + parser.add_argument('-sM', '--smoothingMethod', + type=str, + required=False, + dest='smoothingMethod', + default="no_smooth", + choices=["voronoi", "no_smooth", "laplace", "taubin"], + help="Smoothing method, for now only Voronoi smoothing is available." + + " For Voronoi smoothing you can also control smoothingFactor" + + " (default = 0.25) and smoothingAneurysm (default = False).") + + parser.add_argument('-c', '--coarseningFactor', + type=float, + required=False, + dest='coarseningFactor', + default=1.0, + help="Refine or coarsen the standard mesh size") + + parser.add_argument('-sF', '--smoothingFactor', + type=float, + required=False, + dest='smoothingFactor', + default=0.25, + help="smoothingFactor for VoronoiSmoothing, removes all spheres which" + + " has a radius < MISR*(1-0.25), where MISR varying along the centerline.") + + parser.add_argument('-sA', '--smoothAneurysm', + type=str2bool, + required=False, + dest="smoothingAneurysm", + help="When using Voronoi smoothing one can choose not to smooth the" + + " aneurysm as this method often removes to much of the aneurysm") + + parser.add_argument('-m', '--meshingMethod', + dest="meshingMethod", + type=str, + choices=["diameter", "curvature"], + default="diameter") + + parser.add_argument('-a', '--aneurysm', + dest="aneu", + type=str2bool, + default=True, + help="Determine weather or not the model has a aneurysm. Default is False.") + + parser.add_argument('-f', '--flowext', + dest="fext", + default=True, + type=str2bool, + help="Add flow extensions to to the model.") + + parser.add_argument('-vz', '--visualize', + dest="viz", + default=True, + type=str2bool, + help="Visualize surface, inlet, outlet and probes after meshing.") + + parser.add_argument('-sp', '--sacpoints', + type=int, + help='Number of sac points to add', + default=20, + dest="sacpts") + + parser.add_argument('--simulationConfig', + type=str, + dest="config", + default=None, + help='Path to configuration file for remote simulation. ' + + 'See example/ssh_config.json for details') + parser.add_argument('-atr', '--atrium', + dest="atri", + type=str2bool, + default=False, + help="Determine weather or not the model is Atrium not Artery. Default is False.") + + + args, _ = parser.parse_known_args() + + if args.verbosity: + print() + print("--- VERBOSE MODE ACTIVATED ---") + + def verbose_print(*args): + for arg in args: + print(arg, end=' ') + print() + else: + verbose_print = lambda *a: None + + verbose_print(args) + + return dict(filename_model=args.fileNameModel, verbose_print=verbose_print, smoothing_method=args.smoothingMethod, + smoothing_factor=args.smoothingFactor, smooth_aneurysm=args.smoothingAneurysm, + meshing_method=args.meshingMethod, aneurysm_present=args.aneu, create_flow_extensions=args.fext, + viz=args.viz, config_path=args.config, number_of_sac_points=args.sacpts, + coarsening_factor=args.coarseningFactor) + + +if __name__ == "__main__": + run_pre_processing(**read_command_line()) diff --git a/postprocessing/compute_wss.py b/postprocessing/compute_wss.py index 2937fd68..e69bd443 100644 --- a/postprocessing/compute_wss.py +++ b/postprocessing/compute_wss.py @@ -9,7 +9,7 @@ parameters["reorder_dofs_serial"] = False -def compute_wss(case_path, nu, dt): +def compute_wss(case_path, nu, dt, velocity_degree): """ Loads velocity fields from completed CFD simulation, and computes and saves the following hemodynamic quantities: @@ -44,7 +44,6 @@ def compute_wss(case_path, nu, dt): if MPI.rank(MPI.comm_world) == 0: print("Define function spaces") - velocity_degree = 1 V_b1 = VectorFunctionSpace(bm, "CG", 1) U_b1 = FunctionSpace(bm, "CG", 1) V = VectorFunctionSpace(mesh, "CG", velocity_degree) @@ -217,5 +216,5 @@ def get_dabla_function(): if __name__ == '__main__': - folder, nu, dt = read_command_line() - compute_wss(folder, nu, dt) + folder, nu, dt, velocity_degree = read_command_line() + compute_wss(folder, nu, dt, velocity_degree) diff --git a/postprocessing/postprocessing_common.py b/postprocessing/postprocessing_common.py index 4fa5d68e..5f8bea11 100644 --- a/postprocessing/postprocessing_common.py +++ b/postprocessing/postprocessing_common.py @@ -13,10 +13,11 @@ def read_command_line(): metavar="PATH") parser.add_argument('--nu', type=float, default=3.3018e-3, help="Viscosity used in simulation") parser.add_argument('--dt', type=float, default=0.0951, help="Time step of simulation") + parser.add_argument('--velocity-degree', type=int, default=1, help="Degree of velocity element") args = parser.parse_args() - return args.case, args.nu, args.dt + return args.case, args.nu, args.dt, args.velocity_degree def epsilon(u): diff --git a/test/Case_test_atrium_07/case_test_at_07.vtp b/test/Case_test_atrium_07/case_test_at_07.vtp new file mode 100644 index 00000000..5d9f2854 --- /dev/null +++ b/test/Case_test_atrium_07/case_test_at_07.vtp @@ -0,0 +1,51 @@ + + + + + + + + + AwAAAACAAACAQQAANAAAADQAAAAmAAAAeJztwQEBAAAAgJD+r+4ICgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYgAAAAXic7cEBAQAAAICQ/q/uCAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIAAAAF4nO3BAQEAAACCIP+vbkhAAQAAAAAAAAAAAAAAAAAAAHwbQYAAAQ== + + + + + BAAAAACAAADwbAAAhm8AAJlvAAD5bgAANF4AAA==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 + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + EAAAAACAAAAACQAA9hIAAIITAABrEwAA2xMAADoTAAAfEwAANBMAAJ8SAAB4FAAA+RgAACEYAABOGQAARxoAAFAaAABBGwAABAIAAA==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 + + + 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 + + + + + diff --git a/test/processed_model.png b/test/processed_model.png deleted file mode 100644 index fa623e4469162126d83c22fd3c7486e87fab1328..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 192857 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 0 - - -if __name__ == "__main__": - test_pre_processing() From 96f56abf2ac750c6db3eddd9e684233b80e512b4 Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Tue, 25 May 2021 08:07:17 +0200 Subject: [PATCH 02/76] Delete automatedPreProcessing_test.py --- .../automatedPreProcessing_test.py | 599 ------------------ 1 file changed, 599 deletions(-) delete mode 100644 automatedPreProcessing/automatedPreProcessing_test.py diff --git a/automatedPreProcessing/automatedPreProcessing_test.py b/automatedPreProcessing/automatedPreProcessing_test.py deleted file mode 100644 index 09ad0e84..00000000 --- a/automatedPreProcessing/automatedPreProcessing_test.py +++ /dev/null @@ -1,599 +0,0 @@ -# Python 2 / 3 support -from __future__ import print_function - -import argparse - -import ImportData -import ToolRepairSTL -from NetworkBoundaryConditions import FlowSplitting -# Local imports -from common import * -from simulate import run_simulation -from visualize import visualize - - -def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, smooth_aneurysm, - meshing_method, aneurysm_present, create_flow_extensions, viz, config_path, number_of_sac_points, - coarsening_factor, compress_mesh=True): - """ - Automatically generate mesh of surface model in .vtu and .xml format, including prescribed - flow rates at inlet and outlet based on flow network model. - - Runs simulation of meshed case on a remote ssh server if server configuration is provided. - - Args: - filename_model (str): Name of case - verbose_print (bool): Toggles verbose mode - smoothing_method (str): Method for surface smoothing - smoothing_factor (float): Smoothing parameter - smooth_aneurysm (bool): Toggles smoothing of aneurysm (if present) - meshing_method (str): Method for meshing - aneurysm_present (bool): Determines if aneurysm is present - create_flow_extensions (bool): Adds flow extensions to mesh if True - viz (bool): Visualize resulting surface model with flow rates - config_path (str): Path to configuration file for remote simulation - number_of_sac_points (int): Number of sac points to evaluate (inside aneurysm) - coarsening_factor (float): Refine or coarsen the standard mesh size with given factor - compress_mesh (bool): Compresses finalized mesh if True - """ - # Get paths - abs_path = path.abspath(path.dirname(__file__)) - case_name = filename_model.rsplit(path.sep, 1)[-1].rsplit('.')[0] - dir_path = filename_model.rsplit(path.sep, 1)[0] - - # Naming conventions - file_name_centerlines = path.join(dir_path, case_name + "_centerlines.vtp") - file_name_aneurysm_centerlines = path.join(dir_path, case_name + "_aneurysm_centerline.vtp") - file_name_sac_centerlines = path.join(dir_path, case_name + "_sac_centerline_{}.vtp") - file_name_distance_to_sphere_diam = path.join(dir_path, case_name + "_distance_to_sphere_diam.vtp") - file_name_distance_to_sphere_curv = path.join(dir_path, case_name + "_distance_to_sphere_curv.vtp") - file_name_probe_points = path.join(dir_path, case_name + "_probe_point") - file_name_voronoi = path.join(dir_path, case_name + "_voronoi.vtp") - file_name_voronoi_smooth = path.join(dir_path, case_name + "_voronoi_smooth.vtp") - file_name_surface_smooth = path.join(dir_path, case_name + "_smooth.vtp") - file_name_model_flow_ext = path.join(dir_path, case_name + "_flowext.vtp") - file_name_clipped_model = path.join(dir_path, case_name + "_clippedmodel.vtp") - file_name_flow_centerlines = path.join(dir_path, case_name + "_flow_cl.vtp") - file_name_surface_name = path.join(dir_path, case_name + "_remeshed_surface.vtp") - file_name_xml_mesh = path.join(dir_path, case_name + ".xml") - file_name_vtu_mesh = path.join(dir_path, case_name + ".vtu") - file_name_run_script = path.join(dir_path, case_name + ".sh") - - print("\n--- Working on case:", case_name, "\n") - - # Open the surface file. - print("--- Load model file\n") - surface = ReadPolyData(filename_model) - - if not is_surface_capped and smoothing_method != "voronoi": - print("--- Clipping the models inlet and outlets.\n") - if not path.isfile(file_name_clipped_model): - # TODO: Check if this is a valid call to this method - centerline = compute_centerlines([], [], None, surface, method="pickpoint") - surface = uncapp_surface(surface, centerline, filename=None) - else: - surface = ReadPolyData(file_name_clipped_model) - - parameters = get_parameters(path.join(dir_path, case_name)) - - if "check_surface" not in parameters.keys(): - surface = surface_cleaner(surface) - surface = triangulate_surface(surface) - - # Check the mesh if there is redundant nodes or NaN triangles. - ToolRepairSTL.surfaceOverview(surface) - ToolRepairSTL.foundAndDeleteNaNTriangles(surface) - surface = ToolRepairSTL.cleanTheSurface(surface) - foundNaN = ToolRepairSTL.foundAndDeleteNaNTriangles(surface) - if foundNaN: - raise RuntimeError(("There is an issue with the surface. " - "Nan coordinates or some other shenanigans.")) - else: - parameters["check_surface"] = True - write_parameters(parameters, path.join(dir_path, case_name)) - - # Capp surface if open - if not compute_centers(surface, test_capped=True): - capped_surface = capp_surface(surface) - else: - capped_surface = surface - - # Get centerlines - print("--- Get centerlines\n") - inlet, outlets = get_centers(surface, path.join(dir_path, case_name)) - centerlines = compute_centerlines(inlet, outlets, file_name_centerlines, - capped_surface, resampling=0.1, end_point=0) - tol = get_tolerance(centerlines) - - if aneurysm_present: - aneurysms = get_aneurysm_dome(capped_surface, path.join(dir_path, case_name)) - centerlineAnu = compute_centerlines(inlet, aneurysms, file_name_aneurysm_centerlines, - capped_surface, resampling=0.1) - - # Extract the aneurysm centerline - sac_centerline = [] - info = get_parameters(path.join(dir_path, case_name)) - num_anu = info["number_of_aneurysms"] - - # Compute mean distance between points - for i in range(num_anu): - if not path.isfile(file_name_sac_centerlines.format(i)): - line = ExtractSingleLine(centerlineAnu, i) - locator = get_locator(centerlines) - for j in range(line.GetNumberOfPoints() - 1, 0, -1): - point = line.GetPoints().GetPoint(j) - ID = locator.FindClosestPoint(point) - tmp_point = centerlines.GetPoints().GetPoint(ID) - dist = np.sqrt(np.sum((np.asarray(point) - np.asarray(tmp_point)) ** 2)) - if dist <= tol: - break - - tmp = ExtractSingleLine(line, 0, start_id=j) - WritePolyData(tmp, file_name_sac_centerlines.format(i)) - - # List of VtkPolyData sac(s) centerline - sac_centerline.append(tmp) - - else: - sac_centerline.append(ReadPolyData(file_name_sac_centerlines.format(i))) - - else: - num_anu = 0 - - # Get 'center' and 'radius' of the aneurysm(s) - sac_center = [] - misr_max = [] - - if aneurysm_present: - # Merge the sac centerline - sac_centerlines = merge_data(sac_centerline) - - for sac in sac_centerline: - sac_center.append(sac.GetPoints().GetPoint(sac.GetNumberOfPoints() // 2)) - tmp_misr = get_array(radiusArrayName, sac) - misr_max.append(tmp_misr.max()) - - # Smooth surface - if smoothing_method == "voronoi": - print("--- Smooth surface: Voronoi smoothing\n") - if not path.isfile(file_name_surface_smooth): - # Get Voronoi diagram - if not path.isfile(file_name_voronoi): - voronoi = makeVoronoiDiagram(surface, file_name_voronoi) - WritePolyData(voronoi, file_name_voronoi) - else: - voronoi = ReadPolyData(file_name_voronoi) - - # Get smooth Voronoi diagram - if not path.isfile(file_name_voronoi_smooth): - if aneurysm_present: - smooth_voronoi = SmoothVoronoiDiagram(voronoi, centerlines, smoothing_factor, sac_centerlines) - else: - smooth_voronoi = SmoothVoronoiDiagram(voronoi, centerlines, smoothing_factor) - - WritePolyData(smooth_voronoi, file_name_voronoi_smooth) - else: - smooth_voronoi = ReadPolyData(file_name_voronoi_smooth) - - # Envelope the smooth surface - surface = create_new_surface(smooth_voronoi) - - # Uncapp the surface - surface_uncapped = uncapp_surface(surface, centerlines, filename=None) - - # Check if there has been added new outlets - num_outlets = centerlines.GetNumberOfLines() - num_outlets_after = compute_centers(surface_uncapped, test_capped=True)[1] - - if num_outlets != num_outlets_after: - surface = vmtkSmoother(surface, "laplace", iterations=200) - WritePolyData(surface, file_name_surface_smooth) - print(("ERROR: Automatic clipping failed. You have to open {} and " + - "manually clipp the branch which still is capped. " + - "Overwrite the current {} and restart the script.").format( - file_name_surface_smooth, file_name_surface_smooth)) - sys.exit(0) - - surface = surface_uncapped - - # Smoothing to improve the quality of the elements - # Consider to add a subdivision here as well. - surface = vmtkSmoother(surface, "laplace", iterations=200) - - # Write surface - WritePolyData(surface, file_name_surface_smooth) - - else: - surface = ReadPolyData(file_name_surface_smooth) - - - elif smoothing_method == "laplace": - print("--- Smooth surface: Laplacian smoothing\n") - if not path.isfile(file_name_surface_smooth): - surface = vmtkSmoother(surface, smoothing_method) - - # Save the smoothed surface - WritePolyData(surface, file_name_surface_smooth) - - else: - surface = ReadPolyData(file_name_surface_smooth) - - elif smoothing_method == "taubin": - print("--- Smooth surface: Taubin smoothing\n") - if not path.isfile(file_name_surface_smooth): - surface = vmtkSmoother(surface, smoothing_method) - - # Save the smoothed surface - WritePolyData(surface, file_name_surface_smooth) - - else: - surface = ReadPolyData(file_name_surface_smooth) - - elif smoothing_method == "no_smooth" or None: - print("--- No smoothing of surface\n") - - # Add flow extensions - if create_flow_extensions: - if not path.isfile(file_name_model_flow_ext): - print("--- Adding flow extensions") - extension = 4 #5 - - extender = vmtkscripts.vmtkFlowExtensions() - extender.Surface = surface - extender.AdaptiveExtensionLength = 1 - extender.ExtensionRatio = extension - extender.Centerlines = centerlines - extender.ExtensionMode = "boundarynormal" - extender.CenterlineNormalEstimationDistanceRatio = 1.0 - extender.Interactive = 0 - extender.Execute() - - surface = extender.Surface - surface = vmtkSmoother(surface, "laplace", iterations=200) - WritePolyData(surface, file_name_model_flow_ext) - - else: - surface = ReadPolyData(file_name_model_flow_ext) - - # Capp surface with flow extensions - capped_surface = capp_surface(surface) - - # Get new centerlines with the flow extensions - if not path.isfile(file_name_flow_centerlines): - print("--- Compute the model centerlines with flow extension.") - # Compute the centerlines. - inlet, outlets = get_centers(surface, path.join(dir_path, case_name), flowext=True) - centerlines = compute_centerlines(inlet, outlets, file_name_flow_centerlines, capped_surface, resampling=0.5) - - else: - centerlines = ReadPolyData(file_name_flow_centerlines) - - # Choose input for the mesh - print("--- Computing distance to sphere") - if meshing_method == "curvature": - if not path.isfile(file_name_distance_to_sphere_curv): - distance_to_sphere = dist_sphere_curv(surface, centerlines, - sac_center, misr_max, - file_name_distance_to_sphere_curv, - coarsening_factor) - else: - distance_to_sphere = ReadPolyData(file_name_distance_to_sphere_curv) - else: - if not path.isfile(file_name_distance_to_sphere_diam): - distance_to_sphere = dist_sphere_diam(surface, centerlines, - sac_center, misr_max, - file_name_distance_to_sphere_diam, - coarsening_factor) - else: - distance_to_sphere = ReadPolyData(file_name_distance_to_sphere_diam) - - # Compute mesh - if not path.isfile(file_name_vtu_mesh): - try: - print("--- Computing mesh\n") - mesh, remeshed_surface = generate_mesh(distance_to_sphere) - assert remeshed_surface.GetNumberOfPoints() > 0, \ - "No points in surface mesh, try to remesh" - assert mesh.GetNumberOfPoints() > 0, "No points in mesh, try to remesh" - - except: - distance_to_sphere = mesh_alternative(distance_to_sphere) - mesh, remeshed_surface = generate_mesh(distance_to_sphere) - assert mesh.GetNumberOfPoints() > 0, "No points in mesh, after remeshing" - assert remeshed_surface.GetNumberOfPoints() > 0, \ - "No points in surface mesh, try to remesh" - - # Write mesh in VTU format - WritePolyData(remeshed_surface, file_name_surface_name) - WritePolyData(mesh, file_name_vtu_mesh) - - # Write mesh to FEniCS to format - meshWriter = vmtkscripts.vmtkMeshWriter() - meshWriter.CellEntityIdsArrayName = "CellEntityIds" - meshWriter.Mesh = mesh - meshWriter.Mode = "ascii" - meshWriter.Compressed = compress_mesh - meshWriter.OutputFileName = file_name_xml_mesh - meshWriter.Execute() - polyDataVolMesh = mesh - - else: - polyDataVolMesh = ReadPolyData(file_name_vtu_mesh) - - # Set the network object used in the scripts for - # boundary conditions and probes. - network = ImportData.Network() - centerlinesBranches = ImportData.SetNetworkStructure(centerlines, network, verbose_print) - - if not path.isfile(file_name_probe_points): - # Get the list of coordinates for the probe points along the network centerline. - listProbePoints = ImportData.GetListProbePoints(centerlinesBranches, network, verbose_print) - listProbePoints += sac_center - - # Add points randomly in the sac. - # FIXME: This is not robust enough. Suggestion to fix: Extract the - # second half of the sac centerline, then get all points from the - # voronoi diagram which is closest to that part compared to any ther - # centerlines. Then randomly chose among those points. For now, simply - # add just one point (sac_center). - # numberOfPoints = numberOfSacPoints - # for k in range(num_anu): - # u = np.random.uniform(0.0, 1.0, (numberOfPoints, 1)) - # theta = np.random.uniform(0., 1., (numberOfPoints, 1)) * np.pi - # phi = np.arccos(1 - 2 * np.random.uniform(0.0, 1., (numberOfPoints, 1))) - # radius = misr_max[k] * u**(0.3333) - # x = radius * np.sin(theta) * np.cos(phi) - # y = radius * np.sin(theta) * np.sin(phi) - # z = radius * np.cos(theta) - # for i in range(len(x)): - # listProbePoints.append([np.array(misr_max_center[k][0] + x[i]).tolist()[0], - # np.array(misr_max_center[k][1] + y[i]).tolist()[0], - # np.array(misr_max_center[k][2] + z[i]).tolist()[0]]) - - print("--- Saving probes points in: ", file_name_probe_points) - probe_points = np.array(listProbePoints) - probe_points.dump(file_name_probe_points) - else: - probe_points = np.load(file_name_probe_points, allow_pickle=True) - - # Set the flow split and inlet boundary condition - # Compute the outlet boundary condition percentages. - flowSplitting = FlowSplitting() - flowSplitting.ComputeAlphas(network, verbose_print) - flowSplitting.ComputeBetas(network, verbose_print) - flowSplitting.CheckTotalFlowRate(network, verbose_print) - - # BSL method for mean inlet flow rate. - parameters = get_parameters(path.join(dir_path, case_name)) - mean_inflow_rate = 0.27 * parameters["inlet_area"] - - # Extract the surface mesh of the wall - wallMesh = threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) - - boundaryReferenceSystems = vmtkscripts.vmtkBoundaryReferenceSystems() - boundaryReferenceSystems.Surface = wallMesh - boundaryReferenceSystems.Execute() - refSystem = boundaryReferenceSystems.ReferenceSystems - cellEntityIdsArray = get_vtk_array('CellEntityIds', 0, refSystem.GetNumberOfPoints()) - refSystem.GetPointData().AddArray(cellEntityIdsArray) - - # Extract the surface mesh of the end caps - boundarySurface = threshold(polyDataVolMesh, "CellEntityIds", upper=1.5, type="upper") - - pointCells = vtk.vtkIdList() - surfaceCellEntityIdsArray = vtk.vtkIntArray() - surfaceCellEntityIdsArray.DeepCopy(boundarySurface.GetCellData().GetArray('CellEntityIds')) - - # Find the corresponding couple (mesh outlet ID, network ID). - ids = [] - for i in range(refSystem.GetNumberOfPoints()): - distancePoints = 10000000 - pointId = boundarySurface.FindPoint(refSystem.GetPoint(i)) - boundarySurface.GetPointCells(pointId, pointCells) - cellId = pointCells.GetId(0) - cellEntityId = surfaceCellEntityIdsArray.GetValue(cellId) - cellEntityIdsArray.SetValue(i, cellEntityId) - - meshPoint = refSystem.GetPoint(i) - for element in network.elements: - if element.IsAnOutlet(): - networkPoint = element.GetOutPointsx1()[0] - if element.IsAnInlet(): - networkPoint = element.GetInPointsx0()[0] - if vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) < distancePoints: - distancePoints = vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) - closest = element.GetId() - if network.elements[closest].IsAnInlet(): - verbose_print('I am the inlet, Sup?') - verbose_print(network.elements[closest].GetInPointsx0()[0]) - ids.insert(0, [cellEntityId, mean_inflow_rate]) - else: - beta = network.elements[closest].GetBeta() - ids.append([cellEntityId, beta]) - verbose_print(beta) - verbose_print(network.elements[closest].GetOutPointsx1()[0]) - verbose_print('CellEntityId: %d\n' % cellEntityId) - verbose_print('meshPoint: %f, %f, %f\n' % (meshPoint[0], meshPoint[1], meshPoint[2])) - verbose_print(ids) - - # Store information for the solver. - idFileLine = case_name + ' ' + repr(ids[0][0] - 1) + ' ' - areaRatioLine = case_name + ' ' - for k in range(1, refSystem.GetNumberOfPoints() - 1): - idFileLine += repr(ids[k][0] - 1) + ',' - areaRatioLine += repr(ids[k][1]) + ',' - idFileLine += repr(ids[-1][0] - 1) + ' ' + repr(ids[0][1]) - areaRatioLine += repr(ids[-1][1]) - info = {"inlet_area": parameters["inlet_area"], - "idFileLine": str(idFileLine), - "areaRatioLine": str(areaRatioLine) - } - write_parameters(info, path.join(dir_path, case_name)) - - # Display the flow split at the outlets, inlet flow rate, and probes. - if viz: - print("--- Visualizing flow split at outlets, inlet flow rate, and probes in VTK render window. ") - print("--- Press 'q' inside the render window to exit.") - visualize(network.elements, probe_points, surface, mean_inflow_rate) - - # Start simulation though ssh, without password - if config_path is not None: - - # Set up simulation script - if not path.exists(file_name_run_script): - run_script_sample = open(path.join(abs_path, "run_script.sh"), "r").read() - config = json.load(open(config_path)) - run_dict = dict(mesh_name=case_name, - num_nodes=1, - hours=120, - account="nn9249k", - remoteFolder=config["remoteFolder"], - results_folder="results") - run_script = run_script_sample.format(**run_dict) - - # Write script - script_file = open(file_name_run_script, "w") - script_file.write(run_script) - script_file.close() - - run_simulation(config_path, dir_path, case_name) - - -def str2bool(arg): - """ - Convert a string to boolean. - - Args: - arg (str): Input string. - - Returns: - return (bool): Converted string. - """ - if arg.lower() in ('yes', 'true', 't', 'y', '1'): - return True - elif arg.lower() in ('no', 'false', 'f', 'n', '0'): - return False - else: - raise argparse.ArgumentTypeError('Boolean value expected.') - - -def read_command_line(): - """ - Read arguments from commandline and return all values in a dictionary. - """ - '''Command-line arguments.''' - parser = argparse.ArgumentParser( - description="Automatic pre-processing for FEniCS.") - - parser.add_argument('-v', '--verbosity', - dest='verbosity', - type=str2bool, - default=False, - help="Activates the verbose mode.") - - parser.add_argument('-i', '--inputModel', - type=str, - required=False, - dest='fileNameModel', - default='example/surface.vtp', - help="Input file containing the 3D model.") - - parser.add_argument('-sM', '--smoothingMethod', - type=str, - required=False, - dest='smoothingMethod', - default="no_smooth", - choices=["voronoi", "no_smooth", "laplace", "taubin"], - help="Smoothing method, for now only Voronoi smoothing is available." + - " For Voronoi smoothing you can also control smoothingFactor" + - " (default = 0.25) and smoothingAneurysm (default = False).") - - parser.add_argument('-c', '--coarseningFactor', - type=float, - required=False, - dest='coarseningFactor', - default=1.0, - help="Refine or coarsen the standard mesh size") - - parser.add_argument('-sF', '--smoothingFactor', - type=float, - required=False, - dest='smoothingFactor', - default=0.25, - help="smoothingFactor for VoronoiSmoothing, removes all spheres which" + - " has a radius < MISR*(1-0.25), where MISR varying along the centerline.") - - parser.add_argument('-sA', '--smoothAneurysm', - type=str2bool, - required=False, - dest="smoothingAneurysm", - help="When using Voronoi smoothing one can choose not to smooth the" + - " aneurysm as this method often removes to much of the aneurysm") - - parser.add_argument('-m', '--meshingMethod', - dest="meshingMethod", - type=str, - choices=["diameter", "curvature"], - default="diameter") - - parser.add_argument('-a', '--aneurysm', - dest="aneu", - type=str2bool, - default=True, - help="Determine weather or not the model has a aneurysm. Default is False.") - - parser.add_argument('-f', '--flowext', - dest="fext", - default=True, - type=str2bool, - help="Add flow extensions to to the model.") - - parser.add_argument('-vz', '--visualize', - dest="viz", - default=True, - type=str2bool, - help="Visualize surface, inlet, outlet and probes after meshing.") - - parser.add_argument('-sp', '--sacpoints', - type=int, - help='Number of sac points to add', - default=20, - dest="sacpts") - - parser.add_argument('--simulationConfig', - type=str, - dest="config", - default=None, - help='Path to configuration file for remote simulation. ' + - 'See example/ssh_config.json for details') - parser.add_argument('-atr', '--atrium', - dest="atri", - type=str2bool, - default=False, - help="Determine weather or not the model is Atrium not Artery. Default is False.") - - - args, _ = parser.parse_known_args() - - if args.verbosity: - print() - print("--- VERBOSE MODE ACTIVATED ---") - - def verbose_print(*args): - for arg in args: - print(arg, end=' ') - print() - else: - verbose_print = lambda *a: None - - verbose_print(args) - - return dict(filename_model=args.fileNameModel, verbose_print=verbose_print, smoothing_method=args.smoothingMethod, - smoothing_factor=args.smoothingFactor, smooth_aneurysm=args.smoothingAneurysm, - meshing_method=args.meshingMethod, aneurysm_present=args.aneu, create_flow_extensions=args.fext, - viz=args.viz, config_path=args.config, number_of_sac_points=args.sacpts, - coarsening_factor=args.coarseningFactor) - - -if __name__ == "__main__": - run_pre_processing(**read_command_line()) From 243988b08124c1eef780b34523c256ea1b01c4dc Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Tue, 25 May 2021 08:51:29 +0200 Subject: [PATCH 03/76] Delete Parabolic.py --- Parabolic.py | 220 --------------------------------------------------- 1 file changed, 220 deletions(-) delete mode 100644 Parabolic.py diff --git a/Parabolic.py b/Parabolic.py deleted file mode 100644 index 8e464072..00000000 --- a/Parabolic.py +++ /dev/null @@ -1,220 +0,0 @@ -# This file is modified and simplified from Womersely - - -from dolfin import (UserExpression, Mesh, MeshFunction, SubsetIterator, MPI, ds, -assemble, Constant, sqrt, FacetNormal, as_vector, SpatialCoordinate) - -import numpy as np - -from scipy.interpolate import UnivariateSpline -from scipy.integrate import simps, romberg -from scipy.special import jn -import math - -def x_to_r2(x, c, n): - """Compute r**2 from a coordinate x, center point c, and normal vector n. - - r is defined as the distance from c to x', where x' is - the projection of x onto the plane defined by c and n. - """ - # Steps: - # rv = x - c - # rvn = rv . n - # rp = rv - (rv . n) n - # r2 = ||rp||**2 - - rv = x-c - rvn = rv.dot(n) - rp = rv - rvn*n - r2 = rp.dot(rp) - - return r2 - -def compute_radius(mesh, facet_domains, ind, center): - d = len(center) - it = SubsetIterator(facet_domains, ind) - geom = mesh.geometry() - #maxr2 = -1.0 - maxr2 = 0 - for i, facet in enumerate(it): - ent = facet.entities(0) - for v in ent: - p = geom.point(v) - r2 = sum((p[j] - center[j])**2 for j in range(d)) - maxr2 = max(maxr2, r2) - r = MPI.max(MPI.comm_world, sqrt(maxr2)) - return r - - -def compute_boundary_geometry_acrn(mesh, ind, facet_domains): - # Some convenient variables - assert facet_domains is not None - dsi = ds(ind, domain=mesh, subdomain_data=facet_domains) - - d = mesh.geometry().dim() - x = SpatialCoordinate(mesh) - - # Compute area of boundary tesselation by integrating 1.0 over all facets - A = assemble(Constant(1.0, name="one")*dsi) - #assert A > 0.0, "Expecting positive area, probably mismatch between mesh and markers!" - if A == 0: - return None - - # Compute barycenter by integrating x components over all facets - c = [assemble(x[i]*dsi) / A for i in range(d)] - - # Compute average normal (assuming boundary is actually flat) - n = FacetNormal(mesh) - ni = np.array([assemble(n[i]*dsi) for i in range(d)]) - n_len = np.sqrt(sum([ni[i]**2 for i in range(d)])) # Should always be 1!? - normal = ni/n_len - - # Compute radius by taking max radius of boundary points - # (assuming boundary points are on exact geometry) - # r = compute_radius(mesh, facet_domains, ind, c) - # This old estimate is a few % lower because of boundary discretization errors - r = np.sqrt(A / math.pi) - - return A, c, r, normal - - -def compute_area(mesh, ind, facet_domains): - # Some convenient variables - assert facet_domains is not None - dsi = ds(ind, domain=mesh, subdomain_data=facet_domains) - - # Compute area of boundary tesselation by integrating 1.0 over all facets - A = assemble(Constant(1.0, name="one")*dsi) - assert A > 0.0, "Expecting positive area, probably mismatch between mesh and markers!" - return A - - -def fourier_coefficients(x, y, T, N): - '''From x-array and y-spline and period T, calculate N complex Fourier coefficients.''' - omega = 2*np.pi/T - ck = [] - ck.append(1/T*simps(y(x), x)) - for n in range(1,N): - c = 1/T*simps(y(x)*np.exp(-1j*n*omega*x), x) - - # Clamp almost zero real and imag components to zero - if 1: - cr = c.real - ci = c.imag - if abs(cr) < 1e-14: cr = 0.0 - if abs(ci) < 1e-14: ci = 0.0 - c = cr + ci*1j - - ck.append(2*c) - return ck - - -class ParabolicComponent(UserExpression): - # Subclassing the expression class restricts the number of arguments, args - # is therefore a dict of arguments. - def __init__(self, radius, center, normal, normal_component, period, nu, element, Q=None, - V=None): - # Spatial args - self.radius = radius - self.center = center - self.normal = normal - self.normal_component = normal_component - - # Temporal args - self.period = period - if Q is not None: - assert V is None, "Cannot provide both Q and V!" - self.Qn = Q - self.N = len(self.Qn) - elif V is not None: - self.Vn = V - self.N = len(self.Vn) - else: - raise ValueError("Invalid transient data type, missing argument 'Q' or 'V'.") - - self.ns = np.arange(1, self.N) - self.omega = 2 * np.pi / self.period - - # Physical args - self.nu = nu - - # Internal state - self.t = None - self.scale_value = 1.0 - - # Precomputation - #self._precompute_bessel_functions() - self._all_r_dependent_coeffs = {} - - super().__init__(element=element) - - def _precompute_r_dependent_coeffs(self, y): #y ? - pir2 = np.pi * self.radius**2 - # Compute intermediate terms for womersley function - #r_dependent_coeffs = np.zeros(self.N, dtype=np.complex) - r_dependent_coeffs = np.zeros(self.N) - if hasattr(self, 'Vn'): - #r_dependent_coeffs[0] = (self.Vn[0]/2.0) * (1 - y**2) - r_dependent_coeffs[0] = self.Vn[0] * (1 - y**2) - for n in self.ns: - r_dependent_coeffs[n] = self.Vn[n] - elif hasattr(self, 'Qn'): - r_dependent_coeffs[0] = (2*self.Qn[0]/pir2) * (1 - y**2) - for n in self.ns: - r_dependent_coeffs[n] = self.Qn[n] - else: - raise ValueError("Missing Vn or Qn!") - return r_dependent_coeffs - - def _get_r_dependent_coeffs(self, y): - "Look for cached coeffs." - key = y - r_dependent_coeffs = self._all_r_dependent_coeffs.get(key) - if r_dependent_coeffs is None: - # Cache miss! Compute coeffs for this coordinate the first time. - r_dependent_coeffs = self._precompute_r_dependent_coeffs(y) - self._all_r_dependent_coeffs[key] = r_dependent_coeffs - return r_dependent_coeffs - - def set_t(self, t): - self.t = float(t) % self.period - self._expnt = np.exp((self.omega * self.t * 1j) * self.ns) - - def eval(self, value, x): - # Compute or get cached complex coefficients that only depend on r - y = np.sqrt(x_to_r2(x, self.center, self.normal)) / self.radius - coeffs = self._get_r_dependent_coeffs(y) - - # Multiply complex coefficients for x with complex exponential functions in time - par = (coeffs[0] + np.dot(coeffs[1:], self._expnt)).real - - # Scale by negative normal direction and scale_value - value[0] = -self.normal_component * self.scale_value * par - -def make_parabolic_bcs(t, Q, mesh, nu, area, center, radius, normal, - element, scale_to=None, coeffstype="Q", - N=1001, num_fourier_coefficients=20, **NS_namespace): - """Generate a list of expressions for the components of a profile.""" - # Compute transient profile as interpolation of given coefficients - period = max(t) - transient_profile = UnivariateSpline(t, Q, s=0, k=1) - - # Compute fourier coefficients of transient profile - timedisc = np.linspace(0, period, N) - - Cn = fourier_coefficients(timedisc, transient_profile, period, num_fourier_coefficients) - - # Create Expressions for each direction - expressions = [] - for ncomp in normal: - if coeffstype == "Q": - Q = Cn - V = None - elif coeffstype == "V": - V = Cn - Q = None - expressions.append(ParabolicComponent(radius, center, normal, ncomp, period, nu, - element, Q=Q, V=V)) - - return expressions - From 0e50569ca8dde489250a9f0d0cfb5c0880a11fb0 Mon Sep 17 00:00:00 2001 From: EhsannKh Date: Tue, 25 May 2021 08:59:02 +0200 Subject: [PATCH 04/76] updated Atrium.py --- pv_velocity.txt | 220 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 220 insertions(+) create mode 100644 pv_velocity.txt diff --git a/pv_velocity.txt b/pv_velocity.txt new file mode 100644 index 00000000..d250d571 --- /dev/null +++ b/pv_velocity.txt @@ -0,0 +1,220 @@ +0.001140250855188 0.168889733519152 +0.010262257696693 0.171118712783479 +0.013683010262258 0.171861987415009 +0.017103762827822 0.17334600278728 +0.020524515393387 0.174830018159551 +0.025085518814139 0.176314878162085 +0.028506271379704 0.178539634275096 +0.033067274800456 0.181505975759111 +0.036488027366021 0.182989991131382 +0.039908779931585 0.185214747244394 +0.042189281641961 0.187438658727142 +0.046750285062714 0.191145740951898 +0.050171037628278 0.194111237805651 +0.053591790193843 0.197817475400144 +0.058152793614595 0.200783816884159 +0.06157354618016 0.204490054478652 +0.064994298745724 0.209677773554626 +0.0672748004561 0.213383166518856 +0.071835803876853 0.217830989484353 +0.075256556442417 0.222277967819587 +0.07981755986317 0.225985050044343 +0.083238312428734 0.232654250601799 +0.088939566704675 0.240806621901263 +0.091220068415051 0.246734237087715 +0.096921322690992 0.254145867646438 +0.100342075256556 0.258592845981672 +0.101482326111745 0.260815912834157 +0.103762827822121 0.263039824316905 +0.106043329532497 0.267485958021876 +0.108323831242873 0.270450610245365 +0.11060433295325 0.273415262468854 +0.115165336374002 0.280085307656573 +0.118586088939567 0.283791545251066 +0.119726339794755 0.287496093585033 +0.123147092360319 0.289720849698045 +0.125427594070696 0.292685501921534 +0.12884834663626 0.297132480256768 +0.132269099201824 0.300838717851261 +0.136830102622577 0.306027281557498 +0.14139110604333 0.311956586004477 +0.144811858608894 0.31640356433971 +0.150513112884835 0.322333713416952 +0.156214367160775 0.326782381012712 +0.15963511972634 0.329747877866464 +0.163055872291904 0.332713374720216 +0.166476624857469 0.336419612314709 +0.171037628278221 0.339385953798725 +0.175598631698974 0.340870813801259 +0.180159635119726 0.343837155285274 +0.184720638540479 0.345322015287808 +0.19042189281642 0.346807719920605 +0.19612314709236 0.34681194307192 +0.202964652223489 0.346817010853499 +0.210946408209806 0.3460821825246 +0.217787913340935 0.344605768824697 +0.224629418472064 0.343129355124794 +0.230330672748005 0.338689133831665 +0.234891676168757 0.335729549389755 +0.23945267958951 0.333510705688585 +0.24515393386545 0.329811225136197 +0.248574686431015 0.325369314582541 +0.253135689851767 0.320187507918409 +0.255416191562144 0.315744752734491 +0.261117445838084 0.310563790700621 +0.264538198403649 0.307603361628447 +0.266818700114025 0.301679124963047 +0.271379703534778 0.297978799780396 +0.27594070695553 0.292796993116263 +0.280501710376283 0.287615186452131 +0.285062713797035 0.282433379787998 +0.287343215507412 0.279472106085561 +0.290763968072976 0.274289454791165 +0.291904218928164 0.270586595717725 +0.295324971493729 0.265403944423329 +0.299885974914481 0.258740656277714 +0.305587229190422 0.254300434984585 +0.307867730900798 0.248376198319186 +0.312428734321551 0.242453650914312 +0.316989737742303 0.237271844250179 +0.320410490307868 0.231348452215043 +0.326111744583808 0.225426749440432 +0.330672748004561 0.217281979813337 +0.334093500570125 0.212840069259682 +0.339794754846066 0.207659107225812 +0.346636259977195 0.200256767599983 +0.353477765108324 0.195076650196377 +0.356898517673888 0.191375480383462 +0.361459521094641 0.186193673719329 +0.367160775370582 0.183234933907682 +0.372862029646522 0.180276194096034 +0.377423033067275 0.175835128172642 +0.381984036488027 0.174357025212213 +0.385404789053592 0.17213733688078 +0.388825541619156 0.170658389290088 +0.392246294184721 0.169179441699396 +0.394526795895097 0.169181130959922 +0.397947548460661 0.169183664850712 +0.399087799315849 0.170665990962456 +0.403648802736602 0.17215085096499 +0.40478905359179 0.173633177076735 +0.407069555302166 0.171412644115039 +0.411630558722919 0.171416022636091 +0.416191562143672 0.169937919675662 +0.424173318129989 0.169943832087504 +0.431014823261117 0.170689640609823 +0.436716077537058 0.17217534524262 +0.442417331812999 0.173661049875417 +0.450399087799316 0.176629925250222 +0.458380843785633 0.181080282106508 +0.462941847206385 0.185528105072005 +0.467502850627138 0.189975928037502 +0.470923603192702 0.192200684150513 +0.475484606613455 0.197389247856751 +0.480045610034208 0.201837070822248 +0.483466362599772 0.207765530638963 +0.485746864310148 0.213693145825415 +0.490307867730901 0.217400228050171 +0.493728620296465 0.221847206385405 +0.500570125427594 0.230000422315132 +0.503990877993159 0.235928882131847 +0.508551881413911 0.241858186578825 +0.513112884834664 0.247046750285063 +0.51539338654504 0.250752143249293 +0.518814139110604 0.258162084547489 +0.522234891676169 0.266312766586427 +0.52793614595211 0.272242915663668 +0.532497149372862 0.278912960851387 +0.538198403648803 0.287065332150851 +0.541619156214367 0.295956754930529 +0.545039908779932 0.301885214747244 +0.548460661345496 0.310035896786182 +0.555302166476625 0.320411334938131 +0.561003420752566 0.329304446978335 +0.567844925883694 0.336716922167321 +0.573546180159635 0.344869293466785 +0.578107183580388 0.353761560876726 +0.583808437856328 0.36191393217619 +0.590649942987457 0.368585666624435 +0.59521094640821 0.375255711812154 +0.600912200684151 0.381185860889396 +0.604332953249715 0.385632839224629 +0.612314709236032 0.390823936821656 +0.616875712656785 0.396753241268635 +0.624857468643101 0.401203598124921 +0.63169897377423 0.404912369610203 +0.640820980615735 0.40714134887453 +0.652223489167617 0.407890535917902 +0.661345496009122 0.408638033700747 +0.670467502850627 0.404941087039149 +0.678449258836944 0.401243295747287 +0.685290763968073 0.39606317834368 +0.692132269099202 0.389401579458592 +0.696693272519954 0.383479032053718 +0.702394526795895 0.377557329279108 +0.709236031927024 0.371636471134761 +0.716077537058153 0.36275265002745 +0.721778791334094 0.355349465771359 +0.727480045610034 0.347205540774526 +0.732041049030787 0.339801511888171 +0.736602052451539 0.333138223742557 +0.74230330672748 0.322772076523502 +0.746864310148233 0.314627306896406 +0.753705815279361 0.306484226529837 +0.758266818700114 0.296857975421259 +0.763968072976055 0.288714050424427 +0.770809578107184 0.276867266354153 +0.775370581527936 0.268722496727058 +0.781071835803877 0.261319312470966 +0.784492588369441 0.253914438954348 +0.789053591790194 0.246510410067993 +0.795895096921323 0.237626588960682 +0.800456100342075 0.230963300815068 +0.807297605473204 0.221338738967017 +0.811858608893957 0.213193969339921 +0.818700114025086 0.206532370454833 +0.824401368301026 0.198388445458001 +0.830102622576967 0.19172600194265 +0.835803876852908 0.187285780649521 +0.843785632839225 0.182106507876177 +0.847206385404789 0.178405338063263 +0.851767388825542 0.173964272139871 +0.855188141391106 0.170263102326956 +0.859749144811858 0.165822036403564 +0.864310148232611 0.160640229739432 +0.872291904218928 0.153979475484607 +0.876852907639681 0.142131002153807 +0.882554161915622 0.12954263271253 +0.88939566704675 0.116955107901516 +0.892816419612315 0.107328012162676 +0.896237172177879 0.099182397905317 +0.899657924743443 0.090296042907217 +0.903078677309008 0.082150428649859 +0.904218928164196 0.072521643650492 +0.908779931584949 0.063636133282656 +0.911060433295325 0.054748933654293 +0.914481185860889 0.047344060137675 +0.919042189281642 0.036236327547616 +0.925883694412771 0.025130284218084 +0.930444697833523 0.015504033109506 +0.937286202964652 0.008842434224418 +0.941847206385405 0.005142109041767 +0.948688711516533 0.003665695341864 +0.956670467502851 0.005893829975928 +0.962371721778791 0.010342497571688 +0.968072976054732 0.014791165167448 +0.973774230330673 0.024425017948393 +0.980615735461802 0.034800456100342 +0.982896237172178 0.045913256471979 +0.988597491448118 0.059250812956628 +0.992018244013683 0.072586680180751 +0.998859749144812 0.080739896110478 +1.00456100342075 0.096299674817349 +1.00684150513113 0.105190252966764 +1.01254275940707 0.117787068710672 +1.01596351197263 0.12667849149035 +1.01710376282782 0.136308965750243 +1.0285062713797 0.149650745386207 +1.03420752565564 0.157803116685671 +1.03990877993159 0.163733265762912 +1.04446978335234 0.168181088728409 From 6e5291c5c4a7dd6c6f5e24e663ad9ca5eb10fb04 Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Tue, 25 May 2021 09:00:51 +0200 Subject: [PATCH 05/76] Delete Dataset.csv --- Dataset.csv | 220 ---------------------------------------------------- 1 file changed, 220 deletions(-) delete mode 100644 Dataset.csv diff --git a/Dataset.csv b/Dataset.csv deleted file mode 100644 index 50c13c51..00000000 --- a/Dataset.csv +++ /dev/null @@ -1,220 +0,0 @@ -0.001140250855188,0.168889733519152 -0.010262257696693,0.171118712783479 -0.013683010262258,0.171861987415009 -0.017103762827822,0.17334600278728 -0.020524515393387,0.174830018159551 -0.025085518814139,0.176314878162085 -0.028506271379704,0.178539634275096 -0.033067274800456,0.181505975759111 -0.036488027366021,0.182989991131382 -0.039908779931585,0.185214747244394 -0.042189281641961,0.187438658727142 -0.046750285062714,0.191145740951898 -0.050171037628278,0.194111237805651 -0.053591790193843,0.197817475400144 -0.058152793614595,0.200783816884159 -0.06157354618016,0.204490054478652 -0.064994298745724,0.209677773554626 -0.0672748004561,0.213383166518856 -0.071835803876853,0.217830989484353 -0.075256556442417,0.222277967819587 -0.07981755986317,0.225985050044343 -0.083238312428734,0.232654250601799 -0.088939566704675,0.240806621901263 -0.091220068415051,0.246734237087715 -0.096921322690992,0.254145867646438 -0.100342075256556,0.258592845981672 -0.101482326111745,0.260815912834157 -0.103762827822121,0.263039824316905 -0.106043329532497,0.267485958021876 -0.108323831242873,0.270450610245365 -0.11060433295325,0.273415262468854 -0.115165336374002,0.280085307656573 -0.118586088939567,0.283791545251066 -0.119726339794755,0.287496093585033 -0.123147092360319,0.289720849698045 -0.125427594070696,0.292685501921534 -0.12884834663626,0.297132480256768 -0.132269099201824,0.300838717851261 -0.136830102622577,0.306027281557498 -0.14139110604333,0.311956586004477 -0.144811858608894,0.31640356433971 -0.150513112884835,0.322333713416952 -0.156214367160775,0.326782381012712 -0.15963511972634,0.329747877866464 -0.163055872291904,0.332713374720216 -0.166476624857469,0.336419612314709 -0.171037628278221,0.339385953798725 -0.175598631698974,0.340870813801259 -0.180159635119726,0.343837155285274 -0.184720638540479,0.345322015287808 -0.19042189281642,0.346807719920605 -0.19612314709236,0.34681194307192 -0.202964652223489,0.346817010853499 -0.210946408209806,0.3460821825246 -0.217787913340935,0.344605768824697 -0.224629418472064,0.343129355124794 -0.230330672748005,0.338689133831665 -0.234891676168757,0.335729549389755 -0.23945267958951,0.333510705688585 -0.24515393386545,0.329811225136197 -0.248574686431015,0.325369314582541 -0.253135689851767,0.320187507918409 -0.255416191562144,0.315744752734491 -0.261117445838084,0.310563790700621 -0.264538198403649,0.307603361628447 -0.266818700114025,0.301679124963047 -0.271379703534778,0.297978799780396 -0.27594070695553,0.292796993116263 -0.280501710376283,0.287615186452131 -0.285062713797035,0.282433379787998 -0.287343215507412,0.279472106085561 -0.290763968072976,0.274289454791165 -0.291904218928164,0.270586595717725 -0.295324971493729,0.265403944423329 -0.299885974914481,0.258740656277714 -0.305587229190422,0.254300434984585 -0.307867730900798,0.248376198319186 -0.312428734321551,0.242453650914312 -0.316989737742303,0.237271844250179 -0.320410490307868,0.231348452215043 -0.326111744583808,0.225426749440432 -0.330672748004561,0.217281979813337 -0.334093500570125,0.212840069259682 -0.339794754846066,0.207659107225812 -0.346636259977195,0.200256767599983 -0.353477765108324,0.195076650196377 -0.356898517673888,0.191375480383462 -0.361459521094641,0.186193673719329 -0.367160775370582,0.183234933907682 -0.372862029646522,0.180276194096034 -0.377423033067275,0.175835128172642 -0.381984036488027,0.174357025212213 -0.385404789053592,0.17213733688078 -0.388825541619156,0.170658389290088 -0.392246294184721,0.169179441699396 -0.394526795895097,0.169181130959922 -0.397947548460661,0.169183664850712 -0.399087799315849,0.170665990962456 -0.403648802736602,0.17215085096499 -0.40478905359179,0.173633177076735 -0.407069555302166,0.171412644115039 -0.411630558722919,0.171416022636091 -0.416191562143672,0.169937919675662 -0.424173318129989,0.169943832087504 -0.431014823261117,0.170689640609823 -0.436716077537058,0.17217534524262 -0.442417331812999,0.173661049875417 -0.450399087799316,0.176629925250222 -0.458380843785633,0.181080282106508 -0.462941847206385,0.185528105072005 -0.467502850627138,0.189975928037502 -0.470923603192702,0.192200684150513 -0.475484606613455,0.197389247856751 -0.480045610034208,0.201837070822248 -0.483466362599772,0.207765530638963 -0.485746864310148,0.213693145825415 -0.490307867730901,0.217400228050171 -0.493728620296465,0.221847206385405 -0.500570125427594,0.230000422315132 -0.503990877993159,0.235928882131847 -0.508551881413911,0.241858186578825 -0.513112884834664,0.247046750285063 -0.51539338654504,0.250752143249293 -0.518814139110604,0.258162084547489 -0.522234891676169,0.266312766586427 -0.52793614595211,0.272242915663668 -0.532497149372862,0.278912960851387 -0.538198403648803,0.287065332150851 -0.541619156214367,0.295956754930529 -0.545039908779932,0.301885214747244 -0.548460661345496,0.310035896786182 -0.555302166476625,0.320411334938131 -0.561003420752566,0.329304446978335 -0.567844925883694,0.336716922167321 -0.573546180159635,0.344869293466785 -0.578107183580388,0.353761560876726 -0.583808437856328,0.36191393217619 -0.590649942987457,0.368585666624435 -0.59521094640821,0.375255711812154 -0.600912200684151,0.381185860889396 -0.604332953249715,0.385632839224629 -0.612314709236032,0.390823936821656 -0.616875712656785,0.396753241268635 -0.624857468643101,0.401203598124921 -0.63169897377423,0.404912369610203 -0.640820980615735,0.40714134887453 -0.652223489167617,0.407890535917902 -0.661345496009122,0.408638033700747 -0.670467502850627,0.404941087039149 -0.678449258836944,0.401243295747287 -0.685290763968073,0.39606317834368 -0.692132269099202,0.389401579458592 -0.696693272519954,0.383479032053718 -0.702394526795895,0.377557329279108 -0.709236031927024,0.371636471134761 -0.716077537058153,0.36275265002745 -0.721778791334094,0.355349465771359 -0.727480045610034,0.347205540774526 -0.732041049030787,0.339801511888171 -0.736602052451539,0.333138223742557 -0.74230330672748,0.322772076523502 -0.746864310148233,0.314627306896406 -0.753705815279361,0.306484226529837 -0.758266818700114,0.296857975421259 -0.763968072976055,0.288714050424427 -0.770809578107184,0.276867266354153 -0.775370581527936,0.268722496727058 -0.781071835803877,0.261319312470966 -0.784492588369441,0.253914438954348 -0.789053591790194,0.246510410067993 -0.795895096921323,0.237626588960682 -0.800456100342075,0.230963300815068 -0.807297605473204,0.221338738967017 -0.811858608893957,0.213193969339921 -0.818700114025086,0.206532370454833 -0.824401368301026,0.198388445458001 -0.830102622576967,0.19172600194265 -0.835803876852908,0.187285780649521 -0.843785632839225,0.182106507876177 -0.847206385404789,0.178405338063263 -0.851767388825542,0.173964272139871 -0.855188141391106,0.170263102326956 -0.859749144811858,0.165822036403564 -0.864310148232611,0.160640229739432 -0.872291904218928,0.153979475484607 -0.876852907639681,0.142131002153807 -0.882554161915622,0.12954263271253 -0.88939566704675,0.116955107901516 -0.892816419612315,0.107328012162676 -0.896237172177879,0.099182397905317 -0.899657924743443,0.090296042907217 -0.903078677309008,0.082150428649859 -0.904218928164196,0.072521643650492 -0.908779931584949,0.063636133282656 -0.911060433295325,0.054748933654293 -0.914481185860889,0.047344060137675 -0.919042189281642,0.036236327547616 -0.925883694412771,0.025130284218084 -0.930444697833523,0.015504033109506 -0.937286202964652,0.008842434224418 -0.941847206385405,0.005142109041767 -0.948688711516533,0.003665695341864 -0.956670467502851,0.005893829975928 -0.962371721778791,0.010342497571688 -0.968072976054732,0.014791165167448 -0.973774230330673,0.024425017948393 -0.980615735461802,0.034800456100342 -0.982896237172178,0.045913256471979 -0.988597491448118,0.059250812956628 -0.992018244013683,0.072586680180751 -0.998859749144812,0.080739896110478 -1.00456100342075,0.096299674817349 -1.00684150513113,0.105190252966764 -1.01254275940707,0.117787068710672 -1.01596351197263,0.12667849149035 -1.01710376282782,0.136308965750243 -1.0285062713797,0.149650745386207 -1.03420752565564,0.157803116685671 -1.03990877993159,0.163733265762912 -1.04446978335234,0.168181088728409 From 87bb146ae89d5274c22460e5cf86ce244b002b68 Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Tue, 25 May 2021 09:04:51 +0200 Subject: [PATCH 06/76] Delete launch.json --- .vscode/launch.json | 14 -------------- 1 file changed, 14 deletions(-) delete mode 100644 .vscode/launch.json diff --git a/.vscode/launch.json b/.vscode/launch.json deleted file mode 100644 index d01f4381..00000000 --- a/.vscode/launch.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - // Use IntelliSense to learn about possible attributes. - // Hover to view descriptions of existing attributes. - // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 - "version": "0.2.0", - "configurations": [ - { - "name": "Python: Attach using Process Id", - "type": "python", - "request": "attach", - "processId": "${command:pickProcess}" - } - ] -} \ No newline at end of file From 03fdd5286968a61e65b7e6b8a06cfee0b7e91a82 Mon Sep 17 00:00:00 2001 From: EhsannKh Date: Tue, 25 May 2021 09:09:18 +0200 Subject: [PATCH 07/76] Updated Atrium.py --- Atrium.py | 174 +++++++++++---- Dataset.csv | 220 ------------------- test/Case_test_71/Case_test_71.vtp | Bin 333848 -> 0 bytes test/Case_test_atrium_07/case_test_at_07.vtp | 51 ----- test/b003/README.md | 16 -- test/b003/surface.vtp | 51 ----- 6 files changed, 132 insertions(+), 380 deletions(-) delete mode 100644 Dataset.csv delete mode 100644 test/Case_test_71/Case_test_71.vtp delete mode 100644 test/Case_test_atrium_07/case_test_at_07.vtp delete mode 100644 test/b003/README.md delete mode 100644 test/b003/surface.vtp diff --git a/Atrium.py b/Atrium.py index 4a57ce62..4fe2c4a6 100755 --- a/Atrium.py +++ b/Atrium.py @@ -7,18 +7,20 @@ import numpy as np from numpy.core.fromnumeric import mean from Womersley import make_womersley_bcs, compute_boundary_geometry_acrn -#from Parabolic import make_parabolic_bcs, compute_boundary_geometry_acrn from fenicstools import Probes from oasis.problems.NSfracStep import * +from scipy.interpolate import UnivariateSpline +from scipy.integrate import simps, romberg + -set_log_level(50) +set_log_level(50) def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_namespace): if "restart_folder" in commandline_kwargs.keys(): restart_folder = commandline_kwargs["restart_folder"] - f = open(path.join(restart_folder, 'params.dat'), 'rb') + f = open(path.join(restart_folder, 'params.dat'), 'r') NS_parameters.update(pickle.load(f)) NS_parameters['restart_folder'] = restart_folder else: @@ -32,8 +34,8 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n id_out=[], # Outlet boundary IDs area_ratio=[], # Simulation parameters - T=1045, # Run simulation for 1 cardiac cycles [ms] - dt=0.1, # 10 000 steps per cycle [ms] + T= 1045,#1.045, # Run simulation for 1 cardiac cycles [ms] + dt=0.1,#0.0001, # 10 000 steps per cycle [ms] no_of_cycles=1, dump_stats=100, store_data=5, @@ -60,15 +62,53 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n def mesh(mesh_path, **NS_namespace): # Read mesh return Mesh(mesh_path) - + +class boundary_expression(UserExpression): + + def __init__(self, coeffs, omega, period, normal, normal_component, area, centers, radius, **kwargs): + + self.Cn = coeffs + self.omega = omega + self.period = period + self.normal = normal + self.normal_component = normal_component + self.area = area + self.centers = centers + self.radius = radius + self.num_fourier_coefficients = len(coeffs) + self.t = None + self.ns = ns = np.arange(1,self.num_fourier_coefficients) + + super().__init__(**kwargs) + + + def update(self, t): + self.t = float(t) % self.period + self._expnt = np.exp((self.omega * self.t * 1j) * self.ns) + + def parabolic(self, x): + r2 = self.radius**2 + x0=self.centers[0] + x1=self.centers[1] + x2=self.centers[2] + return 1 - ( pow(x0 - x[0], 2) + pow(x1 - x[1], 2) + pow(x2 - x[2], 2) ) / r2 + + def eval(self,values,x): + + # blunt profile + par = (self.Cn[0] + np.dot(self.Cn[1:], self._expnt)).real + # Scale by negative normal direction + values[0] = -self.normal_component * par + + def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, id_out, pressure_degree, **NS_namespace): # Mesh function boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) boundary.set_values(boundary.array() + 1) - id_in = [2,3,5,6] # Hardcoded. FIXIT: automated prepocessing - id_out = [4] + id_in = [3,4,5,6] # Hardcoded. FIXIT: automated prepocessing + id_out = [2] # Read case parameters info_path = mesh_path.split(".")[0] + ".json" @@ -77,8 +117,9 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, # Extract flow split ratios and inlet/outlet IDs id_info = info['idFileLine'].split() - #id_out.append(int(id_info[1])) - #id_in[:] = [int(p) for p in id_info[2].split(",")] + # id_out.append(int(id_info[1])) + # id_in[:] = [int(p) for p in id_info[2].split(",")] + #Q_mean = float(id_info[3]) area_ratio[:] = [float(p) for p in info['areaRatioLine'].split()[-1].split(",")] area_in = np.array([info['outlet0_area'],info['outlet1_area'],info['outlet2_area'],info['outlet3_area']]) @@ -88,32 +129,37 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, NS_parameters['dim_MV'] = dim_MV NS_parameters['dim_PV'] = dim_PV - Q_mean = 20 # [ml] - t_values, Q_ = np.load(path.join(path.dirname(path.abspath(__file__)), "ICA_values")) - Q_values = Q_mean * Q_ - t_values *= 1000 - - # t_values , V_values = [], [] - # try: - # with open(path.join(path.dirname(path.abspath(__file__)), "Dataset.csv")) as csvfile: - # csvReader = csv.reader(csvfile) - # for row in csvReader: - # t_values.append(float(row[0])*1000) #convert to ms - # V_values.append(float(row[1])) - # except ValueError: - # raise + # Q_mean = 10 # [ml] + # t_values, Q_ = np.load(path.join(path.dirname(path.abspath(__file__)), "ICA_values")) + # Q_values = Q_mean * Q_ + # t_values *= 1000 + + t_values , V_values = [], [] + try: + t_values, V_values = np.loadtxt(path.join(path.dirname(path.abspath(__file__)), "pv_velocity.txt")).T + t_values *= 1000 + except ValueError: + raise bc_inlets = {} for i, ID in enumerate(id_in): - tmp_area, tmp_center, tmp_radius, tmp_normal = compute_boundary_geometry_acrn(mesh, id_in[i], boundary) - inlet = make_womersley_bcs(t_values, Q_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element()) - #inlet = make_parabolic_bcs(t_values, V_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element(),coeffstype="V") + tmp_area, tmp_center, tmp_radius, tmp_normal = compute_boundary_geometry_acrn(mesh, id_in[i], boundary) + inlet, coeffs = [], [] + coeffs, omega, period = get_coeffients(t_values, V_values) + for normal_component in tmp_normal: + _in = boundary_expression(coeffs, omega, period, tmp_normal, normal_component, tmp_area, tmp_center, tmp_radius, element = V.ufl_element()) + inlet.append(_in) + NS_expressions[ID] = inlet bc_inlet = [DirichletBC(V, inlet[i], boundary, ID) for i in range(3)] bc_inlets[ID] = bc_inlet # Set start time equal to t_0 for uc in inlet: - uc.set_t(t) + uc.update(t) + + #inlet = make_womersley_bcs(t_values, Q_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element()) + #inlet = make_parabolic_bcs(t_values, V_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element(),coeffstype="V") + bc_p = [] for i, ID in enumerate(id_out): @@ -187,13 +233,13 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) boundary.set_values(boundary.array() + 1) - id_in = [2,3,5,6] # Hardcoded. FIXIT: automated prepocessing - id_out = [4] - + id_in = [3,4,5,6] # Hardcoded. FIXIT: automated prepocessing + id_out = [2] + # Update boundary condition for i, in_id in enumerate(id_in): for uc in NS_expressions[in_id]: - uc.set_t(t) + uc.update(t) # Compute flux and update pressure condition if tstep > 2: @@ -208,21 +254,22 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, max_cfl = cfl.max() min_cfl = cfl.min() + # print(cfl.max()*h / dt) dim_MV = NS_parameters['dim_MV'] dim_PV = NS_parameters['dim_PV'] - # Re = U.vector().get_local() * dim_MV / NS_parameters['nu'] - # Re_MV = Re.max()*1000 - # Re_ = U.vector().get_local() * dim_PV / NS_parameters['nu'] - # Re_PV = Re_.max()*1000 + Re = U.vector().get_local() * dim_MV / NS_parameters['nu'] + Re_MV = Re.max() + Re_ = U.vector().get_local() * dim_PV / NS_parameters['nu'] + Re_PV = Re_.max() if MPI.rank(MPI.comm_world) == 0 and tstep % 10 == 0: print("=" * 10, tstep, "=" * 10) print() - # info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}, Re_PV={0:2.4e}, Re_MV={0:2.4e}' - # .format(t, tstep, max_cfl, min_cfl, Re_PV, Re_MV)) - info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}' - .format(t, tstep, max_cfl, min_cfl)) + info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}, Re_PV={0:2.4e}, Re_MV={0:2.4e}' + .format(t, tstep, max_cfl, min_cfl, Re_PV, Re_MV)) + # info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}' + # .format(t, tstep, max_cfl, min_cfl)) print("Sum of Q_in = {:0.4f} Q_out = {:0.4f}".format(sum(Q_ins), Q_out)) #for i, in_id in enumerate(id_in): # print(("({:d}) New pressure {:0.4f}").format(out_id, NS_expressions[out_id].p)) @@ -230,14 +277,15 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, # print(("({:d}) area ratio {:0.4f}, ideal: {:0.4f} actual:" + # " {:0.4f}").format(in_id, area_ratio[i], Q_ideals[i], Q_ins[i])) print() - + if MPI.rank(MPI.comm_world) == 0 and tstep > 2: velocity_path = path.join(newfolder, "Timeseries", "velocity.txt") if not path.isdir(path.join(newfolder, "Timeseries")): os.mkdir(path.join(newfolder, "Timeseries")) with open(velocity_path, 'a') as filename: - filename.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, V_out, V_ins[0], V_ins[1], V_ins[2], V_ins[3])) + #filename.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, Q_out, Q_ins[0], Q_ins[1], Q_ins[2], Q_ins[3])) + filename.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, V_out, V_ins[0], V_ins[1], V_ins[2], V_ins[3])) # Sample velocity in points eval_dict["centerline_u_x_probes"](u_[0]) @@ -334,3 +382,45 @@ def EdgeLength(mesh): return edge_length + +def get_coeffients(x,y): + + num_fourier_coefficients = 20 + + N = len(x) + 1 + # Compute transient profile as interpolation of given coefficients + period = max(x) + transient_profile = UnivariateSpline(x, y, s=0, k=1) + + # Compute fourier coefficients of transient profile + timedisc = np.linspace(0, period, N) + + Cn, omega = fourier_coefficients(timedisc, transient_profile, period, num_fourier_coefficients) + + return Cn, omega, period + +def fourier_coefficients(x, y, T, N): + + '''From x-array and y-spline and period T, calculate N complex Fourier coefficients.''' + omega = 2*np.pi/T + ck = [] + ck.append(1/T*simps(y(x), x)) + for n in range(1,N): + c = 1/T*simps(y(x)*np.exp(-1j*n*omega*x), x) + + # Clamp almost zero real and imag components to zero + if 1: + cr = c.real + ci = c.imag + if abs(cr) < 1e-14: cr = 0.0 + if abs(ci) < 1e-14: ci = 0.0 + c = cr + ci*1j + + ck.append(2*c) + + return ck, omega + + + + + diff --git a/Dataset.csv b/Dataset.csv deleted file mode 100644 index 50c13c51..00000000 --- a/Dataset.csv +++ /dev/null @@ -1,220 +0,0 @@ -0.001140250855188,0.168889733519152 -0.010262257696693,0.171118712783479 -0.013683010262258,0.171861987415009 -0.017103762827822,0.17334600278728 -0.020524515393387,0.174830018159551 -0.025085518814139,0.176314878162085 -0.028506271379704,0.178539634275096 -0.033067274800456,0.181505975759111 -0.036488027366021,0.182989991131382 -0.039908779931585,0.185214747244394 -0.042189281641961,0.187438658727142 -0.046750285062714,0.191145740951898 -0.050171037628278,0.194111237805651 -0.053591790193843,0.197817475400144 -0.058152793614595,0.200783816884159 -0.06157354618016,0.204490054478652 -0.064994298745724,0.209677773554626 -0.0672748004561,0.213383166518856 -0.071835803876853,0.217830989484353 -0.075256556442417,0.222277967819587 -0.07981755986317,0.225985050044343 -0.083238312428734,0.232654250601799 -0.088939566704675,0.240806621901263 -0.091220068415051,0.246734237087715 -0.096921322690992,0.254145867646438 -0.100342075256556,0.258592845981672 -0.101482326111745,0.260815912834157 -0.103762827822121,0.263039824316905 -0.106043329532497,0.267485958021876 -0.108323831242873,0.270450610245365 -0.11060433295325,0.273415262468854 -0.115165336374002,0.280085307656573 -0.118586088939567,0.283791545251066 -0.119726339794755,0.287496093585033 -0.123147092360319,0.289720849698045 -0.125427594070696,0.292685501921534 -0.12884834663626,0.297132480256768 -0.132269099201824,0.300838717851261 -0.136830102622577,0.306027281557498 -0.14139110604333,0.311956586004477 -0.144811858608894,0.31640356433971 -0.150513112884835,0.322333713416952 -0.156214367160775,0.326782381012712 -0.15963511972634,0.329747877866464 -0.163055872291904,0.332713374720216 -0.166476624857469,0.336419612314709 -0.171037628278221,0.339385953798725 -0.175598631698974,0.340870813801259 -0.180159635119726,0.343837155285274 -0.184720638540479,0.345322015287808 -0.19042189281642,0.346807719920605 -0.19612314709236,0.34681194307192 -0.202964652223489,0.346817010853499 -0.210946408209806,0.3460821825246 -0.217787913340935,0.344605768824697 -0.224629418472064,0.343129355124794 -0.230330672748005,0.338689133831665 -0.234891676168757,0.335729549389755 -0.23945267958951,0.333510705688585 -0.24515393386545,0.329811225136197 -0.248574686431015,0.325369314582541 -0.253135689851767,0.320187507918409 -0.255416191562144,0.315744752734491 -0.261117445838084,0.310563790700621 -0.264538198403649,0.307603361628447 -0.266818700114025,0.301679124963047 -0.271379703534778,0.297978799780396 -0.27594070695553,0.292796993116263 -0.280501710376283,0.287615186452131 -0.285062713797035,0.282433379787998 -0.287343215507412,0.279472106085561 -0.290763968072976,0.274289454791165 -0.291904218928164,0.270586595717725 -0.295324971493729,0.265403944423329 -0.299885974914481,0.258740656277714 -0.305587229190422,0.254300434984585 -0.307867730900798,0.248376198319186 -0.312428734321551,0.242453650914312 -0.316989737742303,0.237271844250179 -0.320410490307868,0.231348452215043 -0.326111744583808,0.225426749440432 -0.330672748004561,0.217281979813337 -0.334093500570125,0.212840069259682 -0.339794754846066,0.207659107225812 -0.346636259977195,0.200256767599983 -0.353477765108324,0.195076650196377 -0.356898517673888,0.191375480383462 -0.361459521094641,0.186193673719329 -0.367160775370582,0.183234933907682 -0.372862029646522,0.180276194096034 -0.377423033067275,0.175835128172642 -0.381984036488027,0.174357025212213 -0.385404789053592,0.17213733688078 -0.388825541619156,0.170658389290088 -0.392246294184721,0.169179441699396 -0.394526795895097,0.169181130959922 -0.397947548460661,0.169183664850712 -0.399087799315849,0.170665990962456 -0.403648802736602,0.17215085096499 -0.40478905359179,0.173633177076735 -0.407069555302166,0.171412644115039 -0.411630558722919,0.171416022636091 -0.416191562143672,0.169937919675662 -0.424173318129989,0.169943832087504 -0.431014823261117,0.170689640609823 -0.436716077537058,0.17217534524262 -0.442417331812999,0.173661049875417 -0.450399087799316,0.176629925250222 -0.458380843785633,0.181080282106508 -0.462941847206385,0.185528105072005 -0.467502850627138,0.189975928037502 -0.470923603192702,0.192200684150513 -0.475484606613455,0.197389247856751 -0.480045610034208,0.201837070822248 -0.483466362599772,0.207765530638963 -0.485746864310148,0.213693145825415 -0.490307867730901,0.217400228050171 -0.493728620296465,0.221847206385405 -0.500570125427594,0.230000422315132 -0.503990877993159,0.235928882131847 -0.508551881413911,0.241858186578825 -0.513112884834664,0.247046750285063 -0.51539338654504,0.250752143249293 -0.518814139110604,0.258162084547489 -0.522234891676169,0.266312766586427 -0.52793614595211,0.272242915663668 -0.532497149372862,0.278912960851387 -0.538198403648803,0.287065332150851 -0.541619156214367,0.295956754930529 -0.545039908779932,0.301885214747244 -0.548460661345496,0.310035896786182 -0.555302166476625,0.320411334938131 -0.561003420752566,0.329304446978335 -0.567844925883694,0.336716922167321 -0.573546180159635,0.344869293466785 -0.578107183580388,0.353761560876726 -0.583808437856328,0.36191393217619 -0.590649942987457,0.368585666624435 -0.59521094640821,0.375255711812154 -0.600912200684151,0.381185860889396 -0.604332953249715,0.385632839224629 -0.612314709236032,0.390823936821656 -0.616875712656785,0.396753241268635 -0.624857468643101,0.401203598124921 -0.63169897377423,0.404912369610203 -0.640820980615735,0.40714134887453 -0.652223489167617,0.407890535917902 -0.661345496009122,0.408638033700747 -0.670467502850627,0.404941087039149 -0.678449258836944,0.401243295747287 -0.685290763968073,0.39606317834368 -0.692132269099202,0.389401579458592 -0.696693272519954,0.383479032053718 -0.702394526795895,0.377557329279108 -0.709236031927024,0.371636471134761 -0.716077537058153,0.36275265002745 -0.721778791334094,0.355349465771359 -0.727480045610034,0.347205540774526 -0.732041049030787,0.339801511888171 -0.736602052451539,0.333138223742557 -0.74230330672748,0.322772076523502 -0.746864310148233,0.314627306896406 -0.753705815279361,0.306484226529837 -0.758266818700114,0.296857975421259 -0.763968072976055,0.288714050424427 -0.770809578107184,0.276867266354153 -0.775370581527936,0.268722496727058 -0.781071835803877,0.261319312470966 -0.784492588369441,0.253914438954348 -0.789053591790194,0.246510410067993 -0.795895096921323,0.237626588960682 -0.800456100342075,0.230963300815068 -0.807297605473204,0.221338738967017 -0.811858608893957,0.213193969339921 -0.818700114025086,0.206532370454833 -0.824401368301026,0.198388445458001 -0.830102622576967,0.19172600194265 -0.835803876852908,0.187285780649521 -0.843785632839225,0.182106507876177 -0.847206385404789,0.178405338063263 -0.851767388825542,0.173964272139871 -0.855188141391106,0.170263102326956 -0.859749144811858,0.165822036403564 -0.864310148232611,0.160640229739432 -0.872291904218928,0.153979475484607 -0.876852907639681,0.142131002153807 -0.882554161915622,0.12954263271253 -0.88939566704675,0.116955107901516 -0.892816419612315,0.107328012162676 -0.896237172177879,0.099182397905317 -0.899657924743443,0.090296042907217 -0.903078677309008,0.082150428649859 -0.904218928164196,0.072521643650492 -0.908779931584949,0.063636133282656 -0.911060433295325,0.054748933654293 -0.914481185860889,0.047344060137675 -0.919042189281642,0.036236327547616 -0.925883694412771,0.025130284218084 -0.930444697833523,0.015504033109506 -0.937286202964652,0.008842434224418 -0.941847206385405,0.005142109041767 -0.948688711516533,0.003665695341864 -0.956670467502851,0.005893829975928 -0.962371721778791,0.010342497571688 -0.968072976054732,0.014791165167448 -0.973774230330673,0.024425017948393 -0.980615735461802,0.034800456100342 -0.982896237172178,0.045913256471979 -0.988597491448118,0.059250812956628 -0.992018244013683,0.072586680180751 -0.998859749144812,0.080739896110478 -1.00456100342075,0.096299674817349 -1.00684150513113,0.105190252966764 -1.01254275940707,0.117787068710672 -1.01596351197263,0.12667849149035 -1.01710376282782,0.136308965750243 -1.0285062713797,0.149650745386207 -1.03420752565564,0.157803116685671 -1.03990877993159,0.163733265762912 -1.04446978335234,0.168181088728409 diff --git a/test/Case_test_71/Case_test_71.vtp b/test/Case_test_71/Case_test_71.vtp deleted file mode 100644 index b5d43aee615f50d11a13f755d8d89eb9f81836c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 333848 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

$hr6=y?AWpjO=FMSNi(U-`h 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%0DXUjq7^e{X@zC- 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

Jsqk-t>`nRYKhTz)EE61x-( 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 Og5h-)EFW>5+M diff --git a/test/Case_test_atrium_07/case_test_at_07.vtp b/test/Case_test_atrium_07/case_test_at_07.vtp deleted file mode 100644 index 5d9f2854..00000000 --- a/test/Case_test_atrium_07/case_test_at_07.vtp +++ /dev/null @@ -1,51 +0,0 @@ - - - - - - - - - AwAAAACAAACAQQAANAAAADQAAAAmAAAAeJztwQEBAAAAgJD+r+4ICgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYgAAAAXic7cEBAQAAAICQ/q/uCAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIAAAAF4nO3BAQEAAACCIP+vbkhAAQAAAAAAAAAAAAAAAAAAAHwbQYAAAQ== - - - - - BAAAAACAAADwbAAAhm8AAJlvAAD5bgAANF4AAA==eJwUV3VYlcvXtfXa3UVz6O5cC/OagHSeczhBKCK2XpXuRiREQRApA7u7u7uvXT/z2n7z/TfPPPvds2fPflfYaAfwk8qEfkOSMX2OP6etMWbbx8koaONP5XQT1vsnw+SgP0tSTWkSkITcUj8Wu5jy7OEk1Jzz5eRKE55+koyV9325eKUp7R4k4cIOP3pPNOPvD4lYnunLlAVmnKxKwsEhflylNOeBeYnQ8PZlVzNz6rZOglG+D7/8MmOXr0nwt/Ll3k4WlG9IxIQv0xg32YKXLifh0mEfRnSz5O+iRKSf96WjpiXjXiWgzSo/BkZZcPy9BBx770tvFwuGaCViUoA/jxWb01UjES+X+DN0jQVN1ydg14QAlv+2ZL1fApa4BPDuCwt2XpUAzUP+/A+WrJqfgEMLAtnxoCUHNyVg8xsRY23Jm/UJ6DwrkCdeWzFFnYBORUHUuGTFFzcS0FUniB1NrFhzLgGPrYP4oKMNIxMScOtMMO21bZhnmghjk2AOm23Nuj8JSP4SxNlzbPj3vgS4eQdzopYtS68mQEM3hMf+suUSu0TMPxjCc4et2e9WIhbJQtgUZ8OLMxMxtHUIi19YcWNJIi5/D+HkMiu2yJKQbRJG31vWlH5Iwv70UJ4OtaZffhIUYv1KZsPjTklIHB7Ghgwr+kcm46VhOM9nW7ND5xRErQ1jdhdrbtqRjP+2hDFinA0VSIanvZQZATbUfpgCm4nh7LjfhkcbkjHHUcoPaba8GZKCmWYy2pjYMvxkKs7pyljz3pp/KdLQ3lTKRAdrnlKnwv+6lAa/rHhrcRoejZFSpbRiYoc09Hkt5SWJFdcYpONkPymXxVrysV8afMT+oE8WTO2egeJmGad9tWRaSwbur5ExbJA1lx9Lx35fObtstWJTWiZsKOeUa5Z8MCgLE27I2PifBZueZWJzppze4k3Xh2Uj2F3OljEWzE/LhuqMjKtGi3mQZ+Gwj4y12haMTchE3Q4ZJzWZ0+NgFk4OkfGIgzk3XMjEiSIZ358w407HbEQZyvn3OHPmOeZgbDs53Wea0WVVDqqDZPxvmynfHcnG0LFyamw15Y9XuVg0V8Yxh0w45HwOYjrK6Vpiwgb3PKw5IGW7chNK/snGWTcZcy4Yk/a5qE2TcuReY+69l40vS6S8d8WIi7bloOJOOI1tjPnCLhvjBkq5sq8J227NQlF8OL9WGXNF/ywc+zeM57YZ8bdtFhYvCufjLkY8cyIb6eVh/Oe8IY/syoL2yDBWfjWk7ctMzLgWys1ahrwszYLr9FCmrzJkX7m477FQ/p1rxK/nMnCjOYQfI40YnZaOuJwQzpYZsv+qDHT9L1ScZcw1B9PRsVcol00w5rqfaTglZji2rTF/u6Zhwlwxt2+NeXJLKgZHhHLBaBP6zEuD85NQHpWZMtEoDSFHQzjgpQml9qm4Zh7GtlkmbPFIR/2mMG4W8Ur7DJjvCWN0tjHNO2biU0I4DaJMuFfUuahDOGOtTbn3WTqi3aV0nGfKpH2ZWGEs5medCb9MzsLfDeF01DZj/vAMaERIqdtoxqNvMlD3RcrNIWYcPSYLsYVScoc528ozsHNXOKX9zLlybjqynoTTx8GCmY/SIH0XxsQ55nzdMQ3a/cLpuc2ChjGpeNEtjGdumbPfphS0koSxj8Clf4emwG5/GC9VWXLj0hRc8AznWw0r4mUKTu8O4+9pVpyhkYKfw0OZGGPJgv+SMKNS9PCHJSeYJGPxsFAOMbPg+/Rk5HUO4bYECx5emIR2OiFs2WfJDj2T0KdDMLU3WLDv7kQULQvmubECG08nYow8mBv/tuKKiETcvxHE8P2WlCIR0rJAfjpvQZ3WiVgxRuCPnSUTdBJxd1QQ3zlZ8MmyRNjtC+RBqTl3r03EwfIAHllhzla2iXg1PZDS4RZ0sk5E1sMAThD1mD1OQNueAZxha0HtOwnofS+A7eaZ0U3glf59fy5oNuPs0kTM7hZIjSBTeggssu4SxNXeZpR5JuGBSRCH2JnSoEsy2o4OplzHjObDk5HyM4j3FpjzvmMSfoj7yj3MGSZJhmRiCItCzehzMhkv+oVSu7M5nTVTIG0Vyq9fTDlwRwr6dgmh6QJTuo5IwbUrwaxLMmF8eQo+ZQdzrOA13/6peNA7mOZGJlyHFKwYFsyDX0w4Yk8y+k4I4k43E17Yl4zvHoFsnGbCRV7JWJIWyOsKY94cnoJMZQBPzDVmq5fJSFsfwC7ZRgw5k4KnM/x5eoMRu59PwYc4P74S8e7i3MI8Py5LMGLo+FS8PuhL2/lGHPouFXXuvlSuNmajdypmnvFhcL4JfQXG9rnvw+lVphx8LhlPv0/jhv6mHBGRinvHp9HG0YzMT4Fjz2l8vNGUTnppWPPAm5uumHGCfyrmZk3j4VHmDG6VgiEHvRku3utbagq8jKaxp7kl945Pxpnf0/i02ZL9tJLwq/M0psdZcdCvJBh6TGNInhU/7UrCrQ4+LLCzovGfRITV+PBZWyv2FHz9+pMPm19aMt0qETFr/XntHys+dk3An3EBbL5uxba2CXhq6M+ptOLXCQk408WfyzMseTEuASNS/dihhxW/zxUz09mPFz5asldNAva4+rL/M0v+7Ch47UgAIwytOdUtAYfdAtk32ZrNExNw8Wkgw7rYsEdMAoL6ibm1smFrwdF9c0O5MMyePQ4LLaETxsWT7XhazIyTWShrpXbUqEzE0r9DOTnKnj9qEuH3LoSfftjxpuBQnw8hHPfVjm/iElF8L4Qvr9vQqiERXetCaLTVlmmKRHjMC2XPBbZ0epOIVnbhbLxvy/uWyfjsH8YZbW25eXMSHmmH07CdPR/cTcJDQym1W+z4RMzG3G5S7r5uT4+iZOzqKOOCZfZ0OJiCOh0Zz4XbcbZtKn7fl9HWRcT0S0PMcDnLettx2ss07Nwq55rx9ow4ko5nHeR8nePAly5pqBkvZ8UgB/JwGmQNMm7Rd2D7lan4dFtOvYUOHNAjA8e85Bz23YFz/peGpt8yandw4u2VaXh5Sc47jY4MdMzAk60y5rZ15P1TqUh9LmWvegfeTE9Bgq2M3WodqW2UikXXwlnawZGLwpPhkyelxzJHPndKweWO4dyi6cCuDUnYeS2M2t0cKStMwtWvYfTf58gON5PQvXc4931y5KufSYDo25yTjvyvXTLabwxjma0jzyYLjWcnpbzWiavEP7g7MZwepU6sXp6MnZ/DaevnzM/hKdA8IeX8L0780i8VPselfPrHmZ9qUpGeImN2L2cusU3D2K1SPrNyYlZtCrqPkzFZ7kTDtFSsvCxj5hdnPhiajv+UMmp1cOWcF2l4ESDlbwNXLq5Ihep9ON3OuXDLsFQsFpivM9aFluKNHg2Q8ridKztGpiJHIWXAeTe+bElDbbSUSb/ceOWm4IIcoVt+u7FP63RUTJXSVcuND0em4WkrGWe3d2PduTQsMxe9TXelujYVnT7JOKunG6WZGSgcL+PTAe68apSB+Z5yXrnqQn2vDOy6I+eYVa6crsrCrA4R1JnmwruHM/F3kdA2h5x5OjgDc9/IGXTIiRmCl+dbR7C3wpl7GzNxfXkEh+1wZml3oSXSIvjPGye6emXhw8II1g914utuWcjvo2DZNSfO0M/BytYKvlrgyILobIyYHsHoHw60Ls3Eu38j+N5dzMOTLJz1jqD5bXs+c8zE2M0RfPnBjq/jstDxbwVVS+15ZHQO7CUKfj1sx7fPszG3vYITu9vx/uFsFGYoKEmwo/e8XHh5KdgyypY5QbnIEXkevbPh0JnZ6NZTwd5BNmzpl4vKNAV76trQziIfr9qK/DOsaXYhF1nFEdx2yZrRn7NhuyCC9xus2HgoB6O/RPB3gRV3LM7DgGAFte5Zsf5IPv7TV/BbdyuO25+PjdkKnjltyVZbC+Ekzvqua8mP8gK82RHB8gOW3JSch+NxEVTNtiDf56HydwRXCh7c1KMQ/1MomLLYgt+nFyHMSsG55eYsXVCE1WsULPYzp3vjcqGlFTxULjC5TzGqjkbwteDNfV0LUVkQwRP2ZtTzL0TH/0VwhOC+pwuK8WaRgh43TbkhswSXHRU8kGxC2/Ul6HIygg81hc75Vow1EyKIxybMzy5EgGsEl4YY893RIkw6HsFRFsaMWbccT/sraLbYmE53S1D9JoI1B41Y960EEzQUvLLfiJuySxHzIIJb9Yz4uk0puv8U3z435M/3ZdAeJ3reZMQNHSowNlTBAbXG3HSiFPsrxbfnjRmsUYHf8xSM6mBMqXklvugpmNzJiP5nKpEdrhAYZsTUblU4elbBzX+M6fK1Eo0nFIx/YMyzS6tRE6Kg2zUj1s+owbk2Cn56aEiPcWswS8zG2n2G9OlVBUljBDc+N6CvQTVC70ZwoIshJ/63Co6pEYxUGTBPvQrpYg69PQwZ5FuJpV0UHH/QkD/eVODnYdGrfobMKanA+KIIRtka0m9PKfZIIzjc2ICzXSuwc1AEc8ZIKE+pRGxvsQ6TcNjyKmTtk3OFQp894lfj92E5n43X57PNKyFrG8FnRhI+3lWOLs1yvnHTZ2zncliclzN2uIS9/ErRSSeCL/oY8GJmKRYdkvPLXQl3K0swqmcEL/1lSJe3y7EzI4In3Y0Y3K8Eqz/J6atpRMvnRXiULee5Z0Y06VyIaw1yDu9uwiP+Bdgr8DloujFhmI85G+S81tOUc5PzUf1VzvFfTbm+Ih/3rUQfhphzizQf2wQOTN9hxtYPcjFQ1H/5sDkPxedi8w05nzRacOOlHOTrRTAsyZJHX+Rg0EU5f9hYsZdFNtxbRbDA0ZqH9mUhc5G440VrGn7PwAbDCMZp2rB9bBasf8qZ+t2GE0MycTkxgrxoyx4CQ+rEtw3Wdgw6LvyXwBzLfvbCy2Vg8EA5dQ7aEJnpuFEo59XZtrw2NAMn7sl4/ZU1R1Wnw2GSjIUVRoyLysO6bzJuX2IkOC4fXXNk/FFsyEvn85HpJ+fXF4a84FoI495yPvpiwG9zC/GlTEaH1wa8G1KAigEyLttpQOf8fLzJk/GLlwF3PilAzU8pO/wrYbR+AVRzZIxxkDDrZSHGTJdyXisJX3/OR91lgefO+hweXIhv06Rc76tP6fgCLDkt/JSlPjdm5eOPmZRjzugxNaEAXwvDWRSnx/R7+Qh8LDzye12qThZg7KcwolCXU+/kwzw6nM7HdThVpxBd88O4rFKHo/8uAAaF0e+RDrcV5aNHVShtXmnTc1gBLtmGsq5Wh9165aPvj1BKqnT54kgeDq4LoUaULsvu5mKidwjHh+pw3f48xC4SHn+7NrWy8/G5JZiTj2pz6qB8eAUGc98jLe57nw/ng0HcWK5Naft8MCmYDjE6nD0lD7KgID6T6/Bwqzxk5AXSslqbk57kweNPIKcd1uJfT/Lx9+EA5rzVYuzdfJhkB/DYLm1WvszDh48BvFOqwz+luXj70p9Zhjo8uiAP84r9+f6mDkcl5uKFUwBHhOqyelYOFj4LYLydLrsV58BLFshid10aFOTApm8gzW7octwO4bXfBdJ/py5fds3BBo8gdtimx94fsnD8fhB7v9blZNMcjBwRxL+1dHn0XQ5mIJhnLXS5ZWwuJncI4eURepwm8l9qCuapp3ocnpiNgh0hrO6sz3P9cuD+OYRnZulx3ZMczH4eyrR6PSrrc1EYH8qpQ0VMbQ5MR4SxoFSfFPkLM0KpvKPPnn1yMGlBGEOXSthSkgPz3aHs3NOA3UZno2NuCL+1l9CrXzambgph17YG9LLLgl67UB6/bcDqzZkwchZvt8yAH5wyMeyfYPYda8iNhek4OT6Y4xwMxLkZaMoJ4rEOhtQSvrgHgyh1NeDTQ+nIvhLInk1ith+nwaptEBPnGdJb6Pn5/wVxxwlDPhUe+aR5MFcLPN9Wl4pZvwL5ZaYR27ilYs3JYNaYGHHekTRsLg1iq9nGDEhKQczTAC6qFL6+ORW5//rzwQVDmswRGu+iP5suirOC0pC9y4/hKw05u1UanE75cXS+Ad3vpmH2RH++aG3AqV7pmGnnx10PJFzQNQNTevvx0FUDWv1Og4GJL3e9MmDc1XRY7vRl62RDOm9Lw+TevrzyypDLeqVD3ujDcbeNuGRXGuwNfOgg9n1HZ6B27TSOHW9Myx3pmOPmw3vfjekg7vtl8jTOEjxY8y0N++u9uea9MTUaMtAzwpvPTUxZfk6c1eRFw80mPLkyEx5ZXpz53pQVizNAK28GB5qx1/M03A/zoszcnAcT0tF2pDcnCC7W7J2Gj5Ve/Cl4/GXrNDRP9eaFWZZ8750Cy3li/4Ul/0xLRf0wb2YI72M8LAXNo7x5fKQ1s08nI+ScN8+cFftWydj8youmcms+dxBeL9GLLZ7WfC18X+/FXux32JqXzqVg3mwpj/qBr3tn4EGYlHvmkw90MzFUKmXGIjLVMBNz90j5SgJ2YwZGWMu49D/wyo1M6OyUCT9F/q7JxvRHMnb3AYuysvDqiYwHPNy5bG4mFoXLWP8/dwb2zERJsJwt4935qkjounyB58/daX07G70fyqm65cZ9Io+nfwTPv3bjB79cjBAcd6HcnZXfcrDimcBbf/D41lz8EyzwvNSdPol5ODczgsd7iW8P5KDj6Qher3Gjuks+Cr8JbRnryg12efgsOHrXvy689DAbd7sJnWblwrV2ubifoqB/ujO7ZuUhTOiuRQec+PfTXCiEDjT+6Mh3slzM/6Lg75VOHLorH5s/K9ggvMDIj3n4NUtB1y0OTL6eg7dPFPzniD0dE/LQtpOSPVbb8ZRC4Nu/Co4UXmynwGqXqUoe72vHe8MKsYFK2ljZcsisQjjmKUWsLdX/K8JAuZJ7VtpwSX0RrNYrecXThsbly/F7ipKNe6y50b4Yql5KekfYcBQL0Unknzfcmo9PFcLbVcn4C1Z8da0Y1blK+gpPemdSCVJFzom2Vvw2owSLVymZt8qSnQ6XYttDJT+0sWbD9lL0gZILJJaM/LcEHbuIc39a8sWBYoy6peCOkxZcr78cY0coWf3ZnKrYFfgwW8nJfhY8bVsGO09Rm7M5ywrL8LiV+PamGT/+VYpaKyWd4s3ov7EMN8OUHC1mXpkldI6JkkcvmtKxpBxRTkpOWWbKTd1WoqevkpcqTfloZyWaxFnf35tw9ahKDBPrf8+Z8KV6NXSildy9y5ROrlW4Kfp2LtuMOUcrodmi5Lz9Zgw4tBpL6kW8OKv0nzVw+Z/o8wpzbguoQu4AFSOzzOkVXYOSI0quGmVGu4a1WBSiZKWPqOd5LbaIPut6mjJ9yxrM/6lgZJgJ07/V4JuGkpYXTDhhZTWqmxQcvMKYF87VQLJS6GFXYxYPrMMdobe/xhrxVOZa7HFR8KSXERs7rcPxVAV9fY24YEs9dIX2/nXekJ1/rkNfSwWPCPy8MLQBU+sVnOZlyO/xjdARPqJqvQGTyxrQ/X4EZ+gYcrVmPazzIhjgYcCTY+rRfmsEzzVIeONTAyb0j+DnARIeUtWjQ0AEj+3W5155Iz4KXVSWpk+fiw1Yu1PO04P0OSC4Ab9bR7Cnjj57L2nEt7Piv5PqsXJ7I766yrlcX48/HtXjfLqcf+vps7DzOtzpKWeCsR6n7FyLXjtk/Bquy72b1+FEvYzNE3Wpm7AWPZ/JuG6ZLjt/XgN9Y3FuqB7PF9cgaKGcceKsuR1qcS1Izp7L9Tg/uRoxG4VmW6bPW7uqYTVXzjqhW+avWIUVBnI6bdFlgkkVkoUe25Ghw6Jvq7HOUejPObrMv1CJgj4iT7YOz/ephOcVGWujtHlkYSVaOss5aKQO7/9XjrUOckaO1uVFiwqMbC/npdc63He0FJGj5Xw7SY9WZ0qhmifnBC89HrlVgU+L5dwp0+e9WyvQ+ouML131qV+2HCVL5XzVQcJpRSU45SK0ouBc74vFeL9MzpJ5BpwlK4ZVG7nQSgZ87lKE61Vy3p5kSJu9RUhRyNg0UZ/f1xeht6mMatGT5A7F2JIhZV+lHm8lFOK1WkrZbF06DinCue4yPvqmwy0i/8SBUm7sokOztUVoYx7Ogn3a7LuhEDcGhzPziBaTwouQXBzGqfraHJNeCGV2GHXvavPB+wLYbwtlitBaF/sX4mtRCJdfEXppQQHa7glh1UdNSiYW4tiiYJbs0+S7NoXoFhPE8b816bamAJ/7BfLzfk2WfClAO5MgurXVZFB0ITz0A1m2VYMr9hZibpXQZiYabNO/CPb/BDD3yUj6ZBThvDKAfZ9pMOVCIWyD/Rl4RoM+/kVY+tqfu1I1eTK1EIvP+HNVpBZ1jxZgdY4/sVCbzpX5cEj0419ttdl8ugD95H50e6rNrc1Ci37yYy9/0ZPVQgfe8eXteh2Gn83DLZUf4wx0mZaVi4C+/qxu0KXm5BzEv/TltdZ61PHLQbssP/7K0qPJ0GzEPPfn//z0eLO74KkOgczYqMfneVnoFBjAU176dKnKRGpRIKsXCb29MRPSXwHMhoQb4jLwyDmIh5VCU13NwLCMIK7Ypc+yW5kwiAjm9WP6/FuVBftBwUwPktBwfibqbgfz0GYJz+3ORO20QKb3FZ5RmY4JUwM48ZOEu6alI0fU0FX4Ar3sNPRO9eddQwmL4zPQaaQ/uzvq877g1tsL/Pj0sT4n983E3q5+HCD0/53+WRgT4kvFQ/E/hmfj2xhf1hXo88OkLKRU+vJPLwnfBGSi+oAPQ0ZKuFpXaL+OvnzyWMLMPxkYPcmHXR9JGHhBeKVH04g0CVvfyILHwWnsK7zJEFPBy2N9mLPBgIZamdgXO40PHA2Z/1bogc/e9Mg14sLcTNgWeVNRKvThANEla286LTNiyNssLH3qxbdtjNjtfTYO53hR/tSIzVuzMaWrN4uEZ0wfl4UlTl5s/8OYLWbZuHrAk/nBxuzRmIMJ4Z5UrDVhXgehmb948p/LJmw4loVnDzzZrsqUtztlYcpqT54Q+mrFnywscPPkyjWmnKifjXJ6snqxGWcbZeHLNU/+bDbjrE8ZmOzhyZ5p5pzbPRMjT3qyldycQZMzcGuPJ2udLfhjZTq6DPXkryQLvg7JALKn0mWKBdXxmXju4skmlSVPL0jH1N1TeV/fkgtjMnBeeyr1Iiy5TzMTK/9MZZ7KijcgNGTeVD7/YUn3IRnovdGTgQusaOKWhp3PPZk7xpK+WUIzi9pqDllTvSEVLRJP/s6y5sm6NCzY4cku02145noqftl7MfKbNQt0UuFj6cmh120Yu0xo3QJP2hfY8Gm3NPzu4Unb2zbsvT4NkUKzOQidFinJxECxLhR6bJ/QbN/+kvLdCw9+qstCbKCU93qPYpFHNmZaS7lJ4cFzA7KQnCrlDD8PdpFlofebcP70GsXWg7KxriWcWntHMaE0GzLhMd37jaamXi7MW8u4x3YUZ53LwR8TGbPXjWLY0jy4OApfHOdBxf+yMWKd8LNPPDixUx5yOwlc7efB/eI/3ekk57YlZHqHXNz2l/PYXTB7bg6qqwUOTyfjlufBxiOCfy8FR5zIx81eEfygIodcKYBhWgQnbAd7fylEoNB4h6rdebtzIXr0VPDiv+50qSmGdG8E1z8FE+2WI9dEwcZ6N7Z3KMTYAAX7fHDjosHF8E5U0MPQndG2JZh9TEFddze6rVgO39cKXp3jxlMXVmBWrYLWUneeWFaKbkKrvM1yZebwFagW+u32HlfOV5Xh/l9KZrS4Md6mHIoYJT2/u7LlfxU4uE/JhnMuPHKxHLcuKlk0wZWG1qvwYY6S1j5uXG+wCtdHKrnihxv3b1qJge5K7tJz58ABq3FJ6D0tazf6lVXhq0rJu6Pd6bC0Gs8vKdlW6sYfgTXYVaBkzSx3xvauxaTWKs6tcKVr2RrcslCxZp4r92qtxfEJKv5ucOH2zWswfaGKgXNcmPyhFleWiPh6F47PqoPbKRWnlDuzJqMOc6tVtJ3lwplb63HxjYopC515eHQDqvXUfFku9HBJPbqZqjl/nxMbtJtwcI6aD7c60rugEecWqLnovCMHO62H/gE1z55yYNiOZjhvVvNArQOfOTei40c1D++x5wNlM1xvqnl9hT23DmzE/6rUnB3hwAMT6nE2Qs07/zgK770OD1Vqmtc50PvhWjwyU/PxBUeejFuLWwPU7LvAiTfi6pD7WMXck06s71yLdhUqGl9zpsHHGoTnqWi0wpmH9lWj1kHFynAXjny+Gu6JKk70cuagDqsx8aKKpkucONigGr8PqZjg6ETZzFWYO0vFo9+cOG7eStzSUzG0twvDhlXif8NV/F+2M5/Fl8NRqmJwrRPHR5RjXZOKWfccue9CBaRzVLz2x5ERFWV4vVZF3VaObNOrHH2DVbRY5chG11IcG6pip01ODG1bin49VPxa5kgT4xLse6Lk4GQnTnqyHMfqlLQPd+butcux8LjwC61deMO9FK+WKXnxvQtfq0rRKUrJGwUulClL8KSd0MnjXFn8vBhFtkpehgutNYqRIWb1h6kz7YSumLlWyb5/O9FmYDFWBwjvIHr4QF0IWaCIb3GkXu9CuDxXcMRHZw68VoCX8QrO3+bCw8KzDDiq4Lp+rjx+ohDO3grBva7UmF2AwUUKLu7uRpd/inBhl5KGHUWeh0VwD1IydLYDJx0pgO1uJQsO2nPoqSJ4iLNWWNtz940C3BdzPiXZjpKnRRjQR/Sngz2DryxH6nclF9bZCr1bAntPFeOLbfla9M0yWsWWRDsWvl0hZkPFtSn2/LxhBQbWqHjvph3jQ8pEPaLnPew4MqcMU7arOH6TLTN8K/DqkopNB8R+fAVWifnfYGfLAz/KkLNGxannbLjpdgVuHxHvGGLDvi8qMe9fFRfl2nLgrkosTVfx5nFrDs1eiRuBKq5zt6GrTzm83VQcrGfNQucK/IxRccRRK06dXIl7Yh4iPaypfXwVhmeq+NHfip0NVuNTrYpr+lsxrUs1wq6rKLe0ZkaramTFqehWYsktX1aj5z+iBntL3iuqRpsVKna1tOTt8TX4IeatU4Hgo4trsDdSxQUOFlR+rcWtzaKGDpZcvX0tNp1X0UvDit8jazD3i4o9Oltxd5c6bL6rolmjBbtuqMcaMf93X5tTN20dDFer2CrfnEn5DZj0WsWgWHM+ljbBKFfFfx6YsXB1I8JE/qXhZtx1pQk/bdRUWJpRN2k9bMvFXfxNGePVjAHije73MuPtxkaUfFXyz0sTOp1phLV4I9UbY+5b0ow+5mqOaDRhx/vrUe+o5hC5Mesursc00Z/UMCP+t7cZpgeVbPlpxDXbm+Aq1l5Pjdkwtglh4UrOjjPm56pGqITfrLY3YVynRswrVvLRDxO+tmrA83FKRi0xoTK/HunzlQxxN+V02Tp4vFKyzUdTGpbXY6mBit+1zVlRXQe/aSpOeGNGefcG3Buo5Bm5CRN2CwzsqGRApjFfPKhH4lAl/fKNaL+sEf0ylEw+ZMi9O5qgNlZSf4wBU9c2YayhiuMGGrLD2GZ4hanpaWHI+8ub8XSSiu6vJeSnJrzwULOstQG1FjfB1D+SV/0MeOBnI9rlqLnFQkLXIY3wL4jk/rkSmq4U3rAmihOcDWis24AWlygGFkp4wGAddl2J4qb7ErZtrkNgSzQvGhnQcnsd0nWiOeCohPFD1yJ8SzTHPZEwWbMWbqUxvKdhwEKTWszsE8O0cxIe/VWNzG7TeWegAas7V2PAkulM0jfgmyE1WPZ2OpvEui+q8dZrBme/EFp3WQ0irs7g4J8SPvOswj2TWPaLk3B72xqMOBHLwbMkzDtXhZojsWz9TMLc25VwvDKD1oYGLEupxLsn03lAy4Bnq1ahctoM1ow04MjFFSgYFctbxgacVyv+R8tYVukZcFS/Mswxn8mivwx4v6YcCUNn0kjkeTukFLs/z+S+NxKGxJfi7vyZlIh73SktwdVhcdR7L6F+lxL8cyOOrgslrI8V3H08jqczJJyxowT5JnEMfS5h/oflmDE8jn3eSeh+bzl2P5jJS18lDC9cjlVf4/hALuHcbyV4J51F/W4S9k9dgTPRs5jaVsLFRStwWDGLw/fp03VxGb4emcWNyfqU9SnFpGez+NZDeIExpWj6OYs/1grf4VmOcZPiiQI9xj8sRWZqPIMf6zLGowwXkuM5WKXL4WHlmNISzzsJuhyXVoZ5Z+I5qo8utXaLPryMp7Vch5d/lWH+pnhe/6PNG/oVsPwTz84btFkt9Mbm9rPZf4g21/qVY/DheP7bpEWtmAr07jibDNPisoXlKPodL/SbJuNyyrFaxLRWarKPTwXy38fzuZkmv5SUY+T1eG5cpsGTYp24K55DQjX49kU5bE/GMwQazC0oR1luPOsTR9I0thy9xsdzx6iRXDOgAs4z4pljOZK9RA1lkniuOTiCJweV49O/s/jQagTjHpYhpHkWrziMYKNXBXTXzqLs8XAuqS3DrG/i7XyHc+zxclzoOYtjpwxnTfcyPDsSR4+vwzj5SCmccuJ4//gwTgksQ4eYOA4T68fyUuwbE0eb7cOY4liKqA5xnJUxjN1/lGLUX3EsF/uK9+Lt1s5kr7XDuP/5Ckj2zeSBXcN4vmQFStvO5I/vw+iyoQSu78XcfhtGHTEnaz7E8vOfYXQrK0GXnrGULx5Ov7nLMeftDC5YOJzBq5dj+P9mEDnDuXTScjj3m8FdtiP4wqgYYc+mM2DsCPq5FuPQj+nsMnEEX3YuxnKxPytExLwrQmP1dEY1jmBqXhEeYTqX9R/J912KULYphvpaIzkhsBhXhk/nmXEj2fdGIa6ei+GggpGccbMQI57E0K5mJFckFqLvLvFfd9dgubPga88YHg3X4K9thZiSF8OlMzWY870A0dEx9G8jvPy2AviMi2FxuiYr4gvw5HQ0R+zUZLnw4I52MZyXoMVeVgWYPCiG//6nxeC/C/DGLIajn2qxflABlpnEcFtnbU7uWQBTmxj+WaTNfu0L4Chy3pygw01f8qF3MpoXonR443IhnsyO4dj2urzWuQCv/4lhbqAu9zgXoFN6DFd66vJInwJo5cbQUKlLvwEF6F0fw8G1uuxtWIDn/4th24l6DJYWYK2oP8RAjxNNilA+ZDrbFevRMK0AKebT+eubHutDC7FaOp26Yp15qgAOVdOFZ9FnSbtCTDg+nScT9WknKURC6nQa1+jTdl0RxrrN4F/v9WlZW4gmvxnc0kHgwL5CnDSZweO+Ei77WIxOXWO5UmBIb6Fn8u1jWVcp4cXmIhzsG8uKKxLe+VaMnU2xnP2vwENJMVp2xLLN/yTc/Xcx5uyLZbe3Eto5F6PH/VhuFh6/WVqMf31nMkRgmtPbYryrj2WPIQYMYAnSZs3ktC4GrO2+HFqrZnDNPVHPjxJYOc2g4oPAeY0yeMybzlqZhI7DSxG7WtzrvMC08HI0eooZuyvh15yVGHIvhukiJuxhOa5OjqE8SOBwYSX2D47hx/P6bL+oApcvRLPkjD5f/rsSX+dFc16DPuOMVkFH8MiTsRJuHlaFFFUM4w4J/Ly5Gud+xjDglYTaG1bhWf9onhwlYe2lNejwOYreufpsO6oKT9Oj+H6ZPpWfqzGZUXSv1qdpQw2UqVFcHyBhN66Fw75Iftipzwcd6/C2KZK9N+kxMboG+7tH8kWpHgMvrcXaL2r2EnmMPq3D6go1j+7U4/kV67CvSE3lUD36NdVhnUTN3jp6bN2tHr7uap7pr89TIxtweamKOeP1+O1mA8YIrdIwV5+t6xqRe0ZF/8kSvhzdhD5mKra7r8+wzCb0HaXkxxZ9Jl5qQn9jBccIbP89pQmqyQq6mRmw17FGDHdUsKBGj7++NiEyNoIWz/QoCWxCuXcEJfN0OVu3GS7hcu4VGH63fxOOL5PTeZEO56xuRskZGXOSdBg1S3D9Gxl37NNmYL/1+CtDxrxX2lS7NmOCi4zSp+Kf6tGEob4yBnhp8+eFZsxeJ6XfVy129RVnfZByfKEWr+9fj1H/SHl7iRbPdV+PN4OlbKevxdiYZsiVUpp30aK30wa4HAinc4wmdxlswMWUcG6do8mrqU2Y2U7KZSZaTG1oQEx8OCNGadLoaz2MfoXx+VYNNgttc7tbOFvKNLg8vh7fIsO596QGf6bWQftROA9t12TQ8HWY+T2cO6dqcvbNWmRMkVJhoMVDscKXuUj5cpYWI2PW4WqTlE6DtKnhVYeH86Q0fKfF8PX1WPJWSk3Rh7yCepz6JeWHS9q8HV2HzpNlDEkRGFJeh44zZHxYpsNHYxrw566MY6DLiNMN+GQko9Mxbf6nX4tzS2R03K/DN9JaZBbKeH+xDltXr0HGYhlXXBUxDdU4ai/jtQ9aDFxZjYUlMvrGaPPI99X4GS3j0flanGO1GiMvS2nfqEnZ8Gosd5CxTmBjdfYq9Fgh4+COWrQtXonUezI+eK/FD7vLkbRRrL9qMpPlGOojo7yTJhs+lUMyV8Yh8zR5q7kUD7bLWJqlxYX1pfgWJmPYCC22GrICv0RtngbavP+lBH+JnIsFd0fuK0UXcdbscB1WHynB6r0y/tqpy/WRJZj+WcqMem1meS9H5Ucp7yWJ9z29HO0MpKzdoUXT3GL4e0tZtFqTGYrlaIVwmlVo8nNcMXTbhfFXhiarlhbhj3UYy8R9958sxOTMUA4T95q8vhClrUPZ5K/J0P8KUbIthLt9NWh8swgjO4fwUWtN6p4vxKlRwew8QION8iK06x1MnWMaVG0oRFd1EJ/aafBx5yKkfwrk32MEHwlee5sRzM+SkbRKLcaY4iBG6I7g7SnLYW4XyNreIziy7XLYVgfw/PkRnDC5GJ9K/bnn5wh2FDVrjfLn28sjGdihGO+j/fhm2kj6XC5G6wQ/rpysQV9t4Wdb+/GUVJPztxdhyTs/Vj7X5JxNhZD/9KWtTItmgh+blviy6whtLggvxLADPrwxW5u/MgtxTMeXV7V1eNa2ANmGPjzQU4dqq0JEHZ9Gy7s6jPMswIoQH3b30OXBnvnoONKXyuc67Pw5D8c1fBm1Rpcr1+ei6eI0/gnSo9vzXIwq8KFFnR6P5uUg18yXW8bqUarKwUsvH47I1+eFedm4cGwa31rp02lTDvzCplF7oIR6Ojko6jaN/l4GHBqZjcmzvXk+X8LCbrl48dWLe94Z8EtTDkYmeNH5h4SP++Xhgo4XB/00YNGzXIRKvBja24irtXOxL9aT1QmGvFKSBzt7Tza1GNHdLA9epVN5oZURuy7Nx9IxU9luvDGXMx/5z6cy+q4xbzTn4oTpVF4LNeH+BSK+eipX7jXh2/G5eFs8ld8LTRk3PQd9B07lEYmpwKVclL+ewkHXTHnDJxcL/kzhgQ1mDDTPgWz/VD6fYsZB47JxqGoqT5ia8+LSLPT7bwrjLptzxNssXH43hbprLZg8MAsR3lP4V40F9+tlQ75mCh8Jn6vsnIXh+lOod8qSCyKyEF4/hXv3WVJWnImjZ6bw3Swr/vUpA3cuT2HSKWtWBGZg0MKpdPhhxR170lG9Yip3thb+fUI69oRNpXs/W0YnpqO5aCpTgmw53CsdC3t40u2rDfM2p+HzIE9OeGfD5bVpGDkwnE+3j2bQlRzsOh5GX50xfCnPxaNp4SzXGMPX/fPw37wwHt86hiv75mH+xzCu/DWGCRFC87wM54GyMcz1L8DMU1L28RvNsQb5sHeQ0u3RaKab58NB7L9+Opp3TxbgQISM04aOZklCAS4GyfjPmtHM7FCEnq4y7rcfw5Z5xTC+IaOpajSjkoux8KWMA+6P4tgfhXD4LuNd91HMCyzAmhg5vaaP4sPoYly1l9NVOorxnwpRUSjn2wkeDF9WAL1UOffc9WDlr0I8ey1nZh8PnhB6cqWFnK2XerBmWD5ufZLTfa4HB8wpxoLxEcwuJrdfLkJ2ZASf3CEPv12OS68jOLYL+WrFCjTkR3BvPw+GTS1FRHsFN4WTWn3LccZPQd9gcNDUMix3UXBNL/DsuxLk7VGwucWdE9pUYOR0BXdsBF/ursCYGwo+f+9Om+mVSMpV0PVf0KbzKuT/UjBlMHjqwGqE7lDwiTi3cEwVIvWUlLiDMZ3X4METBZdaku2XrsHpsUraLQG/dKlFXpKS89Vg6p46OJ9X8qyNO3sV1kEuvP/BVDd2UK/FZk0V15m6MalLPY6Gqajr6Mo9S9bBN1LFD+NdWTGkAT/yVLxzxYXHchoReEPFc/ecOT+tCRZFKh445sKpzc3Iu6bioVPObCnagAFZKv7e5iJ07UZUe6t4e5MrZ49aj7HjVdyzxpU1HTbh1WIVKwtduOdHC1yOq/htszM7+bfg4noVj1Y5c+m1LQiNVzHR14UtQ7eii5OKETJX+ptsEbpRRSeVCw2fbkNgror9tznz34Jt2JiqYlOcM3vm74C9qOfIISeODtwOZVs1VZucOLVgC/Jd1Zy5yZFh37ehapia/9Q7snzPTsz4R82XWx24gzvxUqlm4DoHev3ajXuH1Ly03Z6dgndj9nk1v1+yZ+3OHajrFsmDp+wY27QLc3pF0vynHXNWbof1NTUT2zhQumobQt6qef+2Pbe83QJuV7Oi3IHNfbdi1wo1PfY5UP/MNsyOUlOzxJEz9bbg711qLj7mwD/fW/AuXs0xJx25TvTK+aCaj6460ChgI8x/qLnrhj13J7VA87eaVaKea2824LdxJB+ftuMNtoB6kXx13Y5+j7Zgg1ckE3faijnbAuMpkRx83JarfLZj47xIbq634Zs221G5NJJNm2y4vnAn5lVFMv24NUc/24HdRyMFz1qzfeZunL0ayX2VVuTonZjbOYqzFFas3LobfwZFsaVZYM7rvZinjOK5REsmPN+DnEVRnPDYkqscDqCNVhTXvLbiPcsDuHIhkoeuW1Nj1z70/hXJgCxreow7iEtToviuyopvdx2CZqsoardYs0fOYST9HUW/E1bcufko/vodyatHrKk9+Rj+1xLJqO02nGd8BDGbIrl0iw1VfY9j8OdIHt5izc2tTuKMUxT3XrRiovoENmpH8dQpK3pfOoXEN5HMnGPNd6anMaYukjrzbTjW6xS6H4+kY5A1g0POor5DFIPFtybJZ+Aszl0abcXLg87BwzqKvZ5Z8rDVWUSL+568ZknvraewZWEU2x8VGO5+FuMdo6h73IJB186ji+jD+5XmLLx3Htusorig1Jx1YZfwQRVF3wVmlPleQqao7VuKGWfGXoHSLYo3Z5pyTcMVxH+J5NetptxcdA2a7aIoWWrC7p+v4Z+tkXS6Y8IBH28gcXck2xQY08f+JqJ7RjHJzZh1+texyS+KCQ4mPPvwCvZMj+LLD0bM630VXkNFbYIHf0y6DtODkYydasQFE28i/1Qk5wwzZODYm4jSi6LNGQPuXnQd7ZdG0W2VId+GXMWzjCjKzQ046fJVLNYX+e9IuPXgdfS9Hcm7wq+5a95E4X+RVI6W0HXPDWwdL2ajq4RPxVkeouefw/T55eENNIREse1pPb78fg1rn0dycZQel+29gQhZJKuEx3ly5hYGNEdycrIuT3a9iXtifhYd1+Xr/OvoKGbv0Rkd9rO/jsFhkZxorsMRl29g9qtIFt7XZumhaxgZKno7WIfzfK4C1VH8JbyJ9oyr2H9f1OwnNE/ZZcQOj+ZpV10mh1yGzbhomq7XYX+tSyhJEvvrhR9Pv4jrutFcYK3HQ4WXkZkQzelf9bj69EUUSKK5zlOfE0sv49bVKMZu02P7nlex/VgULz/U5xHbq1iiJ7y/jYR/x1xG+sxoTu4rYerLi8ieIr4VfTvvfgmaVdG0oAEn9L8AyZho3rlkwLwTF6HROpqP2xpwze7L2PMsihutDBmTeBntbaLZ2MaIGhMuYnxmNOsaDRmceB7LZwgPe8mI02zOo9Q0mj2/GtFm2wV8vhNFuxojvjh3CXo9ornynDFH7boA722i5j/GdNx8CcmfonhEw5Ra384jqzCKk8aYUm+u6MOOKOrFmHHdq/Mw7SruItYDvc5ioKjh8DxTdjxwFk8Zzcp0ExaUnMPmKBHjIPajz8AvK5rXfhlzyZCzWD85mp0qjXlh8nnY74+m8x4jzhp8Fh8fR3PZE2MeTjiFKY3RHDnElEcCT2Hbh2gadjcV/95xLKoXNeuZ8eOT4+jy/z20NWPl+FPoOj6aq9qZ8abTGexyEvk3mrEHTqP8r2h6lZhzxqpTqDocxS0VQmuNOwvXrVE02G/B0JJTCHghMKHZgi1NxxFkJt50uznfzjmBK6L/xv3NGbznJI4oRZ/7mnNW1xOIt4+m73/mTPE8hpGp0QzRMOfGdUehPyqarl0tuLXpsPCkUUx9aMGi4iOQrYpi+jFL9nE7Cq/MKHqdt+T0v07ApSGKp9da8u3zQxj8Jop3n1uw8u5ByO5GscthC67ush/HRQ0df5rzxdMDcHaNpuqgOR1H7MNo0R9pa3O2/rof1hXRXLTdjD1P70GmQTSvxov9m7tx7aJ40ykWVEzYg4Nnonh+tjn/XbwT9wVGnT9hwYX+u/BFM4rjd1syr3IXhnaK4h2FJQ+W7EDixkgu0rXingnb8O5JJN+9t+Cuxm1wdI3ivrEWbP97O3oLXP3rh7j7pa0Ykh/JnA6WfO6/BeMrIrlumTkHbd+M/SKnfh9zmmpvhZn4BydZm7PX2W3Cz0YxbILQw3ZbEf1vJO+nmnFVhy04IDC2bZMp3xRuRpf4SAaNM2NWaAuMBJddlpkz8tYmaFlGcs1SCx7p24I2V9Qs7GHB9MkbsfmhWngTS/4YsRF3ctR8KGre6rceKzaqWdzFigqr9Qh9ruZAFyt6lm6A2kRw3xdLdq3bhI9tBf47WHNS6AZYjY7k0fHWnHxyEyJjI7nax4oRuzejYm4kR4VZ8579FrxeHsmby6x54fA2HImJ5Mh8GxYu3oJUwa0LFttQ9nkTAiZE8lSDLQcObMFTUfO6UlveLdyANrqR7LvXjp03bcDqrpGMrrXjYvdmNHYW36bZ8qp1M4YIvh483Uborg24/EbNJdE29BjQjFOX1TQU/OsT1Yxz59TsKvgox2k97lSp+WKkNV+xCRoH1EztZEPpp0Z8LFbzfzIbul6rR/xRNZ33Cl4b3IhJt0VP/rHllBGNKN6kpoPQ/3PKRcwW0TdfO2a0rofHv2qap9nxY7tGXN+g5tlF9jz6ZB0eCV10fpI9E2rW4hTUHBHmwJFGNWgaouakFY485VeDlnZqDghwpOnBKmzVUjPW0IHDVlahzFPNfv3sOdakBq0MRZ6PdpxcUgXdcWr+dcSWgR41eL1UzZrLtqwxrENloJplC204pVsd/idVc6eZNTvvqMcUE7HvaM2jPeuQY6Bm2ldLXtxWj4wYocd+WfKQXhOeW6spPWLBA3ZNuKFSs02zOZ/NW48LbdQc72xNk7gajNJXM0X0eZ51DY59UTF4pliPr0KRuEvwZlvOza2CkdCKebfseFpo700d1VwktNxG41UI+1fFBe/seehSBQY+EjrzhgMXua1E+XsV5cMd2cNhFSKaVWwj9JhqZRlclCq+q3fgwRsr0Hqgiv6jHTjlzHLUihm2PW7G/TEb4fldTeFs+DhnI8Y1ihnTNeVk/Rb8b1skB/wwZozLJny7pOaazgJjn2zAIzEz5gONOb9xAzQWqrlebUS9mvXY4B7JqVqC3z+tR+yhSD4SXKCrvxHvDKPoMdyICckbMF9ohgY/Q/JZM77ujGLVPEP+k7wedQK7NogY/XEbkVIgNNI3Ix7z24Rdgu/eLDfiz3EtuN8UzbJ8Q354twFaATE0O27IT8ktOD85hgcmGLIhcyNCvGLY+bnQBvfWY+W5GO56b8DBupugpzGdHZ0NWP9tPTYujqHNLANeHdSE7Jho9rhnwJGvmrB0RzSPxRvwYGwD/vKP4dhpBhyfUY/HWtN5sa+I+ShmoCGGhnYGTDtVh+dJ0xnQzoBh99dixxsRkyCh39p6BAbN4JxkCaN96jDo8gxGRUrY91Mtsq7O4B+hQ97l1iFvTCwXbNHnsNlr4fAiljp1+uyoUyMMViwvF+vxWc5aVHvMZKezevyzrQY/vWey4qUunTNr8W3dTOE79NilfQ0G3Pq/Dq46Kuqt7WJe22sHTNDdKYrKs1GEYQaQkm6YocPubkW6u6WkEUUBQUXsQGzUa3eL+Z33+++ss87vxH5i773WrInGhuVKGGdZRDHh0Rh/VhFDp5dQ5PsoLDJXgoW4lLaPiYbUJEXInSiladHReH5NAW1bSsjoQzRGj1PE0ctFZJ4Rjd0/5dGkXUK3ZGPg2iKPmclFtCQzBjMOKqBveCHlrYmB3RdF9B4toGZeLFxdFPFNN58Ch8Zi3yUlCFbm0Q/dGPxcrwxlvQKaWBQDmREq8JmeRx2IwRQLFTx6kUf9A9FQ3K+CpyvyaVV8NKq0VaCrWkgNbtH4/p8K3hoU0KtN0Ti/SBV2y/LoiAG7T58K/q3NpWfXoxGxm+mZb9n0ZVIMMppUUXUxk8I3xaCfVDF6UjbdromBjq8q7v7JoNqJsdjVrALPxiy60RiD89Uq8IvKoSy3GBgrqCLbIYfCTWIh06+MV5IcatwVi3YZFUTvyaI99bF4t4Lh7JNNj77GorJCCbywbHq/LxZSX5VgWJ9DZ7Jj0SClBKF9Lv2jvBz+WxRR1ptNS9m3FicYzg251KIbi7N/5XEsLJ8MTsRiVZQ8Ci/k0g6z5UgxUMBY6RxqtliO54/lwJuRQ0vbYtGlLIetObl0Tj8Wx+rksN07n8q5sXjmKIvGafmU2xCLGGVZdFjl0tu5y6GzQxabG7Mp9lEsmg/xYaOZQ2NcYnHHiQ9xYS5lJsei5ygP6xhu77tjcNOOhzVNzNfLxuLgey4a67Op2yIGtmIuenJz6Of3aPBPcWAwkEW7ImNwiI3jD2VS4s9oqO/mYNSiTGoXRWNSLAdrl2TRA/1ouB7kQJCZTRKbaBje50ChO4dU6qPwJpeDYStyaE1xFC6v4eCeIJsU+FHQL+Vg9OIcSv0UCX4WB5MfZtFAThQWRnFQ1pdJ3BFR2JTDgalNJtG8SCz9wgH/QibT+ZF48pUDKY90atgVBTl2n4oNGRR4Pwox7KydvunkwO7mF8PB0uQMmrk7ApkbuBg/JIMe34vA/iNcRNel0tyP4WgYw4NrQBpZK0XASsDD41Mp9M/6cAxk8tDtkUpto8OZp+Gj9GYKOfeFQf47HxZnk+nrtjAIh8lBSSaZJjLdvmWrLOyOpNDnD8x7ZsjhKNtn1stQcD1kMbuH7R8Wiq9H5FD8LI3adoVC/h6rL/U0+sM8zrzV8lickk5fxzPv+UgO03wyaPJACLYflUeYIJPmKYXCWU0Buk/SqZZ50o+5CnigkkmD9SFIOqWAY27ZpDc1FGb2iuh/k0lNTGsNzFSEw6t0+rQyFO6LlfBJP4uMvodiCJTg75VOda+Yj2Nr4qxSafekMNg9k8f10mT6ZB4GhQEFzKFk5tmZDkxVxOnbyfRudRgs3RSwb3oSpTeG4flGJVTdS6bNY8Ox0kcJU/4k0it+ODokyrjvkEL9reFYO0oF4vxk8qBwDJmsgrHmafSYF4FvJ1mNj0ylLtaf3XpUEFORRpN2hOP7ORWsnp9BCRfCcGe2CqReZZDOOuYp5rLaN8gmc9kwjBUp43BlJlkfZ9yRoAyfnhyayTTe3ofKCE3Ip9cTQ1E/VBlDNuVR9McQXF2jDH5IAcky73ZrggqszQtpTGoIPh9WQqtCAZ2dHoJc5u+u+heRtFoI4KYI2ZJ86jsrwcQditjwppC0j0qQx3COlCmky44S2LxUQJywmFKKmbb5o4hNUcVUZilBuqEScoSlNLlNgpAmJYhcS6i+U4xt6or4eLuUyivEeD9fCZau5WQjJ0bpPEUMeVNOdxzEKHNUwKGiMsocDMaSEAVc7y+nOduCYRapgPtaFWR6IBhrixWxMqeCVDliXGa9veXqYbpREYzN7Ur4+bOCaYNg6DxTxiBVUsroYChZKGPJzUq6+ToIsyYrYdKZSvITBuEUe++m+VUUNC0IdhqKcMqrosGPQZBnXOC+p5L49UEw+k8ezVJVNMYnGOaK8hi3qoJe3w3CuY1ysJxVRR90gnBriDw+Ma177k8gPnyUhxWqya8gEL8i5HF8SA25iwNhskgBii3VdEY9EC6aDCuVasooCIDzCgW4nqumsb8D0B4pjzs7ayjrtT/697I8ZHp1XGcAsl3kkJ53hKZmB2LZHjlo7q2h+LZAOJvJYmfMEdIKDMKy87IIOFJNF94EYYsHH4kqNVQrGwwDC1kYOFTRzC3B+PxGFt35FZR1PhguF/hI/lpB3uuD0ejNR8mqKtKfLMap1zw876yk/CIx3sjwsWfgMOkbiXFJIou9t8uJyzSVSjUfr9zKabO9BM+JD2tRGX1oFqN7qixOxZSRxQQJwqJl0dRRQrXlElim8bH9RTEZyoXA4CoPNrtLaBPT4XaRPEiMykjmpgQfrHnY5HiYdteF4NcgFzE3yujk6xCc5vPw7XkJXWe1PLeVi4uqZbRZwHxKMRemPodJIYp51W1cOJ8qpUVBYTi0jouDteW0NiIMbdu5sEqsoPaloTDcxEXEsCra80WCppNcLA+poifvQxgHcjHEkGm5USE4wsayY4/Q0GtiDNRyMcHuCPX1STDdhQuVoXX0SkqCejsu/LrraOpQMfS2cOFZVkf6R8Q4yeEiLbuBghjOz8dxYfy8gTRqgrD5OZfp/zoqlQ7CCx0uXjQ00LEjgeiYwMOiVfVE5wPRx3osba2jElEQGt7zsH1BLRWHB2OWBQ9OxUdoy6pgvE/lwcKqhi58DsaG+Tx4zakh6/pgcI/z8GBBNR3eJ8ZNcx4OdVdR7G4xLNJ46PCppN8TmX52Yj2cafJ7LoE4tpwP74/Mc/0XgGfOshDE1RLHLQAH7vHxNrmOpC0DsPCULFrbamndf/54GiOHSdK1NHazP3SPyEJbo45axvrj9VE5hOQeoU1WfhhYL4ele47Qlx1+uP5UFuZXamnIQ190Scnh5/BaOtfmi10msphjV0cfFvtCukAW15ne/jXOFyM6ZLFoWjX9SPSBcLQsMpJqKFTig+mf+dhxvJJGv/ZGIuPuQ3HV9OquN0Yu4LM6qaSW6T7od+ZjRNxh8sv1gfIoWWROPkwmUT544M6H/4tSan/mAzlFWYTNLaO1033h/IaPLpRQYoUvpm+SBWcsy0mJLypb+Xj0vJBkX/vimpUsXmgV0sT/fGHZxEe6fT51S/vi8G8eGvML6I6XL0y+8aAxIZ+Op/jihBQfX/1yqa3TB59EPBSfyCOLnz4oCOJBNS2bBE998V6Rj7zvWTQY6Ytb93iYOD+Tbo5nWFnwERCXSX0ZfpB/y4f6zkxq/usLKR8+DPdm0FBlP5Q+5GMjL50W3fDDHhdZSHanU6+6P6ZVyuLl4gya8t4P6yJkcSUum0yX+aGvg4/s6BxyO+kHxyKG891cCnP1g0O+LMaNLKAqAz9sHCKHvycKqS/UD1fa5DBjexFN7fbDsAR5SMqLKGGBP/jT5FA7LYdGKPmjpV8WX0el0zI2LrWXw5npaVRT4wfNEtZ/pNOoqd0Pt+fI4aRRKsXZ+mH8I1l8/ieVAn76wbhDDtc0Uqn4EMO2WRZpcSl0X8oPEgdZdCankgXXFx+OsH7VnEqcGF8cYRqjVpJOvz/7QE2aD93iNLJn+RD3kYe5hmm0+l8frGD5IDU1lQ6Y+eCQnSykvyfTph9e+M1w/ic6hWQee8LQiAf+uxRSe+6F7Wo8KH9JJf1Cb5w4wUNcaSrFP/VGly0PUE+n86reuNvERd/WdIoo88L0Qi5e1adRqL4X/iviol82jUZ4ekFXjQuLw+lkbeIJN1MuJGPSKDDFE4olHHzMSKenozyRkcn5f22j4OCBMds5uJXGOP2cO/wMubg1N5WW/XTD2mVsjVMajdnohs8mXPz4kEKv/rpi1788DJ2UQta2rhjmyoWDVCqNPOcKA6b9nl1Mpcs7liEnj4PVgjRyW7oMJQVcPDJl+u2/ZfhCPBjYp5B0nwvWbuUh50oK5axxwSDLpccrUij8tjOOjOBj5uJUqrjhjBN3+bhZlUJ961xgyfpAWV8y9fk5w7tFFjnrUyipwxkGW+WYR0umm0+cMDJJDj4LU+iLuxMGp8thnWwqKRs4wfuPHM5uTKGv3U64t14eZ9Yl06teR+zvksefsSkkfOyE9csVULEoiXp2O0LphgKivyWR9ldnHN0nj7qoJLJi++SHK0KwO5HmLXaEVJ8iTC8l0qetjsg8oISNOxNIwcoJh88pYaFdPKXmOOKvvDLiNsfT0m5HPC1Rxszjh2iilBOCQlUQuz6ONnxzwL4qFaQmH6Kyvw4YvUEZ127H00Q1B0w0UcGcIQlk/GYpqgSqiPGIJ4uSpfAXq+H710O0cORSlHeqIkU+gWSv2KPinhosuuOpf5w9LhuqYfqQRPoz3R4DtupoWplAiqV2WOmsAdmCBLK2s8MeLXUcikkkrbe26B+mAeeaRPqQbguEq2PP/CQ6KLTFYzUNzEpJIq9rtkh5o4GI7EQyHmWLunmaeHQhiV7ssoW0rBa+pyeSVaQdPDI14eKfQGt07LC6RgsrP8ZTqYstxuhqo3ZWIk3NEcEiSAuvucn0cKQtjM5q4eXUJHJQF2F/tDZ2+SfT+xYRTB20Ybkgie6OEuHwNS3kTk2hDQ1CrI7XxjKWJ3ppQqz/poUJrL5iFwvR16mNxvhU8s0VQilKB0W3kmlroAjtVjpoHJlED3uFsDbRhdP+JLoeJIL8Ql00fUig91Ns8Wy9DkbOTaBLX0TYel4bOgsSSSnIFsd7tKHvmEDnr9riLEcHi2fGk0OMHfzXaYMKD9GbMDtMt9SB5FgcFXyzxalaHajMPkTDnOzwI1cXKoKDNM3GDspvdHBAO47mNdiiKkIX8e1xlCtji3cL9bD1n0M0hs3DSw8ZhQdJZ8b/sNJH8c+DtLTRFk919JF29ABtTRWB80APw9YfIoGNCHWT9FBukkA1OiJwj+nBtCKexuaJ8GmxHjbKxVPsNxG+bdSFpnU87b8oxKQiPYy7lED3rggRxtHHIuUEGvJDAIdrgNTrOspMEWDQA8zHNtDlHAFufQAehTTSsSYh4nfpo/t+PCUHCnFqvj6uKbK8WiDA2lcEfadGWrFfAJtawuDHOpr13Qbba/VwTieZfENtsEioD33DFKoftIGasj60dyVRbI8NnPv0sVwviebaC9E63AAP7RLoYaUNzjw2QN/iRAocYoOYBAPc/ZtMOx4LkPXNEC+fs5y0E6A2wxCivam0Z4oAondGOLswlUSXbODqYoSq9fHUWC+AJN0YO+WSyOmzNR4YmGBdQgpNMBUie5MxKmLi6N1GG4wdZ4KxRvG077MQo6qN8GPOQVL1EmLKZiOcZDHV8hNCdMsACrNZLV8V4uMmQxQ4xVHQKyGuFxmg+XEcrXITobrfAFO7DlKBtAiuIn3sYvin/idE3BAD/Nt5iP6sECE+QR/D3sXR2CUi2M8zQM3+ODrTLoL/DAPYth4ko5ci3F9rhHm5+4mfLcKIOkMEph6gG2W2uPHFED/u7CMnVi8j3hqgbsMB+i/XFlMfGSFv1z569tUWJd8NMPrVPuoPsIXOdAOM33SA1qyxw4l+I1Qc2ksx+nbgyJjAt3svedjawXiCCah8Lyka2aF2gzGiu/bS6SO2cK0zxlfrfWS10RbHNpigdus+OtBvi+FCEwgU9pHIzhbv/UxwrHYfGc8QYIwXcDm0mR7GCvBF2wJPvjXRzX4Btg9bBN6bJvKxFSDE2wLHwlto1HRbPHG1gpVMPW2qFOHSgyUYod5AWz8xTLZaYcOWRvI7KMLE2CUYu7KO3riKMN9/Ca6rNNBrcxH+JCxBZ3sj8a4JsSPLEjzFBvr8zhZjjyzBnYFcmnXeFtYjluCuVA5ts7BFUJMllEtyqSfTFj/dLbEzI4tWMBz2fLbES+UsSuLawWChJSpXZdDXn3a46bgEXi8z6OMmO2RULsHCtdm0468Nlh4Clo7Nol8dNuA/JGw6mUFRq2zg94zwdkUWzXlng3XOBKO2NBrpIcTxZcBuxrPyLCc3u5vj/ORUsjovxGI5wrKvyfQhWIgIE3OMmpNMVUZszzhz1DO99PqINfKuLgBnXj7Nf22NQ9EL0fEml75XWiOtZgECa3Mpbq017GQXYG1BAU0+Zo3Mdwuw40wBpc6wwcmahZAekUbHRDZotCFoymWS8QMBpp40h2FLJmU8s0bN6wVw/JxFMUoC1N1aiK+BOSRitWy+YiE2dWXS4CoBZpexu93JIaGZAPo25njFtKKkSoCMn2xNXAaZr2exnroQCzTT6dYFD/i5ClAUyfq5owdqIwXoPZ1MPW88wN8iQOnFZNqt5Il8YwGu8pJp+DIvXBdawyw/kdo7PWHfZ439jFtlV3kh75w1dvYmkd11byTFL0GtSTw9XcO00HArDL8eT+ffeaPs0BK4CuNJrO2NDi8r7LRNIE91pmOtrPDTlPGygjcGQ61wzjeBxKne8JC3RtKhJFrd7YOBFVbI7k6iq7U+2PfDCv2zUqh1mC+4d5dgH+Ov53G+KOhfggdXkih/uS/2uVjBcHoKKZ/yhbzlEvScSKQGXaZLaQnMWC8KTvJDVoYllmokUT3XDy9YHuaOSyFq8sNbqSV48jSZjA390dZpidUKqbRU1h+Wi5bAuTyNxpf74+E6S9wPTaOyY/6o/70Y7z6l0A69AASnLcYy6zRSnR2AM/KWCLmYTjv3BuDE+cW4VJpJs9cHwGfDYvwZSKeW4QFYzu6wXzeTzFL8seCPJeKlMsj5ZQBWDCxCVW8G1Z9k3rxhEZra08hwYiBEMxZjzc8s8vQNxGjTRbCyyaKi7YHgL18Ev8wcmqgRCBnPxVhplkuRNwJxdK8F1L9lk+6vQGi2WcDOLI/2lgYi8NQi7DLOJ1e1IAT/ZwHdlQU0NCYIBj8Av0v5dDU/CHvlLTBkYhEddwzC8OmLYJFTREacYNQzyivuL6amq0E47WUBvX0ltNc0GBn7AbpQShoRwZD3Z3VkcZjS64Ixw4UwvYD56AfBaA8zx9Tn5VT8PBgPcszB21NJz7lixhcLYTamkg7MFuNh7UI0nKqmTe5i2KQswLozFbT7STCqO83xXYV5twliqFUuxPDkWlL9Esy83kI8Wd5Ac6eJ0Ru+AL+lmyngYjDO5C2E0LaZLN4HQyZgARYMHqVAEmOs1nzotxyl+RwxpGk+Nq0+TvZBYqham+ErjpPFZjEStM2gGddKXwvFWJc2D7s/HSObDjGC98yDl3IrRfwQY2XNXAQXHafrxWLEhs5D2LAT1PJLjDEb5sLo5EmyLhBjp+c8vCttJztn9pYlZlA6coL2W4tRLzLDI48OUsgR417wPLz2P0VLfouxZeVcfMnupLM/xRi+ay5e1XbTmjQx7qxn55Z2U7SZGMIgM2gt6SJvPzEmDTPD6FOnqbdNjGj+PCjNPksX2FlSk83w7OtZai0VI3QBu1vPOVJyEgN/5qFmVi9JHgej8a8ZDlmdo3N6YvRzzHD9w3nK2inGq4h5sE86T382svvMnYfehouUeZ9hFTUXc9ZcIIcxEjRYzcW3zHMUtkyCAzqmyORcoEFZCdpMTeGscJk+b5YA0+egacplUiiRwNhoDrY8u0BpJyUwSzHBJdVL1HNfgqIEE2xff4GEr//3W3djzGq+RC6yIXhcbAx/5ws0/4cEN3JMsJXXS2+rJfBcMQfru3tpZSs799AcDFHuobFiCVr8TfFr2Dn6EyyBcL0p7jicIY82CRoz5yAw4jQZjgsBr8wEJ2PP0urJIZhYZYLfh7vpLdtndM4cPCo5RS3eEtzaa4rgfV0k8pAgYp8pbtd20K4WCY7kzkH33XaaOSkEbypNEPigk6aOD4FBtQk+y7STBdvneekc1Mw4QbvZtyPSTOF34wR9GRMCcbMJ3ILbKM0pBL6txhi97CRd9AlBaq0xNGZ2knl1CBzTjTCT00EFASF40GiMUe+7aMA7BDcrjBF24wydtwrBggJjuNedo7jIEEw4YIQW8wukqBMCyxwj2Ny8REnrQ/A9xBDCSZfJUzkE4zcbYsKNqzS4IQSTdQzw9d1VsmPzIfIG+HztBr1h60WP9SCuuUHDdUPw4bQedNz66XV0CPSzdeFo1U+zFEMQnKcLvZ7bZL80BP4rddB0+TZpDwnB3e06qHC6RwMqIRi5Xxsr7t2l3kcS7DXXRs+0B6Q/IwTdTlq41HSPbMUhODVHG4fH3qGBEPbtK02ccb9Dg7NCcH1QA2cO3qN3PezbRZr4fvwBneuSIGWCBhZtfkCGKyWYEaKBE3sf0nMW3+dz1LHG6iGNY/H9cFUNadoPqIyd9bJRHS7e9+jGzBDcXq6G++Pv0fejEjzNVMWJI/dpjosET76ror1/gN6w8ZtTKlj55gGdaJKgukAFafr3aRXLvaL//W/Mxrs07KkEuqNVID3kHo1fLUFWpzIUtt+n1LMSmExQRljZXfrNlyBxlRJWe96nplIJ1HlKMDW+S61snzgnJSiduU3X+iWYtlURpc9vU5uzBMtcFNEpvEsxhyXoKVJAq/g2zfoqxkEzBUj9vkPZQRL81ymPTf/cJtVBCfJeymPf5n66mx6Cq7MVUHi5j3YYsfcOl8dCcR+dH2A5s0oe259eJ43poYCVAuIjb9CDbaFYMkQB8w2vUdWEUHx+LIfcadfoTGYIqvPkUOl6nXIKQphukcUs76v0guFmN1wO699fp9Xs7S/kZdFXeY22aIXg2is+xg1eoZ6tITj0nA8pt8uk8UWCdvBhdv8yRVmE4O8wPu4ZXKQFt0Nw4TUfEYcvUv7f/9UdH0oV5+mncyh098li0fSLdPQP2+eALEyHXKY7a0JxOUcOVhsuk+HDUJRayyFj7QV6phQGibk8RtRcJK/BUFgzTJ6cvEya4WEwtVFAXeAleqcYhg9tCnDOvEJheWHYsFMRL4ddpu9XwjDjlgJWPr1AT2eHY9RPRbR7X6Cbj8Kgm6eEHx6XaOv9MNg3KOPikUs0UiccKm7KqE2/QALdcOh2qqDZ5wKNPB8G668q2Hj1Et0eE44ls9XgeOACZTwNw7oodfQuu0CWM8KhlaMB/ePn6P6ScBQJ1LHi9jnyCgrHsm0aOJV7lubsDkdyrTo2lp2lsHg236kGq2U9tPdoOGbvUccy9TNkdykcSgvVsKX5DOWlszXXVKH9tYdeeodjJcvbZSt66ci6cLQoqELDppc4teG4P0YVQ6p7aPnacFRqqSApo5d0jocj8aUyJHt66MvKcHwcVMKKLb2UGRoOu/eKqGb9f0RrOB5kKKFiVg8tZndbt14R23N66JdSOASdChgQ9lJLTDhijymg5NVZauGH43G5PFJOnKWB52FoPyWPt7/PUS/7doU/y+HFZ6i+NxzDtimigHeG6k6HQzNWARffddGisRHgLVfEw5IuqlWKwBR/hv+LLtr9NxydnUoQdZymlb/D4X9WGXZGZ6jtXTjmS6liSvQZmqYbgb7HKlj/qos0p0aAo64GzdHd9P19OPMl6jD93UXj2Z7Tl6ojLrqTbAbDocAwnxbDOLQ7HG3VGuAMdtGzrHCku2ogUPMMme5j7zXXxNHA0xQ5Pxyiy5rQu3KGrFaEY46KFv7Z0k0DheE4cVcTK6mL+jaGwzZbCx+kumg+i8unQ6yn+XXSa/9w7NHUxnPGBTbzwnFvrDaOTOwmo3/DoTFGB2fMOqn/Xhii5XXgvaCbTuaHYRVHF1dedlIxW6M5VgcLR5yklSxPOCJt7D3XTk4sRkPktTERJ+heRTi6I7RwXb2dljeHI4qjhfXL28hREo6pN7WwSvY4tUwOx6L//cf4kuOUqRqOiA4tFF8/Si9zw9DxWBu5T48SXxCGrTd0MD2lldZph+Hhch0c+tpCd6+H4uU8HUwe20z72ZpdJ7Ux9W4zLeeF4Z6VNhSWNlFPVhjiz2shTK+ZjFk93luhBfUPDaSSHAaHYk28r2ygQTavwrA6+KieppSHwnCiFvx49VT0v99bBmji32H11K8UikuntTDqcx19yg1FuKk2epsbaIx6ODrOauBmSQN164XjXZMmVNSb6XVcOKwva+DsgSaaUsqw1dDEg6Ut9HtkBMr4Gpj5sJnSB8LxRkUTO3600qM5ESgdpoGAN63076oIrGIcYXPzKG1YG4EJ09WRMHCcFI9FYGiAGor8jtHVExEY5asGp2ctNPtTBOamqoLL8Nn3OwJf1qniiXwLtddFYO0iNTgva6KX0RF4MlEdiiHN9EglAltk1NG2voFWlUTgE1cNy1UbaOyfCLywVMV2cSONvBKBSYdUcY293Xp2JCJTVRAsX0+T2bk9K1Ux7uwRmhISgQZSw1qpOjpTHwEJm1f9p5oaZ0bi9z4VXB12hP5Vj8SjFhXEl1fSoXKW54zL+moqKCgxEj9aVTClrpzWlUZCarUy9ksqSeF1JLreKmPp53KaOz4KrV+UcLPuMM1CFKK7lbF4Zxk9XhkFxyIlBAyWUZJaFOKPKuKMUgUduRqJXaOV8HpKFe15HIni0woIpirC3Ci4rlWAwLmC7iVFYZe7IjZ4llNjTRRUBuTR4F1OVwyjcHiNPL5vqKD3zyOBfHm0S1fR5u+RMO5nnMJ0/hDLKIgS5LDu3mEyZ/tXK8thyKpKkhoWhZn1shgvrqAk9q4bIlkEX60k5yeRODtFFonjKygxMhLTXPmQ866gw0OjUF7Dx9KX5WTlHoV922Wxs6WcnFdH4XMOH9OnlZHS2yi4FcliwqVS0uqJgs0eOay4WEafjaLRJpHDC+dS0pdE4+VjWfxYVUJLq6OZ35LD5tfF1K8XjTsCeew5WEqmutG4b6QAn62lpP4kGtLVbP21IrI0joF0nRxmCopIUBWDdkt5fPpTQPYZMbg/VQ5PvhVQkksMfrzh4+DIQvIriIFIhY/6iHzif4mGwXA+/KYXEictGgpb+UguLKKKEdEYGs3D52VFdPJ9NFzAg9qLfFo7Mxp6Z7mwTSygaUXRsDjGxd11+fRjdAwCO7g4ujuP0hZGw9KNiwTm9w0MojDqIwfjn+dSwdNIWIZxkfS2gPAsAmI9LtbPzacvmpEI/sEBheZQyZtwPAnnQq0jl7YOj0DyHi5W1WVR9lDGBV+50I3JoZbfYSicw0OxSdb//3b6SyEPXsimZk/GpzP4GJmfQYqsd7lo8nCAn0H+jB+HPuOhcnMa/WD9rcmbhwuH0ui7dxgmrOUjpTeNzm8Jw40GPhZsSqW4hFB8+stHnkEmPaZQFP6VRc/mDMKsUExJkkWsbBZNvsz0bRzD1iKLPp4PQX2yLB59z6YbniFwKpXDiXG5dC0uBGPj5SHlm02/zUMQzlfA/rhc6g8PQfNoRXwLy6XFDSEYeKgI/e25pMh0yLRTirCKzCZSC4X5NiVcW51DS/+TwGGhAuqr8mn1KwlMmQ55ppFPq3Ywf8G4b11oIT1kem/5DjkoPyggIUeCvz1y0HAtpr8aEly/I49qmWIae1GMzZ/lUdlQQh/zxRg2Wh6Rk0vpU60Y++zk8O/MUrrO/OC0VDmo7CijQV8xSrayNRPLyPxDML4kyiOvopwEfcx375LDPd3DdPWAGC3tLA+ns3zOlCBtnSyknIrozAcJuBWy2GRfQK6jQtBLchBy8yltZQh0BayO0vMogen50md87HxXQCo9IVhjzscvjQLawTTk0918xLJcuusUCu9/mH5zyaPD/4RioJ6P79K5FJQVilAuH4M2OVTICUMEy9V/8nNp9VGmOb14+O5VQOv6wrCyj4szk/PpPOOOwKNc6FUUUi/TKjOjuHBeUUBRjDfbl3ORZVBM41k+1GVz8U9zMU3qCIVqK8vz9hLKqQnFmR9c3P+nmG71hiC3nId3qUW0hXmo0CV8rLxbSAcVQvBamQ/BjGI6wd6+qpiPfyKK6OmacMyI5WLt0FKyZvpn+gEubn8po20ZEcjez0WrVAlFtEfA4hkXNvplVGAfCa8nXEyqKaEhryKRt4mHn4tKSfIikvEMF+V6xXRzRxS+X+XiS28hndwSgTRXLtwyC+nEwyiEafLxXqGEfp2NxN1JfFS4ltPLwQhcjOJhmfxhOlUcgcBmHrhHK+mfEZEIjeXD9HAVcTZHIP4jD5Hx1TTpItOWy3goq6kmz38iYDuFB+GwSmqcHo5JXVxct66ijZHhyKxhd9CpoNfyEWi7x0XsrMN0fFQYDu7kwsWzmnSPh6Gtn4ttz2qIXxKKrzu42Dqplo6GhGHSXS7Gj68jdSvGs2E8LH5eSydiw6A+g4foyYx/L4biQiUXRXr1NOJAKKrbuBhDjbTxWgi2irmw9Kwnv3JWg+7sDuq19G+jBJdMuFgzv4E4q0Iw35uLVPsmamB+/P4ULgLnNNGF7WK493Ig/aqJCooleDmWi4jnLaRWIcaO/RzkfGbjL2IMbORgYOgxMlAQ484UDrxuHKUkTzHEl2Vg7HicHkpLUBnGQcrRNtJnPrGP7fPY6DidvyxBw3gu5k86SbO0JFAI4mD0hnZau1+MbTUykFI4SdVFYjxk4zWvOqhRh/mvUA4qDU5R9nnmcSZzcfx6B/1plyCOx0VzQhfZKUqQvpqDg7e6qaNEDDohg8bkLjqTze7WL4Pzk8/Qt1EShG3nQMX2LAWVSHBDlwsp7zOU6y7BSTUu/oSfI72nYqSydzlf66GPrGZXfZNBq7CHWsvEqHfnQG1BL837EYwhVjIYObqXrumKMdleBtOdzlL98WDEBEszbM/SNw0xho6XwaYZp2nCqWC4/piNB+O6qUYcDH/RbBgEnqE3K4Nx7N0sTPTppiHZwWj7MAvylzqp9n4wSjjSGGXfSQls/4VvpKEYdooGZcVQvy2N40fa6XJdMHxbZ2NS80kquhuMKdekkZffRsW7gxFpLYPJia10ZX4w5i2VxpJ9x8j2fBBKyqXZ/FEqkGI9it3/0+ijZG8UDM5bGXhMbqElvkHoMZZBwsgWUn8TiN18Dk6Jm6hocSBUxspg+e8msnMKQOtEDsKmNFGkbCBu/cfwtGqklHsBUHjARfXSBppqH4B6Yy4CdBtp1Qt/+HxkfHe6gZ7d8Ef9IA+B/fV07GcAOi7wUMOvJ518f0Q/4eP+5Hri3/JD6lM+ugzrKb3PD1K/eJAVNpD5PH98sOWh+mIDfbD3ww9THi7KN5LfoC+UF/Nx9U09rdX1RXscD2+zG2j4MF/YBjPO+ree9j/3wefvjO921ZKPgg92L+Qjf3ktadj6IKmLh2+76ynunjdiLjMer6ujfXu8sbWEh73/1VJRvjek3XiosKknm5demD/IaqS6lmaoeKO0ltXsiAbSLfGC+BAX54bWk7+5FyIXc8G/VUuNQV6YMYuLE1MbqLLJE0urORixpI5+dHhifgMHZb9qaLbQCz6sNm8W1tDZJ56wz+YgY1gV5UV6oWYlF9JXq8h+oxcSbLhQaakg7hMvtAznocmvit60ecHgJRc5VjX01NEbV1J4GHukhpaGe+PUER5eDK2iW1xvfBzKw7+Vh2l1jjfu9rAeolBBGse8oZPMw3OmJz/M8YYwlfX8ZaXkmOUFpYms3uXLSYO9a6CDA3upUqp/wd5yjYP+4cWkkO2NR4lcyAYUEW+YD5TEPLQbl1Cxjw/aWIy89hTSsF/sDgVcbP+UT7kK3rC8zmpKroBW13rDiLjYMCuPpur7YGQDF3s25NExMx94sN616VUOJW32xhQjLrqbs8l8pg8CuplGSsqiRXt8MG4J67H8TNK/4g3521ykNGbQsCXeEHhxMc09kzYleaG4iYNaxSwaOtMLs8s5eJmQQRlHGf4WHKTqZ1Lie08c/ySDVzXZVPbUC5Z5HOyakUv/LvVC6x8ZKNXlUZ7ECxNncGC5uZD++ntBYMZBdWMxLbjiiW3rZDDNtJj8TnoiyUUG200KaKuyJ2RZfS1MLiT1vx6oOSKN+kd5VLvPEzwHGajF55Juhwcy+qSZ/sghZ2NPODjLIDY7m3QHPTC+VAYyHZm0OtsDc2bKYGh/Fr2Q98BjQ1Z3BZlk2eGOyixpGM7KpsTpHvioKY2uLbkUmeiOwzx2rmUOmb11g9VYaXw6nU1Z3m4YmSrNvEQmLZnvjitcVu9/MijA2g2P9WTwwTmDek1docnOKsnIoLntrjC+IYOH09NJvt8NwzJl0JmbTj3v3fH4lAxM/qZTU+0yRByTwcrYdHp9zwUv/8ogd0U63VnlgrEMw9iPaeRi4QJnhpVyejq16bngVKsM/hRl0OgiZyy9yUEhm69664RnkawWWBxr9jhhUwYXbyZk0JhZzlC9zwWNS6fNmi54x3Ljq1waaT1xwvdHPHS6pJHzTyc8+cTHzJBUGnbFEdmLZLHDMY1U/zjCyIyP+aPSafJuR6xjOir2VColpzvg7V45SILT6F9HR6gryePb7FSqMHCA1E157A5IpXO3HWC0QAGjHFNo7velyGxSwO2kFGq2dMB3fUUolCVTS7gD6p8rQrAviTRUluJVuBJmKibTu3VLIStWxA/FFHrdvxS3zitB50UixZU7wGGHErqiE6nfzAE/A5XxriuBTm5cinPpzOv5JFK42VIkSStDSy2JIkvt0dGljDKtJPo0dymEmSoQnUygB4vssXuEKoZtSyTxSjss2q6CSX1JZLHZDtk7VbFrSBJVmdjhANRQ/jiRNtTbIqtVDTL2SVRcYwvfLlU4DiTRzrcivJRSx47oZLpwVQSHw6q4OSWFSv8VQc5VDQ9+pNDQD0J8y1TH508pVLhACPmvapjrkEYHtYQwtNfA3+g0GrgpRH+nBo79SaE1+0V47qGB4+eS6ZqVCF8DNHFrbAotuCrEmSg2fpFCuZ5ClMRoIvZrKrXfEcJGTgu2bSn0nYRYG6kFD14aZWoKcZKjDQv1NKq7YgPhNy28DEmn6os2yGjQBs80nZICbZCVpo1F7zLIMcEGH711sLAtnQ702WCSiS6081KJP0IIy9U62H4+lTR32eDCbF08kk+nFYY2aOLo4uGbDApcYgNtHx2kq2TS9yE2SN+hg2mFWbSzXwALX10sl84mubcC7L6ri/PNmVRpYoOvb3VRtSOdvl4UYOYmPfTNyiSJmQ18avXQ/iGVajoFkFXTx7ZV6TS13wYHOXqYFppC6Rts8GuCHuJepJL+ARuMz9XFN+s0mjxXiB5zXRxUTiGBixAbPurCbGgy7WHY/v2ki6iERApmd+C762PI3VSaeEIA1QF9rHmeSnkBAvjXGGDznDT6YynAQj0DZMln0NMv1pi81BC2V9PpV681ksYZQm5mFmXOEEDjrz5s12dR8AoBtB30sX5RJvX6CBA2SR8nR2eT6xAB5nWw/bNyaEerNZY0G+CqXg4FPLfGjCJ9zK7Jo5HN1jgdYMC4P482brfG7O8GcFyfT7O2WkOiYwj3a7lM61rj5ytDFGjn0O9ka6ziGGHY2kxSu2KNYXONcN8gnU4mWqNkjDFUPqSTKNca7+4bA3VpJBVkjde1xhiXkkG+cdY4dcIEm0Vp1OVmjVgnE0TPzyBDK2vES8/BqOkZpKBmDaNhJkgvzyIdFWs0dZqgoSaTxk2yRsyhOfCenEUDRtbQ72Nj1QyqmmaNlhmmqLbLZPVrjdXbTPE3JoP0Pa2R4WKKpKo0On7MGn+vz4Xj6RRKSbWG4itTnJ+fSq0O1jhoPBfSUizfYq0xQjAPv1elkQ7HGt/nz8Wqnxn0SMoaFbVz8eVeFvFkrKHyfC7GumRSA5vfv9cUHnuzaNpjK6g9N8Wmkbl085kVZG/MxXBOLmm5CrBy8QL43kilX/8J8PXpAnwYmUp/WUwLli1AoEMGfXS3htKk+TiwOpOmMQztZs/Hv13p1CC0hqGLGRZUZVCinDU218zDjdOZ5GpujUVq82D+TwblmAswx3k+ViWmUGIni+9RM3AepNKBVyxeGfOxY3caTfghQDcW4FFrMlmOFiJuzgLcX5xIHsNtULRmPsrik8hgnxBGgQvRezWRai2FaN2+AOvUEol33gbf3BbC0z2ZzOcIYWKxAD7fEminthDjZy1gvJJAn8pt0DZghkn7E8j+kAA3M8xw5XoSDfIF7D7zkLoumezZe1+tNsOdlBS68kCAhhPz0B+QSF9FAuj8nIuZcUl0T1GIwcfzwLtxiOx1hHDOmYe0uEO07bUNckvmwWhSPA1uFODbMnM4DWYR94sAaQLC6zXZZMze67t1IbR355POTHusDLHEdEEazf9rh4NLLHGe1dTZsfZIjLZES0wabVCxR8oWSyxivBNr7IqrngIsjkilxlfLkLpIgHtbUulm3zI89BLg9C3GR0dd8X2DAAssUql8nBu+PBRAa3Yaeei7okHdBnmf0yndzg3/rWW9oDSdbr1ww2dPGzztSaPshe548k2AzftTqfmcG4wYRj9Zn+QudIPzbgFMhqXSvf3umHFQgE92KXS53x3jNwkgmJVCwQc8oDzDBrXVqTTypjseFNlgTmg6rWzyQFaVDaIb0uneAw+4awhxYH0mZad74kKmDRR/pZPrc08cHS+E9etMGrvFE0d2CnFzUzatZponzFSIjz7ZtGaDF8YeFCIhIpdWTvXGcZYfnTI5pOvljYlqQnztyKUSkTeGrBXifVs+XfrojZZPNlj2Oo/mmPvAUUqI16aF9O0Q04FFQthlFpFKqxecZ4jgzfTV9E1eWP1RiO35+eQ21QtmziK4Hiwg/cleuBMvwgW7InrGdJrTXBH+fCmm/2Z4YcstEaw/l1DWPE8EjrfFopoi2u3oCS8rW2xPKqGAGx6wDLFF5eFiunDOA84ptthjWkryuzzR6WQL6/1l9Oy0B6q6bNG0sZzUXrtj5CNbTK0upW1n3DFioR322BymC5eZZntti545laSd4wkXiS34GhV0tMATf1fYYtKwalp13IPxki1y1Wpo8Ut3tLvZ4YRLFWW0uCPT2w4WAUeIn+iBxMe2mKdYR8PZHapibNF/9wj9cvHEn1Bb/FWupzV6XpB5KsK223V0zNsLO1+JoNBQQ9ozveHgKEL0vFqy1vLGeA8RyK6a7gR7oYetGd5TSQ18bzj6itC5ooIqnbwgzfaR+1ROif94Y6ebCB3NZTSqzhtfXwlRr3OYeq9642i9ECOPldLQYB/0eQjhZn2YDrLYNR8XIq2mkoYW+OClOlsvqCSnVB9Is1grhlbTsvve+O+EEO4dNfRmmw8m84TQ1ayl393eSG8S4mVWHc0b5o355iKYjmogqwrmOyqYnohopAiJD/bPFEJveAMVOvrAjuUe51YT7dvlDd0CIbixLfSGxXqDjghGpU3UfcILMzVEmHmhhaJGsflSETIfNJM681mFfiJEjW8lh2hPKHWKMCyylbaM8cJKFxFqNY5T1UxPhDeJIPp7nKI1PNCsZ4scjWPkZeyBZ59EmPWZ+eU+D/yXLQJ2n6SRXZ4oEIjgU3GC9vwvRgYidOt3kMMKD3jvFOGAXidJbrtjxWMRLo5pp6j17jC9LMLjdx00ZZU7BhJEOO3dRXtTWf0yvaVv0Ul7zdyQ3y2C+79dtDHEDfzNIkiJTlPpQldotIlgdaiLggxccWqlCBubT1PRFDfksDxfFXeW9s1yh8hEhFG2Z+k6zx1Jb4TYmHyOaoUe4P5iPfrkWTq/0x0GLDduPjhNuy09ED9PBEXD01Qf7IkT94WIVz5N0zM8mO4QwWB3F+UKPLFRVsRy9xRleHlhTKEQSyadokYHL5Q+FmKzQTt9MfFGtb0QYGNRKfODD4R4+rSNVHd64wfTK+aabfTCxAeTSm2w9d0JumLJavyqDc6qHKepzFdWugmh9qCVdr9nNfuEabuxx+gK89q5H9maxKMU9tEH96xssOFTKy395cN6vA1OmLTQiAxf7K4T4EzVURoo8sX5XgFooInujPLFrJU2mBHVSLvrfPH3jgCHZjfQea4vKpnGSs6ro/MWvviy2gYlRTXUdNoXJoxHx62spZGPfTHkvgBBUTX0rd0XQRNsWCyrSKTki9pKG1S/rqTyZF8UwQaNuw7Tv4M+WP3QBqbyFTT/mw9+DtjgWV45ySb7YIQq6132ZbSS74t77O3/XS+lhVE++MMV4tf0EqrV8IVCqA3eSRXTncu+uDLI9FZ4KcUH+2GjhGm15eXUu90PvfoCPIspoRcvfPHwtAD/B1KcJp54nBxaZVSWXdO1m+4uBVRAQrEFZpM3KYLSfQdK2PrY3a0ISEiLKN2tdKMiAiKKgmJ353fe79+ss851Ys6ePXuvdQUap9J+CsCTlba4JptC4Q8CMCuOA82OZCoxCkCSqi1c2hMp87I/5vbaIvp3Er1f4w/JdFtYzkogHbkAXO/hQHXSZWqqD4DJKg72pySQQ04AhH/Z4OKtODKVCcDbvRzIT42jGx7+cLO2RQU/joQdAvCbzZHOjiG5dH9MiOdAa38M+b33x790G+h1RZH/LX8MqHMwZeYlurIxACLbbXDH7BK5nA3Ax9/WcLsTRXuEArG81ho+Cy6R5csAfLe1wYrGGIo9HYiYzdbQfxVD7VZBKL9uhY0X46i8JRCP0qyxYmc89ToHocDAGs/TEuhDQxBSTKywtuIy2TUH4VWXJdKa4uiPHpftY4k5xxLpWHsQdKOskFKXSCvEuPi53Qp7PibT4vNcKGy2ROuJZHL+yMWMVAvQ8mRy/cPFnQmWsEAqveTxUHHQAt6f06hhKg/OPpYY7XCFdp3lwmCUFV5ZpJH2fS5K3lnC7nw6bXfh4Y+OJRqPXaX6QS5iVK0w1JtBBX48eK6xBO/EdXo0xMUydmbjhEwqcOei4oMVJv+4Rt0sNv1rhZltWTTlCRcp5lbwC8yhWH8ewvexu6zKJju2fsY6S5Sr5NGJHi5ez7bCGLF80ljFhconKxy8lEuNzlxEVFjBILmA6m9zMfjHEkJahWQ0l4ff3pZYUFRAcaN4WLbeEssPFpG1Nw82Oyxw0qmYjubzoB5kAR3LAlrUxEN1ugU26ebSahk+5tWZ42drHmVp8dHTY45h5xxa78tHyBegwCqP7q3no/MZMKo9mx7qsDlV5vAryKTOWzzQNQs8CskificPPrsskJt1jRpm8XFjnzmmil2jMZv58C8DbmllUrIiHzTXHBoD6VTSyoOiuAX+Tr5KVvl87M0gbLt3nZ5m83G9jyC7OZvudfOxscMMT4dyKSGWj+63BHNFlp8iPoS6zZCaVEDXN/HxaxLgUV5Apkf4MH1oBq5XMXnH8bEzxRSvLcroAY+PiCIzHNxaSptd+TD2I8ChhHYZ8bHNlWA5UkpZLnxM9TVDy7FyEpvGh4o+ocGwgvoX8eGgYgbDqVW0eT8f721N8derklw7+XBdYYIbXRX0sZCPJDLBzLPVZD1BgJW0DH1a1fTyIx9WDstQ3HmTUh7ykSVYhnLROtL+zcfaX0tx50YD9UTyIS5tgiipevpylg+Ft8tgl9lImhv4iJ9sgu5zzRRgxkdvkgnGajXRKhW2700TVH1opvOhfNweWIZ/Ba3UP4aPCwUmMFzfRqrsjp7Vy6AT1EF2DXzEvlkK1yPtdCyDj3GNSzF+1S0aze7lemEZIiRvU+cQD94XTXB3QSddb+Ch08EE1rw7FMve8Z7bMvQs6qJPB/gYk7EUii/vkOgKPn5XLsXvvLs0OoePjMYl+HOumx6NFsAwawmaE+9QsbwAtr+WYN/JTpq4WoDB8UuwzuY28esEmLF4MW6euUWlyQLkKi5G9MQuGvYRYFbVYozmd5HVXgHCVRdDna0/p1yA3YsWwWtjN1V+EKBXdxHuvrhDmpODsVxkIbTOdNPZVgG8pBZC27uXpkkFQ6l3PsI5vaQ8IEBqy3yYf7pPm9j4rgRjVH65T7N6BFiUaYxS3gAFjg8GbZqH5pQB0qwUIC9tHlL6H1HXQwFcTObiSuwgZZ4V4EfLXNywfEJt8ex97xqh9/sTWhUswIWvRihYN0zhBwQ4ucAIhvxhOnxDALlnhpggNURtBwWYeMwQqdJP6VGKANFNBoj6N0zRPwS4VWyAyOEn9EM1GGteG0J12yDdWRKMx7PZXncH6NeeYAS/MIRi7wDtCArG3CgDvAsapKXXgrHlvQFsjR9SYmkw1o8xQPGnh2Q6FAzdIgOc639A5+uD8UxKH/v3PCKnfcGYZqKPlb8HaVNSMFrXzsGimkF6kxCMswV6sP0+SF7NwZizVA9N7x7R7q3B6MjWxdfex6TOCWb8o4fx/U9oFDvnyxRdhLwcojvTg+GaooOHR4ao744ApQ918O/AUzrC3uLBpdlon/iU+v8T4NcEHUguHaHaEAFeT5mNlU3P6LmMAOMkZ+NX73Nq0hWgavQsKIuM0PLzAtw7PAufQ57SKpa32OMzUZc+TIlSAqSUaGNezVMSWi9A5TltFN4Zop5HAoz804aj7RNS+SzA+N2zcNR6iOq12H2vzca3v09oYYQAlyZpo273EzLRFKAsVgv7qoYomWGMs1ILqx89pmAj9tbRmrB7+5iGUhkmWzTRdmKQUt4JsLFYC7UMA/0bBdj1dgYqvj+iNcUCHNabAe7EhzSoJ4C22AysP/+IxgzwURYxg+31mC7m8vHu7HR8EgyS9jwBps6eDlGth3SS8ZXQNg0cDHlEw7/4yDfXQNOOASpi6wvv1cCTtQ9o1kIBJherQ+9zP8kyHL4w0MCYpvt0ltXLVzV1vL/dR+nNfDzMVcOttH5KZGe4Z6YG34o+mpwvwFmooUi5l3rmBCPxixomP+qhMeuDcXhQHdMv9tJwdjBuLVKHdd092ucdjPoVasibcI+MGT6XrFXF4nP3yHVuMO7ZqCJa4S6dqw1GwV5V7Dpxh4K2MDx8UMHVyXeo/bkAJ1apwOTAHZoSEoxuFxWUT7lFgazGi1OUMdxyi+6wOu3LVUZwRCclGQdjaroyFvl1UFeFAHN0lbFSpJNSWF3rTFSG9tc2OhQejK1xykgtbKNsMwGqTZVwZ7id6CPDnpoK4l63Ui7Dv+d0Fcy73053o1ajsUcFIQ6tFG66GgekVdAv00wOD1dDYkAFo4Kb6fDL1VidoYJcp0Yq9VqDtaGquNXaRPuU10CPp4r+1BZ6kLYG++3VYKDRSqdG1uCavBqWmTbR12UhMHqlhmNnmqlgVggmm6jjzclW8o0NQeFbdYzktJChcwjmDKkjoYid/0oI5No1YPGsjUqyQxAQpo6saU2UKB2KI3fVMXZsAw2uCcXiAg0cM2+gkh2hGOWsgTyZOgoaDoXWsAY4f26S/PQwOE2ZAZOCGnI0C8OYzOlojr1B0/aHYe/QDIzacYM+WIbB6NsMrFWupSmbwlCnqIWSlTX0X2EYXJS14DTqBi25HYatmZpwPlpFL16HYU6NFqReV9LeojDYqmhjh+4N2vMgDN592qi0r6LveWEYKz0TXq3VZPRfGGKKtPFQuoYaFoUhNloLX2/X0fzlbF+JWWjzrCHb02G4OmEWuOer6ZpzGBrnz4ZUXTW9VwzDFzcd3P1aTbL6YbgzTwezWd+c9jsUpxR1cWakkipGQrF0jS7Gj71B91pCkZ+oC0ePGmo7FYqj8/QQI1dOs/aFIvy+LtKCS6mpIAyn9GbhX0glidWFoT1iJnJDq+j0wzDcjZ6J43UVVDcmHAl12hhEBV1UDsfoXG0ITy4jcflwjP2ohfCEcvo4MRxZJZq4MlBO5Ubh8CnUQlt2Kd0wDkdQmyaWqZRSjlg4Vh+cgQm2pfTJMhwFxzTZ2xXTZxZ7ndBCeXAx5XHCobFVC24TC+kH+/a3tTbCSgtpjV44luzXxuPyYuqxC4c7m/NhZR4ZrAyHIFwTEw4W0ENBOAxXaWLkcy49dgrHKdcZ2KJfQArLwmEcNQNVfkWkwM7wkTMdS04VUU8Py6fJdBiyPOypD8PL9OlYZlZOmzeEwW+LBmZrl9O+sjDsXq+BOdtL6KN7GCpd1fGQX0LqHWHQFtbAwrQi6hcNx3JJDZQO5tM4dpdi9+nYl5JPU/jhCJk6HX1HcunH2nDYG8yAdkUupV1m5x81A8mCbFp/JhwGJpqQ8M6mrIBwKP+nBcn12eTF5iQyzO81yKYXbuGomqgBnz85lM/mS29Wh/ihLHrIcs5/q4Yr53JJqCYMGh/VMPgznwqywlDtxGqkqJAabcJw21sNmocLyet8GNpM1bBdMZ+MRodhGl8VO23zaUdSGCZ2q2Ld7Fw6rxgOYSM1HDXMpnPFYViyXhVreNlkz/D2c5wq5u7IIZWZoSiqUsGLRwW0NDkUnzarQk+miKaJh+K/zypIGC6iPssQNLuqoG5cMV1oDoHXVxVMjCmhQ3NCUHqR8UZhKUUnhEBsvCrcv5TSRlbLg5Gq6NQrI64344e/KngTVE6Ti0JQc0EVyU0Me2NCEPFFBX9vVVLkrjU4bquCvV/LqXX9GsSMUcEUi1IyjFsN7ShlmLWWUXfhahQcV8ak8yU03mkNtjUqI8m1mFafXQ2lDGXsjKmkR4vXoNRZBXoTq6lt22rU5yvjQ9gNihCsxoJaZUQb1ZKUzBpcDlDB61s3adToNRDdpwJE1tFP19VwfqSME2Ma6Gg0m+OnCi+FBmphvOeuoooDc2rJUCsE5kOqGO9eRzlq7Pwqavjs0UDPo0MwUquGrEP1VOESgpxkNdicbqTMuBBI8dTwiPGPtnwofM3VEWtQS+NehEB9txrSym7QFN9QTFyhjnOPb5BReChqJ6mjtLuKXrWG4tpoDQSUVlPQ8VAYv2f97tdN4jHew3sNpKdXU79uGCL2aeDb40qaz3jPgHFg9IdK+sV44/1Rdaj0VdAs9TAUb1fH7qYy2lweisQsNXytKKNftaFMW6qhTrWEbtiHYhJXFQs/F9PfRaFYNkMNa+UqKI9xb1CRGiyHKujxNIYNEzXkildR+6YQyKSp4qRFNS00D8GxclWo9d6km01rcG+0KjYz7m3oD4PN9hkYUqug7awezz6ZgUtPKql/gQBp3UqYlniLilL4mHxXETs9bpFzAR+yyUpIvXmHtKwFsD6kDOOqOzS5j49JAcqY43KX5DisJ3qqQKDTTc5n+Lh0VhlfhO/RB6YZdB8pYVLaXbL5xcOq80qQk7hHjUv4OLFICTLfu6hvmIdbXop4dqCLdEJ5iFujiLli9+jAcj6W9CliV8gd2sr0vNJcRZzn36a8Fh7WLFZAG26TB/MXBc0K0PTppHrmv6ycFGH2tJ1KA/gQ3qiA8z1tNGMbH5oLFdCX2EJrpJm/85VHfkMrLWe+qeKCPD5saaYUCT7un5SD+NlmurmMj5XWcrCa2kiO4/mQXCuLTTebaCzzfUGHZaE6oZW82Rla9slAJZyteZYHwxsyUOC3kQ07/8mT0qiIb6OdVjzUp8rgy/UOar3Aw/VUWay2aqeNXjzIjJdD6rNOcv7JxUYhWdTOvU27XnMRICMDmZW3qOsIF+X6Mgh1v0PfErj4pCSNu+tvkaYED1OSpPHzeQdZjeNB9b0U82Yd5HWNizJ1KZy830GLZ/AgvkEKwUbt9PYMDyEWUnCUaiXVQR5ebZeGdHszHddgeSiUwq2LTVSix4dIhDQ8fzfSCeaX37lKY1Z6A928xHK+WAqdbQ00Mol52G2SqJnaTLOL+SgalMDqfw2kXMBDzGgJFHs30/dlPNS9kECfcSttOMSFd704DHNbaf4uLrZfkkD2rzaKPR6EHSPi4P5qp/LoIMwzEof9vjbqUuBi22hxtLq30qhaLnqei+GodgtlvQ2CiLoYqse20OttQXh6Rgw5Hq20/SsXpZJiiBxqook3edBrE8PCy01U1MTyIyaGiWOa6PZyHty2ieJvZCOtZPe9VSGKNdMa6Qy74+d1YuAvbaTxvXyoPhRFbWY9dTKNbfJdDOM66uk/pr0zDopBdnwdXWC6lJcojpLnjKMgwDN5CSxIrKdxF/gI2yOOVG4jvXJiGl5YEsMK9SR0RYC4Ygls6qilR8wLaOyXxOPWWnrAPFr3eUkc+nGT4pm/mK4phXOfa6hghgB7x0rhTUUdWdxjfnymNEKv1lHgIgEwShqPfWoo+wEfM5RlEBFSQz1H+QjgyGDf1zp66MTHFiEZFDU2kLUjn/VWGQhZNlCvLB97Qxn2xJtIbTEfr1fJYl5yA73n85E+SxYLpOspRsBqZ7Ic9r2oo8yLfBxYLYvwgRpKZF5+q4Ec1iVVU5YPH2JT5BF0rJLSt/Jx+aU8gp0raRbL5/798jD6U06aDNuzT8rjxddSmvaV4TxSDlm25WSwjgfjE3Ko+I/1oEQe/l6QRcOiUkqewUd7vCz0fMqpeiUfvfJy2DGxkoai+fB9KYO3IpUkUs1H4wcZDLveoBExAbY9kkY+02mmEgJkpkij9EgFTVkrgPR4aegtryL3UAGcB6XwfWkFeTIP+1BWCur+lbQrW4AojhQODlZT1BoBcv5IwcnvBglOCiC6Tgr7D9+kvV8E+GYviarcahL7LkB2iAS2tt+kR8zPSspIgIKqKU0xGE/niOND1E2azTymK0ccouNvkA7ztgaTxCFnf4PaVgcjSEIcBfuq6Z9cMD6sF4P3VNY7zIKh4yMOmapKGrsuGN6rxTHPu5rWMK83uF4CsS8qqHtqMB7ISaL5WiVJMt/0y0UScQrldOKUAK8cpVD4r4xy+AJ4f5bEa+8SmjpLgJofUpjM+vjjm3xs6peCrGMxnZ8gwNMkSezPKqD9WwWwDJDENKadrI8L8Oe1BMTrC0mtQYBzdyUQJlJCP1oEsGf1qHetkDzYfNkrErisWUBPI5lv/SeOV2PzqaRZAL8x4mj8m0cdbM6fOHGcy81hmlOA75ESSPiQS5s3C/DpsjjiruZQLJsjyuYMXM8h7v989CVxzMjOITH2LgvbxfDsdC5J/uRDaxXL84NsqojkAySJd8K5VKbEh4OWFEp984i/mg/HOCnUfS+gPFbja+ZLY1xMAY04MJ6XlUbShCKyX8hHfJw0elFM2TF8+D+RhlRvKS2ZzWceTQYaESUUwvAm2SgDt9eldCCZh9uerF50i4k7gQcxCVm4fCpi5+Hiwxg5eP4qJqWVXAi2y6JZv4jee3DRu0YOI9OLyeAvF/3P5fDsRAm92saFlr08vhQV09GxPHD2yUM0o4RWv+RijJ4C9qOEfAuDINwlj+NDRaSyMAiVdQo4dqSIlvMDIXVXHi+5RXTMNBDC4xXhcriIpkoGYouEEl56FZH34kC8NlOGYlIh3Z4dAONoJXw5V0RCjgHYGKqMW68KaVG4Px7uUkbEOJYHK394xbE54sW0XuCP5e2KuHKhmKZX+iFSWwkGzcU0c7sfap4poexBER3u8sUmKSUcmllCLzi+8PqhhCzdImo38oMj01pu0oV0kHww8ZIStJSLaEaGN7T3KWG7bwG9ifbGTCsluE1juPrkDfdZrI/7F5O5vjf2tiiiQb6Y+BN8kBetCCfhUjr+xwt8jiJU5pfSXV8vFJEiQr2Kaf9OL1YjiphmWEirnniiqlcBVc6FJCHvhcy/Cth3JJ/2XmXj9gpYMpJHUgpe+FesgOmBubTztBfkNzE9MJhHyrleyLBXhGAom9JV2XlElPBjRx7pWntj1Wwl7IvPoTcsHv9ZEStWZ1H8kBcOT1eE8oPrtMPPCwohChjxyKSTsV4YcVNATWwGdSh6I1hLEQWPM2gxW7PjkQKW3U4n91hv5NUp4qt4Bum6eSO+RBH+C67TPzUf+DJto7oygxYq+cBpphI+9l6hsRe8keqrCNH4KyQ+2xuR+Qr4bp5GCvFecJmqgB3pV+jiGS/UfZBHyKsUmjzaC0eM5SEhSKP5tzyx1IRplcxk0g/ygulfeUjOTWK86onIcHmc+pNAr909EdYhjxzpy6S/ywMP1sqjz/4ycZI8oP1eDjH/EijijweCi+SgdD2JVpt6wGOnHHKfJ9JaJw+sYDqkPiWZJht5YhNPDtpLU+nQaQ9k5slib0gqrer3gG2pLIYXXKHjMzzwR08W/v+lkbS3Bzaz2ukuS6fJE9k5O2UhVnOVTu7xhOQuOcyflk57LnhiIEcOc+ozaIqYJ/6yXmOec5227PbAPjVZ2Hldo94THoi2l8XXy5n0etAd0dtlUOOZSb3V7tjF+tcZZNCst26YWcb6YMs12vDMDd+nyGBE5CqdOeyOw2dk8JLl9nifGy5YySDG6wqVCLtj8gEZaJ1Jo/C57pgyWhb7fFJpTKgb+OdlIGKYRrP+rAJnpiyOpaTQ7/NueJoiC1uvZBJma56OlMXT1mSaOprlLVwWnQ9TaJOLOywM5dAtm0SOU9yg6CmHV1cTSSrODXqDcoiiBIppdofMPTmM25NAmUvckcmTx6z78TT1rjvUPsrj05Y4So5xwwYRBdy2jKPPY93QdlEeyVnxhMWr8G2HAkYtiSOvBaswhvHD0aR4qmKxuqk8EiUTKGrbSqxbwPB/JZ5y6l3hJa6A5qkJ9KfGFUHXFJCeGU8yHa5QYLXwzT+OYvevxPJwRbyaGEvrlq2Cspgi2ntjKE7ZDUE9CqArMXTWyA0vVyvin/UlOrLYHfM3sFpTiqUl91zh068Irk4sGS5wRaufEgqtY+l9iwuer1WGqm8MXYt3gdg7JTzyjCUXSReYMF/QER5Lu+6tgN0pFUwPiyHzSBd0ZqvATeUSXfJ3hdR6FVTbR9MQuWBGmSo2bI2mk0MrUHVcDXoK0fTPZwXcn6pB1z2aONXOGOCrQ/9INN1xdca8ixowiIiiCkVnPJ2igRVHo2n9juVYEaOBmsvsW93liMufjk+7o0hexRna96bjP9NIOiu0HHI1M8CbF0lH2pbj8c0Z+OF9kSrMlyPNXxM/lS/Sxi9OMFyqhdsbI6hqixPWVmliXeRFshjlBM8cLTwSuUjSDY5QUteCx6+LpPjIEZtNNDFKIooGNB3Bf6YFzt+LZFbugFJTLUxeHUXuag7wuqyN6J5IelbkgPY+bexMuEhb1jnicYk2ogYjqMfMAc8DZ2L8l4t0Psgeb/Jm4tWqKFq43B6JbdoQmhRN5o12mOo7k2noaHK+ZIdq51lwyIymnUfsUHJsNtAbTZFvbRHbPQuPXWKo+bUtlo7SweiDMdS53Q5NzTpwnnOJzN/ZIVtZl2nNaLKts8Pop7pQOxVNyXPs4JirCyGHGHrLvu1/xr5tiKFtxbbI3qiLhx2x1PfCFv94ejiYEEtcH3aGy3po/XaJolXsALk5OD8tlg4O2UJFbQ4OKjKci9uhp3gOPghiaW6FLTwz5mCuXDzZJ9lCq1Ifp2/Fk7aPLVbemgO1BQnkH2iLwS962HfwMq2fZ4sRqTl4k5ZAk7Rs4WSpj7ddiZQ/1RbHHdmabxJJ+yMHE9/PgZNxMl18wsEOf32MU0mh12NtsbBYH71ayfR1kAPODxZfTCGTUg4SP+lj/JI06uznYHajAfYoptLJCg5crhpg5ck0upvOwWuOAdScr1Ani7f8MIBO6RX6VMRBxUdDzHufRlL1HGxdaggxThoNneTgS60hFullUFg8BwU3DcFNTaf2UxzM/GWArReuUhabU8H2nZ6QTg7bOfhhYYAditfIYh8HD/QM8Ur6Gk06yMH1yYbYnnqd+g9zkPzIEEqV1+jJMQ5GPI3QVZ5BV9kcowYjnH97jW4d4eDvOyP4z82gLxc4EP9ohF+F6VS+l4OuY3Oh73aVZHZzYPVuLp53pFHYCQ4+b5mLLJF0mruZAxGJeRjySCezFA7kXxtBUfgKlSdxMEFgBFvVdFpzgwPZXUZYm5ZKIn0cbKg3hOqoVGr+392jjZjPTKGIVxwYfzPEtw3J9HacLU4PGWJ9dyLZ/2P3cjSE7Ypkqr/FgXkmW3NnEulf4mDUwbn4y0mmV/kc5CyZC4vERLrO8uZnPxdqTqlUv4aDn9x5cO1PIWsvDpb3zoNFaBqZ8TkIPjsPzoev0C1LlnMHY/T4pdK5hRz0hxvjXlQy8bkcDG6ZhyuvkuiCHQdqk4xxUTKR/pPjoGrKfHy6mUgJ6hy46c1H+7LLVOrCgePU+XgZHEvzftjgg/gCLBRLJI9/NjDSXQD7AcbJo1nOHy7A54txZPvSBjd7FmD4xGW699gGtQsWIko2kRa/tUHoqoXQf55MEwdtoHZlIXLPJtHQRxukZi+Ap3IyZT23QVHTQnDZmvl9NmiyWASOciKtGrDB4Z2LMO4by8+wDfoCF2NxOcNzvw3+0GLGXYk0k+27nM3pKkyh9M82+K26GM1/U0l8Cgfe1xei+mca7f5jgw3LF2HV0TSq/26Dz2zca3kqfRXh4OvEhVgenUaj5Dk4TAuRNTGdEqQ4KBdl8yPTqXgWG5daiMk/rtKADgfTNBbh++sM0lZhd49dBMOcq7RkEgdX7i1CUtsV0pfkQO76IuzuTadVhhyM+7IEFRPSKVaCYcltCawDr1CzLosNl+Dx7KtUsYjVacRSDOSnkZI4B73dSxDP+u9+doYPzktxLjiFBn/bQP/KEkx7lELB720gGbgED9OTKZnd5ZXwEkgnpBKX5UdNdAnaxiTRpW82cOxaAs9xiTQ4hoNTMkvxPT2JGodsECuyBE07Eqj9kw32nVqCsdzLFK7Ewb5DSyE8+jJtncNB96RlEPovkeo8OFgbsgw2Xqn0awGrEd1l0AlOpgVbWN4kTWD8N4GKQjmY2r8MO7ZcpgsM5z/yTHFhUTL9zOCAf9oEs4aZfphsi2P7TbGrPpUK7GxxxMoM+TEp9OO4LYKemuFPTBLFNNriqw3h3c/LNOadLWZFEJzYXppednhjBayakUw/GJf2PyWsC0mkQMafFWWEKOlUur3MDlFvCYpv02j8Hjss/w+YI5pKFtfsUFwCtH5PI5+7dtguZI4/+qk0aZQ9Ar3NkWCcRlMf2GG9jDmGdZJpm5U9frSYY2ptEvlNt0dsvDlcolLozDl7RAZZ4OD4FNqdwfqOqwWyLBNpqYYD3otb4vTpBGr7Z4/V0pb4HpFEzX/sYWJiiZ7GFEp0t4e1kAWOWadRznV77Mu1wOL+VJrwyh6XllpCxfwKua52QJ6yFQ62p9LD/xxwY5QVRk1PprVdDjhUYYV+kxS6p+MIk/HWcJucRLtqHXBqqRUUVVg95jig67Yl5iReJtGFjsh2sILugng6/dYBaemWCN/IanONA77NtcQR1lO+TXKA/SULnPoeT2YHHDD6qwUijOOoR8QB12Zb4FtlLBk8csDHLgv8EWNaaIsDZs+0gHvaJRo12gGzEsxRfe8SPd1ujxVR5tCoj6NP++1xzsccR9xiKfCwPVzHmqPy7iXSU7LHvSnm4EbG0Vt5e8QsMoe46mVKiLSH7Ttz2MtcpoY8O3ysAcRHJVKtkT3Ujptjz9cEkj5gh0DWOo+lxNP5Tnv8EgbyzkRSdiAHFtuXIWBGHMkwTqZ3y3C+PoaGWJ1GrV+Kj+Wx9JT1O8XZpjDZG08Huu3ht9IMiYcuUMBFe5g9MEXiwgt02sEB2laElaoR5CHmgP4WM1jfukBLrzqgXh2YVhpBpzMc8JfFQ0UR1MjG96gBnwsjqPeaA+7PYLgqiaCYAXtkXARcfKMoZasDNj4GFq+LpG2nHCCVaw7V8dFU9cEeb1kerDjRtEXbEcvizLFgYSSNl3CEn4IFMkOj6NMGR5y6Zg7Kvkje2Y5IVLLA+68X6V2UI7zA3is4kvrgiDB7c1zacJFGtTpiP8PhgHwkfRdxwuFbFtjMjSTr947Q/GaBu58j6YS9I/qSLcAbE00FcY7Y6GoJ76JoSnRxhHSSJYyOxtAKUycoZVoiKSWKrh5bDi0fG2hkxVLodGdc17KB0IZLdL5kORYFWmOfdDSNO+GMuBfW6H4QRWeUnPH3nDXWtUSR6htn+M+0QfrjKDoUtgLrO2wQ8DSaeNErcDXCBs1Po6iUad2VjGf/3IminAgXGLPeI9UVRevZ+EQF1pu7oyj7kgv+YzGPzXn6ZyV2tHIQph5FbkdWQpv1xX92UdR7dyX6WB9VHh1NE7avginrtXt/RtLbklWYqWyLBV5RFNK+CuO/s97WG0mFxcz7LLLF5guRdNXYDQev2+Io03Vqfqtw5JQt3M0vkbqUG77MtcNNlhPPOe64Um+H219jKPu3Oyoa7DD4l+EfHuAz3fknKpYGvnpA+o8dftddotfPPRE+1x7fjGNI2pHFYfYwV4ylndO98DnfHocWx5HPdw+s/myPVLN4mvvAE4XGDtD8HE9bMrwgou6AZOHL9IW8EH7aASHXEqhY2htebg4oXpdAR5k3j0tguHRIov/avCGt74CpzLeu2+ON+d/s4RxymfyZT28b7YjFA0kUsN0LXSscYbwthW5neGLfSkfMf5FMgbO9MD7SkeEylR5peeJUAcNiVipZFnmgZrYTPJgn5fW5Q6jEEbnZqbSB3DGBnOB17wr9muKBulgnfD56lTIGPKB1zgnx4zLo3VoP/GpxwqW/GfRT0ROK6cwnDF6j9W4eUHzshOGm6/Qh3h2lg06YyPysV6w7Xvx0gmZgJnWLeuD4GyfwZmfT/QmeiMh1QpF9FrW1eUChyAlma3JI674HOnc4YdNAHp1q8oT8AifM3JVHN7o8kTLaCZO2F1BSrRcWJzii16uABGFeKDvjiFtbisjJxROLHzrigm8xjb3rgeWLnTB3QyG5rPJAGLuvqXQx2Zh7YPawI17uKaWMo+6wNXHCk5PFxJ3qjiQVJzz8VUIzVdzxsssRf/jlFPZzFe7JO0HDu5RW1qxCyG1H3LtTzvy4G+JOOWLy60qaccsd5w86wn1fJS1lnr3DxBGWw9WkMMUTSeaO+NhfScEMSxcuO2LeqAqaycbvHHZEo105pQZ5ojHGEcqppfRKwgsPdzrCPLGE7L544SXzUWs9SihsizfctRwxc3chFa7ygWuqAy74F5LglwdomiN+bb1BcuvcUcjwcNOthu5vc4O1Bav5xTcom/nZx18cULm9hmSYv54c4wDF4ToaHlkJM9ZvvJbU0I/Sldi0nfH+gjpqWb8KIhwHPOA2UGEQ8/LuDsgXbqSFi90AaQcsOtREM6XccWyRAzy9mkh2vzvUX9jj6u4WspZ3Q2qBPYKiWmjE1h1mG+yRtrSdSq944FG0PfLGtVPtkCc8WJzxt43MGNM519mjltNKtxq94HvUHg+y28hY2RvRl+1x/VMLrcz1RraJPRJGt5OFsA8uONtD9lgL6eT64NxDOyxe2kYBb3ww6TXr61nN5AYf+AayXi7dRHEbveF6jc3/3ESTd/jgKN8epf31pCHtC6XvduDoNZKjni9Mpthjc20dpbr54oKwPU5eraEtj32he94O5m21tPyvL6qS7MA7dZM0w/wwoGWH1S9rSHSdH16PtoPfuzr63e6LrN12MJNtoPJgP0g+tUUbv5FQ7IvNYXbwiGui12d9Icy8opZTK71280Nchy32S7TQUhM/BObaQuphG92x94WIpR1OuXTQENcHct12KON0kKm3D5oP2eHr5lsU4u+Ll09sYTj9Noku9YP8altsqOykD8J+0CVbPNe+Q2UNfuhN5KA2+jYprfHDxDIOPD266NETP5yX4UD3fhctOOUPtR028Am/Q+Lm/rjgyoHWrU5yv+2HPcwrqt/tpHODfjD6xcGL2R1U9s0PhbK2yD3VSk2n/eEMpokt2unTJX+EbmL61bqFdoz3R4qxLYKbmmj1FH8krLLFTqkGykzxR0ckB6c3N1JVqj8O1XFgk1BHtqPYtydt4bCtlp7H+MNFiPn2/TepsN4Ppr9tkffmBu2AP2LSGZ9LVdPBVj8INOyQJVdN/Ad+uGhkh9qtlTT+rD9WH7XFhdgK+jzsj5ofHAw8rCI1jQAoMn+bpVJJcYEBeMT06wd+Fd2ODYDkcuajUivI61UAdmfboO4tmz8rEKVJNrB1qSCL3gBEEdMck8qoNzAQrcdYvztQRluTAmEkbAOrJ+UU/CAQhj+tsX1KGXXoBSF3ljVWXKqg64IgxNla48nVUpouF4Qbf6zZfsV0PTkI+8ytcbm1mIIHgtBYaYVC7VL6JcOFeYEVRrsWE3lxMa3TEt9el9KGS1zsGGuFc3+L6ENWEH5tsMboa4VkVx2E31HWMHyaR06qQchZaAPDpQWkvzsQFT028I0rJL2wQEjk2yCKW0KHHwagjr3RJrZO7NIA/CfJMMO4ZUQnAPNYrkLEy+mfVQDM9W0hf7iQro4EYDCCg+maBeTpHIA1FrZIb8kjwSqWTy9bWFjmUBXL2+U8DkTdc////3bjRwxvHll0yCQAXuwtpL2y6M/yAITsskUOrtPP3wFIamDefuU1GhALxI6rHHREpdNgfCDOTOUgwDSDYlhuIz4wTRJzhSbrB+G0ow38p16loOlB+Ktvg2XL0+jN6UCsYr7R/EMKTdMMRPc2DqzZeFNwIISqbCCvlkRWkkGw/mKNVzbJ9LU9EFYTbKBTnUBVjmz9nTbo8L9M920D4TbDBkfc40gqir2XpjWUfiZRTjyLg6wRqp5Kn0S5CHtgxfRYGmnnBcHshDUWlV+hkBVczLxphWXP02l9QxCmp1pjZHMGbTAKQlmgDWY1XaNjTUF4mWeNf2aZ9Fs3CEe4NtA9lUXN9UFYk2ONl0I5tFs7iHG2Dd765NKzY4HoZJ5QczibDh4OhNRPGyRX5ZHjhcD/10g/JmWS8gjbd7YlIs6V0PjbXKzusUB3WhltmsnD8iUWqNcqI9fTPIxmunHVx1Jyt+RhlyPT5AyT2bk83JzDvNVZhs9wHq7OBiYeY33qOQ+Jz82w27CaOgt5OPbCDOWyNbRQhA/V76ZI67xJqXp8aA+a4ofMDbrkwMcsC1PcOXiTtNbw4a5rikNd1dRwkQ9xdxPkLK6hObZ8ZAqZYuORWtpKfAj6TdAm1EBfv/IQ2W+KKSvqqOMpDwfjTVEf0Ej6ETzcbjTD2k91FCbgwbLDDK/7G+l1CQ+x103RbdVCtSt4kDhvBoMXLaQYxe4VZYrXU1lfCOZh9jlTpL7opCMLeFi3yQwtoe00UZKHA/vNcFK/k3recfFAhbC4rp10mrjImEWwOMc4cyIPGxeb4e3c26SRzEXNMzMIr71DS39wcfudKfqWdVGsLVvHxhSLbt+hK1t5+OBhgrsh3fTmGw/gLkONRDfVtfMwX2EZJvzpISNTPvS3LMX86nu0UYePebOXorKll8r28nHo8BK8DumlKW/5SI5dDI8FvcRN5OPtkcWQleqnf+oCaLktwqIH9+lHBx9PzBbhefkAvTQWwFtpITTbBmjCGgEkVyzErWv9dGqnAH+TFuDjyAMqTxbAuHwBzGf2k1GKAP9q56OXO0APQgX4abAAuYKHdGybAGsOzEfXqkc0J1aAspvGKFv7iKbwBdj21hhe9wfp5VYBRL7MQ3fyYzqpI8C6ncYwMR2iUAe2r8Q8TJIYplIRAbjz56HV7hn56Atw7KcR9I88o89jBbD9YwSV389pRFEAuxuGUJ/wgi6zcf1qQ9inv6KtUwVYscMAQ/mvKHSSAIf2GODR6rdk942PfAt9KPi9JbFxbE1zfcSqfqCcXj5mKs1BetN72vaU5U1iDmZnfKKIWD6s+nTxX+9H8k7hI2OcHvYIf6Vmhj2dnzrY6/eFXrrwsbJcB+0SnyjtGB/DIzrItH1PYpV8zNbXw1zF9+TexUftKD0MT3lLWs/4mKYyB0UL3hJ/sgBFv/UwMPSKFgsJ0D9fHwdbX9GxZSweo49te16QyQJ2r40GGBh8Tsc2CVD/Rh+vFUboM3ujtJcGUNz3jDpqBWi6qo+js57Ss/0CppHmICB8hCb1C7ArYA56HJ9S8DE2vlEPPedGqN1MAKkaPczLeUEHlgqw56QufFJeUNVBAfoW6kLnyAh9eSBAnbQeJu1/ShMNBDjorQOe1wvqfs9HerYOAs68otWP+fBImY2Iny/p3hk+CkpnY1fOGypmedMImAUl9Vek8YSP98qzsOH7c5p/hY/P4jPRl/KcLjvxEblkJuZOe0W7jfgwLpqJwfrXNO8JD59TtLHu6GvS0OejN1gbKSovKbuXB1l3LfzOf0GzWG3ev66FknGvqcGZj3/vtXDa7Tn9SOBD7qoWQuY+o6k5fCw8qomdPUNU7M5HQJkmFHKfUgLjmR41LcT6j5A844cEXU3MzX1GA0v46BujiarSYdrwnYfvyjMQLjpMV9fwMEFkBja7PKMF6/nwvD4DCYZD9IzHR/a4Gfim+4RspPhYbTAdVwYfU/M2HhyFpkOnb4icGB86KmpAe8VjKjDmYZW+Bj5PH6KeiXz0H1fHKJtHdOU8H7HH1HHw0gAVjuGjLUoNz/oGaGQHDwsmqkN+3iA9N+PBo0MVnFGPSKKeh5PJqugaP0Al7MxZr1XRN+UBJbJvO7+pIEKon6TTGK8WqsKDe5/2XOBD76kKeKJ9dEGcj+IuZdic6KXWG3wsW6OCK2t6yHKYj51vVRCp3EudrKakdqriyf5eymRc0ftaBacX9NATxoG+j5WhMbWfxofyMOqqEn5F9tIaOR5m/FZC46H71KLAQ06lIvSUeun+By7OGythYl4fFV7h4oiNInJt+2jFVy7GfVbA6ZVszSwuKn/J49zUHnI25SKNFNAq6KM+WR761ypgXUc3DbJ921wVYPK+i46N4SFpnzyqs+7SLkceKmTlMX7eHZr0losVJ+Ww7koXlTI9o1Msh9Jj3TQxnostB2ThUNNFFdPYmSfIwXDGHXKYzsW1dlmEOd6j+y+DwF0rw7R6N304GwRLHVlIxfdQhE4QAo1k0ObfQ8WNgQisloFvTB9VLgiE+w5pfGnopWUzgqC+UBo3BrpJSy0QdzZKYdzve1QwHIjQECnsdeumRt8g3D0thdnWd0nlXyCOv5bEHqW7ZBoRhNELpXBrfBf1vA3CImlpqMzqotM/gpAwSgoOM27T2hVMvyVJYvbxO1RpEgS7PxK4Y3Sbjh8PxKOZkrjk1EVjA5g+2SWBzy9u06H7gXgpkACabpHjsiDYBkkgpq2TtFYyPflUHA4LbpH2rkB4uIlj3OYOusY0zGcLcazd1U4HzwZiSbsYmp610bB3AM59EMO1FR2UtzWA9ToxSEe20Vqmbe7LikHXoJUkDIMwIi6GsQkttPFzIExSRFFa2kwvDgYgwl8Uz12bKeyFP8R/i0JpYSuNneOP3ARRLMxrJrURP3ycKgZlqVb6ONcf2TvFINrRxvLjCwcfMfxTbKU/AX7YNSKKE6Na6Hy9L1LHiyFpUTPFOvrh6GlRTFzRRBfZmg+URKFzu5HO9fphcrMIAqmBJjKfsklDFCKf6+nFdj+MThLBtin1VG3qDxs3EcbD9TTix3yHjwgC/qsli+n+uNojDPuSGpJievXpO2EIo472f/TH5fPCML1eQ5/W+4O7SRhDzKP5aQZAfLkwjnncpBXLmB+xEsaq3mrKXRwAF0lhHPSrpgSDQPiYCuORzk063BeAyAvC+Dellg6LBeFftDBe/auhfPYWPlIiuK1RT7N8A9C0VgQvvBuoyCsQJ86wc05qpBehQTCKF8Gm9gb6mB0I/0miEHZsIsOWAKCLffu4kRQmB2DjYza/oZGaD/ojMlMEP0oa6NxELky8RPHNo4kSKrhY1y6C/P0NdEKRC2FFEbxPq6OPTjzcXScC3Td1VPOF1bK0KPJZ3tIZT9qdE0G5Qh1llTN+UBNFSH4d6awUwCpGFHsaaunBJz6+DYvAR76WzpwWYGCLKLrLb9K3LgEs9cVwya+GyuME2OIniocWTL9NFOBHgQiEft4gedb7Ok+J4PD2Kopm306YJ4rmjAr674cAc+aK4aBqJSXeFUDzGXtr0TIyEg9GkLg4Wq6X0X4Wv9WVwNzWMjL9xfp7pzicT5WQwicBal+IobO7mJYOC+DZIYb1Wwpp4LYAt5+KYlRFEYWdEUAgzzBzpoRmRwvwRlgUk04VUV2uAKNtRbGLW0BWrPfdMhADx7SAEloEeNopCo/4PDpzh535jyimh+VRZqcAy6eL4bV5Hp1m33LniqLRLJ/eMW1jWiyC5TX59M2HnWGbCP6NKiDnILZ+tAj69hRSjJ4Ap5eJ4PqSAuLfZX3wiTDMCguptYcPmVvCUL1WQM+3My23VxjG3wrISY2PRwuFMW1JIRW85MFqsTBMJItJeDMP7/uEoHyhkBYb8LC3WAgq+YX0WZsHrztCaJEppvRmLr5GC0GqpZBqzLh4clwIN4SKSWUBF5rBQlD6WEh/YxlXLBdC299Ces44TcVUCCsmFtGxt4GIXS0E3evFdGNRIIbmC6H7dyG5jA7E9wVC+PW1kM7vYX5tgxAWni+mEebL4m2EENZdSP5h/ji8XwiphwrplK0/nh0VwridhVRJ/lh2Qwh180votRLjhzghDAYVkoKJHySFhcFj6++38sOKMcI4O1JAolt80R0jjOlGBaTg74ul14TxSbWAzAN9EZchjA9fi6h5pS/Ui4SxT7KAOsp9YOMtgjXzCmk2i4+Hi2Aj5ZPKJR9szBFB5s882uDqg87ZDANF+eTi5wMNhr0qQR79tvNBeLwo5L/lkqKBD3THiiHUN4/0zH2Q+E8UH0/lUoaTDw7GieHDSA59s/LBnjHikJ+byzjTB6uei4EfnUPJu31QHSIOiLD4pA/SL4tj0f1suhfiA/OxEngjmks1ST74r14cxfnZZD7sA6lLEljRlU1ab3wQYiqBb8bZdHqWL5qjJfD0QRa9T/OFipYkrjtl0YqrvrjaIYmi1Gx6NdEPL49JIvhtJvkt8YNWpiQsOjLJJsIPrQZSOLkhixKi/DAwLImjlzKpY4o/TkyRQtP2TFrj7I90DSm85mXSpq3+iDsjhWvuWaS1JAC1kMLwqkzqYn58np0UZPwz6YpLANZbSeGnayY98wqAsrUU3rO4Nof1IzbfZnMm7b4TiJ+BUtjXk0nprwMhbyYF9V2ZFPAlCOflpDBYmUnNrMfFK0rBpyWTjv4OAkdWCnerM0nfjYuVfyXx6UkmfSnnQvWJJKZPzqKrTD9EeUthzY5sMqnjwv+hJDqEsujwFh547F7TL2aTtDMPD+MkIe6TRR//8OC+RBKvurJojhAfW4wkcflhFj2RZjotVRIuvBx6wDTbNB1JLBzJopulfFyMl8Cc49mkBuYTU6VwODqXfLYx//tVCh/G5tJFpmdirKRR251H8qN52P5KGt/SCyhcnst0pTR8d+aR/Tou/h2XgdZwAS3qYDXlKgO9Q/lkkcb6+BsZbA8uIPWtQbAYkUX/6UJCSyAyVWSh+zmfzp8MRGGTLNY2FlD7B9aDlsniV08+WXcEYPilLL7dLqDx5YHYkCPHvHAhmbN3KU2TQw6L0xn/Z92URUlDATVYBeCUqyzujGMcctYfL+Vl8fJvPlmu8IdrjSy6VxSST6Efuu7LIH19AaVp+kPAkUF9VR5d4vjh/W9p9Lnmk22ZL+r9ZNC7sZBy1vrhzjlZWOgVEZ9hb2ecLOa1FdPtFX74tFQOO1cXk4+0PyoS5LCgo4iKRALw/os81n8qosIqP+w+KI+naiWUfMQPITflMFBeTJ+F/DAjTw5Da0tIqcgXEy/LI/FmKe3Z5IeN7grQelNCUy380V2kAP+3xfTrgB8O2SoiMa6E1i9lOPRRRPSYYpr7zBcj8QrIyC6l3pu+6OEoYpxvKY1Y+WLUPQXMmldGESK+8DyuCHf3Uqqr9IHBfCX0PmT8ed4HLmMV8dSljDqveON+lQK448rJtsIHqooKmCtRTmrrfNHqoIDVHmV0v8OHaXw5TJAvp+3+PpgTLg9joQoym8TGW+TgPFDBvKQ3znbKw3F3Bfm4ekNlhTwi/lWS9m0v3FFVgOSnCpp7ygs/OxTw/U4ZRfZ5oihAAfcHysm32RNn7zM97FJF31O9cN1fHiE/q2jaKC+Ea7LY7gblGHniyyZ53Je8QdxvHuhsk8eFc1X0apInrvyTx9X4Cup29UBYojxO3KxkutED6gfkoT9cRq473FGvJA8d5UrSP+COYyNy4JeV0dpb7rieLYcnZiWUe9IDn4/JQ+JlMSlpeiJ7gQJ2dZbSeiFPGEopwN6pmOxbPXD1kjy+fSukKj8PfGiXQ49HIT3u9sA4Z3nYOxSQG3kiQkQBUnKs76h7QuAgD1PjPGrO8ITITXkUj80hG11PROfKQWFFNqVVeMDDQg6JE3KppcUDLo9kIXiaRbMiPREmLg87xj988sCXpbJoHp9Dz1i8/QXD4aM8+pvsDqdbrL6S86g23x3Tc2UxV1BI1657YHGpHM7L59NBOXeoZslio3gJzdV3R4KPHOZ3lNKrC26Y1ieLHfvKKNbC7f86uOqoKrunCwYlIKCkHSDdHYqzyds0KCBx76XEFrHjtbsLEZCSTkEUFFBERQRBFBUsFFssQDH4nt/336yz5pkzM2dmz+x117o4KKWBIOcqulgfiHsf1DE3rpLyDILwV0MDb1wrqL8qECMi1HGbmZsGXkHY2a6O0FvltFQhCLcd1LHodRlphAYiMEsNfevK6dbTQPwtVoNWVQmp/wrAmIlqSOotpXcugSjQUsNQSAlZRARCZoYaDjD433U4AJJtqpAbVULPywIw+rkqxuYXkrYoENeM1fCRwfDzqkFQK1RDVEkhdU5hfHZWg3lfHt2rDwD3nyo+/cqnJ4EBcLVRw8uTeXT0nz9u/VCFnn8BKTX7Q79BFa9XFFG8tD8MZdWwdkQhsfX8oZuohuRjebQn3A8Vi9Sg2J9PZ2T88OKXGpwy8ih4nh9a+OoI/JBD5lb+uDegBtqRQxUf/RFwUg07p+bS1F5/mOgzeZh7np5+DMCoDCZ2yVwaqcTkzUAdvZey6cvMAKx6po6JnzPplIM/djM5fN+dRXZX/eCTrgHbA5nEXeMP3hUNCF0yKMcmANUhGjAWZ9B8+wDclNSEzs9zNOOWHxrvauJV2zmqWeePqYOaoGVp9MMxAM1HNDF3cxrVXvODUowWTsSmUbK6H/J/aCF2SRqlrvRFif5EDE5KpXZNPyyzmYgjF8/Saeb86O2JmHHtLH3d6YuZwklw3JZM3Bc+MAmfBK3HZ2lXtA/kDk3GysvJtGKtD+Stp8DovzM09MIbctOmQmb+GUpZ7o2LB6bAy+ws2XF8wFabhqGw07RY4M3YmYZT+5NosNwLLdOngW+aTNENXhA+nYbcxiSy+uIFccJ0bDlxmvqtvXBpy3QcuJtEUwoF0KibAclc5vy5AHGuM9G66RStZwvQPzgTmb6n6E46H09OaeOf/ynSleFDwVIH0dGnKHQTHyd+z8RQzmmay+ZBw0IHFs2nSSuYh/RuHYzcfoo8G7jovzwLzktP0RUrLmScZ8HIIYmOvuAgKVEX+9mnKULIgZKJLiZ1JNF5XQ5aEvSw0TyJ9l5h436DLsboJJOPgA0PPX0YJCZTiyEbV/7qMntCCr1vZeHhNz2YBabQ2GIW9hzVw5EXqZSwi4WjUfowPphKvi0sVJfro3dsCkkeYSFysgHW81JptJAF8wkGkPI+RyeTWHDqNkBDayqN+sSCerEBtHrPUoYsG+UVhjjpnEK36lj4+s0Q25zTaO4KNl6tNcQEXjJ9D2GjOcwAU2WTycWRjdUHjdD39yztDmeDZW8EndFnqV+CjbB4I0hOT6U4ZTYMA4wRzdzlrs3E0m2EhsYUOujDRqGdMTYYp1DLDjbG/DAC/1MyTbzOgkyFETT0zpHNPRaWHTLGqifnSI2JcZqyEU6z06ltGQtfphgiseQcnQ5gYQzPEKkfMsgmnoWIICMM2WbSsXks5KQa4VdYNinxWNh/whCnb2aR5VoWbrGM8S03k0amsTBSyRjDN9KJfY7J1UVG3p1Bh0+wkAYTOFVnUmATC7mM/LIjnV40sDDipQlqyjKIHcNCbLkxPNyyKWQDk/9rJpB7kE1a51monWiK97pZ9PwkC4OJpnjGyiaLsyxovjJF/dpsclzKgr+iKe6a5VJqGAuT3hhDWjuHgmJZEEmbwHZfHu1exYLXMlM47M+nmEQWuBwzrD6TTxsOsRAWbAbzHwXkyrzjOztzCJwKKekwC/KjLeDM7Ir6RSx03TJHDauI9M+wsELREiyjIjJIYWFdggU6GDzsqGKhRWSB36bF9GkvCzofLTCYzuDbJha0qy3xN6CQjq9mdJIs8a82n6q3s6A7zxLJfQX0PIGFcmcr7AosokwxCwuXWWHB/AK6f5Spq2OWsPpaRBeOMzpDluhHCc2OZkH4zAqOgcW0eT4LLv1WcL9QSLUCFjgrrLEqsYgaGXlRszU8WoupCiwEy9jA0a2IjB1YsGmygemdIjKZw4LrahvoyhfSJjsWTghtMYHZe1+bs7D5ti3e3S6inU4seF63wVArMxfMmDz72mLW22J6bsTCqY+2zC5aShxrFoqn2ONyVjH5mTJv958dwlcxvjE6727ZYcfJEvrB3PtjnD1+rCwiEYsFiRf2eJRQSN3MecM7O7z7XkDls1nIvG+PqbH5VMz4djXeHkrBBbTHj4WLNQ7wVGR4BCN/i3CE6/w8CiUWnm93QEh6HgVasdCa64DDCbnUzuQz6pojJkcVkPQ+Rj/TCXbX8mhkEAvNOk7gNebQ6m0snNWajUdHcqinmQWFL7NR9SeX7Jk3fVHshA3Mu8QzvdO/cTa+TS8g9d8snBTPQfkIxs8eFhYPz4aY4TItemx8n+aM+wF5FPaLhfbmObjPzSFxPBsFfc54tSSXNJ3YmL/DGZb7cmhgIxs5ynPxQCef1tmycd3VGVM7C0h8go1Ta+ZiXkwhbRzBgc4qgojhI88fsNHwcS7GReVTOoNpSRfm4nhELnXYcOB0m1C/Op8WTeLg/iZCs3Ye6ShwUCkm7E7IJ/cYDoxFwJXtBfQwkQMNT+DgojxSmMDBdQ1gW24RpTSzsdaFsPdAEdXfZCP+JOHlx2I61sfgkjmQuqaEvK05cHnigvDAcqpK4uBKiwt0D5XQ2HwO1u9yxalzZXRHiYtPn1zRIi4lMzYXuQ2ukMgpojVPOTC66YL79kW0bQsH80a7QHtxERU7cLDnFlAxXEyRtzlMP7qgsKSADo7joqnMBae/5dFGLS72ybii6WkB7b7Igep7wNI+n1a3cKDwCzh/OJcKT3JwdR1gapdLsSUc2JYBfWNy6BQzF06OB0K7cmhIhovpC12wXfI8Kc7gwieP8aElh2o/ciBh5II983Po4SouPge6Yqn/edqWwIXOcldMSculwSVc8NNccfpZPo3v4EKR4wZxRB59vcGFlYIbrGJziGfBzKx3bqhcxtj05KHonxsKjmbTi1wePpS54w+DY/Oe8FDx0R3qnZnEn86HwTIP/G7PokWBfDSe9kDCiQz6eZmPK/M8oTgqm85qCbA0zRNfLTLo1UM+dit6Qt7iHKV4C/B2kSeOXkqll+8FqDrkiRuWKcSa641UpjeEEWepabkX6pawYDacSuXrvZkdn4W/qqnUGeqNXW5s3LiYRh6TfLBtDRuLslJpX6APMpg6niybQjeMfNE3wEZ0cCpFJvmimZlVvK5kyl/sBwM75p3cUuiImx8Cr3AQNiGN3o33R9UtDj6ZpZJdhD8ermBm882ztIbZwd5KcTFcm0LkHgD/dRxIH0sm/tsA9BlzsaHnLE3U9Mfal2ykmieTqmIAct+xMWMwiezEgUjt4uDs3GQajvWHeBGjMzWJpHP80MzM0Q/pp+gAzw8fLZjeaE2iBf/5QsDMZm1mD8ny84XdO2YmWZ2hp+t8kFfN4OnMZMoo8UHMYkY+kET+1d64PeyJN0NJNLs6EJz5XLjMP0s2TkFIs+Firl8yTTobhHPM/sEuPkvvDgZCuYuLqWNTSY/hLK/ceDjM5OdDzDzYhfPgLpdKygHzIbWMhwWPUsjDdj6cuniIYfK8oC8IHrU88CrTqGTdPGi58ZGRlE4fJIPAZ/Yhzvp08hsIxJJVPExl9kOb5gAoOvHwdtw5GnUoACc/83CTMuhOeCAa8/hI+ZRJfc4BcInkw7c7kySDAvDyBR8b8rPpIisQ4kkCTDyZTd8dAqG/UIDXPjm0luEXqzMF6CvPoeIbgZC8I0DFm1w6yXAK6z4B5CQK6Jd8IKTLBKj+L48OVzE+NAlgmFbA5DkQI78JMOZkEcUZM/zinwD7ugvp+qwgBH4R4KdDCcnPmofhFgFuBpSQUXMQvGoFYD0tpcriIIzcIsCaGReoYXIQdjE2UxeVkVZ+ILaXChB6vJx++QQio1uA8J5SOjwYgEjmfFZ0OdUyvGPrDQE8dcpoYm4A1jH75b+FJXRNKgCpJQLcQCk97vfHE0ZWzSsms6XMTt7K2DlRRH1+gRANCGAfVEKHLvtDfZ8AWw4U0kKVAFTFC7CjK4+GbPzhYSnA+6J8OtnuhzYLAVy2FtLXCf6wDRKg1rmElMb64e1TPqL/K6IRf3yxrZuPihWl1PHOD49MBBhfVU4pqgEo3y7AQW45Tf3mz+yoTP41K6k9MBDHmbtcdleQoN4fG//ykZNfRVZNflgpKcCK9ZV0qNQPWU18mD+rommH/BFSycerN5dp9LoAhG3jg6dwhWQ5/tgWzYfdjRqyNwiA0IwPI61a0mV4hO5oPtpDr1KYyA9JLD5WatTQkuMMJ9rDx9Wbl+n4J1/cmcfHvrLLJN3jC6/tfFROY3il0BdpjnwMll6isTN9sZfNx8eyi6Tx2BdtRXxofa+kC7K+2BnM7O4TKsjnuS8k7vLRFHCBEpR9cSKMD65/GZ2a5YuMCD5eryumb/N8sOoODxtWlNAWng9OPeAh3qec4rO9YWvKw9GzpZSe6Q0pZx52r7lAPxl938c8nDaopJxKbzxw4eFu5EU6n+IDhzYeFjlfokU93jBmsHUULlNcmQ8u7eLhWX81LTvii09SfEy9WU0NF3wQxGDu18tXiHfQF6qneFgy/yr9YbDi4kEelg3W0dkaX5z240E3qo66VX2Rac/DZl4tBcAHUb1cbKq4Sp9m+ODRFB7019fQcLA3w++4CGm4SjaB3pA+x8WDH9W009oHthu4sFxZT7lsbxyaykX84Tr6LfCF+zAXxxfWEz/KFy4pXCSMaaA4az+UzuHh9lA9bdjmh1ZJHi6Oa6AJTP1Y8Xlw/H2N/jA88Y8VD947G6il2x93P3LhdbuRJh/yw9bTXGidaaTGWn84LeMidMVtWrXaD+3ODH7m3CJDpl+0fbhwLb9DQ1MD4KnLhUbRHXpm6g8FZo4+et5EoUxNandz0DX+Lh2+GQBlOS7Wa9+lndqBsGRmqmBuK/2uDMRvDS7M792lkCymr7W5OBrbQkUrgtD4iAPt9lbSYM9D5D8OOotbaSBhHopcuLih20JJzvOh8IcD/r9WenZqPjT4XMgrtVDLkmCs+sHBzJ5WItlgTDrB7CIf2+hiXAgmr+Rg2dE2+hoZguU9HFxY0kqt94JxibhwKr1LT66FYJIEF6TSQuPyQvF5iOE/r9uoVyYUojY2rr65T/8ZLACX4Tx6jFybsACl+9hoGtNO83oXYI8SG1v+tdPDmwtg2cXCTlYHcX3DoMfszWbTO2ht8gIkrGMhSfUhXcwPg/N+Tzj9fUD2M8NgcNoTh7s6SbcpDMseeGAo4BG92BOO6R4eGP3kIcnMDYcXzxNrnDvoWWsY8p54ggQdZPw8HH6bPLB3+D7dnx6B8C0emGHUThNCInC0yx2f9t+nrGMR6Opxx4LCNvr3LALpXW6YP7eDWrQi4TzVHVLKbTS1JgIsAw/UPGihk1YRqLjlgV7texTOjsCXkZ6o0mmhjP8ikPzRAx8imklCLQJGWz3x6l4zCR+FI/e4J6aebqHmKRHwKfBEa20T7SmIwL1fHlB5cpukGJuutz0xJHuLzs2NQOpnT7B1btD2JxF4I8HE/q6R5DsjMMnFE5kt12mbawRqp7Lw1v4auT2PwJkVnnj7tY5++kXgpiezTyfW0ollkdCt98DRhlq6eyASK155wET6ChVKCLF1tAdGXbtKIzYLYe/mjiOTr1JviRDBc9zxwqOG3r0SQjrHDQfLr1DnRBECz7qBXlZTJk+ED7Wu8Nt6lXxSRPhT7oqT16tpzw0h6je4Y449g283Rdja4YJZ+ozNHyLMeuwCr4U1pKolxmFLF3RVXqH0XyKcN3eF9rvLJDtGjOZnQG5PLR3xFkOvg6B9oZ5y+kXYnQTIbbpGk7JFSEp1wecrdSR/UgQOywX1nddp2WcRjs4H8k80ULy1GNbFhCC3Bvo4Xoz864SNso1kqyDGp70Ek8m3qLaZWbyXAO5BjTSmXASmtRHVdYtmD4mQFkw4mt9EZ0+LEMns4Ukf79AbrgiWTi74ufQ2fVNjYnFzQR2nmQQLRLBjdNK7W8j4uxCLpFywwLiVUieJIJYH7G+2UW2oCJcfz8Uwt4PEt5lYvjljpnwH7UgWYUSBM1rfPqQVcmLslHTG2OIH1D5RjF08Z6Rm36c8nhhuinMw4NNJVQMiSJXNgXJNJ0lPEOMNcz7J4DFpJ4pRrjEbRj8f0/IB5pzhUNPPPabdN8RwbHBE8JluSrSOwnxDR8Syu2gFLwqntjvC1OExLY6PwhVTB1x7202WU6Jwq9EB48RPyc8pColaDtAqfEaD66MQYWkPj4DntPhpFI4o2UFu+XOy3RUFBQU7aKj20KbnUXC+awNF5x7iH44Ch5HjJvVSCaM/tMkaRyf20pTiKMiutsb+d29pVE8U1JyscP31W9rRHgUXDytYJ32g89+jcG+EJYKPfqAHo6KxTIvh4Iafae/YaCQ3mcPS8zNNdIrGmr/mcCn+QtvNoyHYY4Yl3l+pISEaA+PNkTruOy0WRaNvmhnOVH2nRSnRkAkww5hp/TRnZTQcU01hb9JPA2nR0DhkirdPBujNgmjsGWWKMTRACxkdpQoT2IT+JNnuaFxZaopBi1/U9SEa7xeboWrWIElzY2ASa4ZRWb/o56wYjLEyRcn8P5RxKAZhRmaYcfk3JeTEIKfdDHOqhij+VQx+VpkhL/4PTaqIQe49Uyy9/pfIPBbflplhxehh+mAVi3Up5rjw8Q+Vn4/F673mGBEyTBMLYlGQaIZZDRL43R8LG5hj3VkJzB8ZB+n35ng6VwLn3OIglWGOe1aSKFSIQ22rGaR8JLHHMw4zTpuhJWAEwj7HgmdnhoErkvjdFwutO6ZwWz0CGrpxUM83xdDykVhzOhYq402ZGh2BHU2xWNJogkLXUVgSG4fPy00haBmFFRfjwNlnhqX1I1H4jblX1wxdpqORnxmHHY6maF4mhWD9hRAYmEFrhhQ2eC9EbI0ZIleOxuVtC7HxhRk+zJPCbKuF4CmZIcleGhnZCzHlnxl25Unj3s+FOPzVHMIDUnBUiUfaD3NI90jDxygeY40sMKZTGmfD47ExzwL6HtLIiolHwlULfKyTxpW0eEjFW+JQiTQKMuNxf7UlrFOlkZkVD62NlkgslobEpXjEfLeEGaOT2RQPU7EVOkql8SQjHj3KVnCulcLeO/GIXWmFX2XS2F4ejy3jrBH+QAqKD+JhEmGNEzcZP+/H48hGa5TekYZjXjzWTrBBr5Q07l6JR/dCGxzol8b3C/FITLFBn4QMVqyLR7O6LZYaS0MhOR4lk2wxeYoM0nbGI2SxLcaPl8G3PfHYHmuLGnMZZK6Mx+o8WwR6yMDGLx7L/9oiWCyD89PjMWOCHXzXSeNjz0JE1drh3XUZeD1fiO2Ndhh9UwbsrIUYHLbD21XS+Nu1EH/u2KHhtgz+zV6I8GJ7zBwng0/2C5FXao9EjiwWWC8E56I9RglksSEvDvFiB0wslkHJ2Th88nTAiTpZvN8Qh9/Muc0jWeyQjsOfQQc0uMnikX4c3p93wAY1OSRIxuFrswN6p8hh4F8s4m444LOVHMYfikXvZwc83SSH5bxYzOc7wlJSDnptMVCydMTXEWNwtzYGknaOSFYcgwynGJTfcYSKpRwci2NQZO+IOM0xEDdEw+u4I9QYefFANLQZO1WHxyBubzRaXR1xqGMMVB2jkSl0ROrlMdC0jAbPwRHf5eXxvS0K7ZMc0ekuDzNEYYrIETo1YyD0iIKY8c0xSR5T3ohR98EB68/I45tMFH4+csDBOnmUNIlhVueA4dfyYPuKcXa7A7oMFHC0VYSnlx3gelAec0aJsTjQAR+CFFBTKEIqxwF97gowYubgFHMHqKxTwOF4Ee502KM4TwFT3wtRdt8et1kK8NEWIfGwPULaFMB/LkQ37FHWrwCZO0LsI3sovFbA2iYh7Cba49A/BWSnCnGjyg6vFRWxdq4QWfr2uCBQwL0dQkRstIONhiKWd0TifaQdZvkqwJLRycy3Rb6RIsR2QvxJsUWDviL0nYR4lmqLz8aKOO7I+HPGFh2MXGwjxNsYWzgZKuLLDCEzf22QPE0R24oj4THRFrRHAbeY8+NbmJqfrAiDrEgEatmgLUIBEoZCKD6yxlYpRVjrCaGxyBqHPyrA1EyI88utUTeogFRzISYzffTkhwIWBwlhOt8KgVcUoKUmRKCiFVLnKMApQoivY61gV6yAgpVMjAWWKD6pgJQjQtwbbwnXFQrYFyaEdrEFLv2Qx+gCIfxOWOCxnwJimD0keLwF2qwVcLtMCPEDc0z8I4/sDiGs75jjw0zmrkEhs4uaw3dIHsXNQix9ZIYX5+UhJy2CYooZfHrk8WWmCKJPpphRLY/6N0LIFpoigORRMEeENnNT/Dwmjx0+IiS3msB4gzyqfwshddUEsUwdpi8XQUtogvAQefhGihi8NMZNpiZvHBYh7JYx/tjIg8PUiWqcMaomyKP/nQhXeo1wvHcM5j4VIavVCL/2jYGOshht6Ub40jAGMfPFuMYygt/eMXDmiFEz2whzeuUgKBTDZ9gQl3ljMO6fGBtuGMJRdQye/BbjX60hmvzl0BQTBRwzROltOagzszhsoyEsk+SQfSEK/O2G+PlOFkM60diw3hCPeEyfhkdj5wZDbNWTwyqPaLzYacjMJFn4NUZjcpohDD7K4kZvNGKKDTG1SBYvvzBzlpGd2mWRoxSDHTcNkcXgxsnEGNycyMS1UxY6jjEw0DfC2nMyaBofi6hKI/y1kkXa9FjEXmPOjWWx+3sMrF8YQfaiNLqdYrH/pRH2TWV8q47F8E5jDK6RgUl9LFbsMkbaUxmIRsUh5bMx0q/KwIwbh/nBJohMlkHMnDiM9jdBQ6E0Xp2JQ1OvCfpXy2DdrThY2pnCY5oMHjOyK0xxMkoGR3/F4XiSKf56y0DA4GSWjhmyrGUwatVCRCaZYROD1drj45DLMoFRthTWnIvFvkxjVDJ4fictFs9eGeOUkRTMemLQZWWMChMpHD0ag8Z6Izi+kcJOqxgkFxrhzgIpiCfG4M9iI8TNloaLVzQ8I4zwfbwUXP5G49hdI+iEjIaOSTTG7jbC0kyGYV+JRvVTI5z0HYVZq2NwKtgYI1eMgmtALH72G2PxOGa2KsZC3tQEz3eNhGh0HOoOmGBt0mjkhcdgUZYxOsePxP7KGMxQNcGlqhFoG4hBeL4JZg5JIjE+Bka/jDFgNAInXGMwxcEEY/slmPkfjQymPh+MHoHxe6IRcdAY+xIlINUXjbtsE7xVG6Z1CTEMfzGBqWiYXl+Lge2ACcYVSiD8RQyebTfFxPZhWmoWy+TCFHY3JZB8OBbnTpki4Y4kcoui8dTZBBMM/1Iws3fVXDbGnqx/tME5Gj5FTI+U/yHe6WjkrjdB6u8hWj8jGofvGmO19BC9qYqC9k8j7Jf+Q+eY/bNypDH22w4TTycK3VZGiB/6S6PtorDR3AjXPw+RsCgKm6SMYT32F612j4KOrhGmzvxJc5Si4adlgo/3Buj8SzFebDWESekvimNmwVt7Q/xyG6SR0WL8zDBA0apf9Hm/GAvnGWJl4B/6NlKMqr0GePr8N01meARdN4Dszn+0L0aMD0cMcS59mAKVovDF0QjqVyVQADGMLxgiSEYSDrkibHRieidLAgdqGY6wzxBqJyXhNcTgs6UhUk5I4gKDS++TDbBkhwR+vBDiiJQBJB78I3u+EE9HGGC5rQRKtYW4vlAfrR7DND0zEjJ5+jizVwK7RZHYMFIfnlMlsO5mJD716UFPa5heqAih2qmHkaP/0c2wSBQL9GBz4x9VOjN4bq+HvtbfNCohEi9P6WLeiL+Udy8SXW668Jj8m7ZzGLzl6eJO7C+6ytgMXjgLcqG/6ESoED8Xz4KN6iBVlAtxgKuL4OuDtKdTiPa3s6BgOEDphiJ0Negi68UArbwuxMAPXbzU+0UZJILglx5+9/wizkURskv1cCVvgI5eEGKVqz7mqf4lm8UMV/qmjy8r/9DrToZD/dSHsniIOoZFyMzQZ3rzJ+3YJsZaXQN4mgzQOR0xbrH1EfWqn15UMudKBhhW+UHrlzDc0EofNUe/09a/YjzsMYBg/g/a90mMe0P6aOn5SvNsonB3jCE8x30jA1YUzlw0wJmgL1TfEIUEKSOE7PlEM82jEP9DH2sX99FcThTct+kDZZ+op1cMg8d6iLbtI0GuGLJy+ri35CtVCpmdYaIepvR8ITeG33m46WFg0nfKlhLDK0cPby/9IJViEcqv6yLD+geVDIqgc0gX69W+0cZUEfJSZ2Hlnq90W0+E9JJZqJz0g16riNEzUxdLI75QX4oYv7t0war7TOlBTLxfZqH/f7zJQ4zLTTo4xPCpwBFirBrUQWH+J+qLEyNYWQcPHr8lzW8i7MjWxpGQ9yRUF8PVXBua3LfU8FOEybtnYpnRG/rD8E0d05nwzH1NK/JE2Fk8A9nHesmOsamxawYssl8R/7II2qnTITv6FW1k3nrgzHTcWtxLZCTGiP+mw1rlJa14JIL/oWk4VvyCcuyZXWjxNPzp7CG1Zcxdk6fi4c3nVPiVmfsxU/HRoYdke0VoqpwCTuxTcmByqPZsCqy/dJE2w5eHZ01B45suijsmwq1rkxH2pZtK34tguGwyEtW6qDdJBIv/JsE84wklTmRmdOYkdH/vpgmMb8PRE3H/5BNyfCiEY+FEBG3sppG9QuxdNAFdlk+o6ZIQ699OQNzFLjq/TAjX71rYldBFKi1CBGzSgq/xY3IPFKL3uiYkRjwhy4tCcFM1oYlHVKgrQtBfTdz/8pD87gnhP04TvxQ7KSxYCN4jDUQkPqKTVyIR0qiB+OInJKkcidLL6uj/9YSm6kQyPmigyK2bzm6OwO4X6vA2eUrb3SIQaaqOXuluWlQcgZNT1VF69QkpjI7ETHV1rM99THtNI3Bkvxq+rX1CFUYReP9NFeIPjyg5KwLn61XRd7qThB/D0e+piuy8TtquGI6m/apo3v2YFheE4f6L8dBp6STX/8Jxomk8kgce0j6rCEjeHA8vxYe0eWo4an3GQ+PtA1L1i8Bz1fGIMeig4wbh+HtxHKTdOmh1dTgCT49DbMF9kp0QgQMbx2HP33b66RGOhzQO4260k6tXBIImjEPA/DYavMHElTUOW5a3k/uvcJxbpYJlC1vpXUsE9oWooDS2hQZHhUNRSgUJMi2kmxsGl+UqeNjRSu1zwmF1VwVSk9pon1IYyn6r4MmxNvpxcQE+7lLB2rOtdF0tDDLmKnixvYWc3BdAap4KKv7epfR3CyDXo4zqQ83E+xOKzcYq+MltpoMJoVDOVsGeV83EXRkKl1AVFOrcIaHiAuzsVcaGE010FaFoYKuApXab3IdCsXGXMj6OuEV9KqGwNFJBiKCRxu8LwbiR45Bx7CYdXBmC3/9UMLmmgbp6Q2CuqoJEk+tkfSIU0hHKODjlBunFhSLFShmW765Ri1YolixRRs6OOiotDIWgWAlWV+sp+0wotq5UQvP+Wno3LhS21spwDr5Cc2pDsNRUBXJRV+l2YQgcD6hgy0A1Pf8Qgu4dynh96zJtaA7B2HAV/LC4ROr/QrDfVRlK+6so7m0IHusw/uRX0mT5UOyfoIxVwxXUKBkK32FlVOACSU0IxYeRyph6vJwkGd/Yzcy3nmU0YBaK399U0BFQRiNGhCKTidev7wK5R4ZCY/J4aFWUEf9ZCOZ4jsMcj4t0VScUBbPHo123gua+D8HK4PHw67hInuJQyMWqoiK2gtYxfoqbx6P28CXaNTUUbkmqmNZ4kVw7QmBfocrsc5eJGP3uWjVUSFdR3dkQBPHUILGyhq4ph6JaUh0P5lymocYQTAhQR5JuDYl9Q+GlpYE13MvksYyJN0EdFU+vkPTTEKyJ04DunBoK9AnBv+MaGGd9lR7Eh2D9Sk0UHLxCkfXB+BKmiUGHWvqlEoJv/ZqInHiVhgeDkSzFfFtVS7lewQhar4FEYT09VgnG91WaoBN1dKtqPi7qaMKhop7M4+fDsZ2xWVpHRYPzMMFUEyPjrpH8unl4KqWFFH4dde+bh8SdWpi48yrpPw3ChblakF91ldS2BGHTS03EOteRyVAg2p9owmjLVTpzPxAlJZoMf6wjzuQghB/SxI6t9dTkE4hmf02Yraqn7olBGNTWhMac6zRKPRDf/mhgRu91co4JgISyJpInXqO6tQHYr6SJxCW1dMfdH9wuDQwsr6cFYn+YnNBAlGotdS30w49lGiiNq6VJn/wgUNfA7OQrVPnIFzFv1VH73xWyXeGLtdEaeKZQS+XVvuAxdvIYH94n+kDyhgZGKtfSpzc+yJqogck7rtB0fx9ocDVQbn2F3kX7wOyNOrb/qCarKm+IdzDYOKuGFij4wDBfHUUHLlG/hzf2LtbA35pLtNTGGxlGGpCMukjdnd44GaGOs+6VpH7XB/LX1eCeeZEeDflAaoY6wrQvU9IJH2zfoo5vvy7Th5m+iNyrDpORNXT0ti92TFNH0MRqWsPIzonqaPOsoejNfrjLyE1aNbS1yg/mH9WQ7HOZlBT9weapYzO3msb954/COnW8aq+mKWv8EeakjoubLtN7bgAsstSh1XuJAoMCYOykgYtbq4m++6MggakZwRXaMjoQtb80kKtXQx4fA/BxngZe0mXyfRuILds1Ydh0mSIrAjE1QxNVF2ror2sgTi3XhJzSVeLNC8TOnZpIOlhLa8oC8NNTHQuGLpKiZyBYS9VRdrWSDJhzrTI17JxeSVTtj8oGNfhnVNHjK/7YZaWG6heVlKEbgGvaarAqriC99QHgT1VDvMUF2rXHH5rdqng8vYI29vpjIjM73JaVUWWqP+4VqEIoKqHiSj9I96jialwxKUn5Q6VEFUcPlVL8sC+e/1D9/9+XF3b6IYjp2T/7ysl10BeljM3Lay5QxTRf3J+rBqUV5bR72IfhmGoI5pZSClMPN7vU4CUso3jygbOXOqLLiyl2uS9erWfOjYrpRaMP5jFvPUWtkLiJvliUrwbD1YV0UNMP3Rw1RG8tpOx0X5xrVUOjYwGNNffFXeatZwzk0YilPrjjpoHdk/Kp7KU3dm7WwM6FBdSv4YNZj9TR11lIw4e9sctXAz68Igr+6wX1HZpIe1xAy7d4Y+FqTVx7lUezB72x+L4G7irmk6KWD66qayLidS5dyfGGiOnTk8gl/iRvKAq14HY/l3ZGeEO2Rgt7x+TQTL4P+guZfrx+ntJveWPfhAm49DCLTgh9cMtcC2sNssm23wfu+zShz8iTz/jgdpwWvspkUetOX0w4pokT+ZkkeOeDTsam8cYMKljnC0VrLTR6ZtCKSX7QLmJqwzKDRq72ReBzLVS+PUfvl/ji9PYJeL4mjfDIB+smTIT68TR66+ODMx6TUOKfSs4CH5T/mAT/P2eJ1eaN96sm45F9CmVt9IbajMn4VJtKVpbe2CM9BX8aU4iX44ULf6dgaWIKJQwIMEp3GjZrpVCYpBd8NKYixTuNPooFSGNPQ3xSKmmuEODYhqkIjDpHz4b56NefhrFrz1F5PR/r1adj+YtUesjo/OiaBssxKST3l49TK6cjWymFlPYKwEmYjk9xybRNyMefSzPglpJMw6MFmFE9AwqSZ2hDsgB1WjPw9WsS7Yrj41PoTGyUPkNqLTyMldTGI7UztF2fh7ky2vham0zvzXhwS9XGyOlnqDuFi5tmOoh2OUOxilzMstZB6qtkMh/HRXa1DhLFZ+j4WQ6uO86CZ9YZknLhoHzKLCQYnqXxahy8eDwLo2Yl07hKNqy+zoJa1lnSGGRjitIs1KmkUkUcG//1zELk/VSK+M6CXbkuTDvT6DebjZ2tszBZlE7feliYUqSLxPAMun2KhZMr9bDk8zmSXcFC3Ex9hIw6Rz9ELFiz9HGnNZ3kvFgIMzXAuKwMWuLNwtTDBrj6JYtuBrEQwXDJ3I7zlBjGwpknRvBsy6Fsfxb0HIyhwz5P3C0sLPxhiHKzPLLbxMLIb0YY7MqjXObe1+uM8dqigBROslDwnwnqOgso7w0L67ca445HEel0sRApZ4rrY4upZg4bB8eY4HB9CfXbszEQb4odp0up/SPjv4UZPimX0IYKFr5LmeHp0iKiy8xd78wQWFNEh5i7ZDeaIia8kMIZ/dTvZpBeVkIJWmzcX22GPftKaVCJjbTxFki5VUaRT1m4X2MO/agSMhrPxloLc9x9WUpz7rPwebolTF6V0phuFtKXWGC+VimtrGQhRdIS4RIltKqZhQmRFgh3KKEYOTY47yywcrCcPJ+woDtkiU8sBpc6WZi53RLecuX0pJiF+cpW6LQqo0NMHtJarGD+vIy01rKQ3WcFd71SmraUhaFL1hg/spwcmDeqDrDGCJUyKp/PwtL71ghcWkr77Vmo07VFSHIZreOy8DfcBhfVyuhfAAul22xwt6ackv1YMO+2wcGZFVT7P/04W4zyukBtOiw817GDQ0I5Jc5iMf1hB96IMpqiycJNe3v4vSynEbpMntPt4bKmjIatGR/0HJD+rJRUHFiIyrDHt4slpO7CQv9ZezyaUEyP+CwcS3KAYn8JNfsw/vAcIX5QSq8XsRCw0BFdg8Vk58TCjQoHOBqV0dEpzFv7OKCxspzqLFg4q+GIJI1ymsbU2MshRzx/UkbB5iys8XdE0bYLNDmRhQP9Tsh7U0ZdG1lQO+kE6/RSWpfNxLhyNrrNS+nbURZEh5zg8rOY/vf/K3VHZuOIYjFJnmfqttMJaguK6P4OFhoVnfDQtYgUo5i75BwR3FdIUrdYaIudgys5pXSUeTsJuzm4Y1xCniPYiEyeg0XJRZQrzYbU4TlY4lRIU5j6bDzvjF0qxZQuwUaihDOCFpaQ7ww2fj92RghTJw/XsuFWMxcxkiV0mKnhMZlzMUeijCYospH+ZS42N5XT3jYWQiwIVZKVtOQkGyMFrqh2qCLX+Wz8XOCK3zsv03pVNq6ucYHz3kv08yYb/4Zd4eR0iaSncjBS3g3xiy/SCkcOVJrccCL7EnU2cRD+0w2HP1XSh+0cDH10xdq2CxQxmYu6m244E3GBmiO5MNzuDv0jFeRzjYsXkh7w86+g+kk8XN/hjvGTSij8MBc3ytww1FRCYRwuHp9xg/OpMnLr48B5lhv0DMppQysX+oxNiZYiynTkgS9yx7m0QhrRxkXDf27oqC+gG848/DVxR6NOPn0q52GSqgdcpxRQfgkPuS/d4bA5lyRN+dh20wNXd+dRgCEfbckeeNN3nhaU86GzyRNNv3IogisAswHAoOA8tRbxIcrwxPYz+bTFWoBeBqcumebRQxMBXjO1MuoCc2+1ALums6EyN5/kKgR4+p4FpTG5VBLqhcJrbIzl5tLLEV54M44N02/ZFLpfgHnzGBxUzqLhtV4od2Aj2DWTcj4IoLecwbud6SS1WYDJnYw/w2n0uNALP2TYEP9ksPSKAMe7PDEiO5XaBd6oPc/G6JR00pjtg8/DbNwIPEcevd6QmMMBVyeDLp30wYvzHBy5lU6RLF9syWTeb/456mLkVZpcjL6QTls7fdCmw4XjwwzK1PTB8gYOTuZl0oRjvhjI5UKpK4Nc6n0w8wgX9ceySLTMFxWTeRgZlUXVbD/4iXnIPJFJoQnMzjmShwTTDGqZ7YcuERdX/5wj80X+eGDJw72l6dS61h9fFnPhvCSNbu0KwJ6DXHglpNLKN34oY+y82ppBkkJ/tD3iwcstk2Yxe9pdBT4kZLLp3UF/2EbykV+RRRYe/ticxEfvhPP02zQAHZYCjMjPoduG/pj8no8UTi79Xe+HpDA+fJ+cp6dmfti+jo/Xq3PphZcfqm7xIZ2eT3+SfFHH4mPy6Txyi/DF2CA+uhoLiL3XBy2NPKgyNTa5xwdPW3n4MCqflJV9kKfLw8ucfKor9cZrWR527i4iVz9vnFrERYZ5Ac1Q8YYznwuOThEFtnlB/gEHMm8K6NMxL6wt5CBPuZiWqXvj52ou1jqXUHu2F2y/c+CYUErb5LyRdpSLJgaX5i3xgtItDrYwOLlptDd+JXHxr6SCSpd7IeYdB/pyF2k6Y6c/g4uO0iqyW+mFPSO5MB5zmXYe9cK5PxwoDdaQ1EsBDPw4UF9aTauGBYhcwkFNxlW66yDAvVI2VrXV0E2mtgtvsHHkci25SzP+OHGwPquePtd44fdVDhYo1dPTOi/ofOMgUa+W+o95Q1KOiTflGiVu8sFIZy7umjaQ4Is36r9w8LuwgeYf88GTMVyc/nCD3iz1RYEbF1FrG8m8yBcSSlw0xt+iUyMYnsX4uXLJTVJk+8K7joNZm29TLlM/F4Y4aB28TWFn/LCZydsjx2Zy8faFVhAHk+WaSXaDHx6acuDwqoUKW/1hvooDe81WcijxB6lwUDmrjXb9C8A5GybexjaCZxDOLOPAt6aNbifNw7RUDl5mtFECdx6k9Dm4cv8+PTwwH8ctOfj74T59bA/GlokcRH+8T9W+wZjXyOxA9x/QmiUh6DrOBr/zAdW+C0ZZOIO//E5a3RmCUUyfnrjRSUr/heKlGRt2PQ+o5Xoo2gtZeLink+bGhWIRMxsi3j4iXdcFIAkWxn14RNMpFAcmsvAt9wmVYgGE8z3hz++iXqMwPBjtCeNPj2m9VBjyGbxSG+oi+ethWKrpAfM5XbR+eRgG+9zBH/mUnPrD8PM/d+Se6SbT3eGQkmbku12kPCccP4fd8evwY1JuDMPvjR5wv/mYUp6HQ3mOO6o4jylTLwKGc92xKbmTPoZFYEyyG173P6KhtAicTnHDeotO0nsWAYcsV/heekxy0yPR+sQViq8e0ubgSGxm5L8KD6h8ZyRWOrji3qaHFFMfiWYzV6hVdtDCj5GQ4rgw87iTfN2EkJrtAvlFHRTfHwnlcFd812qnhBWRmDrDDQO97VSTEomccDe0z75Hk3iRSPNwx8DqFlKtjERdlhtM1Vso20CIB+ddIcHUgPmHSJinucHfrpnMd0TivKM78vOaafexSLgkukM1vYnWq0XihpIHov7doWNWkZju4gGu+W06mxyJ8RfcsSzpFh1QF+I0M2uez7lNXtciIZ/jjo/1jeS04H82PbBAcJMezItE9WIPNDrcoCkPIiG65g51+wZqi4jEllPMjDtwjba8iYRKjzuW7qinYIEQE0a54/6867TSXojmt24o1WwkdrEQfye5oWjODXrWIMQZB2a2br1GbtNE8HBxhfx/DZRkK0JPvCt2ZNRT3SMhDsQw79JRSxAJMWKmO/xz6giLRVjJdUF6SSPtGy1CH5Pzcseb5NIrxC4dVxy6eJvSTwphMcoNM9/dpFH7hXDvcMVOmSZKDxVi8jNXZPXcocOXhbBxYt5u7R16nyvE+58u+LnnLvUmCVGd5wK3s60Uxfg5PNIFo6XaaP9CIY4mu6B9SxuFlwuRlgtcULlPD34wOpcI+890kEuGENd4QMa0ByROEGKiJTDNspM+3BJCppBAIQ9JqlGI7UEEmSed9EdThK7WuVg3upNcPwmxoWou3sx4TF9ZIoy86Ix/A49Ju0GE5vI5yDrxmHrOibAsZA5uHOimJFkxsi7PxkzHLur4KYJN1GzYcp7SVrYYW+qdIPu6mwRaYoyrc8LHS8/oxEIxJl93hH/yc9L+IEbCSQe0H3lOV8+KkbjbAWm+PaQqHYXORHv8c+uhDIsoyBbZQ9HxBb3iReGYhD065r+kd4jC8SN2+Pq2hxSCojDpuS3MLV+Tw4QoPNpgB+v818RxjULqBlscYr2hBUui8GCTDTRk3lGCbRRMLG2x2Ocd8YfEWGtrB7XEt8SeGoX/wmzxXeUDFfpH4cdpG/i1vafnIVGw2G0DqU8fqeJkFGYlWcPv3gcqK43C6EJrRM7qo/jYKPwpsoH2mD46qhWFOwdsoVz6iaZxo7DNyxbXfvdRW34Uxh+2wYMVX+ltWBRmnLVFwLGvlFcShWf5tljy8jut/hyFtjQbZKz+Tl560TiebY13rt8pwDYaXy/ZIJXXT26borG2xhqjQvtJ7Vw0op1tEFg3QHZ90TiibY2YlwO07lc0upfa4G3mT2oXx8BvgzWOxf+iviUx4NpaoW3NT7K4F4NxlVYQHhyi0x0x0K21hKLKEL00jcX/AeCJXwN4nBSbZVyVW9PGaTCPQQoYhCKCCgjSMX9AZYOUdO69AVGxux/z2H30HI/d3YmBHlvsbsVA7EBQEeG930/MbzFr7lmzZl1zXR/29eed+Pf1L5mk05vXhzyY9qFKfq7vRZFXJzD6KX8v60Vd8eCdwU8JkF6oHTqxwu27VDfvxTRbT24+qpSka/kU1nZiYGCFdJ6fT9taT7oUf5PEvvnkzPAkfHi5ZFjnU7LWE++uX6SstCdL/vFiTugXcVbsI3mevOj9Ub52yuejqhPTd36WoWPzyZ7RCUejcimdmM/qCA9MHn6Vdg/z6b7Og/11KmT0uXyWZbszULHPdOpFk7XulOR/lx+zezE/3p0+BT9l3P1eXJ3vzsUrVXJ0cm/Sz3lgMfO3JGzrTX0rTyrb1UjXkt78VM4VXF0jTxr1YcqWTuy6VSstXPtwQqlJw2Qdqgf34cPeTui80SF9ah9mzfLgTKoubkf6UHrAHbvheqgf96FxjQdrzfSo066AL/Ee5LTRp2fjAg4MdSdtnj6xKQW0v+xO4wYGFHkUsNbYnZhJBsxbUsD1be7UOhjiO6OA1xs8OFLHAFVVAavLPdjlbcg7VV8+3ffgVrQR+9V9Sd7UieHvDOk/tS/fIjqhX2SExeC+XD/oSdJ9Q2wt+zK4mycmHww4YduXMZO92KhjyD9D+rKq2It5ekZcsOpLl7WdudLbkJH5fVm9qTMdYoz42qwvGRO8ueBvxJlVBVxZ6IN1sBH3NhbQYqc348wMeRBfgMsSH6rcDdEPLCC3ow+TRxow61EfXhn6YrnGAEOHAjI8fbm435Bdf/XhsK4fUWcMee5aQPp0Xy6fMuL5uj7oJfsRFG+M7bfejKz0Y8hMI1oY9OFkI38G1xozK6A39/f749DNmE2RvXm+zJ9zO024ubAXIV/9iQmrQ3BiL0pVAUTVN6HfsHw0vQIY2K4OKwbks/t0AIGNTcj7N5/F1wOYZm7M9a09WdYskJ7JxgTe78m7kgAuZplwsjIPv4aBnGxgwu7hPelwMoC4lyaU2PVkfWIA/xyug1NUPt9NAkjqVpf1R3oy/ZI/hV/qErooD++r/mw6WpfUT7lYdvOnwZh6LF6ci+8hf54OrUuzy7lsaR7AhRN18K3NYetDfx6ercPy7Tmsdwtg2DUTdCNz+FHkz+P0Okw+rWXBE3+eLTfh/SgtpiHKd1cYc0BXy7vD/jS1MCFhiIZDb/3Z6GfM5hQNPwcHUBlgxLcZavRe+1Pez4hRj7Pp2ScAG0tDLt1Xc0apQ0Rbpa8C1TT/EcDSQQb8mpXNznKlhkYGNNZVUzcrEPVkfVL0s5naMZCNkfqsv5XFk22BTE/Xw6VBFntaBPLiph5ti7IoOhTA/Xv6bPszk8aaAJ731cfubgbhNQEYdNdj35BMhq8I5MZtXRaYZ7BlfiC3u+gyQD8Tt4ZBBDfS5URmBrfCg9CdrcPAnHQa+gTh2E0Hm04ZTH8aRMLgWjG6lcbAi0EK1tRIY9KY4hTEhKpaqd6axuSpgUwo0uHouFR6zAikfZwOo1JTSbQPYvuYWtF7mMrZ5UEsf1gj4W9SWLA2CKPcGqnwTSFqeyBrCmvl3wHJNDihxHz8W16sSqFtajC36v8Wwy+pNOwWzIcFv2WNElOrE8IHk2pRJ6Vw6XMw8TW/pO3pZFbPCEaWVku/7GS2e4UwYekvWaKTTBdlPX5DtcSrk6hjFIKLZbWMqk7kctdg3vn8lomOSbxRB2EVUyMNjicxaXcgy4JrxWxoIp8Ve0TbWrHSS6RgURDDgmqk2COBOpcDmdm6Vt7v6EH780GUZ9bIqbEJNFkazNkev2XC7B68+CeY2i2/5cq6eGYMCya94rdEbo1ny5QgOpyqkX+OxOFWGITlrBpxs4injVIHSa6VNJce1P0aSFunWjmv2Je+BjD2Ta0YrEzg66sAUvV1mHu5B+Or/WnUV4dzzRK5bxXA//6nwzNNApv9/bH+okPVskS6DfIn2kCXrIAkFrYLIGuJDoWvE9n9IoAgUx20bZK5f1uJH6bDJJNkLtgFYHdSh8BpSezb7M88ZW+/xGQ+K7aOpy5LriWzTemx7orPhOUp7C/xp3W+LuWLkulh6M+ZC7pczU+hqb4/cwz06HYnGe0wP+511cNhawqeih0/SY/KyFRO4I+zrR5jn6VyZIcfK0/q8fRdCoeO+LLDQp8Temn0v+vLmFR9fkkq+bU++G3Qp7xjGn+E+DLrrD7nj6bR6YovTTbrs98wnX3Bvtg5G7BQnc7aen7seaTPppJ06tzzZXucAR07ZJC7xo9IQwOa6aYrM8WP5sn6jClORy/Sn16iT++KNHZq/el4SI8WHml0GOtPaoQeC++kYV/jT0FHPUq+p5JUN4Dy08o7OpHK2PMBjGmsi7ZeOpnHApi1Tpe06nQ6vlaw5YsuKVXp1O8YgOtqPWZtTmHt0wAcl+vQ61cyNl8CeJGmQ/8rGTSZ58+pI/pYncmk+zF/ZkQpZ1mYxekWARRNNICcLBxn+fOHgSHF3tmkn/Fn1zBD1A+ziVIwR+eeIXkPFDwZrJylwIjmFWouuvoTdcuY4uPZDLzkh2kjYzr7q9k61I+CN8Zoz6uJSPcjY40Jlc5qBhb6MmWiCVe/qmlxw5f/tHW49Y+ayZ98+GOlgu1LNbTr50vj9XXpuk1Dw9F+PJxXh5sJWra6+zHobl0C/9NiucWXx03qE6qTw44cPxyG1iOlWMuGy350nlCXpMs5jFfy8VlVj/PbcuiX48/o9Loc6K8lPtEfg451mGidS2E/P1qsqY/36Bz+DvNDx78+5bu09NXzxW1ffcJMtegu8+GAXn1SU7RcO+CNqrQ+A45qWVzkzarpDTjcXkvF0c5sPlKf0rMa/IZ5M1enPj/WaXDP7MzSB/U40V5D44betLevRz8bDf4fvIjSr8foeRq65nkh8+rxpYWWI396MbZffX5f0XAn2ZO5U+rh4Kjh8BVPmhTXxchTw2aFz1jn1cVqiZre7T35/LAOM5ar+a/Mg8RudfD+lY3txk6sqTTBpkqZEe89sFtlgmtNNv29PND6m/DHejUHFH7y53QTVIEaLrfz4JNS5zxfDXavPThgUJcjVzX8euWBzem6GN7TkLXInSmf63BOo+WyhQeLLetxM0lLfYXDbBxfj+hsLTV/Kbl9r6fMai0fpys5/68+1du0bHPwQuPYgN9ntews9uCFTX2uWuQwYog7U2/U42mBcncVbtzV1lX4q5Y9zd1YsKwu6/rkMEfcsN1Xjx5jcnjl2ZFA5bvH9XOoY9qR1o/qEDtFS8KmjhwdVYeq9VpeVXYg5YsJMwK0jI7vyI1/TeiUo6VsQQdKvxvzqVBDsndH6hUZM+qlhhIlflC1CR+CNXg96UjbK8Y4ddFg29+N0hgTFm5V8+xPNz4r/i23qRk+qCNOlUbsMFUz2MSN2d+MWDkhmzetOjLKxwjrXWpC4joQZm/Ebz8Nr9914NFXhf8o9oi0jlREG7NFqW3rrh3494kR+xZr6BvdnoMrDXm7REv03PZUHTFiaU8tVuYd+B5uzIYLWppVtsdlrzHmpjmsCu6A0S0TFg3M4UVue/LuGON7UanJgvaE5NTh6oQcrid3oKBNXVJ+5pB8uj0Gc5X+uZ3D58QONGhWT5kVuYytduVmdF369sjF7oEr9zaYMCk0j61+rnyIqcOVV7nE5bliUmbM1ta5NDnmSh9fY0I1ObSscuXrOCMO/sjB6R9XXjoq532Zy9B4V06NN+K1woVyY11JNzXksnceMe1dcTIypLN9TwxdXDmQZMSvF3m41nUl+psS00nheHVcab3HGNPzPRm814WquyZ0s+1J/lkXFgbVoXJcPqOKXJj7yISMmJ6cCHNF55UBL+fmscfelZr7+kwZkMv6SheM/tanoFcef/924UiiHj175zJxnQtuaXrUH59D0ngXnPbo8eqmlo7n2/Hyji7HI7V493Bh7A89Ag1yuKjjysVPCs8v0rDpjgunL+kzL0PDEn8XrvroM6xAQ8Wkdvwap8fRZWqSHyl2F31+Z6qZZNiOA4/0uPJIzd0fzoT3VuaRu4bEO85cr6fH9b/VTBnszB4F/w97aBji5czPv3Rpb6Ql9qszhiN0GfhRQ3iIM81e6pCUraFBdFum79HBz0tNTlpbHKz1SO+hJqaTE+O761Jcq8Yt3AlvtQ7B6zU8XeJEdv9aearEn7ShDXX8a2XKQw0BjZ3Y+ui33DXXErnTCT+Fn1QGaem2ug13jv6SpdOU/q9qzX3T37K8QsO5S61J6/RLVHFagr615pJDlQwz0zLMvjUrp/6UU8obfLGsNRt2/5DUfIXHvnHk7tnvsv+5ls35rfl5oVL+v7eX/8+RGodKuWSnpUM9RxqGfpdNir9mhwN2ERUSo+SzcKM9swu/yeTdGnzqOdBv0HdJXKhlhL8D/40vl7UKPmz1ceSe1Te5k5RDWGtH7pz6Ii9KtDQ0dqBl+hcxSs9BV9WaG0O+SfaWHPY1aM3b/l+l9GoOG3c60unkZ9lnl8u7ea0Jzfgi9R/k0PCKcpa8chm9N4cJnm1ItqyQOmW5OOe0oST3kyTPzOXEoNY8fvRRzK/n4t6utTJT30teVi7lpo7oV74Tqya52E5x5MLrj5KwK5c9Gx14UV0mJh65dDpqzyarNxLzXtEItfY4Z7yTbneV/K/bcX5GmdwpzKGHjz0hQW/lY1YOj8LtsCt+I4l7chTtZ0f19NeytG8Ok1xbKVheKpoqLdZmrRjc+Y0UP8xh5s5WeD95JTrHcuBdS27+eCn9++XQ/00Leu58KfbFOaRoWjDf7bl8is3Bel1zptu9kEdrczjRsznFChLuVvK3PtacxG9PxepEDpEPbRn55Kn0jcqhUZYtt11KJHFTDhobW741eCqnlHxuudrwx19PJPanln2Nbahd80y+6OVQ0dKaxVefyP6HWo59tmKY9rE4z9TyT2YzHm96KuFpWlzmW/H22ROprdWw6pgVFleeydEbGt6et+RO+FOp10dLkpkVDVc+loxIDberLJn2oEQaXlPztsqCv/c+k5D9ahLjLBhQ76lokxV8zrHgSMozeVCSzRUdC64YP5NLQWoabTbn5/PH8qqJmtdNzRnh+UgCNqv5qWfOFrOHUl2cxV+bzHBr90gGlWbR0s2Mj3EPZMeKTIzam7F6ygO5H5tFTbEpI/XvS//zWdzLNOXf3nflUfNsAh41pdPV29LkYSZ/G5pybs1taTc8izfjmrKy+y0Zl6dwqoKmpI65JXW+Z9IkvClZJ25I0D+Z6K1vypfLN2WwUyb2U5oizW/IsMJMjn9rwp4/r0nz6xlMHdSUlsnX5E1SBv3fNaWww3WZGprB/VNNKZarYnM5A+PQpmwackVOKZzwRHlTol9fkvlFGYw1asqMvcViqJPB8rdNKT9xQSZq0vnvjCnZJy5KqzHpvK1vRvSZc9LOKIM+H5ScH52V76fSSf9gyrU/zkiwZQbl75tS1uW0LFbid7xnypvL/8nDdhmYVjYl0+w/iXXOoOsRU3yKT8j7ehkcKjEjN+SkjO6Rwfh8Mw61K5LpCRmk9DZlsVuR3CaDx1+bciHrhOSNUPamNyX96HHxTs5goGL/bX9ShmkzGGLTFCeHUxK9IoPYOU0YknlSMidkMHJxU16ZHJOAORl4bjLFtu4xWbhDif+vsrftEbEYnUFdpSaWXsckzVxFbo0v363/kpG7Inju5cuf5xaL7sYI5V6CeG2/QmbrRlIwzo8GMxeIS2wGmwvMWTisSM5aZ6D6Zc7YpSfEaWc6fnoWOC39T7yV+nQ6bcbavFOSmp6Oq685EV3PyBPLdMwWWtA9+rTY703DaqQlvd+dktpNaUx4bUG42RmZ2T6NN90tsbI/I1nuqRTusORE9hmZ8yqF2aOsuGR+SrzrpdBgjiXxT8/KdftUovUtCVt3Tg6+TOXYPQsqis7Kok2p6PxrQR+T83IvN5W4JAvG9L0gfc3T0GlrocyW87LBWfluH3P6cFECQlMxumZO3vtimXZS0Qu9LHh18qJ0HZ2ClFrwr9sFefoumX/2W9Dco1gsFO38JdCSiIAL8v1HEj0bWtLNvFh2NkqmarMFNnaXhapkuinfpfKS5P+ZwsxAC2otL8mAWSlYlplTfvSyTN+VzCd7C64fvSIGvVKwm2aO6ZRrMl7RgCerzLm9+5r81CSzcos5/g1uyvoxSRxrY4H16evyOiyJthXmRNnckoSviqZeovhMvS2xxknsUc7S9/4dMe2qaFJfC0bcuSWZGxIxVDAh6vwN6bUzgcwtFjifvCHJyxOxW2GByz/XRO9gEj8UrEiaelUaNUmiW7EFtllXJKkigbyWlrhMuSJHqhLxdLIk2f2S+FclsG6AJccdLslYSVD0nSW3dC7L1ZAEHt60JG7WRfmZk8ja6ZZMn3xRbqYl0vSCJeH1zsuIHkns6mvJ9cILknEgif7KXTsnnRP3d4mMemvJKI8zkr42gXuVlniGnZGlCT3oHGjFtB1npOPyeC5HWJHS6pTcGxhP70VWBFmckUsj4xmzxgqV4zlJvhzH9G9WLFP851bE8fSQFd6XTskJlzgmeDTjyqBTUu9EHGHTrBiz/KQsGRJHXIAVp1sVicPzWLTKXsdGJ6SsPJZGis/W1ONyyCKOOm5WVI44Jv1HxNLyihVTjh2VQL042v+wpLr8iFzcEMvUhlZM33JYhtrEsv2hFSNvHJadit1Bya3eyIMSsCyW4dctmbnugPjZxVI6w4pPd/fJu3WxXD5hye+6+yQpMJblc6yom7lHRl9QfBT897uwW8LHxPLfUiuKbHfJ8NcxTBjSDKN/dkk391j+mdWMvnE7xGh8LGefNeNl6VZx0oljRNNm7LbcJs5KnLNe1lx/uVmad41lz3trpv/YLI4VMYy/Z82lEVvF7E0MzwusCXu3Tb6OjsGktw3/C98mFZdjeDHThsyELeLWL4YZC21ZNX6zvK8fi/q9DeeGbZIpF2IofGpLnmwUq5QYKu815/7lDRL7QIkzrDnL1q4X69UxPPFuwaAT6yTdJ4bFjVqil7NO1hRH41HWgnl7NojfoRgcjrRgseda+eAYy8drzWlzYK0cKorl5qPmjJq6WvIvxvL9vi2dlik+2bEMGWHLjq/r5a5y3o7vbLhnsF7yrsayc6cN7bw2SNjlWB42sKHz5Y3yUOmBbR42ytvbIMUr4vjR3IaT79fJ+oI4EgxtUfVfK28j4vnbyIYvXmulwZU4PrjZEv1ytezvGs++7TbM2r9advrEUXnHFj23NbK4czytoqw51ni9WB6OJv1VSzx6rROnIdFYXGiJm8EGGZkRTS9tS9xXbBQ33WgqwlsxW2ejvAmM5uiEVkx/vU7yD3Xnznw7hleslWvjuqPnaceRkg3iPiBa4eOtuFi+RvZZReN0zY7eCatl4ZDuPJ1nT/Do1dLtZxQhF+zxMlkrK5p2J6CNPUHj1sudFVE8/WjPhjPrpH5yFPcWOrDdea2E6nZnUmsHDndZLZ+nRqF/yoF6Vqul1R/duTjYgS4fV8rRGVGKNnSkS9hKufozkuGbHblhtUrsxkWi0681OkNWyv4+kay1as3mZatlR7GK05WtWTJijdT1jmRis9b07L5OhpyOpFTlSIvda0W7LpJB3RwxctsgK5wiadi2NeusN4rHQZWiM1rzV/v1MqBQhYVVG6xrN0oP10gWprXGii1yYGkkS3s48uHnJpm8PhLdPEfGX94q7bSRlHdsjcWdbVK3XiR3fdpwuGKbfDun4llMGzYqfct6FZfK23A7Z6uM1KiIau7EZOvNkhShYv/LNui02yA2HyMY/t6JNZ02ivrvCI4sbEtLj/USsyKC6tttedFmoyx7GsHdY21ZkrRZaqZGUGeLM9ecNsnfvSLYNtqZuKr1YjM4guXT2jG8ZpO8PRTBp5/ORM7aIq+mRbCwVtFE/bdI/nUlvpELZjO3ybyiCPrnu6I3aLs8r6ei/UwXChfvkOuNVJikuvJ3/51yM1bFrxOuvJbdMkGr4vkoF97u3iVLdqk4UOqCqeleabVJhXvb9uybtlccl6u427cDBvX3yQPDSA4tbM+kt/vlRYWKntUdmKk+ILaDI1lcvwMdZx6S9l0iWeLQkYX+hyS9fiRvXd0osT8kb5X4ZxVdP+HJftmoxDR+5kbw0APin6RCM8GNM+77pPVsFeqxHSmfuk8GKLVN++GOnhK/WbSKDcnuJJTtk19nlXyi3Pnc5pA03a5itr0H4VWH5I2XisONOnHe4KB07qkiOagTp/wPy8I6KubVdKLP9IMSdCmCvj88aT7hoHy9GcGh4Z506nNAjm6KwLrGk50j9svVyRE0fe2Ff/sDUke5LxvjzuzRHJLj/SLYM7czn7wPSvu8CMzcvdlZdEjWxkfwzN6brjEHpV+AYhd7oz1zUOb4RjB9rA/FYw/LcecIgjJ8ONJQydMmgv898WGM2SHRtolgTIgPzmsPSHaTCCJifNl744CsaBZB9gEfYor2S9eGEZx56EtNxX7p2yCCVwP8eNT4oPQwiyB2lS8R1w7JrPqKvcOPzDGH5YTyLfd//TFYe1CexkVwcE4ADZU4p0MjeHAmgF3mh+T0wAjmvwhkYeABiVBs/ZhACqr2SY+FEbS/EkiKMju2KlwuozCIZTH7JPxFBOU3g+nssU9GvVZ6zy2YC+/2yMB/I1jUPJgnL/fLuJ0RuFmE0G3MAQkaFMHEH0Ec8j0kE5XeHhUVQuXtQ1IxJAKLf0KosT8iaUoNdfKCmfKgUBI2RGDVX7DqfliWz4jg2Fqh18Ajcu+OUufxYPnysAxX8omaDcd1jspeJaZfkfAz75joKHf3cJHi8/SYeB9Q7m4OHF5RJA+Us5SXCgEVx2XzI+XdxYViu+y4vFPyn54fSuzmo/KmuYq5jcMonH1M6nZUUdo0jJqpRbJjiop9H8I4deWYRB1W3pFPOKlFR+RXpQrVwXASS47K4VmROE7rgoPvMVn9NpL9h7rQNqNQvgZF8axPVyTkqIweH4XbsK6c/XRYLl2Pon+DbmzIPCKPK6P4+1dXQqcfFrvw7rwZ0o1luYXyflh3bOO6sbLdIam8GcXm4V159vKgXHSKppVtBPNOHpRuL7qzRemhU7MKZey/0Sy/FoEq+bDc2RhNyvYIhnU6KBGdY2iVp+Lq5oOyqDQa38sRpAzZL+b9o8n7/x79tl9CpkXj0yqCl2b75OXKaAJrurHl4G5Js49huYJNbj/2yGu7aKbad2PB4V1yanN3DklXth7YKWddo/nnW1fKHXeI3ZZorK9242uHnXKvTQxj1in3jeK/PYZF4QqO39ghN9bE8KBAqa//bjnTSOEMH1Tsqd4petGxHFBwVn/BdiluFcsOz0iGROyRxRtiWKBgxKXWeyWwLAaXhpGsSt8nsYNi2DtGRZHufsktieFy60gGzjogw+7FUOIfydFehyVWOfvvRSqSLhdKu3nRbP8agafnUZGF0VxpoMKvjaKP3nWnV1IEFeuPyX/l3fnWMwImnpDIVdGsbKLgTsP/RBUXwzkFX1STT0no6WgaNlQxyuGMlNd0JzJb6cuUU+L5uzvFrhF0UZ2V1Y+iydofQYn1eVk6KYbeCq6FLzknBhNjyF2h3MUGhUMqPGfJFRVjGpyTBIXLLVHwUSfgjEwyiSN/cSQllacluyoWG7dI3pSck1+28Uw6FInJ7XPi7xLPsNRIvo1UOHBoHIlfVQzadlH+9oqntkZFzZdL0lYdx61DKi4MvCSFvj2o+aUi3+qq9BoeT/fTKo69uCIDrsdhvFnFqa+XZYFhHHu6qfjfmMuSXBhL7hwVo8OL5WRKLI23qTjZ9oLsvRJDg5oI/r5wUaL8YolZHsGqP67IsbA43pVE0M78mqxxime2gtdlOtckjHi8X0bQZN4Nmda3B7dSVWxaf0N8jXtwW6lnh/xrUvW1B3JJeWNR1+XSkwTsXymz0/aGbNuXgO1iFU3G3xSrqYlcUrB+8KKb8n5QEtPvqPgQdks8XybiP1iF147bYtMxmcaK/0TVHfmcqdgvVfQuuyUdnVPYr/RVwfFbclk/hWHHVDz0uiPbK1NoqdRhw7o7kueURpRyF9U378ivI6n8UN7L5mX35FV5GsvyVYrWvSd/LUlDX0eF6YAH8ufDdHZVRGBs8UDW5KZjOj8Cde1D6a7o7k3/i2Dc9IcSEZjBdAWXu3Z4LPlnM2iuYNOyQQ/kuyqT4oJuxDs8kaY6itb+qxvnxj8V+wbpxDlEcO3LY+mzOo28I914VfFU7uSkU59uLJ5fIvtTM2hp2Y0k7xJZ0SaDvBNdef7uufzjm8nNuV2ZcK1EWn7LwMm2G9tbPpPXtzPZu6crI549FS/XLOo1V3y6lohl0yxi9nbhk/sLcfqt5NamK9YmL+XN9kx8hndBFfNK4V1ZjNoXTsW3l3K0eRZv7oejs71UXp/LQuURzlR5LQl9ssm5HMaloaWyID+bk9lhSHqZaP9T4pcq66vLpGXjLC4VhLPwnzJ5tjOLmglhOOe+lZVHMil1D2fVuLcy510mvS6Gob/mnbTyyeKBaxhjDT7IApdsHm0PZVT795L9K4trWaGYtPko+1tlYb4xlMZhn8TaOZOQLmGMvvxRLoZnsuJhGNf3vpfdizKUORWG37MP0l+5i05/h2Gq+0mOnU7HwDAcT+OPEqNNZ92qMFrN/CRlXhlUtwqjeOhnuVs/nWGK/afqi7gGpaHdEsbzR59k8YE0xrQMZ0KnjzJpQiodXcMx9/ooPX+l0HNXGEbln6TvuVQOtwvj0OovMvp/KQqHDGPerS/yY2syDbeH4dr0s5Q2T6G0czgJzz9I2NEkzCzDGd7ioxhlJVG1IYzS3p9loXcy6R5Kzm2+ytf7iQz1Vep2+quURSu2ko/68Wd5cSmB4v+FsTHwq8wxT2CxcvZOfBZnowSezwgjZs9X2fI7nsMHwljT/KtETFXeWnIYlWbfpOWSBLKtwpjT/ZuotT2oPhbKRHWljDqbwOgBocwfXinXDidiodQ5oX6FfL2RROjBUHJafZOvs5I46hfKtUsV4jU3mWbeoYxIqZD7jZKJPQsXzlTK3XYpWG6DO2srpf7RFC67hNLLpkLqG6Wgs0+5u63lEh2Wit825U4LyqVjVSplzUPJqvgmUZpUYv6FrzMrZd3yNEJnQfzAShkdnM4gw1A+XPgmB+enMXd5KB4dy2VrnQy6jA2lyeGv8nGs0v8XIeX4N2lyNp15QyA4qlLcjmaQ0gXCvCslKSiDK9WCS8/v4h+byZEDwuyc73LqQiZv46G85JvMW6j07QpBulTK1wdZdPsifF37TcxOZzFD8RkRVi6PW2Sx/QiUVXyVZpGZJBuFEmZZLg++ZvKfZSjuL7/Iq8NZtD8HV0Z8kWD3LGaHhvLj4Gd5HpXJzkWheNb5IgNOZHHKMZThdz+J78Js3vyD0pefZNLtbK6+hyfNPsiM/6lxt4Bz3T/Kt0VqJvSBGI/30rAqG01mKG7qt/LGU0NOCxgU9Vb+9NLw73JhuvkHeXJJw4PmQoHje4VHabDbFcL4AR+l3E5DeXeB6E+yb5CaFzuEE0Wf5XZDDScdhBFnP8ugaRo2bQlh6YHPUl2uJv5jCHNGfhWT6xoO6oRQXvtVvrhoGfUrmNn9P8vcXlpGfgmmW+FH6bZNS8cBwQS8/CQxj7U06RvMgGYfZWvHHNQ7g9jU7bNMyM5hyp4gZuz/IG8Ncmi4Opj1bd+J/twc/JYFkVL5TvqdySG5XhBVcR9k9rscHn8KRO+fdzLVJZedzoGUffwgkyNzmfdHIOeUvf0NFFs/iNv2b2Tq0hw6XAuiX9kbeX4gh/RfQRSrX4uF5GB6MpgONmXSZb+WRktCcBpcJms/aMlRzvvrj1IJyNJSqhHcjpeKY6SWD+7CtdQy4aKGnsqf2l+vZYOHll+VIbx0eSsn/TU0/x/cjC2TiLVq1io9v967TOp4aJjxEIaeLJWixWoGrw8lLrRUSn+qab04FKNJL2XHVQ2m/cHe4ZX8NV7DYIWj+t96Li3qa/jzcShvFZy/Ml3NknFh9Dv1XD5XZyMrwqg9/lLsddScNQon1+iFLO6VTZ/14Zx9/1xMzmcx16kLAzu/kKeXlR4e2YVJz0tkSb9s9lh2YZxViZx7mcW6b10oOvxUOvzO5v6PcJ5nPJU/lJgNM8LJ214iF6ep+aMyjGYvnslSMw1xbcL4PLRE9lWo6fIyjALTp7JcqcmxKaHMsnwmWUrPfPpT4c+9H0uShYbCDuGc6P5Yfiv1CU8PZ/uFh3LZWkuDnaEURDwWqzQt+ltD6TPtodyZpsWoocLPSx9J+HEtr+qHcs/2oSR81uLTFs7MfyyX3HIY4glFxQ9kywBl/VsoO6bel8/LcvgzRaic9UCGDVJ8fIQuuo/F+3EOQQUhTI55JCOPK+udQhis/1TWOOdSNy0YQ/8n0t8kl6EdlP78o0RqVuUQaBzCq/0lck2Vw+a6gkfxU3nYIoeLtxT9YvBCChcrca4G8+DuC4l5k0Mf62AazH8hJadyGNMpGEtlhkZa5vJXQBBN2pbK5K65HHQOYmPKCxnRPxcXCSJ35jMZvVvJwTKQ5TXPZcGEXMa2CGTUzVfy5VYu99oF8O0vJc6PXFa2CiDy2gupa5rH3fH+5PNKzgfk8WaUP4dGv5Cm6Xncn+7Hc6dS+X0mj24Fvjh+eSUnluSxTe2LxYUyCb6ZR1GeD+P93sl/g/JoudCXj3feyY4LebRY4MPZkR8kWKcn4WofTjf6LJWr8zjn6kuRghVbN+ehGupLrOdnWfItj1s9fEkd/1Umh/XkWbwP1v2+yvC0ntic9kH7W8H2DT0pfO1Dj98V4mmVT6SBD5X/VUrnGfncCvQm4tB3OVGQT2igD+Ynf4hLST5ZV72x7Vgl6sG9WFrUma1tfkmTlF7sNffh6e5qMbzZi/h0b2pn/RaXz70YnNgZT2X9fH5vilZ1ZlK9WnnfuTfXA7zQ3KyWu6d7cWmfF5+Cf8n77b2ZoPJi9d0amdKoDzdXenK6oQ53qnvz9r4Xsd11sB3Sh00WXmxoqsv7F32wD/ZkZqUuFaEFDB7ciZ4/9EiMLmDnHk+03/W4u6OAD/c6UflNn5hDBcyz82JilT6+qgL2fvPiiKs+2c/64DTPi2uOeug/6kOf6515skaPs34FDK/szNgx+ozbXMCz/3VmaYgB+ukFGI31JtfWgCbv+lD02ZuLM/Wx0yq5PfJmW5Ieetl9eK7ry9w+yncj+mDxwJeYAgMiDPuw4pYvNev0sfnYm7bDfUmq0OPnYKU+yX5cC9cn831vwv38GGxuwJOrvem23Y/6HwwIaNCb0Un+9OhpQJ8Ovfm0yJ/ki4aM6deLW6YByjA24FtqLz6nBLAnz4jTB/Jx3B7AYC9Ddi/JZ9rjAPbZGuFunU+d+oEs6mvIpZc9+c8+kGRfIzLa9iSkeyD/+2HAqdd5qJMDiWhjRNDOPF6FB9KknjG2t3Pp0jOQbq2McH6SywC3QHK7GjOzUx5JPwNY4mHCxcm5tK0IwO6RMRX6uYxrEkijDsZU7c8huksg4m7E8fgcFhgG0v0/I6pPaHG0CaS+kRFRvbUsygzE86NylmsahikxWy0yJH+WllbnApizQcnTVMNrj0CcpxqwpauG2UsD8Vuij99yLXP3B3J7mz4GCoas/lOJU25AUFkOEbuUHIr0efktl+0TA1ErZ3zVOI+RUwOJOamPq0lPokMCqaPcS+i7nmz/FUBUPwMM9vSkw8cAJvTXR6x6Mt46kKATeri0zMNgcCBz8vX490EeB4wDmb9dlzn3cwntH8jvxzosP6dg2v1Axqt1edwmF59Dgbw7oofOKy2mynw0ztBj/Fotl9oGUWqvS+xbLX96BrG8kw4hHzUYDQ4iK12H5gc1TAgJYl62LjOfq9n6TxCPB+mwb7Ka2Igg7g7UZdtkDaO+B/J0tB6dPNWseBZIwTA9BgZloxMYxPF8XUK2Z2O0Q4k5TAeX3ln83hjEv8N1WKiXRWnrIP4QXaoCMhWMCmKOEt92USbLzYIVjVkrs0uyMGgRzMAWtTKzWRZ7lwfTYtRvafpfBjsWKrxix285l5bJ6TYh1K38JccMM0h1CGGGQ7XCXdNpMzKYrC2/5cuWNHyahPBMWR+Yls6xEyH03lYlL2pSmX8ghAWFVZK8M41EZabP7vpTAlJTaaHYb9N/ys65KfhsDqHV2SoxMEth/QghKO6nXMhPZsePEI5nV8l1uyRiKkI4c6dKskqSWLlK+Dflp3x7m8j/rgr7R/+UkPqJ/DwneLWokt1HEvCwFoZrfkl4SiJP/JS93tWyIDaB+qNCGNq3Whbd6YG9jcIlXv2SeHrwfEgIe19US5SjYucK/Ut+yWPlP9tjhDT3avmp6OvCnBButvwt1/rHEVAUTMTs3+LuF8feVyGkx1fLb2KxU/hYVn+lDptj8fkQxJDy32L6IZb4H4GMK6mRUY1iCe0QRJxfjayrH8uxiEDiL9XIO8M4un8NoOPEWrEwj2WEWwDnomvlSjNl/ZE/r4x0eGIdyw99f7bsrZXgjnH0WOMHSTpUmsQSddaXg3o6BD+IZVAvXzbO0GHz1xiu5vuwM0iHr3dicfhLmQvXlR5bFIv6H2+Ka3R4PzKO+EQfnNN1mTQkjn7NffHS0eVG/3jahCtzaoQuK8/G4ffWl5v3dNi4IR61rx/5jXR50SmeJgf9aLtDh1Hp8fTd7c/PHjosbttD0Xn+yBUdwnf0wCnMj+UaXcJ0Enn9tx8rJys43zOB9kd9eamnR8vliXT+6Uthaz2uZSaR/smPS/N0OfE0iSbefngH6bHTPQn9WF8yLupxe3kymRt8cbmrR+jxJC4v88EzT5/G9VLYcNkHvwn6XOmYzMy73uz/oU/J6BRa1vPh2x8GaFcms7WRNzvGGvDreQqLQ7w5Nd8AzwYpjAntzLxKA/aGprJkSGdc9A1ZoptGucYbwyIDEh+kcjzJhzRvA/rXSaeJmw9HTxlw7mgajeO8GV1rwEO3NKYf6Mw6U0Pc9NK5tqkzzpmGmKrTsZzjzQx3Qx7dT6e/8t1v8w2RjhkEdPRh5CBDunxPJ8DOlyvXDNh/UdHRyl2MG2xIyvkMOv7w5dwnA1aOy0RvmS+dlBlRb0omFUp9pvcyxHV+Jh3K/Nj3xoCeXopO9/Fj2h9GdH2YhVU9f0UjG1JSNxu9Xn6UHDUicH42L239ePinMdX3sthW6EvxH8Y0zMumbV9ftig4b7k/m8fnfZi0xISWh7KwW+PD5JnGhCVk8/6gN6ELTLD+Q025pQ/5CXUw2K2mt8IlDkhdZikaZ8Y6HxotqMvMLA25Fj50c6/HYwXTQo/5cMe6Hpf+UmM1szPa6Lr4K7z3mq03RyfUoZ/CsT9/9uLdtDocnq+mW5oXd9vXpbHCkyPPetIrpQ5PcrL5W1k/WWzCv9psigI82T/ThDq3lLPf8uRQcxNF/2fx5WMnfMqMcU7LYmeCJxMWGKPtkkVgQiemBBuzODKb6hoPTtcYM39BFhatPNjb0Jjy1Gze7XBncq4xK+uo+drBHf11xuwcmk2v6W7kPjPinqIfXR3cuXjaiBY5WXS1ccOkmxFNs7Po+6IDK8sMObUzi+N32nNZmXfGu7O59649vxYrsy8qm4Cm7dnSyhCi1GR1bk8jZaabH8ymX6QrBlsNaPBSTavurvQYY4Dbz2xOxLmwxcCAVnrZTBvhgstfBoxrnM0Zacf3lgbk+2fhuKUdExVekeydxYN2zrw8bUDemywirJ2JL9Pnxsxsdi9zZlW2PiZPs/lf33bsn6iP5kc2SZ2dGfyfMgezs3Gf05ZB7fWpvKholiQnUhQe1TEgm9kBTlzR12e3opcHJbeh1EYPVXUWo163JruDPoX/ZDE9vQ2rWhjw54osDtu15oDCeaKUPhxb5Yhekj4POmbj1ro1R2bqseZ9FgM7OHLTTJ8LoUp9rBw5YqtHl13ZGCg+7Qbr0l6p/3qXNrTw0CXeTU3a/NasXKHg2Gw1Ovlt8B2qw+7DajYkt2apWa30d9Lg98URk8fVMudfDQstW/M87peUdNHwXO3Irgm/xOq6mu4vHbh0oVp2umgI2OzA3cdVsvCdmqhD9vgtqJJ2/6opfmRPWEy13Oyh4VB7B5zyfsrENRre2TpSsuSnXA/U8KaLPd1Cf0j1TA21D+zw/Fwhc9toUGntaG75XRKuqmk51o5q45/ic1+Ntncr+h+slLdKPsO+teLWrApp46zhe0Arfq36JkY31ZQltaT74G9iE64h6UBLbhV9leOzNQQVt2L3qnK5sV+J37wV+aZfpMZcy+FcO34/+SLxN5V8ttgxsc43ceylJaCPPd9HfZX+87SsMLRnxerP0i42hywzB9ZafpKal1pWltgh4R/FZ4iiv/Lssc96Lwsu5bBhogNu8z5I9/U55FU64LP7k4Tb5XDvLzsia9/J4dtaqs63ovLgO4meq8X1XSuunvggfRVed6mwJdqyt9JgsxZLt5bENXsjW2q07GjZEmuv19LtucLrXjTn2bZXkqbs3dy9BT4Ny2T7QC25Oc0JaftaVttqmTSxucIz38gONy0HB9hy9mepHHqtQXeeLZnHy8T8Ly31P9mSseeVTB+rZVtTWzZdfynfzbQ8S7Ahascr8empZam/DQVPX8j//0Zpyl4blv/3XH6/0DLwrC0ej19IjaJ/t+y35mLAc6lS6rk3x5rDL1+IKljLrGPNcDlfIn2V+/3RqhmHj7+Qdf9oeBFljb17qUzbqsFklg1mvmViGaWhZKE116RMdrppKGtsw/92v5EzRWqq2lmTs/ON1G2pod2zZtjOey2TF6pxMm9Gv1OvJUvxf6ZtRqfmpfJXmZqVB61wXPBK5geqOdzGigJ1qZj+p+aNjhUTrF/Ku5psDoywpNrolexJU2Odb8nC/17I/XWKf54lq/Y9F5P72eS9sGBFzAtZ/Tybwz0tiJpcInYx2dxNt+DEjuey9YnyBj+ZU7u1RBLNs/Ebb86mgU9l4aNMwrPNuT7xmaz0y8JU35w+2U+kbXQ2l9uYs2LfY7HvnsnVpWa4Xn0kK8sz6PzVjOKqJ3KrNp3j680I8H0s+nvTGfzJjIWRT+XG/Az0w8zZXbdEbilcsbGfORGdS+TvSWl8qTJjYPpTeXYljZGFZuzr91gsjqay9Y4Z+mMey4+8VKY2NudLy6fy1jENuplT06FEPh5JIaS3OWl/P5PCcSkKLzfHKPWJhLxLwbnSjPlDH0sXpxRyzM051ueR2H1PIeGhGW+PPhQ3mxTO1zHHyfSBWPkkUxKn7C17IMsVOzvVHL1696SDVwoNjc3J07snu1ulMumUGX/G3ZeR11PY+cSMyto7cuxHMpe8zdm/+bZ8qZNK+2dm3Hp9S+xyUugXaM4EbspEP4X3fjZjV8IN8W+URvfRZqx2vCVxZamYzDRjdse7sqljOqnmZuQH3ZHklum0izFjY4P7cscjjdo/zfiw777sKU8lZqsZY6c9lPMm6bhONMMw86H84ZehYLIZv6ofSHGPDBrqmFGw7J6Ux2Uy6Kopry/cE7mXQf42U+quuiup6zK5PNaUftPvyr7bGXzobUpGozsSfyyD841MaXz4ppS8SafTClNeHbglmsJ0xowwpW2HG+JRnYabEn9sp5tio5vO3jJTRj69Jp8XpfOtpymne12VFoouyA0y48DCK+Ik6dgfN8Xtj8tyV+FLTYaZUVNcLL9fp9F2rxlH0i/I/cVpVE80xzn6vETrK73RwpzN+efEalMat1wsGJl9VtwN0gjQU+6o4pK0fZNKwTUzHulelbbt0hig1HN5m+uyTOmTvYbmfPK7JsfDU2mUYo5f2hUxc89gjZLD2313ZH9WEv5LzDFLui8/kxNpqPR/uOq+XOiSRP5ac5qvfSh/hycytULpq5aP5HFyAlOCLKgf8kBkQAKHwy2orn9PKsf1YPBKC6za3ZNsrwTWTLagz4Xb0tMwkT8cLDj38Y5U5vTg6kULcurfEbu+PRhaY0Fq1U1ZPDRe0TeW7HC/Ja+WxhNlacnegXekx9U4Vs61ZOz/bktJURwlzy052fam/Hc/nunDFVv/hkhmPHpfLLnT/pp8C+lB6TxL8oqvivn3HkS2sWTpq2uSeCGBM8rbf73umuh87kH2QEse7bkiE7x7sLvUkhs9LsvmH3Gc72+FRueK+I9XYir2jK7FUjQvju9Prch0uCTH7sQx4ZEVWdEXJahFHL1jm+E496LM2BRHn8bN2B1yXuokx/NsgxXe7hekqlMPloZbMfzzeRkT04MLllaY1CuWce0SGGJsRf6ec7L4YyyrFzYjY8R5Gdk4Ds+RzQiJPyvDesfyuL41w6POybQBseSXN+P73tOy+34Md9dZM/HRGbl8M4b9k63ZGHJKSlJiMTjXTOm/k9KzVSwN1jUj3KNInh2IQZ1njXrfCen2bwz7sObvGcdl7d0Y/j7UjKFtj8mXmBjODbPGPfKo7DkVg/Mc5SzlhXItLIYHIcp6/GEpfRJN51Y2pHQolI8Po/nXyAb/cQdlRFAMW12sMV58QPo8juagsQ1jTu2T88ren+7WTCvZK+lvo9nlZEOI7h5Zmh2DUbw1um67xaBuDN5jbPhSsUM+L4shsp81wXt2SFZpNNX/2tLMdJt4b4jm21BbxHWH5P0dTUprWxZ03SWXMqL50KQ5P5fsENcp0cyxac6uN9skNCya49XNWRK5TQwXRGP9Z3NKs7bK2sHRDOncAoPQLbK3bTQuNi1ZuGezHH7VnVzDlvzuu00ylTiPtrdg1JZN0vtONOdONycvcbPs3dKdEu9WzLqyWY507c4kNzvlzW6S8d7dKfjVilY6W2VpWRRrbtlR2W2z1GvcnW+X7Vg9eqN4rIii7TJ77rTYKG1HRhGwUuFRJZvle5MoGg914HntRnniFIXPZAcO9l0v7iZRbBrjwOf/tohJ3yh6rLfnj53bpOymEueMHX2Lt8qs4ig8D9uR++8Oudc7iitH7dn6ZKfsrBvFhcUO2MzbLmMaRjHohIPS9zsl3juKev9zoMvyPfKuNJK3qY5c+rpL/A5GMvkvhXNu3CF9l0Ui6a0Zb79b3uRFMnxca+Yt2yGNuyi2Yxu6T98pZ3UiGeLvxNM1O8X1iApXnDhnvl1s1qnYV+WE1+ftsjRJxfNqJyyGbJVKrYpzRs6MvLZdzjVUYWXjzJK/toqLjQqPMiecwjdLo7oq1r92ZtaObVIRpqIgvx0ZD3bI/o0qHPKcaTRylzxYomJEz3Zcdtotpw+pOP+iHVUr9sj0UhXFx52502GvDNGNZMS1dnxusl8i9COx9HFlwcT9YhQZSVmQC3svH5Ts9Eim/uNK7M+D8miFUod1LtTkFYrzrkj2vHCluOawNC1WfDa251xaofQvi0S3RXsaJByR/TWRnHqmrBselZBTkbzL7EC0plDuKfVsd7EDZ3cckbZzI9md05HzLQrl4sNIjk3vSEbXo1KaGMn9Pm6UdSoUy+WRNF/lxtz0oxJoFcmbQe7cmFgoNhmRXN7gzsedR6XiiopTMzwIPlcoi5pF4rrZgzoOx2TdVhWXsjsRtO6IrLRT4ZbtSeL8w7I4W8WD4Z50KD8iNp8ieDjOi35/FkrWvQiKPL3oXXlI3J1UjO7nxawBR6XobQQdBnRmz8qj8ufaCMYp2vNjeKG8+TOC8rHe5Lc5IumnIth42Zubx45Jw84qxr3szNMlRTJSX4XlXW+8txTJ3ZsR+Cu6eNv4InkzJQKXRz48VR2T9iMjeH7Pl8iDx+S6bwTM9GVGxBF50CuCpn19ePjsiHx2/78Orjqs6q3pSreAKGDRSDccumZJnd8JulMF7G69Xrv76rVbsfXaLaEiNqgISkunCIK0336///Yzz47Ze2bWrHXgHD6UPzMN/voRXbXkY/VHD2yof0B5dnzsUfZE6rjHBF8+jvd4olT8kIbC+FDP8UL/f/dpViQfDsbeOLPvIZmm8lG60htPah7T1bl8jCz0wc0ZT2jmImZv98Xklsf0fjMfsyp8UWyTSUnX+diUSUjNzCJxAR/JW4DqMdkkZG/iYAok7s+hmdIc5H4BXgY5ZP6TjyduE6G1PovagjnkV01ElEkOjTjOYXKdHy7szaJ5LN9CX/jDenwm7dIU4MRlf7x4nU1v9wrgtyEAa5ZlUZSxEOfjAzFTJpOeWQtROjEQy1Vy6PNjIaRGBOHD8iz6+4kQN7SCMCLnCUWFiKCVGYQp2pmUKhbh5MUgKCx8TFYxImg+DYLMx2yKSRah4XoQFsU8pzaGCaMUg+Dj+oyaKoSItwhCqdsLcg4TIWldEG745JLXBRGOzArC+vg8OhMnxjVFPg6Mf0VeY8X4NzkI0VmvaVmKCM/nB+JJ9mvirMV4UhQI/b63ZLJUzLhMEKq83lLgMzHkW4OQ8fcbWvpDjMXMLj3iPanNCYaOKR+aLu+oNigYOfP5+LzuDfH7xLizgI9Gvdf0LiMY6fuYPfQtlbQHQ1wQhLf++aSWFQI5lh9VJ/Pp9AjWZ9X4mDT4kU5NDcWD3Sz2PwqI9y0Ujiy3dDd+IrO1YVA7wIfO4c/0Li0c8l/5WGxaSIKhMDis4GOE6ReadyUcmTv56Dcqot1LIjD/OYt3ahHNOxSBXgsOvEWF1Pk4EhUsxrrmxZQqE40haw4HHIppem0Ulrziw9HhG9krxuBzAx/XI77R64gYjGH1JmldTPuDGSfv5+PU4m+0rSUG7sxPqcRSGm0bh2/7+TgSXko3c2ORZcHHQs9yGrUiBtImfEhbltP1m9HQWMfWGpaS44hoTB/Lx8mTZWT6NAoBzH/5CyX0dnQUJp3kY7PoG6m2RGKmkI9jGSXkbxOJXdv40N/1lVq9I6A+jw/FK8WkfTYCIzT5+FjxjVaHh2Mri0WTczH9mBOODceDwC/4RoMnIhCxKQg508oo7HUkhKVBCNpQRlbvonD7cBDqH1bQOZUYXLsfhGvDKmnUjWgUTAxCzBemL1pjkBAZhGMS38ljawyu1AaC976avNgdY1oDca+gmnZZx+EJm/OqqYo0o2MRkhMEA8NKMpSMx5bKQJRuraa2I3HwWRaIfWtrqaw+HieDA2FlUEvVnxIw51sArB7Vkp0oAfsLAvDgZR1NsU1EUUAAGoT1DMcS8GV2ALi5DdQrn4gVH/zRvrKRQlviEVbvD79LTdTDeLjGtgB8lGokwW6mL0YFYEtNEzl6xuPtZn9c391CyaEJiA30x529LTRdKQ4HTvsj+1ALDQwl4OJkfyT6N9OtdYlYrumPuq3NtDwsFpPHByCroon2lcRg7QV/jJ7TQqXN0VC95g8dmRbiWTJtpcrOvdxEaRHRMGr0R29WEyUrRkM9LQCmuxron6lRGKrwR6RZE1mrRWPpFn9kGrRQWlYkbizxR8mVZhKtisT19wxDtjWS5tVIZJsHYOHIBoorj8Ccn/64ptNAs1ZEoFUQgK6fteTRFQ7pMn/MiKmnEZcjkH/OH/e3NlJNSji2bfdHWV4DjVIMh5hhlOqSOvqH8eRrzM/NY2tJa2UY5L+xOY01tNkzDH2jAyBu/E49n0LR8cofMf3VdCc9FCNK/DG49DtVcKH4o8nWnq6k7lchwDN/KKVXkVlyCOyK/XFVXEFqP0JQPC8Ao3eW0VzzMCzaF4CUyEqyrAjF95YAlGmVk8nWMFTIBSI4uoKSZ7JaTgxE4IUy+jwlFHusA3H4dAmluIbh2OdADASW0LzIcPgxLNpaXEaf5MMRah+E4I8lVHEvHMsCg5BVX0qnt4chXxiE+57fKCggDKNOBEGT1XV8TSguGAdBz+IrXZsfinB3lvM7iuhecCgUDwTh67lCevg+BE7Dg7DJlWlYUQhSBQwztzNNx/yvZ3VUdLiQHkuHIGZWIK6XFRJPOxTVFwJx8F4xTY0LQcG4QPy1opgufAxBpV0gzrz9SkNbQ7DybQCurv9Gt/uD8dwjAIPDS+hJdTAyjgVgd0ExjWgIhvqvAFyaVUS5DD9PZARg4oMv9NguGLZd/rDpKKaNj8WYpRWAZdWFlB0tRku4PzKOF9GafYzr6vjjok4JrfoiwoEDfnis/ZUkm0ToXeeH3aEl9NVIjPzrfvCcWkrzJjEcLvJDZncZbYoOxq1p/pBzKKeI6cGIus/y+VwJzfkTjMUt/vgztoyWDAvBmxX+2OJeRaceiLFU0h89EVX0vj4YnSJ/jC+ppp7+EBQe8IfRv9WUwMaH0v2Rxq+jkePDYHiU5YNOHZnrh2Fiqj/Ofm2gJqa5+jl/mE1ppq2zIrAx2h9LDzVTrmoE9Az8cXBHKykERaJVzh+BaW2UrcF0Jbtj0LtW+lEYhqQ+P/Byf9CUjlBIjPFHZ10r8auYNmzwQx3XTh4fQ3HpnB9MD3TQs31hcIr1Q9bkX6R0MBQ6QX64uvQXWZmF4XPnRNRLd5OrRRg+iifi+cgeumYWiu6LE9Hl0E3LHEPxWXMiNsb20KhzoVh9D9hc1EsuLMe0/gG6NftoXzfTjEbASON+irnFNGw7wU/UTx/+DoXvQ2KY3E9TKkIQ9IZQLtNPbvwQjNQhXBvXT387hmB2L6F+fS8ZvQjG+wjCgcJemnc+GL9yCCkXe+jT/7SVFWHfpR4yEgbjYR9hoLabJp4Xw8eZYPRPNyUcFSPYwRfp33qItzUYH/b4QnZTHznYB8PvhA8ORvXTjONi/LXAB6XL+ujUyWAcqfDGNrlB8t8mRmcG41E7+6nQhO0j8ME/u3opd48IczN8UKv2m66wXAo/7AuV7C7q7xbi0ikfTAzvIvtBIWLFvpjxvJNEW0UYVGH+L+ykD2oitHT74t+kDkrfzLRMjS+67X+S7xgRbA8SlJR+0grGhdJPEEQ32+h0mRBLzYHc4B90ZpcQBe8BpbmttPy6AAlzgfRXzTRdQYgz0RPhpNlMh1cxDaI2EZMcGklXX4At1sA4XhM96+ZQFQ4MMWx0zuZweDZBq6qRug9zWL+UsIirp5mSAlROB1YeraXzEQL0sH2Cv9eROuP/E5ImwnZPDfX6C5CyFkgu+k5NGRxeJRAO+tXQQC+HfVcJWf5VdOScAA93AyWvK+jlgACFIRNx/lYV1TgK0Ro0ESq9FfQmRohsh4nQ8CunrnoBrq8BXkqxPjtPgEksjsfrWa+3EOBtNoEvqqBXCgLc4xFaH5eRfRHTO2aEyoIKKr7EAVt8YalTQbv+4nBjqi+S8qpo3BQO5fN9oD21glTdOGyZ4IPnCt9pryXjqEIf7LSoIRUhh/tu7P0v1ZBmCIfpc32h9rWOTk7ncHa5LxSXNtJoGw7jp/og17aR1ugzHRfrgzvn66hQlYOyjzdmqDTSfSUOWq7eeDG/joxGcfCx8cbTxmpKYlqgTMYLP4R1lMPmHJTywvQz1aRlwuEfO2/ERVXRDk0OccO8ENNeSTGuHMzNvFF6opyO6nIo7fREM+NFXRM52Ep6w769hDZM4NBb6Qmz8yUkGcTmv/HC/ZyvNMeOg0m1JzrVv9II5n8o4/+Bo4uo1YNDV4MnHoZ9IdO5HLYP88Y/Kp/JjJg/FZ7YtOETeTD7yw4vTPMtoJvM7lnlibZ7+fRrKododm7Gkvf0gu2T0+UJjc/v6EwEh2Mib0iL3tAoKw6Z7F7ODa9pMfNtvpM3HoTnUSN7h8ZeT1SMy6NsxgHvj/CGVOYLyujlo6HGE4YrX9CwD3xE93phKPwZ2TGtVPzME15DOVTONNe+PC8c1cymyFN8uO72hMTxLNJn3PbZRi+45D5lvJePVJEn1kQ+JavLzB7mgb/jsqi/nI9t2zzQcjeHjjPeqpHkjgvJObTiER9DWu4wVsqiObP5CFH3QNeIpwQ1DmJbN/Sp5lC9FwfVWhdUnMgmDXb3wXRXOK1+/v/fNzm/xQ3Wls8pL4XpcVM3bJd+SdvHsDkr3aFS/JzGsDmjtrkzPv2S6lncda574LjzC5qhzeriuQeSKl6Snj175+PuWBX/mjyZPh353gNKZ17TG/aGh465I9L+HTWyN/z9ygNDy97RAjZW3esOkXo+TWE5o5rpgRUR+bR8PNP+W9xh2/yRbIxZrt73gMDkE6WyNw/Z6I68e4WkxHK194EHvrcW0muWq7LMnrK8mG6O5fDhkQckGB+epszqaIM7pjmXkCzLw1xml08sofWKHK6vd0dqRxn9rc70LDtXRamcXBU4zGb24OuV5K/CIYndS5xVSe1yHOqYffHsapKQ5+Dw0gPeK6vJhtnvbXKHi3kdzWZvUp7ngUBeHY1m+8zc5Y6G4gY6xuzz33pgYX0DWTJduUvBC16/G0iJ+Xy9wANN25ppCfNNRdkLlSeaKYnVYw+x+rrbTMdZrs5T9cJw7zbSn880vpc3Ji5so64kDjfTfDDsQzO1XmOxi/HBVss2mviYw4yZvnDxaaEVLgIcSWUSelIL/cc06b5LvkwztFL3VgFe5vki92UbqUoJkfbNF6t6f9D83wJkjfTF/Sk/6ayRAKW/fZAv/4NohgBjelm/+PKT+voYDvj7wOr5D6ruFsCcnav7q4MKFwhhttUHzdK/6OtnIQL+eGNzZDe5jRHC55E3zp/4RXeXMt26xhuSvr20aD3TvD1eGJH+m9QVRNh/2wtTtvVSyCQRxhd7IYQBJI/xmaxsLzxc2U9hs8X4WOCF2zsGSGwcDIfXrHY2DdKXIDHkGP4U9Q/QGLNgPDvoifjgITrPOFJBoQfsjw7SGetgmE3zgPGTIVKPFUPmJMuHskFab8F4l7M7LHqGaFqaGBO3ueEv9SH6oByMil5XWA//Qz+6RFDkXKG0ZpC8KsQY9p8LZI3/kP/GYLwtdsbX0GF4e0uMe9edMcH+D00fL4ZarzMSJIfI1FeMy3rO4DYPkfxeEeb95mGC/iAdYnwsiceD+MoQabz733dgeZj+/A9dey1G4QUnXHUdhuHKYsRKOuGo+h+6vVKEizeccE40SGapImxZ5Ijj2wbpVLcI5w44QLfoD0UfEcNmDrMvGYaJ18Ww9nfAoKkEfBzFGLfIHhKVw2BwmGn5xfYwWC+Bc6MZNxDYoyRdEk9jgtG1ygFuvRIYVAvGeh1HtLhIYP/+YBjMd8TRRxI4aRmM+y2OyPw9DB1pwUi66ITalmE4eyUYsTwnzFooAd+eYFzodYLkUgnMXhKMuE3sXleHIS01hHF1Z3xPk8C8SyFQdORhnrkkEkNC0K7qhK0RkjCUD8W62044VSCJ5UahsBPysPW0JOYHhuKOjDPWpkpixO1QmATzcMxECmkyYSj1dkZHlyQ+5Ici864zfmyTRNeMUJg7uCC0TgJWoWFYHOqCMwfYnpZhKHjuDKvPkriaEYaNuc5IN5TCBftwCDa6QKQgBaXGMPgouqJ9uyS0KQzpFq4YJiOJTePCMTrTFXb2klj5IhxH4lzR9koSlxrCkaXhBu0oSSQvD4fcPDfEVUugsigCjnJu2HlNEiN3RaDS0xXjraWg3xeOhw9dkCGQgkFmBH4dcsHpU1L4xbSe9QxXuHNS6K1jevyyCxxLpdDdFIFVp5xx3UsaXWFRCP/ujPxp0ni9OxLaXTzofpaG5KsodI53RmCzNKo6I3HcjofJwTJ4y4tGuICHzykyiI+OwqlYJ4heyeDShWhEpjhh+UcZjHsWhS8LHbHeUxbHlGJgEOeITR6yeDwmFhacE6w/y2Di5hhUpvPwV5oM9Jpjsfc6D3/PlMHCoDj8Ou+EJ1kysPOOw8pgR5xQlMXBUbGYNcERpxxk0bYxFvfnO+BdlCxWusVh8xgHTODLQrAnFsPi7fHXWVlUbI2DdKQ9mpNkMX5FHKqi7NB/WBZhpvF4XmIHR4EsNi6PR9x3W6jHyOKv1jjk8Gxhc00Ws1picW2yLVJ05PCA6f3zNda43CGLb5Jsz4k2WLhQDtGJsdAotMGZE3L4kBSLpZ3WePZLDlxgHF6bWuPnBTnc3xkL/1NWeDZVHqYrYxD2zBqLt8rj+8MY3HhthdEt8uhSj0GarzVWKymwvIuB1hwrXJmhgAyPWMjctYS2jQJqj8XgicgS6FFA085ovNaxQvqgAo7WRyPP1hIHdyoitywK3fctwe1XxNjwaKR+tcBZSyXUzIqBtqsFCvSUsOdeNJRHW6D0uRIyhDE4+sYcP58oQTo7BsFLzLHqqRL+MohB3hRzJEUr46RuLAxvmqFlujJmbovFgK85dusqsRyMwyIyw4wOJSRXx0JcbIojbcr4RyMWtzXM0LFaBb81YjDnqhkGElTgFRqD03JmOBkwHPuHojAs1QwhS4djrk40Tvwyw77tKihdGo0ZPua43aWMuowo3JpvDhkNFRi7RSFGzhx/XqngxNFIiA6aw8ZMBbm6kQjRM4dGuQoO50Ti2WUzhC0ajn/vRqLAygwm8aroexgBxQwz5J0dDpfECMxg9shNqki0joTlc1PMTVXDU4coHL1vCm8nNezXicLWaFOY2ahjqmc0ymebQjNWDTtfR6GnxhTLd6hClBuNNrY2xkUV8mtiEMU3heC+KiKvxGDGYVOcKBqOBVqxmHqLzXEfjmtrYlHjbYrqx8OhnxGL8P2mkPyggrNz4pA72hSZ11Rw/EYc9i82xSihMp4mxUPrXxPENytj79p4zOo3geZUJaw9y/LK3AyNckp4xo/HqdemuCFUxJRvcdiQboZP7oqoDYvDUhajBCVFTL8Ui4aP5mgMVkQhqx1xsAV8Fyni/aYYXH5hAbcNisC+WFittcDpLAW8pTgc9LDAAnsFpLyJxahmC1y3U8Bk7Tj85WaJo9flkXI+Duksx/rr5fDQIB7y3y2Q/0YOBb/iUO9gAfcUebi9j0N7qjnLSwVwafF4/dUMsu/ksS43Hq8CzSHF1gb+HY+HkRbYxWpEi93xldgSO/zkoKkej8+rrTAyUA61VfG4udIKK6/I4r1TAgbJElPOy2KuXgIcWA6L1eWgkZ8Ak38sMJbhTOjzBBjXW0JLXxb31yfiGGeJBf/I4NSJRByqtILMeRkM8pOQ3GCJM6NlwN+ZhF3vrfDEWQYf3yYy3WGDhJcyaPycgJPGNqiTl4XSiQTYDFlhxgRZ5MkmoO+kNeZMl0Xgm3gcv2WDwlRZrF6cANMttlAxksW51Yl44WaL0iEZlJokYsJxOwjNZeE3LAHXntmhlI33LEvA1ef2mGUhi9d+iVj40B45Yll86k/E1Ah7jF8pi8pnzOfJDuCx+yoMS8TgcQeExsviENs/y88RgtuyiP2agJc3HEFzZLHFLAGTWh1gZykLK7945Co5QNNUFpaJ8chg2FukxPw3jscfhs+Pm2QQpZAAKW0nDBjKgvcjHrY+POxUkIWTfDy2beTh638y6Poej70pzrhcKIOj9xLQqeEMKeZD5YMEpHAuSGFrR8xPRNgbZ/QVyGICG2/f64Ja5vOyxYmoXPy//3eVRd2YJCzd7gLdIDnkT0hCUpIbivewuz9MwqgsF8yokwNlJuH9gDPqNeRxwSAJ9cnOWLxaDpl/JSLjHA+VDHv1nJKwyZsHqT1yuJWXhC01PLhYy2PwdCLOxDihs08W414mILPCCVqLZTGYlIwZa52xvEAeOZ1J6A+xwuVqaYjZG/pUmmPyYRksYG+oMtIcu3bLYvemRBSuNoP8Q9bLehIxvt4UEfoyaD2eiLwQU6yrkYGBdSI+3TCF/wlZaM9MhO0rExifloXanURcTjRBD+tNwSOSsPGiCap8WI+jJMRjAha6ysCwJhHvuQkYXCGLBf8mQbPCFEaW0lihl4Qzf4ywfKYs7tYlwu2nEdJZTeX9l4iNncaYekkOZhpJyH5uiLnn5GDazPLqiyE8OuXRP5iItgcGkC+Tx53SRCzOM4CisSKmsXFHjT4WfVWAN9un5Zg+io2UGA4mMu6qh6BxiuhtTITUOX3Ef5LHqOuJMD2gh0v35NEgTMSFV7oozFbAtuBE/Dmti6pUeWjdTcT32XpoSZNDFHuf2Pn6uLZfDn7SSeiDPoziZPHWJgmSsQbwnyyLXq0k3N5rgGUn5ZDumcT0hyHiwmQx8L//n/c0xJYOaTyfnYT0EiP8+SmNv68koSrGCLxqKdRcZ3PCjfGrRApPO5JQ9scQgzmSUD+fBMVIQxjdYzztf99VrDVARh/jVGyftaMMIPNTCvybSXg23gDtpyTxJTYJPl16UDoiiYX5SVDJ1seLbAmoqCfDpsYA999I4EFUMnSPGWD+rWFwG52MzLPsXgeHoXFrMhQOGWLM02G4yU9Gk5YRdG5LwO50Mg4WG0FCSwJ7fyejYjaLncYw2IxKwd8HjaE0ZRjGpadg9hhjXK8eonx+ClyZ/wfkh2jqlBSkvDeA2dN++ks1BXwJQ4wqGaQNSSm4OkMf6/x7iUanQPGePrKS+6mrJRl3JhhgqvkgPT6ajLWj9cF/N0AFP5JxtVwPEWv6aO35ZKzr1IVbcS+F2yVDuUgXEiMGKILtE7pUD9sf91Bmcgq+TtTDhkfdpNqRDHqki/Gvf5OCVgo+x+hCW72bZu5LxuUyHWyL+U1D1cn474wO+t27qCmOnVs8HlVzuugqu6+ZlQ56T3fSlbQUxIzThWl+J2VfSkF4ng4OnvxJKkiBzrPx0HH4Se/6U1B9Thd7mn/Sd0zCglW6+Lv9ByX0pCByvw4u7/tBNxdMQquFLpZZt1Hef5Mw01APsdVtNDRpEnY56OHvknZqNp6M50J9vHnbRim6k7E6RA8+p1vIbu5k/HLVR97TFpommIztN3XxEk1k8H4SQpV1ofyjmZ4fn4RC5o/UqSaKFU2CiZMOsjVaaZn1JDQFjkfIYDO1v0zBylnjkTW2jcbksdiFjINTdTPNjpqEuwXj0JbcRGoKKZiRMg5xv9tIqy8ZXXZjEbO9hUp7kvHRdwyWxzTRC5ZLtR5j8CmihTQDkuGbOQYNea3UcikJMvmjGaa20NHNSTgUNgaFf7WRPctDu6zR8KxqpsjEZEg/HQ2ZnibaepVhZtRo/ElsppLVyfgcMBrSgw3kF5PE+II2/LMaaZxEMnZe0sa79AbSmZuMK4e00aVYTxG7krDdh43z6mm+WjLiJLRx+kotmW9NwvpELWir1tDJVwyvLmkh42wdHYhKhKeVFtrka0knKRHRzzUR3fydNG0TENagiRn/1dB73QTkbNDEldvf6almPP7ZpYki3WoaWxSLhHOa0HCoplGMh/CaNeGnW0uPb8ciYkgT1yfWkjHjG0XFmlgVU03LU6Lx4K4mi0UlyS2Ohs80TXR8KaPf/lG4xM41oXIysYvCdbY26XIlLRNGYqOyFsRry8kmNQLRvlqQKiulz2ciIBmohaLf5fTvlXCY7NPCEv9yEs0Nx/vdWvjmUkIT/wvDlSItOMWX0oP4MCixd1h5/SuNZlqvxlMbTz1KqW1nGJYNaTFeUU4XD4ZCe5I2WqvK6dTXEHje04YwpIxWNYTA+7w2bOxLyMIgBKuDRmP8phLyfBaC76Xa8DL4SpfT2Z7p2njU9ZVc94diaKk2ap8VUe6XELwdNxpWSl/ovFwIdNePxoyZxTRKIgSf7rGYJnyh3QuCMdlpDFqpiAYuBaPXbgxGpxRSsWYwuuXHQlO5kJyeBGPF3DE4Nv8TWYiDUec7FqaDBaSdJ4a4dywG732kHQfEsPvJxv9+pqItYgxcGovufV/IkMRY/+847BlZSF0zxejZNw6Jfp8o2kCMXfvHo2f2R9pbKYLzwfFICy6kkavE6P0+DuvcC2iGH1v7mdXyyQ9kNiiCYpEO6t5+oGvpYnzIG49dH97RR1MxVr/TgXnlW3JqEGFQSQ8u9u+ooF+EKbJ6OJTymrLtxagd0IHks1eUwOyKQ7q4efrl/9v9BnWQ2JdLgnYR9L/rol7+BVmYi5ne1UGw93P6ViJCSa4uBubl0LaxYpy+p4OLUdk0L08Epcu68HLMIo16EVar6mJ1z1OqPyDCIjk9KDx6Qk8qREjo0MGjC49pxS4R7tbqouvMQ3rxTYTNlTpIffuAfmwWIadHF2+X3KPochHOFeqg8cddOnBMhO35urhw7jYVsntJ5evgpuVtWnNFhL0fdTGx8wZt+y1CfwnDvaU36HSWCO11ush0uU4H1cVIY+d+KLxGMetFSO/Vw5uOK7R+jgg2RXrIzrlOT0xEcCjSR9ydq6SqK4LOE30sW/IfPZ0kQvxzhu3zb1LNOBGKT+ojdswt8o4SISJHDyHVt+mdngiLl+nj/oQ7JDtRhPJWPVQfvksLh4tQdFEfY8vv0olSIeanG+DgrNskfiMEnTDAuDH3qHebEPkrDPGi7Ta17BXidYwh6o7dJIUCIWwOGyB78Q2SDRZCLdEII9bfIUtFIfixxvAsvE0PGwXYv8MYfgdukv9rAe4aTsDkLbfo/U4BmgxNsOrPLXoSyezTTDAz8gad9RLAXs8UP+Jv0mYJAb4IzWBsepPannCwTzPD9ePXaZmFAINnzOCteYc26gnw13Fz6D66Q+oiAf4Um+H41nv03E+AF33muHnvHvUvEEBzhDnOFz+g6DUCKAVaYCk9pBsZAoxwNMca/8dUnCtABtM1+QZPaESRAImbLTFm/WNa3CKAYqglBEVPaNkvAY50WCBKLZNWyglx5awllhY8pZ1DArjLWaF22xNaYizEkjVWGJ6eSWIlIZ7VWqHo12PKLhdAFGkF15xHdN+Urd1tjSTZp6SoL8TkFzYw0HhKj/2ECMy2Rs2fTFIKFSKe6QW7u1mk6yDEynpbBO7Loqt9AhxttcXm9if0oEaAp/fssOnRUzIcEOCMij0kVmaR8TEB3ubZI73lKfHYuZdy7bF3ejZ9ixFgX54DvoRkksNeAWxyHZC0Kps+v//fZ9GO+LPiCR3XEuDVB0dINWVSxGUOTlsZT/Z/Sq9zOaxvd8ICySwKm8LBbysPsTFP6eAZDnLVPNwfyKLFGzg8/uyMDe3ZVHuMwyZPF8R1PiPJQg63dJ3xbd0zUmzloLiUceygXLI2E6DNnQeNTf/7/R8BDpc7IXNFDp2ZJsCbMU542vmcLiYKkJTjiKBDOWR/RYBxqo4oj35OVm0COCk44PUdtj+Ly24XB/Sl5dLnWwK8tnHEa72X9Hu+AJLuTpB8+5IUbgqwRcoRN6Je04zZAnR5O2Hpjdck6SJAfhQPq0PzKMaZxXESD939r2mfkgASPs7Y3JBHm/M59AS4YK5uHi29zuHgFheY1L8g6YMctAxcMT0nlwxOcfhl5Ioctk/dbg77p7rC48cr8o7l8GOhG4bkX1MKe58/C1wxZ+5bkg9mb/iXG+q+vqX1SzhExLpCx+sDpYFDXZob0nM/kNZUDseUXFG3+iP9seOgEeaGE48/EkccNmu4AhsKqUOHQ4rIDdyRQso24vBUzRVf4otpnjoHKYEbNFKLaYoihzcBbkg1KSGHERxeK7higmkJtchxEE50g1ZjGXUpcHCQYvaWMtKQ5zDe1w3dFyupiY1XDLjgIeutYcocDku6wjOlmm6x+cHkBsVp1fSZ7dnK9tRTrKOzbM4jfzcs062jJeM5LBrtiqYLDeTC5nQw/3/nNVCsFQdpT1cEuzdT7Dh299lusBQzPsPmpB1xx9x5zTSO3XfhBjc8fNBK4aYcllx0x8t61vGsOSh98cBsszZ6H8rh5Hl37BK2k8UMDoc+euBEeTtpr+awW80LN9e1U/kdDj8DPeF+oINiWA43W3pBangHjWW5fSbfCzqX2JwCDp+OeSPGqJ1WyQsYB/eCh2MHRR0SYGqZFzJn/yJNEwG253gyzf6LtO8IYFbtidGe3XR0rQCFGR5IOdVN73o5DK3xwL+bftHFCxy+JXmgQrGTcj9wWHzLHYPWv+jpTpYn7I6ztncQ95GNc92w2PYXfd3EwWOeG7ykOkhVwGJx2w19d37QstmsNv/3GwXq7fTOg8Nfm13REN5KrqwGl8EFq8ta6ZYPi+kwF6z52URyKznwsniY8amF1nEcGvt4uOrbRAXsDZObnHGIcb/Rzhx0nrOcd2ggyTEcGljNVjbV0nwDjmlHHj68YbxOjeX8S2fsjKimo5rsXrt48BRXUy2L7/nHzph5qZK2jOJQvoaH5puVxJvAwXkLD1ptZaSgwbDihTP2s/FSdpdxB3nwZfn2xoTDyvfOCDMrIad1HP65zEPAgmLSZnOGfXVGT0ox+bJ34+p5yIj9QlPYXXYVO6PkbCENu8HBju8Mx9zPdOAIB8ffzihY9In8Mtg+vi5ooQI69IbtL3BGjcYn+vqd+//PBGbez6flwwR4FMNDnOQnMhkrQEMiD7Uz8qmsg0MIw6J8pfc0k/WUDdN48Ln2jj70cPj9rzMWKb0hMcMfUzghaO07ms0XwNLXCZORT1EMW/RGOOK8XT5F7hEgVc0R8UnvKPgwy41v9rhlmk97WL/LY+PpU99Rc4MAdQP2UPZ+Qxt/sPnODuCGv6L/1IXojLJHQe5rUmPYPi3SHhUr35IRs29ZbQfNzrc001GIgnl22Ln3NUW1CiDdYYezUu+p6aeAcUs7hFe9p4AXArhl2OHEqHya+k2AhfdsoSbMpx9bWd4eskPb14/UdIb1QW9bhF74SKpzmZ+l9phW+5HeRAkw+YodkhmeKAQIYNFijxl/F9LwcAH2jnQE1X0kXxsBbuo7omBhIS21ZX3ZxwnWLR+pRYH5zHdC4vxCml3EYpTGw/SZhaR+n0MOj4dtU4tIk9nNwpxwsayIas9zGJnF1vYV09L/OPytxPrLt6+kzGLdNM0JvLElVHCIw+QFjgibUsK4CusvgU6YWltGBukckvoc8OZlGR3icdAb5oiyI5U0aPg/fGZrL1TSTjOGzwqO8IuqJgW9/2GmE86HVdMJN1ZTto64M1RLcjYMx5Y5IbK0lhRSONSud0TEwwZK8+Vw6SXrF5X1dHAuh88ZzOeMJspkOH8qxhHHfZqp8yjDN7EDDrNa80zjMFPNAVeONFAD85k07SHqbyKbSRwm7bRDkE4jWXpyqPpijwlj6yjUkUPnGjvMcamjWIZjlQ/t0T6/mnwsOcxYZIdb+6opwI9DdJod/htVRTzmT/ZteziXV9LpOezuG+xhvK6ceIsZJvDscCiznOZd4fDKwx4Xp5TSiFsc7g/ZYnBHKfUsY/jZbYNPxeV02J9jvcsWZ0yryCWAg22NNWStqkhuFfPtoTWmVpfTjnusX2TaYObpUpr/mIPFams0Piilpes5vN1khYct5XQ+iIP/f1aYYlRFwWKGP2sscUWtii4zTNOZbYm/GsvpXjaHDL4VEhpLySaHQ3GEJdwCysjyNKvN8xYw2FPOaopDta8FLmRVktQJ9oZ3zHGKrbWIYvVeaoZX2lUkUOFwxMYcC0Kr6Z+RDBMWW0CVjau1OUietsRk1oNaWvhYc8MCr6JYHH/x0X/UEocqa2lwLOMbuVY4ua2a5PU5mPZZY+gkmy/J3pnZK0zqqIv1mro/1nhIddTLsKvPyRbabM5+lktbPG1xwb2O1jBcHetiiz0DDXSF5ZJjrzXeDTUQfykH87G2UH3ZTIqBHOY3WCPjYTNV7+PgNcoOV9c102LWX0yW2yJCupVWPuOg7sXqVLGVij8xfA6zx3eVVprSz3A70A7SZj/IRlWA7zPtcVv0g6KKWQ4fdkBPeitVaArwYbIDpmf+oLKfHPjXHLE8/AcRi3VpliNuPmkh0UUO6duccMmvld5ksXf+zXK+vo0UGVepUXRG5M0fdERagNkVTliz9CctZRxsUZozxKs76FeQAPPEPIS7sx7kLcDnBGdMqfhFL4YLoHPMBW1rf1EWy43kHS4w1e74/7/v34tk3ONwB5mwWsgc64LMVe10gfUy6beumNvUSTXWAtxpdMXZt13UyfjVYLA7IlS6yf2hAAs83KBm3ENjngugvMEdsbwe+qdDgKvRHujf2UOnbIWQfeGOEXt6afY0IQ4d8MDk3F6KURBiiqcnGvV6qP+aEKrvPfGAzZGVY5qr0AMC534KfyVE9X533FLqpzdM0y3UY/Z/BijjvAifvT1xN3WABl1EOHHeE7u4fpp+UoQ0KS/otfZTjZ8ItiFeUP7QR/HbRZh7yw2uVwbo+EMh/hW7YfbofprkxHC4yg2VT3tphAfTOAOuUKzqpQ2qQqwNccUM9FL2acYZPrrAaPVv2k5CnIhyQfGjXhpZK4DJXmc8Dumhc95CFLH+cuVKL5k/EMIixRm3pPppRpEQ4r9d0BTfTwb7hZjq7wrHF32k/lOIAXlXSGQwO9OA7btc8VBxgHS9RZhX7cL6+wAFpYrQMsEF43cP0Io/QmjyefirpJ9S5wgRZc2DtV4fRboLoazhjHM7emmqhBDHzvNwZ18PLR5kfeGxE1a79JBSqhBbaxwxq72XHtcK8Z3hfMHjfrr7SYgyWUfovemnkYlC/HfGAc1tvbSJaZ/mzY642vObtIax9+ccMObnb/oWJsT+WHsomrP3zBbi7VN76A8foENXhVgczHL++QA5Mn9WatrhzfK+/+99Rsr2yNTvoS1MM077aIupO3ror1FCKPbaYP3TPpo3U4hBGVvEfRigTKahnny3hlT2AInamSZytIFVXh8tZ73v3482rEf30k/G0/7+Zo1NW3pJdboAsu3WuFXQTaJTLM99bXH+ezctWSHAhQtWyEjtpVTW4/KvWyH7Uzc91Beg96c1Tlv9ov/9dqbuAyvc9v9FRayv+ctYQ9GpgyrKOEzvsYbw2E/yYzVYsMEaO/a003rG8+/8Y4XDuj9JinGbZWetYLekjWLWcNhZYI0zM9tIn3HXbIaZM6R/kjTj8EvnWSIgrY2uM848/oYVVJ80k3c3Hz5zLDHpVDPFSzGe9tgKH9saqL+WD9FKS/y83UDvc/mY7m2BIcUGmp3HR4iSBYpTm6nhMB9Xncxh6t1E6qf4mNxghttjWyh5PR9m882wKrSZMlbxoZxshq+5jTTjOB9nDcxRMq2Bhu/lw1ZkhgeP6+n+Oz4eLDZHSn8thT7jI9TUDLKLauky4//STaa45VxN43P44BeZwMG0lh4zXH331QTzVKqpmOG590lTpNtX0bgYhkWTTRC1vIr2MQ7wT6AptrtUUMZNDg+lTLBhNhtPY1pmzATYPquiij4+jm6bgOf8GvLxZvg8yhin/1STFus1NT+MEF9QRfufc9jz1BhKzyvoMuPwefeM8D6skhwZ599pZMQ4dxWNYLx6cqshkvZWk+ZLxjcWG6Jo+nc6zHpcuIohHF5WUyfjk4sUDCFYXEstfLa2zxAa0nWk2MZHvokxVj2ooyuMuxa0GwLnG8iukI/9343QuL2Reo/xYf3WGKM8G+jZf3xYWk5A85o6UljLx9zTE7BgZz05n+NjX80EZCgxDvC/33xONMHP1jpq2cxnGsgUEp71tGgWHzIhJnj5toGi5vKxdoYpSkIbKW8OH8YnTHCX8Y22RXz4nzWFNOMhErv4qGsywc6mFkr4l4/LEmaYV9ZCeS/4eC82xcPCNjr4gY9bmWYwFrSRJePtE+6bYrjkTxrDePsrNXP829ROdSzHOi1YLw5vox0WHCbyLXC+qp0qWF9LTDLHxa8dVDeZQ6rQAh0enfRiO4cTSZa4sbuTdjGNPy/IApnJXXRuC4cAI3Nwxl20kukduVXmaHH+TW4sLr8WWeBHZTdpsj5yUMUS7nu6yIhxb5cFllB83E0vnzAN+NwS+3N+kR/jM28CrVDv2Ump2gIEj7WAf1sPZfsLmE60RDyra/+FAigFWMB9Tj8t+VeAZcstMeZaP41/KcCtI1ZQbukn9XKm9zdbIv/FIC1g9muzGU+4NkgztYW4/tgCl479oYhxQny9a4n/HP+Q2YAA9zgrRH4fpCQI8fmqFT5I/iF9hpPtA1Zo1RqkHYzDtzJeNPFsP13dIcQnhi1+Y//Q2RtC3GG40XJ5GIr6hIzvWWPw3jCMKBWiRM4Wk8z/ULeyCDcGbZFZNkQh9iJYzLKFnv4wDKaLcMbWDufHDcMxPRGUuhgeOg2R1VkRJgfZI73jD+36IcKOADv8NJDAtGVixm3sYPZcAi5hYtaGbSE3ThKzhouxcoQttrpLwmW5GBnTbOH2UhKlOWJ80LND8wNJSDaJoTzGFsvvSCEiNRj9ZnbovyaF+LZgaKjZo/yxFCg/GF8n2UFXTxq+LiHYmcJ45jFp2PaEoMjKHqe/SKNyfgiMxzlg91kplGUGY2q3PUaUScJHOgSm5Q5oOCWJs89CEGztCMNYKRRLhOLdoCNGWkphytZQyFx0xNoaKeSvD0X/XCfcnS+FUUvCoH/SCR6G0ii8HIaURh5cDkgh7Wo4bjCdaBMqDa1F4fgnl/GcTGnk6Ydj/m9H7PsjjQjFCPgudsIWngzjZRH4ZMqDdwWbUxqBHfo8PDKUQeaRCBy/z4P4gTRmXgmHD9OVIzOkUCIRifPOTlhyTgYLC8LxdBXj+SdlIDwcgZpwRxjIyiJvIBz8Vw6w1ZJF+pMIZLLe1/a/v+NvjcQdplP2mMhialkkVu9xQMhxWfwqicDoe/bYVimLb1ZRKFljj19mchDKRKL7sx3kZsjhSUkkXjHNZXpGDifcI1FtZYcN3+SgqBmF8B5bjJWUx9ZPUdh/iem+Q3JoiYzGlzu2kBmUg3R8FNLUbfFlmTx+r47GqdOsP66Sx4t7UUiysEFrlzxeHolGcIk12uvkMdwzGjx7a6SkK6BKKgqzd1jDbb4C6uZE4ccZKwwOKcDKJxKdzVYQtSqAfy8S9RpW0NmtiPnOUajwscQnOyWUK0cic4UlzIyVUH8wEkVPLRD6SQlz2blpKyzQma+EXKMoRA1nXH25MuZZRsPgjTnUpitjpVQkjJwtkLdUGdeXRmD1VXM06qvgYmk41FktB0coY8OcCDRUWmDYEyUoisNxuc4CvauUMPpFGFb5WOC6rDJEEeGYfI31ow5ldAQy+2Fz/NyvjCcfQrFAn63dr4TPFIZPhRZ4OVwJHvahyD5sgeoURVR/D4XuWktsGaGI7xahsNvEtEmqAi5vCcGAriVSpBTgbBWCQxIWkP9XAVK5Icj91xzz2D5dXqGw6TIHBSjh75RQnJ9qjnXaytjG8nz1ITNc9VbGfn+W20VmOP1MGQ++hWJ6lxkCLFUwsTgMhRrm6Dmigu1RYahNNcOjtOEo2hoOJba268hw9PSFI8/QHG8+q2A/LxybtcwweaUqIgfD8TXTFC8XqYHXHIaWU6ZYFKOGjIxwvIowxc80dXb3CJikm2JxkjoObopAtQrrHUkjkLsrEpFapnA2GAHz0iicKzdBvv8I7NeKRpqBKdZBHbccYlBYbwJTQ3VM1IpB+Wk2ZmuzjkejcJsJFtto4HRLDIziTRAh0IDKrxgYbDXBum51hPDiUOhhAr8edVhOi0XNPhP06apDY2ssqt+aIEBSDZZT41BwywShncPh83cchuaZwKRUFdLWcciZYQL7S2qocImH/zATzNmohi61eJz1NYFtsCrKSuIx9dEEjDVUxQXXeJyKY/v7DsfQsAR0vJqA9hsqKP4nATojJkC8cTjazyXAX3sCSi1UUKafgEs/JyBLoIyZ2QnYzZuA6DwlfODY2NgEVe2KkKyLh7m8KRrtFBE+PQGFC9i5xQoY+yMBNtMnQM5TEa9OJ2D0MxN0vpDHB7NEXL86AWkv5dFtkID7NqaQjFRAmmoCQv+YwnatPHSPJaC3xRS/98hhsnkCZm00w7QCOZwTJCCX5YNxrBy+GyZi7xET2PzL6n16IqSOTUBvkxwOrk3EQKsxPm6Xh+adRPzXZYScEQpYk5aIKzeNEbZbATMPJMLtvRECohVxLzYRi2Yb49k2ReTyErFyEeMq85RQsSIR/d+MkOWohM75iVh+wAivPJVhciYRf9SMkLpICeq5iUiuNES5nyJM7iZCutgA4y8rQXgkEVeXGOLwoDLGHE/E5bkGuCKngpUHE9G23gDS44bj+tFEPI02hPSr4fg/tb1KWXicHJp1VNXb8/7plAapcw6H7lKxc7/Uq3KCQzd2XPtjXr12d3d3t9fCVuxOxG4URRDERH/7+1v8s9de8549e/bM8zyzDp165ZL9dwCtNtox73+5NB8QQJ7SgS7uuaS3C+SItz0zPHM5lhdIvbkO/B6Xy7YlAVQJR6bsz+XDan8KejiSui+XftkBjJnkhGthLkv6+dNnvxPuF3MZtNePI387MeBuLo1e+PGxjzPXN+Vy9Y8vnaY600yuYw/68S7fhbgHuUzc7M/FU878fT2XQ0X+ZDi6smi7jGeJ9DnblTvncnltHUDZalcWns9lY7cATu1yJULab18XwFyNKxuO5rLrfAATT7jiuCqX0a6BxF51ZerkXBZ3C8TxjwurOuYyZ3kg11670rpJLkMuynWpK3llOfRVBbFU7crVMzm0aBjETQs3vs/KoSA9iFb2blx0yaHR6iCs6rgy4kk2V3cHERPoxuD52WgvBfEtwo0j1tmc/BlETgdXul/PokWNYDq0cMP7f1nEKIM538YNuzeZPIkJxnOUK8ZrM9kv151S3XBJyeRpXDAeWW7onmbwtUUwjze5cmx4Buuigint7CbfKoMbct2pixuui9IZaQjmQ19XpqxLR6UOZmZvN6bsTMPPNRiboW5cT0kj0y2YWXluDO+ahptdMLOHuXGgSxrfZGwL5LpPqzQirYIZNNyN4yap1HwXxL2JbtR5kcLwb0EkZ7ux5XoKx58EcX6SG0++J2O2NYhGU93YtC4ZuwtB9PFzw7AtGeOZQZyZ4oa7TTI1mgbRZIIbDUqSmNgkiMM93VBWJuERE4T/eDfWTU/i5ctA4ke4sbxFEi22B9JKxjwiIYnoBjLPRa78qp9E/3WB6Ie4Me12Imp1EJvbulIZkUT2wkAKB8lv+ybiJt937rL/y0Mive0Cce/mxqt/Ekl5GIDo4EaWLpEJVwPoGerGREMi7dbK/Uw3TGsnEpUegEOCzM93A7enBxA/2RVRaeD5OX/iGrthUWjgfR9/9ka70XKRgfmz/HkY7IrregMzJ/txy86N9msMLBzsh8LWjbgeBt5N9SPqsQu9VhrY0sCPZcZufJlh4OJ6X6oPuXJgmYHaS30ZVuzKwSMGjN+qGX9J1sMlA0ZL1Uw95sqevgZ6jvXl5S4Xml01oJqiZv8RV24vNPBirZo9/VwwuW+gTj81HHAlzCaRnWt8ZF260Ds2kVbzfNg105UeKxM5YOJDq/+5ojiVSPENFau7u/JnXyLWC1W08nShcLbMp6uKFs1debI0ido2KvybulJrcBL+hUrGWLuQsyuJv38oWdLQlZX1ktndR0nNRS4syEjm+hglL1WuWD1JxrOZklV2rhx2SuFLoBJLS1c226cw9a2CCT+d0bimcvS6As0HF2p6plLvqoLNJS7YvE9hxXgFLSxcWKNO5dslBSXvZWyHUlnXWcGTFi7YxqWRslDB8jsudP03jcazFDy/7kK/s2ns0ym41siFgQnp9J+u4NBZFx4NSadypgL1GRcWl6QzNUNBrpcLR/tmkHpGwZvjLtzYnoHfLQUhcv1v40waj1UQdMSZuTUyWVGhYLXcT3mXSUN3JV17uTD1SiYR8o6vT7rwtyaL3wOVVJ12Ib19Fq1HKzkuz6q6lsWJoUqColz4disLy/dK9l9z4U1ZFnYOKhxuu/BhWjbFjirCbzpjH5bNvHYqlj5wIWhxNt0WqXi6XvoZks0P+UYFz13YuTSbO9dUPCl2oeJcNjFhPnh/caFEn8MS4cONk85EyXXtCh+c7V1RdsshV6lmmot8l5859Bqs5mWFM433S3xbouYvf1ea/8qReKUmSr5X1vscbn5RExftyi1p39bLFy+JdfENc0k+40t+vCsju+bS4aAvzY648FeaxHa9H33by7qdk0vCJz9eDHblZVYuS+v7MsbVhca95bf+vpx0cOaJ5JTTybJW+zkxc2gu/aN9mWDnRLduuWx2k7zg4Ii1Uy7tbGVs1o54LsxFvdOX3QMcObYhl9D7vgT85USvnbmMG+HH01BH1s7PJeOZL7nHHChYkcuFrn6s9nMgcXwue4/4YlJuj8/oXGqv9WXITTsaGXIJv6pmwX17Zhnl0vq0D4az9vRel8Mwcx/6VjnQbV8O83N8qFQ6UbtmDmfTVdxLd6Jfn2yy5iuJ/OnEqtRsXmcp6X/Vkckzs7hYpmBGlDO2s7M4dECB/y9Hrsj9E1cUfD/pQPT3TMZ2VBA73ZF/92eS1VXBp8MODE7KRMQpuNrQkThNJl1CFLz87ojtz0w03RQMG+rEpwaZfK2j4NFtJ7rfyiS5v4K/PJzZ81cGKb6yj2KdedRD1rOtAre2TpjMTCfCTMGZZU606JaOm5OCnytlPEPTqOOuwHiAEwmR6Wz0UjC0gzNbvdOYGK7g8zBn4runMqupgkZXnbg4JJXJWgXLTjpyJjmNUREKtnaR77Iplee9ZA8OcWD2yTSe1VMwaY8Dv7ZLHumiIHWkPW2OprNPxtxujANzpmRwRZ41N8uReo8y8G2t4If89qcyg4BOEhM62bNmciYr5yn4NcOeC4sysJ2kIDrSDvva6eQPVrDT047q8+mc+7+7H7alIDINz5EKIjba4ncvDaWMc+Q2Gz4cSWezxIGeE2044pZORaCCTUutyWuTRk5tBWnPrMkqTeWUxIF1g22IHpnKtb/kufOtme2UxoiaCl68siK7USoPailosN+KZitSePg/BVXVVmzbncL9tgpK/ayYkJlKE2k//ZolJbNTMBIKbnaxZGdZCpeUCto8s2BdSAob5VmWvSyIepjCGW+Zcx8LrqalMKuxgi0DzFE4pfLbTsF/mON9OxV1tTeLl1lwScZjVuHNPitzDoalU/O3N2+iLfhdmcbgX9JmviWnJR6+++nNtHeWON1O44Z89yezrEg5kU6UWoHpLiuuFqez10NBqz6WnNibQYVBgW1bK1yWZWCcrsClvTUHF0pNslXBoCRrjB9k0Hicgnk7bbCzyCCwhYLfV6wZ9SOTqfcUXN5gw50XmQRKzKxzzhYL40yqlygIU9RgvsRG03MKFrjbsel0Frsk/jfZWIMXN7MYKvGzJMye7iOzSZTc0U3vwJrt2bgtVGKUaM+LmdncnKck0WDHqaAcWrmreFBkR237HNzLlWy/bo/xjBzWH1ARtcyeix45dJU2a+440HWV3L+son19O+p9lt+O8iFtmx1P2+ViMktNVX87IiT+JOX70LZJDR4NyGXdLTXNwmpg/08u5+eqcUqzpb/EsV+bffGdWYMAXS5bq3yY9tqG9FtSH9r68PypjdRCOax8q8JZ5uptbA5j6qvY523DvOgcjCJVWO+xwkLa/LmlwvDekpuJubSd5sNeW0t0N3JofUHi/zQLlkXl0DRIxal2lijq5GAIUDGhxJxW93MIP6nCpo45lhJjtw/zYcxBc662zyWyqw+FvcyYUJzD1z0qmn805e9WOeCr4vNCM2J75NDES8U2gyn1zHNZtkJF5wsmJEscftvchzUNTCmQmv8vGx/KtSYExuRSMk/Ft0fGdN+UQ3pNFR9UJrx2kfgpY5t014glLWU+5Rsd6GTMQZl/t0VKmq81wk/e8cpcJQ/e/hEDTXKoE6BkXm8jTk7LwcZTydS2v0XzyFz+SMw83ey3mCnfYnCaUmq2X6JAavWzJir6TqgWD+S9epmq+Jr2R7SpzpU5VrF41x8RvCWXl3Y+NM01ZlPbPB6aqKlWGWM3L49LL6SeefJHjNyRx9M+PrS5XC2qa7RHP06N9dHf4t25PDkXqCVeGCGy2zP0b19ybP4ItbR3+q3GP8mY8Ie5nDziQ5NsE27cy2W/s5r3C0z5XZBLapyaV4VmjFXmcfWVmkwrM+a45HFD7cs9tTn3ZPzdE9USOy0oaCrPMvWjPNecpivas6W9H/byLnOu5nHU2If4uz/FDs/2rHqlIqPouyh4n8cnCxUpP7+KZuvySPBRMWvvdzFzZR7nB6ow+fpD1PPMw/q+Ejx/ioe6PMZOVeJs9F18k7wWa6bkZPV3UT83j2s2SiqeVYn1PXKpGKZgsvM3sULOXKN6K3i3pEoMi8qjfqoCn9AvolByX2+JFX06V4mHB3LJ2eLN9shK4bIrj+V+CgqrPouBy/I4O9abHv8rF8tWy15w90Yz9bOwDshD/duLv6LKhULaLCrz4kXlJ2Eu56wmk73Q3y8TTbNzaXPbk0vqT+JFkHwvuU4p+yiGP8rlaH9PVsR9FMrROXzy8mTBzY+iluydJgulzYdP4lS/HKKcvBjRulyUTMmm40lP6jYoF3s9s2mn8cT+2CfRe2IWnQ96Uu9suTizI5ODWk+s65UJ71aZXDriiWvoZ/HJP4tL/l4ynxVi8+0MvP28qGdZKV5YZfD8rCdPYz+Lve0z0LT35Hx2mdjQSGrCMTKGbmXCxiWdlMueTHhULjp0Sqd9gBdzzlaImc3SaFLpyfayctHxf2n02yrvsqxMPJyXygkZ56pvn8Qu9zSqO3nyfXKpmJyWznKlJzs7lgqvkDTmvPQg4nmJsLiZgiLekxOfS8TkuylUX/TAKe+d6HwulW0zPGi2/Z0YHy3xv78Ha+KKRfm3VOKaezBWXyxyHqdgVcuD9s3fiP+sJJc9c8er3hsB6ZQ6eeD3oVgcOZxG+GAP7vd7L0q3pLOwowerXEtE1JAMYhp4UPPxe5GRlMH9SR5UpX0QwSOkBtjnwbvBH4TZ1gzM33rwu06pKHLJovKJB7OTS8X5NplcHS1jW/tBHP1HzrNDPCia80EMWJHJTy8Put58L2oVZzHM0QN2vhdZe7OxHeeBb8IHoYnNhvseFLz5KMql5ixc7MGTFyXiTkIOZmoP6rd9Ly5LbJwzUPpc/V50GpfLN28PepUXi55LcvlZ7MGZwhKxZKGsjS3unHAoFsuP5WChd6cw840IPiT1GO4sOfdG7JC10aCVO9P/vBEb07JJ3+hO/t5iMfdtJk7r3cnYUCwWzspki7TRXngjPr7OQKl2Z8+U12LcwQx69XTH4sMbca9C5iTanW5vXoktDdMxMnEn5ewLofiZxnrhzmDPVyInO52uc9zZ0faNWGyURsFgd07ueynyeqRRM9ydFYtfiBX7Uunf2B2z7c9FQrtUvKLcmRT5TMw/n0KYtB/g/FxoL6Ww+aY7D3e/FCOWJOP7yJ0Fqufiv15J3Ir3kLj0XLzancTOYR5oZ70UASuSGVjHg5FFL4X3nUR+3JQ5D3opyuScm7rUg+GHnonaTw10MZX17P1cWJcZOHrCg+qMp6JnXQP5Ok/+/HoiejcycHOGJ86Ln4ujcxJIdPXi+Opn4qY2gf/Jmm+/6LFIe6tnz3kvoqqeipLtehq+9eJT+WNxsJce0dEbdeBTEdxYT8kmb4rKHwnNf3pW3vNi4YOH4kuinnmzvDmaVSSalOi4N0RB681FIl6lp057BVde3BcdVuu4u0RJ99aFosMIHRmSE4vz7oqPiToKJWfVH3ZfLGyp43Oy5Na5D8QkDx0bW/rQsOy+mNhQh328D3rtPXHQVcffEWpqPrkrCoq0PJC4PTikUFi11eH1nw9Fd+6IT42ln+5q7hvfEW99dQyL8eWmXF9+qeWu8GWz+T0xK1nHZckLr2beErZaHcLEj8NVN4XSRsfFv/xIenpbbM/X4j3UDyebeyKwUst/4/3ZsPO2+KuFjsdN/aledVP0iNJhNCqAl7k3hVWhliNXA1jW9bYIXq7F6bw/3L0rkoZrMXULpM3IuyJlo5bh4UEc/3hLWNfQ4bIvkOn2N8X5Z1r8dwbhOv2GODhNy5j2wRS53RQzb2kJnBrMywPXxOKOWjqlh/CW66KvvMu+t8GUKa6Kdou0vB0bQm+rq6KOtw735GBW/7oiBr/VMtc3hKv7L4vzcTqS8oJpu+SS+CtPx860IMa+uSLyxuk45BbEzVOXxG+Zk+/3g5he+4LwnKMjfW8g/X5fEEu66vjvSiBX1p0T6+R9270IwutrgWhrqiPgcjCqnHPixT0trr2CCXU9KzYodXzrGkSNjWfF4Rta6nYI4tTQ0yIqRuatWyDdI86KgFItnl6BBFw5JWbIXJ16GkiK4aRI26kl/20AkcNOiNp6LYmlgczedkyMmKhlSX4AzyYcE6aJWi6ZBjLFO1+Mctay3CuIdjXyxcufGhZfCcJQkS/+vq5hmLG879jDws5CS48XgQwoOiTqXdQQvSoIzZMDotlsDbN2BhP78oAQBg27B4UwdfV+saCzhr8uhDA78KAYsFBDPZcQGhsdFotGaVj7M4RH4w6Lw+c0lP4M5vt/+eLUCg2ZDULJGZcvrt2X3xqFkvj8mOjzUEP/VmH8PHRcLHeQtZccSnLXkyLXXMvGiWGEvTspmrzXsDcsnEMdT4gkSy0l68Lp9fik+MdJy5Z/I3AKOilq+2px2RRB9/6nRX4LLRYVkbjuPCX8MrVElkWxp/1pcaKBlk0vI2nc4aywytUyOjKaG4VnhVNnLVlGMdS6cVroe2r5GBdDy8gC8SxLy63nMZzMOyNWh8lvi2PxrDwtdmVoaR0TS+qIAqGO0pJRrxYd7hSItxotnzJiaWV9QRwKkDGk1OLCgAvC0FLWZ48YJkZeEuPluXFpMcxedF5k1tNS3jia4pkXxUB5lsvIaOaUnRMfY7U4dopiZrfzothavqlvFKnfL4r68u1GDInknf1F8e8NDUGhkYj5l8Wsr/JNU6NICrgieh7SMKprJFMGXRPez+RbzImi4YZrYouXlt2Do1nb/orIlX5GrYvm5Z5rYvplDeseR+E+7YbIuKOh+cVoAvJviOA/GlIWxBBdcE0EyrsoJsRwY+MVEbdUw/WNUfwyuy20PTRYGkejXHdXBHbRUKt9DNcn3BXutTSMaxrNfz6F4lOEhv3TY7hsVSi2BWjYdSOW4p/3RVV5PBPPxDA5o0ioS+JxMqnFFlEkYt01NLStzaHi+6Lbk3hGxNVmn2eRKP0tberXYfSd+6LwYjw3/6pDytsHosnaeMYNqI2DzSMxqyqe4zKHaX2KRMsf8SyJjWLq0iKRUVuD65tIJhkKxRC5X3Uqggu2D0WTOA3lCyLo1rtQHOmgoXhDJJ9K74o2mRpO9oog1fKeyBquYVBmJG+qb4uQgRr6dYzg+qTbYswa2SNbIpluuCkaTtFwKieCwls3xIvlGho0iyDI95roIvfLGoRj1uGGmLFRgz42nN4Hror8vRo2OkSQ8umy+HVV5qRJOAtcL4vXj2UfdYjAP+uicPuhYUrDcGIyL4g6v6SfsAgyjp8TvlZaov4OJ7rVOdFH9kvz5+H4Hj8rliq0NLAL55Z3gegrazV7ZRgFO8+Jl2202PmHUVpxVhRM0CL6h9Iz5bzwXCqx8WIIe4vPiugmstf2hqI+elqUd5G1+lcI12qcFqXS52RNCBaXT4guso/ClMFscz0pXslvj2uCORx9Wgw01vLiaTCzWh0XCkeJIYpgni08JtootSR7hPPc84zwkrjnu0j6KT0nOtjpsLIMYWijC0Ij9xcdCOHo1/Ni9k0tHitDEKMuinrd5L0mhRKx56J4X0tLd8Io+/uCmGenxTIljMD0S+JqKy0n5V0CLl0WJsUaLqvCsFVeFSfqaOkQEErZ4ati6G8N92JDubfkuni1R0NyWBj7310X7STuLXIP5Vv4LeEt8W24ZxhPDt0S2wZoiGocTj2/22JGPw0/HcJoOuuuMGRrqCPCqbx5V7xpK9/FN4wljQrF5kYaAjPCpZYoFOc8NeS2DCNhd5F4UEPD1eHhxJ0qEnWfxpM0IAyHD4/EwTvxbJ4ZzubSR6JoTTzdxodKLngqtr6L51STUJr9eCROfIsnWGJmH9fHwlf2zgDLUMZtLxKD4jWE5wdz/b8iUST77u5zmTdVodiwSsO5JcGkyV47e1fDkWPBPLa7Jzw2aeh+OYR1ze+K5CoNM61DmG9+R1wN1rKwvsTtRTfFkLZa7tWR9v1ui+Myt6N9glk/5644L/dtGgbh3PGuaGKi5VlmECPEfSGealjvEcwy//tieoGGQyuDGDS7ULy9rWHBpkC2tXogLv8j49QGUVpYJCrmSfy5EkDfTQ/FrEANXSWX+ds+ES4OGrqsD+Kj4bF4I/vu4WF/Xro+EYrDGvKn+fPl80PR/qOGRgMDMD36QHyV3FTR3J/goCKx44mGnNF++Hs/Erny7sfm+hFt/UQ4PtJgu8OXuCOPxcNdGvqM9MVd+UxYpmiIXO2HZ5tnoo2xzNUJfzqNeiYibTVULPFDsf+FKJb5rJnvy5iYF2Lom3jMu/lReeyVqJY4YNTdl3+MXgtruT8n0A/1nTfi7bh43H74YXX/rVj2LJ5wdznnjn8nwobFU++PH6vHvxfV6njufvHHSl8iNo6N52GkPyczPorqiHiilAHc7/VRvH7YjvA/AbSJ/SAmLmpH+vFAFvBeDFrVjlE/Ann0s0SEPGrH5IeB9AkuFXbz2uF+N4j2Cz6IDkPaMXd1EOXL3ov559oxRb7Lyo2lIqlGPI8zgmgZVyZKbeL50DWYy5fKJF/HMyUpiMT+n8XzzHhmHJB6yaNC/JUVzwC/UN7NrRAp2+I5bB7Czj5fxPyN8TSWtff4lZyRr8TzZWwobr5fxT1Zn7n9Qni156twUWnYNDuUZaHfhXt7DakxYRib/xTv52jYUBVCwdafolqvYU7nEPYd+S4iN2u4MCWYSzd/iOYaDROmBzPp6Tex1kaDITiYEaZfhe5APPmXg+h0uVL0kD21RGqbk65Vot5UDSX6IPxOfROtx2pI+x6A/fsq8cJew9PDAfh2rBTuBfG8KghkfEyl+C3762jDQCqvfhYfDsZzoU0AwRXlYlSI1BuD/NE8+iwaL9bwv83+9Mv6Ip5LDOm+34/MsC+iZqTE2/F+aPaUiSFrNThKfVsYVyFsZf+27eJPm+oyUeekzImVP91GfBJf38ezrZ8fGcNLxfeX8fjV8SO21QdxTHJiyXxfrOJLxdFUDaYJvuyLKRFHJC9PW6wmc/0H0UPqGdtzahr3+SSa7NegW+1LqX25uC71zFV7Xz5uLRdIfk9f70vx7c+iq62WKnM/8ttVimYSk31a+rGzSZWYLHmhYx1/TDdVicAyDb3DAwg4+1UUPNDwJiKQMde+iZB4iZ8yVytq/RCfJb+cPxlI7To/xPa3GiZOCSL81Q8x1EbLGqdg/Nv8Eo2/Sd6UuPHYq1q45EktFBfM+Ijf4qxWy9GhIXTo+0c0u6ZlwehgRg02oo/khYwpIexaYERkfy0x40JpO9uI3S5aiiXWhYX+EUlSiz6Tui5r8h/x54gGpcTtPfpqcVlqvDsmoTy8Wy0i+2ihOIyxBUYYSV5I/hNK3CFj1kqdPzglnNxrxsweKHV++wjuLzdC80FL5poIWp8xJstdR9DZSOx2GlOQpeNmRQTv95pwt4/U5F8iWdfehNjWOjpOj8JhqzGBOh0tpFZp1MyY+mE6th+LZvg0I1pO0LHBLwZrF2MebZD2n6JoUNuEZhF6LL9GYdHAlJGvdaxbHMni8aakjNWzqF4Us7RmVK/Rs1ZqyxWvTcnvrafRqWjcw0zlrJbA9ltR3KxpzpPlCfxbK4Z/t5jRqqmBX1Oj8XhmzuH6BmYvieF4iDmGWwncL4/BY6AZhccNdAyNpUayOaavDFj0jGHmN3PuL0ykpy6Wjz/MWVOSyOHWtajcZE7BgUR+Xa5FaJQ5O7omYjK6tnwvM+62S2Jf59qc15jzSZHE5gu1sJ1izrOVSXy7WAt3GUNIrWQGzKnNgWvmOLxP4op/HaYnmRNDEnez6mB0wIwP25IJfVGLjZ0seLc5iflVsXTIsODF6WS65scy08GS/ZOTWPUqhtplFpR2Tcb6egxfRljSsygJl8bS20JLErcmc1TmwemPJY8NKTiYxpJ32JKRlSnUljaPU6w4/iSZD0OjWTPfivCtKZzIiWbJSyuUihReP48iy8uaVu9TMM+P4nCGNXGLUgnsIvP5yYoZf5LxcI+i1npr6k9Mwa15JLv72lCrQzKaxpE8iLHhRkESabcjOZpjjW3TZKJ3R8m5z4riwCRm9o3i0wArBq5IpFnnSAq+WHHLNpHCZlH47bbkx7ZEYl2jabXUkiOeMs+fo/jQyJJxewxMex/FmXsW2AQmsmNhNLUuWrBHaUChjaLHMguaLk9kbbcYHFdYMNYhieYl0dRsZ4nXqSRq94om0c2K7u0NNB8Uyaollgz5YOD7OKntY60QFwzU/RKBaooVG5sY6LwjAp2HFRHXEggpjmA2luy4ncDCp+FEhVrRX51AtdSlo9Za0CAlgaA3YfQ0s2LUkQQyVOEc22ZFs60JuCwN45mJNVUXE3gZEMbOI9a86ZGAyaFQegXKHH7Q83JbKB7nLLkTmMCBMVKz2VvT45qevOYhxD6ypNZkPb6hodS5ZIHHGD2LvwTTfo8FAy/omVYouWm/JQbbBD40D+brHyva2sm+cAmSnGpFA+l/0bZAljla0eE/PRFbAnm504LfE/T8+hDElcEWZPTU02VYEPt3mlN/mJ7u2wO5k2LOkDA9RX2DuNXVTHKO7FMRSOvBZlgG6OkcF0iNIFMMQ/VM7hdAnqkZXTrpuWMagImnKRY+ejZ/llxw0RiD9KmuLTXJEhPypZ82Z/xovN2YPC89F9f7cT7TiHej9fh/92V9gDGjZTxLZ/gyoJER46SfpX19sbH8LZ5Nl36K1Gzq8Ee8/UfP8mFq3mysFppYPcHd1Ggm/hQlT3TUiPXF9u5PUXeLHu+bPrQe80v0WKhnXFcfxnX6IUK89bw748PEy9/EzjU6prxWM3Xed9F4s46mH3wYM6dKXNDoSDmi5ky7r+KLxLEBnXw5mPVN/PNUy6S6vkSKKvG4ro66HdRYbv8ilpfLuSBPzd1XFWJrBx3tr/vg17NSnG6l49QkHx7X/iwGrNJys5masoByUUdq8qkNfZl3rkK4+ukIET7E9P4kpk6Ws7D8Nmb/R1HloiPSxIfuPh9FwnUteT4+1Hr9XoyW83iXNz6srF8i0nN0VI1Scet6ibiereNgKxVTFr4T4RLnZz1XYfHjrQiSPFW524c3T4uFY6IW+5k+jC17Larvaul3SMXn5a/Fg7mSywJ8mPnlhfhPzhpjSny4cfml2PRQQ0GOGruvr8S1sxqm5quZeemFGOEjecdYjWetF2JRhYbQGWr2lzwT5uZS615Q87XqiTD+S0vvdz5M6vpM/NVRy/cIaTPtsXi0T8t9Rx86H3wqHGScI1U+HHrySPRYreV5bTXT9xSJjZVa+kT7UNmwSLSWPLg4TfJ450Lxj9TSmlRfpv8pEknZWupt8kM7vVBYeWiZ18aPDSflbGuq5edpX04pHolkdy3bFL7MsH0s1gvJp54BXHh6XxyM0eEfrcIk4JGIlfk/qFbR99YT8Xi8Ds+mSga+fCwWTdYxo5mSY9OeiRM/dbxCgS7nqZhzU0eT6QoULx6Jc1N0nM5Q8rP1Q1HHRE/98QomTHghukg/Pj2U/PfghTjjqWNBoIruM54Ly2gdK2qquFTnlfC8ImOIUZLW+LVYpdehdFVRUPhG7Hmjo7qPEtOsYhHfS8+9OQpyq9+I27NlL9xX0OH+O5FnrGfYQSUjVsoaWKXnuKuSqh8lQif5cfLfShr9+iD2LdYRPlTF2scfxcc2eoyuKvE4UCrqndLxfquKsjVlomc/2dcuKnqVlYsuL3VMNffhVGGFOLhST12d/PZDpThRX0+Ykw9DZ1ZJ7SfxapIKndSuzrJn/1j74Jv9TZyu1qNbpGKlz3cRFpeAVbmK01G/RMdtCby2UGHm+EOEnUvg7zYq8lvJ/XUJErNV1M+rFlMXJrDM2If+kX9El1I9Fl9knd//v9/ypM0NH9xmGTHqocS6F2pafZH6p30CFU5qWpw0ZrwigeVy3zHThNCzetyllnMeY0JZcAJGtX35NMiUa1/1nLP0Y+9TU14c0PNbYtGF76Z0r5Eg+9gPl1IzfEr0/AiW+13Msdor79IrgBtdzbH7o6dc6tsp/1rwv1d6ybsBeN+xwE/eN0Bqv4dFlrh4JWC225/8jZasaZTApFf+dLlixULfBKJ+BbDquxU3JeZnRAdQpbQhuUUCtzIC2ffIGgsS6KSTWtHRhvsjErgSG4gwsWXW2ARODAkiOMKW7MQE/AYFkxNiQ70xCQxbGMK8tjYMW5TAsZnBPK9ji+vxBPJ1IVxsa8vjwgQGy3kkwqgGKT4GXFeEcPOPLR0ll73+HsKlYhtaq6XmuRLK5Ks2nNwrddGQUA6H21Bjl4GNQ+R8McWOiiADH0Uwo4Ud/20wsFMXzJFf9oRIfdXXPIhXJ+1Z8z2BLhcCWdfdjgbnEwjMD2Jf/RqcPix9jg2ksF4NHMpl/OkBKBPtKPQ2yP4OwGmfPXNlDIf/lnk7YE+BkwFHhT9lu+3QvU5gmtYfu841cM2Xuf03gMMuNfhH1swkmwDS023ZeSCBC7b+qI1sae5goFGxL4dv2/I7zMC2YD8Gpdqxp6OBKTV9mWtmh3uu5PQbauKf29JW2sS+lbU0wIaUOwnYOPlxcqoN02V9Pjrii8d2a+yKE3hl7Usnb2uYJWvsoy8rRloxXWrIA9KPW6UlrYdI3l/sS0NXS1Y2l7Ft9eNKN0uahSUwtasfp8ItWNRRxq/xJWy9Oe9rJRA22Jfo4WY0kO8bIDFzzgAzkqWfotZqjBxNeSLv3ma5D2WFpix8k8D6Sz60/WlGt/1S36ap2bjInOsqA61W+zDE3wKHYwmMmq8mbrMFj2sa6PbLhw1dLbGdZ8DN3wdtmiXBaw2suaXC2c2C7t0NaL6r6HLTjJbuiTRvpCKlmzlXfBOpm6rC+JAFqy4lErZbyaYAqT+vJBL4UEnOZkty1iRxPVrJTqk/Q6XGm4qSZR2sSHZMouktJU1drJmWKfXz3yp2H7VigVcipWNVuJ215OltAz2rVQzsY8WzFAOfyn14eMMK11ID7bx8mDDGmtmLDYyWfJ1Ry4YjMuaaVmoaZMnarpFIq9o+jLhow7OaiVSn+7DWvQY6qQnrhKo5t7YGK+RZm/r6ENnTjn//k7XUUs2vMjtu9ZR3r+fLiEx7ruyXs4Dc90hyoHMfA4UtfEnMd6BpYwNGcu7LWGfPkxYGJnf2Y2OJA4NjDZxf4s/53w4cR+rPf/0QzZxwkutuO/zJyHBijbSPLgxgjJMjR0Ya2GUdxOOmjiyV5/4sCqBirJPU/QbCqgOpuufEohcGiiuD6D3LkUWd5XzxOJg8D0cyLBP50yKE87IvWixL5GB+CKUv7bGX92p0KISPQfacNSRypHUo0+bb0b9DEqWvQhjf24ENHlLrDgvhTLUDqmFJXHANoVV9Jy7sTcT272CJeU6cn5HE2NXBeEx2pmXvZDZ9DKZNL2f2JSTTY0Ywx7u7SP8pjN0TTEY3F8atSKXZ8WBONHBhU91U2nUJJinXFe/WacT1DeZMPVf6nUmjfH4w30a6EGCXQo42GJN0V4hMZl50MLV9XPm8JYlm+mBu9HPh16AkNCeCGBfgSoB3EoaoYNLKnKn4V+p/OS+fL3GmqdT2y99IzTnNCY1890lzA1kpY3vdPhHtl0A+nnVhoayNzUcC2GTswvK4RNnrwTT85Egdqe0dt/iz/5gzuzQGRk3x4/1cZy51kHjVzxd9X2dayfrvn+jLL5UTUdJPH6nZXqY48/SggUw/NTGvHDlllUhRRx+6xDlzSNZbaJwPW2s54eOYSEWuD/u9HRkk92f8z4f4s/Z8mZaI2z4Vs8c7cG+UnF82qJh/1RFvZRIL7VS0bOnIx5pJDJXrDgVOWPVMJOSwiob3nfh5T86JQ5TklzvSxTyZ9x2UnNc58/pOMv+9VDCsvxO1NqbQYpRC8pkzPgdSuPuPglstnXDQp9JVoyBwvjMF/VLYtlfBELUjmUOTaalUopZ1WLoqmcdqJY0VDsy9kcSE6Up2rHLg0YskKhcq2a+3Z1FoEnc8VdgW2/OsThLDlCoCZ9mR/SGJD4uURH2rgcXhZNzCldw8b8f1U8l4hyrZ2q0GNZ8n4TNTSewmW+LikpjtrOJPwxo8i0xi6zclvn9sKD2UxMMpSgJW2fC/tckM91bS7YENu28nYdVeyaA91oyW/s2eK3iYbE3o6xRclyiw7GFD9o0U6l1UcKjSFuXOFDbcU9AozY7K26nMXagg2MeO0KGpDFwsberYUzgvhX8uKcjebM+/55P5sl7B4HxLljdNYvhlJZ8cbGi/JJFenVV0dLGh5+JExi6ROmeELfNk3w3aL7XN7Ro0WJSIxVEVigh7fNolU3FcwYMkC+pPS2KQzG3QVHO6D0lm4SIFrzzNWTwmiRB7Jbn+Znw+nkjtZUrCj5kRtSsRzxlKSlJNOWWeiGOkim8mZpz/ZuCL1F1ey02wWJDIx9HSvtpYYncS/pZKyvaY0DA2ifWmSq4HG1PdI5G4UUoOVxiRUWLAo1JJuxRj+lQZ6HJa2nc04s7QRHISlPhYGTH6hIE3R+W7X/wtvmQkMiRQybvh1ULRzYBqm5JeRr/ELcmbKvkXb/JbuCQbOJChYkWWEaoLCbSWeHu+pjG/Mg2MXyHx/L4xZZ0NnL0oZw1hyuGHUrP18GHfPyY0UEvueKWgZa0fokcjA4MGKKm7+bto/yBB5lbmZOY3cV3O1Hskd6x+8FX80yWBi1KLFpVWiQLJZflvFfQw/yJu1k4gWuZhab8KkXgpgYOnFDhfKxfmxgms+UvJjMwy8XVeAuXTFMRcLRWXpCbUuCixO/ZRXD2ZwOzaChI7fxQlhgRu5yn4q6hEREu9MbeGgum5paLSy8DTO958P/NB1H9goMMcbx6cKRUeOQa0agVxvcrEsg6JLF3nzfCf5WLaegNvpeZvHFQhcsYmsuudNxcOVwrzV1JjZCpYKr6I7m8MPFquYGz4V/FoUCI9IhTcnlolOJXI5XYKjs79Jk70TCL9ijdTW3wVUXuT2GCu4JPpDxEjMeGsjHP70h/ifb0k5sxQyLn0lxh0OIl/5F02n/4pFtdIJi1Owe8m1UK3MpnGpd4M6fxL3Nwma2+DN7+PfRdr76Vgu9qbPrm/RPn+FCIfelNT/BHHqlK5t8kb3vwWC0plj1zw5uU5Iy5UpZBV7k1QLWPufEzG4KcgLNGIFtJnXVcF9f79LeKsksnOVvD9+2+xzFti0UiJLflG+Lmk0K6OgpNbjYmrk0yNeQrGqU3YEpaCczMFV2uYEuKayuQ/3ngsNcFElUqIlczDT1M6N5bnColdnc3oZUhGL3u8eLYpk5Vp7HnvzYKZpngEpqP7JvM8x4x/RTp95H3HfjGRc0Ya1x95k+BnQqunaTje8sZ9lTHJRuncO+rNqglG5HhnkCnvtWCpMRPL0zl2xpuf9Yw465dO2RJvBiz/LQ6p0ng80Jus5F9iRed08nt6067dL5HbPQ3nOt60tPshOn5OYZneG9WY7+LIhFTq/vLi56mvYtGpNGq/88LO8psIvJlK1A4vkp59EXWc5VlzvOjx64vYYZZB8+deGKTN4t3p7In05prnD/HhTQana8u3u/5dzGudybfXXsSd+SredczAZqIXM398EcoDmayd6kXswS+iz5gsulZ5MSXsq2jsnYVHO2/ut/0uuiRn8/xvb/xafxPJo7JROHrTq3eVMPbMpmKVFx5GX4TGJQevCi+mO8n6/Eeu13oxOKxCmHXM5n/BXsy481n8fJnD3VBvjmVVirY9chjSy5tx2ioxOzeH45+8CVn1TVSXZVF2yZvN1j9FpVkOFuGyTwt+iE8FOeztqaDp8+9izvgcauxQ0PnHT7FsWTaRrRT0H/NLmI3L5sVsBT7HfovGV7MY4qHgyDA56+3OJHKC7AV+CtutmRRe86b/6mqhWpXB7UHe9P7yU8QnZdBqizdGSb/FEY9MJn/1pnmaEV3SsnhRV8GAg3/E58+Z/IpX8OiXEe9eZVG8WoHJJSPy1Fl0nKtgNSY0JpOlUQrOzDCmtkUmSfUVjOxjwpmcDOZ6Khj03YTUmAzqy94f4GfGiVaZiK4K7q0zJcoqk+0dFZhKbL/rnsEKaXPnX3M8gzK47yv9T7Og6EUGWekKamVaMHZTBgp597tNLZk6S8a8QoH7AkvGXMmkWvKyq8qCf5f9Xx6UDPe05M78LALcldyeZ8W47Vlk+Cvpb25Di8HZhEju2JZnjVq+r+tqJREn5ZwSnsOkWiqODLZly/hsVi1XMtGhBgtPZrFA8vLZVFtaBuawyV9F1V45fy3LYdxJFUU+NXjUL/v//29tXzmzjJH+N0tO7zTDgpH/ZfFEaoOUA+b8MzmbwUuVrKpljn5rNvMWKxn/wpSZRVmES+4I6GFGH/NschRKfihMSXiTzV/zlXxbYoJxXjZlbkqyC4wlTmUx7rzk3C2mzPiRydZjCmwvmeFcI40fBi+OXKsQbrdSmCZrft/OCnG4UuKGvxf9mpWL3ONSt4zx4ljPctFf6oQGIV4sWVwqdm1P4dxDT1LsPomrkSnsP+CJm99H0d8xlWmLPFkQWipunU3m2GRPVtcqEb1Ck7F56cnSoyXCyjWZ04s9WVz5TrhvSGZWLU8KI96JHbuTUAz05FJ6sbiwOokqK0+q6r8RGqkZrud7MC7urdg/LoWhozx41eWt2P09mU89PDCpeC1ypb79MceDfrGvxespSfza58GUMa9E8ZhE2nbyxFn1Wqx6auBbmicmXi/FlZNSlx6TZ82XNokGmhR4Ulf3UgRLftzk5sX4DS+EkZ+BAL0X2ddeifV1EvjvrRd/Wb8UnSXfdfWRGBXxRowr0lN6yhtD/9cidLqefNmbt3q8FI90evbIOozOfyV+DdeTLXnNqdVz0b5uAuckZ3m2LxYRLxKY2Mybjw2Kxf50A5H7vFjZ4a3I72Tgs4k3Pup3Is8vkUuzvPg+/J0Ys8PAEluJw8Pfi/rmBqwnefM+973YIXVyj3hvxtT5ICY2TeREocScaSVi+axEUn540XbnR7FG6kDHXl7kNfkgBqxM4utmL3YlfBJHXyQywtcbRbsy0e5WEj0ee/H8fLnYILVZcazE5+6fxaCnSeTZePNsWIXo0z8JVVd59wmVokGbZFa6eVP3faVodCiZ/de8OHq7QhwrT+ZctRfVh78IP6mNB9/ygn1fRM1JKTSS2Dgw+Ku4vCAZJ503b75XiXZSl7b86Mno3HdikY+cp0y8yLz8RuQaJVFjhidrfd+K8AZJbLwie3/wHzFeaonFv/xo3NOK45MSmHHTj9Jl1uiua7DpqeZOzFtxOVFDN+FLuaZYhFzVsHe4mmYf3gmHIi1RiX7EnfwmOtzXcmSpP30tf4qGHbXYtPfn97/fxOMQHamL/Tj94ofIPqWlW1UAbqd/iUZ6LcfsgtDU/SXsrmup9A3CsfC3aOSmo6kikOvbf4vICJ3EpQA+LK4WcwfoyNkYQFtrI5rV0knMD6RtTSN2jdRhfT2Q/2KM8VDoeNAtSOKwEXXr63B5HYRfQ2MGBOjYtjmYswuMaf1Ky5WNIYztb0zzVjoWBoWwTm/C3Tgdx0JC6Sb16roYHQd6hBF4wwTlTB3rR4eyMN+UuYt0OBSEseW5KVve68i8Ecqa+xI3HPTccwnnm6k5fffq8HGLwPy6KS2a6gjcG87neyZsC9Wzv1MEtQ6ZcaG9nngRicVOMzQL9GStiJAYZs6ux3q2DIqUGtkcMSKBf2dGsk9rQbsS2UezIvnngwUHR+s5viOcgAvmPLuk59a7MF7etKB7Tz1jz4ZRz9aCEy31LPwZyqKn5qyao+eOMoxm2y04X1dP7ychPDpqzuA3OjyXh2C33IxRjfQUzAtmj4zhcJmOxOXB/KUzo+4SHd4xIXTpZIr/bZ3E32CWTTdl+SQdU62CGZljwoRXOjrkBvEkwhTPSzrMPwaizjbhwGMdnXwD+fHWmPqndDjtDqCXizFHr+u4VOhP6hgjXi/TYdfSn2Nrfou8IvlGmX4kdPkt7ss8m9b042IjqVta69jl58/cf6T2k+sr93xZ9+O7+Cxnbb1XJPHPrOl4J4n4yRFYbLBhy6tk5syKYN93G4YMjOdGuT/zp30S19rF07luIE0Wl4m5HvGMORdA4wGlou+QduzoEsQBx3fic4CWlUmBfB97XwQv07L/WQil3pfFODctl85FMMKiQKTX0OJaK5KmP86J0DsadPWDaBT9n9j7Q0P/i4Fs3H9A3G6i5ca9ABZdOSjuTdaS/Mif4x5HhNEkLSmbZI+MOShqntOy9Lofc7YeFtcs5X0v+nJCf1jst5G5NfUjMfSo6HleS6izP+Pv5IuuP7SUvPVj+LTjkju0FBb7s3/tUVFT9pS9TQDzVh4XP0x0vHvoz6v7J4WDrOeIs348Dzglmsq8fTb3Y0Tnk+JAXR1XT/ii2nxc+E/Q0eOBmnkDT4rZBh2jXX3x2X1M7G2nY2OxGpOO+eLfUToc3/uyxP+MKPhPR+U2Na2SzohZBTrWSJtbUwuEbqeOyfd96el4TthPlm9dw58+PQvEbK0O11B/Kq6cFqOa64iLDqDOmDPi1z86ugwMoJHrOWG7Xcf8/v6sa3tBGNboOLEngNmLLojfB3S02OvPl+uXhGGLDvti+e2zS6LHOh27y/w5F3hVeMvebB8RyAuzq+KCxIeedQOITLguTqTpeNMrEDPv68I0UMY/MYhpr6+JoNE6jEr8+N/C60K7Q8eONX6M1V4VP6fqSO/ny7voG2LuSR3Xdb6kZV4VI2Xd3u3tx7RTl0TSPR1PY3zpsPmS8D2qY1SMHx61Loh7d3WctPUlzuWC2HJEx1xXNf9Z3hBxQ3W0MlOz9fIt0emMjnPXVDTZfEvEtZHx3FOjOXBInPhHz6Le3pgvKhSrn+s5+ciLXlX3xe/dejw+eLHn7gOxq2UCj2t5ccKrSDyancHJW+7E3S0WnX/nceq2Fy8ulIqVqe25neFNuekncSa5PYmfvakzTM6Sbu3511FB0aJy8XJ4eyZuUdA9v1ykVudxR86z3UIrxZH17fkj59l5URViZXoelvPl/Hv0l+gQmc2NQUrWznemQ+ssWgYHs6mnC99FNjHvg9B7uFA2JBt9YRDHPzjxT2oOVQOD6HHPmdzaOfQcEkR+rhOnPufwvCqQrQpnzj/KYefDQD6cdmRxmNThg4K42syRx9NyaKcKYuVKBx7k5nJaFci5s474ds8lqm0gLW87yVk/l+K9AfjVcKFh71w8xgTS+bYzZYpc4ssDGRvhgq1vLhEpgVQeqsHjKbmc/RTEDwdL7DZm8/VxCJ/7WTPSMZtzM0M5vMGaziMySC+L5vcvS25oMlj9NEZqQ0uOG2WSMS2GuhMt6Xc3A+uxsXK2tyT0mpx3hsaim2xJxYF0RmXX4oHCkpMR6TwbUJulOy24MzmDQ01rY7bYAputGWzvUouSV1Ib78tE1SWWGa8t6CR5p3NUbfR3qsX9/+KxFdG8GPtJuK6Pp/p0NKVvP4q/78QjwmJwdPgkXFw07AqJIXpquXCrp6E0K5bRY8vFthQNo+vG0NK7Uuz6n4amI2KpfFYhKlppODyhFkHSfscwDZ8P18JwqEJcbqah+ebadFhcLvoO0OD9ujaZJyqEIk6D9YY6XC0vFzvzNKxxiuN3UYUYsEvD0bg61Hj6RQSt17C+TxxzFVVi+CoNq/bVZcD2KtHhgIb71bWwffxFzNijoeBgLKs9qsSHwRr+ulGPTV2qhD5My3J1Ux4u/Crmf9ewcmlTjreRs5i1ljjXZrzb/0WMPxnP8HH1OfX1suhxKh6PFfW5W3RRjJD5udWzPjOXXBOOkteulytJ/rZbJMXpCSlSUrB0n+gwWS+/k/PO671COUbP9Ndyfl/yn3gfqefXbSUTEg+IslFy/V5BVsIhsThcz/8eKzFxPiyejdWz00TJncoj4mO0nubS/6fCfHFf8ma5nF/uzz4m1jXUk+Ks4uaV46LtasmVUUo23TohSvrrEceVNAg8JYplL296o6Rh9zPi1hM9S+RZh6JOiwHP9PRXKVlQq0AsSEnAtLWC8y3PivGZCSjtFRi+nBI9PBP4EKvgWMMT4mVSAg3ayxnt6zlRU/r5Ha38fx2cdzzW3/vH0aBhVYiWyqdBw8je18tt3Pdtr5btvs32Lg1Fe2gZFdJSkkKJBpGKIpSRCBVKRRkhod/5/v47j/O43ud93udc1+t6vh6PGzSKFNHlXfY4JzEdU+Y+J7md9iyPp+P5tyL6+NYeisxbvS5l2mjngAS3qagtKCY+HNDIfNymphKaet8eeyZOg3VgKQ2tt0fTwDTUXXxF+YcZG8yfBgv9Mlrbbg8/86lo+1hG6sccsGX5FGwVltHsdgfUX1DCeqUKWqPhCLVUJejWvKa/1Q5QsZiCXz6ltGKrI8rvKqHWo4TU2Lzn3im4NO8VzQ51xKM+JXQUFlP4KCfc12f+aFkJOfx1RLu0Elznv6aMGgeoJk/Bs/Ai8tzv+P9/d+bMLycTxt4bIxURWlFOl/0d8aNbEbsc3pCaniOaCxWx9GAlba93xLxgRQQHvKX8OnvoMI8gsfMRqYb6IYdmYXfET5rW4I3h0Nl4EfaPlF24MDMzwcPdj6gunIuuPFOkmOTR+Jtc5CuYQepKPv09wMWTPDbOyCPli1z0zjdHuXg+HWExNz+YY8LyfJpbyQVpmqPN9SkdLeNCyCNoHCygGbI8KK0n3LhfSOXSPCh7m8O7+hmJOvDw/bs59m19QTECHlw1gerh5/TbjIeiT0CzeyHti+Ih09UCNi3PySeehzJlDhp+sHVYXYz9wIHP6Kc05wsP37o4GFVaSLNqeNhZwIGH/nPqYPWeKrTE0K9nNGEKH+O2WMKs7il5n+djtpUV4u49JTPG7bvMrLAk8DmNcbPFi4XWmLH9GYlMtEXvQyukSr6gx5ts2ZpW2FRcRDW9togts4Z0wAtS/WSL12FW6L79iios7OBQboWxq0tIMt0O42utsEr9NT1VYzzgb4UY11KqZDEX5a0Q+fQ1bSmxRccNS5TXl1IJY/6wHEsUWb+iOxa2+PqWgx1XS6mqn4/cbxzmo19Rzyc+hp0tccT6JTWd5eNBIAd5rO+PSODjcIQlxnoVkf80PnZs4GCMfhGtVeGjdroF9Itf0qt3PAxEWmCloIgG2bmtmcKB5dBzmpXLg/kRwPNvESW18fD0PuGi6ysS1eJDo4uw8HYp9ZzhY76GBcLeldK0dXzwxYBuYTldYT7I9DuwtaCc1o6zRU29BVo0y2h6Ix8uhhw8YuyRl2iLtD1sn0/LaSbTuuMHLDBoW0HhzAed32eBRSZvaRnzHZULOTj9+S1tFzBemmEJQd0bGp7O/MI2S+yeXE4yjLfXiFth2oFyGiNqjweiVjh3+A11TbJHZpQlqp9Vkv5qe7QtsUJs1VvyFdpj8z4rKOx9Q2Kz7HE7wQqX2sspLMIeEh+s4PmyggqT7JG02hrynHKSYF7Pba4NCnaXE2+rA9qeWCNm/xuihw64wLHB3eQKetjJ9LDBCmcuvaVZ8XYYesRBjnQ1SZMdhg9wIBFfSUXT7JCmwoFsVhX5x9pCwtMCkWbVdICxZYQYB+fLasic8e0GoQWmjqklNysW/9MCD/Le07FwW8hPtYDrxjq61mmL4UwLVC/+QHpX7JBtx8EKpw8UxM6q+pcFLk5rojjmC7QOc2Ce0EiLk+2QepSDhQc/0qlyO8Q+5eCPXjPFD9njymRLnN3STAnPmbeStMSxm620s9EB9kaW0N/bSjMLHPBwjiX+SrTRYKcjpK0tMa/7K3kxDRk93xJbDn6nJ1LOeGdsCY2N38n9uSMmDnBQPrmDOs87YMIgB05R3+nVPgdwUjhINOqg+U8cUZbBgf/TX1T0xgGCVRxIbvtFmVOZjzbi4P2hn/THnXkxbQ5aKtpptJE9CpNZzQq+094Vdvi5gAN3+R8UyLg0Zr8FwkU6KDGM3WOyBf6r+0m6nXbYpW6BTSk/ydbZHrFs7BD9iya+scfFcRY4Y9dFl0IdkNJmgX+bO0lT1BGT9lhgnU8PqTg4oggc8H26aFWFI+bOYPk5s4eKpZ2gGsZBZ0cXCd0cMf8z4O3RR+dqHdDdCzz+9ptkHjggPgZoS+ul8X4OOHIfuDD5N7kyrR7DASZ19NHcK6zvSAG0tIfM9e0h9ACstbvIn3nh1cXA5Ne/aJjd1yFtNi/eSRF+dtieDsiu/kkTTBmHzwE65v8i5Y92MHpEWJ3XRa0q9ihwIuw620O/mxwRvBcIiP9DvSm2cLxrgUPjftC7W7Z4OJcDg3HfKXy8He6t5aDQ5RvtW22LOeyct4//xnyBLZydOAhK+0pmEra4884CL7e00fPfrGbLLTD5vy904IstArdzECZsJZstzEfc4WBD0Vc6xPItvJYD9cFWEjljj/IeDjzHt9HjWlvY+HJQqtVMygp2SFjJYk5/orQQW3T9toCYyGf6wmP7lOXg8+gWxvm2sPpmAf+H38hT3xZvbwCJH95R2CAfU/2B/h/vKbmQ8Vs/4cPJWtqym4+BB4TmmDpylWa6/dkc2avrKMaBjzlTCbHB7+hGFg8CU3OoSH6gUyVM/6XN8WnteyrexMMDNTOIBNfT7X08eHWYYuPGWpKqZQzZYYZniu/IUIwPRzNzlG6popu3eKi0MoNjSzXdSOMhbJoZoqIr6eRPHpZImCM8kGlCCg/Nf01xvKaCltTxsOuLGcbmlVFNIg/9v0yxWLuMEpjGqlSZQdq/lO4c52HRGDPceFJChoxjJcvMMC/xFVWH8VDiYwbXJy/pnhUPsYfMsHJtERUcZH0Q5tCqKaYTCTyc8CRwPYopgrHfpnhz7I98Rdu7eegpNUfTxVJync5Hyy9zOE0tp//Rjd0kQl3JGzqbwjhzMvBV7y1t8uOjnUP4qF5FD+/zkdZOeDOumiplbVGUASzJqKRIMVu4tQPjrzCW+J+vZznWWMhiKthdjATGddXQSHF2X78toW1VTBNYzuy0t8KHthe0cAQPryzMoM56ehNjANtBUyytfkrXXZygYArI1Q5QQI4LmsQBk0MDdMXKBeu7gdO1/bToswvEUgA9iz90f5YrdCWZHir209sIV/RsAir0/9DVqW54WcZq53cffSxyw1oFC1hn9pK1sTuM1wDpo/qpbakbqixYPQ73U5LAHd2sfgVvemnkgaVoVAOusJiX+cvwRxJQG+4jrxErMF4USO3so3967F1TbVB6sIHW/nDFCFUb+IU1kmuGGy4F2qB/eyNtOeKGoyNtsPprE8lFuMNfxQbh2z6SsqQ7lC9Z41TPJ/rpvBRbSq3xNvIznRy9FA2u1vgwpYWOzluGRWut4bGnhVS8luPsLmtsvtZC63qW4YaENXb6fKHzi1egabw17H2/UMPT5ciJtkLrgjZa57WScakVLih9oQXhy5B/2Aqlo9vo9iP2rt9WCJL+QrseuqP5hxUKVrRS/xx3vFhgDUF1M43PdENIthX02lvokbkbYnWscf/IZ8JxV0RdtsbJD01Ue8wVUtrWmB/1ibwOueIy45Z71Z/J5eP/fu9tjeqaj5S90gVTjlvhxPAnuiThgtzvVrBuaKJQaxeEO1vDN7+RHrNemeWlBDPZTKKbDrBdroRNt+7RmFsOWLtaCSp22ZR00w+h6lOw+1wTjf/sg9sHF+BazghIzvPDn10L0XVnJAIz/VD/YyGsL4+CppQ/ZrJ54+6RCAj1x9WUhWhIGIXzsj7IOqGB5+bMn1r4wl1JE7uqJDDU6YSiJGPI9v+j96YrMeUv08+iPno93QMXhYTgnn5yu+mBXTnmiDo1QK7WnsBswnu1P7T2kyfuJJtjjekAOeV7YfQUcxgH/mVM64VnseZ4lvqHUny8cEyRYCjop6WW3kh6wmrwYD915XtjiGMOy/1/aH2rNxSSGBuXME+X7QMNVXPIxfVRtLYP/iszR+LMXipc4Y05EwliMn00J84bNasJ5SN/U1uwD3rGMJ2366EkRR+EHSQYiXZTWYA3VrQQKs92041D3ohjPeIY86QbxXxhss4cfd97SDbDF1PTzSAzrpeG9/hhy1QzKMf10NCF/zG/GVpaO8lN3R/vN5rCYUk3pT3xx8GnJhCr6CSdPH9MajVBs/VPmqcigOE8E4Tu/MWeFYCvZ4xKx1/U6SVA3ltjTOzpIqc6Af70GmEosYuedwowe5YxxIqY17YU4qKNEWZs7aZbp4W45WOE+3q99GmCEPdWGmOETx/RBgGW/TaGQ8dvmhIlQNoEE3hu7aduJSEy2d099/tDFg+E2NpshHTBHxp2FqLjojGsLf7SF9kATBw2Qo7uIA3OC0DHZSOk3BmgcpMAZHCNkFjC7jEiAK8NjbAYf6k7JgBjTxjibtgfklAOwM5eQxhP7CfepgAU/jNApk0fTR4bgNrdhghQ66UH+UIIVhtCdl4PfdMOwK9kA2yW+E3/VgsxZa0h1II66dVYIWSFRvDY1kkdYkLoqxqhy+8nSV0XIH7ICILZ7RQoIkRDnyGindvpGNu/zGxDDG/sIPs5QjSuN8RD1x90apYQUuy9goJvdMdUiDJ3Q8SMbaOJ7NmosUZ448zGzQKoWhvhuvJ3OpUrwGExY0g5fyWnWAFKwc5kxze65yPAByUT/DjwlVIlhJhqYgRv7heKGxsId0cD6LX20xnpQBzzNkTIgb8kEhwIn0gDtCj+pQMRgcj5aYAFJwcpuDYQmGCAFAxSQ0Ug4sYYQnLpMEUtD0KqhgF+PB+mr7eDcMxeH53rhim/OAh3qvQR/fIf1U4MxpCEPnYm/CNZxWCEyxjA+qUIVsQFw7lHD8dfi+B8czDWfdHFhSsiqJIMwaMIPVitFMUVzxDk7NfFq/Wi+P47GGct9bH/qSjOT2DzRfqI2iaG4vhgfJpjgCf9okiXCUZajwE6X4hi16Ug3H5liD0LxKDwPAi1RkYIWTkCQXOC4JFihAMfxdC2OghKJUb41zoCfdGBCA4yhueDEVgfGIjXisaoNhCD8oMAiGUawzdCDPOSAuDqZ4zRKqLISWb32GKMEK4I1toGIELHGHP0mLZIBuJBuhHMzUQwpi4A7Y5GiMkeot1hQgjzjRFTNETTPQNx7qgh3hwfopLwQHh+M8TcyH8kNAqCk8AQf9g5+CYGYoWVEYofiyDSLRDcMiMEGYtC9VsgKlntHE4TxWB6EARcQ/CCRZm/Z9/YYABpEVHU3WDfvssANu4iaCoUQG6FCfI6hsmpxR/Z1Sborv9HAT3+8C02wQGtIfr1UAAvIxO0OQ/S3LECeF41gYjzAA3O8YeQTJGc8Jf48v7YZmSKZYrD1Cv0w6cLpsjJH6QPqn7YcMoUGhnDFLDMF5biZvBvGaRoe1+EFZhCW/cffTX1QQPjnNb8YYpw80G2vxnMKgapLdcHRjvM4Bz3l6J6vLH1hRnObvxLWV7e0Dtohis6QzQvwwfbC83g/vsPjXT2RbubGc4/GqDDB30Rso2tea+fgpb4YfiDKUzWDtBctjfXPlO8WNdHt+b6Q8LWFAEN/VSg5o+a5abYKtZLNk3+SLxpAknPPvpR5o/0GyaYeKKHJNhZJcuaYIXnANkcDER9qT42Gw0w4+vP8sIYp9LEsfytALmJxih4JIHsXCEulxjjdLEExMcIcW6NMYZffKTe1wJI+JlAbXYTHQ7xx+tGMzhcbCG5/X4YiCV4uDVTeoIf9lQTltl8IpU3foioIfwNbaLVvn54uR1Y0NJE1jP9sHAf8DHpE9Ws94Pac8b/nxoo8rcX9i6zhqZOA+0WeGGw0BrRmg2UL+GDp1IcxE/6Qr/H+GBirgXe7/xKqmzN7VbmcH75g7472eJWkxXqHbNp6JQtchk/nLW6T45/+Sjg/Aef+iQyf2KH5Bez8d+pRNoUZA+jgVmgxEQ6JOaEH+8mw2bEHZrr5wS5yZOxxCCd9mk4oUZiMkIsMsnqkRMatinAODaDZNjYebkCZly6S1e3OCMlWx6X6u7RuHlOmMviZVLukVgf6+8majj3UwRqGwPwzWchUjeNQLRfAL6vWgiBkhi6uwOg83EhCqxE8WUyy//ihYi9KQbNl4FwVVyEk4IRuG4WiLC7C/Hw3ggorPFDjYkGjBrGQLkxGPahWpC1/0f28MVzxirK56rJu9sRenf4OFNwkyTVnZB8mo8PajfofIETuBttoRKZQo/anZAyyxZ6P5Np8zonLGF+I3JmMkW/cITIR8b6kcm00dEJBcx7+O6/SuobnfGxzhbv71ynLDkXfIUdiuqS6fFbZ0Qx75oyfJ2m7nOGu40dJjql0INtLmitt0N7yA1aUu2C/czPly1LJvF1XFgPGGE0MmizGxeXvAxR73mHWgpdoaimiJqFV2ibois+H56MJ63XaNxeF0SIKSJTIplKIl2wctNkNB69Thp3XTHzrgL+k7lOsrddMX36ZLiXXKOtJ13wLEMBRzal0KRqZ4SvmQzxVSmUb/O/30LII/xZFo2KdsEcA3nEbcomrowrxrTLYfLa+xR+zRX8QjmEr8qi2s+uyBmQw1PxbFrLc8MJM3nWu7NJmu1z80p5rEjMoUMarng+Qx5z67Mpv8QFV6PlUTbzAUUKPZE+MBk/ch/S6AZPTIuZDLvmHIqI9MT5WAXsKM8h2V+e8ApRQED9fRI9z3hsqTwiNe+TlpgXhqfIY+fAXWqO9sT9sXIQ23KXils8wSuchFWmGSSR7oXdQ3KwW51Bons8ca9gIuRb0+kyxxtGD+WQ43aHss55Q3ynPF6dT6fMqT64NFoexu9u00d/H6x7LI+znHQSu+yD52oK8B2XQTTIxmIKkDyUTv1zfTEjQQEupRl0K9cXfDkF9KSm0+9pfvC8zvK/OYOSuv2QrqWAs6EZJLvID+fPyEP70h26N8MfWkbyULK8Q05t/vCaLc/y9g6trvVHQgY7z+Db5Nbpi6V9cpghe5vCpvtiVpA81FXvEMn7Qvq9HCQfpdGJFB8s+COHU+q3aSjYC/N2KEJ2Ww4V23uiY74MPuhmkbStJyrNZVDclk3H8z2x3Vcafey+nF95QixcGorND4hn44mUTTL4Xf+Q0ks8ce2mNCw0HpPzfhajJ4NBu1ySnevFfLY0Knbk0Yl1XvjcKo2ktALaNsMb3sNSiKl5Qr/+eWHjM2moriyk3kleEL8kg9HlhfQ+yAvP38tgH+8F5Y/zxsJ0KSwfk0c9J7yQ9U0KcRaPySncGzHhUvicm0cLNnhjl58U9url0sI6b1azUrj+6wktIB9IyUnhfdRjMnfwxnx7KXjXPqRdbD+p+Wws9oCemnpj9iIpLP6XTT3GPpjQLonQUQ9JcYUv+u5IYvXWB3Te2hcbmySRPPYxRdgz/RmSxP7eXHIU+GFxiSS+XXxEe4xYvxuQRKBfLh1f6w9DcylsSHtCVssFeKkphdSKXBo85g/+B0mM9X9E63ME4PxvbzKPSPyzP3bnSKL7bQ6tOueHi4mSUJnD3su4LktMCgsNcugw48kdq6WgevIhhe4QYtZOKVRMzaV/TPc+/ZCCNR5T9aIA5IyUhsbMJzSkL8T1k1JYav2EDh4RIGqzFLSU82nIQYjdv6WQcLWAtjM+/5kghfEnCuidMACDy6Uxzb2Abk4IxMON0njy7yHJHw3ApU9S+FD6gKbPDsTiVdKwuptD424EoLROCm+Cs+m9SSCSNkvDccN9itgRiLpBafRfe0AnxgSgf70Uxu7IoUgHP8iemIS3byupvMsXewsmobeniur2+cF4hBzct1VRZXsous5pwuCXONyuhyJHShM/xkvAYkkg4vXVYSPeQzZ6gXj8SRcqu5qoSIaP8M2ECz3X6cUzHu42mOP26+v0oZQH1wmE2bOTScefB0lLc0hHXKMRc3n4EWGG203JtH83D/EW5pBJv06zq7noeGgKSU4yLT3DxSlRU8wsv0baa7lQ5Jpgw8VkErnNxZsBE6Reuk4yeVw8djJBWWwaDehxETnNAHYXUumUNhd8R30MrE4lri4XFar6sNNJo3/GbPxUF9k2qeTM5leG6aE0/SZtYc/GfdXFxekpJLDjYvi4DkwephDHgovR6rowdrlJomz8Wl4XHoWs14CLnXN1UfkulSJ4XKhc0sHGZal00oaL+ts6aBBPow5nLhRUdJBid4tuu7P40TqQ+3CT9qzk4kKzNsYbpVDHKi7mLdFGwcsbZOXDxbFcbZy/e52+sf1MttFFXFUydTly0Wiug7/xyTTA9la8TQdh8jeofR4Xnwx1kRdwlcax/ayJ08GT8GskOoWLtYv1cMLqGuWJcjGxXg/ug1fowTguLGfqAXeu0AdJLlRjdfF42WUa/o+Lp5v1MHH6dRLX4UJmmz70F9wmYfwyzHJWQLzkHbrVswKbKpUw+OMWrRu7Ep9jlDCx8iZFzl6Jt8Ip6OLcpli5ldDzUELhwhtUkbwC/25NgWbBfTpZvwKHc6Zgxp8c2me+Et/GTsVEZZaHhYyvahQZI2XREPNfb7YwHe66RytlBKgfOwmhf1/ThlYBLA5NwpZxpRSVIMTO/5Sg3FFGmb+Zp3umBJWw16SUI8TvTEWovy+lX5VC/LdcEccbXlGqaCC6Kxdi8svv1DU7CJar1HF5+BOdcGZ8WK0JxaBWGscY3uyRPp5F11Ii8xEJygboCK+huyxG9YEBCvtqyGZnIHa+NMAi7WoyZvk/6rohXMOr6Fa7EDbGQEp3DqU0CrGFLHBm3n1Smh+AmhmAu0g2eeoG4O4VIPbHPRorzcYbLDD97V2S4gTAQswCifJ3ibc8AI/eEFxqs0hS2g2ip7g4si6WCne5QjOUi/CEWNr0yhGSPGvU3YulmBY72FlZ4rrlBZKVt0d+F1CpH01qNXZYa8fBf5fjKJQxi0y8JUy2J9GZWFvcPs3B8Z/X6H0gH+NVgbTl18k3mYeLf82h0nqFFgRx0VxpgqeiV2g74xbpBGPMC7pONYu4cGOe+tmTFGo35MHzvSbq/BJpHXhok9fEvqKLtCOeh3JdTWyLjadl63iI1NGEy5xEWnCMB5HbGjD8mUDfhDxMstWAmu5FmqjOQ4q2Bja8SyKjKTwsa9TAKuElclrOg0SaOhrPXaSAbVxcPb0Eb1oZ2wRwmRfThvX6m7SVacJTLy0Er7pB0sVcyG1VR8iCq5QpysPmbRr4EnaZei/yIP5gEdQVEqhd9n//q3wqQh/fpV9PgnArTBO9j+tpcnsQfLM1Yfr6Pe3KCoKWqhaySuso+ngQNk1fgjqtOnryIgjPY7Uwy/E9qeQGYRl3CSbPrCVuZxAqMrWA8+9I/30QxmQtwd/FNfQzOgiPXbUhtvQdDRUE4eg5bRhKVZNRdxDqdbTRosF0lcVnzdBBnWIlFbF16KkOsj5V0KG8IFSJ6uLdwrf0JyYIYVd00LK1iuROBkGjQxeiL97QFke2twZd1B+uokGXIETH62Ak9x3dtAuCm682rkrXkR6CIDFJH5aVb8jifhCmaeqhP7WcvhcFYfiQLtSvVZDwqi/k9lhj09IYWjfGF8cX2uB4aAwNevlAr9IG6qtjSN7KB/v5XHx5GkvX73hDnelvTgiLj/HGnxYu7qbH0ioVH7ws4qJN7hzJjfRBswYPVS7n6ctVb4zM4EHW8QI5X/AGGGNHrUggkcfe8FrCx6nviTT8wQtJ6Xzc6Uwg3aXeKN/Ph4rsRerJ88Yofz7sgpKobi/jwPN8LNOMJ4NyL8xU5SO98zx5VHoi9ykf1nSB5ld4otWUjzCxc2S03BOyN/n43HuOar96YN8vHkTTY0hC1gsPMnnYPSWW7sV7Mc7nQbkkjvY3eqHKlwetsFhqWu6Ncft4MPM/R6mTvRHVwzQ0PIZ0mEczHMeD6cFoalLyRsppLkZsiqY/pzyxIoiHmWuiqbTOA00ePBTePkv6fd6YEMqHzOzLlD7NA2M9+OjIjyWPaFto1JshWv8MVcrYwmOuCfNdp2i7sQO4My3hEB1Dl8Ic4H7IEk/exFCgri0mLjfE/ZITdMePj2YjAwiMT9JN5m8uXzWE2v4T5HOch2PGBihef5rSx/KQJmuAkSpnaUQl6192+rjnGU2XTXhwZHpesPMM9b7hwUtGH1FlpyjyAh/+6vpQOh5FYSzG/L4eJJvOUNchWyxyNkTHohOkf98WUz8aIPzWcXqRzsWiN0boso+hJZu58JYzRlx3LIlOsIVkhTHm55wkkRFcOJ83gnx9PFVt4mLmWX3o+MXSqZ6VaNCaBqeWOLIp9YZ77gwcPR1H1x55Y4qSMhomXaWuz0L4HZ0G8elZdPZKAPNw0zCtKIuKxwVimcc0RCpkU7/+OrSOn4kit2u0rzgE1/jK+G/rBeJbhUBYq4yzKvGk+G8NtPfMQ8Ka67TUdDWsxVSxclsqpaeuwpfZC/Bh1j36LzEYGUrzccr4PW3YEYwL6qpo73tP2muCUe6vhhSLOuoJCYb05QVI9K0jsZRgZNupo0f/HSm9CEbLTQ3w4qvIpT0Yo9PVsbitigpHhWArVwNmIZW0aSgYnSJMJ/e8JaFMCM5FaOLKzwoaUxGMuN+a2Pv3DZWIhSDERAuZ78vpK4t5nqMFrkkZmbGYIK0lcNcrJ5uDwchq18HPrbmUycY1j5luGD8iSdtg8J7povDRI9rOD8aKIl1MmPCA6pWDELjIEGuciijTUgjZCuBMXCLVMXadlATME8bT8wwBylwtcCvzPNkZCyAQ5WCf+DmaNFKAKU0WaIyNoUYvfwx3cbBOPIZSJfzRGm6J0Y3RJMP1wQhGt7kJp+jMQ284RltjhvAUjWc8L/vLCie8o8iu2QvWTFvGKJ+kaOZBNGW5GONwmvkFDxwbycOXrDP0S8IRzbd0kfntEImtdsSLjbpI3nWISlockMi+q2ziYbpnZcveo4f0USdIU94O5d260Iw4Rsc/2GHRCl3E+hwlv0oHdJXoYobKYdrtZ4v2GE28G3eGdCPtoVShjvuNUTT1nT3E1y3G4cqTNO6xA9reLsK9yij6WuiAjqmL8G/TSRodEYp867m47xpHpf6hOJIyB+fbYkhXLxS3xefAziyG5hWEYrfWXMw+G0Nzt4ci48xs7P99mlbyQlH+exbyG89QimcItD6oYllGKtnPD2J1YYRndWl0aFoQ1PKMcCQvnX6K++GOvBW+zT5DQcwrpeVaoXJGFJ1b4QN/jiW4lsfpKAVi7l1N7E9KYh4wEJ8atGDWkUCfxwfiyFNNBEgk0sORgVD5oYXHay6QvGwgtgTqoHhCHJ3OD4DHeU2sFVygtJMBmLpWA5X7L5DgRQDqYzTg8SKBYhkX+ZuZovFtEulP9ENFLWCRfJQS3vtj46j5yBq4THWf/CGiMB+jWa2NchBg2gRVDE1NpuUmAvztmQ8F+StknCLADBk1hHpeJadLAtizb9+em0xJHQKcua0GG2EypY4QYt0/NczZeJW+eAmgPUcVIpVJNKlPiKHORchdeIGMGNc1Fyxidx9HN78LserLYtS+jiNN5t3OnDTDxAlHqWaNL97OMcfnoYOUsoH1rz5zbHtwiLZNdMWNa0ug/y2CFlzxBsmrIXPjMdrNes02P1VUaR6nu8t88Gy8GrK2HSe7YB+IGqiixPoEFS3yweGGeVinHEUhHF+sYGCkmRdFsn6+qApQw8G3Jyj9uzfWn5mLz1+jaIq5P86KGGPZhkPUuccHJ5cZM6bfT8eZl5f9Zox3G/bTWr4PEqOMsCEkkjo2eGH/eX1UPthHB9q9sEHVAEkD+2jDNG8sEBrgk3wErQz0hq+fPg4jgpY5eqP3pgHmG0QQV80bplsNUDIjgnr3+8PXywhf8g7RUXMPqFrqYvzrveSe54GSPF2M7d9Lyv1euJWsDrulB6is0RuL7NUheHGQpM18EF+zBNiyn7LLPaBVoQu/4b0UwFsJ8tGBbsRe4rrbI+2kHramHKEqFzs4i+vjvuQx8omwxddufcy5d5w4E+0g0q+P79ePkV6aHSap6eHgsaMU0smHhIIBPH6eoBOb7LBXoI9fX4/Sr/t2yFTRx9+DRylzgh3GihigN/UYbWe1LMPWOXP5GI0fy0XyJUMon0ymzKlcLDAwxDjdG3S11QYTvuojqeYyyTO/ph2pB41DWRTHWCX+jyHKSyLJz9MHlcVG6DgbSaf2MAY4qIc4zj4y+OSJ7HY9jA/dR5f8PcEL0UOr/j66XOmBJVW6aP63l0RYXx6apYt/+XvJ5uFK9L/QwbEreym51RYZIQaonnuc/g9GKL6n - - - - - AAAAAACAAAAAAAAA - - - AAAAAACAAAAAAAAA - - - - - AAAAAACAAAAAAAAA - - - AAAAAACAAAAAAAAA - - - - - AAAAAACAAAAAAAAA - - - AAAAAACAAAAAAAAA - - - - - EAAAAACAAAAACQAA9hIAAIITAABrEwAA2xMAADoTAAAfEwAANBMAAJ8SAAB4FAAA+RgAACEYAABOGQAARxoAAFAaAABBGwAABAIAAA==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 - - - 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 - - - - - diff --git a/test/b003/README.md b/test/b003/README.md deleted file mode 100644 index c8bcb8ea..00000000 --- a/test/b003/README.md +++ /dev/null @@ -1,16 +0,0 @@ -# Left atrium model -The provided left atrium model is collected from the Left Atrial Segmentation Challenge 2013 [1], spesifically case b003, segmented by INRIA. - -The model meshing and probe points can be computed using automatedPreProcessing with the following command: - -``` -python automatedPreProcessing/automatedPreProcessing.py -m diameter -i test/b003/surface.vtp --aneurysm False -c 1.3 -``` - -Note: Aneurysm workflow is intended for artery models. Therefore, boundary conditions for other models will be wrong. Adapting to other vascular models, such as the atrium, is work in progress. - ---- - -[1] Tobon-Gomez, Catalina; Geers, Arjan J.; Peters, Jochen; Jürgen Weese; Karen Pinto; Rashed Karim; et al. (2015): Left Atrial Segmentation Challenge 2013: MRI results. figshare. Dataset. https://doi.org/10.6084/m9.figshare.1492974.v3 - ---- \ No newline at end of file diff --git a/test/b003/surface.vtp b/test/b003/surface.vtp deleted file mode 100644 index 5d9f2854..00000000 --- a/test/b003/surface.vtp +++ /dev/null @@ -1,51 +0,0 @@ - - - - - - - - - AwAAAACAAACAQQAANAAAADQAAAAmAAAAeJztwQEBAAAAgJD+r+4ICgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYgAAAAXic7cEBAQAAAICQ/q/uCAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIAAAAF4nO3BAQEAAACCIP+vbkhAAQAAAAAAAAAAAAAAAAAAAHwbQYAAAQ== - - - - - BAAAAACAAADwbAAAhm8AAJlvAAD5bgAANF4AAA==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 - - - - - AAAAAACAAAAAAAAA - - - AAAAAACAAAAAAAAA - - - - - AAAAAACAAAAAAAAA - - - AAAAAACAAAAAAAAA - - - - - AAAAAACAAAAAAAAA - - - AAAAAACAAAAAAAAA - - - - - EAAAAACAAAAACQAA9hIAAIITAABrEwAA2xMAADoTAAAfEwAANBMAAJ8SAAB4FAAA+RgAACEYAABOGQAARxoAAFAaAABBGwAABAIAAA==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 - - - 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 - - - - - From 7c41d2e8e26b2aaa65f61d122649cbebc112da61 Mon Sep 17 00:00:00 2001 From: EhsannKh Date: Tue, 25 May 2021 20:29:18 +0200 Subject: [PATCH 08/76] reverted missing files --- test/Case_test_71/Case_test_71.vtp | Bin 0 -> 333848 bytes test/Case_test_atrium_07/case_test_at_07.vtp | 51 +++++++++++++++++++ test/b003/README.md | 16 ++++++ test/b003/surface.vtp | 51 +++++++++++++++++++ test/processed_model.png | Bin 0 -> 192857 bytes test/test_pre_processing.py | 36 +++++++++++++ 6 files changed, 154 insertions(+) create mode 100644 test/Case_test_71/Case_test_71.vtp create mode 100644 test/Case_test_atrium_07/case_test_at_07.vtp create mode 100644 test/b003/README.md create mode 100644 test/b003/surface.vtp create mode 100644 test/processed_model.png create mode 100644 test/test_pre_processing.py diff --git a/test/Case_test_71/Case_test_71.vtp b/test/Case_test_71/Case_test_71.vtp new file mode 100644 index 0000000000000000000000000000000000000000..b5d43aee615f50d11a13f755d8d89eb9f81836c7 GIT binary patch literal 333848 zcmdSAcT`o&vM-DxAi)FzDxiocNup%dtO7(3M3O`i1q3ALARu7GfH`5#IV(nFR+$hL z5zIN~fT$Qz^jmxHv-dscopay$-W%iIao_x7joCfBdsSCg{LPw@;J_j73CXd#+4(5cav6;UOlK%g{xc(gEosb&)ZwC#_&P+)Ex1)X|Svtth+QROi{_>A){Jt+K z>A&$v*C#DAB`R4u;cqv;@B0r*CBF@D$;^z({~Kf7lhdNI2T1qo6O|(6^Pe;RV#vU> zl=QUJ*gu$}ryKX%(%FJuRC;=BYD{d5o^C)?>X_J}3DN_xFmtfCv9h)uVC`UQ^B0|e zJdYat`+-^fep&zZP)bxPFcK`l={`Z`4_w?}$ z9Q6MjL+tJU?^z--|Lds#1EdbXsa^?C9)-+=T4>|Gkg+d&~ca9sTY1KYYZ$e*UM>J6PFS{GBfRv4HviUn>7t zCF{SKK+Av9%D)Jdx{Tifhd=3+{2n3v+4>*EW2=Ai#eZ$#-%m@r{~N8vKfB1k1m)jR`QISP zR(6(_|3u+m1pXGmNW=a=L|5AQEl>Ha@kjrkag4;}Z;|+K9lEipqtjv%QpX5-nNfLv zM4zMDACUR|It9@O-Eu8bB&z#b$&pjX(fftOv10L@~C8EdwS83j@k!Sll8bl(t4VT zWv8Z4qhtc@-Ia>FA}3Ra)uZtF4qx~@{}Hv{FdDaYSSpm9d`1sWN1~Uy6a47+kY=0c zi97qma>w|`uxy|Y<@$uO-L6(})Nm)g=1?9P`2$MyOvNVISnhfHF~pbZak~kFaPV$p zaeI76-r_S1vrnB8Lle~aQ;{!ze|l5w^{X4dJTwH?=2nQFGQVj3)8V-Jpc=8hBD)R> zLS21X`VdG|EV%P!RauNGW7;urAP;Df$JslF)3J(Ro?`Y39_@DE8(J3lDXm^&V<7N% zzyA2G@w=qlTwoo~{`h9c4~duAK#1y_jB#(bQ=Mu9>=%OZ(D9>me}M@1TSBlru$qEj z4g^+C#^Z)NC{NiN#9v8lWVj6+b*2k&J(-QY8B{Bl2`0}Ixu&`XY9}efW5*=E5>g52 z-)w{dG6~%GbOX$MaEdN>i9>uHLe{x^$zXas{(2Hio#YZZXxs$RPreRp>XX?~=c7=$ z<1l!sC-IBiaN&AgHDrki{8XX6sI{^lDv#$2h11e8JZ}g2q`E+mO)?rk-cIU=yoBcl z8JKi)E6q7jO&xE>Vh7t$db{!m4Lvy=FK*YPPesul^38|m`D?((GMRTA(t|da_rcNX%^~J(5Wyh9=WSMe!3Eig-$z& z=FTI-(g@sr@-1ysm(Zq7Bk^qJ3u@TsLbNjuPx^CcQuQKm z;^;g$*yjPAc^QODi?)HJk zb|$}u>8qmH@X|fuvgSu9&WYfdG##+~pn{U+!#L{x4#7|HKI|M6$(v1G!6(NDgEUpy zHK8XR8tH}EbGq~6kzd69>7h6?Pll&O8I;g5it&aZ1l)Q2y;U{p{x{mNsYL3bS=| zdsn46&@>ZY%dIB+-T}N&zY~@}cq?487dT$hA5(9(N`87<<99h5E-D)@YIWAa)jz%X z?j3ny*?TLTwB439*7Oh+ueo6RE&BZWEsIUo!EALw9$(#4g^U#utTE&*SiG?Z6(e1G z;F!;sCK=Q1iNnclLmtb^tH6dgfpp0vpZmnOO6G2nP~g3MzNT9v9-A#o@eiW7to}Lq zA5x}kPcyj3<~dYoCqn}}#k0}*^E9+!K7A~W#jO|FYGIE`(A=| zG3Uj~ck}5+OC~j&_A5@~f_`!o$JM z6xe1Yi{=IpvbuqiU&ZjuE5_9MWe+y?^uWE5CS)8e$LcP@SaYdAt(_pxCTT(VPFoF9 z1{b29Y#Y#76bx>M^D$z2Nmb1mgr4v7(JJbQ5NAIg@Z~nRw;`Ut6vaRv4TOGgvw7Z& z{Sa!O0UtMy;rj^(VB@4*_+USVM;Ra{)!j`|ze%C3GH}Ku-oE z7uEN|J+~9ceu^_6=-m^8%JOJ)7ay+QuY{o;i%Hn-$7bi`&`qX{=KBV+`_pf*KX@a= z%O4jebj{#Pd-p?AK?L+)8_zq9k{`kq4x(1u^ z2yJVu-|tN?XIOBCsTDp*izbsdPW)0u9}it!41I3(!c!Iwyhqps+vpCQo*2R=^4p=~ zvZoL*Wf-TXuYqs7b+CS$J%9hO4+bbKfPlWE`F+=8g5{_0>*4O4d?rmR*iL5;WoX3`OxM=LZ^PRoSqZLHcL9etBP#A zZ#o%R zX)fu?XH0zgtKmSh_Aue(a66o9rw-GN(s0d&^$4I<9s2N`0-UxyAkyR^-GI;a8y)dzOk&xMx%AYs%=MRr0SQhZC$~DDuMw5{@4H^vD%$aaA6VHs>R zV=X)_zbB}EPhh{K^Kid)fxx|obJvk_Xw}bGxVR#UEA(E0>Gx(~icdJqOiI96qbq3X ztpw12nSf53JE*j3C(O1Qg{v>@CllMTB(zg4rL0O**M){CO`;Gnfe8^>Jux zRY6GaGoo0I)xNkPV&hO9F|&u7-$cFh=g_;wJgE$P8JBiy0=PgiW5qs5a3$AQ9^ za6I&*nN+6(wCz3$Z#`(D<>R_Sn~y0hxwee5`iIi|tfMffHHrhO7K6pIK@j4U%{rG8 zp}2hoB>BfN)lY$6IziwsWb)#vMQ~}s83^)<;F-hMLQYHo7tQ_*lkP4j?G{(I8Ki>q z_4d+6YY(<6Q%1EDt7+Hsc)s~|7uAJlQ1Ijk_7xtG;pTj@eL0#b@eoCQn?pZ*l&M{K zAy&I8(1M&)(Xp@?kN2$-HIEsIuk?$tf5+$Iv#}qX-g}myVQsk>;Co59v9K7YM<1>V zz4t<>)hNaTYpq3P+iha2PaaE33c$aO3ca!@;Pu=3f|X4GEgqZ4>Wj2tIP|9Ki~{`f zT#*ci4H8FpD8bx|^ThSm3&k=?F}jFVVpca(*p^v{cHWx>^(phg^KlmTs=X+z%a=gd zvO*kqI$W|`?m8IU3B#GmYvELw7H+v}j>FELhYl9%=(W)mSKXNpk(uu#me)$KX~(9j z0(dEmXeq*dp&>$((k9{buVM_|-$}5EG=qlN0`$K8QMl{4ov!s5&9|?wqXQpB+R%Rx zhhJ#NACEtz$=j{iWNc@iu*w2w`K%COusxQYv&EdT)2sHH4!|w?78vqjobXlC0TqlN zLC!WKd{Wy3O*X%RS3yQ-_e~QuzSo2LbO9r@6tQu8G<2Pxj=Phm&{v<%FsLjC9~l-> z7hNT2n3RLusf4C3QpLQj#T3x$fj{MC(G)7E=-Oa3UfBvO1FqAf#jY51>7lUUY9=0U zEGOriqoDJQRO~)-Azg{{!u$56;Jmp5ZXb-O;^zq`rs!e4ks-F+S`P`;X80{m568<{ zgWLgU+;L}u==#VH6|~gQ)YOR*?1OMYr5xHk-&5{DWgfmNc890e-_r}75ge0v0(QLu zcGOd0+BF_VL>cna8XFEe6+voK_EtTy7I8jsL)~ApyYjZF>rikwKmjka~DQI)Il6IZ&7Q2PT;Jv)ZWMH^m z7;N>Owket7*wZQ;eeM?Jb`HQk!6)do!xO44F+jr@Z5C^K@uIu#SRb}s48GK!p9`V5 zMDA^s+2IS6tQ3X2PfVbgWfin4vn|O@NWq{kJ-E?%H7WT>Q2mz!op4j&v%Y}{Kh4p% zuPIx_P6dx|9k4cCk8K+i(L~C}?j3Y_hR#^nwfrN!cwj8(Z-~VA&zi~p=R6@RG!k{( zuaL$&C1L&fcsx~V!|~(m!Qqe^Uapt$q0(Ns#BmBd2({vwJ1@eSvl{3eV#PgG`{Vlf z@gP}xRLpxkg*vw6pn1X?VMxI~O6!q^tCGe^-VB*Xt1@yha>8U-bEqpj%^8H--tL6k zy1m$9pEZ8<3Wr(dXK6xH49-5$mUUbA08jM93itNxe!d5WZPP@z*X{U{f*P91>0wR( zlc4eIllXaSB08;j0v$)3p>IEjBHw=snhREv*Rfz+(CdtFXXXRiUJ--KYd=Y5mA<3% zccO4t!bZ5!)Sb(_I$=WHMGF38i3Zl1ICjMzDj7Kl%R4Aa*WX6(XGwLg!~qSH!+4UZ z^c>UYQ-7si7=OAiKWuymZS5s!u)Qz8O80>fx6WwY&Xn8OHG{^dc#LuBLgVaf=tpB1 zt{?T9xMTvIjT?qe=j7S?vk$G28HW8AD)D&}V;VDh7d%WJg)5XR=t|uKFzGl9Cto{A zn=a<#j6>?M)36`4TbYf@gK}Yaof#F5D8L1Vde9G)Y0ljU_OQD_8EvM)1&<xT+) z|3y{W*-=s0)wTq81#S|rFZZO+ni=dqw+!aq?@3Rl6`(_VC31Qcfj13xp!@d^5WYAG z0}e)1jtM;jqp!x}BALOk_JP#z?LX!ed!+<7r>Tki{Fe%M29@9@1BI%MM=pZoWsKBz zIKWZ6GBDQ7zzxlwfW;5sOv^z0(B(Y{+tz^hs%ZRCw;Q%5oCiG@FAOk$3+0L36b1XO%yDHLnK2B1qE7IExn) zs)$+_SJLFjEDrT~NRm|!2rCs>vP6chO1-f@WGkIg`$am5PN;Fek$ySL!MehZ+`Cf% zcDr$w!qYwRu|_it>F|*{=iG+8LN}DjJPgO0PD^gjPDSf`2OuTSSXekS6?OYehn02< zply5-E;(};9((VX7|cnUkkUd1mpgzBGqll z*Nk5mW3tIZ}b_;ohFC<=rf@BP4TRxl*1q~f@SWi+w&7$mh0$3vYD z5;e_)!A7xoVSEME$vl!wnVE|nw5L0H}l-;MPJjPK?|FPha;& z|ChR$cl0^Pe>TE!_imV=@&ZhkcfkYOCHUrJCFq^LD17d<9sF;m@shU_;75WtUkYx| z>-^Tk-Q?jM=6Ieuxu(FR?H(N8sK&+%mqBXwU@o>*=KcEHXjIN{SYVmN=R52s*>-!O zeZ?rQH5AGH!v`2J-J4$*R#KY#0jQZYg3n%>D_R&8^5$%Nm=(QIa%xE-8-H_x@*nzQ z=NE;nxXltMSCtx9Fm(&7KRzC$+`+s!O?ee8zb3 z=h$)hwn(3xzw{PI*_)x+S4TV+n=T$SH^B)u12}l-c*qTGhtuT!_~P~HaQ|CRoIl8k z)wJh=4q&em8+tPU7<}t3Yc+Hnz^3C2Y=L2*o`YRlfO>%k{OT zVCp-I3N~kQgLWUdGt5JnI;w=9i9>}kEnRrXaSy&Rc@q8HV8RMF`?2+e12pbTe;%)A zz!R1CknAx%j%YQ(sO2XpO|>0oNW9Q+?N++w+m^E)_@ED$)2MNFxMIE$%GpU{rDSJx zP1DBLro|w9^1%G)&iKq~I&^)!OU$b;!tTA#i4I@2=@1s;q_3~VF=s;IQ{q@O@_#GL z+}a`>I$VU~GlB)}A~moWH4dK}?GYB#?vy-zSAv}ehC0nZ>5kix9=;0Syp*sgm6wP?kJX0?3a0#kr1hH3D6=hz^6Z9^fp*PBGGyucmqCC*l01k?eQ6oT&eOa4rku9=GpOOGP_0s*-RtTjNC=WA3mnA9kZZ_FdSC z9WKj*&DUGt^udweMzu#J`8-(sc@A8xO~7}hLt*LsqhPHSk2)2HDDzhn>|gJLpOp?% zr-YkeaU>A$lwBtCL7j0>-@q z@je|Jaf1dvAHsX>uTy;KJ+j}%Q%32P&fLU%*f!{ubSb_2|w7R#E}$sB!g4V{#arD*eLPAgZS+_w{OOj8!x9LeVOcM70+VPBYZ zFP+tN7DK}ZQ}Fz9fl0xYC3tgJ)WE5j2|sx(Jy(nNJAgeaB2S7@#RnP>x6qWbzKxLnniT!(?Z&C zcLY|SAqx1ui-s4TgIkB9`F=n?jQOsFW0d_^yEYWg9#=rsGGFE&MX=;(7O!_JgB}*0 zKrgx*zW6Ng#2YKYV`~>I4MMhFxf|vUxkIA27w$~BPwMCOMC&34oGHa2mh_z~xf`c~ zw(WwkO8JI(;GQc6Ug(1cJ#Pprr#HfJ<0xKrLY2p__GI&jG0>-r35S{6uqr1){T)p% zI_Ac|hUY-oh8%SAo=xYp9K?ZcQp_fJD8<)J6vyAoMo+~>WWQo@)%bIUEOWm-4+&7< zb(#|H5qY0Rw6x=pGY&i?NuKYld`w1pl~j~l1NE~*+4EL8%$XH|N5u=&G5Z3|>+%U+ zZuQ_ZJDv+UXMRGf!3ac+iLl`32Vrfc)DJDpM%Pids`f5k3}2ga(DQzzP#IVT7v5#z zvf5?h>6pb(QP~DB9WcgG_m%Pb)z475*BI9pbwT$cd9*F>hSphHIHYqg?%QWDM$Qfv zpU>SzSI4HZ{){#t${izzE=la;(-wk)XOpK_CKvTIgf7yvGiy0RRSQaC*y?a}7*R(v zlQ+P+{s#p6Z^hVk&~QoU$IX(xjV0*0$yu`3(Fmr$AB%zMhOp>P3pkzYf$Ar8v9e96 z_)Bgu1y3ws)&7y>m{|C3!kx2u{8KjzOb>;E z;ete-qPh$2K4=kq>N2@{>mt~{cPOf!S7YCOU1@NSD4b_>pNwX@(XZ95^ki-zH|?DW zO+(Vry?G7IGVKCu)Z=mWhf_4G))HbLcV_>7gSq9^6xyCLfp!Gs;h?}^;j~{*vin+y zE0TAM=Do}XjmcNV6(ft;-e(<5eY=`eonv{w=2S2@3gn+Ve$d1{#?Wt(8mH8Fvv*)T zuG&3_+&&W(Ir`9j?@-P=&UHZf{ zcmp|Xh(g)n@b2D)eC%4Lgb%|Ras&q+hG ztqW;w(^bJ@eHMmZSU?#I(s@Z_8JV3N2KP)OxMtcz%B;zUh3ixJ=$`o$b}kd@9{qwD zZ-%mE?gn`M_5^g)O~S^s+v3;Lvbf3B18d|CLus}S7JHcD`i}L`d(sz2gVqwPo}(@~ ztuas7Mp6tmY?g4(;k0mk`8eztC8+@(O2WKj&V3$3@i-Ew)_qB6?eIYn6Vt(c!!7l^km=5xTg{X*DWZ?Gzu zPm69RqVK9%bmFQt1u19Yf!4`%>}V~$o4gCWREF~fDyQ||ZNb_so!h*sgRAR0QC`|; zymRtCe118X@_P=)!)f|F;iDd&pL2^=-dAS(cR}bdc(iDg{e^Caj=&@P`oR1s4|;kz zf@K0;!=!DK#oAX%3^J$Sed27|`#1@A-=9G}YiCwXO3TKrPs-`I6q#H!V<>h!xK7-; z*q%Q`SfaMMOjSwQSx9V3;E6Tog)tx8K~ZHauQ;d;)#oO_zP&kou=0zb)%6*~y2Ws; zQlubfWQjjxjoAOd0(iXK6z7#2^1wEm;g?JwEd6N5zbxm#4^wqk{!XNQ)t9~HlJQKH^E+fvocLM~s|D9*n7zG|LfF+W|t zjGj#GB3eGo;vAz*I z(c|w9~sh~N6RQoDGg6P9!MuQtR#a`W4N8g z5}LJsASwH4RQ()O$T1TN@%)sY)ZOW-kpD0rPfLu*e`;s2^{fD!nl$XDtS5JxFfVDRpiC;o60NX zTI5bSURiwEHJ?1cwZXd{jUajBfNy?$fynk9aPkjRoLl@0Jbx+S)93xsKzl4LRY>BQ ztJc7ym?;#sbu_n6I|dV4+F|z2N2JihiC=tM2L9U|c~UPOZi*hj$q}~LYjrQt{H1wJ((7aC$Jd%^UG`pYAxduQ!fgw^n$zrU_gxM&hn^=fv={ z{#=<}K~GIykkh;Ig3W|tEG(@M-#@p<*3^llvs52HXd!0LKyma-Bh+eZgDN9miElSp z;p4q#SX{D<+GQAH8v{K&lD~mw+FN5(_7-Yb9l}3W+ya^HdnkXC8;|R(gq9CiQS*@? z?o#st{NHuqkv~1rdt4&?e7Fgg);se^4^=ewxC&d7y?Dj0r%*lU5ljy0!usbeao5aH z9A07#VRvP?@p1tke}r(m&m3{|up%tFxLzn&_eoSAVDV8vZoU`3HW_NE~ z@AOD4RsKLPJA|@P^#o{5s3)Zx!RT`M2wj+Qh0akJHhOHNoanY}+I0v%yts|XaTp{P z72uO?qLY5>9pUEGW#m9BIB^ zO)Ab~@cU&TmD3$@xY`i0w{{>t_~4FFvbt>jdXexn#20Tht8*NGswz7oi%Zhil1XoG zTw=c+5*5-ppzegQ)>sSN?quNpa|>yOcJHHyS7f1O@JgDU=u4$_89X9nGBlL?Q%igz zTk7nEr8P5YLbg$kGsUr%~cuNQtW z+Bq9P6-L75(wXqYGy!{ETnT-eXHr|&AYQop6QmZbfhFY$9KEp=)B^g!{`Z-DHf#oL z{<#QprS*y(?@a*89DomsbkO<8VOTynh-OIfxRSC!HqO2SX-fjJbL)Om)m$fB(az#N z1D3;>MoVd&k;(@)9|m3BLVkKipp?@oVyI3SR!mEvUbjDj;sP1`ILw6o-zj6mqF>-{ z)rW7gI*##bgM&o_mI4U)ZMh>K|8fU*E4IhvA4Otocqq%gQouLkABsw*(fm>8B~0%A zSW<)|*m6i)yt7dTBlbCPhb>KTTY8@^y}z}&2^NR7#cR_1yv6G_1iybtL#H2t{4su9 zlg|{prVeb|2J_V121>z3*j4Pw-}9!^ldK$`s7|8m;bD{)p2cyBDdd^4fbw6B;w>@ z-J&qCSPI{j^HeC3AxKPkLVTg}?oH^*SqB!%uI&Pir%lE`1 zP7n4vA>QoIkDhE4dwhw<^$MDl<$0PSV-@lB*7kVR-2g3Pw^Vtok;Ul~!m%+c6EY*x zctO9ZaHBB^b_J$#cI#X?rhOecst)HMqcu=xAj7NDn<3WH0cX58NZL;O!2DqZy06v6 zpf*-KG`Rw{pB#yPdu1i7oPSWao>Cd;)P_b((S$O$BF>ALEV<&@6>bgA<$GyU#K!GY z!Br!hdtV($sk>8QqOD00Sn;%3=sdg~ z`^$vk@ww_wyPuVy{_{swb%A|_dDSJjzs^gtLGvp(yzIqp)!NvsdIyf=2jY{q2T5ML z7W~#qWBPV-u=jd67hJ7@X`i>kSVakMb63ORu7~09cu}HWm(9Mui(rcRYp0@7IsEC} zJh-;9E$*uWUVivCyqj|jZf%y@oW94w@I)u_U0aA_N}I)zZ>E!{eI!=?JWmPoE+Wjz z!Q$hy$wyMecYl3wjOn5Q3w*P2^oJ!>+0&u&R!9fISbr?04bG>LCyMdjNfR;1=%BDk zk)fa@hAY-gfI!gaI!jet+g+B+BOE6^JxYUW-c)Us)&rC!@1mnQ0nof64Ic+e>k!|ap@F6!p*hHtFSsbf z`UQE|t^Wx65PFRc`j5tjFRs*YZ;YhjO$nZUv9`+aQ5YSM&SlA_{;(l)68Tmqa+>7| z5c*B08#m**?dEkbd#^5MFYkyx1C+6Q;~61B4)2HJEa`h=v;C4?hQFwd zv`(TrUY^Sh9#TM@2cBeTZYVHWi7@xxLb{>}2aGVkpt#hzoXf{l0qfhlI zxfq~14wBQJi?ep@haWmgI9Ah+u5}85pxA6I`xQc2JES#9U2?HzQEz&6aE|!8B^8zB z_S5m3W2rhl6*nD~VrQ8T#AEw&@M*wgn)A(1iq$J&Rh>6Pc5}pnktXPWMH>`LT#z^R z#8r`@u-@PjrO0NALCx`a*!(e047ek@<#6<1@6@GL(SIdnG(-^_4Ky|kvT zbv~RqxR_>CXYibR>QXG{7ibLwUe)md9J=uXu1)sj=K+H1(a>#N9qyXwTd7rqGF8^*EOOa*MO_8x9-v_|n6|y(9uCearwO+cIQG$OP`$oVD7iltRm!7b>&6SvIZA_9%pZWUr=LO}`R{bd4bkY} zEvOqI$4|`#EH-{gQ!+-f!c=$YHAjuxTMp)iYngC+tpzV!^a5tOb!NwsgA}9D03Sw% z@L`?q98aMz{lOqKz2wY8?wyC=&2rdowo*rif8o ze{wT;nI6o83aG zmlso`ZUD#J{Yk>g_Y~mi$eGgG)n$*~z!ir+cvI|#uM!k7`fxW~5xR()1r^c?&BWrl zQT(b+BfK>{E%cb;4tk#6C{b7C@A*ogm*$TKnw@x|*aos2d!l_uckZ840L5=q@NkGX ze_el(UaX5pxdR(TtMd<~@)3bG)_G9Y*%m#N2k?xFd1Cz39CXc?Lr+@z3U^bI@JxO+ z2{q+{YF@bS>IuqNB8?>QP6$eQyX0GgIO2@d4a&x(jx=c8fGly7H=uXK=4?6DbDDQQybixM{f; z-@Y=B7R|NbJQj-kO3sUU6N=E)e6pBz;D>m2_*h((nn5yI31Z$9Ti!9< zfRi4NhoH;jVU@Jj|Ka;y7@oZq?7Ew?O-er;e0?F@Ewo`CuaAvOEx}YHLpo;xEFKcg zKO!1or`=d#?aofz>(Vfup0%nf>X;mk9`_z1Z`h#4JQ?=CI~X;4R#NhjR>-^`fs&z# z!u+@saQsX%nqONWx&0!Kd}pO{uhBE0&>@36-rWZ8R_@nxIPjbvS9Ijh$R= zFx&7ID6t~;&{5)+hYfIfmW1odDugp}#XMVzxm^p776w%naZ1lGf@Y8g+>kHe?Gtoi z=~X$dTngwi_X=EboIwqdWB6RlR@l2Di-tT&;VJv(Lfbx8bT}x1Ki?&IJn8`Hc9P~O zR`+0U_(mGyIf5@8Jqx?mKZBxGuI#p>2_E(S1YM1WvCN015WegUxV8H8@cBC+_fZ_m z3_c+)K6#za9kS**iX+K;Wq*EcV88>K=aK&U0enmvk2s8sC#i|!q^D|p=4Bey8V%-U zg&Mqn<2+J-;KJJVepJ1Bn7DXQ0T0mGLiHayfTKkk>uqYo&aPpo*RuyX*mr@zPo|u) zz?!=$_JYg12k^J2X1qA^qj2qo7Ei7k%(K#$3ZrIs;R{FnI6_)m8ri=cKTJ6#Trsuf zgO}T)!IjS>E9=4|C*FjM?lOFM@(xmw%fR|ODw1l2uOQy*$adZPV~VdTr2ZU(vQ@RD zpf>==-?qZ+{oNq>;f<*m41^pa!wYt^(N7MQXWnoE&Xojy90(;RY2PwuP8s>0Uz{khjptA z@Qf6?dw=7updW6CncuBB)@cf4=)0lHoF~wK*Bc12amQ(;FF^Ls#YMjp=}90)euPK!Gx?gZZjQcQ5` z2dX+eg3lS)k>}ZZswnD*-=g*Tef3+4>mi3)wsu@7IYNViM_||ZLv-rKM!FQ8%rPGW z$WMG*)!oh#O_$i?hT0pV^H*g|Srdp;9LC`29phl**$O%tG8h*vy9f7lpU|4Kp4iaq zJq)~Xj*1^z;S%#M@U3J3*4|g9{KO(|J>5ez*m6s3GpUGo&N(RV2zG_Ll_Q{|T@I$c z=nfy-?SsrW$ymSaB5e|)aK2?8RUC7~1u14Y<5{)<=c4gu!)sVDI9jL(_rx4KWlXGH z1g*iZV8Mk~r2Wek7ga~nOTBcK9XcHjmyIKr^KU4&-Ee-B*bS}1U%=2xBYZLXmbA9j z2XSdV=}bCC#a&Z4YW*)s-p(^5Tav{0+&rq*ZET`i*C=*uw^@8y*#TN0AGz9rrj0H_ z`=4^Ofa8Q_EmvIj&`20FuODve;>^G7<# z|JVsXT(reI8CNOPK@ErXv&Y(!8ak4!jgt?XVc)FT z>du|}`9j}kgYd$NOLXH|Ebmy{i&_lY;0ZNv4n4OOf_uo|unoP@b(1CrpH{`qtJ_Lz zw)N4mR11=xwj_az* zCp|TJ`nN9pYx@T}YtftC7V5B0_ZO5O5R8{MuAr=;XQ|^2sXT0*Ol}^LBu*As^`IWM zd+Ux~>6+MLFoLwiNE|r69Ga_-k?|@y9y~CZ!*UJDeepGD7~4wwu1ViLhiKqeLpN3^ zngR{^A0cFpI~s>eK|L{#SK8W(`)(IOSm!j3E;px)Lu(*>NfsM)J|~p-S_GjgF8ESj z72fvL$I5LkxaOcPoGjJDJ!_`JZH=3BEiMAR{F7l}p19n;)V2k=umHRe^k>P6f9O^Fy^$UGd6oMTw%Dw5EOL8OWB{2}8qWP$$$6 zBO@0>!K{0d@f!-bcB&7Q9V%qk2UCS9hfJY)PY0}YD1vuOhG5TU8W{V=0^DT1aL8>> zHdv|5yXMcMk2j~&yeU4scB?#Y_|^``H$DPK1t*;UMGoi4R>AsPZn%()$W6?^Mbhtc z2OiuUm5|=9NgX240;8JrSKP??b zXYR}5BiTUq{p3$qrpjUAb1xp=Z$C+a3b?;28HI_9$#hUYM4L z7Lrg_w%`5z*Poxq{q(u-_j!%yVNKtUFeRr4Z_~45zxFq<`ptPU=IAWx9ki0B{WPTb z{B+DHOQNB5LQUJ4Je+4VlqS7U;O>#ZeAiNr!aYW#pIj34?584SUtRFV(bJ?dNgkg{ z=TF_UgD@@C4bMu?xL|b-^gQf=8=@7Y4)R#uqL~6CTLbAzYc_vxULu6XUls?+ zGNHapC+#Zt`G2PcPR)N#uAU)$d&Exg@lfI{!By({?SY>2BB;;VMBZ_v7@C4&*uCU6 z%(!AIUUv)Uzw>`U{dy83AN%q2yJ}dcdO)22!G=smXW$(DAbQZWlRj^Y#hO>^X~K&A z^jtRBq^ME+=&&(QC@!E2hTVCUiLSUtej+b=Bg-bSrZh2q9K*Ajto7(H zbi@n;&zobgY-VrHZq0+zVXb0Vw5brGosaWAzY?B>C(x})nP|J$6ush|I7#VOjh?GI z2LI=e6K8I5oUSm8x0nvY$dSuQZ?*v+-XP%c&++sGuTa&ZEpU6sWFFbNmZsPr2LD^p zJTNI26(8zDRYij^$0QFMmn*@~6}N;p-H$@9QZ&X)+yLSImGQlYGoF}zkb3vk#ZQS= z_@w+aJ^A1V1HWbPl{01_c0UO>7svC-?>)e4;x@Q^J&D7$`@`*fviN3?fQP5trM7b| z@N}>j9-G!kkNPF?vZXVqC2u*%9ZTo<`++s4#YNEPRy(8*MV>FVgWA1MP;%ds$Hdgb zzw2YE!#|ZBFG=~;Rq^=n(M~v*=0l4wNj+HaH?U)F7DXOU=Og|l;-wc$;rr|FH9HKfBNljTzOFdJpJToh(j1XHM9G8#3j0ZiFO1&Pv(6uA}j zeXOx{um&z%`V{KU4#n7$`(Wc4slUDFHVwKb%bA^BdC=9Ny!*#I(bH1uXU%mIU%nkE z<^&a>#`r9;xbQfXTnxb%^KX-7PggN?T{61Desb!+kw$69ac9_Om~8Nx62oqgZHNzV zUh>3z-VPO{UUB#NM%bqF0ro!C;hCTG@l&NWM`u>TOsVtZuykpS*&}y2 zd?cHz#;C!9K4!3M!(1ZiK1xYlL1A+os*Jcqmc^EI@NqnP6r85icMrre^9guV>LnI_ z?@l@MzQF0PdhD#H%UddE;l`>}qJ~{D%*lwyvEd$6?z{)0e41&YMGW5iv{U%=bu%5P zOk&4ibNbqrMLV`;a*y+CM1wC=$>v=K=jJF<7byoEG0+K%`d+5Ad(kNOsg^903t?!z zI=&r4P~&TdY&V0{?Iz>Tf>*S#>l#|pJQ@>b$@A4-u9WH)EA_W-(7!J(sBLfyf^NyM z(`ZX9x9y2xF+b?>-cX^#D3{ZEBJ8MmO$TElxN65xN`9=wre~IlohO30?)Ouu_#Da8 zj4j|@^&Lq062 zHj2Nv|DlyZ-8lHV7Rr3>kBweFcyaODPw>E$}DhyV+c4V}R|^j`;9I zKG>9*pvl?+_-pw~7^7(^{#^5^=JSpM9P6dR_tr|!=h8G%vF*vze{L4eJ`BbA7XN5O zpOcP@9!jd!%zK;k4LzIUWcfK0(T@z=%cTyGX z78pSKwj6w;&>bqZW%$4qYvfllyifTj1?5TENtFYnByYm4FNUH2!%EsS$`&gITXC=K zB(Z*)4ZobDkHN0n=*@^8yyEcyer&J7TjhGOVTv-p(bQ+-CtY|}NEe1vR-C03fd#*= z(P)e1@T2i3MPCWRf)mT>%YZTpIhTm{3cbjneHc3BsAANx7MQy-jXjR7g8jumh0(u% zflK)qKHTpZjLeY1G2p>o{uiKV`4YJ2n}Uz}j{(;}J?Rd9n#iOf(_)N*?d>n#w+A@E8Abuo#!}mZFvf{YrEo4zfq|3;Va}g%3yqo^!bw| zPtxZn*q?Ccj>(rOGgk(4BIiQqfOLMJqXf4UeYv)}H!t*?4(S&aI5lA>nMX*z!1%tr zt)&NRD(mq8Dc@%u^%rhu8{mv#hsmWQ6B-)hcxXW{K0ah2SiBj7Uv`>G+2m~D?l;6Q zC5^CVh&9jLpeprr3GUob<6R2&xK`-`JkT4&#j=Ai?6o$^jgWGgb$!u)gdFz0rGpRG zNbehm-njgd8K#&2fegt9HvXiIWnX5{)$A$wF7qv{O0uL3GsNE+I_Ua%DVZ%zLigX5 z@a)bb@zBMw__1D{{X?#ZyGBjKc+FoFP-RR@cAup7;8@(&KA&Q0vhb~4EO@1C65e^* zq0L4M{PuoHP4~31SQn;&FIEh!Y2RRrS8rRQ*4S8amewZHpO?m`H@k=r@91+?#z@%u z(HUc%+9~*)HJ7Q&^OgrkKRhBw@aWWMPA}lb-L;4P?^Ql}t7^k0; z!^g>^C`if!K9cumEVH0FS35x_QzB>BOPFxu4`6!XULiE4H9`jdmT z?~jRg@2sh4xx}YXm`^%ao$1P_{8{8L{owY!l zoF*S7{82q585BM(w837usL%-y!V_-y)*}5%S(T_b=e*#K3C*bn*y=os|sDT zSLen;U(_ZQT0X*(6Sml3o5nM-X|@-h?XAsqLHh8eK8N*(6$+kCE>M;fg|o*vlJ@*2 zdVjGmD~vl$;$l0_&{pNIjWa3iqBoZ+DB~hYoS?XwE+|EHWNLO-%qjCfWR9U!q)BHoK-2a@2&H78uwuNV7% z5+PS(5Sl&g!X+wwu;)%sELQkR;mhiva_)G1@$?M!ol^@phlF8c*=HJdGo13~tP{1tyv-sJtlL9cLBuom$2RSgV0^dEf>*TcQ0BXP8*#8CP# z6BFykz>ur@uqJah7HnTEnBD#@s4vgKzWrPweAg!7^3ggWIyD;I?O)N&rIF&jhy*Oy zBGUD#74$iM2K(L20NeHZ;ku0*FWcD*@BWHLS?6^S-tQ27jB29FGjm{|SvdO6kcTj_ z1;Qj=*Rm-gY3&M=(kwPwS3lTuh> zmd0VOEkgHgO~RP`99GI00r7WZ(4o#jXbftmQRZke)M25%${_g2CSRRcXXG5(x4}F)=nQ!v>0>PlMgh)qZck* zY{gxpqRIPk22NAcq*U`HYAcnz`?!HrpgvFV2`j)!#a)G6pYBokjVV}DolX5Os_+F3 zXG|Txi)yXg=;_8#T={q<9XPH^su4N-K}825qNddtcFW^|Y1VKr^fAreu7?h6!oA#X z(Z8?VaE8QxI(bD89kq0^TaT}h+R#9+<_1B~?Nt5%7*29=sl3;JB{h^9)8kV~JY`xD zZ4Dn!O~=FVe111xS+`9v3zD**o>wTX@_=LJ$V?13456B51E{NmJC?1hg#7{Ub1|*aNSf`2S3J7;5E01(l5vG&fG_ygO^+yiR+R?Y@t0 zT=S*&$NGFF(g{;~M)TOC%iz*G0@GtLB3|q7P`sglA3MvSZ|^a<%Iy$&l)eP5#im?T zsDsC}2cy|Y80f7DLLSq5jy#8_`G)&NbA7Eju@9)5M*2?y^)@bk_iFs0u!I=(W7%Z4W49>|Iqo=T`==TBK~`=O_MMA!-GHR*wBDvVqXMp@rgLUDv=H;$KtcOb);e8M!#SA z!0yXAI462V&0e)paQ{XwX1h(T5tcm>3LB)1O^qtu7-hTtvkeD?aPP!ZOich0>kDDR-2RUPil(|!J)W9zKV{qxKzL36uE7eVY zMa9xHEchjLYZaZ)ciUI!dL$j5cFV$)n%QE>-YVMkI|gyhYFe>oYW4c0n40|$3Q$#7 z3EM0ESVzMV`tC5p5Gj9RZ{P+c{d=RLw-5I$%!WmgN_exzfGtNU;7_~PU{b5cF&hlg zdhr+V8fqu;yZ%9!9bGA)Y&LJd=Pq_T@4yN!x2Rd67k(OYmzGBiN8_GanDJ;h`JGJ0 zkMV11YC$u!-hL=`7QFG)LnjWD*WqT5LfEpvidWqq#4DWFz}?@2a7-^Jlzp{R_&p*X zr=@J8Yu3>;NILj;szNwV43vs*w&y& zLzXGC`o^)SQznq&H5)9KQN*1$p2Ad_X_%*Q7c4KV7lV~Af&cOuxc&G=VXV_(C^b#O zw}ZC|{YNZ?!9-zYNK{efUpn3!Rz1 zo)#aS$}>i9gAkRyw550^a-U$bRC`3PcZcKt5m^*eTta)ECS$Ua4c)pd^}ns(+ZSl3 z<8JrUkhE$R+2u{eL*X~z!<^kz@E{C5?^nUC8e>*$8;TbLrT)ID4(IM2hPq`@HQScD zq2WJ6zH?EBOg8Cb;5=8pG0sI?bV(b1myh8Qx2CgQ#AV7F{#x{p(Z`CPqi}RdDRrsM zXLp|p$EEKsh&!LQfc5@QG`71lo^A3$kLd2WDzgk~?Sil@=Q(V)IR-mdjzyP7NxKc+ z0;#or*gZ^*RX^Pj748>P=7@BzhN7BpIj6{@E`jBaZW13)$feKyviSI+OOA=^b;9=2 zeEc@xo8#S=GN|@q64yD{3C0$cHLxHbn|I$AQd2EqN=7XIgUuO^`Zq z>s4}5vtmol@}4QU#AY9jf9%Y)!v>-A?km+_&-cNMed{2(mpj(aYa#ROAdGyrm+X6_ z(XFd?7&KO5cF61|xzW?`Qtm?1v;Rbm9TU-GpC?@mc}17HOu~w+JaXDmK$~qdS!-so z;C)t^tF~Mb#DGBD^e>Y}JW1y+ZxsP@E5NmS3V%K&W$qqt0Ouz$JkD@0v`sAnz8BAi z!wcct1Vz-`^a_zp);myn z7L2oUx5BU>0X|(%W%>F-*qKxUTbie{`P*V>J{J!MUL|7Xqvf=sARcw2&ymuf?=@ZL zU8M%YN!Z152OWLaNw#wW@IdYsYTIB#*%>MPHNOZd^S_gA$`knN=)%XPJd%U&bo`KN zO8Z0C!JoH@`0KAf$t=xeLC=ED)i}|P)2>n<$q& z05@MF3^*2nG1nAD*z<+X&q+e8cNf+4kI?gEd-g9aCEF@po>xARD!RvVcg;Iw3Xf;JXJ_&L5Q+RH=)L)s| z6?Yey@m*&H+_0(>WWxjw-1`v@#=G<3WNo?~tcxjgGx?2qy!hpQK1BTJ&qn{O@zsQr z^!j5y8V2Tx2VItkqdbnlgumYGW#5Gl#=5any0)Z)g~PYCz1gJ2oR?Jppyy~o`wO#p zW|$egH|$A^pXc!5^%|g`8$oJ6H^bO3@fh%@k}U7l!Mj@%@MdKuRz}W-2G#LmjCm}t z(P^fm#paG3Wldtr;&8N5>x8{_ij;RT48tT{rO0_A1r3Tv*X#=Tc`FfTcAHZ(z+TeW zre@*(keC{6yG+Wf)8K(f8T<5$4c8|!1pT~po?TAk>tg{q8B<6C2 z<3GX3q7OvQm-xOzN8!V>dxg@Cs{HuQ5Kg-B8LCBDwsN}%ez^k26(nNs9|tH`=a0}F z*AF&aPs4=gi^-7Z2|w#*V}tWs@jtmtt{HDhBOAS`hkF)hO+vA^ZaTfU)u)DKDd?MD zN?xC(&Q)9&z9rh@pl=VLCi*gs9}s{!=L*3vP=hxecEyqAEkfE7dv0nm$JWK=WV%Yv zp_fJ)c6868H-b>3X2wH&6OS}YE@evAemOGJl| zKnD$H6U^T$dC{_eDWq~d?+TD|Zj~x5$21Ib?(Tg3YQ1>lz$(YE5lysaY#a;86~fH-vTRX0o-Iz-I3Ac5 zjeMsS4!Jeaut`CDS*-@X+8?G@C#AdPtlePc=27jqAQkmG{)3}hYhd)%Y3QuGf!fO4 zYI>;Tu*-um2vL*4`DU7!VQzrMQXo@Z>J%4`F~r{<%G|Zq0p}H6pe|J>plNy+4t?&0 zg(YKfv(inCPeaU6&PFTIwg}44wM(w#b;drJke;T7A zd6;)=V%754bb|%F+$m*jo;1*&?l;(~dQsvH2H?4oH(^6rJxspa4Q+my^6GAiSfVe71Esm?k(9l0{XB@vAE`*s z;}4wKF%!3Fo`Gv2x5N>xX&7z20XB9G5?3Bajz07oqLW|HWkcZ7I5W(Od0U;XDT-Y8pt(>o7w+XrEpXUiTEq9BRHaY0A z#$34YeuLnqSb$9y8FXe?2FIGqLBA4Pep7v4JQHET2RFI%w=@IVv3me7Q|iW+O_C1l zUP=LdwAuKD1IFPtlJ66Me?L7GLu^#gso0lo^!;e{JY}?67JzcKKWmB_RWW{XFWfoI z2B&;_L4BLdFm|w{NBtKGJFf%ompCZqe~KW^ZzSqA4v{!7GhxYnDGTQ_f;M#~;DGMZ zJ#1k!$p(zXmG#QVKEEg?ZwUHJ@4=tn)VcYhDPC{T;eSzv^!2L;@4~)3c3cV_R`g`u zma~xf=QC}7G8)fHT%L1lRJlcvc-0pc5I*$gkIR(sk6WBL;KVhdB_JPLqL+E-Kk7eUnB zAoU{ZSkx*tXK#mU^6)g`7uQDN0Pe#3T{~dgJ~!0rf1SSC%18_>Z~XSOn(}-71FKgV z+;GH!vb(s#*}uK;@aA!RO-F9ysH~QEI$rfFpvf z@b}^U)c3wMH8^ad`(;U(uhD~c$F3#Wq*P2lBE4hoPk`QX34+z_JPZraf({;!A!?gHq0-iys6&c zJ3kJ_wa?_roNch-%mateu6bPY(;5P!C03o)HOQ8k4D@yD=-V5epSsk6UBW?%^K zQkx5tvPE#{7R@k!8+{i(6F1JjM|*u^@b8;plxZT*yyXHccXr~B zAIrrl;}q~uMhGw2wA10&KIwPydNFJ>dPePMCZM-gDHT7P%JKgmKe2inR+<0E=7RdWM9O-b124l+YB6YfV>B*FAIr{+r$-xosrE9U=EZ@$a@G~GBRmA(?U3gsRoy5h zDFjX5$nnkAlfocV$#-aRqxoBHaN-Rs{1P!koZveKgD30YIn}P>O3h$+D`eroL)~f9 zKY#9+_nZz&vBNiwA$;KC2`bgNMHSw@{8c(53PPXI82{6>ahwy29f}-%DGa03o2jsT zF;z^A#mbG_$U(N8&iWZ(a?~gsw_*(~H~<_eb?h8k>*zvb5#0Rb#3wX0`FB=-1{DXf z%40O=YngL)xSQkQe1Y2~oky`emEW|l6i)4t_-=DjI3&8j(QQ%!PM%!`va2E>b9D-? zdNl?NqZh&RwKK4wYA2YiNdy_gFLb{=0zVBLC)|Cj%)v{8@Pa`v;rIP%yx?{NIB5+O zN~PR|^MoT*ymhs>;A4QK;dQ{&xSjBM?;xH#&>T;$tfHToj8AWkq%*tL(GdR;xM#9F z&uM=T1KT%~;lfzFa%?+Qfd=33@nPRzp9K2{2f%xajx^iZveFV644!dJ;w*YI?>J7W zQE$X^Qxh<1fISY(7$6wV8IHyK&QqHFR6Nst0=3;uVe=Yg=zVP+?OK+?|JoLU-!h4f z9=;lkF59!Bn;u`>|EuQR);JExc?gQn2k^$((<%J96W6I~^R7)uCu==8`Cxy3HOYuv z96eaC_zWd36ZnL?65j1wOIrU%@WMBJ8{pMcm1wS@c1px06^Yb7 zZW-N(PR4b1q4dV(itu@8D|xs?@r{vw?DMB5_uiKYGvC!y%KAY5aN;Vg3*SI;@hRM{ zrB13c{n2Kd)Mv^WFJ-7tl6hy0;4>i+e>A$I${lC%)?WiGP5%NNIreD3>KDwgehAy# z-LZJVXUKIu2q{k`O@jA=;fE(sFELADwFry0KNeqRXXAcrZ+fr36x7a-<0;F(!p5uR zFiDyd$6U3*?S*S#_u(>E4 zcYg-nynChCwPY~1y4!M}4JnRu4_o1JOAp*4_e%OqufQwE757Nq$bkVjz~{zlSpH@L zTGc!!zs-Fi;`CHByIoIxt6GE&+Y-^gTNPQI{SCc8YVhRK197(P0DdXhvt{`vdYY`k zy>6TE*}k92OkR~AR1D%%H~-KS*JO&3c%^1vme8E4T$;5r5|`xG(akTGH0E^zc6qdu zK1tvI)ddN7W~!t=NM~eL?P}p)@d-gCEJbWIn29+ym+5bO8Z4}jl<(^hw> zuhIcmZ7X06Nviy-)3BpoFh_n|N9)Z$)3fiHB-cI+z7|M2?<+rgeswXJo2Kw8_p|h= zuR2`skUBH#RB44c19J`#S?pQ{OWo3NWV;rvY+FIA=ANtG`z;++pZnm_&hB_cV!Pd+ z?2dzG>GG1zTA)}rkYluOi!bY3*|~K(D$hO+Z_j(e<-w{rL(;U%i+;lCq{qSqm4~2Z zHI-9tT&L_z$s^L3O7S>{A}%Ike8YU2y0V&PjGBu6+h&n)*b76p9s#!j5=(uxJ9fk# zh0uj^T&+J6|73N-$e-PK`2)~C&`~^cZaChbWs6Ct{c1W419-y*HJofzQr%(T&*_SNaodW&qHEG* zPJZ_tbd#LXeC2j1*r$plxJaJ$ZrIYGj5m~=u{7-}jBt>}6XUJLVNO~!{z;zX4XUt; zf;>;TtH;|OxRLKyAB^s%jE^+J=}<3!)Sb{1D=d1_ROz!-NuTZ9z`2ycp=g`^88otY z!_N(YtQGm5){GnpZcohlg0C$bZjHy0t*eBkJ!;7yKLzC{t*c(pyoa)8ZV~#~C*iX; zX>W|O1q{ed!`ab=bj7+w6qgr~X17^5LYkW*_IATVuA_OF#wGeQPzODCT5{JBHeh%l z8&|&T0Sb$|v-Xd%?B!Dg3euTU^m;1(=$lAd#}%<+kmM1ynPP5!04mC=;pYd(995M= z@xvy0EcPoEgzYhSK(`q_X66fXs^<%L4rbw+3)9KhHk>}FPm#EA&ta{6I467#5mILS zfv2()*!O)P+;;p4;V;)wX7ViFkg>=y(DoGU9Xk$BY2AZOf+7!>IOmJTydr2xqPwrs zxqN{ZB=0Ms+WAS`FWw(2?80e(z$~^<3WNg&Pw8*QU`ol2!b9Jl)7IMoLeThF)HI7G z|9xA;jyqXsJl2)>=^OKaLso)A^AfuDA)e8HF?{(EL5evETw1;n0t?2_l%FYlb?cs&9>5*$JK^#H87y8A%;)B1fa9;9aJdt?SI$c~P$TuLueO8778#7b>VWF= z>LFlsFDcgjlIn2^HtPn`@ST^*F(d}Nv`?iGC5|W4T~bKnS{CxTePT?_D6)8(gXeQR zvDKv?Pgjft{(YW&g5ub>-U&+k^Z}oSUGzoL>rGRC(u?ALZ2Qzm^09LH{FD7cQ@k;J z+*bhhX6g8Ml`81CexB>cFnQnP2nc&J#Q|ksT*(~kCUSJc6S^&*_qX^kD&Th2Keqn9sLM- z0{;ER;=#7FBx|_{mOqX{s14=W16PBFXDdyX{#Mz$7am7Fpo%}vIPs4T%uN`G$^M@y zUSc|8eK+cEdxM%~r?c+5JK}1?w_vCjh!fXWk&VG^agL<-43UqaK;8|dxhdFMI8Z3s zV?l`@Gx(dg4-DsGTHTq#k8Si}h*bv7)|0db*YSe=u@kUq=vcm3+yTc_*3h6ksT|p* zJ0;v1L>K4h@zz*x$K~H7CXf6zaG0%yA6CDl@NSX#@Sg?ARSaY8OEwstY(QsI-1vF7 zfv7XML9D6TLkj|Jaj?q(E`70v`mXZD3B!AE-mI=@R3*=6-xKF%Y^NV zKG4`-;h42Tk2YL*M0Yn$W#cA4vDd^?uC1CNZc@t$?UK?UR4^*DhEDGzYjfrV{FgECC#KRVOdS^ zcT>EGfa_aC$IK;q*yDgFZuw=%3-^p-v-=C-)}QB&3w;Z)xB7C?qqtUR*qe`U-|CBx zXS;IIIG=XIooPsWa7iiU-No+jm3jBRrA@N}p@ko?EZ#e7@3zfHuZ=^ji zGfqASr;-Lza*4zg{baBhRY6Nalkw6-8E_xki)&fRqK#j`G2KYIZm|;;gu#m^t7pS(*jlpS%jPSRv^k$A_Z) z{U4N;*%!xY8sQ<$fAk`2Aq|}si}oLnLqQ$z`!7B5?tyDmF?a~?U1NgxKUY)o3*^2j z^7zc@BAGwc!?AL8bZL?q>SQ_6ixUL%nx=8m(~I!8#|s*);)k;LJwQWd2KE?xoEoRS zgTx8@=xBH#E*)-xi;L`d)qlTgy2KTcmgg!;mbAIs<%7un#S#kml8R-~U8Igw2(Fmq zLrcONsH5D3w`v)pyOj6e)ii{+bvMP31)t8@KnactY~Ae3 z@!I(`V@(~+G10*_dBgd-^9WR}RRnE`dH-Tle>67uDUg~M>yMboy?->p-}++8msf^4 zoQJ7>%ESQ~C17;=AYFVMgP)HP%*^P@V^(z0d{iaa;Sn$Y^xLdU?1Lh)clQg(%g}=$uz!P=iFM*HIHrg?7GzO2B zMOW!eQ+eD?a5IymZMuHk-uw@=g16A$Sz&DV?;$La-$*a^`Qllf4X{PhM`e}4U*5@s87l8MPL=*>EQ^56Y@S=A%EReF=#=T3)sQ#6( zdSxbmHJkx~lHL|?`CTae5rr!fS|C1pGFzUW2!qZyf=l;suDL%COe+sTM?f5xZk_|r z^Pa$olQA6ns6|+RSB8Gf8HcYI$>Zs-&5~;zjSVp*=o+Mg-Ad0 z3@NHGmvxjc2t}Ry>5s(jUGCB;Y-_2c(!MGDuHiq&3unSOI;|c)8}Fd43uDS|i`;sHDf zw8QM!Uii=6m%d8<-w98)z{ka}DE)&M9_i9V7J6=IlyArndaMyQx4B^70%NXu>n7fi zmslrj%yCqEp`+Jk6VB{y!M_ewz^0`GdAGzg#?q4@yE+@}d}s3J)GhF$JrUlO$1*w8 zLVxvZusmWCpRxImCQH3*_pTW%+am_LtSX?rkx4xA;T)iUnzV11#0#=m0wpV)uuFOh z%v&@7b$S}%mT)(ISlC_slscAm>hi1SPtjl}^>KXS{OOwF3%%L0e;{j&S0=pHn_E^K zqHTroxbuK9)HtM|?rA$PmR|)5cgw{;+3O)}Wg5%m$D&T%5_l;b1=Zq6R14V&Meh#6 zjZ>Pq{e(HUEPMjNUH`y~iVYO@+#lz7bj1Vf4pHAj-e}Y^1y3D32%m!w!s0h+xc@>a zsjk{3&huR8Xz)D`FIe}7a9a}`x?7JQJb41WC@ zqJe8&aLoI5D&E)wwWW8`wz^~BX6}NSk*Odg>)=Im$$wb27ut8IeF}7 z;+uBDQKfWT;!;cnduIw`eA95zoK57{w$1TiS|0v)(3IM(&r{5cacHsg3VGN%pmG;Y z9^6m~y^kEEAwG&c)XNo@@?lbN)#qh%tuU)Knz9>a@OhOz@YG-kje42D8DDlookJQI z4F)oCpF`i|GkM^P&*B2lBs%+E9be@n(z`jHm|A3sMUy2~`||@}TcCta4vM_7S&u)d zn$qrd**K^~i#|s8A@{>l-(=@d+B*D>@L+r%t2N5e5WT?|QQ4mtl|6yF(sGesOZUpM zNHCi;m44tVHw_#x7NN#LXmH2(ceROU6O$v zk&EbZvnnPO1@O61w;azKPNw(YZV7ivvhbtfHyEisgf3^K{vvGn5rau5cU?Esu4VUsT&frlZa4)$~5< zB_%)5$IkhNY%e`WpD*e-)w(P1)4o7yQU=z{`xA{gJF$lNOU;B2v2&uVWY0Tqnt`ll#LsYcK=NlFW*qYd#=HF?7g~JH5PH@SWRqO zC^16KXJNokOK@+^f$C3w>?RXK1u_b3IW~Z!E_8^)-23oltw*rFPYfS+?+1aAKfry~ zB(75E3om|VvgX)WnAp-JX6=k-?T1Rj6p0ly_NX-(=IF9_rz;*X?m@bDWI0hO6w^k& zrfv@7`3J2580Es-<1NIE(@oeiGJv&v&k^UxtFqORRNNqG+g=kb;rgN+%$isy-dbo2 zAt@<1{$0N0sYk-0&hfPIV>%u?W=o}7LwH`@SgG1FirY5L7hja@qMG0o-jY-$I7++2 zuKuZ#cGqZQ_^_dTN9s#f+MT25&RFzbHbv_19HC2Fl5pDge&X!!jkF{(3a>OFeeBbZ zOU-P#U&&dr*d)!v&pkNeL0=4UyGZBXIIwU>2`8+tp~p8IIN3@SSMEyS+fh;G1K#+{n-2!P-dF z@A*l}I?lpVLx+w!(w^M5E0n)W+O1WZfYaM!U`+mc7#xwz6}S(^3@8!CUGhV> zybidLSw(VMC!yg^B3|sb-cc{13kE0y2lRdp-@=FCPBl|>db5L6mV5?JY44%)Pz#(@ zcAdQ2{=tmnZroPCL2Rz*jp`A>xMo>VP1BiTSTFVWf7jd)nugRs&qMJz-taWpZ%@F- zPs@eA>$Ul~J&7uNMzhBJE@Ie-^)+uB3ec#m(6P^-H2!p9BSolKVR5-K+e-YN!xeoY z(I%01cT_^SUw`};yNj;u8ig7*zhOz9E1x-j7aWgY0GCa!e8jsujx_0l|Bcm`b}VV) z!uoIYym2I!dv%lcLawbo6eis*FP|pE2i~OYJCwUF9f?Qo=AiN_9iiic7x7IIy1mk4 z_iw{-T8swjFR_-Gme(L$@d*tH-zuiwjOFJWU9nGm9gKZ1gVUGXri(2jSYxUhH+PKU zcfW_@$m8q8n`UOxPFM%@S^HgdQc~mgw?4Sje>naAE$vp2vfp#h4#w*DoiHD)cZg&={W=Wuig>Sq{xjA_a23QZ+?+g_%AS7lz}ck zbYSJ)Xgcz^9>O$7n}NEHC6g=e|K7Lor?q3 z&IY57OblCGS2NJPKlsYbM$eTs_UGpsf>ux-+FpwgyjIGhLxwABXw^df!*O`xfu?v~ z;>+i~i=^z4S==q^p>TGcQH_Rn9uGcg3AtJRs8QQWSFMi2xyNoOg!kb6yG4lFc#{Ic zB<_k|KP+%rN8eAU@k77u!g2X4aCeUeC-ohH3xk(C%9(v7m6enE&3Ywq`qOLFt>1LM zZ<`9r8Ns|Ev$X=gwPXT& z{wIr%gL?>jij1&e@JMzsUJKm|cG2(^3E2Ci4QyIv%=zcqY2j%toc66B*B{f8`i}~j z@@_7Lb%x;gi(et+pfo#Lh4SzyJNW9ligYaHFjCEzKh0l8L!v^t@b3pGSiGC+zD?lX zeQv?gn$uLHlE@aeAgoN+<>pW~)N~q3UyQAJN6`p$uX`hY4YuUD-Xl@Ivllt3w}Z*L z3H<0wIt(fA05o*Qg{$6D>oSS!zh55b$8Ds;YJ1>$domkbFBZm^42FK0dE9wu^XWB{ zCg973XJE;<8gSY&9=ol345~I;;rT8rDEAu8q0{=Ig3%A*!8>n0?WB#ivvX>0@TAolT?MBb~Zi5cF2CzQToReBc;h0mptW%pveJ&#^ z-8@F!0+M*wADz=fkND!qus`IIxCb1syWuz8UOZ*zK6nyyszz5ohX+3!4+W%K23^ z@1msREei(>uY-=NfxM#B6fK;NKy7VLp7zTPH??mS_s-A2L5B0GebGg@W+=-~2fEVX4}OJ0Q$j$UBM+l?Dxs=JZ2lg*U1 zs;@%D@ZRD9&vabBY&E@VlHtm;6L8}~9hyCE2Q|Kr#n~6u(~wKAA#`&v4_mYgmW=m7 z%ipJ9Zuf66+5Q~JJrCiHAs0a{y#pMlkLJ;DEZFP%(UOV6<1Eoqy+|fv`A+#96vsq4SJqR zZDhv6gs~Rvh`j~OtFvIqOJ1Y0!L@XbvMf}Ma%Fd4DY5l^GvH{!0J_@uHQK*F80xjQ zqDM8_yk2X`GJOE1aIN~qIkVZzm}2z!e~^P+O-3OLb9sMeHmbmOLF zV7*C?o+|i7U)gbw$qyZPv7pCokxK^jg*Avp=^&_FTM3uQ6W8RuA4~h=SHhp4$->U# z1je0JVSCC?quQA2(t?jEO!Ytp(!OfQMtm5=_q4q<K)?gnO>}Fs1BR= zuY7ETwWM-Yx!tKBZ*QRyl!%)D4B4!K=i%9YHYKq?L{;a-rLAU!uj^ z$FcdM3LG620Riv7)7ajrV$PZp^xtTI_S~f$mH*z1h7a;%4bR(=IZcP#t#Zh2W_YRZ z1QoXYAAxzhPt&N;ZYV4{g6YCrRww3At4fW=8hC8jqYAo`F z7wouWMCV8xq%x&TA-FDIFnLjl?yi{241&YxUXMNEA{@cioNhq3xo#uth6a1PLXD}{ zEMT1-1KsW&D5K`hi`d!2?!x9dCDguG8J-XHfmsjC(K+*Ja7#lUWH;<7ZEB97>c-32 zqM!tU9^8ad<|M&}L3f41$rsU=rZ~`w&T~`nYecg~VU?6kg zXH*#J-f;qZA2p_UT#aoR%lVgv9n`&vXCjx3WI^aVYWiDb!f_XNsW)pwp8qNR6yU@`kDBtPLk z++ocq%0i#@scfMJ5||xbyV@(^31oC8@g!Lv0)H`#<0~|ax5oiEK3for5|jciERp;$HMz|ul7dj z^D>NW*Li?^|JI=_d2MF2dKg42KN9h{JfUJ>2AodormE%1=+aIdA}-7mfS0 z@8TF_bG`~4YL0}#zv{*3u8+|lrx>`<*e<@BKOEGq7y#HlquUpbW$$urg~z7DAv492 z4R5pugXVMeS(h%mJ>3mbbWYNtSd;bX00elQp{u{06LQK^S(BtWT_~50g4ZOmxqCN= z?tMK}+E^Z5esEy7?G41rj&%68;*WUi`)4|V?-6i+Bm_GdGrd3~G=*zs{#tIQnKr}N zV_ADx=sXSTU1j0g*<6}QKLJ@(d*aq zV8nrJy2SD{`tTsFT#=Dn#s`k>2CS53Q;TU#h+ztAM>q#S1 z-PvWSEFo!85JX5wGEEc93(jdoRI&uXpN#J$hxs7EnSI7--+V7B5s&t%$HK(7q$ zLyvb&Wx@PB@#XS(lIF&EkR1TArQ3r6m1^Yik`0Xfh_@rG}WjQ;RjmGF4GYP+A1+K3qPm`zu_h} zbAIP3Z%C?+prZBx3XPCmOvvjgEi35V~gM)A`l0u;NE9eH4{Q_bxk)RF-v!2NL4oeo-_P zEdjZSiBNO(k!W_OSZFz)4h!x5*=hqoCmf~N2ld%-ZQK!LjCn0$pC9bIyaGAR??P(T z-mpkp4m$6yK;}82kjeF>LlTnE<~K2{HU0{H^?NFEeWd^^Ka7G9pL#m#Nj*BrJ$HMp z8_?-Zh15M{A5v_Lg!Sn&VUFWr`lO|WYD`FkX~*`W+mj!a-ja&rSpt{PSEIdR#cEYH zSMdlvY~aBH)YMtJ^ge1e%!6G$tIRyV-lW>Lh$$|*NTnh}S-sN*w1z~nL*0APxfg}h zJ99Y%ZdF2!14h!8?P+i)bG@*nNspG^<2s4I2I%4(7g~5Fk~Q?z(Cj%(Ox|88EFCw8 zWlfcY>TVSpIogla@O;KbotNV3!~oWiCIf?>zjXCFG>e(3@$9tfC^#oRrB`>^)2-)1 zVS82+-I}3I&4&B4xj2xX?CGP$yuZrXhQfhA*HBs7H)`gu&D_<8fef$nD2H03#O%kY z;s^K97pZ}E)=~PvIslh&5F%r{_<7p;v?E zvy-JRRD5uYv!%6QdZ-Z%RG0?4hH#(nnk%K24t-Qta|nyHbb$3KCum2_AeN9l3jEqn z(1S_;#2{fQOLWdd?pzNVwfQ+}JJ3kqJ(3KZ*crb~1oR_AW3s=zxH$I|qdQmLF z;inMqQcYbe{NVJi6ZElB1lvCEg)rIw8|psdk8Jq)#vZk$=#Z{HO0HM{t2IRWhS%UW zxz2`j`p4;-<>&dccNi3Q9jB@-$->6<8Q``2ikQD+1=67LtoX$el&~igwM|*dicF`W zqeo_;*C$grUseOT%|`6^`b+fr9d)*OT^_BHm<=A^zaS4iu2H!;oqKFck#F7tq$f^c zMyaY$p>TobCrxL+d;idQm4#rEa|-3R(D6Km%tNq zO|(QQkLTk=L-DIdf!=+InyZqH`Aw5V#L0uX2!r8ovIV?X8w984 zHPG67Lm(URJ)_!Bs>*dL2dFh1=GWKG(1s;fts&o_oqpTbkM3^fdfMHyAuLLYy&pCk zg3jB})ma0XkNqT;Hk{vkHJjq9Q8#jF{0;-aVY{M%60QL>R%4Y@`ClUW3* zvoE=|U42b2h0TXAo9#q3FAM&;I?$l|oM$;!9gcGgr-lDzG*r)-W$^mX7hj%Nr7JLr z!P;=(+&P+c%bnHRtAg|A0y_FNL-lzJSC4zRi6HbbWdO zg~@+~6%BE0t|!+KCMhCkr8v$$*-k5uI15>i6WG3m&v?ym7Q_%rYuaAWv8tos@=JB5 z(((Y^>74~NY4_0I3x`q9!FhnT<{@R(0nEsvi|#CTVA|8C!1Ne(radN@zKYhPeNPs# z1G(o=%>Gey*t%$Dxbi---Bm`PD9>lLC)Ckz%a?R4*GjG0t1Gq~s1v(;(;%C^5-!Vq zLqG3$vzO0`QH<*ev~yr2i+ywyt>N11JQMEq(7%e7J$oh`kDJT1i+&*=OL@T30kEaX zS6Kbl4~EZpM<;q-Kwc;oj3>s^ngyImF>5x{ej(46c5D!z+sMJ`?f~}m*v`_pBmYoB zU@+UL^jh#D&U9177$}}G6yBeIL7!(8putN6nT*~!s_SQhLNpe!@Q+j3j*FYU6jvat2NKdjyXpM&n z8nHV8-b-#kn~aTw%2Gq9Y@H15+7j&ha$9tFZ2*fs_7>$yL^I#u5+Nbm9Ws_!04mQA zj+cgWuT~OWv9yeyl$-}X&-T+GwIeh?FNa>qSpw>I&S;a`LV%*XbVLfDs-hr&RaW9UvrINNaH4Eo4( zJhQ^WnUzF2s+}4GHw%9X#?v38-6RVB#w4L(9Sq6ll%w`??*IByMNd9RM0I!Of}h_j z8n)JlU6@^pK&qC8{PAJ<`eRg-@RDX-l7@oFFs@njg%t1W=(R*3t2e$wpN)Hup6=%3 z?L#L$DD?tu-(OF2iYLQ_vYe7yLw>%Iep*xuoX9M+Yw3s+HR#oSCvjVM01S8_%Q*N| zC~)AMBVMCV`W%h+nl1;^JZtg(LeBYCp1|()$iQ}O1!i;gm~gw&AN18-X}J4R$V%Tx z7w^uYDH8Dz)jEUbl>djmoSnl?ZNH8F>mLo{PxqjpJKa>HdM3MYUKI-0{^y#xD2>i< zT7+z>;z94A2g|6^VUK-RAuY)OmOECKhMbmW9?9H0%Fi9Vj_IH=t=ep*pBq}OHJKf- z<(je24MO=wAGZIMGbsPmWgEBLLuEI3M*SCi*s?>O>Fo}O0dMN5Yw|~7@Ly-qhcj6; ztv4YVKSj=oQbKm0W`ci%FWMHkoW;+-CU|d9gyt#UFj~h8<&5^D*Dl6G-tJ8_ow$gm z`L~fnW-QzM&y+os9}aT6_%qNj85Z_<0!-R`nfj+JV;lcVErD&x)I`UhopTUS^m-{a zkIZ3HBPR-9wn#H;8wciEY|L6m-$eln?U{sx9{WD*1DdeEfT~$zP-YtJ_|TuoFk&{` zHQY=kvyLK{RS}>y?-czt|1UCapTpiwvZF;ubLiUL(VR1PjFzc=q>oa9!078{`qo;F zjnH`Qnz>~rTV$;+3KP=d$6__AX3kkob7%8@{EePc&!8dlp%7R5j;=N+qN{o)fo+c@ z!^?}%^6aNVY{FvpXzM>Td6Xafx;h2r1U*H2edjWiw+_wz`jmEh#K6jct>Q#>o#Mb) z7@;dqcZ3RXCf=6qdHF!Ra(XsvHC`py%$H|HDwoi#CM(wDIuw@rsInzqkEu<!l9XI zta!B<6zsBw3vCtj#fH&PTBQJEb?WFRnJ;Lsu{-O^Y(>!>GguAxbQwK+SR&PJ!p@Bt z386;|sd~UvDB%0a5q~VvsvC}AYwO4Y(tw-p(iE7}#*qxb6oS-J1VXV;pJaYOM z%jm(&^z2ndy6Z^{OMh8TrLXK4o5pbd!5_l(domXFff*VJabmO%{gB6(TmwY;ic%)FTmmbrl_Q12wa?o;20zd|FUdh>H;@# zIdepCF|~u=8*QN_K%bSTenCE0Z9yY&5PNd(6$*L2RXm-Y3LEtuXhBRgJE6ISPSHO_ zhv&wz;!-0Tl5&)0j`U^~0|_1XQi<2|1KAJXa`Bh0H2c}iIph&utW!LRF1D+KJ7D%i z@&wvYm5b&rie@)=A4Erw&E`3N&1lQ9wKOX)khy1Bh_bI`*wfT;5Nct~(#I?i#yxLA z3j>1LS;?_<)q6RVa65q+4ar8wSDX_LFImR?$3!FIe2;2GM}b9U7+w6ah2j%I@aUu` zO?*8XJo;MEgnLr#w~-tROP$6Rc5X*M##w^OyF>JSoDOvs5zq zC(7yM`XmoP{X=>QhL)tM&^thl z-dk9WmS|K{#Z8mojVb2>^M2lbwt)KPOsDJABiQc$UZJ70%0#ccV0O{tAF`CUq7@fb zz|inNqQV7Vmhhql_5H}B^7o{upqa)31KWk(X`DH;`xjlYY!sUj=?i_zN=!}sBKFQQ zfl8%OtYqFvT6ie9_eKX&iP&R`aFBK?TI2=y5u7*M**xl^Z>oK@>prP>N1w> zkcJL~{SqI?FJrxr{n1z0A`ZH7LC{UkV4bI8VP*mM<(4$Lt!fK~fFb?peL_m{6y?Wa z^Yvu-SCLLNpPSS6yoK=e&Q%&3V#3ru4-&iexTk*pds_W>4hvGz{b?6Y~suJ zB^K|!>5Sl+umH*ITw18rnpU)Xkwpv{1a|Ki(=Qrv@bd0v>M&y+>e!pWf|9II*^3F_qNfSoa%o7+oDMG0 zav;^d8U2ybb_>v12`BHL5hG&w+?y7_ie`^Tt2V7i9nX{DP@JCF@392c@ys%JqZ+Yd zOaj|hq96vmI7p@aCb06~MYOh9mig3dD)qGYhJ`=1m_&~Zn*)95rHm5`_R?Xk50zk- zsvgYSrO&Jud80L&p0L%)4hE>3GS~f&QQnz6dZT3u^P3^ZP9No(C5+YvZ=iNu! z0=}T#{$XtL?4bzT8$yfyWENp@Q&3RjT%J4r>`s#n%HKZ?WVx1MdD~Iyd*!@%T{0a$ z&6lJvPEVnB8F8#8Z8uuwqybKIT>!n%i@}aC`!~l4eGhS5P>VOQYcur?gBm>LyNH;W>{_QY=P!q0S4l_f= z`?}Gdb3rieg&aD#rIv=}&W7A^d+F9;Z>i>nK$w$rfW|-5UOZhj-LjekC*#(qj9Fy)mww05Ef9dslK zuC;GLIq$Xz^BMv`(P|wEo!^K8Y7(JJI-JJoxuX?-_}OL7S~23F3g^&Ly8CuCc#QC& zW=CphX?_5_A-id$b`$r2`a<;D14!z=1GwL_VG}BMqBDb9(AjsBn0iY&+EG%D(AzLL zbTR{7_`I3cc=@n}Qc`eh)oxl=p2(hi?JO;9H)k_r?Lju>3jKLQnO(l*36C@KsnIJ- zHlk!G=SlD!R-OZ*G&2&tI3Gq$mZpG{lPxNFH-TR6TLzOe-wOGLzI5XIeo?bHi9O0* zg-lF1XF0)*xo3QJ3)wK2U9#IvA8ffp*S9A@V4(@k>{@`xMebEYz}z>SMcb~}GdZw= z4DJQG{YjS55-S$9gXd5FeIa;u#X-66Y0eq6p|#0zEMMs`8aPM|#*K90S;pn)!=pa5 z=FbRLqA3NVoc-AQP=C52PLh2}aYbeBsW2@dN*v$Fzh{NPOhxa0sn$cDLCLebH@W!G z>GyxqXP0KfaJ3Ee?!57cc60v9%_%7Eh9`4<+ljKaJ)w@K5$v=}J?(bCB_6!FfI-nM zdU2&B{Z}8)`YX9F|LQPW5-lQ&+(oQ-=5Vny_CCsgvyiQNsvx`xPX&dihlO}W2Wl|- zEn@w?Q0adIHP+37>sefsS|ba(XJ_-Z8@Y}5Qh@!-#xrLdGl0b_MAc>6kmLHZZ0$Fr04&^VP?LL#Go+Ij<5M{71pKnPVY+`XMxB zi4mMtok8P{MnPv1&+E?XK~2+xVX(nH@pp|0{G!&Zf7u()2 zyDeOI4|!HZF{B)bhH;M7!mC`T=%zq-SQnxCVexEibbE=^w%O<>Tf`FE_Ms*7*3z#I zaZqiXN=qRf9GM1Mx}eF;)9?}Po*Tjxw&x>>z|msuu>>ed-bdGUUKJfK#DmeSLVD2L zlIp))3V%0kp{L)?r%HM8(6DJW-P37Cmt0&5?kd?-=lD=z?zVJx(@hQ)tXDvV>Zxp& zodzGjd*~MRcs4r71!){{p+PJB;ME&xHakBZ#vaNSul;EduP_&=U%3$#M4Lfg)F?Q( zp%|TBrw{&nN5UI{`)sHoe9T{s_I+N+w&~=enusNIn06ApQ5s5L->5)$PiwJ|PG_*Q z=DDU_RcLjn0y13K?DpYb2H#tr6%KtphxE2CfYKuYs4?O;TIw1JmpanWZ~q10Cw+sq z9vn&IN@s$@mu`CdPZnnf=b&-QvFzK8jp(hXCnA^Q7;W8+zE9bOv>L&%csFRKcm(*E4KHO5qu9A&YISlL8R<8`abOjUCecg0VjV&gX`%y12f^1L0W|Qd3LBs@oz;w=PODWo zv-oZpT-|Y(F7V1mGoM96d;c-|{pnlOnm!F|rQgwc9k0-@hu&;Z&l6O`!s+y&c(_-$ z9wosHx}+cmYCA3?@8+-6WxW%e;+YZsSANq&DJGC)HHd8-^pjqXK1<(Q&w%P52CQcw zqi^J$p{d)9z2Lb+0|zD|UfO26Qf#=xO&JA7%7_jfl4xt}Xn(W#n!lv3C zpo&jlBJKOLnU~8M8dy+=l!x%=VR;S6aURDqJI$HWI7|AsULXD$*s(pfRs8wO3;Ij? z(9yzu^!e7W^la^+(#Nt!r~-jjvSt(;ztF%wQ|H?}r~HQ}!=rO4*{;Ig9s(GiX~QDFXo&fCo^;ZFo}bR-+NvveIb=~&T~O| zjoy6iTTDB{<=MHHUQEe4pSEg9u*Xg6%%iUo8Rm{)?f7y@gX--4tC~cwSifR+iZp4uqL&tQn6-U~4$9OE2wx>Ab^JnAdP!&RtYQM`SkA ze`Yc4=AR>Ug9P{CFPYAChj!5+bNHIRzXDwx!uP^!0T!xGN5$2HVbq+9;#2i>aP{dC zZGv-MPZjX9pN>GzOECj6)POyD{|D{axsJ-t@CAdm9!f^PLib`}-p#IBfs#ZYI z(c`Ox)@jSxhP|Q4bCUJNclMM9RQd2df-Ji{Zzd(21E@zh8{WoLIWq?pi6(vWDU_g z^XF0-{U{j)?>2kW;MxTCcBc-icG*bhcE&QtGaFIQgiW-e!kf)deuh52eL;V0_G00Y zpV8oa?hidZ6{<%LfZnRjNJf1cC`-u00fp`8T}dj0_A64AMZX2Nf!SzXjVgP7asqtV zs>J@jc}Go?#<2W-O02D%^I&bpG9>jn|-*P?cXQMx~CfysHWscE{nViw)HWN<1 z&ZlEHZbe_SM>5^#mf$-_9i}L}LBBVSgrT1Lw1*A{9qUod&>>KCX&niMJ4dkO-+JsA zXCsVxF_q0)_XV{)2x7yXm!Z2`Rtx3vM)Y|~8r;3P9PWfT(byUVDz`=!9v%yTbm^1Uezvxq@3618K?5UFkn?BeMdQ@FlYm*s$Gu8waEa8kqJ^50bjXErM zcPe$6IG$M!s7G~UN3s!mig4%j4z4>%fX`Od!ng-KW829K{ZCh85}QpUF2#cNl=akj zW&uhF2xS#nB7OKnl{x;#ph8a}nJBIw8AssK;oCH9#B6r>(nk8^bQ5jgd7SPJS^_#Q z$HgIote|L74Jxx41ajU#s4UEa57&8h>Er-bk~sxVzs=$KnK4Z6Y9{R*ejH_=O^5yS z0^N=)4nQ~5(!kYPPfWaNkD{NBqOTsu!8X@?dUmEcG7eeB^$KH=BInP=taD^LbF3jk z<_I0bYeNn8Tj`Ad7Q=AQ|B&ag&%)o&{~?c!k+5vYE~;}ahBZFGNHn}b|4f(wQS}3% zEAI$;%X8`1U44OeMjc0Jf+@IMcVQ88cAzB($~f<47L3=shxUD00iU)#5liWCWOwFw z>8UgiDEwg#ssGjqo#ztS%<>&5dAz_zE-0Yi?{iK>(=EE?`g}I+o+BDzG*s{%zY-+& zuM*RglF^52iEPv@JM{JZU37O+EY}8KbGsI&!Mc@sU$^q4v&{`zgPkWli*ThL62>gn z+ylxFd(czuBjDev;rw$r!1vl<5KrtwKjI&wme?G+z%mj3^Q;lBbUM?aE9bDmJj+9J z=2+T1-jmhq8bZjbsSudM^F`8S;nl4vNZvAur3cSKJEUUi>AR26?>i9??IO(-vS%~r z*E;ly?J3cZpV?3Q!Z{dExz}vmBuJ<(q;8w+p~2IY{Tb)%sx-J4$;k&Z=1?Ktu91hp zBeU6sS>r^zol3AfxtX3n?g)O(W^lvsJoR#QggKj%+0lS@u{tLO-B@S}esd>4!@Jtj z@mquF&FL{{{nAFm`>_0VA8 z3>~-B&>`%3HUVc@B{#j&Nzk~}hy}@R7Xx>GrmH5*g7c1NXnd>>w2STZ_1NR+%nY8@ zIbea{dEv1jr~QDgH;V)}e%`)d$0NE=B@zlZx}pU(w`iRY?=!p7(cgvZh3)f}L!)#s z-N#v?)}h0hsKU=p-dVHUa7)PIxj~KhAGqP4U&Zr2oI_S6!y0n}KyOcpsNlZ~1$YFr z?9>-XEuZI%@33a;N1dTv$rfzyBO~_y%@1_oD%VYl|LE=u7=}oHqAxw|*zNiHtcd$) z3gpw#*un_<{B01sB4}JF1=&NXAMLEi9Sp=@}?@NC#Dn%Vf z2C%Zm$?T`=PP*-$8ay}U^^#Ey!o1n{QTv)%?4j`^G-BvWI^^Iq*rENAt_;aSpZ<$t zqDv9dzAzR|c8F&UIl1WU`h&Jai8Y~hQ96ijfM1MPjcM8^SxpwoLI7@s*I z?s7AR(Jv>0%Ha#*yn=DasB8)QRI>?L{hi3%(lywzuBE8USCg$gD^JhmPUp-mLw0E3 zdvRUrBzD$Vfc}6EVa0PBxRKJ%buMMJ;p;>gRu@Hmz9g`YXFjO->p-^7#T`llFVms9 z<)T9V3brMA6ng3PQFt*U9hi7m?5*mfG6Vnetl}~JY(^g(^<3b|k_$Am_bAd>v4C|< zTtQv-rNiu(Z-fnn7lrj_=fbgnKj|d9e&L2(xDd5sCA;J+ExuT@s#7|$@c?t34}^n|kruS}HFVb5%TS;2_D0*bY+h}LtavVrUL z;CJH>Y7!m7`Nl4E;Zhm4^^HGhY3b0S?~CA>MJAP(*^IJVX3_S*6i{AjKw~})fZdNK zz@B4AspEPXHgX+ju5s_jifRP<@#e7LfIFJL)r5wRo&eVw*Hfc-I{BhCRJDy_TUOVL zmy*Uqik~Sf8~YI*PKbgr%^$^mCb!U>G@j$;zL?(Rc~#?WB;AZlVqi?)v(hO?J;1HZ zoayIE(23LBVeT9=<`Cn^_Gl}y4DVmaRK1KJwb1d>$1&X97UV^((ZYR8*sYieXnO+{pA7MaH3mFmJv<2pn`}p?KeW4ToWEFntsDda zeH)Ah* zC|Cht=Bgu1D71k&cr4A>7s^uH>QVLCe7fb)Vpz9e5_P|ELoj@r!lvwrL+9262!+`x z?34LQ)Oe2PW`E>;O!Kv989E9Ls!e6v&xMpG+#CT5zuCdN%6Vul2?g2EcG~r{Nw{c! z1&z0i1pnae6kEwKG&MvJp9ZoQ>h}fH^du--wUNH92os8olVQZb&9uX>&~0scDqL|w z)W@CIP2(NuQUw=So5}O|dvnCSSq=~xJsbi?YjCZ9J-xQZh)uM3N%gbyD^`OJwIlEGwpXYhcp+`R?aed1ubWZq2oBhMtz7k245pKYyy*%fpU_KSp)>cxh zEEkrTG!WKZWOSZ)B)q(yiB3IYG=sNSZ_eaV@y)2$c`jQQC_#;FN5h<#cA&321}Vq; zur;k3V0c1BJXN!fXHQ47F%!Xd3(&5eDUGyV!Et59Hv-ip^HY0BCAM{?_Q05 zO{*4t?b3K&rviQC%bDiWL)gE*r-J9hzbJHN2#cEVSeR|_n`$dbg5uZF47GGni7W{i zGG`1^xFYfYKTak_6Lw^x71Rb_^xLE|g-+xH!RyJ1KQcGuyn zosIbL14ELOT#rwhe8<<$7!t#w->|?Maekc^F}=`=CHMTm1s&R?MxqUWtN)HwRJ6&W zX|1?x8jN;jkw;=ki^M0V(*>?Y_`*oT$oXhC8soE2VX-n^m+p}e%pXY zS?dtR-IdtVrUTm#KS+g;}<8@$w%#GykY7u zJaV`?k(DDf8T~-x-PMn zt;C<#w&9g|I%JMfjc&kCCbVM9!D^%+w;u05*NPYa z(jz-BRbn^eHY_KlM|P=J;tk!c`00Ooq|UPvCxy1+>jyN+g-suEZdwQKxUET!ntjCg z96Ip$cZQ_tQVpKa^AoRHWk}XGeZtDKny~gtLvp156Fy|#gvI|1NtJsIwqN)YuV#ki zr}byt_4fx>Td6_RRjTotR~`8319c*=RD%^wI`FFJ>LmL~HFo*ij+afhMoIVL&6^7G^+-gMMPIFZFo5jRCp+n_quW zkIQn@$(toLcv@9Eo)oB0oXuMBqtpg`TtT07+O%NB1NB&An;uDe-GUDk*5luI^vSX6 zCOm|<(Gq=9l-7)`4%TCLH%;a-}K4Iun&0CsaC9&Y*ixx$c4ne+*3>b2k)Q$ymEU4^qWn(^r{Lo#Q>Cp_?o?(2Ngu8;~B$Dx4SGj7OYMBSpDC zu(+%R?@L!BnS6eA|K5VNO8((7``d8T8#9uo`47`mZFtlNbFwqE8~fgA!Qbb_(wZ=>f7nh@is;!{llMda z;dv!JxOIXJQM2pDaaZ~<1ly1;9i7Wo>>#6z-}DvB1t~HwI7m-$fbaOTy{a4WNVm_x61t( zy^z*MaMDEJ+Lh`_{MvA9uARCyTpq3?FB!Ut16~pbuN@>BRG%n~=z! zKK%ahA3T1zDXBrdc(T!7yk>wYaZc;S^MCxszZ*3ul;i!_lrV@|$2kRUhQ zB*}GGQxbbZf+RXf5U*wvV!pK>@B1J@{@gbqVcYt#Qk?`j{m6vu{MU!ily~8PViVH( zrWb3dcHzsHOo)+XANDcs#vxfI>A>V^Xj_<&e z1`Q?}7rOBE)xUAM&k%COrVGD4{|DPkT9J=xUHIgYKlp6>5OUA83wsp)#)h+oko8_& z_+7wnd|Yn`u~^=Pb&ERiz`d3v=|n$Xl-7?+^G(R(HT}5xsswRiCL}jag6tkGO$-tS zllYVUn9YzTWzz?fSpJ%S>C$A!sljC4;(k0hrWgOW)r1uDdv!DBAMV~~LOx{oVd2X^ z?4DvmKE3S2;lp}y=u#7sHlZ6|%KVF`9JAO|F)%M|~q0$7OwIm1ada+W5H2HMMl9(&@;&%(BiDJ1WxfIlkYaai` z&lj4KubRC$=F}g2$JUe>+4kYiOVVV}D+}Tw^kJ1sX|h<|f?WU6i?807Cazm8$nwBG zoFwxP@5(eGhiCTSh<6=$!ZTCy{b3J&Tm2jRN1Bp74V`$pXD1dPS`mY#y;zy|b1P&? zGOqPwpKd8~@sBB4wV?-xT1k`2)FI?WR1dDxkS66PhLHOmeR%G>Uc5HRg!qo`$Nx?2 z#|PJ#kkt_yWX#4E?EIq@%bryyy?k$Db*>F(C>oFgN4^f1wcv4l&h%Q}h7VV?;?*q% zJi#pLJKk?#%-}pd*I=Obc31@%$ zgTEY6C*eL#xJ|MPr;IQlix%*4(#*%uMgy{ef3}zR`|(#NLt^*kFShpU!}C)N$-Uf8 zd}oXV3H+o_wjS%k;Tt4~@m&KlKE4Zgy^$a($8|`}hiYtDDn)9E4)MEOjV;P0$xdfo z;xeQfNB@%~+p={Do?VTN8l*`6HEojhrv~E!DRQ7*n|#o##r7vAcT4TtSv7s%eq2BfjBDV`a(9Pnx9sb{)1flOZ2-`1OphSh`4t_*>|ZUn#YC z$YEKM=&eoOMSa1~hs%=cn_492!&iK*M3#7XXpyjlZ`g3M9NAl}O$4Q{IAnx8iD}g$ z>kR8KVsa#KgEkpd@&zw&lp}TtS|l<18&>gp2#8l>B#729MFAl@w+WQ6H2JmZoA2{+dyXAGM0v?mHgKWq@$WBd(2 zy+45Hs+y1=%Ng9z>4tHUE#@KvI&<=alLOyzlG);&;G=bn$(S<^=^JJ5ZCP z`SCq<;Q(S%XGmn1*Wsf%%A^n(lJmE|;`CZ2;%{R_4y)DS%za8kw%>rHY1HA+DrI6@ zXh;S$*I~nzD&(<|26>p>jV)7D$kwA8q|K7gL911W%Rc`8)&AkPCzZ*=ZR*5&Q42N* zQ6-P6`2J@}6HcyICENVf$rbY!EFG;zRu^fJi{mB9WnV3Fz(t$nNAh(_UYjgAp-r~= zN|Ki*TIA#tZL)m1B%z`8OX zvFmh5RFWiFVyQ>&ZPX(U#RFbGAwn6;pi@w@#Z#=J3xlQI9yu=#WAD z{XdY=C-1|hNL1M`EV*Sc!3QKsRzoYktTvc5t>fdNxE1e7G9~-HG|9XPzwxeJ=A?%A zB~bi>Q`*f)a;hc?;^XpKk~t|Kr$!ovNDy@yb3%31$t`UOawW-({NVejipvsYfrlBX z7_C6o_)3#SNfsn0Ql8W&Ns|sA3vwt=p7b5!bGwNpnFDHMpHv4fd}~QYE>I0P5hjMqt%A#*IrZzW|?VAF#w*IN-6U1ie7 z=Xal4D{`S&nK(S}#@mdo$dnt(WZ08Vylkx%sh!I2-+U=zwZ)1!OpzpB8~EPlkQK42 z=W|4}6uEMJ2(eO-B+F439-?AH(lhv4^yDwrUT;l~uaYEE*?;l3Q`Y26j}lRx*ojX$ zSd-stl}OfyE}U9qO=eC~A~wPQaHN+FS@l$rj9$`(eRkTASrdEkyM#U*A7Dd@T6^(& zbqNwQ%7z#wXp#j@vZTJwhPZy#B=&sH7=FfTQ?oM5{+iu&fyLa2IySuw?-QC>{3N7yL@}K*8@x0^Wf|UI7m2+l3b6PVP za~jy;?RqsX)eFMmTK2f#)ErUSfvDS!Ju;u~5UU^zYHN?&&K4Nz5CjWn2V8t$jym@P z(YKx@H18{9Tv`y;PO!v<`c*P=ZZL*7|6TLOCIv&Eku7ld%5+$~w zuo^mCQUA zhRd_fug|4l58D;8gAye!}mVCaRjQMhBCQa3j8CG zR;WhW&oc3U9FDkHb3E8kF7xk%Lt$e9n|qZqw{rwCx|^daz!cjSMZj?iU&qG`b?qXs z^Rybf{x!w##tbGQv~YW(BMg!5$@HA zgw9a|C2O5dNf8*SutcN53bZ*8fkp=`v6r9kz~>RjJD|Y_r5Zx$?rzh&Z` zH2K-o4ZA{qiGEwY>>B5W6CdNn=~$t({$)Vwwm8

$hr6=y?AWpjO=FMSNi(U-`h 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%0DXUjq7^e{X@zC- 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
\ No newline at end of file diff --git a/test/3DPipe/ATT00002.htm b/test/3DPipe/ATT00002.htm new file mode 100755 index 00000000..441df9c9 --- /dev/null +++ b/test/3DPipe/ATT00002.htm @@ -0,0 +1 @@ +
\ No newline at end of file diff --git a/test/3DPipe/ATT00003.htm b/test/3DPipe/ATT00003.htm new file mode 100755 index 00000000..441df9c9 --- /dev/null +++ b/test/3DPipe/ATT00003.htm @@ -0,0 +1 @@ +
\ No newline at end of file diff --git a/test/3DPipe/ATT00004.htm b/test/3DPipe/ATT00004.htm new file mode 100755 index 00000000..d279d499 --- /dev/null +++ b/test/3DPipe/ATT00004.htm @@ -0,0 +1,285 @@ +




Hi Kei,

I would be grateful if you could share your 3D pipe mesh with us.

Best regards,
Ehsan

On Fri, 21 May 2021 at 09:58, Kristian Valen-Sendstad <kvs@simula.no> wrote:

On Wed, 19 May 2021 at 10:33, Henrik Kjeldsberg <henriakj@simula.no> wrote:
Hi Kei,

Sorry for the late reply, and thanks for your comments! I'll have a look.
Agree that it's more convenient to keep it on github.

Best,
Henrik

On Wed, 12 May 2021 at 22:04, Kei Yamamoto <keiya@math.uio.no> wrote:
+ + + +
+Hi Henrik, +

+
+
Sorry for sending a message at this late hour. 
+
I am trying the updated workflow and so far it seems nice.
+
I will test the post processing part later. 
+

+
+
I added one comment regarding “save_solution_after_cycle” and also created one issue for the warnings that appeared during pre-processing.
+
I thought it might be convenient to have it on github rather than on my google documents :)
+

+
+
Anyway, have a nice holiday and (a bit early) Gratulerer med 17.mai ! 🇳🇴
+

+
+
Best regards,
+
Kei 
+

+
+
+
+
+
On May 11, 2021, at 18:26, Henrik Kjeldsberg <henriakj@simula.no> wrote:
+
+
+
+
Hi all, +

+
+
I've created a new branch on Aneurysm workflow called artery-refactor - https://github.com/KVSlab/Aneurysm_workflow/tree/artery-refactor  
+
It should contain most of the suggested changes we discussed today. I've run through this myself using the artery model which is located in the test-folder, for 200 timesteps and compared the results to the original Artery.py-file, and I can see + no differences in WSS or TWSSG. 🤞
+

+
+
Kei and Ehsan, If you are able to test this it would be great! Just run the simulation for 100-200 or so timesteps, and check that you get consistent results.
+
If you have any comments, suggestions, or discover any bugs or issues, you can add them to the pull request (PR) I made.
+
If you haven't reviewed a PR before all you need to do is:
+

+
+
For general comments: 
+
+1) Go to https://github.com/KVSlab/Aneurysm_workflow/pull/15
+
+2) Scroll to the bottom and add your comment 
+

+
+
For code specific comments:
+
+1) Go to https://github.com/KVSlab/Aneurysm_workflow/pull/15/files (or click 'Files changed' under the PR)
+
+2) Scroll to the line you wish to comment and hover the mouse over it 
+
+3) Click the blue '+' sign and add your comment 
+
+
 
+
+
Best,
+
Henrik
+
+
+
+
On Tue, 11 May 2021 at 12:04, Kristian Valen-Sendstad <kvs@simula.no> wrote:
+
+
+
Thanks, Kei :)
+

+
+
Best, 
+
KVS
+
+
+
+
On Tue, 11 May 2021 at 11:55, Kei Yamamoto <keiya@math.uio.no> wrote:
+
+
+
Hi all, +

+
+
Thanks for today’s session.
+
This is the link for the comments I made. Hope it will help.
+

+
+ +

+
+
Best,
+
Kei 
+

+
+
On May 11, 2021, at 10:02, Kristian Valen-Sendstad <kvs@simula.no> wrote:
+
+
+
+
Hi all,  +

+
+
Here are the coords:
+

+
+ +

+
+
KVS
+
+
+
+
+
On Mon, 10 May 2021 at 18:42, Ehsan Khalili <ehsan@simula.no> wrote:
+
+
+
+
Hi all, +

+
+
Works for me as well.
+

+
+
Best regards,
+
Ehsan
+
+
+
+
On Mon, May 10, 2021, 18:32 Henrik Kjeldsberg <henriakj@simula.no> wrote:
+
+
+
Works for me too!
+
+
+
man. 10. mai 2021, 17:52 skrev Kei Yamamoto <keiya@math.uio.no>:
+
+
+
Yes, that works fine with me. +

+
+
Best, 
+
Kei 
+

+
+
On May 10, 2021, at 17:47, Kristian Valen-Sendstad <kvs@simula.no> wrote:
+
+
+
Hi everyone,  +

+
+
I noticed that I forgot to specify a time. 10am?
+

+
+
KVS
+
+
+
+
On Mon, 10 May 2021 at 17:26, Kristian Valen-Sendstad <kvs@simula.no> wrote:
+
+
+
Thanks, guys. See you tomorrow.  +

+
+
Best,
+
KVS
+
+
+
+
On Mon, 10 May 2021 at 13:10, Ehsan Khalili <ehsan@simula.no> wrote:
+
+
+
+
Thanks. Sure, I will make a list of my questions.
+

+
+
Best regards,
+
Ehsan
+
+
+
+
+
On Mon, 10 May 2021 at 13:05, Kei Yamamoto <keiya@math.uio.no> wrote:
+
+
+
Yes, I will git pull the updates and try to run it again today and updates the comments.  +

+
+
Best,
+
Kei 
+

+
+
On May 10, 2021, at 12:57, Kristian Valen-Sendstad <kvs@simula.no> wrote:
+
+
+
Hi Kei,  +

+
+
That sounds good. Ehsan and Kei, could you please compile a list/presentation with all your questions and comments to the repository? 
+

+
+
Best, 
+
KVS
+
+
+
+
On Mon, 10 May 2021 at 11:31, Kei Yamamoto <keiya@math.uio.no> wrote:
+
+
+Hi Kristian,
+
+Happy raining Monday ! I am doing good :)
+
+I have a meeting with Mikael from 9am tomorrow but I am willing to participate after that.
+
+Best wishes,
+Kei
+
+> On May 10, 2021, at 11:27, Kristian Valen-Sendstad <kvs@simula.no> wrote:
+>
+> Hi Kei,
+>
+> Happy Monday! I hope you are well.
+>
+> Henrik, Ehsan, and I are trying to improve Aneurysm Workflow and would really like to have your input. Would you be willing and able to share your experiences with us in the near future? Would tomorrow morning work for you?
+>
+> Best,
+> KVS
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+
+--
+
+
Henrik
+
+
+
+
+
+
+
+
+ +


--
Henrik
+
+
+

\ No newline at end of file diff --git a/test/3DPipe/mesh.h5 b/test/3DPipe/mesh.h5 new file mode 100755 index 0000000000000000000000000000000000000000..dc88b4e0e0dcc54506f478cab32f38be2ab66e05 GIT binary patch literal 2865805 zcmeFYbx<7J*Deepc!1yz0fM_bBuGd|fZ*=#?(QzZU4sO71|6K>7Gz*>cV~b>K5|Y@ zeO2$hx4v6-?;mgdzSA?)>)C6swf63(d#{;U)gAs(;sY8A5em%j4G9V6CCux;;6J;k zKU;JQ<6o+O+W++H{QL`f|6t&w=U2_m?N^i@z0J@BWr>f8zbuHr(@-|JwrdjVKJ#UpDVxxKLrZ zp8hz%KWl&YzkvID7*v=ye*xIP!#?BR{je}b#wJ$!PR7sc^Y0Dm&x(S30mt@7hxojR ze|!Bk4A!5~ek(5T%JpDi-aVuL^X>OKg@t|bKdjTmKlA-xjd1((@1CbWcEKJ0bIY#( zqF;UYx5GdD{>|b4-1lGYzYP4#z`qRq%fP=3{L8?<4E)Q$e;)?ibdEry7TEG6A!j8s zDi!HP=Fe{d&NFl;(H)D@6r*-**7qfhs>d(izt*CQP{aAge?kS1zdnTFwmeF)bH6QG zm+G2880|yrI$Wh{_-NweL$0m;G;(+2^fN)^VER#K)X@jHyP;G2RO)NTvB|w-dsmm< z1aLhB4*2fo%v{8Jw;yg|A9Eg)K;R*`5Hwx}5cyeViu4$3ik53(ko78$ovQtuT?T*| zjCU+>jBre2L);YI8r&M)8c19x+8@imverTh{w`E*qrf1TvFc*q3ZTCz8p%k8&K#{> z+i`A>rt%st`?xDDiP(&_@n38M;I>Iu@kTUP@xYKc_fP=!MKaiRu#IY)bWH_-d!aHS z*iX7abWQA~xPNBerwi#{v{UHY)NoKZJFpB-3-Q(z{uQl+b_ttyhL{R+xn9!8G*OX&A zy`V_G|1%}vsTh9+mX(;8?fKM#-IZh>fQWX5IFyD#9~Dd_`)R%N{S&2we^Fqfe3PIj zla!=-`1vdMl}wSe(Z?JF`FMoUX+i}e<=|uL(jd(*4=v3gYOMJa^0;)xCD_L~QDiUj263qk#tSB&_-23SzxD|lKM{992xuo4VM40Z~g!ck8?jddFc1YD+hXZuAw779>WVB$vrJ$KlTw^yV`zy zptuVCMXuoczXxEi5Py+>^?mp7{|(+e+flB_ zeJXMLB#~t=zVfLBCnP$GbZGa*hY@HM;b2zovQ14-1T*Z0Qg%p0z)P%Sbi-GKbFgzX zfcM4v?#GR&0|O+k##@bmW;0ywNQZHo=4L)83)f@+9VjG`_i}sao)d%lDJ@j|F)cLx zX{3khX+%8T^xefPvuxN=&Rlnda@;v<)(j{AssU>2sQsXcpVfHsKVBLs_cN+HxxNdi zfv+ESd8cr+j71B2yf}}#z>Jv9S|trAl+nk!=|b8g{5AvY8ZorbsnghVELzOMdZSAF zWtynDHjoPT#%k;=hrwUnHL*jaX%{BBYtCAIagjo@e=}FH>Lm*X(kYn{3oIlDo&}Lg z;LWc-pWHXaq&o9D_n2R45thVX9jj?0x4G=f&LZ!@D6OX>D%A(BPM*V}pC5H{(LuYj zSwe0kL|N04NcAqLS7t>!NL{=$^8$_xRu36H%Zr#1EOGi()gx9veUw?6Bs`kXu=e@& zR_j%916-7_I;EQW;{Z*pIb~S=bd`WLV-WN(sFg~B@~f-mm{L8qzjA-}n;9pHFAMEL zdAk`fk0h3LgVx_*QkNW8t#V(t0ap@G_i*2>!j96ZhQMSl&op)XTV-aMOdj zcZJ4!d-3%gnh2e(1v=ndgopbf<`u^xW>jwbfAaWsJd*;bZg9z8gcT%HJGx+YU+#n_ zaJO1xBxWf$A&u3_SwyH|7Cl0gwF;Ed&VcYq)%$mse`*a*Sm>l@QI(|q21ifJ-P2#@ zpw}DVF7BFb5V(8@A|sxfkK?!TJEt<_+09X!PE@MXYp&T&%N}I{xKlet95B;p@sjiJ zhf-lXXm3##BxvdnJNHYXxu6Cud)g@SmcWnwk`NhIF%O|?n)9A-1t8Bp%-q%NNmGG$ zM|Ybk%wawQVIA@JxjMNDCqi*$uf7t|^Xx=e=%*-e;1_B)=s9d?PUNN&eN|056s##h zXf(Mx{DxW?;xdO8OBt)&#UyEen<=jxSC&ljom3V1N4MD1Ljr^U#r}HR!cUZWPOIE; zdU^VvNR_4B74*SBUrP=C8m?OF_J^MFb5l>4a<->F)e#hJa_c;%%EMrO>Po{ag0D83 z#-nHzB1d6jSq3z+kheY74lkuh`Siu{rs6cV0bL!{1#EYzE|&Q;Mhy9Vin>Pg>u%w)k|E zqPyYOyDjeAK&{5Y37maj^fGOjD*uF}tUKD+g2Gcud2Q{XVJy!+X?HF!_u5#2T4Njq z^_8fmzsGi#pmA>lKzhk@WI?-uK(M#WLsbS1{p0y5Q9S^mwR{E59Y-s=?iwH`PzOK` zm2)8!J+`2-h>1*PoCf*1yn@Vz3ZU(NI~QJ?Z}cb^9L}yB(#w}wZC|oY&}45`Ro@|K zg`XL#X+6TxIMr@+BsbLJJO=TP*n1KYH^_>lX_}Ap-%C)90f_Kqm(v~G{NYd&NVb!H z(z4s1JY*6dV_LhZlz9i0YY_Jr4h7HCI-FXDR;+m_qjShfE&+Taq8Ae(Y~Dw1d@@+e zU#C0!1Uv5Ov4~kdBt>}>WiEzXBQscz(lk=|x*y$=dwab~jZfD(?vX0?)A?5B7dkw1 zmENv;ahiD$=4{GhFK>KPMxFu}%;zCjtgBT8gOLMPb`GKF>rN#5h1ZlWLeBPDI1h+-K2nDjCy8(FkW?$0dq9K_d`qb?YpXq@>o6xRkTBd31m7Ak8^^RA(-x?(Zi} zlV)kh5*m8ow+?E4Nq8N>`#>dddN=xw#hd?#VEy7NbBAmc&wCMd$)|mZ8Xc=mshF41 zik@2C#nKazn0eQ;`EaH}p4f`D?W9L#IVIL9M`Djr;J}`8L3x5+Bs0{6)v1^rN$fg- z>fGDuu(p(=)J5;BaYh<#vr*^B!PtEXj8^3Fw}n`3uRUiyyddg07PN_jq2|lSu3655grt(|r-s`UcEZ0$Td;t)9a{ zYc)L^@lrFt!w!+eZh^p4n~yiop_UPIqj!I>5peZt&rw?c-cr#RQ3`X)QpxUm(0zN- z_wn37=GsY|g5(mmJ&EVVJkV<{oO?}(u1VK0S*;)56?DbBnB$Pkuya{riDp%DqQ=A8 z8IP<<)0V1_$ZY5MqjGK6`0AA6q1Iqzk;rXzk7WJ3BCNst>Y+Tz!Z`DWnq@~97J|&S zmac-j*X4Dk+8c**U5`W|V$&cdx8?IZ&?pP8iI%`>bJ+>I3-3lnE(~5d?-whAZ z3|ob+5c3DytC?juK3jX7g9d|+b8!NZpQalxPEt-)qCnZV^mgOj7xS>PLXmHV!dW#tDozf4MaNVt8_y3ads?#ZzY#<5*Bf)|M;&9iy5e08n|+9NHp+KR zV`=7;@-!3d)^bzD>^7skTa+4b@qM4xR~LtR6RUj7g}v%9$A7tCh-4?vo$QtvpLB4o zzyBt1Le(~`b9n1bTPDAg^6wA z%*^EHJnFeDgHhri*LH8okVg{5IH`*(oQN^dfw;t9Fc>TeNoM(#Tzv|iL4>Cmv%a~R z?>d<|`vNB1&Az^}6kh(u>n$YMhF5n?(4uu<)eFxGkde!oF-TP8V5Q0kAHTQa=nGUM zINF_r9Q6vCnMY;WUgn`;U}SN(n>#RSaM?~hfHguTQ5fsQWG}u_83z}9{}%Xo$D94s zXD)tGA}1)rf@^S-3$rN4dyu=Ry;)Pyfh-a%9Zxc)GzD$c-2kfK~r3;5&C$NB$*i;E`G`@XY#fO^9X{Trpd;ouqfV zld)vp#GhOD0`Q=#i^ZB%3l7C7QtHw6vCTBL2fZ4s~;hdJB z-0^#2|6tSj)3Tp?Qzi*sUPiM;Lc9ovVF%A&1E3{y5tar@s>*L83! z7rWh558WNL8GB_KJ9~s{6~h#3|IqgBTqS+ke~8RXrZDH5t)cOKMiG?-W9JG*s(S5< zxp-xrD*aCo2Wb>deJ2@ksJ2spWkjRtKypBvMV5oz<=7B6AF8(1qSd2db#bJHSs?Gv zQd@xa3y8DITflDIjzRRs12C8qae*@7HBc-PNrpa@qLZzsq!OOZ%?N3}YxG}#dr*gu zSlgLC@VSP`)Ns9_bY7ndl$&atRqw9E4JN(V=hzYF9Fx`Nrgu|^`;bUrqcm6+q)~hZ z*YHca(+8B?o&MO<%}>PqMLAkESCq-K;8Y2n zCJU>!8W*6~S{g>Ho@HnTx1%(u6WDO;`a|1L%Fant+Bz<= zBD`2unj*HZ$Z5w*pc6v_Y-x!`ODSk}Q!|%7y^1Uh^yV#IR~wzLacfi`Pd|ixCCWKZ zQV;g<Dle=$e?g4{qtwDgk7uy#XTIt8bsims%EDJ20BM@QFn4#Rg24jg2$tRUh+>4bWnFAp#Xg+Vgu zZ|z&ja$=o^GzT{du!e1~LZ(!rfJbp|lF6Y09__`#DyMpPXX`cko|0^k&9MRwycYzu z3N<$Qp|6J^{5-g1zR{{t!_ITMti9Z**TSid?~ruPrK$?7FH_6gv(8k+ zA>Si-Xc;5yGiG7}NCeplgzn6-8d=Z+TL$hrvOzCftE$KzNAhr+76w2*BOak-MMWMK zl`n2?x=+nkdU)K(Y8C0wJrO~H=hT2CIFrvWhmN5VKXbgEx{H)Vd}i-+wOo>81B-3Q z&$mADv#_*~HUzBry)Q$tj7|=x;BgDBjF6|g;S}*jcO#EvTpriVDS05+z!@z_PcG^T z)v8-;ao0Lz`58&Xs~!bDKJ5}_H}EPJzA!X06?OwbmKB+;I)4=g#+Gi`uSRJ9BGJdg z?motCy>tJimnYT>^gss&^@&c)nGGj*Uu}r0Rj_{kwlTToE2fT={T_SxQNV@V$>!$> zIpg%xqp9};5l}gdKcD@}GQ7z3avgo$tb4Tg+|cLqBIP{r;e;~E^-MKrhL`F_kX%+~ zzn0Ex63JtX!84SG=S2_u{4AdmQn;)!e-Q%HuMGYQt%6FJ{0b*BT^FgSKv=UX)uZ~1nz1VH)#%V;r#GHCq7jN<5;hG}F zM)-Hf?&5L{Ca+Hp>c7*=m_Lr`&M`|Xrcd2x0V_9>int1I1%0*WSbkS*TpwG;#s4bR z+&ix%a23*zuG}7oyfc3`2VTs1*GwfAary34L3<1T4m2(k_qV^Wl*Hd|S6ZZhtR0KK z(~mx3+>+xaBV+uo0YZ6|pihW)5&Jkv5egE!$6-p+0#z(iKb$DS6@nDy>EypfL^u?C zHYX~S;D}Jhr)UlqYH`@0^%HPzun2sbJ8_vEo`YOG+{3P1XT(P`$h2@n|s~Zr;R6Ow=3FGMcX;4f^OQU*%U~An zr?nlaHCFqtGK zFn8%%;cP(_QUB;FXR{ZOR_6<)?J*^V?yPK`ltWE{CbybTLab)dv!WY(9v*#YQ3vi2 z+pbRg1u&$KnYjuq_EUi#mjQ0{w&Qe!abCC`ibU6^+XGd& zT~IV93Ey~z=~ILAY8!E#4Ulw~LKR$LpPPdB39-RHTY=J31JR@4G44)$ALEDU_y5~q z@*aB>_%wYBIXTEP!?w=1HY4@|zLA!XaG;aScvd_$qdm6M|8BpL0g6Hnb=2d{^_+}H z_uw)|=uwM5Z`NsY2%EfghmP+K)=%LpGMDWQhjrg(sl10hG54>MnTnOoKhV)b*nNJpsw;{%2ZJv1)sS)N;T8M zo7|%h6k(Dzu`0@V@4{~ahO*Y-Cvu71u4<(CQ#+I|h57PGv`85tcan)+gV*089#D*{ zowJ{A{ZT51o&t|37D!ja=LcEh+i!2lxkVnEBV4$}~sdWcbR-8x`-zaqoc_Ic! zeirGR-)mH)St*5Y81x55y3YEA2a7*&juP>aKsRDSmARGRdB+l)%wRSy{Wd+;m&yJ4YCO^wxefbeau1Ux&N7V@UI?~&%PGUQx*u>C-9KQ}K%!mrkbVjpl9 zqxn>`I5r{HclQ=3Fu-Qwm8ixex8^Ur5WK9q{ceNZt(=3>E?>6bU)3SXMOTZKDHq-H z)50>CC<%QOw@!0yAe9+wg}13QfUZDux?bR&>D&y|qvPnbvrzXy+MHNvb6H@65`>Rk-#(OqmT0s zYz_Qi#488EccRC2)}2x4b~Q*!UZ(TtjygD@xN1%Q>XPaCSJf=5QIN#kAiw=6m^|&oI8_FS2sQgAKAS> z2PltMyR4Q2T8|Lwa-eGmb>BeatUrO3!64gIFb=)A2~hAZWTO8Nl6$V_Pwfca?j80o zNZlZV^yOoW*!ybS_>hg0K+ejVX2M78AvxK389kYy`%G!dMe9=Yw7qk}A}&=Kbi zG7qTMw`Lnnc>?t@ttKvAl_X+LjD1F)mI~wTu3(VP-PnkbnsTkzfW8UY%e37jUA^tD z>3+epjWqW{s{vV}zL7HK@ayICkv4_-D$gBU&MMhqqLXUFZDsLTftQ>Ymp8GrSRErm z!YAMHJp9s%lTXSHE>hhEysV&$XCp#O*T!oDIws4yR=YJH4YwZv6Cw2tBW;jYyP*NU zG>9d(7^Lc1ojqjkB0J(;zZK`%^?6(51tG?f*S3hp06(r#FIZ~L88{Nc36YmhX@1bz z?jYfp(+7UdLuR7l*y2iqa$J|EKjA#9fnNb&>aZCsT^@`(8A z?^zYL=IstAi((PeoXw_-@0KxmE!T8(*LOTgxvOu#&z~%e2z+PQf|UQNC5i~p;62x1 z&|gVj@S!)+*7Q8dfFPM@D<+@tIhnAdUcdEiOwpTdXoOo-3`li$ST32xayH2tQHnat z9xYF>@79u&GRfN9)}1bS#Q^WQw?;e0eozTmOh(KLW&$sT2Y!h+nTAE2ph|x z52I3cD>E{eufSr3K5cj6gVe&(2sVZMf|Iw~`xkNl>BYeR_-ZGa`YByS72T^PIqQr{ zYgg2k169cuX3JoC#>54TDvLhk;Lw9jDBsrv6OPP{E=hL!W;b;-vXLvp9dgdplSg2$`6i$_ zqt4ghaBHdFhp?OS(E3^K2ce~{N%Mm5wtwn5h=^NTBqW4cNyPh%Kgi=!b0BhOT@1T8 z2S~aTc>5DtH_r*$CCSR+Y(IdzNBI$-l4uD(Bh}EsU^9O9@mv7@0mAI24DkvQbX+RN zA&OdTE`v9ay(6G5!G{&@AIaP-TPry6kCrS4dd-V}&3WT~3kji%s*;`i2*yOOb-`{K ztMmv6Rb5$8PCG_^2)&+bQ<3e;rVMsV8W$lrsy3gTI!!6j7upGqQpT~^zhoTZ+cNMI z9@y?#=ksD;-@d8u@Y;Mi-g@_m8s3l;Yo7)z>t}X_+frDIX~zPYOan$n%A3I2T8y5} zy(w}Xb8PlNPmG}(6Ff;oInfd>BB)|Q4D^FIN4inJ_Uf$UdK&(GYM(-WU2F&sKt)wW zdSJ9u_~k4dqr+XPky)*L7|T&E@B{c@<%CAm;7MFEsI;1#K#IS4D{1#A`CYvJl>Z}X z9gC-65mEh;l67_{zM$d*`uR5+(;^Ud@qw_6soJ+TB?C2Bx z)Rxt!2R}&X!rAxYAE|+%%%-?8=cw-$vo^QJTWt$w9%F8xWDTi4MGlcKXtCj(hF*S< zbas>FnDl9NM!R^V8WK4nMWo%mG1jahVpsRQ`z2_MR>I5Zvqo#fBXU#I&TB1+H{&aRR9D8N$l1iHOg%p>*ZMiiRIS>n++QK_*sSQWcYG*UJ z=uT42w6~fHNo@M0wJI_PL}_QK5-M3#jnTCw+wb6L#B8rBQ`(6x?Zn4l3gE3_ zoY0kGU-}h-Dw0CkaZ~R|;oVRrtI3M!k^xf5hs7w5sH>ct;SO+71ElIwVB8>P$#q2U zh_yFcZWOkTe$_fAH*hFG-aO{ZXwF*ggcibj<_Pe-0Dgup%zq{06L5AM$l4K$MSe2T zkPx;@;7!S_+kV&3q!M@8s4>CC1jaEPMJQAq&c02ldm}PoUNBN?L0~;Q^Aq?LV=R{I z!bhtz_{L!6(|D80yHvc-A{o;!2`A%iV#OFK=m)yv>bG;+csO3)+MgJVw=7&<)sui9luq? zvk?)xO(V)v_dc$?eZ<|Fh3R7h4zcrFR3QwaFIT8;FJI7Kc$bZvygMW3#iHiOe(&|w z6TDRWL5&t4c_-&=6|}D}mviT+cRs>?qdpO|e+X|l($K6|{4H)@|d>Jxi3izXw0#-r<&v}m^pN^2i0H#Ua(ktaR3fJj}E4jJu47Qbx^pTt&2 zG--HSElSTKto*}=Y~KsLz}kk9t=YH_mu6muoV)>WpFI1ot?qsXCkN}!dOe@x@NgDa zQWS#XB5j*&rGXy8zM9Z15w49Th+$F1$hM&iP;8;hi%exavVrH)CIqc~ri1$Ng&qE{ z!?E`MP+IO}qHnT42sr279&~RDX_4NTJ>>U#wW*0dDcY|J-XGEF7AX`W`KH#46*$XOq{r?%GyO6oWS&YAfj4ZcVxB&cMpE*c7MtvE&k?MXiA$^Md~^>7W74Qx9T zjAbI3X`Bk~_3}5%+baN)>Fa0Eyd_6P-w!i#>?uExkeLQ9D?{o6)j!a2@e7?m60YP-%MH$+fxM z*%}9Sx2oZjZnR64=|cw)IQ`9+CsSqs9-3dS6N+$BX=}_f7E+t+9_KSreXX~0lJ`58Gh0x?)^yM2ALLquWi#+CEDS$eS=$p}Ma+_wRwdRal~w(mnN?ec&s# zlV}dgSbEh44m$*zR1!6&NDLiQB5z|d?tNsKfQ2an1u6YdD-?^vqxqMk_P^nxkZO1dwLe-m-ciABmJQlfj#v3%$J|ef zj9eHDToTUUw28R~#>Nv@qUzU=CxoVDSe&Yy+C;`YB6fV8D%_Lub5Zg&#NLMSB&FhGQ4? zqiXmM6Ex0_k$EL=9uu97z2>*vdaWi=^%h*HVm#Cr3LQ4)-2?zKtfBNP(F`ELXjpL?D{ z?^%0Z4DmhJ0;lC=vE>P*&hkr2{0b8lr0F@Qsdu5^8KsoB$Gz04s|j))X{o7kr@37O zNd2kJPa6zEE1x+zfwwjp+g3b1^;=7QY}U7K{9iObIJcbF%Bt$9&aJg5fQ&;mH)acK zM~RwDR)7Z(ZxPYUvmC%9*mNBK*!ReBnKxVaivNTNk_8n#<@FxB1?}AH0yM#-$7B#< z2qN#gXUt8u=6wv}ePt-M)${$Go2s^DUM(B8m}aJPoI~zP=PUR`a1}rCWnG7wq=6-qaa?>6%yC(4s39M zH!3*5Q4Zu9p;>D?*!=lAtLEfYQ+LIDlferAG0B`Au#2})q{Gaus;eP$di}7QC8Q=Y z(-7a@MIXOsUNTdAzK`v1=xv4XBA=z*yZEf^1xdF3-aVuL4o&dWT%T@GI;YC>$)1y8 zgo7dRI~!~yo|3gmOr(mBT+nyaj8D+2SFtd+2X$%9Dol~k1yAuE8qgAEyw$Wemr$#1 zY`C_#uHuortYdFx_^t0_nXl$MGDf*5Q3gh}L-hE`1;l76@$GIp*||8Y>aP!;G;Ml{&5D+s?g+$}z+oZ2Y7L!J zm%wR(1W2vbsY>7^TVjwwrO`2iXS}Hz{SKZFsX4pZ-5U|JFxbblgC#I*ipCU|@{wag zNPh`ULPVw6!{#)f=3KT z7MSvTOUI;~jL&Q`xn))+pW#rVh+d#&=$c?*1{1@5puBtx3hQ13kfEuHQ0B88oqFR( z+DqUxqRp6nOAwU6sT@6YCC6BPlh1~Utm6dMrO2OP%J{-0lSP%!W_ZD)Gn*dvw2zT$ zcFyxV)4aD()F=3`R;E&+!7Ve*B{O}wZG!CV^E6ZPS;2K3D@ed$^ULd(UHCw_YkMd_5YP(n1i*n|k427Q zk11@rq1g99;~2Lc;^2DW=!|nn+Iozg6o3$70?s(|b&Pt>HqE>{%bA|EN9tf?o33_v z2p&N3IBPu_tht_im~H=@Zq}D0mT)0s&8{)e2@|a8c=E#4zb9Rz|OW3gCa={|g6ir-+1ukZ5T!M*ya zBodfU!8-Ok>%3dic9Rw&ud+p+Gr*U$D^e}|^! zY)X`djE&0RGbT!uti=ax3u6S#VEE9%DUP%c5^GW&_793O&)(J(DW@GvRQaa@m6SP3nVmQ8Uuz(C)+sdB22&oeehmpal$XGv>CV_`RC|dTY|-arV7~ndGng=|Zm(8W zQbJ#EgZsed^m!5`E~<>6=V{jURP-zGzLp29n8+rJJm;?W0o{+LZbk2uS4*C&N3=}(cvB!G|7=@Rr)3oi40 zvgd{gMiy8KK5s1)hO?thfk^ng2hBn&Bv~ZO#dA5Qdl$E6c(&8g%zIOhKWbK`d>ZW$ zF@wdOTl*rACAdaB1xS*>?Q&KG>QSQS z96qOT+!roHiL#?$TBTU?f)YiQhd4jfRq{FGHHu4}U0_k7l!5oy4=e~VgB##BlHV;7 zKacQm@tB50DGfxZIJqLCl+Mt!czu=vJMcZ5ILyop1F|a&hly5qjpm&qCecIP_v48m z%=ZkDqnC^OnZC5H=SNuxJ`_}FG+6xgD9hf+ciXt*9g*m}kF&gIm_aQLTe8ntCwPi7 zf|3Iw*dadY$V+~^v-w2x)-(ZR72>F%qw{L#d(^&qQt?&!P{#0D`H=gT?3(Nv(Kg!i z6CqoXArNjm>mTz)!Iq%u?gl$jE!Ax0%D@BZJ{Ca$H#ptf62J|8?C_bP)rG9BoZo5Z z2%n_+?oLC#9pv0ydWS%}?-}ovbFvRa9#&R6dLI0s$Pm~hR$ZQ7$34P+o=8ooO{fs0V|Fk$fc=8~KJ~z}%@)H(AzRg^8^YfUpDEjys&wH!VZmDOFq<`YBkEy z+3mBtq-^*2)~pjW9eKGgx$S`|%Q{ttpLQV0*Z#3e$EXs2?f+W#hD4-1tTG9P#Q3lh(qN9{*6$n=fj^Mx(Qb$o-lh!%bF0-g&>e*-0b>kv zpsrBj;|-5XkxJSe!~>7hmN93M#gV%AJ9uu_qO*1o&*VPaU8Nriq{?!#$%%0Di8R;{yPk=gDw7+s`OtbwRj^` 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

4tBL_SX6^&s$DYDn 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 QoL#sk!V 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

Jsqk-t>`nRYKhTz)EE61x-( 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 Og5h-)EFW>5+M literal 0 HcmV?d00001 diff --git a/test/Case_test_atrium_07/case_test_at_07.vtp b/test/Case_test_atrium_07/case_test_at_07.vtp new file mode 100644 index 00000000..5d9f2854 --- /dev/null +++ b/test/Case_test_atrium_07/case_test_at_07.vtp @@ -0,0 +1,51 @@ + + + + + + + + + AwAAAACAAACAQQAANAAAADQAAAAmAAAAeJztwQEBAAAAgJD+r+4ICgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYgAAAAXic7cEBAQAAAICQ/q/uCAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIAAAAF4nO3BAQEAAACCIP+vbkhAAQAAAAAAAAAAAAAAAAAAAHwbQYAAAQ== + + + + + BAAAAACAAADwbAAAhm8AAJlvAAD5bgAANF4AAA==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 + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + EAAAAACAAAAACQAA9hIAAIITAABrEwAA2xMAADoTAAAfEwAANBMAAJ8SAAB4FAAA+RgAACEYAABOGQAARxoAAFAaAABBGwAABAIAAA==eJyFnXfYznX/h7uNbNmRlT2y9957b7KyR2bKSJFNdrYIGZFSJKQkDaOhnaK0B0WpFJXy/PF7n7/jcB7P1dM/5/E6X6/P977u262H63t/n6677v/+SQomCya/7tp/8CnUJxNTapdC/np5cioRnzqYRj0+rfrUYjrt0iunkydnkCdnlCffIGYKZtbrS5/As88i4rMGswWzB3PI3xjMKZ9LPfmmYG5l+jzBvMF8wfzq86tnf3OwQLCg+kLyhdUXkWdXNFgsWDxYQueKaV8yeIsyfalgafVl5MllxXLakcvLl5avoFxRvpJyRbGydlWU6auqx1dTj6+u3r6GenJN+VrKNeXJteXJdeTJdYP11OPrq8c3kGfXUH19sZF25MbyTZQby5ObypObBZsr07fQOfqW6vGt5FvKk1vLk9uIbbVrJ8+uvXp7cgd5csdgJ/X25M7y5C5iV+26qu8WvFWZvrvO9dCux//oe4q9tOutTH+b+j7K9H3F7trh+6kn90/gB6gnt5MfqL6f/CD1A+QHB9uqHyy20G6QPDs+7hDtyEPlB8nfLk/m918Dec4NUz9UHK4deYT8MPmqYr0EO643MjhK/UhxtHaj5O+QJ48J3hmsoh09//t8l86PDY4Ljpf3jn5C8G71E8SJwXu0J98bnKRMX1ieP+dMDt4XnKLr4Pnz1UTt6KcGpwWnB/lz3ozgTO1n6Rx5tvw0+SzKqeSTy7ObpR4/R57d/erxc+XZzVNvT54fXKDensz3wULtF4iLtCMvln9AebHYR7slyvRL1fdSpl8mLtcOv0L9cvm5yivlV6pfFVytfpX4oHbkNfKr5ZNE/Frlh+TJ6+TXyq+XJ6cU8RvkyQ+L+I3BTeo3ipu1I2+R3yT/iJhOuwzqt+r8VvUZ5LfJkx9V3i7/WPDxBJ68Xbsd6p8IZlS/Q579k8GdQf5+u0u9Pfmp4G719uSnRTx/z9+jHr83uC/I36efCe4P8vfnZ4PPBQ8En1d/UMS/EDwUfDH4kjyZvy+/HHxFH/9l5cPBI+rtyUfFY9qRX5U/Il9WmXOvBV9Xj39DPf548M3gW8G3de5N7d+Rfzf4nnr278t/EDyhnv1b8uw/DH4kf1Q9+aQ8+ZT8x8FPgqeDn6o/LZ7S7rPg58Ev5MlfBr8Kfi3P1+Wb4LfB77Tn/Bn1+LPq8d+r/0E8m2B/Tv354I/Bn+TJF0T8z8Ff1P8sntXuV/UXlen5vH9T/lX8XTvyJfnLyvR/qP9T/V/yV3QO/7f8FfEf7chX5f+W9x8s3kuwS9IumTJ9cvX25BTy5JTB69WnFFNpR04tn0aZPq16e3I6eXJ6MYN2GeXZ3aDenpwpmFm9PTmLPDmrmE277PLscqi3J98YzKnenpxLnnyTmFu7PPLs8qr3dfJpR84vn1f+ZrGAdgXl2RVSb08uHCyi3p5cNFhMPb64enwJ9UXFktqVkL9FnlwqWFo9voz6UmJZ7crIl5MnlxcraEeuKF9RfaVgZfX25Cry5Kpiae3w1dTjq6snF5evIc+upvrqen015WvJV5En1xbraEeuK19Lvp5yffl68g3Ehgn2DfV5sG+kntxYvqF8DRHfRL+vasizayrfRL6giG8WbK6+mdhCu//P113rm8u3TLqWBbTDt1JfQD6Pcmv51urbBNuqbyNyX6itch15iG+XdC2za4dvrx7P/bL2yh10LqMyfUf1HUTu73VU7qTzEN9ZzKBdBvX8+aWLcmf5rgn23dQnV+4m8ve+W3Wd7sEeQf4+2U2eHfd72XXR16G7MvdRe0bm/i+7ntp30deBP9/415XvC74/+f7JLc+O+4p8//L93lI9nt+H/H7l/mFL+V76fd1b/jbl3vLkPvLkvvLkfsH+6vED1OMHyg+QJw8KDlZvTx4iTx4avF09fph6/HD5YfLkEcGR6u3Jo+TJo4N3qLcnj5En3ynepd1YeXbj1Ps647WboDxenny3PHmieI9298qzm6Te15msHfk++UnyU8Sp2k1VP02ePF2ePEOePDM4S/1McbZ2c5Rny5PvlyfPFedpN1+e3QL1vs5C7ciL5BfILxbHaod/QD1+ifqlykvEZdotV6ZfoX6ZuFK7FfKrgvycBP1q9auT/r1/UOTnJlYr068JrlVO1D8UXKecqF8vbtDuYWX6jeo3KdNvFtdot0Y9nz8/77FZ19uQ4ONx/4/dFu22JP17z/25jboer4OP+4jObZLnfh55awK/TT35Ufmt8tzn2y6/TXws6dod+XH57fI7RPwT8uQn9Tp2yEPuMz4qv1M9xO/S7il58m75XfJPi9zH9G5Pgj2e+5R7dG5vcJ/2e8VntCPvl98n/6zIfVHvnkuwxx8Quf/5rDz75+XJ3BeF+IPavSB/UP6QyH1Qdi8GX1IPD2n3svIhefIrwcPq8UeCR4PH5MmvivjXgq8H35AnHw++GeR+xavyx3XureDbwXfk35V/L/h+8AP5t5U5d0L5XfFD7cgfyZ+QPylyX8W7U9pxv+Skeu530NuTP5YnfxI8rf4T9Z9qR/5M/rT85yL3Vbz7QrsUyl/Ik1OJ+C+DX6m3J38d/Ea9Pfnb4Hfq7cln5Mlnxe+1+0Ge3Tn19uTzwR/V439Sf0GZ/mfxF+1+lWd3Ub2v85t25N/lLynTX1ZvT/4j+Kd6/F/q7clXgn+rx/+jHn9V/RWRB2Suao9PCibTLkl9cu2SyaeQJ6cUr9eOnEo+lfrUwTTq7cnc30ijzNeJXVr1aXWddGJ57dLLs8ug3p6cMXiDenwm9fbkzPLkLGJW7bLJZ5EnZw/mUG9PvlGenDOYSz3+JvX2udWT88iT88rnk88j5teOfLM8uYB8PvmCYiHtCqkvHCyi3p7MfaOiyvTFkl3b2xfW64XFtSOXkC8pX1y8RTtyKXly6QS+jHpyWfnS8uXky+n1lpAvqlxXX1+uy/01duXly8qTK8iTK8qTuQ/HrpL6ivLcnyNXlq8iz26QejyZ97cr6zy+arJr2Tjpv++4nt/PrqSvxyB93tVEfHWR97fZ1ZCvLk+uKU8eoXO11JNry5N5HxtfR762PLmuPLmeWF87fAP19eV5X5zcUB7ix2vfSOfIjeUbyvM+N7mJPMRPVm4q30yeXXP5ZmIL7cgt5ZvLtxLxreXJbfQ6WsnDtto1lef9eIhvp117+XbyHeTJHYO8X99OvqP2ncTO2pF5n7+jMn0XEd9V7KYd+VZ57h90UY8ncx9gtnx3Ed8j2FN9D7GXduTe8j3lbxO5H9FTvo96MvcT8LzPvlA7rtNX1+un3Ffk/e5+8r3V+3q8jr76+JzjfXNyf33d+if7936AOFA73ofvr573dQfqPNcdlOD6eN7/HaRzfB8M1h4/RJ7dUPWDxW7akW+XHyo/TByu3XD1I4Ij1eNHqR8hjtZulPwd8uQxIv7OIO9Lj5G/S709eWxwnHp78nh58oTg3erxE9VPEO/Rjnyv/ET5SSLvc0+Un6wef5/6yfJT5MlT5cnTxOnBGcGZQd73xs9SP12crd0c5fu1mys/T+fmK9MvEHn/fKFeH+fwvJ/NnvOL1Pv6i7V7ILhEfmlwmc4tVV4eXBFcGeT98lWRVwcfFPFrkl27X6ue/FBwnejdavXrgxuU6R/WufXy5I1B3v+n36R+k86zx28OblG/Wf0j2pF5v3+LMv3W4DblRP2jwe3q7cmPBR9Xpt+hc09o98T/6J8M7lRvT94VfEqZfrfO7ZInPx3co5yo3xvcpx7/jHr8fvV7xWe12y//nDz5gIh/Xp58MPiCMv0hnTsoT34x+JJ6/Mvq7cmvBA+rf0U8ot1h+aPBY+rtya8GX1NvT35dnvxG8Lj6N8Q3tSO/JU9+W578TgL/rnrye/Lk9+XfkT+m/QfqyYflT8h/IE/+UHxJu4/k2Z1U7+uc0o78sfxJ+U/E09p9Ks/uM/X4z9Xjv5D/XJ78pfiVduSvE/hv1JO/lSd/J/+1/Bn5M/q8yfvkz8qfkSd/L+7W7gd5dufUf6/XfU7+vPx38uQfxZ+0437xefUX1P+k/HOC63ysnvxLsmv9r8r0F9X/InIfnt0OnfswQf+brnsxgSfz67BT+bcEnwe/Dnyd+HpfUP5d/oL8JZH78N5dTrDH/yFy/927PxPs8dxX/1Pn/gpe0R7/t/p/1P/zP/qr8mT+j0qSkl/b45OpTx5MIc8upXr89epTKdOnFtNol1aeXTr19uT0wQzq8RnV3xDMJM8us3p7cpZgVvX4bOrx2dVnEXNol13+RnlyTjGXdjfJ55Qn5w7mUY/Pq96enE+enF+8WbsC8uwKqvd1CmlHLixfUL6IPLlosJh6e3JxsYR2BZTpS6ovId6iHbmUfEn50iLePy9RJsEeX1a/HqXl86gvq/O55LPJs+PnObLJl9Pr5/Mvrx7Pzz2U046f8yiV/L/3nPevC58vvz7Fda6EfAX1ZH6Owp5zfB9VVI/n5y0qaFdJPb6yentyEbGKdlWV6auptydXD9ZQj6+p3p5cK1hbPb6Oenty3WA99fj66u3JDYIN1eMbqbcnNw42UW9Pbhpspr6p2Fw7cgt5ckv5ZvKtxNbatZFn11Y9vp18W3ly+2AH9e3Fjtp1UqbvrL6j2EW7zvJdxW7akW+VJ3eX76Hr8XF6qsf3Ut9F7K3dbcr0fdTbk/sG+6m3J/cX8QOCA9XjB6nHD1ZvTx4SHKoef7t6e/Kw4HD1+BHq7ckjg6PU40ertyffERyjHn+nenvyXcGx6vHj1OPHq7cnTwjerd6ePDF4j3p78r0iflJwsnr8feoniVO0m6o8RZym3XTlafLkGSJ+ZnCWevxs9TPFOdrdr0w/V/0ccZ5285XpF6jHL1SPX6TenrxYnvyAiF8SXKrenrxMxC8PrlCPX6nenrxKxK8OPqh+tbhGu7XK9A+px69Tj1+vfo24Qbv18g+L+I3BTerxm9Xjt6i3Jz8i4rfKk7eJ+EeD29XjH1NvT35cxO8IPqHenvykiN8Z3KUe/5T6neJu7Z6Sf1rE7wnuVY/fpx7/jHp78n558rMinj+XdVffSdfdrXPk5+T3y7dTPiB/QP3z4kHtDsi3UX4hgT+k/kXlQ+JL2pFfln9R/hV58mF58hF58lER30ie3Fqfz1H5I/q4/D3pmPJh8VXtyK/JH5N/XZ78hjy5nnbH1ddWPq79m/LH5d8Kvq0e/456e/K74nvakd9P4D9QTz4hT64h/748r/dD+RPiR9qRqybwJ9WTK8lXUn8q+LF6ezLPl3D+E/Wn5E8Hef7kVAJP5jkTzn+qPTm3zn0m/6k8+fPgF+rtyV/Kk78Kfq3envxN8Fv19uTv5MlngmfV479Xb/+DevI5efJ5+R/lz4k/aUe+IE/+Wf5H+V+Uf5UnX5T/Tfmi+Lt2l5R/lydf1tf9kvwl9efVc50/xD+1uyz/l75vLsuz43mpv9Tjr+j7lf6KrsPr+jv4j3p78lWR55nY8R8Au6pzeHKS/kNi5GQizzmxS64+SUyhXXL5lOL12pF5jso+lfrU8teLaVJcuyOnlSenS+DTqydnkE8nn1E+o15vKnmeB+P8DeozyvOcGDmTfCbteZ6nls5l1i6DfGb5LGLWBHs8z/2wz6aenF0+qzzPCUF8juCN2tmTc4o898Mul/oc8uSb5Mm5RZ4f8i5Pgj0+r8hzRbnlee6HHp9PfT6dy6MdOb88meeI2N2snlxAnlxQPr98IXkyzyGRC8tDfBHtisoXkS8mT+Y5J4gvrp5cQsSXFHleqYQy/S3y5A7KpYKlRXwZeXJZeXI5eXL5IM9DlZaHFbSroL6cduSK8uRK8uTKwa76OJVFnhNhR66s6+HJVeTJw7Srqn0V+WrB0boOvrr6aupraEeuKV9dnuc82NdSX1O+tjy5TpDnQ2rK19G+brCe+rpife3IDeTryTcUeb7Eu0YJ9vjGIs+hNFSmbyJPnqJdU+2byDeTJzeXJ7cItgzyfIo9+1ZBnh9pKd9afSv1bbRrLd9WbMe/p/j3U5DnVtor089X7si/N0R8Z5HnRDopz5PnORLOddF1u+i6XYPddL6rchftblXfPXKPYE/lXvKwd/C2YJ8gz5P0Vd8vxbW+pzLn+ut6nOuvPCA4MDhInjxYfoiuN1gcGrw9OCw4PDhCfqSuy/MvQ9Tz3AuZ51CGKY/Uxxui17NN53g9o4Kj5UervyPIcyujE3jymOCdyon6u+TJY4Pj1ON5bmWc/Hj1+Anqvae/OzhRmZ7nScarx5N5jmSP9t7xce4R8ffKkycFJysn6u8L8tzKJHk4RTuInxqcpp09eXqQ51Wmyc9Qb0+eGeR5lRkJPHmWOFs7/Bz19yvTz1U/R5ynHXm+/Fz5BeJC7RbJs1us3td5QLvF8kvkyUtF/DJ58nL55Xpdi+RXBFcqL5cnrwquVm9PflCevCa4Vv0a8SHtyOvk1yuvkydvEB/Wjrwxgd+knrxSfrN6zm+RZ/eI+s3iVu3I/wFvT4R6eJx1nHe4zvX/xzn37RhJKSMqI9IgKUnbKrIp0SRRSWhvqVRKISols4XKysiWWUY4sjeRUchsp37X9fu+Hn98Hpe7f57X4/F8vj/3577P4Zz88fksnev//xuh/Cxyadb/8nP5kemkh7+IHKXeHh4dOUa9PTw2cpx6e/jLyPHq8RPU28MTIyepx3+lHj9Z/UTlFO0my0+Vh6cp8dMjZ6jHz1Q/XTlLO/hr+Znys5VztJsrz26eel9nvnbz5BfIw98o8d/KwwvlF+q+5sovilwsXqhcot134iXKpdotEy9VLtcuR7xcHl4R+b36FcqV2sGr5L+XX61co91aeXbr1Ps667WDN8ivk9+o3KTdZnl2W9T7Olu12yK/TR7ersT/ELlDPX6n+h+UP2q3U36XPLw7co94l3Kvdnvkf1L+rB28T36f+v2RB9Tbw78oD2p3QP6Q+LD8IfkjyqPaHdV94nfIH1Ue02639ju0O6r7+FU9/jf1+N/lf5OH/5CH/1T+pd3f8uz+Ue/rHNcO/lce/k8ezpXnxD53nmQPZ8nnkufvoU26/lq9H/wmvV5K18uST8vD/L1I4vl7mvN5dC4tz8+BbHnO582T7O3hfJH51eMLqMefpD6fMrd2JF/nAjqPL5gnmSdrBxfK4E9RD58qX0i+sDK/dqfJe3+6dnB2Bl9EPVw0gy+mvqg8v3cUl+f8GXmSvT1cIrKk+hLKwhl28Jnis+TPlD9bWUq7Urp/+9Lqi8uXEfN7chn1+DnqYX4fLKZzeO6nrF4P5vd2PP//gGd3jnp8Oflz5OHykeeqL6+soB18njx8vjx8QQZ/oXq4ojzM/2ddoB7P+6gkX1EevkjJ/w+yqyzP7mL1+Crqvae/RHmpdlXl2V2m3h6uJg9frqyuXXX1Vyiv1K66fFXxVfLw1fJXq78m8lr11yiv0w6uIX+tfE1lLe3wtdXXkq8jD1+vr1+tDB6uLL5BvrJ8XXE9+bry/HsJ+xvVw/Xl68nz7zTsG6iHG8rXl+ffh9g3Ug8vz0r6hvL8u1RjneO6TfIke3xTeXa11eObybNrrt7+JvXwzfI3q28hD98if4vuC26ZwbdSD98qf5uY/nb1tyrv0A5emXVif6d6+K4MvrV6eGNW0t8lvyayjc5x3bvzJHt8W3l296i3h9tFtlePb6Ee30o9/l7t6e+TZ3e/enu4Q+QD6u1h/p7tqB5/Zirp2Z2RSl7f1+V++HNQQz2+eCr5vu6Xf1DvG+4k31n+lFTSd1HfSf4eXSdvKtnDD+kciW8rfjiDf0Q9/Kj8w/KPycNttNuelewfk9+kHm6t+9mRlbzu4/LsUqlkj88lz47z+CeU+P+ykvmkdvCurBP737KSPa/P/fH14Oub0tc5S55dtpjvm2xxwWC+Hwuq5/uZnu/LYjrHrpB8Mf354Xx78T3y/D3E32/8Pc73c1udg/m+a6Pk+6i1rnunrt9OzM+bnPj68PPIP5/o+b3AP9/4+d9Kr8P1W6jn5yh/D92rHT/3a2jnn/NNlS11P411n9w/v4/wewy/h9VRbw/z+x+/T/N7qX8fraN9bV2fvqbed229/+ba8fOhg3Yd1fP7/VPq8aVSSc/uafVPqb9SO/gZefhZ+afln1OWS51411U7uHwq6Z+XZ9dNfVflC9p1k39R+ZJ28OWppO+unvMvq/f1X9HuZflXI3uot4dfk4dfj+yp3h5+Qx5+Ux7uJQ/3juwjpn9LfS9lX+36ienfVt9X+Y528LvycL3UiX1/9f3Vv6cd/L48XD+VTPwAJf6DyIHq7eFBkYPV44eoxw9VP0g5TDv4Q/mh8h8pP9YO/4n6j+U/lYeHR45QP1w5Ujv4M/kR8p8rh2TYfaEdPCrDdfCj5eEx8vBg7caqhwdk8A1SyX6c/Fhdf5zOfyk/Wn68erhhKulh+ubiCfITdL2JkZO0x3+lHj9ZPX6Keu+n6H2SX2g3WX6qXm+y/DT19vD0yLapZD9dOUM7/Ez1M+RnRX6tHj9b/SzlSO3gOfKz5ecq52k3X57dAvW+zjfawd/KL5BfqFyk3WJ575do9514iXKpdt/JL1M+nUrulmm/PPLZVLK3h3Pk4RWR34vpV6rHr1Kfo1yt3Sr5NfLwWiV+nTy8PnKDevxG9euVm7TbKL9ZHt4SuVW8WR5+NXXic9t0fpvud4M8n3f3VNJv1X1v1+v/IN4uD++I3Kl+h/JH7XbK900lE79LPbxbHu4v3iO/R+f3Rv6k/V7lz9rB++T3i+kPqLeHf5GHD8rDhyIPiw/Kw0fk4aPKY9rhf1UP/yYP/y5/TH6/7vuYPLs/5P+U/10e/kv5YSq5+1vn6Nn/Iw8flz+u/Ujt/5Un8f8p8bmyk5k7O7mDx6SSPkt7XyeVndzNSiU5JQ/PSSWvk9Y+JT8v9nnEae2ys5M7OK/8Al0vrzy8OJVMfD4lPr+ygHYniQsol6eSO3xB9ST+ZCW+UOQp6u3hU5WFtTtNXFgePl0eLqI8WTt8TirZr0wl+9OVvG7RyGLq8cXV28NnKEtoV1y+pDx8pjx8lhJ/duSaVLLHl1J/tvrS2sEbUklfRv3Z8mXVl5bfHNc7R57z5bKTvX0Zve/y2pdTltQOPle+vHwFefi8yPPV28MXyMMX6r7Pl6+o/kJlJe0qym+Pz/kieZ+nrxy5I5Xs7eFdwRdrx/WqZCf7i/T+q8hfon0VefjSyKrq8Zept4crKKtpB18uD1eXv0Ke3ZXq7eGr5OGrI69Rj79Wvf116uEa8nBNebiWfG0xfR319vD18vANyrra4eupryt/o7J+hj2+QWRD9Q2UjbRrKN84son6xsqm2jWRbxbZXH0z5U3aNZe/ObKFenv4Fnm4pTzcSh6+NfI29fZwVXn49sg71NvDd0bepd4evkIebh3ZRr09zJ/L2urtG2a4bhv1+CYZ3v8d6nk/fA58ftXV4/nc+XrdHXmJenxb9Xcr79GurXw7efhiJb69+F759vL3ycP8XNqjn1/3ycM/p5KJv1/nOsg/IO4gD3eUhx+Uh/elktxJvpP2nSO7aN9Z+ZB28MPy8CPyXeQfVR5MJXePav9Y5OPq7eEnlIdTyR1M/6T2T8k/LaZ/Rr09/Kw8/FxkV/XPKZ/XDu4m/4K4mzz8ovIl7bqL6V9Wb/+KevhV+e7yPSLzp5N9D+3pX5OHXxf3lH9GTP+Genw6ney9p39T3wf0+F5izvUS9w4+lkr2vTNc72gqmU9qx+fQR/efJ53kPkrO8XnzdXpLX5cC6STT91VvD/eLfFu9PfyOskg6uXtX5+jZ98/g31P/vvg9efgVeXiAPPyBcqB278sPUg7WDj9E/WD5kukkl0mf2A9VP0ye3TDxh/LwR/Lwx/LwJ5GfqreHh0eOUG8Pj5SHP1N+rt0I+S+UZdPJHTw0w/lRGa6DH608J53cjZFnN1a9rzNOO/hL+bHy45UTtJugfmJkhXSyx09SP1H9V9pNkp8sD09R4qdGTlOPn65+qnKGdtPlZ8rDs5T4r+Xh2ZFzxPRzdY6+UjrZz9b7maXz56eTvc/x+vMiK6eT/Twl+/nKBdrBF6eTHqb/Ron/VrlQO7hqOulh+kWR1dPJfpGus1j7RfJXxbkl8pzHf6d+sfzSyGvSyR6/TP1S9cu1g3Pkl8nXSCf3K9TnyH8vD9dKJxO/MnKVmH51hh25Rjt4rfxq+XXi9fLr5DcoN2q3UfeJr51OenabxFx3s3q/7pbIreJtkdvlf1C/TX5H5M7IH+V36dwOMf1u8R753fJ7lT9p97P8PvF++QPyv0QeFNMfijwceUT7I+qPRh5TD/8a+ZuYc79H/hH5Z+RfkX+rt9+r/p/I47rev5H/RebK+7/InTe5zwpO5U3u08F5IrMj80bmy5s8n1dMnz+ygDif8iTtCopPkodPlocLRZ6i/lQlu8KRp+nc6fJFIotGFossHnmGuIR8ycgzI8+KPFv7UpGlI8vo9cuoLxt5jnp8OXFp7ctHnitfSvdFz/d1KTE93//N0klfXsn93By7CuKyGd4Hu/Miz4+8QHmhdhUjK0VeJD5P5yqJ2VeOvDiSP19V5C+JvDSyauRl4mqRl8vD1SOvkOfclZFXRV4deY38tZHXiWtE1pTnXK3I2pF1Iq+XvyGybmS9yBu1p68f2SCyYWQj+caRTSKb6jzXaybfPPImvq8iW0TeIt8yslXkrdrfFnl75B2Rd6rH3xXZOrJN5N2RbSPvEbeLbC/fXvt7I+/TuXby7ZX4+yM7iOkfkO8Y+aCYvpPOdZSHO/N5pJN9l8iHIh/Wvouuh783newflocfiXw08jF5+HH5J+TZPRn5VOTTkc+ofzbyuciu2j8h7qo9138+spt6e/iFyBfF9C/p3AvycPfIl8WZ+lciX1VvD/eIfE1M3y2dPNdDHn49sqc4U/8Gn0862b+hfFM7Et8rsrd29nCfyLfU28N9uY90ssf30zl2L2vfT+e4/tvy8DvcdzrZ28P90snEv6se7q/EvycPvx85QL09/IE8PDBykHp7eHDkEPWDlUO1GyI/IJ3cD1P/oZj+I/XDlB9rB38i/5H8p8rh2o2QZzdSva/zmXYj5T+Xh79Q4kdFjlaPH6N+lHKsdmPkx8nDXyrx4+XhCfITdF+j5SdGThJPkIe/kocnR05Rbw9PjZymfqpyunbT5GcoZ2bY42cp8V8rZ2s3W+8LP0c95+eq9/XnaQfPl58rv0D5jXbfyrNbqN7XWaQdvFh+ofwS5XfaDUwn/RL5oTrHdZdmuD5+UJxfJs/5ZeLlkTnq7WGeO0ziV2i3SH6F/Hx5+Hu+H9LJ3h7mecPz5Veqh1cp8TPk4dWRa9Tbw2sj16lfq1yv3Qbxenl4Y+Qm9fbw5sgt6u3hrZHb1G9VbtcO/kEe3iG/U57dj+rt4V2Ru9XvUu7RDt4rv1v+J+XP2u2TZ7dfva9zQDv4F/n98geVh7Q7LO/9Ee2Oio8oj2l3VP5X5W/awTzfGP+7el/nD+3+FP+h/Eu7P+X/Vv6jHcxzkv8U0x/X/l/54/L/KXPlS+54DvNx9STncsvDPI85S55zqXzJHp+WZ5cW55GHs+XhvJH51OdV5tcun3yByJPU28MFlSdrV0h8sjx8iu67kPwp2p+qLKzdaeLCytO1O02+iDK3djxfO7d2nC8qz/O3i6hnX0weLi5fVP6MSJ7XXVSeLKEdvqR6+Ez5EvJnycM8F5zE8/xszp+tc2fJ81xtuJQ8iT8u5vnH9qXVl5FnV1ae3Tnq7eFykeXV489Vj6+gvpzyPO0qyJ8vD1+gxF8YWVE9vpL6C5UltYOLy1eSv0hZWbuL5b2vot0lYvpL1VcV01+mrKYd/nL11eSrK6/IsMdfqfdZTZ68SrvK8hXFV2fw16iHr5W/Wv5c5QUZdtdph6+hHq4pf518LWV57WrL15KH6yjLane9PLsb1OPrqsfXk68rD9+orK8d3CCDb6gebiTfQJ7nuTcQX6/rNNa5RvI8d7yRmOfBcx2eh825JvIN5eGmkc3UN1U21w6+SR6+WR5ukcHfoh5uKQ/znO8W6vG8j1byLXWdW7WDef63/W3qYZ5rjYeryN+u63DdO+TZ3an+dmVL7e7S3h5urWyj3d1i+rbq24jpeb7a3eJn5eF7dB24nZjnf9vznLwr9Dq87gt63XZ6f231flrLwzwHjsS3V+LvjbxPvT18f2QH9fcrH9Cug3zHyAfV28Od5OHOkV3Ud1Y+pB38sHwX+UeUj2r3mDy7x9Xjn1CPf1L+CXn4KXn4aeUz2vGcvme0e1a9r/OcdnBX+efFXeVhnrtH4rsp8S9EvqjeHn4psrt6/Mvq8a+of0n5qnZwD/lX5F9Tvq5dT3l2b6j3dd7U7g35XvJwbyW+T+Rb6vso+2rXT9xXHn5bHn5H+a52+P7q35V/L/J99fgB6u3hD5QDtRsgP0jM8wkHiQdrD/eU76n7tO+tnuvwfMWeuv8hur+B8kOVPEdxoJh+mBL/oZLnqw0Tz5En8cP1ekMyXB//kZLntrH7WJ7dJ+p9nU+1+0R+eOQI9fbwSHn4s8jP1dvDX8jDPL+NxPMctdXyo3R+tPwo+THy8NhInrM2Sn6s9uMiv1RvD4+PnKB+vHKidhPkJ0V+pd4eniwPT4nk+WZfyfP8sik6N1nXn6qclmGP5/ln03SO55FNEk/V601XD8+Qn6H9zMhZ2s9Ufq0dPFt+lvycSJ5TNkue3Vz5OfI8zwyeJz9fPE87nqfEbkGG83j4GyXPRVsgz/Om6L/RdfLr9XkeFJ77m6f3/a3u3x5eqFykHc+P+lb9Ip1brFyiHfydPM97WqSeXKrdUvVcd5n29vByZY52K8Q58vD3kTxXaoX8CvVL1XOdlUqed8SO597g2fE8mmryOerxq+Rz5Hk+Df1y9Tn63HhuzSr5Jerh1fL+vPl8FmvP+TXy7Naqt1+nHl4vv0F+nTy8MXKT+o3Kzdptkt+i3KodvE1+m/rtkT+o367coR28U/5H8U55mOf6/CjelS+Zu3Uez/OFdov36NwevS/8Bvk98vDeyJ/Ee+Rhnq/kcz/rPLxeiV8t5nlO9j+pr6nPgc+Fz5fPf59yv74OB+TZ/SJ/QHlQu0Ni+sPq8cPlD8vDRyJHiw8rD2g3Wv6oEs/nNDLD63E/x3S/cH/5Q/L/B8r/nKF4nHWdebSNZeOGSfbexznGiuZBoaJSSoWSRGgQZVaiyJihEJKpzCRDMoWI0CRDFKWMkSFShpKUKRkimUrfWr/fc/3xXKv9/XOv67rv993vdhztvc/6zns8le3//nck5PGQf4mHy58Q059UP1xMf0p5WrsT8meU+L9D/qPeHq6aiD38eyrOszr+X+05X7aMuMdnl2d3TkbcZ1Pm0O4c+XPl4ZxKfEIeTsondV3Z5VMhH0zEfUrJvnoiTnyGdrnkM+Qz5eGaiTjxWUp87pB51NvDeUPmU4/Prx5fQH1e5XnawefLF5C/QFlQu0Ly7C5U7/NcpB18sfyF8pcoL9XuMnl2l6v3ea7QDr5S/nL5q5SFtSus/mrlNdoVEV+jLKodXEy+mJ4v/lr1RZXXaQdfLw8Xl79WvoTyBu3wN6qHC8nDl8rfIM/zu0nnKyFfUj1cUD6/PLub1ZdU3qIdXEoevlX+NjF9afX42+VLy8N3yMN3ysNlQtZKxH0ZZVnt8OXUl5W/S3l3mj2+fMjaibgvr2TfJBEn/h71cFNxBXkS31znraDz3yt/t7KidvB98vfKVxJXlq8kf7+yZSLetdTzwldRz/FV1dvD1eThB0I+qN4efijkw+rt4ery8CMha6i3h2vKw48qH9OuhnwtJb52yDrq7eG6ynra1RfXk4cb6PnXl6+vvpZ6ztNQ2TYR7+CqOr6hzvN4yCfU28ONlO0T8e5J9Y8rG2sHN5GHn5J/Uv5pZVPtmsmze0a9PdxcHm6hbKld90TM9K3Ut1TfQju4tXwr+TbKlxLx7ll5dm3V49upx7+ViD27txNxbw+3l4c7hHxOTP+8enxH9e2VrbXrpD2+uXp8Z3l2T6lvLqZ/QdlFu67iLspu2sEvyneV767slGb3knZwD3n4+TS+p/pe8ux6y7Pro96+l66vj/hlefgVZV/t+sj3U/bXboB8P3l4oHKQdoPFg+ThWYnYw0My4uyv43vLD9HxnP8DMdc7VPmhdvhX1Q8T07+WEfevKodrB49I40eqh0fJj5B/XTlau9G6zhHav6HdaPl5iTjxY0KOFY9L03+aiBM/Xj28SDwh5JtK/ER5eFLIzxJxP0nJfrLyLe3gJYnYw/RTQk4Vv52mnxZyunp7+J2QyxJxvzoR96vVz9DxnG+m+mli+lkh31WPf0/9LOX72r0n/4E8vCERJ/5D5Sbt8LPV4z9SP1t+jjy8ORHv5qqfIz8v5Hz185QfawcvkJ8vv1D5iXafyrNbpN7nWazdZ+LF8vDn8vAviTjxS7T7Qv7XRMxfavel9kv5/lC/POSKkCu1W5XGf6V+lfxqeXiNPPy1PLxWvE5+vXiD/DchN4p53ptCfqt+c8i9iZi/C3kyEfPfifj4nMn4OJg+kYyfz4Y0zwv/fcgtOt4+Mxn3W+W3aL8tI97B2+W3yudOxsxxP4T8UX6Hns8O9ex/CrlTHv5ZvIvvI+WvIXeH3KPjd4v36Pr36vn+IKbfF3J/yDzJ2MP0vynxB0L+rv5gyEPqDyoPhzwS8g8dhz+q/ljIP0Me1+6vkCf4ey8Pnwp5OuQZvi90/n+0g8/quDPy/4bMluv/o274c80e+JyQjyXjPkfw54bMGTIhToZMhcwImStkZsiskLlD5gmZV30ecb6Q+UMWUE+ep/OfH/KCkAXF9IVC8nWhvzDkRSEvDnlJyEv15/ZoyMuCr5GMd3WSsa8aslrIy8PugcBXBL4y5FUhC+eKe/zVIa8JWSRkUfVFlMW0K6b+Wnn4Onn4enm4eMgSIW/QroSY/Y3q8TepL64sqV1J9TfLw7eELBXyVvnb5EvJw6VD3q7eHr4j5J3q8WXU28NlQ5ZTj79LPf5u9fZw+ZD3iNP1FeThe0NWVI+/T709XClkZfX28P3ycJWQVdXjq6mvonxAO/hB+WryDykf1q66PLtH1Ps8NbSDa8o/Iv+o8jHtHlNfS1lbuzri2sq62sH15OvI11dWT7NrkGaPb6h8WLuq8uzuU+/zPK5dA3nv6J8I2Ug9/kn1+Mbq8U3k2T2lHv+0+sbKeto11R7fTP3Tyrrawc/IN5NvrmyhXUt5dq3U+zyttWsjbq18Vru24mfl4XYh26vHd1DfTvmcdvDz8h3kOyo7addZnt0L6n2eLtrBXeW7ibsqX9QO7i7/kri7sod2cE/5l+R7heytvpeyj3a95V+Wh18J2Vf8sjzcTx7ur+ym3QD1/eThgfIwX+dB4oHKwdoNEdMPVT9Y+ap28DD5ofKvKYdrN1x9K/EI+WHy3tGPDDlK/Ujl69rBo+VHyb+hbJlmNybNHj9W2UK7pvLsxqn3ecZrB0+Qh9+UHyc/UfmUdhO1nxRysnp7+C3lk9rhp6jHT1UPvy0/Rb6REn+3sqJ207Tn8aarn6rnOT2Nf0c9PEMenik/S36GPPyuPPye8n3tPpBn96F6n2e2dvBH8vAc+Q/l54acF3K++o9DLgi5UPuF6j/RcQvl4U9DdkjGPX5RyMXycNdk7LskY79YHv4s5OfidP0SefiLkF+qx/dMxj1+qXr8MvX2y9UvlV8Rsk8y7vEr1dvDq0L2S8Y9/iv1+NXqVynXaLda/mt5eK0Svy7kevX4DerXKb/RDt4ov0F+k/Jb7TbLs/tOvc/zvXbwFvnv5Lcqt2m3Tf125Q/abZP/UblZux3yP8rDP4Xcqf4n5c/awbvkd8r/ovxVu93y7Pao93n2agcPSsYe3qc9vD+NH5CMe/grHQevld8vz/P4Tde1Vx4+EHJ4Mu7t4d+V+IPy8KGQI5Nxf0jJ/rDyiHavJ2M+ovxDu6Py3h/LFe/gP+WPyh8X/yV/XP6E8qR2J3Wd+FPyJ+Xh0yHPqLeH/w45JRn39vA7yTjx/6iHz6r/V/6sfLbMON9Pxrvs8t6fkxnv4Bzy2eXPFeeUP1c+oUxql9R14lPqOT5Dvc+fSzs4Uz5DPkuZW7vc6vMo82qXWz6fMqVdfvl88nCBkLOTcV9AeZ5258uzuyAz7guI6QsqC2l3vvyFIS8SF1JerN0l4ovl4UtDXqbeHr485BXq7eErQ16l3h4uHPJq9YWV12h3tXwRebioEl9MeW2aPf465fXaXSW+XllcuxLy18vDN4S8Ub09fFPIkurxO5Jxj79Z/U3qb9HuZvlS8vDOZJz4W0Pept2t6ktrtzsZc2ntb5eH75C/U3yHPFwmZFn19nC5kHepL6e8W7u75MvLw/eErCAur7xXuwryFZX3aQdXSuMPJuMe3idP4ivrz4W+sp5PJe3u1+P7+qtoV1VcRR6uJg8/oHxQO/yfybjHP6T+YTF99cy4f0j5iHbV5WuErKneHn5UHn4sZC319nBtebiO8nQy3tVVX1tZT7u68vWVDbSDG8o/LqZ/Qr093EgezpmK82zyv88L0zfU9TYSPynfSL5xyEQq7u3hJiGfEjeWh58O2VS9PdxMHn4mZHP1zyhbaAe3lG8lpuf/p90qjYf9/8vGt9a+jR7vWXEbeThXKn6ez8qT7Nsq8e1CtldvD3dQPqfd8+Ln5OGOIbNScd9Re/q26jlPJ2Vn7V4Qd1Z20a6rmL6b+lLhuvKnYt9Nx5VK/fdxJVPxnsQXTMXnuSUVH/+ivHf03UO+pN4e7qEsnYp3MH1PZS/t8L3Vw33ke8m/LA/fHs7/ijzH9c2Me3u4n7K/dn3lB4gHysOD5OHB8oN1nQPE9ENC3qHnPUTJvlwq5qHyr8qzww9TP1S+fCrm19L44erhEfKvyY+Uh+9JxYkfpV2NVOxHyVdJxY9XU+drkYo9u9e1b6EcrR1cK/Xfvmkq7uGG8sN1XVxPa/XD5GG+rm+ot4fHhByrfoxyoHZj5ccp26bi3Xh5dhPU28P9lW9qB0+UnyT/pnKydvBb8vCUNH6qevht+Sny0+Sn6Xonyo8Xt0v9t++Yivu35afpOjtrN12e3Tvq8TPk2c1Ubw/PCvmuevxk9fj35CfLw+8rP9DuQ/EH8vBsefgj5bva4eeof1d+rniePDxffq78TO0/Vg8vkJ8vP0O8MI3vkYr7V1KxX6DHfUX+E/Vc96fq8Yvk2S1Wj5+jHv+Z/Bx5+HPlEu2+EC+Rh7+Uh5cqF2u3WP0y8XJ5mN9ft0w9fljIRerxy/U4K0KeUr9CuVTPj+T3wq0Q8/vx8CvVc/wq9V+K6b9SrtZupTy/f479GvVfi+nXql+jXKcdvD6N36B+vfw38vBG+Y26rq/lNynx34bcrN4e5vfPbRbnUn6n42H6hHK1duRqXRe/j47H5bq+V/+tzrMpzfPZqOPhLfLfy29V8nvw2PF76vDstqn3ebZrB/8gv03+RyW/B48dv6cOz66d+h913g46bwf1O5T4n5Q7tftZvFO5S7tfxLvkYd4fd1b/YprzddLxPP6vyt3a7ZLvLua4PSH3qreH9yn3a/ebeL887Pfv+APi3+Xhg/IH5HuLOY7XTYfE9IfT7Mgj2sGz5f+QP6Jcpx18VB5eJf+H/BKdh8c5FvJPcbr+uDzMv/d/ien3qMefkPeO/mTIb9SfVG7Rbrs8u5/U+zwntOP579P171PP3wO+rnwdlmh3RHuSv2f7lfu08+P7+5Hvp93iHvK/6vlynp3y7Pj3h393dmjHcfy58e/pdvkt8lvl+e8YX0f//cLz9/mYdkfV8/qG1xW8juH1h1838d/br3S+NWJ6f5/BvN7jdfhs7fx6nNfNvK5dJD8ovO78RD2+r3oSz/sV3k/w/oT3DR/pev1+4iM9D/4dPCzP+9aD2uFPqT8tPqV8U7t+Yvd90pyPx/f7bt738v6W96cz5Xkfz+cAfJ7C+9AZOg7mfeZ0cbdU7KfL83kGjzdVjztLPFnPF+bPh8+B+PzGn9vwuQyfR/H5Gp+LtQnXw+dsfC43SInn89sx6vkcjs/Hxsn303Wz89efr7M/n+bz8Zfl+Zya4/w64IA8rz/4d/M3+d3qeR3F67Vd8v55Tj79nKSzjn9BO35e9Iv2/nkTP4faIe4g79fF/vkaP+/yz+f4OSF7/5zQP5/k55mtlfgzIf9Wj/9HPf6senwz9fh/tT+rzJYV7+Ds8ueIs2uXIyvenSumz6k+IaZPKrl+din1OeXhDHk4l5I/55SYPlP7LPlMeX6vN1/XTHl2ueVz6zx5QubV3h7OJw/z+77zi+kLZMW9PXxeyPPV28MXhCyoHl9I/QXKC7UrJH+RPHxxyEvUX6y8VLtL5C+Thy8PeYX4Mnn4Snn4KmVB7fCF1ReUv1qJvyZkEfX4ourxxdTjr1WPv06e3fXqr1UW166EuLg8fIM8fKM8fJM8XDLkzert4VtClhK7v1XH3yamL63+VuXt2sF3yMN3pvFl1JcVl1GW0w6+S76s/N3K8tpdJ8/uHvX4Curx98pXkIcrKu/TDq4kX0l95ZD3i308vpj2VdRXlq+qLKpdNXnvH9AOflC+mnwR7R9SDxeQf1g9x1eXf1j5iHYw95Wwr6Ee5j4P+JvU1wz5qPY11T+mHcz9HPC15NnVVo+vI8+urnp8PfX2cP2QDdTXV9bQroF8w5CPq7eHqyjxfJ2e0Hkel4cbhXxSPb6xenwT9fin1HtP/7SyonZN5JuGbCamfybN7hlx85At1NvDLUO2Ut9S2Vq7VvJt5OFnlW10XXBbebhdGt9ePdxYvp08f34d5NvLw88pn9eugzx/jzrKc3wn9fZw55AvqLeHu8jDXZXdtHtRvqs83F0efknZQ7ue8ux6qcf3Vo/vox7/ss7fU/4V9T3kO+n595DvpH3fkP3U91X2166f/AB5uKMSP1A5SDv8YPWD5IcoG2g3VP1g+brq8a+qh4el8a+ph4fLD5MfoayTZjcyzR4/SllLu9flR8lzn6Va8twXiX6kep+HfrQ8zP2USPwb2o2Rf0N+rDzMfZlI/Dj18PiQ5XTceB03Qfvx8m/Kw9x/CJ4oP0Ge3ST5CfLwZOVb2k2SnyKeKj9F/m3lNO2m6Trx3Fdponbc34jeHvZ9iqbpOvAw9x2qKT895Dva4Weot4dnhpylfqbyXe1myb8nD78f8gP19vCHIWert4c/kofnKOdqN1f9vJDz1eM/Vm8PL1Byvyd2C9XPU36i3UL5T0MuUm8PL1Z+pt3n4s/kYe5DtUA9nmS/RMd/IQ9z/6Ul4rryX+o4n5ee+9bAS+UXy3tHvyzkcvXLlCu0g1fKL5dfpeS+Ot59lWaP5z4zJPfV8W619mvk2X2dFff28NqQ69Tj16vHb1C/VrlSu2+0t4c3htykHv+tevxm9RuV32m3Wf57eXiLcqt2W9VvU27X7gfxduWP2sE75H+Q/0n5bZrdTu3gn+V3iX9W/qLdLvlflbu1g/ekOQ9+rzy8Sbv16vH71O/R4+9T4vcrf9MOPpDmPPh1Yo77Xd+fB+TJg9rBffX9f0g9xx9Wjz8iz+4P9YeVR7WDj6Xxf6o/Jn9cHv5L13EsjYdPyMMnQ55Sf1LJ/aBOiU/reHig9qfkz2TFeUg7zn9S13tCz+tveZj7VJH4f5Rntcf/q/6sfLbccWbP/d97/DkhuT8WPT6HenuY+1hxv6sc8uN0/LnqYe5zNVY+p3p4vDgRkvtckfikMqU9PkN9Sj6XMjPNHp8VkvtmpeSztM8dMo96ezhvSO6PlUf+f1cn0Ap4nIWdZZRVZf+G6WH2OVN0d3c3DM3QDENLd3eHpMCgNIK0KN0iqaSAiiiKSodIKSIiISIh71r/93d/eK7F/r9+udZ93fd+zj5nDgOf3KtDE/zffxFh/2WkcXWomzdhF4V9CmT1KdFHgamwS42cBrs0Pn1aXJ8aPh2YHrv0uE/5raGuTw+vvCPUPX8nevkM6NPhPtXvCnVzRuwyYi+fCb1yZviM8FmMe0LdXj4r+izos2GnnB0+K3wOcG+ou1NWn9OYy3gg1PW50eu6POjp86JXzgefGz4/KF8AuSD8UbvvQpZPWP7KWNh8EWNR5MJgMeyKwhc3lkBfEl65lLG0sYyPL4u+nLE8+groKxorGSsbqxijjVWN1bCv9j/66mAN7Goi14BXrgWvXBuMxi4afR1jjLEufD34+sYGxobGRsbGuK4hvD7PJvCx6Jsix4Jx2DWFb2ZsbmwBr11LeOVWxtbGNvC6/g34NmAD7NrCtzO299nJd0Cv3BG+I/pOxpuhbt8Je/Wt0OuczmAX7JRvh7peWX1X7O+Hvt53M3bHTrmHsSf2vYy9jX2MfY39cF0v5H44/0Go619a/he+P16vP85nP8A40DjIxw82DjEONQ4zDodXHgGOxE55lI8fjV55DPwo+LHGcejfxH2Pw/sab5xgnAg/yTgZnGJ8yzjVOM3HD0QvPx19PPwMZPVvG99BjgdnYjcLPh4+Hq+r9znbOMfYMMS9bg7OUT/X8rwwNzewfr7lLN5/2cj8gjC3b4S9+nexW2hcBL5nbGHnLLa8xLgUWf0y43LjCvgV6Fca30deZfwA12n3IfrV8MprjGvRy69Dvx79Bh+/0bjJuBn7Tcjqt4BbsduKfhu4Hbut8B8ZK9rPbQf8DvQfW95p3IWd8jofvxv9Hnjt9sLvAfdhtxf+E+On6OX3wx/A/iC8eAjXi4eNR4yfGY+il/8A/RL4z+CVl+K6Izhf38vd6HXfx7CXrxbi9sfgaxgz2++R97CTz2RsHuLulFvgnCaWY40tQ9xz5I/bOTUt1zI2xnV1kdW3Miayc5tabmZMbP5ze50vjF8a9fv8c1Bev3/jQtzzT5hP4Lmvr/v5yvqTxhi83zoh7vv+2vw36LU/Bf+t5e/Qnw5ze/nvjT+Euefq56a/R/T3wY/Yn4E/i/4s+nPG8+gvgPIXcd1F9DrnEry+p/weN8H3u7rxMl5fr3MZ+Qoof9X4k/EavH5P/Yz+GnyVEJfZ7b6vWx8Nz30lY2Vj1RD3usrI6m+EubyJ11O+BX/b8i/obyPr+l/R3wTvYPcbsvq7xt+N94x/oJe/b/zT+ABe+SEo/8j4GL38X+gfgbk9d/cEnvu/scvnufkpdk999vL/wCs/A+Wfwyu/MOb33J5euYDl4vAvQfl/4ZVfGUt6bv8K1D5BuHvfyjxPPqExUbjb0ysnNiZBT6+c1JgMvXw1z+25D8F1IejL2fVVPTfzPN1PcmMtz+3lQ9HTK3vwygFjHc/tA6D2QXjl+p6bw3x8OHrlCHjlSPgo5Eh45RTGlOjlU6FPAabGTjkNfCr4tGA67NKhTw829dydfAb0yhnhM2KfCYzDLjO8dlnQy2dFz/OzYaecHT4HcnYwJ3bKueBzI+cC82CnnBc+N3w+Y370+cAC2OWHLwivXMhYGLkgvPIQz/XKRcJd5sD1RdHruqLIxbBX1s+5OHIxeOX+dl4J9PLK6ltg38NzfV/P9SXwfnS/WX0+V30e+nmUxOdaEH6Uvc5Qz+3lS+K8sZ6bS/n40uiVy8CXgh/vubmsjy+HXrk8fFn4CsaK6CuAlbBTrgxfEX6C/v0LH42sfqLnnu+3k68Kr1zNOBmvT69c3VgDPb1yTWMt9PTKtY110NcGY7BTrgtfB74eWB+7aZ7rtWuAnuc0xE65EXwD+BmemxvDN8a+iTEWe/mm6OXj0Ms3Qy/fHF67FuibgQ2xU64L3wK+JdgKu9bw2rVBz3NisHsDOQa+LXrldvDK7eHbo+9g7IieXrkTvHJneOUu8MpdwW7YdUPfHWyPXWt47Xqg5zk9sVPuBd8DvjfYCrvm8Nr1Qc9z+mKn3A++D3x/MM5nNwC7gcgD4JUHgYOxGwg/23O9sv7cD4EfjOsHYac8FH4I/ALPzbpumHE49vTKI4wj0Y8AR2E3En60cQx6+bHo6ZXHGd9EPw4cj92b8BOME9HLT0JPrzzZOAX9ZPAt7KbATzWe99x+Kvbqp4W7lJ8e7jIeu3i8r2nI6mcY30Y/A3wHO+Ux8GPQzzTOQj8TXOi5u4X4Xs/CXufPBhd5r9/N8dnLzwUXe+5umed67eah5znzsVNeAP8u8gJ45YXgCs/dLcR+Ebjec3fvwS+CV15sXIJ+MbgUO+Vl8Evgl4MrsNvsuV67leh5zvvYKa+CXwn/AfiR9/rdIc/dKX/oc478Dtvt99ysXn4X+sOe+/p6P6vD3Z5eeY3xuOf28mvRy69DvwZcht167OU3oF8HLsVOeSP8BvhN4Gnv9bvNPnv5LeD3nrs757leu+noec5W7DbDc6d+m3E7+m3gfOyU58Bvh9fv93icvx3n634+Ahf47Db67OX1+0I/J30f9PM6aV7fn/Xwx9Hr+63vob6Xx/DnRt93/XnejD/Xy3Decnh9H9fh/SzF+9LvKf2eXAK/wXN7XbcIn5fyAnj9vl9u5/DvDf389XOZAz8XXn9P8u99fS/4/ZPX91n/ftG/c3YYL3luvwPU/mNwJ3bKlz3X74Lfif1u7PYg7wb3YrcPeS+88ifwyp8a96OnVz5gPIj+AHgIu4Pwzzx3fxj9K8/N6o+gP4z+M+yUj8IfgU8UcPfH0B+FPw6v/Dm8cuKAm7X/AjvlL41JcR29shdwKX/C+BWy+pM+O/Fr7JS/gT8Jfwr5W/hT8N+Bp7E7jfuUDwRcfxr8HjtR/gdQ/kd45TPG8IDbnwG1Pwuew045IuD68/DnsL+A3UXkC/DKl+CVLxuvoKdXvmr8Cf1V8Bp2P8FnCrj7n9Ffg78O3vDZy2cJuPub6G/A3zJmC7j9Lexuwyv/An8LPkfAzbruV+Md7OmVfzPeRU+v/LvxHnp65T+M99HTK/9pfICeXvmh8RF6euXH4F/YKT+BV/4b/hH8U+R/4JWfwT+Ff4D9c/TKL+Cfwd/H/iV65X/hX8DfQ9Z1r4wJItxePl/A7eUTRri9fKIIt5dPDK9dkgi3TwQmxU45GXwS+BAwOXYVAq4PwfWhPufIVwq4Wdd5xgD29MpBMAw75SoB14fDaxeBPhI+OuD2YdjxOvVRYArsUiKrT4U+NbL6NGAEdhHoq9v7SIvs18dYToecPsLdpf8ffQYwI67LhKw+M/osyOqzgumwS4e+nt1nk4CbeU62CHeXDX1m7JSzwyvHBtxdDvQ5kXP59HEBl/K5wTzY54XXLi9yPnjl/PDKBYwF0dMrF4JXLgy2Dri7IugLwSsXhVcuBhbHrgSy+pLoiyOr76jf+0E3q5cvifsoiXPlEwbdXBTvsxR8aeQyPn1iOzdZ0M1lsSsb8f/35cDyuK4CsvqK6Cshq68M6n4rwFdBL8onDbr7aFxXFVl9NfTRYHXsqsHXgFeuacwQdHMNXF8LvjZyLXjlOsYY9HXAutjFwNcz1kdPr9wAXrmhsRF6euXG8MpNwFjs5Juij4XPHHT3ceibIcfBKzeHV24Br9zS2Ao9vXJrY5Gg27dB3wbXay//hrEtchuwHXZt4dvDK3cwlgy6Pb1yR2MnZPWd0ct3QS/fFV67bui7gN2x6wbfA165JyjfC165N3xv3FdX+D6gfF9jP2S/vr9xAPr+4EDsBsAPMg5GLz8EPb3yUOMw9EPB4dgNgx8BjvTZy48C5UeDY7Abg/dFPxb9OPgx8MpvguOxGwc/AZTvDK88EfcxwccrTwIH+Oz6YNcHvb7Hk3Gfep9T0PNzeAs75anwU+CngWWDr99N99nLx8MrVwi6eQb82/DcqX8HnIndDPhKQTf3DLq+J/q+Qff8vuhn+ezE2dgpz4GfBT8XnIed/Hz0ygvg58H3C7r5XR+/EL3yqKDr34UfZFyE63Su/Oig278Hr91i9PSL8P7FJdgpL4VXXga/GH45KL8CXImd8rjg68+R1/t7H34l/OSg26/C6+u+Pohwe3rlD0H51cY16OmV1xrXoZdfj15+A/q14EbsNiFvhFfeDMpvgVfeCspvM25HL/8Revkd6OmVPzbuRC+/Cz298m7jHvTye9HL70NPr/wJvPKnoPx+4wH08gfR0ysfAuUPG4+gp1f+zHgUPb3yMVD+uPFz9PTKX4DyXxpPoKdX/gqUP2n8Gr38N+jlT6E/CX6L3Sn470D508bv0cv/gF7+R/SnwTPYnUU+A698DpQ/b7yAXv4ienrlS6D8ZeMV9JfBq9j9hKz+Gnr5n9FfBa9jdwNZ/U3018Fb2N1GVv8LenrlX0H5O8bf0N8B72L3O7L6e+jplf8A5e/DK/8Jyr9lfy8/QC+vc6cG3evkH6K/i/f9EPkR/EP4x8bpQbeX/ws9vfIT49/o6ZWfwiv/A688N+jmZz7+OfoXyM/Bl9i9gP8XfIVdgkjXa5cw0u3lE0W6PX1i9MpJ4JPCJwaTYaccAq+cHD4UOTm8sgevHACD2IXCJwHlEyCHwS8Oull9OHIQjMAuHD4SXjkKXjkFvHJK5FTwKeFXBV2mxi413pf8kqDrU+NcvX4aY1r0acB02KWFTw+vvNruIwOy+s3o04MZsVPOBJ8ZPiPuLzN8FnjtouCzwGfB5yKfFddlQ84KZsdOOYePz4k+B3wueGV9HrmR1edBL58XvXw+9PT50SsXgM8LX9BYCD29cmFjEfSFwaLYKReDVy4OXwS+BFgSu1Lw2pVGT69cBl65LFgOO/ny6MvB7wi6uQJ8RfjyYKVId6dcGV75PM6tCF8Fe50XbbwYdPtoUPuqxmro5aujly+DXr4Gevni2KuvCV8cXrkWvHJteOU68Moxxrro6ZXrwSvXB6tj1wB9PXjlhsZG6OmVG8MrNzHGom8CNsVOOQ4+Fr4Z2By7K0HXa9cCvXxL9PKt4LVrjb4lGIdda/g28MpvgG2xa4u+Hbxye3jlDvDKHY2d0HcEO2On3AVeuRV8V/SdwW7YKd8Iur4r/LWgu9d53XGOcg945Z7wyr2MN/E6vcDe2PVG3xM75T7wyn3hlfsZ7+B1+oEPg+5OuR/O64vX7Q+v/DjoUn4AeuWB8MqDQPnB8MpDjE+Cbk+v/BJZ5wzFdcrD4JUThLmUH24cgTzSmDDs9btR6OVHox8BjsFuNPxYeOVxoPyb8Mqe3dd4ZL9+QqSbJ8IHwtw8EV45DHmSUc8FEeUnG6cgT4J/C/1k+KnwynruiCg/DZSfjnOn+/TxPufI63ke2s9AHw//tlHP+YiHfxv7d4wz0dMrzzLORk+vPAdeeS688jzjfOS58MoL4JXfBRditxD9IuN7yLxefrFxCfrFoJ57sgRZvZ5HshDn6X3PRF4C6rkrM3F/S43LjHnxust83vdycIVxJbKeM/I+Xk95FfYfGD/E661Gvxr9GnAtduuQ1a9HvwFZ/UZwE3ab0G82bjFuhVfWc1U+hNd123DudvTKH8HvgP8Y1PNPdiJrvwuU3w3uwU55r8858nqOivI+H/8J+n3weu6K8qfwovx+7A7AHzQeMh42HsFO/WfGo8ZjxuPGz7HT+V/Aa/+l8QS88lfGk8gn4JW/Nn6Dnl75lPFb9PLfoZc/jf4U+L3xB+OPuE7+jPGs8Rz8efQXjBfRy18yXkZWfwW8avwJ+Rq89j9jdxX+OrzyDeSb8Lfgr4O3jb9gr/yr8Q6y+t+Md3G9/O/Ge8Y/4H8D72On/Ce88gPjQ/TKj4yPjX8Znxj/Nj7F7h/0ep1n6Omfo3+B/BxMEuLu/k3mZvXyyq+SuT6B+Zc6B+fRK7+CV04Q5TJhFM6NdH0iMDH2ykngk2CvzykpvM5NFuX2Icbk8MnglUPhlZ/ieyDvGQPGIHyYUc8l0S4cfYQxEl67KPThYDLslFPAR8GnNKZCnxJMjV0qeD2fJBVyJHZp0KdBnxbcgl06+LTwyunBDNjpeSjp0GufEV45E7xyZvgM8Hq+inL5ENcrq88CZsV1onxVeOUKyNrr/+OfDednN+aIcvvsYE7scsDnglfODcrnMeZFL58PfR4wP3b54AvAKxcE5QvBKxc2FkFWXxTXqS+Gnl5Z/z9+Ub64sQTOKQavrP/vf0n0el6BsvpSyKXhlcvAK+eFz4v75L4sduXgtSsPXw7U8x7Kw5dGL8rfw/e/LF6Pfz7klXP73FcZvP49vK4+X/18+PMohc9NviC8vsf8PhYH5SuAFbFT1vMd6HVdJaOem1ARvhL2lXEflX3Ok68CRvucL6/nM4jyVUH5avDKeu5BNeyrgzVwnbKH62ui1/W10FfH+63ls6+N65TrwNeEjzHqeQc14bWrC69cDz4Gvj68sp6jIMo3MDbEjl65Ebyynoug5y40hNeusY9vgl45Fr4xfFN45TijnsfQGD4O+2agnsugXXP4ZvDKLUA9f6E5fEv0ynpOgrz2rXBda+RWYBvs3kBW3xY9vXI7Y3v08h3Qy3dET6/cFJTvZOyMczqCsdh1hu8CdsVOuZvPOfLdkXvAK/eE7w7fC15Zn19v5F7wyn3glfXz7IvcB15Zz8NQ7ufj+6NXHgDfD34gvLKesyHKDwLlB4NDsFPWcxV4jrye2zEU1+ncYVFuT6883DgCPb3ySOMo9PKj0cuPQU+vrM97LPbajUNP/x9EZjhTeJyFnXm01uP+hkNkfPe723ubSqOhSEU0mFJUCGUqJKQ0SMaKBg0aNM+RopJmGtEkQ4ZEpVBklikZQ4lMv7V+53P98Vyrdzn/3Ou67vv5vt93O+esdc4fz9sjv9j//+u2yA6R98n3iuypvr16fG957+j7RPZV30d5v3ZwP/m+8v2VPXPsBuTY4wcqu+fYPZBjjx8kD3eLHCymHxI5VH6wfJfIYZGdI4eL6Wtn0vPejZAfqvcZIT9Snt0o9fZD9L1Gqh8dOUZMP1bnxonH6r3Gyz8oDz8UOUGcq39YHh6mxPP3hydG1smkz52oc5PkHxHTn6HnePeo9pPF9HXjOVPEU7Wb+h/9Y8ppOgc/Lv+4+uny8Ax5mPc+V9+Dfqb6GepnaQfPlp8pP0c8V/4JMf2T6ucq52kHz5d/Un6BcqF2i+S9vy6T7siGmfQcvkUm7RfofXgevFh+sfZPKZ/WOfgZebhlZu+ec0sib8ik/RIl+6XKZdrBrTJ795xbHrlCvT38rDy8Uh5+Th5+XvmCdi+ovymT5rIcO57/YmTrTNrjV6m3h1+KfFn9S8pXtHtZ/lXl6hx7/GuRa8Sr5eHXlW9oB6/N4dtn0h5uI79O/Rt6zuvawevl18m/qeyQSXe3ZlLPboN6P2ejdvBb8hvk31Z2yux9906OPX6T8vZMuuuSSf0mne8mD9NvjnxX/Wb172kH986kHqbfEvm+env4g8gP1X+g/Ei7D+U/jhyQSfuPtaf/RD3P+TTyM/X28NbIJZm0x3+uc+y26jlf6By8LPZfium/yk/7L5Rfawdvk/9K/hvldu22q/9W+Wom3eG/U4//Xj38g/x38j8qX8ukuzcyqf9R53/K8Rz8uky636H+J/mf5eFf5OH1mZTZ/6rcqXMbdG6nPLxLHv5Nid8tD/8e+Yd6e/jt+Lw9Yvo/89P+dzH9X8q/tdsjvymTJv4fJf5febhYyf/FPiXT3h5+Pz5vXzH9fiXTvpiYvrhyf+32lf8wPucA8f7alSiZ7g4Ul1AepN3B4oPk4UMiD1VvDx8WmVFvD+dFZtXbw/mRJdXbwwWRhert4aLIw9Xbw0dEHqkef5R6/NHqj1CW0u5o+dKRx6jHl1FvD5eVh8tFllePr6C+nLKidhXkj408Tj3+ePX28AnycKXIyurt4RMjT1KPr6LeHj45sqp6fDX1+OrqT1aeol11+VMja6jHn6beHj5dHq4ZWUs9vrb6mso62p0hpj9TvT18VuTZ6u3hc5T4upHnqsfXU4+vr94ePi/yfPX2cIPIhurxjdTbwxdEXqjeHr5IiW8cebH6xspLtLtUTN9EPb6penv4ssjL1eOvUG8PXykPX6XEN4tsrh5/tXp7+JrIa9Xbwy2U+OsiW6q/Tnm9djeIr5eHb1TiW0XepB7fWr093EYevlmJbxvZTj2+vfq2yg7a3SKm76jeHr41spN6e/i2yNvV4+9Qj79TvT18V+Td6u9Sdtaui5i+q/rOynu0u1dM3029Pdw9sod6fE/13ZX3addLfJ+yt3Z9xL3l4b6R96vH91OP768eP0C9PTww8gH19vAgeXiwEj8kcqh6/DD1+OHqhyhHaDdSTD9KPX60+hHKMdqNFdOPUz9GOV67B8X0D6m3hydEPqweP1G9PTwp8hH1+EfVT1JO1m6KeLI8PDXyMfX4aerxj6ufqpyu3Qwx/Uz105WztJstniUPz1Hi50Y+oR7/pPq5ynnazRfTL1A/T7lQuwXyi5T4xZFPqcc/rR7/jPrFyiXaLRUvkYeXKfHLI1eot4efjVypHv+cenv4eSX+hcgX1dvDqyJfUo9/WT3+FfWrlLW0e0X+1cga8qv0fjXkV8uze009fo08u9fV28PL5eE3Iteqt4fXycPr5eE3xRvk4Y3y8Fvyb+k93xTTv63Ev6Osph28Kcdz8Gv03M16Lvyu/Hti+i3q8e/Lb1F+oB38ofz78h/Jwx9HfqLeHv5UHv5M7/2J/Fb19jD/P9NJ6o/TeXxVvUcFPY/3Lq/dMfLsPlKP/1ye3Rfq7b9UD38l/7U8u23q8d+ot9+uHv5Wfpv8d+Lv5b+T35lJ84cc+x/0PeCj5L/X5/8Y+ZN6/A71+J/V43+RZ/erevxO9T8rt2sH75LfKf+bcrd2u9X/rvxDu93ye/Teu+X/VG8P/xX5t3p7+B95+F95uFjB/2KfgrS3h/eN3E99cfXF1e8nv3/kAer3V5bQ7gD5AyMPUm8PH6w8RLtDxfSHqc/ovQ/VLk89Pqsen6/eHi6p5D9H+WL6Au0L5QvkiyIPF7s/Isdz8Pz3Abwrs3fP846MPErPsYePVu7OpDv8oXlpT+JLaV9a544Rl9auTEG6y9e5MkrOldX3Kau+nM6VlYfL659X+f/oKygranesmP449ceL6U9QltOunPpKkZXFJ8iXzEv7Mtrzdy/KS/ecP7Eg7U+SL9T5KvInan9yQbqDq8pXkS8VzyuTl3JV7aoVpLvq4mranVKQ7k4V09dQf5qY/ti8NCvkpbvTtashD9eUhyvlpVkxb+/na+lcbXGdHH3lvDTxZyjP1P4see/PLkh354jp66o/V0xfMy/N0/LSXW31dfU5fm49Pb++uJ6ee1ZkncjztINz9ecrG+hcQ3EDZSPtGspfoLxQO5jvYX+mvmf9vNSzu0jn/LmNtWuUl7L7Bnr+BfpejcUXy8MX5qX+EvmL5eFL5eEm8nBTefiyyMvV28NX8HfIS/sr1V+p8+zxV0U2E18pDzeXh6+Wh6+JvFa9Pdwi8jr19nBLefj6yBvU28M3ysOtlDdp1ywv9eyuyUt7e7i1PNyG75OXMv3N6vFt1bdWttMObi/fVr6D8hbtblHfMfJW9fhO6jsqb9Ouk/zt8vAdSvydkXepx9+t/k5lZ+3gLvJ3y3dV3qPdvfJd5eFukd3V43uox/dUbw/fJw/3iuyt3h7uE9lXvT18f2Q/9fZw/8gB6u3hgZFr8tJ+oJL9A8q1eXvfDcqxxw8WD4kcKh4mP1R+uHhE5EjxKPmR8qPFYyLHisfJj5UfL34w8iHxBPmHxROUE7V7WH6SPFwxmya+UjY9X0n9I3q+34P+0cjJ6h9VTtFusvxUebhyNt09pn6q/DTlidl097j8NHl4ujx8cjZl9jMiZ2qPn6XeHp4dOUf9bOVc7ebIPyEPPxk5T709PD9ygXp7eGHkIvX4xerxT6lfqHxau6fkn5GHlyjxSyOXqbeHl0euUG8PP6tcqd0K+eeUz2sHvyAPvyi/Sv4Fefgl5cvarZJfLA/z93tF/mXlS9rBr8rDq+VfE9OvUb9aTP+6PPyGPLxWHubfv+vkObdePb5hNvXe0b8ZvEH9m8pq2XS3QX6mPLxRiX9LHp6n99io771On7NR59bK8/d4XX+H9fKNsmni31a+o/0meXabxJvl4Xfl4fcit6h/T/m+dvAH8k2yKX8gD1+eTRP/YeS16u3hj5T4jyM/Uf+x8lPtPpH/TB7eGvm5+q3KL7T7XP7LyK/U28Nfy8PbIr9Rv025Xbtv5Ftm0/P0/P1aZFP2+W16r2/V479Tj/9evT38gzz8ozz8kzy8Qx7+OfIXMf2v6ncod2r3q/yuyN/U28O75eHfI/9Qbw/vifxTvT38lzz8d+Q/6u3hfyM7ZtPeHr49mya+WGHK+xSm/o5syvvIw/vKw52zaeL3iywu3j+yS3bvOzx8r/gAeRJfIrKHevyB6u3hgyIPVm8PHyIPHyoPHyYPZyLzxPTZHLusOF8eLikPF0T2yqY9voc8u97ZdMfz8HB/caE8iS/SexfpHP5w9UXyR8jDA7Jp4o/U+SN1Dn+U+iPlj5aHB2XTxJfS+VI6hy+tvpT8MfLwkGzK7MtoBw/Lpruy6svIl5OHR2RTLp/DV1APV5SHj5WHR2VTD9Mfp8QfLw+Py6Z8gjyJnyGuFDkzm/Kc7N59ZfUkfrb4RHl4SfBJwQuz6e4kfV4VPQ8+WR5emt27r6oerpbDV1d/iri68lTt4Bryp8ifFnm6enu4pjy8It6/lnp8TT2ntriO/BmRZ0aeJX925DnKupHnal9P5+D6kedFnq+dPfsG8nDDyDXZtG+oXaPICyIv1A7/Nv+7OJvuLlLfWM+9uDD1l0Reqp7nNInclE0T31S7y+Sbyl8eeUXklfKbs6m/SvtmOtc88mr110ReG9lCe/i6yJZi+usjb1B/Y2Qr9fib1LeSbx35dXzfNjn8VvUk/ubCNK/W7mp9fhu9Z9vIdpHt9Z7227Npj/8pfIfgW+Tb6/M66vm36lxHMX0n5Y5suoPp92TT87fpfPESKd+mvF07eL8Se/d3qIerlkg9iS8mPiWyWmR17fB3FqY95+4qTPu7xfSdlV20w3dVD98jD98r30W+ur4X/u/459VNe57bTdw9snaJtLeHe8jDtUqkHq4pf3pkz8I079Nz4V7yvbQvFve49Nbevpv6PnqO36evdveL+yr7aXe/fEF+ypzrrx08ILJI5wYo2Q+MfED9QOUg7eBS+amH6QdrPyRyqHiY/FD54ZEj1A9XjtRuhPwo+VF6z9HiUcox2o2WH6ssnZ/uxsmzK5+f9vbwePkH9dwyes6DOjdW7zte/FBkxfy0x09Q/5D6h7WbID8xcpJ6/CPq8Y+qn6icrN0U8VTtpubY4x9TTtNuivzjyunaTdf7T9F+hnbT5WdGVs5Pe/tJhXvveU7D2M1Sbw+fHVklP93P0vvP1ufMkJ+jbJSf7uZoP00enisPPyEPX5ifMvsntYMvyk8TPy9yvtjn8Bfnp4lvGtw6P+V5OT6ntd5jgXp4oTy8SH6+fJv8dL9YPfyU/CL5dvkpc186vrf6p5X4Z5RLtIOX5ngOnnvYl+rcssjl2tvDK5TPardcfqX4OfmV8s8ruSd+pXhpjvMv5HgO/kUl98d7tyrHHv+SkvvjvXs5xx7Pfegk98x794r2r6h/NXK19q8qX9MOXiO/Wv51efiNyLXq7WHudV8rHq3vRY/n/DqdI/HcBz9Wfr3OvykPb5BfL8+98RvFuXrua+dedvitwnT3lvZvF+59h39HPbxJfrP8u2J67nPfJOa93/mP8/j35OEtkdz/vlme3fvyW+Q/iOS++C05PPxhJPe909vDHynxH8vDn0Ryf/tHOTz8qRL/WeRW9Z8pP9cO/kJ+q/yXSu5fZ/eV+i/k4a+V27TjfvOv1LP/Rh7eLg9/Kw9zX7o9576L/F69PfyDPPyjPPyTPLxD+bN2P6vnfnfy2xw7nv9LJPez75D/Vb09vDNyl/qdyt+02yW/O5L72XfJ/67eHv4jco/6P5R/ardH/i/l3zn2+H+U+H+V3DfPrlhR6tntU5T29vC+RamH91MW1664+v2VB2hXXL6YmHvv8SXU89wD1dvDB8nDBysP0e4Q9YcquW/+EO3xJcTr5XnuYTmej88ouZ/eu7wcezz3xWflOZ8V58vDJSML1JdUFmoHF8kXyB+uPEI77qM/QjvOcz88nnvU8ey2iQvl4SPl4e/F7I/SOZh7x0n80Up8qcjS6kspD9KutPwx8nAZJb6sPMx952XER+v8vjpXVr6cknvTy4rpy2tfQb68fEV5mHvWjxXTH1eU9hWV/Pf3cdrjj5eHT1DiK8nDleUr672Olec++Mp6zonKk3Susjz3x5P4KpF/qq+inv3J8nBV/l46X1XJvpqyunYw98Pbc+4U5anaVZfnXnkSXyOS+9/pa6hnf5o8fHpkTfX2cK1I7oevKV9L+9rysO+Nx9fR7gz5OvJnysPcK3+WmP7sorQ/U3mOdmfL15WHz1Xi68nD9eXr673Okuf++/Pked75RWlfT9lAu/PlG8rDjZT4C5QX5tjjL4psrN4evjjyEvX28KWRTdRfqmyqXRP5yyIvV28PXxF5pXp7+Cp5uJmyuXbN1V+tvEa75vKXi6/N4Vuoh5vIXyffQtlSO7hxDn+9eviGHP489XAj+RvVc76Venv4psjW6m9SttEOvlm+tTy/C3GzzrWNLKUeXyTPrq2e43+ubfTe/I5FK70fv4dxY47vzd+npbJFjr9LC71PWzH/Pm6n3h5uH8nvSbSTh0vr79JMOz+Pnt+RIPEdtLtKvoP8LZEd1dvDt0Z2Un+r8jbtOsnfHsnvT3TK4eE7lPg75eG7Iu9Wbw93juyiHt9VfWflPdp1lb83kt9v6CrfTb093F0e7hHJ7zp0k+f3FXroXE/13dXfpx3cS76nfG8lv8vgXZ8ce3xfJb/L0Fue/f3yML/TAPM7CPb91PeXZzdAvr9yoHbwA/ID5Acp8YPl4SF6j0Hy/H5DP3nOD5UfIs/vNgzVuWGRw7UfphyhHTxSfrg8v98A87sJ+FbqRynxoyPHqMePVW8Pj1OO1+5B8Xh5+CF5eIJyjHb4h9XDE+XHyPM7EhN1blJkW/WTlOwfUfL7DuwelWc3Wb09PCVyqnp7+LHIaerxj6u3h6dHzlCPn6neHp4VOVs9fo56e3iuPPxE5JPq7eF5kfPV28ML5OGFykXaLZZn95R6e/jpyGfU28NL5OGlkcvUL1Uu1w5eIb9M/lnlSu2ek2f3vPr/Axq/NMt4nIWdabiNZcOGVbQjKnuttdmlaDAPmcqYIiolQ5QppUmzpDIkUgkJRYYGRYNkSBEKSWYyRZkzExmiVKbKdxxf9/njPg/reN8/13Ge13Xfaz323u/3/Xqfmakc//+fb0LODDlb+a12c8T0c9Xj56nHz1dvv0A9vFB+kXihcrF2S8SLld9pt0R+qfxSPd9c+WXK5dqtkGe3Uj3+e3l2q9SvVK7WDv5BfpX8jyHXqLeH18rD60KuV28Pb9DzrJffqN4e3hTyJ/WblJu1g7fI/yS/VblNu+3y7Haot4d3Kndpt1tM/7N6e3hPyL3q7eFflPu02y+mP6DeHj4Y8lf1B5WHtIMPy/8mPqz8Xbsj4t/l4T/k4T+Vf2mHP6oePiYPH5A/Ln9MHj6hPKndfjH9z+rxf6vH/6Pe/mv1U+XZ/av+H+Up7eAv5E+o53yOrPj7/y0Pzwo5R739GVlxv1t7ev7Od+scyX3bdf9y+RN6npN6Tnp+/kfVHxPTn5kVe3iy+Cx5OGcan0s9fLb82FTM9Bnqz1Z/jnbwJ6nYw/S5tc8jn1v+3JB51dvD+UKep94ePl8evkCZX7tMee8T2mXKJ+XhlDhLPiVfIGRB9fgPUnHvfX6dyy1fUB4enYrv4/u8m4q5Y2bss+XZXZgV9/adM+M+IX+hfPfMuMdfpL6QPLvnM2NfSB6+WHmJdr0zY8+ucFbc28NFQl6qvojyMu3gy+Uvlb9CWVS7YvLeF9euhLi4PFwyZCn19nBpebiMsqx2peTLKa/UDi4vX159BWUJ7SpoX1FZSTu4cpr78VfJw8XEV6fxAzPjHq6icyS+qLhvZuyLyhfW51bV51VVX1lZSeeqyldTDta91dVXkq+hHq4pD7+ZGftr1HO+lvoaymu1u058rTxcO2Qd9fjr1dvDdUPWU28P3yAP3xjyJvX2cH15+GZ5+BZ5uIHyVu0a6LnoG8o3kG+gz2kobiQPN1Y20a6hPD+f28T0TdPsyGbawbfLN5W/Qx6upV1z9XALefiaNP69zLjnnlGZ8Q7fUn1zfa+WSnwrZWvt4DGZsb9TPefbqPf9zbSD75JvI3+3sq12+HvUt5W/V3mfdvD9ae65X8/H/gH1cDv5B8XtlJ9mxjuytc6Ny4w9u4d03wPy8LTMmJdlxr6dzn0e/HKd4/kfzop7e5h/90fU28OPhnxMPf5x9fZw+5DHM+Me/4R6fAf17ZVPagd3lO8g/5Tyae2eVv+MPNxJHu4csov6zsqu2nWRf1bZTbvn5Nl1V28P95CHn5eHe4Z8Qb09/KI8/JKyl3ZnJmKmz5mImfMvq7eHe8vDfUL2VW8PvyIP91NmJOIdTH+O+NWQ/UMOEL+qHKjda2L619UPEtMPVr6h3Rvqh4QcKqYfpnPDtRv+P/o3lW9p97aYvlgi7ouK6d/JinOY7h2mnp8DP7f+6vPoXj7nrTTfo6j6ESHfFafrSyfiLJmId+9px7mR6keJ6cuGc++L6T/IivsPxfRXhnOVQ1YI+ZF2cLp+tPJjnRsjpv9E/Vgx/Tgl33eMmL6SeHzIKsFXS8Q8XrsJWfHuU/EE7SZmxbtP5T9Tfq4dXFWfB9NXDzxJ53z/5Kx494WYfor6qWL6Ook4r0vEu7rqp+hzfC88TZ8zRZ57vwxcLxH3X2r/Vcjp6r9SztBuuvxMefjrkA0TMc/U+Vny8DfycKNE7GH62Ur8t8o52sFz5RsnYqZvmoh7e3iePDw/ZPNEzPOUC7Qj8QuV+EXy8OKQLRJxv1i5RDu4dSL2rdV/p8QvlYeXhVyu3h5+KBF7uK2yjXYrtOe+leqXiem/D7lKPX61+u+VP2i3Wv5HeXiNEr825Dr1+PXq7eEN8vDGkJvU28M/hdys3h7eEnKrevw29fbwduUO7eCd8rvEO5W7tYN/lt8lv1W8J43fq75TIua92u+Wh7snTu95jl9C7hOn6/fLwwdCHgz5a8ijuf/LQ4EH5/svG2TE53ok4u93UZ7/8nDgAnni/X6d4/sNTJz+e+1O83w79Hz75AeH+34T0+OHJU6//109PCIR+xHqj+j8dvkj8n8o/9QO/kv+3UTM9EfV28PH5OHjyvcT8Q5/Qv1JMf049fi/1eP/UW8P/6s8pV2OAjHTn1Eg7k9pT3+mdvBZ8nBOeTiX+Gz5DDH9OerxudXj86i3h89V5tUuj3w+8Xny54vPk4cvCJlfPT5T/QXKhHaZ8kl5OBUyS31KWUC7LPmC8gX1fbPF9Beqt4cvUhbSDs4tf7H6i+ThS5SFtSsiLiwPXyoPX6YspF0h9fz+Xi7PfVeot4eLhpyYiHt7eEoiTnwxZXHtS8izKyEuqSylXQn50kp8GXm4rL5HafmpibjHl1NfVv2V2pWTLx+ygnp7uGLISurt4cohZybivrKS/VXy8NUhq6i3h6uGrKbeHq4esoZ6fE311ZXXaFdTvlbIQ4m4t4evlYevC/lHImb62urxddTjr1dvD9eVh+uFvEG9PXxjyJvU4+urt4dvDnmLenwD9fhb1TcM2Uie3bnJuL9V+8Y611h9k5C5kzG7v03nG8vzHE3FtymbaQffLn+HmL65evzRROzZtVDfXH0z7VrItwzZSr093FoevjPkGcm4x5+ZjLm1PJxL3EaexPPzO1t9E31OS93XRv42Pddd+vf4OxF7dqcSce/z/FxayJ9IxD0/V/7u/HtSRz2/F/wcm+t5mum52oj59+Hvkr9D/o7u1t9bW+3a/o/+Hnn43pD3qcffr/6BkO3k2T2oHv+QevzD6u3hR+ThR+Xhx+Thx0O2F9M/kWbXQX175ZPadZDPTsaJ76jEP6UsnIx3T8uze0a97+mkHdxZHu4iD3eVf1aeXTf1+OfU23dXD/eQ7yb/fMie6u3hF+ThF/W9e8q/pN4e7iUPX56M+WX53vLseov7yMN95eFXlPgSyZj7yffT/lVlf53rJ18yGTPnBmgHlwn7geIB2r1WIN7Br8sPlC+fjHmQ/GB5dvg31MND5AfJV0zGPFR+qPbDQg7XfpjyTe3gt+SHy78d8h319vAIefjdkO+pt4cr6Xnfk+fekSFH6fPeVw9/ID9S/sOQH4l9Dl87efpzo7WD6yRj/jjkmJCfaGfPfqw8fGMy3o1TP1Z+vHJCyE/FE+Xhz0J+HnJSyMnyX4RsEr7fFDH91JDTQrZKxp7dl9rBX8lPk58uD7dJxomfod1M+RnyX8vDs0J+E/Ku5Ok9+9nKdsl4h/825Bz5uerniecq52u3QEy/UP0iMf1iZYdkvIPpy2XEvCTkdyGXipcol2m3XEy/Qv1KMf33ylXarVK/OuQPYp/Hd+T/L0vGfUcxvZ8fXyH8u/2o83zOGvkf5eG1yk7JeIdfpx5eL79e+w0hN2q/QblJu5/Em+Thzcot2m0Vb5GHq2TEXDkj9tvk2W0vEPdbxPQ7Qu5Uv0O5S7ud8rvl4Z9D7hHT71X/i5i+YkacPO8e9VeFrKT9vgJxv19Mf6BA3O9THtQO7peM/QH53sn4eQ6muZf+V3m4fzJO/CEl/rDyN+3g39Pcgx8QPm9mMva/KY8UiHdH1Pv7/KFzf4r/UP6l3Z/yR5Wzk6ff7Uqzxx9Tzkmefnc8zR6/IBl//1/0Pf6S363nmq1/R+45rHO/iun3ptn1Cvfye87vq/8+ngs7fk/5e9qr7+u/W//d8/e6S8+9W/9e9Pz3zgn1+EXJ2LM7qf6E+r+1g/+RPyn/r3JxMt6dkmeXo2Dc+54zCsY7+Ez5HPJnycM5Q+ZSbw+fLQ9n6Hvnkl+SjHt7+Bydyy1/jvyKcD6PmD6P9ufKw6t1Lq/6fOLz0vRrkzGfL3+BPLv8BeM+nz4nv3ymPLuEevvz9HxJ9XnF9CklPqd8ps7js9RnyheQhwuKs+ULyl8Y8iL19nAheZifz7pkzPQXqy+k/hLt4MLyF8tvSMZcJI2/VD18mXwR+cuVG5PxDn+FenxR9XAx+c3JmOmLqy+mvoR2cEn54vLbkjFzrpR2cOmQO3SutJJ9mZBl1ZdRltOurPzeZOzhK7Urr76CfDllxYLxDq4kX0G+csir1FdWXq3dVfJV5OGqIauJ6aurx9dQj6+p3nv6a0LWUm8PXysPXxeytnp8HfX469Vfp6yrXT1xXXn4Bnn4Rnn4ppD11eNvVo+/RT2+gXr8rertG6pvJG6obKxdI/kmytu0ayrPrpl633O7dvAd8s3kmytbaNdSnl0r9b6ntXbwnfKt5Nso79Lubnnv22p3j7it8l7t7hPfKw/fLw8/oGynHf5B9fBD8vDD8u3k71biH1HiHw35mPpHlY9rB7eXf0z+CWUH7Z6UZ9dRve95Sjv4afmO8s8oO2nXWZ5dF/W+p6t2z4q7ysPdlM9p1138nLKHdt3ln1f21A5+Ic09+BflX9TzvST/gjzcSx5+WdlbO/wt6vF91PdR30se7isP8383XhH3VfbTDn5VHu4vD9eXH6D+VXl4YMjX1ONfV48fpH6gsp928GD5QfJvKIdoN0T9UOUw7YbID9f3HiL/pnp7+K2Qb6t/S/mOdm/Ljwj5rnr8e+rt4ZEhR6kfqXxfu1HyHyg/TLPHf6TEj1Z+rN3Hei78GPmPlZ9oN0Z+bMhx6scqx2s3QTxeHh4g/lR+gPzEkJ+J6T9Ps5uk3h6eLA9/oZyi3ST5qfLwNPGX8tPkv5KHa4mny09XP0NZI81upnbw1/JwdflZ6mfKw9+EnK0eP1W99/Tfhpyj3h6eKw/PU87Xbo78oWTsYZ5jgfx8nZ+nHfxXMvYw/cKQi9Tbw4tDLlG/WPmddkvklypPJk+/xy8LXCwV+6Xy8HIlfoU8vDJkqVTcr1Sy/165Sju4dCr2q9Vz/gf1vv9H7eA18j/Ir1Wu026d+vXKDdqtk9+oXK3dJnl2P6m3hzfLw1tCblVvD28LuV39NuUO7bbLVw4/z51i+p3a7wpZS+fs4d1K/M/y8J6Q9VJxbw/vVf+L/F75ffLw/pAH1NvDB0PWT8X9QeWv2pH4QyEbqLeHDyvxvyl/1w5unIo9TH9Eif9DHv4z5F/q7eGj8vAx5XHtjqtvmoqZe06EfES9PXxSif9b+Y92cPtU7GH6f0M+mYp7e/iUEp8jO84zsuMd3DkVexLfkf8db93DvWdlx70/N6d2cC75s+TPVmZol6H+HGWvVLzLkO+Zis/nTnMPvrf2udTDeeThc+Vzy/dJxZxXPp/8ucrzsuMdfL58PvkLxPnl84rpX0nFfX7dkykPJ+Tzy/dPxcy5ZMiU9vZwVsgC6u3hgvJwdsghqbjP1u5C+Wz5i+ThoamYC6XxF6uHL5GHh6diX1ieXRH1+EvV28OXhbxcPf4K9fZwUXm4mLK4dmNSsS+m8yXkx6Vipi8p5nwp9fZw6ZBl1NvDZUOWU28P83t0pfoLleW1gyvIwxXl4UppfGX1leSvUl6tHVwlzT1V9HxV5TlfTb09XF1ZQ7tq8jXF18jXlK+lvFa7a/U9a4rp+X25Tp57a6v359bRDr5evrZ8XeVnqXg3JRX7ujpfT+enaUd/g5jzN6q/Xkx/U8j66m9S3qwdfIt8ffkGyump0+9uTbPH8x4yckYq3s2WZ3erPqdhyEa6v6GysXZwE/lG8rcpeU+ad03T7PHN5GG/Hw1/u3Z3yMPN5eEW8rfLt1S20o73sd2uvrXY99ypXWv5NiF5Pxo970Njd5f28N3ybeTbysO8P43E36PdvfLwffLw/fIw72W7R0z/gBLfTh5+MORD6u3hh0M+ot4efjTkY+rt4cdDtldvDz8RsoN6e/hJZUftnhJ3lIefloefUbZPs+uUZo/vrHxMO3wX9fiu6rvI8/68rjrH5z+rPX6zzrHrpv5Z9c9pB3eX7ybfQ8n7+9jxfj18D51/Ps09eN6P97zO9Qz5gvY9lS9qB78k/4I878N7Sed6hXxZe3u4d8g+6nsr+2oHvyLfR76f8lXt+suzG6DeHh6ofE2718WvycOD5OHByv7a4d9QD/PewP7aD9FuqHiIcph28HD5ofJvhuT9g0PTeJj3vb2pe97SOfhteZj3vbF7Rz3Me9bsR6jHv6t+hPx7St6zNkJ+pPpR8uzw76uHP5CHeY+b/Yfq4Y/S+NHq4Y/lP5L3++DwhcSj5Um83+81Ws8xJjvuP1T/iXbwWPkx8uOUvC+MHe/xwo/T+fFp7sHzXq/xOjch5KfaT1BO1O4z8UR5+HPlJO0miycpv9BusvwUJe8dYzdVnt009fbwl/LwV/Iw71OCp8uT+BkhZ2o3Q/3X2sGz5GfK8z6lWTr3TcjZ2uO/VW8Pzwk5V/0c5Tzt4Pnyc+UXKBdqBy+SX6Se95yQ+MXKrtrxfhE8ux7iJfLwdyGXiumXpdktV79UuUI7eKX8cvnvlau0w69Wv0r+B+WP2i0T069Rbw+vVa7Tbo0873thv179Onne60Lieb9Kb/kNyo3ab5L3/qfseLdZTL9F/VYx/Tbldu3wvDdlu3Z43rfyina8r2WjzrHj/h26b6eYfld23O9Q7tZul/zP8vCekHvF9P8HeCiCuHichZ15tI1l44aFSJmH/e59nENJA1GRSoOhMhQp0YBUhjSYQlJkLI1oIFOUFEVpoMGYEoWETIVCk1QaVESGfGv9vuf6rfVcy+7rn3td132/z97vOc7e56zVWvuHTL7/++/7kD+G/EH8k3KndjvV/6z8Rbud8r/KwzvET6T+m99m4sy2g3/T4/2W+fd+l3J0Kt7B9L+H/EO8S/5P9fBu+T3i3crnUvFunJie5LpJ4hdSsffjc58v6Dqe91T1+L+04/73qt8n/2Iq7qenYr9X+7+1g/fLwwfkSfy0VJz4VwIfDDxD/UGdfyjkP+oPKQ9rly8n5qNyjtznD1lAnE9ZULsC8kcrC2kHF87iZ6Xi/jXxLH3dvMuv89kdo8fx8yySE++OFdMfpx5fVH0RfV2KyheTZ1dcvpg8XEJZUrtS4pLycGl5uIyyqHZl1ZeWh8uFTKm3hxN5OB0yo94ezgm5MBX35dWXz/n3PlcezpOHF6XixFdQ4ivKw8eHPEE9/sNU3OMrqcefqB5fWZ7dSepPVJ6sHXyK/EnypyqraFdVnt1p6n1ONe3g6vKnyZ+uPEO7M9SfGbKGenxN9Wcqz9IOriVfU/5s5TnanSvvfW3tzhPXVp6v3XnyFygv1A6uk8XXVQ/Xk68jX1/3WUeevEi7c+RriKvKc87F2sFVsvjK6i+Rv1j3c4l8A3l2S1Oxb6h9w5x/7xuFbKy+kfJS7RrLr0jFib8s5Gr1l6ln3yRkU/VNlJdrBzeTbyp/hXJd6si7K7Ps8c1DfpaK++baXSXfXH5TKuYW8i20z5/8N1tqj79ant01OXGPPyqJe+/p/0nFHt6Xis+l3yMPb5bfrPvkPrjfa3X/V8pfJ75SHm4lD7dWttEOXzyJ+wvkfU4r7fx82ygLJPGuaBL7NjqX+2qmvFy7VvJ+ncXzc3W9evsG6tfp55mfo0t1Hec0kmfH6w6vK8tS8b6BruN1j99P/LrI62Z9XV8vy/3DfH1aifk+8j7H992e98mSoff7Ku9L54r9/lxL58FlkiN7fl9oG7JsEvf4G9S3VX+jdjfI3yQPtwvZXn07ZQft2st3lIdvDlkuibmjru8kf4u4kzx8a8jbxNn625Wdtesi7qzsql0X+W7K7tp1133YJ0nc3yHPrnwS9z10To+cf+/9PHtqVyGJuaf2XeXhXvJ3invJw71D3qW+t7KPdnfJ3y0P3xOyShJztr6vfF89rzvl+4krJrHvqR1f33u15/qT1ffVffbX8x8g7i8PDww5SP1A5WDt4CHyg+TvU1ZL4t0ZSezZ3a/e5wzV7n75B0I+qN4efijkw+rxj6i3hx+Vh4eFHK7eHh4R8jH19vDjIZ9Qbw8/GXKkenzDJO7xo9Tjn1JvD4+Wh8eEHKveHh4Xcrx6/NPq8RPUTwz5jDy79kncT9D+WV33rPomSfz4E7M8Dn6S/CQ9j04hO4R8Tjs4Wz9ZO/j5kC+ot4enhOycxP0U7TvreU/ROVOVL+oc+CX5KfJdkpi57u4kTnx/8TT5aTqH5zdde/zL6u1fUQ/PkIdflX9NfoY8/Lo8/IY8PFM8S36m/Jvy8MAkZvZvaQcPSuLEvx3yHe3s4dny8JyQQ5K4n6PdXPk58vPk4YfCufPV4+9LYj9fPecMEy/I4ueqh9+VXyA/Ion3C9XD78nDI5PYvyv/eBLv31e/SN47+g/k4VHhnMXiD7RbkhPv4A/lF8uPSeL9R+rhpfLwuCT2y+SXar9cO/hj+WXyK8SfyK+QX6nnQT8+iXertF8pvzrkp2Jfh386iRM/OfAa8eosj7NGvFZ+jfy6kOvF2foN8vCUJE78ZyE/F2frN8rDm7TbrH6j/Bchv1RvD2+Rh2eE+9kq/4VyW068g7+S3yr/dchv1NvD38rD34Xcrt4efj2J72e7PMl+tpjH/V7nwnOSOPE7tPtBfof8j/Lw/CRO/E/a7ZT/SX5JEueC5Mi7pdrhf1YP/yJP4j8S/ypP4peLf+N1K4l5dXJkv0s9vCqJ/e/yu3T9HznxDv5T/nf53bxuJDHv0W5Plj3+L3l4fRInfq8Sv0/5t3bw50nsYfr9SvwB5UHt4ENZzsFvSmLmun9CHtb+H+XBJN7BX8uT+C0hv9DjH/b5IfOVj/NQEu+OSsee3VHl497n5NcOLiAPF5SH86eP7I9WDxeSLyzPrrD4GGUR7QrLHysPH6fEF5WHi8nDxeXhEvIldH+F5AukYy6XPrIvrh4umcUXUw+n0rEvJc+utHwp7ctoV1q+rDycpONdOfVl5TPpmFPycJLFp9XDGV8XMkc+kS8Pp+MeXyEd9/bwCek48bnq4Tz1FeTz5CuGPF69PXxCyFPTcX+Ckn2lkCeqr6SsrB1cMx37E+WrhTxJ13HuyeXjHn+KPLtT1dvDfP2qqMdXlWd3mvoqylzt4Bz5auIc+epZ9qerh8+Qh8+Ury5fQ/dTPYuHT1Hia8rDZynxtUKerb6W8hzt4HPlz5avrTzPj5eOPbvK2rPj3POznI+vlY6Z6y7QDr6Q+9J1FzrT8a6OPLs6uq6usp52dXRePe3ry8MXycMN0rH/f5a/WNfVV16iHdxA/mL5hiEbqW+obJ6Od9ekY8+usXr8pTqfc5ql497+Ml3fSPtsPV+nxjqnmZ5XAz1vuIl8Y/mmymvT8e76dOzZXa7eHm4W8gr19vCV8nBz5VXatZBn11K9PXw132/19vC18vB1ylbatZZn10a9PXx9yLbq7eEbQt6oHn+Tenu4Xcj26vEd1OM7qreHbw7ZSb09fIs8fGvI29Tjb1dvD3cO2UW9PdxVHub9uJt6e7h7yDvU43uot4d7huylHn+nenwZ9fZwb13P/i5lH+3wd6uH75HvI8/3ra+YvmOWXT/1+HvV99XzuTfLnr6/PDxAHh6oxA+ShweHHKJ+sPI+7eD75eGh8kPkH5CHH5SHH1LiH5aH++l+HpLn+g667hH5B5WPaveI/DB5eHjI9uqHK9mPkIcfC3mj+seU7B+Xh1sr8U/Iw08q8SPl4VEhW6i3h9uG9/lW2rPrkI73I5VPaQePzuLHqIfHyo+Wvzkd8zh5Ej9eiX9aOUE7+NZ07CfKT9D+Ge3gZ+Unyk8K+Zz6ScrJ2j0vniwP35SJE/+CerhDJk78lJBTtbOHXwz5knp7eFrI6eqnKV/Wbrr8K/LwDOWr2r0m/7p8x0zcT9Wenv0b8jPl2c0U87iz1Nu/rvt5Uz3+LfXe078d8h352fLwnJBz1dvD80LOV28PL5CH3w25UL09/J48/H7IRert4Q9CLlaPX6Ie/6H6D5QfaQcvlf9QfplyuXYfy7Nbod4e/kQeXqlcpd0K+dXKT7WD18ivUb825Dr19vB65QbtPhZv0P4z+Q3ynys3agdvkl8u3qTcrB28JIv/Qv2X8uy2qMdvlWe3Tb39Ft3nV+rxX8uz+0a9PfxtyO/U28PbQ36v3h7eEfIH9fbwjyF/Um8P7wz5s3p7+JeQv6q3h38LuUu9Pfx7yD/U28N/htyt3h7eE/Iv9fbw3pD71NvDf4fcr94ePhDyoPoDykPawf/IH5Q/rMyXG++Oyo09u/y5ce9zCuTGO5j/zwRfUOfg+f9jCsofrevY4Quphwtn8ceoLyxfRL6Ini+7Y9UXkT9OHs6nxPN95vqi6o+T36d9MfVwcfmi8vz7ZV9CPVxSvrg8PzfsS6mHS8uXlOfnlX0Z9XBZ+dLyvE6wL6ceTsmXlef1iX2iHk7Lp+R5XWSfUQ/nyKfleT1mX149nCufI8/7APs89XAF+Vx53n/YV1QPHy9fQZ73PfYnqIcryR8vz/st+xPVw5XlK8nzPg+flMWfrB4+Rf4keX5PgU/N4quoh6vKnyaulqXn96aqWXZwdV13mjy/r8H8HYE/Xb66rj8jN96dLn+mPMzfT3CNLL6mepi/4/Bnqef6WvJny5+jvqb8ufIwf3fC/ju2tvx5ubHn72D68+Vra39BbryDL5SH68ifL19XHubvfriePImvr91F8vXlL1bemjny7pIse3wD5e2ZI+8aZtnjGym7ZI68a5xlj79U2S1z5N1lWfb4Jso7MvGuqTy7y9X7nGbaXSFuJg9fKQ83V16lXQt5di3V+5yrtYOvkW8pf63yOu1ayV8rD7dWttGulfz18nBbefgGJf5Gefgm5XXatZBn1069z2mvHdxBvp18x5A3i+k7qcffot7+VvXwbfKd5G9X4jvLw13k4a7ycDf5brq/m+V7ZuJsql137bsq79Cuu3wPebinPNxLHr4zZG9xL+Vd2sF95HvL363sndE+E/d9Ave3D3lPbtzb99Hz66veHu6nvFe7/mL6Aert4YEhB6kfqBysHTxEfpD8g5mYue6+kPdrbw8PDfmA+qHKB7WDH5J/QP5h5SPaPSrPbph6/HD1+BHqvad/LOTj6u3hJ0I+qd4eHhlylHr8U+rxo9Xbw2NCjlU/Tv24/9GPl4efDjlBPX6ienv4mZDPqreHJ8nDz4WcrB7/vHp7+IWQU9Tbw1Pl4RdDvqTeHp4mD08P+bJ6e/gV5QztXhXTv6Ye/7p6/Bvq8TPV42fJs3tTPf4t9fbw28p3tHtLfrZ4jvxs+bnKedrN0/PEz5efp1ygHfyu/Hz5hSHfU79Q+b5278kvkoc/CLlYvEi5RLvF8h8qZ2n3kbz3S7VbJl4qDy+Xh/l3+rF4uXKFdvAn8ivFn8jDq5SrtVsp/6k8/Kp4jfyr8mvl4ZfE67L459Wvl18rv1aPv168Qc9/Q5b+M12/Xp7H/zzkZPUT5T9XbtRuo/pNITfLb1B+od1m+S+VW7SDt8pvzfI88NvUb9N94L+SZ/e1evw36vHfqrf/Tj28XX67+u9D7lD/vfIH7eAf5eF5mdjvkP9JHt4Z8mf19vAv8vDXup+f5dmNzeJ/Vb9Tnt1v8ux2qbf/XT38hzz8lPyf6rl+t3p7eI/yL+12y+8V75PfK/+3cr92+/U894rpD4gPyh+QHy4+JP+P/EH5w+rhfHmxPyQ/TPuj8uIefjwTe/jR3CPvOS9/4ALq8ysLagcfLV9AvlDIkZm4L6RkX1gefi4Te/gY7eExoR+fifkY7Z7R7hidT8/zKKL+WHl2x+XFfWFlQe3govLHyRdTFtfutUzsi+n6ElnOwb+RiZnrSobk566EPMm/d3YldU5+Pe9j9fyPVV8q5GR9vUspp2XiXSmdMyP4Inoc9vz74/tQWM+7oJ7/k3xehf7d0x/W/R/W6wF+v7xfN/br67lPX39/P+hnZuLE/6XkdfrNTMyzM7Gfo57Xe7++8vr+hzyvp6PU4zmfc3k/4/2J90Hep37SjvfBuZnYs+P3B36/KJ0X54JMvMOzXxT6xZnY83tMmby4x/P7Ab8v7NB13+l6uGxe7El8OeWSTLxLybNL1PuctHZwRj6Rz1GW1668+tyQeWL3qzLx9XAFnUtW0P1VzPJ4x6s/IWQl+ePl4RNDVlZvD58U8mT19vApylO1g6vIV5U/VXmadnA1+ary1ZWna4c/Qz18pvzp8jXka+g+qshX1vU11deQr6T9WerhWvI15SuKue7skOeox6/NxD3+XPX42urx58nXVp6v3QXi8+XhC+XhOsq62tVVXy9kfbH7i3R9XfmLdZ915cl1mXiHv0T9RfLe0TcI2VB9A2Uj7eCNmdjD9JsCNw78pfptmdizu1T9ZfJbM3G/PRN7dk3y4r6pzmn6P/rLlc103RVi+ivVNxfTX6Vsol0T9XyOXwuxz2mZF++uFrdUXqPdteJr5OHr5OFWytbatVbfJuT1YvdtdX1reT7PsLX4au0474aQN4qz9Tcp22nXXtxOHvbnJ+I7KPEdQ96s3h7mc/I6ielvyYt7/GFdx+5W9fbwbSFvV3+bsrN2t8t3kYe7huRz1rqq5/pu8nB3+S7yfA4bfId8D3l2PcQ95eFeIe8Ue4/vHfIu9fZwn5B3q7eH75GH+4bsp76v8l7t4P7yfG5cP/V8rhu9PTxA1w2UHyA/SDlYO5jPfRug/RDtBsvfF5LPWRssX1Ge3X065/6Qp6i3h/kctWryQ3XdA/JD5R9UPqQdn8c2VD0eflge5vPZHtHu0ZA3qsefJc/uUZ0zTDlc59yk64bLwyPUPyYPPy4PPyE/Qp7PX3lC1z0ZcqT2+FHqn1Q+pd0o+dHy8JiQY9WPUY7Tbqz8eHn46ZATxOOVE7WbIM/nuzwjz/XPyj8jD08K+Zx6e3hyyOfV419Qj5+iHj9VvT38ojz8Ushp6vHT1b8c8hV5djPU28OvysOvhXxd/g15eGbIWert4TdDvqXeHn475Dvq7eHZIeeot4fnhpyn3h6eH3KBenv43ZAL1dvD74V8X709vCjkB+rt4cUhl6i3hz8M+ZF6e5jPzSDxS7VbJg8vl4f5XIylYno+1+FjXce5K/Lifpnuc4X8J9rTr1SPX6Qev0r7lcrV2q2S/1QeXqPEr5WH18nD60NuUG8P87kWG3Rfvo7z+bwL+DN5Ev95yI3a2cOb5GE+7wLeLE/iv1Div5SH+bwLEr8l5Fbt7GE+74HPXVioPbktL97B/wFtgJOGeJyFnXm0juXihhEyz+P2frZNoQyVCkmiMpUxUYYUCSlRJCFSkpKoDIlIytSgAWmgDJEGSeYh8zxnHuK31u8811nrvZZvnfPPva7rvp/n+769kX1arXdrIt3//29Byn9yS+BtIbeKt8tvlV+YEt/vUA/vlN8uvzglvt+lHt4tvyQlznu026P93iS7veJ98vB+5QHt8AfVw4fk4cPye8T0y1LifEjJ6xyRh39JiSf+qHbH5OF/5I/KHw95Qr09fFIeXpEST/xK8amQp8Vn5E/Lnw15Tuxz+FUp8cSfD3lBnKz/Vx5emxJP/AbxxZCXxOmKx/0l+S0pcU4vD2eKLu8zqL9Cnl1GeXaZ1OMzq79CmU67K7XHZ1GP5+ueRf6ivi/4c9pf0K+TrHo9fLbi8R7OLp9VPod8Dn0OOGcSn0s9nFs+p3weeTiTdnnV55HPJw9nVOLzhyyg3h4uKA9nDr8OM6jHc76QzhWUzxLFubA8iS+iXVF5OEW+iHzOKL4vph6O5FPkc0fxfUI9XFw+ks8bxfep6uES8sXl80fxfZp6uKR8CfmCUZw5VyrkVWLfiy8cXf7c1SFLi30vvmh0+XNlQpYV+158sSi+v0Y9fK18GflEFN+XUw+Xl79WPjWK7yuohyvKl5dPi+L769TD18tXlC8VxfmGJL6SevhG+RvkS0dxvimJv1k9XFn+mijOVbSroj2+qnr4Fvkq8tXkq+l9wLfy/Zavrv6mKM70t6nH11BfXe+vhvzt2tPXVI+vpb6Gsqp2d4jp70yyu0v9HcrK2tXWHl9HvT3Mr5u66vH15OvKw/z6rq8ef7d8fXmY34f3qMc3kGfXUL093ChkY/X2cJOQTdXbw/eGbKbeHr4vZHP19nCLkPeLk/UPhGwpTta3CtlanKxvE5J/nj4YMk3cRufayrN7SD0+oZ7Xe1jeO/p2Snz7kI+ox3dQbw8/GrKjenu4U8i86vGd5fPKP6a+izy7x9Xbw/x9+gnt2XVVbw8/GTKXmL7b/9jRd1c+pd3T8j3E9D3le+p9d5V/QvxMyF7iZ+V7yfcO+ZzY53rrdeE+SXxf9XA/+T7yz8vDXbTrr/55+QHy8GNKfAedf0H9APlHxAPlB6p/MeRL4mT9IHm4lRL/gPjlkIPFr8gPlh8S8lXxK3odzrXQ/jWdg4fKD5Fvof3r6uFh8kPlm2v/hnp4uPww+Wbaj1APvyk/XL6p9m+pf1Oef26/Lc/5kerxo9TjR8uzG6PeHn4n5Fj19vC7Icept4fHh3xPnKyfEHKi+gnK97WDJ8lPlP9AOVm7D+XZfaTe90zRDp4q/5H8NOV07WbIs/tYve/5RDv4U3n4M3l4ZhL/ufqZ8l8ov9QO/irJPV/p88GzkvjZ6uE58rPkv5aHpyvxH4rnJvHfqIe/lZ8r/508PFmJH6/z36v/Tn6cmHPzQs4X+1782CTnfgj5o5h+jM4t0G6BevxC9fAi+QXy/Pm3WLxI+ZN28BL5xfJLlSOT7H5OsscvC/mLenv4V3n4LXGDJP439fDvSfxy9X+IlytXaAf/Kf+H/MqQf6m3h1fJw/x8v1p9PZ1fo3Or5OuIObdWHub/51gnXqtcrx28QR6uKb9RfoNyk3bwZvmN8n+H3CKm36oev029/Xb18A75rfI7Q+4S75CHa0VxD9dQ7k5yL7xbfrc+9xb56uHeO6P4++Fz7hHzddmrfptyn3b7xfvkYX49HVBvDx8MeUi9PXxYeUS7Q/JH5eFj8vA/SvxxefiEPMzX6aS8z9HXj+Ie3qPdKfUkvmEU3x/TuWO677i+Lt411v3sTqvHn1GPP6vee/pzyvPanZG/oPxXu4vy7C6p9z3pUuM7OL08ic+gvEL7jPLsMqXGe9+TWTv4SvlM8lmUWbXLJs8uu3p7OEfInOrt4Vwhc4vp8+gcfV719nC+kPnV28MFQhYUJ+sLhSys3h4uErKomD5F5+iLqbeHo5AJ9fZw8ZCp6u1hfn7g55ZU+RI6N0c+TT1MXzJkKfX4q9Tjr1aPL60eX0a+tLKsdteIy8rD/Dx5rXp8OXl25VPjvT1cIWRF9RWU12kHXy9fUf4GZSXtbpRnd5N633OzdnBlebiKPFw1ib9FPVxNHr5Vvqp8dfnq+nzwbUl8DfXw7fJwTfla4pry8B3y8J3KStrhy6nH36Ueri1fW32dkHXV11HW0w6uL19X/mrt71YP3yNfX/4qMecahGyovoGykXZwY/mG8k3kYf95h0/ofFP1TeSLaX+veriZfFP5FPF98s3l2bVQb3+/evgB+ebyLcWt5FvKt5Zvrfd7n3wb+Tb6vOzyq2+t182v9/mgeritfCv5vNo/pB5+WL6tfB5xO/n28uweUW/fQT38qHx7+Y7iTvId5TvLd9b7bSf/mDJnkl027TrrdbOJuyTxj6uHn5CHu8p3kc8qzij/pHxXZTft4O7yT8o/FfJpcXdlD+3gltHlfU/1z8ize0bcS/msdnDvJP459XAfebh1FPdwT+37qu+je/pp11f+eXm4vzw8QB5+QYkfKA+3ieK7F9XDHaO4h9vKt5Nn95LOvaj7B6XGdy+LB8nDg+XhLlE8O0WX372i/RB5dq+mxnt7+DXlUO1eFw+Vh4fJw28oh2iH76/PAw/XuRei+LlhSt7PCL5fUbwfoWT/Zsi31NvDbytHajdKTD9avT08JuQ76u3hsSHfVW8Pj1OO1+49Mf0E9fbwxJDvq5+onKTdB+JJ8vBk7oni/WQl+w/l4Y/wUbz/SMl+inKqdv/lSPdE8X6aEj9dOUM7+OMk9+CnRHHm3CchP9X+E+WcKL6bpvv+ez6K9/bw7Ch+P+/nM+Vc7WbKs/tcve/5Qjv4S/nP5b9SztJutjy7Oert4a/5POrt4W+U32o3V/475ffawfPk4fnyP8jPk4d/VC7Q7gf5hfLwbPGiJH6xevgn+UXyS5SztJspz+6bKN77nu+j+O4n+SV6H7zfpfLwvCie+J+V+GXKX7SDf01yD35+FGfO/aYd/Dvfd52zh5eH/EP9cvUrtFsQxZn+T/FyeXil8i/tVon/kodXy8NrlCu0w69Vv0J+cRRP/FLxOvn18uzWizcoN2q3SbxRHt4sD/+tXKfdOvXL+O8+5Tcrt6bGd/A2+S3y25W/Rpff7Uiyx+9U/hbFd7vk2e1Wbw/vCblX/T75/eoPyO+Vhw8qD2l3QH5T+ByH+T5E8X5HFPfsyAKJ+O6wXp+exBfhvwcXH9T9h5J8Lj7vEeVefT2PqreHj4VMS8R7e7gE/126+JjOHU+N706I6U+qP67co91J+VPy8Gkl/ow8fFb+rN7XCflzIc+L6S+ox/8rz+6ievwl9fZwuhL/ifQl4j2ezKAdfIV8evmMykza4TOrzyR/Zcgs6u3hrCGzqcdnV59VmUO77PI5Q+ZSj8+tHp9HvT2cN2Q+9fj86u3hAiELqreHCynxhUMWUY8vqt4eTglZTD0+Um8PJ0IWV49PVW8PlwiZph5fUr09XCrkVerxV6u3h0uHLKMeX1Z9aeU12l0rpi+nHl9ePb6Cenu4Ysjr1OOvV19ReYN2lcT0N6q/QXmTdjeL6Surt4erKPFVQ96ivqqymna3iqspq2t3m5i+hnp7+PaQNdXbw7WU+DtC3qneHr5Lia8dso56fF31tZX1tKsvrqe8W7t7xPQN1NvDDZX4RiEbq2+kbKJdU3ET5b3aNRPT36ce31z9vcoW2t0vpn9AfQtlS+0ekG+lxLcO2UY9/kH1+LbqWysf0u5hMX079Q8p22v3iLi9soN2j4rpO6rvoOykXWcx/WPqOym7aPe4mP4J9V2UXbV7UtxV2U277mL6p9Tjn1bfTdlDu55i+mfU91D20u5ZcS95uHfI59Tj+6i3h/sq8f1CPq/eHu6vxA8I+YL6AcqB2r0opn9JPX6Q+oHKl7UbJD9Yiefv16+oxw/R3q9Hz9/3XxUPUQ7Q7jUx/dAku9fVDxPTvyEPDxePkB8un0X7N9XDb8nD/Nw3Qj2en7e4522dh/l5Ez9Snt0o9fjX1eOHybMbLc9ujHp7+J2QY9Xj+6l/R/madr20t39X/Tjxu8rx2o2Tfy/kBPX28MSQ76vHT1KP/0A9frJ6/Ify7D5SP1k5Xju4q/yHYvop6vFT5afIw9NCTlePn6F+mvJj7WbIfyIPf6r8TDt4pvxM9Z+H/EK9PfylPPyVcrp209XPEs+WnyU/Scy5OSG/Vo+fq94e/ibkt+rt4e/k4e9DzlOPn68e/4N6/I/qvadfEHKhevwi9QuUi7VbJP+TPLxEiV8a8mf1S5XLtPtFvEwe/lUe/k0e/l2JX678Qzt4RZJ78H+GXKIev1D9n8qV2sHz5f+SZ7dCPX6VvHf0q0OuUb9auVa7NfLr5OH1Sjy/Dzi/QT28UX6d/CZ5+FvtNqvfJD9X+7/Vw1vkN8t/rcRPEG+V3ya/RR7ertyh3Tb5nUr8Lnl4t97HTvlx6ncruWeMmNfdo9yr3S750eJ98vvU7w95QL09fFBZJhHfHZA/JObfs+AP67798vARebgc/55MfES7YyXiO/gf+aPyx5Xl9Xon5NmdVO97TmkHn5Y/KX9GeVa7c/Lszqv3PRe0g/+VPy9/UXlJu3Rpcc8ufVq8t4czBL4iLd7bwxnl4UwhM6vPpLxSOziLfFZxFnk4mzK7djnE2eXhnHrfOeRzqcfnVo/Po94ezqvMp11+MX3NRLwvoD19wbR45tYOXz0R7+FCOldIfeG0ePLrkB2/H/Dsiqj3PUW1KyKfIg8XU/L7lB1/XuDZVUjEe9/D/dcl4hwl8dUS8f5GMX1RcYq+DtW14/vv7zec0Pc/ob5BIn5Pw0S8b5KI+3x63bzawcXl4VR5Et84EU98M3GJkM2DT5NnlyYuqSyl3VXiUvLw1SFLqy+jvoz60vJlQ16jvqzyWu3gcvLlxfQV1FdUX1F9BfnrQl6v3h6+IWSPRLy3hyvJwzeGvElMf7N6fGX1lZRVtKssX1UevkWJrxbyVvX46uqrKW/TDq4hX13+dmVN7WrJs7tDve+5U7s75O+Sh2sr8XXk4brydfW+asnXC1lfXFcevlsevidkA/X2cMOQjdQ3VDbWrpF8E2XTJHv8vSGbiZvKw/cpm2sHt0ji71cP10via6rH36r+Afn75eGWIVupb6lsrR3cRr6V/IPKttrdLM/uIfX4h9Xj28k/LA+3l4d7J+L5SJJdX+36J+KeXX9xh5CPqreHO4YcmIj3+JcT8R7fSX1HneusHfyYfCf5LsrBifgOpn9c+yfkH5fvKg+/Eu59UkzfLS3ed1V2166b/FPy8NNKfA95eKjeJ/2QRLxn31Pnn5HvKf9GIs6c66X31yvJvfhn5Z/V/cMTcT8yEU98byX+uZB9xD6H7xuyn/q+yue16yffXx4elYgz+wHawaMT8d0L6gfIDwz5onp7+KWQg9Tbwy/Lw4P5/aAeP0S9PfxqyNfU28ND5eEZ4es2NRHv8a+Lh+n8sP/Rv6EdPDzkCPX4N9W/FfJteXYj1eNHqR8dcow8u3fU48eqH6UcrR38rvxY+XHK8dq9J89ugnrfM1E7+H35CfKTlB9oN1l+kjz8YciP1NvDU+ThqSGniemn69xU5Qztpst/HPIT9fhP1dvDn4WcqR7/uXr8F+rt4S/l4a9CzlJvD88OOUc9/mv19vDckN+ot4e/Dfmdevz36vHz1NvD8+XhH0L+qB6/QL09vDDkhkS8t4cXqV8sv0h+i87/pB5eIr9YnueAsl+qHv5Zfok8zwFlv0z9z/I8HxT+JYn/VT38m/wv8r/LwzwvlN1y9b/L8xxR+A/5P7RfEfKg+j/V/6n72OOPiVcm8X+ph1fJr5RfLQ/zXFB2a9Svll8rD/O8UBK/LuQp9et0fr328AZ5mOc3rlOP5zmh3LNR5+FN8jDPf8TzXBb8Jt3TQx7uLr9ZPef/Vo/fIs9uq3p7eI0Sv17nObct5Hb19vAO5U7ttsvvEu+W3yW/R7lXu716n/h96n3Pfu3gA/L75A/Kw4dC8tydQ+p5bg59snM91PO6PDfngN7v4ZDPqT+sPKIdfDSJP6Ye/kf+qDzP44GPJ/En1MMn5Y/Ln5KHeX4Pu9PqT8mfkYd5Tg+7s+p5jg7M82/Ois/o9c7pvrPyPAeH54mc03k+1/t6f3zdJunz8xwQPLvz6u1hvk/H1OMvyLP7Vz3+ojy7S+rt4XQl/xPpS8Z7ezhDyCvU28MZQ2ZSbw/z51Nm9fgr5dllKRnv7eGsIbOpt4ezh8yh3h7OGTKX+pzK3NrBeeThvEl8PvX5xfQF1NvDBUMWUl9Qyd8f2RXWOXp8EfVwUXn4K93Pzz9Fdb6IXj8lZDH1/wdEFgsneJyFnXnYDeXjxomQqCT7cs55vYSslcoSUYRESUkREQpRlLLEi1SWbBWRQosWkURRpBDJEqJEKpLSRqsW9LuuX8/nj+dzmev7/nNf9+e+55mZc87MmffMnDmls3L9/1+ZoKWDrsv8p29n4nyd/JvBl9T0JYKuD/lrQc8KvHjQskGLBT1TfGMmzssFLZoVj7coE+dnqU9ePivWlHrwtPKi8hn1Mgl9eJYUXkEcXyhoEeWFNH22pqsgXlEcX1C9SsrxZ4tXFK8sji+gXhXl+KrilcXzy5+TwKspx1cXP0c8j/o1lONrilcXz61+LeX42uI1xf/NxP1zlePPEz+eiT35/PJxfp7GWVg+5ueL06ujHF4zFXN6Fyg3x18Y9CLl5vi6QespN8fXD9pAvJp4feUXJ0xfRTm8obh75I2CXqIc3lg5fE4mzj0OvEnQS5Wb4y8Tx9eTwi+Sbxq0mRR+ubS5evgWCeO00Hzp10nFOb6WOArn9dVS47F8Vyj38rdSD3+l+BXiraVt1INfpRx/tTi+rXgb8Zby14hfo7xueJzayZNfmxXnbeXJrwvaXj4pv14cXz8VK7yDejeIdxC/URzfMBX7jgm8k3L8TeIdxTuL4xulYt9F/GZxejfLdxXHdxPH3yKFNw/z7S7eVdojK+7he4p3F2+Vivu3KsffJt5TvHUq9r0SeG/l+D7i+OtSMe8l3jYV929X3lfcPfJ+4vj2YZxOqdj3U++OrLh3pzi9/llxDh8gTu8u5eb9tR53K+8r7a0efqD43eL3SO9Vb5A4vcHK4UOUu08+VHqfeoPFh0mHqzdceU7QEUFHKh+lfJg8+f1BRys3x7OfekB5J3nyB6Xwh6Rj1MOPTRgHPk58nNaD3njl+IfF8SMT+ATl+JwEPlE5fpJ4jvhw+cniw8UHyU8Rn6L8Eemj6k0Rv1f+MXH8gAQ+VTl+WgJ/XPl0+celM9TDPyE+XXxm0CeVm+OfEsfPCjpbuTn+Tq3PbPFZGr9bKub4zkHv0HTwORpnpvTprLiHf0Z8jviz0ltSJ+49l9CH907Ffm4Cf145/gXxueIvSvuk4h78JeUofJ56L4vPE++n6ecrxw9MxXyBOL1XlM/Xer6SdeL+Qk2Hf1V8gfgi+UGpE/PXlOMXJ/AlyvGviy8Wf0M6OBX37kvF+evi+KVS+DJx/JtBh6Xi3Bz/ljh+uTh+RdC35ZdLV6r3tvg74vh3xfGrxPGrg45NxX6VdHIq7q3S+OQsxxrlj6Riv0bL/Z74GvG1Qael4nytlP66oO8rN8evl36g3gZ58o3KzfGbgm5Wbo7/ULpFva3y5M+m4nyLxtkmvkV8bir2H4lvF6e3IyvOt0k/Vg//ifhOefJPlZvjd4njdwf9TLk5fo90iXqfyy9Rf1kC/0I5/EvlX4ivE8e/qXF2aTr8XvH18nu1Xp8mrO8+5fivxPeL0/ta+T7pAfW+kT8gjv9WHH9Q+p1634gvD6/z7+XJf0jo/aj8e+lB9X4U/ynoIeXww8p/kv6sHv4X8cPiv0p/U+93cXp/KIcfUQ7/U7n75H8F/Vu5Of6foEeVm+OPBT2uHP6vcnN8rgr/Se4KcQ4/Sbk5Pk/QvMrhJys3x+cLml85vIBy+CnKCwY9VZxeIeXwwsrN8acFPV35GcrP+B95EXH8mUGLKjfHnxW0mHJ4ceXwEsrN8XzuUFKevJTGYfrSyktI+ZyDXhn14WWVlwtaXpxeSjk8rdwcnxHHZwWtoByerRxeUbk5vpI4/uyglZXDqyiHc36EnPMOVTWde+TnSOHVglZXDq+h3BxfM2gt5eb4KeH838RMnMNR+rWV46cGP1nTTdX052qc8+TPV+/8/5HXEcdz3oveBcrriHM+DF9VvJr6NTVfzsedp/WCXyiOnxUenxmZOJ+lxxc+Q8/TRXqe8XXF6yqvF7S+cngD5fCLlZvjGwYdk4lz+AOZeByP20jzx18ijm8s3kSc3qXK4ZeJ02uq/FJpM/Xwl4s3FW8uTSX0WqiHb5kwDvyKoK3kPR28fMJ0V0pLJfRaJ/ThbaTFE3pXJfThV4vjeR8+Xf5qTd9WHH+NOL5wQr+devhC4teKt5Nepx6+vTj+evFrxTuI428Qx58qT/9GcXzHoPmVd1Svkzj+JvGO4p2D5lXeWb0u4vibxTuLdw2aW3lX9bqJ428R7yrePSj/J3QVp9dDHN9TvLs4//fgbxW/TZwevJdyfG/xW8X5v41+H+X428V7i/N/Ib5vAu+nHH+HeF/xO8Xx/J+Kwg/J9xcfIE7vLvEB0rvVww8Uv0v8Hin8XnH8IC3HPeIonxv0F2ccPp9gfu+k4nywOL0hyuFDxendpxw+TPkQ6XD18Dniw8RHSEeqN0qc3v3K4aOVwx9Q7j75g9KH1BstPkY6Vr1x4vTGK4c/rBw+Qbn75BODTlJujp8cdIpy+CPKzfGPiuMfCzpVuTme/fg05fDHxaeJ43m/ma7cfIZy/BPi+JkJ/Enl+KfEZ4qzHrPEmX62cvgc5fCnlZs/oxz/rPizyp8LOlf5c9Ln1cO/ID5X/EVx/EtB5yk3x78sjp+t5Z4nTm9+Al+gfL74K+L4h+UXJvBXleMXiS8Uf00cP169xcpfE18ijh8n/3oCf0M5fqn46+LLxPFjpfD7Nf2bypeJj5J/K4EvV45fIf6W+Nvi+JFS+H3yKxP4O8rx74rjV4mvFB8qha8Oukb5aul76q0RXyuOHyyFr5Ou1XjrPN9UrPD31Vsvjl+fOjH/QPlqcz0OG5R/IL5RHL8JnorzTeptFt8k/iH9VJyb47dI4VuDblO+VVolHfc+Un+btFI67m1Lxd755tSJ589ybpfWSJ+4t1m9HfLkHyuHfyJOb6dyczzP36fq75RuUO9T8V3Sd9XD7xbHf5YwPrxe+j9tkI4508PxTdKxwvdId2v5dmm9PhfHr9Jysnw8fmjtwHl+dojzPPN88Lxu1HLsFF+t5aHHdv+eeqvUX631WqXHgf32HvEvxOmtUA7/UnyFePN0nLdOx5zeXuXmeN7/9imHfyVOb79yc/xS8a81Hb5tOuYHlDP9N8rhbyiHfyvuHvnBoN8pPyj9Xj38D+I/yv8gjr8uHXP81wnjHdD0zP+noIeU/yQ9rB6+czrmePKfpfBfpPPTcQ//q6bHd1X/F43/mzh+gZbvd+V/yP8ujj8S9E/lR6R/qYf/W/xP8X+kR9U7Jk7vuHKP8696+FzZMT8unlt6kvrwPMpPEs8rPVk9fL6EceCsHz5/Ai+gHH+KeH7xguL4o3rc4Tz/TL8wHecFxXl9sTyL0vH0y9Ixp/eWfD7xfHoc30nHOXyNfF5x/KlSOP+Xo3CeZ14PhcTziPN/PL5wAs+lvLD4aVL+Py4sv0Achb+k13MuLS+e7cbzhZ+eHeuiCifu/Z3Qh5+RHeti9XkfWqw+28sxbc94XtdHtRws1z/ifyUsD9zvc3D2g8yH7eRP5exXeb9he/F+md5h9Tuk/1Pevw4p/17z+0vc79ffan15/+T9nfdXOO+zPk65KiwXx0EcfzUNnOM7jtc4nuP/fI6nvlRvn3I+p1iqHM7xy371lmh96S0WXyLO69mvb7az07Rdwfk8i+2MnM/R2O7ZLumxn2H/QY/PD9k/0Sui/Ra9M7PjHF5UnN5Z2XFuji8WtLjyYtIS6uFLihcXLyUtrV4ZcXpllXuccuqVFS8vjk9J4emgGeXwLOXm+ApBOW+eJU4vWxzPeXB4RXF6lZRnS8uphy8pXkn8bGll9TiPUFk9Pocn9zgl1Kus5ff6kHP+vpOm4zxHFT0vPN5Vs+M8S8r1DlXVh58jjq8mhVcPWkM5vKby6lKuE6FXS314beU1pVzPQu9c9eHnKa8t5foa9/DnB60jznVCddQjv0DjnS+Ov1Acf5E4vq58PfG64vWltRJ6DdTDXyyOr5HAGypvJE7vEvFG0sbq4ZuI4y8Vx1dJ4JcpbypOr5k4vcuVN5U2Ue9y8ebSFuq1lG8hvUI9fCvxluJXiuNbB22jvLX0KvXaiPN4XC3O9G2Vw68Rp9dOeVvpterhrxNvJ95eer16RcXpbUjHeXuNuzEdc5ang3r4zekT8xuU3yhOr2N2nMM7idNrpRx+k3gr8c7Ku4jTu1m5OZ7Xa1fl8G7i9G5Rbo7vLo7vEbSn8h7SW9XD3ybeU7yXtLd6fcTp3a7c4/RVD99P/HbxO6R3qtdfnN4A5fC7lMPvFqc3UPk94vcqxw8SH6S8ari+uUYm5owLx9fOxAq/MBPrQC3nXfJeD/KLM7HC+yWsxwApvL/8YPEh8kPVG6ocfp9y/DDxoeLDg+bIF8icOB+h5RyewPEjg46SJ79T040Ux/eRwu9PmM/9UvhocTz7m97Ku2n6BzTdaPEu8kz3YNCHlD8oHaPeQ+JjxfHjpPDx4vjO4p21XJ3Vf1h6o3rwCcrhE5XjJ4lPEJ8svUG9D9MxpzdFucd5RL0p4o+K47enY0//MfXwO9Jxb6py/DRx/OPij4l/ko79dPHp6s8I+oT6M6Q/p+MefqamR+FPSp9S7/N0zOntS8e5x5ml3kxx98hnB/0mHeezpd+l495sjXNIyz094XEk3xX6PJ48/nOkv6j3Rzrm9J5W7nGmqYd/Rvxp8WelR9Jx72g65vSeU+5x5qqHf178OfEXpMfSce+kTMxf0PQvavq8mdi/KI7Pn4kVzn43R70xGo/5j5XCXxLHT5Sfl8DnKsc/Iz5PfKo4fpKWb67m94w4zyuvY15fc9SfljAfvPe77E/ZT09Sb7Iej3kad7zyh8XHKvfzRp6jnPdj3g95v+X9coR6o8RzlHO85eMqjtMqZuIevqD42Zl4usHieI6fOd5jfkOU0/fxKT2OwzjO5biX/wsaZuK8rzj+0kys8NuU41/W/Dnu8/9RHKf11niM30vjkd8qjp8fdIFyc/wr4viFQV9Vbo5fFPQ15fCWmTiHL1a+SPkS9RaLvy6Of0MKXypdltCHvxn0ikycw99Sbo5fHrRNJs7N8QN5fWdiv1zTrciOe8s13xXyy8RXiL8tHZSJe0Mycb5S06/U9PTh70jh74rjV0lzMnEPvlo5fI3y1eLvieNHZGJPf616+HVB31dujl8vjud7zh8oh9Pj+8dwxm2m3gZxL88HWt73xEdl4vXcoPXYKE5vk3L4ZvFN4vgPpVvUw29N4NuU4y8U3ypeR+uzVRzl+9n0PtJ8WI7t4h9Jd6iH/1h8u/gn0osSejvVw38qjq8nXk855112Bd2t/DNxenuU75LuVG+POO9Ln2ucPeL4L6Rfqoffm8C7K8c3F98r3li8sZYXz+O4W/NleXvIs17ztbx7Nf7uhPnxOPM88bjyOnlFnNfhQvWWiO8Qx+/T9ov/KCH/Kuh+5eZ43jeWqr9fy+H5sZ2wPW5Xb4uWC92k+X8lzvvDu8rh7J/Yn2yUwjdoOsZfq/HJeZ9bqfnS4315v3pLxelxnLRPPfgS5Rx3cVzEcRzHfxzvNQt8ocZZpJzjTB9f8vr065Xtge3jsjAOx70+3uU42fsHONsdx+Ocf+mpnP2B9xec32mhcbppPDyfv94s30Xcn2v6/BafV3L+6wZxPm/kfBrn4Tj/d6VyczznNTnvyHlPnwclLy2Fc33T1ZqO64y+Vl5GmlLvKvXN8ZdJ4Vy30lrrzfpyvrGjcs4H3qReV+W8Hjgf7fPo3dVrrn4zTddM6+fz/1wfwPn8xhoXzvUMDdTjugOuf7hEvJpyxrlY4+2W93EG+2Mfx3A8xn6a60G4XsXXo/g6mFrqM30N5fW1HtXU47ogri9qp+uV6PO48DxkxPG83nzdG9eLpcXLKS+r6b1dsB2xvZXUOKXEuR6M68P4Pja8mMZjuy2unOsY+Z4223lRTbc+/Z8WUc51lkXUY1yus2R8vl/N963nKmc9fN0k3N9jZ5zZUr5vPUt+ijj+KfEnNL8nxWco57o6ONfX8b1+vs/v+xQwX9//gPsk9JC/LYEfyI7zyeKPin+THecovJeWb4qWc5I4j+9EjT9ZfXq+/8QETYd/SByFc/8avuc+XuPzvfVxyvF8v3yslmOM5o8+qPni+yXwB5Tjc8SZP99j5z4hfG99lHI83y8fqfFHaD4o91+5Qwr3fXDgQzQfvpfu+7/w/XK+L873vgeL8z1u7kszWPNlfgO1HHdrObkPD/fP6a/1osf9f3i8c9Tro5z7GfF6I2e7OKDtxNslnvs4Paac+0l1Uw6fppz7W3VRDp+unPttdVIO535fXC9Mr4M4Pa6nJue+Ze2Vm3M9sK8b5v3Y1//C20q5vtfX+3K9rq/f5fpbX68L5356XG9Lbs7nRf78iM/l+L+Pz+3gfM7H/QG5DyH3CWwizn1SGyvnPqnVlcPritNrpOXgfoncp5HPCemNzsS8gcZlPr6vJPelbCg/IRNzPDn3weQ+n9yXk/t0+v6Xvr9qdT0OlZVnazzuA8r9Qbkv7LW63+s5Gg/O/Wf5fbqzxb/NjnMUfjA79t+JHxT37yvxu3XuMR735eV+wN+J83tMcHqllcOztF6V9Ljw+Pp+vrxuK0h5nfs+wozP/MpqPTKaPqVxyos3F+d+l2W0vuXE6ZUSLy7OfS+LKW8jzv0sff9p7lNdUgrnd6e+D48LvzfF/bAnKuf3pX4I/segP8mTP6L+IXEUfli9n8UPi/N7Tr+IM/2v2XF+SJ78N+nv6v2u/A9x/BHxI1ouPL83Zf6ncvxf4vi/E/g/yvFHxf8W5/ec8MfEj6l/POi/6h+X5qoY9/C5xVH4SdI86vO7TnnU4/eMyOF5lcNPFs+rfj718PnFTxbn95P4PSM8eYGKcQ7n9ycKaLzPNV4BjXOKevy+xSnq5dN88osXVI7CTw1aSL6gOD63OL6w9DT1+B2K09Q7Xbk5ntfZGcrhRcTpnancHF806FnK4cWUw9kei4kXV5+8hHI4+50S4uw3/tB8Smo88lLK4fzOBJxe6Ypxbo5nf1lGOfz/AMhFFEZ4nHWcd9iW89/HS0M7ZN6/+7qv+1rZW0QpInumoSIkqyVJRApFaWgPaSlK0k5Dm2io0FSErFBka8lzHI/3+4/P63A//7yO9/h+z+95Xufqfn7OEpli//9/ebl/+T8xXyyRiX4Cuf0C5PStf8tG33q3+BNy+wnM514S26VvvUs8MhPzXZjffjn1KmWiZl46E8db52Ndx4t/p//lcdDH5qJvfUD50dBH5aJfRTxCPJSN/SNzcZz1r8orS+9NR9+94t5vsaRYSSwvVoD/UzrmHl8a8xSHPkysiLwY9rMY9reEj6v0P9monY9Px3EHRR/HA9DOj0G+T9yL3P6fyP8SfxdPyMWefV8Xvm5+lf5D/AXXjft7cL77/P9RPErnp6+DfjoOlXB+O68sHiFWEW8WK6JXFteL571FrIBx5eE3gN9ELIPrrRx89w6Hb32bWArz+P7m69W9kuhb3yEehvHFcB91rzj61s3Ff9JxvO8Hvl+4dygd+9b3KD+YjuMP4L7i3v507O/Dde5x+zH/X+jvxbj71fszHfut5P+Rjrl1W+W/Y97fcB8yf8H9yvcZ+77feL494s9ie23vR+Qe9z3uV53U352O46wfU74w+S93yf8B85nfYX7rb8Uy8ndKL9C830iXzcX+l+mYu/+19FfpqD8G7b+lcZ9hO55/u/iJuA3cIu4Qt2L73l6h5t1UhG89PxmZysXeRoxznkaeQj4zGXtzk9F3z/uzGfu1A/5arMPb9f5tSEff252UjHka65+RjL0PsN310B9gPevEj8Q1oP0xmn819s/zvKT8fYxfhb7Hf4F8hbgyHed5D7T/YjKOe9fnp7jU5znyBciXiIvFd8RF0N2T0V+I+ZZg+9ye/fni59BzxDfFz6BniTPE6fBL5aI/TZwpdtT6p0pPEqeIr4uvwZ8EfyLm93uS/VfF8cjtjxP9nuXe/mzMR4ottO7R0i/79xdHiWN9HmI+zzMCvnt+P3I+HPMNw/aGij9nY9/a+RBxMHL6g5BbDxD9PtYfuqjc73N+X3tB9Pvc8Zno9xX7pGNOv5d4XCbq58U8+T9ko99TfE5sAr+7mNF5crv0s2IP8Wn0u2Gc9ZPwTftZ+NY5sRnG50D3m6vXW3wG67R+SuyCdXfBes3OWKf1/UX4TyC37gi/q9hJfFwcKD6G3PM8ivnc6yA+Av9h5Na+jh4Cx4jtxLZie/FBsbXYCr2O8B/AfneE7+Pn/F741v59r9H9527pe8Q7xBzOhzvFu3z/EqvmYk7f+opkZJ1k7F2SjPNUxXnr9Xh9vp4y6DXFdeleE/hN4d8qfp+NtN9IrC82FC/Suk/MxF4D8WboeuJN4imZ2KuWifkN4vXieZn/9q8TL8hE2j8xF33rsalI+5di3rqYx7RfR7zR55d4rXgV/PN13G6Bvgbb8/avxHacXy5eIl4m1sB6Pc77VVusJb6SiuMuxrw1MP9FPq/F6ljPhf49xDPEq72/GOdeNfEs6HPgXwB9BrZrfZpYE/oU8WTk9k/E8XFvQir67lVFTj8rvpaKtH9SLvJ19ArT0Wff86TSse+cfoE4WfMlpJNiFTEtHgn/CDFfPAp+ZeT58D/Udk/ORe3c/oZUzE+B755ZMR17O1Kxb9/bqYjtVcL+VkCvPOb/CvOWx7iMWE78OhV7ZcWcWAZ956Ux/iTpwzHO+lSxFHQJ+D9pvpLSh4mni8UxznkxjD9T+p9UHOfe3/L3iGfLP5SK46zfKPiXB6EnwjftH0jF7f2C7Xo91l7/DzgO9Hci/076e/HHVPStt4vfYrzn8+/q3L+vz6vy+N153vn8/kb8XPwS+RfiRvS+wzq3Y/0P67h+Jv2JuFXcDL0F2/kCvQ1Y10b4H+F6N9eJvo9Yr4Fv/b54jPzj0tFfJealo14hLoF+VzxVx3+Z9LZE9E9DviURffacnw7feqnmWZiK2vkZuZjbPxM5fevN2v5Z6Lu3Hrn9s3PRd8/+Ocitzy3CPw/5ufCrwa+G9bp3PvJq8BekYv8C5OfDn69+dfgef2Eu5vYvQm6/Bnz3aiKnb+3jdTHyc6CdL0hE35rrsK4FXRu+9SXwrS+FXwt+HfEy5PStL4dvfQFof65+r7rw64BX5GLP+kr4deFPT0XOwfY8z1UYZ301/CvhT0vF/jXIra+FfzX8KanYvw659fXwr4X/RirqG4rwx6ViPioV/eux3VHwb0Tudd+E3P7N8N2rh5y+9S1ifeT0rRuIDZHTt/b5PiMR++x5fp830xNxPfXhNypivd4vnzeNcBx4XJwP0+9wK7TzxrmY25+SiHkj9OwP0nx9UlE3xnqGy78ReiR80/512P9rcBxugfZxbgDt+4KvZ983fF37PuX7kO/3l2I+z+P7YUP0ZiWi796biah9n52biJr37VpYT3Ws0/dHPz/8HPLzws/ri+E3ge/eh4mYc7z9RXhv8HP7DNDPZ7+/+L3L71tvi34v8vuP368WF/He9pb4v3TsLcJ7lLfrdSyA7/cBvwcswPzzxOP9dwn/bqk4zr030fd55vPO42bj+TId42eJJ6SjnikejX/n25+K+WZge34eTUPPzxc/V5x7fs/rvyf4OeLnhMdNSkXfzwv/XcLj/XeOVzHOfecTRf5dxX+H8d9f/Pct/91mAub3vONTsf+y6L+Xuefnmvv++6H/vuZxY0T/3dE9j/dzcDTud/Z9fxuB+V4Sh4pnZ2LP8/g++qI4DL7vv3wODJYegO0MRm8QfN7v+4v9xIFF+C+IZ2k/amWi3xvz9sU8rydi7ufLpETM7T/v8yET52+qvKd0L59PiZj3Qt/5bbnI23OxdzvyZvCte2j+Z1JRN0NveCL2RiWi3wzbGwOf6/J+PyderOPj43U71uf+s2LNTBzfTVydjb3u2C+v/2nf/7NxvPenK/pPie9k4/il2Zg/Cd/6CbGzOETbeUy6k7g4G/v2HxcXKX9UuiPyh8SbkLeD715b8UGxvdga49rAvyMX83bwb5Z+AH5r+E2Rm/briy0xzvPcL96G3P6dyFvAvx++9b1ic/Tdu0u82+sH7VcTL/R1JZ4P7fxWrNfbvR3755zHybox5ve8TZA3EhuA9dGz9u/q3+kW6YZiPeir4bfDPDxPrW8UrxcXZKN/nXgD5nf/Woyrh/V4/DXi3GwcZ/9KcVY27tdVmM+5+1eIl4tTs9G/THwjG3uXinXEutjeJejVwny1xYt9XWdj79FszC/CvDXEmjhvLkReHfNdBP8C5L4OeN77OjkP10vHRPTdaw/fPfvnYr6zsZ5zxIfVv1Pn8Vm+rqGdP5SIuf3TU7HfPBd7zXP/nd+N8fZbILc+LfXf/j3I7d+L3LpRIvpVU1E7L0zF3L7nb5qI89pvk4h5CxyHNjiO1s79e50pngGeKj6m8+p0HBcfh9OwXydj/CmYh8fjZPROEk8Ec+KT2Tjexy8rlkM/I6bF+3LRty5fRL8AvRS2V4iexyXhH4l5TPsVxSPEKmJl8VixEvxi8I/FfOWL2M9y2F/rMmIXHeey0hXE0ugdLj6Vjb0S6LtXSiwJHia+lo3jvV/Fsb/Fkf9TGHMfh78L4/yHCqN/UHzV/32J9H7xgLgP/vGa7y/Ms7cw+n+K4/zfl0j/Lv4h/or+b/B/EUf4fy+Zjf4e8QdxbDb6u8WfxJN0P/hR+ntxlzgY/o/g38nY24ntfyd+JY7Jxp618y/FHeLX4hfi5+Jn6I/ORv8TcRty+1vEF7OxNyQb803iBnGzuFXcKA7Oxr7zxRj/obhe/Ej8APO51yQb83Viw2zUa8D3xUbZqFeJVeSvlF4trhVXiOWzcdxK9N4T30V/BfzlyEtlo79MfAfzvi0uLYzjliH3cV4i+vgvQm79sfiWuFBcgO1ZzxfLaPufSs/DPO7NEWeK28W5GDdWfBO5x8/CPNPFstnoTxNniJPQnyr+nol6ivhrJuo3xN8ykfZboDdZvA/r8TpeF2eLE5HbH4f8NXECtjMZfkuMfwXzvIzc2/NxH4uetX+P0eIYcZQ4XvT96SX03RuJ/gjx/lzMR8J/WPpFzP8t5umIcc6HYfxwsa/YS/xGHIpx1r7/D4EeDH+A2EccBO38BWzf6+ktPg/dTyyH3H5P8Wmxq9gZ27HfEflj8H3c+fvYf7Aw+tZtRJ+PE+D7+piMHq8n95qLvv5awL9D/EX5nkz0m4KNC2OvofTuTMy/QV4PvEn8KhP1DeKOTNTXiFeBdcXPM1HXEbdnoq4t1gQvEj/NRF1d3JKJtH8ecuuzwTPEjZmoTxY/kr8+E/2qYEbckIy0Xyg+kIs5feuE2DIXc/ubktF3r1Uu5vStW/vfjchbg23Rs34Qfhv47cBPkv/de6iIvv3tGleiMPoe3z4Xc/rWD4ulC2NuvwNy+48gfxhsi94j8DvCtz66MPrW3k6FwrieDtjPL3RceDzaYn0d4beGb32c5vXv5POhDXo+f/LU34T+JzjvfL667+20xjze/45YTwccnyPFisjtVxJ7iOXFCuh7/LNiOfT9/CmDvKx4OObtL5bCOPdKo19S9HlYGn4J5IdJf4Hr4VHkxcS9yZgXQ39HMo7zuv+RXxzzHUzGeQfKP5SM4/zvxkP496N9//vygHRO/07dn4y+t7cP2/0T+0X/K+Q74bv3fTLmv4m/i3+IfyXj+n5FL5OIvns/+79P9v9/Khd1Av4vWJfX43wP5j0hEX33dkl3kv4hGWn/G+h1+dG3dv54LupP86Pv7X6KcTuxX99iPd/A/wq/y9f4PZ3z/LXmfdHaz5H3tb7PpD8Xfd/y88f9beIm9LZ6f8WPxc0YtwV6M+bze4Cf4/bX+783K4y9DZmYrxM/EjeKH5qZ2FsLrkFvtfNMzFcjX+X/7ltcmYn+cvjurcjE/G341svgWy8FF/n8V2+J9BxxMXL3/f0Hf7fBegHo7yz4uwv+voG/e+Dcvr9P4O8SzMM6vC6v8034s+G/I87E/LPg+/sD/h6B55kmThdfR38qtHN/x2Ciz7t09K2dTxBf8fmUjv7LPk/TsTdOHKXrciz0E7noe7zn8/cQ3BudjP3O8N17Mhdz+y/mx5z9Lhhn3RV+V+RPwbcepXUNT0b9FHpP52LvGfjudcvF3H7//Oh3g98N6+2O3P7Q/Jg/ie31yI/r6psf/WewnW5YZxfM272I4+rfc6TvYzovfD50xfF1/yX0Pd7fs3Du71qMwO8yHPkw0d/F8H4PRd/+c/kxH+z7ZTrO596QZOwPQt/jl6VjPkAcmIzz9Aftd8+P43qLvbwe34/S0X9e7CP2FPuJPeC3y49+P/itkHu73bH9btLPivdpnL8L4v4zPh+SMaffBfmT0vPSMZ+LvDN868d9v/H1LDbVOmenY6+T7+fpqB+Fb90RfFh8Q71H/NwTOyB3v52Po//dLd1ebJgfc/sPYVyJZKT9QwVRN8iP/oNYl9czOR3zNmJbbL8k+u619nMpHXUrP6fSUd8n3oOcfgvk/h6K/bvFe8W7xObiHejd6d8hHfPbxVvFRvDbpKPfUGws1hcbiPXQu0VsmY75jeINyO3fl475dWJGvFa8Hrm/3+DvNvg7Dvav8vFNR+3vL5wo1hWvFC8X66Bv/zLkpr/f4O82XCx9qXiuf5907NcWa4m3paPfOB3zmmIN5Pb9PQZ/n8G9C/07pmPP3x9wfoHI7xPQr+bjrPw86erY33OgfTzOwjxnwz/T2/P86eifLs4oiPnp2O5p4hkYdwrGn4q+x9v3eXIy9Inwq4qF4knQbxZEP4d5fB5eLWbR8/WQQZ6Cf5OYxvarop8Qk+Jira9AemlBnO9/GOc8X/oE8WYxD+OOg3+beDzGe75jxedyMT8Bfg/k1l6fez3R7wH/7YKoPe558Zhk1JzX/rsFUfcqwu+N3LoP/F7w+8K3fq8g9l5A3hd+P/jWKwtirz/yfvAHwLdeVRBpfx30QPj94Q/A9gYhtx4MfyD8DwuiHlKEf6Ag5sWS0R+M7Tq3PxR5f/jFkzEvnYy+e8OQ07d+ARyK7fbBOPcqJ6PfG/7hyPugZ/+oZPR9fvv6PhrXv6/rY3Adu18F49w7CtdfE+kjMc69SlhXM+kjMM7vVRWRe3xlzFMBx8f5A2J5zGe/HHLrlmLZZJy/DLZj+nzw8fc4v7+Wgvb7rd+ni2Oew+D7fPb56XF+z/6nIGq/h//t73AUxHkOwt+P68v6J/im/eHwrT/CvPswn9f1l7gXfv38mFvfCN/z/izugb8H2zV3Y/2m/fXij+Kv4i7oH4rwv0P+qfi9uEP8XdyJcXW1n18i/1r8XPxCfFHr/wx5jfyY14R2PkK6NuYbAbr/Enzriwsi7V+YH2m/uv9ej+3WxnHz8dqO4+h8m/iJv48iXiJuxTj3dyPfgt9/N/wPxA3iJtHnu88jj/dzbAiuCz8Hna/DfGuxvbXIrxHX4Hm+Dtr5++IKcbU4SPT7hd8XPN7vL34fcc/vTX7fcc/vXc79/vYOtHO/79lfAi5Fz++h9v1ebPp9+S1xPnr25yCfK/rfA34/d8//PnA+S5yJ3L7/PePc/66ZLvrfR/bPTcd8qjgFOX1/h8nfaZosPU18HZwtThInYp7X4E8Q/R0nj3tFfBV6njhefBnzjIM/VvxD8+9PRX+0+HxBzEdjOyPFMei710tc4PsSxjkfJfYRF/q+hHEjfL2jv0gchnHuDRFfEJeJQzFuMPzluF6dr4Dv63ogttcf2x0O3Qf7ZT0K9HHyce2B38XH/VlxXyr2uiHvLj4tPiPeJu5NxXFPiV2Q2+8s/pmKvSfE31Kx93Mq5o+JnZDbf1TclYq9R8Tdqdhrj7yD2E7097wegv+g+Knma4teG7Gj2BrzWz8utgSfFB8Q7/H1oPvsff7doZ3btz4O/SoFcdxo9Lk95ydgXS3Ee8XmmM/zdBXvxri74DfD+dYM+Z2Yn9tz/j/M73nuKGI7t4E+z5uIz4m34rpIiU3FrNhTbIjxzhuLVcXeYgOMc95IPEnsK96CcfXFeuj3E2/GOPduEk8WB4g3Ypx7N4inir6fXY9x7l0rno7+dRhn7fcpv0f5veoq+BvFK5BvFusivwz+x/CtL4W+BL6132P9PjwC79n2/V59Xn7Mq0nXKIh5DeSngfbP9Xu7+jXFiwqiX12sJdaBf754OXQ18Uroc8VzkNu/GvlZ4pnI7V+L3OfJDdA+326C9nlbD9rnf33oRqCvs8agr9emoK/728Gk6PuM70O+LyVE30d933LP9+mRuN8eK47C/bwK/GPhHyX6Pn8ktPPK4v3oVRJboVdBfBC98vArwC8nbtNzs6z04WIZ6IpiKfAIsaR4tHgY/OJiMbGEeEj/+73SyA8mYv63uM//O8lE7O1NxP1y/qf4cSr2fkP+h/iz+Lu4Lu9f/iq9KRXH/yKuT8XebuR7xA9SMf9B/B45/W/Ftcp3Sn8n7kpE/yfxPa3/G+nVqTjfylTMv/K4VNQ7xOWpqD8X30lFvV38FLn9bfDd24rvkrq3Bf5W+P4eqL8PukHa3/10vh6+e/4+mL8L5t4H+G7Yh/CXILe/Fvkan0/iR/49kG8SJ+fF3P4qjHNvjLa/3L+fOBS5feuxGGf/ZeTW4+CPhT8evvXbidh7Bfl4+K/Ct16aiL0JyF+FPxG+9eJE7L2GfCL8SfCtFyZi73Xk1pPhW89L/Lf/BvIp8N2bCt+9acjtT0dufwbyKVj/jCL63fPiOOun4Zv2p2EdM7Fe61nwrWfDfxO+e3OQ25+LnP485Nbz4Vu/BX9qIvrzwQXomfbfgPa4hRhvPdnXRSLqhViftzMtEeedh/msF8G3Hp/4b38x8iXw3Vuai7n9ZfCXgm+jtwz+O2DHvNizXo7x70I775AX8+XY3ntFbNd+l7yoPc7n2Uz07T+FcTMx3sdjHta/pIj9WoHc/krkK+CvAhejNy4RffdWI+c876NnPTIRfWvnD+TF9bXMi/lKzLcK+9se41dgv3je+bz0cfbv8zZ8X1++z/C+43ym9mc28tnyZ2I7vi/5Punzwj3P4/s/nwfO52h+3899H/dzxL6fYzNA+2vEHnkxX4PeBPhr4PfKi/oV+NZ+X+idF7XfR/rKH5IXfb7HOO/n69nvn34PFv3e4veV5egt8/ko+v3E7yUetxZ9vwf6PcTvHx7n7876PdJ9v2/4PcPj/D10f7/W4/0e8VYijnN/vujv8brv94y30JuLvns+v+ag5+8B10bu83A2ev6u8CXMcb245+9SN0Tu62saev7+tL9H7e8/+7vPzj3Oz0f3/B3Oxhjv56+fs35ev4bnr5/HE339oWff3+H09zn93Uv7L2O+VzHPeOR+Lvu+Ng69sYno+37r7fh7m16H89EY756/39kMPd7HR4gviQPF+/Oifgl+c+TDsd0XRX9n0/lQbHeQOEz0dzO7pGLf39F0PhjzDMR8Xl9/5APEfpjH+gXR39/skIp+n0T0rXuDPUV/b9O6h+jvcrZKRf858FnxPv//k6SfRt5VvCcVc/tdkHeWfgL5MTpuj0o/jl4n/x6iv8/3fx16GmN4nHWdedRV8//FG5TmUD3d+5zn3tt0bxMNhsjsaw6FEElFIyFNRCVDyEyUIZIhX6lMX/PXmJREiqikNNBASqVSSr+1fvb+rvV+rZ7+2Wu/9v58zrnnnjs855x76lG/zP//G5r5R6+T9pcOgXd+QPE/eq38YOlA6CDpIVrOAPnu+Zhfmo/51dJrSlkP9927Snox/BXQruh1Rd5XeqW0j/RyeOdltR2qF0fv3LwM8m5YXm/Mtycdl9dT+qf4ZfJf5qN3bt2c3nvPfj36Xs72dFyvHpm43t3he+DxdMP2vcTPm7QL/C/pyPn8dJZe6O2Vjz17552k50vr1Y/8POkF0ovQ7yjNady5GLcuHXvnSDtIz5KeLW0Pfqa0dv3oT5dmxOfmoz8dvVMzsWc1P6mU+Y7DPF7+adIzsN7tsDyP+zEd+SlY7gLlJ8qfjPwErL/9ceDH43E4P0Zap37s2Ts/WnqkNF0/8rbSo6THSo/w+xfGt0XvcGkb6Vd63IfCl2QiPwzze3kl9SNvJW2J3DypH/ODpAdK/6i3d95c+nu96JtIN4g3k28hbSpdXy/2G0Pz0r9ycVwjaQG9htKd6reWb4Bx7tWTblb/YL9uMS4jrY/cz0MJeLF0aD6ON08jt09JN2p9EvkiaV3pjHTkWb8fYJ464D+V/KOrpCulP0tXQB+RLocfD26/CHwZlvcj+FLk9j9If8tFv0R6Qz76eeDfyy+WLpR+C/8d+LxSlmP+FXQuevZfeLtq/b+Uf0n6OXpz/HyovywX+WzpLG/nXOQzpZ9JX5F+Kp2B8fYf+3Frvunyn0j/I/3IjzsXx83JxfyDkjjPf6UfIn/f66vx73l9czGfjvXwfO6/K31H+rb05dze+ZvSqcrfkJ+Wi/mUkpi/Kn0L6/O69DVwbz8/L6+g9zK4n7eXkHs/8f4zDb0pWL+p6P1b+iL6k6UvQJ93LxfHfyN9Dr1JHq/+pFzkz0qfwXjPN9G9XOw/jXF+nT6Fvsc/6X4u9iZgviekj0uH5eN4v3+NR/8x9D1+nHREPvYexTyPQDdIx0rHSEfl47zuPYz+Q+Cbwf+SPoj5H8By3Lsf/fukt+TjuPsx/z3o34txu+XvRr+MPo/uQm5/pz7f7vT86cjvwvJGS++A3i69WeszNhf5KC9Peqv0NvDR6Zh73C3errnYuxnzuXeT11v9+3KR3+j5Nc8I+ZHe//w85GL/FvWHl8RxN6A/DHwA8gHIh0ivL4nzD4Wa36T1GCwdJD5YOhDL9fzXlLIe/ZD3l15dEue/Cn5gOvIrMZ/nucL7Sy7mfaV90Ls1F3lv6eXSntJe0jOkPZCbn4P8Usx7mbQ7eudKu2JcN2kX7/e52LvYz1Mu9jr7ecrFnr3zi6AXeHurd6H8JdJO0vP9usrHcebnSXdn4zg/zo54/Ocg74B5zpaeJd2Wjb0zpe0x35nwfp5Ox3ztpGuyMT8VejJ69idKV4qfIL8qG3Pz46THSo+Rrs5Gbu/8aOmP2egf0/NwlPwR0vHih8u3lb6RRO+8DXr2h0oPkR4mPRi8lbQluP2B0oPgnTeTHpWNuXlT6ZHKD81G3lhaKIm5eetszBtJGyI3b5GNeX2vdzb6nNczG33G65WNPpHms9GnvT7Z6OtKG2SjryOtl42+ljSbjX5/aUk2+prS4mz01aWpbPRVpJWQm9fJxryitIK0XDbyfaT7SstCK0vLSP/W/ltefg+887XFUc2/yke/G9xqvr44+nn5yOeh/5d0fj7m5l+Dz4d+k4+9r8E3Fkdu/1tx7C1Abv4tcvvvwBeA/14cvcctRM9+c3HsLUJuvxjc/nvwheBLwJdgue79gNx+KfgS8K3F0S8D/xF8KXR5PvbsV4D/CL4Sar4K3P7P4rgeK8E9/ieMWwX+s/fT4pj/DC2XxJ7Hry6lb74G3H4tuH35JHr3KyXRrwO3/wXcav6rX8fwzn8rpbcB+XroOvQ2gG/06wm5+Sbk5PabpVuQb4b+gd4W8K3SbcjNtyMnt/8Tr6/t4DvAf0DueZajtwPL3wa+E/oXeva7SuG7kdv/Db4LfI+0TCHme6C/o1e2ELl75ZCTl0duvw94WfAK0orIK0D3Ra8iuPf3SuCcp3Ih9iqBVwG3rwqthp55deTVwGtI/bqtBl45iXkN5NWS2KsJzv5+hdirCb4/uP3+CVR8UBLHD0Lu5R6A5ewHPiSJfkQSeTU8Pq/Hvtiu3E7VsZyq8M6rlNIzH4n1qwzuXi3kteGd36RxFUrp1UG/Nrj9PuD2ReD2deFT4HXB09Bbktizr1XK+OJS5jFPwO1LpLcmMS+Bup+RZpGT2+fA7e/S8m5LYm7uXj1wq3l9qHkDcPuG0ruTmDeEut8I3D4vvTeJeR7qfgHcvrH0/iTmjaHuj0uib1IKb4rcvhm4fXPwJuCPaP4DwT3+oELMzVsgJ7dvCW7fCty+tfRg5OT2h0APRe9g8MPA7duAt8Hja4P+4dAj0GsD7u3XFpzzPJnEXlvwx5HbH4l5jsI486ORHwN/NLj9seD2LyZRj0PP3P3joebericgJ7f/l/RE5OYnISe3PwT8ZIx7N4n+ZPBT0H8L/O0k8lMLMT8Vj5d8ShLz15PI3XsvievHx38KttMpWK65n7/S9g/np0mfT6LnePMJ2A+8X/H14/3a+3Nz5OT2j2p+7x/HYn4/3879fnAIcvOTkLcGt38/if508Fbg7rUDbwVuf4b0TOTk9mdJ2yM374Dc/Gzk5PbnSM9FTm7fUdoAeUeo+y3B7f051wh5U4w/A+PqYT29/PPA3TsfOfkFyO07gXdCPiuJ3N7b+4skco/LICe/oJT17oTHZ98B/CPN2x75zCTm5hdiv2oPbv9hEvV09Lw/+fk6B3k7LKcdcs/XEvP4dePPcX9+8/uKP58PhPp9pjnm9/cZ7of2/n7m/bwjet6PzkXP34fPRy8D7p6/l/t7tb9n+3v83CSOLwZPwP13xkXSzsjJ7S+GdkGvM/hXSfQed4m0KzzzrzHe3nk3qHl36KXo2X+XRP5zErl7l2Gc5+2BnMvtil4P8J7g9r2kveF7Qvug1xu8L/S3ZO+9y0vpm18B3ZjsvdevlL75ldBNyd57V5XSN78auiWJPfP+yM2vQd4f3Ocn7AeAD0B/oHQn8oHQQej1A2f/mlIe91Wl5P0w3v5yLMd+MPggcB8/db8Pcvsh4IPBfbzV/tpS+HXI7YeCXwt+vfQG5NdDy6NXBO7eMOTkFyEfDj4MfBjWdzh8V6yXjz9fC14O+VDMfz3mc+7t2BPe270PcnO+D/2aRG5/GZbL5bnvnt/v1pTyPsvPB7+f+vNhOPLhyP08+PPHn2v8PPPnII/z+bicjwP6+LSPl/r4qY+z+zi6j/f7eKKPN1bAcpxzf7T387wL5xW24fyEe3uwv/yN8xx+Pdr7de3Xu73fl3bgfYzva859/tXnk7ZhfX2+x+ehfJ7S561GFGL+B/iN0J9K6fk8oXvmPo+2Buu1Cevt9dmIecvgefU4n88z5/mU39Cz937D840+H8nzh+uw/jfi8a4Gt+d2svf29/m3reB/Ivd5bp+/9nnnZei75/N93i92gPPz0z1//jr3dQMjCzE335pEPhLqnq9LuAm5+Xzk5juSyN3bnsR5nH+D+TyPr//wdRy+fsPXuezUfLtwXYmX7/mqqv9nEse5tx3rW83X0SVxnHtb8ThqqP9HEsdtwXb2uP3U35zEce5vwvexA9T/PYnj3PP3SX8PrK3+hiSOc8/fY/39s0j99Ukc554/p/w5llL/lySO8+eP++v8+aH+2iSOc74G40t8fV8Sx7nnvzP8uZdV/6ckjnNvFf4uqefrEZM4zr3l0oXSBuqvSOI4+7yvO4RflkRu30T5D0nU5uJL5JdKv5culi5CvhjrvQjrvwre22EB/n7j33PO/XfjN9LP/fpCPg9/b1rN/X3Cf1f7ewX5l/h73Gru4zpzsB6fQ7+Vzsa4z6Q8nmQ/E+NmSD+V+vn5BHkLPX8fI/8I805H/4MkjvPxHx8X8ngfH/VxnA8xz3+TOJ+Pu3rce1Afj/fxb49vrfnekfd1rG8mkXu8j9f7+LiP2/u4u4+3e/wbyF+T/kd6ZEnUV9GzP175K/C905FPlb4snQY+Betj7/MwPt7/gryP1zufjHn/ncT+8xjn3iT0n5PyPMHNhcifA38q2Xv+LHpPwzu/RX6i/DPg9l3Tkd+KceajkN8GPwp6O3q3gd8B7ZuKvdHg7t2JnNz+LnD7TunI78Z8/VLRO78qFb3H34P8TuQXpGPPviO41fzeQtSrU7E3KBW5e/ch5zznpGPvLmy328HtL0xHNed+4+evTyr2RqHP/df7u+d5Qn4iXgfu+Tyaz+v6PNsEzOP1eAL98VKfN/Z5M59HM/d1AT4O7p6vR/B1BO75egbnD0sfQE5uP0Z6P/ru+XoMX0fhnq/38HUa7vl6El8H4t5tyG+X+ri681HensjJff2Or6/x8QJzX6d0h/RGv28h93VQvC7K13Hxuq7hUl/fNQzz3yAdLe0Bfp30eulQzDccPXNerzZQ/lrpNdIB0qulg6HmLaQp5C0wb3/Mb3458v7gV0mv8P6l9b4yiWreCv4BcPsHS+FjkNs/BH5wEv1D6D8Mbj8W/CHwQ5PYH4d8LPgj0jZJzMntH4WaP+b3D+SPQcejZ39iEvnj4E8Uoh6F/pOYz8ubgNy8QxK5e08hJ7f39puI3PxpcPeeQU5u7+fvWeTkzyGfBO/8eeTm/wZ37wXk5PaTpb2TmE/Gek7GOL8e2fP4nv4+CX8J+CSs5wVJ5PZPo3dxEvPnsB7PYzt6Pj6v9h2wnPOSyL1fen9rh/3vrCRy799+HXk/9/7r190E+HHgE8G5/9iPAbf3+9r9yMn9fDr3+28/vA/3wfPucX4/74v3797oe3xP7G/u9cI8/tzz5+Bl4JeC3wl+j7SbtDv2w57odUXf/j5pF4z3fuj90r3O6HfGPBdJL4R/EPu15+8E7v3T+6vn6Sg9H975udJz4Lvo+2YHzH82Xgfez73fe54zpe3hnV+s+dthnjPw+nJ+kvRE5OTH4/PlNPkTpP9C7v6x0KPRsz8K/HC8rp2bt0Huz2Nzf763lR4iPUyaB2+Lcf7e4e8NrfE9xHkrcPeuRN5SejV8C+iB0rT0IGkzaXNpE/DGeFyN8fgaIffjbab9pb58Q2kDaU5aMFc/I1/P86ZiXg/js5inKXiJNJEWg6exfZz7+3AL9AYjL5LWQU5eC7l//zEIeXVpNfQqg1eR+nd2Po9VGbyC1L/rqypfUbovcvf3kfJ3geT+faJ/T7irOPIy6Dn37xl34PeP/D2kc/++cht+f2m+Fdy9LVL/3nQr+Gbk/l2tuX+Hu0n6h3Ru3X/Uv9t1j78Ptt8g5e+Y3fPvoJ3/Kl2H3HwtuHurpf59tnurwN0rVxLzFd6O0pXSn6XLpf59ufs/gru3JxPzJZhvKZb3g/RFbd9F/n0x5lsC73y3/Lfez+QXyi8Ad2++f7ctfUbL/1p+eyaOt3e+1fdN9H4iP0/+C+9P6Jl/jny296NMzDcgnyX9TDpH+qjWfybGuf9TJuYz/Hxnop8u/djPfybyD6UfoLcsE/k70reQm78B7t7r3m8ysfcauHuvSBdlYu9lcPemer/IxN406UvSV6Uj6sbc/AWMc2+Kf5efict7UTo7E3vTMN9k748YNwn8aeSzMpE/Je2l9Zoo/6z0CYxz/1HpzEzsTZA+Jn0c3vlD8KfWjfwx9B7Bcsdh+fZj/bjycfzDmGeM9Bgt9wH4FwuR34/5HyyOufv3wU8Bt3d+hJZ3r5+vfFwex90DPxV8KpbbRvPf7f0iH5fHcXfK3yV9Lh/H3+H3p3zsefzo4jjPaOSHaX1uR36w+G1+/eTj8pzfWhzHuz8K49xviXE3o38L+E1+X9A8M/OR3yg9UPOOkB+JfLj0E41vpv51xXGce9eiPyMf+WDpUOkg6RDpp/nYGyi9QToA4z7Lx96V0CvQs79cOicffV/peL0e+8j3k/aW1tV26AHeS3oZ5nsgE3l3aU/pJdJLkXeT3qvxXb1fZ2LueWrXjfN1kR5SHMffmYm8lbSNtLX3V/hm0pbSFpivFbzz0b4/sPdb308Y83n+5tITpE2RN/b+K20iLfj1kIm9HPKGmLeRNC89UdoAeX3p9KJ/NCtfD8tpCJ/x6zITfYlfR74PMLzzImla+n5R5PZVi+M8Ke+v0Dp+Xfk+wsVxfG2p78vvvu/PXws9j9tP6vvpu1/Tr6NM7Pl+9s59X/sa0v2l1bDcquDv6vFXQT5N79eVimP+dlHMzSth3BvqVURuXkF+H2ll+DJ4XOWk5aX7Sn1fft+n/2/5XpmY74buRM/z70rHeXZi3F/gOzCPve/X7/v3+77/vq//NukW+EnaPr/j/wng/xvg/DfoevR8H3/f19+57+vv3PfPXy31/fXN10jXSn+V/iz1/eg9fhnylZhnlfQn+Af0+B8siuOWY94fpL7f/VLpEvgV4PbfY57FUt8v/zt53x9/Ebxz309/pNb3C/lvcZ99976R+v709l9L50l933ryr5Dbz8X97H3/cvM50vnpuJ5fSj8H9+PxuNnpOO+n8M4/k87EuNngn0JnYD77T6S1xNeWRP6xdJb0I+l08CFFMbd/qRD5B9IDMnF+9z7EcswHFsXcav5yIWoH9F8Bd+/VQszJ7QcURW5/KfQ1jDd3vx96r6Bv3rUo5vZng/vxvI/t4u38Hrb3upLI34W+I/2lJPq3pb+LvyW/tSTmb0r/488p+VOLondu3qJo7/3XCzE/vSiO9/K8Pq97fuir/hzw9YbyNTMxN39JWt3HM+SnSV9OR968KOY1MnGeqehNwXzOJ0v3z0T/Avgz4M/CO39aOlFaObN3PkH6JHS89DHpI9Jx4A9LK2Zi/kedf/Qh+bHSMeg/DP6gtHwm+vulZcV9n23fX9v5vdIHpPdIN2t97gb3fbr/Nx+475Pt+2v7ftnmt6fjvLdJ7wDfWCfmHuf7Z/u+2e7divnc8/2zfd9s38/a3Pe1Xqd5RsrfjHyE1PfFth8Ofl1J5DdAr03Hnu+n7fta877X5gOk/aW+f7H5NR4vvRr9q6SnadyV6A1Br5/0FPWHyl+RjuPN3yjEfHGdyIdi3sulJ5XEXl8sx3xhnZh7fB/pv0pir1c69t3z9dK+frqn38+SmNs77yH1dcz2l0m7S7uB+zpiX1fsvIv3z0LsmV+EvLP8xdKv9Tjn1Im5ucdfiHl8na+vY3Vu7utwfZ1uR/Dz0pH7ulleR3u23ycKUc3fLEQdnIq961ORv4nxb2G81XxYKnqPay99G33zd8Dde7cQ87eh7dKxZ/9fjLeavwd9H70PwNn/EL2P4D8Et/8Y3H469BP0PkE+Q3pjKuYzsN6foOfxn6JvPxPcfhb4yFT0s6Ae9xm4/U2pqOaj5MeAe76xyLkc89Gp2J+Jx2luPxv5dPDZ4B9DP0fPflwqcnvnc6RfIJ+D/Ev07MenIrd3Plf6FfK5yOehZ/90KvL54PPA7b+WfoOc3H6B9Fvk5t8hN1+IfAF0EXr2i8EXgn8PXYLeEuQ/gNsvBbdfJv0RObn9cnD7FeD2K+FXgdv/BG7/Hfh3WE/2f0ZvNbh7v6YiXw2+BuPsvwVfC74G3H4ddD56v4C79yty8/XIzX8DXw9uv1qPcwNycvuNhai/F2LPflMpfDNy+y3gm8B/gX8mtXf+B/LN4Fuw3KWpmNsvBreaPyvdivn8OJdh+VuRbwS3X4l5N2B78Pnx87guFXP3f4Vuwvb0fvm/eZxjfvf8uvHrdTX8hlTk9s63Qc1XgNtvl/6JnNx+h3Qn8h3Qv9DbCb7Lz3sq5ua7kZPb/y3dg/xvaJnGsbcHvKx0eyrm5uWQk9uXl+6DvDy0Sjr2zCsgt5pXRG9f8IrgNTC+LPJyWN9dqbg+ZbE8594OfPxlML99JfB9wWumo5pX9vZArzLyquhVAa8Gbn9AOnr3q6NnXzsdvfs10LOvKW2NcTXR2w/c/tB05PuDu3cA8v2gtdCzrw1+ALi/v1jrlNJbjp7fL8zdK2occ3L7ulK/XxSBp5Cbp5HXhdZCLw1eDG6fQM1rYHlp9FLwlcHtS6QZ5OT2fn1k0XevDPIMvN8/Pa42tkNdPE5z70/eD7y/cf9znpMelo55DloPvfrg7jVoHHPyhsjtG4Hb58HzyAvSxsgL0Cbo2TcFbwz+f1IvDZ54nHWcZZAUZ9uF8UVCZnfHe0nwadxdgmtwoiSBCBHcWSR40MUJGtzdFncJ7u4ahxBCgutb9eWcr+o+Bfy56sj9dE9PT+8Wtc+UDif5v3+53P+YE8wB5nZtrj51HmFe6eUWP5/ojRHr5xO/ethqzm0VnV/8POLnlfMsIHlB0QWEhaRXWHQhYRHpURcVv7D4ByJWc64YWFz6xYRnI7ZHfVx8kv5h8JAcv7isz/PJKjwXsb0S4rOXTdbh9dqPnl5fXv8c0tf3bXvE9vPIHO8r3s+8L6vJ50B7zCtKj7osmFPm6PP4ETn/UsizQ7uu1cwzyXw2WaeI+LzOJURnAS9GbE7fLzn9zHJePJ+MMse+A0aDr4PpwDjx4yRPA6YGM4j/huRJwOc47zfFfwb/BXgvZPtPZY76CRiC/wg64Nq8JPRD6MfiU/8Tsus8kPXYvx+x690JWZ+9a9BXZb3r4AXwivQug5dAvt98H+mfl/vkovjnJKfm84bPAZ7HafAM+At4SvLfwROSH5f1T0r/mMzdAGeEbM51jspzT59/+pylf0DI55b+PKDP5xJ/LvG5RX8LuA3cKT71ZnATuFHWZb4e3AB+G7I+e2ulz94u/3+sjedPXbAO+Da4LmJ1TfF5fvT5c3w91q8KXUNyPm/5HGa/StjOsVdJns/L0C8PXQEsF7Z+TtFL/NYvK+u+Jc955qWFfG7zec7nJf1iYBmwBFgSLC5+Hvk5wPmiYBEwxrW+x7V5IbCg5OoXANO7lvQDYH6wMN8vOf884ucFc4NviM4iPl9/LlmP72NOyfn+5ZA8u6zP47lgVjCbaOalXKtn+62fVXqZRWcKWz+T5KVdq2f4rc8+dUbRZcQvI+tOlPWm+a2vc+Ph83q9Ke9LXtFxoCM5/ZDcV+wFxGcvCH6P8/BD++S+5Pxw9Lxh2x/ltzn9WPA1167rAdO6tvc6GOXaXirX5ul4fmA0jyN99tKCKVyrU9KXnP6zkPXZiwKTgclFM++J65FU8h7wu0hO/zmPCz9J2PrPJOf50X8KPgYfiM/fz+jz97RH4L/8PUj8+n6bc+4uz0t+/+LvY8zp8/cs/n5FfVt+/6L+S/xb0L9GbE7/puTVcd6/w/8TvAH+FrFzf7AXsb1yWOcX6CrQv/F4Mn87Yv2fwVKY+wn6Leii4rPHueuy7lW+DxGbXwGvgWVdqwv5rc91Lst6zC/Kum+Jz15Bv83pc91LvA8itnchZNfL67c+e/SPhWzOdc+D58Cz4JxX+OVcm58W/6z4pySnni/+fOmXh1/BtZp5BdEVXctKMk9d+RX+jpDNqRPFryI553eHrF9F1q8o89T7pX8yZH32Dot/Uq5DZblO1CvlepYXf4Ec55SsfwY8Dp6Q++iY5Idl/qj4B+R17JXXT38PuA88KP3dMsf8vs/O75T3hXOJ4m8Dt4Obwa2ib2H9TaKrutYn6VeTnLqk6AKhl/t/+Gx+02dzHmcj8nXgFiH9tcLV0tsm/iphovSoeV/x/lsk/jJwBbgGXC6kX921uoL4S2WOfg3J6ZMVQ7Y3VDRz+tRVQnZdnV8Ssq97mbx++vzczQMXgosl53ORn1t9Xs6VuSmyLv2ars3pj5Cc63NdPudngefEvxux+UyQ/79Bzf/nmAYekf//mApOB2dLf7LMzZbXy/lJ4vN1cf4HWWciny8Rm0+Q9bgO++NljvlImWdvnPTH8vkWsTn9MeBo8PuQXX+UvH8j5Tz5/g6THjXvX963CeAQcLgcn/4g8Dtwb8T6fcF+4ADxqeOF9BsI6dcC+4C95Tz2RKzfS9gT/DFiNf9fif/v1B16rfy/E/2ufD4h7wHdBewmrzde8oZgZ8npfyA5dTvxO8r5dBK/A9/HiJ3jOu3BD8G2ktNvLDl1c/Fby3HbiN+K9xvOJyFi/RayHtdvyfsuYnvNxKf+Rvg12J+f9zjrfylsGrI96s/5+YT/GfQX4Ffgp/z8xtm5z6TXRPqfyFxj6fF6fCw9ztWPs/lH8n7x/Wwk9xV9vu/vyfz74r8LVouz6/D+fUc+v/R5n9eTdeqDdcCqcbZXV9bjc6C29DnP58Xb0q8p/kCwhuSDeZ+CVaTH41bndRBWZR/nVRm6QpzN+ftEJTlOBcn195+3pFcuZI9TXvyy1HF2fj1Ymr042y8DlpLeBpC/x5aUXgnx+ftqMVm3OOfibF5E1ikIFpW8MHuYLwSdLU5yOQ+ux34+MA+YH8wN5hX/J5/NOZcLzIrj54DOHGfzTJJHwOyS088ieVbxM4NvYC4j9JuSO+JnAENgHBgNhsFgnJ33xUkOBsDYOOv7uW6c7cWwL+cRIzpayPP0gK+Br4PpwDQ8X+mlEj+N+NRRYArps5dcXh97ydiLsz36SUnkKaFfBJPghf+HZ0Hbfx60/lPwufMfr4n/GPwVvAr+BF4P2jntF4myc5ekf1n8C+ALnM8V6PPgxaD133ZtTr+Wa/NuPquZd/dZzflnjj2fc3K8s3Je9ON9NufcGV4frPvAsf5p4cmg7R2HPiH5Xcf6R8HDktM/CB4BD4EHRB+T/j7wL6y3X+Y6+GxvL7gb/BHcA+4Cd4pui3V2QG+S+W0y10b6W2VuI3jDsf568DfH9taJz95a8GfH9ugngivAxbyv0V8GvZD3sWN79OfyvkE+h/eFY/PZ4rM3k/eJY3sz+L46tjdJ8sngePAHcCo4kfeJY+epmR+A3gVOgD9O1hsrx2P+Pd9nx+ox4m9zrD8aHCF6JLjZsfkwMIH3jfNyfxA4EPyO95dj/f7gAHAwGPHZnH5fWYfr9uH96NheL3CNY3s9eR86tteD96Vje9+C8x3b6w12A7uDXcXvB2bx2Zx+R5ljL16O3wXsDM5zbK+l+OzVdm2uPnUHOQ+eVyewncx1EM28NRjA62jD5xVYx7W+9pi3gv4maDXz1vK6eR4t5Dowp9+czwXkX4rfVI7b7BXH/1p6dcVnL8Znc/rU6X12jvqroPW/CFq/iZD+a5j/PGhfH+fpfwZOw3WoAz3FsTnX/1TWqS15Op9dp6asVw/6bbCW6IZgDZmvxuegY3vVpV8RrCo556vwuYh1KvO559ic/luSc/1Kchz674EVRN/zWr+crM/j3UavHv+OQ3pl5XwWRqxfKmjnSwftOvTrS07dQPyG4rP3s9fm6lP/Bf2OrNNQ+JP0qN91rU/S3+y1fE9678lx9TyYlwza8+X563VsIP0SIN8HXn/mXL+46E1e6xcDF/HvJ4M2Z78IdFFwccTOFwIHOba3HvMFoQuLny9oc65TAMwv/dUyl0d6ecFcYA/H9uIdm+cEI/z541g/B5gbdMHsYHfHztPPLPkinHdW+NmC1n8asDl1VND61FnEzyjHyyz+m2A35G0d68eBb4CZwAySh8A2mE8DHQYd0czTg0GZ53pfODb3g00dq32gFyziWD+anw/H9mLAWDAAeiQPyzqv8/nm2NfhkT57r4GN0E8HnVzy9HJ90oKpxef15/sdJb2U4vO+SRG0x08lOoWc13uO1cnApHweO9ZPIsd/FrD9F9DPAzZPKef5SHqPxX8o+X3wXcfm98Rn76Lkd8F/wDvgNfC6aOaXZZ75z+AV8Kro38BLojt5rX9ZzveuzLF/QV4P++cDNu+I/lnoc2ADx/ZPg/Uc2+P8mYBdpzX8UwGbHwtYn72T0HUcezz6JySv4Vj/KHhc1ufxjgTsHPvf4PiHoZtBfwLuh38IPAgekHWp94HVHEv6e4V7wCqO1bvALPB3Qmd2bE5/h+TU28E3Hau3gXHwt4hmTn8zGObzyrH+BjCtY/U6cBO4Flwvfi2vzZdE7Pwa8alXC1eCqXAeK6ATwfJe61Mvh14GLpX1qBeDT/n375hfAr+E1/YWgU/CVi8E54NzwQXgPPHn8LmGdWaJPxOcLfNFcD7TAnZuBjgFnA5OBXN7rc7ltT3OTQAnimZ+L2z978Hx4CRwHDhG9DCZGyvrjoa+Hbb5bclHgsPBUeAIOc4IOQ/2E8BrWHeozI2T3hBwMDgQPB+2fn9wEBjltT3ODRD2A/uCvcEzYesnw3o9oPuI/yLW5pzner2EPcH9YTv/bcCuQ/0ceXfR77vWp24TsD51x1f4nHuEdbvB7yrn213W6SK9eLCzsBO4B6+3A58HEZvTby85dTs+XyL2PPg62oItpN8afIjX1xK6VcDqD3AdmkN/6FqfvXuxNm8pfeaNoD9ybd5IeD7W9qg/lnmS/ifCD6RH/0iszT8Qv1nA9rn+0Vh7PqfkvBrJ6/1deEGuw0/i/y7n9aGcP32eX3N5fz8HPwOb8OdN5OV+Y8nfga4n+afgx7wu4EfiNwXfDdj1GoENZP13xK8vOVkXXM59e2Hrvw3WBDeGrb8mbPMawmpgIvcjQNcGq0ivKrgK/cqimdMv9Ip+KcnpN3ZtXk589irJ+fF864AVpVde/IZgBTlOZemz95acB/ulwffAstKn/gH3dxmZK/WK1134FdePOr/41PnA1WGr8wrz8P4PW9LPLcwJLuJ+O+gCYA7pueBC7iuEjki/GJhd8qyyTjbxs4DzsP6csPUzyboZwczgG2AG6ftABwyAXvHZi5Z12IsBY0E/6AFnh+38tLDN04Ovy3qvSZ4OnIz5NNKLkZz9tOCksNWpxadOBa7APpcU0AugU8oc+xPCNk8OJpOc/j2/zR/4rX8XHBu2+h9wDPw73A8G3gf/BhPCdu6O9P6S/m2Z6xe2/i2Z/1PWuQH2Cdv+I/CmzP0hfc73Ctv8N+4fk3V+5f4ssGfY9pPg+v4i/Z+kz/nrftu/JjwEXgUvy3pXxL8Edsdxuoatf0HWOw9eFP+w5Jw7x32MYavPgKsjVp8Gv0T/s7D1T3J/F3gKPAueAD8J2z4184+gD0AfB4/IekfleIfF5+s9JDmvy0G/PQ7X3w82kvOgvxd8F/ke6H3gDnA32CBs5+jvkpzfI0D/R79dn+vulNe1XfKtMr9NepvBLeAm8Z+CG2S9jeLz+wZq4bzXQvP7B9bL+qvBdX7bXyNz1KvAymE7/xxMBF+AK8WnTiHP5WWy/nLxuT+e33fAucXgUnARyH30S6THuQXSXyhz1PPASNjOReH85/st+XNsrsxz3z334bM3x2/71CHks2Se++u53569mX7bpw4iny7z3EfPffXsTfXb/lRZZwr0RFlnMsh9+MwniE89XjgWzBC2mvvow7I/nj73yY8Bx4GjwZGim+L32RHQw2Ud7sOnPxT8EHMJ0MMkHwzG8P9roLl/nvkA3ifSSx22+Xdgf3AQ2A/sLb2+IPfHc788e9wHz/3y7HWRvBsYD3IfPXtFcR06QXcGO/itXzDWrtMRbC999tqKziU+59rx+YK/e20D3VryluCTkM2b8O9uoFvxcxlr81ayTnNZj71mfrse/WyxNn8XfBiy61Ezbwi+DzYA35Gc3xvA7xFoBF1X5tirB/J7BupA/x2y+cdgbVmP/Voyx/7bMtcErCZ5TbCGrMfvE+D3CDCvCvJ7BqqLX0XyynLcSuCnYEXx08dan71ysn4FkN8rwO8rYK8MWBYsD5aSudJgCX6epJcC51MYupj0ioD8PgNqfv8Av4+A3xvA7wtgnp/n49oe/bySU+cGuZ87F/SRkM1zgIekRz8ieTbo7PwcglnAp/g7razQmfgckx71M5/104DJwTfAGMnjQAfMAL4peRiMFe0TPwhGg17JY2Rd9j0yR/9MjM05nx5MK0wjvXRgFJha9CGsn0quF9dJKT6vN69nCjAJmFTeD/ZfyPvD/KnwCcj75RE09/Ezfwg+Bp/7bP+BzDH/McbO3xP/U9fO35d17kLvCtn8X1mP67D/j8wx3xxj59m7LX3qv0B+7wBJ/5aQ3wfA7wH4E/oOeEO+L4B9/V4B6t/BX0Huf/pdNHPui1qP1/kz9C/ir5Kc+6g4fx3MGbL6KpiI+SvQ1yS/DLohqy+JfwE6W8jm58W/IP45MBP3XYWsfwY8DXKfEv0TIPcpnRb/uORpQ9Y/Ah4DT4JTY2zO/lHwsM+ud0T8g2DqkCX9/cJ90t8LzX1MzOnv4ece+aOg9XeBB/g5BXdLvpPPhaDV28Wn3srnRNDqzfw8By3pbwQ38PMafLn/mWvzEdJn/rlrc/rkF9Kjbir+5+J/KfxKel+Lr/2pPtv7WvyJko/m34PLOk1lrqm8jm/A6ZJ/I2wmvebia7+Fa3stRbcQn3q1z/rUK332eLpuKzkf+gt9Nl8m6y+TfIYcp5Wc3zdy/VqIXoP5dT7r837i+8P77XPJN8j8JnAtn9c+exyuz34LOQ+9ftSJch2YLwf1OtFfKPli8WfK9Zwl/nzRM15x/afL+6D3L/PJ4BRwGjgb/EF6ETyPJ0jOzxOPM0k+X8zHg1llnWwxts+efi6pR4KDwVFgHNYZIXPs6/NsmKyTAA6XfCh4G/NDoG8FbZ4g6w3y2T71ADCI8+0PPVDy78A/cZw+0DeDNu8N9gWTYt3YGKv7Sp9+D59d/1s5TvGo/8j9s4XBK5Jz/yrJfa7cz1oCvZ7wu4K6LzZe8l5gF/BFtNXMuc+V853BjuCpoPWpmbcHC+I8uY+0HVggyupOYD743IdaUDRz7kPlvlLuF+X+Ue4npd+azxGfzel/BW6H3wL6U3BL0PaomTcGNwSt/hhsxOcl8k+gPwDf53ni/Wvj2vxL8Fy0zb+U9RuCDcC6fO7iuKuCVjOvAy6AX5v3G1iFz03k1aAris9eZXAvzrcsdAVwVtDOl+JzM2h7U6Cng2Xgb8a6xaBL834Di4LFwcKyXknoQiD3q7I3KmjzArJefjlefsnX4fzy8TkYtOtQM88rzCO9oUHr5+TzMGh1Dj43g1a7YERy+tlA7mPVfa3Ms4Lc98l9ofQz8TkRtL2M4rPXPmjzDGBYcvrcf8n9mexx3yL3K7IXK7kP9PDz4do8Nfg6GC399DLH/Yvcz8icPvcZct9hGs4Hbc7jppXjR4H1Zb57tJ3jeaaSPudTgCmll0z85GBSPr+CtvcCfy/aKGh7LXA+bXFdnqP3dbTVzOk/8b683861OXX7V/gdJKd+5LV+R8nbiU/dib8nR9u8k/SbRNv1qDvLcUj68eJT3/da/Y/X+je91o+XdW+8wm8cbXNe507yuvn+PuM+M+FjsDHe/ydyfXm9O8jreSTzD8EHIPedch+q+ndlX2r5oPX/luvE6/MveEf8mzLH/axcl/srua+SOfeNMr8l6/0px4uX94U9vh9/eG3+qxznlmjuN+V+VO4vpX8N7CI5/S2yX5W9rq7N6XeTnP5Vr83V7y7z34pmfs5rc/pXvDanf1r6zOn3kOOR9HuKT91LdG/xe4nfVfq7vDY/5bV+T/H3Sn5Kej3kuHode8l56PvE8+D7+Qt4Gbwu98tVed+vyHVnfon7Ery2x/UvynEuSF/nz8k6tfG5OMn9aNI7I+/3abl+vG4nuJ8MrIl1j0Pvk7lT4vP92cN9QuCPku+W95HcIfcD9Vbxt0OvA7dJzr5+bqm5n5z7rrlvW/2NIPdlU3OfNPdZb5Dz4HnxPNeIz/m1IPdbrwK5/5n+SjBR1lshOa/zAXCZ9JbKcZZLf4nMLQa5j5rzx8AFMsf+IplbCM39qMzng08Ctsf158lx2J8jc+zPlbn8uH9nSz5T5rneDPHZexCw+TTxqaeAk8CpYM5om08G/+XfKSMfD3+i1/p9XJuP9VrNnOzr2l4/0cz7Sf878alHeS3HyLr9pce5AZKnjraa+TCv5Qiv7Q2UHucGST5YNPPBXssEr+0Nkd4g8amPeWyP+UDoIx6rh8jr1POjPuWxx0kQf7D41EN5XSSnP1zyocJU0bY3XPwR0CMlV596FDhacvpjJB8lfOaxvWTR1mfve1lnjPjUTzA3VvrsjXNtrj71fY/1qcdDT5C58cJ/PS/vUV+X9aknyvz4V5zPRHkdY8WfJPoH8akniz9JfN5HFz1WT5Z1mKvP41/22PVHy3mPFF/PZ7j0eF/wPuT9O0nOm3MJ4p/F+URhjp+PwUJ+jtkbJs+RBHn+6fNulDzXRsjzOG20nZ8iPnsZo21OPzra9pnrz4Ex8nMjo6w/Tn5OTZCfN1zve6/tU48GbwSsHik/P0aJP1zm6N8M2Hyo/JwYJv4QmaPfW3z2+srcIPk5MVj8qbhO/fh+grs8Nu8v/WkyR3+65NQzxJ8m/kzxqft4bW+W5NSzxaf+1vvy/hzpUXf3Wn+u+HOkP0961G091qeeL32S/gKwlcdqnaPfzfvyuYWuZbz02nutz14zj80Xyuvi614ELhbNfInMLRKfeqn41J09lsukR5/95eAK0UvFXyrnvVLyxcIZ0kuUPv1tHpuvFE5/RW+VrLfBY/1E8VfLHPUa8VeJv1x0vOfl/lrJ14nPHv31klNvEH+t+F2w/kbxOb/JtTn9zeKzt0Vy9am38rp6bL5VuEle51bR/3/dPTanv03Oh8dZ5rG5njf97eAOybcLd0qP+kfxd4i/S7hRehsl3y16j/i7xd8rPvUGIf1uHqv7e17u75F8l7yuPaL3iU89yPNyP8Fj8xEe6++T9UeIz+s/0mN7+8Vn74Dk9A+Kf0B4SHoHxT8snOR5eZ/+Eelznbkee9yjki/0WH1UuE16R+V1bJfzOSKve7/4o7DO/wAc1LiZeJx1nXW0lWX3tZE6cGLH2UE3uA+IgCjdKamAgEgoiCAiIiq2iIGg2Pmq2GJ3B3Yrig0oGFiAhQgmCL8xPq75jbHm0Pefa6w551r3s5/97H0Qz/JdXqj0//73MnwRvmf1C3AZfBa+BF+DT1vuGfgUfBI+ZvXj8FH4IHwIPgDvgPeZfkwy+vfDe+C9xtvgrcabLaf6JviwXncy6jfABZldPAueC2/EP5P6bMudARfDW8jPz8S+H/Ixf7rlT8vEPvnz4Lf0n0y9IR/9pcw5NRPnnZKJ+u2FqN9FfVImzj/BzlHuxEzMHw/X52Of9LlwDf6qfNSPycS5x8Lj4OG8X3PMn5WJunJHZ+I5mi99tvnv56N+JDzK5s8yToMz4fRk1JU7IhPPOdJq+SuoJ1PP0OuyczR/up07yc6fYv1TTZ9s/qFwIjzEavnv8xyMScba+6V/UIj1h6Z/YPow5o7PRF/6hzZvf7sOXZd0vc6D4STjBPhWPp470c4fm4n+GOs/CI6DB8LX8lEfDV/Jx5xe3xg7R/kDrE/1SDjCuD98nvx+1Mvy0X/G/GFwOBwFB3N9T+Rjbl/jgEzMqe4PH0fva3of2A8OhN05t3cm9vWCD+aj30N9sCfcJxl11d2sr6vN7UTdBXbMRH1veDf55sztgN6Mei+dC9vDdlY3tXxbeAvzGyZjX4NkzLWBN+djvafpqlvBG9CzzGuNXpe6JfUeMIdeoL4uH3Oq5bfQ/YC7w+ZWyy+GCVhiflPzXc+a38TOawwrYEPTG8HaMA/r676YXwf+ntjFWtanXM6ur6nlpJfb9SdML4Np+Gv5Lqaot1EnM1EvsXmlpuu+634uyUe9Bqxp/dXhBfmYW0x9DixCr2b9VWyO8spVNVaGC/KxX693N/hPeayT1l8J7iyP3AFPY/526gML0f/H7rPuu/J/W5/ehy3lMa/cX5b/k/qofPR/h7PyMSf9N/P/KI/nboW/mq7rk67n6xfqDPWm8qj/xnP/Y3n0f4bfw81WbzT9N9M3wB/gd3A9rAO/Nf9r6/8GfmX5BnCN9a01/VM4nvdlNfXH5n8OV8FPrG4DPyyPc1bavImFWL8P3zNf+qRC9N81vgOPyMf6bTgNfQX1m3C55d6CT8E3LP+B6R/B14zS94bL4OvweauX2bmP23VJn5GP/sPwQfOl3wen52Pu8Hz074Z3wAn5qB+Uj/5S01XfZLwBjsvHegnskY/11bB7PtZXwi75WF9meud81C8yLoad8pHSzzUuhI3055N81M+E88uj7/o8WC8f61Pgica5+vznI6UfC6/PxXo2nGW+60fofchFSp8OD4PX5v5dnwIvwZ9o+sHlUT8IXkj+/FzUxxpH630jN5L67Fz0h5ZHfzgcpPcpF3PSB+h9ysW6HzwN/dRc1HsZu5fH3Mm5qHeBXfX9wPdZZ6s/Nl31q+VR7whPyMX5ynWyfAfLq789PD4Xc/vYnL2N+n5rB/eyOe0t19bybUzXz4t1sLXl9oSt7Dzl97A+1S1gS+uvgHO43gL1UbnoN4eHFGJOc3e3+V/CppbTnGb6/HFOY+oZueh/AZvYvEaWV399eHgu5hranAZG/Tmhrs2pp++BXMzVsXxt038yXfXKQqx/TUS9tuXy1LVgzq5LuWx5zE/LxXymPObUV271L4moqy8NpzL3Z3Kp8phXLqnvP/I/kk+Uxz7lyuBk8t+TLy2PfcqVwL7kN5AvLo99ytXU9xP578jXKI99qwpRV65LLs4psnz18ti3NhF15dYloi+9Uy7OrQar6nsuF/Uq+h7KxdxK5u5I7+Ju6JXgznTsV/0PbMe87dRtctHfBltb7j3O/Z36L/gn/MP6Vf8GW+ZivRU2R2+Si/oW42bYiFzdXNR/gT/B2rmo/2i6chvM/9709eZ/B3O56G+E38Bv4SuJqCv3tOnKfWHnfA2/gp/BL+Ejiagrpzlrbd6nMJ+L/idwDfzc8qutT/78ROxXbhWsRT6Zi/rHxg9hIhfr901X/R4sRX/H9BWwuvlvGl+z3BvUy+HrVk9NRL1SLs551fgK3JHdxZeoJxei/yJ82c5V/gXre92u50XLPWv5X7JRfwYu03Of/Xf9KX0O8J+mfh4+abkn4KPGR/T5YM79ek6z0Zd+n/lrs1G/Gz4I74H3wr6JqCvXB/0u67tTn5dsnC/9DvNvT8c5vZm71PK3wVv0+cjG3MfZ6N8Mr4c3mH4TvBXeCK+z/BJ4JfwfvBBeDa+y/svhO9noXwqvgBfDy/ScZ2PuErjIcrqei+y8i8y/0KjrvwCeB8+F59t5l5gv/Rx9rrKxPlufn2ysz4LPoT+RjfoZxvl67smdRn06PBOeko7+Aniy+QtN1+s+EZ4ET4BHW+54y881XfftOPM78zzPsfnH2jnSlZsNT7XcEeYfCWfAeZY73O6ncg9loz8NHma+9Puz0Z8KD4GHwummqz7YOBNOhJPgeDjF6tGmq3+CzVE9Cx4Ex9mc8eYrf6DVzRJR15yxNm+UXZ/0kXCy5UbYfVRumPn7waFwiOUGw3uy0b8rG/194W3ZWA+EPaweAPvB/jDB/ehF3RP2tbqHzWkD78hGv7XpyrWCt2djTnpL85dko747LMAK2BZ2gi0sp77m8GrmXgmboTeBTW1OY9gIXpWN+YamK3dFNvoNTFdd31gPXkpuUTbqdYy10jGXoz4nG/2zzc8Yy+FZ5HYzvQimYBpmYZn5d5dFLoU3w+p6/mBNWA3WgH+koq66CnVluz7l5tnrqATnZ2O9MxX5DzyJ3A7qquR3VI+5SkW70A5WKYr6TvLbU7Ff87ahH8V5VYtiXrm/UjH/t/VVsfuj/J+pqOu+/mZ+qemqV/Pn5E8Ksf4UXl8Wa/lr4Fr4mc1RvYXzfkzFWr5e52b4i3ETnJmN1685v6bidfxA/VMq1vI/h1fwur74D/1i81WfBb8sRF/1OvhNKtby9Xq+hxvgd/Arcuupv7XXoXnrvC8V9c/gtGysPzH9a73fuk/wG9OVE08tiznxPV039Xemr7f8KWVR32B90jfC7/U+W076j/p7SPiz6e+mYp/01/S86Z8b4VupOGeTzd9oedWbTf/V9C1wK/wN/m76H/r36FbL/8v4N9xmedXbLX9iWexTLf8fy281XfUG0zeY/4Ppet+V1/Ok52sN9/1ofa9Qj+G5/Yh6BPUq6g/gEMvpeXxf39P2PLxnz8W79r6/Q70Cvm3nKbc8FfPKvQkHcl16rpZbv3JvWL5XNuqvp+IcPb+vwmdhN/peoO6Yjf4y+LT50jtlo/8kfAK2zUa9VTb6j8OH4IOmq74b3glvh3fBO0y/DRb09wqWu8d4K7wFXmlzrrZa/hXGS2ELzr2M+nJ4leUusXyTbNQvSsU5F8KL4QWwYTbmG/N5Od/6FsMG2dhfLxv9c+E5sHY26gtgLhtzZ5p/FpxvunKnw0w25k41/zR4kvknwpPhKbCI1z/PavnH27wT4FxYJRtzc8w/Vt8/sFI25o40fzacoXmFmJN+uPnTdb2F6M81/1B4GPy8dBenWl65yXAcnAinWF65Q4wH676Rm0S9MRN96RPghkysx8O1mXgduq6D4FjTp5qu+jNe9wHUB8LRqaiPsvPHwP3gSKvl7+T19jFfuqj8Gq6nl+Wk6zpGwP2Nw+HqTDxP5w+DH2Vifggcajn1DYIfZmJetfx9jQPhO+QGUK/IRF96O/P7Uw+Gfe06+5iu+9XL/H6wN+xu7GK5rrAb7KnPbUX0XVe9W0Xk06UxV7ki1vJXlcY+zati8zwnf1lppPRX/uN8vQ7Vj5RGvZPdF79P8jvCfWAH2Nl01VUrIqU/yPl7W59y1Sqi73OqW66a6S3ou6801vLvL421n7t7Kp4vSm8N28O97P7o+R5gvvS29vwvzUR9TztX57Uxfw94ayZSeitjS3gTuWszUa+w11mw86vZ/VWufirquu+a1xw2g03gNZmon1mIfiPYADaGTWEaXl+I+aZ2XeqvDevBOrCh+XlYCy7l9WSpy+185VN2PfJLzE/CBMzAMssrV2r98ouNNeCCQqyL4MJCrKvDC9AvLUS9Cqypz6Geg1TMK1dZ34uWr6Tv7WSsr+G+/pOM/TuoLy9Efxvcnozz/ra6qCLqqi8r/Xddff/Dv0L//Iv+VzLqqv+Ev5sv/Tf4B6xREXXVF5XG3MWl0T+3NPYpL131YriV3Ba7vqsLUd9o/NZyovSv4OfwmkLUlxSivxauhhcWon5+Ifofw3MLsX4fLi7E+l3jcriI75U3qBdmov8qPMdy0rUvqz1Z7c1KfwE+Ax8p/Lv+tPmPU2uf+P/78HnLPQCfK8TcfbqOQszdbbpy7xSifztcClcU/l1fYv4S86+z3LWWf7cQ9cvh9XrO9ByZ/z99nvT+FqJ/KbwEvlX4d/1i+Ar+RdSXwVl8Xs63/AV6DpPRPw++Xoj+QtNVnwM7cc7Z1AuSsZ4C58P2pVFX7lSbezqcB8+Ap1lOfafAk/R8FqL+RCH6J0Ltt6s+Ac7Vc1qI+nHweHiy5Y+xPvnHWr9ex9Hmq38O1B79bOo7C9E/S++3zVP+KOtT/kjrU26mPm+FWB9humrtaWuPW/vL2peWf3Ay+lPhYXAanAEPNf9Me46mWE7P1WTz90ZvCyeiH2LXNdXqSXa943U9mehr7oRknK/8QdbXhnxNfv6Nwx+djLV89R8Ixxq1H6197QOo9zd/tM0dlYyU3rg0UnqxUfqe+vsH5oyw84dD7XlLHwr3gyNNVz3QKL1+aZyrc4YZh+g+ZGKt/WftQw/NRH1fux6dP0hzMzE3wK6rn/UNzsRcX9jN6l6wP+wN+5hepzT6vU0vqYisaXnppeaXma6c9ERp9BOmK1e7NPrSM6YrV8f6da6uV9fX0+5TD7uPXaD2zLua3ln3k/ejo+kdYCfrr8752jNXX1udn4l+a30vwT1hG9PHl0S/lc3TnALcQ98rJTGnvpbGCl1vJs5R/+7ULWAz69P+uvbgm5iufXXtr9ej1l57/WTUtX+uffQ6lqsN85avZbV87beXQ+2xZ0xP63VxboNM1MtgyvqTyZhXrtRYrNeZiXWyIuqi9L/4faSevB819fm0udVtnupqpovStzH/n0TUK8MasAqsanqnkuirTlVEvb3pyknf03xRekvzVe9m1ydfeiW9v+g7ErH+IRH1Qkn01b/T7lNlu7/SdT91n1XrfdT7q/oP7UtA/XcFXNe+tf47A9q7lr7VqH0i7Rf9Sb0ZbrGc9n20//M39SbrU057P9r32a7zrE857f1o30f3+wfrU057P9r30fux0fqal0RdOfVrH0h7QMqvT8Q+5bTnoz2gb2w/R/5Xpiu3znTlPtPehu5bRazrlkQ9UxFr+dKz5qv+1ObnzFd/rZLoZyyftz7VqxOml0Rf/Z/bftM6u65P7b4ot8b2pVR/os+d9tfsejRPe07Kr0rE60uWxD75K61f9Ue2R6X6A/i3fh8tHfX3jdqLUk71u7Yv9Y4+l+nov63PleWkv6XPG/5y6hXwTfiG9lKsT/Wr+nwxR3tI0rV/9BJ82vRl5r8An4HP6XuveBeftb4XzH/K+pfZuX4dT0LtS/3OnCcScZ70WhXRX5eOcx5PxNxjiZiXXtv8OqYrV8fqrcUxJ7+u/lxgc6TXN1/6puLoS29gvufXWV89O+eL4qh/Ztdd166/gVH6Fvq0f6b7+2gizltL7jHztcemftXn6PtEv99Lrf0z+WfBBXBRIubPsD75Z1r/6aafb/3zbc48fc+ko3+azdMc5U+xPvmnWv9Jpl9k/SfbnBP1/ZaO/gk2T3OUP9765M+1/mPg0dY3B46Csy13lL5f07Gepe9L9CNMn5mI+gx9P5I/zPTpiahrP077e8+lo34onKLvmfS/64foewN/MvU0eDB8LB3zk+DD6VhPhBPgQ+moa95BcDwcZ/rhpo+BY+EBph9p75N8vV96H0dabn/TL+BzPIJ6Pzja6uGmDzZ9iOmD4IFWD7T7NRQOgPuavqA4+tr/05z+lutn8+T3tX7V2iPU/qD2/7QPKL8XvNFy3aH29HpZLb8r7KbvIa63E/W16ZjrYtQe1zXktOclvSPskIi+661gBWwNW8CW5hf0faH9FH0PpKM/y/zmNr+pndPM+pTXnpP8JrANbGTzGluf8g0t3xY2MH8vfa6Koy+9rp1TH9ZRXzrmVMuvBfP6nKajntPnMh1ztWEGZq2WP5LrHlYcfelp61OunDpl15G2XJk+5+mYT0LtYw1KR70Uan9LuWLTleuTjn4NWMV86UWwMqwKd4O907F/Z1nMdyyOc1RXtjmVbJ7qbczrjr69LOo79HvnsFs6+tL/hHtpH4a6XTr6m8uivwX+Ahvq95LSUVe92XKNLP8z/k9l0Rd/snk/Un8PN5ZFfaPNWw8bM+9by30Du6Rj/bXp2m+Trv21bkW72BU+UhbPacL72wt/nd4/6p6mP2q+9Kc0j9fRB/859AHUH1C/avoa6qb0f1gWddUr4QqbI1/nam5fOApW5vW+Tn4EegP9nKR+DX9TPub1epbBj+Eq+BFspr8vMP8L+ITdT923J6mfgS9a/rH/eB9U6/3tgq73/0H0h+EdsDnnPkBdNx3ztdPRvw/eC/PpqGtvUH4L5t9Jfb+d+zj17XZdL8Nbzb/N9hDvtvwt1jeE1z8MXop+I9xd/14mHfuvhTfAV+DVcAm8BhaYcx219tC0P3cl+liuYyhsWBzrN8vi9WpPbTh1hX4vCv1CeBFcCBfAxbbnJv0s43zYsiLWZ+r7ht/z0v6O9nZaVURd+z7a+9Lej/STjNpDUs73k06Ac+HJ8HjjcfBYeAycA88ti/M1dyacZb7r06D2qg6h1t6V9Knoh1rfNNN9zsE2T3ti2gebiD8ZjoMT4Bj4Vc1d3IP3pXVF9KWLe8I2sK31ud7O/Nam72W66vb6uWp6O2Obsphra3o705fXjL7qtvb69Hq/qBl11StMH2v3Vdc/qiz6XeBIOB4eYPr+5qseZrrq/eAkqL3CfbiODvAZPoeDyA00DiiLOdX94FOpWPfVzxn0PtT9YS9jR/37bOpRdl962tzusBvsAB/Q760zr7O9D7r/7an3sudJc/axeW3LYp/yN+j3tTXPfD1P6u+i50mfI/0cYM7N8Dr9HrZ+vujnhH6fm7o5bAFfrBn1ltbfFDYxaj/sWuZrT0x6Q9igLPrS68PzUjEnvRZclIp13vQs9dmp6JeVRT8Ny2EG5mDK/Pu5L7fBBPpS6qSdo/nKl5bFvptNVy5rc7TXVkx9hn6Pm3qe+TWh76tJ116b/OqwmvnSq5ruOfm7wcpWy68EtRcn/7hU9Hfq97pLoy/9d/O3m/4bPIa+rVbL/xXOstz35m+Cv8DNcAv82fy/4E/mb4OLakZf+o92/ia7Dukb4bdwZirqquV/A7+G01JR/0q/5wW/sPw6+KVR+4DaD9S+nHTtzWlvTbX21D6Cn8C18FPbb1O+Ryr6q43ad9I+1Erbb5L/munKvWf+Srs+Xe/Hdr8+svu2Hr5vuQ/snJWWf9f6NsAV5v8A3zb/bfOXGxfy3L1F/SZ8Hb5j9Wt2vbpf0rUvdipzX6Z+FT4Hn4UvWZ907aE9A5+HT0HtvWmPTXnto8l/zPqftDlPwAO43setvrM06qL0rhWRj1rugdKoK/eIXa+uU/tz8h+G2m/TvtvDNv8hO0d57aVVteu8x/qV056V9tjupdbek/y7Yd1UzGn+XaXxHOXvsD7ldT/Vd5vl1LfUdOW0RyX/FtNV3wyvh7lU1G+Ct8Ib4RLLq/9a05XTHpL2r5TTPpD2g64x/QqoPSLVl5mu+lKo/SPt+0jX3o/2ebT/I32x+RfAc80/D/6ajP5CeA7clIz65mT0F8DT4Tx4ttWnQO1znEY9X98vljsZXpWM/gnwJMudCI+z3CJ4vPF8ONco/WB4jJ2j+Vcmo380PMp86doj0V6JckfC2fAI3Xf9/0nZ39PMxJ9hc9V/uM1RbjrsYZTex/rnwGlwKtwXHma1/EHWNwUeCo+Fk81XrfdB9/8QOMnO0fs0wfIXwoPMHw/HwlGWH2d9B5p+CRxj/uU2d7TNH2/1SDjR6hFwPzjY9DQcDvc3tqoZc5oz9D/mqdb7Nclq3Wd/n/ubrrqfUc+Tnq++cADsDVtaXbDnU3N6wu72XCu3OBn9rrAX7AK7WS2/g1F6K9gZLtLvs5veyXztY0nfB3a083XeXlbrXO3jaN4+pmsvR/s6qtvBtkbtzWjPRnsn2kORL30PqH0V1U1Nb22vo5Xl1Fdh97el5fV86Dnw52Ig3B0OgS1MVz0MNrM6a3pzu15dZxN7nf665WvPp4E+78moN4SNYB5qz0X7OOrX3ov8ujanFqynz2Ey5rQHor0Q7YPUsTl5m9fM7o/8HMzYXN3PcutTLgW1p6Lvr7T1JSynvjKY1PtbM+ZLxYpYF7teEXXtwVTT94vtxxTBGnC7fn+fWnssVWFlq//R793r85eM/ZX0OU3G3GEl0d9REudr7s6SeJ26Pvkl6LNKoj8dboNHwNlwGpxh/uHWL+p6d1h/zRq7ONVej/JT4KElMae+ydanvPZ95E8wXfV4o/Z0tB+kfR3pY+EkeCAcZ/q2ouiPtv0fzRkFx8C/i6Kuej/r17wDjCOh9oZUj4CN0YeYPtyuR+ftD7fadfxZFPuGlsS5g2BtO29fOBgOM111f6P0n4sipf9K3Y+6r12H6l5Qe0a9qfvAAVD7QYlk7NO+kPzuJXFON9jD/K76HNI/kLqL9UlfXxR99XeG2hdSrqPNU66T5fc2fZ+SqLc3v5t+3lO3M11194rIHhUxp7p1yb/rPc3vZbpyvU1Xro/5vYzdLdfH9E+LYr/8vsZ+dk5/05UbYL7rqldz7kDLDzCutJzqfSuirnqQ6aoH/4c+xHzVQ00fbPowe/2D/0NXPdx01T2N0vcoiZTeyGrNb1ASa11nPX0/Uf8fcGteHHicfZ11tFVV28WBe87Zp+6hO0RyA9IgBiEhLSIgiDTSKd3dDZfu7u4ugUuIItLdICKhhEj5jvE55x/PHPC9//zGnPNZz1q7zj367nWs5Mb5v/9VEFYCU4b+4ybH+uXBL12bq09dGdzm2LyysIzUkfRPOrae/ctKn7LSrxxYCiwtmnlJsDh4FvOVgP5M6oqCxcAiYGFhHpzHi+iXEzofmBv8FPUfQOcK2XlyhGzOPtnBbGDc+Fa7YFYwTnzrZwYTuraOfibJ70SsnwHMCGYB35c8PXgrYo/nPalnXTrwBuq/wPxpZRzr0oBXUV8R9alDdhzrUoFXUM/7n/c9xyV2bX1ykM9DipAdR3+jY3PqxCHrJwOTurZ/Uuau1IEJJGc/9k8CJpJ6HR9f+kSgT0VsHgZPRGwd/ZDkQejDEZtHg34wwPsLdCRf7Vifdd6QnccHRoGxEVsXD9wXsXX044B7kceF9oCrHFv3b9DWv4beHbH5K/Ffi/9C8qmY5x/4L8F5js1fyvjn4C70mYy6P4O2H3PW/w0+A7dGrP8ETO7ausdgStfWpXVt/gj8C3watOtiPesegvfBa+LfA69LHf07kt8Fb4G3RR8DbwrpnxSf+rLMw3lvyLquy3Gkca2+Iv3Z96rkl8DUrtUXwRTwL0Cvi9j8HDg4Yuvon5Wc+gw4FP556FPgaVn3Scl/lT4nxD8OLkf/JRHr/yx9eV1+kev4k+RHg7bfz+L/KPkR6XMYHIbnaIhj/Vjpc0j8A5LvBxdEbD4AffuC++D/AHaBv4ufN+Ae6Uu9G5yLeXZCz4/YnP4Oydtjvq/4fSxoSb8KuDlodVWwrWN9jmvp2DrtQ7+akP7XYDPHah1XHawhPvUWzLcpaP1vXOtTbxBdU3yS/rfgasnVp64l42qDdfh9EvV1xa8t4+qB9UUzbwB+HHx7fUOpayD+d6IbgQXQr7H4rGvi2px+U/GbiE/dTK5r03f41DXEby7jWohm3lLy5qKZN3GsT11PfOpW0qeVHDfrWktO3egdfi3H5tR5gtZvKcfztZwvnmfeBzUlry/rbyznr5WsU69nw3f0p+b9+Y3MW1P8GpJXl+Ph8fFzbSu4UZ73LfLcb5LndL2Mo14nXAvOi9jxfL7XgKvE53O8SnQbsAj8RUHrL5N+zFfIelaKvxSchXUulz7sOyVi65eAkyJWz5FxXMfioF3/QsnnyfgF/HsFNgRnc70yP8fNBCdGbB39GWAMv1eLPy1o/cngmIjVk8BR8DtGrD8BbAGO57okHwt2iFg9Rnzqkfx7Cz+G6wBHB63fTnLqzuKPEn8E+GXEzjscHAJWjFh/KL8fgV3BgWCFiB0/CBwM9uD3H7BkxI4vGrF5P+nTG+zP+y1i6/qChSJW9wELRKzuJf17yDw9ZRzr80ds3l3OT1fp103Gsb6L1PO8dpac16uj9OsE5ojYvIPwezBPxPbn/dIebCt+jIxvI31ay7gYqWsF5pN61rWU56eF+M3FnwI2lf7NpL4x2AT8Tvzp8rnDfLb4/HyqD84H64lfEqwjeV2wFthAdE3xqb8BG8nx0q/O5xesBtYAvwbzRmx92ojNq4JVwNQR638FpojYumoyf2Wwkvjf8nNE+n0hfgUwGvOUhQ5FbM7+5cDyYBmp5/jPwUDE1pWWPqXAEqA3YsfzupaU+uJSz/Gfgb6IrSsmfYqC/HtZRPzC4vP7An3+c8An0J+CH8k6WMfv/6yn5vf9QjL+Q9CJ2LqCQVvPuvzgv9H/kf98wHr+c0Re6Neoy8f7HTm/x7aFzgGdPWjH5xX/Ffplg3bBF/AzQz+LtnlOMAuYFcwEPpXxYd5vYAIwjvh+Pg/4fh6Xz7Fj6+JKn9LIyzrWPxJt/Z+iLemXAX+E/71r+5Blpa48/38fMB3qJkRb/wswEfJ26J84aMnzxLqq/Pcp6FcB+mEy61eBPxp6HBgDpsd8GdD3feEtqbsKfR28DLZ3re7gWl6WcTw/XA/PQxTmPQjfw89Vx/o8Tt4XQblvOmLeTuAj1Hd2bZ4qaEk/ddCO6wL/PvQDsCv8bmB319b3AHuK7iT1vaTPHwGrE+L4e0P3kePoCybDupOC/ST/B315n/WX+433d0Tu7y/l+eFzlkSez2iZ1+HnOj/HwUPR1h8Vbf0BGP8v1wt/BNgafIP8dcD257yvAlbz+J+Df4PPQF5f9nsCPgb/BJvKOhrxvkR+D+R1fAAOxHH9Ljmv730Zz353Anaeu+LflvwmdAPoWwHr3wBrIs+BdV2Hf1V4JWDrLkFfAy+Cv4DnwbPgz9LnsvhHwZyu1T+KfwQ6V7TN6R8GP0B+EPon8AS4H9wn4/aC2aJtTn83mAn5TtHMt4M7wF3CSz5bt138s8JtUrclYOffKv5m8D2sK3W09TcGbN/14CbRzE9jHRugU0XbPimjbb4OXC16jfirJE8Qbf3l4ApwJe8brGeB1C0Dl4BLeR/5bB9q5vug50MvBhcF7DzsPw9cGLDj6M+VnHo2GMZxzoT2R9uc/gzQi3wK9HRwKjgJjJI6+hMlnwD9JmzzGH4uhm3di7DNx4BjwXHgeF5nn80ng6Ol3xjRzIcLh4AvUTcMeiQ4FBwM3g/bcfQH8fMibEl/oPTrDw4QPQrsK3qQa33qDlK/2Gd91rHPUp/1+8HvA/YW9pT1U/cAD+E494Wt3w3sys+58Nv9hpJ3hu4Cdgc7BmzeS467g9TxPLSX/HuwFdgObMvnCePaiB7sWp+6r9RP8VmfdfQHSM7+06S+lay3tay7OdhJSL8ZzxP6NoFuKn53yamHuNZvHLCaeQefzenXk3GsawT9nayT90FXyek3kPvkG/HryHycvz5Yl+cT66gNXTNg+7HPHpmnOlgD/Bb8GqwGbgnb+qrg5rCto18FXBK2/SqBX0ldZfBL4RfgIvSpKH1qCcsFbB3HVwDLg2WlvrXP5mXA0mApcHbY+iXBGWFbV0R81pUAPweLSz3rioKFpQ/rCvE6Yd1D+e9j4H8s4z/icxy2+aSwzT+U/uxbUPQw8Un6wyWnTiB1YcnpV/XZfKj4Oj/75pXjKADmF+bj+cPxVw1bP0/A+tS5wRyiPwCz8/4N2zr62cCEYauzgPHhu9A5waxgdNjWZwLTghnAzGBGfr6GbH16yd8X/z1+rvC9SpknHZhGfK4zlfRJLX5K8Dzfk4RODqYAk4mfC0wifZKKnxg8w/cNed7BRHLf0Of9w/sxInXR0j++1PN+5bigjAuJ74A+0AMeCVk/CjwYsnUv/DaPA8YF44Fe8F+/zSvieXoD/yX42m/9Z5I/EJ91r/x2XVzPP9CxIZsfCNn8ufT9W+YdgfM8EfqJcIHUUc8U/5HMw+P5E3wI3pecx/kHeEPq7oHXwJvgbfA6+FjGrxSfdatFX5V+V2Q+5pfBteB68S+BI12bXxKOcm0dSX8b6i5KvY5nvktI/wx4Drwgx8e68++o/w08C54Gd0s9/YOSn5LxJ6WO4w7LOOZ7xd8l8+6Q88H8gfc/bofeCW6Teo7fINdtm/jrJb8sPu+HjeAacJ34V7025zjej7zPLqBulfRjHe/r66JXyP2+WPxl4CJwKXjUa33qeTJuifQlF4J/iebnxBOZl33ng7Ey3xHomdJnLjgV5OeOfg4xnwROByeDU3gfgBMk57iJ0nc89FPJqZnHgGPB5+KPAcfJ/KN5X4fs+DFSx3WPlPrR4o+QfLiMHwbOwfkeKv5g6TNE/EHg5pAdPwAc6Lf+bK/NqaeKT9Lvz/OD69DX/3afejLG9ZF19pP63n7bb5LX+qxjn57gVhxvL14f1HUXzXys145jnx5SP8Jr+3SRuq7id+Lzhr6dobuBHYX0O4ge7rV+B/GHgGNdmw+RvJHf1pHNpC9Jvz34vRxXO3BGyOZtwWkhq1tLv5ZgG8lb8XMgZHULPqch26eZ9GNdc6lvyvsvZHOehybSj/WNZRzreT45ri5YW8bVAb8Dawnp1xT9odf634LfgNVlPuqv+byErK4qPnUVfn6FrP4KLCv6S7AaWAmsLHkFsJywrNRRlwYnYh3FRTMvA5YHPxfSL+W3fTi+JPjZO+YrBo4L2brRIZsXAQtLTn9UyOafgB9LTv8j8VlXCBwYsnUfgv1Ctq4A2Dtk66iZ5wPzgPnBvGBu0QXFp84F5gSTS1/mOcAPRH8KZgNdMDWYXfyskmeR8ZmFRcFMYAkwg/jppX9G0czTSp/3pR8177/3hPSjvbYf+6eTedPK8ZKp5PwkFz+F+MnkuvQIWT+xMKHUxYdOBMYDu4dsfQJhNNgpZHVY/LYh6wfBEBgB/WAAbByy9Q1DNndkvEf6sJ51PqEXrMf9j9BvHJvHk/48X3El5/n717F92LdOyPqvHOtTvxS+AGtwn2zI+s/Bv7n/EfzNY33qZ9BPwSfSp2LI+n9xPyT4GLzpsT71I8eS/jjXMsZ9ez39e6LHv8M/57H5ZY/1Y8SPkXU8RL8HcrzU98FSIbtOruMP0VzH76IniE/Svyn1Zz02pz4hPkn/Bq+3rP+u+HfA0vx7ErL+LVkn13cbLBiyddfkeG7IOOpfsc7roie61ifpX5J5Od9VMG/I6svSh+OvSM7fF+DvDXC+CzJukvism+zaXH3qX3CcU6SedVNE/4z6qVLPuqOS05/mWp919KdLPkN81h3x2Jz+TBnHOvqzJI/1WF/Hz5L5qc84b1/vdDkf1OfkOvG6ngcLyzjWX5A6/n5FcenP9XDc566tP+3Y9Z9y7Lj9HuuzjuP4Ox38/Q3Wn3DsuOPgD3x+hPR3gLPR7yfoY+Bmj83Vn+PanHruO/x5klPP9Fh/rvhHMe8qjx3HvmtkPbruuXJ81OxL/2e+Nwse4nu7YCzfMxV/juSx4i8Un/oAuE/m2y/XcZ9cN47bA+4Vf5Hke8Sf71q9THyS/npwt9Stl/70WbdD1r1L7kPm2+X+pubv1GwB+fs29DeDW8GdUr9JxjHfIONZx98R0d8ZWQfy9z92y3nZIDnr14L8nQ3+vgZ9/u4Ff3+DdW+CNl8OrgBXgmtkHcukbqn0Wy7+EskXSx/eH7yvFoo/X/osAPl7GvwdDdZNk3y29OXzMleer1mSTwdnghP4d0jmmS35FBnPuqmyLmr+zgd/3yOG30Mc2491k0D+/sYE6AdBm48H/5A6+jGSj4b+PWjzAVjPKOgxjq0fKeOoR4g/HPq3oM3pD5N8MPQQyQeCB4M2X4DnqT/0ILC7x+Y9PdZf6Nqcup/0pWa+COzosZp5V4/N6XP9A+Q4dB4eB/v2dmzeW/LFYAeP1YvEXyL11D0d61MzXwr2gd9XjqMXP4eDNme/HrJu1neRcTo/x3H+JjiOZdDNPTbnetm3G/8uoH8H3hdgZ7Aj2ImfT66tby/jvgf5uxjtxG8reXPoVvy8FX8FdCN+/kKvAhs6Vtd3rM/5WoAthfy9Df7OBjV/96ClzNNI1tUYerVrx1HXga4nfj2ZZw18/v5BXceytYyrDdaS8WQtGfctdG5c7zxC1rMunuzf4X4f7ufifhLuL0kifmIZF5D9JwEZz/0x3GfE/Sfcd8JxXunLfVsu8jHQY8XnPibutxoudYPFHxptjyuZrDcgPvfxcJ3cz8L9LWvhrwOre6xPvd61pJ8F6+d+GPbnvC+gdV8N993Qfwny9xH4+wv8HYMi4nM/Jvcvcr8j9y1yPyRz7nfk88XfweFzyN/b0d/H4b5L7p/kfspEGLeB3wtd61Mngd4EnRM6O/ie5BmhXXAz/GwyLqOMI9mP86YHM4ApweTvqOP6E8vx8fzq79FEo+4Crt9vAeuHwHN87ws6DMZ3rE+dDPSDPul3LGD943zfC3oL1udAv/JZn3VkAIwr4znuNN/zQ54GTA2+RN1j8C/wIbjVtT7r74K/Ce/IvAfAk2AseAt1N33WvwG9J2DzXZJfE5+a+4qugrfB38EL4EXuN3Ktf5/7leCXwedFKY/1qXe41j8r6zjH8yH7m1h3CuQ+JNadANcGbN1J8Az4K/iLjDsuPvcRcV8R9wfRPwrq/iH6R0DuN2LdQV4/qdsvOlZ87kPi/iPqPbI/aRf0nIDNd4CzpI6aOfcVcf/Qdj5PvB7gTt7voIvru1n8TT7bb4v4GyXnfiD667m/zGf7Z+HfL58dx3r6ayQfEbD+anAdrze4SjTzTJh3uYxf4bM+9+novp0lsn+HpL9YuFD2wSzidQMXSN18cJ6Q+1S4T2aO7FthPlv6cp7pPjtupujp0o+cCnJfDEmf+2omgePAgbwfwYm8jqKZJ/XYPuOlXww4ARwrpB/2WJ3IY332G8PrKOsdJ/4Uybl/qD84FOwD9pW6fuL3BrlfqY/06Sl13CfUMmDrukk963qA3YVdQO4P4vjhYFdwBNhZfI7vJH1I+txn1BF8FPUf20O3A7k/iPXcF8R9Qu3Ebwty3xD3w9DnvpiHmK8Vz7PkLUHuqyHptwCbgdz3Qv8e+jeFbg42lnFNwO/AhlJXLGD9+mANydWvLjn31XwasDn3oTDnfpSa4FdgNcmr8DlCv8rQgYDN2aeS9PtS6jn+C9AfsHV1wArSr6LUc3x5kPsDWFcCLC39ykk9x/O9eOZlwTKS0/8cvOW3ddTMS8l6Ssq6ioOfSf1dv/WLgXy/m7qosAh4wm/n/RgsLHWfgp9IXV3wI2FtsBD4IVhQ+jDPDxYAvwHzSp4PzANmBRuAuWVcIzCX5DnAy3guM0BnA3OC2WWePFKXT/IsYGY5XvVTgcdx/l2fXUcm0Vzn+9BpwFPwk0GnBtODaWW+jFLH+ZmnFKaQuqN+6ycFk8u6uJ4TWF9i8dmH4xOCCcBDfuvH+m0eAeODicBoycPgPowPQR/BuvzQQX7+yDhqBzzgt9oHPsX7XTtd63t81n/mtTn9XZLvFr1L6l5JHf09ktPfKXkcn9U7xafm+uOC8Zjj/K2Jsjn9N97/fz7mXOcLOR49PuZ/g/+AL8Hn4F7X6pfC6VG2jvxBxlHffUf/qVG2jvqOjOf6uW69/tS8fx6D+/3Wp2b+l/AhzzfqHkH/CT4BuR+H+3A47p7s02Ed+/wB3pfzcVfy36UP+/7G9+79to7n6Y70uy31HH9L/Nvi3wQ3Id/st/51cASu1zXoGyD3B7GO+4SGov6i147jfiDW6X4h6rPgJfAceB78FTwt+Rnpxz6nwOV+W0f/pOQnpD/nuwIeF79vlPVZ94vU90LdzzLvMa/1uY+J+5y4v4g+9xkdBn8EO0ZZn/oQ9EEwVvpQHwDn+O24fXyuvNZvE2VzsiWfdz5n0n+v1+a7+PklfrMom5ON4G+H3gEu4fMq/hbJt4nPurrou5HPjfgbvDZf57V+VdSth14Lbub9L3qt+Ct4H4pPvUzWvUyOi1ws52GP+AvBmeA8cJHkC8DZuB+m+a0/H5wLzvC/3Z8jOTX3UXGf1TxZ1yyOE3+p+CvBaeBU6T9d6qZIPfddcR/WVPG5v4r7qqgngNx3RT1efGrup+L+qhK4X8bBj/FaXQz5GGjut2KfkVI32mvrqQsjHyV6n2t96v5e6w8WzXyErGuk+NyHxf1a7DNM+rFuKMh9WYP4vPvf7g8EG0h/rm8A2E98HufHUTan30f69+V143UFP4yy9T3B7jxusKHf+hkxLh3YFX5x8FOwCK8X+AnYRfTH4ncT/yOuF+Q+KvULgtxXVQg6P1hANNeZD8wjffKCuaUul7A0uBb//jCH9MsJZhefdTX8NnfFp84Kcl8WdRbwC7/VmcC0ktPPxusJZpZxGWQ89ftgOvHTSX0amZd+AslTganB5GAK0enBZGBKMAmYWHzqhDJPQllHfLCi3/rcz8Oc+3q434c6DAbBCBgAE4HOO3yf5NRJQa+Q/o+436Kg44J+MCT+vx7rU78BX/Pfg3utHwf6JfQr8IXH+hfFp34i+qr4z2X+f8R/BqbBef9b5nkqfCH9/5Q+f4EPwZR+W/cATOq3dUn8Nv+D+13Ae+B98HeQ+4RYH8dv87tC7tN5zfcxHOvfAm+Dd2R+7rfhONZzvwvza9LnOvePiOZ55HW7Iv2uiX9Z8ksy/qKQ988F2bfDPufF5z4Y7pPhuNPgGdHxcP+e4vv00uek+NyPwv0q3L9Bn/s42O8YeBzkvg3u42C9B+v4ScZx3wbHcb+GV55zjuM+DNZx/wU/Fw577Djut2DdQZCfo4c8dhzzWBlPzX0J3L+wj+fPsfle8AfwgMfOt0fqdnlsv93gTp53x9ZxvwLzbdJ3O7gDfA/Hu1XyLdJvm/ibJd/ksX02gvw7ukH8D+Cv89h8jfRfL/X8PsFx1Py+sVr6cP8E90mwbqXH1rNuBcj9FtSzxC+DPss9th/rl8m4cqhf6rHjWLeY6wQroH6Jx46bI/ULeF/H+48LoReJv9+1OUn/gGv1MI/1D4g/WnLqSeB8ySfJvPRZN1eOb4HoWXK+ZvN6gDPk+rBe99NQT5fxU6UP82n8PHGsnsJ1ObbPZOnHuolcj2OPe5KMY856vsfP9/D5/j39cezv2Lox4FhwvMw3WupGSr9R4Aj2caTOsflQ6cv7ZLjcZ0MkPxzP+qwbLPOw/yDxB4s/QHLqfjwux+q+4vfh8Tg2p99b8p1Yfw/4vUC+18/3/nuLZs737Pl+Pt/L536Ajei/DuwCvz3YmZ87yDtB8z1/fe+f793zPfx20HxPnTn9tpJTNxf/O+hmfG6xnnnxrG4m45uCTYSNuW6crzaO9WNd27e+x66jIVjPY8dT1+XnMPocBPmeO987J1nPukPgt/BrC2fFs3X8777pfyeS/x1J+nwvl+8r10A/vo9cFeR7yepXATM5VlcWn7oS+Az/f8wjn/UrguU8Nle/LPiA7wNA8z1J5p+DfC+SdSXA86jn+5LF4fP9RdYd89m8GNgD570o9GeSFwF/8lldWPxP+Pnks/khyT8CC0lOvwCYX+rygAd8NqefW/Jc0D/4bP4BuFvqcoB7fbYuu/g5xHclzwrN9w+ZZxH/f/TOA0d4nHWdd5AU1duFd2ZnZkmrS5AgiiTdJZhQUQQRUZGgCIIJFRVREBAMgALmnHNOYFZAQcCAgoIgICA555xzzv6qPs/zVb2nhH+eOud97+2bumf69tKTn8r6v39VxSGZf3mKdBXx20zMq2x+FfMrif0V/zgT/Yri8aZPEEuLH2ZiXlmxnHhJ8l8eZ/mULyW+lYl5b2ZivISYKxYz/9VM9IuIT2eiLiy+nIk6IxYSi4o5lk9e2pgSn1PeS5noJ8SkmC3W0Pgczo7lyEcT3yP+I2Ypr0D1HJFfUfqAlaOe/eJuca+42fJ3Wbt2W94O8cVMzN8p9sxEvV3cJnbP/Le/VbxX8S6Z6G+ydmyx9mzMjuXI3yB2yMQ86lkjrrf8deJa42rxNNW3yurZJy7PjvGDVn6luMK4TKyZifUcEpeaPiEZ/RqZWM8SsVIm6kXiSZmo54sVMlHPM86xPPRs80tnoj9TnCGWzES/VCbGp4rTxVniNLGu+Lf5lJsi5qreSdJFMzFe1OITjX+JhZQ31vw/xbTFxxj/sLzsTPRHiePF38XR4kjL+838X8XB4lDTxL8VE5kY/ycd498Yv7I89Kdcb+T3M038oMU/oH8FUb8nvsX5l47+qxZ/XXyB8ysd85anY/xZzoN01E9x3qSjfpzzLx31o6zPdNQPGXuzPtNRP8D6TUfdXZwkf0I6+vcYu2bHPHRn1l866o6sx3TU7VlX8m9l3aRjvK043PLwrxGHpaNuZX5r6avFNtnRHy5eJQ5Jx3paWl4Lyyd+pdhMHCE2t3JozrsrrPzlVk9TcVD6v/0m4rvpqC9j/abjcRqJjVnX6Zh/qbXrEitHvKGVHyd9sZW7yPwJVv5C8bV0jDew8ujJYn0rX098OR3zLrB8NNfzula+DutZ1wuu9+db/lzxPIvXFh9Lx/rIP9fKPZSO5U62vLPFc8SFYvFkjFPuLPEUsaod52Tzq4h9FM+XriRWNn2qWFGsYPWcZH55sVM6ljtBPNH06eLxVr6seGc65pWzfPLKiB2UX5rrVTrGKV9KPE4saX4qGX30XwXRRxeXLiEekx3bQV5edsyfaP6kgpg/6SjxyQWx/ETzi2ZHvS3xL4tkR+IXll4n/bfKbU5E/1Ayxim/2cptTcQ47ZhicfzdieiTN9Xi7qOniVnJGMffn4g+edOsnklWDp2djHmTjxL3+cuzec6VLiYemx39iTZ/uTZfPq+Md+GjzCfxlPThZNTEM9auQmJSzBHT2bH+lPl+nIR0lpidHf3u6Rj/R+UOij3T0afeI1Y//ThkeWs0HgeSMU79++w46D3mo7eIq8XN4nZxk7jR9E5xnbhW3GD14q+x42wxv0c6xlcaV1geepl4r/zl0qu47zPiLzH+JC4WF1r9i8S26RhfYOXmifPN/9ni88yfXhD1CPPnmf5Dera1Y654UzrGZ4ozLI7fJh3j04xTLe/ydPSniF+nop5Mu8WJXG8tPkn8MhX1X+LYgljPBKuPvPHiM6pnlvSfVm6c5VFurPhkKubNEcdYfeSPtnLk/2Hl0MzjKCv/m/h4KuaxHkZZ3u+WP1L6oVSM/yr2sTw08V7Sw20dsi5Zzz+Zv14cZvEfxF/EHy1/qJXjOjPY4t+LQ6zeQVzXUjG+W/zO6iN/gJUj/1srN1fX2/4Wn20+edQ70Or/RvruVIxTz1fJWB/5X1u5L6U7p2Ic/3PxM+OnYtdU1H3FfsaPxVuU/xHnT0GMT1D7P+D6ovj1KveG/LfEV8WrU9F/weIvia2V96L0VdLPSF8h/bx0M4s/IT4lPi0+Kz5m5Z4w/1GxqeIPmv8I51syxh8x3Ue8WPXUT0X/Ac4njWcv6d7i/clYjvweYt1UzOvJ+Sx2N+L/qOPdJ10nFev9TvF7Of+kuyajT949Vg/14t9t8dqp6N8ldrP6Od5AHaeL+R2T0SeP+jon4/G6WLk7xTvMp57nxDbybxRvEK8XO5i+zvxO5l/L+SDWSkUfTbw154F4air6aOI1pFtKXylWk9/cNHH8KyzeTPrkVIw3FU+yPPzGYgXFm0hfLl4mXmr5jczn+Vl5e76G31BsIJZJRR9N/ELxArFkKvrdNO/1pS8Si6diuXqsazEvFf2Oqud81qN0Lcun/Onmk3ea+eQdk4rxmiLP69A8X+O5G5rnZdVZR8y7yPM18ipZ/BQxn/UhztTnQRXTs8yH+CeaLp2MfmmLzzbizzHOPUo+/jzz0aV0vPnmU25BQYy7j66ViH4xq7dkMtaPf2wyxudbv85OxOMsNN/H4YJEzJtp/hwbx5lWHs08U451UVWsLPL8leexlcw/SeT5LM/v8HmOV8HWC+uB53vklTceLy7OjuVYR+UsryzXC+Nx4gL216we1g15JcSFlj/P5ru45ZUw/xg+D7JjOdZFnmnWR66VLyqemR3zWIfko1mnZyZi+ULiGeynSBfmepGIeRnLr5kd/bSR/cnTbL+SfSn2oxLS7G8Rz7F2JKV9n4zyRxIxn34cTsT46YnooxcVRF3DfPTiguhD/CXiASu/xPIqJKK/xPy9YjnTFaz91H+Q/VCR/UXGa5G1i/wD1o59Vn6P7VOSR3v2HaW9u6z8bquHvJ2Wjy4h7jDibxTLmE/5rXbc7bYvzL7kFqt/k/mbLL7RWFTcYMRfKeaZT/l11q715rNfyD4h9a8W19p+IvmrLG+DtYf4CuY7GfVy89FLme9k1EsY12TUi/icMi5gXJNRzzMfzf35Lvl7/kXWdD7vLG+GONs4y+7Xp0l/kYzxpexns24TMX+ylUNPMv+TZPS5v14mLmd/PhF99Fb1c4X8AdL9xd+VN1YclYj+SPFlteNXae6nieMPFx9XnPvZh5Mx3svi3Id+rnb9IP2TxYeK3Meih5g/WPo7iw8ynzzu87ifJD5A5L5woPlfi+0V7y/9rfiNeHsy5n8p9rM4fl/zybstGeMfix+Jn4gfiB+KbZMx/32xXTLmoYm/y3mv9fO29NX/ImuV+eTho1cb11jeW4moia+1OP46i+Ovt7j7tyVivAPXQSu32sqtMf+qrBhfb/4V4k2JGMcnb7WNE+P9js3Hm9KvWNzHj3l4IxF9+ve61fOm5ZP3mukN5qO7J6LfNRH9DTZPncynPa9au+DL1t8e4oviS+b3sTh8UHzBiP+Y+Jwd93nznxHZB3pa+lmr92nTj1n5p8QnjU+I16j+x6VbJWP8UbGF5eE/YvGHpdlnecTaxTg8ZOOIzzj24nou9hbvFy9Oxrye4gNWb0/TzB/rqLv599px7hPvFtmXIY91eI/VR343K4e+S6ybjPWwXrtYHvs47OuwvrtYOa4zxDkf7pTuaPWh7xDPS8Z6uE7dbnntxdrK53p3u5W7ORHjXJ/aSd9q9aFvEc9NRuJfJrYVG1u5m+14N1l+06OUa2z1c1z0pcZLxHOUd1Yy+g2Zf/HM5H/7F4pnJKOuL7LvhWYfxPdFaovstzRgnYn1OH9YTxY/1+qpI55t9RI/i/6Lp1o++1C+L8V9vt/3nyEWUb+4zz1i8bPseKexfsVqFq8pcn9MvdVF7ndrmH+SxauaX92OW2DHzzf/fPMbMY/McyIep7rlVbH8KhavLFYy3cTaTf0Vza9g/aWeE8QTTV8hlhfLWT3Hm8998E4rV1osa5r4ccaWYimxhNVf0nzuazdauWPF4qaJHyPmmm4lFrX6i5lfSFxp9RRmnYvXihmLUz7H6iE/28qRlxZTxoS4TExaPdebPy1L/6z8P1mxHvQRcbH8mdL7xcOWd0g8aNwrzlc9+6yejVqfM6RXmU/+WnG31ct9OfWjd4rcV3Nfu0vcLm4Sd4jrxXWmyV9rcdqzyuK0f5O4mftvxbdwXy69yIi/WNyq/G3iL1lRbxd3GD1vvvSfWTFvJ/tt8hdkRR+9qyASn3rniPPE1eIMi68RZ1p8t+qdZvEsW8es68nS10lPyor+GeJfWTE+UZwgTjU9XpxtmnGjv6eLY8Rx4mniWIujTxHV3axfReaLeRkpvdXmcw/7omJF+ezTfC3+loj6K/O/kB6RiHF89ld+UZx9FvxPxaLiJ+JnFu8nDktE3dd89Mfi9/LZF8H/SPwgK8bx3xe/SsS8zxIx/m5W/PeO+J5p/j1r5d4Wv1C9b5o+WvwN8RbxJvF18TXTb1n+q+LN4r6CqInvL/jvPHx0V8Vvt3rJe9na9YId5xWrH+LfbXn3m3+/xV8S6TfH4/gvis+Jj1n+81YOzXwyj5R/2up50fSj4gMW7y2eLPYQe1k+/aNf3u97ROaB8SOvtniX2M3yu4jMF7qj+R0t/07x9qPk3WrxdqaJs15Yx7eIbc2/UWT9f56I/nXiDVa+jXibeK35Lc0nj/qut+NdI/1eIsbfszj7lq1E9t3wOW5rOz757NtRjnza18LYXrzSyjcX2Q9sJnI/jN9UvNzquUNsZHmNxSZWL/oyfB3nUtqTiPFO4sV2HPIvsXL1zb/I6mlo9TUwv7NYz+LnihdmxeNcZPoCsYXaU1f6qkSM459v8daJ6Nex9tCO80TO29oWP9v8+8SzrN5zxFpW7kBBLIcmTj1nWn1ovh+1UX/+Mv90I99r+D5De6qLp4pjLb+m5dHOGtJcP6uJPcWqFue6WlkcJfI9iu9DB7nvzYqsaHnDpQ9JnyB9vFhBfFD8Sfw5K+bDcpZXRiwvPiL+aPmDjfilxLLiw+KTYklxiFhafFwsIT5leXniseJ34g/mw2MsD50rfiPyPfBLi39i8UJiYbGIWMzanWN5GauvkPlpi39oPn/WkbL6+W86fC/IMj9h9SXN5x/fG9trPXXjfFQHaxWJ/hnSrflcEa8RD3OeqKGnip0tv6P8G/m+J9ZR/X2kHxRLKj+j+BPyJ2jCbrV6bmH/VWwr3iDWKxLjtOOI+A8naLXo05+E/GNVT3GxmFhZ+dPVvinGmbkxj/qH2fGHWf8Zj0FFYn/aWn/x24hPilu0MHcUNl8nYi/pY3S8PLFYTmwHPvM0Q/25VP5s6UukW4gNxXvFX9WP3tIjikR/uM33i6r3JbF3QWz3A9Zf/E3W392FY7/Ru8R9Ynu1q4N4J+vZfNbzHfx/CJ5/8Hf1OdHvIX2z4reKN4q3mN/O6u1v9dD+vdavshq/zdJ7FH9I5Zm/PJtX5vlYsXtOPC79vF9+T7GXeJ/5tHO7rb8tNi/49Kec2l9efLwgEr+k2MP6db/Y3c6rpM7ff3Qc1hXr7J7cGD9i64J1csDau8/mgXF/wM6z3rZeaedtGtf2YgfTrINxzJv6faXGt5E4We2/THpabiQ+16MBXEf4/ztcT1Mx3kXluol3iZ1yYn/oN/3aJs18MR9drZ67bd08YOunj/msv+KsP9XL+r5d7b/H1vFBzQ/zzecK1yXyWyr+rMbpBdHXBz7ryK/frLdsMWWfK1zXe1h+WszwRVNsp/YNtHnjfC8jMu5l7DxhHphX6uH6xrywztrZOhxn4/uPjSfj243/jyJyPexj88T50NHyO9t50CkV8x5VuePUH65vJW0cSqHtunac+KPqKSX9g63jskcZT3yOv1nH32bXN/RWsUNuPC7HS9i6+MHWEZ+jfK42Mc153cjWOdepw3adws9R+7vYODNfrFe+3/E9CNJe8m7i/53a+mxrn3Pkcd3fadfXw+bz+cH/C7yL/18lst7usnWUZ9cJ1t2GwtHne49ftzgvf9W8jRR/Fn83/yLV84t0FZWfZXq49FJxmenhlo8/V7xX/mLpJVYevUA8UfN8tdr3bm7UJyjeSvo9xT8Q3xHHmv+H+KU4Whxj44T/ozhOfF3cWjq241q1o7X4m/L4fnmp+Yw788B8MQ8+/r/YOI8SR9i8/mFx+v++1iH/P/QdIz7/jzRH58czKn9fbvQLiY/lRuIvy4v5xB/l+0turB//SYs/LlbXOCxUvUvzos9xH1R+N/v86yr2ZD2KhVXubuvnM9Zf/IfMf9Tyn7D+PJIb20U7H7Z+Ee9jPuPo442/RKxWEI+3Uj7jR3xZfmznU9b+p81nPvqK/cSPxU/N/1xcbPO00OYLn350s/nw+eks3UlcpX6sFaepnnXm91Z+R5HPszvEbfY5x3Wb79Gsm3usPbSXdvWy9dHD1gk+8/i+9Ic2nh+Zv0D9eIV5l14qrsqLPvN8itjX6i1WPMbnqdydinexftFfxp3zZ35+bN9i07Q/X8fZL/+guDc/Hg//gLg7L7ZvZ17sBz79oJ5DdpybzW9n8/SwzcuD5jOvC4/Sz0150d8szTgXtfFGFxaPFfepXJHi/12+iJVj/peLS8TVedFnfcy3cWT8tuRFn/5s5Ppix3kzN/pv2Xq/19ZJN/O5znK9+MSuG7nFo8/6vVUbtreJ7U23E1eoXevzom5n+fhrlLdB3Gz9X2Tzyjwn9PldWCyfE/3jxcPaQC1reaUtv7yVW6vrzyJxjbjY/AXiMnGluFxcIV6fG+PldJwTc2L7KubEOPchu9TvfZyfYtvc6HNe77G8neavFzfmx+MwLtz3FDGf8d5p9d+UG+snvl28WvFrRcblOvNbcd2z45Y3lrXxY972815k8ZCYtPWwXsdfJzLfuTnR53v+yWIFsbLp3ar3BOnL1Y8bxRvEtuYzb/T/ehufVbZ+rrPyjLvPM35zMa125Yg/873N/Az9t/WxwdYPPuuyhuo7Tawpnm7+qexf2fcA7nc7mn+7uJf3iXP/kRP9neIBkfmpJFYVq4mniFVEzsvVdv6uMf9WtWeMrkeNpUfnRX+ceI76ezb7lhqvZlYPceqjHPVsy4/5Xu/m/Ji3NT/m4W83H73D5hd/vbWXPNYVxyfeRKwv1hHPF6+y+AVWrqlY2/pHnPE5T/6ZYm3511ic4++0dvs84F8hXim2sHa1sHY3ENfZebKGzy3z19s8/mHr5U/zx4sjxNFHWXe/iWOt/FiLjzafdjBe59q8oc9B81zM+n+BjU8Dm0fuF1bz/U3HnZ4Xfe4j5vP5nxfzV+ZHn/uaZjZ/TW0e8bkuX6jvIYzLKHFCXoxfII60vN9N11VeA/FIfuzfHOvnERuHP22+vR3jbR5HWjt8ffxu+Rxvno0nerZ4tY53np23rIf65rMOZlk/p9tx59jxNtt1aos4MS/6nBeN1K4m4uS8qC8Tm4nni/VF5udC85nfplb+cjse/oy8mE9ec/GbMtGnXReJF9txLzG/odiN703SrcV5Nk+cJ/SngfWX9dnA+n+h5u0yO08bm9/IzmvyOL+amE+5etaO82xeiPfTeLWQvsr628b8ljY+10hfVyrqVuL1Nr/M05WmrxCL6D70C7XrK5F5+dr8L639tHsu+yr50ad9l4qNRV/f+Kyf2jaOdW0c8euInM+0g+PPMp/z8kP1g/n4SGS+8PuKQ8Vh4hCRccVvaePKOH+reHOLUw/n0YAysdxA8/ub/tbyqRf/O7GNrY9WNj/414pz9IdT88Uv7fj4846P5W+wem4yn3Z01Tq5UfpmW9fEuQ9nXH+w/vxYJvpDbX6+N/8n8weJ9Ww9sR7OMv9sG+fv7HiDbNwHmh58lPYNtvJ8Xmyy71NT86LP5wjjfaON3y9los98TFE9M+3za5b5XP9vUbkOtv/R0fzO7Heo3Fq+B4jrzWdfZLmuo5V4rif9k/k8j+hv+zn/v49jzxfeE7fpeDvELaa3i3usvetsv2ad9eNO9Zf9w10i+2t7zd9ueo/5O8ynXsaZ46239uBv5fuQ5n20eIfiXUpFf5R4jO0PFrb9QHzG+QuN+wDxG9PMz8n8PUbxqPtbPv7A3Fj/1yLPz74zn+MmVH+OmBQz5pcQh6hcVR33e6sX/ytp/o6L52v8ndos83muxj4l+7hvS7O/R5x9Tfr1vR2/bk70B+fG9g8VOV/q5UT/fGn+HuAxsbCeI6bEIkWiX1/lVqgenr/eVxD9ikUi8StJsx/P81Kek7KfTZxxSvIHpNauouYnxHetXp67Ui8+49/RrlOd7LzobOcH18+RYlvFfzN/hMh1l88zPr+4fuJTD+1829bLW9buN6yf1+REv1lO9HlOzXPkbI0XfxeatPkfz3rkvlPk+R/PefDZ5+d53avi86Z5jlRgf1ewkb8D4+8Jc6PPfuV0cZb4J/tTmeiv5felpMeL48S/zZ8gsm9XS2Tf9jzz2XdhP6e17b9cbT77m7RvtrWT/Uh89it5rsTzMfYD7zKf54TUM8eOsy4T/X3SB23fkH3EvebvN3+/7UceMp/6Z9p4z7Bxn2nzWFP9GCNdXXqixU8Vx9q8/mHrYZytl2q5sd4xVi9+DXEVvztmxxljxxstfq/zYIj4rWn2FdhHqiV9NveRfK7lRf8srrv8Dh2/UyeuycT4UrGOjlPA9yPVy/gRP8P2u2gf7aX9+IOkT1f8TGvnx3nRp/58a0eBtQO/n8g4DLLxGGI+41zLxpHzlPO3tvVzpcZpBb8jKK42n3VQ09aHjyM+/Rqgdn0qfi6+a/5H1t/PxIHix+YzzvNtHSyydYC/WGRcPxD75sX2E2e+3rH2fWDt+cj6wb5YXb5/mGY9DVP+AOvnZzaf+P3teH2tPf3Mp30/67ysouOOlK6aG/3Ktq6G2vnaMDf6nOfV9bldg/0R+YPzov8j9wmahw1HOW832Dwy/h+K74mcR/ifWLuHWfvr2rjTn18K4vE2igszMb7Z9KZM9NH0b7jypmq854o8X5tn/jT+/pPfSxWb87sM5vM5Rf4Oix80n/YQ32P1t0hFn+ed9G+L2Jj3lqeiv13keSjP53g+y+cm/m6b740274zzRhtfnr8vEZeKU8xnPPldhCvt9xFamN/cdEvLv8p8yh+08V1v7cXfmoncbuPKeG63eW0kn99d4PcWmplPeX7v4Tney2aa34/gdx94HyXvqeS9lE+Yz+9A/KT+DOXvnHKij+Y5a3XTPG99U/W9Jr5i5PcvyON8/FXHGcF+cyr6rFfyyVsg3TAV/Uuk+Z2Nl218njKf93xOte9zf9v3OXy+rzOOTx7l/aH4jPvzNl/M3wvm87sgvOd0ojiF94aYz3tTJ5gmzn4RPvtGvM91Ju8robz5vB+W973ynhreW8N7bPB57+x43ithfwdLv3apHO+7oT78v61dvGd2srUDf7rFp9g4Ue8U6w/v7eE9OGtN8/4f3vfCe2nHWX9WKm+FuNw0793hfTK8F+hAVmzHIfN5P9EWkffgMm68d2a3tZf24/PemqLa150rvdj8pdK8D4f3AW2UXmk+mv7yHiF0sWqR+MvoV0GM4xc1TbvoB+PIuK4wn/ZPE6eL/h4f/Fnmo3kP0Gzzp5o/z/JpPz7jzft8poi8/+d/Zps343icdZVbS1RhFIb3jGhE5dYZbczOB3Nvs8Du/B8SZf2HqFTKYwe9CwR/RpdiXaiUiUKodLiIVJBC6Aco0UWJdTHPG6yX9OZhPd/3rfV+e8Y9H5Pq33v4CW7CLfgFHsmj/wY/ww/wHVwxrznb8Dv8av3l1+HNQpW3YA0sml9j/zH61MM3SeS87VM9BxeTeP71AedVz8Ib5LhdiLlXk+h7YZr/P0dq9VvjAjwPl2Bm+S+Yb4c9zL9jebqS6LttjuZehL9p3JDHfPKqdb4DdsJrll/+snndR5/PvHnNaSTHOepSHil/Nom5U8uv56Z7Ltg95E/bfj3fNpibv2LnlMPzyu9lkfKnoO77M4t9tH4GtsJL5pVjh/M/4IZ51bvUc1YvU5+AJ2EFjphXnibYApvhqHn1eQSH7T6t5jVvEI6Zr5jXvIdwyOaNmFffcTv/zHJrXfcqWz0Bp229wfo+tv7PzSuPnufxA/rKa/4T66t+4+afGidsX9l8CaawER6Fh83rvou8d7b5Xr3ATxWrXGZ9yThZjPtKh6pshimsmG+C+8wr8P/0kvqV+avsH8OX8X+yyL4s7huAo7YuFunTTz1sfoa6jromj7nrrNaLpzaPddmYWP676PvwQdz2zw/Ae1Zrvc18v633WX/VmqP35HX4i3wdtl9effS7ofPttl9e5/4Ckb2Ayw== + + + BgAAAACAAAAAAwAAlhgAAJcYAACXGAAAmBgAAJgYAADIAAAAeJw13VPDGMYWBdAbp7Ft27Zts7Ft27Ztp7GTxrZt28Z9+FbnZf2GmTln7yD/CzjB+RfDMDwjMSpjMDbjMSGTMDlTMS0zMDOzMSfzMD8LsShLsDTLsSKrsDprsS7rsxGbsgVbsx07sgu7sxf7cgAHcxhHcgzHcxKncgZncx4XcgmXcxXXcj03cSt3cDf38gAP8xhP8gzP8xKv8gZv8x4f8gmf8xXf8gM/8xt/8g8DBwowGEMyNMMxIqMwOmMxLhMwMZMxJdMwPTMxK3MwN/OxIIuwOEuxLCuwMquxJuuwHhuyCZuzFduyAzuzG3uyD/tzEIdyBEdzHCdyCqdzFudyARdzGVdyDddxI7dwO3fxX+7nIR7lCZ7mOV7kFV7nLd7lAz7mM77kG77nJ37lD/5moMABBmUIhmJYRmBkRmNMxmF8JmJSpmBqpmNGZmF25mJeFmBhFmNJlmF5VmJV1mBt/s0GbMxmbMk2bM9O7Moe7M1+HMghHM5RHMsJnMxpnMk5nM9FXMoVXM1/uIGbuY07uYf7eJBHeJyneJYXeJnXeJN3eJ+P+JQv+Jrv+JFf+J2/+L8gYHD+xTAMz0iMyhiMzXhMyCRMzlRMywzMzGzMyTzMz0IsyhIszXKsyCqszlqsy/psxKZswdZsx47swu7sxb4cwMEcxpEcw/GcxKmcwdmcx4VcwuVcxbVcz03cyh3czb08wMM8xpM8w/O8xKu8wdu8x4d8wud8xbf8wM/8xp/8w8BBAwzGkAzNcIzIKIzOWIzLBEzMZEzJNEzPTMzKHMzNfCzIIizOUizLCqzMaqzJOqzHhmzC5mzFtuzAzuzGnuzD/hzEoRzB0RzHiZzC6ZzFuVzAxVzGlVzDddzILdzOXfyX+3mIR3mCp3mOF3mF13mLd/mAj/mML/mG7/mJX/mDvxkoWIBBGYKhGJYRGJnRGJNxGJ+JmJQpmJrpmJFZmJ25mJcFWJjFWJJlWJ6VWJU1WJt/swEbsxlbsg3bsxO7sgd7sx8HcgiHcxTHcgIncxpncg7ncxGXcgVX8x9u4GZu407u4T4e5BEe5yme5QVe5jXe5B3e5yM+5Qu+5jt+5Bd+5y/+d+EPwuD8i2EYnpEYlTEYm/GYkEmYnKmYlhmYmdmYk3mYn4VYlCVYmuVYkVVYnbVYl/XZiE3Zgq3Zjh3Zhd3Zi305gIM5jCM5huM5iVM5g7M5jwu5hMu5imu5npu4lTu4m3t5gId5jCd5hud5iVd5g7d5jw/5hM/5im/5gZ/5jT/5h4FDBBiMIRma4RiRURidsRiXCZiYyZiSaZiemZiVOZib+ViQRVicpViWFViZ1ViTdViPDdmEzdmKbdmBndmNPdmH/TmIQzmCozmOEzmF0zmLc7mAi7mMK7mG67iRW7idu/gv9/MQj/IET/McL/IKr/MW7/IBH/MZX/IN3/MTv/IHfzNQyACDMgRDMSwjMDKjMSbjMD4TMSlTMDXTMSOzMDtzMS8LsDCLsSTLsDwrsSprsDb/ZgM2ZjO2ZBu2Zyd2ZQ/2Zj8O5BAO5yiO5QRO5jTO5BzO5yIu5Qqu5j/cwM3cxp3cw308yCM8zlM8ywu8zGu8yTu8z0d8yhd8zXf8yC/8zl/876E/CIPzL4ZheEZiVMZgbMZjQiZhcqZiWmZgZmZjTuZhfhZiUZZgaZZjRVZhddZiXdZnIzZlC7ZmO3ZkF3ZnL/blAA7mMI7kGI7nJE7lDM7mPC7kEi7nKq7lem7iVu7gbu7lAR7mMZ7kGZ7nJV7lDd7mPT7kEz7nK77lB37mN/7kHwYOFWAwhmRohmNERmF0xmJcJmBiJmNKpmF6ZmJW5mBu5mNBFmFxlmJZVmBlVmNN1mE9NmQTNmcrtmUHdmY39mQf9ucgDuUIjuY4TuQUTucszuUCLuYyruQaruNGbuF27uK/3M9DPMoTPM1zvMgrvM5bvMsHfMxnfMk3fM9P/Mof/M1AoQMMyhAMxbCMwMiMxpiMw/hMxKRMwdRMx4zMwuzMxbwswMIsxpIsw/KsxKqswdr8mw3YmM3Ykm3Ynp3YlT3Ym/04kEM4nKM4lhM4mdM4k3M4n4u4lCu4mv9wAzdzG3dyD/fxII/wOE/xLC/wMq/xJu/wPh/xKV/wNd/xI7/wO3/xvw/+IAzOvxiG4RmJURmDsRmPCZmEyZmKaZmBmZmNOZmH+VmIRVmCpVmOFVmF1VmLdVmfjdiULdia7diRXdidvdiXAziYwziSYziekziVMzib87iQS7icq7iW67mJW7mDu7mXB3iYx3iSZ3iel3iVN3ib9/iQT/icr/iWH/iZ3/iTfxg4bIDBGJKhGY4RGYXRGYtxmYCJmYwpmYbpmYlZmYO5mY8FWYTFWYplWYGVWY01WYf12JBN2Jyt2JYd2Jnd2JN92J+DOJQjOJrjOJFTOJ2zOJcLuJjLuJJruI4buYXbuYv/cj8P8ShP8DTP8SKv8Dpv8S4f8DGf8SXf8D0/8St/8DcDhQswKEMwFMMyAiMzGmMyDuMzEZMyBVMzHTMyC7MzF/OyAAuzGEuyDMuzEquyBmvzbzZgYzZjS7Zhe3ZiV/Zgb/bjQA7hcI7iWE7gZE7jTM7hfC7iUq7gav7DDdzMbdzJPdzHgzzC4zzFs7zAy7zGm7zD+3zEp3zB13zHj/zC7/zF/wb7gjA4/2IYhmckRmUMxmY8JmQSJmcqpmUGZmY25mQe5mchFmUJlmY5VmQVVmct1mV9NmJTtmBrtmNHdmF39mJfDuBgDuNIjuF4TuJUzuBszuNCLuFyruJarucmbuUO7uZeHuBhHuNJnuF5XuJV3uBt3uNDPuFzvuJbfuBnfuNP/mHgCAEGY0iGZjhGZBRGZyzGZQImZjKmZBqmZyZmZQ7mZj4WZBEWZymWZQVWZjXWZB3WY0M2YXO2Ylt2YGd2Y0/2YX8O4lCO4GiO40RO4XTO4lwu4GIu40qu4Tpu5BZu5y7+y/08xKM8wdM8x4u8wuu8xbt8wMd8xpd8w/f8xK/8wd8MFDHAoAzBUAzLCIzMaIzJOIzPREzKFEzNdMzILMzOXMzLAizMYizJMizPSqzKGqzNv9mAjdmMLdmG7dmJXdmDvdmPAzmEwzmKYzmBkzmNMzmH87mIS7mCq/kPN3Azt3En93AfD/IIj/MUz/ICL/Mab/IO7/MRn/IFX/MdP/ILv/MX/xvoD8Lg/IthGJ6RGJUxGJvxmJBJmJypmJYZmJnZmJN5mJ+FWJQlWJrlWJFVWJ21WJf12YhN2YKt2Y4d2YXd2Yt9OYCDOYwjOYbjOYlTOYOzOY8LuYTLuYpruZ6buJU7uJt7eYCHeYwneYbneYlXeYO3eY8P+YTP+Ypv+YGf+Y0/+YeBIwcYjCEZmuEYkVEYnbEYlwmYmMmYkmmYnpmYlTmYm/lYkEVYnKVYlhVYmdVYk3VYjw3ZhM3Zim3ZgZ3ZjT3Zh/05iEM5gqM5jhM5hdM5i3O5gIu5jCu5huu4kVu4nbv4L/fzEI/yBE/zHC/yCq/zFu/yAR/zGV/yDd/zE7/yB38zUJQAgzIEQzEsIzAyozEm4zA+EzEpUzA10zEjszA7czEvC7Awi7Eky7A8K7Eqa7A2/2YDNmYztmQbtmcndmUP9mY/DuQQDucojuUETuY0zuQczuciLuUKruY/3MDN3Mad3MN9PMgjPM5TPMsLvMxrvMk7vM9HfMoXfM13/Mgv/M5f/G+RLwiD8y+GYXhGYlTGYGzGY0ImYXKmYlpmYGZmY07mYX4WYlGWYGmWY0VWYXXWYl3WZyM2ZQu2Zjt2ZBd2Zy/25QAO5jCO5BiO5yRO5QzO5jwu5BIu5yqu5Xpu4lbu4G7u5QEe5jGe5Bme5yVe5Q3e5j0+5BM+5yu+5Qd+5jf+5B8GjhZgMIZkaIZjREZhdMZiXCZgYiZjSqZhemZiVuZgbuZjQRZhcZZiWVZgZVZjTdZhPTZkEzZnK7ZlB3ZmN/ZkH/bnIA7lCI7mOE7kFE7nLM7lAi7mMq7kGq7jRm7hdu7iv9zPQzzKEzzNc7zIK7zOW7zLB3zMZ3zJN3zPT/zKH/zNQNEDDMoQDMWwjMDIjMaYjMP4TMSkTMHUTMeMzMLszMW8LMDCLMaSLMPyrMSqrMHa/JsN2JjN2JJt2J6d2JU92Jv9OJBDOJyjOJYTOJnTOJNzOJ+LuJQruJr/cAM3cxt3cg/38SCP8DhP8Swv8DKv8Sbv8D4f8Slf8DXf8SO/8Dt/8b8F/iAMzr8YhuEZiVEZg7EZjwmZhMmZimmZgZmZjTmZh/lZiEVZgqVZjhVZhdVZi3VZn43YlC3Ymu3YkV3Ynb3YlwM4mMM4kmM4npM4lTM4m/O4kEu4nKu4luu5iVu5g7u5lwd4mMd4kmd4npd4lTd4m/f4kE/4nK/4lh/4md/4k38YOGaAwRiSoRmOERmF0RmLcZmAiZmMKZmG6ZmJWZmDuZmPBVmExVmKZVmBlVmNNVmH9diQTdicrdiWHdiZ3diTfdifgziUIzia4ziRUzidsziXC7iYy7iSa7iOG7mF27mL/3I/D/EoT/A0z/Eir/A6b/EuH/Axn/El3/A9P/Erf/A3A8UKMChDMBTDMgIjMxpjMg7jMxGTMgVTMx0zMguzMxfzsgALsxhLsgzLsxKrsgZr8282YGM2Y0u2YXt2Ylf2YG/240AO4XCO4lhO4GRO40zO4Xwu4lKu4Gr+ww3czG3cyT3cx4M8wuM8xbO8wMu8xpu8w/t8xKd8wdd8x4/8wu/8xf+Ce4IwOP9iGIZnJEZlDMZmPCZkEiZnKqZlBmZmNuZkHuZnIRZlCZZmOVZkFVZnLdZlfTZiU7Zga7ZjR3Zhd/ZiXw7gYA7jSI7heE7iVM7gbM7jQi7hcq7iWq7nJm7lDu7mXh7gYR7jSZ7heV7iVd7gbd7jQz7hc77iW37gZ37jT/5h4DgBBmNIhmY4RmQURmcsxmUCJmYypmQapmcmZmUO5mY+FmQRFmcplmUFVmY11mQd1mNDNmFztmJbdmBndmNP9mF/DuJQjuBojuNETuF0zuJcLuBiLuNKruE6buQWbucu/sv9PMSjPMHTPMeLvMLrvMW7fMDHfMaXfMP3/MSv/MHfDBQ3wKAMwVAMywiMzGiMyTiMz0RMyhRMzXTMyCzMzlzMywIszGIsyTIsz0qsyhqszb/ZgI3ZjC3Zhu3ZiV3Zg73ZjwM5hMM5imM5gZM5jTM5h/O5iEu5gqv5DzdwM7dxJ/dwHw/yCI/zFM/yAi/zGm/yDu/zEZ/yBV/zHT/yC7/zF/8L7AvC4PyLYRiekRiVMRib8ZiQSZicqZiWGZiZ2ZiTeZifhViUJVia5ViRVVidtViX9dmITdmCrdmOHdmF3dmLfTmAgzmMIzmG4zmJUzmDszmPC7mEy7mKa7mem7iVO7ibe3mAh3mMJ3mG53mJV3mDt3mPD/mEz/mKb/mBn/mNP/mHgeMHGIwhGZrhGJFRGJ2xGJcJmJjJmJJpmJ6ZmJU5mJv5WJBFWJylWJYVWJnVWJN1WI8N2YTN2Ypt2YGd2Y092Yf9OYhDOYKjOY4TOYXTOYtzuYCLuYwruYbruJFbuJ27+C/38xCP8gRP8xwv8gqv8xbv8gEf8xlf8g3f8xO/8gd/M1CCAIMyBEMxLCMwMqMxJuMwPhMxKVMwNdMxI7MwO3MxLwuwMIuxJMuwPCuxKmuwNv9mAzZmM7ZkG7ZnJ3ZlD/ZmPw7kEA7nKI7lBE7mNM7kHM7nIi7lCq7mP9zAzdzGndzDfTzIIzzOUzzLC7zMa7zJO7zPR3zKF3zNd/zIL/zOX/wvqDcIg/MvhmF4RmJUxmBsxmNCJmFypmJaZmBmZmNO5mF+FmJRlmBplmNFVmF11mJd1mcjNmULtmY7dmQXdmcv9uUADuYwjuQYjuckTuUMzuY8LuQSLucqruV6buJW7uBu7uUBHuYxnuQZnuclXuUN3uY9PuQTPucrvuUHfuY3/uQfBk4UYDCGZGiGY0RGYXTGYlwmYGImY0qmYXpmYlbmYG7mY0EWYXGWYllWYGVWY03WYT02ZBM2Zyu2ZQd2Zjf2ZB/25yAO5QiO5jhO5BRO5yzO5QIu5jKu5Bqu40Zu4Xbu4r/cz0M8yhM8zXO8yCu8zlu8ywd8zGd8yTd8z0/8yh/8zUCJAwzKEAzFsIzAyIzGmIzD+EzEpEzB1EzHjMzC7MzFvCzAwizGkizD8qzEqqzB2vybDdiYzdiSbdiendiVPdib/TiQQzicoziWEziZ0ziTczifi7iUK7ia/3ADN3Mbd3IP9/Egj/A4T/EsL/Ayr/Em7/A+H/EpX/A13/Ejv/A7f/G/gP4gDM6/GIbhGYlRGYOxGY8JmYTJmYppmYGZmY05mYf5WYhFWYKlWY4VWYXVWYt1WZ+N2JQt2Jrt2JFd2J292JcDOJjDOJJjOJ6TOJUzOJvzuJBLuJyruJbruYlbuYO7uZcHeJjHeJJneJ6XeJU3eJv3+JBP+Jyv+JYf+Jnf+JN/GDhpgMEYkqEZjhEZhdEZi3GZgImZjCmZhumZiVmZg7mZjwVZhMVZimVZgZVZjTVZh/XYkE3YnK3Ylh3Ymd3Yk33Yn4M4lCM4muM4kVM4nbM4lwu4mMu4kmu4jhu5hdu5i/9yPw/xKE/wNM/xIq/wOm/xLh/wMZ/xJd/wPT/xK3/wNwMlCzAoQzAUwzICIzMaYzIO4zMRkzIFUzMdMzILszMX87IAC7MYS7IMy7MSq7IGa/NvNmBjNmNLtmF7dmJX9mBv9uNADuFwjuJYTuBkTuNMzuF8LuJSruBq/sMN3Mxt3Mk93MeDPMLjPMWzvMDLvMabvMP7fMSnfMHXfMeP/MLv/MX/inmCMDj/YhiGZyRGZQzGZjwmZBImZyqmZQZmZjbmZB7mZyEWZQmWZjlWZBVWZy3WZX02YlO2YGu2Y0d2YXf2Yl8O4GAO40iO4XhO4lTO4GzO40Iu4XKu4lqu5yZu5Q7u5l4e4GEe40me4Xle4lXe4G3e40M+4XO+4lt+4Gd+40/+YeAUAQZjSIZmOEZkFEZnLMZlAiZmMqZkGqZnJmZlDuZmPhZkERZnKZZlBVZmNdZkHdZjQzZhc7ZiW3ZgZ3ZjT/Zhfw7iUI7gaI7jRE7hdM7iXC7gYi7jSq7hOm7kFm7nLv7L/TzEozzB0zzHi7zC67zFu3zAx3zGl3zD9/zEr/zB3wyUMsCgDMFQDMsIjMxojMk4jM9ETMoUTM10zMgszM5czMsCLMxiLMkyLM9KrMoarM2/2YCN2Ywt2Ybt2Yld2YO92Y8DOYTDOYpjOYGTOY0zOYfzuYhLuYKr+Q83cDO3cSf3cB8P8giP8xTP8gIv8xpv8g7v8xGf8gVf8x0/8gu/8xf/K+QLwuD8i2EYnpEYlTEYm/GYkEmYnKmYlhmYmdmYk3mYn4VYlCVYmuVYkVVYnbVYl/XZiE3Zgq3Zjh3Zhd3Zi305gIM5jCM5huM5iVM5g7M5jwu5hMu5imu5npu4lTu4m3t5gId5jCd5hud5iVd5g7d5jw/5hM/5im/5gZ/5jT/5h4FTBxiMIRma4RiRURidsRiXCZiYyZiSaZiemZiVOZib+ViQRVicpViWFViZ1ViTdViPDdmEzdmKbdmBndmNPdmH/TmIQzmCozmOEzmF0zmLc7mAi7mMK7mG67iRW7idu/gv9/MQj/IET/McL/IKr/MW7/IBH/MZX/IN3/MTv/IHfzNQmgCDMgRDMSwjMDKjMSbjMD4TMSlTMDXTMSOzMDtzMS8LsDCLsSTLsDwrsSprsDb/ZgM2ZjO2ZBu2Zyd2ZQ/2Zj8O5BAO5yiO5QRO5jTO5BzO5yIu5Qqu5j/cwM3cxp3cw308yCM8zlM8ywu8zGu8yTu8z0d8yhd8zXf8yC/8zl/8r4g3CIPzL4ZheEZiVMZgbMZjQiZhcqZiWmZgZmZjTuZhfhZiUZZgaZZjRVZhddZiXdZnIzZlC7ZmO3ZkF3ZnL/blAA7mMI7kGI7nJE7lDM7mPC7kEi7nKq7lem7iVu7gbu7lAR7mMZ7kGZ7nJV7lDd7mPT7kEz7nK77lB37mN/7kHwZOF2AwhmRohmNERmF0xmJcJmBiJmNKpmF6ZmJW5mBu5mNBFmFxlmJZVmBlVmNN1mE9NmQTNmcrtmUHdmY39mQf9ucgDuUIjuY4TuQUTucszuUCLuYyruQaruNGbuF27uK/3M9DPMoTPM1zvMgrvM5bvMsHfMxnfMk3fM9P/Mof/M1A6QMMyhAMxbCMwMiMxpiMw/hMxKRMwdRMx4zMwuzMxbwswMIsxpIsw/KsxKqswdr8mw3YmM3Ykm3Ynp3YlT3Ym/04kEM4nKM4lhM4mdM4k3M4n4u4lCu4mv9wAzdzG3dyD/fxII/wOE/xLC/wMq/xJu/wPh/xKV/wNd/xI7/wO3/xfxkC+D8HdnCoeJwtxVOwGAYCAMCkcdLYjW3btm3btm3btm3bttnGtm7m3u7PBkkf6P+CO5T/dnhHclTHcCzHdQIndjKndBqndyZndQ7ndj4XdBEXdymXdQVXdjXXdB3XdyM3dQu3djt3dBd3dy/39QAP9jCP9BiP9yRP9QzP9jwv9BIv9yqv9QZv9jbv9B7v9yEf9Qmf9jlf9BVf9y3f9QM/9r9+7ld+6w/+7G/+6T/+K0PAwRzSYRzOER3F0f2P4zi+EzmpUzi10zmjszi7czmvC7iwi7mky7i8K7mqa7i267mhm7i5W7mtO7izu7mn+7i/B3moR3i0x3mip3i6Z3muF3ixl3ml13i9N3mrd3i39/mgj/i4T/msL/iyr/mm7/i+H/mpn/ml3/i9P/mrf/i3A2cMOKhDOLTDOoIjO5pjOrbjOaGTOLlTOa0zOLOzOafzOL8LuahLuLTLuaKruLprua4buLGbuaXbuL07uat7uLf7eaCHeLhHeawneLKneabneL4XealXeLXXeaO3eLt3ea8P+LCP+aTP+Lwv+apv+Lbv+aGf+D+/8Gu/80d/8Xf/cqBMAQVxcIfy3w7vSI7qGI7luE7gxE7mlE7j9M7krM7h3M7ngi7i4i7lsq7gyq7mmq7j+m7kpm7h1m7nju7i7u7lvh7gwR7mkR7j8Z7kqZ7h2Z7nhV7i5V7ltd7gzd7mnd7j/T7koz7h0z7ni77i677lu37gx/7Xz/3Kb/3Bn/3NP/3Hf2UOOJhDOozDOaKjOLr/cRzHdyIndQqndjpndBZndy7ndQEXdjGXdBmXdyVXdQ3Xdj03dBM3dyu3dQd3djf3dB/39yAP9QiP9jhP9BRP9yzP9QIv9jKv9Bqv9yZv9Q7v9j4f9BEf9ymf9QVf9jXf9B3f9yM/9TO/9Bu/9yd/9Q//duAsAQd1CId2WEdwZEdzTMd2PCd0Eid3Kqd1Bmd2Nud0Hud3IRd1CZd2OVd0FVd3Ldd1Azd2M7d0G7d3J3d1D/d2Pw/0EA/3KI/1BE/2NM/0HM/3Ii/1Cq/2Om/0Fm/3Lu/1AR/2MZ/0GZ/3JV/1Dd/2PT/0E//nF37td/7oL/7uXw6UNaAgDu5Q/tvhHclRHcOxHNcJnNjJnNJpnN6ZnNU5nNv5XNBFXNylXNYVXNnVXNN1XN+N3NQt3Nrt3NFd3N293NcDPNjDPNJjPN6TPNUzPNvzvNBLvNyrvNYbvNnbvNN7vN+HfNQnfNrnfNFXfN23fNcP/Nj/+rlf+a0/+LO/+af/+K9sAQdzSIdxOEd0FEf3P47j+E7kpE7h1E7njM7i7M7lvC7gwi7mki7j8q7kqq7h2q7nhm7i5m7ltu7gzu7mnu7j/h7koR7h0R7niZ7i6Z7luV7gxV7mlV7j9d7krd7h3d7ngz7i4z7ls77gy77mm77j+37kp37ml37j9/7kr/7h3w6cPeCgDuHQDusIjuxojunYjueETuLkTuW0zuDMzuaczuP8LuSiLuHSLueKruLqruW6buDGbuaWbuP27uSu7uHe7ueBHuLhHuWxnuDJnuaZnuP5XuSlXuHVXueN3uLt3uW9PuDDPuaTPuPzvuSrvuHbvueHfuL//MKv/c4f/cXf/cuBcgQUxMEdyn87vCM5qmM4luM6gRM7mVM6jdM7k7M6h3M7nwu6iIu7lMu6giu7mmu6juu7kZu6hVu7nTu6i7u7l/t6gAd7mEd6jMd7kqd6hmd7nhd6iZd7ldd6gzd7m3d6j/f7kI/6hE/7nC/6iq/7lu/6gR/7Xz/3K7/1B3/2N//0H/+VM+BgDukwDueIjuLo/sdxHN+JnNQpnNrpnNFZnN25nNcFXNjFXNJlXN6VXNU1XNv13NBN3Nyt3NYd3Nnd3NN93N+DPNQjPNrjPNFTPN2zPNcLvNjLvNJrvN6bvNU7vNv7fNBHfNynfNYXfNnXfNN3fN+P/NTP/NJv/N6f/NU//NuBcwUc1CEc2mEdwZEdzTEd2/Gc0Emc3Kmc1hmc2dmc03mc34Vc1CVc2uVc0VVc3bVc1w3c2M3c0m3c3p3c1T3c2/080EM83KM81hM82dM803M834u81Cu82uu80Vu83bu81wd82Md80md83pd81Td82/f80E/8n1/4td/5o7/4u385UO6Agji4Q/lvh3ckR3UMx3JcJ3BiJ3NKp3F6Z3JW53Bu53NBF3Fxl3JZV3BlV3NN13F9N3JTt3Brt3NHd3F393JfD/BgD/NIj/F4T/JUz/Bsz/NCL/Fyr/Jab/Bmb/NO7/F+H/JRn/Bpn/NFX/F13/JdP/Bj/+vnfuW3/uDP/uaf/uO/8gQczCEdxuEc0VEc3f84juM7kZM6hVM7nTM6i7M7l/O6gAu7mEu6jMu7kqu6hmu7nhu6iZu7ldu6gzu7m3u6j/t7kId6hEd7nCd6iqd7lud6gRd7mVd6jdd7k7d6h3d7nw/6iI/7lM/6gi/7mm/6ju/7kZ/6mV/6jd/7k7/6h387cN6AgzqEQzusIziyozmmYzueEzqJkzuV0zqDMzubczqP87uQi7qES7ucK7qKq7uW67qBG7uZW7qN27uTu7qHe7ufB3qIh3uUx3qCJ3uaZ3qO53uRl3qFV3udN3qLt3uX9/qAD/uYT/qMz/uSr/qGb/ueH/qJ//MLv/Y7f/QXf/cvB8oXUBAHdyj/7fCO5KiO4ViO6wRO7GRO6TRO70zO6hzO7Xwu6CIu7lIu6wqu7Gqu6Tqu70Zu6hZu7Xbu6C7u7l7u6wEe7GEe6TEe70me6hme7Xle6CVe7lVe6w3e7G3e6T3e70M+6hM+7XO+6Cu+7lu+6wd+7H/93K/81h/82d/803/8V/6AgzmkwzicIzqKo/sfx3F8J3JSp3Bqp3NGZ3F253JeF3BhF3NJl3F5V3JV13Bt13NDN3Fzt3Jbd3Bnd3NP93F/D/JQj/Boj/NET/F0z/JcL/BiL/NKr/F6b/JW7/Bu7/NBH/Fxn/JZX/BlX/NN3/F9P/JTP/NLv/F7f/JX//BvBy4QcFCHcGiHdQRHdjTHdGzHc0IncXKnclpncGZnc07ncX4XclGXcGmXc0VXcXXXcl03cGM3c0u3cXt3clf3cG/380AP8XCP8lhP8GRP80zP8Xwv8lKv8Gqv80Zv8Xbv8l4f8GEf80mf8Xlf8lXf8G3f80M/8X9+4dd+54/+4u/+5UAFAwri4A7lvx3ekRzVMRzLcZ3AiZ3MKZ3G6Z3JWZ3DuZ3PBV3ExV3KZV3BlV3NNV3H9d3ITd3Crd3OHd3F3d3LfT3Agz3MIz3G4z3JUz3Dsz3PC73Ey73Ka73Bm73NO73H+33IR33Cp33OF33F133Ld/3Aj/2vn/uV3/qDP/ubf/qP/yoUcDCHdBiHc0RHcXT/4ziO70RO6hRO7XTO6CzO7lzO6wIu7GIu6TIu70qu6hqu7Xpu6CZu7lZu6w7u7G7u6T7u70Ee6hEe7XGe6Cme7lme6wVe7GVe6TVe703e6h3e7X0+6CM+7lM+6wu+7Gu+6Tu+70d+6md+6Td+70/+6h/+7cCFAw7qEA7tsI7gyI7mmI7teE7oJE7uVE7rDM7sbM7pPM7vQi7qEi7tcq7oKq7uWq7rBm7sZm7pNm7vTu7qHu7tfh7oIR7uUR7rCZ7saZ7pOZ7vRV7qFV7tdd7oLd7uXd7rAz7sYz7pMz7vS77qG77te37oJ/7PL/za7/zRX/zdvxyoSEBBHNyh/LfDO5KjOoZjOa4TOLGTOaXTOL0zOatzOLfzuaCLuLhLuawruLKruabruL4bualbuLXbuaO7uLt7ua8HeLCHeaTHeLwneapneLbneaGXeLlXea03eLO3eaf3eL8P+ahP+LTP+aKv+Lpv+a4f+LH/9XO/8lt/8Gd/80//8V9FAw7mkA7jcI7oKI7ufxzH8Z3ISZ3CqZ3OGZ3F2Z3LeV3AhV3MJV3G5V3JVV3DtV3PDd3Ezd3Kbd3Bnd3NPd3H/T3IQz3Coz3OEz3F0z3Lc73Ai73MK73G673JW73Du73PB33Ex33KZ33Bl33NN33H9/3IT/3ML/3G7/3JX/3Dvx24WMBBHcKhHdYRHNnRHNOxHc8JncTJncppncGZnc05ncf5XchFXcKlXc4VXcXVXct13cCN3cwt3cbt3cld3cO93c8DPcTDPcpjPcGTPc0zPcfzvchLvcKrvc4bvcXbvct7fcCHfcwnfcbnfclXfcO3fc8P/cT/+YVf+50/+ou/+5cDFQ8oiIM7lP92eEdyVMdwLMd1Aid2Mqd0Gqd3Jmd1Dud2Phd0ERd3KZd1BVd2Ndd0Hdd3Izd1C7d2O3d0F3d3L/f1AA/2MI/0GI/3JE/1DM/2PC/0Ei/3Kq/1Bm/2Nu/0Hu/3IR/1CZ/2OV/0FV/3Ld/1Az/2v37uV37rD/7sb/7pP/6rRMDBHNJhHM4RHcXR/Y/jOL4TOalTOLXTOaOzOLtzOa8LuLCLuaTLuLwruapruLbruaGbuLlbua07uLO7uaf7uL8HeahHeLTHeaKneLpnea4XeLGXeaXXeL03eat3eLf3+aCP+LhP+awv+LKv+abv+L4f+amf+aXf+L0/+at/+LcDlww4qEM4tMM6giM7mmM6tuM5oZM4uVM5rTM4s7M5p/M4vwu5qEu4tMu5oqu4umu5rhu4sZu5pdu4vTu5q3u4t/t5oId4uEd5rCd4sqd5pud4vhd5qVd4tdd5o7d4u3d5rw/4sI/5pM/4vC/5qm/4tu/5oZ/4P7/wa7/zR3/xd/9yoFIBBXFwh/LfDu9IjuoYjuW4TuDETuaUTuP0zuSszuHczueCLuLiLuWyruDKruaaruP6buSmbuHWbueO7uLu7uW+HuDBHuaRHuPxnuSpnuHZnueFXuLlXuW13uDN3uad3uP9PuSjPuHTPueLvuLrvuW7fuDH/tfP/cpv/cGf/c0//cd/lQ44mEM6jMM5oqM4uv9xHMd3Iid1Cqd2Omd0Fmd3Lud1ARd2MZd0GZd3JVd1Ddd2PTd0Ezd3K7d1B3d2N/d0H/f3IA/1CI/2OE/0FE/3LM/1Ai/2Mq/0Gq/3Jm/1Du/2Ph/0ER/3KZ/1BV/2Nd/0Hd/3Iz/1M7/0G7/3J3/1D/924DIBB3UIh3ZYR3BkR3NMx3Y8J3QSJ3cqp3UGZ3Y253Qe53chF3UJl3Y5V3QVV3ct13UDN3Yzt3Qbt3cnd3UP93Y/D/QQD/coj/UET/Y0z/Qcz/ciL/UKr/Y6b/QWb/cu7/UBH/Yxn/QZn/clX/UN3/Y9P/QT/+cXfu13/ugv/u5fDlQ2oCAO7lD+2+EdyVEdw7Ec1wmc2Mmc0mmc3pmc1Tmc2/lc0EVc3KVc1hVc2dVc03Vc343c1C3c2u3c0V3c3b3c1wM82MM80mM83pM81TM82/O80Eu83Ku81hu82du803u834d81Cd82ud80Vd83bd81w/82P/6uV/5rT/4s7/5p//4r3IBB3NIh3E4R3QUR/c/juP4TuSkTuHUTueMzuLszuW8LuDCLuaSLuPyruSqruHarueGbuLmbuW27uDO7uae7uP+HuShHuHRHueJnuLpnuW5XuDFXuaVXuP13uSt3uHd3ueDPuLjPuWzvuDLvuabvuP7fuSnfuaXfuP3/uSv/uHfDlw+4KAO4dAO6wiO7GiO6diO54RO4uRO5bTO4MzO5pzO4/wu5KIu4dIu54qu4uqu5bpu4MZu5pZu4/bu5K7u4d7u54Ee4uEe5bGe4Mme5pme4/le5KVe4dVe543e4u3e5b0+4MM+5pM+4/O+5Ku+4du+54d+4v/8wq/9zh/9xd/9y4EqBBTEwR3Kfzu8IzmqYziW4zqBEzuZUzqN0zuTszqHczufC7qIi7uUy7qCK7uaa7qO67uRm7qFW7udO7qLu7uX+3qAB3uYR3qMx3uSp3qGZ3ueF3qJl3uV13qDN3ubd3qP9/uQj/qET/ucL/qKr/uW7/qBH/tfP/crv/UHf/Y3//Qf/1Ux4GAO6TAO54iO4uj+x3Ec34mc1Cmc2umc0Vmc3bmc1wVc2MVc0mVc3pVc1TVc2/Xc0E3c3K3c1h3c2d3c033c34M81CM82uM80VM83bM81wu82Mu80mu83pu81Tu82/t80Ed83Kd81hd82dd803d834/81M/80m/83p/81T/824ErBRzUIRzaYR3BkR3NMR3b8ZzQSZzcqZzWGZzZ2ZzTeZzfhVzUJVza5VzRVVzdtVzXDdzYzdzSbdzendzVPdzb/TzQQzzcozzWEzzZ0zzTczzfi7zUK7za67zRW7zdu7zXB3zYx3zSZ3zel3zVN3zb9/zQT/yfX/i13/mjv/i7fzlQ5YCCOLhD+W+HdyRHdQzHclwncGInc0qncXpnclbncG7nc0EXcXGXcllXcGVXc03XcX03clO3cGu3c0d3cXf3cl8P8GAP80iP8XhP8lTP8GzP80Iv8XKv8lpv8GZv807v8X4f8lGf8Gmf80Vf8XXf8l0/8GP/6+d+5bf+4M/+5p/+47+qBBzMIR3G4RzRURzd/ziO4zuRkzqFUzudMzqLszuX87qAC7uYS7qMy7uSq7qGa7ueG7qJm7uV27qDO7ube7qP+3uQh3qER3ucJ3qKp3uW53qBF3uZV3qN13uTt3qHd3ufD/qIj/uUz/qCL/uab/qO7/uRn/qZX/qN3/uTv/qHfztw1YCDOoRDO6wjOLKjOaZjO54TOomTO5XTOoMzO5tzOo/zu5CLuoRLu5wruoqru5bruoEbu5lbuo3bu5O7uod7u58HeoiHe5THeoIne5pneo7ne5GXeoVXe503eou3e5f3+oAP+5hP+ozP+5Kv+oZv+54f+on/8wu/9jt/9Bd/9y8HqhZQEAd3KP/t8I7kqI7hWI7rBE7sZE7pNE7vTM7qHM7tfC7oIi7uUi7rCq7saq7pOq7vRm7qFm7tdu7oLu7uXu7rAR7sYR7pMR7vSZ7qGZ7teV7oJV7uVV7rDd7sbd7pPd7vQz7qEz7tc77oK77uW77rB37sf/3cr/zWH/zZ3/zTf/xX9YCDOaTDOJwjOoqj+x/HcXwnclKncGqnc0ZncXbncl4XcGEXc0mXcXlXclXXcG3Xc0M3cXO3clt3cGd3c0/3cX8P8lCP8GiP80RP8XTP8lwv8GIv80qv8Xpv8lbv8G7v80Ef8XGf8llf8GVf803f8X0/8lM/80u/8Xt/8lf/8G8HrhFwUIdwaId1BEd2NMd0bMdzQidxcqdyWmdwZmdzTudxfhdyUZdwaZdzRVdxdddyXTdwYzdzS7dxe3dyV/dwb/fzQA/xcI/yWE/wZE/zTM/xfC/yUq/waq/zRm/xdu/yXh/wYR/zSZ/xeV/yVd/wbd/zQz/xf37h137nj/7i7/7lQDUDCuLgDuW/Hd6RHNUxHMtxncCJncwpncbpnclZncO5nc8FXcTFXcplXcGVXc01Xcf13chN3cKt3c4d3cXd3ct9PcCDPcwjPcbjPclTPcOzPc8LvcTLvcprvcGbvc07vcf7fchHfcKnfc4XfcXXfct3/cCP/a+f+5Xf+oM/+5t/+o//qhVwMId0GIdzREdxdP/jOI7vRE7qFE7tdM7oLM7uXM7rAi7sYi7pMi7vSq7qGq7tem7oJm7uVm7rDu7sbu7pPu7vQR7qER7tcZ7oKZ7uWZ7rBV7sZV7pNV7vTd7qHd7tfT7oIz7uUz7rC77sa77pO77vR37qZ37pN37vT/7qH/7twLUDDuoQDu2wjuDIjuaYju14TugkTu5UTusMzuxszuk8zu9CLuoSLu1yrugqru5arusGbuxmbuk2bu9O7uoe7u1+HughHu5RHusJnuxpnuk5nu9FXuoVXu113ugt3u5d3usDPuxjPukzPu9Lvuobvu17fugn/s8v/Nrv/NFf/N2/HKhOQEEc3KH8t8M7kqM6hmM5rhM4sZM5pdM4vTM5q3M4t/O5oIu4uEu5rCu4squ5puu4vhu5qVu4tdu5o7u4u3u5rwd4sId5pMd4vCd5qmd4tud5oZd4uVd5rTd4s7d5p/d4vw/5qE/4tM/5oq/4um/5rh/4sf/1c7/yW3/wZ3/zT//xX3UDDuaQDuNwjugoju5/HMfxnchJncKpnc4ZncXZnct5XcCFXcwlXcblXclVXcO1Xc8N3cTN3cpt3cGd3c093cf9PchDPcKjPc4TPcXTPctzvcCLvcwrvcbrvclbvcO7vc8HfcTHfcpnfcGXfc03fcf3/chP/cwv/cbv/clf/cO/HbhewEEdwqEd1hEc2dEc07EdzwmdxMmdymmdwZmdzTmdx/ldyEVdwqVdzhVdxdVdy3XdwI3dzC3dxu3dyV3dw73dzwM9xMM9ymM9wZM9zTM9x/O9yEu9wqu9zhu9xdu9y3t9wId9zCd9xud9yVd9w7d9zw/9xP/5hV/7nT/6i7/7lwPVD+h/SKJw1XicLcVTsBgGAgDApLFt27btpLFt27ZtN7Zt27Zts41u5t7uzwZpEOj/gjuUwzqCIzuaYzqO4zuRkzqFUzudMzqLszuX87qAC7uYS7qM/3ZFV3F113JdN3BjN3NLt3F7d3JX93Bv9/NAD/Fwj/JYT/BkT/NMz/E8L/QSL/cqr/UGb/Y27/Qe7/chH/UJn/Y5X/QVX/ct3/UDP/Yzv/Qbv/cnf/W//uk//qthwMEc0mEc3pEc1TEc2/Gc0Emc3Kmc1hmc2dmc03mc34Vc1CVc2uVcwZVdzTVdx/XdyE3dwq3dzh3dxd3dy309wIM9zCM9xuM9yVM9w7P9jxd4sZd5pdd4vTd5q3d4t/f5oI/4uE/5rC/4sq/5pu/4vh/5qV/4td/5o7/4u3/4twM3CjioQzi0wzmiozi6YzmuEzixkzml0zi9Mzmrczi387mgi7i4S7msy7uSq7qGa7ueG7qJm7uV27qDO7ube7qP+3uQh3qER3ucJ3qKp3uW53q+F3mpV3i113mjt3i7d3mvD/iwj/mkz/i8L/mqb/i27/mhn/i5X/mtP/izv/k//3KgxgEFcXCHclhHcGRHc0zHcXwnclKncGqnc0ZncXbncl4XcGEXc0mX8d+u6Cqu7lqu6wZu7GZu6TZu707u6h7u7X4e6CEe7lEe6wme7Gme6Tme54Ve4uVe5bXe4M3e5p3e4/0+5KM+4dM+54u+4uu+5bt+4Md+5pd+4/f+5K/+1z/9x381CTiYQzqMwzuSozqGYzueEzqJkzuV0zqDMzubczqP87uQi7qES7ucK7iyq7mm67i+G7mpW7i127mju7i7e7mvB3iwh3mkx3i8J3mqZ3i2//ECL/Yyr/Qar/cmb/UO7/Y+H/QRH/cpn/UFX/Y13/Qd3/cjP/ULv/Y7f/QXf/cP/3bgpgEHdQiHdjhHdBRHdyzHdQIndjKndBqndyZndQ7ndj4XdBEXdymXdXlXclXXcG3Xc0M3cXO3clt3cGd3c0/3cX8P8lCP8GiP80RP8XTP8lzP9yIv9Qqv9jpv9BZv9y7v9QEf9jGf9Bmf9yVf9Q3f9j0/9BM/9yu/9Qd/9jf/518O1CygIA7uUA7rCI7saI7pOI7vRE7qFE7tdM7oLM7uXM7rAi7sYi7pMv7bFV3F1V3Ldd3Ajd3MLd3G7d3JXd3Dvd3PAz3Ewz3KYz3Bkz3NMz3H87zQS7zcq7zWG7zZ27zTe7zfh3zUJ3za53zRV3zdt3zXD/zYz/zSb/zen/zV//qn//iv5gEHc0iHcXhHclTHcGzHc0IncXKnclpncGZnc07ncX4XclGXcGmXcwVXdjXXdB3XdyM3dQu3djt3dBd3dy/39QAP9jCP9BiP9yRP9QzP9j9e4MVe5pVe4/Xe5K3e4d3e54M+4uM+5bO+4Mu+5pu+4/t+5Kd+4dd+54/+4u/+4d8O3CLgoA7h0A7niI7i6I7luE7gxE7mlE7j9M7krM7h3M7ngi7i4i7lsi7vSq7qGq7tem7oJm7uVm7rDu7sbu7pPu7vQR7qER7tcZ7oKZ7uWZ7r+V7kpV7h1V7njd7i7d7lvT7gwz7mkz7j877kq77h277nh37i537lt/7gz/7m//zLgVoGFMTBHcphHcGRHc0xHcfxnchJncKpnc4ZncXZnct5XcCFXcwlXcZ/u6KruLprua4buLGbuaXbuL07uat7uLf7eaCHeLhHeawneLKneabneJ4XeomXe5XXeoM3e5t3eo/3+5CP+oRP+5wv+oqv+5bv+oEf+5lf+o3f+5O/+l//9B//1SrgYA7pMA7vSI7qGI7teE7oJE7uVE7rDM7sbM7pPM7vQi7qEi7tcq7gyq7mmq7j+m7kpm7h1m7nju7i7u7lvh7gwR7mkR7j8Z7kqZ7h2f7HC7zYy7zSa7zem7zVO7zb+3zQR3zcp3zWF3zZ13zTd3zfj/zUL/za7/zRX/zdP/zbgVsHHNQhHNrhHNFRHN2xHNcJnNjJnNJpnN6ZnNU5nNv5XNBFXNylXNblXclVXcO1Xc8N3cTN3cpt3cGd3c093cf9PchDPcKjPc4TPcXTPctzPd+LvNQrvNrrvNFbvN27vNcHfNjHfNJnfN6XfNU3fNv3/NBP/Nyv/NYf/Nnf/J9/OVCbgII4uEM5rCM4sqM5puM4vhM5qVM4tdM5o7M4u3M5rwu4sIu5pMv4b1d0FVd3Ldd1Azd2M7d0G7d3J3d1D/d2Pw/0EA/3KI/1BE/2NM/0HM/zQi/xcq/yWm/wZm/zTu/xfh/yUZ/waZ/zRV/xdd/yXT/wYz/zS7/xe3/yV//rn/7jv9oGHMwhHcbhHclRHcOxHc8JncTJncppncGZnc05ncf5XchFXcKlXc4VXNnVXNN1XN+N3NQt3Nrt3NFd3N293NcDPNjDPNJjPN6TPNUzPNv/eIEXe5lXeo3Xe5O3eod3e58P+oiP+5TP+oIv+5pv+o7v+5Gf+oVf+50/+ou/+4d/O3C7gIM6hEM7nCM6iqM7luM6gRM7mVM6jdM7k7M6h3M7nwu6iIu7lMu6vCu5qmu4tuu5oZu4uVu5rTu4s7u5p/u4vwd5qEd4tMd5oqd4umd5rud7kZd6hVd7nTd6i7d7l/f6gA/7mE/6jM/7kq/6hm/7nh/6iZ/7ld/6gz/7m//zLwdqH1AQB3coh3UER3Y0x3Qcx3ciJ3UKp3Y6Z3QWZ3cu53UBF3Yxl3QZ/+2KruLqruW6buDGbuaWbuP27uSu7uHe7ueBHuLhHuWxnuDJnuaZnuN5XuglXu5VXusN3uxt3uk93u9DPuoTPu1zvugrvu5bvusHfuxnfuk3fu9P/up//dN//FeHgIM5pMM4vCM5qmM4tuM5oZM4uVM5rTM4s7M5p/M4vwu5qEu4tMu5giu7mmu6juu7kZu6hVu7nTu6i7u7l/t6gAd7mEd6jMd7kqd6hmf7Hy/wYi/zSq/xem/yVu/wbu/zQR/xcZ/yWV/wZV/zTd/xfT/yU7/wa7/zR3/xd//wbwfuGHBQh3Boh3NER3F0x3JcJ3BiJ3NKp3F6Z3JW53Bu53NBF3Fxl3JZl3clV3UN13Y9N3QTN3crt3UHd3Y393Qf9/cgD/UIj/Y4T/QUT/csz/V8L/JSr/Bqr/NGb/F27/JeH/BhH/NJn/F5X/JV3/Bt3/NDP/Fzv/Jbf/Bnf/N//uVAnQIK4uAO5bCO4MiO5piO4/hO5KRO4dRO54zO4uzO5bwu4MIu5pIu479d0VVc3bVc1w3c2M3c0m3c3p3c1T3c2/080EM83KM81hM82dM803M8zwu9xMu9ymu9wZu9zTu9x/t9yEd9wqd9zhd9xdd9y3f9wI/9zC/9xu/9yV/9r3/6j//qHHAwh3QYh3ckR3UMx3Y8J3QSJ3cqp3UGZ3Y253Qe53chF3UJl3Y5V3BlV3NN13F9N3JTt3Brt3NHd3F393JfD/BgD/NIj/F4T/JUz/Bs/+MFXuxlXuk1Xu9N3uod3u19PugjPu5TPusLvuxrvuk7vu9HfuoXfu13/ugv/u4f/u3AXQIO6hAO7XCO6CiO7liO6wRO7GRO6TRO70zO6hzO7Xwu6CIu7lIu6/Ku5Kqu4dqu54Zu4uZu5bbu4M7u5p7u4/4e5KEe4dEe54me4ume5bme70Ve6hVe7XXe6C3e7l3e6wM+7GM+6TM+70u+6hu+7Xt+6Cd+7ld+6w/+7G/+z78cqGtAQRzcoRzWERzZ0RzTcRzfiZzUKZza6ZzRWZzduZzXBVzYxVzSZfy3K7qKq7uW67qBG7uZW7qN27uTu7qHe7ufB3qIh3uUx3qCJ3uaZ3qO53mhl3i5V3mtN3izt3mn93i/D/moT/i0z/mir/i6b/muH/ixn/ml3/i9P/mr//VP//Ff3QIO5pAO4/CO5KiO4diO54RO4uRO5bTO4MzO5pzO4/wu5KIu4dIu5wqu7Gqu6Tqu70Zu6hZu7Xbu6C7u7l7u6wEe7GEe6TEe70me6hme7X+8wIu9zCu9xuu9yVu9w7u9zwd9xMd9ymd9wZd9zTd9x/f9yE/9wq/9zh/9xd/9w78duHvAQR3CoR3OER3F0R3LcZ3AiZ3MKZ3G6Z3JWZ3DuZ3PBV3ExV3KZV3elVzVNVzb9dzQTdzcrdzWHdzZ3dzTfdzfgzzUIzza4zzRUzzdszzX873IS73Cq73OG73F273Le33Ah33MJ33G533JV33Dt33PD/3Ez/3Kb/3Bn/3N//mXA/UIKIiDO5TDOoIjO5pjOo7jO5GTOoVTO50zOouzO5fzuoALu5hLuoz/dkVXcXXXcl03cGM3c0u3cXt3clf3cG/380AP8XCP8lhP8GRP80zP8Twv9BIv9yqv9QZv9jbv9B7v9yEf9Qmf9jlf9BVf9y3f9QM/9jO/9Bu/9yd/9b/+6T/+q2fAwRzSYRzekRzVMRzb8ZzQSZzcqZzWGZzZ2ZzTeZzfhVzUJVza5VzBlV3NNV3H9d3ITd3Crd3OHd3F3d3LfT3Agz3MIz3G4z3JUz3Ds/2PF3ixl3ml13i9N3mrd3i39/mgj/i4T/msL/iyr/mm7/i+H/mpX/i13/mjv/i7f/i3A/cKOKhDOLTDOaKjOLpjOa4TOLGTOaXTOL0zOatzOLfzuaCLuLhLuazLu5KruoZru54buombu5XbuoM7u5t7uo/7e5CHeoRHe5wneoqne5bner4XealXeLXXeaO3eLt3ea8P+LCP+aTP+Lwv+apv+Lbv+aGf+Llf+a0/+LO/+T//cqDeAQVxcIdyWEdwZEdzTMdxfCdyUqdwaqdzRmdxdudyXhdwYRdzSZfx367oKq7uWq7rBm7sZm7pNm7vTu7qHu7tfh7oIR7uUR7rCZ7saZ7pOZ7nhV7i5V7ltd7gzd7mnd7j/T7koz7h0z7ni77i677lu37gx37ml37j9/7kr/7XP/3Hf/UJOJhDOozDO5KjOoZjO54TOomTO5XTOoMzO5tzOo/zu5CLuoRLu5wruLKruabruL4bualbuLXbuaO7uLt7ua8HeLCHeaTHeLwneapneLb/8QIv9jKv9Bqv9yZv9Q7v9j4f9BEf9ymf9QVf9jXf9B3f9yM/9Qu/9jt/9Bd/9w//duC+AQd1CId2OEd0FEd3LMd1Aid2Mqd0Gqd3Jmd1Dud2Phd0ERd3KZd1eVdyVddwbddzQzdxc7dyW3dwZ3dzT/dxfw/yUI/waI/zRE/xdM/yXM/3Ii/1Cq/2Om/0Fm/3Lu/1AR/2MZ/0GZ/3JV/1Dd/2PT/0Ez/3K7/1B3/2N//nXw7UL6AgDu5QDusIjuxojuk4ju9ETuoUTu10zugszu5czusCLuxiLuky/tsVXcXVXct13cCN3cwt3cbt3cld3cO93c8DPcTDPcpjPcGTPc0zPcfzvNBLvNyrvNYbvNnbvNN7vN+HfNQnfNrnfNFXfN23fNcP/NjP/NJv/N6f/NX/+qf/+K/+AQdzSIdxeEdyVMdwbMdzQidxcqdyWmdwZmdzTudxfhdyUZdwaZdzBVd2Ndd0Hdd3Izd1C7d2O3d0F3d3L/f1AA/2MI/0GI/3JE/1DM/2P17gxV7mlV7j9d7krd7h3d7ngz7i4z7ls77gy77mm77j+37kp37h137nj/7i7/7h3w48IOCgDuHQDueIjuLojuW4TuDETuaUTuP0zuSszuHczueCLuLiLuWyLu9Kruoaru16bugmbu5WbusO7uxu7uk+7u9BHuoRHu1xnugpnu5Znuv5XuSlXuHVXueN3uLt3uW9PuDDPuaTPuPzvuSrvuHbvueHfuLnfuW3/uDP/ub//MuBBgYUxMEdymEdwZEdzTEdx/GdyEmdwqmdzhmdxdmdy3ldwIVdzCVdxn+7oqu4umu5rhu4sZu5pdu4vTu5q3u4t/t5oId4uEd5rCd4sqd5pud4nhd6iZd7ldd6gzd7m3d6j/f7kI/6hE/7nC/6iq/7lu/6gR/7mV/6jd/7k7/6X//0H/81KOBgDukwDu9IjuoYju14TugkTu5UTusMzuxszuk8zu9CLuoSLu1yruDKruaaruP6buSmbuHWbueO7uLu7uW+HuDBHuaRHuPxnuSpnuHZ/scLvNjLvNJrvN6bvNU7vNv7fNBHfNynfNYXfNnXfNN3fN+P/NQv/Nrv/NFf/N0//NuBBwcc1CEc2uEc0VEc3bEc1wmc2Mmc0mmc3pmc1Tmc2/lc0EVc3KVc1uVdyVVdw7Vdzw3dxM3dym3dwZ3dzT3dx/09yEM9wqM9zhM9xdM9y3M934u81Cu82uu80Vu83bu81wd82Md80md83pd81Td82/f80E/83K/81h/82d/8n3850JCAgji4QzmsIziyozmm4zi+EzmpUzi10zmjszi7czmvC7iwi7mky/hvV3QVV3ct13UDN3Yzt3Qbt3cnd3UP93Y/D/QQD/coj/UET/Y0z/Qcz/NCL/Fyr/Jab/Bmb/NO7/F+H/JRn/Bpn/NFX/F13/JdP/BjP/NLv/F7f/JX/+uf/uO/hgYczCEdxuEdyVEdw7EdzwmdxMmdymmdwZmdzTmdx/ldyEVdwqVdzhVc2dVc03Vc343c1C3c2u3c0V3c3b3c1wM82MM80mM83pM81TM82/94gRd7mVd6jdd7k7d6h3d7nw/6iI/7lM/6gi/7mm/6ju/7kZ/6hV/7nT/6i7/7h3878LCAgzqEQzucIzqKozuW4zqBEzuZUzqN0zuTszqHczufC7qIi7uUy7q8K7mqa7i267mhm7i5W7mtO7izu7mn+7i/B3moR3i0x3mip3i6Z3mu53uRl3qFV3udN3qLt3uX9/qAD/uYT/qMz/uSr/qGb/ueH/qJn/uV3/qDP/ub//MvBxoeUBAHdyiHdQRHdjTHdBzHdyIndQqndjpndBZndy7ndQEXdjGXdBn/7Yqu4uqu5bpu4MZu5pZu4/bu5K7u4d7u54Ee4uEe5bGe4Mme5pme43le6CVe7lVe6w3e7G3e6T3e70M+6hM+7XO+6Cu+7lu+6wd+7Gd+6Td+70/+6n/903/814iAgzmkwzi8IzmqYzi24zmhkzi5UzmtMzizszmn8zi/C7moS7i0y7mCK7uaa7qO67uRm7qFW7udO7qLu7uX+3qAB3uYR3qMx3uSp3qGZ/sfL/BiL/NKr/F6b/JW7/Bu7/NBH/Fxn/JZX/BlX/NN3/F9P/JTv/Brv/NHf/F3//BvBx4ZcFCHcGiHc0RHcXTHclwncGInc0qncXpnclbncG7nc0EXcXGXclmXdyVXdQ3Xdj03dBM3dyu3dQd3djf3dB/39yAP9QiP9jhP9BRP9yzP9Xwv8lKv8Gqv80Zv8Xbv8l4f8GEf80mf8Xlf8lXf8G3f80M/8XO/8lt/8Gd/83/+5UCjAgri4A7lsI7gyI7mmI7j+E7kpE7h1E7njM7i7M7lvC7gwi7mki7jv13RVVzdtVzXDdzYzdzSbdzendzVPdzb/TzQQzzcozzWEzzZ0zzTczzPC73Ey73Ka73Bm73NO73H+33IR33Cp33OF33F133Ld/3Aj/3ML/3G7/3JX/2vf/qP/xodcDCHdBiHdyRHdQzHdjwndBIndyqndQZndjbndB7ndyEXdQmXdjlXcGVXc03XcX03clO3cGu3c0d3cXf3cl8P8GAP80iP8XhP8lTP8Gz/4wVe7GVe6TVe703e6h3e7X0+6CM+7lM+6wu+7Gu+6Tu+70d+6hd+7Xf+6C/+7h/+7cBjAg7qEA7tcI7oKI7uWI7rBE7sZE7pNE7vTM7qHM7tfC7oIi7uUi7r8q7kqq7h2q7nhm7i5m7ltu7gzu7mnu7j/h7koR7h0R7niZ7i6Z7luZ7vRV7qFV7tdd7oLd7uXd7rAz7sYz7pMz7vS77qG77te37oJ37uV37rD/7sb/7PvxxobEBBHNyhHNYRHNnRHNNxHN+JnNQpnNrpnNFZnN25nNcFXNjFXNJl/Lcruoqru5bruoEbu5lbuo3bu5O7uod7u58HeoiHe5THeoIne5pneo7neaGXeLlXea03eLO3eaf3eL8P+ahP+LTP+aKv+Lpv+a4f+LGf+aXf+L0/+av/9U//8V/jAg7mkA7j8I7kqI7h2I7nhE7i5E7ltM7gzM7mnM7j/C7koi7h0i7nCq7saq7pOq7vRm7qFm7tdu7oLu7uXu7rAR7sYR7pMR7vSZ7qGZ7tf7zAi73MK73G673JW73Du73PB33Ex33KZ33Bl33NN33H9/3IT/3Cr/3OH/3F3/3Dvx14fMBBHcKhHc4RHcXRHctxncCJncwpncbpnclZncO5nc8FXcTFXcplXd6VXNU1XNv13NBN3Nyt3NYd3Nnd3NN93N+DPNQjPNrjPNFTPN2zPNfzvchLvcKrvc4bvcXbvct7fcCHfcwnfcbnfclXfcO3fc8P/cTP/cpv/cGf/c3/+ZcDTQjof4nOcQJ4nC3FU7AYBgIAwKQxGtu2bdu22di2bdu2bTtpbBuNjZu5t/uzQcYH+r/gDuWwDu9IjuoYju14TugkTu5UTusMzuxszuk8zu9CLuoSLu1yrugqru5arusGbuxmbuHWbueO7uLu7uW+HuDBHuaRHuPxnuSpnuHZnueFXuLlXuW13uDN3uad3uP9PuSjPuHTPud/fdnXfNN3fN+P/NQv/Npv/cGf/c0//cd/TQg4mEM6jMM5oqM4umM5rhM4sZM5pdM4vTM5q3M4t/O5oIu4uEu5rCu4squ5puu4vhu5qf9xK7d1B3d2N/d0H/f3IA/1CI/2OE/0FE/3LM/1Ai/2Mq/0Gq/3Jm/1Du/2Ph/0ER/3KZ/1BV/yVd/wbd/zQz/xc7/yf37vT/7qH/7twBMDDuoQDu2/HcGRHc0xHcfxnchJncKpnc4ZncXZnct5XcCFXcwlXcblXclVXcO1Xc8N3cTN3dJt3N6d3NU93Nv9PNBDPNyjPNYTPNnTPNNzPN+LvNQrvNrrvNFbvN27vNcHfNjHfNJnfN4XfcXXfct3/cCP/cwv/cbv/NFf/N2/HGhSQEEc3KEc1uEdyVEdw7EdzwmdxMmdymmdwZmdzTmdx/ldyEVdwqVdzhVdxdVdy3XdwI3dzC3c2u3c0V3c3b3c1wM82MM80mM83pM81TM82/O80Eu83Ku81hu82du803u834d81Cd82uf8ry/7mm/6ju/7kZ/6hV/7rT/4s7/5p//4r8kBB3NIh3E4R3QUR3csx3UCJ3Yyp3Qap3cmZ3UO53Y+F3QRF3cpl3UFV3Y113Qd13cjN/U/buW27uDO7uae7uP+HuShHuHRHueJnuLpnuW5XuDFXuaVXuP13uSt3uHd3ueDPuLjPuWzvuBLvuobvu17fugnfu5X/s/v/clf/cO/HXhKwEEdwqH9tyM4sqM5puM4vhM5qVM4tdM5o7M4u3M5rwu4sIu5pMu4vCu5qmu4tuu5oZu4uVu6jdu7k7u6h3u7nwd6iId7lMd6gid7mmd6jud7kZd6hVd7nTd6i7d7l/f6gA/7mE/6jM/7oq/4um/5rh/4sZ/5pd/4nT/6i7/7lwNNDSiIgzuUwzq8IzmqYzi24zmhkzi5UzmtMzizszmn8zi/C7moS7i0y7miq7i6a7muG7ixm7mFW7udO7qLu7uX+3qAB3uYR3qMx3uSp3qGZ3ueF3qJl3uV13qDN3ubd3qP9/uQj/qET/uc//VlX/NN3/F9P/JTv/Brv/UHf/Y3//Qf/zUt4GAO6TAO54iO4uiO5bhO4MRO5pRO4/TO5KzO4dzO54Iu4uIu5bKu4Mqu5pqu4/pu5Kb+x63c1h3c2d3c033c34M81CM82uM80VM83bM81wu82Mu80mu83pu81Tu82/t80Ed83Kd81hd8yVd9w7d9zw/9xM/9yv/5vT/5q3/4twNPDzioQzi0/3YER3Y0x3Qcx3ciJ3UKp3Y6Z3QWZ3cu53UBF3Yxl3QZl3clV3UN13Y9N3QTN3dLt3F7d3JX93Bv9/NAD/Fwj/JYT/BkT/NMz/F8L/JSr/Bqr/NGb/F27/JeH/BhH/NJn/F5X/QVX/ct3/UDP/Yzv/Qbv/NHf/F3/3KgGQEFcXCHcliHdyRHdQzHdjwndBIndyqndQZndjbndB7ndyEXdQmXdjlXdBVXdy3XdQM3djO3cGu3c0d3cXf3cl8P8GAP80iP8XhP8lTP8GzP80Iv8XKv8lpv8GZv807v8X4f8lGf8Gmf87++7Gu+6Tu+70d+6hd+7bf+4M/+5p/+479mBhzMIR3G4RzRURzdsRzXCZzYyZzSaZzemZzVOZzb+VzQRVzcpVzWFVzZ1VzTdVzfjdzU/7iV27qDO7ube7qP+3uQh3qER3ucJ3qKp3uW53qBF3uZV3qN13uTt3qHd3ufD/qIj/uUz/qCL/mqb/i27/mhn/i5X/k/v/cnf/UP/3bgWQEHdQiH9t+O4MiO5piO4/hO5KRO4dRO54zO4uzO5bwu4MIu5pIu4/Ku5Kqu4dqu54Zu4uZu6TZu707u6h7u7X4e6CEe7lEe6wme7Gme6Tme70Ve6hVe7XXe6C3e7l3e6wM+7GM+6TM+74u+4uu+5bt+4Md+5pd+43f+6C/+7l8ONDugIA7uUA7r8I7kqI7h2I7nhE7i5E7ltM7gzM7mnM7j/C7koi7h0i7niq7i6q7lum7gxm7mFm7tdu7oLu7uXu7rAR7sYR7pMR7vSZ7qGZ7teV7oJV7uVV7rDd7sbd7pPd7vQz7qEz7tc/7Xl33NN33H9/3IT/3Cr/3WH/zZ3/zTf/zXnICDOaTDOJwjOoqjO5bjOoETO5lTOo3TO5OzOodzO58LuoiLu5TLuoIru5pruo7ru5Gb+h+3clt3cGd3c0/3cX8P8lCP8GiP80RP8XTP8lwv8GIv80qv8Xpv8lbv8G7v80Ef8XGf8llf8CVf9Q3f9j0/9BM/9yv/5/f+5K/+4d8OPDfgoA7h0P7bERzZ0RzTcRzfiZzUKZza6ZzRWZzduZzXBVzYxVzSZVzelVzVNVzb9dzQTdzcLd3G7d3JXd3Dvd3PAz3Ewz3KYz3Bkz3NMz3H873IS73Cq73OG73F273Le33Ah33MJ33G533RV3zdt3zXD/zYz/zSb/zOH/3F3/3LgeYFFMTBHcphHd6RHNUxHNvxnNBJnNypnNYZnNnZnNN5nN+FXNQlXNrlXNFVXN21XNcN3NjN3MKt3c4d3cXd3ct9PcCDPcwjPcbjPclTPcOzPc8LvcTLvcprvcGbvc07vcf7fchHfcKnfc7/+rKv+abv+L4f+alf+LXf+oM/+5t/+o//mh9wMId0GIdzREdxdMdyXCdwYidzSqdxemdyVudwbudzQRdxcZdyWVdwZVdzTddxfTdyU//jVm7rDu7sbu7pPu7vQR7qER7tcZ7oKZ7uWZ7rBV7sZV7pNV7vTd7qHd7tfT7oIz7uUz7rC77kq77h277nh37i537l//zen/zVP/zbgRcEHNQhHNp/O4IjO5pjOo7jO5GTOoVTO50zOouzO5fzuoALu5hLuozLu5KruoZru54buombu6XbuL07uat7uLf7eaCHeLhHeawneLKneabneL4XealXeLXXeaO3eLt3ea8P+LCP+aTP+Lwv+oqv+5bv+oEf+5lf+o3f+aO/+Lt/OdDCgII4uEM5rMM7kqM6hmM7nhM6iZM7ldM6gzM7m3M6j/O7kIu6hEu7nCu6iqu7luu6gRu7mVu4tdu5o7u4u3u5rwd4sId5pMd4vCd5qmd4tud5oZd4uVd5rTd4s7d5p/d4vw/5qE/4tM/5X1/2Nd/0Hd/3Iz/1C7/2W3/wZ3/zT//xX4sCDuaQDuNwjugoju5YjusETuxkTuk0Tu9Mzuoczu18LugiLu5SLusKruxqruk6ru9Gbup/3Mpt3cGd3c093cf9PchDPcKjPc4TPcXTPctzvcCLvcwrvcbrvclbvcO7vc8HfcTHfcpnfcGXfNU3fNv3/NBP/Nyv/J/f+5O/+od/O/DigIM6hEP7b0dwZEdzTMdxfCdyUqdwaqdzRmdxdudyXhdwYRdzSZdxeVdyVddwbddzQzdxc7d0G7d3J3d1D/d2Pw/0EA/3KI/1BE/2NM/0HM/3Ii/1Cq/2Om/0Fm/3Lu/1AR/2MZ/0GZ/3RV/xdd/yXT/wYz/zS7/xO3/0F3/3LwdaElAQB3coh3V4R3JUx3Bsx3NCJ3Fyp3JaZ3BmZ3NO53F+F3JRl3Bpl3NFV3F113JdN3BjN3MLt3Y7d3QXd3cv9/UAD/Ywj/QYj/ckT/UMz/Y8L/QSL/cqr/UGb/Y27/Qe7/chH/UJn/Y5/+vLvuabvuP7fuSnfuHXfusP/uxv/uk//mtpwMEc0mEczhEdxdEdy3GdwImdzCmdxumdyVmdw7mdzwVdxMVdymVdwZVdzTVdx/XdyE39j1u5rTu4s7u5p/u4vwd5qEd4tMd5oqd4umd5rhd4sZd5pdd4vTd5q3d4t/f5oI/4uE/5rC/4kq/6hm/7nh/6iZ/7lf/ze3/yV//wbwdeFnBQh3Bo/+0Ijuxojuk4ju9ETuoUTu10zugszu5czusCLuxiLukyLu9Kruoaru16bugmbu6WbuP27uSu7uHe7ueBHuLhHuWxnuDJnuaZnuP5XuSlXuHVXueN3uLt3uW9PuDDPuaTPuPzvugrvu5bvusHfuxnfuk3fueP/uLv/uVAywMK4uAO5bAO70iO6hiO7XhO6CRO7lRO6wzO7GzO6TzO70Iu6hIu7XKu6Cqu7lqu6wZu7GZu4dZu547u4u7u5b4e4MEe5pEe4/Ge5Kme4dme54Ve4uVe5bXe4M3e5p3e4/0+5KM+4dM+53992dd803d834/81C/82m/9wZ/9zT/9x3+tCDiYQzqMwzmiozi6YzmuEzixkzml0zi9Mzmrczi387mgi7i4S7msK7iyq7mm67i+G7mp/3Ert3UHd3Y393Qf9/cgD/UIj/Y4T/QUT/csz/UCL/Yyr/Qar/cmb/UO7/Y+H/QRH/cpn/UFX/JV3/Bt3/NDP/Fzv/J/fu9P/uof/u3AKwMO6hAO7b8dwZEdzTEdx/GdyEmdwqmdzhmdxdmdy3ldwIVdzCVdxuVdyVVdw7Vdzw3dxM3d0m3c3p3c1T3c2/080EM83KM81hM82dM803M834u81Cu82uu80Vu83bu81wd82Md80md83hd9xdd9y3f9wI/9zC/9xu/80V/83b8caFVAQRzcoRzW4R3JUR3DsR3PCZ3EyZ3KaZ3BmZ3NOZ3H+V3IRV3CpV3OFV3F1V3Ldd3Ajd3MLdza7dzRXdzdvdzXAzzYwzzSYzzekzzVMzzb87zQS7zcq7zWG7zZ27zTe7zfh3zUJ3za5/yvL/uab/qO7/uRn/qFX/utP/izv/mn//iv1QEHc0iHcThHdBRHdyzHdQIndjKndBqndyZndQ7ndj4XdBEXdymXdQVXdjXXdB3XdyM39T9u5bbu4M7u5p7u4/4e5KEe4dEe54me4ume5ble4MVe5pVe4/Xe5K3e4d3e54M+4uM+5bO+4Eu+6hu+7Xt+6Cd+7lf+z+/9yV/9w78deE3AQR3Cof23Iziyozmm4zi+EzmpUzi10zmjszi7czmvC7iwi7mky7i8K7mqa7i267mhm7i5W7qN27uTu7qHe7ufB3qIh3uUx3qCJ3uaZ3qO53uRl3qFV3udN3qLt3uX9/qAD/uYT/qMz/uir/i6b/muH/ixn/ml3/idP/qLv/uXA60NKIiDO5TDOrwjOapjOLbjOaGTOLlTOa0zOLOzOafzOL8LuahLuLTLuaKruLprua4buLGbuYVbu507uou7u5f7eoAHe5hHeozHe5KneoZne54XeomXe5XXeoM3e5t3eo/3+5CP+oRP+5z/9WVf803f8X0/8lO/8Gu/9Qd/9jf/9B//tS7gYA7pMA7niI7i6I7luE7gxE7mlE7j9M7krM7h3M7ngi7i4i7lsq7gyq7mmq7j+m7kpv7HrdzWHdzZ3dzTfdzfgzzUIzza4zzRUzzdszzXC7zYy7zSa7zem7zVO7zb+3zQR3zcp3zWF3zJV33Dt33PD/3Ez/3K//m9P/mrf/i3A68POKhDOLT/dgRHdjTHdBzHdyIndQqndjpndBZndy7ndQEXdjGXdBmXdyVXdQ3Xdj03dBM3d0u3cXt3clf3cG/380AP8XCP8lhP8GRP80zP8Xwv8lKv8Gqv80Zv8Xbv8l4f8GEf80mf8Xlf9BVf9y3f9QM/9jO/9Bu/80d/8Xf/cqANAQVxcIdyWId3JEd1DMd2PCd0Eid3Kqd1Bmd2Nud0Hud3IRd1CZd2OVd0FVd3Ldd1Azd2M7dwa7dzR3dxd/dyXw/wYA/zSI/xeE/yVM/wbM/zQi/xcq/yWm/wZm/zTu/xfh/yUZ/waZ/zv77sa77pO77vR37qF37tt/7gz/7mn/7jvzYGHMwhHcbhHNFRHN2xHNcJnNjJnNJpnN6ZnNU5nNv5XNBFXNylXNYVXNnVXNN1XN+N3NT/uJXbuoM7u5t7uo/7e5CHeoRHe5wneoqne5bneoEXe5lXeo3Xe5O3eod3e58P+oiP+5TP+oIv+apv+Lbv+aGf+Llf+T+/9yd/9Q//duBNAQd1CIf2347gyI7mmI7j+E7kpE7h1E7njM7i7M7lvC7gwi7mki7j8q7kqq7h2q7nhm7i5m7pNm7vTu7qHu7tfh7oIR7uUR7rCZ7saZ7pOZ7vRV7qFV7tdd7oLd7uXd7rAz7sYz7pMz7vi77i677lu37gx37ml37jd/7oL/7uXw60OaAgDu5QDuvwjuSojuHYjueETuLkTuW0zuDMzuaczuP8LuSiLuHSLueKruLqruW6buDGbuYWbu127ugu7u5e7usBHuxhHukxHu9JnuoZnu15XuglXu5VXusN3uxt3uk93u9DPuoTPu1z/teXfc03fcf3/chP/cKv/dYf/Nnf/NN//NeWgIM5pMM4nCM6iqM7luM6gRM7mVM6jdM7k7M6h3M7nwu6iIu7lMu6giu7mmu6juu7kZv6H7dyW3dwZ3dzT/dxfw/yUI/waI/zRE/xdM/yXC/wYi/zSq/xem/yVu/wbu/zQR/xcZ/yWV/wJV/1Dd/2PT/0Ez/3K//n9/7kr/7h3w68NeCgDuHQ/tsRHNnRHNNxHN+JnNQpnNrpnNFZnN25nNcFXNjFXNJlXN6VXNU1XNv13NBN3Nwt3cbt3cld3cO93c8DPcTDPcpjPcGTPc0zPcfzvchLvcKrvc4bvcXbvct7fcCHfcwnfcbnfdFXfN23fNcP/NjP/NJv/M4f/cXf/cuBtgUUxMEdymEd3pEc1TEc2/Gc0Emc3Kmc1hmc2dmc03mc34Vc1CVc2uVc0VVc3bVc1w3c2M3cwq3dzh3dxd3dy309wIM9zCM9xuM9yVM9w7M9zwu9xMu9ymu9wZu9zTu9x/t9yEd9wqd9zv/6sq/5pu/4vh/5qV/4td/6gz/7m3/6j//aHnAwh3QYh3NER3F0x3JcJ3BiJ3NKp3F6Z3JW53Bu53NBF3Fxl3JZV3BlV3NN13F9N3JT/+NWbusO7uxu7uk+7u9BHuoRHu1xnugpnu5ZnusFXuxlXuk1Xu9N3uod3u19PugjPu5TPusLvuSrvuHbvueHfuLnfuX//N6f/NU//NuBdwQc1CEc2n87giM7mmM6juM7kZM6hVM7nTM6i7M7l/O6gAu7mEu6jMu7kqu6hmu7nhu6iZu7pdu4vTu5q3u4t/t5oId4uEd5rCd4sqd5pud4vhd5qVd4tdd5o7d4u3d5rw/4sI/5pM/4vC/6iq/7lu/6gR/7mV/6jd/5o7/4u3850M6Agji4QzmswzuSozqGYzueEzqJkzuV0zqDMzubczqP87uQi7qES7ucK7qKq7uW67qBG7uZW7i127mju7i7e7mvB3iwh3mkx3i8J3mqZ3i253mhl3i5V3mtN3izt3mn93i/D/moT/i0z/lfX/Y13/Qd3/cjP/ULv/Zbf/Bnf/NP//FfuwIO5pAO43CO6CiO7liO6wRO7GRO6TRO70zO6hzO7Xwu6CIu7lIu6wqu7Gqu6Tqu70Zu6n/cym3dwZ3dzT3dx/09yEM9wqM9zhM9xdM9y3O9wIu9zCu9xuu9yVu9w7u9zwd9xMd9ymd9wZd81Td82/f80E/83K/8n9/7k7/6h3878O6AgzqEQ/tvR3BkR3NMx3F8J3JSp3Bqp3NGZ3F253JeF3BhF3NJl3F5V3JV13Bt13NDN3Fzt3Qbt3cnd3UP93Y/D/QQD/coj/UET/Y0z/Qcz/ciL/UKr/Y6b/QWb/cu7/UBH/Yxn/QZn/dFX/F13/JdP/BjP/NLv/E7f/QXf/cvB9oTUBAHdyiHdXhHclTHcGzHc0IncXKnclpncGZnc07ncX4XclGXcGmXc0VXcXXXcl03cGM3cwu3djt3dBd3dy/39QAP9jCP9BiP9yRP9QzP9jwv9BIv9yqv9QZv9jbv9B7v9yEf9Qmf9jn/68u+5pu+4/t+5Kd+4dd+6w/+7G/+6T/+a2/AwRzSYRzOER3F0R3LcZ3AiZ3MKZ3G6Z3JWZ3DuZ3PBV3ExV3KZV3BlV3NNV3H9d3ITf2PW7mtO7izu7mn+7i/B3moR3i0x3mip3i6Z3muF3ixl3ml13i9N3mrd3i39/mgj/i4T/msL/iSr/qGb/ueH/qJn/uV//N7f/JX//BvB94XcFCHcGj/7QiO7GiO6TiO70RO6hRO7XTO6CzO7lzO6wIu7GIu6TIu70qu6hqu7Xpu6CZu7pZu4/bu5K7u4d7u54Ee4uEe5bGe4Mme5pme4/le5KVe4dVe543e4u3e5b0+4MM+5pM+4/O+6Cu+7lu+6wd+7Gd+6Td+54/+4u/+5UD7A/ofyvpxL3icLcVTsBgGAgDApLFt20ajxrZtO2ls27Zt27Zt21aDm7m3+7NB9gX6v+AO5bCO4MiO5piO4/hO5KRO4dRO54zO4uzO6TzO54Iu4uIu5bKu4Mqu5pqu4/pu5KZu4dZu5w7u7G7u6T7u70Ee6hEe7XGe6Cme7lme6wVe7GVe6TVe703e6h3e7X0+6CM+7lM+6wu+7Gu+6Tu+70d+6hd+7Xf+6C/+7p/+47/2BxzMIR3G4R3JUR3DsR3PCZ3EyZ3KaZ3BmZ3NOZzbeV3AhV3MJV3G5V3JVV3DtV3PDd3Ezd3Kbf2vO7mre7i3+3mgh3i4R3msJ3iyp3mm53i+F3mpV3i113mjt3i7d3mvD/iwj/mkz/i8L/mqb/i27/mhn/i5X/mtP/izv/k//3bgAwEHdQiHdjhHdBRHdyzHdQIndjKndBqndyZn9d/O5X+c34Vc1CVc2uVc0VVc3bVc1w3c2M3c0m3c3h3dxd3dy309wIM9zCM9xuM9yVM9w7M9zwu9xMu9ymu9wZu9zTu9x/t9yEd9wqd9zhd9xdd9y3f9wI/9zC/9xu/9yV/9w78c6GBAQRzcoRzWERzZ0RzTcRzfiZzUKZza6ZzRWZzdOZ3H+VzQRVzcpVzWFVzZ1VzTdVzfjdzULdza7dzBnd3NPd3H/T3IQz3Coz3OEz3F0z3Lc73Ai73MK73G673JW73Du73PB33Ex33KZ33Bl33NN33H9/3IT/3Cr/3OH/3F3/3Tf/zXoYCDOaTDOLwjOapjOLbjOaGTOLlTOa0zOLOzOYdzO68LuLCLuaTLuLwruapruLbruaGbuLlbua3/dSd3dQ/3dj8P9BAP9yiP9QRP9jTP9BzP9yIv9Qqv9jpv9BZv9y7v9QEf9jGf9Bmf9yVf9Q3f9j0/9BM/9yu/9Qd/9jf/598OfDjgoA7h0A7niI7i6I7luE7gxE7mlE7j9M7krP7bufyP87uQi7qES7ucK7qKq7uW67qBG7uZW7qN27uju7i7e7mvB3iwh3mkx3i8J3mqZ3i253mhl3i5V3mtN3izt3mn93i/D/moT/i0z/mir/i6b/muH/ixn/ml3/i9P/mrf/iXAx0JKIiDO5TDOoIjO5pjOo7jO5GTOoVTO50zOouzO6fzOJ8LuoiLu5TLuoIru5pruo7ru5GbuoVbu507uLO7uaf7uL8HeahHeLTHeaKneLpnea4XeLGXeaXXeL03eat3eLf3+aCP+LhP+awv+LKv+abv+L4f+alf+LXf+aO/+Lt/+o//OhpwMId0GId3JEd1DMd2PCd0Eid3Kqd1Bmd2Nudwbud1ARd2MZd0GZd3JVd1Ddd2PTd0Ezd3K7f1v+7kru7h3u7ngR7i4R7lsZ7gyZ7mmZ7j+V7kpV7h1V7njd7i7d7lvT7gwz7mkz7j877kq77h277nh37i537lt/7gz/7m//zbgY8FHNQhHNrhHNFRHN2xHNcJnNjJnNJpnN6ZnNV/O5f/cX4XclGXcGmXc0VXcXXXcl03cGM3c0u3cXt3dBd3dy/39QAP9jCP9BiP9yRP9QzP9jwv9BIv9yqv9QZv9jbv9B7v9yEf9Qmf9jlf9BVf9y3f9QM/9jO/9Bu/9yd/9Q//cqDjAQVxcIdyWEdwZEdzTMdxfCdyUqdwaqdzRmdxdud0HudzQRdxcZdyWVdwZVdzTddxfTdyU7dwa7dzB3d2N/d0H/f3IA/1CI/2OE/0FE/3LM/1Ai/2Mq/0Gq/3Jm/1Du/2Ph/0ER/3KZ/1BV/2Nd/0Hd/3Iz/1C7/2O3/0F3/3T//xXycCDuaQDuPwjuSojuHYjueETuLkTuW0zuDMzuYczu28LuDCLuaSLuPyruSqruHarueGbuLmbuW2/ted3NU93Nv9PNBDPNyjPNYTPNnTPNNzPN+LvNQrvNrrvNFbvN27vNcHfNjHfNJnfN6XfNU3fNv3/NBP/Nyv/NYf/Nnf/J9/O/DJgIM6hEM7nCM6iqM7luM6gRM7mVM6jdM7k7P6b+fyP87vQi7qEi7tcq7oKq7uWq7rBm7sZm7pNm7vju7i7u7lvh7gwR7mkR7j8Z7kqZ7h2Z7nhV7i5V7ltd7gzd7mnd7j/T7koz7h0z7ni77i677lu37gx37ml37j9/7kr/7hXw50KqAgDu5QDusIjuxojuk4ju9ETuoUTu10zugszu6czuN8LugiLu5SLusKruxqruk6ru9GbuoWbu127uDO7uae7uP+HuShHuHRHueJnuLpnuW5XuDFXuaVXuP13uSt3uHd3ueDPuLjPuWzvuDLvuabvuP7fuSnfuHXfueP/uLv/uk//ut0wMEc0mEc3pEc1TEc2/Gc0Emc3Kmc1hmc2dmcw7md1wVc2MVc0mVc3pVc1TVc2/Xc0E3c3K3c1v+6k7u6h3u7nwd6iId7lMd6gid7mmd6jud7kZd6hVd7nTd6i7d7l/f6gA/7mE/6jM/7kq/6hm/7nh/6iZ/7ld/6gz/7m//zbwc+E3BQh3Boh3NER3F0x3JcJ3BiJ3NKp3F6Z3JW/+1c/sf5XchFXcKlXc4VXcXVXct13cCN3cwt3cbt3dFd3N293NcDPNjDPNJjPN6TPNUzPNvzvNBLvNyrvNYbvNnbvNN7vN+HfNQnfNrnfNFXfN23fNcP/NjP/NJv/N6f/NU//MuBzgYUxMEdymEdwZEdzTEdx/GdyEmdwqmdzhmdxdmd03mczwVdxMVdymVdwZVdzTVdx/XdyE3dwq3dzh3c2d3c033c34M81CM82uM80VM83bM81wu82Mu80mu83pu81Tu82/t80Ed83Kd81hd82dd803d834/81C/82u/80V/83T/9x3+dCziYQzqMwzuSozqGYzueEzqJkzuV0zqDMzubczi387qAC7uYS7qMy7uSq7qGa7ueG7qJm7uV2/pfd3JX93Bv9/NAD/Fwj/JYT/BkT/NMz/F8L/JSr/Bqr/NGb/F27/JeH/BhH/NJn/F5X/JV3/Bt3/NDP/Fzv/Jbf/Bnf/N//u3A5wMO6hAO7XCO6CiO7liO6wRO7GRO6TRO70zO6r+dy/84vwu5qEu4tMu5oqu4umu5rhu4sZu5pdu4vTu6i7u7l/t6gAd7mEd6jMd7kqd6hmd7nhd6iZd7ldd6gzd7m3d6j/f7kI/6hE/7nC/6iq/7lu/6gR/7mV/6jd/7k7/6h3850IWAgji4QzmsIziyozmm4zi+EzmpUzi10zmjszi7czqP87mgi7i4S7msK7iyq7mm67i+G7mpW7i127mDO7ube7qP+3uQh3qER3ucJ3qKp3uW53qBF3uZV3qN13uTt3qHd3ufD/qIj/uUz/qCL/uab/qO7/uRn/qFX/udP/qLv/un//iviwEHc0iHcXhHclTHcGzHc0IncXKnclpncGZncw7ndl4XcGEXc0mXcXlXclXXcG3Xc0M3cXO3clv/607u6h7u7X4e6CEe7lEe6wme7Gme6Tme70Ve6hVe7XXe6C3e7l3e6wM+7GM+6TM+70u+6hu+7Xt+6Cd+7ld+6w/+7G/+z78d+FLAQR3CoR3OER3F0R3LcZ3AiZ3MKZ3G6Z3JWf23c/kf53chF3UJl3Y5V3QVV3ct13UDN3Yzt3Qbt3dHd3F393JfD/BgD/NIj/F4T/JUz/Bsz/NCL/Fyr/Jab/Bmb/NO7/F+H/JRn/Bpn/NFX/F13/JdP/BjP/NLv/F7f/JX//AvB7ocUBAHdyiHdQRHdjTHdBzHdyIndQqndjpndBZnd07ncT4XdBEXdymXdQVXdjXXdB3XdyM3dQu3djt3cGd3c0/3cX8P8lCP8GiP80RP8XTP8lwv8GIv80qv8Xpv8lbv8G7v80Ef8XGf8llf8GVf803f8X0/8lO/8Gu/80d/8Xf/9B//dSXgYA7pMA7vSI7qGI7teE7oJE7uVE7rDM7sbM7h3M7rAi7sYi7pMi7vSq7qGq7tem7oJm7uVm7rf93JXd3Dvd3PAz3Ewz3KYz3Bkz3NMz3H873IS73Cq73OG73F273Le33Ah33MJ33G533JV33Dt33PD/3Ez/3Kb/3Bn/3N//m3A18NOKhDOLTDOaKjOLpjOa4TOLGTOaXTOL0zOav/di7/4/wu5KIu4dIu54qu4uqu5bpu4MZu5pZu4/bu6C7u7l7u6wEe7GEe6TEe70me6hme7Xle6CVe7lVe6w3e7G3e6T3e70M+6hM+7XO+6Cu+7lu+6wd+7Gd+6Td+70/+6h/+5UDXAgri4A7lsI7gyI7mmI7j+E7kpE7h1E7njM7i7M7pPM7ngi7i4i7lsq7gyq7mmq7j+m7kpm7h1m7nDu7sbu7pPu7vQR7qER7tcZ7oKZ7uWZ7rBV7sZV7pNV7vTd7qHd7tfT7oIz7uUz7rC77sa77pO77vR37qF37td/7oL/7un/7jv64HHMwhHcbhHclRHcOxHc8JncTJncppncGZnc05nNt5XcCFXcwlXcblXclVXcO1Xc8N3cTN3cpt/a87uat7uLf7eaCHeLhHeawneLKneabneL4XealXeLXXeaO3eLt3ea8P+LCP+aTP+Lwv+apv+Lbv+aGf+Llf+a0/+LO/+T//duAbAQd1CId2OEd0FEd3LMd1Aid2Mqd0Gqd3Jmf1387lf5zfhVzUJVza5VzRVVzdtVzXDdzYzdzSbdzeHd3F3d3LfT3Agz3MIz3G4z3JUz3Dsz3PC73Ey73Ka73Bm73NO73H+33IR33Cp33OF33F133Ld/3Aj/3ML/3G7/3JX/3DvxzoZkBBHNyhHNYRHNnRHNNxHN+JnNQpnNrpnNFZnN05ncf5XNBFXNylXNYVXNnVXNN1XN+N3NQt3Nrt3MGd3c093cf9PchDPcKjPc4TPcXTPctzvcCLvcwrvcbrvclbvcO7vc8HfcTHfcpnfcGXfc03fcf3/chP/cKv/c4f/cXf/dN//NetgIM5pMM4vCM5qmM4tuM5oZM4uVM5rTM4s7M5h3M7rwu4sIu5pMu4vCu5qmu4tuu5oZu4uVu5rf91J3d1D/d2Pw/0EA/3KI/1BE/2NM/0HM/3Ii/1Cq/2Om/0Fm/3Lu/1AR/2MZ/0GZ/3JV/1Dd/2PT/0Ez/3K7/1B3/2N//n3w58O+CgDuHQDueIjuLojuW4TuDETuaUTuP0zuSs/tu5/I/zu5CLuoRLu5wruoqru5bruoEbu5lbuo3bu6O7uLt7ua8HeLCHeaTHeLwneapneLbneaGXeLlXea03eLO3eaf3eL8P+ahP+LTP+aKv+Lpv+a4f+LGf+aXf+L0/+at/+JcD3QkoiIM7lMM6giM7mmM6juM7kZM6hVM7nTM6i7M7p/M4nwu6iIu7lMu6giu7mmu6juu7kZu6hVu7nTu4s7u5p/u4vwd5qEd4tMd5oqd4umd5rhd4sZd5pdd4vTd5q3d4t/f5oI/4uE/5rC/4sq/5pu/4vh/5qV/4td/5o7/4u3/6j/+6G3Awh3QYh3ckR3UMx3Y8J3QSJ3cqp3UGZ3Y253Bu53UBF3Yxl3QZl3clV3UN13Y9N3QTN3crt/W/7uSu7uHe7ueBHuLhHuWxnuDJnuaZnuP5XuSlXuHVXueN3uLt3uW9PuDDPuaTPuPzvuSrvuHbvueHfuLnfuW3/uDP/ub//NuB7wUc1CEc2uEc0VEc3bEc1wmc2Mmc0mmc3pmc1X87l/9xfhdyUZdwaZdzRVdxdddyXTdwYzdzS7dxe3d0F3d3L/f1AA/2MI/0GI/3JE/1DM/2PC/0Ei/3Kq/1Bm/2Nu/0Hu/3IR/1CZ/2OV/0FV/3Ld/1Az/2M7/0G7/3J3/1D/9yoPsBBXFwh3JYR3BkR3NMx3F8J3JSp3Bqp3NGZ3F253Qe53NBF3Fxl3JZV3BlV3NN13F9N3JTt3Brt3MHd3Y393Qf9/cgD/UIj/Y4T/QUT/csz/UCL/Yyr/Qar/cmb/UO7/Y+H/QRH/cpn/UFX/Y13/Qd3/cjP/ULv/Y7f/QXf/dP//FfDwIO5pAO4/CO5KiO4diO54RO4uRO5bTO4MzO5hzO7bwu4MIu5pIu4/Ku5Kqu4dqu54Zu4uZu5bb+153c1T3c2/080EM83KM81hM82dM803M834u81Cu82uu80Vu83bu81wd82Md80md83pd81Td82/f80E/83K/81h/82d/8n3878MOAgzqEQzucIzqKozuW4zqBEzuZUzqN0zuTs/pv5/I/zu9CLuoSLu1yrugqru5arusGbuxmbuk2bu+O7uLu7uW+HuDBHuaRHuPxnuSpnuHZnueFXuLlXuW13uDN3uad3uP9PuSjPuHTPueLvuLrvuW7fuDHfuaXfuP3/uSv/uFfDvQooCAO7lAO6wiO7GiO6TiO70RO6hRO7XTO6CzO7pzO43wu6CIu7lIu6wqu7Gqu6Tqu70Zu6hZu7Xbu4M7u5p7u4/4e5KEe4dEe54me4ume5ble4MVe5pVe4/Xe5K3e4d3e54M+4uM+5bO+4Mu+5pu+4/t+5Kd+4dd+54/+4u/+6T/+63HAwRzSYRzekRzVMRzb8ZzQSZzcqZzWGZzZ2ZzDuZ3XBVzYxVzSZVzelVzVNVzb9dzQTdzcrdzW/7qTu7qHe7ufB3qIh3uUx3qCJ3uaZ3qO53uRl3qFV3udN3qLt3uX9/qAD/uYT/qMz/uSr/qGb/ueH/qJn/uV3/qDP/ub//NvB34ScFCHcGiHc0RHcXTHclwncGInc0qncXpnclb/7Vz+x/ldyEVdwqVdzhVdxdVdy3XdwI3dzC3dxu3d0V3c3b3c1wM82MM80mM83pM81TM82/O80Eu83Ku81hu82du803u834d81Cd82ud80Vd83bd81w/82M/80m/83p/81T/8y4GeBhTEwR3KYR3BkR3NMR3H8Z3ISZ3CqZ3OGZ3F2Z3TeZzPBV3ExV3KZV3BlV3NNV3H9d3ITd3Crd3OHdzZ3dzTfdzfgzzUIzza4zzRUzzdszzXC7zYy7zSa7zem7zVO7zb+3zQR3zcp3zWF3zZ13zTd3zfj/zUL/za7/zRX/zdP/3Hfz0LOJhDOozDO5KjOoZjO54TOomTO5XTOoMzO5tzOLfzuoALu5hLuozLu5KruoZru54buombu5Xb+l93clf3cG/380AP8XCP8lhP8GRP80zP8Xwv8lKv8Gqv80Zv8Xbv8l4f8GEf80mf8Xlf8lXf8G3f80M/8XO/8lt/8Gd/83/+7cDPAw7qEA7tcI7oKI7uWI7rBE7sZE7pNE7vTM7qv53L/zi/C7moS7i0y7miq7i6a7muG7ixm7ml27i9O7qLu7uX+3qAB3uYR3qMx3uSp3qGZ3ueF3qJl3uV13qDN3ubd3qP9/uQj/qET/ucL/qKr/uW7/qBH/uZX/qN3/uTv/qHfznQi4CCOLhDOawjOLKjOabjOL4TOalTOLXTOaOzOLtzOo/zuaCLuLhLuawruLKruabruL4bualbuLXbuYM7u5t7uo/7e5CHeoRHe5wneoqne5bneoEXe5lXeo3Xe5O3eod3e58P+oiP+5TP+oIv+5pv+o7v+5Gf+oVf+50/+ou/+6f/+K+XAQdzSIdxeEdyVMdwbMdzQidxcqdyWmdwZmdzDud2XhdwYRdzSZdxeVdyVddwbddzQzdxc7dyW//rTu7qHu7tfh7oIR7uUR7rCZ7saZ7pOZ7vRV7qFV7tdd7oLd7uXd7rAz7sYz7pMz7vS77qG77te37oJ37uV37rD/7sb/7Pvx34VcBBHcKhHc4RHcXRHctxncCJncwpncbpnclZ/bdz+R/ndyEXdQmXdjlXdBVXdy3XdQM3djO3dBu3d0d3cXf3cl8P8GAP80iP8XhP8lTP8GzP80Iv8XKv8lpv8GZv807v8X4f8lGf8Gmf80Vf8XXf8l0/8GM/80u/8Xt/8lf/8C8Heh1QEAd3KId1BEd2NMd0HMd3Iid1Cqd2Omd0Fmd3TudxPhd0ERd3KZd1BVd2Ndd0Hdd3Izd1C7d2O3dwZ3dzT/dxfw/yUI/waI/zRE/xdM/yXC/wYi/zSq/xem/yVu/wbu/zQR/xcZ/yWV/wZV/zTd/xfT/yU7/wa7/zR3/xd//0H//1JuBgDukwDu9IjuoYju14TugkTu5UTusMzuxszuHczusCLuxiLukyLu9Kruoaru16bugmbu5Wbut/3cld3cO93c8DPcTDPcpjPcGTPc0zPcfzvchLvcKrvc4bvcXbvct7fcCHfcwnfcbnfclXfcO3fc8P/cTP/cpv/cGf/c3/+bcDvw04qEM4tMM5oqM4umM5rhM4sZM5pdM4vTM5q/92Lv/j/C7koi7h0i7niq7i6q7lum7gxm7mlm7j9u7oLu7uXu7rAR7sYR7pMR7vSZ7qGZ7teV7oJV7uVV7rDd7sbd7pPd7vQz7qEz7tc77oK77uW77rB37sZ37pN37vT/7qH/7lQO8C+h8MNXFceJwtxUFEAwAAAMCUUpallE1pioiIiBgRY4wYIyIiIsYYY8SIiIiIiBERMSIixogxImJERERERCwRERt197mORtufLve4130e8JDDHnHE457wpKc87RnPes5Rz3vBMced8KKTTnnJy17xqte87g2nnXHWOee96YK3vO0d73rP+z7woY9c9LFPfOozl3zuC1/6ymVXfO2qa77xre9c970f/OgnP/vFr37zuz/c8Je//eNfN93++X+nux1w0P0edMjDHvWYW8EYhZw= + + + + + diff --git a/test/b003/README.md b/test/b003/README.md new file mode 100644 index 00000000..c8bcb8ea --- /dev/null +++ b/test/b003/README.md @@ -0,0 +1,16 @@ +# Left atrium model +The provided left atrium model is collected from the Left Atrial Segmentation Challenge 2013 [1], spesifically case b003, segmented by INRIA. + +The model meshing and probe points can be computed using automatedPreProcessing with the following command: + +``` +python automatedPreProcessing/automatedPreProcessing.py -m diameter -i test/b003/surface.vtp --aneurysm False -c 1.3 +``` + +Note: Aneurysm workflow is intended for artery models. Therefore, boundary conditions for other models will be wrong. Adapting to other vascular models, such as the atrium, is work in progress. + +--- + +[1] Tobon-Gomez, Catalina; Geers, Arjan J.; Peters, Jochen; Jürgen Weese; Karen Pinto; Rashed Karim; et al. (2015): Left Atrial Segmentation Challenge 2013: MRI results. figshare. Dataset. https://doi.org/10.6084/m9.figshare.1492974.v3 + +--- \ No newline at end of file diff --git a/test/b003/surface.vtp b/test/b003/surface.vtp new file mode 100644 index 00000000..5d9f2854 --- /dev/null +++ b/test/b003/surface.vtp @@ -0,0 +1,51 @@ + + + + + + + + + AwAAAACAAACAQQAANAAAADQAAAAmAAAAeJztwQEBAAAAgJD+r+4ICgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYgAAAAXic7cEBAQAAAICQ/q/uCAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIAAAAF4nO3BAQEAAACCIP+vbkhAAQAAAAAAAAAAAAAAAAAAAHwbQYAAAQ== + + + + + BAAAAACAAADwbAAAhm8AAJlvAAD5bgAANF4AAA==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 + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + AAAAAACAAAAAAAAA + + + AAAAAACAAAAAAAAA + + + + + EAAAAACAAAAACQAA9hIAAIITAABrEwAA2xMAADoTAAAfEwAANBMAAJ8SAAB4FAAA+RgAACEYAABOGQAARxoAAFAaAABBGwAABAIAAA==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 + + + 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 + + + + + diff --git a/test/processed_model.png b/test/processed_model.png new file mode 100644 index 0000000000000000000000000000000000000000..fa623e4469162126d83c22fd3c7486e87fab1328 GIT binary patch literal 192857 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 0 + + +if __name__ == "__main__": + test_pre_processing() From 56bb1f18642a432f99878e4e24ffa05b7f075840 Mon Sep 17 00:00:00 2001 From: EhsannKh Date: Thu, 1 Jul 2021 13:12:57 +0200 Subject: [PATCH 09/76] Updated Atrium.py --- Atrium.py | 135 ++++++++++++++++++++++-------------------------------- 1 file changed, 56 insertions(+), 79 deletions(-) diff --git a/Atrium.py b/Atrium.py index 4fe2c4a6..9b049e1f 100755 --- a/Atrium.py +++ b/Atrium.py @@ -13,8 +13,6 @@ from scipy.interpolate import UnivariateSpline from scipy.integrate import simps, romberg - - set_log_level(50) def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_namespace): @@ -28,21 +26,22 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n # parameters are in mm and ms NS_parameters.update( # Fluid parameters - nu=3.5e-3, # Viscosity + nu=3.3018868e-3, # Viscosity [nu_inf: 0.0035 Pa-s / 1060 kg/m^3 = 3.3018868E-6 m^2/s == 3.3018868E-3 mm^2/ms] # Geometry parameters id_in=[], # Inlet boundary ID id_out=[], # Outlet boundary IDs area_ratio=[], # Simulation parameters - T= 1045,#1.045, # Run simulation for 1 cardiac cycles [ms] - dt=0.1,#0.0001, # 10 000 steps per cycle [ms] + T= 1.045, # Run simulation for 1 cardiac cycles [ms] + dt= 0.1, # 10 000 steps per cycle [ms] no_of_cycles=1, dump_stats=100, store_data=5, - store_data_tstep=1000, # Start storing data at 2nd cycle + store_data_tstep=1, # Start storing data at 1st cycle save_step=200, - checkpoint=5000, + checkpoint=20000, print_intermediate_info=100, + tstep_print = 1000, folder="results_atrium", mesh_path=commandline_kwargs["mesh_path"], # Solver parameters @@ -65,7 +64,7 @@ def mesh(mesh_path, **NS_namespace): class boundary_expression(UserExpression): - def __init__(self, coeffs, omega, period, normal, normal_component, area, centers, radius, **kwargs): + def __init__(self, coeffs, omega, period, normal, normal_component, area, centers, radius, profile_type, **kwargs): self.Cn = coeffs self.omega = omega @@ -75,6 +74,7 @@ def __init__(self, coeffs, omega, period, normal, normal_component, area, center self.area = area self.centers = centers self.radius = radius + self.profile_type = profile_type self.num_fourier_coefficients = len(coeffs) self.t = None self.ns = ns = np.arange(1,self.num_fourier_coefficients) @@ -95,19 +95,30 @@ def parabolic(self, x): def eval(self,values,x): - # blunt profile - par = (self.Cn[0] + np.dot(self.Cn[1:], self._expnt)).real + # Profile + if self.profile_type == 'uniform': + par = (self.Cn[0] + np.dot(self.Cn[1:], self._expnt)).real + elif self.profile_type == 'parabolic': + par = (self.Cn[0]*self.parabolic(x) + np.dot(self.Cn[1:], self._expnt)).real + # Scale by negative normal direction values[0] = -self.normal_component * par - - +def get_velocity_profile(q_pv, normal_component,tmp_center, tmp_area): + U_mean = 2*q_pv / tmp_area + R2 = tmp_area / np.pi # R**2 + in_par = Expression('U*( 1 - ( pow(x0 - x[0], 2) + pow(x1 - x[1], 2) + pow(x2 - x[2], 2) ) / R2 )', + degree=2, U=U_mean, R2=R2, x0=tmp_center[0], x1=tmp_center[1], x2=tmp_center[2]) + u_in = -normal_component * in_par + + return u_in + def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, id_out, pressure_degree, **NS_namespace): # Mesh function boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) boundary.set_values(boundary.array() + 1) - id_in = [3,4,5,6] # Hardcoded. FIXIT: automated prepocessing + id_in = [3,4,5,6,7] # Hardcoded. FIXIT: automated prepocessing id_out = [2] # Read case parameters @@ -129,11 +140,6 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, NS_parameters['dim_MV'] = dim_MV NS_parameters['dim_PV'] = dim_PV - # Q_mean = 10 # [ml] - # t_values, Q_ = np.load(path.join(path.dirname(path.abspath(__file__)), "ICA_values")) - # Q_values = Q_mean * Q_ - # t_values *= 1000 - t_values , V_values = [], [] try: t_values, V_values = np.loadtxt(path.join(path.dirname(path.abspath(__file__)), "pv_velocity.txt")).T @@ -147,7 +153,7 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, inlet, coeffs = [], [] coeffs, omega, period = get_coeffients(t_values, V_values) for normal_component in tmp_normal: - _in = boundary_expression(coeffs, omega, period, tmp_normal, normal_component, tmp_area, tmp_center, tmp_radius, element = V.ufl_element()) + _in = boundary_expression(coeffs, omega, period, tmp_normal, normal_component, tmp_area, tmp_center, tmp_radius,'parabolic',element = V.ufl_element()) inlet.append(_in) NS_expressions[ID] = inlet @@ -157,10 +163,6 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, for uc in inlet: uc.update(t) - #inlet = make_womersley_bcs(t_values, Q_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element()) - #inlet = make_parabolic_bcs(t_values, V_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, V.ufl_element(),coeffstype="V") - - bc_p = [] for i, ID in enumerate(id_out): bc = DirichletBC(Q, Constant(0.0), boundary, ID) @@ -172,12 +174,10 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, # Create Boundary conditions for the wall bc_wall = DirichletBC(V, wall, boundary, 1) - # Need to be updated if there are more than four inlets - return dict(u0=[bc_inlets[id_in[0]][0], bc_inlets[id_in[1]][0], bc_inlets[id_in[2]][0], bc_inlets[id_in[3]][0], bc_wall], - u1=[bc_inlets[id_in[0]][1], bc_inlets[id_in[1]][1], bc_inlets[id_in[2]][1], bc_inlets[id_in[3]][1], bc_wall], - u2=[bc_inlets[id_in[0]][2], bc_inlets[id_in[1]][2], bc_inlets[id_in[2]][2], bc_inlets[id_in[3]][2], bc_wall], + return dict(u0=[bc_inlets[id_in[0]][0], bc_inlets[id_in[1]][0], bc_inlets[id_in[2]][0], bc_inlets[id_in[3]][0], bc_inlets[id_in[4]][0], bc_wall], + u1=[bc_inlets[id_in[0]][1], bc_inlets[id_in[1]][1], bc_inlets[id_in[2]][1], bc_inlets[id_in[3]][1], bc_inlets[id_in[4]][1], bc_wall], + u2=[bc_inlets[id_in[0]][2], bc_inlets[id_in[1]][2], bc_inlets[id_in[2]][2], bc_inlets[id_in[3]][2], bc_inlets[id_in[4]][2], bc_wall], p=bc_p) - def get_file_paths(folder): # Create folder where data and solutions (velocity, mesh, pressure) is stored @@ -223,17 +223,16 @@ def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, **NS_namesp mesh_file.write(mesh, "mesh") h = EdgeLength(mesh) - + return dict(eval_dict=eval_dict, boundary=boundary, n=n, h=h) - def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, id_in, id_out, boundary, n, store_data, - NS_parameters, NS_expressions, area_ratio, dt, t, store_data_tstep, **NS_namespace): - + NS_parameters, NS_expressions, area_ratio, dt, t, tstep_print, **NS_namespace): + boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) boundary.set_values(boundary.array() + 1) - id_in = [3,4,5,6] # Hardcoded. FIXIT: automated prepocessing + id_in = [3,4,5,6,7] # Hardcoded. FIXIT: automated prepocessing id_out = [2] # Update boundary condition @@ -242,51 +241,33 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, uc.update(t) # Compute flux and update pressure condition - if tstep > 2: + if tstep >=1 and tstep %tstep_print == 0: Q_ideals, Q_in, Q_ins, Q_out, V_out, V_ins = compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh, n, tstep, u_, newfolder, t) - DG = FunctionSpace(mesh, "DG", 0) - U = project(sqrt(inner(u_, u_)), DG) - - cfl = U.vector().get_local() * dt / h #Check the used unit in calculating cfl before running simulation - - max_cfl = cfl.max() - min_cfl = cfl.min() + if tstep % tstep_print == 0: + DG = FunctionSpace(mesh, "DG", 0) + U = project(sqrt(inner(u_, u_)), DG, solver_type='cg') - # print(cfl.max()*h / dt) - dim_MV = NS_parameters['dim_MV'] - dim_PV = NS_parameters['dim_PV'] - - Re = U.vector().get_local() * dim_MV / NS_parameters['nu'] - Re_MV = Re.max() - Re_ = U.vector().get_local() * dim_PV / NS_parameters['nu'] - Re_PV = Re_.max() - - if MPI.rank(MPI.comm_world) == 0 and tstep % 10 == 0: - print("=" * 10, tstep, "=" * 10) - print() - info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}, Re_PV={0:2.4e}, Re_MV={0:2.4e}' - .format(t, tstep, max_cfl, min_cfl, Re_PV, Re_MV)) - # info_green('Time = {0:2.4e}, timestep = {1:6d}, max_CFL={2:2.3f}, min_CFL={3:2.3f}' - # .format(t, tstep, max_cfl, min_cfl)) - print("Sum of Q_in = {:0.4f} Q_out = {:0.4f}".format(sum(Q_ins), Q_out)) - #for i, in_id in enumerate(id_in): - # print(("({:d}) New pressure {:0.4f}").format(out_id, NS_expressions[out_id].p)) - # for i, in_id in enumerate(id_out): - # print(("({:d}) area ratio {:0.4f}, ideal: {:0.4f} actual:" + - # " {:0.4f}").format(in_id, area_ratio[i], Q_ideals[i], Q_ins[i])) - print() + cfl = U.vector().get_local() * dt / h + max_cfl = cfl.max() + min_cfl = cfl.min() - if MPI.rank(MPI.comm_world) == 0 and tstep > 2: - velocity_path = path.join(newfolder, "Timeseries", "velocity.txt") - if not path.isdir(path.join(newfolder, "Timeseries")): - os.mkdir(path.join(newfolder, "Timeseries")) - with open(velocity_path, 'a') as filename: - #filename.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, Q_out, Q_ins[0], Q_ins[1], Q_ins[2], Q_ins[3])) - filename.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, V_out, V_ins[0], V_ins[1], V_ins[2], V_ins[3])) + dim_MV = NS_parameters['dim_MV'] + dim_PV = NS_parameters['dim_PV'] + + Re = U.vector().get_local() * dim_MV / NS_parameters['nu'] + Re_MV = Re.max() + Re_ = U.vector().get_local() * dim_PV / NS_parameters['nu'] + Re_PV = Re_.max() + + if MPI.rank(MPI.comm_world) == 0 and tstep % tstep_print == 0: #print_intermediate_info + info_green('Time = {:0.4f}, timestep = {:0.4f}, max_CFL={:0.4f}, min_CFL={:0.4f}, Re_PV={:0.4f}, Re_MV={:0.4f}' + .format(t, tstep, max_cfl, min_cfl, Re_PV, Re_MV)) + print("Sum of Q_in = {:0.4f} Q_out = {:0.4f}".format(sum(Q_ins), Q_out)) + # Sample velocity in points eval_dict["centerline_u_x_probes"](u_[0]) eval_dict["centerline_u_y_probes"](u_[1]) @@ -317,10 +298,9 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, eval_dict["centerline_u_x_probes"].clear() eval_dict["centerline_u_y_probes"].clear() eval_dict["centerline_u_z_probes"].clear() - eval_dict["centerline_p_probes"].clear() # Save velocity and pressure - if tstep % store_data == 0 and tstep >= store_data_tstep: + if tstep % store_data == 0 and tstep>=1: #and tstep >= store_data_tstep: # Name functions u_[0].rename("u0", "velocity-x") u_[1].rename("u1", "velocity-y") @@ -329,7 +309,7 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, # Get save paths files = NS_parameters['files'] - file_mode = "w" if tstep == store_data_tstep else "a" + file_mode = "w" if tstep == store_data else "a" p_path = files['p'] # Save @@ -352,6 +332,7 @@ def compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh Q_out = abs(assemble(dot(u_, n) * ds(id_out[0], domain=mesh, subdomain_data=boundary))) dso = assemble(f*ds(id_out[0], domain=mesh, subdomain_data=boundary)) + # print('id_out:', id_out[0], dso) V_out = Q_out/ dso f.vector()[:] = 1. @@ -361,6 +342,7 @@ def compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh for i, in_id in enumerate(id_in): Q_in = abs(assemble(dot(u_, n) * ds(in_id, domain=mesh, subdomain_data=boundary))) dsi = assemble(f*ds(in_id, domain=mesh, subdomain_data=boundary)) + # print(in_id, dsi) V_in = Q_in / dsi Q_ins.append(Q_in) V_ins.append(V_in) @@ -419,8 +401,3 @@ def fourier_coefficients(x, y, T, N): ck.append(2*c) return ck, omega - - - - - From ffc6a6bc4c05ce3b19e7bbff2d6cf98a3a96614f Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Fri, 27 Aug 2021 10:43:03 +0200 Subject: [PATCH 10/76] Improved for generating mesh for atrium models. '-at' or '--atrium' flag as True needs to be passed from command line. --- .../automatedPreProcessing.py | 62 +++++++++++++------ 1 file changed, 42 insertions(+), 20 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index afec3ebe..4f389919 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -13,7 +13,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, smooth_aneurysm, - meshing_method, aneurysm_present, create_flow_extensions, viz, config_path, number_of_sac_points, + meshing_method, aneurysm_present, atrium_present, create_flow_extensions, viz, config_path, number_of_sac_points, coarsening_factor, compress_mesh=True): """ Automatically generate mesh of surface model in .vtu and .xml format, including prescribed @@ -29,6 +29,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin smooth_aneurysm (bool): Toggles smoothing of aneurysm (if present) meshing_method (str): Method for meshing aneurysm_present (bool): Determines if aneurysm is present + atrium_present (bool): Determines whether this ia an atrium case create_flow_extensions (bool): Adds flow extensions to mesh if True viz (bool): Visualize resulting surface model with flow rates config_path (str): Path to configuration file for remote simulation @@ -65,15 +66,15 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin print("--- Load model file\n") surface = ReadPolyData(filename_model) - if not is_surface_capped and smoothing_method != "voronoi": - print("--- Clipping the models inlet and outlets.\n") + if not is_surface_capped(surface, atrium_present) and smoothing_method != "voronoi": + print("--- Clipping the models inlets and outlets.\n") if not path.isfile(file_name_clipped_model): - # TODO: Check if this is a valid call to this method - centerline = compute_centerlines([], [], None, surface, method="pickpoint") - surface = uncapp_surface(surface, centerline, filename=None) + # TODO: Add input parameters as input to automatedPreProcessing + #centerline = compute_centerlines([], [], atrium_present, None, surface, method="pickpoint") + surface = uncapp_surface(surface, area_limit=20, circleness_limit=5) + WritePolyData(surface, file_name_clipped_model) else: surface = ReadPolyData(file_name_clipped_model) - parameters = get_parameters(path.join(dir_path, case_name)) if "check_surface" not in parameters.keys(): @@ -93,21 +94,21 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin write_parameters(parameters, path.join(dir_path, case_name)) # Capp surface if open - if not compute_centers(surface, test_capped=True): + if not compute_centers(surface, atrium_present, test_capped=True): capped_surface = capp_surface(surface) else: capped_surface = surface # Get centerlines print("--- Get centerlines\n") - inlet, outlets = get_centers(surface, path.join(dir_path, case_name)) - centerlines = compute_centerlines(inlet, outlets, file_name_centerlines, - capped_surface, resampling=0.1, end_point=0) + # FIXIT: when atrium is present several inlets and 1 outlet + inlet, outlets = get_centers(surface, atrium_present, path.join(dir_path, case_name)) + centerlines = compute_centerlines(inlet, outlets, atrium_present, file_name_centerlines, capped_surface, resampling=0.1, end_point=0) tol = get_tolerance(centerlines) if aneurysm_present: aneurysms = get_aneurysm_dome(capped_surface, path.join(dir_path, case_name)) - centerlineAnu = compute_centerlines(inlet, aneurysms, file_name_aneurysm_centerlines, + centerlineAnu = compute_centerlines(inlet, aneurysms, atrium_present, file_name_aneurysm_centerlines, capped_surface, resampling=0.1) # Extract the aneurysm centerline @@ -183,7 +184,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Check if there has been added new outlets num_outlets = centerlines.GetNumberOfLines() - num_outlets_after = compute_centers(surface_uncapped, test_capped=True)[1] + num_outlets_after = compute_centers(surface_uncapped, atrium_present, test_capped=True)[1] if num_outlets != num_outlets_after: surface = vmtkSmoother(surface, "laplace", iterations=200) @@ -236,7 +237,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if create_flow_extensions: if not path.isfile(file_name_model_flow_ext): print("--- Adding flow extensions") - extension = 4 #5 + extension = 1 extender = vmtkscripts.vmtkFlowExtensions() extender.Surface = surface @@ -246,6 +247,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin extender.ExtensionMode = "boundarynormal" extender.CenterlineNormalEstimationDistanceRatio = 1.0 extender.Interactive = 0 + extender.AdaptiveNumberOfBoundaryPoints = 1 extender.Execute() surface = extender.Surface @@ -261,9 +263,9 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Get new centerlines with the flow extensions if not path.isfile(file_name_flow_centerlines): print("--- Compute the model centerlines with flow extension.") - # Compute the centerlines. - inlet, outlets = get_centers(surface, path.join(dir_path, case_name), flowext=True) - centerlines = compute_centerlines(inlet, outlets, file_name_flow_centerlines, capped_surface, resampling=0.5) + # Compute the centerlines. FIXIT: There are several inlets and one outet for atrium case + inlet, outlets = get_centers(surface, atrium_present, path.join(dir_path, case_name), flowext=True) + centerlines = compute_centerlines(inlet, outlets, atrium_present, file_name_flow_centerlines, capped_surface, resampling=0.5) else: centerlines = ReadPolyData(file_name_flow_centerlines) @@ -365,7 +367,14 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # BSL method for mean inlet flow rate. parameters = get_parameters(path.join(dir_path, case_name)) - mean_inflow_rate = 0.27 * parameters["inlet_area"] + if(atrium_present==False): + mean_inflow_rate = 0.27 * parameters["inlet_area"] + else: + Total_inlet_area=0 + num_inlets = len(inlet) // 3 + for i in range(num_inlets): + Total_inlet_area+=parameters["inlet%s_area" % (i)] + mean_inflow_rate = 0.27 * Total_inlet_area # Extract the surface mesh of the wall wallMesh = threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) @@ -424,7 +433,13 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin areaRatioLine += repr(ids[k][1]) + ',' idFileLine += repr(ids[-1][0] - 1) + ' ' + repr(ids[0][1]) areaRatioLine += repr(ids[-1][1]) - info = {"inlet_area": parameters["inlet_area"], + if(atrium_present==False): + info = {"inlet_area": parameters["inlet_area"], + "idFileLine": str(idFileLine), + "areaRatioLine": str(areaRatioLine) + } + else: + info = {"inlet_area": Total_inlet_area, "idFileLine": str(idFileLine), "areaRatioLine": str(areaRatioLine) } @@ -542,6 +557,12 @@ def read_command_line(): default=True, help="Determine weather or not the model has a aneurysm. Default is False.") + parser.add_argument('-at', '--atrium', + dest="atriu", + type=str2bool, + default=False, + help="Determine weather or not the model is an Atrium model. Default is False.") + parser.add_argument('-f', '--flowext', dest="fext", default=True, @@ -584,7 +605,8 @@ def verbose_print(*args): return dict(filename_model=args.fileNameModel, verbose_print=verbose_print, smoothing_method=args.smoothingMethod, smoothing_factor=args.smoothingFactor, smooth_aneurysm=args.smoothingAneurysm, - meshing_method=args.meshingMethod, aneurysm_present=args.aneu, create_flow_extensions=args.fext, + meshing_method=args.meshingMethod, aneurysm_present=args.aneu, atrium_present=args.atriu, + create_flow_extensions=args.fext, viz=args.viz, config_path=args.config, number_of_sac_points=args.sacpts, coarsening_factor=args.coarseningFactor) From 0c9cb5ae5fd3bebefa86f791b7a8a573ef64cbfd Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Fri, 27 Aug 2021 10:47:16 +0200 Subject: [PATCH 11/76] Improved for Atrium models inlet ids and outlet id --- automatedPreProcessing/common.py | 267 ++++++++++++++++++++++--------- 1 file changed, 189 insertions(+), 78 deletions(-) diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 6230fb86..101d7ab6 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -2,6 +2,7 @@ import vtk from vmtk import vtkvmtk, vmtkscripts +from vtk_wrapper import * try: from vmtkpointselector import * @@ -277,48 +278,108 @@ def WriteTecplotSurfaceFile(surface, filename): f.write(line) -def uncapp_surface(surface, centerlines, filename, clipspheres=0): +def uncapp_surface(surface, gradients_limit=0.15, area_limit=0.3, circleness_limit=3): """ - A method for removing endcapps on a surface. The method considers the centerline - of the surface model and clips the endcaps a distance of clipspheres * MISR away from the edge. + A rule-based method for removing endcapps on a surface. The method considers the + gradient of the normals, the size of the region, and how similar it is to a circle. Args: surface (vtkPolyData): Surface to be uncapped. - centerlines (vtkPolyData): Centerlines in surface model - filename (str): Filename to write uncapped model to - clipspheres (int): Number of MISR to clip model + gradients_limit (float): Upper limit for gradients of normals. + area_limit (float): Lower limit of the area. + circleness_limit (float): Upper limit of the circleness. Returns: surface (vtkPolyData): The uncapped surface. """ - extractor = vmtkscripts.vmtkEndpointExtractor() - extractor.Centerlines = centerlines - extractor.RadiusArrayName = radiusArrayName - extractor.GroupIdsArrayName = groupIDsArrayName - extractor.BlankingArrayName = branchClippingArrayName - extractor.NumberOfEndPointSpheres = clipspheres - extractor.Execute() - clipped_centerlines = extractor.Centerlines - - clipper = vmtkscripts.vmtkBranchClipper() - clipper.Surface = surface - clipper.Centerlines = clipped_centerlines - clipper.RadiusArrayName = radiusArrayName - clipper.GroupIdsArrayName = groupIDsArrayName - clipper.BlankingArrayName = branchClippingArrayName - clipper.Execute() - surface = clipper.Surface - - connector = vmtkscripts.vmtkSurfaceConnectivity() - connector.Surface = surface - connector.CleanOutput = 1 - connector.Execute() - surface = connector.Surface - - if filename is not None: - WritePolyData(surface, filename) - return surface + cell_normals = vtk_compute_polydata_normals(surface, compute_cell_normals=True) + + gradients = vtk_compute_normal_gradients(cell_normals) + + # Compute the magnitude of the gradient + gradients_array = get_cell_data_array("Gradients", gradients, 9) + gradients_magnitude = np.sqrt(np.sum(gradients_array ** 2, axis=1)) + + # Mark all cells with a gradient magnitude less then gradient_limit + end_capp_array = gradients_magnitude < gradients_limit + end_capp_vtk = get_vtk_array("Gradients_mag", 1, end_capp_array.shape[0]) + for i, p in enumerate(end_capp_array): + end_capp_vtk.SetTuple(i, [p]) + gradients.GetCellData().AddArray(end_capp_vtk) + + # Extract capps + end_capps = vtk_compute_threshold(gradients, "Gradients_mag", lower=0.5, upper=1.5, + threshold_type="between", source=1) + + # Get connectivity + end_capps_connectivity = vtk_compute_connectivity(end_capps) + region_array = get_point_data_array("RegionId", end_capps_connectivity) + + # Compute area for each region + area = [] + circleness = [] + regions = [] + centers_edge = [] + limit = 0.1 + for i in range(int(region_array.max()) + 1): + regions.append(vtk_compute_threshold(end_capps_connectivity, "RegionId", lower=(i - limit), + upper=(i + limit), threshold_type="between", source=0)) + circ, center = compute_circleness(regions[-1]) + circleness.append(circ) + centers_edge.append(center) + area.append(vtk_compute_mass_properties(regions[-1])) + + # Only keep outlets with circleness < circleness_limit and area > area_limit + circleness_ids = np.where(np.array(circleness) < circleness_limit) + region_ids = np.where(np.array(area) > area_limit) + regions = [regions[i] for i in region_ids[0] if i in circleness_ids[0]] + centers_edge = [centers_edge[i] for i in region_ids[0] if i in circleness_ids[0]] + + # Mark the outlets on the original surface + mark_outlets = create_vtk_array(np.zeros(surface.GetNumberOfCells()), "outlets", k=1) + locator = get_vtk_cell_locator(surface) + tmp_center = [0, 0, 0] + for region in regions: + centers_filter = vtk.vtkCellCenters() + centers_filter.SetInputData(region) + centers_filter.VertexCellsOn() + centers_filter.Update() + centers = centers_filter.GetOutput() + + for i in range(centers.GetNumberOfPoints()): + centers.GetPoint(i, tmp_center) + p = [0, 0, 0] + cell_id = vtk.mutable(0) + sub_id = vtk.mutable(0) + dist = vtk.mutable(0) + locator.FindClosestPoint(tmp_center, p, cell_id, sub_id, dist) + mark_outlets.SetTuple(cell_id, [1]) + + surface.GetCellData().AddArray(mark_outlets) + + # Remove the outlets from the original surface + uncapped_surface = vtk_compute_threshold(surface, "outlets", lower=0, upper=0.5, threshold_type="between", source=1) + + # Check if some cells where not marked + remove = True + while remove: + locator = get_vtk_cell_locator(uncapped_surface) + mark_outlets = create_vtk_array(np.zeros(uncapped_surface.GetNumberOfCells()), "outlets", k=1) + remove = False + for center in centers_edge: + locator.FindClosestPoint(center, p, cell_id, sub_id, dist) + if dist < 0.01: + remove = True + mark_outlets.SetTuple(cell_id, [1]) + + uncapped_surface.GetCellData().AddArray(mark_outlets) + + if remove: + uncapped_surface = vtk_compute_threshold(uncapped_surface, "outlets", lower=0, + upper=0.5, threshold_type="between", source=1) + + return uncapped_surface def get_teams(dirpath): @@ -839,7 +900,7 @@ def surface_cleaner(surface): return surfaceCleaner.GetOutput() -def get_centers(surface, dir_path, flowext=False): +def get_centers(surface, atrium_present, dir_path, flowext=False): """ Get the centers of the inlet and outlets. @@ -854,27 +915,48 @@ def get_centers(surface, dir_path, flowext=False): """ # Check if info exists - if flowext or not path.isfile(path.join(dir_path, dir_path + ".txt")): - compute_centers(surface, dir_path) + if flowext or not path.isfile(path.join(dir_path, dir_path + ".json")): + compute_centers(surface, atrium_present, dir_path) # Open info parameters = get_parameters(dir_path) outlets = [] inlet = [] for key, value in parameters.items(): - if key == "inlet": - inlet = value - elif "outlet" in key and "area" not in key and "relevant" not in key: - outlets += value + + if(atrium_present==False): + if key == "inlet": + inlet = value + elif "outlet" in key and "area" not in key and "relevant" not in key: + outlets += value + else: + # FIXIT: 1 outlet and several inlets. Setting names should be corrected + if key == "outlet": + outlets = value + elif "inlet" in key and "area" not in key and "relevant" not in key: + inlet += value num_outlets = len(outlets) // 3 + num_inlets = len(inlet) // 3 + if num_outlets != 0: - outlets = [] - for i in range(num_outlets): - outlets += parameters["outlet%d" % i] + if(atrium_present==False): + outlets = [] + for i in range(num_outlets): + outlets += parameters["outlet%d" % i] + else: + # FIXIT: several inlets + inlet = [] + for i in range(num_inlets): + inlet += parameters["inlet%d" % i] - if inlet == [] and outlets == []: - inlet, outlets = compute_centers(surface, dir_path) + # FIXIT: atrium case has several inlets (instead of inlet) and only one outlet (instead of outlets). + if inlet == [] and outlets == []: + inlet, outlets = compute_centers(surface, atrium_present, dir_path) + + print("The number of outlets =", len(outlets) // 3) + print("The number of inlets =", len(inlet) // 3) + print() return inlet, outlets @@ -1046,7 +1128,7 @@ def compute_distance_to_sphere(surface, centerSphere, radiusSphere=0.0, return surface -def is_surface_capped(surface): +def is_surface_capped(surface, atrium_present): """ Checks if the surface is closed, and how many openings there are. @@ -1058,7 +1140,7 @@ def is_surface_capped(surface): number (int): Number of integer """ - return compute_centers(surface, test_capped=True)[0] + return compute_centers(surface, atrium_present, test_capped=True)[0] def getConnectivity(surface): @@ -1146,28 +1228,29 @@ def getFeatureEdges(polyData): return featureEdges.GetOutput() -def compute_centers(polyData, case_path=None, test_capped=False): +def compute_centers(polyData, atrium_present, case_path=None, test_capped=False): """ Compute the center of all the openings in the surface. The inlet is chosen based on - the largest area. + the largest area for arteries (or aneurysm). However, for atrium, the outlet is chosen based on + the largest area (new). Args: - test_capped (bool): Check if surface is capped - polyData (vtkPolyData): centers of the openings + test_capped (bool): Check if surface is capped. + polyData (vtkPolyData): centers of the openings. case_path (str): path to case directory. + atrium_present (bool): Check if it is an atrium model. Returns: inlet_center (list): Inlet center. outlet_centers (list): A flattened list with all the outlet centers. """ - # Get cells which are open cells = getFeatureEdges(polyData) if cells.GetNumberOfCells() == 0 and not test_capped: print("WARNING: The model is capped, so it is uncapped, but the method is experimental.") uncapped_surface = uncapp_surface(polyData) - compute_centers(uncapped_surface, case_path, test_capped) + compute_centers(uncapped_surface, atrium_present, case_path, test_capped) elif cells.GetNumberOfCells() == 0 and test_capped: return False, 0 @@ -1203,24 +1286,44 @@ def compute_centers(polyData, case_path=None, test_capped=False): # Get center center.append(np.mean(points[(region_array == i).nonzero()[0]], axis=0)) - # Store the center and area - inlet_ind = area.index(max(area)) - if case_path is not None: - info = {"inlet": center[inlet_ind].tolist(), "inlet_area": area[inlet_ind]} - p = 0 - for i in range(len(area)): - if i == inlet_ind: p = -1; continue - info["outlet%d" % (i + p)] = center[i].tolist() - info["outlet%s_area" % (i + p)] = area[i] + if(atrium_present==True): + # Store the center and area + outlet_ind = area.index(max(area)) + if case_path is not None: + info = {"outlet": center[outlet_ind].tolist(), "outlet_area": area[outlet_ind]} + p = 0 + for i in range(len(area)): + if i == outlet_ind: p = -1; continue + info["inlet%d" % (i + p)] = center[i].tolist() + info["inlet%s_area" % (i + p)] = area[i] + + write_parameters(info, case_path) - write_parameters(info, case_path) + outlet_center = center[outlet_ind].tolist() # center of the outlet + center.pop(outlet_ind) + + center_ = [item for sublist in center for item in sublist] # centers of the inlets + + return center_, outlet_center + else: + # Store the center and area + inlet_ind = area.index(max(area)) + if case_path is not None: + info = {"inlet": center[inlet_ind].tolist(), "inlet_area": area[inlet_ind]} + p = 0 + for i in range(len(area)): + if i == inlet_ind: p = -1; continue + info["outlet%d" % (i + p)] = center[i].tolist() + info["outlet%s_area" % (i + p)] = area[i] - inlet_center = center[inlet_ind].tolist() - center.pop(inlet_ind) + write_parameters(info, case_path) - center_ = [item for sublist in center for item in sublist] + inlet_center = center[inlet_ind].tolist() + center.pop(inlet_ind) - return inlet_center, center_ + center_ = [item for sublist in center for item in sublist] + + return inlet_center, center_ def compute_bary_center(points): @@ -1395,7 +1498,7 @@ def compute_centerline_sections(surface, centerline): return line, CenterlineSections -def compute_centerlines(inlet, outlet, filepath, surface, resampling=1, smooth=False, num_iter=100, smooth_factor=0.1, +def compute_centerlines(inlet, outlet, atrium_present, filepath, surface, resampling=1, smooth=False, num_iter=100, smooth_factor=0.1, end_point=1, method="pointlist"): """Wrapper for vmtkcenterlines and vmtkcenterlinesmoothing. @@ -1417,15 +1520,21 @@ def compute_centerlines(inlet, outlet, filepath, surface, resampling=1, smooth=F if path.isfile(filepath): return ReadPolyData(filepath) - + centerlines = vmtkscripts.vmtkCenterlines() centerlines.Surface = surface centerlines.SeedSelectorName = 'pointlist' centerlines.AppendEndPoints = end_point centerlines.Resampling = 1 centerlines.ResamplingStepLength = resampling - centerlines.SourcePoints = inlet - centerlines.TargetPoints = outlet + + if(atrium_present==False): + centerlines.SourcePoints = inlet + centerlines.TargetPoints = outlet + else: + centerlines.SourcePoints = outlet + centerlines.TargetPoints = inlet + centerlines.Execute() centerlines = centerlines.Centerlines @@ -1488,13 +1597,15 @@ def generate_mesh(surface): # Compute the mesh. meshGenerator = vmtkscripts.vmtkMeshGenerator() meshGenerator.Surface = surface - meshGenerator.ElementSizeMode = "edgelengtharray" - meshGenerator.TargetEdgeLengthArrayName = "Size" - meshGenerator.BoundaryLayer = 1 - meshGenerator.NumberOfSubLayers = 4 - meshGenerator.BoundaryLayerOnCaps = 0 - meshGenerator.BoundaryLayerThicknessFactor = 0.85 - meshGenerator.SubLayerRatio = 0.75 + meshGenerator.ElementSizeMode = "edgelengtharray" # Variable size mesh + meshGenerator.TargetEdgeLengthArrayName = "Size" # Variable size mesh + #meshGenerator.ElementSizeMode = "edgelength" # Constant size mesh + #meshGenerator.TargetEdgeLength = 1.0 # Constant size mesh + meshGenerator.BoundaryLayer = 1 + meshGenerator.NumberOfSubLayers = 4 + meshGenerator.BoundaryLayerOnCaps = 0 # it should 1 + meshGenerator.BoundaryLayerThicknessFactor = 0.7 #0.85 + meshGenerator.SubLayerRatio = 0.55 #0.75 meshGenerator.Tetrahedralize = 1 meshGenerator.VolumeElementScaleFactor = 0.8 meshGenerator.EndcapsEdgeLengthFactor = 1.0 From d09bfd39da55bc62ff566db958181068fb2fcc6d Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Mon, 11 Oct 2021 16:59:07 +0200 Subject: [PATCH 12/76] Replaced AW methods with morphMan methods --- .../automatedPreProcessing.py | 233 +- automatedPreProcessing/common.py | 2158 +++-------------- 2 files changed, 446 insertions(+), 1945 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 4f389919..80219cb6 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -12,9 +12,9 @@ from visualize import visualize -def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, smooth_aneurysm, - meshing_method, aneurysm_present, atrium_present, create_flow_extensions, viz, config_path, number_of_sac_points, - coarsening_factor, compress_mesh=True): +def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, meshing_method, + aneurysm_present, atrium_present, create_flow_extensions, viz, config_path, coarsening_factor, + flow_extension_length, edge_length, compress_mesh=True): """ Automatically generate mesh of surface model in .vtu and .xml format, including prescribed flow rates at inlet and outlet based on flow network model. @@ -26,14 +26,12 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin verbose_print (bool): Toggles verbose mode smoothing_method (str): Method for surface smoothing smoothing_factor (float): Smoothing parameter - smooth_aneurysm (bool): Toggles smoothing of aneurysm (if present) meshing_method (str): Method for meshing aneurysm_present (bool): Determines if aneurysm is present - atrium_present (bool): Determines whether this ia an atrium case + atrium_present (bool): Determines whether this is an atrium case create_flow_extensions (bool): Adds flow extensions to mesh if True viz (bool): Visualize resulting surface model with flow rates config_path (str): Path to configuration file for remote simulation - number_of_sac_points (int): Number of sac points to evaluate (inside aneurysm) coarsening_factor (float): Refine or coarsen the standard mesh size with given factor compress_mesh (bool): Compresses finalized mesh if True """ @@ -64,22 +62,21 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Open the surface file. print("--- Load model file\n") - surface = ReadPolyData(filename_model) + surface = read_polydata(filename_model) - if not is_surface_capped(surface, atrium_present) and smoothing_method != "voronoi": + if not is_surface_capped(surface) and smoothing_method != "voronoi": print("--- Clipping the models inlets and outlets.\n") if not path.isfile(file_name_clipped_model): # TODO: Add input parameters as input to automatedPreProcessing - #centerline = compute_centerlines([], [], atrium_present, None, surface, method="pickpoint") - surface = uncapp_surface(surface, area_limit=20, circleness_limit=5) - WritePolyData(surface, file_name_clipped_model) + surface = get_uncapped_surface(surface, area_limit=20, circleness_limit=5) + write_polydata(surface, file_name_clipped_model) else: - surface = ReadPolyData(file_name_clipped_model) + surface = read_polydata(file_name_clipped_model) parameters = get_parameters(path.join(dir_path, case_name)) if "check_surface" not in parameters.keys(): - surface = surface_cleaner(surface) - surface = triangulate_surface(surface) + surface = vtk_clean_polydata(surface) + surface = vtk_triangulate_surface(surface) # Check the mesh if there is redundant nodes or NaN triangles. ToolRepairSTL.surfaceOverview(surface) @@ -94,22 +91,28 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin write_parameters(parameters, path.join(dir_path, case_name)) # Capp surface if open - if not compute_centers(surface, atrium_present, test_capped=True): - capped_surface = capp_surface(surface) + if not compute_centers_for_meshing(surface, atrium_present, test_capped=True): + capped_surface = vmtk_cap_polydata(surface) else: capped_surface = surface # Get centerlines print("--- Get centerlines\n") - # FIXIT: when atrium is present several inlets and 1 outlet - inlet, outlets = get_centers(surface, atrium_present, path.join(dir_path, case_name)) - centerlines = compute_centerlines(inlet, outlets, atrium_present, file_name_centerlines, capped_surface, resampling=0.1, end_point=0) - tol = get_tolerance(centerlines) + inlet, outlets = get_centers_for_meshing(surface, atrium_present, path.join(dir_path, case_name)) + if atrium_present: + source = outlets + target = inlet + else: + source = inlet + target = outlets + centerlines, _, _ = compute_centerlines(source, target, file_name_centerlines, capped_surface, resampling=0.1, + end_point=0) + tol = get_centerline_tolerance(centerlines) if aneurysm_present: aneurysms = get_aneurysm_dome(capped_surface, path.join(dir_path, case_name)) - centerlineAnu = compute_centerlines(inlet, aneurysms, atrium_present, file_name_aneurysm_centerlines, - capped_surface, resampling=0.1) + centerlineAnu, _, _ = compute_centerlines(source, aneurysms, file_name_aneurysm_centerlines, capped_surface, + resampling=0.1) # Extract the aneurysm centerline sac_centerline = [] @@ -119,8 +122,8 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Compute mean distance between points for i in range(num_anu): if not path.isfile(file_name_sac_centerlines.format(i)): - line = ExtractSingleLine(centerlineAnu, i) - locator = get_locator(centerlines) + line = extract_single_line(centerlineAnu, i) + locator = get_vtk_point_locator(centerlines) for j in range(line.GetNumberOfPoints() - 1, 0, -1): point = line.GetPoints().GetPoint(j) ID = locator.FindClosestPoint(point) @@ -129,14 +132,14 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if dist <= tol: break - tmp = ExtractSingleLine(line, 0, start_id=j) - WritePolyData(tmp, file_name_sac_centerlines.format(i)) + tmp = extract_single_line(line, 0, start_id=j) + write_polydata(tmp, file_name_sac_centerlines.format(i)) # List of VtkPolyData sac(s) centerline sac_centerline.append(tmp) else: - sac_centerline.append(ReadPolyData(file_name_sac_centerlines.format(i))) + sac_centerline.append(read_polydata(file_name_sac_centerlines.format(i))) else: num_anu = 0 @@ -147,11 +150,11 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if aneurysm_present: # Merge the sac centerline - sac_centerlines = merge_data(sac_centerline) + sac_centerlines = vtk_merge_polydata(sac_centerline) for sac in sac_centerline: sac_center.append(sac.GetPoints().GetPoint(sac.GetNumberOfPoints() // 2)) - tmp_misr = get_array(radiusArrayName, sac) + tmp_misr = get_point_data_array(radiusArrayName, sac) misr_max.append(tmp_misr.max()) # Smooth surface @@ -160,35 +163,35 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if not path.isfile(file_name_surface_smooth): # Get Voronoi diagram if not path.isfile(file_name_voronoi): - voronoi = makeVoronoiDiagram(surface, file_name_voronoi) - WritePolyData(voronoi, file_name_voronoi) + voronoi = make_voronoi_diagram(surface, file_name_voronoi) + write_polydata(voronoi, file_name_voronoi) else: - voronoi = ReadPolyData(file_name_voronoi) + voronoi = read_polydata(file_name_voronoi) # Get smooth Voronoi diagram if not path.isfile(file_name_voronoi_smooth): if aneurysm_present: - smooth_voronoi = SmoothVoronoiDiagram(voronoi, centerlines, smoothing_factor, sac_centerlines) + smooth_voronoi = smooth_voronoi_diagram(voronoi, centerlines, smoothing_factor, sac_centerlines) else: - smooth_voronoi = SmoothVoronoiDiagram(voronoi, centerlines, smoothing_factor) + smooth_voronoi = smooth_voronoi_diagram(voronoi, centerlines, smoothing_factor) - WritePolyData(smooth_voronoi, file_name_voronoi_smooth) + write_polydata(smooth_voronoi, file_name_voronoi_smooth) else: - smooth_voronoi = ReadPolyData(file_name_voronoi_smooth) + smooth_voronoi = read_polydata(file_name_voronoi_smooth) # Envelope the smooth surface surface = create_new_surface(smooth_voronoi) # Uncapp the surface - surface_uncapped = uncapp_surface(surface, centerlines, filename=None) + surface_uncapped = get_uncapped_surface(surface) # Check if there has been added new outlets num_outlets = centerlines.GetNumberOfLines() num_outlets_after = compute_centers(surface_uncapped, atrium_present, test_capped=True)[1] if num_outlets != num_outlets_after: - surface = vmtkSmoother(surface, "laplace", iterations=200) - WritePolyData(surface, file_name_surface_smooth) + surface = vmtk_smooth_surface(surface, "laplace", iterations=200) + write_polydata(surface, file_name_surface_smooth) print(("ERROR: Automatic clipping failed. You have to open {} and " + "manually clipp the branch which still is capped. " + "Overwrite the current {} and restart the script.").format( @@ -199,36 +202,36 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Smoothing to improve the quality of the elements # Consider to add a subdivision here as well. - surface = vmtkSmoother(surface, "laplace", iterations=200) + surface = vmtk_smooth_surface(surface, "laplace", iterations=200) # Write surface - WritePolyData(surface, file_name_surface_smooth) + write_polydata(surface, file_name_surface_smooth) else: - surface = ReadPolyData(file_name_surface_smooth) + surface = read_polydata(file_name_surface_smooth) elif smoothing_method == "laplace": print("--- Smooth surface: Laplacian smoothing\n") if not path.isfile(file_name_surface_smooth): - surface = vmtkSmoother(surface, smoothing_method) + surface = vmtk_smooth_surface(surface, smoothing_method) # Save the smoothed surface - WritePolyData(surface, file_name_surface_smooth) + write_polydata(surface, file_name_surface_smooth) else: - surface = ReadPolyData(file_name_surface_smooth) + surface = read_polydata(file_name_surface_smooth) elif smoothing_method == "taubin": print("--- Smooth surface: Taubin smoothing\n") if not path.isfile(file_name_surface_smooth): - surface = vmtkSmoother(surface, smoothing_method) + surface = vmtk_smooth_surface(surface, smoothing_method) # Save the smoothed surface - WritePolyData(surface, file_name_surface_smooth) + write_polydata(surface, file_name_surface_smooth) else: - surface = ReadPolyData(file_name_surface_smooth) + surface = read_polydata(file_name_surface_smooth) elif smoothing_method == "no_smooth" or None: print("--- No smoothing of surface\n") @@ -236,78 +239,87 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Add flow extensions if create_flow_extensions: if not path.isfile(file_name_model_flow_ext): - print("--- Adding flow extensions") - extension = 1 - + print("--- Adding flow extensions\n") extender = vmtkscripts.vmtkFlowExtensions() extender.Surface = surface extender.AdaptiveExtensionLength = 1 - extender.ExtensionRatio = extension + extender.TransitionRatio = 1 + extender.ExtensionRatio = flow_extension_length extender.Centerlines = centerlines - extender.ExtensionMode = "boundarynormal" + extender.ExtensionMode = "centerlinedirection" extender.CenterlineNormalEstimationDistanceRatio = 1.0 extender.Interactive = 0 extender.AdaptiveNumberOfBoundaryPoints = 1 extender.Execute() surface = extender.Surface - surface = vmtkSmoother(surface, "laplace", iterations=200) - WritePolyData(surface, file_name_model_flow_ext) + surface = vmtk_smooth_surface(surface, "laplace", iterations=200) + write_polydata(surface, file_name_model_flow_ext) else: - surface = ReadPolyData(file_name_model_flow_ext) + surface = read_polydata(file_name_model_flow_ext) # Capp surface with flow extensions - capped_surface = capp_surface(surface) + capped_surface = vmtk_cap_polydata(surface) # Get new centerlines with the flow extensions if not path.isfile(file_name_flow_centerlines): - print("--- Compute the model centerlines with flow extension.") + print("--- Compute the model centerlines with flow extension.\n") # Compute the centerlines. FIXIT: There are several inlets and one outet for atrium case - inlet, outlets = get_centers(surface, atrium_present, path.join(dir_path, case_name), flowext=True) - centerlines = compute_centerlines(inlet, outlets, atrium_present, file_name_flow_centerlines, capped_surface, resampling=0.5) + inlet, outlets = get_centers_for_meshing(surface, atrium_present, path.join(dir_path, case_name), flowext=True) + if atrium_present: + source = outlets + target = inlet + else: + source = inlet + target = outlets + centerlines, _, _ = compute_centerlines(source, target, file_name_flow_centerlines, capped_surface, + resampling=0.5) else: - centerlines = ReadPolyData(file_name_flow_centerlines) + centerlines = read_polydata(file_name_flow_centerlines) # Choose input for the mesh - print("--- Computing distance to sphere") - if meshing_method == "curvature": + print("--- Computing distance to sphere\n") + if meshing_method == "constant": + distance_to_sphere = surface + + elif meshing_method == "curvature": if not path.isfile(file_name_distance_to_sphere_curv): distance_to_sphere = dist_sphere_curv(surface, centerlines, sac_center, misr_max, file_name_distance_to_sphere_curv, coarsening_factor) else: - distance_to_sphere = ReadPolyData(file_name_distance_to_sphere_curv) - else: + distance_to_sphere = read_polydata(file_name_distance_to_sphere_curv) + elif meshing_method == "diameter": if not path.isfile(file_name_distance_to_sphere_diam): distance_to_sphere = dist_sphere_diam(surface, centerlines, sac_center, misr_max, file_name_distance_to_sphere_diam, coarsening_factor) else: - distance_to_sphere = ReadPolyData(file_name_distance_to_sphere_diam) + distance_to_sphere = read_polydata(file_name_distance_to_sphere_diam) # Compute mesh if not path.isfile(file_name_vtu_mesh): try: print("--- Computing mesh\n") - mesh, remeshed_surface = generate_mesh(distance_to_sphere) + mesh, remeshed_surface = generate_mesh(distance_to_sphere, edge_length) assert remeshed_surface.GetNumberOfPoints() > 0, \ "No points in surface mesh, try to remesh" assert mesh.GetNumberOfPoints() > 0, "No points in mesh, try to remesh" except: distance_to_sphere = mesh_alternative(distance_to_sphere) - mesh, remeshed_surface = generate_mesh(distance_to_sphere) + mesh, remeshed_surface = generate_mesh(distance_to_sphere, edge_length) assert mesh.GetNumberOfPoints() > 0, "No points in mesh, after remeshing" assert remeshed_surface.GetNumberOfPoints() > 0, \ "No points in surface mesh, try to remesh" # Write mesh in VTU format - WritePolyData(remeshed_surface, file_name_surface_name) - WritePolyData(mesh, file_name_vtu_mesh) + write_polydata(remeshed_surface, file_name_surface_name) + write_polydata(mesh, file_name_vtu_mesh) # Write mesh to FEniCS to format meshWriter = vmtkscripts.vmtkMeshWriter() @@ -320,7 +332,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin polyDataVolMesh = mesh else: - polyDataVolMesh = ReadPolyData(file_name_vtu_mesh) + polyDataVolMesh = read_polydata(file_name_vtu_mesh) # Set the network object used in the scripts for # boundary conditions and probes. @@ -352,7 +364,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # np.array(misr_max_center[k][1] + y[i]).tolist()[0], # np.array(misr_max_center[k][2] + z[i]).tolist()[0]]) - print("--- Saving probes points in: ", file_name_probe_points) + print("--- Saving probes points in: %s\n" % file_name_probe_points) probe_points = np.array(listProbePoints) probe_points.dump(file_name_probe_points) else: @@ -367,17 +379,17 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # BSL method for mean inlet flow rate. parameters = get_parameters(path.join(dir_path, case_name)) - if(atrium_present==False): + if (atrium_present == False): mean_inflow_rate = 0.27 * parameters["inlet_area"] else: - Total_inlet_area=0 - num_inlets = len(inlet) // 3 + Total_inlet_area = 0 + num_inlets = len(inlet) // 3 for i in range(num_inlets): - Total_inlet_area+=parameters["inlet%s_area" % (i)] + Total_inlet_area += parameters["inlet%s_area" % (i)] mean_inflow_rate = 0.27 * Total_inlet_area # Extract the surface mesh of the wall - wallMesh = threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) + wallMesh = vtk_compute_threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) boundaryReferenceSystems = vmtkscripts.vmtkBoundaryReferenceSystems() boundaryReferenceSystems.Surface = wallMesh @@ -387,7 +399,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin refSystem.GetPointData().AddArray(cellEntityIdsArray) # Extract the surface mesh of the end caps - boundarySurface = threshold(polyDataVolMesh, "CellEntityIds", upper=1.5, type="upper") + boundarySurface = vtk_compute_threshold(polyDataVolMesh, "CellEntityIds", upper=1.5, threshold_type="upper") pointCells = vtk.vtkIdList() surfaceCellEntityIdsArray = vtk.vtkIntArray() @@ -433,16 +445,16 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin areaRatioLine += repr(ids[k][1]) + ',' idFileLine += repr(ids[-1][0] - 1) + ' ' + repr(ids[0][1]) areaRatioLine += repr(ids[-1][1]) - if(atrium_present==False): - info = {"inlet_area": parameters["inlet_area"], - "idFileLine": str(idFileLine), - "areaRatioLine": str(areaRatioLine) - } - else: + if atrium_present: info = {"inlet_area": Total_inlet_area, - "idFileLine": str(idFileLine), - "areaRatioLine": str(areaRatioLine) - } + "idFileLine": str(idFileLine), + "areaRatioLine": str(areaRatioLine) + } + else: + info = {"inlet_area": parameters["inlet_area"], + "idFileLine": str(idFileLine), + "areaRatioLine": str(areaRatioLine) + } write_parameters(info, path.join(dir_path, case_name)) # Display the flow split at the outlets, inlet flow rate, and probes. @@ -538,49 +550,48 @@ def read_command_line(): help="smoothingFactor for VoronoiSmoothing, removes all spheres which" + " has a radius < MISR*(1-0.25), where MISR varying along the centerline.") - parser.add_argument('-sA', '--smoothAneurysm', - type=str2bool, - required=False, - dest="smoothingAneurysm", - help="When using Voronoi smoothing one can choose not to smooth the" + - " aneurysm as this method often removes to much of the aneurysm") - parser.add_argument('-m', '--meshingMethod', dest="meshingMethod", type=str, - choices=["diameter", "curvature"], + choices=["diameter", "curvature", "constant"], default="diameter") + parser.add_argument('-el', '--edge-length', + dest="edgeLength", + default=None, + type=float, + help="Characteristic edge length used for meshing.") + parser.add_argument('-a', '--aneurysm', - dest="aneu", + dest="aneurysmPresent", type=str2bool, - default=True, + default=False, help="Determine weather or not the model has a aneurysm. Default is False.") parser.add_argument('-at', '--atrium', - dest="atriu", + dest="atriumPresent", type=str2bool, default=False, - help="Determine weather or not the model is an Atrium model. Default is False.") + help="Determine weather or not the model is an Atrium model. Default is False.") parser.add_argument('-f', '--flowext', - dest="fext", + dest="flowExtension", default=True, type=str2bool, help="Add flow extensions to to the model.") + parser.add_argument('-fl', '--flowextlen', + dest="flowExtLen", + default=5, + type=float, + help="Length of flow extensions.") + parser.add_argument('-vz', '--visualize', dest="viz", default=True, type=str2bool, help="Visualize surface, inlet, outlet and probes after meshing.") - parser.add_argument('-sp', '--sacpoints', - type=int, - help='Number of sac points to add', - default=20, - dest="sacpts") - parser.add_argument('--simulationConfig', type=str, dest="config", @@ -604,11 +615,11 @@ def verbose_print(*args): verbose_print(args) return dict(filename_model=args.fileNameModel, verbose_print=verbose_print, smoothing_method=args.smoothingMethod, - smoothing_factor=args.smoothingFactor, smooth_aneurysm=args.smoothingAneurysm, - meshing_method=args.meshingMethod, aneurysm_present=args.aneu, atrium_present=args.atriu, - create_flow_extensions=args.fext, - viz=args.viz, config_path=args.config, number_of_sac_points=args.sacpts, - coarsening_factor=args.coarseningFactor) + smoothing_factor=args.smoothingFactor, meshing_method=args.meshingMethod, + aneurysm_present=args.aneurysmPresent, atrium_present=args.atriumPresent, + create_flow_extensions=args.flowExtension, viz=args.viz, config_path=args.config, + coarsening_factor=args.coarseningFactor, flow_extension_length=args.flowExtLen, + edge_length=args.edgeLength) if __name__ == "__main__": diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 101d7ab6..3d263c1b 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -1,18 +1,11 @@ -import json - -import vtk -from vmtk import vtkvmtk, vmtkscripts -from vtk_wrapper import * +from morphman.common import * try: from vmtkpointselector import * except ImportError: pass import numpy as np -import sys -import re -from os import path, listdir -import math +from os import path # Global array names radiusArrayName = 'MaximumInscribedSphereRadius' @@ -36,1893 +29,250 @@ phiValues = [float(i) for i in range(2, 43, 2)] thetaStep = 2.0 -# Shortcuts -version = vtk.vtkVersion().GetVTKMajorVersion() - - -def ReadPolyData(filename): - """ - Load the given file, and return a vtkPolyData object for it. - - Args: - filename (str): Path to input file. - - Returns: - polyData (vtkSTL/vtkPolyData/vtkXMLStructured/ - vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/ - vtkXMLImage/Tecplot): Output data. - """ - - # Check if file exists - if not path.exists(filename): - raise RuntimeError("Could not find file: %s" % filename) - - # Check filename format - fileType = filename.split(".")[-1] - if fileType == '': - raise RuntimeError('The file does not have an extension') - - # Get reader - if fileType == 'stl': - reader = vtk.vtkSTLReader() - reader.MergingOn() - elif fileType == 'vtk': - reader = vtk.vtkPolyDataReader() - elif fileType == 'vtp': - reader = vtk.vtkXMLPolyDataReader() - elif fileType == 'vts': - reader = vtk.vtkXMLStructuredGridReader() - elif fileType == 'vtr': - reader = vtk.vtkXMLRectilinearGridReader() - elif fileType == 'vtu': - reader = vtk.vtkXMLUnstructuredGridReader() - elif fileType == "vti": - reader = vtk.vtkXMLImageDataReader() - elif fileType == "tec": - polyData = ReadTecplotSurfaceFile(filename) - return polyData - else: - raise RuntimeError('Unknown file type %s' % fileType) - - # Read - reader.SetFileName(filename) - reader.Update() - polyData = reader.GetOutput() - - return polyData - - -def WritePolyData(input_data, filename): - """ - Write the given input data based on the file name extension. - - Args: - input_data (vtkSTL/vtkPolyData/vtkXMLStructured/ - vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/ - vtkXMLImage/Tecplot): Input data. - filename (str): Save path location. - """ - - # Check filename format - fileType = filename.split(".")[-1] - if fileType == '': - raise RuntimeError('The file does not have an extension') - - # Get writer - if fileType == 'stl': - writer = vtk.vtkSTLWriter() - elif fileType == 'vtk': - writer = vtk.vtkPolyDataWriter() - elif fileType == 'vts': - writer = vtk.vtkXMLStructuredGridWriter() - elif fileType == 'vtr': - writer = vtk.vtkXMLRectilinearGridWriter() - elif fileType == 'vtp': - writer = vtk.vtkXMLPolyDataWriter() - elif fileType == 'vtu': - writer = vtk.vtkXMLUnstructuredGridWriter() - elif fileType == "vti": - writer = vtk.vtkXMLImageDataWriter() - elif fileType == "tec": - WriteTecplotSurfaceFile(input_data, filename) - return - else: - raise RuntimeError('Unknown file type %s' % fileType) - - # Set filename and input - writer.SetFileName(filename) - if version < 6: - writer.SetInput(input_data) - else: - writer.SetInputData(input_data) - writer.Update() - - # Write - writer.Write() - - -def ReadTecplotSurfaceFile(filename): - f = open(filename, 'r') - line = f.readline() - - # Read title - if line.split()[0] == 'TITLE': - line = f.readline() - - # Read array names - if line.split()[0] == 'VARIABLES' or line.split('=')[0] == 'VARIABLES': - arrayNames = line.split('=')[1].strip().split(',') - arrayNames[0:3] = [] - line = f.readline() - - # Read ZONE variables - if line.split()[0] == 'ZONE': - lineNid = line.find('N=') - lineN = line[lineNid:lineNid + line[lineNid:].find(',')].split('=')[1] - numberOfNodes = int(lineN) - lineEid = line.find('E=') - lineE = line[lineEid:lineEid + line[lineEid:].find(',')].split('=')[1] - numberOfElements = int(lineE) - elementType = 'TRIANGLE' - if line.find('ET=') != -1: - if 'TRIANGLE' in line: - elementType = 'TRIANGLE' - elif 'QUADRILATERAL' in line: - elementType = 'QUADRILATERAL' - - # Initialize vtk objects - points = vtk.vtkPoints() - cells = vtk.vtkCellArray() - points.SetNumberOfPoints(numberOfNodes) - surface = vtk.vtkPolyData() - surface.SetPoints(points) - surface.SetPolys(cells) - - # Fill array object - for arrayName in arrayNames: - array = vtk.vtkDoubleArray() - array.SetName(arrayName) - array.SetNumberOfTuples(numberOfNodes) - surface.GetPointData().AddArray(array) - - # Get rest of data - data = f.read().split() - - # Insert points - dataCounter = 0 - for i in range(numberOfNodes): - point = [float(data[dataCounter]), float(data[dataCounter + 1]), float(data[dataCounter + 2])] - dataCounter += 3 - points.SetPoint(i, point) - for j in range(len(arrayNames)): - surface.GetPointData().GetArray(arrayNames[j]).SetComponent(i, 0, float(data[dataCounter])) - dataCounter += 1 - - # TODO: Is this necessary? It is not inserted into the surface - # Insert ids - cellIds = vtk.vtkIdList() - for i in range(numberOfElements): - cellIds.Initialize() - cellIds.InsertNextId(int(data[dataCounter]) - 1) - dataCounter += 1 - cellIds.InsertNextId(int(data[dataCounter]) - 1) - dataCounter += 1 - cellIds.InsertNextId(int(data[dataCounter]) - 1) - dataCounter += 1 - - if elementType == "QUADRILATERAL": - cellIds.InsertNextId(int(data[dataCounter]) - 1) - dataCounter += 1 - - cells.InsertNextCell(cellIds) - - return surface - - -def WriteTecplotSurfaceFile(surface, filename): - # Triangulate surface - surface = triangulate_surface(surface) - - # Open file - f = open(filename, 'w') - line = "VARIABLES = X,Y,Z" - - # Get array - arrayNames = [] - for i in range(surface.GetPointData().GetNumberOfArrays()): - array = surface.GetPointData().GetArray(i) - arrayName = array.GetName() - - if arrayName is None: - continue - if arrayName[-1] == '_': - continue - - arrayNames.append(arrayName) - - if array.GetNumberOfComponents() == 1: - line = line + ',' + arrayName - else: - for j in range(array.GetNumberOfComponents()): - line = line + ',' + arrayName + str(j) - - line = line + '\n' - f.write(line) - - # Write header - line = "ZONE N=%s,E=%s,F=FEPOINT,ET=TRIANGLE\n" % \ - (str(surface.GetNumberOfPoints()), - str(surface.GetNumberOfCells())) - f.write(line) - - # Write coordinates and array - for i in range(surface.GetNumberOfPoints()): - point = surface.GetPoint(i) - line = " ".join(point) - for arrayName in arrayNames: - array = surface.GetPointData().GetArray(arrayName) - for j in range(array.GetNumberOfComponents()): - line = line + ' ' + str(array.GetComponent(i, j)) - line = line + '\n' - f.write(line) - - # Write connectivity and ids - for i in range(surface.GetNumberOfCells()): - cellPointIds = surface.GetCell(i).GetPointIds() - line = '' - for j in range(cellPointIds.GetNumberOfIds()): - if j > 0: - line = line + ' ' - line = line + str(cellPointIds.GetId(j) + 1) - line = line + '\n' - f.write(line) - - -def uncapp_surface(surface, gradients_limit=0.15, area_limit=0.3, circleness_limit=3): - """ - A rule-based method for removing endcapps on a surface. The method considers the - gradient of the normals, the size of the region, and how similar it is to a circle. - - Args: - surface (vtkPolyData): Surface to be uncapped. - gradients_limit (float): Upper limit for gradients of normals. - area_limit (float): Lower limit of the area. - circleness_limit (float): Upper limit of the circleness. - - Returns: - surface (vtkPolyData): The uncapped surface. - """ - - cell_normals = vtk_compute_polydata_normals(surface, compute_cell_normals=True) - - gradients = vtk_compute_normal_gradients(cell_normals) - - # Compute the magnitude of the gradient - gradients_array = get_cell_data_array("Gradients", gradients, 9) - gradients_magnitude = np.sqrt(np.sum(gradients_array ** 2, axis=1)) - - # Mark all cells with a gradient magnitude less then gradient_limit - end_capp_array = gradients_magnitude < gradients_limit - end_capp_vtk = get_vtk_array("Gradients_mag", 1, end_capp_array.shape[0]) - for i, p in enumerate(end_capp_array): - end_capp_vtk.SetTuple(i, [p]) - gradients.GetCellData().AddArray(end_capp_vtk) - - # Extract capps - end_capps = vtk_compute_threshold(gradients, "Gradients_mag", lower=0.5, upper=1.5, - threshold_type="between", source=1) - - # Get connectivity - end_capps_connectivity = vtk_compute_connectivity(end_capps) - region_array = get_point_data_array("RegionId", end_capps_connectivity) - - # Compute area for each region - area = [] - circleness = [] - regions = [] - centers_edge = [] - limit = 0.1 - for i in range(int(region_array.max()) + 1): - regions.append(vtk_compute_threshold(end_capps_connectivity, "RegionId", lower=(i - limit), - upper=(i + limit), threshold_type="between", source=0)) - circ, center = compute_circleness(regions[-1]) - circleness.append(circ) - centers_edge.append(center) - area.append(vtk_compute_mass_properties(regions[-1])) - - # Only keep outlets with circleness < circleness_limit and area > area_limit - circleness_ids = np.where(np.array(circleness) < circleness_limit) - region_ids = np.where(np.array(area) > area_limit) - regions = [regions[i] for i in region_ids[0] if i in circleness_ids[0]] - centers_edge = [centers_edge[i] for i in region_ids[0] if i in circleness_ids[0]] - - # Mark the outlets on the original surface - mark_outlets = create_vtk_array(np.zeros(surface.GetNumberOfCells()), "outlets", k=1) - locator = get_vtk_cell_locator(surface) - tmp_center = [0, 0, 0] - for region in regions: - centers_filter = vtk.vtkCellCenters() - centers_filter.SetInputData(region) - centers_filter.VertexCellsOn() - centers_filter.Update() - centers = centers_filter.GetOutput() - - for i in range(centers.GetNumberOfPoints()): - centers.GetPoint(i, tmp_center) - p = [0, 0, 0] - cell_id = vtk.mutable(0) - sub_id = vtk.mutable(0) - dist = vtk.mutable(0) - locator.FindClosestPoint(tmp_center, p, cell_id, sub_id, dist) - mark_outlets.SetTuple(cell_id, [1]) - - surface.GetCellData().AddArray(mark_outlets) - - # Remove the outlets from the original surface - uncapped_surface = vtk_compute_threshold(surface, "outlets", lower=0, upper=0.5, threshold_type="between", source=1) - - # Check if some cells where not marked - remove = True - while remove: - locator = get_vtk_cell_locator(uncapped_surface) - mark_outlets = create_vtk_array(np.zeros(uncapped_surface.GetNumberOfCells()), "outlets", k=1) - remove = False - for center in centers_edge: - locator.FindClosestPoint(center, p, cell_id, sub_id, dist) - if dist < 0.01: - remove = True - mark_outlets.SetTuple(cell_id, [1]) - - uncapped_surface.GetCellData().AddArray(mark_outlets) - - if remove: - uncapped_surface = vtk_compute_threshold(uncapped_surface, "outlets", lower=0, - upper=0.5, threshold_type="between", source=1) - - return uncapped_surface - - -def get_teams(dirpath): - files = [f for f in listdir(dirpath) if path.isdir(path.join(dirpath, f))] - teams = [] - for folder in files: - try: - teams.append(path.join(dirpath, folder)) - except: - pass - - teams.sort(key=lambda x: int(x.split(path.sep)[-1])) - return teams - - -def makeVoronoiDiagram(surface, file_path): - """ - Compute the voronoi diagram of surface model. - - Args: - surface (polydata): Capped surface model to create a Voronoi diagram of. - file_path (str): Absolute path to surface model path. - - Returns: - voronoi (vtkPolyData): Voronoi diagram of surface. - """ - if path.isfile(file_path): - return ReadPolyData(file_path) - - voronoi = vmtkscripts.vmtkDelaunayVoronoi() - voronoi.Surface = surface - voronoi.RemoveSubresolutionTetrahedra = 0 - voronoi.Execute() - - WritePolyData(voronoi.VoronoiDiagram, file_path) - - return voronoi.VoronoiDiagram - - -def write_spheres(points, dirpath, radius=None, name="sphere%s.vtp", base=0.2): - radius = [base] * len(points) if radius is None else radius - for counter, point in enumerate(points): - sphere = vtk.vtkSphereSource() - sphere.SetCenter(point) - sphere.SetPhiResolution(100) - sphere.SetThetaResolution(100) - sphere.SetRadius(radius[counter]) - sphere_ = sphere.GetOutput() - - WritePolyData(sphere_, path.join(dirpath, name % counter)) - - -def get_tolerance(centerline): - """ - Finds tolerance based on average length between first N points along the input centerline. - - Args: - centerline (vtkPolyData): Centerline data. - - Returns: - tolerance (float): Tolerance value. - """ - line = ExtractSingleLine(centerline, 0) - length = get_curvilinear_coordinate(line) - - return np.mean(length[1:] - length[:-1]) / divergingRatioToSpacingTolerance - - -def getRelevantOutlets(aneurysm_type, centerline, centerline_aneurysm, dir_path): - """ - Extract relevant outlets of the - input surface model. - - Args: - aneurysm_type (bool): Type of aneurysm, saccular of terminal - centerline_aneurysm (vtkPolyData): Centerline into aneurysm - centerline (vtkPolyData): Surface model centerline. - dir_path (str): Location of info-file. - - Returns: - relevant_outlets (list): List of relevant outlet IDs. - """ - - parameters = get_parameters(dir_path) - if "relevant_outlet_0" in parameters.keys(): - return parameters["relevant_outlet_0"], parameters["relevant_outlet_1"] - - n_aneurysm = centerline_aneurysm.GetNumberOfPoints() - tol = get_tolerance(centerline) - div_anu = [] - aneurysm = centerline_aneurysm.GetCell(0) - get_point = aneurysm.GetPoints().GetPoint - - for j in range(centerline.GetNumberOfCells()): - line = centerline.GetCell(j) - get_point_line = line.GetPoints().GetPoint - for i in range(min(n_aneurysm, line.GetNumberOfPoints())): - point0 = get_point(i) - point1 = get_point_line(i) - - dist = distance(point0, point1) - if dist > tol: - div_anu.append(i) - break - - index = np.argsort(np.array(div_anu)) - line = ExtractSingleLine(centerline, index[-1]) - endpoint1 = list(line.GetPoints().GetPoint(line.GetNumberOfPoints() - 1)) - inlet = list(line.GetPoints().GetPoint(0)) - - if aneurysm_type == "terminal": - diff = True - line_id = -2 - line_div_point = line.GetPoints().GetPoint(div_anu[index[1]] + 10) - while diff: - line2 = ExtractSingleLine(centerline, index[line_id]) - line2_div_point = line2.GetPoints().GetPoint(div_anu[index[line_id]]) - if distance(line2_div_point, line_div_point) > 3 * tol: - diff = False - endpoint2 = list(line2.GetPoints().GetPoint(line2.GetNumberOfPoints() - 1)) - line_id -= 1 - else: - endpoint2 = endpoint1 - endpoint1 = inlet - - data = {} - for i, e in enumerate([endpoint1, endpoint2]): - data["relevant_outlet_%d" % i] = e - - write_parameters(data, dir_path) - - return endpoint1, endpoint2 - - -def SmoothVoronoiDiagram(voronoi, centerlines, smoothing_factor, no_smooth_cl=None): - """ - Smooth voronoi diagram based on a given smoothing factor. Each voronoi point - that has a radius less then MISR*(1-smoothingFactor) at the closest centerline point is removed. - - Args: - voronoi (vtkPolyData): Voronoi diagram to be smoothed. - centerlines (vtkPolyData): Centerline data. - smoothing_factor (float): Smoothing factor: remove points with radius below (1-smoothing_factor)*MISR - no_smooth_cl (vktPolyData): Section of centerline not to smooth along. - - Returns: - smoothedDiagram (vtkPolyData): Smoothed voronoi diagram. - """ - - numberOfPoints = voronoi.GetNumberOfPoints() - - threshold = get_array(radiusArrayName, centerlines) * (1 - smoothing_factor) - locator = get_locator(centerlines) - if no_smooth_cl is not None: - no_locator = get_locator(no_smooth_cl) - - smoothedDiagram = vtk.vtkPolyData() - points = vtk.vtkPoints() - cellArray = vtk.vtkCellArray() - radiusArrayNumpy = np.zeros(numberOfPoints) - - count = 0 - for i in range(numberOfPoints): - point = voronoi.GetPoint(i) - radius = voronoi.GetPointData().GetArray(radiusArrayName).GetTuple1(i) - id_ = locator.FindClosestPoint(point) - cl_point = centerlines.GetPoint(id_) - - if distance(point, cl_point) > 3 * threshold[id_]: - points.InsertNextPoint(point) - cellArray.InsertNextCell(1) - cellArray.InsertCellPoint(count) - radiusArrayNumpy[count] = radius - count += 1 - - elif no_smooth_cl is not None: - dist1 = distance(point, centerlines.GetPoint(id_)) - id_1 = no_locator.FindClosestPoint(point) - dist2 = distance(point, no_smooth_cl.GetPoint(id_1)) - - if dist2 < dist1: - points.InsertNextPoint(point) - cellArray.InsertNextCell(1) - cellArray.InsertCellPoint(count) - radiusArrayNumpy[count] = radius - count += 1 - else: - if radius >= threshold[id_]: - points.InsertNextPoint(point) - cellArray.InsertNextCell(1) - cellArray.InsertCellPoint(count) - radiusArrayNumpy[count] = radius - count += 1 - else: - if radius >= threshold[id_]: - points.InsertNextPoint(point) - cellArray.InsertNextCell(1) - cellArray.InsertCellPoint(count) - radiusArrayNumpy[count] = radius - count += 1 - - radiusArray = get_vtk_array(radiusArrayName, 1, count) - - for i in range(count): - radiusArray.SetTuple1(i, radiusArrayNumpy[i]) - - smoothedDiagram.SetPoints(points) - smoothedDiagram.SetVerts(cellArray) - smoothedDiagram.GetPointData().AddArray(radiusArray) - - return smoothedDiagram - - -def get_curvilinear_coordinate(line): - """ - Get curvilinear coordinates along - an input centerline. - - Args: - line (vtkPolyData): Input centerline - - Returns: - curv_coor (ndarray): Array of abscissa points. - """ - - curv_coor = np.zeros(line.GetNumberOfPoints()) - for i in range(line.GetNumberOfPoints() - 1): - pnt1 = np.asarray(line.GetPoints().GetPoint(i)) - pnt2 = np.asarray(line.GetPoints().GetPoint(i + 1)) - curv_coor[i + 1] = np.sqrt(np.sum((pnt1 - pnt2) ** 2)) + curv_coor[i] - - return curv_coor - - -def merge_data(inputs): - """ - Appends one or more polygonal dataset together into a single - polygonal dataset. - - Args: - inputs (list): List of vtkPolyData objects. - - Returns: - merged_data (vtkPolyData): Single polygonal dataset. - """ - appendFilter = vtk.vtkAppendPolyData() - for input_ in inputs: - appendFilter.AddInputData(input_) - appendFilter.Update() - - return appendFilter.GetOutput() - - -def get_array(array_name, line, k=1): - """ - Get data array from polydata object (PointData). - - Args: - array_name (str): Name of array. - line (vtkPolyData): Centerline object. - k (int): Dimension. - - Returns: - array (ndarray): Array containing data points. - """ - - array = np.zeros((line.GetNumberOfPoints(), k)) - if k == 1: - getData = line.GetPointData().GetArray(array_name).GetTuple1 - elif k == 2: - getData = line.GetPointData().GetArray(array_name).GetTuple2 - elif k == 3: - getData = line.GetPointData().GetArray(array_name).GetTuple3 - - for i in range(line.GetNumberOfPoints()): - array[i, :] = getData(i) - - return array - - -def get_array_cell(array_name, line, k=1): - """ - Get cell data array from polydata object (CellData). - - Args: - array_name (str): Name of array. - line (vtkPolyData): Centerline object. - k (int): Dimension. - - Returns: - array (ndarray): Array containing data points. - """ - array = np.zeros((line.GetNumberOfCells(), k)) - if k == 1: - getData = line.GetCellData().GetArray(array_name).GetTuple1 - elif k == 2: - getData = line.GetCellData().GetArray(array_name).GetTuple2 - elif k == 3: - getData = line.GetCellData().GetArray(array_name).GetTuple3 - elif k == 9: - getData = line.GetCellData().GetArray(array_name).GetTuple9 - - for i in range(line.GetNumberOfCells()): - array[i, :] = getData(i) - - return array - - -# TODO: Get bounds and compute polyballs based on that -# bounds = surface.GetBounds() -def create_new_surface(complete_voronoi_diagram, poly_ball_image_size=[280, 280, 280]): - """ - Envelops an input voronoi diagram into a new surface model at a - given resolution determined by the poly_ball_size. - - Args: - complete_voronoi_diagram (vtkPolyData): Voronoi diagram - poly_ball_image_size (list): List of dimensional resolution of output model - - Returns: - envelope (vtkPolyData): Enveloped surface model. - """ - - # Get the x,y, and z range of the completeVoronoiDiagram - modeller = vtkvmtk.vtkvmtkPolyBallModeller() - if version < 6: - modeller.SetInput(complete_voronoi_diagram) - else: - modeller.SetInputData(complete_voronoi_diagram) - modeller.SetRadiusArrayName(radiusArrayName) - modeller.UsePolyBallLineOff() - modeller.SetSampleDimensions(poly_ball_image_size) - modeller.Update() - - # Write the new surface - marchingCube = vtk.vtkMarchingCubes() - if version < 6: - marchingCube.SetInput(modeller.GetOutput()) - else: - marchingCube.SetInputData(modeller.GetOutput()) - marchingCube.SetValue(0, 0.0) - marchingCube.Update() - envelope = marchingCube.GetOutput() - - return envelope - - -def get_aneurysm_dome(surface, dir_path): - # Check if info exists - if not path.isfile(path.join(dir_path, dir_path + ".txt")): - provide_aneurysm_points(surface, dir_path) - - # Open info - parameters = get_parameters(dir_path) - dome = [] - for key, value in parameters.items(): - if key.startswith("aneurysm_"): - dome.append(value) - - if dome == []: - dome = provide_aneurysm_points(surface, dir_path) - - # Flatten list - return [item for sublist in dome for item in sublist] - - -def centerline_div(centerline1, centerline2, tol): - # Find clipping points - N = min(centerline1.GetNumberOfPoints(), centerline2.GetNumberOfPoints()) - get_point1 = centerline1.GetPoints().GetPoint - get_point2 = centerline2.GetPoints().GetPoint - - for i in range(0, N): - distance_between_points = distance(get_point1(i), get_point2(i)) - if distance_between_points > tol: - break - - return i - - -def provide_aneurysm_points(surface, dir_path=None): - """ - Get relevant aneurysm points from user selected points on a input surface. - - Args: - surface (vtkPolyData): Surface model. - dir_path (str): Location of info.json file - - Returns: - points (list): List of relevant outlet IDs - """ - # Fix surface - cleaned_surface = surface_cleaner(surface) - triangulated_surface = triangulate_surface(cleaned_surface) - - # Select seeds - SeedSelector = vmtkPickPointSeedSelector() - SeedSelector.SetSurface(triangulated_surface) - SeedSelector.Execute() - - aneurysmSeedIds = SeedSelector.GetTargetSeedIds() - get_point = surface.GetPoints().GetPoint - points = [list(get_point(aneurysmSeedIds.GetId(i))) for i in range(aneurysmSeedIds.GetNumberOfIds())] - - if dir_path is not None: - info = {"number_of_aneurysms": len(points)} - - for i in range(len(points)): - info["aneurysm_%d" % i] = points[i] - write_parameters(info, dir_path) - - return points - - -def getData(centerline_par, centerline_dau1, centerline_dau2, tol, aneurysm_type): - """ - Get info about bifurcating points and diverging points within a bifurcation. - End points are set based on the MISR at the selected points. - - Args: - aneurysm_type (str): Type of aneurysm, saccular or terminal - centerline_dau1 (vtkPolyData): Centerline from inlet to relevant outlet 1. - centerline_dau2 (vtkPolyData): Centerline from inlet to relevant outlet 2. - centerline_par(vtkPolyData): Centerline through bifurcation. - tol (float): Tolerance parameter. - - Returns: - data (dict): Contains info about diverging point locations. - """ - # Declare variables before loop if values are not found - data = {"dau1": {}, "dau2": {}} - - # List of points conected to ID - points_ids_0 = vtk.vtkIdList() - points_ids_1 = vtk.vtkIdList() - - data_list = [("dau1", centerline_dau1), ("dau2", centerline_dau2)] - - # Additional point for terminal - if aneurysm_type == "terminal": - data_list += [("par", centerline_par)] - data["par"] = {} - - for key, centerline in data_list: - if centerline is None: continue - # One is the branch to the left and the other is the one to the right - centerline.GetCellPoints(0, points_ids_0) - centerline.GetCellPoints(1, points_ids_1) - - # Find clipping points - N = min(points_ids_0.GetNumberOfIds(), points_ids_1.GetNumberOfIds()) - for i in range(0, N): - cell_point_0 = centerline.GetPoint(points_ids_0.GetId(i)) - cell_point_1 = centerline.GetPoint(points_ids_1.GetId(i)) - - distance_between_points = distance(cell_point_0, cell_point_1) - if distance_between_points > tol: - tmpI = i - point_ID_0 = points_ids_0.GetId(i) - point_ID_1 = points_ids_1.GetId(i) - center = centerline.GetPoint(point_ID_0) - r = centerline.GetPointData().GetArray(radiusArrayName).GetTuple1(point_ID_0) - break - - end, r_end = move_past_sphere(centerline, center, r, point_ID_0, - stop=point_ID_0 * 100, step=1, scale_factor=1) - - data[key]["end_point"] = end - data[key]["r_end"] = r_end - data[key]["div_point"] = center - data[key]["ID_div"] = point_ID_0 - data[key]["i_div"] = tmpI - data[key]["r_div"] = r - - return data - - -def write_points(points, filename): - """ - Writes input points to file. - - Args: - points (vtkPolyData): Point data. - filename (str): Save location. - """ - pointSet = vtk.vtkPolyData() - cellArray = vtk.vtkCellArray() - - for i in range(points.GetNumberOfPoints()): - cellArray.InsertNextCell(1) - cellArray.InsertCellPoint(i) - - pointSet.SetPoints(points) - pointSet.SetVerts(cellArray) - - WritePolyData(pointSet, filename) - - -def surface_cleaner(surface): - """ - Clean surface by merging duplicate points, and/or - removing unused points and/or removing degenerate cells. - - Args: - surface (vtkPolyData): Surface model. - - Returns: - cleanedSurface (vtkPolyData): Cleaned surface model. - """ - - surfaceCleaner = vtk.vtkCleanPolyData() - if version < 6: - surfaceCleaner.SetInput(surface) - else: - surfaceCleaner.SetInputData(surface) - surfaceCleaner.Update() - - return surfaceCleaner.GetOutput() - - -def get_centers(surface, atrium_present, dir_path, flowext=False): - """ - Get the centers of the inlet and outlets. - - Args: - surface (vtkPolyData): An open surface. - dir_path (str): Path to the case file. - flowext (bool): Turn on/off flow extension. - - Returns: - inlet (list): A flatt list with the point of the inlet - outlet (list): A flatt list with the points of all the outlets. - """ - - # Check if info exists - if flowext or not path.isfile(path.join(dir_path, dir_path + ".json")): - compute_centers(surface, atrium_present, dir_path) - - # Open info - parameters = get_parameters(dir_path) - outlets = [] - inlet = [] - for key, value in parameters.items(): - - if(atrium_present==False): - if key == "inlet": - inlet = value - elif "outlet" in key and "area" not in key and "relevant" not in key: - outlets += value - else: - # FIXIT: 1 outlet and several inlets. Setting names should be corrected - if key == "outlet": - outlets = value - elif "inlet" in key and "area" not in key and "relevant" not in key: - inlet += value - - num_outlets = len(outlets) // 3 - num_inlets = len(inlet) // 3 - - if num_outlets != 0: - if(atrium_present==False): - outlets = [] - for i in range(num_outlets): - outlets += parameters["outlet%d" % i] - else: - # FIXIT: several inlets - inlet = [] - for i in range(num_inlets): - inlet += parameters["inlet%d" % i] - - # FIXIT: atrium case has several inlets (instead of inlet) and only one outlet (instead of outlets). - if inlet == [] and outlets == []: - inlet, outlets = compute_centers(surface, atrium_present, dir_path) - - print("The number of outlets =", len(outlets) // 3) - print("The number of inlets =", len(inlet) // 3) - print() - - return inlet, outlets - - -def triangulate_surface(surface): - """ - Wrapper for vtkTriangleFilter. - - Args: - surface (vtkPolyData): Surface to triangulate. - Returns: - surface (vtkPolyData): Triangulated surface. - """ - - surfaceTriangulator = vtk.vtkTriangleFilter() - if version < 6: - surfaceTriangulator.SetInput(surface) - else: - surfaceTriangulator.SetInputData(surface) - surfaceTriangulator.PassLinesOff() - surfaceTriangulator.PassVertsOff() - surfaceTriangulator.Update() - - return surfaceTriangulator.GetOutput() - - -def geometryFilter(unstructured_grid): - # Convert unstructured grid to polydata - filter = vtk.vtkGeometryFilter() - if version < 6: - filter.SetInput(unstructured_grid) - else: - filter.SetInputData(unstructured_grid) - filter.Update() - polydata = filter.GetOutput() - - return polydata - - -def threshold(surface, name, lower=0, upper=1, type="between", source=1): - """ - Wrapper for vtkThreshold. Extract a section of a surface given a criteria. - - Args: - surface (vtkPolyData): The input data to be extracted. - name (str): Name of scalar array. - lower (float): Lower bound. - upper (float): Upper bound. - type (str): Type of threshold (lower, upper, between) - source (int): PointData or CellData. - - Returns: - surface (vtkPolyData): The extracted surface based on the lower and upper limit. - """ - - # source = 1 uses cell data as input - # source = 0 uses point data as input - - # Apply threshold - threshold = vtk.vtkThreshold() - if version < 6: - threshold.SetInput(surface) - else: - threshold.SetInputData(surface) - if type == "between": - threshold.ThresholdBetween(lower, upper) - elif type == "lower": - threshold.ThresholdByLower(lower) - elif type == "upper": - threshold.ThresholdByUpper(upper) - else: - print(("%s is not a threshold type. Pleace chose from: upper, lower" + \ - ", or between") % type) - sys.exit(0) - - threshold.SetInputArrayToProcess(0, 0, 0, source, name) - threshold.Update() - surface = threshold.GetOutput() - - # Convert to polydata - surface = geometryFilter(surface) - - return surface - - -def compute_area(surface): - """ - Calculate the area from the given polydata - - Args: - surface (vtkPolyData): Surface to compute are off - - Returns: - area (float): Area of the input surface - """ - mass = vtk.vtkMassProperties() - if version < 6: - mass.SetInput(surface) - else: - mass.SetInputData(surface) - - return mass.GetSurfaceArea() - - -def capp_surface(surface): - """ - Wrapper for vmtkCapPolyData. - Close holes in a surface model. - - Args: - surface (vtkPolyData): Surface to be capped. - - Returns: - surface (vtkPolyData): Capped surface. - """ - - surfaceCapper = vtkvmtk.vtkvmtkCapPolyData() - if version < 6: - surfaceCapper.SetInput(surface) - else: - surfaceCapper.SetInputData(surface) - surfaceCapper.SetDisplacement(0.0) - surfaceCapper.SetInPlaneDisplacement(0.0) - surfaceCapper.Update() - - return surfaceCapper.GetOutput() - - -def compute_distance_to_sphere(surface, centerSphere, radiusSphere=0.0, - distanceOffset=0.0, distanceScale=0.01, - minDistance=0.2, maxDistance=0.3, - distanceToSpheresArrayName="DistanceToSpheres"): - # Check if there allready exists a distance to spheres - N = surface.GetNumberOfPoints() - number, names = get_number_of_arrays(surface) - add = False - if distanceToSpheresArrayName not in names: add = True - - # Get array - if add: - dist_array = get_vtk_array(distanceToSpheresArrayName, 1, N) - surface.GetPointData().AddArray(dist_array) - else: - dist_array = surface.GetPointData().GetArray("DistanceToSpheres") - - # Compute distance - for i in range(N): - distanceToSphere = dist_array.GetComponent(i, 0) - - # Get distance, but factor in size of sphere - newDist = distance(centerSphere, surface.GetPoints().GetPoint(i)) - radiusSphere - - # Set offset and scale distance - newDist = distanceOffset + newDist * distanceScale - - # Capp to min distance - if newDist < minDistance: - newDist = minDistance - - # Capp to max distance - if newDist > maxDistance: - newDist = maxDistance - - # Keep smallest distance - newDist = min(newDist, distanceToSphere) if not add else newDist - - dist_array.SetComponent(i, 0, newDist) - - return surface - - -def is_surface_capped(surface, atrium_present): - """ - Checks if the surface is closed, and how many openings there are. - - Args: - surface (vtkPolyData): Surface to be checked - - Returns: - open (boolean): Open or closed surface - number (int): Number of integer - """ - - return compute_centers(surface, atrium_present, test_capped=True)[0] - - -def getConnectivity(surface): - """ - Wrapper of vtkPolyDataConnectivityFilter. Compute connectivity. - - Args: - surface (vtkPolyData): Input surface data. - """ - - connectivity = vtk.vtkPolyDataConnectivityFilter() - # Backwards compatibility - if version < 6: - connectivity.SetInput(surface) - else: - connectivity.SetInputData(surface) - - # Mark each region with "RegionId" - connectivity.SetExtractionModeToAllRegions() - connectivity.ColorRegionsOn() - connectivity.Update() - output = connectivity.GetOutput() - - return output - - -def computeCircleness(surface): - """ - Compute the area ratio between minimum circle and the maximum circle. - - Args: - surface (vtkPolyData): Boundary edges of an opening - - Returns: - circleness (float): Area ratio - center (list): Center of the opening. - """ - - edges = getFeatureEdges(surface) - - # Get points - points = [] - for i in range(edges.GetNumberOfPoints()): - points.append(edges.GetPoint(i)) - - # Compute center - points = np.array(points) - center = np.mean(np.array(points), axis=0) - - # Compute ratio between max inscribed sphere, and min inscribed "area" - point_radius = np.sqrt(np.sum((points - center) ** 2, axis=1)) - argsort = np.argsort(point_radius) - if point_radius[argsort[1]] / point_radius[argsort[0]] > 15: - radius_min = point_radius[argsort[1]] - else: - radius_min = point_radius.min() - - min_area = math.pi * radius_min ** 2 - max_area = math.pi * point_radius.max() ** 2 - - return max_area / min_area, center - - -def getFeatureEdges(polyData): - """ - Wrapper for vtkFeatureedges. Extracts the edges of the cells that are open. - - Args: - polydata (vtkPolyData): surface to extract the openings from. - - Returns: - feature_edges (vtkPolyData): The boundary edges of the surface. - """ - - featureEdges = vtk.vtkFeatureEdges() - featureEdges.FeatureEdgesOff() - featureEdges.BoundaryEdgesOn() - featureEdges.NonManifoldEdgesOn() - if version < 6: - featureEdges.SetInput(polyData) - else: - featureEdges.SetInputData(polyData) - featureEdges.Update() - - return featureEdges.GetOutput() - - -def compute_centers(polyData, atrium_present, case_path=None, test_capped=False): - """ - Compute the center of all the openings in the surface. The inlet is chosen based on - the largest area for arteries (or aneurysm). However, for atrium, the outlet is chosen based on - the largest area (new). - - Args: - test_capped (bool): Check if surface is capped. - polyData (vtkPolyData): centers of the openings. - case_path (str): path to case directory. - atrium_present (bool): Check if it is an atrium model. - - Returns: - inlet_center (list): Inlet center. - outlet_centers (list): A flattened list with all the outlet centers. - """ - # Get cells which are open - cells = getFeatureEdges(polyData) - - if cells.GetNumberOfCells() == 0 and not test_capped: - print("WARNING: The model is capped, so it is uncapped, but the method is experimental.") - uncapped_surface = uncapp_surface(polyData) - compute_centers(uncapped_surface, atrium_present, case_path, test_capped) - elif cells.GetNumberOfCells() == 0 and test_capped: - return False, 0 - - # Compute connectivity of the cells - outputs = getConnectivity(cells) - - # Get connectivity array - region_array = get_array("RegionId", outputs) - - if test_capped: - return region_array.max() >= 1, region_array.max() - - # Get points - points = [] - get_point = outputs.GetPoints().GetPoint - for i in range(region_array.shape[0]): - points.append(get_point(i)) - points = np.asarray(points) - - # Get area and center - area = [] - center = [] - for i in range(int(region_array.max()) + 1): - # Compute area - boundary = threshold(outputs, "RegionId", lower=i - 0.1, upper=i + 0.1, - type="between", source=0) - - delaunay_filter = vtk.vtkDelaunay2D() - delaunay_filter.SetInputData(boundary) - delaunay_filter.Update() - area.append(compute_area(delaunay_filter.GetOutput())) - - # Get center - center.append(np.mean(points[(region_array == i).nonzero()[0]], axis=0)) - - if(atrium_present==True): - # Store the center and area - outlet_ind = area.index(max(area)) - if case_path is not None: - info = {"outlet": center[outlet_ind].tolist(), "outlet_area": area[outlet_ind]} - p = 0 - for i in range(len(area)): - if i == outlet_ind: p = -1; continue - info["inlet%d" % (i + p)] = center[i].tolist() - info["inlet%s_area" % (i + p)] = area[i] - - write_parameters(info, case_path) - - outlet_center = center[outlet_ind].tolist() # center of the outlet - center.pop(outlet_ind) - - center_ = [item for sublist in center for item in sublist] # centers of the inlets - - return center_, outlet_center - else: - # Store the center and area - inlet_ind = area.index(max(area)) - if case_path is not None: - info = {"inlet": center[inlet_ind].tolist(), "inlet_area": area[inlet_ind]} - p = 0 - for i in range(len(area)): - if i == inlet_ind: p = -1; continue - info["outlet%d" % (i + p)] = center[i].tolist() - info["outlet%s_area" % (i + p)] = area[i] - - write_parameters(info, case_path) - - inlet_center = center[inlet_ind].tolist() - center.pop(inlet_ind) - - center_ = [item for sublist in center for item in sublist] - - return inlet_center, center_ - - -def compute_bary_center(points): - # Get i+1 - shifted = np.zeros(points.shape) - shifted[1:, :] = points[:-1, :] - shifted[0, :] = points[-1, :] - - # Compute weights - weight = np.sqrt(np.sum((points - shifted) ** 2, axis=1)) - weight_sum = np.sum(weight) - - # Compute center - center_x = np.sum((points[:, 0] + shifted[:, 0]) / 2 * weight) / weight_sum - center_y = np.sum((points[:, 1] + shifted[:, 1]) / 2 * weight) / weight_sum - center_z = np.sum((points[:, 2] + shifted[:, 2]) / 2 * weight) / weight_sum - - return [center_x, center_y, center_z] - - -def get_vtk_array(name, comp, num): - """An empty vtkDoubleArray. - - Args: - name (str): Name of array. - comp (int): Number of components - num (int): Number of tuples. - - Returns: - array (vtkDoubleArray): An empty vtk array. - """ - array = vtk.vtkDoubleArray() - array.SetNumberOfComponents(comp) - array.SetNumberOfTuples(num) - for i in range(comp): - array.FillComponent(i, 0.0) - array.SetName(name) - - return array - - -def get_locator_cell(surface): - """Wrapper for vtkCellLocator - - Args: - surface (vtkPolyData): input surface - - Returns: - return (vtkCellLocator): Cell locator of the input surface. - """ - locator = vtk.vtkCellLocator() - locator.SetDataSet(surface) - locator.BuildLocator() - - return locator - - -def get_locator(centerline): - """Wrapper for vtkStaticPointLocator. - - Args: - centerline (vtkPolyData): Input vtkPolyData. - - Returns: - locator (vtkStaticPointLocator): Point locator of the input surface. - """ - locator = vtk.vtkStaticPointLocator() - locator.SetDataSet(centerline) - locator.BuildLocator() - - return locator - - -def distance(point1, point2): - """Distance between two points. - - Args: - point1 (ndarray): A point - point2 (ndarray): A point - - Returns: - distance (float): Distance between point1 and point2 - """ - - return np.sqrt(np.sum((np.asarray(point1) - np.asarray(point2)) ** 2)) - - -def remove_distant_points(voronoi, centerline): - """Take a voronoi diagram and a centerline remove points that are far away. - - Args: - voronoi (vtkPolyData): Voronoi data. - centerline (vtkPolyData): centerline. - - Returns: - voronoi (vtkPolyData): Voronoi diagram without the extreme points - """ - - N = voronoi.GetNumberOfPoints() - newVoronoi = vtk.vtkPolyData() - cellArray = vtk.vtkCellArray() - points = vtk.vtkPoints() - radius = np.zeros(N) - - locator = get_locator(centerline) - get_data = voronoi.GetPointData().GetArray(radiusArrayName).GetTuple1 - limit = get_data(0) - limit = limit * 10 - - count = 0 - for i in range(N): - point = voronoi.GetPoint(i) - ID = locator.FindClosestPoint(point) - cl_point = centerline.GetPoint(ID) - dist = distance(point, cl_point) - if dist / 3 > get_data(i) or get_data(i) > limit: - count += 1 - continue - - points.InsertNextPoint(point) - cellArray.InsertNextCell(1) - cellArray.InsertCellPoint(i - count) - value = get_data(i) - radius[i - count] = value - - print("Removed %s points from the voronoi diagram" % count) - - radiusArray = get_vtk_array(radiusArrayName, 1, N - count) - for i in range(N - count): - radiusArray.SetTuple(i, [float(radius[i])]) - - newVoronoi.SetPoints(points) - newVoronoi.SetVerts(cellArray) - newVoronoi.GetPointData().AddArray(radiusArray) +# Shortcuts +version = vtk.vtkVersion().GetVTKMajorVersion() - return newVoronoi +def get_aneurysm_dome(surface, dir_path): + # Check if info exists + if not path.isfile(path.join(dir_path, dir_path + ".txt")): + provide_aneurysm_points(surface, dir_path) -def success(text): - if not "error: " in text.lower(): - return True, "" - else: - error_message = re.search(r'error: (.*)', text.lower()).groups()[0] - return False, error_message + # Open info + parameters = get_parameters(dir_path) + dome = [] + for key, value in parameters.items(): + if key.startswith("aneurysm_"): + dome.append(value) + if dome == []: + dome = provide_aneurysm_points(surface, dir_path) -def compute_centerline_sections(surface, centerline): - """ - Wrapper for vmtk centerline sections. + # Flatten list + return [item for sublist in dome for item in sublist] - Args: - surface (vtkPolyData): Surface to measure area. - centerline (vtkPolyData): centerline to measure along. - Returns: - line (vtkPolyData): centerline with the attributes - centerline_sections_area (vtkPolyData): sections along the centerline +def provide_aneurysm_points(surface, dir_path=None): """ - centerlineSections = vtkvmtk.vtkvmtkPolyDataCenterlineSections() - centerlineSections.SetInputData(surface) - centerlineSections.SetCenterlines(centerline) - centerlineSections.SetCenterlineSectionAreaArrayName('CenterlineSectionArea') - centerlineSections.SetCenterlineSectionMinSizeArrayName('CenterlineSectionMinSize') - centerlineSections.SetCenterlineSectionMaxSizeArrayName('CenterlineSectionMaxSize') - centerlineSections.SetCenterlineSectionShapeArrayName('CenterlineSectionShape') - centerlineSections.SetCenterlineSectionClosedArrayName('CenterlineSectionClosed') - centerlineSections.Update() - - CenterlineSections = centerlineSections.GetOutput() - line = centerlineSections.GetCenterlines() - - return line, CenterlineSections - - -def compute_centerlines(inlet, outlet, atrium_present, filepath, surface, resampling=1, smooth=False, num_iter=100, smooth_factor=0.1, - end_point=1, method="pointlist"): - """Wrapper for vmtkcenterlines and vmtkcenterlinesmoothing. + Get relevant aneurysm points from user selected points on a input surface. Args: - inlet (list): point of the inlet - outlet (list): flatt list of the outlet points - filepath (str): path to where to store the centerline - surface (vtkPolyData): surface to get the centerline from. - resampling (float): resampling step length. - smooth (bool): smooth centerline or not. - num_iter (int): number of iterations in smooth. - smooth_factor (float): smoothing factor. - end_point (int): 0 or 1, include end point in centerline. - method (str): method for setting the inlet and outlet location + surface (vtkPolyData): Surface model. + dir_path (str): Location of info.json file Returns: - centerline (vtkPolyData): centerline of the surface. + points (list): List of relevant outlet IDs """ + # Fix surface + cleaned_surface = vtk_clean_polydata(surface) + triangulated_surface = vtk_triangulate_surface(cleaned_surface) - if path.isfile(filepath): - return ReadPolyData(filepath) - - centerlines = vmtkscripts.vmtkCenterlines() - centerlines.Surface = surface - centerlines.SeedSelectorName = 'pointlist' - centerlines.AppendEndPoints = end_point - centerlines.Resampling = 1 - centerlines.ResamplingStepLength = resampling - - if(atrium_present==False): - centerlines.SourcePoints = inlet - centerlines.TargetPoints = outlet - else: - centerlines.SourcePoints = outlet - centerlines.TargetPoints = inlet - - centerlines.Execute() - centerlines = centerlines.Centerlines + # Select seeds + SeedSelector = vmtkPickPointSeedSelector() + SeedSelector.SetSurface(triangulated_surface) + SeedSelector.Execute() - if smooth: - centerlineSmoothing = vmtkscripts.vmtkCenterlineSmoothing() - centerlineSmoothing.SetInputData(centerlines) - centerlineSmoothing.SetNumberOfSmoothingIterations(num_iter) - centerlineSmoothing.SetSmoothingFactor(smooth_factor) - centerlineSmoothing.Update() + aneurysmSeedIds = SeedSelector.GetTargetSeedIds() + get_point = surface.GetPoints().GetPoint + points = [list(get_point(aneurysmSeedIds.GetId(i))) for i in range(aneurysmSeedIds.GetNumberOfIds())] - centerlines = centerlineSmoothing.GetOutput() + if dir_path is not None: + info = {"number_of_aneurysms": len(points)} - # Save the computed centerline. - if filepath is not None: - WritePolyData(centerlines, filepath) + for i in range(len(points)): + info["aneurysm_%d" % i] = points[i] + write_parameters(info, dir_path) - return centerlines + return points -def CenterlineAttribiutes(line, smooth=False, iterations=300, factor=0.1): +def make_voronoi_diagram(surface, file_path): """ - Wrapper for centerline attributes. + Compute the voronoi diagram of surface model. Args: - line (vtkPolyData): Line to investigate. - smooth (bool): Turn on and off smoothing before computing the attributes features. - iterations (int): Number of iterations. - factor (float): Smoothing factor. + surface (polydata): Capped surface model to create a Voronoi diagram of. + file_path (str): Absolute path to surface model path. Returns: - line (vtkPolyData): Line with centerline attributes. + voronoi (vtkPolyData): Voronoi diagram of surface. """ - attributes = vmtkscripts.vmtkCenterlineAttributes() - attributes.Centerlines = line - attributes.NormalsArrayName = parallelTransportNormalsArrayName - attributes.AbscissaArrayName = abscissasArrayName - attributes.Execute() - centerline = attributes.Centerlines - - geometry = vmtkscripts.vmtkCenterlineGeometry() - geometry.Centerlines = centerline - - if smooth: - geometry.LineSmoothing = 1 - geometry.OutputSmoothedLines = smooth - geometry.SmoothingFactor = factor - geometry.NumberOfSmoothingIterations = iterations - geometry.FernetTangentArrayName = "FernetTangent" - geometry.FernetNormalArrayName = "FernetNormal" - geometry.FrenetBinormalArrayName = "FernetBiNormal" - geometry.CurvatureArrayName = "Curvature" - geometry.TorsionArrayName = "Torsion" - geometry.TortuosityArrayName = "Tortuosity" - geometry.Execute() - - return geometry.Centerlines - - -def generate_mesh(surface): - # Compute the mesh. - meshGenerator = vmtkscripts.vmtkMeshGenerator() - meshGenerator.Surface = surface - meshGenerator.ElementSizeMode = "edgelengtharray" # Variable size mesh - meshGenerator.TargetEdgeLengthArrayName = "Size" # Variable size mesh - #meshGenerator.ElementSizeMode = "edgelength" # Constant size mesh - #meshGenerator.TargetEdgeLength = 1.0 # Constant size mesh - meshGenerator.BoundaryLayer = 1 - meshGenerator.NumberOfSubLayers = 4 - meshGenerator.BoundaryLayerOnCaps = 0 # it should 1 - meshGenerator.BoundaryLayerThicknessFactor = 0.7 #0.85 - meshGenerator.SubLayerRatio = 0.55 #0.75 - meshGenerator.Tetrahedralize = 1 - meshGenerator.VolumeElementScaleFactor = 0.8 - meshGenerator.EndcapsEdgeLengthFactor = 1.0 - - # Mesh - meshGenerator.Execute() - - # Remeshed surface, store for later - remeshSurface = meshGenerator.RemeshedSurface - - # Full mesh - mesh = meshGenerator.Mesh + if path.isfile(file_path): + return read_polydata(file_path) - return mesh, remeshSurface + voronoi = vmtkscripts.vmtkDelaunayVoronoi() + voronoi.Surface = surface + voronoi.RemoveSubresolutionTetrahedra = 0 + voronoi.Execute() + write_polydata(voronoi.VoronoiDiagram, file_path) -def create_vtk_array(values, name, k=1): - """ - Given a set of numpy values, and a name of the array create vtk array + return voronoi.VoronoiDiagram - Args: - values (list, ndarray): List of the values. - name (str): Name of the array. - k (int): Length of tuple. - Returns: - vtk_array (vtkPointArray): vtk point array +def compute_centers_for_meshing(polyData, atrium_present, case_path=None, test_capped=False): """ - vtkArray = get_vtk_array(name, k, values.shape[0]) - - if k == 1: - for i in range(values.shape[0]): - vtkArray.SetTuple1(i, values[i]) - elif k == 2: - for i in range(values.shape[0]): - vtkArray.SetTuple2(i, values[i, 0], values[i, 1]) - elif k == 3: - for i in range(values.shape[0]): - vtkArray.SetTuple3(i, values[i, 0], values[i, 1], values[i, 2]) - elif k == 9: - for i in range(values.shape[0]): - vtkArray.SetTuple9(i, values[i, 0], values[i, 1], values[i, 2], - values[i, 3], values[i, 4], values[i, 5], - values[i, 6], values[i, 7], values[i, 8]) - - return vtkArray - - -def GramSchmidt(V): - """ - Gram schmidt process of each column + Compute the center of all the openings in the surface. The inlet is chosen based on + the largest area for arteries (or aneurysm). However, for atrium, the outlet is chosen based on + the largest area (new). Args: - V (numpy.array): A (n x n) matrix + test_capped (bool): Check if surface is capped. + polyData (vtkPolyData): centers of the openings. + case_path (str): path to case directory. + atrium_present (bool): Check if it is an atrium model. Returns: - E (numpy.array): A (n x n) matrix where all the columns are orthogonal + inlet_center (list): Inlet center. + outlet_centers (list): A flattened list with all the outlet centers. """ - V = 1.0 * V - U = np.copy(V) - - def proj(u, v): - return u * np.dot(v, u) / np.dot(u, u) - - for i in range(1, V.shape[1]): - for j in range(i): - U[:, i] -= proj(U[:, j], V[:, i]) + # Get cells which are open + cells = vtk_extract_feature_edges(polyData) - # normalize column - den = (U ** 2).sum(axis=0) ** 0.5 - E = U / den - return E + if cells.GetNumberOfCells() == 0 and not test_capped: + print("WARNING: The model is capped, so it is uncapped, but the method is experimental.") + uncapped_surface = get_uncapped_surface(polyData) + compute_centers_for_meshing(uncapped_surface, atrium_present, case_path, test_capped) + elif cells.GetNumberOfCells() == 0 and test_capped: + return False, 0 + # Compute connectivity of the cells + outputs = vtk_compute_connectivity(cells) -def get_parameters(dir_path): - """ - Read the parameters in the info file. + # Get connectivity array + region_array = get_point_data_array("RegionId", outputs) - Args: - dir_path (str): Path to folder. + if test_capped: + return region_array.max() >= 1, region_array.max() - Returns: - data (dict): The data in the info file. - """ - # If info.json file, return an empty dict - if not path.isfile(dir_path + ".json"): - return {} + # Get points + points = [] + get_point = outputs.GetPoints().GetPoint + for i in range(region_array.shape[0]): + points.append(get_point(i)) + points = np.asarray(points) - # Get text - info_path = dir_path + ".json" - with open(info_path) as info: - data = json.load(info) + # Get area and center + area = [] + center = [] + for i in range(int(region_array.max()) + 1): + # Compute area + boundary = vtk_compute_threshold(outputs, "RegionId", lower=i - 0.1, upper=i + 0.1, threshold_type="between", + source=0) - return data + delaunay_filter = vtk.vtkDelaunay2D() + delaunay_filter.SetInputData(boundary) + delaunay_filter.Update() + area.append(vtk_compute_mass_properties(delaunay_filter.GetOutput())) + # Get center + center.append(np.mean(points[(region_array == i).nonzero()[0]], axis=0)) -def write_parameters(data, dir_path): - """ - Get the old parameters, then write the new parameters in data. + # Assume multiple inlets for atrium, and multiple outlets for arteries + if atrium_present: + # Store the center and area + boundary_name = "outlet" + boundaries_name = "inlet%d" + else: + boundary_name = "inlet" + boundaries_name = "outlet%d" - Args: - data (dict): New data to write to parameters - dir_path (str): Path to data location. - """ - # Get old parameters - parameters = get_parameters(dir_path) + boundary_area_name = boundary_name + "_area" + boundaries_area_name = boundaries_name + "_area" + boundary_id = area.index(max(area)) + if case_path is not None: + info = {boundary_name: center[boundary_id].tolist(), boundary_area_name: area[boundary_id]} + p = 0 + for i in range(len(area)): + if i == boundary_id: + p = -1 + continue + info[boundaries_name % (i + p)] = center[i].tolist() + info[boundaries_area_name % (i + p)] = area[i] - # Update with new parameters - parameters.update(data) + write_parameters(info, case_path) - # Save to json file - with open(dir_path + ".json", "w") as f: - json.dump(parameters, f) + boundary_center = center[boundary_id].tolist() # center of the outlet + center.pop(boundary_id) + center_ = [item for sublist in center for item in sublist] # centers of the inlets -def data_to_vtkPolyData(data, header, TNB=None, PT=None): - """Converting a range of data to a vtk array. + return center_, boundary_center - Args: - data (numpy.ndarray): Data array. - header (list): A list of names for each array. - TNB (numpy.ndarray): Data array. - PT (numpy.ndarray): Data array. - Returns: - line (vtkPolyData): Line couple with all the new data. +def get_centers_for_meshing(surface, atrium_present, dir_path, flowext=False): """ - line = vtk.vtkPolyData() - cellArray = vtk.vtkCellArray() - cellArray.InsertNextCell(data.shape[0]) - linePoints = vtk.vtkPoints() - - info_array = [] - for i in range(3, data.shape[1]): - radiusArray = get_vtk_array(header[i], 1, data.shape[0]) - info_array.append(radiusArray) - - if TNB is not None: - for i in range(3): - radiusArray = get_vtk_array(header[i + data.shape[1]], 3, data.shape[0]) - info_array.append(radiusArray) - - if PT is not None: - start = data.shape[1] if TNB is None else data.shape[1] + 3 - for i in range(2): - radiusArray = get_vtk_array(header[i + start], 3, PT[0].shape[0]) - info_array.append(radiusArray) - - for i in range(data.shape[0]): - cellArray.InsertCellPoint(i) - linePoints.InsertNextPoint(data[i, :3]) - for j in range(3, data.shape[1]): - info_array[j - 3].SetTuple1(i, data[i, j]) - - if TNB is not None: - for i in range(data.shape[0]): - for j in range(data.shape[1] - 3, data.shape[1], 1): - tnb_ = TNB[j - data.shape[1]][i, :] - info_array[j].SetTuple3(i, tnb_[0], tnb_[1], tnb_[2]) - - if PT is not None: - start = data.shape[1] - 3 if TNB is None else data.shape[1] - for i in range(PT[-1].shape[0]): - for j in range(start, start + 2, 1): - pt_ = PT[j - start][i, :] - info_array[j].SetTuple3(i, pt_[0], pt_[1], pt_[2]) - - line.SetPoints(linePoints) - line.SetLines(cellArray) - for i in range(len(header) - 3): - line.GetPointData().AddArray(info_array[i]) - - return line - - -def get_number_of_arrays(line): - """Returns the names and number of arrays for a centerline + Get the centers of the inlet and outlets. Args: - line (vtkPolyData): Line to investigate + surface (vtkPolyData): An open surface. + dir_path (str): Path to the case file. + flowext (bool): Turn on/off flow extension. Returns: - count (int): Number of arrays in the line. - names (list): A list of names of the arrays. + inlet (list): A flatt list with the point of the inlet + outlet (list): A flatt list with the points of all the outlets. """ - count = 0 - names = [] - name = 0 - while name is not None: - name = line.GetPointData().GetArrayName(count) - if name is not None: - names.append(name) - count += 1 - - return count, names - - -def ExtractSingleLine(centerlines, line_id, start_id=0, end_id=None): - """Extract one line from multiple centerlines. - If start_id and end_id is set then only a segment of the centerline is extracted. - Args: - centerlines (vtkPolyData): Centerline to extract. - line_id (int): The line ID to extract. - start_id (int): Point ID to start at - end_id (int): Point ID to stop at - - Returns: - centerline (vtkPolyData): The single line extracted - """ - cell = vtk.vtkGenericCell() - centerlines.GetCell(line_id, cell) - N = cell.GetNumberOfPoints() if end_id is None else end_id + 1 - - line = vtk.vtkPolyData() - cellArray = vtk.vtkCellArray() - cellArray.InsertNextCell(N - start_id) - linePoints = vtk.vtkPoints() - - arrays = [] - N_, names = get_number_of_arrays(centerlines) - for i in range(N_): - tmp = centerlines.GetPointData().GetArray(names[i]) - tmp_comp = tmp.GetNumberOfComponents() - radiusArray = get_vtk_array(names[i], tmp_comp, N - start_id) - arrays.append(radiusArray) - - getArray = [] - for i in range(N_): - getArray.append(centerlines.GetPointData().GetArray(names[i])) - - count = 0 - for i in range(start_id, N): - cellArray.InsertCellPoint(count) - linePoints.InsertNextPoint(cell.GetPoints().GetPoint(i)) - - for j in range(N_): - num = getArray[j].GetNumberOfComponents() - if num == 1: - tmp = getArray[j].GetTuple1(i) - arrays[j].SetTuple1(count, tmp) - elif num == 2: - tmp = getArray[j].GetTuple2(i) - arrays[j].SetTuple2(count, tmp[0], tmp[1]) - elif num == 3: - tmp = getArray[j].GetTuple3(i) - arrays[j].SetTuple3(count, tmp[0], tmp[1], tmp[2]) - elif num == 9: - tmp = getArray[j].GetTuple9(i) - arrays[j].SetTuple9(count, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], - tmp[5], tmp[6], tmp[7], tmp[8]) - count += 1 - - line.SetPoints(linePoints) - line.SetLines(cellArray) - for j in range(N_): - line.GetPointData().AddArray(arrays[j]) - return line - - -def move_past_sphere(centerline, center, r, start, step=-1, stop=0, scale_factor=0.8): - """Moves a point along the centerline until it as outside the a sphere with radius (r) - and a center (center). + # Check if info exists + if flowext or not path.isfile(path.join(dir_path, dir_path + ".json")): + compute_centers_for_meshing(surface, atrium_present, dir_path) - Args: - centerline (vtkPolyData): Centerline to move along. - center (list): point list of the center of the sphere - r (float): the radius of a sphere - start (int): id of the point along the centerline where to start. - step (int): direction along the centerline. - stop (int): ID along centerline, for when to stop searching. - scale_factor (float): Scale the radius with this factor. + # Open info + parameters = get_parameters(dir_path) + outlets = [] + inlets = [] + for key, value in parameters.items(): + if "area" not in key and "relevant" not in key: + if "outlet" in key: + outlets += value + elif "inlet" in key: + inlets += value - Returns: - tempPoint (list): The first point on the centerline outside the sphere - r (float): minimal inscribed sphere radius at the new point. - """ + num_outlets = len(outlets) // 3 + num_inlets = len(inlets) // 3 - # Create the minimal inscribed sphere - MISphere = vtk.vtkSphere() - MISphere.SetCenter(center) - MISphere.SetRadius(r * scale_factor) - tempPoint = [0.0, 0.0, 0.0] + if atrium_present and num_inlets != 0: + inlets = [] + for i in range(num_inlets): + inlets += parameters["inlet%d" % i] + if not atrium_present and num_outlets != 0: + outlets = [] + for i in range(num_outlets): + outlets += parameters["outlet%d" % i] - # Go the length of one MISR backwards - for i in range(start, stop, step): - value = MISphere.EvaluateFunction(centerline.GetPoint(i)) - if (value >= 0.0): - tempPoint = centerline.GetPoint(i) - break + # FIXIT: atrium case has several inlets (instead of inlet) and only one outlet (instead of outlets). + if inlets == [] and outlets == []: + inlets, outlets = compute_centers_for_meshing(surface, atrium_present, dir_path) - r = centerline.GetPointData().GetArray(radiusArrayName).GetTuple1(i) + print("The number of outlets =", len(outlets) // 3) + print("The number of inlets =", len(inlets) // 3) + print() - return tempPoint, r + return inlets, outlets def dist_sphere_curv(surface, centerlines, sac_center, misr_max, fileName, factor): # Get longest centerline length = [] for i in range(centerlines.GetNumberOfLines()): - line = ExtractSingleLine(centerlines, i) + line = extract_single_line(centerlines, i) length.append(get_curvilinear_coordinate(line)[-1]) ind_longest = length.index(max(length)) # Get all bifurcations along the longest centerline bif = [] bif_id = [] - longest_line = ExtractSingleLine(centerlines, ind_longest) - tol = get_tolerance(centerlines) + longest_line = extract_single_line(centerlines, ind_longest) + tol = get_centerline_tolerance(centerlines) for i in range(centerlines.GetNumberOfLines()): if i == ind_longest: continue - comp_line = ExtractSingleLine(centerlines, i) + comp_line = extract_single_line(centerlines, i) for j in range(comp_line.GetNumberOfPoints()): pnt1 = longest_line.GetPoints().GetPoint(j) pnt2 = comp_line.GetPoints().GetPoint(j) - if distance(pnt1, pnt2) > tol: + if get_distance(pnt1, pnt2) > tol: bif.append(pnt1) bif_id.append(j) break @@ -1931,7 +281,7 @@ def dist_sphere_curv(surface, centerlines, sac_center, misr_max, fileName, facto pop = [] for i in range(len(bif)): for j in range(i + 1, len(bif)): - dist = distance(bif[i], bif[j]) + dist = get_distance(bif[i], bif[j]) if dist < tol * 6: pop.append(j) @@ -1962,14 +312,14 @@ def dist_sphere_curv(surface, centerlines, sac_center, misr_max, fileName, facto # Multiple the surface curvatureSurface = curvatureFilter.Surface - curvatureArray = get_array("Curvature", curvatureSurface) - distance_to_sphere_array = get_array("DistanceToSpheres", distance_to_sphere) + curvatureArray = get_point_data_array("Curvature", curvatureSurface) + distance_to_sphere_array = get_point_data_array("DistanceToSpheres", distance_to_sphere) size_array = curvatureArray * distance_to_sphere_array * factor size_vtk_array = create_vtk_array(size_array, "Size") curvatureSurface.GetPointData().AddArray(size_vtk_array) - WritePolyData(curvatureSurface, fileName) + write_polydata(curvatureSurface, fileName) return distance_to_sphere @@ -1986,7 +336,7 @@ def dist_sphere_diam(surface, centerlines, sac_center, misr_max, fileName, facto # Compute element size based on diameter upper = 20 lower = 6 - diameter_array = 2 * get_array("DistanceToCenterlines", distance_to_sphere) + diameter_array = 2 * get_point_data_array("DistanceToCenterlines", distance_to_sphere) element_size = 13. / 35 * diameter_array ** 2 + lower element_size[element_size > upper] = upper element_size[element_size < lower] = lower @@ -2004,12 +354,12 @@ def dist_sphere_diam(surface, centerlines, sac_center, misr_max, fileName, facto if len(sac_center) == 0: element_size *= factor else: - distance_to_spheres_array = get_array("DistanceToSpheres", distance_to_sphere) + distance_to_spheres_array = get_point_data_array("DistanceToSpheres", distance_to_sphere) element_size = np.minimum(element_size, distance_to_spheres_array) * factor vtk_array = create_vtk_array(element_size, "Size") distance_to_sphere.GetPointData().AddArray(vtk_array) - WritePolyData(distance_to_sphere, fileName) + write_polydata(distance_to_sphere, fileName) return distance_to_sphere @@ -2017,7 +367,7 @@ def dist_sphere_diam(surface, centerlines, sac_center, misr_max, fileName, facto def mesh_alternative(surface): print("--- Meshing failed.") print("--- Proceeding with surface smooting and meshing.") - surface = vmtkSmoother(surface, "laplace", iterations=500) + surface = vmtk_smooth_surface(surface, "laplace", iterations=500) subdiv = vmtkscripts.vmtkSurfaceSubdivision() subdiv.Surface = surface @@ -2025,27 +375,167 @@ def mesh_alternative(surface): subdiv.Execute() surface = subdiv.Surface - return vmtkSmoother(surface, "laplace", iterations=500) + return vmtk_smooth_surface(surface, "laplace", iterations=500) + + +def compute_distance_to_sphere(surface, centerSphere, radiusSphere=0.0, + distanceOffset=0.0, distanceScale=0.01, + minDistance=0.2, maxDistance=0.3, + distanceToSpheresArrayName="DistanceToSpheres"): + # Check if there allready exists a distance to spheres + N = surface.GetNumberOfPoints() + number, names = get_number_of_arrays(surface) + add = False + if distanceToSpheresArrayName not in names: add = True + + # Get array + if add: + dist_array = get_vtk_array(distanceToSpheresArrayName, 1, N) + surface.GetPointData().AddArray(dist_array) + else: + dist_array = surface.GetPointData().GetArray("DistanceToSpheres") + + # Compute distance + for i in range(N): + distanceToSphere = dist_array.GetComponent(i, 0) + + # Get distance, but factor in size of sphere + newDist = get_distance(centerSphere, surface.GetPoints().GetPoint(i)) - radiusSphere + + # Set offset and scale distance + newDist = distanceOffset + newDist * distanceScale + + # Capp to min distance + if newDist < minDistance: + newDist = minDistance + + # Capp to max distance + if newDist > maxDistance: + newDist = maxDistance + + # Keep smallest distance + newDist = min(newDist, distanceToSphere) if not add else newDist + + dist_array.SetComponent(i, 0, newDist) + + return surface + + +def generate_mesh(surface, edge_length=None): + # Compute the mesh. + meshGenerator = vmtkscripts.vmtkMeshGenerator() + meshGenerator.Surface = surface + if edge_length is not None: + meshGenerator.ElementSizeMode = "edgelength" # Constant size mesh + meshGenerator.TargetEdgeLength = edge_length + else: + meshGenerator.ElementSizeMode = "edgelengtharray" # Variable size mesh + meshGenerator.TargetEdgeLengthArrayName = "Size" # Variable size mesh + meshGenerator.BoundaryLayer = 1 + meshGenerator.NumberOfSubLayers = 4 + meshGenerator.BoundaryLayerOnCaps = 0 # it should 1 + meshGenerator.BoundaryLayerThicknessFactor = 0.7 # 0.85 + meshGenerator.SubLayerRatio = 0.55 # 0.75 + meshGenerator.Tetrahedralize = 1 + meshGenerator.VolumeElementScaleFactor = 0.8 + meshGenerator.EndcapsEdgeLengthFactor = 1.0 + + # Mesh + meshGenerator.Execute() + + # Remeshed surface, store for later + remeshSurface = meshGenerator.RemeshedSurface + + # Full mesh + mesh = meshGenerator.Mesh + + return mesh, remeshSurface -def vmtkSmoother(surface, method, iterations=600): +def compute_centers_for_meshing(polyData, atrium_present, case_path=None, test_capped=False): """ - Wrapper for a vmtksurfacesmoothing. + Compute the center of all the openings in the surface. The inlet is chosen based on + the largest area for arteries (or aneurysm). However, for atrium, the outlet is chosen based on + the largest area (new). Args: - surface (vtkPolyData): Input surface to be smoothed. - method (str): Smoothing method. - iterations (int): Number of iterations. + test_capped (bool): Check if surface is capped. + polyData (vtkPolyData): centers of the openings. + case_path (str): path to case directory. + atrium_present (bool): Check if it is an atrium model. Returns: - surface (vtkPolyData): The smoothed surface. + inlet_center (list): Inlet center. + outlet_centers (list): A flattened list with all the outlet centers. """ + # Get cells which are open + cells = vtk_extract_feature_edges(polyData) + + if cells.GetNumberOfCells() == 0 and not test_capped: + print("WARNING: The model is capped, so it is uncapped, but the method is experimental.") + uncapped_surface = get_uncapped_surface(polyData) + compute_centers_for_meshing(uncapped_surface, atrium_present, case_path, test_capped) + elif cells.GetNumberOfCells() == 0 and test_capped: + return False, 0 + + # Compute connectivity of the cells + outputs = vtk_compute_connectivity(cells) - smoother = vmtkscripts.vmtkSurfaceSmoothing() - smoother.Surface = surface - smoother.NumberOfIterations = iterations - smoother.Method = method - smoother.Execute() - surface = smoother.Surface + # Get connectivity array + region_array = get_point_data_array("RegionId", outputs) - return surface + if test_capped: + return region_array.max() >= 1, region_array.max() + + # Get points + points = [] + get_point = outputs.GetPoints().GetPoint + for i in range(region_array.shape[0]): + points.append(get_point(i)) + points = np.asarray(points) + + # Get area and center + area = [] + center = [] + for i in range(int(region_array.max()) + 1): + # Compute area + boundary = vtk_compute_threshold(outputs, "RegionId", lower=i - 0.1, upper=i + 0.1, type="between", source=0) + + delaunay_filter = vtk.vtkDelaunay2D() + delaunay_filter.SetInputData(boundary) + delaunay_filter.Update() + area.append(vtk_compute_mass_properties(delaunay_filter.GetOutput())) + + # Get center + center.append(np.mean(points[(region_array == i).nonzero()[0]], axis=0)) + + # Assume multiple inlets for atrium, and multiple outlets for arteries + if atrium_present: + # Store the center and area + boundary_name = "outlet" + boundaries_name = "inlet%d" + else: + boundary_name = "inlet" + boundaries_name = "outlet%d" + + boundary_area_name = boundary_name + "_area" + boundaries_area_name = boundaries_name + "_area" + boundary_id = area.index(max(area)) + if case_path is not None: + info = {boundary_name: center[boundary_id].tolist(), boundary_area_name: area[boundary_id]} + p = 0 + for i in range(len(area)): + if i == boundary_id: + p = -1 + continue + info[boundaries_name % (i + p)] = center[i].tolist() + info[boundaries_area_name % (i + p)] = area[i] + + write_parameters(info, case_path) + + boundary_center = center[boundary_id].tolist() # center of the outlet + center.pop(boundary_id) + + center_ = [item for sublist in center for item in sublist] # centers of the inlets + + return center_, boundary_center From 9fce4b84970989776308c432eaade7c9d84adbc9 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 12:59:25 +0200 Subject: [PATCH 13/76] Update common --- automatedPreProcessing/common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 3d263c1b..c52ff991 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -499,7 +499,7 @@ def compute_centers_for_meshing(polyData, atrium_present, case_path=None, test_c center = [] for i in range(int(region_array.max()) + 1): # Compute area - boundary = vtk_compute_threshold(outputs, "RegionId", lower=i - 0.1, upper=i + 0.1, type="between", source=0) + boundary = vtk_compute_threshold(outputs, "RegionId", lower=i - 0.1, upper=i + 0.1, threshold_type="between", source=0) delaunay_filter = vtk.vtkDelaunay2D() delaunay_filter.SetInputData(boundary) From 91d89876f725a488c25098e2215212ba32aedb91 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 13:00:37 +0200 Subject: [PATCH 14/76] Update test --- test/test_pre_processing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_pre_processing.py b/test/test_pre_processing.py index c960645b..7047e7f4 100644 --- a/test/test_pre_processing.py +++ b/test/test_pre_processing.py @@ -27,7 +27,7 @@ def test_pre_processing(): assert path.isfile(mesh_path) # Check that mesh is not empty - mesh = ReadPolyData(mesh_path) + mesh = read_polydata(mesh_path) assert mesh.GetNumberOfPoints() > 0 From 3cea87268f6e4d241321d2c1f5ce081b1dcaa981 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 13:18:40 +0200 Subject: [PATCH 15/76] Update travis with morphman dep --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 576def23..d91eafb4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -27,10 +27,10 @@ install: - conda config --add channels vmtk # Set up environment - - conda create -n vmtk_env vmtk pytest itk vtk llvm=3.3 paramiko + - conda create -n morphmanEnv -c vmtk -c morphman morphman # Activate environment - - source activate vmtk_env + - source activate morphmanEnv # Useful for debugging any issues with conda - conda info -a From f9e7c9ff1931f313e201d57a7be4de63aaa32e64 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 13:21:52 +0200 Subject: [PATCH 16/76] Update travis with correct env --- .travis.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index d91eafb4..d0fdb628 100644 --- a/.travis.yml +++ b/.travis.yml @@ -36,9 +36,9 @@ install: - conda info -a # / -> // in vmtkcenterlines.py and vmtksurfacecurvature.py - - sed -i -e 's/len(self.SourcePoints)\/3/len\(self.SourcePoints\)\/\/3/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py + - sed -i -e 's/len(self.SourcePoints)\/3/len\(self.SourcePoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py + - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py + - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py # Dependencies for code coverage - pip install pytest-cov codecov From 3e61f7d9a7c9d47aa65ba3807551a0c039bd0130 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 13:28:50 +0200 Subject: [PATCH 17/76] Specific imports from morphman --- automatedPreProcessing/common.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index c52ff991..c2378e0c 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -1,4 +1,8 @@ -from morphman.common import * +from morphman import get_parameters, vtk_clean_polydata, vtk_triangulate_surface, write_parameters, read_polydata, \ + vmtkscripts, write_polydata, vtk_extract_feature_edges, get_uncapped_surface, vtk_compute_connectivity, \ + get_point_data_array, vtk_compute_threshold, vtk_compute_mass_properties, extract_single_line, \ + get_curvilinear_coordinate, get_centerline_tolerance, get_distance, create_vtk_array, vmtk_smooth_surface, \ + get_number_of_arrays, get_vtk_array try: from vmtkpointselector import * @@ -499,7 +503,8 @@ def compute_centers_for_meshing(polyData, atrium_present, case_path=None, test_c center = [] for i in range(int(region_array.max()) + 1): # Compute area - boundary = vtk_compute_threshold(outputs, "RegionId", lower=i - 0.1, upper=i + 0.1, threshold_type="between", source=0) + boundary = vtk_compute_threshold(outputs, "RegionId", lower=i - 0.1, upper=i + 0.1, threshold_type="between", + source=0) delaunay_filter = vtk.vtkDelaunay2D() delaunay_filter.SetInputData(boundary) From fcc1e9c2f5b58ad41bed3139504b623206195f9e Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 13:33:17 +0200 Subject: [PATCH 18/76] Update travis yml --- .travis.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index d0fdb628..123570ab 100644 --- a/.travis.yml +++ b/.travis.yml @@ -25,9 +25,10 @@ install: - conda config --set restore_free_channel true - conda config --set always_yes yes --set changeps1 no - conda config --add channels vmtk + - conda config --add channels morphman # Set up environment - - conda create -n morphmanEnv -c vmtk -c morphman morphman + - conda create -n morphmanEnv morphman # Activate environment - source activate morphmanEnv From f13c5d56a809db7cc0fa8a72af6c9e72a5bfa97c Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 13:44:37 +0200 Subject: [PATCH 19/76] Specific imports from morphman --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 123570ab..e1dd06bf 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,7 +28,7 @@ install: - conda config --add channels morphman # Set up environment - - conda create -n morphmanEnv morphman + - conda create -n morphmanEnv morphman pytest llvm=3.3 # Activate environment - source activate morphmanEnv From 493fecb07fcf94d0601888e258f1545c0713075a Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 13:47:45 +0200 Subject: [PATCH 20/76] Specific imports from morphman --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index e1dd06bf..cb607c25 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,7 +28,7 @@ install: - conda config --add channels morphman # Set up environment - - conda create -n morphmanEnv morphman pytest llvm=3.3 + - conda create -n morphmanEnv morphman pytest llvm=3.3 paramiko # Activate environment - source activate morphmanEnv From 779eb4bef3b7a9618532cf91841a96e403f289ed Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 14:58:31 +0200 Subject: [PATCH 21/76] Add imports --- automatedPreProcessing/automatedPreProcessing.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 80219cb6..cbba6993 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -2,6 +2,11 @@ from __future__ import print_function import argparse +import json +import sys + +from morphman import is_surface_capped, vmtk_cap_polydata, compute_centerlines, get_vtk_point_locator, \ + vtk_merge_polydata, smooth_voronoi_diagram, create_new_surface, compute_centers import ImportData import ToolRepairSTL From 204eb555e654bcc24421ea70a34792f925b6c1e6 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 15:02:50 +0200 Subject: [PATCH 22/76] Update imporst --- automatedPreProcessing/common.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index c2378e0c..eb0d6a38 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -1,9 +1,9 @@ -from morphman import get_parameters, vtk_clean_polydata, vtk_triangulate_surface, write_parameters, read_polydata, \ - vmtkscripts, write_polydata, vtk_extract_feature_edges, get_uncapped_surface, vtk_compute_connectivity, \ - get_point_data_array, vtk_compute_threshold, vtk_compute_mass_properties, extract_single_line, \ - get_curvilinear_coordinate, get_centerline_tolerance, get_distance, create_vtk_array, vmtk_smooth_surface, \ - get_number_of_arrays, get_vtk_array - +# from morphman import get_parameters, vtk_clean_polydata, vtk_triangulate_surface, write_parameters, read_polydata, \ +# vmtkscripts, write_polydata, vtk_extract_feature_edges, get_uncapped_surface, vtk_compute_connectivity, \ +# get_point_data_array, vtk_compute_threshold, vtk_compute_mass_properties, extract_single_line, \ +# get_curvilinear_coordinate, get_centerline_tolerance, get_distance, create_vtk_array, vmtk_smooth_surface, \ +# get_number_of_arrays, get_vtk_array +from morphman.common import * try: from vmtkpointselector import * except ImportError: From 48e1a477a608c32704599118d598189a7c389560 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 12 Oct 2021 15:06:47 +0200 Subject: [PATCH 23/76] Remove unused imports --- automatedPreProcessing/automatedPreProcessing.py | 5 ----- automatedPreProcessing/common.py | 6 +----- 2 files changed, 1 insertion(+), 10 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index cbba6993..80219cb6 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -2,11 +2,6 @@ from __future__ import print_function import argparse -import json -import sys - -from morphman import is_surface_capped, vmtk_cap_polydata, compute_centerlines, get_vtk_point_locator, \ - vtk_merge_polydata, smooth_voronoi_diagram, create_new_surface, compute_centers import ImportData import ToolRepairSTL diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index eb0d6a38..271458d8 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -1,9 +1,5 @@ -# from morphman import get_parameters, vtk_clean_polydata, vtk_triangulate_surface, write_parameters, read_polydata, \ -# vmtkscripts, write_polydata, vtk_extract_feature_edges, get_uncapped_surface, vtk_compute_connectivity, \ -# get_point_data_array, vtk_compute_threshold, vtk_compute_mass_properties, extract_single_line, \ -# get_curvilinear_coordinate, get_centerline_tolerance, get_distance, create_vtk_array, vmtk_smooth_surface, \ -# get_number_of_arrays, get_vtk_array from morphman.common import * + try: from vmtkpointselector import * except ImportError: From 1bbfb26d4ae1d5c7850efef571c3fd582e3b60a7 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 13:26:24 +0200 Subject: [PATCH 24/76] Added flow extension and movement scripts for atrium models --- .../movementPreProcessing.py | 445 ++++++++++++++++++ 1 file changed, 445 insertions(+) create mode 100644 automatedPreProcessing/movementPreProcessing.py diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py new file mode 100644 index 00000000..e33f8551 --- /dev/null +++ b/automatedPreProcessing/movementPreProcessing.py @@ -0,0 +1,445 @@ +import argparse +import os + +from morphman.common import * +from vtk.numpy_interface import dataset_adapter as dsa + +cell_id_name = "CellEntityIds" + + +def main(case_path, move_surface, add_extensions, edge_length, patient_specific, recompute_mesh): + # Find model_path + if "vtp" in case_path: + model_path = case_path.replace(".vtp", "") + elif "stl" in case_path: + model_path = case_path.replace(".stl", "") + + cl_path = model_path + "_cl.vtp" + case = model_path.split("/")[-1] + mapped_path = model_path + "_mapped" + moved_path = model_path + "_moved" + + if not path.exists(moved_path): + os.mkdir(moved_path) + + # Compute centerlines and get center of mitral valve as new origin + surface = read_polydata(case_path) + + # Cap surface with flow extensions + capped_surface = vmtk_cap_polydata(surface) + inlet, outlets = get_inlet_and_outlet_centers(surface, model_path) + centerlines, _, _ = compute_centerlines(inlet, outlets, cl_path, capped_surface, resampling=0.01) + centerline = extract_single_line(centerlines, 0) + origin = centerline.GetPoint(0) + + # Get movement + if move_surface: + print("-- Moving surface --") + if patient_specific: + move_atrium_real(case_path, mapped_path, moved_path, case) + else: + # Use constructed movement + move_atrium(case_path, origin, moved_path, case) + + # Add flow extensions + if add_extensions and path.exists(moved_path): + add_flow_extensions(surface, model_path, moved_path, edge_length, recompute_mesh) + + +def IdealVolume(t): + LA_volume = [36858.89622880263, 42041.397558417586, 47203.72790128924, 51709.730141809414, 56494.613640032476, + 53466.224048278644, 46739.80937044214, 45723.76234837754, 46107.69142568748, 34075.82037837897] + + time = np.linspace(0, 1, len(LA_volume)) + LA_smooth = splrep(time, LA_volume, s=1e6, per=True) + vmin = 37184.998997815936 + vmax = 19490.21405487303 + volume = (splev(t, LA_smooth) - vmin) / vmax + + return volume + + +def move_atrium_real(case_path, mapped_path, moved_path, case): + surface = read_polydata(case_path) + surface = dsa.WrapDataObject(surface) + mapped_surfaces = sorted(os.listdir(mapped_path)) + n_frames = len(mapped_surfaces) + for frame in range(1, n_frames): + displaced_surface = read_polydata(path.join(mapped_path, "%s_%02d.vtp" % (case, frame))) + displaced_surface = dsa.WrapDataObject(displaced_surface) + displacement = displaced_surface.PointData["displacement"] + displaced_surface.Points += displacement + surface.Points += displacement + write_polydata(surface.VTKObject, path.join(moved_path, "%s_%02d.vtp" % (case, frame))) + surface.Points -= displacement + + +def move_atrium(case_path, origin, moved_path, case, cycle=1.0, n_frames=20): + # Params + A = 25 / 2 + t_array = np.linspace(0, cycle, n_frames) + volumes = [] + + surface = read_polydata(case_path) + write_polydata(surface, path.join(moved_path, "%s_000.vtp" % case)) + + for i, t in enumerate(t_array): + surface = read_polydata(case_path) + surface = dsa.WrapDataObject(surface) + points = surface.Points + + for j in range(len(points)): + p = points[j] + displacement = IdealVolume(t) + + # Axial movement + x_o = origin[0] + y_o = origin[1] + x_0 = p[0] + y_0 = p[1] + + scaling_x = (x_0 - x_o) + scaling_y = (y_0 - y_o) + x_new = A / 100 * scaling_x * displacement + y_new = A / 100 * scaling_y * displacement + z_new = A * displacement + + # Longitudinal movement + p_new = np.array([x_new, y_new, z_new]) + points[j] += p_new + + surface.SetPoints(points) + + write_polydata(surface.VTKObject, path.join(moved_path, "%s_%03d.vtp" % (case, 5 + 5 * i))) + capped_surface = vmtk_cap_polydata(surface.VTKObject) + + volume = vtk_compute_mass_properties(capped_surface, compute_volume=True) + volumes.append(volume) + + +def capp_surface(remeshed_extended, offset=1): + capper = vmtkscripts.vmtkSurfaceCapper() + capper.Surface = remeshed_extended + capper.Interactive = 0 + capper.Method = "centerpoint" + capper.TriangleOutput = 0 + capper.CellEntityIdOffset = offset + capper.Execute() + surface = capper.Surface + + return surface + + +def add_flow_extensions(surface, model_path, moved_path, resolution=1.9, recompute_mesh=False): + # Create result paths + mesh_path = model_path + ".vtu" + points_path = model_path + "_points.np" + mesh_xml_path = mesh_path.replace(".vtu", ".xml") + remeshed_path = model_path + "_remeshed.vtp" + extended_path = model_path + "_extended" + centerline_path = model_path + "_cl.vtp" + remeshed_extended_path = model_path + "_remeshed_extended.vtp" + if not path.exists(extended_path): + os.mkdir(extended_path) + + # remeshed = original + if path.exists(remeshed_path): + print("-- Remeshing --") + remeshed = read_polydata(remeshed_path) + else: + remeshed = remesh_surface(surface, resolution) + remeshed = vtk_clean_polydata(remeshed) + write_polydata(remeshed, remeshed_path) + + # Compute centerline + if not path.exists(centerline_path): + print("-- Computing centerlines --") + inlet, outlet = compute_centers(remeshed, model_path) + print(inlet, outlet) + centerline, _, _ = compute_centerlines(inlet, outlet, centerline_path, capp_surface(remeshed), + resampling=0.1, end_point=1) + else: + centerline = read_polydata(centerline_path) + + # Create surface extensions on the original surface + print("-- Adding flow extensions --") + length_in = 1.5 + length_out = 1.5 + remeshed_extended = add_flow_extension(remeshed, centerline, include_outlet=False, extension_length=length_in) + remeshed_extended = add_flow_extension(remeshed_extended, centerline, include_outlet=True, + extension_length=length_out) + write_polydata(remeshed_extended, remeshed_extended_path) + + # Get a point mapper + distance, point_map = get_point_map(remeshed, remeshed_extended) + + # Add extents to all surfaces + extended_surfaces = sorted([f for f in os.listdir(moved_path) if f[:2] == "LA"]) + n_surfaces = len(extended_surfaces) + + print("-- Projecting surfaces --") + points = np.zeros((remeshed_extended.GetNumberOfPoints(), 3, n_surfaces)) + for i in range(n_surfaces): + model_path = path.join(moved_path, extended_surfaces[i]) + if i == 0: + points[:, :, i] = dsa.WrapDataObject(remeshed_extended).Points + continue + + tmp_surface = read_polydata(model_path) + new_path = path.join(extended_path, model_path.split("/")[-1]) + move_surface_model(tmp_surface, surface, remeshed, remeshed_extended, distance, point_map, new_path, i, points) + + # Write points to file + points[:, :, -1] = points[:, :, 0] + points.dump(points_path) + + # Cap mitral valve + if not path.exists(mesh_path) or recompute_mesh: + print("-- Meshing surface --") + remeshed_extended = dsa.WrapDataObject(remeshed_extended) + remeshed_extended.CellData.append(np.zeros(remeshed_extended.VTKObject.GetNumberOfCells()) + 1, + cell_id_name) + remeshed_all_capped = capp_surface(remeshed_extended.VTKObject) + remeshed_all_capped = remesh_surface(remeshed_all_capped, resolution, exclude=[1]) + + # Mesh volumetric + sizingFunction = vtkvmtk.vtkvmtkPolyDataSizingFunction() + sizingFunction.SetInputData(remeshed_all_capped) + sizingFunction.SetSizingFunctionArrayName("Volume") + sizingFunction.SetScaleFactor(0.8) + sizingFunction.Update() + + surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh() + surfaceToMesh.Surface = sizingFunction.GetOutput() + surfaceToMesh.Execute() + + tetgen = vmtkscripts.vmtkTetGen() + tetgen.Mesh = surfaceToMesh.Mesh + tetgen.GenerateCaps = 0 + tetgen.UseSizingFunction = 1 + tetgen.SizingFunctionArrayName = "Volume" + tetgen.CellEntityIdsArrayName = cell_id_name + tetgen.Order = 1 + tetgen.Quality = 1 + tetgen.PLC = 1 + tetgen.NoBoundarySplit = 1 + tetgen.RemoveSliver = 1 + tetgen.OutputSurfaceElements = 1 + tetgen.OutputVolumeElements = 1 + tetgen.Execute() + + mesh = tetgen.Mesh + write_polydata(mesh, mesh_path) + + meshWriter = vmtkscripts.vmtkMeshWriter() + meshWriter.CellEntityIdsArrayName = "CellEntityIds" + meshWriter.Mesh = mesh + meshWriter.Mode = "ascii" + meshWriter.Compressed = True + meshWriter.OutputFileName = mesh_xml_path + meshWriter.Execute() + + +def move_surface_model(surface, original, remeshed, remeshed_extended, distance, point_map, file_path, i, points): + surface = dsa.WrapDataObject(surface) + original = dsa.WrapDataObject(original) + remeshed = dsa.WrapDataObject(remeshed) + remeshed_extended = dsa.WrapDataObject(remeshed_extended) + + if "displacement" in original.PointData.keys(): + original.VTKObject.GetPointData().RemoveArray("displacement") + + if "displacement" in remeshed_extended.PointData.keys(): + remeshed_extended.VTKObject.GetPointData().RemoveArray("displacement") + + # Get displacement field + original.PointData.append(surface.Points - original.Points, "displacement") + + # Get + projector = vmtkscripts.vmtkSurfaceProjection() + projector.Surface = remeshed_extended.VTKObject + projector.ReferenceSurface = original.VTKObject + projector.Execute() + + # New surface + new_surface = projector.Surface + new_surface = dsa.WrapDataObject(new_surface) + + # Manipulate displacement in the extensions + displacement = new_surface.PointData["displacement"] + displacement[remeshed.Points.shape[0]:] = distance * displacement[point_map] + + # Move the mesh points + new_surface.Points += displacement + write_polydata(new_surface.VTKObject, file_path) + points[:, :, i] = new_surface.Points.copy() + new_surface.Points -= displacement + + +def get_point_map(remeshed, remeshed_extended): + remeshed = dsa.WrapDataObject(remeshed) + remeshed_extended = dsa.WrapDataObject(remeshed_extended) + + # Get lengths + num_re = remeshed.Points.shape[0] + num_ext = remeshed_extended.Points.shape[0] - remeshed.Points.shape[0] + + # Get locators + inner_feature = vtk_compute_connectivity(vtk_extract_feature_edges(remeshed.VTKObject)) + outer_feature = vtk_compute_connectivity(vtk_extract_feature_edges(remeshed_extended.VTKObject)) + locator_remeshed = get_vtk_point_locator(remeshed.VTKObject) + + n_features = outer_feature.GetPointData().GetArray("RegionId").GetValue(outer_feature.GetNumberOfPoints() - 1) + inner_features = np.array( + [vtk_compute_threshold(inner_feature, "RegionId", i, i + 0.1, source=0) for i in range(n_features + 1)]) + outer_features = np.array( + [vtk_compute_threshold(outer_feature, "RegionId", i, i + 0.1, source=0) for i in range(n_features + 1)]) + + inner_regions = [dsa.WrapDataObject(feature) for feature in inner_features] + inner_locators = [get_vtk_point_locator(feature) for feature in inner_features] + inner_points = [feature.GetNumberOfPoints() for feature in inner_features] + + outer_regions = [dsa.WrapDataObject(feature) for feature in outer_features] + outer_locators = [get_vtk_point_locator(feature) for feature in outer_features] + outer_points = [feature.GetNumberOfPoints() for feature in outer_features] + boundary_map = {i: j for i, j in zip(np.argsort(inner_points), np.argsort(outer_points))} + + # Get distance and point map + distances = np.zeros(num_ext) + point_map = np.zeros(num_ext) + + for i in range(num_ext): + point = remeshed_extended.Points[num_re + i] + tmp_dist = 1E16 + tmp_id = -1 + # Some hacks to find the correct corresponding points + for region_id in range(len(outer_features)): + region_id_out = boundary_map[region_id] + id_i = inner_locators[region_id].FindClosestPoint(point) + id_o = outer_locators[region_id_out].FindClosestPoint(point) + + p_i = inner_features[region_id].GetPoint(id_i) + p_o = outer_features[region_id_out].GetPoint(id_o) + + dist_o = get_distance(point, p_i) + dist_i = get_distance(point, p_o) + dist_total = dist_i + dist_o + if dist_total < tmp_dist: + tmp_dist = dist_total + tmp_id = region_id + + regionId = tmp_id + regionId_out = boundary_map[regionId] + inner_id = inner_locators[regionId].FindClosestPoint(point) + outer_id = outer_locators[regionId_out].FindClosestPoint(point) + + dist_to_boundary = get_distance(point, outer_regions[regionId_out].Points[outer_id]) + dist_between_boundaries = get_distance(inner_regions[regionId].Points[inner_id], + outer_regions[regionId_out].Points[outer_id]) + distances[i] = dist_to_boundary / dist_between_boundaries + point_map[i] = locator_remeshed.FindClosestPoint(inner_regions[regionId].Points[inner_id]) + + # Let the points corresponding to the caps have distance 0 + point_map = point_map.astype(int) + return distances, point_map + + +def add_flow_extension(surface, centerlines, include_outlet, extension_length=2.0): + # Mimick behaviour of vmtkflowextensionfilter + boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor() + boundaryExtractor.SetInputData(surface) + boundaryExtractor.Update() + boundaries = boundaryExtractor.GetOutput() + + # Find outlet + lengths = [] + for i in range(boundaries.GetNumberOfCells()): + lengths.append(get_curvilinear_coordinate(boundaries.GetCell(i))[-1]) + outlet_id = lengths.index(max(lengths)) + + # Exclude outlet or inlets + boundaryIds = vtk.vtkIdList() + for i in range(centerlines.GetNumberOfLines() + 1): + if include_outlet and i == outlet_id: + boundaryIds.InsertNextId(i) + else: + if i != outlet_id: + boundaryIds.InsertNextId(i) + + flowExtensionsFilter = vtkvmtk.vtkvmtkPolyDataFlowExtensionsFilter() + flowExtensionsFilter.SetInputData(surface) + flowExtensionsFilter.SetCenterlines(centerlines) + flowExtensionsFilter.SetSigma(1.0) + flowExtensionsFilter.SetAdaptiveExtensionLength(1) + flowExtensionsFilter.SetAdaptiveExtensionRadius(1) + flowExtensionsFilter.SetAdaptiveNumberOfBoundaryPoints(1) + flowExtensionsFilter.SetExtensionRatio(extension_length) + flowExtensionsFilter.SetExtensionRadius(1.0) + flowExtensionsFilter.SetTransitionRatio(1.0) + flowExtensionsFilter.SetCenterlineNormalEstimationDistanceRatio(1.0) + flowExtensionsFilter.SetExtensionModeToUseCenterlineDirection() + flowExtensionsFilter.SetInterpolationModeToThinPlateSpline() + flowExtensionsFilter.SetBoundaryIds(boundaryIds) + flowExtensionsFilter.Update() + + surface = flowExtensionsFilter.GetOutput() + + # Smooth at edges + surface = vmtk_smooth_surface(surface, "laplace", iterations=150) + + return surface + + +def remesh_surface(surface, edge_length, exclude=None): + surface = dsa.WrapDataObject(surface) + if cell_id_name not in surface.CellData.keys(): + surface.CellData.append(np.zeros(surface.VTKObject.GetNumberOfCells()) + 1, cell_id_name) + remeshing = vmtkscripts.vmtkSurfaceRemeshing() + remeshing.Surface = surface.VTKObject + remeshing.CellEntityIdsArrayName = cell_id_name + remeshing.TargetEdgeLength = edge_length + remeshing.MaxEdgeLength = 1e6 + remeshing.MinEdgeLength = 0.0 + remeshing.TargetEdgeLengthFactor = 1.0 + remeshing.TargetEdgeLengthArrayName = "" + remeshing.TriangleSplitFactor = 5.0 + remeshing.ElementSizeMode = "edgelength" + if exclude is not None: + remeshing.ExcludeEntityIds = exclude + + remeshing.Execute() + + remeshed_surface = remeshing.Surface + + return remeshed_surface + + +def read_command_line(): + """ + Read arguments from commandline and return all values in a dictionary. + """ + '''Command-line arguments.''' + parser = argparse.ArgumentParser( + description="Add rigid flow extensions to Atrial models.") + + parser.add_argument('-i', '--inputModel', type=str, required=True, dest='fileNameModel', + help="Input file containing the 3D model.") + parser.add_argument('-m', '--movement', type=str2bool, required=False, default=False, dest="moveSurface", + help="Add movement to input surface.") + parser.add_argument('-e', '--extension', type=str2bool, required=False, default=False, dest="addExtensions", + help="Add extension to moved surface.") + parser.add_argument('-el', '--edge-length', type=float, required=False, default=1.9, dest="edgeLength", + help="Edge length resolution for meshing.") + parser.add_argument('-p', '--patient-specific', type=str2bool, required=False, default=False, + dest="patientSpecific", help="Use patient specific data or constructed movement.") + parser.add_argument('-r', '--recompute-mesh', type=str2bool, required=False, default=False, + dest="recomputeMesh", help="Recomputes mesh if true.") + + args, _ = parser.parse_known_args() + + return dict(case_path=args.fileNameModel, move_surface=args.moveSurface, add_extensions=args.addExtensions, + edge_length=args.edgeLength, patient_specific=args.patientSpecific, recompute_mesh=args.recomputeMesh) + + +if __name__ == '__main__': + main(**read_command_line()) From 30c2a7ff243321dd580d0d002abe506816edec6f Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 14:02:00 +0200 Subject: [PATCH 25/76] Added doc string to movement script --- .../movementPreProcessing.py | 116 +++++++++++------- 1 file changed, 69 insertions(+), 47 deletions(-) diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index e33f8551..6ea35277 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -8,6 +8,21 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, recompute_mesh): + """ + Automatically generate movement and mesh of surface model in .vtu and .xml format. + Assumes the user either has a set of displaced models or models with mapped displacement fields, + located in moved_path or mapped_path, respectively. + + Can add patient-specific or arbitrary movement to model. + + Args: + case_path (str): Path to case + move_surface (bool): To move surface or not + add_extensions (bool): To add flow extensions or not + edge_length (float): Mesh resolution, characteristic edge length + patient_specific (bool): If case has patient-specific movement or not + recompute_mesh (bool): Computes mesh if true + """ # Find model_path if "vtp" in case_path: model_path = case_path.replace(".vtp", "") @@ -18,12 +33,15 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, case = model_path.split("/")[-1] mapped_path = model_path + "_mapped" moved_path = model_path + "_moved" + mesh_path = model_path + ".vtu" + mesh_xml_path = mesh_path.replace(".vtu", ".xml") if not path.exists(moved_path): os.mkdir(moved_path) # Compute centerlines and get center of mitral valve as new origin surface = read_polydata(case_path) + surface_to_mesh = None # Cap surface with flow extensions capped_surface = vmtk_cap_polydata(surface) @@ -43,7 +61,10 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, # Add flow extensions if add_extensions and path.exists(moved_path): - add_flow_extensions(surface, model_path, moved_path, edge_length, recompute_mesh) + surface_to_mesh = add_flow_extensions(surface, model_path, moved_path, edge_length, recompute_mesh) + + if not path.exists(mesh_path) or recompute_mesh and surface_to_mesh is not None: + generate_mesh(mesh_path, mesh_xml_path, surface_to_mesh, edge_length) def IdealVolume(t): @@ -132,9 +153,7 @@ def capp_surface(remeshed_extended, offset=1): def add_flow_extensions(surface, model_path, moved_path, resolution=1.9, recompute_mesh=False): # Create result paths - mesh_path = model_path + ".vtu" points_path = model_path + "_points.np" - mesh_xml_path = mesh_path.replace(".vtu", ".xml") remeshed_path = model_path + "_remeshed.vtp" extended_path = model_path + "_extended" centerline_path = model_path + "_cl.vtp" @@ -193,51 +212,54 @@ def add_flow_extensions(surface, model_path, moved_path, resolution=1.9, recompu points[:, :, -1] = points[:, :, 0] points.dump(points_path) + return remeshed_extended + + +def generate_mesh(mesh_path, mesh_xml_path, remeshed_extended, resolution): # Cap mitral valve - if not path.exists(mesh_path) or recompute_mesh: - print("-- Meshing surface --") - remeshed_extended = dsa.WrapDataObject(remeshed_extended) - remeshed_extended.CellData.append(np.zeros(remeshed_extended.VTKObject.GetNumberOfCells()) + 1, - cell_id_name) - remeshed_all_capped = capp_surface(remeshed_extended.VTKObject) - remeshed_all_capped = remesh_surface(remeshed_all_capped, resolution, exclude=[1]) - - # Mesh volumetric - sizingFunction = vtkvmtk.vtkvmtkPolyDataSizingFunction() - sizingFunction.SetInputData(remeshed_all_capped) - sizingFunction.SetSizingFunctionArrayName("Volume") - sizingFunction.SetScaleFactor(0.8) - sizingFunction.Update() - - surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh() - surfaceToMesh.Surface = sizingFunction.GetOutput() - surfaceToMesh.Execute() - - tetgen = vmtkscripts.vmtkTetGen() - tetgen.Mesh = surfaceToMesh.Mesh - tetgen.GenerateCaps = 0 - tetgen.UseSizingFunction = 1 - tetgen.SizingFunctionArrayName = "Volume" - tetgen.CellEntityIdsArrayName = cell_id_name - tetgen.Order = 1 - tetgen.Quality = 1 - tetgen.PLC = 1 - tetgen.NoBoundarySplit = 1 - tetgen.RemoveSliver = 1 - tetgen.OutputSurfaceElements = 1 - tetgen.OutputVolumeElements = 1 - tetgen.Execute() - - mesh = tetgen.Mesh - write_polydata(mesh, mesh_path) - - meshWriter = vmtkscripts.vmtkMeshWriter() - meshWriter.CellEntityIdsArrayName = "CellEntityIds" - meshWriter.Mesh = mesh - meshWriter.Mode = "ascii" - meshWriter.Compressed = True - meshWriter.OutputFileName = mesh_xml_path - meshWriter.Execute() + print("-- Meshing surface --") + remeshed_extended = dsa.WrapDataObject(remeshed_extended) + remeshed_extended.CellData.append(np.zeros(remeshed_extended.VTKObject.GetNumberOfCells()) + 1, + cell_id_name) + remeshed_all_capped = capp_surface(remeshed_extended.VTKObject) + remeshed_all_capped = remesh_surface(remeshed_all_capped, resolution, exclude=[1]) + + # Mesh volumetric + sizingFunction = vtkvmtk.vtkvmtkPolyDataSizingFunction() + sizingFunction.SetInputData(remeshed_all_capped) + sizingFunction.SetSizingFunctionArrayName("Volume") + sizingFunction.SetScaleFactor(0.8) + sizingFunction.Update() + + surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh() + surfaceToMesh.Surface = sizingFunction.GetOutput() + surfaceToMesh.Execute() + + tetgen = vmtkscripts.vmtkTetGen() + tetgen.Mesh = surfaceToMesh.Mesh + tetgen.GenerateCaps = 0 + tetgen.UseSizingFunction = 1 + tetgen.SizingFunctionArrayName = "Volume" + tetgen.CellEntityIdsArrayName = cell_id_name + tetgen.Order = 1 + tetgen.Quality = 1 + tetgen.PLC = 1 + tetgen.NoBoundarySplit = 1 + tetgen.RemoveSliver = 1 + tetgen.OutputSurfaceElements = 1 + tetgen.OutputVolumeElements = 1 + tetgen.Execute() + + mesh = tetgen.Mesh + write_polydata(mesh, mesh_path) + + meshWriter = vmtkscripts.vmtkMeshWriter() + meshWriter.CellEntityIdsArrayName = "CellEntityIds" + meshWriter.Mesh = mesh + meshWriter.Mode = "ascii" + meshWriter.Compressed = True + meshWriter.OutputFileName = mesh_xml_path + meshWriter.Execute() def move_surface_model(surface, original, remeshed, remeshed_extended, distance, point_map, file_path, i, points): From 50615df3b8ad02e8eef71fc9e569a2f4da4ac610 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 15:29:59 +0200 Subject: [PATCH 26/76] Refactor ID fetching during pre processing --- .travis.yml | 11 +-- Artery.py | 0 .../automatedPreProcessing.py | 97 ++----------------- automatedPreProcessing/common.py | 67 +++++++++++++ 4 files changed, 78 insertions(+), 97 deletions(-) mode change 100755 => 100644 Artery.py diff --git a/.travis.yml b/.travis.yml index cb607c25..576def23 100644 --- a/.travis.yml +++ b/.travis.yml @@ -25,21 +25,20 @@ install: - conda config --set restore_free_channel true - conda config --set always_yes yes --set changeps1 no - conda config --add channels vmtk - - conda config --add channels morphman # Set up environment - - conda create -n morphmanEnv morphman pytest llvm=3.3 paramiko + - conda create -n vmtk_env vmtk pytest itk vtk llvm=3.3 paramiko # Activate environment - - source activate morphmanEnv + - source activate vmtk_env # Useful for debugging any issues with conda - conda info -a # / -> // in vmtkcenterlines.py and vmtksurfacecurvature.py - - sed -i -e 's/len(self.SourcePoints)\/3/len\(self.SourcePoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py + - sed -i -e 's/len(self.SourcePoints)\/3/len\(self.SourcePoints\)\/\/3/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py + - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py + - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py # Dependencies for code coverage - pip install pytest-cov codecov diff --git a/Artery.py b/Artery.py old mode 100755 new mode 100644 diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 80219cb6..0a65a4ad 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -344,26 +344,6 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin listProbePoints = ImportData.GetListProbePoints(centerlinesBranches, network, verbose_print) listProbePoints += sac_center - # Add points randomly in the sac. - # FIXME: This is not robust enough. Suggestion to fix: Extract the - # second half of the sac centerline, then get all points from the - # voronoi diagram which is closest to that part compared to any ther - # centerlines. Then randomly chose among those points. For now, simply - # add just one point (sac_center). - # numberOfPoints = numberOfSacPoints - # for k in range(num_anu): - # u = np.random.uniform(0.0, 1.0, (numberOfPoints, 1)) - # theta = np.random.uniform(0., 1., (numberOfPoints, 1)) * np.pi - # phi = np.arccos(1 - 2 * np.random.uniform(0.0, 1., (numberOfPoints, 1))) - # radius = misr_max[k] * u**(0.3333) - # x = radius * np.sin(theta) * np.cos(phi) - # y = radius * np.sin(theta) * np.sin(phi) - # z = radius * np.cos(theta) - # for i in range(len(x)): - # listProbePoints.append([np.array(misr_max_center[k][0] + x[i]).tolist()[0], - # np.array(misr_max_center[k][1] + y[i]).tolist()[0], - # np.array(misr_max_center[k][2] + z[i]).tolist()[0]]) - print("--- Saving probes points in: %s\n" % file_name_probe_points) probe_points = np.array(listProbePoints) probe_points.dump(file_name_probe_points) @@ -379,83 +359,18 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # BSL method for mean inlet flow rate. parameters = get_parameters(path.join(dir_path, case_name)) - if (atrium_present == False): - mean_inflow_rate = 0.27 * parameters["inlet_area"] - else: + + # FIXME: Add plausible boundary conditions for atrial flow + if atrium_present: Total_inlet_area = 0 num_inlets = len(inlet) // 3 for i in range(num_inlets): Total_inlet_area += parameters["inlet%s_area" % (i)] mean_inflow_rate = 0.27 * Total_inlet_area - - # Extract the surface mesh of the wall - wallMesh = vtk_compute_threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) - - boundaryReferenceSystems = vmtkscripts.vmtkBoundaryReferenceSystems() - boundaryReferenceSystems.Surface = wallMesh - boundaryReferenceSystems.Execute() - refSystem = boundaryReferenceSystems.ReferenceSystems - cellEntityIdsArray = get_vtk_array('CellEntityIds', 0, refSystem.GetNumberOfPoints()) - refSystem.GetPointData().AddArray(cellEntityIdsArray) - - # Extract the surface mesh of the end caps - boundarySurface = vtk_compute_threshold(polyDataVolMesh, "CellEntityIds", upper=1.5, threshold_type="upper") - - pointCells = vtk.vtkIdList() - surfaceCellEntityIdsArray = vtk.vtkIntArray() - surfaceCellEntityIdsArray.DeepCopy(boundarySurface.GetCellData().GetArray('CellEntityIds')) - - # Find the corresponding couple (mesh outlet ID, network ID). - ids = [] - for i in range(refSystem.GetNumberOfPoints()): - distancePoints = 10000000 - pointId = boundarySurface.FindPoint(refSystem.GetPoint(i)) - boundarySurface.GetPointCells(pointId, pointCells) - cellId = pointCells.GetId(0) - cellEntityId = surfaceCellEntityIdsArray.GetValue(cellId) - cellEntityIdsArray.SetValue(i, cellEntityId) - - meshPoint = refSystem.GetPoint(i) - for element in network.elements: - if element.IsAnOutlet(): - networkPoint = element.GetOutPointsx1()[0] - if element.IsAnInlet(): - networkPoint = element.GetInPointsx0()[0] - if vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) < distancePoints: - distancePoints = vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) - closest = element.GetId() - if network.elements[closest].IsAnInlet(): - verbose_print('I am the inlet, Sup?') - verbose_print(network.elements[closest].GetInPointsx0()[0]) - ids.insert(0, [cellEntityId, mean_inflow_rate]) - else: - beta = network.elements[closest].GetBeta() - ids.append([cellEntityId, beta]) - verbose_print(beta) - verbose_print(network.elements[closest].GetOutPointsx1()[0]) - verbose_print('CellEntityId: %d\n' % cellEntityId) - verbose_print('meshPoint: %f, %f, %f\n' % (meshPoint[0], meshPoint[1], meshPoint[2])) - verbose_print(ids) - - # Store information for the solver. - idFileLine = case_name + ' ' + repr(ids[0][0] - 1) + ' ' - areaRatioLine = case_name + ' ' - for k in range(1, refSystem.GetNumberOfPoints() - 1): - idFileLine += repr(ids[k][0] - 1) + ',' - areaRatioLine += repr(ids[k][1]) + ',' - idFileLine += repr(ids[-1][0] - 1) + ' ' + repr(ids[0][1]) - areaRatioLine += repr(ids[-1][1]) - if atrium_present: - info = {"inlet_area": Total_inlet_area, - "idFileLine": str(idFileLine), - "areaRatioLine": str(areaRatioLine) - } else: - info = {"inlet_area": parameters["inlet_area"], - "idFileLine": str(idFileLine), - "areaRatioLine": str(areaRatioLine) - } - write_parameters(info, path.join(dir_path, case_name)) + mean_inflow_rate = 0.27 * parameters["inlet_area"] + + find_boundaries(case_name, dir_path, mean_inflow_rate, network, polyDataVolMesh, verbose_print) # Display the flow split at the outlets, inlet flow rate, and probes. if viz: diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 271458d8..bc8e7e4b 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -540,3 +540,70 @@ def compute_centers_for_meshing(polyData, atrium_present, case_path=None, test_c center_ = [item for sublist in center for item in sublist] # centers of the inlets return center_, boundary_center + + +def find_boundaries(case_name, dir_path, mean_inflow_rate, network, polyDataVolMesh, verbose_print): + # Extract the surface mesh of the wall + wallMesh = vtk_compute_threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) + boundaryReferenceSystems = vmtkscripts.vmtkBoundaryReferenceSystems() + boundaryReferenceSystems.Surface = wallMesh + boundaryReferenceSystems.Execute() + refSystem = boundaryReferenceSystems.ReferenceSystems + cellEntityIdsArray = get_vtk_array('CellEntityIds', 0, refSystem.GetNumberOfPoints()) + refSystem.GetPointData().AddArray(cellEntityIdsArray) + + # Extract the surface mesh of the end caps + boundarySurface = vtk_compute_threshold(polyDataVolMesh, "CellEntityIds", upper=1.5, threshold_type="upper") + pointCells = vtk.vtkIdList() + surfaceCellEntityIdsArray = vtk.vtkIntArray() + surfaceCellEntityIdsArray.DeepCopy(boundarySurface.GetCellData().GetArray('CellEntityIds')) + + # Find the corresponding couple (mesh outlet ID, network ID). + ids = [] + for i in range(refSystem.GetNumberOfPoints()): + distancePoints = 10000000 + pointId = boundarySurface.FindPoint(refSystem.GetPoint(i)) + boundarySurface.GetPointCells(pointId, pointCells) + cellId = pointCells.GetId(0) + cellEntityId = surfaceCellEntityIdsArray.GetValue(cellId) + cellEntityIdsArray.SetValue(i, cellEntityId) + + meshPoint = refSystem.GetPoint(i) + for element in network.elements: + if element.IsAnOutlet(): + networkPoint = element.GetOutPointsx1()[0] + if element.IsAnInlet(): + networkPoint = element.GetInPointsx0()[0] + if vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) < distancePoints: + distancePoints = vtk.vtkMath.Distance2BetweenPoints(meshPoint, networkPoint) + closest = element.GetId() + if network.elements[closest].IsAnInlet(): + verbose_print('I am the inlet, Sup?') + verbose_print(network.elements[closest].GetInPointsx0()[0]) + ids.insert(0, [cellEntityId, mean_inflow_rate]) + else: + beta = network.elements[closest].GetBeta() + ids.append([cellEntityId, beta]) + verbose_print(beta) + verbose_print(network.elements[closest].GetOutPointsx1()[0]) + verbose_print('CellEntityId: %d\n' % cellEntityId) + verbose_print('meshPoint: %f, %f, %f\n' % (meshPoint[0], meshPoint[1], meshPoint[2])) + verbose_print(ids) + + # Store information for the solver. + inlet_id = [ids[0][0]] + outlet_ids = [] + area_ratios = [] + for k in range(1, refSystem.GetNumberOfPoints()): + outlet_ids.append(ids[k][0]) + area_ratios.append(ids[k][1]) + + info = { + "inlet_id": inlet_id, + "outlet_ids": outlet_ids, + "mean_flow_rate": mean_inflow_rate, + "area_ratio": area_ratios + } + info_path = path.join(dir_path, case_name) + + write_parameters(info, info_path) From 6ce14f62701154b20d097ece547dcc48223ab05f Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 15:30:36 +0200 Subject: [PATCH 27/76] Update Artery.py --- Artery.py | 241 +++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 168 insertions(+), 73 deletions(-) diff --git a/Artery.py b/Artery.py index 0d9fdbb3..5409c334 100644 --- a/Artery.py +++ b/Artery.py @@ -1,12 +1,27 @@ import json import pickle -from os import path, makedirs +from os import makedirs +from pprint import pprint import numpy as np -from Womersley import make_womersley_bcs, compute_boundary_geometry_acrn from fenicstools import Probes from oasis.problems.NSfracStep import * +from Womersley import make_womersley_bcs, compute_boundary_geometry_acrn + +""" +Problem file for running CFD simulation in arterial models consisting of one inlet, and two or more outlets. +A Womersley velocity profile is applied at the inlet, and a flow split pressure condition is applied at the outlets, +following [1]. Flow rate for the inlet condition, and flow split values for the outlets are computed from the +pre-processing script automatedPreProcessing.py. The simulation is run for two cycles (adjustable), but only the +results/solutions from the second cycle are stored to avoid non-physiological effects from the first cycle. +One cardiac cycle is set to 0.951 s from [2], and scaled by a factor of 1000, hence all parameters are in [mm] or [ms]. + +[1] Gin, Ron, Anthony G. Straatman, and David A. Steinman. "A dual-pressure boundary condition for use in simulations + of bifurcating conduits." J. Biomech. Eng. 124.5 (2002): 617-619. +[2] Hoi, Yiemeng, et al. "Characterization of volumetric flow rate waveforms at the carotid bifurcations of older + adults." Physiological measurement 31.3 (2010): 291. +""" set_log_level(50) @@ -14,28 +29,31 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_namespace): if "restart_folder" in commandline_kwargs.keys(): restart_folder = commandline_kwargs["restart_folder"] - f = open(path.join(restart_folder, 'params.dat'), 'r') + f = open(path.join(restart_folder, 'params.dat'), 'rb') NS_parameters.update(pickle.load(f)) NS_parameters['restart_folder'] = restart_folder else: - # Override some problem specific parameters - # parameters are in mm and ms + # Parameters are in mm and ms + cardiac_cycle = 951 + number_of_cycles = 2 + NS_parameters.update( # Fluid parameters - nu=3.3018e-3, # Viscosity + nu=3.3018e-3, # Kinematic viscosity # Geometry parameters id_in=[], # Inlet boundary ID id_out=[], # Outlet boundary IDs area_ratio=[], + area_inlet=[], # Simulation parameters - T=951 * 2, # Run simulation for 2 cardiac cycles - dt=0.0951, # 10 000 steps per cycle - no_of_cycles=2, - dump_stats=100, - store_data=5, - store_data_tstep=10000, # Start storing data at 2nd cycle - save_step=200, - checkpoint=500, + cardiac_cycle=cardiac_cycle, # Cardiac cycle [ms] + T=cardiac_cycle * number_of_cycles, # Simulation end time [ms] + dt=0.0951, # Time step size [ms] + save_probe_frequency=100, # Save frequency for sampling velocity & pressure at probes along the centerline + save_solution_frequency=5, # Save frequency for post processing + save_solution_after_cycle=1, # Store solution after 1 cardiac cycle + # Oasis specific parameters + checkpoint=500, # Checkpoint frequency print_intermediate_info=100, folder="results_artery", mesh_path=commandline_kwargs["mesh_path"], @@ -49,37 +67,93 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n case_name = mesh_file.split(".")[0] NS_parameters["folder"] = path.join(NS_parameters["folder"], case_name) + if MPI.rank(MPI.comm_world) == 0: + print("=== Starting simulation for case: {} ===".format(case_name)) + print("Running with the following parameters:") + pprint(NS_parameters) -def mesh(mesh_path, **NS_namespace): - # Read mesh - return Mesh(mesh_path) +def mesh(mesh_path, **NS_namespace): + # Read mesh and print mesh information + mesh = Mesh(mesh_path) + print_mesh_information(mesh) + + return mesh + + +def print_mesh_information(mesh): + comm = MPI.comm_world + local_xmin = mesh.coordinates()[:, 0].min() + local_xmax = mesh.coordinates()[:, 0].max() + local_ymin = mesh.coordinates()[:, 1].min() + local_ymax = mesh.coordinates()[:, 1].max() + local_zmin = mesh.coordinates()[:, 2].min() + local_zmax = mesh.coordinates()[:, 2].max() + xmin = comm.gather(local_xmin, 0) + xmax = comm.gather(local_xmax, 0) + ymin = comm.gather(local_ymin, 0) + ymax = comm.gather(local_ymax, 0) + zmin = comm.gather(local_zmin, 0) + zmax = comm.gather(local_zmax, 0) + + local_num_cells = mesh.num_cells() + local_num_edges = mesh.num_edges() + local_num_faces = mesh.num_faces() + local_num_facets = mesh.num_facets() + local_num_vertices = mesh.num_vertices() + num_cells = comm.gather(local_num_cells, 0) + num_edges = comm.gather(local_num_edges, 0) + num_faces = comm.gather(local_num_faces, 0) + num_facets = comm.gather(local_num_facets, 0) + num_vertices = comm.gather(local_num_vertices, 0) + volume = assemble(Constant(1) * dx(mesh)) -def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, id_out, pressure_degree, **NS_namespace): + if MPI.rank(MPI.comm_world) == 0: + print("=== Mesh information ===") + print("X range: {} to {} (delta: {:.4f})".format(min(xmin), max(xmax), max(xmax) - min(xmin))) + print("Y range: {} to {} (delta: {:.4f})".format(min(ymin), max(ymax), max(ymax) - min(ymin))) + print("Z range: {} to {} (delta: {:.4f})".format(min(zmin), max(zmax), max(zmax) - min(zmin))) + print("Number of cells: {}".format(sum(num_cells))) + print("Number of cells per processor: {}".format(int(np.mean(num_cells)))) + print("Number of edges: {}".format(sum(num_edges))) + print("Number of faces: {}".format(sum(num_faces))) + print("Number of facets: {}".format(sum(num_facets))) + print("Number of vertices: {}".format(sum(num_vertices))) + print("Volume: {:.4f}".format(volume)) + print("Number of cells per volume: {:.4f}".format(sum(num_cells) / volume)) + + +def create_bcs(t, NS_expressions, V, Q, area_ratio, area_inlet, mesh, mesh_path, nu, id_in, id_out, pressure_degree, + **NS_namespace): # Mesh function boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) + boundary.set_values(boundary.array() + 1) # Read case parameters - info_path = mesh_path.split(".")[0] + ".json" - with open(info_path) as f: + info = mesh_path.split(".")[0] + "_info.json" + with open(info) as f: info = json.load(f) - # Extract flow split ratios and inlet/outlet IDs - id_info = info['idFileLine'].split() - id_in.append(int(id_info[1])) - id_out[:] = [int(p) for p in id_info[2].split(",")] - Q_mean = float(id_info[3]) - area_ratio[:] = [float(p) for p in info['areaRatioLine'].split()[-1].split(",")] - - # Womersley boundary condition at inlet - t_values, Q_ = np.load(path.join(path.dirname(path.abspath(__file__)), "ICA_values")) - Q_values = Q_mean * Q_ - t_values *= 1000 - tmp_a, tmp_c, tmp_r, tmp_n = compute_boundary_geometry_acrn(mesh, id_in[0], boundary) - inlet = make_womersley_bcs(t_values, Q_values, mesh, nu, tmp_a, tmp_c, tmp_r, tmp_n, V.ufl_element()) + id_wall = 1 + id_in[:] = info['inlet_id'] + id_out[:] = info['outlet_ids'] + Q_mean = info['mean_flow_rate'] + + area_ratio[:] = info['area_ratio'] + area_inlet.append(info['inlet_area']) + + # Load normalized time and flow rate values + t_values, Q_ = np.loadtxt(path.join(path.dirname(path.abspath(__file__)), "ICA_values")).T + Q_values = Q_mean * Q_ # Specific flow rate * Flow wave form + t_values *= 1000 # Scale to [ms] + tmp_area, tmp_center, tmp_radius, tmp_normal = compute_boundary_geometry_acrn(mesh, id_in[0], boundary) + + # Create Womersley boundary condition at inlet + inlet = make_womersley_bcs(t_values, Q_values, mesh, nu, tmp_area, tmp_center, tmp_radius, tmp_normal, + V.ufl_element()) NS_expressions["inlet"] = inlet - # Set start time equal to t_0 + # Initialize inlet expressions with initial time for uc in inlet: uc.set_t(t) @@ -90,20 +164,22 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, area_out.append(assemble(Constant(1.0, name="one") * dsi)) bc_p = [] - print("Initial pressure:") + if MPI.rank(MPI.comm_world) == 0: + print("=== Initial pressure and area fraction ===") for i, ID in enumerate(id_out): p_initial = area_out[i] / sum(area_out) outflow = Expression("p", p=p_initial, degree=pressure_degree) bc = DirichletBC(Q, outflow, boundary, ID) bc_p.append(bc) NS_expressions[ID] = outflow - print(ID, p_initial) + if MPI.rank(MPI.comm_world) == 0: + print(("Boundary ID={:d}, pressure: {:0.6f}, area fraction: {:0.4f}".format(ID, p_initial, area_ratio[i]))) # No slip condition at wall wall = Constant(0.0) # Create Boundary conditions for the velocity - bc_wall = DirichletBC(V, wall, boundary, 0) + bc_wall = DirichletBC(V, wall, boundary, id_wall) bc_inlet = [DirichletBC(V, inlet[i], boundary, id_in[0]) for i in range(3)] # Return boundary conditions in dictionary @@ -115,22 +191,26 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, def get_file_paths(folder): # Create folder where data and solutions (velocity, mesh, pressure) is stored - common_path = path.join(folder, "VTK") + common_path = path.join(folder, "Solutions") if MPI.rank(MPI.comm_world) == 0: if not path.exists(common_path): makedirs(common_path) file_p = path.join(common_path, "p.h5") - file_u = [path.join(common_path, "u{}.h5".format(i)) for i in range(3)] + file_u = path.join(common_path, "u.h5") file_mesh = path.join(common_path, "mesh.h5") files = {"u": file_u, "p": file_p, "mesh": file_mesh} return files -def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, **NS_namespace): +def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, velocity_degree, cardiac_cycle, + save_solution_after_cycle, dt, **NS_namespace): + # Mesh function + boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) + boundary.set_values(boundary.array() + 1) + # Create point for evaluation - boundary = MeshFunction("size_t", mesh, 2, mesh.domains()) n = FacetNormal(mesh) eval_dict = {} rel_path = mesh_path.split(".")[0] + "_probe_point" @@ -152,43 +232,57 @@ def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, **NS_namesp else: files = NS_namespace["files"] - # Save mesh as HDF5 file + # Save mesh as HDF5 file for post processing with HDF5File(MPI.comm_world, files["mesh"], "w") as mesh_file: mesh_file.write(mesh, "mesh") - return dict(eval_dict=eval_dict, boundary=boundary, n=n) + # Create vector function for storing velocity + Vv = VectorFunctionSpace(mesh, "CG", velocity_degree) + U = Function(Vv) + # Tstep when solutions for post processing should start being saved + save_solution_at_tstep = int(cardiac_cycle * save_solution_after_cycle / dt) -def temporal_hook(u_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, id_in, id_out, boundary, n, store_data, - NS_parameters, NS_expressions, area_ratio, t, store_data_tstep, **NS_namespace): - # Update boundary condition + return dict(eval_dict=eval_dict, n=n, U=U, save_solution_at_tstep=save_solution_at_tstep, boundary=boundary) + + +def temporal_hook(u_, p_, mesh, tstep, save_probe_frequency, eval_dict, newfolder, id_in, id_out, boundary, n, + save_solution_frequency, NS_parameters, NS_expressions, area_ratio, t, save_solution_at_tstep, + U, area_inlet, nu, **NS_namespace): + # Update boundary condition to current time for uc in NS_expressions["inlet"]: uc.set_t(t) # Compute flux and update pressure condition - if tstep > 2 and tstep % 1 == 0: + if tstep > 2: Q_ideals, Q_in, Q_outs = update_pressure_condition(NS_expressions, area_ratio, boundary, id_in, id_out, mesh, n, tstep, u_) + # Compute flow rates and updated pressure at outlets, and mean velocity and Reynolds number at inlet if MPI.rank(MPI.comm_world) == 0 and tstep % 10 == 0: - print("=" * 10, tstep, "=" * 10) - print("Sum of Q_out = {:0.4f} Q_in = {:0.4f}".format(sum(Q_outs), Q_in)) - for i, out_id in enumerate(id_out): - print(("({:d}) New pressure {:0.4f}").format(out_id, NS_expressions[out_id].p)) + U_mean = Q_in / area_inlet[0] + diam_inlet = np.sqrt(4 * area_inlet[0] / np.pi) + Re = U_mean * diam_inlet / nu + print("=" * 10, "Time step " + str(tstep), "=" * 10) + print("Sum of Q_out = {:0.4f}, Q_in = {:0.4f}, mean velocity (inlet): {:0.4f}, Reynolds number (inlet): {:0.4f}" + .format(sum(Q_outs), Q_in, U_mean, Re)) for i, out_id in enumerate(id_out): - print(("({:d}) area ratio {:0.4f}, ideal: {:0.4f} actual:" + - " {:0.4f}").format(out_id, area_ratio[i], Q_ideals[i], Q_outs[i])) + print(("For outlet with boundary ID={:d}: target flow rate: {:0.4f} mL/s, " + + "computed flow rate: {:0.4f} mL/s, pressure updated to: {:0.4f}") + .format(out_id, Q_ideals[i], Q_outs[i], NS_expressions[out_id].p)) print() - # Sample velocity in points + # Sample velocity and pressure in points/probes eval_dict["centerline_u_x_probes"](u_[0]) eval_dict["centerline_u_y_probes"](u_[1]) eval_dict["centerline_u_z_probes"](u_[2]) eval_dict["centerline_p_probes"](p_) - # Store sampled velocity - if tstep % dump_stats == 0: - filepath = path.join(newfolder, "Stats") + # Store sampled velocity and pressure + if tstep % save_probe_frequency == 0: + # Save variables along the centerline for CFD simulation + # diagnostics and light-weight post processing + filepath = path.join(newfolder, "Probes") if MPI.rank(MPI.comm_world) == 0: if not path.exists(filepath): makedirs(filepath) @@ -212,39 +306,40 @@ def temporal_hook(u_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, id_in, eval_dict["centerline_u_z_probes"].clear() eval_dict["centerline_p_probes"].clear() - # Save velocity and pressure - if tstep % store_data == 0 and tstep >= store_data_tstep: - # Name functions - u_[0].rename("u0", "velocity-x") - u_[1].rename("u1", "velocity-y") - u_[2].rename("u2", "velocity-z") - p_.rename("p", "pressure") + # Save velocity and pressure for post processing + if tstep % save_solution_frequency == 0 and tstep >= save_solution_at_tstep: + # Assign velocity components to vector solution + assign(U.sub(0), u_[0]) + assign(U.sub(1), u_[1]) + assign(U.sub(2), u_[2]) # Get save paths files = NS_parameters['files'] - file_mode = "w" if tstep == store_data_tstep else "a" + file_mode = "w" if tstep == save_solution_at_tstep else "a" p_path = files['p'] + u_path = files['u'] - # Save + # Save pressure viz_p = HDF5File(MPI.comm_world, p_path, file_mode=file_mode) viz_p.write(p_, "/pressure", tstep) viz_p.close() - for i in range(3): - u_path = files['u'][i] - viz_u = HDF5File(MPI.comm_world, u_path, file_mode=file_mode) - viz_u.write(u_[i], "/velocity", tstep) - viz_u.close() + # Save velocity + viz_u = HDF5File(MPI.comm_world, u_path, file_mode=file_mode) + viz_u.write(U, "/velocity", tstep) + viz_u.close() def beta(err, p): """ Adjusted choice of beta from - Gin and Steinman et al., A Dual-Pressure Boundary Condition doi:10.1115/1.1504446 + Gin and Steinman et al., A Dual-Pressure Boundary Condition doi:10.1115/1.1504446 Ramped up to desired value if flow rate error (err) increases + Args: err (float): Flow split error p (float): Pressure value + Returns: beta (float): Variable factor in flow split method """ @@ -305,4 +400,4 @@ def update_pressure_condition(NS_expressions, area_ratio, boundary, id_in, id_ou else: NS_expressions[out_id].p = p_old * beta(R_err, p_old) * M_err ** E - return Q_ideals, Q_in, Q_outs \ No newline at end of file + return Q_ideals, Q_in, Q_outs From 5914df10c01047d203f4423a8ff7bafb8952e645 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 15:35:24 +0200 Subject: [PATCH 28/76] update travis --- .travis.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 576def23..24588d96 100644 --- a/.travis.yml +++ b/.travis.yml @@ -25,12 +25,13 @@ install: - conda config --set restore_free_channel true - conda config --set always_yes yes --set changeps1 no - conda config --add channels vmtk + - conda config --add channels morphman # Set up environment - - conda create -n vmtk_env vmtk pytest itk vtk llvm=3.3 paramiko + - conda create -n morphmanEnv morphman pytest llvm=3.3 paramiko # Activate environment - - source activate vmtk_env + - source activate morphmanEnv # Useful for debugging any issues with conda - conda info -a From afef39850353f98bd0f0cdab375a75f068a0eab3 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 15:38:14 +0200 Subject: [PATCH 29/76] update travis --- .travis.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 24588d96..cb607c25 100644 --- a/.travis.yml +++ b/.travis.yml @@ -37,9 +37,9 @@ install: - conda info -a # / -> // in vmtkcenterlines.py and vmtksurfacecurvature.py - - sed -i -e 's/len(self.SourcePoints)\/3/len\(self.SourcePoints\)\/\/3/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/vmtk_env/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py + - sed -i -e 's/len(self.SourcePoints)\/3/len\(self.SourcePoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py + - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py + - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py # Dependencies for code coverage - pip install pytest-cov codecov From 9199a8d868b6a1ee5785cbf9bcfcff03a8833383 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 15:51:04 +0200 Subject: [PATCH 30/76] Cleanup --- automatedPreProcessing/automatedPreProcessing.py | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 0a65a4ad..6dd47879 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -274,7 +274,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin source = inlet target = outlets centerlines, _, _ = compute_centerlines(source, target, file_name_flow_centerlines, capped_surface, - resampling=0.5) + resampling=0.1) else: centerlines = read_polydata(file_name_flow_centerlines) @@ -286,18 +286,14 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin elif meshing_method == "curvature": if not path.isfile(file_name_distance_to_sphere_curv): - distance_to_sphere = dist_sphere_curv(surface, centerlines, - sac_center, misr_max, - file_name_distance_to_sphere_curv, - coarsening_factor) + distance_to_sphere = dist_sphere_curv(surface, centerlines, sac_center, misr_max, + file_name_distance_to_sphere_curv, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_curv) elif meshing_method == "diameter": if not path.isfile(file_name_distance_to_sphere_diam): - distance_to_sphere = dist_sphere_diam(surface, centerlines, - sac_center, misr_max, - file_name_distance_to_sphere_diam, - coarsening_factor) + distance_to_sphere = dist_sphere_diam(surface, centerlines, sac_center, misr_max, + file_name_distance_to_sphere_diam, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_diam) @@ -365,7 +361,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin Total_inlet_area = 0 num_inlets = len(inlet) // 3 for i in range(num_inlets): - Total_inlet_area += parameters["inlet%s_area" % (i)] + Total_inlet_area += parameters["inlet%s_area" % i] mean_inflow_rate = 0.27 * Total_inlet_area else: mean_inflow_rate = 0.27 * parameters["inlet_area"] From 394da7091f2ac5cfa5f92d8e92c2638bb4dd4d30 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 17:22:11 +0200 Subject: [PATCH 31/76] Refeactor pre processing --- automatedPreProcessing/automatedPreProcessing.py | 3 --- automatedPreProcessing/common.py | 3 ++- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 6dd47879..99e6c41c 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -141,9 +141,6 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin else: sac_centerline.append(read_polydata(file_name_sac_centerlines.format(i))) - else: - num_anu = 0 - # Get 'center' and 'radius' of the aneurysm(s) sac_center = [] misr_max = [] diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index bc8e7e4b..fcb301aa 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -386,7 +386,8 @@ def compute_distance_to_sphere(surface, centerSphere, radiusSphere=0.0, N = surface.GetNumberOfPoints() number, names = get_number_of_arrays(surface) add = False - if distanceToSpheresArrayName not in names: add = True + if distanceToSpheresArrayName not in names: + add = True # Get array if add: From 17f8aac2de97712990818550733be1a81ee0c0ad Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 18:13:00 +0200 Subject: [PATCH 32/76] Generalized refinement of region --- README.md | 6 +- .../automatedPreProcessing.py | 70 ++++++++++--------- automatedPreProcessing/common.py | 48 ++++++++++--- test/test_pre_processing.py | 2 +- 4 files changed, 78 insertions(+), 48 deletions(-) diff --git a/README.md b/README.md index 1197f6c6..c48d403e 100644 --- a/README.md +++ b/README.md @@ -19,9 +19,9 @@ These scripts was written by - Henrik A. Kjeldsberg ## Installation -You can choose how to install the dependencies, but the fastest way to get started is to first install anaconda or miniconda on your computer. Then create two environments, one for `vmtk/vtk` and one for `fenics` by executing the following in a terminal: +You can choose how to install the dependencies, but the fastest way to get started is to first install anaconda or miniconda on your computer. Then create two environments, one for `vmtk/vtk/morphMan` and one for `fenics` by executing the following in a terminal: ``` -conda create -n vtk -c vmtk python=3.6 itk vtk vmtk paramiko +conda create -n vtk -c vmtk -c morphman morphman paramiko conda create -n fenics -c conda-forge fenics ``` @@ -60,7 +60,7 @@ First, use the automatedPreProcessing to create a mesh, boundary conditions, and ``` conda deactivate && conda activate vtk -python automatedPreProcessing/automatedPreProcessing.py -m diameter -i test/Case_test_71/Case_test_71.vtp --aneurysm False -c 1.3 +python automatedPreProcessing/automatedPreProcessing.py -m diameter -i test/Case_test_71/Case_test_71.vtp -c 1.3 ``` Then run a CFD simulation for two cycles with 10 000 time steps per cycle and default parameters with Oasis: diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 99e6c41c..c87faa58 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -13,7 +13,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, meshing_method, - aneurysm_present, atrium_present, create_flow_extensions, viz, config_path, coarsening_factor, + refine_region, atrium_present, create_flow_extensions, viz, config_path, coarsening_factor, flow_extension_length, edge_length, compress_mesh=True): """ Automatically generate mesh of surface model in .vtu and .xml format, including prescribed @@ -27,7 +27,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin smoothing_method (str): Method for surface smoothing smoothing_factor (float): Smoothing parameter meshing_method (str): Method for meshing - aneurysm_present (bool): Determines if aneurysm is present + regine_region (bool): Refines selected region of input if True atrium_present (bool): Determines whether this is an atrium case create_flow_extensions (bool): Adds flow extensions to mesh if True viz (bool): Visualize resulting surface model with flow rates @@ -42,9 +42,10 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Naming conventions file_name_centerlines = path.join(dir_path, case_name + "_centerlines.vtp") - file_name_aneurysm_centerlines = path.join(dir_path, case_name + "_aneurysm_centerline.vtp") - file_name_sac_centerlines = path.join(dir_path, case_name + "_sac_centerline_{}.vtp") + file_name_refine_region_centerlines = path.join(dir_path, case_name + "_refine_region_centerline.vtp") + file_name_region_centerlines = path.join(dir_path, case_name + "_sac_centerline_{}.vtp") file_name_distance_to_sphere_diam = path.join(dir_path, case_name + "_distance_to_sphere_diam.vtp") + file_name_distance_to_sphere_const = path.join(dir_path, case_name + "_distance_to_sphere_const.vtp") file_name_distance_to_sphere_curv = path.join(dir_path, case_name + "_distance_to_sphere_curv.vtp") file_name_probe_points = path.join(dir_path, case_name + "_probe_point") file_name_voronoi = path.join(dir_path, case_name + "_voronoi.vtp") @@ -109,19 +110,23 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin end_point=0) tol = get_centerline_tolerance(centerlines) - if aneurysm_present: - aneurysms = get_aneurysm_dome(capped_surface, path.join(dir_path, case_name)) - centerlineAnu, _, _ = compute_centerlines(source, aneurysms, file_name_aneurysm_centerlines, capped_surface, + # Get 'center' and 'radius' of the regions(s) + region_center = [] + misr_max = [] + + if refine_region: + regions = get_regions_to_refine(capped_surface, path.join(dir_path, case_name)) + centerlineAnu, _, _ = compute_centerlines(source, regions, file_name_refine_region_centerlines, capped_surface, resampling=0.1) - # Extract the aneurysm centerline - sac_centerline = [] + # Extract the region centerline + refine_region_centerline = [] info = get_parameters(path.join(dir_path, case_name)) - num_anu = info["number_of_aneurysms"] + num_anu = info["number_of_regions"] # Compute mean distance between points for i in range(num_anu): - if not path.isfile(file_name_sac_centerlines.format(i)): + if not path.isfile(file_name_region_centerlines.format(i)): line = extract_single_line(centerlineAnu, i) locator = get_vtk_point_locator(centerlines) for j in range(line.GetNumberOfPoints() - 1, 0, -1): @@ -133,25 +138,20 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin break tmp = extract_single_line(line, 0, start_id=j) - write_polydata(tmp, file_name_sac_centerlines.format(i)) + write_polydata(tmp, file_name_region_centerlines.format(i)) # List of VtkPolyData sac(s) centerline - sac_centerline.append(tmp) + refine_region_centerline.append(tmp) else: - sac_centerline.append(read_polydata(file_name_sac_centerlines.format(i))) - - # Get 'center' and 'radius' of the aneurysm(s) - sac_center = [] - misr_max = [] + refine_region_centerline.append(read_polydata(file_name_region_centerlines.format(i))) - if aneurysm_present: # Merge the sac centerline - sac_centerlines = vtk_merge_polydata(sac_centerline) + region_centerlines = vtk_merge_polydata(refine_region_centerline) - for sac in sac_centerline: - sac_center.append(sac.GetPoints().GetPoint(sac.GetNumberOfPoints() // 2)) - tmp_misr = get_point_data_array(radiusArrayName, sac) + for region in refine_region_centerline: + region_center.append(region.GetPoints().GetPoint(region.GetNumberOfPoints() // 2)) + tmp_misr = get_point_data_array(radiusArrayName, region) misr_max.append(tmp_misr.max()) # Smooth surface @@ -167,8 +167,8 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Get smooth Voronoi diagram if not path.isfile(file_name_voronoi_smooth): - if aneurysm_present: - smooth_voronoi = smooth_voronoi_diagram(voronoi, centerlines, smoothing_factor, sac_centerlines) + if refine_region: + smooth_voronoi = smooth_voronoi_diagram(voronoi, centerlines, smoothing_factor, region_centerlines) else: smooth_voronoi = smooth_voronoi_diagram(voronoi, centerlines, smoothing_factor) @@ -279,17 +279,18 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Choose input for the mesh print("--- Computing distance to sphere\n") if meshing_method == "constant": - distance_to_sphere = surface + distance_to_sphere = dist_sphere_constant(surface, centerlines, region_center, misr_max, + file_name_distance_to_sphere_const, edge_length) elif meshing_method == "curvature": if not path.isfile(file_name_distance_to_sphere_curv): - distance_to_sphere = dist_sphere_curv(surface, centerlines, sac_center, misr_max, + distance_to_sphere = dist_sphere_curv(surface, centerlines, region_center, misr_max, file_name_distance_to_sphere_curv, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_curv) elif meshing_method == "diameter": if not path.isfile(file_name_distance_to_sphere_diam): - distance_to_sphere = dist_sphere_diam(surface, centerlines, sac_center, misr_max, + distance_to_sphere = dist_sphere_diam(surface, centerlines, region_center, misr_max, file_name_distance_to_sphere_diam, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_diam) @@ -335,7 +336,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if not path.isfile(file_name_probe_points): # Get the list of coordinates for the probe points along the network centerline. listProbePoints = ImportData.GetListProbePoints(centerlinesBranches, network, verbose_print) - listProbePoints += sac_center + listProbePoints += region_center print("--- Saving probes points in: %s\n" % file_name_probe_points) probe_points = np.array(listProbePoints) @@ -441,7 +442,7 @@ def read_command_line(): choices=["voronoi", "no_smooth", "laplace", "taubin"], help="Smoothing method, for now only Voronoi smoothing is available." + " For Voronoi smoothing you can also control smoothingFactor" + - " (default = 0.25) and smoothingAneurysm (default = False).") + " (default = 0.25).") parser.add_argument('-c', '--coarseningFactor', type=float, @@ -470,11 +471,12 @@ def read_command_line(): type=float, help="Characteristic edge length used for meshing.") - parser.add_argument('-a', '--aneurysm', - dest="aneurysmPresent", + parser.add_argument('-r', '--refine-region', + dest="refineRegion", type=str2bool, default=False, - help="Determine weather or not the model has a aneurysm. Default is False.") + help="Determine weather or not to refine a specific region of " + + "the input model. Default is False.") parser.add_argument('-at', '--atrium', dest="atriumPresent", @@ -524,7 +526,7 @@ def verbose_print(*args): return dict(filename_model=args.fileNameModel, verbose_print=verbose_print, smoothing_method=args.smoothingMethod, smoothing_factor=args.smoothingFactor, meshing_method=args.meshingMethod, - aneurysm_present=args.aneurysmPresent, atrium_present=args.atriumPresent, + refine_region=args.refineRegion, atrium_present=args.atriumPresent, create_flow_extensions=args.flowExtension, viz=args.viz, config_path=args.config, coarsening_factor=args.coarseningFactor, flow_extension_length=args.flowExtLen, edge_length=args.edgeLength) diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index fcb301aa..c3771a47 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -33,26 +33,26 @@ version = vtk.vtkVersion().GetVTKMajorVersion() -def get_aneurysm_dome(surface, dir_path): +def get_regions_to_refine(surface, dir_path): # Check if info exists if not path.isfile(path.join(dir_path, dir_path + ".txt")): - provide_aneurysm_points(surface, dir_path) + provide_region_points(surface, dir_path) # Open info parameters = get_parameters(dir_path) dome = [] for key, value in parameters.items(): - if key.startswith("aneurysm_"): + if key.startswith("region_"): dome.append(value) if dome == []: - dome = provide_aneurysm_points(surface, dir_path) + dome = provide_region_points(surface, dir_path) # Flatten list return [item for sublist in dome for item in sublist] -def provide_aneurysm_points(surface, dir_path=None): +def provide_region_points(surface, dir_path=None): """ Get relevant aneurysm points from user selected points on a input surface. @@ -72,15 +72,15 @@ def provide_aneurysm_points(surface, dir_path=None): SeedSelector.SetSurface(triangulated_surface) SeedSelector.Execute() - aneurysmSeedIds = SeedSelector.GetTargetSeedIds() + regionSeedIds = SeedSelector.GetTargetSeedIds() get_point = surface.GetPoints().GetPoint - points = [list(get_point(aneurysmSeedIds.GetId(i))) for i in range(aneurysmSeedIds.GetNumberOfIds())] + points = [list(get_point(regionSeedIds.GetId(i))) for i in range(regionSeedIds.GetNumberOfIds())] if dir_path is not None: - info = {"number_of_aneurysms": len(points)} + info = {"number_of_regions": len(points)} for i in range(len(points)): - info["aneurysm_%d" % i] = points[i] + info["region_%d" % i] = points[i] write_parameters(info, dir_path) return points @@ -324,6 +324,34 @@ def dist_sphere_curv(surface, centerlines, sac_center, misr_max, fileName, facto return distance_to_sphere +def dist_sphere_constant(surface, centerlines, sac_center, misr_max, fileName, edge_length): + # Constant meshing method with possible refined area. + # --- Compute the distanceToCenterlines + distTocenterlines = vmtkscripts.vmtkDistanceToCenterlines() + distTocenterlines.Surface = surface + distTocenterlines.Centerlines = centerlines + distTocenterlines.Execute() + distance_to_sphere = distTocenterlines.Surface + + # Reduce element size in aneurysm + for i in range(len(sac_center)): + distance_to_sphere = compute_distance_to_sphere(distance_to_sphere, + sac_center[i], + maxDistance=100, + distanceScale=0.2 / (misr_max[i] * 2.)) + + element_size = edge_length + np.zeros((surface.GetNumberOfPoints(), 1)) + if len(sac_center) != 0: + distance_to_spheres_array = get_point_data_array("DistanceToSpheres", distance_to_sphere) + element_size = np.minimum(element_size, distance_to_spheres_array) + + vtk_array = create_vtk_array(element_size, "Size") + distance_to_sphere.GetPointData().AddArray(vtk_array) + write_polydata(distance_to_sphere, fileName) + + return distance_to_sphere + + def dist_sphere_diam(surface, centerlines, sac_center, misr_max, fileName, factor): # Meshing method following Owais way. # --- Compute the distanceToCenterlines @@ -426,7 +454,7 @@ def generate_mesh(surface, edge_length=None): # Compute the mesh. meshGenerator = vmtkscripts.vmtkMeshGenerator() meshGenerator.Surface = surface - if edge_length is not None: + if edge_length is None: meshGenerator.ElementSizeMode = "edgelength" # Constant size mesh meshGenerator.TargetEdgeLength = edge_length else: diff --git a/test/test_pre_processing.py b/test/test_pre_processing.py index 7047e7f4..0ca8b298 100644 --- a/test/test_pre_processing.py +++ b/test/test_pre_processing.py @@ -13,7 +13,7 @@ def test_pre_processing(): common_input = read_command_line() common_input.update(dict(meshing_method="diameter", filename_model=model_path, - aneurysm_present=False, + refine_region=False, coarsening_factor=1.3, viz=False, compress_mesh=False)) From e81c1de10d8db5ec2965d39d5cfd12e69937f52c Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 18:23:52 +0200 Subject: [PATCH 33/76] Remove edge length param --- automatedPreProcessing/automatedPreProcessing.py | 4 ++-- automatedPreProcessing/common.py | 10 +++------- 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index c87faa58..3e06acac 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -299,14 +299,14 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if not path.isfile(file_name_vtu_mesh): try: print("--- Computing mesh\n") - mesh, remeshed_surface = generate_mesh(distance_to_sphere, edge_length) + mesh, remeshed_surface = generate_mesh(distance_to_sphere) assert remeshed_surface.GetNumberOfPoints() > 0, \ "No points in surface mesh, try to remesh" assert mesh.GetNumberOfPoints() > 0, "No points in mesh, try to remesh" except: distance_to_sphere = mesh_alternative(distance_to_sphere) - mesh, remeshed_surface = generate_mesh(distance_to_sphere, edge_length) + mesh, remeshed_surface = generate_mesh(distance_to_sphere) assert mesh.GetNumberOfPoints() > 0, "No points in mesh, after remeshing" assert remeshed_surface.GetNumberOfPoints() > 0, \ "No points in surface mesh, try to remesh" diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index c3771a47..9036a3f9 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -450,16 +450,12 @@ def compute_distance_to_sphere(surface, centerSphere, radiusSphere=0.0, return surface -def generate_mesh(surface, edge_length=None): +def generate_mesh(surface): # Compute the mesh. meshGenerator = vmtkscripts.vmtkMeshGenerator() meshGenerator.Surface = surface - if edge_length is None: - meshGenerator.ElementSizeMode = "edgelength" # Constant size mesh - meshGenerator.TargetEdgeLength = edge_length - else: - meshGenerator.ElementSizeMode = "edgelengtharray" # Variable size mesh - meshGenerator.TargetEdgeLengthArrayName = "Size" # Variable size mesh + meshGenerator.ElementSizeMode = "edgelengtharray" # Variable size mesh + meshGenerator.TargetEdgeLengthArrayName = "Size" # Variable size mesh meshGenerator.BoundaryLayer = 1 meshGenerator.NumberOfSubLayers = 4 meshGenerator.BoundaryLayerOnCaps = 0 # it should 1 From d09016017d18c1322c6214c6b14035dbe2d92f17 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Wed, 13 Oct 2021 18:42:01 +0200 Subject: [PATCH 34/76] Renamingg --- automatedPreProcessing/automatedPreProcessing.py | 8 +++++--- automatedPreProcessing/common.py | 4 ++-- automatedPreProcessing/vmtkpointselector.py | 2 +- neckPlaneDetection/remove_aneurysm.py | 2 +- 4 files changed, 9 insertions(+), 7 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 3e06acac..45b4047f 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -207,7 +207,6 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin else: surface = read_polydata(file_name_surface_smooth) - elif smoothing_method == "laplace": print("--- Smooth surface: Laplacian smoothing\n") if not path.isfile(file_name_surface_smooth): @@ -279,8 +278,11 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Choose input for the mesh print("--- Computing distance to sphere\n") if meshing_method == "constant": - distance_to_sphere = dist_sphere_constant(surface, centerlines, region_center, misr_max, - file_name_distance_to_sphere_const, edge_length) + if not path.isfile(file_name_distance_to_sphere_const): + distance_to_sphere = dist_sphere_constant(surface, centerlines, region_center, misr_max, + file_name_distance_to_sphere_const, edge_length) + else: + distance_to_sphere = read_polydata(file_name_distance_to_sphere_const) elif meshing_method == "curvature": if not path.isfile(file_name_distance_to_sphere_curv): diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 9036a3f9..06b2e7a0 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -54,7 +54,7 @@ def get_regions_to_refine(surface, dir_path): def provide_region_points(surface, dir_path=None): """ - Get relevant aneurysm points from user selected points on a input surface. + Get relevant region points from user selected points on a input surface. Args: surface (vtkPolyData): Surface model. @@ -333,7 +333,7 @@ def dist_sphere_constant(surface, centerlines, sac_center, misr_max, fileName, e distTocenterlines.Execute() distance_to_sphere = distTocenterlines.Surface - # Reduce element size in aneurysm + # Reduce element size in region for i in range(len(sac_center)): distance_to_sphere = compute_distance_to_sphere(distance_to_sphere, sac_center[i], diff --git a/automatedPreProcessing/vmtkpointselector.py b/automatedPreProcessing/vmtkpointselector.py index 73a1e227..8c6d1666 100644 --- a/automatedPreProcessing/vmtkpointselector.py +++ b/automatedPreProcessing/vmtkpointselector.py @@ -130,7 +130,7 @@ def Execute(self): self.vmtkRenderer.Renderer.AddActor(surfaceActor) - text = 'Please position the mouse and press space to add the top of the aneurysm, \'u\' to undo\n' + text = 'Please position the mouse and press space to add the top of the region of interest, \'u\' to undo\n' guiText = VtkText(text) self.vmtkRenderer.Renderer.AddActor(guiText.text) diff --git a/neckPlaneDetection/remove_aneurysm.py b/neckPlaneDetection/remove_aneurysm.py index 93613fa7..41729fbf 100644 --- a/neckPlaneDetection/remove_aneurysm.py +++ b/neckPlaneDetection/remove_aneurysm.py @@ -265,7 +265,7 @@ def remove(dirpath, smooth, smooth_factor, bif, addPoint, lower, capped_surface = ReadPolyData(model_path.replace(".vtp", "_closed.vtp")) # Get aneurysm "end point" - aneurysm = get_aneurysm_dome(capped_surface, dirpath, anu_num) + aneurysm = get_regions_to_refine(capped_surface, dirpath, anu_num) outlet1, outlet2 = get_relevant_outlets(capped_surface, dirpath) # Get inlet and outlets From 7fd71d5b7fb46e968e9f2865a618fb71ab9d444e Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 14 Oct 2021 01:43:30 +0200 Subject: [PATCH 35/76] Refactor pre-processing --- .../automatedPreProcessing.py | 26 ++-------- automatedPreProcessing/common.py | 2 +- .../movementPreProcessing.py | 52 ++++++++++--------- 3 files changed, 32 insertions(+), 48 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 45b4047f..b6eb014b 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -3,9 +3,7 @@ import argparse -import ImportData import ToolRepairSTL -from NetworkBoundaryConditions import FlowSplitting # Local imports from common import * from simulate import run_simulation @@ -357,14 +355,15 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin parameters = get_parameters(path.join(dir_path, case_name)) # FIXME: Add plausible boundary conditions for atrial flow + flow_rate_factor = 0.27 if atrium_present: Total_inlet_area = 0 num_inlets = len(inlet) // 3 for i in range(num_inlets): Total_inlet_area += parameters["inlet%s_area" % i] - mean_inflow_rate = 0.27 * Total_inlet_area + mean_inflow_rate = flow_rate_factor * Total_inlet_area else: - mean_inflow_rate = 0.27 * parameters["inlet_area"] + mean_inflow_rate = flow_rate_factor * parameters["inlet_area"] find_boundaries(case_name, dir_path, mean_inflow_rate, network, polyDataVolMesh, verbose_print) @@ -393,28 +392,9 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin script_file = open(file_name_run_script, "w") script_file.write(run_script) script_file.close() - run_simulation(config_path, dir_path, case_name) -def str2bool(arg): - """ - Convert a string to boolean. - - Args: - arg (str): Input string. - - Returns: - return (bool): Converted string. - """ - if arg.lower() in ('yes', 'true', 't', 'y', '1'): - return True - elif arg.lower() in ('no', 'false', 'f', 'n', '0'): - return False - else: - raise argparse.ArgumentTypeError('Boolean value expected.') - - def read_command_line(): """ Read arguments from commandline and return all values in a dictionary. diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 06b2e7a0..1d87d283 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -223,7 +223,7 @@ def get_centers_for_meshing(surface, atrium_present, dir_path, flowext=False): outlets = [] inlets = [] for key, value in parameters.items(): - if "area" not in key and "relevant" not in key: + if "area" not in key and "id" not in key and "relevant" not in key: if "outlet" in key: outlets += value elif "inlet" in key: diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index 6ea35277..db90e881 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -4,6 +4,8 @@ from morphman.common import * from vtk.numpy_interface import dataset_adapter as dsa +from common import get_centers_for_meshing + cell_id_name = "CellEntityIds" @@ -45,7 +47,7 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, # Cap surface with flow extensions capped_surface = vmtk_cap_polydata(surface) - inlet, outlets = get_inlet_and_outlet_centers(surface, model_path) + outlets, inlet = get_centers_for_meshing(surface, True, model_path) centerlines, _, _ = compute_centerlines(inlet, outlets, cl_path, capped_surface, resampling=0.01) centerline = extract_single_line(centerlines, 0) origin = centerline.GetPoint(0) @@ -61,10 +63,10 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, # Add flow extensions if add_extensions and path.exists(moved_path): - surface_to_mesh = add_flow_extensions(surface, model_path, moved_path, edge_length, recompute_mesh) + surface_to_mesh = add_flow_extensions(surface, model_path, moved_path, centerlines, edge_length) if not path.exists(mesh_path) or recompute_mesh and surface_to_mesh is not None: - generate_mesh(mesh_path, mesh_xml_path, surface_to_mesh, edge_length) + generate_mesh(surface_to_mesh, mesh_path, mesh_xml_path, edge_length) def IdealVolume(t): @@ -151,12 +153,11 @@ def capp_surface(remeshed_extended, offset=1): return surface -def add_flow_extensions(surface, model_path, moved_path, resolution=1.9, recompute_mesh=False): +def add_flow_extensions(surface, model_path, moved_path, centerline, resolution=1.9): # Create result paths points_path = model_path + "_points.np" remeshed_path = model_path + "_remeshed.vtp" extended_path = model_path + "_extended" - centerline_path = model_path + "_cl.vtp" remeshed_extended_path = model_path + "_remeshed_extended.vtp" if not path.exists(extended_path): os.mkdir(extended_path) @@ -170,20 +171,10 @@ def add_flow_extensions(surface, model_path, moved_path, resolution=1.9, recompu remeshed = vtk_clean_polydata(remeshed) write_polydata(remeshed, remeshed_path) - # Compute centerline - if not path.exists(centerline_path): - print("-- Computing centerlines --") - inlet, outlet = compute_centers(remeshed, model_path) - print(inlet, outlet) - centerline, _, _ = compute_centerlines(inlet, outlet, centerline_path, capp_surface(remeshed), - resampling=0.1, end_point=1) - else: - centerline = read_polydata(centerline_path) - # Create surface extensions on the original surface print("-- Adding flow extensions --") - length_in = 1.5 - length_out = 1.5 + length_in = 1.0 + length_out = 1.0 remeshed_extended = add_flow_extension(remeshed, centerline, include_outlet=False, extension_length=length_in) remeshed_extended = add_flow_extension(remeshed_extended, centerline, include_outlet=True, extension_length=length_out) @@ -206,22 +197,33 @@ def add_flow_extensions(surface, model_path, moved_path, resolution=1.9, recompu tmp_surface = read_polydata(model_path) new_path = path.join(extended_path, model_path.split("/")[-1]) - move_surface_model(tmp_surface, surface, remeshed, remeshed_extended, distance, point_map, new_path, i, points) + if not path.exists(new_path): + move_surface_model(tmp_surface, surface, remeshed, remeshed_extended, distance, point_map, new_path, i, + points) - # Write points to file + # Resample points and write to file + N = 200 points[:, :, -1] = points[:, :, 0] + time = np.linspace(0, 1, points.shape[2]) + N2 = N + N // (time.shape[0] - 1) + move = np.zeros((points.shape[0], points.shape[1], N + 1)) + move[:, 0, :] = resample(points[:, 0, :], N2, time, axis=1)[0][:, :N - N2 + 1] + move[:, 1, :] = resample(points[:, 1, :], N2, time, axis=1)[0][:, :N - N2 + 1] + move[:, 2, :] = resample(points[:, 2, :], N2, time, axis=1)[0][:, :N - N2 + 1] + + points = move points.dump(points_path) return remeshed_extended -def generate_mesh(mesh_path, mesh_xml_path, remeshed_extended, resolution): +def generate_mesh(surface, mesh_path, mesh_xml_path, resolution): # Cap mitral valve print("-- Meshing surface --") - remeshed_extended = dsa.WrapDataObject(remeshed_extended) - remeshed_extended.CellData.append(np.zeros(remeshed_extended.VTKObject.GetNumberOfCells()) + 1, - cell_id_name) - remeshed_all_capped = capp_surface(remeshed_extended.VTKObject) + surface = dsa.WrapDataObject(surface) + surface.CellData.append(np.zeros(surface.VTKObject.GetNumberOfCells()) + 1, + cell_id_name) + remeshed_all_capped = capp_surface(surface.VTKObject) remeshed_all_capped = remesh_surface(remeshed_all_capped, resolution, exclude=[1]) # Mesh volumetric @@ -261,6 +263,8 @@ def generate_mesh(mesh_path, mesh_xml_path, remeshed_extended, resolution): meshWriter.OutputFileName = mesh_xml_path meshWriter.Execute() + return mesh + def move_surface_model(surface, original, remeshed, remeshed_extended, distance, point_map, file_path, i, points): surface = dsa.WrapDataObject(surface) From f9c81a6844ff40e3cf2cd64cdcb7c8a6057bbdee Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 14 Oct 2021 02:03:46 +0200 Subject: [PATCH 36/76] Refactor pre-processing --- automatedPreProcessing/automatedPreProcessing.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index b6eb014b..bcee0575 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -3,8 +3,10 @@ import argparse +import ImportData import ToolRepairSTL # Local imports +from NetworkBoundaryConditions import FlowSplitting from common import * from simulate import run_simulation from visualize import visualize From b93aab7fe58319dab33782d09376628f1981159a Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 14 Oct 2021 16:02:13 +0200 Subject: [PATCH 37/76] Update imports --- automatedPreProcessing/automatedPreProcessing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index bcee0575..28763a3a 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -5,8 +5,8 @@ import ImportData import ToolRepairSTL -# Local imports from NetworkBoundaryConditions import FlowSplitting +# Local imports from common import * from simulate import run_simulation from visualize import visualize From b54bf6121256efa16b7bb5a760e11f886ea370b4 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 14 Oct 2021 17:04:03 +0200 Subject: [PATCH 38/76] Uppdate coarsening factor description --- automatedPreProcessing/automatedPreProcessing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 28763a3a..b3d4af4a 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -433,7 +433,7 @@ def read_command_line(): required=False, dest='coarseningFactor', default=1.0, - help="Refine or coarsen the standard mesh size") + help="Refine or coarsen the standard mesh size. The higher the value the coarser the mesh.") parser.add_argument('-sF', '--smoothingFactor', type=float, From 2be01e94dc921dc8d93a657bf6b90e64009b9faf Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 14 Oct 2021 20:23:06 +0200 Subject: [PATCH 39/76] Refactor atrium meshing --- .../automatedPreProcessing.py | 56 ++-------------- automatedPreProcessing/common.py | 67 ++++++++++++++++++- .../movementPreProcessing.py | 31 ++++++++- automatedPreProcessing/visualize.py | 2 + 4 files changed, 101 insertions(+), 55 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index b3d4af4a..952b02d3 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -3,9 +3,7 @@ import argparse -import ImportData import ToolRepairSTL -from NetworkBoundaryConditions import FlowSplitting # Local imports from common import * from simulate import run_simulation @@ -313,66 +311,23 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin assert remeshed_surface.GetNumberOfPoints() > 0, \ "No points in surface mesh, try to remesh" - # Write mesh in VTU format - write_polydata(remeshed_surface, file_name_surface_name) - write_polydata(mesh, file_name_vtu_mesh) - - # Write mesh to FEniCS to format - meshWriter = vmtkscripts.vmtkMeshWriter() - meshWriter.CellEntityIdsArrayName = "CellEntityIds" - meshWriter.Mesh = mesh - meshWriter.Mode = "ascii" - meshWriter.Compressed = compress_mesh - meshWriter.OutputFileName = file_name_xml_mesh - meshWriter.Execute() - polyDataVolMesh = mesh + polyDataVolMesh = write_mesh(compress_mesh, file_name_surface_name, file_name_vtu_mesh, file_name_xml_mesh, + mesh, remeshed_surface) else: polyDataVolMesh = read_polydata(file_name_vtu_mesh) - # Set the network object used in the scripts for - # boundary conditions and probes. - network = ImportData.Network() - centerlinesBranches = ImportData.SetNetworkStructure(centerlines, network, verbose_print) - - if not path.isfile(file_name_probe_points): - # Get the list of coordinates for the probe points along the network centerline. - listProbePoints = ImportData.GetListProbePoints(centerlinesBranches, network, verbose_print) - listProbePoints += region_center - - print("--- Saving probes points in: %s\n" % file_name_probe_points) - probe_points = np.array(listProbePoints) - probe_points.dump(file_name_probe_points) - else: - probe_points = np.load(file_name_probe_points, allow_pickle=True) - - # Set the flow split and inlet boundary condition - # Compute the outlet boundary condition percentages. - flowSplitting = FlowSplitting() - flowSplitting.ComputeAlphas(network, verbose_print) - flowSplitting.ComputeBetas(network, verbose_print) - flowSplitting.CheckTotalFlowRate(network, verbose_print) + network, probe_points = setup_model_network(centerlines, file_name_probe_points, region_center, verbose_print) # BSL method for mean inlet flow rate. parameters = get_parameters(path.join(dir_path, case_name)) - # FIXME: Add plausible boundary conditions for atrial flow - flow_rate_factor = 0.27 - if atrium_present: - Total_inlet_area = 0 - num_inlets = len(inlet) // 3 - for i in range(num_inlets): - Total_inlet_area += parameters["inlet%s_area" % i] - mean_inflow_rate = flow_rate_factor * Total_inlet_area - else: - mean_inflow_rate = flow_rate_factor * parameters["inlet_area"] + mean_inflow_rate = compute_flow_rate(atrium_present, inlet, parameters) - find_boundaries(case_name, dir_path, mean_inflow_rate, network, polyDataVolMesh, verbose_print) + find_boundaries(path.join(dir_path,case_name), mean_inflow_rate, network, polyDataVolMesh, verbose_print) # Display the flow split at the outlets, inlet flow rate, and probes. if viz: - print("--- Visualizing flow split at outlets, inlet flow rate, and probes in VTK render window. ") - print("--- Press 'q' inside the render window to exit.") visualize(network.elements, probe_points, surface, mean_inflow_rate) # Start simulation though ssh, without password @@ -394,6 +349,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin script_file = open(file_name_run_script, "w") script_file.write(run_script) script_file.close() + run_simulation(config_path, dir_path, case_name) diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 1d87d283..50cb9ba1 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -1,5 +1,8 @@ from morphman.common import * +import ImportData +from NetworkBoundaryConditions import FlowSplitting + try: from vmtkpointselector import * except ImportError: @@ -567,7 +570,7 @@ def compute_centers_for_meshing(polyData, atrium_present, case_path=None, test_c return center_, boundary_center -def find_boundaries(case_name, dir_path, mean_inflow_rate, network, polyDataVolMesh, verbose_print): +def find_boundaries(model_path, mean_inflow_rate, network, polyDataVolMesh, verbose_print): # Extract the surface mesh of the wall wallMesh = vtk_compute_threshold(polyDataVolMesh, "CellEntityIds", lower=0.5, upper=1.5) boundaryReferenceSystems = vmtkscripts.vmtkBoundaryReferenceSystems() @@ -629,6 +632,64 @@ def find_boundaries(case_name, dir_path, mean_inflow_rate, network, polyDataVolM "mean_flow_rate": mean_inflow_rate, "area_ratio": area_ratios } - info_path = path.join(dir_path, case_name) - write_parameters(info, info_path) + write_parameters(info, model_path) + + +def setup_model_network(centerlines, file_name_probe_points, region_center, verbose_print): + # Set the network object used in the scripts for + # boundary conditions and probes. + network = ImportData.Network() + centerlinesBranches = ImportData.SetNetworkStructure(centerlines, network, verbose_print) + + if not path.isfile(file_name_probe_points): + # Get the list of coordinates for the probe points along the network centerline. + listProbePoints = ImportData.GetListProbePoints(centerlinesBranches, network, verbose_print) + listProbePoints += region_center + + print("--- Saving probes points in: %s\n" % file_name_probe_points) + probe_points = np.array(listProbePoints) + probe_points.dump(file_name_probe_points) + else: + probe_points = np.load(file_name_probe_points, allow_pickle=True) + + # Set the flow split and inlet boundary condition + # Compute the outlet boundary condition percentages. + flowSplitting = FlowSplitting() + flowSplitting.ComputeAlphas(network, verbose_print) + flowSplitting.ComputeBetas(network, verbose_print) + flowSplitting.CheckTotalFlowRate(network, verbose_print) + + return network, probe_points + + +def compute_flow_rate(atrium_present, inlet, parameters): + # FIXME: Add plausible boundary conditions for atrial flow + flow_rate_factor = 0.27 + if atrium_present: + Total_inlet_area = 0 + num_inlets = len(inlet) // 3 + for i in range(num_inlets): + Total_inlet_area += parameters["inlet%s_area" % i] + mean_inflow_rate = flow_rate_factor * Total_inlet_area + else: + mean_inflow_rate = flow_rate_factor * parameters["inlet_area"] + + return mean_inflow_rate + + +def write_mesh(compress_mesh, file_name_surface_name, file_name_vtu_mesh, file_name_xml_mesh, mesh, remeshed_surface): + # Write mesh in VTU format + write_polydata(remeshed_surface, file_name_surface_name) + write_polydata(mesh, file_name_vtu_mesh) + + # Write mesh to FEniCS to format + meshWriter = vmtkscripts.vmtkMeshWriter() + meshWriter.CellEntityIdsArrayName = "CellEntityIds" + meshWriter.Mesh = mesh + meshWriter.Mode = "ascii" + meshWriter.Compressed = compress_mesh + meshWriter.OutputFileName = file_name_xml_mesh + meshWriter.Execute() + polyDataVolMesh = mesh + return polyDataVolMesh diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index db90e881..b7e018ce 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -4,7 +4,8 @@ from morphman.common import * from vtk.numpy_interface import dataset_adapter as dsa -from common import get_centers_for_meshing +from common import get_centers_for_meshing, find_boundaries, setup_model_network, compute_flow_rate +from visualize import visualize cell_id_name = "CellEntityIds" @@ -66,7 +67,33 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, surface_to_mesh = add_flow_extensions(surface, model_path, moved_path, centerlines, edge_length) if not path.exists(mesh_path) or recompute_mesh and surface_to_mesh is not None: - generate_mesh(surface_to_mesh, mesh_path, mesh_xml_path, edge_length) + mesh = generate_mesh(surface_to_mesh, mesh_path, mesh_xml_path, edge_length) + + if path.exists(mesh_path): + mesh = read_polydata(mesh_path) + + find_ids(surface_to_mesh, model_path, mesh) + + +def find_ids(surface_to_mesh, model_path, mesh): + file_name_flow_centerlines = model_path + "_cl_ext.vtp" + probe_path = model_path + "_probes" + + print("-- Finding boundary IDs --") + inlet, outlets = get_centers_for_meshing(surface_to_mesh, True, model_path, flowext=True) + capped_surface = vmtk_cap_polydata(surface_to_mesh) + centerlines, _, _ = compute_centerlines(outlets, inlet, file_name_flow_centerlines, capped_surface, + resampling=0.1) + network, probe_points = setup_model_network(centerlines, probe_path, [], lambda *a: None) + + parameters = get_parameters(model_path) + + mean_inflow_rate = compute_flow_rate(True, inlet, parameters) + + find_boundaries(model_path, mean_inflow_rate, network, mesh, lambda *a: None) + + # Display the flow split at the outlets, inlet flow rate, and probes. + visualize(network.elements, probe_points, surface_to_mesh, mean_inflow_rate) def IdealVolume(t): diff --git a/automatedPreProcessing/visualize.py b/automatedPreProcessing/visualize.py index fa2f4f62..75a56855 100644 --- a/automatedPreProcessing/visualize.py +++ b/automatedPreProcessing/visualize.py @@ -16,6 +16,8 @@ def visualize(network_elements, probe_points, output_surface, mean_inflow_rate): output_surface (vtkPolyData): Surface model to visualize mean_inflow_rate (float): Mean inflow rate of input model """ + print("--- Visualizing flow split at outlets, inlet flow rate, and probes in VTK render window. ") + print("--- Press 'q' inside the render window to exit.") points = vtk.vtkPoints() scalar = vtk.vtkDoubleArray() scalar.SetNumberOfComponents(1) From 5d595da24628443ae3249b24556354193ccd6d74 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 14 Oct 2021 20:27:26 +0200 Subject: [PATCH 40/76] Add finding IDs to atrium pipeine --- automatedPreProcessing/movementPreProcessing.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index b7e018ce..84c2e94e 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -82,8 +82,7 @@ def find_ids(surface_to_mesh, model_path, mesh): print("-- Finding boundary IDs --") inlet, outlets = get_centers_for_meshing(surface_to_mesh, True, model_path, flowext=True) capped_surface = vmtk_cap_polydata(surface_to_mesh) - centerlines, _, _ = compute_centerlines(outlets, inlet, file_name_flow_centerlines, capped_surface, - resampling=0.1) + centerlines, _, _ = compute_centerlines(outlets, inlet, file_name_flow_centerlines, capped_surface, resampling=0.1) network, probe_points = setup_model_network(centerlines, probe_path, [], lambda *a: None) parameters = get_parameters(model_path) From c94a8a09b483fc6f33c96d35f310a5a14be5517d Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Fri, 15 Oct 2021 16:24:54 +0200 Subject: [PATCH 41/76] Added AtriumMove script (WIP) --- AtriumMove.py | 362 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 362 insertions(+) create mode 100644 AtriumMove.py diff --git a/AtriumMove.py b/AtriumMove.py new file mode 100644 index 00000000..141aafcc --- /dev/null +++ b/AtriumMove.py @@ -0,0 +1,362 @@ +import json +import pickle + +import numpy as np +from oasis.problems.NSfracStep.MovingCommon import mesh_velocity_setup, get_visualization_files, mesh_velocity_solve +from oasis.problems.NSfracStep.Womersley import compute_boundary_geometry_acrn +from scipy.interpolate import splrep, splev + +from ..NSfracStep import * + +set_log_level(99) + + +def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_namespace): + if "restart_folder" in commandline_kwargs.keys(): + restart_folder = commandline_kwargs["restart_folder"] + f = open(path.join(restart_folder, 'params.dat'), 'rb') + NS_parameters.update(pickle.load(f)) + NS_parameters['restart_folder'] = restart_folder + else: + # Override some problem specific parameters + # parameters are in mm and ms + NS_parameters.update( + compute_volume=False, + mean_velocity=0.1, # Simulate with constant mean velocity + rigid_walls=True, # Run rigid wall simulation + # Fluid parameters + # Viscosity [nu_inf: 0.0035 Pa-s / 1060 kg/m^3 = 3.3018868E-6 m^2/s == 3.3018868E-3 mm^2/ms] + nu=3.3018868e-3, + # Geometry parameters + id_in=[], # Inlet boundary ID + id_out=[], # Outlet boundary IDs + # Simulation parameters + T=1000, # 1045, # Run simulation for 1 cardiac cycles [ms] + dt=50, # 0.05, # 10 000 steps per cycle [ms] + no_of_cycles=5.0, # Number of cycles + dump_stats=100, + store_data=2000000, + store_data_tstep=5, # Start storing data at 1st cycle + save_step=100, + save_step_problem=1, + checkpoint=20000, + print_intermediate_info=100, + tstep_print=1000, + folder="results_atrium_move", + mesh_path=commandline_kwargs["mesh_path"], + # Solver parameters + velocity_degree=1, + pressure_degree=1, + use_krylov_solvers=True, + krylov_solvers=dict(monitor_convergence=False) + ) + + mesh_file = NS_parameters["mesh_path"].split("/")[-1] + case_name = mesh_file.split(".")[0] + NS_parameters["folder"] = path.join(NS_parameters["folder"], case_name) + + +def mesh(mesh_path, **NS_namespace): + # Read mesh and print mesh information + mesh = Mesh(mesh_path) + print_mesh_information(mesh) + + return mesh + + +def pre_boundary_condition(mesh, mesh_path, id_out, id_in, T, **NS_namespace): + # Variables needed during the simulation + D = mesh.geometry().dim() + boundary = MeshFunction("size_t", mesh, D - 1, mesh.domains()) + boundary.set_values(boundary.array() + 1) + ds_new = Measure("ds", domain=mesh, subdomain_data=boundary) + + # Get IDs for inlet(s) and outlet(s) + info_path = mesh_path.split(".")[0] + "_info.json" + with open(info_path) as f: + info = json.load(f) + + id_wall = 1 + id_out[:] = info['inlet_id'] + id_in[:] = info['outlet_ids'] + + # Find corresponding areas + area_total = 0 + for ID in id_in: + area_total += assemble(Constant(1.0) * ds_new(ID)) + + # Compute flow rate + flow_rate_data = np.loadtxt(mesh_path.split(".")[0] + "_flux.txt") + t = np.linspace(0, T, len(flow_rate_data)) + flow_rate = splrep(t, flow_rate_data, s=2, per=True) + + return dict(boundary=boundary, ds_new=ds_new, area_total=area_total, flow_rate=flow_rate, id_wall=id_wall) + + +class Surface_counter(UserExpression): + def __init__(self, points, cycle, **kwargs): + self.motion = {} + self.counter = -1 + self.points = points + self.time = np.linspace(0, cycle, self.points.shape[-1]) + super().__init__(**kwargs) + + def get_motion(self): + return self.motion + + def eval(self, _, x): + self.counter += 1 + index = np.argmin(np.sqrt(np.sum((self.points[:, :, 0] - np.array(x)) ** 2, axis=1))) + s = 0.01 + x_ = splrep(self.time, self.points[index, 0, :], s=s, per=True) + y_ = splrep(self.time, self.points[index, 1, :], s=s, per=True) + z_ = splrep(self.time, self.points[index, 2, :], s=s, per=True) + + self.motion[self.counter] = [x_, y_, z_] + + +class InletParabolic(UserExpression): + def __init__(self, tstep, dt, N, n, Q_profile, center, R2, area, area_total, mean_velocity, **kwargs): + self.tstep = tstep + self.dt = dt + self.N = N + self.Q_profile = Q_profile + self.Q = 0 + self.center = center + self.R2 = R2 + self.area = area + self.area_total = area_total + self.normal_component = n + self.mean_velocity = mean_velocity + super().__init__(**kwargs) + + def update(self, tstep): + self.tstep = tstep + tstep = self.tstep % self.N + tmp_scale = 10 # TODO: Only for testing + self.Q = splev(tstep * self.dt, self.Q_profile) / tmp_scale + + def eval(self, value, x): + if self.mean_velocity is not None: + U0 = self.mean_velocity + else: + U0 = self.Q * self.area / self.area_total + + x0 = self.center[0] + x1 = self.center[1] + x2 = self.center[2] + R2 = self.R2 + parabolic = U0 * (1 - ((x0 - x[0]) ** 2 + (x1 - x[1]) ** 2 + (x2 - x[2]) ** 2) / R2) + + value[:] = - self.normal_component * parabolic + + +class Wall_motion(UserExpression): + def __init__(self, t, motion, max_counter, direction, cycle, **kwargs): + self.t = t + self.motion = motion + self.max_counter = max_counter + self.counter = -1 + self.direction = direction + self.cycle = cycle + super().__init__(**kwargs) + + def eval(self, values, _): + self.counter += 1 + # No motion for inlet/outlet + values[:] = splev(self.t % self.cycle, self.motion[self.counter][self.direction], der=1) + if self.counter == self.max_counter: + self.counter = -1 + + +def create_bcs(NS_expressions, x_, boundary, V, Q, T, mesh, mesh_path, id_in, id_out, id_wall, + tstep, dt, area_total, flow_rate, no_of_cycles, t, mean_velocity, **NS_namespace): + # Create inlet boundary conditions + N = int(T / dt) + bc_inlets = {} + for i, ID in enumerate(id_in): + tmp_area, tmp_center, tmp_radius, tmp_normal = compute_boundary_geometry_acrn(mesh, id_in[i], boundary) + inlet, coeffs = [], [] + for normal_component in tmp_normal: + R2 = tmp_area / np.pi # R**2 + in_ = InletParabolic(tstep, dt, N, normal_component, flow_rate, tmp_center, R2, tmp_area, area_total, + mean_velocity, element=V.ufl_element()) + inlet.append(in_) + + NS_expressions[ID] = inlet + bc_inlet = [DirichletBC(V, inlet[i], boundary, ID) for i in range(3)] + bc_inlets[ID] = bc_inlet + + # Set outlet boundary conditions + bc_p = [] + for i, ID in enumerate(id_out): + bc = DirichletBC(Q, Constant(0.0), boundary, ID) + bc_p.append(bc) + NS_expressions['P'] = bc + + print("Loading displacement points") + # Get mesh motion + points = np.load(mesh_path.split(".")[0] + "_points.np", allow_pickle=True) + cycle = T * no_of_cycles + + # Define wall movement + surface_counter = Surface_counter(points, cycle, element=V.ufl_element()) + bc_tmp = DirichletBC(V, surface_counter, boundary, id_wall) + bc_tmp.apply(x_["u0"]) + x_["u0"].zero() + + counter_max = surface_counter.counter + motion = surface_counter.get_motion() + + # Remove explicitly from memory. + del surface_counter + del points + + # Outlet + noslip = Constant(0.0) + outlet_bc = DirichletBC(V, noslip, boundary, id_out[0]) + + # Wall (mesh) motion + for i, coor in enumerate(['x', 'y', 'z']): + wall_motion = Wall_motion(t, motion, counter_max, i, cycle, element=V.ufl_element()) + NS_expressions["wall_%s" % coor] = wall_motion + NS_expressions["outlet_%s" % coor] = outlet_bc + + # Fluid velocity at walls + bcu_wall_x = bcu_wall_y = bcu_wall_z = DirichletBC(V, noslip, boundary, id_wall) + + # Create lists with all boundary conditions + bc_u0 = [] + bc_u1 = [] + bc_u2 = [] + for ID in id_in: + bc_u0.append(bc_inlets[ID][0]) + bc_u1.append(bc_inlets[ID][1]) + bc_u2.append(bc_inlets[ID][2]) + bc_u0.append(bcu_wall_x) + bc_u1.append(bcu_wall_y) + bc_u2.append(bcu_wall_z) + + return dict(u0=bc_u0, u1=bc_u1, u2=bc_u2, p=bc_p) + + +def pre_solve_hook(mesh, V, id_in, id_out, id_wall, newfolder, u_components, velocity_degree, x_, boundary, + **NS_namespace): + # Create point for evaluation + n = FacetNormal(mesh) + viz_p, viz_u = get_visualization_files(newfolder) + + print("Setup mesh velocity") + L_mesh, a_mesh, coordinates, dof_map, mesh_sol, u_vec \ + = mesh_velocity_setup(V, mesh, u_components, velocity_degree, x_) + + # Set wall motion BCS + bc_mesh = dict((ui, []) for ui in u_components) + + bcu_in = [] + noslip = Constant(0.0) + for i, ID in enumerate(id_in): + bcu = DirichletBC(V, noslip, boundary, ID) + bcu_in.append(bcu) + + bcu_wall_x = DirichletBC(V, NS_expressions["wall_x"], boundary, id_wall) + bcu_wall_y = DirichletBC(V, NS_expressions["wall_y"], boundary, id_wall) + bcu_wall_z = DirichletBC(V, NS_expressions["wall_z"], boundary, id_wall) + + bc_out_x = DirichletBC(V, noslip, boundary, id_out[0]) + bc_out_y = DirichletBC(V, noslip, boundary, id_out[0]) + bc_out_z = DirichletBC(V, noslip, boundary, id_out[0]) + + bc_mesh["u0"] = [bcu_wall_x] + [bc_out_x] + bcu_in + bc_mesh["u1"] = [bcu_wall_y] + [bc_out_y] + bcu_in + bc_mesh["u2"] = [bcu_wall_z] + [bc_out_z] + bcu_in + + h = EdgeLength(mesh) + + return dict(boundary=boundary, viz_u=viz_u, viz_p=viz_p, u_vec=u_vec, n=n, h=h, bc_mesh=bc_mesh, mesh_sol=mesh_sol, + a_mesh=a_mesh, L_mesh=L_mesh, coordinates=coordinates, dof_map=dof_map) + + +def update_prescribed_motion(t, dt, wx_, rigid_walls, w_, u_components, bc_mesh, coordinates, dof_map, mesh_sol, + NS_expressions, A_cache, a_mesh, L_mesh, id_in, tstep, **NS_namespace): + if rigid_walls: + update_prescribed_motion.not_implemented = True + return False + + # Update wall motion BCs + for dir in ["x", "y", "z"]: + NS_expressions["wall_{}".format(dir)].t = t + NS_expressions["outlet_{}".format(dir)].t = t + + for ID in id_in: + for i in [0, 1, 2]: + NS_expressions[ID][i].update(tstep) + + move = mesh_velocity_solve(A_cache, L_mesh, a_mesh, bc_mesh, coordinates, dof_map, dt, mesh_sol, u_components, w_, + wx_) + return move + + +def temporal_hook(u_, mesh, newfolder, tstep, t, save_step_problem, u_vec, viz_u, nu, dt, compute_volume, + **NS_namespace): + if compute_volume: + ComputeVolume(mesh, t, newfolder) + if tstep % save_step_problem == 0: + assign(u_vec.sub(0), u_[0]) + assign(u_vec.sub(1), u_[1]) + assign(u_vec.sub(2), u_[2]) + + viz_u.write(u_vec, t) + + if tstep % save_step_problem * 5 == 0: + L_mitral = 20 + h = mesh.hmin() + ComputeReynoldsNumberAndCFL(u_, L_mitral, nu, mesh, t, tstep, dt, h, dynamic_mesh=False) + + +def ComputeVolume(mesh, t, newfolder): + volume = assemble(Constant(1.0) * dx(mesh)) + data = [t, volume] + write_data_to_file(newfolder, data, "atrium_volume.txt") + + +def print_mesh_information(mesh): + comm = MPI.comm_world + local_xmin = mesh.coordinates()[:, 0].min() + local_xmax = mesh.coordinates()[:, 0].max() + local_ymin = mesh.coordinates()[:, 1].min() + local_ymax = mesh.coordinates()[:, 1].max() + local_zmin = mesh.coordinates()[:, 2].min() + local_zmax = mesh.coordinates()[:, 2].max() + xmin = comm.gather(local_xmin, 0) + xmax = comm.gather(local_xmax, 0) + ymin = comm.gather(local_ymin, 0) + ymax = comm.gather(local_ymax, 0) + zmin = comm.gather(local_zmin, 0) + zmax = comm.gather(local_zmax, 0) + + local_num_cells = mesh.num_cells() + local_num_edges = mesh.num_edges() + local_num_faces = mesh.num_faces() + local_num_facets = mesh.num_facets() + local_num_vertices = mesh.num_vertices() + num_cells = comm.gather(local_num_cells, 0) + num_edges = comm.gather(local_num_edges, 0) + num_faces = comm.gather(local_num_faces, 0) + num_facets = comm.gather(local_num_facets, 0) + num_vertices = comm.gather(local_num_vertices, 0) + volume = assemble(Constant(1) * dx(mesh)) + + if MPI.rank(MPI.comm_world) == 0: + print("=== Mesh information ===") + print("X range: {} to {} (delta: {:.4f})".format(min(xmin), max(xmax), max(xmax) - min(xmin))) + print("Y range: {} to {} (delta: {:.4f})".format(min(ymin), max(ymax), max(ymax) - min(ymin))) + print("Z range: {} to {} (delta: {:.4f})".format(min(zmin), max(zmax), max(zmax) - min(zmin))) + print("Number of cells: {}".format(sum(num_cells))) + print("Number of cells per processor: {}".format(int(np.mean(num_cells)))) + print("Number of edges: {}".format(sum(num_edges))) + print("Number of faces: {}".format(sum(num_faces))) + print("Number of facets: {}".format(sum(num_facets))) + print("Number of vertices: {}".format(sum(num_vertices))) + print("Volume: {:.4f}".format(volume)) + print("Number of cells per volume: {:.4f}".format(sum(num_cells) / volume)) From 97971b432879cc0b3c52a6b82f9c3a730d577dd3 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Mon, 18 Oct 2021 13:44:27 +0200 Subject: [PATCH 42/76] Added NS parameter printout --- AtriumMove.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/AtriumMove.py b/AtriumMove.py index 141aafcc..e2ce6f48 100644 --- a/AtriumMove.py +++ b/AtriumMove.py @@ -1,5 +1,6 @@ import json import pickle +from pprint import pprint import numpy as np from oasis.problems.NSfracStep.MovingCommon import mesh_velocity_setup, get_visualization_files, mesh_velocity_solve @@ -55,6 +56,11 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n case_name = mesh_file.split(".")[0] NS_parameters["folder"] = path.join(NS_parameters["folder"], case_name) + if MPI.rank(MPI.comm_world) == 0: + print("=== Starting simulation for case: {} ===".format(case_name)) + print("Running with the following parameters:") + pprint(NS_parameters) + def mesh(mesh_path, **NS_namespace): # Read mesh and print mesh information From 8af903f95ae763e81466091329a7a5e9a45b0194 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Mon, 18 Oct 2021 20:14:54 +0200 Subject: [PATCH 43/76] Replace T with cycle --- AtriumMove.py | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/AtriumMove.py b/AtriumMove.py index e2ce6f48..a73dec21 100644 --- a/AtriumMove.py +++ b/AtriumMove.py @@ -1,6 +1,5 @@ import json import pickle -from pprint import pprint import numpy as np from oasis.problems.NSfracStep.MovingCommon import mesh_velocity_setup, get_visualization_files, mesh_velocity_solve @@ -24,7 +23,7 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n NS_parameters.update( compute_volume=False, mean_velocity=0.1, # Simulate with constant mean velocity - rigid_walls=True, # Run rigid wall simulation + rigid_walls=False, # Run rigid wall simulation # Fluid parameters # Viscosity [nu_inf: 0.0035 Pa-s / 1060 kg/m^3 = 3.3018868E-6 m^2/s == 3.3018868E-3 mm^2/ms] nu=3.3018868e-3, @@ -32,9 +31,9 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n id_in=[], # Inlet boundary ID id_out=[], # Outlet boundary IDs # Simulation parameters - T=1000, # 1045, # Run simulation for 1 cardiac cycles [ms] - dt=50, # 0.05, # 10 000 steps per cycle [ms] - no_of_cycles=5.0, # Number of cycles + cycle=1000, # 1045, # Run simulation for 1 cardiac cycles [ms] + no_of_cycles=2.0, # Number of cycles + dt=1, # 0.05, # 10 000 steps per cycle [ms] dump_stats=100, store_data=2000000, store_data_tstep=5, # Start storing data at 1st cycle @@ -56,11 +55,6 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n case_name = mesh_file.split(".")[0] NS_parameters["folder"] = path.join(NS_parameters["folder"], case_name) - if MPI.rank(MPI.comm_world) == 0: - print("=== Starting simulation for case: {} ===".format(case_name)) - print("Running with the following parameters:") - pprint(NS_parameters) - def mesh(mesh_path, **NS_namespace): # Read mesh and print mesh information @@ -70,7 +64,7 @@ def mesh(mesh_path, **NS_namespace): return mesh -def pre_boundary_condition(mesh, mesh_path, id_out, id_in, T, **NS_namespace): +def pre_boundary_condition(mesh, mesh_path, id_out, id_in, no_of_cycles, cycle, **NS_namespace): # Variables needed during the simulation D = mesh.geometry().dim() boundary = MeshFunction("size_t", mesh, D - 1, mesh.domains()) @@ -92,11 +86,12 @@ def pre_boundary_condition(mesh, mesh_path, id_out, id_in, T, **NS_namespace): area_total += assemble(Constant(1.0) * ds_new(ID)) # Compute flow rate + T = no_of_cycles * cycle flow_rate_data = np.loadtxt(mesh_path.split(".")[0] + "_flux.txt") t = np.linspace(0, T, len(flow_rate_data)) flow_rate = splrep(t, flow_rate_data, s=2, per=True) - return dict(boundary=boundary, ds_new=ds_new, area_total=area_total, flow_rate=flow_rate, id_wall=id_wall) + return dict(boundary=boundary, ds_new=ds_new, area_total=area_total, flow_rate=flow_rate, id_wall=id_wall, T=T) class Surface_counter(UserExpression): @@ -175,10 +170,10 @@ def eval(self, values, _): self.counter = -1 -def create_bcs(NS_expressions, x_, boundary, V, Q, T, mesh, mesh_path, id_in, id_out, id_wall, - tstep, dt, area_total, flow_rate, no_of_cycles, t, mean_velocity, **NS_namespace): +def create_bcs(NS_expressions, cycle, x_, boundary, V, Q, mesh, mesh_path, id_in, id_out, id_wall, + tstep, dt, area_total, flow_rate, t, mean_velocity, **NS_namespace): # Create inlet boundary conditions - N = int(T / dt) + N = int(cycle / dt) bc_inlets = {} for i, ID in enumerate(id_in): tmp_area, tmp_center, tmp_radius, tmp_normal = compute_boundary_geometry_acrn(mesh, id_in[i], boundary) @@ -203,7 +198,6 @@ def create_bcs(NS_expressions, x_, boundary, V, Q, T, mesh, mesh_path, id_in, id print("Loading displacement points") # Get mesh motion points = np.load(mesh_path.split(".")[0] + "_points.np", allow_pickle=True) - cycle = T * no_of_cycles # Define wall movement surface_counter = Surface_counter(points, cycle, element=V.ufl_element()) @@ -229,7 +223,13 @@ def create_bcs(NS_expressions, x_, boundary, V, Q, T, mesh, mesh_path, id_in, id NS_expressions["outlet_%s" % coor] = outlet_bc # Fluid velocity at walls - bcu_wall_x = bcu_wall_y = bcu_wall_z = DirichletBC(V, noslip, boundary, id_wall) + bcu_wall = [DirichletBC(V, noslip, boundary, id_wall), + DirichletBC(V, noslip, boundary, id_wall), + DirichletBC(V, noslip, boundary, id_wall)] + + bcu_wall = [] + for i, coor in enumerate(['x', 'y', 'z']): + bcu_wall.append(DirichletBC(V, NS_expressions["wall_%s" % coor], boundary, id_wall)) # Create lists with all boundary conditions bc_u0 = [] @@ -239,9 +239,9 @@ def create_bcs(NS_expressions, x_, boundary, V, Q, T, mesh, mesh_path, id_in, id bc_u0.append(bc_inlets[ID][0]) bc_u1.append(bc_inlets[ID][1]) bc_u2.append(bc_inlets[ID][2]) - bc_u0.append(bcu_wall_x) - bc_u1.append(bcu_wall_y) - bc_u2.append(bcu_wall_z) + bc_u0.append(bcu_wall[0]) + bc_u1.append(bcu_wall[1]) + bc_u2.append(bcu_wall[2]) return dict(u0=bc_u0, u1=bc_u1, u2=bc_u2, p=bc_p) @@ -315,7 +315,7 @@ def temporal_hook(u_, mesh, newfolder, tstep, t, save_step_problem, u_vec, viz_u viz_u.write(u_vec, t) if tstep % save_step_problem * 5 == 0: - L_mitral = 20 + L_mitral = 26 h = mesh.hmin() ComputeReynoldsNumberAndCFL(u_, L_mitral, nu, mesh, t, tstep, dt, h, dynamic_mesh=False) From 7d1609dcb2b4a4374db65e293e99eba13cd7cb4b Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 2 Nov 2021 13:42:52 +0100 Subject: [PATCH 44/76] Fix check for capped surface --- automatedPreProcessing/automatedPreProcessing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 952b02d3..14e9ed47 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -63,7 +63,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin print("--- Load model file\n") surface = read_polydata(filename_model) - if not is_surface_capped(surface) and smoothing_method != "voronoi": + if is_surface_capped(surface) and smoothing_method != "voronoi": print("--- Clipping the models inlets and outlets.\n") if not path.isfile(file_name_clipped_model): # TODO: Add input parameters as input to automatedPreProcessing From 71319f428b74bb4f66338bc1987aef74f17ea383 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 4 Nov 2021 12:31:45 +0100 Subject: [PATCH 45/76] Update movementPreProcessing with recompute all and flowexteions flag --- .../movementPreProcessing.py | 75 +++++++++++++------ 1 file changed, 54 insertions(+), 21 deletions(-) diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index 84c2e94e..422ff6cf 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -1,5 +1,6 @@ import argparse import os +import shutil from morphman.common import * from vtk.numpy_interface import dataset_adapter as dsa @@ -10,7 +11,8 @@ cell_id_name = "CellEntityIds" -def main(case_path, move_surface, add_extensions, edge_length, patient_specific, recompute_mesh): +def main(case_path, move_surface, add_extensions, edge_length, patient_specific, recompute_mesh, recompute_all, + flow_extension_length): """ Automatically generate movement and mesh of surface model in .vtu and .xml format. Assumes the user either has a set of displaced models or models with mapped displacement fields, @@ -25,6 +27,7 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, edge_length (float): Mesh resolution, characteristic edge length patient_specific (bool): If case has patient-specific movement or not recompute_mesh (bool): Computes mesh if true + recompute_all (bool): Computes everything if true """ # Find model_path if "vtp" in case_path: @@ -39,6 +42,9 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, mesh_path = model_path + ".vtu" mesh_xml_path = mesh_path.replace(".vtu", ".xml") + if recompute_all: + remove_preprocessing_files(case_path, model_path, moved_path) + if not path.exists(moved_path): os.mkdir(moved_path) @@ -64,15 +70,29 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, # Add flow extensions if add_extensions and path.exists(moved_path): - surface_to_mesh = add_flow_extensions(surface, model_path, moved_path, centerlines, edge_length) + surface_to_mesh = add_flow_extensions(surface, model_path, moved_path, centerlines, flow_extension_length, + edge_length) - if not path.exists(mesh_path) or recompute_mesh and surface_to_mesh is not None: + if (not path.exists(mesh_path) or recompute_mesh) and surface_to_mesh is not None: mesh = generate_mesh(surface_to_mesh, mesh_path, mesh_xml_path, edge_length) if path.exists(mesh_path): mesh = read_polydata(mesh_path) - find_ids(surface_to_mesh, model_path, mesh) + if path.exists(mesh_path): + find_ids(surface_to_mesh, model_path, mesh) + + +def remove_preprocessing_files(case_path, model_path, moved_path): + folder = model_path.rsplit("/", 1)[0] + folder_content = os.listdir(folder) + files_to_remove = [f for f in folder_content if not case_path.endswith(f) and not moved_path.endswith(f)] + for f in files_to_remove: + directory = path.join(folder, f) + if path.isdir(directory): + shutil.rmtree(directory) + else: + os.remove(directory) def find_ids(surface_to_mesh, model_path, mesh): @@ -104,7 +124,6 @@ def IdealVolume(t): vmin = 37184.998997815936 vmax = 19490.21405487303 volume = (splev(t, LA_smooth) - vmin) / vmax - return volume @@ -125,12 +144,15 @@ def move_atrium_real(case_path, mapped_path, moved_path, case): def move_atrium(case_path, origin, moved_path, case, cycle=1.0, n_frames=20): # Params - A = 25 / 2 + A = 25 / 3 t_array = np.linspace(0, cycle, n_frames) volumes = [] surface = read_polydata(case_path) - write_polydata(surface, path.join(moved_path, "%s_000.vtp" % case)) + write_polydata(surface, path.join(moved_path, "%s_00.vtp" % case)) + + def SineVolume(t): + return -np.sin(np.pi * t) for i, t in enumerate(t_array): surface = read_polydata(case_path) @@ -139,7 +161,8 @@ def move_atrium(case_path, origin, moved_path, case, cycle=1.0, n_frames=20): for j in range(len(points)): p = points[j] - displacement = IdealVolume(t) + # displacement = IdealVolume(t) + displacement = SineVolume(t) # Axial movement x_o = origin[0] @@ -159,7 +182,7 @@ def move_atrium(case_path, origin, moved_path, case, cycle=1.0, n_frames=20): surface.SetPoints(points) - write_polydata(surface.VTKObject, path.join(moved_path, "%s_%03d.vtp" % (case, 5 + 5 * i))) + write_polydata(surface.VTKObject, path.join(moved_path, "%s_%02d.vtp" % (case, i + 1))) capped_surface = vmtk_cap_polydata(surface.VTKObject) volume = vtk_compute_mass_properties(capped_surface, compute_volume=True) @@ -179,7 +202,7 @@ def capp_surface(remeshed_extended, offset=1): return surface -def add_flow_extensions(surface, model_path, moved_path, centerline, resolution=1.9): +def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extension_length, resolution=1.9): # Create result paths points_path = model_path + "_points.np" remeshed_path = model_path + "_remeshed.vtp" @@ -198,12 +221,19 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, resolution= write_polydata(remeshed, remeshed_path) # Create surface extensions on the original surface - print("-- Adding flow extensions --") - length_in = 1.0 - length_out = 1.0 - remeshed_extended = add_flow_extension(remeshed, centerline, include_outlet=False, extension_length=length_in) - remeshed_extended = add_flow_extension(remeshed_extended, centerline, include_outlet=True, - extension_length=length_out) + if flow_extension_length is not None: + print("-- Adding flow extensions --") + remeshed_extended = add_flow_extension(remeshed, centerline, include_outlet=False, + extension_length=flow_extension_length) + remeshed_extended = add_flow_extension(remeshed_extended, centerline, include_outlet=True, + extension_length=flow_extension_length) + + # Smooth at edges + remeshed_extended = vmtk_smooth_surface(remeshed_extended, "laplace", iterations=50) + else: + print("Skipping flow extensions") + remeshed_extended = vmtk_smooth_surface(remeshed, "laplace", iterations=25) + write_polydata(remeshed_extended, remeshed_extended_path) # Get a point mapper @@ -421,9 +451,9 @@ def add_flow_extension(surface, centerlines, include_outlet, extension_length=2. flowExtensionsFilter = vtkvmtk.vtkvmtkPolyDataFlowExtensionsFilter() flowExtensionsFilter.SetInputData(surface) flowExtensionsFilter.SetCenterlines(centerlines) - flowExtensionsFilter.SetSigma(1.0) flowExtensionsFilter.SetAdaptiveExtensionLength(1) flowExtensionsFilter.SetAdaptiveExtensionRadius(1) + flowExtensionsFilter.SetAdaptiveExtensionLength(1) flowExtensionsFilter.SetAdaptiveNumberOfBoundaryPoints(1) flowExtensionsFilter.SetExtensionRatio(extension_length) flowExtensionsFilter.SetExtensionRadius(1.0) @@ -432,13 +462,11 @@ def add_flow_extension(surface, centerlines, include_outlet, extension_length=2. flowExtensionsFilter.SetExtensionModeToUseCenterlineDirection() flowExtensionsFilter.SetInterpolationModeToThinPlateSpline() flowExtensionsFilter.SetBoundaryIds(boundaryIds) + flowExtensionsFilter.SetSigma(1.0) flowExtensionsFilter.Update() surface = flowExtensionsFilter.GetOutput() - # Smooth at edges - surface = vmtk_smooth_surface(surface, "laplace", iterations=150) - return surface @@ -486,11 +514,16 @@ def read_command_line(): dest="patientSpecific", help="Use patient specific data or constructed movement.") parser.add_argument('-r', '--recompute-mesh', type=str2bool, required=False, default=False, dest="recomputeMesh", help="Recomputes mesh if true.") + parser.add_argument('-ra', '--recompute-all', type=str2bool, required=False, default=False, + dest="recomputeAll", help="Recomputes everything if true.") + parser.add_argument('-fl', '--flowextlen', dest="flowExtLen", default=None, type=float, + help="Adds flow extensions of given length.") args, _ = parser.parse_known_args() return dict(case_path=args.fileNameModel, move_surface=args.moveSurface, add_extensions=args.addExtensions, - edge_length=args.edgeLength, patient_specific=args.patientSpecific, recompute_mesh=args.recomputeMesh) + edge_length=args.edgeLength, patient_specific=args.patientSpecific, recompute_mesh=args.recomputeMesh, + recompute_all=args.recomputeAll, flow_extension_length=args.flowExtLen) if __name__ == '__main__': From 26340e0f6297036e5bfc7c2a234850d51a6ecb42 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 9 Nov 2021 15:55:06 +0100 Subject: [PATCH 46/76] Update arbitrary z-movement --- automatedPreProcessing/movementPreProcessing.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index 422ff6cf..f9a4a500 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -144,7 +144,7 @@ def move_atrium_real(case_path, mapped_path, moved_path, case): def move_atrium(case_path, origin, moved_path, case, cycle=1.0, n_frames=20): # Params - A = 25 / 3 + A = 25 / 3 * 2 t_array = np.linspace(0, cycle, n_frames) volumes = [] @@ -174,7 +174,8 @@ def SineVolume(t): scaling_y = (y_0 - y_o) x_new = A / 100 * scaling_x * displacement y_new = A / 100 * scaling_y * displacement - z_new = A * displacement + z_new = A / 100 * scaling_y * displacement + #z_new = 0 # A * displacement # Longitudinal movement p_new = np.array([x_new, y_new, z_new]) From a29b5d4f4c1ff43532796290473f6500bd2bb7d8 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 11 Nov 2021 13:29:18 +0100 Subject: [PATCH 47/76] Let user provide points defining region to refine --- .../automatedPreProcessing.py | 27 ++++++++++---- automatedPreProcessing/common.py | 36 +++++++++++-------- 2 files changed, 43 insertions(+), 20 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 14e9ed47..dbfc3ab3 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -12,7 +12,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, meshing_method, refine_region, atrium_present, create_flow_extensions, viz, config_path, coarsening_factor, - flow_extension_length, edge_length, compress_mesh=True): + flow_extension_length, edge_length, region_points, compress_mesh=True): """ Automatically generate mesh of surface model in .vtu and .xml format, including prescribed flow rates at inlet and outlet based on flow network model. @@ -25,12 +25,15 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin smoothing_method (str): Method for surface smoothing smoothing_factor (float): Smoothing parameter meshing_method (str): Method for meshing - regine_region (bool): Refines selected region of input if True + refine_region (bool): Refines selected region of input if True atrium_present (bool): Determines whether this is an atrium case create_flow_extensions (bool): Adds flow extensions to mesh if True viz (bool): Visualize resulting surface model with flow rates config_path (str): Path to configuration file for remote simulation coarsening_factor (float): Refine or coarsen the standard mesh size with given factor + region_points (list): User defined points to define which region to refine + edge_length (float): Edge length used for meshing with constant element size + flow_extension_length (float): Factor defining length of flow extensions compress_mesh (bool): Compresses finalized mesh if True """ # Get paths @@ -113,7 +116,8 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin misr_max = [] if refine_region: - regions = get_regions_to_refine(capped_surface, path.join(dir_path, case_name)) + regions = get_regions_to_refine(capped_surface, region_points, path.join(dir_path, case_name)) + centerlineAnu, _, _ = compute_centerlines(source, regions, file_name_refine_region_centerlines, capped_surface, resampling=0.1) @@ -148,7 +152,8 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin region_centerlines = vtk_merge_polydata(refine_region_centerline) for region in refine_region_centerline: - region_center.append(region.GetPoints().GetPoint(region.GetNumberOfPoints() // 2)) + region_factor = 0.9 if atrium_present else 0.5 + region_center.append(region.GetPoints().GetPoint(int(region.GetNumberOfPoints() * region_factor))) tmp_misr = get_point_data_array(radiusArrayName, region) misr_max.append(tmp_misr.max()) @@ -324,7 +329,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin mean_inflow_rate = compute_flow_rate(atrium_present, inlet, parameters) - find_boundaries(path.join(dir_path,case_name), mean_inflow_rate, network, polyDataVolMesh, verbose_print) + find_boundaries(path.join(dir_path, case_name), mean_inflow_rate, network, polyDataVolMesh, verbose_print) # Display the flow split at the outlets, inlet flow rate, and probes. if viz: @@ -418,6 +423,16 @@ def read_command_line(): help="Determine weather or not to refine a specific region of " + "the input model. Default is False.") + parser.add_argument('-rp', '--region-points', + dest="regionPoints", + type=float, + nargs="+", + default=None, + help="If -r or --refine-region is True, the user can provide the point(s)" + " which defines the regions to refine. " + + "Example providing the points (0.1, 5.0, -1) and (1, -5.2, 3.21):" + + " --region-points 0.1 5 -1 1 5.24 3.21") + parser.add_argument('-at', '--atrium', dest="atriumPresent", type=str2bool, @@ -469,7 +484,7 @@ def verbose_print(*args): refine_region=args.refineRegion, atrium_present=args.atriumPresent, create_flow_extensions=args.flowExtension, viz=args.viz, config_path=args.config, coarsening_factor=args.coarseningFactor, flow_extension_length=args.flowExtLen, - edge_length=args.edgeLength) + edge_length=args.edgeLength, region_points=args.regionPoints) if __name__ == "__main__": diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 50cb9ba1..d34bdbf0 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -36,10 +36,10 @@ version = vtk.vtkVersion().GetVTKMajorVersion() -def get_regions_to_refine(surface, dir_path): +def get_regions_to_refine(surface, provided_points, dir_path): # Check if info exists if not path.isfile(path.join(dir_path, dir_path + ".txt")): - provide_region_points(surface, dir_path) + provide_region_points(surface, provided_points, dir_path) # Open info parameters = get_parameters(dir_path) @@ -48,14 +48,14 @@ def get_regions_to_refine(surface, dir_path): if key.startswith("region_"): dome.append(value) - if dome == []: - dome = provide_region_points(surface, dir_path) + if not dome: + dome = provide_region_points(surface, provided_points, dir_path) # Flatten list return [item for sublist in dome for item in sublist] -def provide_region_points(surface, dir_path=None): +def provide_region_points(surface, provided_points, dir_path=None): """ Get relevant region points from user selected points on a input surface. @@ -70,14 +70,21 @@ def provide_region_points(surface, dir_path=None): cleaned_surface = vtk_clean_polydata(surface) triangulated_surface = vtk_triangulate_surface(cleaned_surface) - # Select seeds - SeedSelector = vmtkPickPointSeedSelector() - SeedSelector.SetSurface(triangulated_surface) - SeedSelector.Execute() + if provided_points is None: + # Select seeds + SeedSelector = vmtkPickPointSeedSelector() + SeedSelector.SetSurface(triangulated_surface) + SeedSelector.Execute() - regionSeedIds = SeedSelector.GetTargetSeedIds() - get_point = surface.GetPoints().GetPoint - points = [list(get_point(regionSeedIds.GetId(i))) for i in range(regionSeedIds.GetNumberOfIds())] + regionSeedIds = SeedSelector.GetTargetSeedIds() + get_point = surface.GetPoints().GetPoint + points = [list(get_point(regionSeedIds.GetId(i))) for i in range(regionSeedIds.GetNumberOfIds())] + else: + surface_locator = get_vtk_point_locator(surface) + provided_points = [[provided_points[3 * i], provided_points[3 * i + 1], provided_points[3 * i + 2]] + for i in range(len(provided_points) // 3)] + + points = [list(surface.GetPoint(surface_locator.FindClosestPoint(p))) for p in provided_points] if dir_path is not None: info = {"number_of_regions": len(points)} @@ -340,8 +347,9 @@ def dist_sphere_constant(surface, centerlines, sac_center, misr_max, fileName, e for i in range(len(sac_center)): distance_to_sphere = compute_distance_to_sphere(distance_to_sphere, sac_center[i], - maxDistance=100, - distanceScale=0.2 / (misr_max[i] * 2.)) + minDistance=edge_length / 3, + maxDistance=edge_length, + distanceScale=edge_length * 3 / 4 / (misr_max[i] * 2.)) element_size = edge_length + np.zeros((surface.GetNumberOfPoints(), 1)) if len(sac_center) != 0: From 6a69f1afbff9a72b350a6417544ca5bf9bd9c534 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 11 Nov 2021 17:22:01 +0100 Subject: [PATCH 48/76] Add extension for atrium models based on model boundary --- .../automatedPreProcessing.py | 20 +++----- automatedPreProcessing/common.py | 44 +++++++++++++++++ .../movementPreProcessing.py | 48 +------------------ 3 files changed, 53 insertions(+), 59 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index dbfc3ab3..0a97242f 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -239,19 +239,13 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin if create_flow_extensions: if not path.isfile(file_name_model_flow_ext): print("--- Adding flow extensions\n") - extender = vmtkscripts.vmtkFlowExtensions() - extender.Surface = surface - extender.AdaptiveExtensionLength = 1 - extender.TransitionRatio = 1 - extender.ExtensionRatio = flow_extension_length - extender.Centerlines = centerlines - extender.ExtensionMode = "centerlinedirection" - extender.CenterlineNormalEstimationDistanceRatio = 1.0 - extender.Interactive = 0 - extender.AdaptiveNumberOfBoundaryPoints = 1 - extender.Execute() - - surface = extender.Surface + # Add extension normal on boundary for atrium models + extension = "boundarynormal" if atrium_present else "centerlinedirection" + surface = add_flow_extension(surface, centerlines, include_outlet=False, + extension_length=flow_extension_length) + surface = add_flow_extension(surface, centerlines, include_outlet=True, + extension_length=flow_extension_length, extension_mode=extension) + surface = vmtk_smooth_surface(surface, "laplace", iterations=200) write_polydata(surface, file_name_model_flow_ext) diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index d34bdbf0..497e0e8c 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -701,3 +701,47 @@ def write_mesh(compress_mesh, file_name_surface_name, file_name_vtu_mesh, file_n meshWriter.Execute() polyDataVolMesh = mesh return polyDataVolMesh + + +def add_flow_extension(surface, centerlines, include_outlet, extension_length=2.0, + extension_mode="centerlinedirection"): + # Mimick behaviour of vmtkflowextensionfilter + boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor() + boundaryExtractor.SetInputData(surface) + boundaryExtractor.Update() + boundaries = boundaryExtractor.GetOutput() + + # Find outlet + lengths = [] + for i in range(boundaries.GetNumberOfCells()): + lengths.append(get_curvilinear_coordinate(boundaries.GetCell(i))[-1]) + outlet_id = lengths.index(max(lengths)) + + # Exclude outlet or inlets + boundaryIds = vtk.vtkIdList() + for i in range(centerlines.GetNumberOfLines() + 1): + if include_outlet and i == outlet_id: + boundaryIds.InsertNextId(i) + if not include_outlet and i != outlet_id: + boundaryIds.InsertNextId(i) + + flowExtensionsFilter = vtkvmtk.vtkvmtkPolyDataFlowExtensionsFilter() + flowExtensionsFilter.SetInputData(surface) + flowExtensionsFilter.SetCenterlines(centerlines) + flowExtensionsFilter.SetAdaptiveExtensionLength(1) + flowExtensionsFilter.SetAdaptiveNumberOfBoundaryPoints(1) + flowExtensionsFilter.SetExtensionRatio(extension_length) + flowExtensionsFilter.SetTransitionRatio(1.0) + flowExtensionsFilter.SetCenterlineNormalEstimationDistanceRatio(1.0) + if extension_mode == "centerlinedirection": + flowExtensionsFilter.SetExtensionModeToUseCenterlineDirection() + if extension_mode == "boundarynormal": + flowExtensionsFilter.SetExtensionModeToUseNormalToBoundary() + flowExtensionsFilter.SetInterpolationModeToThinPlateSpline() + flowExtensionsFilter.SetBoundaryIds(boundaryIds) + flowExtensionsFilter.SetSigma(1.0) + flowExtensionsFilter.Update() + + surface = flowExtensionsFilter.GetOutput() + + return surface diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index f9a4a500..3e357140 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -5,7 +5,7 @@ from morphman.common import * from vtk.numpy_interface import dataset_adapter as dsa -from common import get_centers_for_meshing, find_boundaries, setup_model_network, compute_flow_rate +from common import get_centers_for_meshing, find_boundaries, setup_model_network, compute_flow_rate, add_flow_extension from visualize import visualize cell_id_name = "CellEntityIds" @@ -175,7 +175,7 @@ def SineVolume(t): x_new = A / 100 * scaling_x * displacement y_new = A / 100 * scaling_y * displacement z_new = A / 100 * scaling_y * displacement - #z_new = 0 # A * displacement + # z_new = 0 # A * displacement # Longitudinal movement p_new = np.array([x_new, y_new, z_new]) @@ -427,50 +427,6 @@ def get_point_map(remeshed, remeshed_extended): return distances, point_map -def add_flow_extension(surface, centerlines, include_outlet, extension_length=2.0): - # Mimick behaviour of vmtkflowextensionfilter - boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor() - boundaryExtractor.SetInputData(surface) - boundaryExtractor.Update() - boundaries = boundaryExtractor.GetOutput() - - # Find outlet - lengths = [] - for i in range(boundaries.GetNumberOfCells()): - lengths.append(get_curvilinear_coordinate(boundaries.GetCell(i))[-1]) - outlet_id = lengths.index(max(lengths)) - - # Exclude outlet or inlets - boundaryIds = vtk.vtkIdList() - for i in range(centerlines.GetNumberOfLines() + 1): - if include_outlet and i == outlet_id: - boundaryIds.InsertNextId(i) - else: - if i != outlet_id: - boundaryIds.InsertNextId(i) - - flowExtensionsFilter = vtkvmtk.vtkvmtkPolyDataFlowExtensionsFilter() - flowExtensionsFilter.SetInputData(surface) - flowExtensionsFilter.SetCenterlines(centerlines) - flowExtensionsFilter.SetAdaptiveExtensionLength(1) - flowExtensionsFilter.SetAdaptiveExtensionRadius(1) - flowExtensionsFilter.SetAdaptiveExtensionLength(1) - flowExtensionsFilter.SetAdaptiveNumberOfBoundaryPoints(1) - flowExtensionsFilter.SetExtensionRatio(extension_length) - flowExtensionsFilter.SetExtensionRadius(1.0) - flowExtensionsFilter.SetTransitionRatio(1.0) - flowExtensionsFilter.SetCenterlineNormalEstimationDistanceRatio(1.0) - flowExtensionsFilter.SetExtensionModeToUseCenterlineDirection() - flowExtensionsFilter.SetInterpolationModeToThinPlateSpline() - flowExtensionsFilter.SetBoundaryIds(boundaryIds) - flowExtensionsFilter.SetSigma(1.0) - flowExtensionsFilter.Update() - - surface = flowExtensionsFilter.GetOutput() - - return surface - - def remesh_surface(surface, edge_length, exclude=None): surface = dsa.WrapDataObject(surface) if cell_id_name not in surface.CellData.keys(): From f1f4ebd3aebab517e315b895198a3820b18ecfff Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 11 Nov 2021 18:21:54 +0100 Subject: [PATCH 49/76] User boundarynormal for flow extensions in Atrium case --- automatedPreProcessing/movementPreProcessing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index 3e357140..65fbc1d7 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -227,7 +227,7 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extens remeshed_extended = add_flow_extension(remeshed, centerline, include_outlet=False, extension_length=flow_extension_length) remeshed_extended = add_flow_extension(remeshed_extended, centerline, include_outlet=True, - extension_length=flow_extension_length) + extension_length=flow_extension_length, extension_mode="boundarynormal") # Smooth at edges remeshed_extended = vmtk_smooth_surface(remeshed_extended, "laplace", iterations=50) From 226b95ce9e9e4aee37012c9ed28aed8507e5233f Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Mon, 15 Nov 2021 13:55:08 +0100 Subject: [PATCH 50/76] Getting gradianets_limit parameter as argument --- automatedPreProcessing/automatedPreProcessing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 0a97242f..6daf076e 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -70,7 +70,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin print("--- Clipping the models inlets and outlets.\n") if not path.isfile(file_name_clipped_model): # TODO: Add input parameters as input to automatedPreProcessing - surface = get_uncapped_surface(surface, area_limit=20, circleness_limit=5) + surface = get_uncapped_surface(surface, 'gradients_limit=0.01', area_limit=20, circleness_limit=5) write_polydata(surface, file_name_clipped_model) else: surface = read_polydata(file_name_clipped_model) From 94c4442817ea2b3b001cd9eda7541c91c93d4e7f Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 16 Nov 2021 08:55:02 +0100 Subject: [PATCH 51/76] Update clipping --- automatedPreProcessing/automatedPreProcessing.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 6daf076e..5decacbc 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -66,11 +66,11 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin print("--- Load model file\n") surface = read_polydata(filename_model) - if is_surface_capped(surface) and smoothing_method != "voronoi": + if not is_surface_capped(surface) and smoothing_method != "voronoi": print("--- Clipping the models inlets and outlets.\n") if not path.isfile(file_name_clipped_model): # TODO: Add input parameters as input to automatedPreProcessing - surface = get_uncapped_surface(surface, 'gradients_limit=0.01', area_limit=20, circleness_limit=5) + surface = get_uncapped_surface(surface, gradients_limit=0.01, area_limit=20, circleness_limit=5) write_polydata(surface, file_name_clipped_model) else: surface = read_polydata(file_name_clipped_model) From c4c4a280e7645bab7dbad768abc0f0beb515d49d Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 18 Nov 2021 02:04:58 +0100 Subject: [PATCH 52/76] Update travis yml --- .travis.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index ef2cdfc0..e0af4b84 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,10 +26,15 @@ install: - conda config --set always_yes yes --set changeps1 no - conda config --add channels vmtk - conda config --add channels morphman + - conda config --add channels conda-forge - # Set up environment + # Set up environments - conda create -n morphmanEnv morphman pytest llvm=3.3 paramiko + # Dependencies for code coverage and plotting + - pip install pytest-cov codecov matplotlib + - pip install -U numpy + # Activate environment - source activate morphmanEnv @@ -41,8 +46,6 @@ install: - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py - # Dependencies for code coverage and plotting - - pip install pytest-cov codecov matplotlib script: From 46bb0bfb2a66a6f52201b741eb730e3129108676 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 18 Nov 2021 02:08:40 +0100 Subject: [PATCH 53/76] Update travis --- .travis.yml | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index e0af4b84..25c2d26b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,15 +26,10 @@ install: - conda config --set always_yes yes --set changeps1 no - conda config --add channels vmtk - conda config --add channels morphman - - conda config --add channels conda-forge # Set up environments - conda create -n morphmanEnv morphman pytest llvm=3.3 paramiko - # Dependencies for code coverage and plotting - - pip install pytest-cov codecov matplotlib - - pip install -U numpy - # Activate environment - source activate morphmanEnv @@ -46,7 +41,9 @@ install: - sed -i -e 's/len(self.TargetPoints)\/3/len\(self.TargetPoints\)\/\/3/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtkcenterlines.py - sed -i -e 's/(len(values) - 1)\/2/\(len\(values\) - 1\)\/\/2/g' ../../../miniconda/envs/morphmanEnv/lib/python3.6/site-packages/vmtk/vmtksurfacecurvature.py - + # Dependencies for code coverage and plotting + - pip install pytest-cov codecov matplotlib + - pip install -U numpy script: - cd test From 2dea06a390118d225ee87e56e20313ed9117720a Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 18 Nov 2021 02:13:00 +0100 Subject: [PATCH 54/76] Update travis --- .travis.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.travis.yml b/.travis.yml index 25c2d26b..d29b7565 100644 --- a/.travis.yml +++ b/.travis.yml @@ -44,6 +44,9 @@ install: # Dependencies for code coverage and plotting - pip install pytest-cov codecov matplotlib - pip install -U numpy + - pip install -U scipy + + script: - cd test From 13e1c25bcca2aea835ac3b8c094482726b39326e Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Thu, 18 Nov 2021 20:34:15 +0100 Subject: [PATCH 55/76] Refactor automatedPreProcessing, add print statements --- .../automatedPreProcessing.py | 28 +++++-------------- 1 file changed, 7 insertions(+), 21 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 5decacbc..7c03d72a 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -92,11 +92,8 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin parameters["check_surface"] = True write_parameters(parameters, path.join(dir_path, case_name)) - # Capp surface if open - if not compute_centers_for_meshing(surface, atrium_present, test_capped=True): - capped_surface = vmtk_cap_polydata(surface) - else: - capped_surface = surface + # Create a capped version of the surface + capped_surface = vmtk_cap_polydata(surface) # Get centerlines print("--- Get centerlines\n") @@ -107,8 +104,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin else: source = inlet target = outlets - centerlines, _, _ = compute_centerlines(source, target, file_name_centerlines, capped_surface, resampling=0.1, - end_point=0) + centerlines, _, _ = compute_centerlines(source, target, file_name_centerlines, capped_surface, resampling=0.1) tol = get_centerline_tolerance(centerlines) # Get 'center' and 'radius' of the regions(s) @@ -210,21 +206,10 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin else: surface = read_polydata(file_name_surface_smooth) - elif smoothing_method == "laplace": - print("--- Smooth surface: Laplacian smoothing\n") - if not path.isfile(file_name_surface_smooth): - surface = vmtk_smooth_surface(surface, smoothing_method) - - # Save the smoothed surface - write_polydata(surface, file_name_surface_smooth) - - else: - surface = read_polydata(file_name_surface_smooth) - - elif smoothing_method == "taubin": - print("--- Smooth surface: Taubin smoothing\n") + elif smoothing_method in ["laplace", "taubin"]: + print("--- Smooth surface: {} smoothing\n".format(smoothing_method.capitalize())) if not path.isfile(file_name_surface_smooth): - surface = vmtk_smooth_surface(surface, smoothing_method) + surface = vmtk_smooth_surface(surface, smoothing_method, iterations=400) # Save the smoothed surface write_polydata(surface, file_name_surface_smooth) @@ -321,6 +306,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # BSL method for mean inlet flow rate. parameters = get_parameters(path.join(dir_path, case_name)) + print("--- Computing flow rates and flow split, and setting boundary IDs\n") mean_inflow_rate = compute_flow_rate(atrium_present, inlet, parameters) find_boundaries(path.join(dir_path, case_name), mean_inflow_rate, network, polyDataVolMesh, verbose_print) From 535f64a0b06d2b9afafa935f7ab8c2e62f5380d1 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Tue, 23 Nov 2021 14:33:03 +0100 Subject: [PATCH 56/76] Add movement projection to preprocessing script for dynamic meshes --- .../automatedPreProcessing.py | 94 +++++--- automatedPreProcessing/common.py | 211 +++++++++++++++++- .../movementPreProcessing.py | 131 ++--------- 3 files changed, 291 insertions(+), 145 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 7c03d72a..d1065b8b 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -6,13 +6,15 @@ import ToolRepairSTL # Local imports from common import * +from movementPreProcessing import get_point_map from simulate import run_simulation from visualize import visualize def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothing_factor, meshing_method, refine_region, atrium_present, create_flow_extensions, viz, config_path, coarsening_factor, - flow_extension_length, edge_length, region_points, compress_mesh=True): + flow_extension_length, edge_length, region_points, dynamic_mesh, clamp_boundaries, + compress_mesh=True): """ Automatically generate mesh of surface model in .vtu and .xml format, including prescribed flow rates at inlet and outlet based on flow network model. @@ -35,6 +37,8 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin edge_length (float): Edge length used for meshing with constant element size flow_extension_length (float): Factor defining length of flow extensions compress_mesh (bool): Compresses finalized mesh if True + dynamic_mesh (bool): Computes projected movement for displaced surfaces located in [filename_model]_moved folder + clamp_boundaries (bool): Clamps inlet(s) and outlet if true """ # Get paths abs_path = path.abspath(path.dirname(__file__)) @@ -59,6 +63,9 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin file_name_xml_mesh = path.join(dir_path, case_name + ".xml") file_name_vtu_mesh = path.join(dir_path, case_name + ".vtu") file_name_run_script = path.join(dir_path, case_name + ".sh") + file_name_displacement_points = path.join(dir_path, case_name + "_points.np") + folder_moved_surfaces = path.join(dir_path, case_name + "_moved") + folder_extended_surfaces = path.join(dir_path, case_name + "_extended") print("\n--- Working on case:", case_name, "\n") @@ -226,55 +233,70 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin print("--- Adding flow extensions\n") # Add extension normal on boundary for atrium models extension = "boundarynormal" if atrium_present else "centerlinedirection" - surface = add_flow_extension(surface, centerlines, include_outlet=False, - extension_length=flow_extension_length) - surface = add_flow_extension(surface, centerlines, include_outlet=True, - extension_length=flow_extension_length, extension_mode=extension) + surface_extended = add_flow_extension(surface, centerlines, include_outlet=False, + extension_length=flow_extension_length) + surface_extended = add_flow_extension(surface_extended, centerlines, include_outlet=True, + extension_length=flow_extension_length, extension_mode=extension) - surface = vmtk_smooth_surface(surface, "laplace", iterations=200) - write_polydata(surface, file_name_model_flow_ext) + write_polydata(surface_extended, file_name_model_flow_ext) else: - surface = read_polydata(file_name_model_flow_ext) + surface_extended = read_polydata(file_name_model_flow_ext) + else: + surface_extended = surface - # Capp surface with flow extensions - capped_surface = vmtk_cap_polydata(surface) + # Smooth and capp surface with flow extensions + surface_extended = vmtk_smooth_surface(surface_extended, "laplace", iterations=200) + capped_surface = vmtk_cap_polydata(surface_extended) + + if dynamic_mesh: + # Get a point mapper + distance, point_map = get_point_map(surface, surface_extended) + + # Project displacement between surfaces + points = project_displacement(clamp_boundaries, distance, folder_extended_surfaces, folder_moved_surfaces, + point_map, surface, surface_extended) + + # Save displacement to numpy array + save_displacement(file_name_displacement_points, points) # Get new centerlines with the flow extensions - if not path.isfile(file_name_flow_centerlines): - print("--- Compute the model centerlines with flow extension.\n") - # Compute the centerlines. FIXIT: There are several inlets and one outet for atrium case - inlet, outlets = get_centers_for_meshing(surface, atrium_present, path.join(dir_path, case_name), flowext=True) - if atrium_present: - source = outlets - target = inlet - else: - source = inlet - target = outlets - centerlines, _, _ = compute_centerlines(source, target, file_name_flow_centerlines, capped_surface, - resampling=0.1) + if create_flow_extensions: + if not path.isfile(file_name_flow_centerlines): + print("--- Compute the model centerlines with flow extension.\n") + # Compute the centerlines. FIXIT: There are several inlets and one outet for atrium case + inlet, outlets = get_centers_for_meshing(surface_extended, atrium_present, path.join(dir_path, case_name), + flowext=True) + if atrium_present: + source = outlets + target = inlet + else: + source = inlet + target = outlets + centerlines, _, _ = compute_centerlines(source, target, file_name_flow_centerlines, capped_surface, + resampling=0.1) - else: - centerlines = read_polydata(file_name_flow_centerlines) + else: + centerlines = read_polydata(file_name_flow_centerlines) # Choose input for the mesh print("--- Computing distance to sphere\n") if meshing_method == "constant": if not path.isfile(file_name_distance_to_sphere_const): - distance_to_sphere = dist_sphere_constant(surface, centerlines, region_center, misr_max, + distance_to_sphere = dist_sphere_constant(surface_extended, centerlines, region_center, misr_max, file_name_distance_to_sphere_const, edge_length) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_const) elif meshing_method == "curvature": if not path.isfile(file_name_distance_to_sphere_curv): - distance_to_sphere = dist_sphere_curv(surface, centerlines, region_center, misr_max, + distance_to_sphere = dist_sphere_curv(surface_extended, centerlines, region_center, misr_max, file_name_distance_to_sphere_curv, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_curv) elif meshing_method == "diameter": if not path.isfile(file_name_distance_to_sphere_diam): - distance_to_sphere = dist_sphere_diam(surface, centerlines, region_center, misr_max, + distance_to_sphere = dist_sphere_diam(surface_extended, centerlines, region_center, misr_max, file_name_distance_to_sphere_diam, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_diam) @@ -313,7 +335,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin # Display the flow split at the outlets, inlet flow rate, and probes. if viz: - visualize(network.elements, probe_points, surface, mean_inflow_rate) + visualize(network.elements, probe_points, surface_extended, mean_inflow_rate) # Start simulation though ssh, without password if config_path is not None: @@ -431,6 +453,19 @@ def read_command_line(): type=float, help="Length of flow extensions.") + parser.add_argument('-dm', '--dynamic-mesh', + dest="dynamicMesh", + default=False, + type=str2bool, + help="If true, assumes a dynamic mesh and will perform computation of projection " + + "between moved surfaces located in the '[filename_model]_moved' folder.") + + parser.add_argument('-cl', '--clamp-boundaries', + dest="clampBoundaries", + default=False, + type=str2bool, + help="Clamps boundaries at inlet(s) and outlet if true.") + parser.add_argument('-vz', '--visualize', dest="viz", default=True, @@ -464,7 +499,8 @@ def verbose_print(*args): refine_region=args.refineRegion, atrium_present=args.atriumPresent, create_flow_extensions=args.flowExtension, viz=args.viz, config_path=args.config, coarsening_factor=args.coarseningFactor, flow_extension_length=args.flowExtLen, - edge_length=args.edgeLength, region_points=args.regionPoints) + edge_length=args.edgeLength, region_points=args.regionPoints, dynamic_mesh=args.dynamicMesh, + clamp_boundaries=args.clampBoundaries) if __name__ == "__main__": diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index 497e0e8c..ecca39f2 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -1,4 +1,5 @@ from morphman.common import * +from vtk.numpy_interface import dataset_adapter as dsa import ImportData from NetworkBoundaryConditions import FlowSplitting @@ -8,7 +9,7 @@ except ImportError: pass import numpy as np -from os import path +from os import path, listdir, mkdir # Global array names radiusArrayName = 'MaximumInscribedSphereRadius' @@ -745,3 +746,211 @@ def add_flow_extension(surface, centerlines, include_outlet, extension_length=2. surface = flowExtensionsFilter.GetOutput() return surface + + +####################### +# MOVING MESH SCRIPTS # +####################### + +def get_point_map(remeshed, remeshed_extended): + """ + Create a map between original surface model and model with + flow extensions; remeshed_extended, for clamping the inlet(s) + and outlet. A linear profile for movement between endpoints + and moving domain is prescribed. + + Args: + remeshed (vtkPolyData): Input surface + remeshed_extended (vtkPolyData): Input surface with flow extensions + + Returns: + distances (ndarray): Array of linear profile between boundary and moving mesh + point_map (ndarray): Mapping between surface IDs and points along extension + """ + remeshed = dsa.WrapDataObject(remeshed) + remeshed_extended = dsa.WrapDataObject(remeshed_extended) + + # Get lengths + num_re = remeshed.Points.shape[0] + num_ext = remeshed_extended.Points.shape[0] - remeshed.Points.shape[0] + + # Get locators + inner_feature = vtk_compute_connectivity(vtk_extract_feature_edges(remeshed.VTKObject)) + outer_feature = vtk_compute_connectivity(vtk_extract_feature_edges(remeshed_extended.VTKObject)) + locator_remeshed = get_vtk_point_locator(remeshed.VTKObject) + + n_features = outer_feature.GetPointData().GetArray("RegionId").GetValue(outer_feature.GetNumberOfPoints() - 1) + inner_features = np.array( + [vtk_compute_threshold(inner_feature, "RegionId", i, i + 0.1, source=0) for i in range(n_features + 1)]) + outer_features = np.array( + [vtk_compute_threshold(outer_feature, "RegionId", i, i + 0.1, source=0) for i in range(n_features + 1)]) + + inner_regions = [dsa.WrapDataObject(feature) for feature in inner_features] + inner_locators = [get_vtk_point_locator(feature) for feature in inner_features] + inner_points = [feature.GetNumberOfPoints() for feature in inner_features] + + outer_regions = [dsa.WrapDataObject(feature) for feature in outer_features] + outer_locators = [get_vtk_point_locator(feature) for feature in outer_features] + outer_points = [feature.GetNumberOfPoints() for feature in outer_features] + boundary_map = {i: j for i, j in zip(np.argsort(inner_points), np.argsort(outer_points))} + + # Get distance and point map + distances = np.zeros(num_ext) + point_map = np.zeros(num_ext) + + for i in range(num_ext): + point = remeshed_extended.Points[num_re + i] + tmp_dist = 1E16 + tmp_id = -1 + # Some hacks to find the correct corresponding points + for region_id in range(len(outer_features)): + region_id_out = boundary_map[region_id] + id_i = inner_locators[region_id].FindClosestPoint(point) + id_o = outer_locators[region_id_out].FindClosestPoint(point) + + p_i = inner_features[region_id].GetPoint(id_i) + p_o = outer_features[region_id_out].GetPoint(id_o) + + dist_o = get_distance(point, p_i) + dist_i = get_distance(point, p_o) + dist_total = dist_i + dist_o + if dist_total < tmp_dist: + tmp_dist = dist_total + tmp_id = region_id + + regionId = tmp_id + regionId_out = boundary_map[regionId] + inner_id = inner_locators[regionId].FindClosestPoint(point) + outer_id = outer_locators[regionId_out].FindClosestPoint(point) + + dist_to_boundary = get_distance(point, outer_regions[regionId_out].Points[outer_id]) + dist_between_boundaries = get_distance(inner_regions[regionId].Points[inner_id], + outer_regions[regionId_out].Points[outer_id]) + distances[i] = dist_to_boundary / dist_between_boundaries + point_map[i] = locator_remeshed.FindClosestPoint(inner_regions[regionId].Points[inner_id]) + + # Let the points corresponding to the caps have distance 0 + point_map = point_map.astype(int) + + return distances, point_map + + +def move_surface_model(surface, original, remeshed, remeshed_extended, distance, point_map, file_path, i, points, + clamp_boundaries): + """ + + Args: + surface: + original: + remeshed: + remeshed_extended: + distance: + point_map: + file_path: + i: + points: + clamp_boundaries: + + Returns: + + """ + surface = dsa.WrapDataObject(surface) + original = dsa.WrapDataObject(original) + remeshed = dsa.WrapDataObject(remeshed) + remeshed_extended = dsa.WrapDataObject(remeshed_extended) + + if "displacement" in original.PointData.keys(): + original.VTKObject.GetPointData().RemoveArray("displacement") + + if "displacement" in remeshed_extended.PointData.keys(): + remeshed_extended.VTKObject.GetPointData().RemoveArray("displacement") + + # Get displacement field + original.PointData.append(surface.Points - original.Points, "displacement") + + # Get + projector = vmtkscripts.vmtkSurfaceProjection() + projector.Surface = remeshed_extended.VTKObject + projector.ReferenceSurface = original.VTKObject + projector.Execute() + + # New surface + new_surface = projector.Surface + new_surface = dsa.WrapDataObject(new_surface) + + # Manipulate displacement in the extensions + displacement = new_surface.PointData["displacement"] + if clamp_boundaries: + displacement[remeshed.Points.shape[0]:] = distance * displacement[point_map] + else: + displacement[remeshed.Points.shape[0]:] = displacement[point_map] + + # Move the mesh points + new_surface.Points += displacement + write_polydata(new_surface.VTKObject, file_path) + points[:, :, i] = new_surface.Points.copy() + new_surface.Points -= displacement + + +def save_displacement(file_name_displacement_points, points): + """ + Resample displacement points and write them + to numpy data array + + Args: + file_name_displacement_points (str): Path to numpy point path + points (ndarray): Numpy array consisting of displacement surface points + """ + N = 200 + + points[:, :, -1] = points[:, :, 0] + time = np.linspace(0, 1, points.shape[2]) + N2 = N + N // (time.shape[0] - 1) + + move = np.zeros((points.shape[0], points.shape[1], N + 1)) + move[:, 0, :] = resample(points[:, 0, :], N2, time, axis=1)[0][:, :N - N2 + 1] + move[:, 1, :] = resample(points[:, 1, :], N2, time, axis=1)[0][:, :N - N2 + 1] + move[:, 2, :] = resample(points[:, 2, :], N2, time, axis=1)[0][:, :N - N2 + 1] + + points = move + points.dump(file_name_displacement_points) + + +def project_displacement(clamp_boundaries, distance, folder_extended_surfaces, folder_moved_surfaces, point_map, + surface, surface_extended): + """ + + Args: + clamp_boundaries: + distance: + folder_extended_surfaces: + folder_moved_surfaces: + point_map: + surface: + surface_extended: + + Returns: + + """ + # Add extents to all surfaces + extended_surfaces = sorted([f for f in listdir(folder_moved_surfaces) if f[:2] == "LA"]) + if not path.exists(folder_extended_surfaces): + mkdir(folder_extended_surfaces) + + n_surfaces = len(extended_surfaces) + + print("-- Projecting surfaces --") + points = np.zeros((surface_extended.GetNumberOfPoints(), 3, n_surfaces)) + for i in range(n_surfaces): + model_path = path.join(folder_moved_surfaces, extended_surfaces[i]) + if i == 0: + points[:, :, i] = dsa.WrapDataObject(surface_extended).Points + continue + + tmp_surface = read_polydata(model_path) + new_path = path.join(folder_extended_surfaces, model_path.split("/")[-1]) + if not path.exists(new_path): + move_surface_model(tmp_surface, surface, surface, surface_extended, distance, point_map, new_path, i, + points, clamp_boundaries) + + return points diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index 65fbc1d7..dbc14cf8 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -5,14 +5,15 @@ from morphman.common import * from vtk.numpy_interface import dataset_adapter as dsa -from common import get_centers_for_meshing, find_boundaries, setup_model_network, compute_flow_rate, add_flow_extension +from common import get_centers_for_meshing, find_boundaries, setup_model_network, compute_flow_rate, add_flow_extension, \ + move_surface_model, get_point_map from visualize import visualize cell_id_name = "CellEntityIds" def main(case_path, move_surface, add_extensions, edge_length, patient_specific, recompute_mesh, recompute_all, - flow_extension_length): + flow_extension_length, clamp_boundaries): """ Automatically generate movement and mesh of surface model in .vtu and .xml format. Assumes the user either has a set of displaced models or models with mapped displacement fields, @@ -21,6 +22,8 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, Can add patient-specific or arbitrary movement to model. Args: + flow_extension_length (float): Length of flow extensions, factor of MISR + clamp_boundaries (bool): Clamps inlet(s) and outlet if true case_path (str): Path to case move_surface (bool): To move surface or not add_extensions (bool): To add flow extensions or not @@ -71,10 +74,10 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, # Add flow extensions if add_extensions and path.exists(moved_path): surface_to_mesh = add_flow_extensions(surface, model_path, moved_path, centerlines, flow_extension_length, - edge_length) + clamp_boundaries, edge_length) if (not path.exists(mesh_path) or recompute_mesh) and surface_to_mesh is not None: - mesh = generate_mesh(surface_to_mesh, mesh_path, mesh_xml_path, edge_length) + mesh = generate_mesh_without_layers(surface_to_mesh, mesh_path, mesh_xml_path, edge_length, centerlines) if path.exists(mesh_path): mesh = read_polydata(mesh_path) @@ -203,7 +206,8 @@ def capp_surface(remeshed_extended, offset=1): return surface -def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extension_length, resolution=1.9): +def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extension_length, clamp_boundaries, + resolution=1.9): # Create result paths points_path = model_path + "_points.np" remeshed_path = model_path + "_remeshed.vtp" @@ -232,8 +236,8 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extens # Smooth at edges remeshed_extended = vmtk_smooth_surface(remeshed_extended, "laplace", iterations=50) else: - print("Skipping flow extensions") - remeshed_extended = vmtk_smooth_surface(remeshed, "laplace", iterations=25) + print("-- Skipping flow extensions --") + remeshed_extended = vmtk_smooth_surface(remeshed, "laplace", iterations=50) write_polydata(remeshed_extended, remeshed_extended_path) @@ -256,8 +260,7 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extens new_path = path.join(extended_path, model_path.split("/")[-1]) if not path.exists(new_path): move_surface_model(tmp_surface, surface, remeshed, remeshed_extended, distance, point_map, new_path, i, - points) - + points, clamp_boundaries) # Resample points and write to file N = 200 points[:, :, -1] = points[:, :, 0] @@ -274,7 +277,7 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extens return remeshed_extended -def generate_mesh(surface, mesh_path, mesh_xml_path, resolution): +def generate_mesh_without_layers(surface, mesh_path, mesh_xml_path, resolution): # Cap mitral valve print("-- Meshing surface --") surface = dsa.WrapDataObject(surface) @@ -323,110 +326,6 @@ def generate_mesh(surface, mesh_path, mesh_xml_path, resolution): return mesh -def move_surface_model(surface, original, remeshed, remeshed_extended, distance, point_map, file_path, i, points): - surface = dsa.WrapDataObject(surface) - original = dsa.WrapDataObject(original) - remeshed = dsa.WrapDataObject(remeshed) - remeshed_extended = dsa.WrapDataObject(remeshed_extended) - - if "displacement" in original.PointData.keys(): - original.VTKObject.GetPointData().RemoveArray("displacement") - - if "displacement" in remeshed_extended.PointData.keys(): - remeshed_extended.VTKObject.GetPointData().RemoveArray("displacement") - - # Get displacement field - original.PointData.append(surface.Points - original.Points, "displacement") - - # Get - projector = vmtkscripts.vmtkSurfaceProjection() - projector.Surface = remeshed_extended.VTKObject - projector.ReferenceSurface = original.VTKObject - projector.Execute() - - # New surface - new_surface = projector.Surface - new_surface = dsa.WrapDataObject(new_surface) - - # Manipulate displacement in the extensions - displacement = new_surface.PointData["displacement"] - displacement[remeshed.Points.shape[0]:] = distance * displacement[point_map] - - # Move the mesh points - new_surface.Points += displacement - write_polydata(new_surface.VTKObject, file_path) - points[:, :, i] = new_surface.Points.copy() - new_surface.Points -= displacement - - -def get_point_map(remeshed, remeshed_extended): - remeshed = dsa.WrapDataObject(remeshed) - remeshed_extended = dsa.WrapDataObject(remeshed_extended) - - # Get lengths - num_re = remeshed.Points.shape[0] - num_ext = remeshed_extended.Points.shape[0] - remeshed.Points.shape[0] - - # Get locators - inner_feature = vtk_compute_connectivity(vtk_extract_feature_edges(remeshed.VTKObject)) - outer_feature = vtk_compute_connectivity(vtk_extract_feature_edges(remeshed_extended.VTKObject)) - locator_remeshed = get_vtk_point_locator(remeshed.VTKObject) - - n_features = outer_feature.GetPointData().GetArray("RegionId").GetValue(outer_feature.GetNumberOfPoints() - 1) - inner_features = np.array( - [vtk_compute_threshold(inner_feature, "RegionId", i, i + 0.1, source=0) for i in range(n_features + 1)]) - outer_features = np.array( - [vtk_compute_threshold(outer_feature, "RegionId", i, i + 0.1, source=0) for i in range(n_features + 1)]) - - inner_regions = [dsa.WrapDataObject(feature) for feature in inner_features] - inner_locators = [get_vtk_point_locator(feature) for feature in inner_features] - inner_points = [feature.GetNumberOfPoints() for feature in inner_features] - - outer_regions = [dsa.WrapDataObject(feature) for feature in outer_features] - outer_locators = [get_vtk_point_locator(feature) for feature in outer_features] - outer_points = [feature.GetNumberOfPoints() for feature in outer_features] - boundary_map = {i: j for i, j in zip(np.argsort(inner_points), np.argsort(outer_points))} - - # Get distance and point map - distances = np.zeros(num_ext) - point_map = np.zeros(num_ext) - - for i in range(num_ext): - point = remeshed_extended.Points[num_re + i] - tmp_dist = 1E16 - tmp_id = -1 - # Some hacks to find the correct corresponding points - for region_id in range(len(outer_features)): - region_id_out = boundary_map[region_id] - id_i = inner_locators[region_id].FindClosestPoint(point) - id_o = outer_locators[region_id_out].FindClosestPoint(point) - - p_i = inner_features[region_id].GetPoint(id_i) - p_o = outer_features[region_id_out].GetPoint(id_o) - - dist_o = get_distance(point, p_i) - dist_i = get_distance(point, p_o) - dist_total = dist_i + dist_o - if dist_total < tmp_dist: - tmp_dist = dist_total - tmp_id = region_id - - regionId = tmp_id - regionId_out = boundary_map[regionId] - inner_id = inner_locators[regionId].FindClosestPoint(point) - outer_id = outer_locators[regionId_out].FindClosestPoint(point) - - dist_to_boundary = get_distance(point, outer_regions[regionId_out].Points[outer_id]) - dist_between_boundaries = get_distance(inner_regions[regionId].Points[inner_id], - outer_regions[regionId_out].Points[outer_id]) - distances[i] = dist_to_boundary / dist_between_boundaries - point_map[i] = locator_remeshed.FindClosestPoint(inner_regions[regionId].Points[inner_id]) - - # Let the points corresponding to the caps have distance 0 - point_map = point_map.astype(int) - return distances, point_map - - def remesh_surface(surface, edge_length, exclude=None): surface = dsa.WrapDataObject(surface) if cell_id_name not in surface.CellData.keys(): @@ -475,12 +374,14 @@ def read_command_line(): dest="recomputeAll", help="Recomputes everything if true.") parser.add_argument('-fl', '--flowextlen', dest="flowExtLen", default=None, type=float, help="Adds flow extensions of given length.") + parser.add_argument('-c', '--clamp-boundaries', dest="clamp", default=False, type=str2bool, + help="Clamps boundaries at inlet(s) and outlet if true.") args, _ = parser.parse_known_args() return dict(case_path=args.fileNameModel, move_surface=args.moveSurface, add_extensions=args.addExtensions, edge_length=args.edgeLength, patient_specific=args.patientSpecific, recompute_mesh=args.recomputeMesh, - recompute_all=args.recomputeAll, flow_extension_length=args.flowExtLen) + recompute_all=args.recomputeAll, flow_extension_length=args.flowExtLen, clamp_boundaries=args.clamp) if __name__ == '__main__': From 9fcca82ba6de391d38a9648988838b451fcf6133 Mon Sep 17 00:00:00 2001 From: Henrik Kjedsberg Date: Fri, 10 Dec 2021 17:42:22 +0100 Subject: [PATCH 57/76] Add funnel and coarsening mesh part --- .../automatedPreProcessing.py | 130 +++++++++++------- automatedPreProcessing/common.py | 98 ++++++++++++- .../movementPreProcessing.py | 20 ++- 3 files changed, 186 insertions(+), 62 deletions(-) diff --git a/automatedPreProcessing/automatedPreProcessing.py b/automatedPreProcessing/automatedPreProcessing.py index 2ffac609..ca06f3c5 100644 --- a/automatedPreProcessing/automatedPreProcessing.py +++ b/automatedPreProcessing/automatedPreProcessing.py @@ -59,6 +59,7 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin file_name_model_flow_ext = path.join(dir_path, case_name + "_flowext.vtp") file_name_clipped_model = path.join(dir_path, case_name + "_clippedmodel.vtp") file_name_flow_centerlines = path.join(dir_path, case_name + "_flow_cl.vtp") + file_name_remeshed = path.join(dir_path, case_name + "_remeshed.vtp") file_name_surface_name = path.join(dir_path, case_name + "_remeshed_surface.vtp") file_name_xml_mesh = path.join(dir_path, case_name + ".xml") file_name_vtu_mesh = path.join(dir_path, case_name + ".vtu") @@ -118,47 +119,6 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin region_center = [] misr_max = [] - if refine_region: - regions = get_regions_to_refine(capped_surface, region_points, path.join(dir_path, case_name)) - - centerlineAnu, _, _ = compute_centerlines(source, regions, file_name_refine_region_centerlines, capped_surface, - resampling=0.1) - - # Extract the region centerline - refine_region_centerline = [] - info = get_parameters(path.join(dir_path, case_name)) - num_anu = info["number_of_regions"] - - # Compute mean distance between points - for i in range(num_anu): - if not path.isfile(file_name_region_centerlines.format(i)): - line = extract_single_line(centerlineAnu, i) - locator = get_vtk_point_locator(centerlines) - for j in range(line.GetNumberOfPoints() - 1, 0, -1): - point = line.GetPoints().GetPoint(j) - ID = locator.FindClosestPoint(point) - tmp_point = centerlines.GetPoints().GetPoint(ID) - dist = np.sqrt(np.sum((np.asarray(point) - np.asarray(tmp_point)) ** 2)) - if dist <= tol: - break - - tmp = extract_single_line(line, 0, start_id=j) - write_polydata(tmp, file_name_region_centerlines.format(i)) - - # List of VtkPolyData sac(s) centerline - refine_region_centerline.append(tmp) - - else: - refine_region_centerline.append(read_polydata(file_name_region_centerlines.format(i))) - - # Merge the sac centerline - region_centerlines = vtk_merge_polydata(refine_region_centerline) - - for region in refine_region_centerline: - region_factor = 0.9 if atrium_present else 0.5 - region_center.append(region.GetPoints().GetPoint(int(region.GetNumberOfPoints() * region_factor))) - tmp_misr = get_point_data_array(radiusArrayName, region) - misr_max.append(tmp_misr.max()) # Smooth surface if smoothing_method == "voronoi": @@ -227,35 +187,47 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin elif smoothing_method == "no_smooth" or None: print("--- No smoothing of surface\n") + if edge_length is not None: + if not path.exists(file_name_remeshed): + print("-- Remeshing --") + remeshed = remesh_surface(surface, edge_length) + remeshed = vtk_clean_polydata(remeshed) + write_polydata(remeshed, file_name_remeshed) + else: + remeshed = read_polydata(file_name_remeshed) + else: + remeshed = surface + # Add flow extensions if create_flow_extensions: if not path.isfile(file_name_model_flow_ext): print("--- Adding flow extensions\n") # Add extension normal on boundary for atrium models extension = "boundarynormal" if atrium_present else "centerlinedirection" - surface_extended = add_flow_extension(surface, centerlines, include_outlet=False, + surface_extended = add_flow_extension(remeshed, centerlines, include_outlet=False, extension_length=flow_extension_length) surface_extended = add_flow_extension(surface_extended, centerlines, include_outlet=True, - extension_length=flow_extension_length, extension_mode=extension) + extension_length=flow_extension_length * 3, extension_mode=extension) + surface_extended = vmtk_smooth_surface(surface_extended, "laplace", iterations=50) write_polydata(surface_extended, file_name_model_flow_ext) else: surface_extended = read_polydata(file_name_model_flow_ext) else: surface_extended = surface + surface_extended = vmtk_smooth_surface(surface_extended, "laplace", iterations=50) # Smooth and capp surface with flow extensions - surface_extended = vmtk_smooth_surface(surface_extended, "laplace", iterations=200) capped_surface = vmtk_cap_polydata(surface_extended) if dynamic_mesh: # Get a point mapper - distance, point_map = get_point_map(surface, surface_extended) + distance, point_map = get_point_map(remeshed, surface_extended) # Project displacement between surfaces points = project_displacement(clamp_boundaries, distance, folder_extended_surfaces, folder_moved_surfaces, - point_map, surface, surface_extended) + point_map, surface, surface_extended, remeshed) # Save displacement to numpy array save_displacement(file_name_displacement_points, points) @@ -273,30 +245,40 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin else: source = inlet target = outlets - centerlines, _, _ = compute_centerlines(source, target, file_name_flow_centerlines, capped_surface, - resampling=0.1) + centerlines_extended, _, _ = compute_centerlines(source, target, file_name_flow_centerlines, capped_surface, + resampling=0.1) else: - centerlines = read_polydata(file_name_flow_centerlines) + centerlines_extended = read_polydata(file_name_flow_centerlines) + + funnel = True + if funnel: + cl0 = extract_single_line(centerlines, 0) + cl0_ext = extract_single_line(centerlines_extended, 1) + surface_extended = create_funnel(surface_extended, cl0, cl0_ext, radius=1) + if refine_region: + region_centerlines = get_region_and_radius(atrium_present, capped_surface, case_name, centerlines, dir_path, + file_name_refine_region_centerlines, file_name_region_centerlines, + misr_max, region_center, region_points, source, tol) # Choose input for the mesh print("--- Computing distance to sphere\n") if meshing_method == "constant": if not path.isfile(file_name_distance_to_sphere_const): - distance_to_sphere = dist_sphere_constant(surface_extended, centerlines, region_center, misr_max, + distance_to_sphere = dist_sphere_constant(surface_extended, centerlines_extended, region_center, misr_max, file_name_distance_to_sphere_const, edge_length) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_const) elif meshing_method == "curvature": if not path.isfile(file_name_distance_to_sphere_curv): - distance_to_sphere = dist_sphere_curv(surface_extended, centerlines, region_center, misr_max, + distance_to_sphere = dist_sphere_curv(surface_extended, centerlines_extended, region_center, misr_max, file_name_distance_to_sphere_curv, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_curv) elif meshing_method == "diameter": if not path.isfile(file_name_distance_to_sphere_diam): - distance_to_sphere = dist_sphere_diam(surface_extended, centerlines, region_center, misr_max, + distance_to_sphere = dist_sphere_diam(surface_extended, centerlines_extended, region_center, misr_max, file_name_distance_to_sphere_diam, coarsening_factor) else: distance_to_sphere = read_polydata(file_name_distance_to_sphere_diam) @@ -323,7 +305,8 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin else: polyDataVolMesh = read_polydata(file_name_vtu_mesh) - network, probe_points = setup_model_network(centerlines, file_name_probe_points, region_center, verbose_print) + network, probe_points = setup_model_network(centerlines_extended, file_name_probe_points, region_center, + verbose_print) # BSL method for mean inlet flow rate. parameters = get_parameters(path.join(dir_path, case_name)) @@ -360,6 +343,47 @@ def run_pre_processing(filename_model, verbose_print, smoothing_method, smoothin run_simulation(config_path, dir_path, case_name) +def get_region_and_radius(atrium_present, capped_surface, case_name, centerlines, dir_path, + file_name_refine_region_centerlines, file_name_region_centerlines, misr_max, region_center, + region_points, source, tol): + regions = get_regions_to_refine(capped_surface, region_points, path.join(dir_path, case_name)) + centerlineAnu, _, _ = compute_centerlines(source, regions, file_name_refine_region_centerlines, capped_surface, + resampling=0.1) + # Extract the region centerline + refine_region_centerline = [] + info = get_parameters(path.join(dir_path, case_name)) + num_anu = info["number_of_regions"] + # Compute mean distance between points + for i in range(num_anu): + if not path.isfile(file_name_region_centerlines.format(i)): + line = extract_single_line(centerlineAnu, i) + locator = get_vtk_point_locator(centerlines) + for j in range(line.GetNumberOfPoints() - 1, 0, -1): + point = line.GetPoints().GetPoint(j) + ID = locator.FindClosestPoint(point) + tmp_point = centerlines.GetPoints().GetPoint(ID) + dist = np.sqrt(np.sum((np.asarray(point) - np.asarray(tmp_point)) ** 2)) + if dist <= tol: + break + + tmp = extract_single_line(line, 0, start_id=j) + write_polydata(tmp, file_name_region_centerlines.format(i)) + + # List of VtkPolyData sac(s) centerline + refine_region_centerline.append(tmp) + + else: + refine_region_centerline.append(read_polydata(file_name_region_centerlines.format(i))) + # Merge the sac centerline + region_centerlines = vtk_merge_polydata(refine_region_centerline) + for region in refine_region_centerline: + region_factor = 0.9 if atrium_present else 0.5 + region_center.append(region.GetPoints().GetPoint(int(region.GetNumberOfPoints() * region_factor))) + tmp_misr = get_point_data_array(radiusArrayName, region) + misr_max.append(tmp_misr.max()) + return region_centerlines + + def read_command_line(): """ Read arguments from commandline and return all values in a dictionary. diff --git a/automatedPreProcessing/common.py b/automatedPreProcessing/common.py index ecca39f2..62c6ebff 100644 --- a/automatedPreProcessing/common.py +++ b/automatedPreProcessing/common.py @@ -12,6 +12,7 @@ from os import path, listdir, mkdir # Global array names +cell_id_name = "CellEntityIds" radiusArrayName = 'MaximumInscribedSphereRadius' parallelTransportNormalsArrayName = 'ParallelTransportNormals' groupIDsArrayName = "GroupIds" @@ -345,20 +346,24 @@ def dist_sphere_constant(surface, centerlines, sac_center, misr_max, fileName, e distance_to_sphere = distTocenterlines.Surface # Reduce element size in region + F = 3 / 4 # For 3xMISIR + F = 1 # for refining for i in range(len(sac_center)): distance_to_sphere = compute_distance_to_sphere(distance_to_sphere, sac_center[i], minDistance=edge_length / 3, maxDistance=edge_length, - distanceScale=edge_length * 3 / 4 / (misr_max[i] * 2.)) + distanceScale=(edge_length * F * 3 / 4 / (misr_max[i] * 2.))) element_size = edge_length + np.zeros((surface.GetNumberOfPoints(), 1)) if len(sac_center) != 0: distance_to_spheres_array = get_point_data_array("DistanceToSpheres", distance_to_sphere) + # element_size = np.maximum(element_size, distance_to_spheres_array) element_size = np.minimum(element_size, distance_to_spheres_array) vtk_array = create_vtk_array(element_size, "Size") distance_to_sphere.GetPointData().AddArray(vtk_array) + write_polydata(distance_to_sphere, fileName) return distance_to_sphere @@ -456,12 +461,39 @@ def compute_distance_to_sphere(surface, centerSphere, radiusSphere=0.0, # Keep smallest distance newDist = min(newDist, distanceToSphere) if not add else newDist - + # TODO: Edit if coarsening + s = 3 # 2 and 3 works + # Coarsening: + # dist_array.SetComponent(i, 0, s * 1.9 - (s - 1) * newDist) dist_array.SetComponent(i, 0, newDist) return surface +def remesh_surface(surface, edge_length, exclude=None): + surface = dsa.WrapDataObject(surface) + if cell_id_name not in surface.CellData.keys(): + surface.CellData.append(np.zeros(surface.VTKObject.GetNumberOfCells()) + 1, cell_id_name) + remeshing = vmtkscripts.vmtkSurfaceRemeshing() + remeshing.Surface = surface.VTKObject + remeshing.CellEntityIdsArrayName = cell_id_name + remeshing.TargetEdgeLength = edge_length + remeshing.MaxEdgeLength = 1e6 + remeshing.MinEdgeLength = 0.0 + remeshing.TargetEdgeLengthFactor = 1.0 + remeshing.TargetEdgeLengthArrayName = "" + remeshing.TriangleSplitFactor = 5.0 + remeshing.ElementSizeMode = "edgelength" + if exclude is not None: + remeshing.ExcludeEntityIds = exclude + + remeshing.Execute() + + remeshed_surface = remeshing.Surface + + return remeshed_surface + + def generate_mesh(surface): # Compute the mesh. meshGenerator = vmtkscripts.vmtkMeshGenerator() @@ -917,7 +949,7 @@ def save_displacement(file_name_displacement_points, points): def project_displacement(clamp_boundaries, distance, folder_extended_surfaces, folder_moved_surfaces, point_map, - surface, surface_extended): + surface, surface_extended, remeshed): """ Args: @@ -933,7 +965,7 @@ def project_displacement(clamp_boundaries, distance, folder_extended_surfaces, f """ # Add extents to all surfaces - extended_surfaces = sorted([f for f in listdir(folder_moved_surfaces) if f[:2] == "LA"]) + extended_surfaces = sorted([f for f in listdir(folder_moved_surfaces) if f[:2] in ["LA", "Co", "Fu"]]) if not path.exists(folder_extended_surfaces): mkdir(folder_extended_surfaces) @@ -950,7 +982,63 @@ def project_displacement(clamp_boundaries, distance, folder_extended_surfaces, f tmp_surface = read_polydata(model_path) new_path = path.join(folder_extended_surfaces, model_path.split("/")[-1]) if not path.exists(new_path): - move_surface_model(tmp_surface, surface, surface, surface_extended, distance, point_map, new_path, i, + move_surface_model(tmp_surface, surface, remeshed, surface_extended, distance, point_map, new_path, i, points, clamp_boundaries) return points + + +def create_funnel(surface, cl, cl_ext, radius): + surface = dsa.WrapDataObject(surface) + points = surface.Points + p0 = np.array(cl.GetPoint(0)) # At MV + p1 = np.array(cl_ext.GetPoint(0)) # At flow extension boundary + n = n_z = (p1 - p0) / la.norm(p1 - p0) + n_x = np.array([0, -n[2], n[1]]) + n_y = np.cross(n_z, n_x) + tol = 1E-1 + max_dist = get_distance_between_points(p0, p1) + tol + + for j in range(len(points)): + p = points[j] + + current_dist_p0 = get_distance_to_plane(n, p0, p) + current_dist_p1 = get_distance_to_plane(n, p1, p) + if current_dist_p0 <= max_dist and current_dist_p1 <= max_dist: + x_mark = (p - p0).dot(n_x) + y_mark = (p - p0).dot(n_y) + z_mark = (p - p0).dot(n_z) + + def get_scale(d): + # TODO: Find choice for "1.2" based on MISR + return -d / max_dist * 0.95 + + scale = get_scale(z_mark) + x_new = x_mark * scale + y_new = y_mark * scale + z_new = 0 + + X_mark = np.array([x_new, y_new, z_new]) + R_inv = np.array([n_x, n_y, n_z]).T + + p_new = R_inv.dot(X_mark) + + else: + p_new = np.array([0, 0, 0]) + + points[j] += p_new + + surface.SetPoints(points) + + return surface.VTKObject + + +def get_distance_between_points(p0, p1): + p0 = np.array(p0) + p1 = np.array(p1) + + return la.norm(p1 - p0) + + +def get_distance_to_plane(n, P, Q): + return np.abs(n.dot(P - Q)) / la.norm(n) diff --git a/automatedPreProcessing/movementPreProcessing.py b/automatedPreProcessing/movementPreProcessing.py index dbc14cf8..bbae189e 100644 --- a/automatedPreProcessing/movementPreProcessing.py +++ b/automatedPreProcessing/movementPreProcessing.py @@ -6,7 +6,7 @@ from vtk.numpy_interface import dataset_adapter as dsa from common import get_centers_for_meshing, find_boundaries, setup_model_network, compute_flow_rate, add_flow_extension, \ - move_surface_model, get_point_map + move_surface_model, get_point_map, create_funnel from visualize import visualize cell_id_name = "CellEntityIds" @@ -77,7 +77,7 @@ def main(case_path, move_surface, add_extensions, edge_length, patient_specific, clamp_boundaries, edge_length) if (not path.exists(mesh_path) or recompute_mesh) and surface_to_mesh is not None: - mesh = generate_mesh_without_layers(surface_to_mesh, mesh_path, mesh_xml_path, edge_length, centerlines) + mesh = generate_mesh_without_layers(surface_to_mesh, mesh_path, mesh_xml_path, edge_length) if path.exists(mesh_path): mesh = read_polydata(mesh_path) @@ -213,6 +213,8 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extens remeshed_path = model_path + "_remeshed.vtp" extended_path = model_path + "_extended" remeshed_extended_path = model_path + "_remeshed_extended.vtp" + extended_cl_path = model_path + "_cl_ext.vtp" + funnel_path = model_path + "_funnel.vtp" if not path.exists(extended_path): os.mkdir(extended_path) @@ -231,7 +233,8 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extens remeshed_extended = add_flow_extension(remeshed, centerline, include_outlet=False, extension_length=flow_extension_length) remeshed_extended = add_flow_extension(remeshed_extended, centerline, include_outlet=True, - extension_length=flow_extension_length, extension_mode="boundarynormal") + extension_length=flow_extension_length * 3, + extension_mode="boundarynormal") # Smooth at edges remeshed_extended = vmtk_smooth_surface(remeshed_extended, "laplace", iterations=50) @@ -241,11 +244,20 @@ def add_flow_extensions(surface, model_path, moved_path, centerline, flow_extens write_polydata(remeshed_extended, remeshed_extended_path) + capped_surface = vmtk_cap_polydata(remeshed_extended) + outlets, inlet = get_centers_for_meshing(remeshed_extended, True, model_path) + centerlines_extended, _, _ = compute_centerlines(inlet, outlets, extended_cl_path, capped_surface, resampling=0.1) + cl0 = extract_single_line(centerline, 0) + cl0_ext = extract_single_line(centerlines_extended, 1) + + remeshed_extended = create_funnel(remeshed_extended, cl0, cl0_ext, 1) + write_polydata(remeshed_extended, funnel_path) + # Get a point mapper distance, point_map = get_point_map(remeshed, remeshed_extended) # Add extents to all surfaces - extended_surfaces = sorted([f for f in os.listdir(moved_path) if f[:2] == "LA"]) + extended_surfaces = sorted([f for f in os.listdir(moved_path) if f[:2] == "LA" or f[:2] == "Fu"]) n_surfaces = len(extended_surfaces) print("-- Projecting surfaces --") From 0580b907fbe17d9fb7812ac6d56978f0dda4d977 Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Mon, 21 Feb 2022 10:07:41 +0100 Subject: [PATCH 58/76] Update Atrium.py Update Atrium rigid problem file --- Atrium.py | 377 +++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 259 insertions(+), 118 deletions(-) diff --git a/Atrium.py b/Atrium.py index 9b049e1f..f89cb4bb 100755 --- a/Atrium.py +++ b/Atrium.py @@ -6,24 +6,30 @@ import numpy as np from numpy.core.fromnumeric import mean -from Womersley import make_womersley_bcs, compute_boundary_geometry_acrn +from .Womersley import make_womersley_bcs, compute_boundary_geometry_acrn -from fenicstools import Probes +#from fenicstools import Probes from oasis.problems.NSfracStep import * from scipy.interpolate import UnivariateSpline from scipy.integrate import simps, romberg +from IPython import embed +from ufl.measure import measure_names set_log_level(50) def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_namespace): + backflow = bool(commandline_kwargs.get("backflow", True)) + backflow_beta = float(commandline_kwargs.get("backflow_beta", 0.5)) if "restart_folder" in commandline_kwargs.keys(): restart_folder = commandline_kwargs["restart_folder"] - f = open(path.join(restart_folder, 'params.dat'), 'r') + f = open(path.join(restart_folder, 'params.dat'), 'rb') NS_parameters.update(pickle.load(f)) NS_parameters['restart_folder'] = restart_folder else: # Override some problem specific parameters - # parameters are in mm and ms + # Parameters are in mm and ms + cardiac_cycle = 20 + number_of_cycles = 1 NS_parameters.update( # Fluid parameters nu=3.3018868e-3, # Viscosity [nu_inf: 0.0035 Pa-s / 1060 kg/m^3 = 3.3018868E-6 m^2/s == 3.3018868E-3 mm^2/ms] @@ -32,16 +38,20 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n id_out=[], # Outlet boundary IDs area_ratio=[], # Simulation parameters - T= 1.045, # Run simulation for 1 cardiac cycles [ms] + cardiac_cycle=cardiac_cycle, + T=cardiac_cycle * number_of_cycles, # Simulation end time [ms]# Run simulation for 1 cardiac cycles [ms] dt= 0.1, # 10 000 steps per cycle [ms] no_of_cycles=1, dump_stats=100, - store_data=5, - store_data_tstep=1, # Start storing data at 1st cycle - save_step=200, + store_data=5e6, + store_data_tstep=50, # Start storing data at 1st cycle + save_step=50000000000, + save_step_problem=1, + save_solution_frequency = 5, + save_solution_after_cycle=1, # Store solution after 1 cardiac cycle checkpoint=20000, print_intermediate_info=100, - tstep_print = 1000, + tstep_print = 100, folder="results_atrium", mesh_path=commandline_kwargs["mesh_path"], # Solver parameters @@ -52,6 +62,12 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n dim_MV = [], dim_PV = [] ) + if backflow: + NS_parameters.update( + # Backflow + backflow_facets=[], + backflow_beta=backflow_beta + ) mesh_file = NS_parameters["mesh_path"].split("/")[-1] case_name = mesh_file.split(".")[0] @@ -59,8 +75,12 @@ def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_n def mesh(mesh_path, **NS_namespace): - # Read mesh - return Mesh(mesh_path) + + mesh = Mesh(mesh_path) + #mesh_ = Mesh(mesh_path) + #mesh = refine(mesh_) + + return mesh class boundary_expression(UserExpression): @@ -103,67 +123,101 @@ def eval(self,values,x): # Scale by negative normal direction values[0] = -self.normal_component * par + -def get_velocity_profile(q_pv, normal_component,tmp_center, tmp_area): - U_mean = 2*q_pv / tmp_area - R2 = tmp_area / np.pi # R**2 - in_par = Expression('U*( 1 - ( pow(x0 - x[0], 2) + pow(x1 - x[1], 2) + pow(x2 - x[2], 2) ) / R2 )', - degree=2, U=U_mean, R2=R2, x0=tmp_center[0], x1=tmp_center[1], x2=tmp_center[2]) - u_in = -normal_component * in_par - - return u_in - -def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, id_out, pressure_degree, **NS_namespace): +class InletParabolic(UserExpression): + def __init__(self, n, center, area, mean_velocity, Q_profile, area_total, **kwargs): + + self.center = center + self.R2 = area / np.pi + self.area = area + self.normal_component = n + self.mean_velocity = mean_velocity + self.area_total = area_total + self.Q = Q_profile + + super().__init__(**kwargs) + + def eval(self, value, x): + + if self.mean_velocity is not None: + U0 = self.mean_velocity + else: + Q0 = self.Q * self.area / self.area_total + U0 = 2*(Q0 / self.area) + + x0 = self.center[0] + x1 = self.center[1] + x2 = self.center[2] + R2 = self.R2 + parabolic = U0 * (1 - ((x0 - x[0]) ** 2 + (x1 - x[1]) ** 2 + (x2 - x[2]) ** 2) / R2) + + value[:] = - self.normal_component * parabolic + +def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, backflow, backflow_facets, id_in, id_out,velocity_degree, pressure_degree, **NS_namespace): # Mesh function boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) boundary.set_values(boundary.array() + 1) + ds_new = Measure("ds", domain=mesh, subdomain_data=boundary) - id_in = [3,4,5,6,7] # Hardcoded. FIXIT: automated prepocessing - id_out = [2] + # print(boundary.array()) + + # Get IDs for inlet(s) and outlet(s) + info_path = mesh_path.split(".")[0] + "_info.json" + # info_path = mesh_path.split(".")[0] + ".json" - # Read case parameters - info_path = mesh_path.split(".")[0] + ".json" with open(info_path) as f: info = json.load(f) - # Extract flow split ratios and inlet/outlet IDs - id_info = info['idFileLine'].split() - # id_out.append(int(id_info[1])) - # id_in[:] = [int(p) for p in id_info[2].split(",")] + id_wall = 1 + id_out[:] = info['inlet_id'] + id_in[:] = info['outlet_ids'] + if backflow: + backflow_facets[:] = id_out #Q_mean = float(id_info[3]) - area_ratio[:] = [float(p) for p in info['areaRatioLine'].split()[-1].split(",")] - - area_in = np.array([info['outlet0_area'],info['outlet1_area'],info['outlet2_area'],info['outlet3_area']]) - area_out = np.array([info['inlet_area']]) + area_ratio[:] = [0.3, 0.3, 0.2, 0.2] #info['area_ratio'] Take care about Q_ideal! #[float(p) for p in info['areaRatioLine'].split()[-1].split(",")] + # Find corresponding areas + area_total = 0 + for ID in id_in: + area_total += assemble(Constant(1.0) * ds_new(ID)) + + area_in = np.array([info['inlet0_area'],info['inlet1_area'],info['inlet2_area'],info['inlet3_area']]) + area_out = np.array([info['outlet_area']]) dim_MV = np.sqrt(4*area_in.max()/np.pi) #[mm] dim_PV = np.sqrt(4*area_out/np.pi) NS_parameters['dim_MV'] = dim_MV NS_parameters['dim_PV'] = dim_PV + #Will implement Analytical profile t_values , V_values = [], [] - try: + """try: t_values, V_values = np.loadtxt(path.join(path.dirname(path.abspath(__file__)), "pv_velocity.txt")).T t_values *= 1000 + V_values *=1 except ValueError: - raise - + raise""" + + flow_rate = 1.089*8.1 * 50/3 #4.1 #8.1 #3.5 #mm3/ms # 1 [l/min] = 50 / 3 [mm3/ms] + mean_velocity = 0.3 #m/s bc_inlets = {} for i, ID in enumerate(id_in): tmp_area, tmp_center, tmp_radius, tmp_normal = compute_boundary_geometry_acrn(mesh, id_in[i], boundary) inlet, coeffs = [], [] - coeffs, omega, period = get_coeffients(t_values, V_values) + #coeffs, omega, period = get_coeffients(t_values, V_values) for normal_component in tmp_normal: - _in = boundary_expression(coeffs, omega, period, tmp_normal, normal_component, tmp_area, tmp_center, tmp_radius,'parabolic',element = V.ufl_element()) + # _in = boundary_expression(coeffs, omega, period, tmp_normal, normal_component, tmp_area, tmp_center, tmp_radius,'parabolic',element = V.ufl_element()) + _in = InletParabolic( normal_component, tmp_center, tmp_area, None, flow_rate, area_total, element=V.ufl_element()) #parabolic profile + # _in = -normal_component * mean_velocity #plug profile inlet.append(_in) - + NS_expressions[ID] = inlet bc_inlet = [DirichletBC(V, inlet[i], boundary, ID) for i in range(3)] bc_inlets[ID] = bc_inlet # Set start time equal to t_0 - for uc in inlet: - uc.update(t) + # for uc in inlet: + # uc.update(t) - bc_p = [] + bc_p = [] for i, ID in enumerate(id_out): bc = DirichletBC(Q, Constant(0.0), boundary, ID) bc_p.append(bc) @@ -172,33 +226,40 @@ def create_bcs(t, NS_expressions, V, Q, area_ratio, mesh, mesh_path, nu, id_in, # No slip condition at wall wall = Constant(0.0) # Create Boundary conditions for the wall - bc_wall = DirichletBC(V, wall, boundary, 1) + bc_wall = DirichletBC(V, wall, boundary, id_wall) - return dict(u0=[bc_inlets[id_in[0]][0], bc_inlets[id_in[1]][0], bc_inlets[id_in[2]][0], bc_inlets[id_in[3]][0], bc_inlets[id_in[4]][0], bc_wall], - u1=[bc_inlets[id_in[0]][1], bc_inlets[id_in[1]][1], bc_inlets[id_in[2]][1], bc_inlets[id_in[3]][1], bc_inlets[id_in[4]][1], bc_wall], - u2=[bc_inlets[id_in[0]][2], bc_inlets[id_in[1]][2], bc_inlets[id_in[2]][2], bc_inlets[id_in[3]][2], bc_inlets[id_in[4]][2], bc_wall], + + return dict(u0=[bc_inlets[id_in[0]][0], bc_inlets[id_in[1]][0], bc_inlets[id_in[2]][0], bc_inlets[id_in[3]][0], bc_wall], + u1=[bc_inlets[id_in[0]][1], bc_inlets[id_in[1]][1], bc_inlets[id_in[2]][1], bc_inlets[id_in[3]][1], bc_wall], + u2=[bc_inlets[id_in[0]][2], bc_inlets[id_in[1]][2], bc_inlets[id_in[2]][2], bc_inlets[id_in[3]][2], bc_wall], p=bc_p) def get_file_paths(folder): # Create folder where data and solutions (velocity, mesh, pressure) is stored - common_path = path.join(folder, "VTK") + common_path = path.join(folder, "PostProc") if MPI.rank(MPI.comm_world) == 0: if not path.exists(common_path): makedirs(common_path) file_p = path.join(common_path, "p.h5") - file_u = [path.join(common_path, "u{}.h5".format(i)) for i in range(3)] + file_u = path.join(common_path, "u.h5") + file_u_mean = path.join(common_path, "u_mean.h5") file_mesh = path.join(common_path, "mesh.h5") - files = {"u": file_u, "p": file_p, "mesh": file_mesh} + files = {"u": file_u, "u_mean": file_u_mean, "p": file_p, "mesh": file_mesh} return files -def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, **NS_namespace): - # Create point for evaluation +def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, velocity_degree, cardiac_cycle, + save_solution_after_cycle, dt, **NS_namespace): + + # Mesh function boundary = MeshFunction("size_t", mesh, 2, mesh.domains()) + boundary.set_values(boundary.array() + 1) n = FacetNormal(mesh) - eval_dict = {} + + # Create point for evaluation + """eval_dict = {} rel_path = mesh_path.split(".")[0] + "_probe_point" probe_points = np.load(rel_path, encoding='latin1', fix_imports=True, allow_pickle=True) @@ -209,7 +270,7 @@ def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, **NS_namesp eval_dict["centerline_u_x_probes"] = Probes(probe_points.flatten(), V) eval_dict["centerline_u_y_probes"] = Probes(probe_points.flatten(), V) eval_dict["centerline_u_z_probes"] = Probes(probe_points.flatten(), V) - eval_dict["centerline_p_probes"] = Probes(probe_points.flatten(), Q) + eval_dict["centerline_p_probes"] = Probes(probe_points.flatten(), Q)""" if restart_folder is None: # Get files to store results @@ -218,38 +279,79 @@ def pre_solve_hook(mesh, V, Q, newfolder, mesh_path, restart_folder, **NS_namesp else: files = NS_namespace["files"] - # Save mesh as HDF5 file + # Save mesh as HDF5 file for post processing with HDF5File(MPI.comm_world, files["mesh"], "w") as mesh_file: mesh_file.write(mesh, "mesh") h = EdgeLength(mesh) - return dict(eval_dict=eval_dict, boundary=boundary, n=n, h=h) + # Create vector function for storing velocity + Vv = VectorFunctionSpace(mesh, "CG", velocity_degree) + U = Function(Vv) + u_mean = Function(Vv) + u_mean0 = Function(V) + u_mean1 = Function(V) + u_mean2 = Function(V) + u_vec = Function(Vv, name="u") + viz_p, viz_u = get_visualization_files(newfolder) + + # Tstep when solutions for post processing should start being saved + save_solution_at_tstep = int(cardiac_cycle * save_solution_after_cycle / dt) + + return dict(boundary=boundary, n=n, h=h, viz_uu=viz_u, viz_pp=viz_p, u_vec=u_vec, U=U, + u_mean=u_mean, u_mean0=u_mean0, u_mean1=u_mean1, u_mean2=u_mean2, save_solution_at_tstep=save_solution_at_tstep) + + +def u_dot_n(u, n): + return (dot(u, n) - abs(dot(u, n))) / 2 + + +def velocity_tentative_hook(mesh, boundary, u_ab, x_1, b, A, ui, u, v, backflow_facets, backflow_beta, + **NS_namespace): + boundary = MeshFunction("size_t", mesh, 2, mesh.domains()) + boundary.set_values(boundary.array() + 1) + + if backflow_facets != []: + ds = Measure("ds", domain=mesh, subdomain_data=boundary) + n = FacetNormal(mesh) + K = assemble(u_dot_n(u_ab, n) * dot(u, v) * ds(backflow_facets[0])) + A.axpy(-backflow_beta * 0.5, K, True) + b[ui].axpy(backflow_beta * 0.5, K * x_1[ui]) + -def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, id_in, id_out, boundary, n, store_data, - NS_parameters, NS_expressions, area_ratio, dt, t, tstep_print, **NS_namespace): +def temporal_hook(h, u_, q_, p_, mesh, tstep, save_step_problem,dump_stats, newfolder, id_in, id_out, boundary, n, store_data, + NS_parameters, NS_expressions, area_ratio, dt, t, tstep_print, save_solution_frequency, save_solution_at_tstep, u_vec, + U, viz_uu, viz_pp, u_mean0, u_mean1, u_mean2, **NS_namespace): boundary = MeshFunction("size_t", mesh, mesh.geometry().dim() - 1, mesh.domains()) boundary.set_values(boundary.array() + 1) - id_in = [3,4,5,6,7] # Hardcoded. FIXIT: automated prepocessing - id_out = [2] # Update boundary condition - for i, in_id in enumerate(id_in): - for uc in NS_expressions[in_id]: - uc.update(t) + # for i, in_id in enumerate(id_in): + # for uc in NS_expressions[in_id]: + # uc.update(t) # Compute flux and update pressure condition - if tstep >=1 and tstep %tstep_print == 0: - Q_ideals, Q_in, Q_ins, Q_out, V_out, V_ins = compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh, n, - tstep, u_, newfolder, t) + if tstep >=1 and tstep %5 == 0: + Q_in, Q_ins, Q_out, V_out, V_ins = compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh, n, tstep, u_, newfolder, t) + + if MPI.rank(MPI.comm_world) == 0 and tstep >=1 and tstep %5 == 0: + velocity_path = path.join(newfolder, "Solutions", "velocity.txt") + flowrate_path = path.join(newfolder, "Solutions", "flowrate.txt") + # if not path.isdir(path.join(newfolder, "Solutions")): + # os.mkdir(path.join(newfolder, "Solutions")) + with open(velocity_path, 'a') as filename: + filename.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, V_out, V_ins[0], V_ins[1], V_ins[2], V_ins[3])) + with open(flowrate_path, 'a') as fname: + fname.write("{:2.4e}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f} \n".format(t, Q_out, Q_ins[0], Q_ins[1], Q_ins[2], Q_ins[3], sum(Q_ins))) + if tstep % tstep_print == 0: DG = FunctionSpace(mesh, "DG", 0) - U = project(sqrt(inner(u_, u_)), DG, solver_type='cg') + U_ = project(sqrt(inner(u_, u_)), DG, solver_type='cg') - cfl = U.vector().get_local() * dt / h + cfl = U_.vector().get_local() * dt / h max_cfl = cfl.max() min_cfl = cfl.min() @@ -257,9 +359,9 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, dim_MV = NS_parameters['dim_MV'] dim_PV = NS_parameters['dim_PV'] - Re = U.vector().get_local() * dim_MV / NS_parameters['nu'] + Re = U_.vector().get_local() * dim_MV / NS_parameters['nu'] Re_MV = Re.max() - Re_ = U.vector().get_local() * dim_PV / NS_parameters['nu'] + Re_ = U_.vector().get_local() * dim_PV / NS_parameters['nu'] Re_PV = Re_.max() if MPI.rank(MPI.comm_world) == 0 and tstep % tstep_print == 0: #print_intermediate_info @@ -267,62 +369,101 @@ def temporal_hook(h, u_, q_, p_, mesh, tstep, dump_stats, eval_dict, newfolder, .format(t, tstep, max_cfl, min_cfl, Re_PV, Re_MV)) print("Sum of Q_in = {:0.4f} Q_out = {:0.4f}".format(sum(Q_ins), Q_out)) + if tstep % save_step_problem == 0: + assign(u_vec.sub(0), u_[0]) + assign(u_vec.sub(1), u_[1]) + assign(u_vec.sub(2), u_[2]) + + viz_uu.write(u_vec, t) + # viz_pp.write(p_, t) - # Sample velocity in points - eval_dict["centerline_u_x_probes"](u_[0]) - eval_dict["centerline_u_y_probes"](u_[1]) - eval_dict["centerline_u_z_probes"](u_[2]) - eval_dict["centerline_p_probes"](p_) - - # Store sampled velocity - if tstep % dump_stats == 0: - filepath = path.join(newfolder, "Stats") - if MPI.rank(MPI.comm_world) == 0: - if not path.exists(filepath): - makedirs(filepath) - - arr_u_x = eval_dict["centerline_u_x_probes"].array() - arr_u_y = eval_dict["centerline_u_y_probes"].array() - arr_u_z = eval_dict["centerline_u_z_probes"].array() - arr_p = eval_dict["centerline_p_probes"].array() - - #Dump stats - if MPI.rank(MPI.comm_world) == 0: - arr_u_x.dump(path.join(filepath, "u_x_%s.probes" % str(tstep))) - arr_u_y.dump(path.join(filepath, "u_y_%s.probes" % str(tstep))) - arr_u_z.dump(path.join(filepath, "u_z_%s.probes" % str(tstep))) - arr_p.dump(path.join(filepath, "p_%s.probes" % str(tstep))) - - #Clear stats - MPI.barrier(MPI.comm_world) - eval_dict["centerline_u_x_probes"].clear() - eval_dict["centerline_u_y_probes"].clear() - eval_dict["centerline_u_z_probes"].clear() + # # Sample velocity in points + # eval_dict["centerline_u_x_probes"](u_[0]) + # eval_dict["centerline_u_y_probes"](u_[1]) + # eval_dict["centerline_u_z_probes"](u_[2]) + # eval_dict["centerline_p_probes"](p_) + + # # Store sampled velocity + # if tstep % dump_stats == 0: + # filepath = path.join(newfolder, "Stats") + # if MPI.rank(MPI.comm_world) == 0: + # if not path.exists(filepath): + # makedirs(filepath) + + # arr_u_x = eval_dict["centerline_u_x_probes"].array() + # arr_u_y = eval_dict["centerline_u_y_probes"].array() + # arr_u_z = eval_dict["centerline_u_z_probes"].array() + # arr_p = eval_dict["centerline_p_probes"].array() + + # #Dump stats + # if MPI.rank(MPI.comm_world) == 0: + # arr_u_x.dump(path.join(filepath, "u_x_%s.probes" % str(tstep))) + # arr_u_y.dump(path.join(filepath, "u_y_%s.probes" % str(tstep))) + # arr_u_z.dump(path.join(filepath, "u_z_%s.probes" % str(tstep))) + # arr_p.dump(path.join(filepath, "p_%s.probes" % str(tstep))) + + # #Clear stats + # MPI.barrier(MPI.comm_world) + # eval_dict["centerline_u_x_probes"].clear() + # eval_dict["centerline_u_y_probes"].clear() + # eval_dict["centerline_u_z_probes"].clear() # Save velocity and pressure - if tstep % store_data == 0 and tstep>=1: #and tstep >= store_data_tstep: - # Name functions - u_[0].rename("u0", "velocity-x") - u_[1].rename("u1", "velocity-y") - u_[2].rename("u2", "velocity-z") - p_.rename("p", "pressure") + if tstep % save_solution_frequency == 0 and tstep >= save_solution_at_tstep: + # Assign velocity components to vector solution + assign(U.sub(0), u_[0]) + assign(U.sub(1), u_[1]) + assign(U.sub(2), u_[2]) # Get save paths files = NS_parameters['files'] - file_mode = "w" if tstep == store_data else "a" + file_mode = "w" if tstep == save_solution_at_tstep else "a" p_path = files['p'] - - # Save + u_path = files['u'] + + # Save pressure viz_p = HDF5File(MPI.comm_world, p_path, file_mode=file_mode) viz_p.write(p_, "/pressure", tstep) viz_p.close() - for i in range(3): - u_path = files['u'][i] - viz_u = HDF5File(MPI.comm_world, u_path, file_mode=file_mode) - viz_u.write(u_[i], "/velocity", tstep) - viz_u.close() - + # Save velocity + viz_u = HDF5File(MPI.comm_world, u_path, file_mode=file_mode) + viz_u.write(U, "/velocity", tstep) + viz_u.close() + + # Accumulate velocity + u_mean0.vector().axpy(1, u_[0].vector()) + u_mean1.vector().axpy(1, u_[1].vector()) + u_mean2.vector().axpy(1, u_[2].vector()) + +def theend_hook(u_mean, u_mean0, u_mean1, u_mean2, T, dt, save_solution_at_tstep, save_solution_frequency, **NS_namespace): + + # get the file path + files = NS_parameters['files'] + u_mean_path = files["u_mean"] + + # divide the accumlated veloicty by the number of steps + NumTStepForAverage = (T/dt - save_solution_at_tstep) / save_solution_frequency + 1 + u_mean0.vector()[:] = u_mean0.vector()[:] / NumTStepForAverage + u_mean1.vector()[:] = u_mean1.vector()[:] / NumTStepForAverage + u_mean2.vector()[:] = u_mean2.vector()[:] / NumTStepForAverage + + assign(u_mean.sub(0), u_mean0) + assign(u_mean.sub(1), u_mean1) + assign(u_mean.sub(2), u_mean2) + + # Save u_mean + with HDF5File(MPI.comm_world, u_mean_path, "w") as u_mean_file: + u_mean_file.write(u_mean, "u_mean") + +def get_visualization_files(newfolder): + viz_u = XDMFFile(MPI.comm_world, path.join(newfolder, "Solutions", "u.xdmf")) + viz_p = XDMFFile(MPI.comm_world, path.join(newfolder, "Solutions", "p.xdmf")) + for viz in [viz_u, viz_p]: + viz.parameters["rewrite_function_mesh"] = True + viz.parameters["flush_output"] = True + viz.parameters["functions_share_mesh"] = True + return viz_p, viz_u def compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh, n, tstep, u_, newfolder,t): @@ -346,10 +487,10 @@ def compute_flow_rates(NS_expressions, area_ratio, boundary, id_in, id_out, mesh V_in = Q_in / dsi Q_ins.append(Q_in) V_ins.append(V_in) - Q_ideal = area_ratio[i] * Q_in #FIXIT: area_ratio - Q_ideals.append(Q_ideal) - - return Q_ideals, Q_in, Q_ins, Q_out, V_out, V_ins + #Q_ideal = area_ratio[i] * Q_in #FIXIT: area_ratio + #Q_ideals.append(Q_ideal) + return Q_in, Q_ins, Q_out, V_out, V_ins + #return Q_ideals, Q_in, Q_ins, Q_out, V_out, V_ins def EdgeLength(mesh): # Compute edge length From 8f88496d61206bc94f81b64e895b32b936850bd0 Mon Sep 17 00:00:00 2001 From: Ehsan Khalili Date: Mon, 21 Feb 2022 10:42:14 +0100 Subject: [PATCH 59/76] Added pipe problem file and mesh --- Pipe.py | 112 +++++++++++++++ test/3DPipe/ATT00001.htm | 1 + test/3DPipe/ATT00002.htm | 1 + test/3DPipe/ATT00003.htm | 1 + test/3DPipe/ATT00004.htm | 285 +++++++++++++++++++++++++++++++++++++++ test/3DPipe/mesh.h5 | Bin 0 -> 2865805 bytes test/3DPipe/mesh.xdmf | 1 + test/3DPipe/mf.h5 | Bin 0 -> 113481 bytes test/3DPipe/mf.xdmf | 1 + 9 files changed, 402 insertions(+) create mode 100755 Pipe.py create mode 100755 test/3DPipe/ATT00001.htm create mode 100755 test/3DPipe/ATT00002.htm create mode 100755 test/3DPipe/ATT00003.htm create mode 100755 test/3DPipe/ATT00004.htm create mode 100755 test/3DPipe/mesh.h5 create mode 100755 test/3DPipe/mesh.xdmf create mode 100755 test/3DPipe/mf.h5 create mode 100755 test/3DPipe/mf.xdmf diff --git a/Pipe.py b/Pipe.py new file mode 100755 index 00000000..f6e8aefc --- /dev/null +++ b/Pipe.py @@ -0,0 +1,112 @@ +import pickle +from os import path, makedirs, getcwd +import pprint +import matplotlib.pyplot as plt +import numpy as np +from mshr import * +from dolfin import * +import numpy as np + +from oasis.problems.NSfracStep import * +#from ..NSfracStep import * + +set_log_level(50) + +def problem_parameters(commandline_kwargs, NS_parameters, NS_expressions, **NS_namespace): + if "restart_folder" in commandline_kwargs.keys(): + restart_folder = commandline_kwargs["restart_folder"] + f = open(path.join(restart_folder, 'params.dat'), 'rb') + NS_parameters.update(pickle.load(f)) + NS_parameters['restart_folder'] = restart_folder + + else: + T = 5 + nu = 0.005 # + dt = 0.05 + NS_parameters.update( + + # Fluid parameters + nu=nu, # Kinematic viscosity + # Simulation parameters + T= T, + dt=dt, # Time step size [ms] + U0 = 0.50, # m/s + save_step=1, + checkpoint=500, + print_intermediate_info=100, + folder="results_pipe_parabolic", + mesh_path=commandline_kwargs["mesh_path"], + # Solver parameters + velocity_degree=1, + pressure_degree=1, + use_krylov_solvers=True, + krylov_solvers=dict(monitor_convergence=False) + ) + + +def mesh(mesh_path, **NS_namespace): + + mesh = Mesh() + mesh_file = XDMFFile(MPI.comm_world, mesh_path) + mesh_file.read(mesh) + + return mesh + + +def create_bcs(V, Q, sys_comp, nu, U0, mesh, mesh_path, **NS_namespace): + info_red("Creating boundary conditions") + + # Geometry + L = mesh.coordinates()[:, 0].max() - mesh.coordinates()[:, 0].min() + D = mesh.coordinates()[:, 2].max() - mesh.coordinates()[:, 2].min() + R = D/2 + + # Mark geometry + inlet = AutoSubDomain(lambda x, b: b and x[0] < 0.0 + DOLFIN_EPS * 1) + wall = AutoSubDomain(lambda x, b: b and ((x[1]**2 + x[2]**2) >= R**2 - 0.01 )) + outlet = AutoSubDomain(lambda x, b: b and (x[0] >= L - DOLFIN_EPS * 1000)) + + boundary = MeshFunction("size_t", mesh, mesh.topology().dim() - 1, mesh.domains()) + boundary.set_all(0) + inlet.mark(boundary, 1) + outlet.mark(boundary, 2) + wall.mark(boundary, 3) + + # File("boundary.pvd") << boundary + + id_inlet = 1 + id_outlet = 2 + id_wall = 3 + + # Reynolds + print("U0 is {}".format(U0)) + Re = U0 * 2 * R / nu + print("Reynolds number is {}".format(Re)) + + noslip = Constant(0.0) + inlet_in = Constant(U0) + + # parabolic + R2 = R**2 + inlet_in = Expression('U*( 1 - ( pow(x[0] - x0, 2) + pow(x[1] - x1, 2) + pow(x[2] -x2, 2) ) / R2 )', + degree=2, U=U0, R2=R2, x0=0.0, x1=0.0, x2=0.0) + + bcu_wall = DirichletBC(V, Constant(0.0), boundary, id_wall) + bcu_inlet_x = DirichletBC(V, inlet_in, boundary, id_inlet) + bcu_inlet_y = DirichletBC(V, Constant(0.0), boundary, id_inlet) + bcu_inlet_z = DirichletBC(V, Constant(0.0), boundary, id_inlet) + bcp_outlet = DirichletBC(Q, Constant(0.0), boundary, id_outlet) + + bcs = dict((ui, []) for ui in sys_comp) + bcs['u0'] = [bcu_inlet_x, bcu_wall] + bcs['u1'] = [bcu_inlet_y, bcu_wall] + bcs['u2'] = [bcu_inlet_z, bcu_wall] + bcs["p"] = [bcp_outlet] + + return bcs + + +def temporal_hook(mesh, u_, p_, q_, t, tstep, save_step, T, dt, **NS_namespace): + + if tstep % save_step == 0: + info_green('Time = {0:2.4e}, timestep = {1:6d}, End time = {2:2.4e}'.format(t, tstep, T)) diff --git a/test/3DPipe/ATT00001.htm b/test/3DPipe/ATT00001.htm new file mode 100755 index 00000000..441df9c9 --- /dev/null +++ b/test/3DPipe/ATT00001.htm @@ -0,0 +1 @@ +