From 77ff47caa384c09c21183d830846934295c359e5 Mon Sep 17 00:00:00 2001 From: Paul Date: Thu, 10 Feb 2022 15:23:49 -0700 Subject: [PATCH 01/28] Add streamlit example --- examples/12_streamlit_demo.py | 144 ++++++++++++++++++++++++++++++++++ 1 file changed, 144 insertions(+) create mode 100644 examples/12_streamlit_demo.py diff --git a/examples/12_streamlit_demo.py b/examples/12_streamlit_demo.py new file mode 100644 index 000000000..968b217ae --- /dev/null +++ b/examples/12_streamlit_demo.py @@ -0,0 +1,144 @@ +# Copyright 2021 NREL + +# Licensed under the Apache License, Version 2.0 (the "License"); you may not +# use this file except in compliance with the License. You may obtain a copy of +# the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations under +# the License. + +# See https://floris.readthedocs.io for documentation + + +import matplotlib.pyplot as plt +import streamlit as st +import numpy as np + +from floris.tools import FlorisInterface +from floris.tools.visualization import visualize_cut_plane + + +# """ +# This example demonstrates an interactive visual comparison of FLORIS +# wake models using streamlit + +# To run this example: +# (with your FLORIS environment enabled) +# pip install streamlit + +# streamlit run 12_streamlit_demo.py +# """ + +# I think this example shows some interesting things +# 1) Something is odd with the Jensen model +# 2) Doing reinitialize in a loop without redoing the interface gives an error (try it!) +# 3) CC can't be visualized + +# Parameters +wind_speed = 8.0 +# ti = 0.06 + +# Set to wide +st.set_page_config(layout="wide") + +#Streamlit inputs +wind_direction_user = st.sidebar.slider("Wind Direction", 240., 300., 285., step=1.) +spacing = st.sidebar.slider("Turbine spacing (D)", 3., 10., 6., step=0.5) +N = st.sidebar.slider("Turbines per row", 4, 8, 5, step=1) + + + +# Get number of turbines and make 0 yaw angle matrix +num_turbine = N**3 +yaw_angles = np.zeros((1, 1, num_turbine)) # 1 wd/ 1ws/ N*N turbines + +# Grab two different wake models +fi_gch = FlorisInterface("inputs/gch.yaml") + + +# Define layout +X, Y = np.meshgrid( + spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), + spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), +) +X = X.flatten() +Y = Y.flatten() + + +# Title +st.title('FLORIS Model Comparison') + +# Create the main analysis image +fig, axarr = plt.subplots(2,2) + +# Calculate for alligned case and user requested direction +for wd_idx, wind_direction in enumerate([270., wind_direction_user]): + + # Grab two different wake models + # Not positive why this is necessary + fi_jensen = FlorisInterface("inputs/jensen.yaml") + fi_gch = FlorisInterface("inputs/gch.yaml") + fi_cc = FlorisInterface("inputs/cc.yaml") + + + # Configure model + fi_jensen.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.05 ) + fi_gch.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.06 ) + fi_cc.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.1) + + # Calculate wake + fi_jensen.calculate_wake(yaw_angles=yaw_angles) + fi_gch.calculate_wake(yaw_angles=yaw_angles) + fi_cc.calculate_wake(yaw_angles=yaw_angles) + + # Get turbine powers + turbine_powers_jensen = fi_jensen.get_turbine_powers() + turbine_powers_gch = fi_gch.get_turbine_powers() + turbine_powers_cc = fi_cc.get_turbine_powers() + + # Put the turbine powers in descending order + turbine_powers_jensen = np.sort(turbine_powers_jensen.flatten())[::-1]/1000. + turbine_powers_gch = np.sort(turbine_powers_gch.flatten())[::-1]/1000. + turbine_powers_cc = np.sort(turbine_powers_cc.flatten())[::-1]/1000. + + # Show the (GCH) Horizontal plane + horizontal_plane_gch = fi_gch.get_hor_plane(x_resolution=100, y_resolution=100) + ax = axarr[0,wd_idx] + visualize_cut_plane(horizontal_plane_gch, ax=ax, title="Wind Direction = %.1f" % wind_direction) + + # Compare the power production + ax = axarr[1,wd_idx] + ax.plot(turbine_powers_jensen,color='k',label='Jensen') + ax.plot(turbine_powers_gch,color='b',label='GCH') + ax.plot(turbine_powers_cc,ls='--',color='r',label='CC') + ax.grid(True) + ax.legend() + ax.set_ylabel('Power (kW)') + ax.set_xlabel('Turbine (sorted)') + +# Show the figure +st.write(fig) + +# # Using the FlorisInterface functions for generating plots, run FLORIS +# # and extract 2D planes of data. +# + + + +# # Visualize cut plane +# +# +# +# # horizontal_plane_cc = fi_cc.get_hor_plane(x_resolution=100, y_resolution=100) + +# # # Create the plots +# # fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) +# # ax_list = ax_list.flatten() +# # visualize_cut_plane(horizontal_plane, ax=ax_list[0], title="Horizontal") +# # visualize_cut_plane(y_plane, ax=ax_list[1], title="Streamwise profile") +# # visualize_cut_plane(cross_plane, ax=ax_list[2], title="Spanwise profile") + +# # plt.show() From 2f08df42ba7e601d242bcea5642ba8fcb7ab500b Mon Sep 17 00:00:00 2001 From: Paul Date: Thu, 10 Feb 2022 15:28:05 -0700 Subject: [PATCH 02/28] clear comments --- examples/12_streamlit_demo.py | 25 ++----------------------- 1 file changed, 2 insertions(+), 23 deletions(-) diff --git a/examples/12_streamlit_demo.py b/examples/12_streamlit_demo.py index 968b217ae..142da435f 100644 --- a/examples/12_streamlit_demo.py +++ b/examples/12_streamlit_demo.py @@ -78,12 +78,12 @@ for wd_idx, wind_direction in enumerate([270., wind_direction_user]): # Grab two different wake models - # Not positive why this is necessary + # Not positive why this is necessary + # If you move this above the loop so it only happens once, there is an error fi_jensen = FlorisInterface("inputs/jensen.yaml") fi_gch = FlorisInterface("inputs/gch.yaml") fi_cc = FlorisInterface("inputs/cc.yaml") - # Configure model fi_jensen.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.05 ) fi_gch.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.06 ) @@ -121,24 +121,3 @@ # Show the figure st.write(fig) - -# # Using the FlorisInterface functions for generating plots, run FLORIS -# # and extract 2D planes of data. -# - - - -# # Visualize cut plane -# -# -# -# # horizontal_plane_cc = fi_cc.get_hor_plane(x_resolution=100, y_resolution=100) - -# # # Create the plots -# # fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) -# # ax_list = ax_list.flatten() -# # visualize_cut_plane(horizontal_plane, ax=ax_list[0], title="Horizontal") -# # visualize_cut_plane(y_plane, ax=ax_list[1], title="Streamwise profile") -# # visualize_cut_plane(cross_plane, ax=ax_list[2], title="Spanwise profile") - -# # plt.show() From 0e1d486c23ef8fa79e2ecd8bd9f23cd918d95b32 Mon Sep 17 00:00:00 2001 From: Paul Date: Thu, 10 Feb 2022 15:28:05 -0700 Subject: [PATCH 03/28] clear comments --- examples/12_streamlit_demo.py | 123 ++++++++++++++++++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 examples/12_streamlit_demo.py diff --git a/examples/12_streamlit_demo.py b/examples/12_streamlit_demo.py new file mode 100644 index 000000000..142da435f --- /dev/null +++ b/examples/12_streamlit_demo.py @@ -0,0 +1,123 @@ +# Copyright 2021 NREL + +# Licensed under the Apache License, Version 2.0 (the "License"); you may not +# use this file except in compliance with the License. You may obtain a copy of +# the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations under +# the License. + +# See https://floris.readthedocs.io for documentation + + +import matplotlib.pyplot as plt +import streamlit as st +import numpy as np + +from floris.tools import FlorisInterface +from floris.tools.visualization import visualize_cut_plane + + +# """ +# This example demonstrates an interactive visual comparison of FLORIS +# wake models using streamlit + +# To run this example: +# (with your FLORIS environment enabled) +# pip install streamlit + +# streamlit run 12_streamlit_demo.py +# """ + +# I think this example shows some interesting things +# 1) Something is odd with the Jensen model +# 2) Doing reinitialize in a loop without redoing the interface gives an error (try it!) +# 3) CC can't be visualized + +# Parameters +wind_speed = 8.0 +# ti = 0.06 + +# Set to wide +st.set_page_config(layout="wide") + +#Streamlit inputs +wind_direction_user = st.sidebar.slider("Wind Direction", 240., 300., 285., step=1.) +spacing = st.sidebar.slider("Turbine spacing (D)", 3., 10., 6., step=0.5) +N = st.sidebar.slider("Turbines per row", 4, 8, 5, step=1) + + + +# Get number of turbines and make 0 yaw angle matrix +num_turbine = N**3 +yaw_angles = np.zeros((1, 1, num_turbine)) # 1 wd/ 1ws/ N*N turbines + +# Grab two different wake models +fi_gch = FlorisInterface("inputs/gch.yaml") + + +# Define layout +X, Y = np.meshgrid( + spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), + spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), +) +X = X.flatten() +Y = Y.flatten() + + +# Title +st.title('FLORIS Model Comparison') + +# Create the main analysis image +fig, axarr = plt.subplots(2,2) + +# Calculate for alligned case and user requested direction +for wd_idx, wind_direction in enumerate([270., wind_direction_user]): + + # Grab two different wake models + # Not positive why this is necessary + # If you move this above the loop so it only happens once, there is an error + fi_jensen = FlorisInterface("inputs/jensen.yaml") + fi_gch = FlorisInterface("inputs/gch.yaml") + fi_cc = FlorisInterface("inputs/cc.yaml") + + # Configure model + fi_jensen.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.05 ) + fi_gch.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.06 ) + fi_cc.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.1) + + # Calculate wake + fi_jensen.calculate_wake(yaw_angles=yaw_angles) + fi_gch.calculate_wake(yaw_angles=yaw_angles) + fi_cc.calculate_wake(yaw_angles=yaw_angles) + + # Get turbine powers + turbine_powers_jensen = fi_jensen.get_turbine_powers() + turbine_powers_gch = fi_gch.get_turbine_powers() + turbine_powers_cc = fi_cc.get_turbine_powers() + + # Put the turbine powers in descending order + turbine_powers_jensen = np.sort(turbine_powers_jensen.flatten())[::-1]/1000. + turbine_powers_gch = np.sort(turbine_powers_gch.flatten())[::-1]/1000. + turbine_powers_cc = np.sort(turbine_powers_cc.flatten())[::-1]/1000. + + # Show the (GCH) Horizontal plane + horizontal_plane_gch = fi_gch.get_hor_plane(x_resolution=100, y_resolution=100) + ax = axarr[0,wd_idx] + visualize_cut_plane(horizontal_plane_gch, ax=ax, title="Wind Direction = %.1f" % wind_direction) + + # Compare the power production + ax = axarr[1,wd_idx] + ax.plot(turbine_powers_jensen,color='k',label='Jensen') + ax.plot(turbine_powers_gch,color='b',label='GCH') + ax.plot(turbine_powers_cc,ls='--',color='r',label='CC') + ax.grid(True) + ax.legend() + ax.set_ylabel('Power (kW)') + ax.set_xlabel('Turbine (sorted)') + +# Show the figure +st.write(fig) From 2cdd5433a1b6389ac21674ed91052841aafc6a95 Mon Sep 17 00:00:00 2001 From: Paul Date: Thu, 10 Feb 2022 16:00:01 -0700 Subject: [PATCH 04/28] add example 00 --- examples/00_getting_started.py | 74 ++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 examples/00_getting_started.py diff --git a/examples/00_getting_started.py b/examples/00_getting_started.py new file mode 100644 index 000000000..e8dafb92e --- /dev/null +++ b/examples/00_getting_started.py @@ -0,0 +1,74 @@ +# Copyright 2021 NREL + +# Licensed under the Apache License, Version 2.0 (the "License"); you may not +# use this file except in compliance with the License. You may obtain a copy of +# the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations under +# the License. + +# See https://floris.readthedocs.io for documentation + + +import matplotlib.pyplot as plt +import numpy as np + +from floris.tools import FlorisInterface + +# from floris.tools.visualization import visualize_cut_plane + +""" +00_getting_started + +This initial example creates a FLORIS instance +1) Makes a two-turbine layout +2) Demonstrates single ws/wd simulations +3) Demonstrates mulitple ws/wd simulations +""" + +# Initialize FLORIS with the given input file via FlorisInterface. +# For basic usage, FlorisInterface provides a simplified and expressive +# entry point to the simulation routines. +fi = FlorisInterface("inputs/gch.yaml") + +# Convert to a simple two turbine layout +fi.reinitialize( layout=( [0, 500.], [0., 0.] ) ) + +# Get the turbine powers assuming 1 wind speed and 1 wind direction +fi.reinitialize(wind_directions=[270.], wind_speeds=[8.0]) + +# Set the yaw angles to 0 +yaw_angles = np.zeros([1,1,2]) # 1 wind direction, 1 wind speed, 2 turbines +fi.calculate_wake(yaw_angles=yaw_angles) + +# Get the turbine powers +turbine_powers = fi.get_turbine_powers()/1000. +print('===========') +print('The turbine power matrix should be of dimensions 1 WD X 1 WS X 2 Turbines') +print(turbine_powers) +print('===========') + +# Now apply 3 wind speeds +wind_speeds = np.array([8.0, 9.0, 10.0]) +fi.reinitialize( wind_speeds=wind_speeds) +yaw_angles = np.zeros([1,3,2]) # 1 wind direction, 3 wind speeds, 2 turbines +fi.calculate_wake(yaw_angles=yaw_angles) +turbine_powers = fi.get_turbine_powers()/1000. +print('===========') +print('The turbine power matrix should be of dimensions 1 WD X 3 WS X 2 Turbines') +print(turbine_powers) +print('===========') + +# Make a small plot +fig, ax = plt.subplots() +ax.plot(wind_speeds,turbine_powers[:,:,0].flatten(), color='k',label='Turbine 0' ) +ax.plot(wind_speeds,turbine_powers[:,:,1].flatten(), color='r',label='Turbine 1' ) +ax.grid() +ax.legend() +ax.set_ylabel('Power (kW)') +ax.set_xlabel('Wind Speed (m/s)') +plt.show() + From fc3fcb28733dafb23c72e1a628b2c853aa54458c Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Fri, 11 Feb 2022 16:51:57 -0600 Subject: [PATCH 05/28] Add markers to the plot --- examples/00_getting_started.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/examples/00_getting_started.py b/examples/00_getting_started.py index e8dafb92e..310b8f56b 100644 --- a/examples/00_getting_started.py +++ b/examples/00_getting_started.py @@ -18,12 +18,8 @@ from floris.tools import FlorisInterface -# from floris.tools.visualization import visualize_cut_plane - """ -00_getting_started - -This initial example creates a FLORIS instance +This example creates a FLORIS instance 1) Makes a two-turbine layout 2) Demonstrates single ws/wd simulations 3) Demonstrates mulitple ws/wd simulations @@ -64,8 +60,8 @@ # Make a small plot fig, ax = plt.subplots() -ax.plot(wind_speeds,turbine_powers[:,:,0].flatten(), color='k',label='Turbine 0' ) -ax.plot(wind_speeds,turbine_powers[:,:,1].flatten(), color='r',label='Turbine 1' ) +ax.plot(wind_speeds, turbine_powers[:,:,0].flatten(), color='k', marker='o', label='Turbine 0' ) +ax.plot(wind_speeds, turbine_powers[:,:,1].flatten(), color='r', marker='o', label='Turbine 1' ) ax.grid() ax.legend() ax.set_ylabel('Power (kW)') From b9ec583008dd6164ea1540a2c65ea4119946c891 Mon Sep 17 00:00:00 2001 From: Paul Date: Tue, 15 Feb 2022 14:12:21 -0700 Subject: [PATCH 06/28] split example --- examples/12_streamlit_demo.py | 166 +++++++++++++---------- examples/13_streamlit_demo_large_farm.py | 123 +++++++++++++++++ 2 files changed, 221 insertions(+), 68 deletions(-) create mode 100644 examples/13_streamlit_demo_large_farm.py diff --git a/examples/12_streamlit_demo.py b/examples/12_streamlit_demo.py index 142da435f..e776b65ea 100644 --- a/examples/12_streamlit_demo.py +++ b/examples/12_streamlit_demo.py @@ -32,10 +32,6 @@ # streamlit run 12_streamlit_demo.py # """ -# I think this example shows some interesting things -# 1) Something is odd with the Jensen model -# 2) Doing reinitialize in a loop without redoing the interface gives an error (try it!) -# 3) CC can't be visualized # Parameters wind_speed = 8.0 @@ -44,80 +40,114 @@ # Set to wide st.set_page_config(layout="wide") -#Streamlit inputs -wind_direction_user = st.sidebar.slider("Wind Direction", 240., 300., 285., step=1.) +# Parameters +D = 126. # Assume for convenience +floris_model_list = ['jensen','gch','cc'] +color_dict = { + 'jensen':'k', + 'gch':'b', + 'cc':'r' +} + +# Streamlit inputs +n_turbine_per_row = st.sidebar.slider("Turbines per row", 1, 8, 2, step=1) +n_row = st.sidebar.slider("Number of rows", 1, 8,1, step=1) spacing = st.sidebar.slider("Turbine spacing (D)", 3., 10., 6., step=0.5) -N = st.sidebar.slider("Turbines per row", 4, 8, 5, step=1) +wind_direction = st.sidebar.slider("Wind Direction", 240., 300., 270., step=1.) +wind_speed = st.sidebar.slider("Wind Speed", 4., 15., 8., step=0.25) +turbulence_intensity = st.sidebar.slider("Turbulence Intensity", 0.01, 0.25, 0.06, step=0.01) +floris_models = st.sidebar.multiselect("FLORIS Models", floris_model_list, floris_model_list) +# floris_models_viz = st.sidebar.multiselect("FLORIS Models for Visualization", floris_model_list, floris_model_list) +desc_yaw = st.sidebar.checkbox("Descending yaw pattern?",value=False) +front_turbine_yaw = st.sidebar.slider("Upstream yaw angle", -30., 30., 20., step=0.5) + +# Define the layout +X = [] +Y = [] + +for x_idx in range(n_turbine_per_row): + for y_idx in range(n_row): + X.append(D * spacing * x_idx) + Y.append(D * spacing * y_idx) + +turbine_labels = ['T%02d' % i for i in range(len(X))] + +# Set up the yaw angle values +yaw_angles_base = np.zeros([1,1,len(X)]) + +yaw_angles_yaw = np.zeros([1,1,len(X)]) +if not desc_yaw: + yaw_angles_yaw[:n_row] = front_turbine_yaw +else: + yaw_angles_yaw[:n_row] = front_turbine_yaw -# Get number of turbines and make 0 yaw angle matrix -num_turbine = N**3 -yaw_angles = np.zeros((1, 1, num_turbine)) # 1 wd/ 1ws/ N*N turbines +# Get a few quanitities +num_models = len(floris_models) -# Grab two different wake models -fi_gch = FlorisInterface("inputs/gch.yaml") +# Determine which models to plot given cant plot cc right now +floris_models_viz = [m for m in floris_models if not 'cc' in m] +num_models_to_viz = len(floris_models_viz) +# Set up the visualization plot +fig_viz, axarr_viz = plt.subplots(num_models_to_viz,2) -# Define layout -X, Y = np.meshgrid( - spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), - spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), -) -X = X.flatten() -Y = Y.flatten() +# Set up the turbine power plot +fig_turb_pow, ax_turb_pow = plt.subplots() + +# Now complete all these plots in a loop +for fm in floris_models: + + # Analyze the base case================================================== + print('Loading: ',fm) + fi = FlorisInterface("inputs/%s.yaml" % fm) + + # Set the layout, wind direction and wind speed + fi.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=turbulence_intensity ) + + + fi.calculate_wake(yaw_angles=yaw_angles_base) + turbine_powers = fi.get_turbine_powers() / 1000. + ax_turb_pow.plot(turbine_labels,turbine_powers.flatten(),color=color_dict[fm],ls='-',marker='s',label='%s - baseline' % fm) + ax_turb_pow.grid(True) + ax_turb_pow.legend() + ax_turb_pow.set_xlabel('Turbine') + ax_turb_pow.set_ylabel('Power (kW)') + # If in viz list also visualize + if fm in floris_models_viz: + ax_idx = floris_models_viz.index(fm) + ax = axarr_viz[ax_idx, 0] -# Title -st.title('FLORIS Model Comparison') + horizontal_plane_gch = fi.get_hor_plane(x_resolution=100, y_resolution=100) + visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - baseline' % fm) -# Create the main analysis image -fig, axarr = plt.subplots(2,2) + # Analyze the yawed case================================================== + print('Loading: ',fm) + fi = FlorisInterface("inputs/%s.yaml" % fm) -# Calculate for alligned case and user requested direction -for wd_idx, wind_direction in enumerate([270., wind_direction_user]): + # Set the layout, wind direction and wind speed + fi.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=turbulence_intensity ) - # Grab two different wake models - # Not positive why this is necessary - # If you move this above the loop so it only happens once, there is an error - fi_jensen = FlorisInterface("inputs/jensen.yaml") - fi_gch = FlorisInterface("inputs/gch.yaml") - fi_cc = FlorisInterface("inputs/cc.yaml") - # Configure model - fi_jensen.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.05 ) - fi_gch.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.06 ) - fi_cc.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.1) - - # Calculate wake - fi_jensen.calculate_wake(yaw_angles=yaw_angles) - fi_gch.calculate_wake(yaw_angles=yaw_angles) - fi_cc.calculate_wake(yaw_angles=yaw_angles) - - # Get turbine powers - turbine_powers_jensen = fi_jensen.get_turbine_powers() - turbine_powers_gch = fi_gch.get_turbine_powers() - turbine_powers_cc = fi_cc.get_turbine_powers() - - # Put the turbine powers in descending order - turbine_powers_jensen = np.sort(turbine_powers_jensen.flatten())[::-1]/1000. - turbine_powers_gch = np.sort(turbine_powers_gch.flatten())[::-1]/1000. - turbine_powers_cc = np.sort(turbine_powers_cc.flatten())[::-1]/1000. - - # Show the (GCH) Horizontal plane - horizontal_plane_gch = fi_gch.get_hor_plane(x_resolution=100, y_resolution=100) - ax = axarr[0,wd_idx] - visualize_cut_plane(horizontal_plane_gch, ax=ax, title="Wind Direction = %.1f" % wind_direction) - - # Compare the power production - ax = axarr[1,wd_idx] - ax.plot(turbine_powers_jensen,color='k',label='Jensen') - ax.plot(turbine_powers_gch,color='b',label='GCH') - ax.plot(turbine_powers_cc,ls='--',color='r',label='CC') - ax.grid(True) - ax.legend() - ax.set_ylabel('Power (kW)') - ax.set_xlabel('Turbine (sorted)') - -# Show the figure -st.write(fig) + fi.calculate_wake(yaw_angles=yaw_angles_yaw) + turbine_powers = fi.get_turbine_powers() / 1000. + ax_turb_pow.plot(turbine_labels,turbine_powers.flatten(),color=color_dict[fm],ls='--',marker='o',label='%s - yawed' % fm) + ax_turb_pow.grid(True) + ax_turb_pow.legend() + ax_turb_pow.set_xlabel('Turbine') + ax_turb_pow.set_ylabel('Power (kW)') + + # If in viz list also visualize + if fm in floris_models_viz: + ax_idx = floris_models_viz.index(fm) + ax = axarr_viz[ax_idx, 1] + + horizontal_plane_gch = fi.get_hor_plane(x_resolution=100, y_resolution=100) + visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - yawed' % fm) + +st.header("Visualizations") +st.write(fig_viz) +st.header("Power Comparison") +st.write(fig_turb_pow) diff --git a/examples/13_streamlit_demo_large_farm.py b/examples/13_streamlit_demo_large_farm.py new file mode 100644 index 000000000..eff399d8b --- /dev/null +++ b/examples/13_streamlit_demo_large_farm.py @@ -0,0 +1,123 @@ +# Copyright 2021 NREL + +# Licensed under the Apache License, Version 2.0 (the "License"); you may not +# use this file except in compliance with the License. You may obtain a copy of +# the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations under +# the License. + +# See https://floris.readthedocs.io for documentation + + +import matplotlib.pyplot as plt +import streamlit as st +import numpy as np + +from floris.tools import FlorisInterface +from floris.tools.visualization import visualize_cut_plane + + +# """ +# This example demonstrates an interactive visual comparison of FLORIS +# wake models using streamlit + +# To run this example: +# (with your FLORIS environment enabled) +# pip install streamlit + +# streamlit run 13_streamlit_demo_large_farm.py +# """ + + +# Parameters +wind_speed = 8.0 +# ti = 0.06 + +# Set to wide +st.set_page_config(layout="wide") + +#Streamlit inputs +wind_direction_user = st.sidebar.slider("Wind Direction", 240., 300., 285., step=1.) +spacing = st.sidebar.slider("Turbine spacing (D)", 3., 10., 6., step=0.5) +N = st.sidebar.slider("Turbines per row", 4, 8, 5, step=1) + + + +# Get number of turbines and make 0 yaw angle matrix +num_turbine = N**3 +yaw_angles = np.zeros((1, 1, num_turbine)) # 1 wd/ 1ws/ N*N turbines + +# Grab two different wake models +fi_gch = FlorisInterface("inputs/gch.yaml") + + +# Define layout +X, Y = np.meshgrid( + spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), + spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), +) +X = X.flatten() +Y = Y.flatten() + + +# Title +st.title('FLORIS Model Comparison') + +# Create the main analysis image +fig, axarr = plt.subplots(2,2) + + + +# Calculate for alligned case and user requested direction +for wd_idx, wind_direction in enumerate([270., wind_direction_user]): + + # Grab two different wake models + # Not positive why this is necessary + # If you move this above the loop so it only happens once, there is an error + fi_jensen = FlorisInterface("inputs/jensen.yaml") + fi_gch = FlorisInterface("inputs/gch.yaml") + fi_cc = FlorisInterface("inputs/cc.yaml") + + + + # Configure model + fi_jensen.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.05 ) + fi_gch.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.06 ) + fi_cc.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.1) + + # Calculate wake + fi_jensen.calculate_wake(yaw_angles=yaw_angles) + fi_gch.calculate_wake(yaw_angles=yaw_angles) + fi_cc.calculate_wake(yaw_angles=yaw_angles) + + # Get turbine powers + turbine_powers_jensen = fi_jensen.get_turbine_powers() + turbine_powers_gch = fi_gch.get_turbine_powers() + turbine_powers_cc = fi_cc.get_turbine_powers() + + # Put the turbine powers in descending order + turbine_powers_jensen = np.sort(turbine_powers_jensen.flatten())[::-1]/1000. + turbine_powers_gch = np.sort(turbine_powers_gch.flatten())[::-1]/1000. + turbine_powers_cc = np.sort(turbine_powers_cc.flatten())[::-1]/1000. + + # Show the (GCH) Horizontal plane + horizontal_plane_gch = fi_gch.get_hor_plane(x_resolution=100, y_resolution=100) + ax = axarr[0,wd_idx] + visualize_cut_plane(horizontal_plane_gch, ax=ax, title="Wind Direction = %.1f" % wind_direction) + + # Compare the power production + ax = axarr[1,wd_idx] + ax.plot(turbine_powers_jensen,color='k',label='Jensen') + ax.plot(turbine_powers_gch,color='b',label='GCH') + ax.plot(turbine_powers_cc,ls='--',color='r',label='CC') + ax.grid(True) + ax.legend() + ax.set_ylabel('Power (kW)') + ax.set_xlabel('Turbine (sorted)') + +# Show the figure +st.write(fig) From 5e04a549b6b431f8a086ea3f3e895ddcc34448d8 Mon Sep 17 00:00:00 2001 From: Paul Date: Wed, 16 Feb 2022 14:48:58 -0700 Subject: [PATCH 07/28] Add getting started notebook --- examples/__getting_started.ipynb | 481 +++++++++++++++++++++++++++++++ 1 file changed, 481 insertions(+) create mode 100644 examples/__getting_started.ipynb diff --git a/examples/__getting_started.ipynb b/examples/__getting_started.ipynb new file mode 100644 index 000000000..c3924b7c8 --- /dev/null +++ b/examples/__getting_started.ipynb @@ -0,0 +1,481 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "86e53920", + "metadata": {}, + "source": [ + "# Getting Started with FLORIS V3" + ] + }, + { + "cell_type": "markdown", + "id": "bb74834b", + "metadata": {}, + "source": [ + "This notebook is designed to step through the basic operations of FLORIS V3 and highlight what is new/changed from FLORIS V2.4" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "a700d720", + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from floris.tools import FlorisInterface\n", + "from floris.tools.visualization import visualize_cut_plane" + ] + }, + { + "cell_type": "markdown", + "id": "699c51dd", + "metadata": {}, + "source": [ + "## Input file" + ] + }, + { + "cell_type": "markdown", + "id": "f1099a88", + "metadata": {}, + "source": [ + "As in V2, a floris interface object is the main point of interaction with FLORIS.\n", + "\n", + "Something that is new is that the input file can be either a JSON or YAML file" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "602f311c", + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize FLORIS with the given input file via FlorisInterface.\n", + "# For basic usage, FlorisInterface provides a simplified and expressive\n", + "# entry point to the simulation routines.\n", + "fi = FlorisInterface(\"inputs/gch.yaml\")" + ] + }, + { + "cell_type": "markdown", + "id": "e1eaeb53", + "metadata": {}, + "source": [ + "## Reinitialize function" + ] + }, + { + "cell_type": "markdown", + "id": "64226134", + "metadata": {}, + "source": [ + "Similarly to V2, changes to the background flow and farm are put in place via a reinitialize function. Another way to think of this function is that it changes the value of variables specified in the intial yaml/json file" + ] + }, + { + "cell_type": "markdown", + "id": "264156e3", + "metadata": {}, + "source": [ + "#### Change farm layout" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "d040b810", + "metadata": {}, + "outputs": [], + "source": [ + "# Design a 2x2 farm, units are m\n", + "X = np.array([0, 0, 800, 800])\n", + "Y = np.array([0, 400, 0, 400])\n", + "fi.reinitialize(layout=[X,Y])" + ] + }, + { + "cell_type": "markdown", + "id": "2bf73f42", + "metadata": {}, + "source": [ + "#### Changing the wind direction and speed" + ] + }, + { + "cell_type": "markdown", + "id": "63f45e11", + "metadata": {}, + "source": [ + "This aspect is one of the major changes from V2 to V3. \n", + "\n", + "Previously, wind speeds and directions descrobed one condition. Now they can describe one or multiple conditions, including an entire wind rose at once. This enables the underlying vectorization which allows the computations to be handled at once, rather than wrapped in a loop.\n", + "\n", + "Some aspects of this specification are still under consideration, but in current form, unless explicitly specified to represent a time series, a vector of wind directions and wind speeds will be \"expanded\" such that each combination of wind direction and wind speed is computed." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "6f9d834a", + "metadata": {}, + "outputs": [], + "source": [ + "# One wind direction and one speed\n", + "fi.reinitialize(wind_directions=[270], wind_speeds=[8.])\n", + "\n", + "# Two wind directions and one speed (Two combinations)s\n", + "fi.reinitialize(wind_directions=[270, 280], wind_speeds=[8.])\n", + "\n", + "# Two wind directions and two speeds (Four combinations)\n", + "fi.reinitialize(wind_directions=[270, 280], wind_speeds=[8., 9.])" + ] + }, + { + "cell_type": "markdown", + "id": "4aff228a", + "metadata": {}, + "source": [ + "## Calculate Wake" + ] + }, + { + "cell_type": "markdown", + "id": "f40efe20", + "metadata": {}, + "source": [ + "Similar again to V2, there is a calculate_wake function. In V3 this will calculate the velocities for every specified grid point, and for every specified wind speed and wind direction. If not doing visualization, grid points will be on the turbine rotors" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "e3bf1698", + "metadata": {}, + "outputs": [], + "source": [ + "fi.calculate_wake()" + ] + }, + { + "cell_type": "markdown", + "id": "8ab273db", + "metadata": {}, + "source": [ + "#### Applying yaw angles" + ] + }, + { + "cell_type": "markdown", + "id": "89ea9b19", + "metadata": {}, + "source": [ + "Yaw angles are applied to turbines in the calculate wake function. Some important things to note when using the new framwork\n", + "\n", + "**yaw_angles is a matrix** -- You must provide yaw angles in a matrix with \n", + "* wind directions\n", + "* wind speeds\n", + "* turbines\n", + "\n", + "**unlike variables passed in reinitialize, yaw angles applied to calculate wake are not remembered between calls**" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "be78e20d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]]])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Matrix of zero yaw angles\n", + "num_wd = 2\n", + "num_ws = 2\n", + "num_turbine = 4\n", + "yaw_angles_zero = np.zeros([num_wd, num_ws, num_turbine])\n", + "fi.calculate_wake(yaw_angles = yaw_angles_zero)\n", + "yaw_angles_zero" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "0f041620", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[25., 25., 0., 0.],\n", + " [25., 25., 0., 0.]],\n", + "\n", + " [[25., 25., 0., 0.],\n", + " [25., 25., 0., 0.]]])" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Yaw the front row for all wind directions and all wind speeds\n", + "yaw_angles_yaw_front = np.zeros([num_wd, num_ws, num_turbine])\n", + "yaw_angles_yaw_front[:,:,:2] = 25\n", + "fi.calculate_wake(yaw_angles = yaw_angles_yaw_front)\n", + "yaw_angles_yaw_front" + ] + }, + { + "cell_type": "markdown", + "id": "e11352e8", + "metadata": {}, + "source": [ + "## Getting turbine power" + ] + }, + { + "cell_type": "markdown", + "id": "bf4b6ac8", + "metadata": {}, + "source": [ + "The calculate wake function computes the velocity at each grid point on each turbine. To then compute the power, you call the get_turbine_power() function" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "6054265f", + "metadata": {}, + "outputs": [], + "source": [ + "# Aligned\n", + "fi.calculate_wake(yaw_angles = yaw_angles_zero)\n", + "powers_aligned = fi.get_turbine_powers()/1000.\n", + "\n", + "# Yawed\n", + "fi.calculate_wake(yaw_angles = yaw_angles_yaw_front)\n", + "powers_yawed = fi.get_turbine_powers()/1000." + ] + }, + { + "cell_type": "markdown", + "id": "5a11cdee", + "metadata": {}, + "source": [ + "The powers are returned in a matrix of the same dimensions as the yaw_angles matrix and by default in units W (the division by 1000 converting to kW in the above example code)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "7de24fe5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[1691.32648289, 1691.32648289, 592.65288889, 592.97819946],\n", + " [2407.84258855, 2407.84258855, 861.30598083, 861.73203268]],\n", + "\n", + " [[1691.32648289, 1691.32648289, 1629.75508349, 1629.75457548],\n", + " [2407.84258855, 2407.84258855, 2319.53233514, 2319.53161349]]])" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "powers_aligned" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "e2606e36", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power of turbine 0 across wd/ws conditions for aligned case\n", + "[[1691.32648289 2407.84258855]\n", + " [1691.32648289 2407.84258855]]\n", + "Power of all turbines when wind direction = 280 and wind speed = 9\n", + "[2407.84258855 2407.84258855 2319.53233514 2319.53161349]\n" + ] + } + ], + "source": [ + "# Can therefore use normal slice operations to get specific powers\n", + "print('Power of turbine 0 across wd/ws conditions for aligned case')\n", + "print(powers_aligned[:,:,0])\n", + "\n", + "print('Power of all turbines when wind direction = 280 and wind speed = 9')\n", + "print(powers_aligned[1,1,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "d0ead739", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Farm power across wind directions and speeds\n", + "[[4568.28405413 6538.72319062]\n", + " [6642.16262475 9454.74912574]]\n", + "[[4568.28405413 6538.72319062]\n", + " [6642.16262475 9454.74912574]]\n" + ] + } + ], + "source": [ + "# Can also use sum operations across dimensions\n", + "\n", + "farm_power_aligned = np.sum(powers_aligned,2) # Some over turbine dimension\n", + "farm_power_yawed = np.sum(powers_yawed,2) # Some over turbine dimension\n", + "\n", + "print('Farm power across wind directions and speeds')\n", + "print(farm_power_aligned)\n", + "\n", + "# This specific matrix could have been obtained via the get_farm_power function\n", + "fi.calculate_wake(yaw_angles = yaw_angles_zero)\n", + "print(fi.get_farm_power()/1000.)" + ] + }, + { + "cell_type": "markdown", + "id": "99b7465c", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "markdown", + "id": "cd938402", + "metadata": {}, + "source": [ + "Tools for visualizing the flow are similar to how they operated in V3 however there are important changes\n", + "\n", + "First, because yaw angles are no longer remembered from previous calculate wake calls, it is important to pass in the yaw angles to the visualization function itself\n", + "\n", + "Second, because to make a visualization of flow on a horizontal plane, a new grid has to be set up, but since this changes the gridding of the farm, future calls to calculate_wake() will be on this new grid. It is therefore recommend that visualizations be performed on copies of the fi object called fi_viz or similar\n", + "\n", + "Finally, visualization does not accept multiple wind directions and wind speeds it is important to reinitialize if the original was using arrays of wind speeds and directions" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "8bb179ff", + "metadata": {}, + "outputs": [], + "source": [ + "# Make a copy of fi so as not to impact the grid of the original as this can lead to confusion\n", + "fi_vis = copy.deepcopy(fi)\n", + "\n", + "# Choose one wind direction and one wind speed\n", + "fi_vis.reinitialize(wind_directions = [280.], wind_speeds = [9.])\n", + "fi_vis.calculate_wake()\n", + "\n", + "# The yaw angles matrix must also be of only one wind speed and wind direction\n", + "# But still should have 3 dimensions\n", + "# Take just this slice and flatten\n", + "yaw_angles_zero_viz = np.zeros([1,1,num_turbine])\n", + "yaw_angles_yaw_front_viz = np.zeros([1, 1, num_turbine])\n", + "yaw_angles_yaw_front_viz[:,:,:2] = 25\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "38ea41cd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axarr = plt.subplots(1,2,figsize=(15,5))\n", + "\n", + "# Plot the aligned case\n", + "horizontal_plane = fi_vis.get_hor_plane(yaw_angles=yaw_angles_zero_viz)\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[0], title=\"Aligned\")\n", + "\n", + "# Plot the yawed case\n", + "horizontal_plane = fi_vis.get_hor_plane(yaw_angles=yaw_angles_yaw_front_viz)\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[1], title=\"Yawed\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env_testv3", + "language": "python", + "name": "env_testv3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From f19baa50f3f54af3779e2961613b39aa42e500d2 Mon Sep 17 00:00:00 2001 From: Paul Date: Fri, 18 Feb 2022 13:47:43 -0700 Subject: [PATCH 08/28] adding grid visualization to notebook --- examples/__getting_started.ipynb | 142 ++++++++++++++++++++++++++++--- 1 file changed, 129 insertions(+), 13 deletions(-) diff --git a/examples/__getting_started.ipynb b/examples/__getting_started.ipynb index c3924b7c8..63799e6d5 100644 --- a/examples/__getting_started.ipynb +++ b/examples/__getting_started.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 1, "id": "a700d720", "metadata": {}, "outputs": [], @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 3, "id": "d040b810", "metadata": {}, "outputs": [], @@ -122,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 4, "id": "6f9d834a", "metadata": {}, "outputs": [], @@ -155,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 5, "id": "e3bf1698", "metadata": {}, "outputs": [], @@ -188,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 6, "id": "be78e20d", "metadata": {}, "outputs": [ @@ -202,7 +202,7 @@ " [0., 0., 0., 0.]]])" ] }, - "execution_count": 61, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -219,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 7, "id": "0f041620", "metadata": {}, "outputs": [ @@ -233,7 +233,7 @@ " [25., 25., 0., 0.]]])" ] }, - "execution_count": 62, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -264,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 8, "id": "6054265f", "metadata": {}, "outputs": [], @@ -288,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 9, "id": "7de24fe5", "metadata": {}, "outputs": [ @@ -302,7 +302,7 @@ " [2407.84258855, 2407.84258855, 2319.53233514, 2319.53161349]]])" ] }, - "execution_count": 64, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -313,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 10, "id": "e2606e36", "metadata": {}, "outputs": [ @@ -340,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 11, "id": "d0ead739", "metadata": {}, "outputs": [ @@ -370,6 +370,122 @@ "print(fi.get_farm_power()/1000.)" ] }, + { + "cell_type": "markdown", + "id": "4dc966e1", + "metadata": {}, + "source": [ + "## On Grid Points" + ] + }, + { + "cell_type": "markdown", + "id": "e8241714", + "metadata": {}, + "source": [ + "In FLORIS, grid points are the points in space where the wind conditions are calculated. In a typical simulation, these are all located on a regular grid on each turbine rotor\n", + "\n", + "The parameter **turbine_grid_points** specifies the number of rows and columns which define the turbine grid. In the default yaml this value is 3, meaning there are 3x3 = 9 total grid points. Wake steering codes currently require greater values greater than 1 in order to compute gradients. However, it is likely 1x1 is suitable for non wind farm control applications, although retuning of some parameters could be warrented." + ] + }, + { + "cell_type": "markdown", + "id": "c771d0fb", + "metadata": {}, + "source": [ + "We can visualize the locations of the grid points in the current example using pyplot" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "774acfea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs has shape: (2, 2, 4, 3, 3) of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.0, 150.0)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAADyCAYAAABkv9hQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABnaUlEQVR4nO29d3hc5Zk2fp/pGo2k0Yx6r7Ylq7tRjNkYCCTgQrNN8gNC2SQkLKSwgSRsQnaXhLAsCbubj2S/EELyJaHYtNiGhSUQCBgwtmz13seSZjRFml7f3x/Sezgzmt4kWXNfFxfWSDrnjObc532e572f+2EIIUghhRTOb/BW+gJSSCGFxCNF9BRSWAdIET2FFNYBUkRPIYV1gBTRU0hhHSBF9BRSWAcQhPh+au8thRQSDybRJ0it6CmksA6QInoKKawDpIieQgrrACmip5DCOkCK6CmksA6QInoKKawDpIieQgrrACmip5DCOkCK6CmksA6QInoKKawDpIieQgrrACmip5DCOkCK6CmksA6QInoKKawDpIieQgrrACmirwAIIXA4HHC5XEjZbaeQDIQynkghzvB4PHA4HLDZbOxrfD4fQqEQAoEAfD4fDJNwH4IU1hmYECtKarmJEwghcLlccLlcsNlsGBkZgUwmg1wuh1gsBiGEJbjdbkdGRgZEIlGK+OsDCf+AU0RPAmio7vF4oFarMTw8jPLyctjtduj1ethsNshkMmRnZ0Mul2NoaAgVFRWQSqUAUiv+OkCK6GsdLpcLTqcTbrcbAwMDcDgc2Lx5s9cKTgiB0WiEwWCAXq/H/Pw8srOzkZubC7lcDpFIBI/Hw/68QCBg/0sR/7xAiuhrFdxQ3Ww2o6urC8XFxSgtLQUAOByOgATt7OxEXl4erFYr9Ho9nE4nMjMz2RVfKBR6FfEEAgG74vN4vBTx1x4S/oGlinEJgMfjYVfxc+fOYXJyEo2NjcjIyACAkJV2Ho8HmUyG/Px8VFRUwOPxYGFhAXq9HufOnYPL5UJWVhbkcjnkcjkYhoHL5QIAMAzjteKniJ8CkCJ6XEEIgdvtxvDwMKRSKc6dOweBQIDt27dDIFj+p+aG78HA4/FYUgOA2+1miT81NQW3281+PysrCwDgdDoBpIifwiJSRI8TCCHsKr6wsIDx8XFs2LABhYWFy36WYRgwDBNwZQ/2PWCxOJednY3s7GwAi8Sfn5+HXq/HxMQECCEp4qfghRTR4wC6N+7xeDA2NgadTofq6mq/JE8E+Hw+FAoFFAoFgMUCICX+2NgYGIaBXC5HdnY2MjMz4XQ6odVqYTKZUFxczOb4fD4/RfzzFCmixwBuwc3hcKCrqwsZGRkoKSmBUCiM+rihVvRQEAgEUCqVUCqVABZX8/n5eWi1WoyMjIDH40EsFgMACgsL4XQ6vVZ8WtgTCARs9JHC2kaK6FGCuzeu1WoxMDCAjRs3IicnByMjIzFLW+MpjRUKhcjJyUFOTg6AReJPTExAp9Ohvb3dKxXIyMiAw+GA3W4HsFgfEAqF7IqfIv7aRIroUcDtdrP5+NDQEEwmE7Zu3cqukrGuyIkmklAoRFZWFhiGQVVVFRwOB/R6PWZnZzE4OAiBQMASXyaTscRnGAY8Hm9ZqJ/C6keK6BGAG6pbrVZ0dXUhNzcXW7Zs8SJnPIiezGYXkUiE/Px85OfnAwCr2Dt37hyMRiPEYjFb3KMrvsPhAIAU8dcIUkQPE3Rv3OPxYGZmBqOjo9i8eTO75cVFsokab4jFYhQUFKCgoAAAYLPZoNfroVKpYDKZIJFI2OJeenp6ivhrACmihwDdG6ehel9fH9xuN7Zv3x6w4LYWVvRIji+RSFBYWIjCwkIQQljiT0xMwGw2Iy0tjVXtpaWleRHf7XaDz+cjPT09RfwVRIroQcDdGzeZTOjq6kJZWRmKi4uD5tE8Hg8ejyfosU0mE4RCIZvXrwSiqQUwDIO0tDSkpaWhqKgIhBBWqjs2Ngaz2Yz09HSW+AsLC7DZbCgrKwPwaXGP6vRTxE8OUkQPALo3/sEHH6CkpATnzp1DU1MTZDJZyN9lGCYg0T0eD/r7+7GwsACPxwNCCLKyslhi0C2ttRL6MwwDqVQKqVSK4uJiEEJgNpthMBgwMjKChYUF9oFGW3LtdjvsdjsIIV5hPn3vKcQfKaL7gBuq06KbyWTC9u3bwefzwzpGIKJaLBa2YaWqqgrAIvFp1xoVtxBCIBaLkZWVteZWPIZhIJPJIJPJ2AekxWJhdyh8W3J5PF7KhCMJSBGdA+7euMFgQG9vL4RCITZv3hzRcfwRfXZ2FkNDQ2wBjxb2+Hz+MnFLb28vDAYDZmZmIBQKoVAo2D3ueN34yYwYJBIJSkpKUFpa6tWSOzAwwJpsUOIzDJMifgKQIvoSuDLW0dFRaLVatLW1ob29PeJjcYlOQ3Wr1Ypt27ZBJBIF/V2hUAipVMpKWu12O3Q6HaampmA0GtnCl0KhgFQqjenGTwZpfBt3GIZBZmYmMjMzUVZWBo/HA6PRCL1ej97e3mUtuQzDwGq1ssdIET86rHuic/fG7XY7urq6IJfLsW3btqjDZkp0bqi+adOmsG9K7oNCLBZ7Vbxp4Wt0dBRms5kNg7Ozs5GWlhbV9SYShJCgf0cej4esrCxkZWWF3ZKbIn7kWNdE5+6Nz83NYXBwEJs2bWLD6GjBMAxMJhPa29sD7rVTON0eaM1OKKRCiATBHyz+Cl8mkwl6vZ4Ng+lqmJ2dHTJ6SAbCbcWliLQll0v8mZkZFBcXp4jvB+uS6NyCm8fjweDgICwWS1ihdSh4PB5MTU3BZDLhggsuCHo8QgiOdamhMtiQlyHCdS2F4POCt7BywTAMMjIykJGR4RUG63Q6qFQqlhTcij733MlApET3RbgtudnZ2ZiamkJhYaHXip9y31nEuiM6N1S3WCzo6upCQUFBRKF1INBQXSaTQSqVhnxouDwE5+ZtyE4XQm1ywO7yQCoKr7LvD9wwuLKykiWFTqdb1q7K9aBLJDweT1x3DoK15FqtVrS3t3u15LrdbtY/n/bir0firyuic0P16elpjI+PY/Pmzaw5QyzgVtWp26s/uD0EJrsLEj6BkM/DrhoF2icXcGFFNkvyeO2j+5LC6XTCYDBgbm4Oc3Nz7HloRT8RW3mxruihwG3J1ev1aGpqWtaSS4mfkZHBEh9YXyYc64LovjLW3t5eAAho8eTv9wPdAP6q6nq93i9R3R6CF9tVGNdZsSFXiivrctBQlImGokyvn0uUYEYoFCI3Nxe5ubnIzMyE2WyGRCJhm1ckEgkbJqenp8flpk800X3P5a8lV6/XQ6PRYGhoaFlLLnXpBc5v4p/3RKcy1tOnT6Oqqgrd3d0oLy9HcXFxWL9P5az+xDKBquoBBTMON8Z1VhRkiNE/a8JlG5UQ8lfuRhIKhWzzCtWw0zCfK2VVKBRRV/STSXR/EAqFyMvLQ15eHgCEbMn1NeE4X9x3zmuic/fGDQYDenp60NzcjPT09LCPEYi0vgIY39/hSmA9HgIej4FMzEdTcRY6VQvYUSGHgOf/plkJCSzVsBcXF3tJWfV6PQYHB2Gz2VhhS3Z2dtga/WQSPZzzhNuSG4j4vjr9tUL885Lo3IKb0+lEd3c3CCHYsWNHxHmob4NKOAIYSlSn24OX2qcxqjXjyvo8tJTK8dn6PFy+KRdutytk48tKgitlLS0t9RK29PT0sPvbXK95f0gW0aN9MAZqyaU7J/5acu12O86dO4f8/HxIpdI1Ybt13hGdK2PV6/Xo6+tDbW0tbDZbVMUmLtHDFcBQomuMDgxpTFCmi/D+sA4tpfKlYzJwuUhAEqy2NlVgubDF3zYXXe2zsrLYVCdZRI/XLkK4LblqtRp5eXle7jt0xV+NvfjnFdHpCk5lrHq9Hlu2bIFEIsHQ0FBUNx0lXbBQPdDvKNKFyMsQQ2Ny4OJqBfv9ubk5tiAolUq98uBkrgix7m/7bnPRiv7w8DBb9OLq1hOJUAq8aBCsJddqteLs2bNeLbncXvy7774bDz74IDZt2hTOeX4D4BoAakJIw9JrDwH4ewCapR/7HiHk+NL3vgvgDgBuAPcQQv4n1DnOC6L7Tirt6uqCQqHAtm3b2Js5WFEtGBiGwdDQEJxOZ9iCGkp0iZCPWy8sg8XhRlba4hilkZERVkfP5/PZG4d2dmVkZIAQwk51WSsQCARe1W5u0au3t5d9oNHcN94PtHjv1/sDV5l47tw5bNmyBRaLhW3JtVgskMlkGB4ehk6ng0QiCffQvwXwXwB+5/P6zwghj/lcQz2AQwA2AygC8L8Mw2wghLiDnWDNE527N063UOrq6tiVhiIaolssFuh0OpSUlKChoSEqrbqQz0NWGg8Oh4MV02zduhUejwdutxvp6elIT09HSUkJmwePjY1BpVJhdnbWS9kW6UNqJUGLXvTvJxAI2BDYZDKxKyHV6MdK/GQQ3Rd0dBZtyaWS5HfeeQf9/f3Ys2cPtmzZgp///OdBo0BCyLsMw1SEedp9AJ4lhNgBjDIMMwRgO4ATwX5pzRLdd2+cVoYDrbrhuL5wQUN1uVyOwsLCiPXa3Bx4fn4eXV1dqK2tZbd5qOkE97g0D1YqleDxeMjLy2OVbSMjI17hcqwtq8mWwPqGwPQh6tujrlAoonLdSTbR/f39qCT561//Oo4cOYK//vWv6O3tjSU6u5thmFsAfALg24QQPYBiAB9yfmZq6bWgWJNE51o80UmlRUVFqKurC3jzh0t036r64OBgxKSgKzohBJOTk1CpVGhtbWXnnYcL30EMdCtIpVJhYWEh5vx+JdpU6XlpJMPtUdfpdGxFn9ucE84wjJVY0YPB6XQiLS0NW7ZsifYQTwL4FyxONP4XAP8O4PZoD7bmiM7dG5+ensbExAQaGhqQmZkZ9PfCIbq/qnowW6hAYBgGbrcbHR0d4PP5EbnT0N/393DhbgXRwhB3VaT73AqFYlV0rgHhVd25Peq0VZVW9CcnJ70aVwKlMMkmeqIfkoSQWc65/i+Ao0tfqgCUcn60ZOm1oFgzRKf5j91uh0QiQU9PD3g8Xtgy1lBED1RVjzTkBxYfGPPz86ivrw9bgRcpuIUhbn6v1+vR1dXFdq4pFIoVze+j2eng8XheHWu0os9NYej3MzMz2c8oWUQPFeHFY0uRYZhCQsj00pfXAuha+verAP7IMMzjWCzG1QL4ONTx1gTR6d64Xq+HWq2G0WhERUUFioqKwj5GIMKGEsBEuqc9PT2NkZERtmc8GkQTRfjb5/YlB9eSKpk5eqwE9FfRp1ZbAwMDEIlEkEgkfuseiQC1sA6GSK6DYZg/Afg7ADkMw0wB+CGAv2MYpgWLofsYgK8sHbebYZjnAfQAcAH4eqiKO7AGiM7tG9doNJibm8OOHTsiznf9ET0cAUwkuX1fXx/sdju2bt0alQUVRTxuVF8vOofDAZ1Ox0o9AbCWVYncv08E8UQikZd+3WazYWJiAvPz8/j444+9tvJitdvyh1BEd7lcEUVQhJCb/Lz8VJCffxjAw2GfAKuY6Ny9cYfDge7ubggEAuTl5UVMcmA5YcMVwPhW0P3BarWio6MD+fn5qKurYwtxwUBvPqfbg1mjHRliAbLSPi06xXvFFYlEXvk9bVwZHh6G1WpNWH6fjL53KlMVCoWoqKiAxWKBXq9n97a5Gv0I9rYDwu12B41SaEPQasKqJDp3b1yn06G/vx8bNmyAWCzG+Ph4VMfk8/nweDwRmzWGCqM1Gg0GBgZQX1/P5pRA+ET9aMyA/lkzxAIe9jXlI0OSeF93hmEgEokgEolQXFwMj8cDk8kEnU4X9/w+mRJY2mTC1SbQ2o5Op0NfXx8cDoeXRj+ah1ooPQb18ltNWFVE97V4GhkZwfz8PCtjNZvNcLtDpiN+wePxYLFYMDw8jPz8/LAdZQKt6IQQDA0NwWAweE1SBSILvfVmJ9KEPNhdHticbmRIkvORcAnI4/G8qt40v6cmlLQ4RvfvI8m5k9nU4u+6uHZb5eXlrPkkddb1eDzLBmiEQqjQPbWiBwF3b9xms6GzsxM5OTnYunXrMhlrNDCbzdDpdGhpaQmpVefC34rucDjQ0dGBrKwsr+sLB4QQGKxOSAQMGAAXVmWjfXIeeRli5MhE7DmTUSwLdN3+8ntuK6dEImELe6Fy4GSv6KHgz3zSd4AGtznH3zFDEd1kMqVWdH+ge+O0eWRkZGRZKAws3oCRrujcEUgVFRURkRxY/nChbZobNmxAbm5uRMcCgA9GdOiYWkCmmMHn6pTIkYlxRV3kx0kmuD3c3P17bg5MFXu+oXAyiR7OauwLfwM06O7O4OCg3wEaoXJ0KvFdTVhRovuG6v39/XA4HAEnldI8O1xYLBa2SEaH/EUKuqITQjA+Po6ZmRm0tbVF7bgypDYjje9Gx8AUsi1TUKYLWZLQZo+VMJ4IF77791xVW3d3N1wuF5vfUy++1bSih4KvIw13gAbtT6euM4EeYrS5ZTVhxYjO7RunMtaSkhKUlJQElbGGu6L7VtVVKhXrFBIJ6Gyws2fPQiQSYfv27RHfUNwbolrmwhsdKuxsqMClm/Lhcbug0+nYZg+ZTMY6mCQS8XqQ+KrafPN7i8WC0dHRqPL7SJAowYy/ARq0Bfrjjz/2O0Ajkhz99ttvx9NPP62Gd4vqvwHYA8ABYBjAbYQQw1LjSy+A/qVf/5AQ8tVwzrMiROfKWFUqFVQqFRoaGkKK/8NZGQJV1aPN7+12OyYnJ7Fx48aIBDoUH4/q8NGYHvUFMhQSLdJddvzg4MVgGAZOpxNCgfeNZDKZMDk5Ca1WC71en1B1WyJWWt9Q+KOPPmLbOiPN7yNBMttUMzMzoVAoUFBQsGyAxvT0NE6cOBG2WOpLX/oSnn766avg3aL6JoDvEkJcDMP8FMB3Ady/9L1hQkhLpNeeVKJTHzKDwYCsrCz09PRAIBBErAUPBG6o7ltVj4boKpUKExMTyM/Pj4rkHg/Bh6N6KNJ4+J9P+nHztiK0tNSxeZ4vaIU4NzcXaWlpKCsr81K3CQSCZWH+agePx1uW39M9bqvVCplMxhI/llnxyZTAut1uiMVir4o+HaDR0dGBw4cP469//SteffVVPPLII7j88ssDHmvXrl0AoOO+Rgh5g/PlhwBuiPWak0Z0ujdusVgwPj4Ou92O6upq1qsrVoQSwERCdLfbjb6+PrhcLmzcuBELCwtRXROPx6BExuCD3jE0VhWjfkN1WOSkObrv6kjzRW6YT4kfC0mSBW5+Tw0ofbvWAk2WCYVkE93fuXg8HlpaWtDc3IyDBw9i3759UaWLPrgdwHOcrysZhmkHsADgQULIe+EcJOFE5xbcCCGYnp7G/Pw8LrzwwqgUbr4IVwATLtFpVFBYWIiysjJotdqo8llavCtwz+If925FTpYM/ACur+HCN1+kQhAuScIN81dDsS9Yfj82NhbR/n2iiL5gc+HZTxabww5tLUamRBC2YCbW+5thmO9jUc/+h6WXpgGUEUK0DMNsAfAywzCbCSEhV6KEEt1XxtrZ2Yn09HRkZmbGheTBQnVfhEN0uqXCjQqiCfmpFsBoNGJHgLQk2LWGU3X3FYL4NrGEE+avttA/nP37QCOjEyW1fXdQi1MT8wCAoiwJrmnMD0swE2vVnWGYL2HRR+4ysnQzLLnK2Jf+fYphmGEAG7BoTBEUCSM6V8aq1WoxMDCAjRs3Qi6X49SpU1Efl5JArVaHbdYIBCcsHbRoNBqXRQXhaN25sFgsOHv2LPh8PhoaGsL+PS6iuWHPtzAf8L9/Hyi/T4Q5JADkyETgLX0eVNAUiuixbq8xDHMVgO8AuJQQYuG8ngtARwhxMwxThcUW1ZFwjhl3ovuG6kNDQzAajaxMlH4/WjAMg56eHtjt9oimnwYiut1uR0dHB7Kzs7Flyxa/bijhruhU997Q0IDu7u6wficQYg2tfcN8qgzs7e2F0+lkZa+5ublrwosuVH5vNBrB5/ORm5sbcX7vC5XBhlmjHZsLM7CjQo5s6aKmY0Pe4pZZPAUzN910E7Do98ZtUf0uADGAN5fuR7qNtgvAPzMM4wTgAfBVQojO74F9EFeic2WsVqsVnZ2dyM/P9yJQLOGVxWKByWRCTk4O6uvrIzqWP7ENvfE3btzI9jr7IpzQnRCC4eFh6PV6r4dPtKqweAtmGM4whrKyMrjdbgwMDMBiseD06dPsWCKlUrlmqvm++X17ezsUCgUMBkPE+T0XaqMdP/6fIdicbmwrl+Orl5RjY7736hxOjh6uT9yf/vQn/OlPfyr0edlviyoh5AiAI2Ed2AdxIzohBHa7HYQQzMzMYGxsDPX19RFLTgOBVtUzMjJQXFwclWsJJSxt01Sr1WzDTCCEIp3T6URHRwcyMjK8dO/091Yjafh8PtuLnp+fz3rRTU5Owmg0Ij09nQ3z49HWmQwQQqBUKtlRSzS/n56eRn9/f9D8ngu9xQmHywOxgIdz8/496cMJ3VebXXfciE73hnt7e+HxeMK2eAoF36p6b29vVKE/VdU5nU50dXVBIpFg27ZtIZ/0wVZ0o9GIzs5OVFdXszcYRSyrcrIlsL5edDTM7+vrg9PpRFZWFpsLr9Yw37fq7jtjzZ8+35/rbG1eOq6sz8Wwxowb2/xrJ0JV+M/77rWuri7k5OREteL6A62qFxQUsFX1aBVuPN6it/rJkydRVVUV9v59oGLcuXPnMDY2hqamJr+Fl9WsVwcC1wD8hfnUcpqGxOFaTifz/YequvsOkOTOkXtrzIazWgaX1ihw68WVuKHVN5L2RqhIze12x2WRiyfiejWtra1hfbi0wBXsqRhIABNNBxuwSEyLxYKLLroo4mmqvkMWqYFBsKglVLXebrfDYDBAJM3AGZURaUI+mksyIeTzVrxNlQvf0UvUkmpqaipkmJ/s1CUCjzY2v88tLMETnZ3IkhH874AOteJ5yEQ8NoKh5pPhnme1PtzjSvRwb1BKVn9EDyWAibSDze12o6enB4QQSKXSiEMqLmFpc0teXl5QD3kg+N/CYDCgu7sbMpkMpyYGMGvjQ5wmRYawCBsKs/3+zmqBryVVoDBfLpeznXjJQLTnkQh5qM1Lx5DGgk3FCuzcUQu3y+llPikWi9mHWTj6j2S+73ARd6KHA0p031ZUf6G6LyLpYDObzejo6GC74k6cCDq1xi/oik7DvE2bNrF71eH8ni/oQIeWlpbFcbs5FnwwqIHVYsbs1ATmp4aQlpbGCo1WWwjIRagwn2EY2O12LCwsxDxZJlHgMQy+c0U1VAYbCrMk4PMY8H3MJ2l+Pzo6CrPZzDavBNIkRLKqB+heU2BR9lqBRQfYA4QQPbP4B3wCwOcBWAB8iRByOpzzrMhd5C/8DtesMdzQnR6voaGB7YuOBgzDwGq1YmBgIGSF3vf3uB+4x+NBb28vbE4XMsvqMGvxoCiDoCZHCrmkEAI+D9lSITuYQqVS4cyZMxHlxJEgESGmb5hvNpvR2dkZVpi/khDyeahQBl6pufm92+3GyZMn4XA4vObE0yjG3wIWDAG61x4A8BYh5BGGYR5Y+vp+AJ/DokimFsAOLE5z2RHOeVac6JGaNYYqxnk8HnaPOJCBRbhwuVzo7u6G2+0Oq0LPBZfodrudDfmtyMSHowZ4iAeXbVCgWJ6G3IxPVwUqZFlYWEBdXR2bE09OTnop3JRKZcxurYleYYVCISQSCerr60OG+bFGLsn0qReJRCgvL2elx3SqTFdXF77//e/D7Xbjb3/7G3bs2BHy/vPXvYbFQYp/t/TvZwC8g0Wi7wPwuyVJ7IcMw8gZ70EPAbGioXs4oXqg3/UHm82Gjo4O5OTkYOPGjTHdyDTsLy0thdlsjlheSYlO83Ea8mvG9ABDAAKEc2/65sQmkwlarRZdXV3weDzsFlEgf7OVBLcYF89q/krCdw+dG8VUV1fjF7/4Bb797W/j97//PV544QU88cQT0Zwmn0PeGQB077YYwCTn5+iAxeQSPVzw+XzMzc1BrVaHpVU32VzQmh0oU6SBz+fD4XAs+xmtVou+vr6wc+hgoM0tNOyfmJiI+BgMw2BmZgazs7Mo27AZ4vTFLbjmkixIhDyI+AwKM/0/7QMV8riNLBUVFXC5XF7+ZtTUIdyiUaIRrOoeSzU/kvPEG6HEMhKJBJWVlfjVr34Vl/MRQgjDMDGHK0knOi1sEULCCtUNFie+fbgTBqsTV23Ox54aideKTgjByMgItFptRDm0P1Bt/vz8fEQ6el/QIYFOpxNpxZvwWp8eIsEC9jcXQi4VorE4i236iQUCgQC5ubnIzc31Mm0cHByE3W5nRzD7C42TQY5IzhGomt/f3w+73e7Vguv7XlZDLzpFnMQyszQkZximEIB66fWoBiwCSQ7daahOVUvhEGlSb4XB6oJUxMdHo3rs31jC5ui09VUmk2Hr1q1hfdiBbj56rIyMDL/NLeGC5uNCoRC1tbX4UGWDRMiH1enGgs0J+VKDRKxtqv5+x3foIm1bHR0dZbvbaNtqMhCL1p8b5nPfi78wP5lET9LwhlcB3ArgkaX/v8J5/W6GYZ7FYhFuPpz8HEjiis6tqhuNxrC3yDbkpaOxOBN9M0bcdmEJu702Pz+Prq4u1NTULJOfBgIt5Pl+UAsLC+jq6vIrZY0E9Jo2btyI2dnFqbdbyuR4d1CL0uw0FGSGX7GPFVwyAMvbVoHF1SkzMzNhI5bjFTX4vhffMF8ikcDhcMBqtUbtzhsuwvF0j2RFD9C99giA5xmGuQPAOIADSz9+HItba0NY3F67LdzzJJzo/qrqFosFdrvd788Pqk34c8cMtpbLsas2B2IhHw9ds4n9vl6vZ6ucra2tEeWiVGzD/aCoL1xzc3NMIRc9Dr0mtVoNj8eDnCwxrmuN3G8u3lVk37ZVqu7jFvWUSqVfJVi0SFR64Bvm0xnx1KAxWJgfKTRGO3QWJ6pypBDyeXE3nQjQvQYAl/m+sFRt/3rYB+cgoUQPVFUPVjn/52N9WLC68O7gHGrzZCjM+nQVdLlcGBkZgd1ux8UXXxxxgwV3a44rZd22bVvUNwR9kNH+eHqc1dzUwjCLs9fkcjmUSiVcrkXLaaoEk0gkbJgfywqZLGdWiUQCmUyGzZs3s/URbphPH2KRVvPnTA78+19GYXO6cUFFNg5tLUqKu0wikLAcPZgAJhjR04R86MxOSIQ8CDgeayaTie1v5/P5UXVR0bCfSlnp9NNoVx2Hw4GzZ89CqVQu2x5c7U0tXNAptXl5eSCEwGKxQKfTLVshI+1eS+aUFnoeSmw65Ye2q6pUKiwsLLDtueE8xAxWJ+xON6QiPlQGK4DwinFUUbeaEPcVPRwBDJfoDpcHPAYQ8Bf/eP+8pw7vDc2hvjCTFZJMT09jdHQUDQ0NEIlEMBgMUV0bj8djjQfr6urYnC8c+N60NB8PNJppNa/ooc5Np5GWlpay9RCtVovR0VHWi06pVCI9PT1kg0eyiB7oAeRrR+X7EOO24PpGdZVKKS6pUWJcZ8H+5gL2XMGiv9XYogrEmehOpxMff/xxSAEMJfonY3r88/F+pIv4eOyGBhTL01CQJcGNW0oAfPrQsNls2LZtG4RCIRwOR1Tda/RDHh8fj3gbztdE4ty5cxgfH0dLS0vADzUUWbVaLSYmJtjwOdFFpGjhu99ts9nYsJg6qdAw31cFthIrejD4PsS4Yf74+Dh4PB5GrRJ8ovbgoppcXNOQh+tavNuZqad7IKyL0F0oFKKhoSHkG6VE/3PnzGIxxeLEyXEDiuWf3uxWqxUdHR3Iy8sLO78PBJfLxc79rq+vj3ivnZvbDwwMsNFKsCd7IKJTG+jZ2VlUVVVhYWEBAwMDcDgcbIgslUoTvqJHS0KJRIKioiIUFRWBEOI1ghgAq9TLzMxc8ZHJoeAb5lttdvzqhW6IGBeePzGIbPsMKgtzvML8RBtDJgpxz9HDeZOUrJdvysWpCQNkYj6aizPZ78/NzaG/v9/vRNVIjSeolLWsrCxq91Mejwe73Y6enh4oFIqw5LX++tE9Hg96enoAAFu3bmUbImiIbDAYoNVqMTQ0BIfDgampqVWjcvMHhmGQlZWFrKwsVFZWspNIqX0TnSFns9kS2sQSr6KfRCxCfUk2hjRm1Cjk2FxbCNOCwSvMt9lsQZuk1kXoDoSXXwoEArhcLlxSm4PG4iyIBDxIRXwvk0XqGuvv+OGCSkMbGxuRmZkJk8kUlTuN2+1Ge3s7Nm7cGPaoZN+/g91ux5kzZ1BQUOB3sivXrpmKdwCwKjca4idiBlu8wJ1ESgiBSqWCRqNhm1gSNUcuFqK7PAR9MyZkSgQoU6Thq5eUY0JnRVGWGOliAbKzMrzC/IGBAQwPD2NiYsKv+WS0oTvDMBvhPZGlCsAPAMgB/D0AzdLr3yOEHI/0+CumdaeEo0oxh8OBjo4OZGVleZksRoNAUtZobKimp6dhMpnQ1tYWUfGO249OC3dcHX6ohyGfz2f76LkFsZGREQiFQvahsJpXe7FYDLlcjsrKymUDJujccYVCEbKoFwqxEP3PHTN4vWcOAj6D+y6vQqVSitq85SsyDfNlMhkqKiogFAq9hkukpaVheHg4amNIQkg/gBYAYBiGj0Vp60tYFMX8jBDyWFRvcAkrQnTf1Y52eAWqYEcC7gPDV8oaCdFpu6vVakV2dnbEoSd9j3THIBJxj+/fx7cgRjXtQ0NDbCipVCoj2v5Kttbdd8AELerR0cqZmZnse4i0tTgWok8v2CHgMXC6PdCaHagM0pcOfJqj+6vmv/fee+jv78fnPvc5XHLJJXjssceiLbJehsWpqePx+oxWJHSnIIRgYmIC09PTEavc/GFhYQGdnZ2ora31u5cZLtHpw0Iul6OlpQUdHR1RhfwzMzNgGCZujrgUXCMEX027QCDwWu1Xst0z2MOEW9TzeDwwGo3QarWYnFzswqQPtszMzJDvIRaiX9tcALvrHHLSRWgqygz58/6KcbSa/7WvfQ3PPfcc/va3v+H06dOx1CUOAfgT5+u7GYa5BYujl75NCNFHesAV8ykihLDNH9u3b4+5mEIlqMG2vMIhutFoREdHh9fDItJ9bZfLBZVKBbFYjLa2tojJFsn5fHXgNpuNDfGtVmvQfeJEI9yogcfjsUU9YHGbVqfT4dy5c+jr62NbVpVKpd+6Tai97WAozJLgm7urwv75UIIZj8eDtLQ07Ny5M6rrYRhGBGAvFqe1AIsuMv8CgCz9/9+xOGE1IqwI0Y1GI8xmMyorK6OaO851kaUWTS6XK+SWVyii0zC7ubnZq6ASSchPZ69lZWWFtRr5QyyrsEQi8VrtaW4/NjbGrvYKhSIpgpxo0wOhUOgVFtOWVe7UWKVSiaysLLbek8zutUDnitPf9HMAThNCZpeOOUu/wTDM/wVwNJqDJiR0Dwbqhy6VSlFYGNw/OxAo8agENT8/H+Xl5SHPHci0ghCCgYEBmM1mVpjje75wPkRqftHQ0BBRh54/xOOm8d0nttvtrMLNYDDAZrPB5XIlbLWPRx3AnzONXq/H3NwchoaG2EKrQCBISt0hlMNrHBxgbwInbPexiroWQFc0B03aik5XXqfTie3bt+PUqVNRG91Th5rh4eGIpKz+Vman08muwK2trX4/pECOrhS01jAzM8NuC5rNZrhcrsjeGOd8iYBYLGbz4v7+fqSnp2NhYYFVhdHcPtYqOEUiVlo+n4+cnBx2Vp7VakVfXx9mZ2dx7tw5ZGZmsqnMSqQqsTygGYZJB3AFgK9wXn6UYZgWLIbuYz7fCxtJ+UvQLrbCwkKUlZWBYRgIBIKwie72EHw4qgMDYHtFNmw2G0ZHRyOWsvpaRQcbqeT7e8FGLlPfeK6BZKx69USH1nSlLClZlBvTfnUqbaVV8FgIk4wVNi0tDTKZDDk5OcjKysLCwgIrL2YYhs3t4+VDF+xzcTgcMY2kJoSYASh9Xrs56gNykPDQnYpWYpm48kavGk+/Pw4AuLyEYJPMg6amppikrDMzMxgZGQk4UomLQKTlurv6pg5roamFe73cfnVuFXxiYoIt+EU6bTWZWncejwcejwe5XM7eZ/586OjDKxEz4lerKg5I4IpOCMHg4CAWFhYCTlwJexCDzQW3xwOLxQxBWgEUivSoiEBX9IGBARiNRr/5eKDf813R6VZeoJHLochKHWIzMjJWZEhDsGvjVsGrqqrgcDhY0ptMpqCNLL7nSCbRfeHPQZdb1KPKNrlcHlaKESoVidRdJplIyB1mt9vR0dGB7OzsgP5rfD4/7Bx2Sz6DjgwbijeW4tDF1Rgb6o9qX9vj8UCtVqO4uDiibS9f0tJoIFT3WqBrdLlc6OjoACEENpttmdJttVkdi0QiL3caGh7TRpZA4fFKE50LroNueXk5XC4XDAYDNBoNhoaG2LFLtJOQYRZFNBqTAznpIogE8XeXSSbiTvSFhQVWF+5vpaMItKITQvDbExM4NWHAoa3FyPPoYDQa8U8HLmZXj2g62EwmE3p7eyGVSlFbWxvR79IVnUpraZQSbDULtKJbrVacOXMGZWVlbIhJ942p0k0ul8PlcoW8sVYC3EYWAMsGTGRkZLCEWU1E94VAIFhW1KMNRTabDZmZmXhjkmDaDJQppPj7nWVhGUOumxVdIpGgra0tpPQvEFnHtBa81j0LiYDBvx/vxKOfK1m2+kaqWZ+dncXw8DA2bNiAmZmZ8N8M53xOpxNnzpyBVCoNKxrwR3Qq9a2rq2PdSz0eD9sMQguC8/PzmJ2dxalTp1hbJ6VSGfcOsHiQ0Dc8prl9R0cH+9ASi8UJHcoQj+p+Wloa21vg8Xig0ekxdGoEaXDgrF6PvgI38rODv4d1taKLxeKw/uiBiK5MF0HCBzS6BbSWK/yuvuGu6L4rsNPpxLlz58J7Ixw4nU6oVCrU1taGLfDxJfr09DTGxsbQ3NwMsVjM7jwAYKMFSvy0tDSIRCK0tbXBZrNBr9ezHWDU/yzWySyJKPYxzKfjiCsrKzEwMAAej8cWw2QyGZvbx9N5Nt7beDweD/k5Sly/HXh3SIddxTIoM8DaUXV3d/sdixVLjs4wzBgAIwA3ABchZCsTYNhiNMdPumCGgpKVEIIpgw3KdBGkIj4WtLP4YrUL8uIGtJT7D/3DmajqdDrR0dGBjIwMdgV2u90R5/a0altQUBCRio+KbLgPm7a2NvB4vGWiCnqT8vl8mEwm9PT0oLq6GsDig5O7YhoMBnYnQyqVJrSKHCu48lx/46QoWaJVEFLEi+jzVife6NUgQyLA5ZtycWmtEpfWfrrblZaWhtnZWRQVFS0biyWRSDA/Px/riv4ZQsgc5+tAwxYjxopp3fl8PpxOJ3713hje6FEjWyrElxsEkPAJLt+5I2guFGpGuslkQkdHB6qqqlBQ8KkVUKQhP224qaysjGqggtvtxtmzZyGRSNDc3MzmrIFuaq1Wy46CojcMd7V3u93ejihWK/R6Pbq7u+NKnHiBm6Nzi2EVFRWsSQVXz05TlEhX+3CtpELh9R4NTo4Z4AZQkClBS4l3kwvVffgbi/X666/j0UcfRUZGBrKysnDdddd53XtRItCwxYixokS32Wz4YMSANCGDSY0BJhRje9OGsKSsgXzh1Wo1hoaG0NjYuKwvOFyiUxWf2+3G1q1boVarYbVaw39zWCxSqdVq1NbWstXqYCSfnJzEzMwM2travG507movFApZwhNCkJaWBolEwh6fup329fWxIpJAW2ArPZLJ16TC3/DISHzm47GiZ0oEcIOAzzBIEy4/nr/IgY7Fuvnmm2EwGNhFiEaBEYAAeINZnLP2K0LIfyPwsMWIsaJEd7lcuGZTFp56fxytZUpc0lQbdreTL2GpO43BYMDWrVv9rgrhEJ3q53NyclBRUQGGYcLWulPMz8+jr68PmZmZbMgdrBGCesa1tbWFrLJTYQjw6WpPUxJuvzd1O6VbYPR7kQheYkW4DxPf1Z76zFNLqlDda7HUG+wuDxwuz1K4noOCTDGkIj42+DGfCMcvrrm5GTfeeGM0l7KTEKJiGCYPwJsMw/Rxv0lIbMMWVzRH1+v1qODx8PLXLoqoQd+3GEf3pdPT04POTQtFWNqi6muAEUrrzgXdY6+vr0d3dzcmJyeRm5vrt9fe5XKhs7MTmZmZ2LAhdCTj7/0AYG8+utp7PB6vOWw0vKSCl8zMTNhstpiabsJBtKaNvj7zZrMZWq0WPT09bPoSj6kyWrMD//HOGIw2F27aWoRt5XK0lgb2gwtnHFO0OTohRLX0fzXDMC8B2I7AwxYjRkJW9FCqMJfLheHhYTidTlx88cURf1jcYpzZbMbZs2dRWVkZdTcc8OkWnG+LKj1fKKKTpamuer2eXZnb2tqg1WrZSS4KhQI5OTmQy+WsuUVpaWlM1+17nf5We+7UVYZhYDQaMTAwgP7+fohEooSJdeKRO3O716jQRa/Xs1Nl0tLS4HQ6YbfbIy5IjuusMFicSBfzcXLcgG3l8qA/73a7g2ononWAXWpm4RFCjEv//iyAf0bgYYsRI+mhOy2UFRYWYn5+PqonMs2DfM0fowE35A8kggn14HK73ejq6oJIJEJLSwsbstJVlbq86nQ6zM7OoqenB06nE6WlpTHPcg+EYKu9TCaDRCJBeXk5xGLxMqMK+jCKRaxzYlSP/3jPgMs3S3DHzvjtLfuOirZYLGhvb/eStYa7/VidI0Vehgh6ixO7akJ3QLrd7qBahhgEM/kAXlp6KAoA/JEQ8jrDMCfhf9hixEgq0WlY29jYCKFQCJ1OF9VxeDweDAYDLBZLTHPMqd+7RCIJGfIHWtGpu2thYSHrde6v6Mbn85Gbm8uaQWzatAlGoxFnz54FAFallagcmq72tAdBIBBAJpOBEMKaPABgfdqHh4chFovZ1T5S77PvvNQLi92FsRPT+MymAlTlxN/Eklo4iUQitLa2srJWugCEEhtlpQnx3Str4PYQCPnhad1DKeOiNIYcAdDs53Ut/AxbjAZJCd09Hg8GBwdhMpnYVdPpdEaVI7pcLvT398PtdmPLli1R52hcKWpxcXHQnw2U23MbW7KyskIW3cbGxqDX67FlyxYIhULk5OSgsrKSbRoZHR2F2WxGVlYWcnNzoVAo4m6L3N3dDYlEgsbGRrb2wBXrcAUvdrsder3ea8AEtZwO9XeXpwlhdbjA4wEyceJkvNzPhStrpau9Tqfzspv2vX4ew4DHD+/BmsgcPdFI+IpOq9jZ2dle0tFo9Op0GENRURHm5uaiJrler0dPT4/fAZD+4K8YR3P6xsZGtgki0EpMt+t4PB5aWlqWXTe3aYSu+NRYQyQSITc3Fzk5OTGNbaICory8PJSWlrKvBwvxfZ1O5+fn2SaQtLQ0drX0lxv/+otNeOYvHbiitQp5GYkT8wR6uNLVnjtDjutMI5FIvJpYwkE4VfdoVvRkIKFEDzaIMNItK41Gg4GBATQ2NkIikUCtjq4A6XA40N/fH5FpBTd0J4RgdHQUWq2WLboFIzkdxpCbm4vS0tKQYTnX/qm2thZWqxUajYZ156EFvUgksHR6bGVlZchJn8G277i93lSa29PTA4fTiSOjPPRo3fjG7ipcvikX+ZliXFkpwqaCxK5w4arifJ1pLBYLtFrtsnFYwWoToYwhrVbrqp2hlzCiT05OYmpqKmYbZy6xNjW2QpouAQMScTRA56HTkD8S73Caing8HnR1dUEgEHgV3QKR12w2sw420frVp6WloaysjPVL02q1mJ6e9hLF5OTkBHw/RqMRXV1dqKurCyt64SLQak8IYYU6BQUFOKtawF/f6YPd5cGDr/ai0K2GUqmE2+1O+J59tJV930IpHYfFrU34jsMKlaNHu52YDCSE6ENDQzCZTNi+fXtMOSYtlonFYkwKivDky30oU6Th/s/WRiRl5c4xj8YPjcfjweVy4eTJkygoKEBxcTH7oQY6lk6nQ39/PxoaGuIWzvH5/GVqMo1GgzNnzgBYLOjl5uay75GOB25qaopL+2Sg1b4gUwIej4FYyEOVcnHvXq/XszssNMRPRAdbKPKFA9/hErRl1XcclsvlCniuZLXkRouEEL28vDwoCcIBtU2mxbJfPt8BhVSICZ0V5+b9y1/9gfrC1dTUIC8vD1qtNuLGFrPZDIPBgJaWFsjl8pAruUqlwrlz59DW1pawZhOumoy6wMzNzWFkZARmsxkikQg2my0ugzH8gbvaV+SJ8IfbWtFzbgEXV8khFfEhlUoxNzfH7i7QfvV4eNFxES+dOxfcllXuOCzauRZoHFY0ZJ+cnERZWdnbWNxiIwD+mxDyBMMwDyEOM9coEkJ0kUgUdmjt749D8/GGhgbW4ODyTbl46cw0KpVSFMslmPV3MB9Q3TvXFy7Sxha6VZOens5eS7DK+tDQECwWS1hy1nhCJBKhqKgIhYWFGB0dhUajgVKpREdHB8RiMbvax6OnfUpvxd3PdcJDgP882IByhRS1eRmozVuMXKjWm44uoukFFetQlV48nGcT7enOHYdlMBiwYcMG6PX6ZeOwov27Lj3svk0IOc0wTAaAUwzDvLn07Z+RGGeuseeJx0F8EWmrKn2y03xco9FAVroJw/MEzRkEfB6DPU2FuGxTHiQCHni84MfnqtR8RTDhEp1uh83NzaG1tRWnT59GV1cXWwH3zYmpaCY9PR1NTU0rEsYRQtDX17fMkdZisWBubo4V6igUCuTm5iIrKyuq63zqgwkMqs0AgP9+bxwP76vzuoaxsTEYjUYv+2yuWEcmk6G0tJTd96bz12iIHOkMuWTmxTS3547Dmp2dxa233or5+Xn87Gc/w9VXX40NGzaEdbylhqTTALCkjOsFEHy/NwqsWFML4E10mo+LRCKICjfgsbeG4fEAB7YWY1/zokRUKgr94bvdbnR2drLjkHxvgnCITvebGYZBS0sLAGDHjh0wm83QaDRob28Hj8djV0k+n4+Ojg6UlJRENXkmHqDvm+6BcwkslUrZgh5tGFGpVOjt7UVGRgZycnKgVCrDLlBuLsyAWMgDA6Ch6NP6A23QcblcaGxs9Prbc3N7WtTztXMyGo3sDLlwJ8Ymc0qLL7j99seOHcMtt9wCmUyG48ePh010LhiGqQDQCuAjABcjDjPXKFYF0Wk+XlpaipKSEvylTwOnm0DAYzC7EH4+brVacfbsWTa/8odQRHc4HDhz5gzy8vJYIQ3Nx7k5sd1ux9zcHHp7ezE/P8+GxStx49FiY3FxccgHjW/DiNFohEajYUNpSrxgofQNbUUoV6TBQ4DtFXIAn/rbi8Vi1NfXB1UZ8ng8CASCZb323A42h8PhFSJTaauvWGclic6FyWSCUqnE3//930f1+wzDyAAcAfANQsgCwzBxmblGseKhO7UR5ubjF1YpMKQxw2hz4doW/w0fVMRCP2S6p1tfX88aMwQ6ZyCi0ypxTU0N64oSqOgmFoshEonYmW92ux2zs7Po7++HTCZDbm5uRKtktKDDMWpqaoKacfoD1/qpurqaHdlE53xnZ2cjJyfHbyi9reLTvzGNJuRyOSoqKsI+f7Bee9qvThtxqIiIil3oap8soofSfMRiDMkwjBCLJP8DIeTFpfPFZeYaxYpOUzWbzTCZTODl1+K3n2hweR2DzUWZSBPx8eVLKoL+Pl2ZqSfZ1NRUWKaUgVpONRoNO2iChorBim4TExOYm5vz2pOnjRbcVZIKNQK1qsaC+fl5VuEXbVMPF9yRTTT/pEo4iUTCrvbcwhNV3NFtx1gQTKxDnWcZhmHFOr29vbDZbBCJRDAYDDG3rQZDqOp+tMaQSw+QpwD0EkIep68zcZq5RrEiRKeFK4/Hg6Lyajz4xgR4YHBqYh5P3dIaVoMBtaKie53btm0Lq4DjG7oTQjA+Pg61Wo3W1lYIBIKQclZa8GptbV12Y/mukjabDXNzc16tqrQQFstNqdFoWG/5RKixuPknsHgjz83Nobu7Gy6Xi+0QGxkZCUtxF835Af9iHeqjl5+fD41GA4PBgJmZGdakIlpLqmAIp6ElGqK///77AHAzgE6GYc4svfw9ADcxcZi5RpH00J02k5SWlkIqlYLHAGIBDyabC9npIvAiGKrQ0dGBnJwcbNq0KaJ0gRKdOzettbWVPW6gYzmdTnR2dkKhUIQ1vRVYtL/m7slS55S+vr6oCmEAMDU1xdpOJTo1oKC6cdoTPj09ja6uLgiFQqjVahBCQk5uiQX+Vntatc/KykJeXh4YhmF99LgGlDk5OTGLdcIZ3hBN6L5z504QQvxdWNR75v6Q1BWdjhWmzSSjo6MQMh788OpN6JleQHOJHPwQW2fAYi6t1+tRW1uL8vLyiK7Bd+RyTk4OW7gLRnKLxYLOzs6YVi/aqkpD/IWFBczNzbEhPv1eoBWa9s6bzWa0trau2HAHm83GpkqZmZns+6BTWbmpSqJabunfgj5IuVbZaWlpbPqh1+tZu+lwR0n5w1ruXAOSRHQaHs/OzrJjhYFPq+7lSinKleHlr1QEQyuwkYLH48FisWBkZATV1dVeE0UC3ZQGgwG9vb1xy4UB74knNMTXaDTo6+uDw+FYttdNow+hULhi+/TAp38LrqyW+z7obsTQ0BCsVivkcjlyc3ORnZ0dt/yZ/i0kEgmqq6vBMIxXiE//Az4dF8UwDLtATE5OsqlJqB0GilANLat5eAOQBKK73W50d3eDz+d7iTiAT/PscMBtbtm6dSuGhoaimr9msVigVqvZwl0owcX09DQmJyfR2toa90kpXEgkEpSWlrJNFlqtlt3rlslkMJlMKCgoQGVlZcKuIRQogYP9LcRiMYqLi1lBCW0NpUYQVHAUrTSYNhZlZGT4/Vv4C/Ep8dPT01kfPdq2SsdEU4Vbdna2X2luqBzdYrGw9YzViITm6HRfu7i42KsHmoJaPocCLd4JhULWbCKafvbx8XHMzc2hpKQkZA85DQ1NJhPa2tqSOvGU27xis9lw+vRppKenQ61WQ6/Xs6FxMlsiZ2ZmMDExscyOOhD6Z00YVJvxdxuU2LgUNVGFXldXF9xuN5RKJXJycsL2ofd4POzwznBSNn8FPVrU47atMgyDhYUFlvgCgWCZj16icvRkIWF3r06nQ29vb9B97XDIarPZcObMmWUPi0g067RS7nK5UFtbi5GREdZ7zN/KRKMQOnhhpcJkk8nEtphyhzZQoY7T6WTJEq2cNRxMTk6yUVA4D7wJnRVf/sNZuNwEf+6cwa++0OxlBFFeXs4OlpycnITRaERmZiZbmPR3DjoMg/b1R4NwxDrl5eWsWGd4eJidH0d9BwKBDphcrUgI0QkhUKlUIc0dQhGdDiX097AId0WnwxGVSiXKyspACIFMJmO3itxuN7tCymQy1p21sLAwoLouGdDr9WybKzf3S0tLY0N8l8vlFeJnZmayFlTxiEBoukR16+Hm2HMmOzyEgIBApfcfsQmFQi/3moWFBWg0GoyPj3uttunp6XC5XDh79mxc9uopIhHrLCwsYHJyEmazGUaj0a+PXrQOsFwwDHMVgCcA8AH8mhDySEwH5CBhoXtTU1NINVEwsqpUKjZU9BeihjN/jVpBV1VVsT5i1J2Var+dTifm5ubYG9rpdKKiomLFNOvAok3V+Pg4Wlpagj4oBQKBX6snqhWnVfxoagtc3Xqkxb+W0ixc31qI9skF/MPfha4pcAuTAFjtweDgIKxWK5xOJ2u1lSgEE+tkZmayElyFQsE+hOnQS6fTGdOARQBgGIYP4BcArgAwBeAkwzCvEkJ64vH+mBBkjHoyhNPpDBlam0wm1kudPSEh6O/vh81mQ0NDQ8CVaXJyEoQQlJWV+f0+3cpraGgIqXQDwN5YpaWlMBqNMBgMrJQ1JycnaTn6+Pg4tFotmpqaYjontaCam5uDy+Viq/jh5MNc3XpNTU3InyeE4N1BLawuDy7flANBnKrrTqcT7e3tUCgUrJ+7VCplV/tkDZZcWFhAV1cX6uvrvR6a9OH6y1/+Er///e/R3NyMAwcO4Atf+EKkD1eGYZgLATxECLly6YXvLp3jJ/F4Dyva1CIQCLxWZafTyRpJbty4MegNFmz+Gh2O2NraCqFQGLToBiw+NGZnZ7Flyxa20ESlrGq1GuPj4zGvkKFAV1Cn0+nXQDJScC2oaIhP82Hq3a5UKpcVmNxuN1vwCle3/lq3Gv/y2gBAgJE5C762K7zfCwbaXFRZWcnacFHZ9NzcHDo7O9kxVLm5uQmbv242m9Hd3c16Gvjz0bv//vvx/vvv43vf+x5OnjwZrb6hGMAk5+spADvi8iawSrrXgE8bSqqrq1mP8WDwV4zzeDzo7++Hw+Fge6FDyVlpeOrb0sqVstbU1LArpL+8PtYbjBb/pFJpVKOZQsE3xDcYDKwbjVgsZqMWPp+Ps2fPorCwMKJc+Ny8DS73Uk5uiGwYpT9Qr/yamhqvARcMZ2oLnchKm6JoQS+eNQrqOtzY2OhlXAJ4V/I/+OADjIyMoK6uDrt27Yr5vIlAwogezs1KBy1SR5mmpqawK5e++T2NBuRyOWpra0OKYOjcs6ysrJDRA+C9QnLzerPZjOzsbOTl5YXld+4Let0FBQVJKf4xDOPlMmuxWKDRaNDZ2Qmj0cjKRSOxRTqwpQj9syZYHG7cfWls+/x0l2Xjxo1BuxCBxYIed3Y87XCjNQoa4kfTTERJ7lsM9cXp06fxne98Bx9++GHUBqBLUAHgbieULL0WFyQsR3e5XCGLZYQQvPPOO5DJZGhubo6oCUGr1UKtVqOurg4Wi8UrzAtFcqvVio6ODpSXl8c8w5qKQtRqdcR5Pb2OqqqqWG+SmED1DlVVVfB4PNBoNDCZTAEHSdicbrzZp0FZdhqaSwIPJYwUtOV206ZNUakeuaAFPY1Gs2zuXaiHMfVHCGXseebMGdx111148cUXUV1dHcvlMgzDCAAMYHEyiwrASQBfIIR0x3Jg9gQrRXQarmo0GnzmM5+JeCU0GAxQqVQoLCxEb29v2EU32tpZX1/PVnnjBW6L6tzcXNC8nhoNJuI6IoHJZEJnZ+cyeS8dJKHRaKDT6dgQPzc3F9/98yD+NqwDAwZP3dyMhqLYZcF0BY2nzJiCquBop1t6ejq72vsuLvRhs3nz5qAk7+rqwp133onDhw9H5SbjAwYAGIb5PICfY3F77TeEkIdjPTB7gpUgOh0oUFhYiKmpKVx00UURH5/6lTMMg8bGRohEopBFt5mZGYyPj6OpqSkpqjKa12s0GlYJlpeXB7vdzppWJsKhNVwYDAb09fWhsbEx5NYQLYLNzc3h+++aMG3xQMzn45/3bMRVm0PXVIKBPmy4uXCiQAt69GEMgBUdCQQCdHR0oL6+PujDpre3F7fddhueffZZ1NfXx+OyEq7IShjR3W43XC7Xstfp9Ja6ujooFAp88MEHEROdEIKuri7Mzc3h4osvDll0o8KP+fl5NDY2JlXOSkHzejqjvLCwEPn5+XFt9ogEVLceaq/eH06P6/Cvx/tRkEZwUy2Qo8hmG1cirTjTyCZe3vORgn4us7Oz0Gq1UCqVKCoq8rsjAQADAwO45ZZb8Ic//AGNjY3xuoyEEz2pd/y5c+cwPj6+zGs8ksIPVUlJpVLWo42aRfgD3RMWCARobm5eMX8xgUAAq9XKmlYuLCxArVZjYGAg6fv1MzMzmJycDFu37ou2cgVevOtCAPDrRBNu48r8/Dx6e3vR3Ny8YpGNUChEdnY2xsfHsWXLFhBClhX0aF/B6OgobrnlFjzzzDPxJHlSkJQVne4RWyyWZSvqhx9+GLY7DC2SlJeXIycnB8PDw9BqtUhPT/drw0zlrHl5eQGFNckA1dozDLPMJCOSvD4eoLr15ubmuD9UaOMKfS+EEHaf23cbkqrLmpubV3ReGa3y+ysA0r6C4eFh3HvvvXC5XHjggQdw++23x9tgY+2G7h6PB06nk/UUo/vRvivvyZMnw6q4cyeg0rne1IDAZDJBrVZ7EUUmk6G/vz8q08R4ggpQqHFiqMglUF4f6349V7fua8WcKNBx0BqNht2GpFLkkZERNDc3J7T1NxSCkZwLlUqFgwcP4tChQxgdHUVRURH+6Z/+KZ6XsraJbjAY2G2bQNtY7e3t2LhxY9DQTaVSYXJyMqyim9VqxdjYGKanpyGVSlFQUMDOI0s27HY76/cejU6b5o9cokRj4kAjKrfbjbq6uhXpxqPbkBMTE9DpdFAoFMjPz/db+U4G7HY7e+8F26+fmZnBDTfcgJ/97Ge49NJLE3U5azdHNxqNOHPmDBobG4NWMIM1tnBDfjpbPVRlXavVwmQysUU6Ksax2+1svhVu/3MsoJNUa2trvdRdkUAoFHrNTaf79ZHk9VzdeiJUd+GCNiE5nU5ccsklcDgc0Gg0OHv2LIDlAyITiXBJrlarceONN+Lf/u3fEknypCChKzod9hcM3d3dKC4uXhY6uVwudHR0QCaTsUKOYIMbCSEYHByEzWbD5s2bl+X8VO+tVqthMpliUrOFArVbiuckVS7Czeuj0a0nCtPT05iamkJLS8uy/JYOiNRoNKyffLztp7jnam9vR21tbVBHmLm5OVx//fX4l3/5F1x11VVxvQY/WLuhOyEEDocj5M/19fWxww4oqFNsWVkZq88OtpLTAQIymYz1EAsGXzVbRkYG8vLyAm6pRAK1Wo3R0dGk5p/+8vrs7GwMDw+jqKgobj3c0eLcuXOYnp4OqwBIPxuNRgO9Xh9U3BIpKMl9NfS+0Ov1uO666/Dggw9iz549MZ0zTJz/RB8cHGTtegFvswmu5joQeW02W0xzz6jpgVqthlarhUQiQV5eXlQ3Fq1oNzU1Jc2G2RdOpxMzMzMYHh72cpZN5n6920Pw9sCiGKUmzQqddg7Nzc0RP0RpoZUKdQCw6UqkIX64JJ+fn8f111+P++67D9ddd11E1xsD1i7RAQRsI+ViZGQEaWlpKCwsZPfZGxsbIRaLQ+bjVGyxadOmkA0Q4cJsNkOtVkOj0YRlwQx8Oi6Zpg0rOQuM6tY3bNgAuVzutToma1TUc6dUePLdMbhcblxbK8I3926Py9+E5vVzc3OwWq1siB8q/aItr9SAJBCMRiNuuOEG3H333Th48GDM1xsBzn+iUy9wm80Go9HIEiUUydVqNUZGRhIqI6UWzGq1mm1NzcvL81pN6ORViUQSlklDIkFlwf704sncr//FX0fxh48mQDwEN19Yjq/F2NHmD/706/60FNS8IhTJzWYzDhw4gNtvvx0333xz3K83BNY20R0OR0g7qYmJCUxOTiInJwfV1dUhQ3XqEa/T6dDY2Ji0EJludanValitVnZc0djY2IoLcoDIdOtAYvfrz/QM4OnTOiiys/GNy6ohT0vsZ0RDfPoQo0MksrOz0d/f72Ve4Q9WqxUHDx7ETTfdhDvuuCOh1xoA5zfRbTYbPv74Y2RkZKCxsTEkyT0eD3p7e1mF2UqFyG63GzMzMxgcHASfz2dJolAoVky3Ti25olmdY92vt7vceGdAi4JMMdIss3C5XCu2Xw+AnWw7PDzMGj0GalG12Wz4whe+gP379+MrX/nKSl3z+Ut02txSWFiIhYUFbNy4kbV98geqsMvJyUFZWdmKhsjUhnnTpk3IzMzE/Pw81Go1dDod0tPT2RsrGbp1um0VaT9/IPhWvcPJ6x862oe3+ufgcbvx3Z3ZuPrCxhX9fFwuF9rb21FeXg6lUgmdTgeNRoP5+Xn2/VDS33zzzbjiiivwD//wDyt5zWtXMAMsupn4I/r09DTGxsbQ0tICPp/PVkRFIhHy8/ORm5vrdVPRHuGqqqq4T+2MFDqdDgMDA14hMnVs4cpxqc8ctQ1OhJHh5OQkNBoNOwU2HuDxeKydMTevD+abN6G3wuF0gc9jIMkuWBUkLysrY+8V7rw7+n6++c1vsvWMz33ucyt6zclAQld0XydYOv1kfn4eDQ0Ny4puvhXvvLw8iMViDA8PJ8SQIFLQ8UzNzc1hEZc2eGg0GhBCkJubi7y8vJiLh1QrbjKZkqZbB/zn9Tk5OXi3YxjP9tlRV6zEd66sgSiMsdeJgMvlYif1BvMddLlcuPPOO1FZWYmqqiq8/vrr+OMf/xhVc43b7cbWrVtRXFyMo0ePYnR0FIcOHYJWq8WWLVvw+9//HiKRCHa7HbfccgtOnToFpVKJ5557jitiWtuhO5foVNRCq9Ph2D0NDQ1Bo9EgPT0dBQUFyMvLW5FOJ1oA1Ov1Ufez060htVoNh8PB5vWRupdSO2yPx7NiebDJ7sInYzrkCWyYU42BEMJGYivVX09JXlJSEtQezO1246677kJ1dTUeeuihmP9+jz/+OD755BMsLCzg6NGjOHDgAK677jocOnQIX/3qV9Hc3Iy77roL/+f//B90dHTgl7/8JZ599lm89NJLeO655+hh1jbRqcsMd6wSHWcbztwzs9mMhoYG1kBSrVbD5XKxK2MyGlW4xIpXATBaOe5q2MrzEIJDvz6Fc/M2iBg3fnltOWoqylZkv57C7XbjzJkzKCoqCto85Ha7cc899yA/Px8/+clPYv77TU1N4dZbb8X3v/99PP744/jzn/+M3NxczMzMQCAQ4MSJE3jooYfwP//zP7jyyivx0EMP4cILL4TL5UJBQQE0Gg29hrWdowOfFt02bdqErKyskCSnXnJpaWnshBA+n4+SkhKUlJTA6XRCo9Gwuna6t50IX2863JHq7eN1fK79Mi1+zc7Oor+/P6Acd7Xo1p1uD8b1VjBuF1w8HmTKgoB5fbhz32NBuCT3eDz49re/jezsbPz4xz+Oy2f5jW98A48++iiMRiOAxYYquVzORnwlJSVQqRaNXFUqFTszTiAQICsrC1qtNmkt1Akl+uzsLAYGBtDS0gKRSBRyRDFt6wymzxYKhSgqKkJRURG7MtLRtzQcjsfAQYfDgbNnzyZcK+5LEmrISBWDtELc09PDvu+VBB8E+6r4eHuKwdVNhSjM9K5VcP3wq6ur2by+p6eHzevjNXCBDl4MNa7J4/HggQcegEgkwmOPPRaXqOzo0aPIy8vDli1b8M4778R8vEQjoUSXSCRoa2tjJ1EG+2CNRiO6u7uxYcOGsOdMc1dGt9sNnU7HDhyUy+XIz8+PqjuNVvmTbVrBMAzkcjnkcjlqampgNpsxPT2Nvr4+pKWlweVywWazrZhZAx1YefvOKnwvTJtsXz987oM5li41SvL8/PygDz+Px4Mf/vCHcDgc+OUvfxm3+sH777+PV199FcePH4fNZsPCwgLuvfdeGAwGuFwuCAQCTE1NsYtEcXExJicnUVJSApfLhfn5+ajbl6NBQnP0Z555BlVVVew2WiBoNBoMDw+HreoKBd/utMzMTDYcDvVBUzvo1VDlpw+cDRs2QCqVeslxaTicjP5t4FO9eEVFRVy2OP11qdHPKFRezyV5sGiLEIJ//dd/xfT0NJ566qmYOxMD4Z133sFjjz2Go0eP4sYbb8T111/PFuOamprwta99Db/4xS/Q2dnJFuNefPFFPP/88/QQa7sY99JLL+GPf/wj+vv7sXv3buzbtw/btm1jyUYIYfeCqXtMvEHDYdqdlp6ejvz8fL9zuGnInCw76GAIplundQqNRgOr1cqGw4makU51DtXV1QmJcLj6A61WGzSv93g87Jz0YJNtCCF49NFHMTQ0hGeeeSah4iUu0UdGRnDo0CHodDq0trbi//2//wexWAybzYabb76ZHRr57LPPoqqqih5ibROdwmq14vXXX8fhw4dx9uxZXHrppbj66qtx9OhRHDp0aNncs0SBOzhxbm6ObUnNzc3F7OwsZmZm0NzcvGItphSR6Nbdbjfry7awsAC5XM5OV4nH35R68IcyaognqCmjRqOB0+n0cp+h6kha2PIHQgieeOIJtLe3449//OOKf55h4PwgOhd2ux0vv/wy7rvvPuTl5aG1tRXXXXcdLr744qR/IGazGbOzs5iamgIhBJWVlcjPz0/aOF5/iEW3zrVe1ul0kMlkbDgczYpGW17DmYOWKNC8nj6cMzIyUFVVFTCvJ4TgySefxN/+9jc8//zzK+JHFwXOP6IDwA9+8AM0Nzdjz549ePvtt3HkyBG8//772L59O/bv349LL700KR8QbZIRCAQoLS1lc2CGYdiVPpkhfDx169zoRavVQiQSsfqDcI5N6wN1dXUrOjIKWPycOjs7IZfLIZPJvPJ6bmsqIQRPPfUU3njjDRw5cmRFH9gR4vwkuj+4XC689957eOGFF/DXv/4Vra2t2L9/P3bv3p2QKjP1pFMqlSgvL/f6nt1uh1qt9ip8JVqgQ2sVTU1NCcknLRYLKy8GwD7I/MlxEzkHLVJwSc79nHzz+t/97new2+2YnJzEG2+8saI20lFg/RCdC7fbjQ8++ACHDx/GX/7yF9TX12P//v244oor4mIyYbfbcfbsWZSVlYWcpkoLX7Ozs3A4HKxAJx5z0YFPdetUBZiMWoXdbmeLeb7viXbmJWMOWih4PB50dXUhMzMzpEjoF7/4BZ577jnI5XKYTCa89dZbET+YbTYbdu3aBbvdDpfLhRtuuAE/+tGPotWvR4L1SXQuPB4PTp48iRdeeAFvvvkmampqsHfvXlx11VVROazSGzmavNPlcrHmExaLBQqFIiaBzmrQrXPfk9FohNPpxIYNG1BYWLiiHV2U5BkZGaisDO5Q88ILL+A3v/kNjh07xj6sonlI0QGMMpkMTqcTO3fuxBNPPIHHH388Gv16JEgRnQuPx4MzZ87g8OHDeO2111BaWoq9e/fi85//fFjztOkYoFDD7cMBFejMzs7CaDRGbB9NdetpaWlhOdcmGtSiury8HAaDAfPz86z+wHc+eqJBh2jKZLKQJH/55Zfx5JNP4ujRo3GtJVgsFuzcuRNPPvkkrr766mj065Fg7Wvd4wkej4e2tja0tbXh4YcfRldXFw4fPoy9e/ciJycH+/fvx9VXX+1XcTQ7O4vx8fGopof6A3ev11evnpmZifz8/IBbXFS3rlAoltUHVgL0Adja2gqJRIKioiIv/cHw8DDS0tJYQ41E7o4QQtDd3Y309PSQJD927Bj+67/+C8eOHYsbyd1uN7Zs2YKhoSF8/etfR3V19arVr0eCNUV0Luhc9MbGRjz00EPo7+/H4cOHccMNNyAzMxN79+7Fnj17kJubi48++ggikQhtbW0JKXT506vPzs5icHCQ3eLKyckBn8+H0+lkNfQrrVsHFhsxhoaG0Nra6lWl5spxaUirVqvR3t7OegXE21iSEIKenh6kpaVxxSR+8cYbb+Cxxx7D8ePH47r1x+fzcebMGRgMBlx77bXo6+uL27FXEmuW6FxQD7kHH3wQ3//+9zE8PIwjR47gpptuwvz8PIqKivDkk08mJfz0JQjd4hodHYVIJILFYkF1dXVUs9jiDY1Gg9HRUbS2tgbdcmMYBjKZjO3io40q3d3dcduVoCQXi8UhSf7222/j4YcfxrFjxxKmF5fL5fjMZz6DEydOrFr9eiRYUzl6JCCE4Itf/CIUCgUqKyvxyiuvwOPxYM+ePdi/fz9KSkqSmhdbLBa0t7dDLpfDbDZDIBAgLy8v7H3teGN2dhYTExN+RyRFAjpOSa1Ww2azsR2Ekcy3I4Sgt7cXQqEwZJ/9e++9h+9973s4duxYyB2TSKHRaCAUCiGXy2G1WvHZz34W999/P5555plo9OuRIFWMiwVdXV1oaGgAsHgzTU9P48iRI3jppZdgtVpx9dVXY9++fXHtNfcHf7p17r42Fejk5eUlZf93enoaKpUKLS0tcU1lqByXVvDlcjny8vKCdqcRQtDX1weBQBCS5CdOnMB9992Ho0ePJqR1uKOjA7feeivcbjc8Hg8OHDiAH/zgB9Hq1yNBiuiJglqtxksvvYQXX3wROp0On//857F///64Txyl1eympqaAoS13UITH44mbt5w/qFQqVtOfyEYPKsdVq9Ws64yvHJeSnM/no7a2Nujf/ZNPPsE999yDV199dcU99BOAFNGTAa1Wi1deeQVHjhzBzMwMrrzySlx77bWoq6uLScBCu+Ei0a37esvFU6AzOTmJubk5NDU1JX27jNtMJBaLkZubi/n5eQgEgpAP1zNnzuCuu+7CSy+9FO2KudqRInqyYTAY8Oc//xkvvvgiRkdHccUVV2D//v1obm6OiPTx0K37CnSiyX8pxsbGYDAY0NTUtKKz4YBFiW1PTw+sViukUikbwfjrK+jq6sKdd96Jw4cPY8OGDStwtUlBiugrCaPRiGPHjuHIkSPo7+/HZZddhn379mHr1q1ByTIxMcGunPEKj33zXyrQyc7ODkl6ag2dLIltMNA59h6PBxs3bvSKYLgtqTKZDP39/bjtttvw7LPPor6+fkWvO8FIEX21gNtT39HRgUsvvRT79u3DBRdcwIbBydKtcwU68/Pz7NhpX4EOddOlU15XWn1Hp866XC5s2rRp2fXQCObMmTO477774Ha78aMf/Qg333xzUlONFcDaJfrrr7+Oe++9F263G3feeSceeOCBaA+16mCz2fDmm2/i8OHDOHXqFC666CLs3bsXx44dw8GDB7Ft27akkYoQwha9dDod6yKrUCgwPDwMt9u9onPQuNc5NDQEp9MZ8npGR0fxxS9+Ebfffju6urqgUCjwyCOPRHzOyclJ3HLLLZidnQXDMPjyl7+Me++9FzqdDgcPHsTY2BgqKirw/PPPs5N27r33Xhw/fhxSqRS//e1v0dbWFsvbDhdrk+hutxsbNmzAm2++iZKSEmzbtg1/+tOfzsvwy+Fw4M0338Q3vvENSKVStLW14dprr8WuXbuSvj9OCMHCwgLUajVUKhUEAgGqq6uRm5ublDlwwa5reHgYdrsd9fX1QUk+MTGBgwcP4te//jW2bdsW03mnp6cxPT2NtrY2GI1GbNmyBS+//DJ++9vfQqFQ4IEHHsAjjzwCvV6Pn/70pzh+/Dj+8z//E8ePH8dHH32Ee++9Fx999FFM1xAmEk70hMSWH3/8MWpqalBVVQWRSIRDhw7hlVdeScSpVhwikYjVRZ86dQo333wzXnvtNezcuRNf+cpX8Nprr8FmsyXlWqjVssPhQFFREZqbm2GxWHDq1Cm0t7dDpVLB4XAk5Vq4GBkZCYvkKpUKN910E5588smYSQ4AhYWF7IqckZGBuro6qFQqvPLKK7j11lsBALfeeitefvllAMArr7yCW265BQzD4IILLoDBYMD09HTM17EakJDHPFfsDyw2AiTpybgiuOeee9gbePfu3di9ezfcbjfef/99HDlyBA899BA2b96M/fv34/LLL0/I/jjwaUecVCplRUAZGRmorq5mBTpnz54Fj8dLiFbdH0ZGRmC1WkPWCGZmZnDw4EE88cQTuOiii+J+HWNjY2hvb8eOHTswOzvLSpALCgowOzsLwP99q1KpVoVcOVacF1r3lYa/G5jP52PXrl3YtWsXPB4PPv74Yxw+fBg/+clPUFNTg/379+PKK6+Mm7kDdWLJysrya34glUpRUVGBiooK2Gw2qNVqdHd3J1SgMzo6yhYmg5FcrVbjxhtvxL/9279h165dcb0GYNGD4Prrr8fPf/7zZY45oeYNnC9ICNGp2J+C2wiwHsHj8XDBBRfgggsuYHvqX3jhBTz++OMoKytje+qjbbWkba9KpTIs1ZhEImGHKtDtrf7+fjgcDq8GlVgIMDo6CqPRGJLkc3NzuPHGG/Hwww/jsssui/p8geB0OnH99dfji1/8Iq677joAQH5+Pqanp1FYWIjp6WnWp/58vm8TUoxzuVzYsGED3nrrLRQXF2Pbtm344x//iM2bN0d3lecpqMHCCy+8gOPHjyM3Nxf79u3DNddcE7a1Mh1mkJeXF9TnPBw4nU5WoEP94qMR6IyNjWFhYSHkFqNer8d1112HBx98EHv27Inp2v2BEIJbb70VCoUCP//5z9nX//Ef/xFKpZItxul0Ojz66KNsfzstxt1zzz34+OOP435dfrA2q+4AcPz4cXzjG9+A2+3G7bffju9///vRHmpdgOq+Dx8+zLql7N27F9dccw1yc3P9Eo2OCk5Eb7uvQIfaZsnl8qCkHx8fh8FgCDm3fX5+Htdffz3uu+8+dqWNN/72t7/hkksu8bqWH//4x9ixYwcOHDiAiYkJlJeX4/nnn4dCoQAhBHfffTdef/11SKVSPP3009i6dWtCrs0Ha5foKUQPuh115MgRvPLKKxCLxdizZw/27duHgoICMAzDzkErLS2Ne7umLzweD3Q6HdRqNSvQyc/PX9aVNjExwc6QD0Zyo9GIG264AXfffTcOHjyY0GtfI0gRHVhTwoe4gxCCiYkJtr0WAC677DK88cYb+M1vfpP0Ti7frjQq0LFYLGFp6c1mMw4cOIDbb78dN998cxKvfFUjRXRgTQkfEgpCCDo6OrB3716Ul5fD6XTimmuuwb59+1BZWZn06jEV6AwNDbHuKvn5+cjJyfEr0LFarThw4ACrekuBxdoUzMQbKeHDIhiGwYkTJ/D000/jr3/9K15++WUolUp861vfwmc+8xk8+uij6O/vR4iHd1yvx2g0gsfj4dJLL0VVVRXMZrNfgY7NZsMXv/hF3HjjjbjtttuScn0pfIo1saJzMTY2hl27dqGrqwtlZWUwGAwAFleX7OxsGAwGXHPNNXjggQewc+dOAIuh7k9/+tNkFVZWBFqtFi+//DJefPFFzM7OevXUJ2qln5qaglqtRnNz87KmE2omqVKp8MMf/hAMw+Bzn/scHnzwwXWxbx0hUis6FynhQ2AolUrccccdOHbsGP73f/8XGzduxL/+679i586deOihh3DmzBl4PJ64nU+lUgUkOQDWrnnHjh3Iz89Hfn4+3n77bdx0000xnff2229HXl4eaxEGADqdDldccQVqa2txxRVXQK/XA1h8+N9zzz2oqalBU1MTTp8+HdO51zLWDNGDCR8ArBvhQziQy+W45ZZb8PLLL+Pdd99FW1sbfvazn+Hiiy/Ggw8+iJMnT8ZE+nPnzmF2djYgySlcLhfuvPNObN++HS+++CL+8pe/4Omnn476vADwpS99Ca+//rrXa4888gguu+wyDA4O4rLLLmM73V577TUMDg5icHAQ//3f/4277rorpnOvZawJohNCcMcdd6Curg7f+ta32Nf37t2LZ555BgDwzDPPYN++fezrv/vd70AIwYcffoisrKzzQq8cDTIyMnDo0CG88MILOHHiBC6++GL86le/wkUXXYT7778fH3zwAdxud9jHo4XRUCR3u9246667UF9fj+9+97tstBXrdNpdu3YtExOtt1pNVCCEBPtvVeC9994jAEhjYyNpbm4mzc3N5NixY2Rubo7s3r2b1NTUkMsuu4xotVpCCCEej4d87WtfI1VVVaShoYGcPHlyhd/B6oPVaiWvvvoqueWWW0hDQwP58pe/TF577TUyPz9PzGaz3/+GhobIu+++SxYWFgL+jNlsJgsLC+RLX/oSeeCBB4jH44n7tY+OjpLNmzezX2dlZbH/9ng87NdXX301ee+999jv7d69e7XeC6F4GPN/a6KpZefOnQEryW+99day1xiGwS9+8YtEX9aahkQiwZ49e7Bnzx44HA785S9/wZEjR3Dfffdhx44d2L9/Py655BK2p35mZoa1iA62kns8Hnz7299GdnY2Hn744aTXTdZ7rSYQ1gTRkw23242tW7eiuLgYR48eTcbY3BWFSCTCVVddhauuugoulwvvvvsuXnjhBXz3u99FW1sb8vPzYTQa8eijjwY1sPB4PHjggQcgEonw2GOPJc2fbj02qUSKNZGjJxtPPPEE6urq2K/vv/9+fPOb38TQ0BCys7Px1FNPAQCeeuopZGdnY2hoCN/85jdx//33r9Qlxw0CgQC7d+/Gk08+ibNnz2LDhg149tln8dFHH+ErX/kKXn31VVgslmW/5/F48IMf/AAOhwP/8R//kVQTylStJgyEiO3XHSYnJ8nu3bvJW2+9Ra6++mri8XiIUqkkTqeTEELIBx98QD772c8SQgj57Gc/Sz744ANCCCFOp5MolcqE5KQrBafTSW677TZiMBiI2+0mJ06cIN/61rdIU1MTuf7668nvf/97Mjs7S0wmE7n//vvJrbfeSlwuV0Kv6dChQ6SgoIAIBAJSXFxMfv3rX58PtZqE5+gpovvg+uuvJ5988gl5++23ydVXX000Gg2prq5mvz8xMcEWgjZv3kwmJyfZ71VVVRGNRpP0a0423G43+eSTT8j9999PWlpaSH19Pdm/f3/CSX4eI1WMSyaOHj2KvLw8bNmyBe+8885KX86qBY/Hw5YtW7Blyxb8+Mc/xtGjR7F79+7z3ZJ5TSNFdA7ef/99vPrqqzh+/DhsNhsWFhZw7733nhdjcxMFHo+HvXv3rvRlpBACqWIcBz/5yU8wNTWFsbExPPvss9i9ezf+8Ic/4DOf+QwOHz4MYHmxhxaBDh8+jN27d6e2dlJYlUgRPQz89Kc/xeOPP46amhpotVrccccdAIA77rgDWq0WNTU1ePzxx6MaMpBCCsnAmuteS2F94Hye9OMHqe618xkGgwE33HADNm3ahLq6Opw4cSLViYVFwdLXv/51vPbaa+jp6cGf/vQn9PT0rPRlrWmkiL6CuPfee3HVVVehr68PZ8+eRV1dXaoTC+tr0k+ykCL6CmF+fh7vvvsum++LRCLI5fJUJxYCT0xJIXqkiL5CGB0dRW5uLm677Ta0trbizjvvhNlsjnhcUAophIMU0VcILpcLp0+fxl133YX29nakp6cvq9qv106sVDNK/JEi+gqhpKQEJSUl2LFjBwDghhtuwOnTp1OuOQC2bduGwcFBjI6OwuFw4Nlnn02JcmJEiugrhIKCApSWlqK/vx/AYl99fX19qhMLix10//Vf/4Urr7wSdXV1OHDgQGqcV4xI7aOvIM6cOYM777wTDocDVVVVePrpp+HxeFbbuKAUEo/UAIcUUlgHSDjRQzW1rL9K0HkKhmG+CeBOLD68OwHcBqAQwLMAlABOAbiZEOJgGEYM4HcAtgDQAjhICBlbietOIT5I5ejrAAzDFAO4B8BWQkgDAD6AQwB+CuBnhJAaAHoAdyz9yh0A9Euv/2zp51JYw0gRff1AACCNYRgBACmAaQC7ARxe+v4zAPYv/Xvf0tdY+v5lzHrc5zuPkCL6OgAhRAXgMQATWCT4PBZDdQMhxLX0Y1MA6H5dMYDJpd91Lf38+mq0P8+QIvo6AMMw2VhcpSsBFAFIB3DVil5UCklFiujrA5cDGCWEaAghTgAvArgYgHwplAeAEgBUU6sCUAoAS9/PwmJRLoU1ihTR1wcmAFzAMIx0Kde+DEAPgLcB3LD0M7cCoC1iry59jaXv/4WE2IdNYXUj1D56CucJGIb5EYCDAFwA2rG41VaMxe01xdJr/x8hxM4wjATA7wG0AtABOEQIGVmRC08hLkgRPYUU1gFSoXsKKawDpIieQgrrACmip5DCOkCK6CmksA6QInoKKawDpIieQgrrACmip5DCOkCK6CmksA7w/wPWhJu78Lh/JAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Get the grid points\n", + "xs = fi.floris.grid.x\n", + "ys = fi.floris.grid.y\n", + "zs = fi.floris.grid.z\n", + "\n", + "# Consider the shape\n", + "print('xs has shape: ',xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", + "\n", + "# Lets plot just one wd/ws conditions\n", + "xs = xs[0,0,:,:,:]\n", + "ys = ys[0,0,:,:,:]\n", + "zs = zs[0,0,:,:,:]\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(xs, ys, zs, marker=\".\")\n", + "ax.set_zlim([0, 150])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8dd8ce19", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD4CAYAAADsBlOYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkaklEQVR4nO2deZgU1dWH3zOMgCiyL4PADCLqJyhrjBgTRUQREU1wQcdENIq7JuqnInGNuES+KCYiQXFlElRcwAUFETQuoIwLiusoq7KICDwsCjNzvz9OtTTjwAzdVV1dXed9nnq661Z3nXO7un519yPOOQzDiC95YTtgGEa4mAgYRswxETCMmGMiYBgxx0TAMGJOftgOADRv3twVFRWl9N0NGzaw2267+etQBGyHbT+utsO2n47t0tLSVc65Fj874JwLfevZs6dLlZkzZ6b83XQJ03bY9uNqO2z76dgG5rpq7j+rDhhGzDERMIyYYyJgGDHHRMAwYo6JgGHEHBMBw4g5JgKGEXOyYrCQkaX88AMsWwZr10J5uW5btujrhg3w+uuQnw+77KKvTZtC69a6b0QGE4G48v33MH8+fPON3uhVX5ct0xu9dWto3HjrjZ7YTjsNbrttqyhs2QLffQfffqufLyjQrU2bbV/btoXOnSHEEX/GtpgIxIHvv4fS0m23lSv1ZmzbdusNuv/+2968TZuCSPXnnDVLSwJVqahQIUgISUJU5s+H6dNh8WL49FPo0AF69oRevfS1WzcThpAwEcg1ysvhrbfgzTe3veG7d9ebbdAguPFG2GcfqFPHf/t16mjpoXVrtVkdmzerKJSWwty58Oijup8Qhp494de/1u9vT4QM3zARyAXWrYOXXoIpU2DqVGjXDg4/PPgbPlXq1tUbvHt3OPtsTasqDP/8p7ZJHHec5qNPH6hXL1y/cxQTgaiyeLEWu48+Wp/6hx6qN8stt6gIRI2qwuAcfPaZCtvNN8Mpp0C/fprHNm3C9jansC7CKLF4sT7ZE0X7DRtg2DCtd0+dCuefH00BqA4R2G8/uPJKbXsoK4OBA2HyZPjoI60u3HknrF4dtqeRx0Qg26mshGnT4IQT9OZftQr+8Q9YvhyKimDwYGjYMGwvg6dFCxg6FJ58Erp2hWuugXffhY4d4cwz4Z13wvYwslh1IFtZvRoeegjuvVdbzS+8EEpKrAUdtJRwzDG6ffstPPggnHwyNG8OF1wAQ4bArruG7WVksJJAtjF3Lpx1lj7h3nsPHnlEX885xwSgOlq00CpDWRnccANMmqRVossv1zSjRkwEsoUZM6B3bzjxRNh3X/j8c+06693buslqQ506cOyx8Pzz8PbbOqDpkEO0d+GDD8L2LqsxEQib0lI46ig491y49FL48ku46ip9whmpsddecPvt2pDar5/2oJx+OixYELZnWYmJQFh88YV2ex13HPz2t/DJJ1qXzab+/KhTvz5ccon+1p066ejESy6BFSvC9iyrMBHINMuWwXnnaTG/a1f9g55/vk26CZKGDeH661VoRXR49PXX6yArw0QgY6xbp91aXbrA7rvrQJhrrrHGvkzSsiWMHq1VsAULtHRw1106+SnGmAhkgmnT4IADdFDP++/DqFHQrFnYXsWXoiLtdXn5ZR1kddBBsW48NBEIknXrdETfOefAffdpv3+ujOjLBQ44AF58UdsJ+vWDm26KZanARCAoEk9/gA8/1B4AI/sQ0RGH774Ls2fHslRQowiIyAMislJEPqrm2OUi4kSkubcvInK3iJSJyDwR6RGE01lN1af/uHGwxx5he2XURNu2OsYghqWC2pQEHgL6V00UkXbAUcDipORjgE7eNgy4N30XI4Q9/aNNTEsFNYqAc+41oLqpWncCVwIuKe144BEv9NlsoLGIFPjiaTZTXq7DVO3pnxsklwqOPFLXNnCu5u9FlJQmEInI8cDXzrkPZNshrXsCS5L2l3ppy1L2MNv5/nsd5OOctvw3aRK2R4YfJEoFhx0Gxx8P8+apGNStG7ZnviOuFgonIkXAc865LiLSAJgJHOWcWysiC4FezrlVIvIccJtz7nXvezOAq5xzc6s55zC0ykCrVq16Tpw4MaUMrF+/nt133z2l76bL+nXr2H3xYl1Ys23bzNsPM+9xsl1ZqeMKysuhY0fW//BDJPPep0+fUudcr58dqC5UcdUNKAI+8t4fAKwEFnpbOdou0Br4F3Bq0vc+AwpqOn8kQ5M//7ybedddzj3wQDj2XXRDZEfSdkWFc3/5i3OFhW7mCy9k3r5HVoQmd8596Jxr6Zwrcs4VoUX+Hs655cAU4A9eL8HBwFrnXG5VBZyDv/1N6/97761FRiP3ycuDv/4V7rhDZ3g+8UTYHvlGbboI/wO8BewrIktF5I87+PgLwFdAGXAfcIEvXmYLmzbB738Pjz8Oc+bYkN84ctJJunDrFVfo/IPKyrA9SpsaGwadc6fWcLwo6b0DLkzfrSzku+9gwACdpvraa9CggS1aEVd23VXXLBg8WFdILimJ9ErINmKwNqxYoUteH344/PvfKgBGvGnVCl55Rd//9rdaSowoJgI18fXXevMPHqxht2yVHyNB3bowcaL2Dg0cqKs/RxATgR2xeLH2E59xhtb/TACMquTn6zJw7dtD//6RXKPARGB7fP21VgEuuACuvjpsb4xspk4dGD9eFys59tjIlQhMBKpjxQro21fX/bvssrC9MaJAXp4uD7/33holKUJtBCYCVVm1SseLn3aaLmVtGLUlLw/uv18bDQcPhh9/DNujWmEikMyGDVqvO+44uPbasL0xokidOrpqUYMGUFwciXEEJgIJnNMwV126wMiR1ghopE5+vnYlL1+usSOzHAtDluDmm2HpUpg50wTASJ+6dTVu4kEH6YPlpJPC9mi7mAgAPP20rgMwZ46uVW8YftCqFTzzjAY/6dQJunUL26NqserAhx/qcmBPPQUFub/+iZFhunfXdQhOOAFWrgzbm2qJtwisWqULRowerdFpDCMITj5ZJ54NHgybN4ftzc+Irwhs2aL1tFNO0e5AwwiSG2/UWBMXXZR1S5XFVwT+9CedCnzzzWF7YsSBvDwdXvzmm3DPPWF7sw3xbBh88kmYPh3eeccCgBqZo2FDmDIFfvlL+PWvNRZlFhC/ksCqVVoke+ghaNQobG+MuLHXXroy1ZlnZk1cg/iJwEUXaRvAIYeE7YkRV4YOhdat4dZbw/YEiFt14Mkn4b334MEHw/bEiDMiGpuie3ftnQq5WhCfkkCiGvDgg7o8lGGESdu2WVMtiI8IWDXAyDaypFoQj+qAVQOMbCRLqgW5XxLIompASUkJRUVF5OXlUVRURElJSaj+pEIiD6WlpZHPQ1ZchyyoFuS+CIwYoaMCQ64GlJSUMGzYMBYtWoRzjkWLFjFs2LBI3UTJeQAin4esuQ5Dh0KLFjBmTCjmaxN85AERWSkiHyWl3SEin4rIPBF5WkQaJx0bLiJlIvKZiBwdkN+147PPdGLQddeF6gbAiBEj2Lhx4zZpGzduZMSIESF5tPNYHgJCRCMb3XJLKAuV1qYk8BDQv0radKCLc+5A4HNgOICI7A8MATp73xkjIuENybv2Wl0jsGnT0FxIsHjx4p1Kz0YsDwFy4IFw1FHw979n3HSNIuCcew1YXSVtmnOu3NudDSRC8h4PTHTO/eicW4CGIzvIR39rz9y58MYbcOmloZivSvv27XcqPRuxPATMTTfBP/6R8SnHOx2avJpjzwKPOecmiMg/gdnOuQnesfHAVOfcpGq+F2xo8s8/1xJA8+YpnTct29WwevVqFi1aRGXSmnN5eXkUFhbSNMWSSqZDdCfnoW3btixdujTtPKRCOvn24zoE+rsvWaKv7dr5btu30ORV0kcAT7NVTP4JnJ50fDxwYk3n9z00+fTpznXq5NzmzSmfN2XbO2DChAmusLDQiYgrLCx0EyZMyKh9P0jkYdSoUb7kIRXSzXe61yHQ333FCueaNnXuq698t812QpOnPE5ARIYCA4G+ngGAr4FkCWvrpWWOykoNFnLzzbDLLhk1XRPFxcUUFxeH7UZaJPIwa9YsFi5cGLY7KZHV16FlS7j4Ym3MfvTRjJhMqYtQRPoDVwKDnHPJTa1TgCEiUk9EOgCdgLfTd3MnmOTVPE48MaNmDcM3Lr9cp7rPm5cRc7XpIvwP8Bawr4gsFZE/osX+hsB0EXlfRMYCOOfmA48DHwMvAhc65yoC874qFRXwl7/oMMy83B8CYeQoDRvC8OE6xiUD1FgdcM6dWk3y+B18fiQwMh2nUmbqVI0Q269fKOYNwzfOPVfjX5SVaWizAMmtx+WYMXDhhWF7YRjpU7++DiUeOzZwU7kjAl9+qcuFnXxy2J4Yhj+cey48/HDgwU1zRwT+9S8dg21rBRi5wl57aQSjxx4L1ExuiMCmTTpL8LzzwvbEMPzlggsCn1iUGyLwxBMaPKRjx7A9MQx/6d8fvv1Wq7oBkRsiMGaMKqZh5Bp16mgJ9957AzMRfRHYuBGWLYMBA8L2xDCC4ayzNGju6tU1fzYFoi8C336rragWRMTIVVq0gIED4ZFHAjl9tEWgogLWrIFTqxvPZBg5xKmn6gI5ARBtEZgzRycJdegQtieGESxHHAEffADl5TV/dieJtghMmaLDhA0j16lfH/r2hbVrfT91tEXg2WdNBIz4MGiQicA2lJVpa2mDBmF7YhiZYcAAXYj0xx99PW10ReDZZ7XF1DDiQsuWOix+1ixfTxtdEZgyRYtHhhEnGjXS/76PRFMEVq+G0lJtKDGMONG4sYpALRYIri3RFIGpU6FPH2sPMOJH/fq6vf++b6eMpgj897/ab2oYcaRvX70HfCKaIlBaqrMGDSOO9Oyp94BPRE8ENm+G+fOhW7ewPTGMcIi9CMyfr8OEd9stbE8MIxy6dIGvvoING3w5XfREoLRUldAw4krdurD//jqXwAdSDU3eVESmi8gX3msTL11E5G4vNPk8Eenhi5fJWHuAYeg94FOVINXQ5FcDM5xznYAZ3j7AMWjUoU5osFH/l0OZO9dKAobRs6feCz6QUmhyNAT5w977h4ETktIf8eIfzgYai0iBL56CNQoaRgIfGwdTCk0uImucc4299wJ875xrLCLPAbc55173js0ArnLO/UyyUgpNvmmTNoh07vxTUqbDcycTpu2w7cfVdtj2f7LtnA4Y6tq11iH3fA1NDqypcvx77/U54NCk9BlAr5rOX+vQ5A895Nxpp22TFEZ47mywHbb9uNoO2/42trt3d27OnFp/l+2EJk+1d2BFopjvva700oMNTb50KbRv79vpDCPStGsHX6d/e6UqAlOAM7z3ZwCTk9L/4PUSHAysdc4tS9PHrSxbBm3a+HY6w4g0bdroPZEmqYYmvw3oJyJfAEd6+wAvAF8BZcB9gL/BAL75Bgr8a2c0jEhTUKD3RJqkGpoc4GfzeL16R3BhgZctMxEwjAQFBTB7dtqnidaIwW++seqAYSRo08aXkkB0RMA5WL7cSgKGkaCgIDNtAlnD6tU6aah+/bA9MYzsIFMNg1mDNQoaxra0aKEPxy1b0jpNdETAGgUNY1vq1FEhWLEirdNERwRWr4ZmzcL2wjCyi2bN0o5WHB0RKC/XuIOGYWxll13Sjk8YHRHYsgXyaxzWkNWUlJRQVFREXl4eRUVFlJSUhO3STpPIQ2lpaeTzEOXr8BP5+Wm3CUTnrop4SaCkpIRhw4axceNGABYtWsSwYcMAKC4uDtO1WmN5yEJiVRIoL490SWDEiBE//fESbNy4kREjRoTk0c5jechC8vNjJAI+RlwJg8WLF+9UejZiechCRKCyMq1TREcEfFC8MGm/nSnQ20vPRiwPWciWLWlXk6MjAj7UfcJk5MiRNKgSNq1BgwaMHDkyJI92HstDFuJDW1l0RCDiJYHi4mLGjRtHYWEhIkJhYSHjxo2LVGNUch6AyOchqtdhG3xoK4tOS5sPXSFhU1xcHN0/m0ciD7NmzWLhwoVhu5MSuXAdfsKHrvPolAQaNYI1a8L2wjCyizVr9N5Ig+iIgE/TJg0jZ3BO5w20bp3WaaIjAj5NmzSMnOG772D33dOeXh8dEWjRQos+mzeH7YlhZAc+Ta+Pjgjk5fkybdIwcgafptdHRwTAtzXVDCMn8GnNzWiJgDUOGsZWYlsSMBEwDMWnYDxpiYCI/FlE5ovIRyLyHxGpLyIdRGSOiJSJyGMiUjdtLxP4FGzBMHKCsBsGRWRP4BI04GgXoA4wBLgduNM5tzfwPfDHtL1M0KaNxiM0DEPjEIZdEkCHHe8qIvlAA2AZcAQwyTv+MHBCmja20qULzJvn2+kMI7JUVMD8+dC5c9qnEpfGPH0RuRQYCWwCpgGXArO9UgAi0g6Y6pUUqn53GDAMoFWrVj0nTpxYs8HKSvjgA+jWTedRkyWx4kMirnm33313+OEHKCvTB2Mt6dOnT6lzrtfPDlQXr7w2G9AEeAVoAewCPAOcDpQlfaYd8FFN5+rZs2ftA7R36eLc3Lk/7WZNrPiY2Y+r7bDt/2T7kUecO/nknfouMNdVc/+lUx04EljgnPvWObcFeAr4FdDYqx4AtAXSD6CeTM+eUFrq6ykNI3KUluq94APpiMBi4GARaSAigkYp/hiYCZzofeYMYHJ6LlbBRMAwskMEnHNz0AbAd4EPvXONA64CLhORMqAZMN4HP7fSqxfMnevrKQ0jUlRUwPvvQ48evpwurdUInHPXA9dXSf4KOCid8+6Qrl3hk0/gxx+hXr3AzBhG1vLZZ9CqFTRp4svpojViEKBBA+jYET76KGxPDCMcfKwKQBRFAKxdwIg3JgLAIYfArFlhe2EY4fDqq9C7t2+ni6YIHHssvPhi5BceNYydZvNmWLLERIA999R2gddfD9sTw8gsa9fqQ9DHkHzRFAGA446DZ58N2wvDyCxr1uh/30eiKwKDBsGUKWF7YRiZY906WL8ejj7a19NGVwS6dtX60Q8/hO2JYWSGadN0deGGDX09bXRFQERLAxaQxIgLU6ZA48a+nza6IgAqAmvXhu2FYQRPeTm88IKJwM847DDYtAlWrgzbE8MIlrfegvbt045AXB3RFoF69WCPPWDSpJo/axhR5vHH4fjjAzl1tEUANCDJ2LEal80wcpH166GkBM46K5DTR18EGjbUXoI33gjbE8MIhn//W6u+7doFcvroiwDA+efDmDFhe2EY/uMc3HMPXHBBYCZyQwTOOAOmTrU4hUbu8dZb2vjdt29gJnJDBBo3hhNPhPH+LmJkGKEzZoyWdPOCu1VzQwRAf6ixY3XpJcPIBVauhOefh6FDAzWTOyLQo4fOLnz++bA9MQx/eOAB+N3vfFtGbHvkjgiANp5YA6GRC1RUaMk2wAbBBLklAiedpBGK3nsvbE8MIz0ef1zjDPq4jNj2yC0RqF8fRoyAa64J2xPDSJ3Nm+Haa+HmmzNiLt3Q5I1FZJKIfCoin4hIbxFpKiLTReQL7zXYCk1Vhg2Dzz+3NQiN6HL//bpy1hFHZMRcuiWB0cCLzrn9gK7AJ8DVwAznXCdghrefOerWhb/+Fa66yoYSG9Fj/Xr9/956a8ZMpiwCItII+A1ehCHn3Gbn3BrgeDQkOfgdmry2DBmiwUmeeSbjpndESUkJRUVF5OXlUVRURElJSdgu7TSJPJSWlkY+D1l5HUaP1iHCPkUXqg0phyYXkW5o2LGP0VJAKRqa/GvnXGPvMwJ8n9iv8v2dD01eDdsNE71una7K6kP89p22XQ2rV69m0aJFVFZW/pSWl5dHYWEhTZs2Ddy+HyTnoW3btixdujTtPKRCOvn24zoE9rtXVGhQnf322250rXRsBxGavBdQDvzS2x8N/BVYU+Vz39d0rp0KTV6F7YaJrqx07rDDnLv//pTPnbLtaigsLHTAz7bCwsKM2PeD5DyMGjXKlzykQjr59uM6BPa7X3aZc+efH5htAghNvhRY6jQwKWhw0h7AChEpAPBew1nxQwRuuw1uuEHHXofM4sWLdyo9G7E8BMjixfDQQ9orkGHSiUq8HFgiIvt6SYnQ5FPQkOQQRGjyneHggzWK8d13h+ZCgvbt2+9UejZieQiQa6+F886DgoKMm063d+BioERE5gHdgFuA24B+IvIFcKS3Hx6jRsEdd2i3YYiMHDmSBg0abJPWoEEDRo4cGZJHO4/lISBeekm7tK+6Khz71dURMr0F0iaQzOjRzh1yiHPl5SnbSdl2EhMmTHCFhYVORFxhYaGbMGFCRu37QSIPo0aN8iUPqZBuvtO9Dr7+7mvWONeunXPTpgVum+20CfgXyyibuegiePJJrRb8+c+huVFcXExxcXFo9v0gkYdZs2axcOHCsN1Jiay6DldcAcccA/36heZCPEQgL09nZP3ylxrHbZ99wvbIMLQaMH06zJsXqhu5NXdgR3TsCNddB2eeaWsOGOGzdi2ccw7cd5+umB0i8REB0GpBfn5W9BYYMScLqgEJ4lEdSGDVAiMbyJJqQIJ4lQRga7Vg6FDYsiVsb4y4sXp11lQDEsRPBECrBU2ahNpTYMSQ8nI45RRd/CYLqgEJ4ikCeXka0GHGDBg3LmxvjLhwxRVQpw7cfnvYnmxDvNoEkmnUSEM9H3qoztr6zW/C9sjIZR54QGNjzJmjjdNZRDxLAgk6dYJHH9Ui2qJFYXtj5CpvvAFXX60PnQBCi6dLvEUA4KijdMz2oEGwYUPY3hi5xpIl2gbw8MOw7741fz4ETAQALr1UV3U94wxIWmzCMNJi40Y44QS47DIdE5ClmAiArj1w773wzTcZW+HVyHGc01DinTvD5ZeH7c0Oya4WijCpVw+eekoHErVrp8OLDSMVnNM2gIULdYqwSNge7RATgWRat9aRXH36qCicdlrYHhlR5MYbtSdg5kyNhZHlmAhUZZ99YNo0OPJIFYLBg8P2yIgSt94Kjz0Gr74KzZqF7U2tMBGojs6dVcmPPhp22UV7DgyjJv7+dx0P8Oqr0LJl2N7UGhOB7dGtGzz3HAwcqHMMrERg7IjbbtPIQa+8ojEEI4SJwI74xS/gxRdhwAANZmJtBEZVnNM2gEQVYM89w/ZopzERqInu3eHll3VQ0Y8/Wq+BsRXnNPjt889rL0CrVmF7lBImArWhc2dt6e3XT9eHv/ZanYRkxJcffoBzz4X58/W/EZFGwOqwf3Jt2Wcfnfzx0ktw8sk2xDjObNkChx+uQvDaa5EWAPBBBESkjoi8JyLPefsdRGSOiJSJyGMiUjd9N7OE1q1V9ffYA371K40jb8SLd96BTz+F446DiROhSgyDKOJHSeBSNCR5gtuBO51zewPfA3/0wUb2UK8ejB+vbQOffqpPAiMelJRoI3H79jBiRNaPBKwtaYmAiLQFjgXu9/YFOAKNSwhhhSYPGhGddFRUpDPEbGGS3KaiQmeaXnedlgQbNQrbI19JtyRwF3AlkJh61wyNSlzu7S8FotdnUlv22ANefx3uvBMuvNDWLMxF1q7VwWLvvANvvw1duoTtke+IRidK4YsiA4EBzrkLRORw4ApgKDDbqwogIu2Aqc65n/1yIjIMGAbQqlWrnhMnTkzJj8Bixe+M7YoKWLBA15Dr0GG7seUDsx8CsbC9YYNe1z320EllXvE/qnnv06dPqXOu188OVBebrDYbcCv6pF8ILAc2AiXAKiDf+0xv4KWazhV4LMKA2MZ2RYVzd9/tXLNmzv3f//ke97BG+xkmp21v2ODcn//sXEGBc08+mXn7OyCIWITphCYf7pxr65wrAoYArzjnioGZwInex8INTZ5J8vLg4ou1G3HyZF2zMORIyEYKvPGGDhlftkzjAvzud2F7FDhBjBO4CrhMRMrQNoLxAdjIXjp21MajIUPgkEN0UomFPct+Nm7UFYBOOknnAfznP9C8edheZQRfRMA5N8s5N9B7/5Vz7iDn3N7OuZOccz/6YSNSWKkgWsTw6Z+MjRgMkqqlgttug02bwvbKSLB6tXb1xvDpn4yJQNAklwrefluHH48frz0JRjhs2AC33KLX4scfY/n0T8ZEIFN07KhrGD7xhMY6OOAA3U+xi9ZIgS1bdEHZTp3ggw/gzTdh7NhYPv2TMRHINAcfrFWEO++Em27aum8ER2Wlzvfff394+mkNAvLYYxaV2sOmEoeBCPTvr2sUTJwIZ5+tT6dbb9X1Cwx/cE4Xjh0+XKtlY8dC375he5V1WEkgTPLydLWiTz7RWWkDBui6hpMnW5tBOmzaBA8+CAcdpO0xV1+t7TEmANViIpAN1K2rcw8WLIDf/16j1u61F4wcCStWhO1ddCgr00Af7drBpElwww3w8cfa+p8jM/6CwEQgm6hfH04/XRusJk/WIKn77Qenngr//a81IlZHRYXW8fv3127Y/Hx96j//PBx7rIYCN3aIiUC20r27TlFesAB694ZzzoEDD4QxY6x0APq73HKLlphuvRWKi3Xpt0Qpyqg1JgLZTuPGcMkl2m4werQuYrLvvvrUW75c17iLQwmhshJmz9bFPD7+WHtVFi3S1v633tJqVASi/WQj1jsQFUTgiCN027xZl7devlwbE/Pzdc77oEFw6KEaMCUX2LhRV3qeMkVjQDRvrnksLNQhvrbYqy+YCESRunV15eNZszTo5bx5eqNceSV8+aXWjw87TMOtH3BAxtY3SJv16+H996G0FGbM0Pz16qU3/vDhOuAKNN0EwDdMBKKOCHTtqtu112p49eee0yLyPfdoi/n//I8KQmLLBmFIvuHnztXXhQt15Z6ePXW+xcMPQ5Mm4foZA0wEco02bWDYMN1Ai9Tz5umNNnv2tsJw4IEaMadNGygo2PraurWWNtJh0yYtsn/zjb4m3i9ZAu+9p/X5zp31SX/44dq117lz7lRlIoSJQK7ToIE2oh188Na0hDB89JHemB9+qPEUEjfqypW6mGZBgW6NG+vNmZ+v2y67aI/F2WfrePzycn397rutN/ymTVu/nywwRx0F//u/dsNnESYCcaQ6YUimshJWrdr6FF+7Vm/0xM2+ZQvsuqt+PyEK+fnQtOnWG75JExugExFMBIyfk5enobVbttTFNqpj1iwdiWdEHmtiNYyYYyJgGDHHRMAwYo6JgGHEHBMBw4g5JgKGEXNMBAwj5pgIGEbMSTkqsa9OiHwLLErx683RIKhhEKbtsO3H1XbY9tOxXeica1E1MStEIB1EZK6rLtxyjtsO235cbYdtPwjbVh0wjJhjImAYMScXRGBcTG2HbT+utsO277vtyLcJGIaRHrlQEjAMIw1MBAwj5kRWBETkYhH5VETmi8jfktKHi0iZiHwmIkcH7MPlIuJEpLm3LyJyt2d/noj0CMDmHV6+54nI0yLSOOlY4HkXkf7e+ctE5OogbFSx105EZorIx961vtRLbyoi00XkC+81sBVJRaSOiLwnIs95+x1EZI73GzwmImkuyLhdu41FZJJ3vT8Rkd6B5Ns5F7kN6AO8DNTz9lt6r/sDHwD1gA7Al0CdgHxoB7yEDnJq7qUNAKYCAhwMzAnA7lFAvvf+duD2TOUdqOOddy+grmdv/4CvdQHQw3vfEPjcy+vfgKu99KsTv0NAPlwG/Bt4ztt/HBjivR8LnB+Q3YeBs733dYHGQeQ7sIsX8B/jceDIatKHA8OT9l8CegfkwySgK7AwSQT+BZya9JnPgIIAf4ffAiWZyjvQG3hpe793hq79ZKBf8m/rCcVnAdlrC8wAjgCe8wR+VZIQb/Ob+Gi3EbAAr/G+uv+UX/mOanVgH+DXXpHsVRH5hZe+J7Ak6XNLvTRfEZHjga+dcx9UOZQR+0mchZY8MmU70/nbBhEpAroDc4BWzrll3qHlQKuAzN4FXAlUevvNgDXOuUTs+KB+gw7At8CDXlXkfhHZjQDynbULjYrIy0Drag6NQP1uiha5fwE8LiK+RqGswf41aLE8EHZk2zk32fvMCKAcKAnKj2xCRHYHngT+5JxbJ0krGTvnnIj43tctIgOBlc65UhE53O/z10A+0AO42Dk3R0RGo8X/n/Ar31krAs65I7d3TETOB55yWiZ6W0Qq0YkVX6N19QRtvTTf7IvIAahKf+D9EdsC74rIQX7Z31HePR+GAgOBvt5vgF+2ayATNn6GiOyCCkCJc+4pL3mFiBQ455aJSAGwMgDTvwIGicgAoD6wBzAaaCwi+V5pIKjfYCmw1Dk3x9ufhIqA7/mOanXgGbRxEBHZB200WQVMAYaISD0R6QB0At7207Bz7kPnXEvnXJFzrgi9WD2cc8s9+3/wegkOBtYmFd18QUT6o8XTQc65jUmHAs878A7QyWsdrwsM8ewGhqjSjgc+cc79PenQFOAM7/0ZaFuBrzjnhjvn2nrXeQjwinOuGJgJnBiw7eXAEhHZ10vqC3xMEPnOZKOOj40mdYEJwEfAu8ARScdGoC3YnwHHZMCXhWxtGBTgHs/+h0CvAOyVofXy971tbCbzjvaAfO7ZGZGB3/dQwAHzkvI8AK2bzwC+QHuKmgbsx+Fs7R3YCxXYMuAJvF6qAGx2A+Z6eX8GaBJEvm3YsGHEnKhWBwzD8AkTAcOIOSYChhFzTAQMI+aYCBhGzDERMIyYYyJgGDHn/wHR8YHy4Cx7SAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Can further consider the points on just the 0th turbine\n", + "ys_turbine_0 = ys[0,:,:]\n", + "zs_turbine_0 = zs[0,:,:]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(ys_turbine_0, zs_turbine_0, color='k')\n", + "\n", + "# Draw the rotor in the wind-direction rotated coordinate frame\n", + "circle = plt.Circle((np.mean(ys_turbine_0), fi.floris.turbine.hub_height), fi.floris.turbine.rotor_diameter / 2.0, color='r', fill=False)\n", + "ax.add_patch(circle)\n", + "ax.set_aspect('equal')\n", + "ax.grid(True)" + ] + }, { "cell_type": "markdown", "id": "99b7465c", From e0a976d8a8dfc0418247c83590616e4deef849ab Mon Sep 17 00:00:00 2001 From: Paul Date: Mon, 21 Feb 2022 15:03:31 -0700 Subject: [PATCH 09/28] Update examples to new visualization standards --- ...started.ipynb => 00_getting_started.ipynb} | 108 ++++++++++++--- ...y => 01_opening_floris_computing_power.py} | 54 +++++--- ...{01_plot_wakes.py => 02_visualizations.py} | 3 + ...djustments.py => 03_making_adjustments.py} | 24 ++-- examples/10_heterogeneous_inflow.py | 12 +- examples/12_streamlit_demo.py | 31 ++++- examples/13_streamlit_demo_large_farm.py | 123 ------------------ .../03_compare_models.py | 4 +- 8 files changed, 176 insertions(+), 183 deletions(-) rename examples/{__getting_started.ipynb => 00_getting_started.ipynb} (76%) rename examples/{00_getting_started.py => 01_opening_floris_computing_power.py} (56%) rename examples/{01_plot_wakes.py => 02_visualizations.py} (95%) rename examples/{02_basic_adjustments.py => 03_making_adjustments.py} (83%) delete mode 100644 examples/13_streamlit_demo_large_farm.py rename examples/{ => propose_to_delete}/03_compare_models.py (93%) diff --git a/examples/__getting_started.ipynb b/examples/00_getting_started.ipynb similarity index 76% rename from examples/__getting_started.ipynb rename to examples/00_getting_started.ipynb index 63799e6d5..2471eaac1 100644 --- a/examples/__getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -313,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "e2606e36", "metadata": {}, "outputs": [ @@ -324,6 +324,7 @@ "Power of turbine 0 across wd/ws conditions for aligned case\n", "[[1691.32648289 2407.84258855]\n", " [1691.32648289 2407.84258855]]\n", + "--\n", "Power of all turbines when wind direction = 280 and wind speed = 9\n", "[2407.84258855 2407.84258855 2319.53233514 2319.53161349]\n" ] @@ -333,14 +334,14 @@ "# Can therefore use normal slice operations to get specific powers\n", "print('Power of turbine 0 across wd/ws conditions for aligned case')\n", "print(powers_aligned[:,:,0])\n", - "\n", + "print('--')\n", "print('Power of all turbines when wind direction = 280 and wind speed = 9')\n", "print(powers_aligned[1,1,:])" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "d0ead739", "metadata": {}, "outputs": [ @@ -398,7 +399,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "774acfea", "metadata": {}, "outputs": [ @@ -415,7 +416,7 @@ "(0.0, 150.0)" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -454,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "8dd8ce19", "metadata": {}, "outputs": [ @@ -503,24 +504,19 @@ "\n", "First, because yaw angles are no longer remembered from previous calculate wake calls, it is important to pass in the yaw angles to the visualization function itself\n", "\n", - "Second, because to make a visualization of flow on a horizontal plane, a new grid has to be set up, but since this changes the gridding of the farm, future calls to calculate_wake() will be on this new grid. It is therefore recommend that visualizations be performed on copies of the fi object called fi_viz or similar\n", - "\n", - "Finally, visualization does not accept multiple wind directions and wind speeds it is important to reinitialize if the original was using arrays of wind speeds and directions" + "Second, visualization does not accept multiple wind directions and wind speeds it is important to reinitialize if the original was using arrays of wind speeds and directions" ] }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 15, "id": "8bb179ff", "metadata": {}, "outputs": [], "source": [ - "# Make a copy of fi so as not to impact the grid of the original as this can lead to confusion\n", - "fi_vis = copy.deepcopy(fi)\n", - "\n", "# Choose one wind direction and one wind speed\n", - "fi_vis.reinitialize(wind_directions = [280.], wind_speeds = [9.])\n", - "fi_vis.calculate_wake()\n", + "fi.reinitialize(wind_directions = [280.], wind_speeds = [9.])\n", + "fi.calculate_wake()\n", "\n", "# The yaw angles matrix must also be of only one wind speed and wind direction\n", "# But still should have 3 dimensions\n", @@ -533,17 +529,17 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 17, "id": "38ea41cd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 76, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -564,13 +560,85 @@ "fig, axarr = plt.subplots(1,2,figsize=(15,5))\n", "\n", "# Plot the aligned case\n", - "horizontal_plane = fi_vis.get_hor_plane(yaw_angles=yaw_angles_zero_viz)\n", + "horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles_zero_viz)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[0], title=\"Aligned\")\n", "\n", "# Plot the yawed case\n", - "horizontal_plane = fi_vis.get_hor_plane(yaw_angles=yaw_angles_yaw_front_viz)\n", + "horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles_yaw_front_viz)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[1], title=\"Yawed\")" ] + }, + { + "cell_type": "markdown", + "id": "9295cd9d", + "metadata": {}, + "source": [ + "Visualization makes a new grid of points on the plane to be visualized in addition to those on the rotor. This is done within the calculate_horizontal_plane call. The grid is however set back to how it was originally at the completion of the funcion as can be confirmed" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "09c91c62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs has shape: (1, 1, 4, 3, 3) of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.0, 150.0)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Get the grid points\n", + "xs = fi.floris.grid.x\n", + "ys = fi.floris.grid.y\n", + "zs = fi.floris.grid.z\n", + "\n", + "# Consider the shape\n", + "print('xs has shape: ',xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", + "\n", + "# Lets plot just one wd/ws conditions\n", + "xs = xs[0,0,:,:,:]\n", + "ys = ys[0,0,:,:,:]\n", + "zs = zs[0,0,:,:,:]\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(xs, ys, zs, marker=\".\")\n", + "ax.set_zlim([0, 150])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf277d32", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/examples/00_getting_started.py b/examples/01_opening_floris_computing_power.py similarity index 56% rename from examples/00_getting_started.py rename to examples/01_opening_floris_computing_power.py index 310b8f56b..e39ce0f07 100644 --- a/examples/00_getting_started.py +++ b/examples/01_opening_floris_computing_power.py @@ -23,6 +23,8 @@ 1) Makes a two-turbine layout 2) Demonstrates single ws/wd simulations 3) Demonstrates mulitple ws/wd simulations + +Main concept is introduce FLORIS and illustrate essential structure of most-used FLORIS calls """ # Initialize FLORIS with the given input file via FlorisInterface. @@ -33,6 +35,9 @@ # Convert to a simple two turbine layout fi.reinitialize( layout=( [0, 500.], [0., 0.] ) ) +# Single wind speed and wind direction +print('\n============================= Single Wind Direction and Wind Speed =============================') + # Get the turbine powers assuming 1 wind speed and 1 wind direction fi.reinitialize(wind_directions=[270.], wind_speeds=[8.0]) @@ -42,29 +47,46 @@ # Get the turbine powers turbine_powers = fi.get_turbine_powers()/1000. -print('===========') print('The turbine power matrix should be of dimensions 1 WD X 1 WS X 2 Turbines') print(turbine_powers) -print('===========') +print("Shape: ",turbine_powers.shape) + +# Single wind speed and wind direction +print('\n============================= Single Wind Direction and Multiple Wind Speeds =============================') + -# Now apply 3 wind speeds wind_speeds = np.array([8.0, 9.0, 10.0]) -fi.reinitialize( wind_speeds=wind_speeds) +fi.reinitialize(wind_speeds=wind_speeds) yaw_angles = np.zeros([1,3,2]) # 1 wind direction, 3 wind speeds, 2 turbines fi.calculate_wake(yaw_angles=yaw_angles) turbine_powers = fi.get_turbine_powers()/1000. -print('===========') print('The turbine power matrix should be of dimensions 1 WD X 3 WS X 2 Turbines') print(turbine_powers) -print('===========') - -# Make a small plot -fig, ax = plt.subplots() -ax.plot(wind_speeds, turbine_powers[:,:,0].flatten(), color='k', marker='o', label='Turbine 0' ) -ax.plot(wind_speeds, turbine_powers[:,:,1].flatten(), color='r', marker='o', label='Turbine 1' ) -ax.grid() -ax.legend() -ax.set_ylabel('Power (kW)') -ax.set_xlabel('Wind Speed (m/s)') -plt.show() +print("Shape: ",turbine_powers.shape) + +# Single wind speed and wind direction +print('\n============================= Multiple Wind Directions and Multiple Wind Speeds =============================') + +wind_directions = np.array([260., 270., 280.]) +wind_speeds = np.array([8.0, 9.0, 10.0]) +fi.reinitialize(wind_directions=wind_directions, wind_speeds=wind_speeds) +yaw_angles = np.zeros([1,3,2]) # 1 wind direction, 3 wind speeds, 2 turbines +fi.calculate_wake(yaw_angles=yaw_angles) +turbine_powers = fi.get_turbine_powers()/1000. +print('The turbine power matrix should be of dimensions 3 WD X 3 WS X 2 Turbines') +print(turbine_powers) +print("Shape: ",turbine_powers.shape) + + + + +# # Make a small plot +# fig, ax = plt.subplots() +# ax.plot(wind_speeds, turbine_powers[:,:,0].flatten(), color='k', marker='o', label='Turbine 0' ) +# ax.plot(wind_speeds, turbine_powers[:,:,1].flatten(), color='r', marker='o', label='Turbine 1' ) +# ax.grid() +# ax.legend() +# ax.set_ylabel('Power (kW)') +# ax.set_xlabel('Wind Speed (m/s)') +# plt.show() diff --git a/examples/01_plot_wakes.py b/examples/02_visualizations.py similarity index 95% rename from examples/01_plot_wakes.py rename to examples/02_visualizations.py index a7e032092..be1318c33 100644 --- a/examples/01_plot_wakes.py +++ b/examples/02_visualizations.py @@ -64,6 +64,9 @@ # running the simulation, and generating plots of 2D slices of the # flow field. +# Note this visualization grid created within the calculate_horizontal_plane function will be reset +# to what existed previously at the end of the function + # Using the FlorisInterface functions, get 2D slices. horizontal_plane = fi.calculate_horizontal_plane(x_resolution=200, y_resolution=100) y_plane = fi.calculate_y_plane(x_resolution=200, z_resolution=100) diff --git a/examples/02_basic_adjustments.py b/examples/03_making_adjustments.py similarity index 83% rename from examples/02_basic_adjustments.py rename to examples/03_making_adjustments.py index 932a18e81..77b57b55c 100644 --- a/examples/02_basic_adjustments.py +++ b/examples/03_making_adjustments.py @@ -35,27 +35,27 @@ # Initialize FLORIS with the given input file via FlorisInterface fi = FlorisInterface("inputs/gch.yaml") -# Configure this simulation for visualization using the full flow field grid -solver_settings = { - "type": "flow_field_grid", - "flow_field_grid_points": [200,100,7] -} -fi.reinitialize(solver_settings=solver_settings) +# # Configure this simulation for visualization using the full flow field grid +# solver_settings = { +# "type": "flow_field_grid", +# "flow_field_grid_points": [200,100,7] +# } +# fi.reinitialize(solver_settings=solver_settings) # Plot a horizatonal slice of the initial configuration -horizontal_plane = fi.get_hor_plane() +horizontal_plane = fi.calculate_horizontal_plane() visualize_cut_plane(horizontal_plane, ax=axarr[0], title="Initial setup", minSpeed=MIN_WS, maxSpeed=MAX_WS) # Change the wind speed -horizontal_plane = fi.get_hor_plane(ws=[7.0]) +horizontal_plane = fi.calculate_horizontal_plane(ws=[7.0]) visualize_cut_plane(horizontal_plane, ax=axarr[1], title="Wind speed at 7 m/s", minSpeed=MIN_WS, maxSpeed=MAX_WS) # Change the wind shear, reset the wind speed, and plot a vertical slice fi.reinitialize( wind_shear=0.2, wind_speeds=[8.0] ) -y_plane = fi.get_y_plane() +y_plane = fi.calculate_y_plane() visualize_cut_plane(y_plane, ax=axarr[2], title="Wind shear at 0.2", minSpeed=MIN_WS, maxSpeed=MAX_WS) @@ -66,7 +66,7 @@ 5.0 * fi.floris.turbine.rotor_diameter * np.arange(0, N, 1), ) fi.reinitialize( layout=( X.flatten(), Y.flatten() ) ) -horizontal_plane = fi.get_hor_plane() +horizontal_plane = fi.calculate_horizontal_plane() visualize_cut_plane(horizontal_plane, ax=axarr[3], title="3x3 Farm", minSpeed=MIN_WS, maxSpeed=MAX_WS) # plot_turbines_with_fi(axarr[7], fi) @@ -84,13 +84,13 @@ yaw_angles[:,:,4] = 30.0 yaw_angles[:,:,5] = -30.0 -horizontal_plane = fi.get_hor_plane(yaw_angles=yaw_angles) +horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles) visualize_cut_plane(horizontal_plane, ax=axarr[4], title="Yawesome art", cmap="PuOr", minSpeed=MIN_WS, maxSpeed=MAX_WS) # plot_turbines_with_fi(axarr[8], fi) # Plot the cross-plane of the 3x3 configuration -cross_plane = fi.get_cross_plane(yaw_angles=yaw_angles, downstream_dist=610.0) +cross_plane = fi.calculate_cross_plane(yaw_angles=yaw_angles, downstream_dist=610.0) visualize_cut_plane(cross_plane, ax=axarr[5], title="Cross section at 610 m", minSpeed=MIN_WS, maxSpeed=MAX_WS) axarr[5].invert_xaxis() diff --git a/examples/10_heterogeneous_inflow.py b/examples/10_heterogeneous_inflow.py index f0605e69c..e1b093198 100644 --- a/examples/10_heterogeneous_inflow.py +++ b/examples/10_heterogeneous_inflow.py @@ -55,9 +55,9 @@ # Using the FlorisInterface functions for generating plots, run FLORIS # and extract 2D planes of data. -horizontal_plane_2d = fi_2d.get_hor_plane(x_resolution=200, y_resolution=100) -y_plane_2d = fi_2d.get_y_plane(x_resolution=200, z_resolution=100) -cross_plane_2d = fi_2d.get_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=500.0) +horizontal_plane_2d = fi_2d.calculate_horizontal_plane(x_resolution=200, y_resolution=100) +y_plane_2d = fi_2d.calculate_y_plane(x_resolution=200, z_resolution=100) +cross_plane_2d = fi_2d.calculate_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=500.0) # Create the plots fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) @@ -90,9 +90,9 @@ # Using the FlorisInterface functions for generating plots, run FLORIS # and extract 2D planes of data. -horizontal_plane_3d = fi_3d.get_hor_plane(x_resolution=200, y_resolution=100) -y_plane_3d = fi_3d.get_y_plane(x_resolution=200, z_resolution=100) -cross_plane_3d = fi_3d.get_cross_plane(y_resolution=100, z_resolution=100) +horizontal_plane_3d = fi_3d.calculate_horizontal_plane(x_resolution=200, y_resolution=100) +y_plane_3d = fi_3d.calculate_y_plane(x_resolution=200, z_resolution=100) +cross_plane_3d = fi_3d.calculate_cross_plane(y_resolution=100, z_resolution=100) # Create the plots fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) diff --git a/examples/12_streamlit_demo.py b/examples/12_streamlit_demo.py index e776b65ea..2bd01e4ae 100644 --- a/examples/12_streamlit_demo.py +++ b/examples/12_streamlit_demo.py @@ -16,6 +16,8 @@ import matplotlib.pyplot as plt import streamlit as st import numpy as np +import pandas as pd +# import seaborn as sns from floris.tools import FlorisInterface from floris.tools.visualization import visualize_cut_plane @@ -77,9 +79,11 @@ yaw_angles_yaw = np.zeros([1,1,len(X)]) if not desc_yaw: - yaw_angles_yaw[:n_row] = front_turbine_yaw + yaw_angles_yaw[:,:,:n_row] = front_turbine_yaw else: - yaw_angles_yaw[:n_row] = front_turbine_yaw + decreasing_pattern = np.linspace(front_turbine_yaw,0,n_turbine_per_row) + for i in range(n_turbine_per_row): + yaw_angles_yaw[:,:,i*n_row:(i+1)*n_row] = decreasing_pattern[i] @@ -96,6 +100,9 @@ # Set up the turbine power plot fig_turb_pow, ax_turb_pow = plt.subplots() +# Set up a list to save the farm power results +farm_power_results = [] + # Now complete all these plots in a loop for fm in floris_models: @@ -115,12 +122,15 @@ ax_turb_pow.set_xlabel('Turbine') ax_turb_pow.set_ylabel('Power (kW)') + # Save the farm power + farm_power_results.append((fm,'base',np.sum(turbine_powers))) + # If in viz list also visualize if fm in floris_models_viz: ax_idx = floris_models_viz.index(fm) ax = axarr_viz[ax_idx, 0] - horizontal_plane_gch = fi.get_hor_plane(x_resolution=100, y_resolution=100) + horizontal_plane_gch = fi.calculate_horizontal_plane(x_resolution=100, y_resolution=100, yaw_angles=yaw_angles_base) visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - baseline' % fm) # Analyze the yawed case================================================== @@ -139,15 +149,28 @@ ax_turb_pow.set_xlabel('Turbine') ax_turb_pow.set_ylabel('Power (kW)') + # Save the farm power + farm_power_results.append((fm,'yawed',np.sum(turbine_powers))) + # If in viz list also visualize if fm in floris_models_viz: ax_idx = floris_models_viz.index(fm) ax = axarr_viz[ax_idx, 1] - horizontal_plane_gch = fi.get_hor_plane(x_resolution=100, y_resolution=100) + horizontal_plane_gch = fi.calculate_horizontal_plane(x_resolution=100, y_resolution=100, yaw_angles=yaw_angles_yaw) visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - yawed' % fm) st.header("Visualizations") st.write(fig_viz) st.header("Power Comparison") st.write(fig_turb_pow) + +# print(farm_power_results) + +# # Show the farm results +# df_farm = pd.DataFrame.from_records(farm_power_results, columns = ['model','yaw','power']).set_index(['yaw','model']).unstack() +# df_farm.columns = [c[1] for c in df_farm.columns] +# fig, ax = plt.subplots() +# df_farm.plot.bar(ax=ax,color=color_dict,rot=90) +# st.write(fig) +# print(df_farm) \ No newline at end of file diff --git a/examples/13_streamlit_demo_large_farm.py b/examples/13_streamlit_demo_large_farm.py deleted file mode 100644 index eff399d8b..000000000 --- a/examples/13_streamlit_demo_large_farm.py +++ /dev/null @@ -1,123 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import streamlit as st -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.visualization import visualize_cut_plane - - -# """ -# This example demonstrates an interactive visual comparison of FLORIS -# wake models using streamlit - -# To run this example: -# (with your FLORIS environment enabled) -# pip install streamlit - -# streamlit run 13_streamlit_demo_large_farm.py -# """ - - -# Parameters -wind_speed = 8.0 -# ti = 0.06 - -# Set to wide -st.set_page_config(layout="wide") - -#Streamlit inputs -wind_direction_user = st.sidebar.slider("Wind Direction", 240., 300., 285., step=1.) -spacing = st.sidebar.slider("Turbine spacing (D)", 3., 10., 6., step=0.5) -N = st.sidebar.slider("Turbines per row", 4, 8, 5, step=1) - - - -# Get number of turbines and make 0 yaw angle matrix -num_turbine = N**3 -yaw_angles = np.zeros((1, 1, num_turbine)) # 1 wd/ 1ws/ N*N turbines - -# Grab two different wake models -fi_gch = FlorisInterface("inputs/gch.yaml") - - -# Define layout -X, Y = np.meshgrid( - spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), - spacing * fi_gch.floris.turbine.rotor_diameter * np.arange(0, N, 1), -) -X = X.flatten() -Y = Y.flatten() - - -# Title -st.title('FLORIS Model Comparison') - -# Create the main analysis image -fig, axarr = plt.subplots(2,2) - - - -# Calculate for alligned case and user requested direction -for wd_idx, wind_direction in enumerate([270., wind_direction_user]): - - # Grab two different wake models - # Not positive why this is necessary - # If you move this above the loop so it only happens once, there is an error - fi_jensen = FlorisInterface("inputs/jensen.yaml") - fi_gch = FlorisInterface("inputs/gch.yaml") - fi_cc = FlorisInterface("inputs/cc.yaml") - - - - # Configure model - fi_jensen.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.05 ) - fi_gch.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.06 ) - fi_cc.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=0.1) - - # Calculate wake - fi_jensen.calculate_wake(yaw_angles=yaw_angles) - fi_gch.calculate_wake(yaw_angles=yaw_angles) - fi_cc.calculate_wake(yaw_angles=yaw_angles) - - # Get turbine powers - turbine_powers_jensen = fi_jensen.get_turbine_powers() - turbine_powers_gch = fi_gch.get_turbine_powers() - turbine_powers_cc = fi_cc.get_turbine_powers() - - # Put the turbine powers in descending order - turbine_powers_jensen = np.sort(turbine_powers_jensen.flatten())[::-1]/1000. - turbine_powers_gch = np.sort(turbine_powers_gch.flatten())[::-1]/1000. - turbine_powers_cc = np.sort(turbine_powers_cc.flatten())[::-1]/1000. - - # Show the (GCH) Horizontal plane - horizontal_plane_gch = fi_gch.get_hor_plane(x_resolution=100, y_resolution=100) - ax = axarr[0,wd_idx] - visualize_cut_plane(horizontal_plane_gch, ax=ax, title="Wind Direction = %.1f" % wind_direction) - - # Compare the power production - ax = axarr[1,wd_idx] - ax.plot(turbine_powers_jensen,color='k',label='Jensen') - ax.plot(turbine_powers_gch,color='b',label='GCH') - ax.plot(turbine_powers_cc,ls='--',color='r',label='CC') - ax.grid(True) - ax.legend() - ax.set_ylabel('Power (kW)') - ax.set_xlabel('Turbine (sorted)') - -# Show the figure -st.write(fig) diff --git a/examples/03_compare_models.py b/examples/propose_to_delete/03_compare_models.py similarity index 93% rename from examples/03_compare_models.py rename to examples/propose_to_delete/03_compare_models.py index 7f369d1be..528e56f6e 100644 --- a/examples/03_compare_models.py +++ b/examples/propose_to_delete/03_compare_models.py @@ -41,7 +41,7 @@ # Aligned ax = axarr[0, idx] - horizontal_plane = fi.get_hor_plane() + horizontal_plane = fi.calculate_horizontal_plane() visualize_cut_plane(horizontal_plane, ax=ax, minSpeed=MIN_WS, maxSpeed=MAX_WS) ax.set_title(name) axarr[0, 0].set_ylabel("Aligned") @@ -50,7 +50,7 @@ yaw_angles = np.zeros_like(fi.floris.farm.yaw_angles) yaw_angles[:,:,0] = 25.0 ax = axarr[1, idx] - horizontal_plane = fi.get_hor_plane(yaw_angles=yaw_angles) + horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles) visualize_cut_plane(horizontal_plane, ax=ax, minSpeed=MIN_WS, maxSpeed=MAX_WS) axarr[1, 0].set_ylabel("Yawed") From 66fc975951273b0559410ce8a54d4938625c6820 Mon Sep 17 00:00:00 2001 From: Paul Date: Tue, 22 Feb 2022 14:36:57 -0700 Subject: [PATCH 10/28] update notebook --- examples/00_getting_started.ipynb | 214 ++++++++++++++++++++++++++++-- 1 file changed, 200 insertions(+), 14 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index 2471eaac1..43cd33c45 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -24,6 +24,7 @@ "outputs": [], "source": [ "import copy\n", + "import time\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -313,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "e2606e36", "metadata": {}, "outputs": [ @@ -341,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "d0ead739", "metadata": {}, "outputs": [ @@ -399,7 +400,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "774acfea", "metadata": {}, "outputs": [ @@ -416,7 +417,7 @@ "(0.0, 150.0)" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, @@ -455,7 +456,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "8dd8ce19", "metadata": {}, "outputs": [ @@ -509,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "8bb179ff", "metadata": {}, "outputs": [], @@ -529,17 +530,17 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "id": "38ea41cd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, @@ -578,7 +579,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "id": "09c91c62", "metadata": {}, "outputs": [ @@ -595,7 +596,7 @@ "(0.0, 150.0)" ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -632,13 +633,198 @@ "ax.set_zlim([0, 150])" ] }, + { + "cell_type": "markdown", + "id": "e91f7a84", + "metadata": {}, + "source": [ + "## Calculating AEP" + ] + }, + { + "cell_type": "markdown", + "id": "34bc7865", + "metadata": {}, + "source": [ + "Calculating AEP in FLORIS V3 takes advantage of the new vectorized framework to substantially reduce the computation time with respect to V2.4\n", + "\n", + "In these examples we demonstrate a simplied AEP calculation for a 25-turbine farm using several different modeling options.\n", + "\n", + "We will make a simplifying assumption that every wind speed and direction is equally likely" + ] + }, { "cell_type": "code", - "execution_count": null, - "id": "bf277d32", + "execution_count": 106, + "id": "f63a2195", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating AEP for 1368 wind direction and speed combinations\n" + ] + } + ], + "source": [ + "wind_directions = np.arange(0.,360.,5.)\n", + "wind_speeds = np.arange(6.,25.,1.)\n", + "\n", + "\n", + "num_wind_directions = len(wind_directions)\n", + "num_wind_speeds = len(wind_speeds)\n", + "num_bins = num_wind_directions * num_wind_speeds\n", + "print('Calculating AEP for %d wind direction and speed combinations' % num_bins)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "ee1918d6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of turbines = 25\n" + ] + } + ], + "source": [ + "# Set up a square 25 turbine layout\n", + "N = 5 # Number of turbines per row and per column\n", + "D = 126. \n", + "\n", + "X, Y = np.meshgrid(\n", + " 7.0 * D * np.arange(0, N, 1),\n", + " 7.0 * D * np.arange(0, N, 1),\n", + ")\n", + "X = X.flatten()\n", + "Y = Y.flatten()\n", + "print(\"Number of turbines = %d\" % len(X))" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "6a381dc7", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Define several models\n", + "fi_jensen = FlorisInterface(\"inputs/jensen.yaml\")\n", + "fi_gch = FlorisInterface(\"inputs/gch.yaml\")\n", + "fi_cc = FlorisInterface(\"inputs/cc.yaml\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "7547d804", + "metadata": {}, + "outputs": [], + "source": [ + "# Assign the layouts, wind speeds and directions\n", + "fi_jensen.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)\n", + "fi_gch.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)\n", + "fi_cc.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)" + ] + }, + { + "cell_type": "markdown", + "id": "1147b4a7", + "metadata": {}, + "source": [ + "Calculate the AEP and use the jupyter time command to show computation time" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "702bb7ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.25 s, sys: 1.21 s, total: 4.46 s\n", + "Wall time: 3.47 s\n" + ] + } + ], + "source": [ + "%%time\n", + "fi_jensen.calculate_wake()\n", + "jensen_aep = fi_jensen.get_farm_power().sum() / num_bins / 1E9 * 365 * 24" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "8b688add", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 5.33 s, sys: 1.37 s, total: 6.7 s\n", + "Wall time: 5.17 s\n" + ] + } + ], + "source": [ + "%%time\n", + "fi_gch.calculate_wake()\n", + "gch_aep = fi_gch.get_farm_power().sum() / num_bins / 1E9 * 365 * 24" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "627f5242", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 7.31 s, sys: 1.23 s, total: 8.54 s\n", + "Wall time: 8.61 s\n" + ] + } + ], + "source": [ + "%%time\n", + "fi_cc.calculate_wake()\n", + "cc_aep = fi_cc.get_farm_power().sum() / num_bins / 1E9 * 365 * 24" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "394ab742", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jensen 883.9 GWh\n", + "GCH 884.4 GWh\n", + "CC 879.6 GWh\n" + ] + } + ], + "source": [ + "# Show the results\n", + "print('Jensen %.1f GWh' % jensen_aep)\n", + "print('GCH %.1f GWh' % gch_aep)\n", + "print('CC %.1f GWh' % cc_aep)" + ] } ], "metadata": { From 48c66a39b3669a14b1676acacf2b06d9a27aa6f8 Mon Sep 17 00:00:00 2001 From: Paul Date: Tue, 22 Feb 2022 15:01:15 -0700 Subject: [PATCH 11/28] Remove references to json --- examples/00_getting_started.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index 43cd33c45..5f8683e0b 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -48,7 +48,7 @@ "source": [ "As in V2, a floris interface object is the main point of interaction with FLORIS.\n", "\n", - "Something that is new is that the input file can be either a JSON or YAML file" + "Something that is new is that the input file is in YAML format to enable new syntax around mixed turbine farms and to cut down on errors related to many-nested brackets" ] }, { @@ -77,7 +77,7 @@ "id": "64226134", "metadata": {}, "source": [ - "Similarly to V2, changes to the background flow and farm are put in place via a reinitialize function. Another way to think of this function is that it changes the value of variables specified in the intial yaml/json file" + "Similarly to V2, changes to the background flow and farm are put in place via a reinitialize function. Another way to think of this function is that it changes the value of variables specified in the input yaml file" ] }, { From 5490fe7879c65aa173ed2c370b7339c1b41ff10f Mon Sep 17 00:00:00 2001 From: Paul Date: Tue, 22 Feb 2022 15:34:27 -0700 Subject: [PATCH 12/28] add yaw optimization example --- examples/00_getting_started.ipynb | 215 ++++++++++++++++++++++++------ 1 file changed, 176 insertions(+), 39 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index 5f8683e0b..4b2313c50 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 27, "id": "a700d720", "metadata": {}, "outputs": [], @@ -30,7 +30,10 @@ "import numpy as np\n", "\n", "from floris.tools import FlorisInterface\n", - "from floris.tools.visualization import visualize_cut_plane" + "from floris.tools.visualization import visualize_cut_plane\n", + "from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import (\n", + " YawOptimizationSR,\n", + ")" ] }, { @@ -53,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "602f311c", "metadata": {}, "outputs": [], @@ -90,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "d040b810", "metadata": {}, "outputs": [], @@ -123,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "6f9d834a", "metadata": {}, "outputs": [], @@ -156,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "e3bf1698", "metadata": {}, "outputs": [], @@ -189,7 +192,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "be78e20d", "metadata": {}, "outputs": [ @@ -203,7 +206,7 @@ " [0., 0., 0., 0.]]])" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -220,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "0f041620", "metadata": {}, "outputs": [ @@ -234,7 +237,7 @@ " [25., 25., 0., 0.]]])" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -265,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "6054265f", "metadata": {}, "outputs": [], @@ -289,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "7de24fe5", "metadata": {}, "outputs": [ @@ -303,7 +306,7 @@ " [2407.84258855, 2407.84258855, 2319.53233514, 2319.53161349]]])" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -314,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "e2606e36", "metadata": {}, "outputs": [ @@ -342,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "d0ead739", "metadata": {}, "outputs": [ @@ -400,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "774acfea", "metadata": {}, "outputs": [ @@ -417,7 +420,7 @@ "(0.0, 150.0)" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -456,7 +459,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "8dd8ce19", "metadata": {}, "outputs": [ @@ -510,7 +513,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "8bb179ff", "metadata": {}, "outputs": [], @@ -530,17 +533,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "38ea41cd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -579,7 +582,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "09c91c62", "metadata": {}, "outputs": [ @@ -596,7 +599,7 @@ "(0.0, 150.0)" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -655,7 +658,7 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": 18, "id": "f63a2195", "metadata": {}, "outputs": [ @@ -680,7 +683,7 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 41, "id": "ee1918d6", "metadata": {}, "outputs": [ @@ -703,12 +706,13 @@ ")\n", "X = X.flatten()\n", "Y = Y.flatten()\n", - "print(\"Number of turbines = %d\" % len(X))" + "num_turbine = len(X)\n", + "print(\"Number of turbines = %d\" % num_turbine)" ] }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 20, "id": "6a381dc7", "metadata": {}, "outputs": [], @@ -721,7 +725,7 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 21, "id": "7547d804", "metadata": {}, "outputs": [], @@ -742,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 22, "id": "702bb7ee", "metadata": {}, "outputs": [ @@ -750,8 +754,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.25 s, sys: 1.21 s, total: 4.46 s\n", - "Wall time: 3.47 s\n" + "CPU times: user 3.09 s, sys: 1.19 s, total: 4.29 s\n", + "Wall time: 3.3 s\n" ] } ], @@ -763,7 +767,7 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 23, "id": "8b688add", "metadata": {}, "outputs": [ @@ -771,8 +775,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 5.33 s, sys: 1.37 s, total: 6.7 s\n", - "Wall time: 5.17 s\n" + "CPU times: user 5.48 s, sys: 1.47 s, total: 6.95 s\n", + "Wall time: 5.64 s\n" ] } ], @@ -784,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 24, "id": "627f5242", "metadata": {}, "outputs": [ @@ -792,8 +796,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 7.31 s, sys: 1.23 s, total: 8.54 s\n", - "Wall time: 8.61 s\n" + "CPU times: user 7.14 s, sys: 1.24 s, total: 8.38 s\n", + "Wall time: 8.45 s\n" ] } ], @@ -805,7 +809,7 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 25, "id": "394ab742", "metadata": {}, "outputs": [ @@ -825,6 +829,139 @@ "print('GCH %.1f GWh' % gch_aep)\n", "print('CC %.1f GWh' % cc_aep)" ] + }, + { + "cell_type": "markdown", + "id": "c006ae1e", + "metadata": {}, + "source": [ + "## Wake Steering Design" + ] + }, + { + "cell_type": "markdown", + "id": "f5777dae", + "metadata": {}, + "source": [ + "FLORIS V3 further includes new optimization routines for the design of wake steering controllers. The SerialRefine is a new method for quickly identifying optimum yaw angles." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "32a93c6d", + "metadata": {}, + "outputs": [], + "source": [ + "# Demonstrate on 7-turbine single row farm\n", + "X = np.linspace(0,6*7*D,7)\n", + "Y = np.zeros_like(X)\n", + "wind_speeds = [8.]\n", + "wind_directions = np.arange(0.,360.,2.)\n", + "fi_gch.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "7d773cdc", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the SerialRefine optimization\n", + "yaw_opt = YawOptimizationSR(\n", + " fi=fi_gch,\n", + " minimum_yaw_angle=0.0, # Allowable yaw angles lower bound\n", + " maximum_yaw_angle=25.0, # Allowable yaw angles upper bound\n", + " Ny_passes=[5, 4],\n", + " exclude_downstream_turbines=True,\n", + " exploit_layout_symmetry=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "1ccb9ab7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Serial Refine] Processing pass=0, turbine_depth=0 (0.0 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=1 (7.1 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=2 (14.3 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=3 (21.4 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=4 (28.6 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=5 (35.7 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=6 (42.9 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=0 (50.0 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=1 (57.1 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=2 (64.3 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=3 (71.4 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=4 (78.6 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=5 (85.7 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=6 (92.9 %)\n", + "CPU times: user 1.49 s, sys: 344 ms, total: 1.83 s\n", + "Wall time: 1.44 s\n" + ] + } + ], + "source": [ + "%%time\n", + "## Calculate the optimum yaw angles for 25 turbines and 72 wind directions\n", + "df_opt = yaw_opt._optimize()" + ] + }, + { + "cell_type": "markdown", + "id": "fb2e01e8", + "metadata": {}, + "source": [ + "In the results, T0 is the upstream turbine when wind direction is 270, while T6 is upstream at 90 deg" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "686548be", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Wind Direction (Deg)')" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Show the results\n", + "yaw_angles_opt = np.vstack(df_opt[\"yaw_angles_opt\"])\n", + "fig, axarr = plt.subplots(len(X),1,sharex=True,sharey=True,figsize=(10,10))\n", + "for i in range(len(X)):\n", + " axarr[i].plot(wind_directions,yaw_angles_opt[:,i],'k-',label='T%d' % i)\n", + " axarr[i].set_ylabel('Yaw (Deg)')\n", + " axarr[i].legend()\n", + " axarr[i].grid(True)\n", + "axarr[-1].set_xlabel('Wind Direction (Deg)')" + ] } ], "metadata": { From 49ec56124ecd21d4b7a558782ce6c18d350474c0 Mon Sep 17 00:00:00 2001 From: bayc Date: Tue, 22 Feb 2022 16:04:51 -0700 Subject: [PATCH 13/28] changes to the getting_started notebook --- examples/00_getting_started.ipynb | 177 ++++++++++++++++++------------ 1 file changed, 107 insertions(+), 70 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index 4b2313c50..7ddec38d3 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -13,7 +13,7 @@ "id": "bb74834b", "metadata": {}, "source": [ - "This notebook is designed to step through the basic operations of FLORIS V3 and highlight what is new/changed from FLORIS V2.4" + "This notebook is designed to step through the basic operations of FLORIS V3 and highlight what is new/changed from FLORIS V2.4." ] }, { @@ -51,7 +51,7 @@ "source": [ "As in V2, a floris interface object is the main point of interaction with FLORIS.\n", "\n", - "Something that is new is that the input file is in YAML format to enable new syntax around mixed turbine farms and to cut down on errors related to many-nested brackets" + "Something that is new is that the input file is in YAML format to enable new syntax around mixed turbine farms and to cut down on errors related to many-nested brackets." ] }, { @@ -80,7 +80,7 @@ "id": "64226134", "metadata": {}, "source": [ - "Similarly to V2, changes to the background flow and farm are put in place via a reinitialize function. Another way to think of this function is that it changes the value of variables specified in the input yaml file" + "Similarly to V2, changes to the background flow and farm are put in place via a `reinitialize` function. Another way to think of this function is that it changes the value of variables specified in the input yaml file." ] }, { @@ -101,7 +101,7 @@ "# Design a 2x2 farm, units are m\n", "X = np.array([0, 0, 800, 800])\n", "Y = np.array([0, 400, 0, 400])\n", - "fi.reinitialize(layout=[X,Y])" + "fi.reinitialize(layout=[X, Y])" ] }, { @@ -119,7 +119,7 @@ "source": [ "This aspect is one of the major changes from V2 to V3. \n", "\n", - "Previously, wind speeds and directions descrobed one condition. Now they can describe one or multiple conditions, including an entire wind rose at once. This enables the underlying vectorization which allows the computations to be handled at once, rather than wrapped in a loop.\n", + "Previously, wind speeds and directions described one condition. Now they can describe one or multiple conditions, including an entire wind rose at once. This enables the underlying vectorization which allows the computations to be handled at once, rather than wrapped in a computation loop.\n", "\n", "Some aspects of this specification are still under consideration, but in current form, unless explicitly specified to represent a time series, a vector of wind directions and wind speeds will be \"expanded\" such that each combination of wind direction and wind speed is computed." ] @@ -154,7 +154,7 @@ "id": "f40efe20", "metadata": {}, "source": [ - "Similar again to V2, there is a calculate_wake function. In V3 this will calculate the velocities for every specified grid point, and for every specified wind speed and wind direction. If not doing visualization, grid points will be on the turbine rotors" + "Similar again to V2, there is a `calculate_wake` function. In V3 this will calculate the velocities for every specified grid point, and for every specified wind speed and wind direction. If not doing visualization, grid points will be on the turbine rotors." ] }, { @@ -180,14 +180,14 @@ "id": "89ea9b19", "metadata": {}, "source": [ - "Yaw angles are applied to turbines in the calculate wake function. Some important things to note when using the new framwork\n", + "Yaw angles are applied to turbines in the `calculate_wake` function. Some important things to note when using the new framwork:\n", "\n", - "**yaw_angles is a matrix** -- You must provide yaw angles in a matrix with \n", - "* wind directions\n", - "* wind speeds\n", - "* turbines\n", + "**yaw_angles is a matrix** -- You must provide yaw angles in a matrix with dimensions equal to:\n", + "* number of wind directions\n", + "* number of wind speeds\n", + "* number of turbines\n", "\n", - "**unlike variables passed in reinitialize, yaw angles applied to calculate wake are not remembered between calls**" + "**unlike variables passed in `reinitialize`, yaw angles applied to calculate wake are not remembered between calls**" ] }, { @@ -217,7 +217,7 @@ "num_ws = 2\n", "num_turbine = 4\n", "yaw_angles_zero = np.zeros([num_wd, num_ws, num_turbine])\n", - "fi.calculate_wake(yaw_angles = yaw_angles_zero)\n", + "fi.calculate_wake(yaw_angles=yaw_angles_zero)\n", "yaw_angles_zero" ] }, @@ -245,8 +245,8 @@ "source": [ "# Yaw the front row for all wind directions and all wind speeds\n", "yaw_angles_yaw_front = np.zeros([num_wd, num_ws, num_turbine])\n", - "yaw_angles_yaw_front[:,:,:2] = 25\n", - "fi.calculate_wake(yaw_angles = yaw_angles_yaw_front)\n", + "yaw_angles_yaw_front[:, :, :2] = 25\n", + "fi.calculate_wake(yaw_angles=yaw_angles_yaw_front)\n", "yaw_angles_yaw_front" ] }, @@ -263,7 +263,7 @@ "id": "bf4b6ac8", "metadata": {}, "source": [ - "The calculate wake function computes the velocity at each grid point on each turbine. To then compute the power, you call the get_turbine_power() function" + "The calculate wake function computes the velocity at each grid point on each turbine. To then compute the power, you call the `get_turbine_powers()` function:" ] }, { @@ -274,11 +274,11 @@ "outputs": [], "source": [ "# Aligned\n", - "fi.calculate_wake(yaw_angles = yaw_angles_zero)\n", + "fi.calculate_wake(yaw_angles=yaw_angles_zero)\n", "powers_aligned = fi.get_turbine_powers()/1000.\n", "\n", "# Yawed\n", - "fi.calculate_wake(yaw_angles = yaw_angles_yaw_front)\n", + "fi.calculate_wake(yaw_angles=yaw_angles_yaw_front)\n", "powers_yawed = fi.get_turbine_powers()/1000." ] }, @@ -287,7 +287,7 @@ "id": "5a11cdee", "metadata": {}, "source": [ - "The powers are returned in a matrix of the same dimensions as the yaw_angles matrix and by default in units W (the division by 1000 converting to kW in the above example code)" + "The powers are returned in a matrix of the same dimensions as the yaw_angles matrix and by default in units W (the division by 1000 converting to kW in the above example code)." ] }, { @@ -315,6 +315,39 @@ "powers_aligned" ] }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2d88eb5a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[1405.86257762, 1405.86257762, 1027.52310514, 1050.99771102],\n", + " [2002.44307076, 2002.44307076, 1465.26930376, 1499.2201859 ]],\n", + "\n", + " [[1405.86257762, 1405.86257762, 1686.4416639 , 1687.16796562],\n", + " [2002.44307076, 2002.44307076, 2400.84095397, 2401.87031696]]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "powers_yawed" + ] + }, + { + "cell_type": "markdown", + "id": "2129f587", + "metadata": {}, + "source": [ + "We can therefore use normal slice operations to get specific powers:" + ] + }, { "cell_type": "code", "execution_count": 11, @@ -335,12 +368,19 @@ } ], "source": [ - "# Can therefore use normal slice operations to get specific powers\n", "print('Power of turbine 0 across wd/ws conditions for aligned case')\n", - "print(powers_aligned[:,:,0])\n", + "print(powers_aligned[:, :, 0])\n", "print('--')\n", "print('Power of all turbines when wind direction = 280 and wind speed = 9')\n", - "print(powers_aligned[1,1,:])" + "print(powers_aligned[1, 1, :])" + ] + }, + { + "cell_type": "markdown", + "id": "c40d87ee", + "metadata": {}, + "source": [ + "We can also use sum operations across dimensions:" ] }, { @@ -362,10 +402,8 @@ } ], "source": [ - "# Can also use sum operations across dimensions\n", - "\n", - "farm_power_aligned = np.sum(powers_aligned,2) # Some over turbine dimension\n", - "farm_power_yawed = np.sum(powers_yawed,2) # Some over turbine dimension\n", + "farm_power_aligned = np.sum(powers_aligned, 2) # Some over turbine dimension\n", + "farm_power_yawed = np.sum(powers_yawed, 2) # Some over turbine dimension\n", "\n", "print('Farm power across wind directions and speeds')\n", "print(farm_power_aligned)\n", @@ -388,9 +426,9 @@ "id": "e8241714", "metadata": {}, "source": [ - "In FLORIS, grid points are the points in space where the wind conditions are calculated. In a typical simulation, these are all located on a regular grid on each turbine rotor\n", + "In FLORIS, grid points are the points in space where the wind conditions are calculated. In a typical simulation, these are all located on a regular grid on each turbine rotor.\n", "\n", - "The parameter **turbine_grid_points** specifies the number of rows and columns which define the turbine grid. In the default yaml this value is 3, meaning there are 3x3 = 9 total grid points. Wake steering codes currently require greater values greater than 1 in order to compute gradients. However, it is likely 1x1 is suitable for non wind farm control applications, although retuning of some parameters could be warrented." + "The parameter `turbine_grid_points` specifies the number of rows and columns which define the turbine grid. In the default yaml input file this value is 3, meaning there are 3x3 = 9 total grid points. Wake steering codes currently require greater values greater than 1 in order to compute gradients. However, it is likely 1x1 is suitable for non wind farm control applications, although retuning of some parameters could be warranted." ] }, { @@ -398,7 +436,7 @@ "id": "c771d0fb", "metadata": {}, "source": [ - "We can visualize the locations of the grid points in the current example using pyplot" + "We can visualize the locations of the grid points in the current example using pyplot:" ] }, { @@ -426,7 +464,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -444,12 +482,12 @@ "zs = fi.floris.grid.z\n", "\n", "# Consider the shape\n", - "print('xs has shape: ',xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", + "print('xs has shape: ', xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", "\n", "# Lets plot just one wd/ws conditions\n", - "xs = xs[0,0,:,:,:]\n", - "ys = ys[0,0,:,:,:]\n", - "zs = zs[0,0,:,:,:]\n", + "xs = xs[0, 0, :, :, :]\n", + "ys = ys[0, 0, :, :, :]\n", + "zs = zs[0, 0, :, :, :]\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", @@ -465,7 +503,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -478,8 +516,8 @@ ], "source": [ "# Can further consider the points on just the 0th turbine\n", - "ys_turbine_0 = ys[0,:,:]\n", - "zs_turbine_0 = zs[0,:,:]\n", + "ys_turbine_0 = ys[0, :, :]\n", + "zs_turbine_0 = zs[0, :, :]\n", "\n", "fig, ax = plt.subplots()\n", "ax.scatter(ys_turbine_0, zs_turbine_0, color='k')\n", @@ -504,11 +542,11 @@ "id": "cd938402", "metadata": {}, "source": [ - "Tools for visualizing the flow are similar to how they operated in V3 however there are important changes\n", + "Tools for visualizing the flow are similar to how they operated in V3; however there are important changes.\n", "\n", - "First, because yaw angles are no longer remembered from previous calculate wake calls, it is important to pass in the yaw angles to the visualization function itself\n", + "First, because yaw angles are no longer remembered from previous `calculate_wake` calls, it is important to pass in the yaw angles to the visualization function itself.\n", "\n", - "Second, visualization does not accept multiple wind directions and wind speeds it is important to reinitialize if the original was using arrays of wind speeds and directions" + "Second, because visualization does not accept multiple wind directions and wind speeds, it is important to reinitialize if the original was using arrays of wind speeds and directions." ] }, { @@ -525,9 +563,9 @@ "# The yaw angles matrix must also be of only one wind speed and wind direction\n", "# But still should have 3 dimensions\n", "# Take just this slice and flatten\n", - "yaw_angles_zero_viz = np.zeros([1,1,num_turbine])\n", + "yaw_angles_zero_viz = np.zeros([1, 1, num_turbine])\n", "yaw_angles_yaw_front_viz = np.zeros([1, 1, num_turbine])\n", - "yaw_angles_yaw_front_viz[:,:,:2] = 25\n", + "yaw_angles_yaw_front_viz[:, :, :2] = 25\n", "\n" ] }, @@ -549,7 +587,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3UAAADVCAYAAADw+tlTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAADIoklEQVR4nOz9ebAs25oXhv2+tTKrau99hju9e99ID3TTAhQ0IAXYISMIYSwxBO0BtQhkaBB2/2GBwUY2SH/YCock4/AA7ZACohFikLGbwTggHGiwRXQLOQTGDUgy4Ibuprvfe33fu/O955y9qypzrc9/fN9auXJlZlVW7drTOev33rlZuaZcmbtqffn7pkXMjIKCgoKCgoKCgoKCgoKHCXPXEygoKCgoKCgoKCgoKCg4HoXUFRQUFBQUFBQUFBQUPGAUUldQUFBQUFBQUFBQUPCAUUhdQUFBQUFBQUFBQUHBA0YhdQUFBQUFBQUFBQUFBQ8YhdQVFBQUFBQUFBQUFBQ8YBRSV1BwwyCiP0lE/4Z+/hVE9GN3NA8mou+4i2sXFBQUFBTcFxDRt6pMrO56LgUFp0IhdQUFJwQR/TARfUxEy7F6Zv5rzPxdtz2vgoKCgoKCuwYR/Z+I6E9kZb+SiD4koi/c1bwKCl4GFFJXUHAiENG3AvgVABjAb7zb2RQUFBQUFNw7/B4Av5aIfg0AENEKwB8D8PuY+d07nVlBwQNHIXUFBafDbwPw1wH8SQDfN9aAiH4VEX0tOf+lRPS3iegZEf15IvqziavmryKirxHR7yOi94joXSL6HUnfJRH974joZ4jom0T0R4noLKn/n2mfnyWif+mmbrqgoKCgoGAOmPlDAL8bwA8S0QWA/yWAnwDw64noG0T0KRH9p0T0CwGAiL6NiD4hIqPnf4yI3gvjEdG/T0S/Vz8/JaI/rnLv60T0bxCR1Tqr8vIDIvpJAL/+Vm+8oOAWUEhdQcHp8NsA/Bn9988S0Tu7GhPRAsD/DUIC3wDwfwHw38mafR7AUwBfAvA7Afw7RPS61v1BAD8PwC8G8B3a5n+hY/9zAP4VAL8GwHcC+G9e684KCgoKCgpOAGb+8wD+FkTmfb/++w8gsuptrfsz2vYfAfgMwC/R7v80gOdE9PP1/FcC+BH9/CcBtBB5+EsA/LcA/A+07n8I4Ddo+T8J4DfdyM0VFNwhCqkrKDgBiOi/AeBbAPw5Zv5RiObxt+zp9l8DUAH4PzJzw8x/EcD/O2vTAPhfaf1fAfAcwHcREUEE4f+EmT9i5mcA/i0Av1n7fS+AP8HM/19mfgHgX7/+XRYUFBQUFJwE/yMA/wxEvn2Vmf89Zn7GzBuIvPpuInqqbX8EwK8kos/r+V/Q828D8ATAf6FK1F8H4Pcy8wtmfg/AH0JfJv5hvdZHAP7Xt3GTBQW3iZL1p6DgNPg+AP8xM3+g5/9nLftDO/p8EcDXmZmTsq9mbT5k5jY5vwTwCMDnAJwD+FHhdwAAAmCTsX806ffTM++joKCgoKDgRsHM3ySiDwD8XXWR/DcB/PMQ2ea12VsAPoWQut8I4GsA/lMAPwzgtwJYA/hrzOyJ6FsA1ADeTWSiQSdTv4i+fC0yseClQyF1BQXXhMaxfS8AS0Tf0OIlgNeI6Lt3dH0XwJeIiBJi9xWIlW8fPgBwBeAXMvPXJ8b+SnL+c2aMWVBQUFBQcNv4LQC+BxIm8FOQkIOPIYpKQEjd/xZC6n4EwH8G4I9CSF1wvfwqgA2AtzJFaECRiQUvPYr7ZUHB9fHfBuAA/AJIfNsvBvDzAfw1SJzdFP5z7fe7iKgiou8B8MvmXJCZPSRj2B8iorcBgIi+RET/rDb5cwB+OxH9AiI6hwSjFxQUFBQU3Dc8hhCyDyEeKP9WWsnM/xCixPzvA/gRZv4MwDcB/PegpE4zZ/7HAP73RPSEiAwR/Vwi+pU6zJ8D8D8moi9rXPofuIX7Kii4VRRSV1BwfXwfJH7tZ5j5G+EfgH8bwL+ICYs4M28B/HchCVA+gQis/ztEuM3B7wfw4wD+OhF9BuD/CeC7dOz/AMAfBvBXtc1fPerOCgoKCgoKbhZ/GuIO+XUAfw+SRTrHj0DCEb6anBMkqUrAbwOw0DE+hsTehb3v/hiA/wjAf6F9/uJpb6Gg4O5B/XCegoKCuwQR/Q0Af5SZ/8TexgUFBQUFBQUFBQUolrqCgjsFEf1KIvq8ul9+H4BfBOA/vOt5FRQUFBQUFBQUPByURCkFBXeL74L4+l8A+EkAv0ljAwoKCgoKCgoKCgpmobhfFhQUFBQUFBQUFBQUPGAU98uCgoKCgoKCgoKCgoIHjAfhfvmULL+N+q6nUVBQUFBwC/hxbD5g5s/d9TweCoqMLCgoKHg1sEs+PghS9zZq/OHqW+56GgUFBQUFt4Df0P6Dn77rOTwkFBlZUFBQ8Gpgl3ws7pcFBQUFBQUFBQUFBQUPGIXUFRQUFBQUFBQUFBQUPGAUUldQUFBQUFBQUFBQUPCAUUhdQUFBQUFBQUFBQUHBA0YhdQUFBQUFBQUFBQUFBQ8YhdQVFBQUFBQUFBQUFBQ8YBRSV1BQUFBQUFBQUFBQ8IBRSF1BQUFBQUFBQUFBQcEDxoPYfLygoKCg4OGDaprXsL3ZeRQUFBQUFLxsKKSuoKCgoOBgzCZoBQUFBQUFBTeOQuoKCgoKXnEUglZQUFBQUPCwUUhdQUFBwUuCh0rOTPUw511QUFBQUHBboJp2hicUUldQUFBwS7jvpKuQq4KCgoKCgiHuu/wGCqkrKCgoOBr3bZG/S1JGdUmmXFBQUFBwf3HfZPapUUhdQUFBQYK7XvTvgpjdFSErlsGCgoKCgkNw1zL6GNyWrDsJqSOi1wD8uwD+cQAM4F8C8GMA/iyAbwXwUwC+l5k/JiIC8AMAfh2ASwC/nZn/1inmUVBQUJDirhb/2yQrt0XICgE7HkVGFhQUFHR4CMTsIcq8U1nqfgDAf8jMv4mIFgDOAfxrAP4TZv6DRPQHAPwBAL8fwK8F8J3675cD+CN6LCgoKNiJuxAEN7mw3zQhuw2h9BCE8z1AkZEFBQUvDe77un8fCNldeMBcm9QR0VMA/zSA3w4AzLwFsCWi7wHwq7TZnwLwwxCB9T0A/jQzM4C/TkSvEdEXmPnd686loOBlxn1fRG8DN7FQn2LhPeW8buLvfLPEtHwvd6HIyIKCh4+yzo3jVQgXuJt7PO6ap7DUfRuA9wH8CSL6bgA/CuD3AHgnEULfAPCOfv4SgK8m/b+mZT2BRUTfD+D7AeBzJfSv4B7jVV7s71obdl8I2Sm+A/edGAbc9d/8AaLIyIJXFq+yfLyveNnCA276fh6Sh9ApJEEF4JcC+N3M/DeI6AcgbiQRzMxExIcMysw/COAHAeA7aXVQ34KC+4JX+QX4vi/mxyzUp/p73jcSGED2dr+v5pavd0coMrKg4AbxKsvZU+ImZfZD9Ba5XfJ7mmudgtR9DcDXmPlv6PlfgAisbwaXESL6AoD3tP7rAL6S9P+ylhUUPEjM+eG/rOneb1uY3iYRu23SdxOE6jZIE5nyQrUHRUYWvLK4j4TrZZXH18V99xa5mfCLm/9+3uZv4Nqkjpm/QURfJaLvYuYfA/CrAfw9/fd9AP6gHv+SdvnLAH4XEf0QJPj70xIrUPCQYc/sXU9hFu67G8wxC98h93Q0uTuCGJ2CTN0kWSJbXmpuC0VGFrzKeCjy8VXAKd8B7kvYQo4btQjegWfJoe8Sp3LE/90A/oxm9fpJAL8DgAHw54jodwL4aQDfq23/CiRV849D0jX/jhPNoaDgTrD8XA0AYHd6D6i7WEQOwU1bgg4lNoeQlWPmfmqiddvuh/f9+/QSo8jIglcSNykfC66H68iDU8qum1Bg3qXi8i7DCk5C6pj57wD4J0eqfvVIWwbwL5/iugUF9wHV6uVNUnBXi9Ohi/xRBO0a90bm9gRGcW98+CgysuBVxVz5yM7f8EwK5uIUhOgm3x3uWibe51jwl/dttKDglrB8vBgtZ/9whdRtkpZdOHbxvu9axIKCgoJXAbl8PFQu3jcLn79n8zkFboKk3LZXyH15Z7lrFFJXUHBNrJ4se+fXWfTZ32+BcV8Jzn3TnM19Tvf97z2Gl/GlpqCg4GYwVz4eshaeUmF639bgu1xf75sczXFf3z9Oiet+HwupKyi4Js5ePwcw/DHOWZxv05p334TXKXBXi/x9eJY3MYc5Y5qZUuMhW6oLCgpOg1w+TpO68fVizpp0zFp4yvXzJte6+yBrCubhPig8C6krKLgm3voV/3XQ6hzQmABmDzCDnQO8BzMDzABY4gbiOcDeAQyAE6EQ6pgB9uEUAEtbaH/P3ede39AO4PiBO+EwaK9jxkPaJ7ler1l23Xys9BLe7Wi7G3MF2iFCdbaQnDHHuded92JyyrHu7rndN2VGQUHB3eH1X/hzUX3p28FtA0B/+8yAcypjvMg5lY1RXui/nhx0DlG+BJnJXl00WcVfKOfuWqncZMCn18jkKvsR2ZZg19p1Stky53rXmsMRYx86/qn6X0deXGe+1yVpdzHvQuoKCq4Bs1xg8fY78O/9TPwBs3MAkQoels/6jw20Tn+wZEBEYKkACND/9NuBRLgN2sg1iFKLVVIHSofoPujnuHAQgXr9+u06kjbSRg8c7hUYHyuZEzBTrrGfOO2EfiTQoUF8EVChnrWFc5F4d//kpYKTc/hsrNbF8bv5HKddHuu3dxHf88Cu87Jxvb79+tySNz62mTV2QUHBw8bq278DvLkCX30KALL2khGZQgSAAWPApOccZCI62QmStVc/hzpCXyZ2fcJ5kI2J3CRALiZtGSzyKq0nM7028dja3TtLlKCqoI3yKS3vyGSUMWP1qQzL6jgqa8frozLZixI4yr1AYAOxTuUeI5aP3/6JlI/3VGmajrlvM46bINDF/bKg4A6xfOct0KMLmMW3AE0LsJMjdIFMyUYK/eFyKM9/yFreWwjyRbC3SPBku3gNzpqPLB48IrBG5zfoeDhJoV1EItxD3iYdM7wQkFF5nAp70hcD7l4KCIAhoKoAGIDSOqPvGIGAm+4IBuk5I5SN3zd7IYNB+xw/O9c/Zw94B9/KsdNUe3DbDu8b00Ihfc77BMf0i8rId+FkhHXHC9LMMQsKCh4mzOe/DP70A+DJE1n3gnLMtdIgkpG+LBzIRvbd2hKIiZx06+WY7EuL8rHT8WOnmetess7xYP1UeeM5IYsJkfSdAlRZZqwDJKyAPUT3ZUJf0xuLve/JtkhMPXrXAiCeNSrP5GrpfPoyLpYRDcXCqJzPlKGJ8lQIY1+BOiCSPpF9Pm3rIxFl18a2O/8m2bzGy48nm6cgZkfL6JkopK6g4BqoX38C9863Au0G5J2QAiUSFBYoALLSIlp/ghsJDSxJvlu8mMHcd0WRuqwMSTnQleUpogfEcgdhnCChOXYKx6mxYvHE4pYu3rmQDuVjwjmdQyTFsWccc5dw7tUPCNsO8pRYPEUgymcyBkQmkkGqDEBV1AZbYyDCmgBjQMaK3jhJKc0ctLJKAL0Xwdi2gG9FIHoHblspd05cmFw7SBM+V9Cx94O01qEN5erLgRC0k9e6jsWwoKDgYYHqGu71z4NefxvYXEmGQiU0FJWNidyKss+DgqtlkJm69nXeGD6pSy1QvrNuuaRvyu56slkxoWDdJ2PkYy5rd8uYWVawyXnofVr9nI8dlu2E0MZ1N5d1E8rTuNZ3BYO6dJ6dMlQ9lJQUklpCo1w0BFbvpKgcDf2MieMwd4pVMkbmmdQP5i8nqlR18uy8T74jPnraRHff1idtXKdwje7ADjmm5NdRBPJIz5t9MrSQuoKCa6B+7QmuLt5Eu7mCcVuAGcaLBpLIwSjRolBmxM2SjGrZgktJWPeCZSkQw+Q8ei4GLR/ruX4ILpjdf0ODCYESF4ecIEIELad1KiB8XwATq5YubwdOrJQZYdVrUC5oAzwnAjYjdzO0uXJI+mVjTBGyqbHiY/MjmsI9QlHuubOUcjtBUvW6rPPgXptAGA1ggqCz8tlaUGUBswDZQAgtYCxgbU8AwnuJa3FONJ+uFUHnWvimEQuha4UgzrD+jRHBFIEUpu0iIZx8qXn5s5sVFLwqqB5fYP34bbjtGsBC5COLLDROYuzIyzpB8Oo04QEQqBrKRoryUuWj9kSUk4hMpPP8JyQ0QA88YqFT2RTkkro1kirVOmVqEgevFidK48Z7ytkQA8jdNZkBfR+IuIaCdZJ0Jv0nSeeUbJy6Riqb4/DjBLYjXPr0fduJe4bEQU6MFaM+/IQszOcFHcokHjaGxPoIqMJUlaZcqfVTyhiBUKp8Df969yTfhUj6vJO5Ba8aPReFaih3Ma9CrB/BSYkiCqkrKLgWqqeP8TX+VlwBWCy9ePcZITaGPAw5kTeQxYl0sQ/lUH96E+uFCBkoGST5ARv2UbNJCGXaJisn5oly369Hp62UOtLrURSegVR2Y+l/Y3wDonWSoBq72Dd0SALzEsFLaTnQE2bEuhi2rYznGjnPjpS78EQSHYSV75PLUAZ0gusQN6Ax0ggcblkc1fb2xxq49AwsjQywPh8P8JZ7wrB3HSBqQ2EsjLXihlrXgLWobAVUVSSLMUGOa+G3W6BtwK4FN1tw0wg51MQHY66i/XnuJ4DF/bKg4OWDPVviZ/kr2ADA0sEQoTby27ekMk9loYEeSRSFnczxEvfGPmkTZF8mC/fIxqhkBQ/lYTZG9HRkTkghidxEF89HStpiKB8AxLrQjYblQVYCiRxO1kEWayNFQpErWseUpUJCOZJPKTMuyNHgxpjJxCgvXP98TCbehMI13vMB5DK9Jobys+uTyEsEay+G+x/O8MwhY9TCaGAC+autWB+DojV431gbvW961kWP+F7CzoksDQTQtfBKCMXTpu3eX2Z6sRRSV1BwDZjzM3zyYoGvfwxYw/AMLGtZDCrDWFgPY+QzEVBZDwJQqUKpMl7etUnqrbYzgcxRtyARfBR6QVMYiSIAKDEMCzypUIgCQy12u4ji/vPpdrGOwnz6bUMRBUvdQKB1QpZ8i+C+AVPD2Eo0a+r7T4AsngmZY++EaKRHtwU1Te86A8G1R5BRuqhmc91L1rIxKTsXzV+mnQzXHQjDfruc/KUxijtdSNmBt82wHIDPhaStQLYCqlqI4MUjUFWDqhpsLALB56YBb9fgZgu/2YCbDahtouDOt57ILXKF1BUUvHygRY1nVwu8/wzYtozWA4uqk48AsKy8ykYhT5WV8zrITCOJTIzxsMQAQY7o5GOUbYmLInMnM4lS4gMQXHIufQx2y75dStRZClRgKOuCmjTKnLxv8LgxGj4XCCG6GLqoeEXvXJslylmj1lBtC6hnRqIs9a3KJCEW1DQJaUTnAgsMCGkuT3P5Feopla8T8jN3++S874gSdUqB2snLcXkaMUYGJz1wnPxzkH87lJaMfn1MFKSeNoEAGmOBegVD6m2jspfJdHfBHu6j97ELhdQVFBwJshbV+RleXDpcvQBWKwNrAHgSI5M1aJ2FU6OWHBneA9b2BVsIX6pUi2lCeRBehlFF4ifE0BhZ2G1ODAERfCoU4z/0FzmGj0IvCMFU6EWCqOWs1jgZo08QiXmgLZ1LEOPzTOqtD645arlUdxWj2srozsqJZU61YlTVoMVKLFLd6CKwXAtqt6IBaxvAtZPWvlHSl2slXW4ZzAjhHNKXCSpKCd9oHz23tvfceu6hJjxb27+X8PfSvkPC2MXDyd+WReC7Jt5DVDPEeTFQ1aB6AVMvYB4/BeoFaLEAiMDbrRC+7QZ+fQXerOPfNd6zkr5C7goKXh7Y5RLPXzisr4B1Y1BZRMLh2aD1GMhIQwzHIr+Avow0sSxY+zr5SOiUp4aUKIZwrUAGtZ01HPOPhLrg6GfDCkd9YhhJoESJRdkTwxAAIHraHKos7c4P8rQBMCSKmeIxkM5gscvbkHhvkK1BWEbyR8HiZEwnA4PcVO8Z9k7kp3dAVJ5msnAgX5P6CQXmQBk6R4k6pUANyOQq5UQsJ5YjVsB8zDGFato+KRiVsfHZZMSQ0/n0xuyZg0dRSF1BwZGgysKslvjoozX+9t9tcX6+AACsziwMAWdnBmdLEWSrJaEywHIhVrqKQhwB0Op7vfPABlbzm4jVL7h2V5ajAAsEMCd+QQhGzWJWHwhYFITgSAjDv0AcU4EXE0Em6wlFwSeuMswMz6zijiMZFDcap04n04QwHZPYw2rchQ1kToXlTrIHJXuM6L5J3sW2xB4wlVj96pUIL2v14bdAsxFXiGYNsO8sdLu0lGbCtTNzmaC8vieMcg3iuFZyiuwxBzdYHid6UqnzzbWTIQAlI6PGxr5xPpEgBmIYbt2L9W99CV5fJmPrPG0F1EvQYonqtTdBS3n2vN3AX72AX1+Cr17Iy0ce/1lQUPBgYc/PcHW5xY/9eItnG3ndXKxk4ThbiWwMMnK5IFgDrBYi42qVkUbJnnNy9B5YgyMR9AkBjLIxk4kp+Qvn4bOZkpdQJakSRKP5r2ywHFLnVWOMhB4QSR1n3iocZCNz33LYKw8Wv93ycdpi2D8PIO6UpLFvkJ/ZeVcOwHmQDy72QWGr49tKLEvGgkOMd7ie92Av8jR6zWgMdzpWz/1yQASzrOGZjBxTou5VoAZMhE4M5OvYGD5/tuNWvzC/zvXTdmVRfvYVqwGdG2mfvRH1rzGFQuoKCo6FMTDLGtRs8fb5FhvX4rPnHs+e1QCA5arCcik/3Hqhx0p+qHUt0icKsmVfoC1qkvg8qwm8QPAs2aC9FyIYBFYgfnMFW3i/F23lOOEbnAeBQn2BUxFFEhi0pZEQGkbYls+qwNNlMxLB4PvvdYFnHduSkjrTJ3NWN0ELJM5mFruc9JF3A8Hl1V+dUiJoLAwZYHUBunhNbmK7ATdrYP1cr2GHwiYEYudCKS/PhUOw8DFFQtWRs35fDn+w6N6aEbSEmHXaPdv7OyG4P+ZxB0GwZGOx50jaBla0OL0gYFVBkZI8AIzkPtYvwOsXfStfvYBZnaN68jro7S+CvQdfPof78JsoKCh4+KBFheZqg9eXLYxv8PyScbWtcLlhLFQmLpeyptcLWS+qSo4LPa8rgrXAakGoK1GKLlROLmvS0CWKTiXOyzLWOsCxkD+byUhjMFCSDpSeoW1YbmN9kIGh3CdtArEyvTGrTDYSCQkUrxuKpNCAozw3iYJUPonF0HOwHAaFakbuRkhhUJJ2ytH+uYlK0nHylypGg6z17MRFM4vPI3Zq+atA9QpYQlz4Q4KbZqNJujagzVXiDYROPlaB3O2w8qXtk1i/Ka+ZSYK2S5kaZOBkrF9GzKKMTNxfofIuuMRGOTlO3qI3zSBkoZC6goKTgOpxe7dZGJjVAp9++Cn+Xz/yDbz5zlO88bTCm6+f4ZNnLd77wKBeivWujoJLtZUq0Cold3WdnSv5qyqjwgs4W4pQO1sSVrpGNi1wtSFcboHKSp/wnt4JMp1vRvqCe2avTW71C/VT1r5E20mZYBsKuiAkxfpXm0D4lBTWgNGFv3FbtM7DasKYyijJowkLXm7ZS4TUtDZyhOx5B2q3Um4IdPYI5tFrEit2+VnnqhnIZBQ+Gdkz2XmugbSJ1SuP3buGEBoInwFh5P7187HHLHq5NU+Rk73copdqFjlrK1sjOfCLT8EvPtU5VcDyTN1+CgoKHjqoqnD56Wf4iX/wDD/xNY/HjyzefvsCb54ZbBqDb3zYgo0oQRcqGztZGWSiHisTCd+YnCQCFrUoQpe1yMrVglBbkTGtA1pHWDdA03ZuJ4fISwCjMjPKugnrX04MY1x71o7AA7kZZGsgfkFeWsMgQyrHJfaOgWj1i94z7EHIlKR6DAlnpuSpyWSlYTfDytc/B3ug3eq5KIFpsQRW56Anb8ldBw+ZzSVSt8yhbBxXjvbj/naTus6Vc4aL5x630GjlA3rlk6ETY/MIXTMXzzxR2q59fVMUUlfwSmGKoB03mAS0+tZhfbnB++9f4v33gbPHLd56vcLP+8oF/sHXwlYG4aVajpkSprO+RIQXW48WQKPCCABq/dVaS1jUwOMzxjtPgWdXQu7iWhY1QjqivtjHeu6sfMFNxFO/TdyqLAgw7p+HhBdMnLh9aCr7MCbLeSCCDNYkVD4dKsZwGTAenVWw8PCaocoHzSf3CUO4ZiAtnkK9LoyJGyEygRqtWtT/20Sp7RzYvYD3DrRYwTx9C/7j9wBN1iL34vt98wcVvXBcf+zYzkN563gdOksYmyAo9FlkFjOJfQjuk9n8BmNMELTwnL0fCpWJuLdOoxi2MAjzyayDY2OEL6DGF/Dzz1BQUPCSgCQ75OZqi8sXDpcvgE+ey/rw1ufO8ZW3F/jkuceHnzqYXCgquvWme13l+PIs60dYcto2kDw5TwmbNcDZirCqgTceM6whfPxCFKPAUF6Syja9BFxG+sIWoGFs6RPKVKZwXwka5EQgiCGOL+rayHc6tJjsRMfwffkVQyEIALiXPEY8ZwjGGFSVxcJW2Gxdt3VtdP4IDDKch/VYz+Majoh0yU7PA6I+MT4DlzXQjI+8FTdNAGQq0GIJWj0CvIN/8YlaAXUemcUsysy4RY5JLtzJ797NZfKze8Xyo+3Im/0y12Zfmin5C9uRxXweCjJ9D5dBnF7+4CdQSF3BreCkZOqOYVQ7aGoC5TFKoQ0RGDRC1vrITeyT1xwZh9Ffx04RjTRzOidBFCiZBYgBOKcZE92w3+hYubtjb7y+K8Qx4O0atDzvB40fgj3fgzvDjucWMVOY7LxMIMG7roP5v4eCgoKHhU6xKWuBxMjx7N88e8Zg77NQl5XziFh2HrjcyL8XGyF2bz8BvvahkreME9hMJ0VRKZrJK04Jno7FwRIn5x0HYZ1LIHfJIAAcDCwy5hU4SiB+6Fcj4znMBAfEGDMCY20cHp1V2Gx0iyXuE8Qgi4Os5Ki0VPIZYuZ8QqxSJW1ynuij4/V77SMBdlH+sG/B61YsclUN8+Qt+GcfDf6Qk0pU+E5OuYxtTpC2OeRutkI1ILtmJHdJuygLZypY41hB4b7Hk6WQujvEy0R0HgoCITsZvLiHnD85x5tvX+CNpxVee+0cH33W4id+1qFeimtJ7nYZXEwWmdtllbiThHMicSdZLQmLSuLu6kr+tQ5YN4QPPgNA4npyiDtJ9N/P4wYm3C+nkrEc4n7ZuZ4gbutgiGS/bCJYQzDwWG+bKOAG8QJZcPggeDwxR+Z10aUjz8I5OHqADGh1AVqcgVP3S0WewXNAjnL3y7x8hp/8rP1+APQyac7FVHrnFNcgc/Eye8hcQUHBSwgGYAzOLpZYnTs8uajwubfP8ejcwpPFNz5o0cJieWajjAzulrvcL63ty8nunOK5UXfMWpOw1BWwqlUvx8B6S/j6h0lMeiY3czfLoftldx77xBCDMEZuqeuXdzKxXz7WZh/37Xu89GX0qjbQlIrXUm7eCkKWUaIYTz7IERIJ3IiCNTKuI5SvxyKLex/FiOdKf4wJBeuBStVC6k6IV5GknZwk3TKoPj5+hyoD3zZYnK3wS37x53DV1vjosxafvE8Aapw9WkySuBAUvqg189eSYiyAZASTxCnGUvfOzoStAxoPXF4lwigJHAemYwHGCNyuJCrAOHlLz1OBE7OEaRB4l2ZaY+YIGhvQqRhDqmhmBnsP7xmulVg6C6Ci42Lp0sQpe33+03oyujH3AqZaSPKW9Qv4F+9pZk2f9fW9MWalcQay7Je7YwByDLSDu9rMzQgWMOHPL12m5jMhpEbK9+4NVLY0KCh4acBtA1sv8KUvP8XZa4RnLzzWzuLDDxiLZQVaVDiPZE7j5GJSsaHCs6pELi4XEmteV9AEYyI3q4pk/2fqlp/GAd4TGgesde9ta6XNYtGXo0BCxPbE0kW3SJMQqUwJGhWYe2LqUlKXJycbkruQlVOsN10WzkAwKZYDYklj12C96ZSkXbxedswUoINEKuyQ7wk4OPpxJepAwZnIGDIVqF6AqgXALFY61w6yRg/2qQsYy6R5m5iaV4p9sm2PTJ6LQupOCHtm9zd6yfBQSN0pCHd+r2ZFINPi7I3XsHnf4XxV4fxzwHIpWxpcnJvRrJaV6Xz+Q7pmkBpaNFUzQ8rDfnaWeEDaplIx7yNgqcAJi3vYPog0XXPYCy9sZRAJmWrQqmxMdTrRtS3JzgU9MoQg8e697sJ5zHaZkbU52S6BjLiNZPCCbmxOpkLI1CU+rA7YrsGbT4HNFQAGeXkWIjh27GEX2ug9S/kEyUvqD7LEpedAv92Osbq2/bEG5C1Lu9yfz/R1e+VT10zvIa2rFzDnj0DnsrF589P/EAUvJ+asw9wUYv+ygLctnrz1Gn7muYNni4sL4I2lkrfawCghM0YUmnJUWakEztqgDNQlWpcQkZscve2kXPeQMyLTDAE1RrxHDE8mM8mtZ3m2yzEL2i5vFGnDAAWPFt36gPpkL2wZJBusU1SOBnQx69zJVwZA8sLAmg0TTpWkSb+KWtQGMBlZ67Y6GCdxxEN5atIEKFldWj7IiulbkbvGitytFp3cbTbA5gr82YcAe5hc5uVK07GtEGZnvdzdridDp2RxQFY+ULiOJV0JmPKSOUQ2j6CQuhPiNghOsQaeFtd5nmYJwG/x1hsL/OJ/DFitJDNVXcv2AyGAOb5HM0DkdUsCKaysZIK0xJB9PscJmk0JWLR4+WTfHCVeSDWPwhYNaX1oF28+IViBgKVplIMbRCBqvmvHMfFHp3Uj9cg/ZKNVOe8vUsT+OPIGdASOvZA1kmBxGAtgofvpqABot0C7BbdbsGtAcfNUdVEZEDafZNs6UHBov12kax+Jm7S+BfSE0B5BccBmqYP5HULismuxrUHLFczyDLQ8A6paM4s+h//gm/DpPncFLx3ytdy3wxeUfWtyIX0PB+7yCufnNX7+t9V4sZXtB5Z1cJWUpSFsOh5kZdh7juDhWWPFGDBePUtU/lUGs8ICgI6QpeROFJQZ4YIQwlSudsrNjsRJWegXLHDUc59M5xO2JSAkchXokRIOspY75Wh4DjJYLifD/PpyNb82sU+yV84nb2l9SuB2kjdNjANjZT9YjcUjU8k9s4/71nGzFjKXELLBfq55RuhdGS6vQ95SpERul2UQM2TiqJyfkMFzSdweS2QhdSdE9WSepW6XUHoVSdsUbpTM2ePHNtqXKoC3V1guCWfnQtA8AyAne8wZRq2be9dWCZgVjVwVXShEMITzzjIWNHeBAHUCKfic94kYomXMsAeDQUFbFxZd1184CXw0AZtq1x+/v6juEjppOwCDfXOi4AAAY0STZySNNciAjBHCFhfhFux0ewLXgL0DtS3g24GgGGwlMCU4nDteYOyzviVls8hbb8xkPTlUy7fPCpdeL05zN3GEMaB6AVRLoF6AFiugrkFkwM0WvLmCu3wB//EHQLMdH6PgpUTu7m5mpHfKiV+x9j0cuM0Gjy8IVw44r3TD8JBdEF5CDAyjskBtg7u+EggTlJQcLVjdXqgiN60MlFjgfI+IBdkYvjGB5IFShSVHmSrIX8Q7xaacalsxkKmcy0iJYv/G4MPyXZuIp/X5NQb9U/fGCdKWu0yOWt2IZCwy0coIsiCymghEnzh7VXy28s7RbMC+VRncecz03gd2Wd6AvZuQR6QEbKYsDpjjEXOoTO76DeX8seSt7FN3B6jP+6QupGMfYHkLkzkA5hoE577i2Cx6ZM3+RgFGfEHefLzFxZKxME592oNFzYPUFdHAiQBgD4ClHOiIRVjg1IXCjCQEiQvukYRrjGwdQrSGYxFEmFG/r/6HoCpNTsoRK1Wzh06WEkH+xyI4jAHsQpo7eW5wLdh7ceVoPLjdAt4JMWPXCQHvEpdJP2F5GxcCO4nbdUhbUj7qMhlwTdfJXts9gmGO9W0gTIhAVQ1aLoS8WXWlqSULAbcteLsBmi14s4Z/9gn8Zt3/LpVYulcS9kwzvwXSpXFTYxa7gH3E7xhrX0AhfzcL3jZ4vNpgVQGenZK24DnSkTtA/s4iVoREiexktW6pUjOuIb4jZMHzAiKXmLmnuJTy/eRpWhbuJ1NjRCq9t+6BzB8r7zNVvy9ZF7FX5aeQs3TrnkjWDMkR4ajwQtTYtSJHXSsymF0ni1vdRymXp9HjZYKw7SBic5Wn3SPy+2Vxek9J+U6XyaxsDmmTvsNrHkrapua1DycjdURkAfx/AHydmX8DEX0bgB8C8CaAHwXwW5l5S0RLAH8awD8B4EMA/wIz/9Sp5nGXqM8l02F5Qbl9XDcV+rHEltwGF/QJamphuQF7hnWd1stkGrLo7hDcRNLzSIBIX2TUlYFoaAkjkX1EqiEDqQDp+mhr5NrKyKLUiZ/SsqxJJGzpIhUVmqweIUK4OG6Cw9kir4KXE0HMwZLIXZn3XZ1rEPYuA9DT8qWCIj6XXW6RN+mOsSO+rTdmwA27YxzvMgnAWlBVA7YSDWxVg6oKsDWoqhHzprkW3Dbg7Qa+2YIvL8HNBtxsB88jv6+Dk628RCgyMiF1VfaimhCzAdHaQ/yOsfbF6xar343CXW3wyD7DxjWA34KZYXOrUOYSuEtJ2ZEnqOxSpaLKRMOdkhHoxGAnPzuFYk+mqTzt+hH6L91BviKO35OzPFKXzKOTxxwNW+G060aqiKRe11w0h00NBmQuvZlePwNyTomPyjDfikxwjSorxQuFgjdKJt96St4YY77HwjWHqE3Ix6Ota0nZLLK28xo8Wyb3+kyNlc89v368htaTBpRCj7YCGQveE6JwSkvd7wHw9wE80fP/DYA/xMw/RER/FMDvBPBH9PgxM38HEf1mbfcvnHAed4YnX3wyWj4nW520uxvhMWlRfAVwXSvlYkl455MfA2+vZF8YEhJFunKHpBxxhY1/45QkJYQmEhtt4x2Cn33n9tG14bRvTqI8J+UT7Xyq8cRwkQ3Y9x1mxuBJTo7V3fvY0+foVorBgjv4Lc0lWclYk4t6Nu+dsWFzF/dszLH6uRq52bFrRBLLYC1AlZC1hcY3GCPCwWq5xhiylwxpcA7cNPCuBZ4/B7tWyJprwe14iuhpojb8++9b4+aulQ8Ur7yMPH9rBaD7HgTZw84PygJYz3Ni1pGtIenLiVjwoZkid9zs+N5pGMAua+IcvIrk0D1/gbfe/7sACNhcdrKQKNKfnbIRQFQQclLfW/cTeRmJRtYuKhaBpEEiexHruVeP/trdm0PaLpOj+bWiPE/vY8aYx2BsDc3l8y6LV1o+RaZ0zNHr7SFVg2vtvN4eOXuI98dMd8Y5oQc7xyBl7SEkxBgwJEQkyGAyRrZrMCqDrUUI5ox833tRVrcN2Ill1Ddb8Ho9Ou+Ak5A6IvoygF8P4N8E8D8lse/+MwB+izb5UwD+dYjA+h79DAB/AcC/TUTEYzm0HxjO37wAMPxD7zWrjuC6BO+midpL/vI1G9WqAn3tH0gq3raRBc2Fowf7NhMcij0uE/sWk7E2k2PF4h1/s30/vxmkbh9mf2dSwjOTgHWnBxCxkTajY4w8z9m/6Rl/x/5YIQrfgKxNhECnsQvCgaz8Y1Dc5FSuweBW4hrC0btWsno2DdC24k7j2kQAD5/NIWRtX79j+rxMKDJSsHy8ANDJJ6+KAnbcEbwRwjdWHsIYAunrWfsyS2AgZFYtc4daA4F5FsFdYxwSL/+yEEC/bUCffAD++D1VULJ6XTA4nu9ZI8fWhpmE56j3lFP+zG7zPekYGXzos58hCw+1bo2OcQIC1l1frbe9pAUGzCQbgYfUqkD/nCR1DpGJqVfJGIkNBwBrYYiya7G6Wqr103v5njsHVnkcZbN6IkXyphbsY+VuwKksdX8YwP8cwGM9fxPAJ8wcdur9GoAv6ecvAfgqADBzS0SfavsPTjSXO8PZO2+i+vyXRciwF2GkFhZmFradaJ2iOxd3GZFiH6Brq59lv5GgceLJNp1lB+NaoIkf/3WI2k28lN0kcTzVfKtVDf7gPRkzT1sPTFqQunkcZ6WZ02fkYjOaHPhcDvgbHfROOjHu5PwmiewBBOOAZ8/QxZ9kUyQydScMjFVvmk44BI0dAgEL52R6c5eU1N3LD3svgsCLUEC7Va2dE3Lm3V5ytu957Hwms8a8BmF7+DxlLv4wiozE6ukZgI7MuaYjbKFsQO6aifKM9AWwTwiiHgeWujNtm5EnmrQGYi/xC9a+OQm+9ln9XqaEae7dr4LXl+Dnn/bK5e8YTBOpuyP1DtNLxMgzOta6tftCaaOZxXPa5UTmwGsegfG1WJ99+DvEQxd7x9ELCfEoZdoujaH3yNoGMiVtWbdpooRkcegT+xl1geU+GdN/kXxx6JfkQhjEKwJgho/v215cSOM7uJY7lbfsxD2VPbhN3VZ9R9jCZzf13nF6eXpriVKI6DcAeI+Zf5SIftV1x0vG/X4A3w8An3sg+VzOv+M7wZsr+OZS/WFZzKwMAKIZ6H05GRoBxb0vPShsOE36HU/qUiQ/nOjll/yAuh9iYtOlzukh/jjnLGYHvuxPBqkGN4j4kZMvKw/7jLlNRBIr/0mvxaFPz2UjkOU0TX//X0eqXd9tMdQlY3XlgF0t4J4/6z+jXUkmpn6w17WUjV1rf4cDmh4uWI4m5TOu1dO+mU67Fhb7mIy6UhIVXSJUAITfQfw9Jtq4dIw0aLy7urgiJjEKceFX7bMLiVt809fcsX5umy6+YfDcjiNm/TbXs4xdRyid1Gr7EqDIyA5nr58DAHwrf/92I5yWvY9lY4QvLc/JXfguBQLnElfK61j7APQsfqew9kk/Pzuz83VdPu8Drn7iJ1B9+duAc/mOdmInU0jvUoDeB+UPzfubTbfvzils/HqNMU6D/jsXp+EYg/ew9DPHduH9yIc2JqlPXTTzsJGeQSL8hl1S77u67F2tM5gk9fmdnTDs6SSeJnu+w6ea7ykkwT8F4DcS0a8DsILEC/wAgNeIqFJN5JcBfF3bfx3AVwB8jYgqAE8hweD9iTP/IIAfBIDvpNU9+EXvR/2FL8O/9zPgpeoFJ+J9hskLArna4WOcc6NDTd4jbSbHGjbYUTXeN1BH9hMaICKJQYsd+lqglIiGe+mR1rSf1SmapD7V9IR2UROkpFk3oO76kFwrlIe26Zx7pJzhPnwPrD+jo9wMuorx8n39cMAL8gHEbKdlcHQOB/xEjQWdnUtSDiVTqYtDSs5CWT4d/cVkGjTuFvgQ8B2EjWchWcEVNmrufK+sF0yeC4sTEutTCJI5Y500nnfmi9W1COHLiSIjFY9/0XeDFgv4RlyR3NWVJNxZX8Gt1+DtFu2LK4B9QuoC2dtN+kI71/hBWYzLm+niGeAdT1r7chfPgJ3WPgCo7CziB9zO3rc3jat33wPefW9y/bhNBU/qpn7agU/3d7pu0reHhJPJgyNI/zHfu0Pne8g1TuY9dt0BmPlfBfCvAoBqIf8VZv4XiejPA/hNkOxe3wfgL2mXv6zn/7nW/9WXIVbAnK3QfOs/Bvq2ny8pXoH4ok7x5VFeEim6YfZfHilmHVJ/c6BLde+TYy/IV/zT4wtnL5B1QvM1Fd+1y596UDfxZR1Y5naMGbvsbzM6VixO73mcSA/a9q7BiJtpj9wz5/GJyfWq80pSuQODVMNj+4dR5Pv5mOMLeRiDLCbvP9lOXPscsJAcSyaPSIJh3voC7OtvAQDcpx/BX73oWbFYtXnc+84fTqwOmdPcNl3bm7j+DRDoA5fUm4jzvY3Y4YeAIiMFZrXE+bd/C/z7XwPTFlhZ8MUFqHoNPrjiVTWYJZGAbxpwu4W7ugLaBv5qDW4btC8u5TzG4ynJ24rVz7duLyEM37u83Vj5PkIYMGkNjPVavivTp8K34+TjIcbaffyP3u+dH/ubPyXZuU6CtOvM4xhSed37Pqb/TRDLGyPUt4i78DA59Pdykz4bvx/ADxHRvwHgbwP441r+xwH8+0T04wA+AvCbb3AOt4b6ySNcXryD7eYKxBsAgPUiZAwcxNFSjqZmLdcXfXUlE99fLxs8MotxSP0qQwrf6GOsGKTODeXMQBxfCxPzN3puhFLeWc5CXUI6e7F63J2PWjUS8tkjWZwQ03SuEyQzYE+SkV7/3MKZk7ssu9NYtqdDMyx2aY372mEau07oMjMwmHYl+siJYiSA/f0Sp8aWMSYW75RMjswfxg7Gim7tUxbhZx/DNRtQvYBZrIA33xY/9u0W3G4lTX6zBTUNfLOJgcP965qd1zgE861qp7TQ3YDm7gbcHU9NRl8F8nYEXikZuXz7TdBqBfO5zwNbzeC2FQWo2W5lb8N2C25EblLbAlUFWwM4Owc/fgTYGkwEspUqgRhufSUZWy+vlASu4a4uAefgm47opceOvIXyjJAlrp55n33un4dYA/PYv4Dc2hcwZR0cw31x3dw8252tby5OSQquQ1pumxBe974PueYh93YK4vcyEL37hpOSOmb+YQA/rJ9/EsAvG2mzBvDPn/K69wHmfIXn5jW4xWtALULAkgNz2HhaLHEMwHALZtlgmZlhWDec5i4DTr5nS76/2WBD6WzPF9nTpU82OsdGJYLxR6mkMhBIhJT8/X7oomC1jrqxorckdfPq/ea1DWPkJTQnOEL+du1jJu1cd2/Bwukk4xDCPmeagajb56xPzMhl5T7ZkHsPIcwRiA+NEETqGo2PHap9NkYy9hQRjGQulO9xxe0RxbnkEoHEZeQ02dwnEj/TJ5XxGq4Bv/i0P4axQFXJZta2Bp1dgB7XqMKm1jEGTfdGaxvR0m838fMuS14qePJ7zYXSpCuxCp7b0tKdImatG2venO/MonhE24eMV1lGVq89hvv8twHsYMLvtlkDvoVZX8r+S20LrC8BcCR83DZy3G4BOPitnjetuNkzg5Y1/OICVL0O2a5atu5g78DOiZWv2cKvJQOsW1+Bt1v4jShgd5G+XYRvrM8c0jcn2UuKqRjAXZgihofgFJbBdj2+FcrhmD/OTVr1DrkbuuaWScDtkLpwj3Pu7dhnO34fh3037ptr6nW3xJqDQzPZP4zo6gcAs1jg2eYM738GtLqI19bDEFBZDwOgMh6GCIY8iIDKsISEEUu2cmJYUoJFwZqnL9Xkldx4MdahO++ODIIQR0rcPQMROmSTz965jgtg0kqW98EE+UzHyPt29YmFMf5mqLPSxKIaFMiotpEwOLV0GiNEKOkXXGHZt4D3IBeyHDUdGQzZBCPx0uPUBtdx7KGVkCYI4dR+MOF286BxGkmqsYsApmN3hHKoKaYpArjPCjhC/uYQPwDgnEwFshbOk+vrAGCjxK+qgXqB6uwCVNdgW2lcJMCNWPq43Yr1r9mCm038u9FESvJ4b3tIXm/bgB3kcaxvPsa1CGJmGR7DXZC5QuIKdqG6uMD2/DU0l89E5hFQVQwy5zCLc5jHHjC220Baf7u0uQS7FrS5BFwLs74CANk/EYHsAaZpAIiljxtZT3zTihxggJY1eHkBVAuArKwfgVxtxVPAXa2BZquxflu49VVHIjNSN8fKN1W+z8oXsM/Vc6xtgF306w95OYyk8QQxfW57KlJ3OMhe3xLkmt31O1/s9/Qdw5C4XE+ZOId4hL/QHBJ6LMkkc/x93AR5OgVB9O3+NreNQupOhOrxBZ5fVWjazu7UgOHE+AXnAWsYnoXEeO5ediv9sltiGMPxMwAY6uoIgNW2xog1zRopN+EY+hnAgjWnB4OI1N0z0D50fplK/IIlsbOQhR+hpn9l0YGyEsRwLkNNEMIR4jhpbcwXrz1kM20X2wRLJySLJXm1fqb1KekzC9H2LhCTcki+FROfCzvZV4TaBpJWvpEx2wY9y2GM13Pd+QSp22cNpJz8JX0nXUsnrIJ5HGEkjuwHVkcaIX4yHy2PRML2r2mnid8wqU9/MR2QPvYDax+8AxoHbtb9ewp9PANVDaoXQv5WZ6DHT2Wj7aoG2MvGndtN8m8tL40HCM2OAO6OY5xLEMcIU+h7HeJz29bFuShk7tVF9fQRXizegLNPYfwG7D1suwazR91uUDn5bVv9jRsiYLGEqSqQrUCuBRnbyYFmKwq4tZA+bNZyvrmMLpy8FUtcPG8bAGv4bQtsEckfPICqhlka0KPH4NeeyrphLTxLUiy/Ee8Af3kp1r6rKyGCl1eqKBwnfV15WA/9ZJKXuda+uOH6CFGb+o1NkbrRtOz1aNMH9/udSjl/SrgdnPUoUnmiPYaj9e2Avxm5OUSn/0yPJVyHWDGnyNNNuG/eN2vgoSik7kQwZ0u8++4L/Ojf3+JFK4/1/KxCZYHVmUFlgLOVkfOlgTVAXcsX0hoLx9CEigSnikrn9MhAWBu6Y0fe0vNQb4hjWVDsB6IYy9GdB4shATA2EETE8kAiDWnbsE0XZdYgcPcvkCJGJIxQsshqXWROyFq0TmYkLh59r11q/Yv34kVIB2tkjGvkzK01d3P13dEEt85AsMgAdQVTL3v7jsWkmJqwhhux8nErLxvkmsTqqHPN3T0H7ph9q2DP0pdb9WbGC067bfqR649bA6diA3du47DHCjhon8wvL5u3aSoDbgO4DfiKO/uvV81KVYMWS1C1AJ0/Ai1XgLUS17dZw1+9AF9dCtkDNDVzHwPLZiR5Ey6noZ8Zvw8ydseL0m7L4mjGtdySPpN87npZu68EseBhwayWeH/7Bj58xlhVDtYQVrUXWbhyMGjhmGG5gfcelsUCV6m5o1bSV+kaX7UbkDGwLGTPsouWPnKieCNV3JjtlSiG1peyVgXPALXyhfPo6hnIXtvANw1AAC8YOF8AT5aa0IVAVQ1WeeDbBmhbuPVa+q070sfNNsb3sfOJy6b8plLCB0wncMnb9eoyItjV715vU7I3tQ7sTel+ABE51J2sm8NpCeWx83goOOr+juiTWzJnk7wjrJgB1AsdunnchpvlqVBI3YlgFwts12s8rrdYrw2evfB4/pk83sVK1F6Lhbz41XqM5xXBGmCxMFgt5fNyoWU1YVnFLXBARjefZ0Lr5HfhnHzJ1fgk8zEYkrqcCNJ4/Vh5jO0LY6DfJlgUjcbWRfJHkvjFBOIIAhkGGYKl4I4aFpLuKGF1ffIH9vIuHy1SHRnsCKo8awslc0bJHWfkLiN1JiF/Ps08io7wyaaUDPJ5dlMXN5ymegEsVx3p814TgIigR54ZNZC8QCACObL600w3NN8X45dZ8KZdPzXuMdn4mnOCEKyk8Q8cCFnWjpIxs+QqyAhD50mr5eEaWYIV9qYbIzynPDFLRpLIZxq7xNWDQ2PXgq9awD/rO/xaC1qsQAtJ4kDLlSRZePEM/sUzifVRS3XuApxb+fa5co4RpCliNUWmdloBZ7hmjuEU1sFToBDHlxdmucDzdYX3nwFLFWjLSv7etbVY1haVAVZVDWsIi0qThlEL7xlt1cB7huUtmBlVPU72rN/CegKohq0JtDQwZ49AwbWTjJI+LzF9zgGbK8C3oM0VwCxWQABoG4n/Q27t80L8mnUsN00jngFkgFUNnC2BWslfcPVkwG828BuRB2696WL92qZz9XS5la9/3t++Ydwjomvb75PXB6RuoTn29U3HmELoYyatgAd4TBxJyNL52WtaZO5qrbzvZHRqfqckRrfx7FM5e9+feYpC6k4Eqix4u8WHHzzDp88tnjyyePIUuLzyeLZxeH7psVjI466XesxIXl1ZVGq9q9SX3eoPoaqkvK5JBN+CURmgXhAWFlgtwvscYduKu2fTEjSkAABg9EsarHkULXfQY07mtB9xzKmSk7p4rm/hJhLC8XaEbizN9xkJYbyuxsYZY5QYorfHdHA5JQLSDJ7OMxpVGzmdjyWNYwjzCxY8ykheUh+IYLTmmSBQtZz6hDCwEmYvFrom6c8sbj3VArR6BBgLdo24CG03AAXSNmHRS1/SB+6d4UEG8hbOI+MZbRcT6BD3CV7SJwrY6EqZkbzg2hmtqjYheOG6MmZO0ALJyhO7sH5RyaBH8FIM/fJNbx6xXdov68PZFhBwDnz1Arh6Af70QxEY1oLOHsG+9iZo+WX49SX8Jx+AQzxP+Dtl2TinyVxGcEfi8w4hgr17HSNkE+TuqLFO0LegwFQVXqwJz6+ArZK6dZBrFWPZqhy08v1aWqfn4tmyqCpYQ1jaMxhD8CQJxzy38N7DsJC+qm5QqeKtcnrUc+u2AOuSQBVsfQZaGtD54z7pU1d7atbA5grsnBA+13ZbFkVrXkr2OisfN21M8IQNwK263jBgyABnC9jVAtD9Oqla6M+VxTrYtury2Uo24EZJYJIhlJ2bdOHc79o5JIN53658nrXP7mgzNVZXvtuVrvdiPfHmundbnXr3HHZhQCSPICmnIAdTZLSsu6fFfX2e+9xDC6k7FYyBc1t8/MELfO1Deeir8zM8vjD4/DvneP2c8NX3t5KLQ/28nav0KF+etvao2iDkZHkMJC+2aWXsq43Ry+piqgtMXQGLSpSEZ0vg8QpoHeHTS0DlQHxPN/ri11n3AunTayXkLhJDH4iYkjUfbn+K7El9cAE0hkesfNRr60J9tPCMWxA76xxgjRF3nlWFzdbBqdY2bmCOcG9a4PvlIXkHs4l1efb83H3bcyAnSowCyVMwGY3p8/DcAu1Wzm0FqpcwF0/Bl8/Am0sQhxdmTecd/kiBkHk3kigme3HPSV6YzmCrgfjH7MhP5G57SN6AxCTkJBA8HZNzAhZInsleJgKZS+P2QtnAEtafV7fAZW6GSb84n6xPfv0eMWMPfv4p3PNPpez8Eaq3vgB2Du03vzqMMZy51cIY8Znr3nhKN8jiUllwqzAGZAkLy/jcY2C9JXx2JbIJUAVkFWSYfDe3tk/yuqOSPUMwBCyV7C2sg6kITB4t1LqnRM94ia2bInvBU8O6LQAWTw4yMIszmGohSh4GyFQgr5k7t+Jmz1sle9u1kj4VtBMunbZthbTBi/LONdE1E23wHGGgqmCMAc5q8PkSVFVgWDmGtd97+I0kmvLNtrP+tVvwtgG3bfT2GJK+IQmcsvrlRDBgyjo4Xhf6DrfDGbtWDjPSfq9b6OSLeScvZhOtat+YY9fvz88eQAQPtkZOjH3bVqb7SoZeFux7voXUnRIecM7BBc+NusHHn4hl4Nu/soSBR9MyjJrArPrHt8HyQ4DXxdqZ4J4XBs+1WFIfLHhIHMqaFti0hGdXwLIG3n7KWFTA5SazBEwqxsKLPSfnuqjHd+i+C13oE+sDaQo8IykPAqnLehmsLX03PYO8nR+tZ88xGHjbOjw+r3F11Y9JC/fi2Wb3FmYfLE8crXoBk+TO9y11cYxgCdWkLDJuLJR+m0vw5grm0WvinqkWxkCmIkEKF0v2HewmFGY4IdgigQ0kLjRPyF0gXnsWigEJyB9KahHS6+ZkKhlMD9Pkbi9ZykjnrNgwOoLcaT1fPkd7+Rzmjbdhnr4B//EH4xfZMUZ/+nNi2Q5zyxwf5Dh3zFOjCPoCkIH3wLsfAk8uGI9WwCcvVN5VElIAiJcJALTBS0WPC5WblX7/ayV9V43vnVemRW1IiV4FYwh1fQ4C4ODgvYfjLbxnIWhIyF6lFr1A8vwWRtdm67YSp+eCBwcB1QpmsRTSBxI38ZCYSy17CGRvo3F9TQPTdpY2ANHFM3ho+CY91+zMzaZzywztWiex7koA6XyJ6vxM3PetlThilZPeed0OZgt2re4P2krSqOD6eQABTDFGBoeZPOcRQjtRPz7GAda9iWubKq+bp+ias6b5WYlHxsek3beW9Nk9311E8lg31l24KzVhkTGCQupOBQZsXePiyQXON8Djc4u33jrH08cWDhbf+KiFWdQ4WwC1umGGmLqq7qxygaTlx84Ns++WGRKWLBeEyiLG352tgMqIK+aLLbBugFpdD/KkK1Mxd2kmzeh+GbNy6vlEjF2ejKVL1uI7Sxv123TX8FnfcI2JfkZcOq0hnNUW7baJyVbysQz1yZ7J9/dLMnoOkqgEchmzcnKv78CFUl1D8/HlgwEtz0WIura/5UPabmzBzpOq3MILe77Fwk4cu7juutc9uBUf+7MLmIvHaL/59elGJ91K4DD3pfHGh7pATc/rmD7HjlnwkoHFCmQM4fNvAJsWeLEGKn0DkSRh8jlY7/IlMJR3HiWBxPW9QypTR6+OmFnadNY+IXtyrGuJ9d6yE5JXtXDeS/ZkABYuuupHoqfx2cHaF5NxhSRdvgVAMPW5uHTCxyPIgnwDahpx6WzWYN/CtFshcI1YFHOSF1w8Y4x14vIZCF6fEDrAbYH2St0+IZkgrQUvLKhagnEGshZsLMhWABlwUHw5CSXw240m/xKrH6s1MBDAadKXJLuaSL41hxjm54ckfZnTfqpsd/lwzdq3Bu6zls2TB1Nr5e4kXbtwqBVvztiniJkc9J0zzwPdYV9WC2YhdScCOwe7WOA7vuN1fP7LFs+vPBpn8e4nHnZRw65qrJYqhJSoRVKXELiUvEWypglTrAUWVhRwdQVURoJPvZf36NaJPa31wLN1SrCA89X+xClTxI2IJ5OqjJG29HyMuO0jbd32DOjH0hF0+wZo5k2JTwjbLHj2aLaNBNEH66eSu5g4xe9PnDInQyaQErV+ebe3nAMFd0oykiLbnIGqBdBu4bdXwOZKE6pou6lslGETdWBI5g5MoNJrF5OnjPeZJHNZOXs/IHNTY8Z6n80/9uNZGTLHyndlycwthsOtFob1tFzBXDyBefQEvNmg/cZXwZv1YEP3KTK36wVlas6Hx6KMtC9kruA+gVnivwj4TGVTXfcz59NA7vSPJpNBAeFrFpwvWm/AIb43WKnCUd0o1jpIIH2Vuu8vKwtbESorybnYObSsRI9CPLYejewEHmSJjYla+iTQ+AYSx+cBOBjnYEKstbWAsRKCEPfoA9Bswd5J/J53au1zmmiLo2sntS0oEMBQFqx5TZ8Y9q18XtIWtuhIH3N0/yT2EibAJISvtqDVCmwMqKqAsLl7WNobIaW+FdLH263GBaYEcCaZm0ECp9bM3EVzztq6jwgO+5qJ8ukyE103D19Lw/zyDMtTY4xZ+Kaue3B8XkKcDiVFg2RnB+H68iInhtdJ3HIMITx2q4RDn1chdSeC3zaoVyu8+9kWl41m9jqr8OQMqNUSt9StDJYL2dogWNdi9suasKg7whJzZnghay55R9564KrNkpwoAVrYbpsCYH6Wy5g4ZaS8KxuSNOnj5fq6N54x6BMzPRI41lFSJmMC0K0QpCRkvdTMg172z/NO98pL5hLGqCDziCSO95O49Bi3NMCQxMXEKFlWzJTEgSS5C9lK9kwjKzffNrLVwdVz3ei8kWewi8T1yv1pSFzSrrdPXU7iAiauOUaeBiQujjEuzGMylBGCNEXiutMJQTxFLHdcP9aTAS3PQKtzmNW5pC3fruFfPEPz1Z+UF5M9ZG6u1vcQbe9c0jdG5I6NOdnV71DN9px5zBmj4GGDmxYXK4cn50nZAX/unMyZTG5F8ofhoN7HSqQf2risERoHbLXAkjgt1pXFoiLY2qAyDO8Z7IXktVxpW5UPutu3tWE7HSV5nCkUfZtZ9bTOu1geSJUxBjAWdP4EZIzICyKg2QopW7/Q/fmaAamjzNrH+Xlm4ePWdWW6bprWAXBg3wJ+G0nfQOZ4dDGAVQ3UF6iMFVOsqcQdVGWYb1uRh41s+M668bvfyj3EOSBcqpM5Q7kwLo8OSfRyKBEc3xtwrlJv94v9eIKqmWv4jpi6KUI4td7mxHDs/nJCOHvttsEdeP6P/zqEMCYiO4LETVkIjyGEx1oGDyWDhdSdCH6zwepiie/6zgWuGoO6tx9d5yopm5FTtyl58s7sCViHLFImORpNBgIke81Jv5yIpQlK0kyUsp1AIFx6hAiIzgLmO7KVjGWJ4hjh69URqvBjZ6RWM4QIOf0ciRp70Q4CYN0GfbgfXUrWumvEODgpTDYt7zYfH5C4HeRt7JyYO+taboEDhLRBFhmqrBylQP+ITsibuqlwu0FvzzvXJ4IDq1u6hQHQJ1PXIW8pkv4DS9wEqdtLmnwyv1C3yxI3Vp6OPTHWvP3qJsb0+qOrF6B6CVQL2bdOY2K4acDrK/D6Es2nH8WNi/vXOx2Jm+r/MpC4OXOZM0bBywO/2eLxsgGeepF7DDgnq71jgvfUo2P515ux++Um7Z0TwDwbcz5mKPUx0Fy+u64FGqdJyTQLdF1VqCyhtpL0zLkWznMkdy64/u/YXmewj2qQR9k+q1FOhX33EqUk2Rr06DXQhSoRXaOZNq+E4G0lU29n1euTOspJnXOyiXtWlh6jTInnfcUctw5onMqW/podxyILqmqQMTB1DV4sdaP3Sv1xCYBYdsXqJ9s+8HYr8YDNtrNChr/jhHzYZf2bXqNDzHJer9+hUavbeJ/pmL5D5MFua9o+ApaSr8H4GTmZmm9KCq9DBPN5Hbr+H2Kv657PzODEQX9/FBEExsngsZbBQ8lgIXUngnt+hfOLGucNcMZC3oy+58dsjsQgC1SWUQFxL7fKdMfeRuAUyB1JG0D2eIPG0oUx0SdwgC4xPataR6wopiTpEzEijimVYzxYOE/J28gx3SA8zEum0K+XMt/vk72I5+WUCeI8li2tN5GcTZC4aH2TuAdSf04TNKDEIGtFK4oKko9fr9OqC4mTTJbcNqLBbLd94pZuS7Bvk/FDrG9zyduku+PINSdcXQ7ZbFxO+TjyNjHWceSNgKpSN1d5cTB1DdhatMf6g+TNBtxswNsN/IvPhLylyVniNfeTq+uQt6n2h5C4g8fY0Wdfv+uQuOvGnBQ8fLirDVb0AnbhwRCPBq9HMGlZkhaLQ2ydeK14BLFEYJVl8Tx8BsuyFs8FU69TA9lCO77/THAM+IaxAcOQR20NzlcrXK1btCEzdBbP7WF6585U0c0yEr1I5hZ6zORVlbVT8mXcBqRx2abdALaGWZ4DF7VsmwAGtuvoJQLvuo3XIzHrSN4Y0ZNjn+whJXFJO9SdV8aA+PVkhwd7B2ybaP0La3psF0MWKpiqBq3OwFbXd2sBkCaQaeCV+PnNRlxXG5HJu1w+p6x+aZupvoJxIpeWTbldThG1/kbw+j6xZ5ucYfnQKncMAUz79RvNs7TNsa51+c7m0bVD6NkhBFDmkK0FM8jg5PY+J8xyeigZLKTuRHBXV/iWN17gnccezA2ISIgZJEg7JTqdttArqdJgOGJNla4Egbs2shAyiMUFkZy2UwI2RnQGyTkU0bqWJ/qI9SPlU21zghHLx8dM2+bzysdAIFo6ArEfqmC1Tg4kwpCMZPwyJGRAXSKDlU3gpC5kKnOtWNmck/g2zVIW63U+Ev+WzX+fBS3cy0jbg4jYdaxo/UGTjxPEa4Lg7CJkh8S39eY31j/0NRpESuLCQ5W68pDGdlR13P6BmcXa1oZYji342WcxuL97Xvk8r0+WDiZJB1jZjiFT14l32zWXOX0D5hC1Elv36qD99DO8ffVTcM8+Buvbrrd6JAuvli2vL4MhC7EnA4DAxgJEYNJjeGkM2Yp13Q/tpSys+EbtP33LXG79S3+W6edO7FDMJim+L4y2bdHtH9ONGax+8Txk/WWbhC+oLFHXzUAIB8m6Mk+UbqP1RrdhSIhecOF0jcy3qkHLC5gnb8p6ullLQpb1M5FpPiFy4XPuyhnJXuZJklvyAjFzXQz4pJUvJ3FjVj/5APgWvE5kYCR+AKoFjK1A52egp0/EE8NW8h1xXix7m7WSPjki8cLorHyHkrqk/5RyNLvGvno70nbumAGHuYeOE5c53hmHZg3dHTc4j7gcklBm3+by+6yWKeZYMHeOvQOHEtt9KKTuRPDrDS7wCRa8Bfmwwakk7TDRna+/MA8yIyZEbDJrInPf9ZDUQhER+iWCaEzDT5RkYtT/9EiUXiPUpZa2eE46FMkCnRAwZVHd+L05BOE2pSnrS9bu5V/FcvoswjGQYe8B9qJZZCVtwbrmPTh79ruShwzI2QSBnUPQDnZznBp7Ynw5nSBiOyxQR8eu5XPJ55j2NRYwRjRfRhIDiDVUCRsMYC1MiMFIh9d9ltg5ycbmWtkMeLuVjX1dI5uHH+AieF+sacdcd9Yc9tRdd+yA/Rnd9gup4n756qB99gLVp++hNkaIDrP8htmDjdUy/ey9bH3D3RYzgexxRvo4q/dkI4Hq2phe25z0hf05ucuxrO0pqYMehy9/Bl2MX0BuBUzLp+ri/nNBTOh8Kc6nv33OrjGCCtN4WSd5G7bNIUkAdXYBMMDr5+DNFYi2INd/LlBLImwgdfr8AjFThVpu4YO1gzbR7VP34OWJ+LzwzsPxb6PlqXUtJYTs5N62V7Heh3qGuNnXC5jlAvbiAlQvwbaS94GtEr3tlXhwhIQ0wMCa1pG/YflgrcuUz2RyOTptEZsib7nla8rqFshMb23Vv0G+Zk8Ril1b8Uyv2fssW9PyYG/PmCxmmnjNdbecsoBOjQfst5YNn+v+eeaYO+99KKTuRGifX+LixTfVSrCRhTMQHYaSKA9ZngMhCgRNBwnEJEVK7hgA1EUybdtz/evadWQk/IfRWf3CqfZNX0bjl4f7Y6WkK5Sn14vlE/fSG3ukdipqPicLgzFTEjhiJUvHnhNvNjdpSFa+M3nI2FzT+cTT8Wvw6N8n67NvzHg+QhDT6xiS1d6IGyrIyMtOJGaqCU+JGnSPJm2fzoOdVyuokjPv4EMmN+fkN5PUjSZKmXMvu57Jjra7+uhDOd1YO/pf17p2inkF7CJsN5H0pJC7lx/NR5+C3n8X/OwjcYcGAbXEVlG9BBbLzgJPFlwvZC2xqmwkjbViVdyBhBCSlXOSF04P6ghBTgAHhDAnf9Q/B3WEMCNWnBC/MTDvfhEEMHD3HCg6J9BZHCkS0TDnEIoRrKEh2KKTfQ68XYPDButVDXP+GHz5DHz1TOYRLDhhLY/nGenL9moN5SFpGICO3IX9NQO5C21zV04OyuKg/O0IHGWKyng+RvYQ1ioHbC6BzWVH9kK4QL0AqiXM8gz0+DWJrwaJa/76En59BdYYxe5afcJDZhcBTBXSSZ9AdLkbI7SfIm85GRkSrt39gAnCh85FeIj51qP9e6/uIi27rzOH9M0laVPkaYrY7horzu8A0ncImezPZ57zaSF1J0L72XPUn7wHXj8Tq1BqPXJOiZcblgP9l8YpK9Bk/QThGRMOed8cuzT/1+h70Bww/6Wx67CDPO6JGeuGmCY6cy1i3VjHE7BuDOiLjOzfwMzywkMEsO3VoSIARs2zpisPFtNAtAzJ1gqAthlenpTgcxssmz4hWh6+dYBv9NzJfkneyXMN7dzEPZ3CErajz95+R1jR9o15fXJ3O+RpbszaKa1rhdQVpNh+8DHcpoH/8MP4ghKsNqgqcZkDZL8eQJVF6DZY1XOql6JQqmuALFAvxYJga1nXqoVY/CnZ2oBC8o4WYC8EiHXbAvZC1DzDB+KRkr+c6E2RPKLx8tzFMzWxzPzaT4ZIjA2QkcxwfYrz5DAoAMjWOts17NljWdO3a3B0C92dRj+Z4GRZ5zCUzSNz5QwkL74Xhb9d7MedOTS6XwaLYlCGUq/vgGj4biw2BLADb17Iv3TtqxegxRmqR4+BNz4Hqmr4zRX81Qvw5XPwZt0jlNOEakgA5XwH2RshenK+n7SNY4wM9PscRvZ2y95DsjXOJVpTY8bYxRFSNdd6NsfCN5fwTcmxOfM7duwchdSdCszgj74B/vQDYLvVsszis8fS02ubI/5BqXcIJ8w+KwMGDce+FGNaxn3Ea0IzKV0PfDkbG2vwDGYuEhQIFSF1KaVQSd2RPaGndWTT1dvQN5ljJEl6j9T1JyVIwSIbyBRD2lEgV5SMmaMXv6jay5CdMvjsqysqRyVBIGBeFAZqTWUlYNECG11SXfw8GSMXp3MTlqbTEbF9Y84Z+xSkaT7Bmb7WXcao3STxOmzsAxU5BQ8O7Bw2P/WPYJ68DhPcrA1FJajx8qJPzVZf+BnwrezlBnSufpWQPErKGVDrn7bT8QNRjJtrLxYAWRgrFsKOCFZyHkkdAwwwtZ1baEzQYoQYAlIeyVJG9sJLODLSl5C6nADORZpIZSpjZpApu1w1I+oFYKwqDykSL4RwhYAoM02YiBxjDHSQ1VUXfxddNHVIE+allsTQLhD97ibl2Cb91GIY0vyHZxsJVhwjyLd++5jcBB6km3ZTtGwmxMa14Befgl982t17tYQ5Owe9+XnQcgV3+Rz+2SfA5fORd5Z4E73HlSdZ6ZB4MOWK1gHZyK+1r356Xt01x8nTOKU7zKq3K7HLsURrF9nbRfSA/WRvTG7l85hMkHIAIZs7v31j5yik7oR49qM/iurtL4GbFkRp8uT8CzFjAc8tTJPxZ4AwBdN9nBij3376VMN1D5pfhxkiZDD34RgjnfaNKvCsbRmdiygjDWYOWy6k9XFeyee8XZ7NC5q0Jrq0hiOgLkJdOY9ZZefg0PY47AX58Bf1mxz7bknLMRkY7xOJOraP9DueVF3HylayXr5a+OBv/pcAAFtrRsi6BtWyp6ddLUFVJduMVDXsainZHBdC1owlIX28AbetJBhrW9GVuVYkj3cSr6sWwED8qK7654EIxvpadHLhPFoJl8BCCE/IoEvVQghIJIR15xHBAJP+nsL6rzHnnkg8GUKGzySGPRBA7LPuZa7thrtEXnniruE+qi1A4jJPpgJsLfdCkGzAn3xTk6skY2VJTQbnEx4xo4rh8FKa88RApCMxDC6feh/BmusJHDrnZC08vwMseNFFMian2UHyAMA3QvSefSzny3NUr70J+vxX4D74hhC8LHYudw+dygiZWvRmWfOA7u8606LXb5NbEMfndYgL5zFxe8fLjht05bz29TvMid+7jivnGAqpOyEuf+qrwFd/NpKDKTe0KdwXF6RDNzu8a9zVfO/673XK65/CUnLd+VznBf+Y+V9nvte91+td++ESsLv+zRTcLdafyt5p4cXFBPJlCKaSFyVbd2VpG1OJBc6uVpLRcbGQbUsWC6A6g10uZMNuq3F5MbNxA3JeiV/bEUDnQHrNlOwBGQmMdfq6lFkOexZCPadA+jT5ExkLYyohLFUlqfnJJGSOuvcGZrCBEiNCTBbGMToubkLeZYRWTxQisYARAazzCJ4iwZVet0DgZgNutyDvuqzOeex5TuKmEoyNkb2p7NAB+zyZ9mR37g91/LoyIJWD+gkSs7mEf/8SDAP7uS8CdQ3/0fs69XFrUG612pWIJJ/XoE9MqjOz/Yw209skDJ/R1D2YiS0PDhljn/VsV/ze0X/PbP5j9zB3jLlzSccK2DfmPtJXSN0JcfXxZe/8ob3A3DY5uo3rPTSC+lBw09/t0xLW+0V+++Odbm6ntHrd52dW8HCxebYG0L3shPXZ1ma0LG0bSB+Zz7Q+IXtJP1NZKTMWZhkyH4r1z6yWILsELReyebftrDPctkKSXAs0euRG3p1dC7K7CWBO/gbuoSkZNFoWrFK6XQOU7JFVAqjx0BS2cwjEMk1uFjxKApEKdWkG6NgOQ8teQHDNT9vmhGvf9j0jWaSnskIfSuY4zUw9hSyRyrRbZIdrr0/ewX32Eexrb8Hj/aOGSF/+h0Tr+uRuP/mYT1LmZso8BbnbV3+T5G7XPeRjBMxJcrLv+zb3bzGFQupOiKCFfCi4ScIzN1PPcWNff96Hbuh46usXnAa3rTi5DXfBm7ynmyRYD02JVXD72L5oe+dhHSZDnfUut9QlbYDEcjdRLlY/+TxFDE3unlnJHpjm7AxkK3X9rGCWS5jFUhO5hO0FlDDBS6KoBnouWXz1lWxI/qqO1FFm7YvnwVctO2ebWPR6D3BEzu77je9ylczJWj7mHutbj8DNzSK9xyI3PuYIIcWQzE0lJhtdqw6ML2cG6PwRqqdvgonQ/uxPD8Nk7inmWJCk3X5r33XmMJcg7h9rmrjeBrk7ZKzrPPs5KKTuhNg82971FEZxHQKzD3QDY5+CEB5LvI55VqckeTdJhguuh/ticbpr8lTi4AqORfNCY7Zsn7AB3TpKuifagLSF81g+bdnbb+0L9TtcPbU8EK5Yt1gIAVwtQbYCLfVYL0CLc9ByAYBgjAF7B4IkqSJmcf1sHYB2lAAiPoNw3rcORtKXyByaSrIyJZd2uTEevAXPBGEDZmegnrzmWNbpqUzTB5K4sW19JvdZ9eriWi9AyxWoPgOdX4jl9PIF2vffhV/3vbT2Zb3eNZ+dcx29x8PX49uUZXMJ0Rxc14p1V2NfB4fOq5C6E+Lyg/VdTwGmulkr0k2QuBynJKFzCVdwrZmDuyB+N0HMb+NveQgKoe3jvpDIgoJTYftRO1pOdbcW5TIs1A3KM2KYrrFhPZ9LDDvyNySMOTHsCKAZHaPnDmqtxADaSmIA6wXMonMHlW0ZCAZGXs5bjf1jJ0QQSgQRYgIhyWAoua+M1MXnkK2nlFv5Ak6x7u7K7jtFOvaRla5iss3Y3rD9a++4RtrXGDBZ+ZtUtRC4QNSrGmAPv92AN2u455+B338XaJsd85qy+u0je9P3mtzUzjHH+h+aeXru/He13Ufibmqv1mNx38jcsbg2qSOirwD40wDeAcAAfpCZf4CI3gDwZwF8K4CfAvC9zPwxycryAwB+HYBLAL+dmf/WdedxH+Cu7v4lzO2ou2nCN4ZUWM/FrnsYwzH3NSA0zfTfLidUvploGMY+gsDtI5VuzzWBI4jfjDFv19V0+De4SStzQcFtoMjIDu5K0+7X2XrXclzHXZPFzbRarudTpA9JPVlZS/L1o7MG9klfu4P0XccNVM6HyWFG2xIpiagk+YutYOpaksMsFkB9Jm6iSfIWNgQiAjsPYtlXlHTLGtY4O4IXYuUlUQqBELe88R4gjlmjb0OxtldZNenuuIsEUBeDaIxsI2QMYKy4+WlcosQqivsrGxOJLnsPbrbgtpF/myvwZgNutj3y1r/m8HwueZrV7sB9VecQsVOQuH19psjcdbb1uU79KZSjD8k75RSWuhbA72Pmv0VEjwH8KBH9PwD8dgD/CTP/QSL6AwD+AIDfD+DXAvhO/ffLAfwRPT543AWpO4TQ5MLyJjAgce3NX9PhcGJ3CNmcepmYdZ25pCQjlceQmZxsntQt9ABL5nWR3rt74NqzEn9ZgCIjI7zKAzOiwMkVV5H4ZTKEc1LX0mT9GOEDEElfLM+IWUr6Bnt3zYz9m+Memlv7jFUCmBHDfMxQD9L5GSNWJmuF+BnNAGpkewfShCsw2qY2mrBFE7FQ52aqF8IA7IUEJclUJrcH0vox9J5maj1Ms3jGVkJ2e3vn6Vx6U4ukVYird04SxHgP7x3gtkJ0my3gHDhkAQ3bHY3gOtaqg/dkHXlW1yFv+9ofQ+Km+h1jkds1h311c+p3XfeQMQ4lczexLdOhuDapY+Z3Abyrn58R0d8H8CUA3wPgV2mzPwXghyEC63sA/GmW1eCvE9FrRPQFHedBg3dYe24Kcyw4AQPt6E3gGiTuOpbEfYT1GLKZz+dQUkw1Hfw8orb6GpqhSCSvMUZOKtkfaj+dxj6i4053qfHr3yJBvc7fIKBYKx82iowcws9Zfyd2jAoybw7p20X4ZIwpK6BaFC2NundK3XGxf8bS0Jq3hxDmxzQWcLrtuEtpnmxlUD92r8Z0/cgI5yITLYwAaXVoEzp25CyOObZPrZLC6KoZt4RSopjuIbsDc13ojrEaHWVpOtDadsz1jyFAxxKeXSTnOiTqNkjcIWMB8wjdIS6bx5K5O02UQkTfCuCXAPgbAN5JhNA3IK4ngAizrybdvqZlD15gzRFUt4mclNwF6TwEk5raU2Dib7OLSB5MFGdccx9xnUMcj7nuGHbe+xFkZLZV8oRk8xjMJah3bWUL5PO+un4Usnk4XnUZyRPr29iatk+e7iJ9x1r5cnJHNU27fR7o4pkSOLKtlg0JX2+Mifo2qZ8ifp31b7x8MN80JjG7bl4+wEi83nXXz7FrncrKcdCL8h4yeT23wpt0STx+7Jsib3Pq57aZM5dDxjpEzh5KtG5zH92TkToiegTg/wrg9zLzZ2lQLjMzER00QyL6fgDfDwCfeyD5XKYE1l1hrmXpmLi3W0F7epPN0Pp2jcF0B4tDyGf+UnEM8heRY5E+3ZuIt7yJ79V1XGGnMElGjyBTpyU6p1fCnNJKOVcIFvInKDJyGsfIziDfRteZCdkxWD8mdiEaW9On1pwpF89d9fmaM20N7BOzWN4jiLsJ4BQxy9ulZXOI366xx+4txxTpu05c3zFE8iYSZNykVeZwl8DTEZ9D2t6kFeuQsY9Vih7zvbiO0uFU38OTSAIiqiHC6s8w81/U4m8GlxEi+gKA97T86wC+knT/spb1wMw/COAHAeA7aXW/2NJLhvtGRm+SZF7Hmjol1A+ygFZ2f5s94F0vM0di6rlchzzt+15dZ/57tfgHzJt10b9ONtBTEJeHEgNZSNrhKDLy5rBrnZlaY46xAg7cPgNCnOCeRC9xviMxf/usgXFeE7F/Y3W5G2gcc8IKl8YPTpG6/FpT9btcOY8vP35Nu8k169SeFLflpndMn5smOscSm+v8Da5Dpk5hOT61UuEU2S8JwB8H8PeZ+f+QVP1lAN8H4A/q8S8l5b+LiH4IEvz96csUK1BwfdwkybxJIrELqTvPbeO2s57e5j3eaPKa/Fq3vJXFKYnZbRKxu3ZbvW8oMvLucKxiaddaPzvWL2AH6dsX85fPc+AempC++dY+12sXyh0wsPrFMSZI3TSZc0nZbkKYt5smb+7gtSW09+M7aTwInOKl/7pj3DV5OQVxPiV5OmWyk1Pvj3cKS90/BeC3AviviOjvaNm/BhFUf46IfieAnwbwvVr3VyCpmn8ckq75d5xgDgUFs3AMYTwFSQkvCfbsYe/FdhfbYozhGGJ2KLG5ia0pduEu9mc8BYrlbi+KjLynOIb0XSfWT8ZM1oh9Vr5w/V3JYCYJn7Zp5sX+9duME78AP2H9y/ulSMnjVBuZ/7g3y6515qi1+iXdF/Umsyue2qp0k/HiD23fuanv8K0nSmHm/wzA1C/qV4+0ZwD/8nWvW1BwWzjWcjj2QlCfz3O/POVi9zK+dN8G4brOc7sOqbqNv9d923j+ZUaRkQ8X98W1M/Y9wto318XTWIrb4kxZ++I8BqRu/x6j00Swj2qifmx7mzjPI+J7r5vR+b55JNwXEnNfE3udEnMVAqcg2Id+zx52dHVBwT3G2AvBo3cueud35Qv+quAUgve2SfF9e1koKCgY4lhln2t42vtjT3KwUffMLGFXPsLcBC9jbafmOSSG05a52GYqVi4jjKsnj0fbHSIrb2PNLvJ3HPdGiTxzHjdJQslcP4dCjn3fu0LqCgpuEaunZwCGP8xTZ6iag4esUcufxV0ToXsjyPbgvv/Ny4tSwauAU8b6BYI1lbDLY8KqkLl+AiMZRWdYCqfmO7AYTqyRJvvN1+cL6X/AptmH4lVYZ256k+uXBfYE7w63+n3a865RSF1BwS3i7PVzAGOkbj7JO3QBOeZF/iH55d9n3Jd7DfMwN7Dil5eHgoLT4hDSd2yMX+w/RvpGCB+wYxuJHQRxbM4pcvK3ehpkZH/e6Vp6zAbhu/rtwmmSdJx+jdx/LzcTM3hfZNptYO690g2GZx763SmkrqDgFnH+lS+i+vxXwE6cZOKiwR5glnJmMDPAXtLth8/e62f5x9Cj8wAY8CzH2B9dOevCwNJGDqG9xheETVbDNQAZR9uAWefL/bZ7cNd7t9zHrFenmNNtk/XpOe+XaK/Si0BBwU1jjPQdGuO3z8IHHGblA7JYvxnEL+8DAI+++7tBVa3yLMgggJ0Dt0E+epWPHvA+ys2uLshG18ktlrZRBnpGJwNz2ZvI2dhnGnPX1ZvYD+7YuZziWofgtr1EbkPZeDN7HOZeSIe5cBZSV1Bwizj79p8L//F74PVaCpRsMQMgikchZASQ7B3EYKCSc/ZyBBGISDqHjYzDGNpXirSfDK4pG7qyUB/6d8cw9sh4Os4MTnfAZqU+EbLofwZ3Y/WIqde2iSDnvpDPhT07H/ulLwBB4LN3SoQTMjw211n3dHrSG8bctdQf9MxnXm8u5gjvYt0rKDgtpqx7R23bMIPwATtIH6ZVPbs2jbePLrB47Qn8N78qBA7oyUhmAMbImk8EgAFrwIbEXBLkItCXp6GOWT8DDOpkX5R7ppOnKl/jGBlG18WUFCaKVlG8yr0M5BbQJ6W5gjYobXPCGZ6Nz645Qko5Xi9rt+teJnCb++idpu/dbwh+vdwJxVJXUHA/QYT65/0C8IsvAm0jC3K77VvSXF+QBW1l1DIC/QU9bYNQPV4eBUi6SOSsLNYNF/5B3+waPEGAAiHL5zFopZxT/uNVsIZzJIRVi4gAWPnMFgTSK/UFtRDXTuBzFOwquKPgF+HPyNtPz10IYqcFZiWHnZAWC2u0hHrVMLdtd65Cl9s20SSnl9zzN5hod2hbfVjj5UeMdUoX4oKCguNwSEKXQLRm78maJXbpu1/uuVY7pH3LL76B6ktfBj7/Tl9GMotsDOvTQE6Go5ZHK9+IHEX4mMlT7wGMrb8TctaMlXsljABAoogFAMuJTCJwkFuolZsGhWtGIsnomLphfE+hmipolYtG2QegVx/6dddJiepgPU49e6IiVOWZCyRR5V7Pouk7guk6mTewnkYimlhcU7KaP/sJ7JIj13bFPUIWHnKNm7DuAoXUFRTcGqqnj9G89jbw+E2Q2wJkQN4psVAx0BNSujCiIwOy8MliSbGNV+2e1BOnVioPRPfMrF+8DoZEMWBEGPb6BYxZtabI5kT9qMBNxx9DNv9OAAftro+cMKa9juR2gtBy/9mE7r328e8EINUSs5wbMp2jvTVAtRCtL0HKDYHIgEM/Y1QgS132ODIi6IQoOiGBYln0QNvI/TsHblv5HOrG7gEjz3mi3UFt49/KJm1OH+tSUFBwWhybwCVgjvWvu9ZwTaguHsF9/tvA7VZkYZCNRCDfgly6RjPg2oRceJBzUcEma2WiPGOfyFMncpB1jDgmkrU9P8/kQ7wRPySR8YGMy88BoYztc1KpYRdpXOSBSlz5OKW8FUQZl8k+9ug8gtQySsHyyRAlaLBsVgRQBXDfAspBAUtGZGBKKhmyPUC0po4+LpF5iTdNeBfy4e8dSGQgkIm7rdfyqHiNilU3fP7YLatOGst5IpfeHIXUFRTcEqpH57i8eAfbzRqmXYOZYb0IFKMaRmI5GgqbuMoP2+jCRUTyOWj3UksTO6iuLlHKBfuVuqqEFoTOxQOICwzFhYbl/+ykSSCSmasiortHED4jdbqIRjKZEs50YUsEXRT/c4ngLk1tJljHNbTd+aRmdnSscWEpgjaMCyXWwzGJfRwjPvlRa6gKR2OEABoLgABjZbNeUwNYSbkRshg+w9i+gHeBEDo5Ogdumt65b1p52Un2cjqWELL3g7Tlg7iBwP/2CLqCgoK7w6Eunin2JnSpCNWTx/js/G002w2s2wCJjLRoQLphgwmyzqhS1HuRjfBSroSwk5G+JysJHMli5yIyIQu9E++NQAgTL4xOySqEiHxoE5SwgVy63pEGSstEPkwpUPcpXsNQYyRvzEsnHXPiWrks7MnA3hicyFXfCTMMieIuJelOGUMEsT6KEhRE4uKrnxkEqowQy2CFNAZVUJSSUdddinJUyOnwmbBnsG87TxqXfA7hGd7Bt04Vp07mHj67oWw8ladL2dKgoOCewJ6t8ByvobEM2BZEQE1K2gKJU/cFg1aomHdi/PEtiJ0KDrHMBSJouOsrxyCUsvJA6rwIIYLvBFfeN/xXLUkUrS79ekpW756QTFwn41jiH9KR0EA2Q6xenEu62AdSmRJFZELSg9tGFl2nx3ar95oQR9d/HlPCMiSxGSWDORGM89whBEfGit08J0RwgiCOEVlupdylxb77a3jWEIqR6xkLGAsyRrSkxsIsKsAshV1ZC7IWTLZHxnwrRI+dE6tgs5XztgW3DXi77f3tunnbgwhgQUHBw8Ixm7Tn8C3DXpzj0ryBtfFYVC2ICDaRkYadipFWyZESLiVTpJY5UnkRZGNUmqqijbzry0Ok8jOcaz1ZFVMGAAGVyK1wV50MVHmYyLZU9lEet44xmRdIEydWxUAgA4nk2I4TGYgg13ueOhwtWMCIsnSfNZJH5NkNKkm76Y3L2ZwghmfWJcIZGSOezyTDgChGlfyRsfLclASaysqTNCvYoDQNBDF43ejm5Ol8g+eMhFk4Uaa6RLHqtMw7lbNTMnO3jCykrqDglmDPz/DZ5gwfPgc8OzgPLK0IEKsWuYX16snAIJJyAqGyDlbLjGEQCIakjijVgIlAE5GSZgQLbpkANG6A2IlQ5ETY6SI0SRTRX7BTwhjJUl6XCqwwBnfzhe8L0YEFD6TX1bgAE9w7AIlJMEooNe7AmE6YwgNxEVXrVNvI57aJmjWZXjbfLG6jRxAnCCBlgo4mBF2ALPQHEMBkrDESyPv6ptdlDzTjgs2n7cPcjRA+mAqwFqaqgdWZEERbAVUFMuKOE4lf24C3G6BpwM0GfrPdY/2b9wJYUFDwMDDbumcMaLXCx1crfPhMZJ9noDadjFxYBwJQ2758lCNQVSJYLFg9/FSeaYx4KhsD8cuVpdHaFohhJIQ61i6CmMlAE9c639Uzd0Qwl5FB9kWXRyNaUKp6HjcUPXJSSyOGhDJNHCMX6M0vTcgSXVGj5ckD7UaVpWKpotR7I5N5AxkXMnwfHNfYne8khJNjHkIIJ5SmvXJ9FqnRcE9oiR+MyZ38VA+b4GXDVQWyqmjVI6ztkX8wizeNc3DPPsYuFFJXUHBLsI/O8bPvefzsRwBZi9oCy0WNwEdaBxARnJdz58VrgAFUllFZWSgqNZoZFVjWaHk4WtHIWcNKEIUoWo3NrrTcEMNUrEKRNfdI0E5yJHtx6wSWPY+6c5b6SAqDAM0sg+E8CFhOBFzaboQgdnXDNkAnNI1vdGwVuKHcNaCKAFqKqwYJ4YvEz9goaCPZcw3YO1CzgcReJKQvfA7zyeMxApnLBN+kJtS5SQF1jMCbHmueoJvnEqOumc06GyuxFBoDNhWoqmHqCjg7A9ULwNYitACgbeA3a3CzAW+7fwUFBS8/crJnlhZ2ucJPf5PxM+8Bjy8sKgss6hqeAz8htF4MI85LmfNIZGNfRgaZaPRYG1WaGoZVOSnyUCyCUqcGFxKXziqRiUCQiUAgQwQf5SCiwrIvJ6dk4qCcfSfDRuQigAHJnKN4nSKdXV8I+WMnSlLIQyYGyKjbqhHlaRwjxHB7JXpBSareMkE2pm6scgxz8JMK1NuwIAbs9a7pjTlUpEqfifKxOHxpIBa5dqYFkSiSvX37ThZSV1BwS7CrJa5ebPFj/3CLLctPb3VWgQBcnIsAOzszclzKsV6QCBoLEAxaL9v9tBJSEHOgBOIHiMADhmQveNIFAWeJYxuTCS5LgRimlkMSKyFJPQiw6j0ZCKQol8Kiw1HQpcQQrAKQfCSG6bXFOz7MK3OFyYRTEICW+7GJMVbRNqNED953bjZRSEK0Z3YlZC8spMFtotkAzUaEVnDvdLqETgmugSDLhJi1XXxF7gobhEwm8HZaAYOlK3jLDoTjxLm1es1ESIWxqC9kKCZyyQUZdWOyEl7XRiHJaR/vxbJXL2EWS+DiCej1JVBVaH/mx1FQUPBqgayFWa3w0Qdr/Fd/b4vziwUAlZEkMvJsZVBXIh+tAZYLwsIAta53qYx0HtigH86cysjw2UblKLQuL+/LyED+otLUcOdFQ4Egcq8NRy/2vmxkyrY4gEcghmC1HOYKTjtNCMfODbu9ytFcnhofCJkDvMpV5yVZTeqeqrHbVNWgxQohGUqM42aIDPAOpMpSBGWpuh3K45ggYFPyM5NfxH7Es2YHSeuNkRHd5DwnXFNj5m6tQc6lsZOD2EKLXtt8XnEMFeasFtN9G50XUldQcEugxQLteo0vPm3xwbMWnz73+PiyAjPwfCU/xXohP+DlUs6rWn7Bi9pgsSDUFlgtCJUVgSZHsehZQ2hCIkQPOIhWMywZUYglpC8SwD2CLSV7U/Xxs+5QZFT4GWNg1BpoSGOW06MZLowED88Mp5pOTjWhOnZ6tNBgeqPHaLlbdJ8j0avleinJQyfQQjZJ5xPSZ6zMd3UB2Apxf8DtWmLLti9Ea8u6UkcBk5/rIm+T8inCFWIADY3Xj2gmB0TPhPM+QWNWB9WMsCG9Vgw2nyBv1L9+2CQ1Jn6JgfG2m2tIA24sAAZvrsCbq2Rs391vQUHBqwNjYFYL1LzBl59u8aJxePbC4/KFyMhnywoLlZMLlZNBXtaaWXO5NKgMsFp2MtIaYCEe46gqkrxdANgTWgc0pMuwTiOSOJWF+8ifAQ/k4V75GWQjAjEMsjCQRlWgAvEl3oQZkshEzx0h1AhqhO0EmDnKRlGSZorTPMwC/fOoFM1iEo0fKkmjHGWRZZ2XSkL+jIGxFVAvQasLkRUMICRWazcany1x2tEDZor0jXnIVBPycw8hnDwP4+bXSZ7f0FsmMrXBmIMEMTm5i9egfnkgdzPlYiF1BQW3BKos2u0WP/4Tn+KzqwpPH1f48ttnePbC4+PnDZoWWKyEcGwXsmjVSu4WtY0Er9ZjpTEJlZVjXQnpWyxItJkL4KyW8tYBrSdsG2AdeIWhKKCmrHyhPiz6u0hfLtCCEOpI27igiwQNYWyDylAkfia4oCcaUIDhvKQrbp2H1RXQkpJhJU3WN/AqFWOboIVUKyAHMqLkLpQb0xdOLrhkNhsJyCcCkQUtz0AXT2UhX78Aby4jIYokK0jmTOB0MRFJGVO/TxBgUSBPEbQukxcHQhaD/TOCNiB5QQiFuETfuUnmsXz6JYluPuiTuZCxNSV5jITgpWOaRIAC4B2bGRcUFLy8IAJsXeHqcoO/+bc/wJtvPsKTRxbvvLnC5ZXHZ+sWzzZB+TlO7q6ugmxUWalkr6q0vCIYEtK3rMUDZrUAFhZYaFvnCVvVtW0axLXcZrIxlZVRLmbWvbDs5lY/ymTjuHK0Lx+7+MCgxE3Jn4ZQmE5mxg1liNU7hsVFniFK0t66HOYRlKP9JGyjStLcA2YX2UOnLEVSL1lJjXj5VAugWkp8tlFZ1mw0KddayF6QlSYjTyEeMHzutdlN3mjC9ZPZS4zbSJ+9MfMjHjNBxkZFqp0ggJSRt1xm70EhdQUF18Tc7F60tPBti+efXeGDTyw+eB/4+je3eO2xxbf8nAv8g5/aRG2NV7c+p3uruaXHwlstUwHVBkElx7YmXAGoNh3JA2RtqyzwaCVE7/EZ4ePnwGabGIx8X3B1Aqt/bBNCCPSFWBvWMZ8JMN8XYG5A9gLp6rSIre8Tvc41E7GtMQaLymCxNNhu17148QA2FF0zY1kgeSqcMm6iWc4QCU6cAzptblx4vQM3a9DmhbhsVgvQ+efBzz4C2m23kId++cLMphNGUYCENiHIPrh4+tF60nmy8QkpC12CZSzcUyBc2icG+ydjhIeRkbRAuKLmU+cbvrOB5LHvEzPpn21pkF03IiN5BQUFrwjUVNWsN3j20Qs0DeMbAM7ePcfjC4Nv/TkX+OR5g48+8/ArWSeCnGwbWQuDEjTIxjaQuVrWqCAT11vqKUOBjgOsaqiLJ+HxSmTf1RZ4ruG+UfaZ7rwjen25OOUJM+X5Ymg8FGL03O1WjnblDEOyd6oxRj8DpiLUJmTEZDjPaNsG3jOsKjYDyfO61ht2UUkaYuMtiRzlQOoypSj78XJJxpIkZAvx6+0m7t8LsqB6CVqeA7YSgrddA+tn2i8hVZkiM43dA5AoUgNBy5SnmTumbN/ke316CtSkz6QSNcDwtCJVXzwi2cvCG+JIOuYgfi9DIXUFJ8FcYvMyI99cdVCvQiRtRSTaQyAhDBPw0a1NzqMCKroC6DjBwBPWIwM0LfBiLWWLulugwrrnBlOPzgK98yC8Yrbd6K7XfYxSJVyf+udxAQyLZ1isgrYQHBdPH7WTQWCFtgQ4oPUeyxqwpkLTerhsgSQYSUkNxCyh8Q6Df0M238h/QsMQb2CSpxIq40Ks59srcLuBefwG/KfvI1wy/E0Gj9k7EVZAR+5MRnQCuQsEKK9OLHictT2Y3CWWtEjwUusdhtY0mrTghWubrm8kiv3rRgK5L2CgoKDgJQdlif8Y3jOcY4m2ZoZTAWTCUdlSKI+OCfqhjWuSWvAABFVfkKPBe++KCVdb4MVaClZL4HNPgLohvNgkis6wVBqgzax5uVK0q++/9HeEDbE+t+4NyR0mynMLX3gGSaKUxNqX97GGcL6sQMzYNhIzbhE8YDqS51ReBWWpM3oeXDaDlS8Qtszq531XT2nsHlKSllj7XAsKMexEoNU56NFT8PoS/iohdz5PzOJ7Y0U5O0X2xix6Y0Qvb7PjPE3W0ln9Jlw4c+KYx8Wb4fvjGAqpu0MUInR/sI+QHQuqu5dUAsNUFk/fOIc9r/H0scVrr6/w8WcOX30fWKyWUdM45l4SXUh2uJYAEj9QW3ExqStxL6msEKH1Fvj0EmgcUFVdlrBOgxjOhy4mvXYj7pi5u2UnVHKBklvqhsIpF0K5S4q4vBDqSlxIm02rWs6+OwlRt9Frl3ksOw4ygfWPs5C0peUj0SZO1Mt5QuGn9p3Zo5EbjL1nU9JZOGSMU+4pl8cNFhQUvFpgBrxHvVrg6ZuP8MYbF3j8yOL115e4XDM+ek7YOovVme0sclEmWj32vVfC0VoanAfZ1slRkZfLWuXnIiRgETK3aUXe2UxmGpPIulxOZvJ0SNiG9SYnYBOvJmaPGpj2qon7cJ5xtXW4WNVom/E2otALyr3+xDhakqh3nodt99qHbYjiVguu3yhawPTgHXj9HOQczKPXZY+3ZiP9KFdQhjEyrW2OTNEZKW/i+RJZsMvmF4hW7ukyplSdkOeTXjP5O0NuUZxAIXUFETdFbB4aUiJ2KpiKAGKYeokvfdHg/WcGn73w+OxDC8BidaEkLiRMqQKZ64RTVUvw96omWAucLeS4qDUYXMLxwCwJUxhC3q4aiUOO8XOypRhMEgswEDpZjMBAaI1ly9yjQcyJWT/bZbLVgklcRjTdtCGNsQsPlBnee3jXYtsk7iLou41Y33aZMfMg8D3bIYzGCvi8TQvZb2Yp2b8A+KvnoM2lCJV8H6JcS5i6eEy12ZfeeQxTaZ1nYtfGsMO242NP7Zk3ikLmCgpeaTADbtugWizwi/7xt3DZWjy/9Pj6RxUYoui8eKTkrQqKzZzMUVYv5C0kSgmys1YCZ02n2AQRmlaWoiA3P1t3snApyThHCdwUecsVm2ZSRnblUxa5juxNjDEiV8P5mGXOUEdIjQEqQ7C2wnrTTI8FP6IU7cu4XFk6hd72CFMyIhsjXmN5pu6Y20HfyeseKAN7OKUC81AcqPAspO4O8ZBI1E0QnfuIU/5NBpZYdqhXK3y4MdiaCqvHkq7ZGuDszMIa4Hxlelm7VgsRStZQ3LsOkL3sPMu5JxFCmxjvFo6Mupq2tglx0s97snV1Gsa+ewtR2AuPJZ0z9HrUZfEK2x6EbJcEIWqDfX/C3ndptksvR89h09jc6uc1KFxJXCB1SUbLYSav/jkl7iBynrmEpIHdAGArGCt7sIFI9prbXMI/+wjUbvtkbsq1Iw3OPnSvnmwPPB5xFznJHj2ZsJyz+Xmv3VjfievG8kOsowUvNfL1c2oT64KXA+wceNuAlmd479JisaqweCSZoAnAamVFLlpgWZtMoSlystZEKMZAtJomLEsiM1llJghoPLB2AAWv90QWGgvUBlhiHmGbQ9byPr3yhLBNuVF2593G6kHeEjr52juGehq67TELIfMs665rGa5xMOjcLUPYQ1CSGvaDRCkhti7PlEk8ohRFX84OCGAaY5ccYQyoWsAYYee8WUt4Q0yO4qeVngMvmT2ycYcMHGBq24QDlKpTsjC/xizlKAqpu1PcJFF6SITxNnEKl9djny27LVaPFvj537GAqQwMSeZK5wEYORo9hk1VtxDPAstAlbgtGgPUIyRNzvuCpdtbDgh7zAWhUCVpk0n79gWEB4FAoTzcTCJ4wh50FKLimHV/HY770YEhcVoh7TKmNYvi5JG38f222RhB0IztV5cLl7CFwVTWLoBl7x1jAFOJUDWVCJi2AbsWvL0CX34Wff1DyuJZJC6t37WlwZwNV7N+h25YPiBRvbGyMcLTyccO5RPCh/1wv58pMjdGCAsKgP1rdyF9DxzOwV2t8cYbS/ziX7jE2cqIBakiJWjirSE5MShshynLEAGOhRMwEpnInUwkK94gNVQOToQS0ECRmRGwhGR1pKnbv1XkqR4DsdIj9eqpOyf1SEmumycHIwr7vnJgZHJAetT973RrA88MbhnI5CmQX4Nh0YUvpCQOSOVpczSJQ9aPfCf7pK2wcTJWc6RUXQbl7RZot/DbZ5JQhdX5M42jy5Weu7xjeuXj8hXsj5LBcpi4VlK2V7G5Q57uQiF1d4jV2/XeNr49XlAVYjcNssc/G3NEXzIEu3D40tuE1TngnOSArHUj0cr4vgtitHL5SMiMtrFZzFqwiHVuEXrNJL4sXfRFKACA7AcndWoJC9YybUteNwgPmba4G7N3f5y4ZWQxarHNhLtGVz/Uau26Xtp2l5WtI2sqNNiL4GCGbDJuEDcbB2Rrg2YLardg3wLbrQgPlrcGApK9b0ZIWlo+h6hdR0Ak5exHxgoYjJmtK2PWtynL28QYu4jbJGmbIoYFrzzsmd1Zz032fUvk3bFysxDDu4NvWrjnV/jSO4T6TKxEDJGN0GPwKKmIZTlHX15G61VKyBKrVuolEklZj0R1SVoG8jTIoDRILJCssGF4LA9EirtTiLshIxC0bK1l9F7gp+Tnvvpd/QYyN2trJohZHNu73SQtKaeUXBHJtYyV5DXGKuO1Iou1ncjeTdyvDhqbPninGCNsh5C1Ge3GQhAGMu4AT5h9Mrnrc5gyNUchdXeIarVbaBXcHsgebzWdS/LINXiyuMLFawDQgkCJm4NatxKSJdYv1zuXcdL9WDguaAPSNJUIJGm3j1jNFRxI/eND29zlYCIBySCgOxVsg0+++0yiwY2ElozM3xgQKrG0qcYSAOAaxH1y2kb88b0X4eHabtENJGlsg9NTCIqs36SLxh4rW3xcB7hMdn0mytOxjyBvvfmMjRmzcFrQYgHYBVAvQIslaLEEM6P96X+IggJ7lm2DkRMuDYYaI3BmKimCYor0zfHkKMTvhsAMt97g9dUaF5WHNcFqpOQBnTeIyKlkbU8UlQAG5Il67aQtcSJrgT4xwHwSJXXz247Wj7jn5VmEJxNt7JOnI22mxpoibAOiRiRzJiPeO9Hf04BYvVyg5skQN962IntdA3ZXMlbTAL7t5FGu8N2XqTLez5CAHSyL07GAfnKTXYrUFLvGnqvYnCObd6CQujvE8olE3rK7vpDwJxjjvuAYS9ht4DrWPQAwlnGBT7Bt1jCtbHoz6cqQkSvDLtNSUbLoy+IZFIgDMqcayA4c+5GKSLDXJv17JD2nAZnqxoDGyenqrpq5fAQgbgQX0+bnL17c1ce6IKzDwkz9hZadnLtWF3bd4LRt9LMbLswxJu0Ijd6EIDjYpz4pP0gw9MaeFg6zBcMc4nYIaZMGQFWDqhpUL8R1NXyuavmKNA242QLNFrxZw332CbjZ7NVCFrw6qB/3SRtX/e9ZKLdKxHpkawfhA/aTvvwaKea68Bfydzjaz57hwn+ARbOOXhcmvuj7zioU3e/HX7b3engM5FROfFJ1IvfLR2KbYl/K5WecWE8Sxsp0PoMxg0Cf+L5xKpPH6vMBuw+De1XZT+ozSggETQPyUnkcNxFvAa9yln0XStCqLE7j3YCeHKZQfqx1Ld5jUn8IWUv7BoyUzw5XGFxjOPZUDHrXdVq5ndYP3hcy3BmpI6J/DsAPQN7w/l1m/oN3NZe7wuJiOSjb9wfbh+K+dPOgqRzDe2Ar4PzZu7gwFahdJ9ouERSy6IdFqk/MxFUSXT24sxxxiGsLVcEdIvku9TSVviNKycLKvT79efSsVCnRSi1hoX3U7qXzBQaLaMCu7/yIAB0da06w874A6j1ukPJxKKDG5rWXqKXl+0jSnsQko/32jHmItY29fkdtLXvtGAuqKsBWIFuBjZWkMWH3XvZK2jbwTQNs1nDPPgW3DQa5sov75SiKfOw8WcJ3IldcBmVoJF5nWp6QKcpIWazbQ/oCdpG/fX13kb9C+MbRfPIZHq8/BLu224A6JUQZQRhauHILGNDJslDKut6NKKPSY9d68ClaBQd/xpG/KysxnJJ/ab+xJpzL5B39e6eZgjHWjV4EwXrZETRWyxj3n/u+GLX8OnMI2j5rWsCky+LxVrWu2bR1rTsdv8YxsnmvTN43zwncCakj2fX33wHwawB8DcDfJKK/zMx/7y7mc1dYPV31zne90BzzsnMXL0jXJaUvMyoLLD76eiewooWJEWO2JsnKGEHr2vReH6aEx67FwOe7zhzQV+ewFzuF2gHX6l13/uJ/iIau1z4Zc66mrjvds9iPxLBN9j2EqE0JghDPEAgZjBA1WwlZMxJfaKyNGzKx1/+0jWSoa7bwrtWN1iVxDNq2c1eduJ/Re9pT/iqiyEdB8GRx2/5LUCB37MZfjrzjSPgGpC6z9k2SvoDKFmvfLaL5+FPYd38SaNadl0VQPHo/X8kXcMz7yCAk4eXArPvYY+XqK3d399lnMZOP15fJh1xPTu9KJiO6qMJY8WwyRv9pTL+xosJQ5SmM0Zj/bt8M99GH2IW7stT9MgA/zsw/CQBE9EMAvgfAKyW03v4Vvwy0WIFbB2YPDtoR1pfH8JIfFzQNrk1dttI2YPlSqc84p9qh0CfGYUGP4aU41KMbd6Rdb6wDcK2XtrlkYOf1jyeb15l7el37+jn46z8NfvZxXDgOjU/a1XbGZA5r3+t6Ay8XJ1QATO2Vtusak/c08ZzGU/XP064N+o1cY3I+3usCTz3ixUSy4AfrmTFgMrEexsZY0SDQ2Tmwd4BzQsycg28dcLUWUuZcd2zb8fnsme+u39oxfV5BFPkI4MkXnwIAfOv1KB4A4TvkmkDqfHbeyad9hDBgWN99T6P7Z0awfDseh523C07nY+RukOwlhyZ/uU7CtIeE7QcfwH3963Dv/lS2VqQx1Qdg8NhGniNdPwv5sd47cb+hQ6415Y554usAGFfM7Xsfm1jLd75DHCBzpXyk/VTbwdiS2luiWJRkESmp0jj8WK5ylSHnVpOtaT1DxiBjlKyZ6Wcd3ptdq+6rGk/vHdA6+Oi26kVGewd2XuRwGkayB3dF6r4E4KvJ+dcA/PI7msudwD66wOKdd+Df/1kADFgDDkGlRABMEruUfAEBXYQ8wpcTkCHUITr6R8cfX9ImLgjJkeM1k3L9TEjru7Ej9hCFWTxCCWz8yjIna2+feHZEs18X+wVoQC3H8rxf0j8hvNJUXwTCxjahv+/S94O5I+HIibZP2nQPoHr9Nfjnz8FXV5Nm/O5WRn7At0qkT0i4btAKM4sMzLz+nD3SBveSCAX5XbIQrSopMxS1bczU176ZQMIkDQCNCQT9bnGMZeg+e+c0AH0r7o3OJfWuc93cRzJ3egns+43vG/sIYv1q45WXjwBw/uZjAB2Zc9u2f944PR+SvkjwzoaET45hjc/I3Aj5myJ8U2TtlLF/AXOtgnPGuq8wFQHtFutvfhPm4nOxvLd+HKrgzWPcIvmaQYwOIGqziFb6nhXOB5/13YRZLDnpO0vaLj0GItJzz0y2P0jaE4UQj4n3oe6O5JCLo12vfnEPCAyee1efhJqk75Lhc/YeKtMOGUm1PhAwyHsSEY1fL040+85ofFuM63O+ewdNDChgL+9vzkVjSrAWcwibYJXHrZf3B9+N1ZvCNWTgoQrPe5sohYi+H8D3A8Dn7u80j8bqC5+DWdUwn/tcL6CUQ3afXb7DAIQBInvR75Oc0fSrvXXkMFcyKdphTRjBYeSk+6F2BLIr7xaBZMzej5l6vyXKCKrERnPvHBoQDLYJcQ3XD22M9u0Cibs5UdJPFptOA5TUaZyR+/Sjnc/iGG3WrL69dgcsEse4/V6TEB7/ok+d1QqJts1m5ColYiZo6Yx8rVTjFrV20e0hExqpEOgJAu4t7qwkzIfkLRrQzWHx92oRCxq7HS8tc57LqQTEdUjerLmcwPr+quNll5FnX/kSqi/8HPirK4AZ7dUV0Gzhrq7AzRbuxQtw08BvZa/IlNztInzAbitfWs6OdxK+sXJoqPwcF9Cc8MU2B2T67PrIfB76VkbP/97fv/FrjCrPBm3mPcc5Y00pzYNckSRsKamBEp+uPVkb2/dIUPKeRETdvAfX7N55KHHnG8xrHybDOxJimhx6xDJWjSnkU2V7ODJSr7MoN3v1c997DpM5h7wnHTT27Pke9x51V5Lg6wC+kpx/WcsimPkHAfwgAHwnrV66N4D6jafAl79D4qGi1sWBUjLHjC6zkAdC5qGen7nT30NSxgyw6/rE+jz4NdP6BIz4Ju8lgHnfeDpCLHNMfXnnajvG3OL2xoCN33PvxxmE9pS/d+zar08zS6V1BIBW/eQ4nAmE6Akydo3cTSS7x7CYH0WKTmDNmn3day6W5ukboMUKsFYyKlqr33EhzqKJ67RtqTW208S52C4Qr6idSz6PxhAceA9T93HdtnMW/bsYa47QKu6WO7FXPgIvv4xcfdu3w3/0TdDlC3npdAxaLFAtHgH1AgAB1SKuz36zEbJ3eQUfiJ8ec3J3COm7jpUvLQ9IY/5ya1+XyKX/kr3T2hcw0+p333H18eXJx5xD0E5B4mZvb7TjWrNI4p4x5tQfcq1DxnzoOIX3yF2F+wB3R+r+JoDvJKJvgwir3wzgt9zRXO4E1dMnWF+8Cbd+AeMkIxx5B0PJRo5EAFeIGzdGKxXBBEsEsxqXVAsTrFzQz5SkrU+OpHt89QwQ8cuUkT3WPchSEuhdfJHuyAUjZpXqxf4lGpXQNyWVLm+TuT3G+e0giFNkY1+MWmYR5bGX+Cxo9zqZDUPyidAnPv49AbdpJsuOZI5vDUAxCeE4caWQpTBtM+CL4/dIE/EHzH6w4E8uTkGQHON7D8A8fgo6eyRDfPYJ/NVzcT1sGt201MW2e/3/d8zjmLldp/1JLGA3OeaB1rWTEsVXC6+8fAQRqrfeAlMDvpC0llWwyG22ALaiwGkRLXXkAKoXsBc1+GIlxI8MqKqFaHkHd7UWkrcWste+uJTzjYwRCFxK8q5j5QPGSV9O+KzkhBmN6QN2W/sCpqx+Oe578pX1p1eTdceSikPIy9xr7CJwpyCI88e4PmGd+3yO2W7qJongoaR0Du5a4fggSR0zt0T0uwD8R5A303+Pmf/uXczlTkCE6tE53l19F5qK4wbUljwIHgyGRfD7TTfIZN1UM9noOexvFjbdVBKU7msW93bRuqnNqKf2SCP20Z0tJ5ek9xPKOwKZnifeAolrZdw+LfiaZ7F7sW0W3Jym+Zd5hrJghQkkKyGGKbkEi0WUPVizTlLbAOxAresI1mA/s/5zGe571ieIo5tVB8zM2jiaHeo6JDMF++ECMpUJ6oAsULODmycIdyoCxubnfvan5DMRaHUOs1gC9QXwuAYtll1q/WYLv113hK/Zglt9GUyRC4Yb1LKdgujcd6vaPDfRYqmbwisvHwFUjy/Qfuk7gS99B6jdAiCYZg12DtX2UjIIb64A1wBrJQGNEDNsNb4UAG+3ABrZWoMIXBlQ9QQeT0FVDWYCaj0yg7cbcem8ErLn1htx82wbcBuse+PHMUI4du4a3xG/CaI4RQgDxhK+TG39kOOYfXFv0/p3+dH62mNcZ6/bY0jIodc7ZM/bU1nuUtyGRfEm5nOdaxw+9ukJ423gzhzxmfmvAPgrd3X9u4RZLmCWC7z/bIFvfgJUVhbMumLU1sMQUFsJ5KytBxEJ4SPAkljZrHFazj23akMdUTMUNjxkIT5IzgERYmCYhDhy0i4lijkB3H8+3a7bFDux8EHJJGvblKgF5GMOCFPYzcbIGMZInTw49COjWLS4zCBDYI2tI/jOBTZYHp3GQukG1+wkGxHFDa4nSF/YrgAYELFoNRsjgiP3uit1L00QwHivO0gg7SGAlJWHFweaIn9jdaHPPkueT+pDH9tvwvkYmyvwJtHspteuF7LptamA5Qrm4jFosQBsLX2bbfyHZgtuNuDtFoyJrI9+vzVyf73R8jsmNSckc4XEnR6vsnwEAHtxjvX5W9iuL6MnorUMqi2qxQpkLIxvZfuN4PmxuZI1d3MF2lwCrgWtxZXPqDUvkD05b0XBswnkT5ePqoY9XwDVBZgsGAZU1zEZAq9FUeQu1cVzfSVkcCtjzyF9uwifnPdJX07udsX8BUyRuzzzZ69u4rccLIn7xj4EU+Ry1/zmInHW2IuQIbjrfPi9qbPVfHLSjBePk5R5z+MQYhQez1xyOU5w1AhwAstm/uc6hqydioR1136YMuvli65+ADB1herJY1ytCa4FrLq0tZJJHM4DRKxHeb8l2UUTlVEXi3DUcjNyXinhM0b2MauMbOJJRgijNZKFyOp5yOth9NxTRw5SshizKjGDyPfOAVYLo7QTyyKiRZGIYSIpO4woBowRxpzo5dbGrm92DbWyyYuBB/kWFDfvDpufEmAqGGMj8ZNEG5q5MCVuup8XvJOVXgkgtlt9RhPWvgEhdP3yxJWT9hFEhOqMEE4Qx7ExJ61qE3vBUGr1s3230OgOmt1z7iZKNhYMXi7CfAiZ+2ocW+eVuJaCHXijBO1qeE9MEpNH9UJI36MnYukjA/ZOiN52A96sxeK3GWqQaWLh30dkUwGUz+tWiGHMiHvzGvjihllwKMxqgcvqKZrVI5jlFuwZ1q/hvUftNwCAupVjBfld2moJWpzDrC5gvAMZ28mDdiskb3MlVr71pazP4Tfds+xBrfkMv70ENy2w1jIi2TakrmEfn4Pqp5K1tl4g7PTpN1sle+rqGeL7Lq8A9qOkbq6Vb4zc7SN+AR2Jsr32vTZ7foehj6nH6w8iZNkYd7UGnIJEBmJ4bbI7o/8UOXJHPD9yc8mT33nt3pgTbfyIrvRYInZb5Pe4edwtCqm7C1gLs1rg/fe3+C9/0mOxsiAA5+cGZ0uDygDLJcEaYLUArAEWlQkGpy40zQMt5BhIIEPed61hBAWUoXlEMGakVQIX6gmctGEledyzHIZzEy2HWm4YCPXaP9m8oLdFAKjbUoAhBI2VCIVyuR8lXdzNL7cozSWKVlea6HrKrnNX7RE+wGtb0rkE8hfcL8k73UQSoGoBqhbCiMnGtLsUMpy2GyF8bduRPyAheyOun3usfjnx2kf+WDMxpnWRPE3EFVJO+qIgscN5JCRttDyMYYYWuwHhO8TKl1yL7JDwxTHBQLsBb8XSF0aUpDQEWixBixXo7BzV0zdAdQ0ww2/WEpOzvgSvL/vEKDynSTI3LM8F2xTJmyJ3Y/2ulTSnoOCOYRYLrP0Znm08CAtYQ1jYc5iaAHJgMFpu4D3DujWYPSonBK1uN7BeyJltlPCRARZnsLaSNfoJK+nTdXa7BtoWtF2ra+cl0LYw203nytn0iZ9pWoDFXRNbwDcqS5iBagGzJNDFY+CN1yShC0i2LnE+xvaFRC687s4BxAQuw7g9n9V3W+nstertseTN2Ydzn+umd9Mv6TexFp3CYvjQcNJ7DiR9JtEZI44DYjNzfsZSl+19JgJhvE6Cbfand6u8T+SukLo7AFkLu1yg3axR+wabZxWeXzEWywr1Ql48F3qsa/kCVhr8XFlJq3+2ENK30OMykj/CwgLWEgwhEj3dbgOtF4uJ5y6UKJK9jASG76kxfVIHDImhCaQp9AnEMDsXsteNEYgeocseb5QQkloWKyMuqHGXgCROj5X4MTriF2LpfEi6grSP799HIHUq3C23kcSFMpO1oUgAfe88r4cPcY1NV8ZeU+4TqF4BSwuytbqcekn00Tbg7RrwLSha7EasfAMiOI/s9QjaZJuM7OX7/YxdMxCrmNItkEcpD888Inw5ckER9k4EkmygfZIS3TKz5C954hf2frZ1ryNeOnazATcb4AU0J1AgeyvQYgnz9A2Yd74kdVcv4J8/g798djTJG7PihXvYNUYAGTObEHYNpi1298ZVtOCVg1nUuGxqvP8CIDXpLKzTYwsCsKpqkX3VCoYIWDmVdVsYvwV7D9sGwidErHJi3bOtErOwdpsKOFvCLs8kq64X0gffghqx8mG7lu1HNpdi2dsKYexb9yCWPUDJYAvfrIHmRReT1zQwHqB6gep8AdSPwMZKjJ/uT8tN27l2Ng38Zg00jWT4bJtIIHtWvxCHl1n3prwexmLwptpO1ecEw0602zXmZLsZ5EA96a9FdO6T4uuuSOrUdeeQvWOf31FS5RrzDJhLJA+Je7wOyYzXO5H7aCF1dwAigBY1Lj/6FP+/v/MR3vnCYzy5sDCuxmcfEz555lHV8qepl3pcyLFSkhdIX1WZ3tHqF7GqDKqKUFlgUctxWQO1BVZLQi3bdqF1wKYxWOu+xYzOkBJJnuk+RzKUEcJo5dtBDAEhbPGz1sVELTMJYmxPXskgy1Zkahk0ahk0hrptxqLbqIdnyT7WOt8lqTFdwhlbicDMCV8kfhPlY+RuQABHiB9CO93njpbnMBdPAWNFi7u5AraXCZEKFsOQMs13YwEjJG+Ha+cx1j1gNOnKgFROWP0GVr6ReL4uTrBv3Qvzm8oAusvCN2ndO4TseQ80a6BZg198ila1I7Q6h338FNXnvwTerOE+fE+seDrvPAvnlNtmimNI3rGE8K7I3X16oSq4PzDLBT56XuHr73e/y1ozPi70WGss+rLyei7HVe2xqrwQvtqL/CIniky17hlu4JlRk5I93+gxkD+19LktbL0FjEXFDjBGLHHWwngPEEDbDdg7mO0a7FuYENsXEreEo1r80DYZ8QuEUMsZEte7qoGzc6CqxcpnK3kYttKQBgZvt/Ca3CUmeWkaoG3g1mvAJ0lZYsbN/tqank9Z9zrr3zjJG5LBlCgeRgyn2o2NNafPnGsdMsahc9rZNyfFE26tc3BfrJbzt9E5fL5TFrEbufdbf567v0dziWshdXcBIpA1WK+3eP/953h2JV+eJ0/P8KUvXuA7vmjxE++2vZwP3eJZ9c5dLRLP6RcwkDvPgHOEDYCNWvmsCYRPxrRWyN75kqP88Ax89JzgfELcLOAjwdO4AZ2bi+ROz33/PJLBWE7xJb+z/qklZ1COXn1uLSS1ABlOLYFI+nLM1E8JybTGoLaE1aqGaxs0bfKgCQDrAwrWHg4p+DFaHo7RQBU4gQFYzT4mkrj+GIHccYgF8w7sO5dAIXlnoIvH4BefgbdXkvgDAAdyl2t4Bq6T2Yfo/kjqSwrEzexj02yiJjxf7Us5yTPRwsXpA0jHitY3fW7BaupNfyxD8QtHJnsh0PkMkrFk1+osVCax5mXWvmweAfl8ev1Gr8Pgy+dwl8+B9wFanaF66x0AhObr/wgSe6pjhL/NyLYOw/ntdru8EQvaLcbaFRRMgawFPOOd14CrLeGj50Cr8T/hGMhdo+e1CpuNY1wpwatVWVdbA0PAwlpYQ1hWHsYQvHHwnuED2TNC9qoqkLxmlOjBQ0gdAAsCqqW6dlYwj1kTuAhBQ7MRhZsmb8F2DVIrHwWilyVyCYq3ENsn2zdso5UhWgUBEAxoUcHXZ6DqMQACqlq0UOruyd5rBs9WXD1dK0mh2lbIn2vBrrP65bHVU2RvMn7P84h757gb6L7zfn+7s82+l3tzBFHcNy/AHEwqBl4hs/rsnqfd8dJ/TMbTucjv/T65Ir5MmPsdK6TuLpG9OK03Hh9+2uDJI4OFZVy1PNDwM+eLKffLk/rwns7BdS17X2PPaDzwzBOeXQFnC+DNx8DTc8aHzxDd5iRmTyeQkxLOXlazW+tIHuk5d5+1rY3RTHPLe8XiZqkTCuQudA3JXky4F4h8bR1wtfV4/VGFTdvAhCB3NpEAhvsPAfCBoIWYwHiM7eJDifXBMhfdF3WMmPwluiTqvONLtR68A6+fg5yDefKmCOOwryFl5CgQhWCJi6bOjJSGOJIxBCkz2AQ9MrbpvoOx8utnlrwA/T4MyF06n/y6U3vdjZVnY8yNN4vPN+nXuXdOkUgGr6/Q/uxPw7zxNszrn4P/6L3pixgzvIcj0ZtfLCsulAUPECT/nl0CTIzPvwZ8/aPM2sxBpnSyBQBaz2iDx4oSvcr1rXmVCaRPlp9lZWANobZLUVySg2dG49suds8qqWNRpuVkL7jpR9IXNhg3VmKs6yVgLWzcagdASOCyvQJrTF9q5aPEugdgQOrgXLT6GSdeH+wc0HRt0ToQGTARyFbgpQXZJTw9AVUVACOaXvVgYe/E8te2ug1MK1bAtoVvtkDbRvfPfC3vW/12k7gpC94UGQTsDsKnzzo7H7YbroNTMVZ7t4ZIrmGqvO66RHE4j3R/2UPH3EceryMfApm8SeIYcF+skfcZhdTdEdh52LpCvajxxutLvPakwltvncOTxc98s4FDBVsDVaVulnXmbhnOQ8zdiBvm0CVT4uyWNVAFN8xKvDwAsdJ9diWaT2uSmDubulFq2aT7ZX4ux5iYxCQunAOL3O7yzi2Te2OaJM4uoOszHMMYuadFZbFt2kG/wVgYX0jSRC37MEg8kmNXvbGg5YW08W56rPLifm9Amk2zfe9ndze84b/ZwcJ65Lt1rMDf1a+4XRbshH49Vkvgckv4+seJYjE0yRSHnZ9GBx+UedHDRAmgCqbWBOuekj1VCgb5t6oMalPDVARrJIGXU5LXejlWVgiWVRfOSPrGyB4A45suTts7wNYwZ1bWeQbIVuJ+zixWPtdKfK9zujdfq3v3QQPl+4QPuTUvuHqGcucA3sqerA1irJ8k8HKiCDIGxlZga0DLM+DxI3H/NFYIYCBmzvXJXyN7BPqtuoO2TZddcgcBTM+7+r7ielebgGlCGM6H7GaKdB5C1Ibr2bxsmHPWwdxbZe9YOyx2U/PZRxjnzTPvc33ZlhPFU2auDHjZiGIhdXcA9gxuHc4vVvgnfunn0HCNT585/KNvAvXSgOolzjSGLsbOKYmrs1i6QNiWCyPxcwuNo6tIPhtguRAyZ0jchBkhaQrhqgFeSOy4eOWRJF0BOgJnqIt362LrtE9O4vJMmiP1lMfbZW6VeUzdgOwl5E7uS44hO6hsy0DJOSXWN4kbYHhsthtYOFSEGFtn4GHQ39A9j52LMXMhG2eSObNX77sN4IOVaJBMJdveQbKAGlBVSwa1aiHa16vn8M8/7vXp+vZdZpDH0OWxdQE7E6VkY2TtBvvajWEqgUuOXWPmsXWxTx5b1y8fG6M7nbeI5/Pp9Rt7uagXME8ewzx5Hdw0aN/9an8PvX3Xmx2LMP7s5+0XdzoBdog2fO71C9krAISQWEv49ApoHFBXSUx1dszjvYFk6RkQP33ZVhlSxSWqT/4MG8ABTetjvHVFQhvrqtZsnAvJxgkP7z08t3DOw7CSO03sEix6IRbbJqQuEj31vjAsmZBJk2AZAKiXMFUNmEoMmCZkGmag0YQtXq17vpVtGrwDBWtecPHP4vgi+UtIXY/4AZIYpm3jGhqSsCAlXJVu92MtUK9AVhK/wFYgazsRogQQ6gbqtxsgEMC2kf1CuYvrGyOB+5K+TFnqdpHBfUSwK8/jlccUYBkJqXaPuWusbn67icwcV85wfbvHNXJyHgmZmkuCcqJ43Np+OqXnlCXxFETxPhHDQuruAt7Dbzawj17DZvUIy2WFt14DFiuLhVreljGrZZblshbhtqiVqBld+6gTXN7LOYO7MgbIiIOgMbJFTJfMJBC2KYLGewlYuv2BtEPvvCNyXogWELNbxu0ODOJ2CdB5ks6HKHW77K7F0ZUluKpmR+97siESRjBqAixGsl/GrJcTZG4i22VeDvYJeeN+W/aSYAPiEoNqIUdAhHCzBV8+19g61qQrE0Qr39PukGyYc8nbRFKT3obn2VhTe91NbXQ+SuBmkjeenN+0lndqPlMEsldnLGi5Aq3OQKtzUL2UPakun6H52k927lH75ruj7FDyNu5aNCFsJgj2QWPs6LOvXyFvBbvgNlu88ahF6xjr/KeUWeR2OTnk1r1cYRjH0DHbEMsbllAikBfJE1z7bUgDH85Jtg+qqyUqQ6grD89A6xyc8+CQjKvSI1xUHNpw9IHU9ZNxdVvu9OuNC/HUC5jleXSzJmNFGUkW5Nq4PQO7RvbmYx8JIzLXTtkkN5C5jPjlVsBABDMZJOVOXqDDNgyhjkmsfMYAZxVwvhDrn61E9hkr7y0eEuMXrH6a+IW3G/itZIfuZExf1uyz+qVflmnL4O61etc6PTfW75A1c5/L6RT619gdixgwh5yMxSVOX3c39suBPlM9hDwNQxHm9jucSObxjDfhilpi6u4x2Dn4zRbvvL3ALzALnJ3J3nSrhXw51FgTyVn4bnov5Ml7wMGj9d1X3kL3jTMArLTLCdfUfnSpRYwIqBKyF8iWQbcvHSi4PAZ3xY6QUVIOdA4xYS4gIWESb8YxixcQiBgQtTO+T9h8JGS6gCOZN+s8sv3oAqb2qRsjcMeQt0G9blpO0P2QjLrXEMnDYq/BfY0QONeI4A3C1OurS0q2rkPeptpNkbeAbP+6Xda3PKvlPvLW9cvGRELi9pGhibF6C3MuhA8gcagXwKKWPevqJVAvJPW4c+DNFXhzBf/BN+DXV9NjjF1jpPy+kLipca6jbT6WGBa8muBtg7Nqi7cfe2wa1q0KRDYy5BjyW8WY5xjf3Y2TE8B9GCN9g61YwhxDHDZUJm+lNMjNRW1QWYuqquE9w7UNnGd4GBhN6ekQLChKHIN3iOmUjMCQ7BnbeYcEQkjeAZ5V+efFCmgszPIMZJ+AnrwpsqfRvfc2l4DbgrZJds42jKXuOipzKCN78TxmTMssfM71XDTlQQUFnQf8NhLDXJnH3gvBMxVMVYEqA6wegcwTMX1VXYpIbtto5eO2AW/WYv3bbDXp2DRRm0P8pvpO1e9z5ezamtH2wPUIYFqeWsr2WfOmLHmj18gIzDBRynwL3SC52h4ckFfmYBtfnkDtsL7Z++ZBWyzMI2sl++U9hm9atM9eYHVm8fprYrHyHvCGRftHgLUMazsiVlkRFNaEo4grK8qtWJ5uDt6ROXUpId9zRSSMHZVEAZF0iXufbgge63y/jQv1YhnL94MLEPI1TrDmErF0rLzf5Fgx/i0r37ENwYC0MYt1jVmSaChBMzDR6gYiEV7MQtKcupu4JlrgxixklBO1sT3ojiFtaTuE6pQ0T5C2gEOsb5OEcAdpwjiBmyJve61ZOwjcYEwiUFWDlrW4u1pxeaW61pSvvksVvl3DX30cXYYm72WmVvUQQnaQUD8BebtOn2PHnDt2wasBv21wRs9h0OBsIWstswERwCRprRiy5rou5zEY4koZiJ9XkeYgP434DyOfIW33fQNz75MxMIBty9iCQVtJDna+WgCNQ9u6jogGYhiyJAdSpwpXp2wgkDlHch5In2EPp1vb5GEA3gn5se0GcC66fJJrQVUNc/EUZGtZW53uv7e5islb5ILBqqd9A6EKlkLfJ3M9spdb+XKSV+uaHq1+fTnAypSJPdCo62emMGQYUL0QC2VdA8vXgKoG1Qshhuy7WL9mC96sxfq3Xsf9BePfbDKxS7+82yM1tLN7+3bn4y/mab9BxueJPlPkb3yrm91kbYqIzYmTs/sSjykZ2W1pmkuk5lO12SPGRDQHELHB89t/tSnZN5cAziV/hdTdAXjbwF9t8NbjLc4XQF05GN1k25qwqHM8MgNEPkodZiF/Qp6k3kA23SYK1i6GgZM20UWxT7TyRB9TJCslU8M28whZ15+He3QdOEb+4krsuySSpP8JffQ8jkEUEqvJZ3m4QIi9MxC1GhkQgpDUa7aNunQ6wMuG4uydqGi97wRgWFyTmLUY93adDcPzF/bruEpOjDnYQy6U77XkJeW34DI5mBcAgOSFT116YNVCWgX3nkr389BF1LWa2W0N3zbg9XOg3YqLT3CbHZn34H5HzifnP+ce94y5y9/sFNa+vdefXX/82AWvNtzlFc63n2C5vUKj3xWvL54+WLmU4JCe+7DdCWz0lGAyICJ4GC3S1V/lgAQAkGSGBOIxrhHoiFcK+Qmm5Z0AojAP6td5z2icj9dN52xCzFr2Fh2tj1Exq/t1Jp4m0dskEL1AtLRt2C4nbrhuRCnlXRK/ZyxsvQQWK1C1AFwDbDfA1TORWVXIpBncMpNQAXRkLrXsxazBGbmLe42G8yoje7nlTsuttQOZIedOLIjtOsoHn9YbC6oqyUC6WoGqJ2LtU1kg2ztsZHP57UYJ36ZL8BJdF3cQt7At0wjhS/t2fabJX07iptoOrWrjFrT0KzV339Lp7XSmM5Dus7rtJH+ziB8wh6pN3eOwnf6GZpCqY7dt6JP1eTTzuuSvkLo7ADsHd3mF1+xnWNatkC+I20R0A8ySdOTugvvIFVHymaFWPA8hPFLQJ3UUZdSgfHCdri0yYhguTomQ04ZZHcV5Tr+kat98D7WsOTElataEzCXxdnGuUS2rhMar1cy3ybFFugF26vbYc4mMLpIjZAnJdYD5VrWAMaI2h6T1GnC/3RghmunOOGldi/MdBrHvImu9ecUx9HthDNiQEjJNVQoNxDdW9rAiI8c0DkNdVNm18eibLfjqUtJwt/ISM2mNnJjnWPmpyNMprG27xrpLl8k5xO0+BZgX3B+0zy+xfPG+EC4lJcykbvgSSO6JwOyTc3Frd6aOxC+QpO5cx4rleuTwNt63oIlfSebembXpeql4yUhgKhutNt6XMTkfw6NvSYmJv5L5hXszFEhdRhAraWc18UbYxsdoO+dEUYlmIx4r1RL09HPyIr95Ab563ll0ckueEkrYjtzFGHDbJ3zxGPZLjeRO/zaZWyaFduwHVj3KidaYK2eYp2vB6mHEnjvlIxndbqKCObuAffoGsFgiEr71FXizhl9fgddXkch210gUABPunnkQJ5lcFg7H6M53W+5yq9oY6Ytj6rMckpTxa42Ru31bAoXvyPT6Py039tGeeXa601n95hK/6ayi0/2mn9/u+e+Tu4XU3RGaTz7DF57/Q/jNpZAHIlD4cRIpgQjkiZIXvfxFPv1icEJkALBLyA4S8qH/8b7rA61n9MoY3PmwxMukfdHVcXb9tD6QqHTuoX6fP/W+TIu7+u+Kok/HzkkUxgTFhMVwqjztsyeua2+82ch1ZlvCuoLJ+n0Wse6a+RyAsMktoAuSUdJlaiFoICFjoQ7QmAkLsiYZS747rFbPsGEuWgd2Yj3zjZBubp2Qb9cXsIP5nsDNcWe/ExKw0/S9P0RsTpxEsdgVjMFfrWG/+hPw7/2MZH4ExLpijLxwGyvxrcZ25fVSjlUdTSas+0CyKvk8hXPStUxkrVc3R9ZjsAqysZEshRfzfQSx28+Udp6nZTk4JwEDLw0tT+RyTu4oc+EcXiPEdQWXTtvFhbv/f3tnFzvNVdfx729m9///P21BW2kKtg0WUy/wRhuCXBC8UKA0mmriReOFCCTEBKJeGKXpDZeikaiRmKCSoEGriRp6Y6AlJiYmIGB4aSHQp4DSR2ihb8/z9P+6Oz8vzjkzs2fn7czLzuzu95NsdndmzpkzZ2fnzHd+L8dMei7nJwAE0WwOedXt0NNj6PHVtfjyVKil3xe5h6H2vmaZW5c/pjSRimfZ8+L10rEBWHPp9MXcmrdIgfhbFWBL42K6OIW+nNs2nhlX1YNDzF5xK+Twkum3xQLJ8XUkp8dITo4zC2apNa9Y7BUtXx+360Re8/V+jN96mfJYP6D42h/+gDNc6NRl71wpVxPz52gS+9d0moZGsYhrhZpaJ32qRR9F3UhcvHgV8vQ3ESeJuRA6t75l9lmhaxfGlDJRkN+kwTaVda6savaMpFZErbSnYZ1t6nZF6vZRJbYCLU+Voqvpha9uHygSYHCmWHMVsu8K+4DAvlSsW2l+O9hyUW55FFmXXyvWoii9uvmusLpcwmUZNYHpRpAZy52JZzDuqgkSOzku7AS3WZnmA0VVv9SVa+PO2LbOpv+XoZOLNBVNTQaWPo4pZBuy31x8//+gp+fA+VUAmlpsZG7dLtPvVvS577N5ZgWyQk9mc+tiaIVgbB84zQ/Mw6bUKcQ8gFT3svF5sA9eNUnMTb0mmaiLVt99sZe6QUom6tYEn1tXIPzyFInAMqufc+nMYuabj7fp/p1F8PwEen4CObwRcumVwPFLdjvnGWTbVTTfmW+ZS5cvVpaLu9VxGtq1JW1UwdGnUxU5zx+7tbvJdqLJbe6SrCVRGru2ZllK8nUp9OIUenGK5NqLdn1iXPoPb0B8402Y3XIrEM2g56dYvnwNycvXIHbyeH/cX7dirbfBt5r5t2Xrlhz/dy1fX25lWy1TZrkrOiuTUpERcL6l1sYyK2TJ/6HC1bLOytbEpbJp7FyZhbOqLkfT9lXVnYeibiTOnnkOev069PlnVqw5tUIsXS8rb/5i5C9/6ysLKXhOUbn9yma1N3wN6yog/TO0r6KA1SFDck9G03gJyb+bgWBFCLlYPCeqZquT+GnerTUN7vfKI1eP2Pkp8nEf/u+ba3n6dNJZR/PumElibjxc3Fz6Mi4smizS7+appdnOZC2zn20dSJJcfEExfabCb1J2CCHWpGzzOjZvzepTmIXsN0SgUcyRphw/dRmz2+5AdMMtAMRY9ZcLk6RruUAEQBcLyNmpSd0PNevn8zUBiJwAVORc+mbmO3Lf3TyhqRVwfgiJIqhLux/P7MMve52PjchT2GuuLrMLtiYmA6dqmolTozgnmlata/5yxarocxSJPl/yZJmdVzNoponAUmubi/NO0naL9w7A9MP8AMnx9fWh2N3sOgEHZMrAuRq6de6mVO16d02yy8VOK7Em7pIk+x3TY05Wy7gkI25qijTpyKq1FZGm4i0TDp61yqsbbn0UA1DoyXXoyfU09EAOjhDdcBNmr74TmM2RXH8Jy5degJ6fZhafhiIv347+RV7RNquUi6l1i6IvSrJYPs/9t0CA1Yu5astckciqi6kLEXt1sYfZdsXHurpNmDWvrF/roKgbiYvnXsDi5XOTrSl9mrRuJl8jdZE0JVY/l5XXwo/FN8a+5arsCPwVTU64ljd0+UDfFta6SlZcQp0rhP1c1LcmeCtNRmPcR/NurrntFFmWLieK8nF+dj/ma86tZM2N1WtyrxaT/urqIrRC9zWG1WgIQRQ2707/+2+zfRthxikLSCinzz4PPPs8IhtrJbGJr42PjoDZHPHhoUmAcXCYusjhkpnwOprFK0IPC+NBIOdJtjxZVoo/s0/jJq4A4CyCzhqVtwxaIQiJjKiUCJgdGI+JeG5u+uLYekxExi1UE/tAzlgFoWrEmyZIEnP9V/soMLUG+mLO1pfHibsse7O9ifVEXGrBSzLXSTMdTwSxMcsihyZDJgBdnCO5+pwd75zoc9atTMRmDQn8z6fHsSxZnn+yaQVgVCzAysSdE8mSJOY3wKr1Lr9tqbhz5OoUJMDiDHr1DMurz0EViG76Ecxuux1IElw8e8Vkvl7bpy9e8vvwtynoB4SJPL+u0KQiq3UXexWFiLymYq4skUvR+jqBVVd3VDHR+pAir65OTmmwBfzgsc8ACLtJGiKxQNOTZWhCUsr2v++mwbXTY5M3zH1aWvo4l/s49i7H1Ed/dK2jSx/00f5+fkda8MgqL3znhwCya7MbH+K5zRjpxJ5d7r7H88iKqBniIzNFSXxohGB0eAiZ2/f4IMtUubQxVXoBXSxMNumFiSuLIgBJkgnAVGR67zm30Lz1T+LZinVQXDZeicw8mFFkBKPE1k00Si2GvlUQEmWxgEliHgRLPubeShDVLLMzrCdKkn3Pu+m7WGfRmRGSujRC+PzUCJGFmfBbkLPclYm5/PJULOrqNmVJwvy4dj+2zvdGya/zy5bEqIfgCy0n7nzvKYkkFYtp5msB9OWXkFx7EXLpRhzc8Tpc/O+TWcydJ+6KKRZxVe6VQJ3Ia2LFK9ouX3+9Fa/ZHsItiOVtKXd3bOO66crXWfOaCrMqi6JPqNjzoagbkZMXjkvX9XGjNIZYG1KYDSG8+mzvmKJ0Gxjjxr3vfQ4hoKcmlH36bB8tdqQppy+dAcjGsWjuibhYVr9bsRXFUiD4zNgR+3W4MkfG2hcfHRnRdWitf0dHwKGNy4ujVCwZwZcYsbO01sCTM2MNdDfsvvjLib7U/TMn/PLfS99tEirMbHy0m75FbLbgSBBF87x/ovUacV4hzgskgcvybD4vi2PAy6YTqhFmzm2/cpu0ymIhVjUFT6iYK0ygUpLUxC/TLutwzmvq4gxpKMfEqMtkGVLGt/71Sfk+y9vf5tj88nVWs6Zxb8XtC+uvpsdDUTcip1fPxm5CJUOIlCGEZh/tbCMY+9jvVKykjj6OaVesLptOt7+JftuEqNqV35+My8WxySjorkliU+OviTn3PV0epda8tGzkRN3q8lT8XTtd+Z4KyVmcCsJoZtwn5cBa+w4OjPBbsf7NMvEmAr24gFirn5xb8YcLY/1bLtPsv04Awrf++eLPjVP59V6yFcTebV3Ta3rR/3Ytxr9E5PnbV+UHaJpN2hdwuTpaiTjvOPzs1n7ZsozQa8eVb7NDBHLpRsiNr0R06QYsnrmyLpyL2otpXj+7CKSyslEsBe6NwwnD9XZtbl99toOJUibM2bXzQesfUjBsjeBrUWeowGvTF+5YlzXb9b3fIZmiC+vYF+w+mMogzznlyCa5OLYibuauczYmLPbEXCr6onT5okLw5cvkxVt+eSb+olTUZetOVutwQtB7Rxyn1j6xMYCYzRAfHUEPDo3Fzm0LNWnxVYHlBWSRCUAsF5mNx7U/L+rS449XtlmfG82Px2txvS5xZywVaECtEGwsnpxVcaWsJwTTXZQsLxByoSKuaMoBnR0gOrwEOboEOboBkAjJyctIrr6A5TNP17en4HuXqQuaMkQyrKZl+xxPqqxqQ1JnsQuhL5FJUTcii9PF2E1YYdtEYFp33F1MrB57sdQKPYaq/iwTc21EaFp2A6Kqug+2X0DtGlMRhHXsgvgm/bI8MeeEu1Zm4s4gc/GWZ6KvTPA5/PXxQSbi8sujWArdO1e2qYjty9eZt/il+3FC9PAAMjuwbqAzRIeHQGySv8iBjbUTK9ycxWfpEpaoSXKyXEKXSyMAXTxbLjlZeu32xVzumi5thF4BxdaskmtRwFRBjedmramz0vrnl7EZT8WKdJnNIfMDMy3GzMYhnp1Cz06xvH4V+sPvm6l8CtpZJeIK21bX9qI6CqyBTQVgk+26TuNTRds6tmWc2wQUdSNy9oOLje7PDYJj4A/IQ9HHMYa2NUSItRXOXURx/6J3GKZmeRySIfqTljSySyyuFj/0lHnx9Sx/3fbHgTJB6K/3rYBAsSUwv7zOGuiLO4mk1EKYWQV9d9GcMIwik+kzjhFZt0/EM0TzmX0/AOJDRAcHq+0HoMkSRgQmXjKTxAqhJBNfdv5c1cRkynSxeTnR0JcIrKJQILp1ZTfzThykc6/ad5j+QzRPE8SowMQjWuHm3p2A1KVJHKPn59DFBfT0OvTi3MTKLVfnWe0ilvztyjOg11g6K8qHTxTevY6qcSm0ribr+5iyqK6epmNtn5m8m9bZSdSJyB8D+GUA5wCeAvAuVX3RrnsQwHtgHp/9tqp+yi6/F8CfwUwc8teq+odd2rDNLE/sk8WSQap3Fv3d9IUKn+VF/zechQKuh2PUUFEXICTLnjo32k9bIXBhLhpdhERinz9M3eLahU3GNy75ZHEv4BjZnqTkWh6VeAQs3TVqHq2NA/41XRZSvT53Tc8E3+p+q9w/88uXBaKvSbKXouVZjOBxWleZQPTjCSU2Iiaaz61raGxEWRxDothm5YxtUpgYMj80oiiyy1yymLyQqxoPVLE+1Y/3Dru+ENv+/Nyw6buYpDD2e+lUR958q1gs0u+6XJqEN0mCZLmALhbQhc38mWS+NCGWqVArVuH2gVMZ9dO+7nU46gRPuzltu60v229oHVMWc46ulrpHATyoqgsR+RCABwH8gYi8HsADAH4awI8DeExEfsqW+QiAtwJ4GsDnReQRVf1ax3ZsJW7QKhukpsyyxsi4EaHaQsA1EVNlArRUvDVoh7/fpiJ3ZZ+Bx7u2zxaWnDUhOWBWVk26RBiu0kZ8LvvbfRBji1kyKBwje6ZM7DmKxtMVwQcEib4ywec/oAsRfeVWvuVKmbU6KtxD19Z5Vr+6uiSSNRd+f9v1OL2SuL2cAJPITZ+Q2zY31UKZtS+dtzcvctJ5enXNalhYR49ze1bVVXvD3WLO2bZujiEuk3V1drFWdRFR3Sx13S1xjj5FXLZtf+0ropOoU9VP575+FsCv2c/3A3hYVc8AfFtELgN4o113WVW/BQAi8rDddq8HrLpBahvwBYReTFOo+mI0SHyWPTkeQijW7LPJfpsIxy77D22PoxdxWbuT4cRn3/QpZsvYJ9fWKcExsj1ac/0qu3ZVjaeNrHzAynWvrZWvSvTVWfnSuhq4eDYRflXri0RdWTv8sv767HtUuq5om0pk4GtXjTAsLdbg5rwPV8DuVqz2YrSN62TzdjWxZg3ff46Q8IXmCWb6e6jQlD5j6t4N4B/t59thBjDH03YZAHzXW/5zRZWJyHsBvBcAbt3R0L+6QasNY8XNTVWY1gmNPsRn8SSaDXHW2hbumK2FYsH+ywhpV52I7HRuNjy/+ozdDBGfXRLcbIRAkTu1qTZ2BI6RPVI1frYRfED/Vr7C9XMJtvKlZUtcPFeW1WT6bGL1S/dXIgCz9Z4lz2tLcZni8bLuwdOUH0y1vSHv002vX8tTB6tkwHZ9iqMxxVu2/XAirmm7a0cCEXkMwKsLVj2kqp+02zwEYAHgEwFtrERVPwrgowBwtxxNUzFMkCGE4jbjhMagYndRb2mpt6p1b0bZTUcXusQArnFSvLjP36bql9hUsp4ixkxS1IYlxu2vbYJj5PRoOw5Wjhcl1/m1GGzvOlflDdI0gYtPUcxfuq5kyodsfbgwTMt6AtFfnn2P1pbVlcmXLV6+vn1ToTdlQdiUIaYV6LNcm8yVQwmbNnVn5YY/DqB9YrPOiVJU9Rer1ovIbwL4JQC/oFm06hUAd+Y2u8MuQ8VyQgajD7Hb5ca8qyWzyQ12H1bHshuQISyx7piGfhDhfrcxrMmbOsauFJ3bU7W+Tw2OkbtHiBWwjfUvLet7edRZAd2+q9xDS9w/0/VxceIsiaR26oe15Wt1uPLLYFGXL1u0vqgOn3prX3uvmrGE4ZDp+rtMQ9C1XW1ETbu5+DZ/jF0yUXft167ZL+8F8PsAfl5Vj3OrHgHw9yLyYZgg8LsB/BcAAXC3iNwFM1A9AODXu7SBkE0RemPep3WmjxvsTQlDR1284pBCMc8mBVXoDd+mqHdDnkY7dw2OkbtH2X+lzxi/tGyN6Itmsub23jbmD1gXfGVZj8vF33rcYHospQLQUSzm8vW4NreN08u3rw66oPc7TU4f4nRMEQqMK9ayeqr7oKsj/l8AOATwqE07+1lV/S1VfUJE/gkmuHsB4H2qugQAEXk/gE/BpGv+mKo+0bENhEySLjfKQ7jrdREYbVzxNikQHUOKqGaieDwBWcVUxKXPHrh4cozcE9okduli5QOM2/7atdGL0w4RffVWPvv9ol78lQm/dH2JwKoTg6ZsmYtmdX9VCTVfKCbF0yTWtmHf6WMS8vU6+xu/dkmoFiGl83tMiLvlSP909tqxm0HIpJl63NZUbuA3Ni9kIFPpn6YMeb699crjX1TVNwy2gx2DY+R20/a/1OSa0WSy9rI2tI75y4mnxrF0NSKwqmyZWKtKYNVUlIW4XW7CujekG+iQrp4h9Cm8yhjiWAcRtAV98cb//Fzp+Lh/KbMI2VGmaiVyTMVaNNV5ITtNtzEGI2QkJWQX6ZLYpX5amvAEL+7a45dskrilzbaV2xcIpbaxdVVzgjYVZEOLvMlnUt4xikTTJhhKuFLUEUKCmZpraQibik/sypBzPW5SME5FzBOyi/Q5n1+W2Kn42lM6fU/B1DylmUQL4gLz26+1u6Cda4LUlXGCqOSGOaqatHpZIxSdIGxwM+7E3DLQGiSR9DLHar4NJIxNWAlDCLUoUtQRQjZKG0E4thD06VOojGHJGlIwOiZvaSRkDwhJ7FJ2XasTe2n5ItFXMxdrqPjLl3FUCcB82aK5R2uFoF2vSfmEOb71blkzy1GpxTBAMNYRKijz7MIUEH0wFXfUECjqCCGTZ5stg3Vsu0AsYxPCkRDSjqJrautJ2xuIvlIrn6ujcm2Nq2lb4Zgrm7Zj5gu0ElGcF1c1YswXYiEC0adOMKb1VLia1tLCWrWPlsGpWfUAijpCyI7TNdZw6qIwz64KRELI8IRO1+CocuXM6m5h5fPrrFlfKd6AFQFXJwAdXepK6/Ru/ivj5moshk3pIhzbsBGxuYPost+HnxR1hBBSwVhzuI0tJhkLRwgB2l0Dg29VvYQuRULJTyblk7p8N7h2lcXlrXHi6i7fvmlCmTpC9uHT50O4QZO1FIj7fbTyDQVFHSGETJBddjklhOw2ba1+jspJ20sETFOXb5lHjR9aZa6lza/HrW0vC20tzmqtlIHtADbnrUFH/f6gqCOEkB1jn1xOCSHbQ9tsnXmaxviVt6FeRjirX4jHQhsBuLpPae0h0XXffjuAYb018r/RWNMKdGWK009Q1BFCCFmhzxsDQghpSlcLH9BMjPQh/IDVLL+hImg97rB9Zug+p+oZIuTA//3Gdu/vwwo5RTFKUUcIIaR3xopFJITsHlXXkzYPkLpa+xwhVr/QNhTRhxB0DCG0yl1jhx0PQs+BsUXlUFDUEUIIIYSQrWSI+ONeMwn3GDXmJ4vpNB9oT8I2j589tIpevTk6/l67ku2Zoo4QQgghhOwdfcT41RGalCWEkPlAQwVgH5bEKvq03nX9ncay3PUtJinqCCGEEEII8diE6HO0ScoSQogAzBMiBod04axiSPfOIePD+xaTFHWEEEIIIYQE0kRMDCEKhrT++bQRg13cQscShmVsIj68r3NEVKcfLCgiPwDwP2O3owWvAvDDsRuxxbD/usH+6wb7rxtd+u+1qnprn43ZZThG7i3sv26w/9rDvuvGIOPjVoi6bUVEvqCqbxi7HdsK+68b7L9usP+6wf4jdfAc6Qb7rxvsv/aw77oxVP91SJtDCCGEEEIIIWRsKOoIIYQQQgghZIuhqBuWj47dgC2H/dcN9l832H/dYP+ROniOdIP91w32X3vYd90YpP8YU0cIIYQQQgghWwwtdYQQQgghhBCyxVDUEUIIIYQQQsgWQ1E3ECJyr4h8Q0Qui8gHxm7PVBGR74jIV0XkSyLyBbvsFhF5VESetO832+UiIn9u+/QrInLPuK3fPCLyMRF5VkQezy0L7i8Reafd/kkReecYx7JpSvrugyJyxZ5/XxKR+3LrHrR99w0ReXtu+V7+t0XkThH5dxH5mog8ISK/Y5fz/CNB7Ot/KBSOj2FwfOwGx8huTGKMVFW+en4BiAE8BeB1AA4AfBnA68du1xRfAL4D4FXesj8C8AH7+QMAPmQ/3wfg3wAIgDcB+NzY7R+hv94C4B4Aj7ftLwC3APiWfb/Zfr557GMbqe8+COD3CrZ9vf3fHgK4y/6f433+bwN4DYB77OdXAPim7Seef3yFnEd7+x9q0VccH8P6i+Nj//3HMbJ5/40+RtJSNwxvBHBZVb+lqucAHgZw/8ht2ibuB/Bx+/njAH4lt/xv1fBZAD8qIq8ZoX2joar/AeB5b3Fof70dwKOq+ryqvgDgUQD3Dt74kSnpuzLuB/Cwqp6p6rcBXIb5X+/tf1tVv6eq/20/XwPwdQC3g+cfCWNv/0M9wfGxBI6P3eAY2Y0pjJEUdcNwO4Dv5r4/bZeRdRTAp0XkiyLyXrvsNlX9nv38fQC32c/s12JC+4v9uMr7revDx5xbBNh3lYjITwD4WQCfA88/EgZ//+ZwfOwOr0/d4RgZyFhjJEUdGZs3q+o9AN4B4H0i8pb8SjW2aM670RD2VzB/CeAnAfwMgO8B+JNRW7MFiMhNAP4ZwO+q6tX8Op5/hPQKx8ceYX+1gmNkIGOOkRR1w3AFwJ2573fYZcRDVa/Y92cB/CuM6f4Z5zZi35+1m7NfiwntL/ajRVWfUdWlqiYA/grm/APYd4WIyBxmsPqEqv6LXczzj4TA378hHB97gdenDnCMDGPsMZKibhg+D+BuEblLRA4APADgkZHbNDlE5EYReYX7DOBtAB6H6SuX7eedAD5pPz8C4DdsxqA3AXgpZ9LeZ0L761MA3iYiN1tXirfZZXuHF3PyqzDnH2D67gERORSRuwDcDeC/sMf/bRERAH8D4Ouq+uHcKp5/JIS9/Q+FwPGxN3h96gDHyOZMYoxsk+GFr0ZZcO6DyXzzFICHxm7PFF8w2ZG+bF9PuH4C8GMAPgPgSQCPAbjFLhcAH7F9+lUAbxj7GEbos3+AcYG4gPGzfk+b/gLwbpjA5ssA3jX2cY3Yd39n++Yr9gL7mtz2D9m++waAd+SW7+V/G8CbYdxGvgLgS/Z1H88/vlqcS3v5HwrsI46P4X3G8bH//uMY2bz/Rh8jxRYmhBBCCCGEELKF0P2SEEIIIYQQQrYYijpCCCGEEEII2WIo6gghhBBCCCFki6GoI4QQQgghhJAthqKOEEIIIYQQQrYYijpCCCGEEEII2WIo6gghhBBCCCFki/l/vfB7P/EcCI0AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -561,7 +599,7 @@ } ], "source": [ - "fig, axarr = plt.subplots(1,2,figsize=(15,5))\n", + "fig, axarr = plt.subplots(1, 2, figsize=(15,5))\n", "\n", "# Plot the aligned case\n", "horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles_zero_viz)\n", @@ -577,7 +615,7 @@ "id": "9295cd9d", "metadata": {}, "source": [ - "Visualization makes a new grid of points on the plane to be visualized in addition to those on the rotor. This is done within the calculate_horizontal_plane call. The grid is however set back to how it was originally at the completion of the funcion as can be confirmed" + "Visualization makes a new grid of points on the plane to be visualized in addition to those on the rotor. This is done within the `calculate_horizontal_plane` call. The grid is however set back to how it was originally at the completion of the funcion as can be confirmed." ] }, { @@ -605,7 +643,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -623,12 +661,12 @@ "zs = fi.floris.grid.z\n", "\n", "# Consider the shape\n", - "print('xs has shape: ',xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", + "print('xs has shape: ', xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", "\n", "# Lets plot just one wd/ws conditions\n", - "xs = xs[0,0,:,:,:]\n", - "ys = ys[0,0,:,:,:]\n", - "zs = zs[0,0,:,:,:]\n", + "xs = xs[0, 0, :, :, :]\n", + "ys = ys[0, 0, :, :, :]\n", + "zs = zs[0, 0, :, :, :]\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", @@ -649,11 +687,11 @@ "id": "34bc7865", "metadata": {}, "source": [ - "Calculating AEP in FLORIS V3 takes advantage of the new vectorized framework to substantially reduce the computation time with respect to V2.4\n", + "Calculating AEP in FLORIS V3 takes advantage of the new vectorized framework to substantially reduce the computation time with respect to V2.4.\n", "\n", "In these examples we demonstrate a simplied AEP calculation for a 25-turbine farm using several different modeling options.\n", "\n", - "We will make a simplifying assumption that every wind speed and direction is equally likely" + "We will make a simplifying assumption that every wind speed and direction is equally likely." ] }, { @@ -666,19 +704,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "Calculating AEP for 1368 wind direction and speed combinations\n" + "Calculating AEP for 1368 wind direction and speed combinations...\n" ] } ], "source": [ - "wind_directions = np.arange(0.,360.,5.)\n", - "wind_speeds = np.arange(6.,25.,1.)\n", - "\n", + "wind_directions = np.arange(0., 360., 5.)\n", + "wind_speeds = np.arange(6., 25., 1.)\n", "\n", "num_wind_directions = len(wind_directions)\n", "num_wind_speeds = len(wind_speeds)\n", "num_bins = num_wind_directions * num_wind_speeds\n", - "print('Calculating AEP for %d wind direction and speed combinations' % num_bins)" + "print('Calculating AEP for %d wind direction and speed combinations...' % num_bins)" ] }, { @@ -731,9 +768,9 @@ "outputs": [], "source": [ "# Assign the layouts, wind speeds and directions\n", - "fi_jensen.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)\n", - "fi_gch.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)\n", - "fi_cc.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)" + "fi_jensen.reinitialize(layout=(X, Y), wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "fi_gch.reinitialize(layout=(X, Y), wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "fi_cc.reinitialize(layout=(X, Y), wind_directions=wind_directions, wind_speeds=wind_speeds)" ] }, { @@ -741,7 +778,7 @@ "id": "1147b4a7", "metadata": {}, "source": [ - "Calculate the AEP and use the jupyter time command to show computation time" + "Calculate the AEP and use the jupyter time command to show computation time:" ] }, { @@ -854,11 +891,11 @@ "outputs": [], "source": [ "# Demonstrate on 7-turbine single row farm\n", - "X = np.linspace(0,6*7*D,7)\n", + "X = np.linspace(0, 6*7*D, 7)\n", "Y = np.zeros_like(X)\n", "wind_speeds = [8.]\n", - "wind_directions = np.arange(0.,360.,2.)\n", - "fi_gch.reinitialize(layout=(X,Y),wind_directions=wind_directions,wind_speeds=wind_speeds)" + "wind_directions = np.arange(0., 360., 2.)\n", + "fi_gch.reinitialize(layout=(X, Y), wind_directions=wind_directions, wind_speeds=wind_speeds)" ] }, { @@ -940,7 +977,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -954,9 +991,9 @@ "source": [ "# Show the results\n", "yaw_angles_opt = np.vstack(df_opt[\"yaw_angles_opt\"])\n", - "fig, axarr = plt.subplots(len(X),1,sharex=True,sharey=True,figsize=(10,10))\n", + "fig, axarr = plt.subplots(len(X), 1, sharex=True, sharey=True, figsize=(10, 10))\n", "for i in range(len(X)):\n", - " axarr[i].plot(wind_directions,yaw_angles_opt[:,i],'k-',label='T%d' % i)\n", + " axarr[i].plot(wind_directions, yaw_angles_opt[:, i], 'k-', label='T%d' % i)\n", " axarr[i].set_ylabel('Yaw (Deg)')\n", " axarr[i].legend()\n", " axarr[i].grid(True)\n", @@ -966,9 +1003,9 @@ ], "metadata": { "kernelspec": { - "display_name": "env_testv3", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "env_testv3" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -980,7 +1017,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.8.0" } }, "nbformat": 4, From e7ee5e4db4f56842c0fb13a93923cfc61521dc38 Mon Sep 17 00:00:00 2001 From: Paul Date: Tue, 22 Feb 2022 22:07:36 -0700 Subject: [PATCH 14/28] remove commented code --- examples/03_making_adjustments.py | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/examples/03_making_adjustments.py b/examples/03_making_adjustments.py index 77b57b55c..f40125d47 100644 --- a/examples/03_making_adjustments.py +++ b/examples/03_making_adjustments.py @@ -35,13 +35,6 @@ # Initialize FLORIS with the given input file via FlorisInterface fi = FlorisInterface("inputs/gch.yaml") -# # Configure this simulation for visualization using the full flow field grid -# solver_settings = { -# "type": "flow_field_grid", -# "flow_field_grid_points": [200,100,7] -# } -# fi.reinitialize(solver_settings=solver_settings) - # Plot a horizatonal slice of the initial configuration horizontal_plane = fi.calculate_horizontal_plane() @@ -68,7 +61,6 @@ fi.reinitialize( layout=( X.flatten(), Y.flatten() ) ) horizontal_plane = fi.calculate_horizontal_plane() visualize_cut_plane(horizontal_plane, ax=axarr[3], title="3x3 Farm", minSpeed=MIN_WS, maxSpeed=MAX_WS) -# plot_turbines_with_fi(axarr[7], fi) # Change the yaw angles and configure the plot differently @@ -95,10 +87,4 @@ axarr[5].invert_xaxis() -plt.show() - - -# # Change the veer -# fi.reinitialize(wind_veer=5.0) -# fi.floris.solve_for_viz() -# plot_slice_shortcut(fi, axarr[5], "Veer=5") +plt.show() \ No newline at end of file From 121af48010b0ef017f3bb8987a913831ab5c0a6f Mon Sep 17 00:00:00 2001 From: Paul Date: Tue, 22 Feb 2022 22:08:49 -0700 Subject: [PATCH 15/28] Remove commented code --- examples/12_streamlit_demo.py | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/examples/12_streamlit_demo.py b/examples/12_streamlit_demo.py index 2bd01e4ae..7a3a58452 100644 --- a/examples/12_streamlit_demo.py +++ b/examples/12_streamlit_demo.py @@ -163,14 +163,4 @@ st.header("Visualizations") st.write(fig_viz) st.header("Power Comparison") -st.write(fig_turb_pow) - -# print(farm_power_results) - -# # Show the farm results -# df_farm = pd.DataFrame.from_records(farm_power_results, columns = ['model','yaw','power']).set_index(['yaw','model']).unstack() -# df_farm.columns = [c[1] for c in df_farm.columns] -# fig, ax = plt.subplots() -# df_farm.plot.bar(ax=ax,color=color_dict,rot=90) -# st.write(fig) -# print(df_farm) \ No newline at end of file +st.write(fig_turb_pow) \ No newline at end of file From c6c9fec7fb2ffc386097d091397b26a7532fb805 Mon Sep 17 00:00:00 2001 From: Paul Date: Tue, 22 Feb 2022 22:09:48 -0700 Subject: [PATCH 16/28] small edits --- examples/00_getting_started.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index 7ddec38d3..f6b189cec 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -1003,9 +1003,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "env_testv3", "language": "python", - "name": "python3" + "name": "env_testv3" }, "language_info": { "codemirror_mode": { @@ -1017,7 +1017,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.0" + "version": "3.9.5" } }, "nbformat": 4, From 5db45d89a9f81cdd6c747781cfbc8c6d3185051f Mon Sep 17 00:00:00 2001 From: Paul Date: Wed, 23 Feb 2022 13:13:06 -0700 Subject: [PATCH 17/28] avoid calculating 0 m/s --- examples/07_calc_aep_from_rose.py | 32 ++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-) diff --git a/examples/07_calc_aep_from_rose.py b/examples/07_calc_aep_from_rose.py index 041f41b79..f348a2185 100644 --- a/examples/07_calc_aep_from_rose.py +++ b/examples/07_calc_aep_from_rose.py @@ -12,6 +12,7 @@ # See https://floris.readthedocs.io for documentation + import numpy as np import pandas as pd from scipy.interpolate import NearestNDInterpolator @@ -29,11 +30,19 @@ # Read the windrose information file & normalize wind rose frequencies fn = "inputs/wind_rose.csv" df_wr = pd.read_csv(fn) + +# Normalize the frequencies df_wr["freq_val"] = df_wr["freq_val"] / df_wr["freq_val"].sum() +# Split the wind rose into wind speeds above (df_wr_op) +# and below cut-in (df_wr_below_cut_in) as below cut-in winds are 0 power and +# 0 ambient wind speed generates warnings and nans in some of the wake models +df_wr_below_cut_in = df_wr[df_wr.ws < 3.0] +df_wr_op = df_wr[df_wr.ws >= 3.0] + # Derive the wind directions and speeds we need to evaluate in FLORIS -wd_array = np.array(df_wr["wd"].unique(), dtype=float) -ws_array = np.array(df_wr["ws"].unique(), dtype=float) +wd_array = np.array(df_wr_op["wd"].unique(), dtype=float) +ws_array = np.array(df_wr_op["ws"].unique(), dtype=float) # Load the default example FLORIS object fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 @@ -54,13 +63,22 @@ farm_power_array = fi.get_farm_power() # Now map the FLORIS solutions to the wind rose dataframe -X, Y = np.meshgrid(wd_array, ws_array, indexing='ij') +wd_grid, ws_grid = np.meshgrid(wd_array, ws_array, indexing='ij') interpolant = NearestNDInterpolator( - np.vstack([X.flatten(), Y.flatten()]).T, + np.vstack([wd_grid.flatten(), ws_grid.flatten()]).T, farm_power_array.flatten() ) -df_wr["farm_power"] = interpolant(df_wr[["wd", "ws"]]) -df_wr["farm_power"] = df_wr["farm_power"].fillna(0.0) + +# Use an interpolant to map the results back to the wind rose dataframe +# Technically this could be done directly but an interpolant is safer +# in the event the wind rose is irregular and/or ordered differently +# than floris +df_wr_op["farm_power"] = interpolant(df_wr_op[["wd", "ws"]]) +df_wr_op["farm_power"] = df_wr_op["farm_power"].fillna(0.0) + +# Recombine with the below cut-in data +df_wr_below_cut_in["farm_power"] = 0. +df_wr = df_wr_below_cut_in.append(df_wr_op).sort_values(["wd","ws"]) print("Farm solutions:") print(df_wr) @@ -68,4 +86,4 @@ # Finally, calculate AEP in GWh aep = np.dot(df_wr["freq_val"], df_wr["farm_power"]) * 365 * 24 -print("Farm AEP: {:.2f} GWh".format(aep / 1.0e9)) +print("Farm AEP: {:.2f} GWh".format(aep / 1.0e9)) \ No newline at end of file From 3d366a4d5f23720796bd202707a6096e39f738d5 Mon Sep 17 00:00:00 2001 From: Paul Date: Wed, 23 Feb 2022 13:20:07 -0700 Subject: [PATCH 18/28] copy dataframes --- examples/07_calc_aep_from_rose.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/examples/07_calc_aep_from_rose.py b/examples/07_calc_aep_from_rose.py index f348a2185..d1701112c 100644 --- a/examples/07_calc_aep_from_rose.py +++ b/examples/07_calc_aep_from_rose.py @@ -32,13 +32,13 @@ df_wr = pd.read_csv(fn) # Normalize the frequencies -df_wr["freq_val"] = df_wr["freq_val"] / df_wr["freq_val"].sum() +df_wr["freq_val"] = df_wr["freq_val"].copy() / df_wr["freq_val"].sum() # Split the wind rose into wind speeds above (df_wr_op) # and below cut-in (df_wr_below_cut_in) as below cut-in winds are 0 power and # 0 ambient wind speed generates warnings and nans in some of the wake models -df_wr_below_cut_in = df_wr[df_wr.ws < 3.0] -df_wr_op = df_wr[df_wr.ws >= 3.0] +df_wr_below_cut_in = df_wr[df_wr.ws < 3.0].copy() +df_wr_op = df_wr[df_wr.ws >= 3.0].copy() # Derive the wind directions and speeds we need to evaluate in FLORIS wd_array = np.array(df_wr_op["wd"].unique(), dtype=float) @@ -74,16 +74,12 @@ # in the event the wind rose is irregular and/or ordered differently # than floris df_wr_op["farm_power"] = interpolant(df_wr_op[["wd", "ws"]]) -df_wr_op["farm_power"] = df_wr_op["farm_power"].fillna(0.0) # Recombine with the below cut-in data df_wr_below_cut_in["farm_power"] = 0. df_wr = df_wr_below_cut_in.append(df_wr_op).sort_values(["wd","ws"]) -print("Farm solutions:") -print(df_wr) - # Finally, calculate AEP in GWh aep = np.dot(df_wr["freq_val"], df_wr["farm_power"]) * 365 * 24 -print("Farm AEP: {:.2f} GWh".format(aep / 1.0e9)) \ No newline at end of file +print("Farm AEP: {:.3f} GWh".format(aep / 1.0e9)) \ No newline at end of file From 9bc0f5205f9ed3d766e50f45832984a014f6bf44 Mon Sep 17 00:00:00 2001 From: Paul Date: Wed, 23 Feb 2022 14:59:09 -0700 Subject: [PATCH 19/28] update getting started --- examples/00_getting_started.ipynb | 94 +++++++++++++++++-------------- 1 file changed, 51 insertions(+), 43 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index f6b189cec..de3423ff8 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "id": "a700d720", "metadata": {}, "outputs": [], @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "602f311c", "metadata": {}, "outputs": [], @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "d040b810", "metadata": {}, "outputs": [], @@ -126,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "6f9d834a", "metadata": {}, "outputs": [], @@ -159,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "e3bf1698", "metadata": {}, "outputs": [], @@ -192,7 +192,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "be78e20d", "metadata": {}, "outputs": [ @@ -206,7 +206,7 @@ " [0., 0., 0., 0.]]])" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "0f041620", "metadata": {}, "outputs": [ @@ -237,7 +237,7 @@ " [25., 25., 0., 0.]]])" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -268,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "6054265f", "metadata": {}, "outputs": [], @@ -292,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "7de24fe5", "metadata": {}, "outputs": [ @@ -306,7 +306,7 @@ " [2407.84258855, 2407.84258855, 2319.53233514, 2319.53161349]]])" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -464,7 +464,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -503,7 +503,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -578,7 +578,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -587,7 +587,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -643,7 +643,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -696,7 +696,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 40, "id": "f63a2195", "metadata": {}, "outputs": [ @@ -704,13 +704,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Calculating AEP for 1368 wind direction and speed combinations...\n" + "Calculating AEP for 1440 wind direction and speed combinations...\n" ] } ], "source": [ "wind_directions = np.arange(0., 360., 5.)\n", - "wind_speeds = np.arange(6., 25., 1.)\n", + "wind_speeds = np.arange(5., 25., 1.)\n", "\n", "num_wind_directions = len(wind_directions)\n", "num_wind_speeds = len(wind_speeds)\n", @@ -749,7 +749,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 42, "id": "6a381dc7", "metadata": {}, "outputs": [], @@ -762,7 +762,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 43, "id": "7547d804", "metadata": {}, "outputs": [], @@ -783,7 +783,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 44, "id": "702bb7ee", "metadata": {}, "outputs": [ @@ -791,8 +791,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.09 s, sys: 1.19 s, total: 4.29 s\n", - "Wall time: 3.3 s\n" + "CPU times: user 3.27 s, sys: 1.24 s, total: 4.51 s\n", + "Wall time: 3.49 s\n" ] } ], @@ -804,7 +804,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 45, "id": "8b688add", "metadata": {}, "outputs": [ @@ -812,8 +812,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 5.48 s, sys: 1.47 s, total: 6.95 s\n", - "Wall time: 5.64 s\n" + "CPU times: user 5.52 s, sys: 1.39 s, total: 6.91 s\n", + "Wall time: 5.67 s\n" ] } ], @@ -825,7 +825,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 46, "id": "627f5242", "metadata": {}, "outputs": [ @@ -833,8 +833,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 7.14 s, sys: 1.24 s, total: 8.38 s\n", - "Wall time: 8.45 s\n" + "CPU times: user 7.8 s, sys: 1.35 s, total: 9.15 s\n", + "Wall time: 9.2 s\n" ] } ], @@ -846,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 47, "id": "394ab742", "metadata": {}, "outputs": [ @@ -854,9 +854,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Jensen 883.9 GWh\n", - "GCH 884.4 GWh\n", - "CC 879.6 GWh\n" + "Jensen 843.1 GWh\n", + "GCH 843.8 GWh\n", + "CC nan GWh\n" ] } ], @@ -885,7 +885,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 26, "id": "32a93c6d", "metadata": {}, "outputs": [], @@ -900,7 +900,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 27, "id": "7d773cdc", "metadata": {}, "outputs": [], @@ -918,7 +918,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 28, "id": "1ccb9ab7", "metadata": {}, "outputs": [ @@ -940,8 +940,8 @@ "[Serial Refine] Processing pass=1, turbine_depth=4 (78.6 %)\n", "[Serial Refine] Processing pass=1, turbine_depth=5 (85.7 %)\n", "[Serial Refine] Processing pass=1, turbine_depth=6 (92.9 %)\n", - "CPU times: user 1.49 s, sys: 344 ms, total: 1.83 s\n", - "Wall time: 1.44 s\n" + "CPU times: user 1.48 s, sys: 352 ms, total: 1.84 s\n", + "Wall time: 1.51 s\n" ] } ], @@ -961,7 +961,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 29, "id": "686548be", "metadata": {}, "outputs": [ @@ -971,13 +971,13 @@ "Text(0.5, 0, 'Wind Direction (Deg)')" ] }, - "execution_count": 78, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -999,6 +999,14 @@ " axarr[i].grid(True)\n", "axarr[-1].set_xlabel('Wind Direction (Deg)')" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "703898e2", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From f832d8b5f5e4d8facf8c8dc1510068013f2e608a Mon Sep 17 00:00:00 2001 From: Paul Date: Wed, 23 Feb 2022 15:43:10 -0700 Subject: [PATCH 20/28] Update notebook --- examples/00_getting_started.ipynb | 32 +++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index de3423ff8..335e0690c 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -578,7 +578,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -696,7 +696,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 18, "id": "f63a2195", "metadata": {}, "outputs": [ @@ -720,7 +720,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 19, "id": "ee1918d6", "metadata": {}, "outputs": [ @@ -749,7 +749,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 20, "id": "6a381dc7", "metadata": {}, "outputs": [], @@ -762,7 +762,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 21, "id": "7547d804", "metadata": {}, "outputs": [], @@ -783,7 +783,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 22, "id": "702bb7ee", "metadata": {}, "outputs": [ @@ -791,8 +791,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.27 s, sys: 1.24 s, total: 4.51 s\n", - "Wall time: 3.49 s\n" + "CPU times: user 3.26 s, sys: 962 ms, total: 4.22 s\n", + "Wall time: 3.27 s\n" ] } ], @@ -804,7 +804,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 23, "id": "8b688add", "metadata": {}, "outputs": [ @@ -812,8 +812,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 5.52 s, sys: 1.39 s, total: 6.91 s\n", - "Wall time: 5.67 s\n" + "CPU times: user 5.52 s, sys: 1.1 s, total: 6.62 s\n", + "Wall time: 5.52 s\n" ] } ], @@ -825,7 +825,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 24, "id": "627f5242", "metadata": {}, "outputs": [ @@ -833,8 +833,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 7.8 s, sys: 1.35 s, total: 9.15 s\n", - "Wall time: 9.2 s\n" + "CPU times: user 8 s, sys: 1.2 s, total: 9.2 s\n", + "Wall time: 9.35 s\n" ] } ], @@ -846,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 25, "id": "394ab742", "metadata": {}, "outputs": [ @@ -856,7 +856,7 @@ "text": [ "Jensen 843.1 GWh\n", "GCH 843.8 GWh\n", - "CC nan GWh\n" + "CC 839.1 GWh\n" ] } ], From bbbff41b28f7372ef0cf0d0a6a85c5614d128ae9 Mon Sep 17 00:00:00 2001 From: Paul Date: Wed, 23 Feb 2022 15:50:01 -0700 Subject: [PATCH 21/28] modify example 2 --- examples/02_visualizations.py | 61 +++++++++++++++++++++-------------- 1 file changed, 37 insertions(+), 24 deletions(-) diff --git a/examples/02_visualizations.py b/examples/02_visualizations.py index be1318c33..68331e0ed 100644 --- a/examples/02_visualizations.py +++ b/examples/02_visualizations.py @@ -33,30 +33,6 @@ # entry point to the simulation routines. fi = FlorisInterface("inputs/gch.yaml") -# FLORIS supports multiple types of grids for capturing wind speed -# information. The current input file is configured with a square grid -# placed on each rotor plane with 9 points in a 3x3 layout. This can -# be plotted to show the wind conditions that each turbine is experiencing. -# However, 9 points is very coarse for visualization so let's first -# increase the rotor grid to 10x10 points. - -# Create a solver settings dictionary with the new number of points -solver_settings = { - "type": "turbine_grid", - "turbine_grid_points": 10 -} - -# Since we already have a FlorisInterface (fi), simply reinitialize it -# with the new configuration -fi.reinitialize(solver_settings=solver_settings) - -# Run the wake calculation to get the turbine-turbine interfactions -# on the turbine grids -fi.calculate_wake() - -# Plot the values at each rotor -plot_rotor_values(fi.floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, n_cols=3) - # The rotor plots show what is happening at each turbine, but we do not # see what is happening between each turbine. For this, we use a # grid that has points regularly distributed throughout the fluid domain. @@ -72,6 +48,7 @@ y_plane = fi.calculate_y_plane(x_resolution=200, z_resolution=100) cross_plane = fi.calculate_cross_plane(y_resolution=100, z_resolution=100) + # Create the plots fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) ax_list = ax_list.flatten() @@ -79,4 +56,40 @@ visualize_cut_plane(y_plane, ax=ax_list[1], title="Streamwise profile") visualize_cut_plane(cross_plane, ax=ax_list[2], title="Spanwise profile") +# FLORIS further includes visualization methods for visualing the rotor plane of each +# Turbine in the simulation + +# Run the wake calculation to get the turbine-turbine interfactions +# on the turbine grids +fi.calculate_wake() + +# Plot the values at each rotor +fig, axes, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, n_cols=3, return_fig_objects=True) +fig.suptitle("Rotor Plane Visualization, Original Resolution") + +# FLORIS supports multiple types of grids for capturing wind speed +# information. The current input file is configured with a square grid +# placed on each rotor plane with 9 points in a 3x3 layout. For visualization, +# this resolution can be increased. Note this operation, unlike the +# calc_x_plane above operations does not automatically reset the grid to +# the initial status as definied by the input file + +# Increase the resolution of points on each turbien plane +solver_settings = { + "type": "turbine_grid", + "turbine_grid_points": 10 +} +fi.reinitialize(solver_settings=solver_settings) + +# Run the wake calculation to get the turbine-turbine interfactions +# on the turbine grids +fi.calculate_wake() + + +# Plot the values at each rotor +fig, axes, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, n_cols=3, return_fig_objects=True) +fig.suptitle("Rotor Plane Visualization, 10x10 Resolution") + + + plt.show() From 49382583e283c45969ab5b3f9860af9eea0ac7e6 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Sun, 27 Feb 2022 14:41:22 -0600 Subject: [PATCH 22/28] Update overview --- examples/00_getting_started.ipynb | 851 ++++++++++++++++-------------- examples/03_making_adjustments.py | 4 +- 2 files changed, 443 insertions(+), 412 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index 335e0690c..90109482c 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -5,35 +5,23 @@ "id": "86e53920", "metadata": {}, "source": [ - "# Getting Started with FLORIS V3" - ] - }, - { - "cell_type": "markdown", - "id": "bb74834b", - "metadata": {}, - "source": [ - "This notebook is designed to step through the basic operations of FLORIS V3 and highlight what is new/changed from FLORIS V2.4." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "a700d720", - "metadata": {}, - "outputs": [], - "source": [ - "import copy\n", - "import time\n", + "# Getting Started with FLORIS v3\n", "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", + "FLORIS is a command-line program written in Python. There are two primary packages that make up the software:\n", + "- `floris.simulation`: simulation framework including wake model definitions\n", + "- `floris.tools`: utilities for pre and post processing as well as driving the simulation\n", "\n", - "from floris.tools import FlorisInterface\n", - "from floris.tools.visualization import visualize_cut_plane\n", - "from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import (\n", - " YawOptimizationSR,\n", - ")" + "Users of FLORIS will develop a Python script with the following sequence of steps:\n", + "\n", + "1. preprocess\n", + "2. calculation\n", + "3. postprocess\n", + "\n", + "Generally, users will only interact with `floris.tools` and most often through the `FlorisInterface` class. Additionally, `floris.tools` contains functionality for comparing results, creating visualizations, and developing optimization cases. \n", + "\n", + "**NOTE `floris.tools` is under active design and development. The API's will change and additional functionality from FLORIS v2 will be included in upcoming releases.**\n", + "\n", + "This notebook steps through the basic ideas and operations of FLORIS while showing realistic uses and expected behavior." ] }, { @@ -41,30 +29,38 @@ "id": "699c51dd", "metadata": {}, "source": [ - "## Input file" - ] - }, - { - "cell_type": "markdown", - "id": "f1099a88", - "metadata": {}, - "source": [ - "As in V2, a floris interface object is the main point of interaction with FLORIS.\n", + "## Initialize FlorisInterface\n", "\n", - "Something that is new is that the input file is in YAML format to enable new syntax around mixed turbine farms and to cut down on errors related to many-nested brackets." + "The `FlorisInterface` provides functionality to build a wind farm representation and drive the simulation. This object is created (instantiated) by passing the path to a FLORIS input file. Once this object is created, it can immediately be used to inspect the data." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "602f311c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y\n", + " 0.0, 0.0\n", + " 630.0, 0.0\n", + "1260.0, 0.0\n" + ] + } + ], "source": [ - "# Initialize FLORIS with the given input file via FlorisInterface.\n", - "# For basic usage, FlorisInterface provides a simplified and expressive\n", - "# entry point to the simulation routines.\n", - "fi = FlorisInterface(\"inputs/gch.yaml\")" + "import numpy as np\n", + "from floris.tools import FlorisInterface\n", + "\n", + "fi = FlorisInterface(\"inputs/gch.yaml\")\n", + "x, y = fi.get_turbine_layout()\n", + "\n", + "print(\" x y\")\n", + "for _x, _y in zip(x, y):\n", + " print(f\"{_x:6.1f}, {_y:6.1f}\")" ] }, { @@ -72,89 +68,172 @@ "id": "e1eaeb53", "metadata": {}, "source": [ - "## Reinitialize function" + "## Build the model\n", + "\n", + "At this point, FLORIS has been initialized with the data defined in the input file. However, it is often simpler to define a basic configuration in the input file as a starting point and then make modifications in the Python script.\n", + "This allows for generating data algorithmically or loading data from a data file. Modifications to the wind farm representation are handled through the `FlorisInterface.reinitialize()` function with keyword arguments. Another way to\n", + "think of this function is that it changes the value of inputs specified in the input file.\n", + "\n", + "Let's change the location of turbines in the wind farm." ] }, { - "cell_type": "markdown", - "id": "64226134", + "cell_type": "code", + "execution_count": 2, + "id": "d040b810", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y\n", + " 0.0, 0.0\n", + " 0.0, 400.0\n", + " 800.0, 0.0\n", + " 800.0, 400.0\n" + ] + } + ], "source": [ - "Similarly to V2, changes to the background flow and farm are put in place via a `reinitialize` function. Another way to think of this function is that it changes the value of variables specified in the input yaml file." + "# Design a wind farm with turbines in a 2x2 pattern\n", + "# Units are in meters\n", + "x_2x2 = [0, 0, 800, 800]\n", + "y_2x2 = [0, 400, 0, 400]\n", + "fi.reinitialize( layout=(x_2x2, y_2x2) )\n", + "\n", + "x, y = fi.get_turbine_layout()\n", + "\n", + "print(\" x y\")\n", + "for _x, _y in zip(x, y):\n", + " print(f\"{_x:6.1f}, {_y:6.1f}\")" ] }, { "cell_type": "markdown", - "id": "264156e3", + "id": "63f45e11", "metadata": {}, "source": [ - "#### Change farm layout" + "Additionally, we can change the wind speeds and wind directions. These are given as lists of wind speeds and wind directions that will be\n", + "expanded so that a wake calculation will happen for every wind direction with each speed.\n", + "\n", + "Notice that we can give `FlorisInterface.reinitialize()` multiple keyword arguments at once." ] }, { "cell_type": "code", "execution_count": 3, - "id": "d040b810", + "id": "6f9d834a", "metadata": {}, "outputs": [], "source": [ - "# Design a 2x2 farm, units are m\n", - "X = np.array([0, 0, 800, 800])\n", - "Y = np.array([0, 400, 0, 400])\n", - "fi.reinitialize(layout=[X, Y])" - ] - }, - { - "cell_type": "markdown", - "id": "2bf73f42", - "metadata": {}, - "source": [ - "#### Changing the wind direction and speed" + "# One wind direction and one speed -> one atmospheric condition\n", + "fi.reinitialize( wind_directions=[270.0], wind_speeds=[8.0] )\n", + "\n", + "# Two wind directions and one speed -> two atmospheric conditions\n", + "fi.reinitialize( wind_directions=[270.0, 280.0], wind_speeds=[8.0] )\n", + "\n", + "# Two wind directions and two speeds -> four atmospheric conditions\n", + "fi.reinitialize( wind_directions=[270.0, 280.0], wind_speeds=[8.0, 9.0] )" ] }, { "cell_type": "markdown", - "id": "63f45e11", + "id": "da4f3309", "metadata": {}, "source": [ - "This aspect is one of the major changes from V2 to V3. \n", + "`FlorisInterface.reinitialize()` creates all of the basic data structures required for the simulation but it does not do any aerodynamic calculations.\n", + "The low level data structures have a complex shape that enables faster computations. Specifically, most data is structured as a many-dimensional Numpy array\n", + "with the following dimensions:\n", "\n", - "Previously, wind speeds and directions described one condition. Now they can describe one or multiple conditions, including an entire wind rose at once. This enables the underlying vectorization which allows the computations to be handled at once, rather than wrapped in a computation loop.\n", + "- 0: wind directions\n", + "- 1: wind speeds\n", + "- 2: turbines\n", + "- 3: grid-1\n", + "- 4: grid-2\n", "\n", - "Some aspects of this specification are still under consideration, but in current form, unless explicitly specified to represent a time series, a vector of wind directions and wind speeds will be \"expanded\" such that each combination of wind direction and wind speed is computed." + "For example, we can see the overall shape of the data structure for the grid point x-coordinates for the all turbines and get the x-coordinates of grid points for the\n", + "third turbine in the first wind direction and first wind speed. We can also plot all the grid points in space to get an idea of the overall form of our grid." ] }, { "cell_type": "code", "execution_count": 4, - "id": "6f9d834a", + "id": "01ea3a98", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dimensions of grid x-components\n", + "(2, 2, 4, 3, 3)\n", + "\n", + "Turbine 3 grid x-components for first wind direction and first wind speed\n", + "[[800. 800. 800.]\n", + " [800. 800. 800.]\n", + " [800. 800. 800.]]\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.0, 150.0)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# One wind direction and one speed\n", - "fi.reinitialize(wind_directions=[270], wind_speeds=[8.])\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "\n", - "# Two wind directions and one speed (Two combinations)s\n", - "fi.reinitialize(wind_directions=[270, 280], wind_speeds=[8.])\n", + "print(\"Dimensions of grid x-components\")\n", + "print( np.shape(fi.floris.grid.x) )\n", "\n", - "# Two wind directions and two speeds (Four combinations)\n", - "fi.reinitialize(wind_directions=[270, 280], wind_speeds=[8., 9.])" - ] - }, - { - "cell_type": "markdown", - "id": "4aff228a", - "metadata": {}, - "source": [ - "## Calculate Wake" + "print()\n", + "print(\"Turbine 3 grid x-components for first wind direction and first wind speed\")\n", + "print(fi.floris.grid.x[0, 0, 2, :, :])\n", + "\n", + "x = fi.floris.grid.x[0, 0, :, :, :]\n", + "y = fi.floris.grid.y[0, 0, :, :, :]\n", + "z = fi.floris.grid.z[0, 0, :, :, :]\n", + "\n", + "# TODO\n", + "# circle = plt.Circle((np.mean(ys_turbine_0), fi.floris.turbine.hub_height), fi.floris.turbine.rotor_diameter / 2.0, color='r', fill=False)\n", + "# ax.add_patch(circle)\n", + "# ax.set_aspect('equal')\n", + "# ax.grid(True)\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(x, y, z, marker=\".\")\n", + "ax.set_zlim([0, 150])" ] }, { "cell_type": "markdown", - "id": "f40efe20", + "id": "ebfdc746", "metadata": {}, "source": [ - "Similar again to V2, there is a `calculate_wake` function. In V3 this will calculate the velocities for every specified grid point, and for every specified wind speed and wind direction. If not doing visualization, grid points will be on the turbine rotors." + "## Execute wake calculation\n", + "\n", + "Running the wake calculation is a one-liner. This will calculate the velocities at each turbine given the wake of other turbines for every wind speed and wind direction combination.\n", + "Since we have not explicitly specified yaw control settings, all turbines are aligned with the inflow." ] }, { @@ -169,248 +248,340 @@ }, { "cell_type": "markdown", - "id": "8ab273db", + "id": "e11352e8", "metadata": {}, "source": [ - "#### Applying yaw angles" + "## Get turbine power\n", + "\n", + "At this point, the simulation has completed and we can use the `FlorisInterface` to extract useful information such as the power produced at each turbine. Remember that we have configured the simulation with two wind directions, two wind speeds, and four turbines." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cc05bfe7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dimensions of `powers`\n", + "(2, 2, 4)\n", + "\n", + "Turbine powers for 8 m/s\n", + "Wind direction 0\n", + "[1691.32648289 1691.32648289 592.65288889 592.97819946]\n", + "Wind direction 1\n", + "[1691.32648289 1691.32648289 1631.06709246 1629.75508349]\n", + "\n", + "Turbine powers for all turbines at all wind conditions\n", + "[[[1691.32648289 1691.32648289 592.65288889 592.97819946]\n", + " [2407.84258855 2407.84258855 861.30598083 861.73203268]]\n", + "\n", + " [[1691.32648289 1691.32648289 1631.06709246 1629.75508349]\n", + " [2407.84258855 2407.84258855 2321.41264704 2319.53233514]]]\n" + ] + } + ], + "source": [ + "powers = fi.get_turbine_powers() / 1000.0 # calculated in Watts, so convert to kW\n", + "\n", + "print(\"Dimensions of `powers`\")\n", + "print( np.shape(powers) )\n", + "\n", + "print()\n", + "# TODO hold wind direction fixed and loop over wind speeds\n", + "print(\"Turbine powers for 8 m/s\")\n", + "for i in range(2):\n", + " print(f\"Wind direction {i}\")\n", + " print(powers[i, 0, :])\n", + "\n", + "# TODO: maybe describe get_farm_power() here?\n", + "\n", + "print()\n", + "print(\"Turbine powers for all turbines at all wind conditions\")\n", + "print(powers)\n" ] }, { "cell_type": "markdown", - "id": "89ea9b19", + "id": "8ab273db", "metadata": {}, "source": [ - "Yaw angles are applied to turbines in the `calculate_wake` function. Some important things to note when using the new framwork:\n", + "## Applying yaw angles\n", + "\n", + "Yaw angles are applied to turbines through the `FlorisInterface.calculate_wake` function.\n", "\n", - "**yaw_angles is a matrix** -- You must provide yaw angles in a matrix with dimensions equal to:\n", - "* number of wind directions\n", - "* number of wind speeds\n", - "* number of turbines\n", + "**Note that `yaw_angles` is a array** -- You must provide yaw angles in a array with dimensions equal to:\n", + "- 0: number of wind directions\n", + "- 1: number of wind speeds\n", + "- 2: number of turbines\n", "\n", - "**unlike variables passed in `reinitialize`, yaw angles applied to calculate wake are not remembered between calls**" + "**Unlike data set in `FlorisInterface.reinitialize()`, yaw angles are not stored in memory and must be given again in successive calls to `FlorisInterface.calculate_wake`.**\n", + "**If no yaw angles are given, all turbines will be aligned with the inflow.**" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "be78e20d", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "array([[[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]],\n", - "\n", - " [[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]]])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[0. 0. 0. 0.]\n", + " [0. 0. 0. 0.]]\n", + "\n", + " [[0. 0. 0. 0.]\n", + " [0. 0. 0. 0.]]]\n" + ] } ], "source": [ - "# Matrix of zero yaw angles\n", - "num_wd = 2\n", - "num_ws = 2\n", - "num_turbine = 4\n", - "yaw_angles_zero = np.zeros([num_wd, num_ws, num_turbine])\n", - "fi.calculate_wake(yaw_angles=yaw_angles_zero)\n", - "yaw_angles_zero" + "# Array of zero yaw angles\n", + "yaw_angles = np.zeros( (2, 2, 4) )\n", + "print(yaw_angles)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "0f041620", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "array([[[25., 25., 0., 0.],\n", - " [25., 25., 0., 0.]],\n", - "\n", - " [[25., 25., 0., 0.],\n", - " [25., 25., 0., 0.]]])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[25. 25. 0. 0.]\n", + " [25. 25. 0. 0.]]\n", + "\n", + " [[25. 25. 0. 0.]\n", + " [25. 25. 0. 0.]]]\n" + ] } ], "source": [ "# Yaw the front row for all wind directions and all wind speeds\n", - "yaw_angles_yaw_front = np.zeros([num_wd, num_ws, num_turbine])\n", - "yaw_angles_yaw_front[:, :, :2] = 25\n", - "fi.calculate_wake(yaw_angles=yaw_angles_yaw_front)\n", - "yaw_angles_yaw_front" - ] - }, - { - "cell_type": "markdown", - "id": "e11352e8", - "metadata": {}, - "source": [ - "## Getting turbine power" + "yaw_angles = np.zeros( (2, 2, 4) )\n", + "yaw_angles[:, :, 0:2] = 25\n", + "\n", + "# TODO Pass the settings to Floris\n", + "fi.calculate_wake( yaw_angles=yaw_angles )\n", + "print(yaw_angles)" ] }, { "cell_type": "markdown", - "id": "bf4b6ac8", + "id": "1ef54dc5", "metadata": {}, "source": [ - "The calculate wake function computes the velocity at each grid point on each turbine. To then compute the power, you call the `get_turbine_powers()` function:" + "## Start to finish\n", + "\n", + "Let's put it all together. The following code does the following:\n", + "1. Load an input file\n", + "2. Modify the inputs with a more complex wind turbine layout\n", + "3. Change the wind speeds and wind directions\n", + "4. Execute the simulation\n", + "5. Get the total farm power\n", + "6. Add yaw settings for some turbines\n", + "7. Execute the simulation\n", + "5. Get the total farm power and compare to without yaw control" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "6054265f", + "execution_count": 9, + "id": "205738aa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power % difference with yaw\n", + " 210 degrees: 3.95%\n", + " 270 degrees: 2.59%\n" + ] + } + ], "source": [ - "# Aligned\n", - "fi.calculate_wake(yaw_angles=yaw_angles_zero)\n", - "powers_aligned = fi.get_turbine_powers()/1000.\n", + "from floris.tools import FlorisInterface\n", + "\n", + "fi = FlorisInterface(\"inputs/gch.yaml\")\n", + "\n", + "# Construct the model\n", + "D = 126.0 # Design the layout based on turbine diameter\n", + "x = [0, 3 * D, 6 * D, 9 * D]\n", + "y = [0, 3 * D, -2 * D, 3 * D]\n", + "wind_directions = [210.0, 270.0]\n", + "wind_speeds = [8.0]\n", "\n", - "# Yawed\n", - "fi.calculate_wake(yaw_angles=yaw_angles_yaw_front)\n", - "powers_yawed = fi.get_turbine_powers()/1000." + "# Pass the new data to FlorisInterface\n", + "fi.reinitialize(\n", + " layout=(x, y),\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds\n", + ")\n", + "\n", + "# Calculate the velocities at each turbine for all atmospheric conditions with no yaw control settings\n", + "fi.calculate_wake()\n", + "\n", + "# Get the farm power\n", + "turbine_powers = fi.get_turbine_powers() / 1000.0\n", + "farm_power_baseline = np.sum(turbine_powers, 2)\n", + "\n", + "# Develop the yaw control settings\n", + "yaw_angles = np.zeros( (2, 1, 4) ) # Construct the yaw array with dimensions for two wind directions, one wind speed, and four turbines\n", + "yaw_angles[0, :, 0] = -5 # At 210 degrees, yaw the first turbine 10 degrees\n", + "yaw_angles[0, :, 1] = -20 # At 210 degrees, yaw the second turbine 10 degrees\n", + "yaw_angles[1, :, 1] = 20 # At 270 degrees, yaw the second turbine 10 degrees\n", + "\n", + "# Calculate the velocities at each turbine for all atmospheric conditions given the yaw control settings\n", + "fi.calculate_wake( yaw_angles=yaw_angles )\n", + "\n", + "# Get the farm power\n", + "turbine_powers = fi.get_turbine_powers() / 1000.0\n", + "farm_power_yaw = np.sum(turbine_powers, 2)\n", + "\n", + "# Compare power difference with yaw\n", + "difference = 100 * (farm_power_yaw - farm_power_baseline) / farm_power_baseline\n", + "print(\"Power % difference with yaw\")\n", + "print(f\" 210 degrees: {difference[0, 0]:4.2f}%\")\n", + "print(f\" 270 degrees: {difference[1, 0]:4.2f}%\")" ] }, { "cell_type": "markdown", - "id": "5a11cdee", + "id": "99b7465c", "metadata": {}, "source": [ - "The powers are returned in a matrix of the same dimensions as the yaw_angles matrix and by default in units W (the division by 1000 converting to kW in the above example code)." + "## Visualization\n", + "\n", + "While comparing turbine and farm powers is meaningful, a picture is worth at least 1000 Watts, and the `FlorisInterface` provides powerful routines for visualization.\n", + "\n", + "**NOTE `floris.tools` is under active design and development. The API's will change and additional functionality from FLORIS v2 will be included in upcoming releases.**\n", + "\n", + "The visualization functions require that the user select a single atmospheric condition to plot. However, the internal data structures still have the same shape but the wind speed and wind direction\n", + "dimensions have a size of 1. This means that the yaw angle array used for plotting must have the same shape as before but a single atmospheric condition must be selected.\n", + "\n", + "Let's create a horizontal slice of each atmospheric condition from above with and without yaw settings included.\n", + "\n", + "\n", + "TODO point out that the farm is rotated relative to west - working on it\n", + "- north-fixed\n", + "\n", + "TODO Describe yaw angle indexing" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "7de24fe5", + "execution_count": 10, + "id": "8bb179ff", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[[1691.32648289, 1691.32648289, 592.65288889, 592.97819946],\n", - " [2407.84258855, 2407.84258855, 861.30598083, 861.73203268]],\n", - "\n", - " [[1691.32648289, 1691.32648289, 1629.75508349, 1629.75457548],\n", - " [2407.84258855, 2407.84258855, 2319.53233514, 2319.53161349]]])" + "" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" - } - ], - "source": [ - "powers_aligned" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "2d88eb5a", - "metadata": {}, - "outputs": [ + }, { "data": { + "image/png": "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", "text/plain": [ - "array([[[1405.86257762, 1405.86257762, 1027.52310514, 1050.99771102],\n", - " [2002.44307076, 2002.44307076, 1465.26930376, 1499.2201859 ]],\n", - "\n", - " [[1405.86257762, 1405.86257762, 1686.4416639 , 1687.16796562],\n", - " [2002.44307076, 2002.44307076, 2400.84095397, 2401.87031696]]])" + "
" ] }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "powers_yawed" + "from floris.tools.visualization import visualize_cut_plane\n", + "import matplotlib.pyplot as plt\n", + "\n", + "fig, axarr = plt.subplots(2, 2, figsize=(15,8))\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[210] )\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[0,0], title=\"210 - Aligned\")\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[210], yaw_angles=yaw_angles[0:1,0:1] )\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[0,1], title=\"210 - Yawed\")\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[270] )\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[1,0], title=\"270 - Aligned\")\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[270], yaw_angles=yaw_angles[1:2,0:1] )\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[1,1], title=\"270 - Yawed\")" ] }, { "cell_type": "markdown", - "id": "2129f587", + "id": "d84cf194", "metadata": {}, "source": [ - "We can therefore use normal slice operations to get specific powers:" + "We can also create a visualization of the streamwise inflow velocities on the turbine rotor grid points located on the rotor plane." ] }, { "cell_type": "code", "execution_count": 11, - "id": "e2606e36", + "id": "3e517614", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Power of turbine 0 across wd/ws conditions for aligned case\n", - "[[1691.32648289 2407.84258855]\n", - " [1691.32648289 2407.84258855]]\n", - "--\n", - "Power of all turbines when wind direction = 280 and wind speed = 9\n", - "[2407.84258855 2407.84258855 2319.53233514 2319.53161349]\n" - ] - } - ], - "source": [ - "print('Power of turbine 0 across wd/ws conditions for aligned case')\n", - "print(powers_aligned[:, :, 0])\n", - "print('--')\n", - "print('Power of all turbines when wind direction = 280 and wind speed = 9')\n", - "print(powers_aligned[1, 1, :])" - ] - }, - { - "cell_type": "markdown", - "id": "c40d87ee", - "metadata": {}, - "source": [ - "We can also use sum operations across dimensions:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "d0ead739", - "metadata": {}, - "outputs": [ + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Wind direction 270')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Farm power across wind directions and speeds\n", - "[[4568.28405413 6538.72319062]\n", - " [6642.16262475 9454.74912574]]\n", - "[[4568.28405413 6538.72319062]\n", - " [6642.16262475 9454.74912574]]\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "farm_power_aligned = np.sum(powers_aligned, 2) # Some over turbine dimension\n", - "farm_power_yawed = np.sum(powers_yawed, 2) # Some over turbine dimension\n", + "from floris.tools.visualization import plot_rotor_values\n", "\n", - "print('Farm power across wind directions and speeds')\n", - "print(farm_power_aligned)\n", + "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", + "fig.suptitle(\"Wind direction 210\")\n", "\n", - "# This specific matrix could have been obtained via the get_farm_power function\n", - "fi.calculate_wake(yaw_angles = yaw_angles_zero)\n", - "print(fi.get_farm_power()/1000.)" + "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=1, ws_index=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", + "fig.suptitle(\"Wind direction 270\")" ] }, { @@ -441,7 +612,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "774acfea", "metadata": {}, "outputs": [ @@ -449,7 +620,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "xs has shape: (2, 2, 4, 3, 3) of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\n" + "xs has shape: (2, 1, 4, 3, 3) of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\n" ] }, { @@ -458,13 +629,13 @@ "(0.0, 150.0)" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -497,13 +668,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "8dd8ce19", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -531,147 +702,10 @@ }, { "cell_type": "markdown", - "id": "99b7465c", - "metadata": {}, - "source": [ - "## Visualization" - ] - }, - { - "cell_type": "markdown", - "id": "cd938402", - "metadata": {}, - "source": [ - "Tools for visualizing the flow are similar to how they operated in V3; however there are important changes.\n", - "\n", - "First, because yaw angles are no longer remembered from previous `calculate_wake` calls, it is important to pass in the yaw angles to the visualization function itself.\n", - "\n", - "Second, because visualization does not accept multiple wind directions and wind speeds, it is important to reinitialize if the original was using arrays of wind speeds and directions." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "8bb179ff", - "metadata": {}, - "outputs": [], - "source": [ - "# Choose one wind direction and one wind speed\n", - "fi.reinitialize(wind_directions = [280.], wind_speeds = [9.])\n", - "fi.calculate_wake()\n", - "\n", - "# The yaw angles matrix must also be of only one wind speed and wind direction\n", - "# But still should have 3 dimensions\n", - "# Take just this slice and flatten\n", - "yaw_angles_zero_viz = np.zeros([1, 1, num_turbine])\n", - "yaw_angles_yaw_front_viz = np.zeros([1, 1, num_turbine])\n", - "yaw_angles_yaw_front_viz[:, :, :2] = 25\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "38ea41cd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axarr = plt.subplots(1, 2, figsize=(15,5))\n", - "\n", - "# Plot the aligned case\n", - "horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles_zero_viz)\n", - "visualize_cut_plane(horizontal_plane, ax=axarr[0], title=\"Aligned\")\n", - "\n", - "# Plot the yawed case\n", - "horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles_yaw_front_viz)\n", - "visualize_cut_plane(horizontal_plane, ax=axarr[1], title=\"Yawed\")" - ] - }, - { - "cell_type": "markdown", - "id": "9295cd9d", + "id": "307afc4e", "metadata": {}, "source": [ - "Visualization makes a new grid of points on the plane to be visualized in addition to those on the rotor. This is done within the `calculate_horizontal_plane` call. The grid is however set back to how it was originally at the completion of the funcion as can be confirmed." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "09c91c62", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs has shape: (1, 1, 4, 3, 3) of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\n" - ] - }, - { - "data": { - "text/plain": [ - "(0.0, 150.0)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Get the grid points\n", - "xs = fi.floris.grid.x\n", - "ys = fi.floris.grid.y\n", - "zs = fi.floris.grid.z\n", - "\n", - "# Consider the shape\n", - "print('xs has shape: ', xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", - "\n", - "# Lets plot just one wd/ws conditions\n", - "xs = xs[0, 0, :, :, :]\n", - "ys = ys[0, 0, :, :, :]\n", - "zs = zs[0, 0, :, :, :]\n", - "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot(111, projection=\"3d\")\n", - "ax.scatter(xs, ys, zs, marker=\".\")\n", - "ax.set_zlim([0, 150])" + "# Advanced Usage and Concepts" ] }, { @@ -696,7 +730,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "id": "f63a2195", "metadata": {}, "outputs": [ @@ -720,7 +754,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 15, "id": "ee1918d6", "metadata": {}, "outputs": [ @@ -749,7 +783,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 16, "id": "6a381dc7", "metadata": {}, "outputs": [], @@ -762,7 +796,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 17, "id": "7547d804", "metadata": {}, "outputs": [], @@ -783,7 +817,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 18, "id": "702bb7ee", "metadata": {}, "outputs": [ @@ -791,8 +825,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.26 s, sys: 962 ms, total: 4.22 s\n", - "Wall time: 3.27 s\n" + "CPU times: user 4.23 s, sys: 1.85 s, total: 6.08 s\n", + "Wall time: 5.18 s\n" ] } ], @@ -804,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 19, "id": "8b688add", "metadata": {}, "outputs": [ @@ -812,8 +846,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 5.52 s, sys: 1.1 s, total: 6.62 s\n", - "Wall time: 5.52 s\n" + "CPU times: user 6.98 s, sys: 2.95 s, total: 9.93 s\n", + "Wall time: 8.65 s\n" ] } ], @@ -825,7 +859,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 20, "id": "627f5242", "metadata": {}, "outputs": [ @@ -833,8 +867,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 8 s, sys: 1.2 s, total: 9.2 s\n", - "Wall time: 9.35 s\n" + "CPU times: user 10.7 s, sys: 5.83 s, total: 16.6 s\n", + "Wall time: 16.6 s\n" ] } ], @@ -846,7 +880,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 21, "id": "394ab742", "metadata": {}, "outputs": [ @@ -885,7 +919,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 22, "id": "32a93c6d", "metadata": {}, "outputs": [], @@ -900,11 +934,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 23, "id": "7d773cdc", "metadata": {}, "outputs": [], "source": [ + "from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR\n", + "\n", "# Define the SerialRefine optimization\n", "yaw_opt = YawOptimizationSR(\n", " fi=fi_gch,\n", @@ -918,7 +954,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 24, "id": "1ccb9ab7", "metadata": {}, "outputs": [ @@ -940,8 +976,8 @@ "[Serial Refine] Processing pass=1, turbine_depth=4 (78.6 %)\n", "[Serial Refine] Processing pass=1, turbine_depth=5 (85.7 %)\n", "[Serial Refine] Processing pass=1, turbine_depth=6 (92.9 %)\n", - "CPU times: user 1.48 s, sys: 352 ms, total: 1.84 s\n", - "Wall time: 1.51 s\n" + "CPU times: user 2.01 s, sys: 312 ms, total: 2.32 s\n", + "Wall time: 1.81 s\n" ] } ], @@ -961,7 +997,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 25, "id": "686548be", "metadata": {}, "outputs": [ @@ -971,13 +1007,13 @@ "Text(0.5, 0, 'Wind Direction (Deg)')" ] }, - "execution_count": 29, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -999,21 +1035,16 @@ " axarr[i].grid(True)\n", "axarr[-1].set_xlabel('Wind Direction (Deg)')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "703898e2", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { + "interpreter": { + "hash": "abb86f6b47589d310a8582323f08589acc6fd65b639f664d8b854acb0023e70a" + }, "kernelspec": { "display_name": "env_testv3", "language": "python", - "name": "env_testv3" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1025,7 +1056,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.9.6" } }, "nbformat": 4, diff --git a/examples/03_making_adjustments.py b/examples/03_making_adjustments.py index f40125d47..6f5089b33 100644 --- a/examples/03_making_adjustments.py +++ b/examples/03_making_adjustments.py @@ -55,8 +55,8 @@ # Change the farm layout N = 3 # Number of turbines per row and per column X, Y = np.meshgrid( - 5.0 * fi.floris.turbine.rotor_diameter * np.arange(0, N, 1), - 5.0 * fi.floris.turbine.rotor_diameter * np.arange(0, N, 1), + 5.0 * fi.floris.farm.rotor_diameters[0] * np.arange(0, N, 1), + 5.0 * fi.floris.farm.rotor_diameters[0] * np.arange(0, N, 1), ) fi.reinitialize( layout=( X.flatten(), Y.flatten() ) ) horizontal_plane = fi.calculate_horizontal_plane() From 553b187e7effc406898e50b94e398052b81f025b Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Mon, 28 Feb 2022 11:10:26 -0600 Subject: [PATCH 23/28] Rename examples in sequence --- ...{09_optimize_yaw.py => 10_optimize_yaw.py} | 0 ...timize_layout.py => 11_optimize_layout.py} | 0 ...mizers.py => 12_compare_yaw_optimizers.py} | 0 ...s_inflow.py => 13_heterogeneous_inflow.py} | 0 ..._types.py => 14_multiple_turbine_types.py} | 0 ...streamlit_demo.py => 15_streamlit_demo.py} | 0 .../propose_to_delete/03_compare_models.py | 57 ------------------- 7 files changed, 57 deletions(-) rename examples/{09_optimize_yaw.py => 10_optimize_yaw.py} (100%) rename examples/{10_optimize_layout.py => 11_optimize_layout.py} (100%) rename examples/{10_compare_yaw_optimizers.py => 12_compare_yaw_optimizers.py} (100%) rename examples/{10_heterogeneous_inflow.py => 13_heterogeneous_inflow.py} (100%) rename examples/{10_multiple_turbine_types.py => 14_multiple_turbine_types.py} (100%) rename examples/{12_streamlit_demo.py => 15_streamlit_demo.py} (100%) delete mode 100644 examples/propose_to_delete/03_compare_models.py diff --git a/examples/09_optimize_yaw.py b/examples/10_optimize_yaw.py similarity index 100% rename from examples/09_optimize_yaw.py rename to examples/10_optimize_yaw.py diff --git a/examples/10_optimize_layout.py b/examples/11_optimize_layout.py similarity index 100% rename from examples/10_optimize_layout.py rename to examples/11_optimize_layout.py diff --git a/examples/10_compare_yaw_optimizers.py b/examples/12_compare_yaw_optimizers.py similarity index 100% rename from examples/10_compare_yaw_optimizers.py rename to examples/12_compare_yaw_optimizers.py diff --git a/examples/10_heterogeneous_inflow.py b/examples/13_heterogeneous_inflow.py similarity index 100% rename from examples/10_heterogeneous_inflow.py rename to examples/13_heterogeneous_inflow.py diff --git a/examples/10_multiple_turbine_types.py b/examples/14_multiple_turbine_types.py similarity index 100% rename from examples/10_multiple_turbine_types.py rename to examples/14_multiple_turbine_types.py diff --git a/examples/12_streamlit_demo.py b/examples/15_streamlit_demo.py similarity index 100% rename from examples/12_streamlit_demo.py rename to examples/15_streamlit_demo.py diff --git a/examples/propose_to_delete/03_compare_models.py b/examples/propose_to_delete/03_compare_models.py deleted file mode 100644 index 528e56f6e..000000000 --- a/examples/propose_to_delete/03_compare_models.py +++ /dev/null @@ -1,57 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools import visualize_cut_plane - -""" -This example visually compares different models included in FLORIS. -We run the same simulation for each model and plot a horizontal slice -with and without yawed turbines for comparison. -""" - -# Initialize FLORIS for 3 different models via FlorisInterface -fi_jensen = FlorisInterface("inputs/jensen.yaml") -fi_gch = FlorisInterface("inputs/gch.yaml") -fi_cc = FlorisInterface("inputs/cc.yaml") - -# Create the plotting objects using matplotlib -fig, axarr = plt.subplots(2, 2, figsize=(16, 4)) - -# Iterate over the model-objects and create a plot of the flow fields -# for each model and configuration. -MIN_WS = 2.0 -MAX_WS = 8.0 -for idx, (fi, name) in enumerate(zip([fi_jensen, fi_gch], ["Jensen", "Gaussian"])): - - # Aligned - ax = axarr[0, idx] - horizontal_plane = fi.calculate_horizontal_plane() - visualize_cut_plane(horizontal_plane, ax=ax, minSpeed=MIN_WS, maxSpeed=MAX_WS) - ax.set_title(name) - axarr[0, 0].set_ylabel("Aligned") - - # Yawed - yaw_angles = np.zeros_like(fi.floris.farm.yaw_angles) - yaw_angles[:,:,0] = 25.0 - ax = axarr[1, idx] - horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles) - visualize_cut_plane(horizontal_plane, ax=ax, minSpeed=MIN_WS, maxSpeed=MAX_WS) - axarr[1, 0].set_ylabel("Yawed") - -plt.show() From 1c8694e058d9399a8ac659b2f0d9549d5af27f35 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Mon, 28 Feb 2022 11:19:11 -0600 Subject: [PATCH 24/28] Update overview notebook --- examples/00_getting_started.ipynb | 194 +++++++----------------------- 1 file changed, 46 insertions(+), 148 deletions(-) diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index 90109482c..fdf84a715 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -187,7 +187,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -213,12 +213,6 @@ "y = fi.floris.grid.y[0, 0, :, :, :]\n", "z = fi.floris.grid.z[0, 0, :, :, :]\n", "\n", - "# TODO\n", - "# circle = plt.Circle((np.mean(ys_turbine_0), fi.floris.turbine.hub_height), fi.floris.turbine.rotor_diameter / 2.0, color='r', fill=False)\n", - "# ax.add_patch(circle)\n", - "# ax.set_aspect('equal')\n", - "# ax.grid(True)\n", - "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", "ax.scatter(x, y, z, marker=\".\")\n", @@ -468,13 +462,8 @@ "The visualization functions require that the user select a single atmospheric condition to plot. However, the internal data structures still have the same shape but the wind speed and wind direction\n", "dimensions have a size of 1. This means that the yaw angle array used for plotting must have the same shape as before but a single atmospheric condition must be selected.\n", "\n", - "Let's create a horizontal slice of each atmospheric condition from above with and without yaw settings included.\n", - "\n", - "\n", - "TODO point out that the farm is rotated relative to west - working on it\n", - "- north-fixed\n", - "\n", - "TODO Describe yaw angle indexing" + "Let's create a horizontal slice of each atmospheric condition from above with and without yaw settings included. Notice that although we are plotting the conditions for two different wind directions,\n", + "the farm is rotated so that the wind is coming from the left (west) in both cases." ] }, { @@ -486,7 +475,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -495,7 +484,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3UAAAHQCAYAAAAGQENUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9ebR1W3YXhv3m2nufc+/9utfWq+aVpBJVIirAiE6yw4hRwAEkQ0QSjGUISDQpZwwaE5OABB4DJ8MMi8Q0ygBjF8hGYigRCpAhBSsG4UQ2JEiAhLBSkkqUVO2r9+p1X3ubc/Zea+aPubq9dnP26e495/vWb7zvnbv3XmvtdfY5Z/3Wb8655iJmRkZGRkZGRkZGRkZGRsZxQt10BzIyMjIyMjIyMjIyMjI2RxZ1GRkZGRkZGRkZGRkZR4ws6jIyMjIyMjIyMjIyMo4YWdRlZGRkZGRkZGRkZGQcMbKoy8jIyMjIyMjIyMjIOGJkUZeRkZGRkZGRkZGRkXHEyKIuI+OIQEQ/QkR/wP79u4jo799AH76CiJiIyuu+d0ZGRkZGxiGBiL6eiL5w0/3IyMiiLuOZBhHNiei7iOizRPSYiH6SiL4huj4jor9FRJ+xQubrk/pERH+WiN6x//4sEdGWfSIi+gUi+umxcsz8vcz8G7e5V0ZGRkZGxhQcCl/adv47IvrTyfnfQ0Q/T0Rnm77HjIxjRhZ1Gc86SgCfB/DrANwD8B8A+H4i+oqozD8C8L8E8EZP/Y8B+G0AfjmAfwXAbwXw727Zp38dwHsAfCUR/Zot28rIyMjIyNgFDoIvmZkB/AEA/xsi+iUAQEQvA/hzAP4AM1+s22ZGxtOALOoynmkw8zkz/4fM/BlmNsz8dwF8GsCvsteXzPwXmfkfAdA9TXwLgD/HzF9g5tcgpPKtW3brWwD8AIAfsn/3goi+lYj+UXT8G4nok0T0kIj+UyL6b6NQzW8lon9ERP8JEd0nok8nFtZ71gL7OhG9RkT/EREV9lph671NRL8A4N/c8v1lZGRkZBwZDokvmfnnAPwZAN9FRArA/xnA3wbwk0T0d4noLct1f5eIXgUAIvofE9FPuTaI6IeJ6J9Gx/+QiH6b/fv9RPS3bTufJqI/EpU7JaK/btv/aQDZ+JpxEMiiLiMjAhG9AuCrAHxiYpVfAuBfRMf/wp7b9P5nAH47gO+1/76ZiGYT6r0E4G8B+HYALwL4JID/YVLs6+z5lwD8HyFk6EJf/jqABsCHAfwKAL8RYgkFgP8VgN9iz/9q27+MjIyMjGcYN82XAP48AIJw368F8L+DzGv/SwBfDuDLAFwC+Eu2/I8C+AgRvUREFcRb+H4iukNEpxB++4dWJP4/bP8+AOA3APijRPSbbDt/GsAvsv9+E0aMrxkZ14ks6jIyLOwg/70AvpuZf3ZitdsAHkbHDwHc3mJd3f8cwALA3wfwXwGoMM0z9o0APsHMf4eZG4jVMg1/+Swz/1Vm1gC+G8D7ALxiifkbAfxRa4l9E8BfAPDNtt7vAPAXmfnzzPwugP94w/eWkZGRkfEU4BD40nLZ7wPwPwPwh5n5MTO/w8x/m5kvmPkxxJv362z5SwD/FLLE4VdBRNv/ByII/1UA/5KZ34F43l5m5v+D9T7+AoC/ijYn/hlmfpeZPw/h24yMG0fOXpeRAcBa5v4GgCWAP7RG1ScA7kbHdwE8sTH/6T3+nwD+R/bw32Xm7+1p71sAfL8VZg0R/W177v++oh/vh6x1ACBrDqibjeuN6PqF5dHbAF6AiMfXI25VUXuttgF8dkVfMjIyMjKeUhwQX4KZP2F56xO23hnEKPmbATxvi90hosKKwP8WwNcD+IL9+z5E9C3sMSBevvcT0YPoVgWAf2j/zpyYcZDIoi7jmYe1En4XgFcAfCMz12tU/wRk0fc/sce/HAOhKMz8DX3no368CuDXA/haIvpf2NNnAE6I6CVmfnuk+usAXo3aovh4BT4PIbSXrJjsa/uD0fGXTWw3IyMjI+MpwqHw5Qj+GIBfDODrmPkNIvoaAP8cEqYJiHD7cwA+B+A7IKLur0I48C/bMp8H8Glm/sjAPRwnur5nTsw4COTwy4wM4K8A+GoAv9WGZ7Rg0zif2MMZEZ1E4SLfA+DfJ6IPENH7IYTy1zfsx+8G8HMQQvoa+++rIBbFf2dF3f8KwC8jot9Gsn/cHwTw3ik3ZebXIeGef46I7hKRIqJfRES/zhb5fgB/hIheJaLnAXzbem8rIyMjI+MpwaHw5RDuQNbRPSCiFyDr32L8fyEc+7UA/gkzfwLimfs6AP+dLfNPADwmoj9hk6IURPRLo2zU3w/g24noeWuM/cM7fg8ZGRshi7qMZxpE9OWQlMpfA+ANInpi//2uqNgnISTxAQB/z/795fbafw5ZUP1TAP5/EHH1n2/YnW8B8J8y8xvxPwD/GVYsxLZevH8LkgDlHQAfBfDPINbHKfg9AGYAfhpiufxbkDV3gFgx/x5k/cFPAPg767ypjIyMjIzjx4Hx5RD+IoBTAG9DEqP81/FFZj6H8NgnmHlpT/9jyJrzN20ZDUkO9jWQ7J5vA/hrkG0cAOB/Dwm5/DTEIPo3dvweMjI2AvWEMmdkZBw57JqHLwD4Xcz8/77p/mRkZGRkZGRkZOwP2VOXkfGUgIh+ExE9R0RzAH8SsobgR2+4WxkZGRkZGRkZGXtGFnUZGU8P/jUAPw8JFfmtAH5b35qHjIyMjIyMjIyMpws5/DIjIyMjIyMjIyMjI+OIkT11GRkZGRkZGRkZGRkZR4yj36fuHhX8HlQ33Y2MjIyMjDXwKSzeZuaXb7ofTzsyR2ZkZGQcHzbhyKMXde9Bhb9YfvnqghkZGRkZB4Pf0vzcZ2+6D88CMkdmZGRkHB824cijF3UZGRkZGRkZGRkZGRnHDqpI/mjWr5tFXUZGRkZGRkZGRkZGxprwIuwAkEVdRkZGRkZGRkZGRsYzgUMSYrtEFnUZGRkZGXvBKHFuEFqSkZGRkfHs4mkVY7tCFnUZGRkZGQAyYWZkZGRk7B6ZWwJUub9nkUVdRkZGxhEik2RGRkZGxr7wLHPMPoXXPpFFXUZGRsY14FkmyIyMjIyM68XTzDnHKrr2jSzqMjIyMkbwNBPjtsjEmpGRkbF7PC288zRxBFXqpruwElnUZWRkPFV4WshwWzxNZJqRkZFxTDhWHjo23jgGoTUVu3j2WdRlZGTcOI6VADfBsZHmrvA0kW9GRsbTi2Pho0PmkmMZ7w/5GW6CLOoyMjI2xrGQ3zp42gZ54HgINiMjI2NXODR+OiRuOSROOKTnMgWH9r2KkUVdRsYziEMelKbi2IjA4ZDIdF841s8mIyPjsHAIXHWT49lN8MUhjd+H8Plvg+t+llnUZWQcGY5tkDskghjCMQqtY3iuGRkZGTfFWdc5Rl4Xh9zEuH9Ic46niff28VyzqMvIuCYc0sDYh0MaLA9ZZB3Sc9oUh/5dzMjIODxc57ix73F2Xxyz/34/PZ/BOniWOGub555FXUbGBBzigPKshYQ4HBLRpDjE78m2OOTnnZGRsR6ua4za9bixa87Zff922951jbuHwFmZYwRU5OyXGRmTcJMD13UPWNcpuG5WWB4eETyr5HSIn0VGxqHjUH83uxrHdsFF2/Zll894d89lv5/7jfLyDoTJsUEd0HvOoi5jaxwqMW2LYw3/AJ6uEJAYhyaantbv/q5xaJ9bRgZw/L/fff2utuGmTfu0zWexzXPY1XdgZ4LvmgXCIQmSdUDqOPu9b2RRt0ccO2EcOq4vPOHZCvtweJbCP4AsPPaBZ9FqmzENh/K7XxeHME7cJCdt8rlt8syu6z7+fluOVfsSRzcpXqg43LXtGf3Iou6IcQjkchM45AXOh2b1c8jhHk8/jtXimpExhkPguesIad+f1216u7sWd2u1t8H4tcmYtwuRtC+xcyxj+LPqJWPDN92Flciibo8oTgsAANdmsMwhZ/nbFQ6DlK8/tOMQY/kdrkMIHQtBAc8uSWVk3BQcP143DtVgdlNGxSn3ncIXU8b7dcbZTYTTNpyzaw44Jv4DDss4yvpAxdM1PSOzxfvPom6P8INluR/yOrbwlWPZX+VpCuG4brGSwzUyMjKmwI2zxxBFsG0fNwo/3IILdiWwxsbzXYu4jbxuO+BLUvvnrGw0HEfqAaMDn0awGXbU7ALFFt/rLOr2iPLuzVgi18UheNJS7MtqdJ3hGhsJHCL/j6JjVapwLi1H1K1v//Y1CO3zvk647vtrr7XqRufbf1PnUvtgqF6rQM+5XSMiDU6sYOmxPdc+ze2y/tW9ROeTMvKSnHfX4mPmdnvR+W65nnM7wjGEmGQcP1bx400mnrgunliHI9bp05S+jLU35ZlNEUObPJND8rZNu+fhKpB9i49d4ya4ZxOvGKnN5/b7fo97F3VE9ByAvwbgl0KmLL8PwCcB/E0AXwHgMwB+BzPfJ5lpfieAbwRwAeBbmfkn9t3HfeHkxVug2UwmXMaAkwkfdyaIO/6wxybX/tSqCXf7Wlq+l5Qi8dCpM3SftOyqfg30RxWJ2OmIH/ICRwZjEgKz14gIUK4c2dPJ9eicSoTQVmAWCxXDfjfak/2OcGAOUqVncp9+3yLF0L4+IHI6308wyJvQuH0pPuh8jyNiGfiK8y6++0MENun7lxwQoFrfLTVQbsX3tnO9Xa8lsOPvqy8ai/zw3WODzvd7I8TfJTby+cRjVXoeDBhu/81GiIoZptFS17hzJox1xgBG2jNXV5v19ynEs8qRs9v9049tvf27Fj+btL+OkFxHFEzt77ZetEMUbNvc92nHsFDYj+DcJjxwCvYlfPpEbrHF92mjfk74DRx6+OV3Avivmfm3E9EMwBmAPwngv2Hm7yCibwPwbQD+BIBvAPAR++/rAPwV+3p8IMIL/9qvQvPwAUgpMKJJmh0w/STNnR9oZxRjk+FeD0R6ONGDEYuFFdc77RAN97Pj1ej3mgyV7/THixTraWGZWPouuOvaiWr7aq8Ztj96E19zHhSGUgjlY9F1A7gJclv1To/Zy7NvopqCa39+VhAyc0skhr+VfM/s36JHlRg+iMLfEANPUVYyIXTtuL+VsgYTeb389C9c7/s8bDyTHHny3MnadfYmwtZZ67VDwXPjfUsNQs6g5H6vQNeQFZWLr3XuvcqInGDUsJdca70Hjq+35wpC/7rdRszdN4Rdj/O7bG9KW2qCctjWS7iL95Ry+roetlV9mBImuslz2EZo7lXUEdE9AP86gG8FAGZeAlgS0TcB+Hpb7LsB/AiEsL4JwPew/Lp/lIieI6L3MfPr++znPnDy6ntR1I9hHr4BNsaPffGXZNOv7CFMPqdgoxCWDe6zM2lDUWO9P1Y6aCvhoQqq6/q+bvv+VxHVvkJZWv3eYdjx9OfOdv4VGzDiq0m7B/o9O0Y8yxx59sIZ1K3bwejnoxMGKnR+GpG3W1FHRFBLsAQDajA6uCttz7l/pTDep1Eeoc1guAi3T7znRFDeMBLVc3933kNUzl2LxNZkTBlK7DMn+xl0DbaREGqHZSR/dj+0QZE2Nnz09LlfCKaickhsOmtu/PwRjtdFx+4dGXZbRuL4nwFrF/1goggIG73gynCIfAAzjNZyzbAI07g9G/UAbnPSJly7Ca9N49r2d3Vdft6Ez9P3so446r3fCj6e8rz7hOQ+52r79tR9CMBbAP5LIvrlAH4cwL8H4JWIhN4A8Ir9+wMAPh/V/4I91yIsIvoYgI8BwMsHuixw/t6XMKcrzF6+A3ahSD0Y+3B3PYk81En/oeAQxPK1CIdrbicd0rbtyy6e0WZ9CCS1i++K68Omi8JXPYetCW2w4eF2D+E3dGR4Zjny7ld9OcqXXoE5Pw9iJkZ82Pu16kZttOrFwoTjc7Fw5OClRlSmEx3Ss8bWe35M1BdYcST3cGIJTRLdEfdPUSSaonJxmbjsRGyy1msbk1I6Hq3b1uAcaY17btJ+f+HVZdmYtgi3kQxAe+mHaEob1eAitWw4vSz9UGAOkQwhpD4+FyImGEnZoffqw+C1FY8GrLU9Z8C6kb+1AVjL+9H21UhZbprJHs0pY/++Pq/Apas9cUPtjvHwUL/7OHZSvwc4dBf8ue/RvgTwKwH8YWb+MSL6TkgYiQczMxGt9U6Y+eMAPg4AH6GTg5xFFCcnOHtRwkv8OpMYyZek74sw5cuxt0FtB/dbr909fYxrhFjsz2K1+X02Gdhusg8O6wxO6/dl+mRlX8/PefW2+T1s+1zXCSXZJoxknfc4JCSzQWkQzyxH3v7Ih9G8/jnALHuv7+o70xtdQQN/9x0DfslEf8Fh+bJR8pRtUv9tEkmyzhjJw2PB6Oe1YgzZ1Li9ci12T93xe42319eX4TrOGGAGlelo5BbzxoKWDcugXigbIu+EoV0KVBRyvipBJ4VcKxSgCgAEqMIeKytWncfT9qvRVhRqEX9ay9+NBjdL8UzqRkSifRWoFc8sYOocgo1Z+TuL77dO2VCnWFkmlO32byocf24z9u1b1H0BwBeY+cfs8d+CENaXXMgIEb0PwJv2+msAPhjVf9WeOypQWYKbBmdf82sApeRHre0Hm1gA2brYOXLLe5e8tep5q0srPMq64ZOwFfZ1kZzXXUthvJ4MDGhuX+9rh107ts4I1vpi7mlyPPSD6iWDobJrksCqH/HGBLbqeY4Q3DbtThmU0jaKkWub3mNqW9drMZxOUml7m8TjT/G+7TqMZEg8rvOe4/d6bBnZ9oxnliPn73sv5u99RTgwRsqRjn/6rvcdd76XE76nm4TibeTWWl1pK1G3qvnII+hD+qK14SGsz543TZiXtMII2Xt/oLW8xuvQU0wwYqehhMPRTVG5oTJRW4Pj1ASBtq/5w6T3tkHZ/jommlN2vyKupJl6byKgKECqABOBisKKwBJqVgKnJ/6cnC+Aogi/MWPATWP/1eIN1E04pxuYxQKFaia8N0jbCbpr6fra6X9+segb9uq1n+K4yCtWlulic47cq6hj5jeI6PNE9IuZ+ZMAfgOAn7b/vgXAd9jXH7BVfhDAHyKi74Ms/n54jGsF1Hwmry+/DH7wJkhrQFnicgRmDMQiAvtltx84KcCoVii4d++bpKwrFMffAxFBRbH5bhByFpc0dp8gA2Ral5N2bBvs79uDse/joKUvCFZOxaT72/0IW6QfZ1a0pBSFGcBl32t0+NuYQFZGg5sofAY9P/bYmjbQ/9YPduLg3juAr/Do9rUzdn6QlLYsGy5uSzjT662uK9f61sZ1210/3n9XYnGayHXCb9gbt04YyTqhmpPJJxKK63hmt0kH/bThWeXI8u5tqFc+AHPxEHR1YcfqsIYIYGsIZRA5kWG/bwrh73Q87hNnk+ZHA9/fEc/UXrGGaNgIbp2eAkS8AaACoNKG+MnzJkYrHBAutZqfPyj7pxt0emJmGT7Uz4cD+tDAJvB008CF/olYrEMW3YHnsFYE1ArRuLVYnBR9lZTZVABPbH+dsi7rbMur5YbqTj+t4DcGqP2Z1q9o8J5OFBYlqKxAZQkUJdT8TERgdM7XaxrwcgGua/tvGV6beqXxs9/QKW9u3KAZ9XsEpGglb9JaXrjNDTvXEWz/hwF8r83q9QsAfi+kx99PRL8fwGcB/A5b9ocgqZo/BUnX/HuvoX87B1Ulitu3UL/4AeCF94GaGtAiIsgs5QfiYpWdh84OdOTIDfCDELkfVCpqEkHTKuPP9wihoTIFAOsB7LTL7bKtn0ynvQkEORg/z27nsyAkU7HpSd2Ec4AVmwqg0laNtxugVjy7F6s2HKE1GXDNeuFnRaIjHjaBoHQjItKRUVMHAdn3vtH+UY8JSGBzEplsYZxkrbxGsbiGSFzPw7haxK0elCcI1R6roYMjjyFDfNzfoRCRKWEkNxE+souwkWcYzxxHFrdOUb/4AZjbL4CaBSILYsgSzSbslTmwfo4640X0G2JbzxcZ4FG4cTHhutaxC6GLRQInfYjL942zbC9zcjnl7u49/Hl2781ERblzvfW8hvg5nhv4ZzI05zCQZ2CTvjECV/mM0T3zE2ecsiGADA5ry0oFwkzW/ikl1XzSGTte2W2H/Huy4Xwu3A+NDQFsahGLRstcS7ffj/zZz308Mjfq1Blpz4+TfdyyygtpJrTr24p+J536w5Ej3XPOg7S+GPXoM6K4/vXwSOAhBrQVZf0tt+9ZVqCqApWVCMBbt0DVLJwjApoGZnEFs1iIAFwuYBYLQDej4mwKd5lJImuaQXos/HNKmVXYu6hj5p8E8Kt7Lv2GnrIM4A/uu0/7hioLqNM5ntx9FVdXVyhnNUrWABEUG5B9BQgEOSYrZggcBtTkleyCbPILsY2IQLAnDRcaQS5M0olGQAa8qCy1wjzd9ei+QHeQT87Hg1ynzJjYSy2g6UAV1x0o24Ex0bNLBlh3rJ1ZKYhXsmU4rSMr3a1j01oqS4CoDMc25pzh9r1TYEJ7DYYBwJZs7KJldrHmdR3EoTFga52cYnFcx9I4SiorBvW43cE1DKMCc3Oh5srEe1f5ga+TgaVLWpt4H4frrB6Mx9pbud5szTCSKeEjQ33bX/jIDXk2jhjPIkcWZ6e4OHsF9awBTAMGoIy2vCac5DiMvKAA4PnN8p7nRh2uuyQlSPnMmguLiLOSflE0xSRX12WebI2h1CrbbsmEe7k6rclvVJcQhKudE4zli0EqckMj7dNEUb2Uu+V/pGu5p9Y2hNIlxtASXdRnYHYZGaNzHYNyr1iM5zBo8zIboB7hbtdtNsKrbJOGqAKoCkDNQOqWeHlU2R5HtRbhoCXED414etDUwrXx8zVhTuDvaZL35vti5099ZcOJzrXAZ9E9Ad9n5m6mdHKLGcbuV7QFmms/5uuh/o4Z/Hx7A2X6+aifWyj+XEaEn+9vzDtGAwsNXsj+ppyUBQAUJWg2g5rNQfM56O5dqNkcKCtAa5irS5iLC3m9uojW+TkMc9cqSWc0T0hMtNoovIvs6oeZFuvIQUWB2XN38G7zApZgFKqBQgPDjII0DDMUjBAZyQetEF6VDdVUXlDZa3aAJUi2LrLtSJhEEIcgOYYt488z+3MhO7OEY/qoTkrEWWugjQayOOOXiQRkJBq9FdGk52Nhma6naH/xaczS2FPHtxeTUFzHXXchHtG1ULZNKuQ8c53nYSSrWVLHfV4c1yFLQn7D8wKqnIPnJ9Ei5gJsrZYejV1krGtPTFzXYqmsl0JU/rF0CYhN0r/0fNzPGxSCw97BlExGLK89ZfpCSgCAVLfuEIGN3S/UGRZJq7xkG1sRJ4SPuPavbx3bfja7zXi6UN27jSfNHTy4ZGitYRhQEKOjsjlh3GtBRn4jBJRkeY24tbuAQsxpLJkFqW0oDCKM/bEL7fS/ICcaXZih+x8by6FwV0DGWMo0vhwD3tDKcFzKHYNnLBDb4jAVj20+pnRimETSxB680G4iMG0dZaNaVGFApZ0bQAQTw3rX3HvVEuLGugbVS/GKNU0QZejh3pi7U4PxBAHYy8OuLrMITjaAqX2ZrmEWYFIy4S9KYD4HKfu3G3ibpQi/5RW4XlpeTeYCDlFfOuN4x/MXxJgXWSv4mCJDZCr8OJ3w9/BxaoALAtF0jYYpB0Zctkrw9XHWsPGvz3jbOWXb6OOPIe7qKELw5QX05UW3aFFAzU+B2QnK51+AOnsVIAVzeQ796BHMk8dAU/f0s5/fw3X7W+pZs941yHbf26r2N0EWdfuAUlBnp7h/eYIv3gfOZgbzilEoYF6KgCoLcei6z1KRsWOZAcFYkjNWDxgbgajtEjohl4KMH7idOCTqPxYCM+1rntxMIAGWActf46SsjWRUsTAsRFgqJxotwQIUiUUnMIUGLW10lwOm6+liIWi9jk6g+pAZF7rKBtzUgNGh35ZMKBZzgJTpIyGgO6AzB/E0EArrCcdZOFvvpU00khSnAXRbALaGgNi6bMUgkQLmJ6CTM1BRySBdlPBJdpYSX45GYs+ha/BiGT3HQDixR3TMwiiH7PvosQsBGFkXU8tir8cWaHnLhkVdt8ykkMI0lCSdiK1BZGMetaHYelLF4Hvaf/jIdqJvHUtjDtHMUGeneLKc4UuPgMslQxEwKxlKifNFovOsqCsYyufnYs+BsswuPmbAiTShIjD38J3jyNbfls8isegFIkldt/zd17FCU6JsgrdMgduZ7rvOt7bAtMZQ9iqyzTEc8Qi55Gj2fMrTcft95wDxiALBSKw4cKFiDRjHl9F5sHBQOZd/ymZMVMqGOzbg5grcNKBmabtrvJgL4ZxNchyLuoSjBz2BjJRTg7DsCkMyIgC5rmX9l3GC3T5fVQDlDDQ/AZ3dBlVzOb+4AhYX4KsL4VXpuH2aRbcPbk9DuFs7pR19+k5IpVEfFPU35RQ3dCd1iDjwbirmfJ0g9lYu34hER1p/GFNE2HSh1vrKem9eunSiK4TC++7nOdYa5uIJcPHE35kZUGe3oG7dQfXSewAiNPffhn7wrp8XDd3bYSypSir0+oyvq9rfBFnU7QME0HyO+48Yb70rH5yyH/6skiJVKR9waSezVSFEUBWMmRN+SsiuUAxFhFLJ+cIODEzwAtCRGjtCg4FhdhwHItMVfG6Q7xGGniwUJ2W7gtALR26X9cKKorKJCApl26+WDsVyCGMtr/DE2xaE5IlTgWVQdOvcGrEqkhavVhB3OhJ8CdEkoo5MWCPX8fzFYs4dpyTk75kQsAll07CUjsWRtYSLNAt4y3LLE6iAshSxV81A8zNQWYELWfiOegleLoBaYs2xvAIgmVU7YRlJ/1tWxhELoxy3P3NghYURAI0INU6FVmRdXBVOIoMykjL9Fk051y7j6LkjvopikuCLOt1zDugjttWLqcfE2RBRcq8lEUC0zm+43TFr4lQxN2UtYMazg+JkjsvLBlcXwPnC7eWl0Gj5LTUaABQaccyhKuXXWNhgh1K5V8uRBewryzUST5+ynAEASnGwFUZ8YxiAfbV/eo9Y2D88cKL7+nZEoo+6iTmvXSY9lnpWvCKIRr8kIxaGJO8h8B1FIgNwxk+O/8EKGiEMMDMKy3exqOs7B6At9uwxGQ1oEzicjaxzKk9Ac0lwwUYDi0tg8QTO+wkA0CHM0D1/AIBpQJyEGY559zpc7T4UFcoAIoT8/MSVcRxrRZhhoF4Ay8tgXCUCZieg+QnUvReBuoZ5/K68J1hDpLH38gZJ274fE4Pg8uOkew8+3DLMjVxjnNb3SAQAoj74IgknRnU6Xt6US/qiaxwvJBzQN+6nwmqK+Bo1eA4YWfuE0KrlBH33IwL48hzN+RM0b74OKisUL7yI+Ye/GvVrn4M5fzzYTnzvtO9DfVATEosNPZd1kEXdHkBEKE/mqC8XePiuwb27FU5OFZYNsNQKV7X445iFrACgKuXDLEvALR9ygs+JuLKILIQACmJPbkUhBBYLQbJCUCL65DwzYKwQdBZNNvYYYULuvrp9Hr/4vHIhLNG19LVXLKI9mI0JwyGvoX/eHDyNhZFwRWXsGkZVgcoTlHRmrVVuLdsVqF4AcQjooHcveN+4GLA8lhHJpBbGMS9fKt50IjDj6wPWSY5JMLJ2cnRPpkLE3mwOdesuuJI4c15cgC/OhazS9ouEZBUDaXx/sn1WrygxCdl5EuwhvR4LY9wexe83JcZO3b6MVO1BuV+MrS6zl/CR6B5DBDEurFZbNNM6m4SNrJvQZaxcxrMJdXqCy8saP/Mvl3jjgWRQvHOrRFkAZ6cKZUk4OyFUBWFWSqbGZQMsa6DWAEOO3RDljKZlQf6c41E3NywkqTQqHy0T+LIsrF0sEouurjYiAtmI8DNWAHbFnb0PmZYYjMvEkTnufOw57KvTjrZJ2kvqKAIIygtachxI8Mf1cgljjE8ZX5gGxg7KTrx5kUdyzE7UkfbLQ1o8yRAudIZTm8VQnbwCc/nIGhHDQ3LG0Tgyw/OBK2Pfm+dN91A14MdUz1FtwdYSeX6Jgn1ayvG8nUB7IWT3bgNkgK8X4MUl+PF9oJpBvfBemHdeB+oFZL+3RJCk7UWCywk0P7Pyxk/Ll5F4ChzaFqhdQRX1wZ2z/ee+OisFWhAUvl8Txd2q9oYwJu463O0+/45BVa0RDTNStqnRvPkG9LvvYP7h/wGufvanJhhZN4Pj3VXibhNkUbcPEIGqCg8fLvCzP3eFszsnODktMauAe3dKnM4Id28p1Bq4qglPrkII1Wymgpizr6X9ApSlvDqyKpSz3MVCMCUYbpUlAFWhvFWzsIRWKLmfGNXEy6e1/AP6yUjuw/4eQ5ZLJ1BGBSAndaK2wt+rBaCm0r5fS0pGwkm0CydhAyoKlCe3QWf3wE0Nc3UOCdOwgqqXtJylzRKEsxC6mHMTjjuhnulgFFscXTuOjNyDTmPvjel4Er2lseuOCh4u328D1FdijYQdRIsSVJ1C3X0BmJ/APHoH/OSRf85eNFoioqjvjoRSIeWIiIqo755MXbNtUpVrwxZGufew6BoNI5mckSpuc8gDuLpMn3VxqtgaC/cYX7M3JABVdK6fyPraWxU2MrY2YEr7GRmqLGHqGs+fLPGuYbz9QOPJYwljmc9lDK/sa1kqnMwLVCVwdkqYlcDpXOHWKaAN4ckCuLgiGBYe8zyZCD7Pm0U4Tq+R50vLuUqWTZSF3LdQIgoLApYNcFkDsPzjeZCUN8T2CT5Xxt2POvUH+DT+27Zjhnh0gGuJCLdP57i4XATPmELH7uTXHCfnFbFfU4ikv2koIJZXMLqBOr0LUy9tH1xDbS5ku55PDlw7bSHhbblKhX65RC5jSNsZEndDlrq4brTGbBdelYztsevnT6dn3b0zh8qOfAf2JQhXIYu6fUERFpcNLs+vvNXhEsDVlXzA83mJWQm88FyBl24Br9+3yt0EUnKvjfPU2e+ZJ5wy/O3GrUY7krKDuwrHrmytuVUmFoAEYFYpVIpRlYSyZDy54hCi6ePGg9gzA2sWCkdcsUBLxJtK6hhO6vSRUyrmItHn7ukG/TT0T9ksaVzXUOYSVFYob91Dc/EoSIVk7JeGBiwqzhPmjg3AboKQFk7bMAh5QLxgc/dOrH0KgVjsbKUbThLqdLxLHUubEvF39Rh88QhQBdRzL4NVCfPonda9vZUxsvZ1FoW784jKUk99RANhnH48IdbOgNhryey3CLasjBPDR9oiqT98ZN0ytjO9lsW4bjjftU6uZcmMrg3112FfawO22dA149kBFQrGaLz11iWuLggv31V47e0FAMA08h1yBsWyUtA2Rf35RWHPybWzE8Jztwn3Tglv3BfOdNnsgxHUcosda7UJQs47etww6347zqbG4hlUGlg0jrsIZ3PguTNGY8QwKxfkpQC37hE3qG2hIt6Ox9nf3MPhcEleur8XH+o3UiaGLNtQqMoCOpmwthOxJONPwrmTwAZUzqDmZyAA5vxB61q7bNR+JylJEvESnx8SYH3RLCsSsHBPNAwbI2n0z+6CTm9L9sR33wgeR0Rj3UiSFne/wfXfqaEXw+NjbzKyXaxtj9tL+zWx7qr2hrCL7Y4m11/RJ3XnHqqXXwEbg8Uv/NxoO1PaG13jvsa+rusii7o9QsYpCdtwPxITvZIC5pUrG86n64QNtYnGwZggyGjCd8Q7E3z/nKfHDUqRwCsIhQIYbr0Dt+pEsRGddsL7HyYetxud108TiGwdsFc1uvfY9YGUXXPWt9+K3+eOp1kEYS2OHP4GesRd373Sa9c575V4XaCqZG3BAKZssHms2NV725d1rndNwIp73UToyLSQmxyK+cyDGZJ7gzGvFFgz0pFyMGsuhDdvnQL3bikUCnjnSbiWDq8hFFJelee4ILr8kgb/KuGLVSmJW+YVoypdeCNj2QDvPIb1DjojpjN8chTZkho6u8dja/PS813vnVtmYaAU+RDLgsj3QZLJMNgYNM0CxjQoABSw4ZfcdMMu3do6t6bO1P58ujxBgUFFCVXOgaKS9f3NEnz5SEIVo7Lpern2mjpn2OxJVJbWXSHUWkseVq5XFwHHswo0OwFVNhFMU4MvHsO8+QXfXizkOp69zrKIrqAaEkutsn310TOm9vRhLBnKqvbG9usbbiOa060h0KbsjTck4rbfs9aeI4Xi9j0Ud++BTs9gzp9g+drnwrYJI21uKuaAaYIur6k7RBiD+bzA7GSG2UmF+WmJsznhubslzk4IpycKiyXw6IJwVQPzuVtTR8FT58Ivk7DL0n5qhYpJiVtlgqfOHhOjtIvJy0JCSirVzjamSNYKaAMYrfFkCZuwJSKaRHSpOAGLfetD6/CI2FsoV63Da60jGCrTsx4vkJMjIdtvDgSkyhKFmkGBYZol9JNHMp1Ik7f0JVVZkSlz66Qq/jglK9NtZ4SkuNNej9WznIHmp6CT21LkwVvgq/OupRGuWR4c7HvPD1hTV224vqr9tchpIqaQ07rtHDL2HTaSQ5MyxsCGwYpw994JXn9ocP+RwfxELJwz+zo/kTV2t28VuH1WWCEnC+MMEy4WwP0LQqOFI09O5NWtUw/r7OQ4XmtXqCDWJKTSnWObkMQNuYxGyxB1tRR+dMJsVrb5SEXiriPietaX+7L+WkiEFtbAAQUBBEKhjE+Q4g2zPjmKzYrJGrL2z8CkicqYUUJEHNDmyCISbQB6E6RAKRTMoKKQLXls5jLZaqcGrs4lmZd2bXE/P8bHMUeuyn4Zt9XHj3HZiBPDWr1CvG9FKXuXqVImU8ySzn5xBT5/DF6+FbJdOox49Rz8eNnHR0MipqeNVfwYC7mVGS1HeG3MG7eWt3AHZaJO9ZRdw5s3UofmJ6CTW1C3bkGd3gLYQD9+jObtN2EuzzcWcVP6A+xfzDlkUbcPMIOXDe4+N8e/8tESd+5UqGYFLpeAZsKTJXBp4z1mp4TZaSCeWUVeiDlyKv3agLZwqwr2Wb8qmyilirKAKSvIpI5Y6+R7x9BGRJE2wLKWKPmYgBQx5mXXati/VYLt1wTBtlLM9Qi2wayaXnyF49jSSKqQxfGqsGGZBDI1uKnBV49h7MBdJESGVMDF2x+MWBr98ZClsS9hypDg6yOpMUsjogEhJREiEXCzObicScpmUpLR6/IRzJuft9bPEUuj7VNfuEhv2Z6Qkyn74d0kSe3c0iidWll3Cjarsx9LY0bGtjB1DVVWeHCpwVWBV95HuHdX1p3fOStRlRJ22WjAgNAYwrIGHiys8VNcTbg1F3lTlSJ+qkq8eM7LVhAwq0LyMEAEmzbwv03DIo5aXOjK2oQjlTKef9M1cMHgGURZYaMqVUegsT0P35ZbgsB+vzu7vZHbUN0YEW/agN3+tnHmSUTLGCJuHMownQo4ZRrhUKVQgAFS8l6pgCIFEIGMhtubjhYXYN2A7dYFXpgZLV65dbxvMSemnNfZNza6HnMgkd+LDkqJaCsKEW1KiQRmlkzYTQ2uF+DLc7/Pa6/3rYfP5KXLfys5cYTf+jjxkLxvg+1OKDNWdh0v3Gg7fXVIgU5vQZ2egmanUGdngCrAiwXMxRPo+++gfu1zYD3OqdsKuXVCLHdp/Myibg9gZjRXVzBqBswZT3SBuSagAE5nhNOz4G1z3jNHPLOSUZWOSNw2B5YQikAmDBesIuGafmsDt6cdM9gA2gmByKNWkCMdBopu2EdMNN097exrjyctbHfQtRD6sh2iaR87EKL9gti9yh9uwbc7hgrWS1WIeFPMYNNIKn9jN+oGg1iHcJAe8Ra/tva06xNvwEZ72rUE3Kbx/nEdwMYSVaCysuRWAtUMYtY24HoBs7wCXz2UdQFN6PcQafSJpD7x1j7kdh+j9+LLHHjc/zrx+DdhcVxdJ4uyjMOGvrxCdTLDL/5whQ8slIgpUlg0gCkUzjVwCqCogLOKcDITIRQnK1EUDJ0uykR4JGxTIMtqhSONCZyjIOedyCqUAQhW1NjtgxB7zdiKNrLJTsLm5sreEwjbCYHtxuQ+GkPbodJyTR24x/NnwoXeS8bcKZtGjLQTQhEUjMwPKN0T1l4jZffZUyBjsw8bLR4rowEtG3CT9bpBR7zJZjSkssV7He9bDwe66/E1VQCQRY+sSgmHpELOKxKjpFuvzOwFGnQDru2+ck0jm4l7Ppsg2IZE0Ri3TAmXTPm8r53kPpO4agcc2Nf+vjhwrJ3RtvrqkAKdnKCYn0jY7PwUNJ8DxsBcXYKvLqAf3kf9pdfAddPf6IQ+reqXw02JuBRZ1O0DDPCixnteKtEo4GzOmFcS6jgvjfekATabFFtSsuIsbKhq2q8mWATl1Q7y1E080ifGBgVa4h0TQoiIxBNDW2zJ9bB+wIfwt8pYkyXZzcmdIHMiLh3k7Tm3756QopHLrr7RYLDdVJQh+/DI3y72n6zVEIlQoxGP2mhoSF/oZNz/Vrx/KtCGhdtKr5tSPkyEqACKAqQKUFHKNgWO2JoG3CzE+7i8AC8WlqDbg1lqaRyz5G1qaZR2d+N9C+1NF35j53ducQwdHKizBgmO3Hta3dWksk37DtcVRpLx9MJcXuH0pMLtO0BxIhEl85kNKiiE/worxoiMN1p68Wa5rCRn+DRehBVKRJcTZip5LaLEWgRnIA1c64QCWyOgE2yxRwqIRFcitBSbrvHSefcgfXMQAypEfLHxxCpGSmfEtFVI9p0FocOfxOzDL6W7xvOkCCbIe2Ej4ZJGg+pa3pvRfu1cL/dF73ktocaAj2WFe1WytRC1j0EUcaHcgxvpJ+oabBaSkdBoEWp1AxHROxZqK0TXtkJtSrurhNrgfVb1d6TeUNlVddYVbhslHiEFOjkV8XZiBdxMxBsvrmAWl9AXT8Dvvg1zddWtP+UeveWmi7Rdc+I2htks6vYBY9A8OcfdkyWql4GCGiiI8FAk5OG8WgW0WAjJAIWcDwItEIM4pOx5t46OjRVx1PKKEVmrX8tKx/ZaRBZpWGNMFJ6U2pN/Z3lkDkQRCMVZ29hfYyvQ/HljAISQynQQTQeJYOlMzrXqRFbLKeGRwPb7yaWCzRFdVKZDOEQSBkBiaaRSSM1uJCjk5jYLd4K1Eeuj0bWQ3OIKXNfSV+t9HA2TjM61H9kagi15X633NlB31xbHvrZ2YU08WCKbWHfb9te5zz4zdmU8W9AXV7h10uC5W4w7Ys1EqTSICJXd562wQq3yQq0tyMQYKhtrE2sflkhobBSj5YXGjv2OAyLPmBggCQoanifhuJaAiD/F2BksmF5gOfHiDara/90ntsBsuRFefAEQDol51B2biFdTXvMcZiKpmHBhZ2zt8bB1vG0UTTSUfQxKMguzAkiBiyDYyHnOAD83cPumsjGWr2QPWTZajI/GCL+5vWN9/9rvbR1+G4sk6Y0iie/n+t6qPp3XwvkBETnQzlBbO/GWbVpnhOOG2pvS7kouIoK6dVvCJk/PQCenALP1vF1CP3kMvnoTvFzuxIg5td8pDsUr14cs6vYA1hrNo8d47+ljXNISFdUobciGhD5EHjVLFHGMfGz5C94q2AGKQVqOmY313nFHWAUx5OraEEJPMNz54VIkckaFU4w4bCIpG9rl7rWxMmn7vu74fQBM86QBrXDGaSGQZMM/VJvsyB6XyoeECMGpdsIJNhLyaDSga7Axsiah0WKB1FaoWSIfjd1Pns0UIgvHuyG0ye2P9Hv0XiPnryuMcZPwkW36MrlfE8tkb1nGoaJ++Bi3Z+eY3zVgU4vBkxsRalyLQHProxsNxU3gSSJZM21DCWPPl3Ih/tZoSURB3EVG0iCanIASHvVGRy+odDjvz0UCK+baWGANhd47xPxkTHTOLr4jcnrS1nVi0r5Ge6f6sr6urcOQ928TmviypCSMUdYrhPeDWJA1Ip50I3s6WOHH9pwINR0EmTtO3uNo8pDk/BCPTfGWhXZHOGySoXCCIBtoax0OG7rfqvJDdSbVXSHUprQ/6T6btEOE8sWXUbzwMsz5E5jLc9Rvfwl8den7vWsR1+nDBByDYTOLuj3ANBr68gp3zz+Pu8aAmhqk7ZouXVutpQEYCXOIvFEu3FD+HiCG+PoqkdQnilZ4x3r3gZniSRkUXZZo/GFsU+SkjJGwwaLs9nXoB9snGmGtiW5VOlMIZVFKwlLsQmoXGiJhLirpH2RVvVv/ZjTYh7DU/jy7Z6Zrid+OPYxbEFrf9SnZI3ch0Abvh5shu9XtbUh2wCTC296jthuyXKfcdbWTkbEOzOUV7izfgWmWoPoqrJGG9agxQNyIUdNokG6iUEK2ZSIx1thj1mLoZLZZGLmfR+P9I11kBKW9pKgspK2WgEIivhBxh7LXVVQf0T2jY78VkIhN1s7o6kSW5XkdPIAoS2nbzRd04uWL23EiVpvAXWwCzzchamXS+uoJxsT0+i4zOvaVmRS2P9Je730Hzq26567bmDRGTxRsO73nGu2tapeKEurOc8EI4X7DRQFe1r11bgJj2/kMYZNM0Nts+5NF3R7Ayxr68QVOHrwO8+htCf8wOiIPkgEwPg61A2kAgXwIsoaMkvMxiOANl/EGzL59Z8VTrWNKyxQ9g2F67DbN7v2RcvTC4VUBbHT3vGuHWbxh81PAxv/7Daxji6OzNmJgEGa2Xi8j99NsiYxD2KUxgGmCF81oyYYUC9o14tz7Fk73XmudH7Y4hvuOkN1AXybf099jxQC1cajFniyOE+pPbWMbb9zUexyyx2yd7QvWIbS8pUHGGPT5Jebvfh7m/CGweCIiTusgVEhFgspEIY5IeJTbZR0IgLF84Y2ZzsslQpAZEg7YF/Lo/8l5dpNMK44ABpuwljuIpHYbrXr+3gFrrRWOuECdnLTqbBQN0SPk1hFfg+0+hXw0tY1129um/XWEnLS9vqiY0h831k+5TypWfEhsU2P56Z8TL/zpGdTtO6ju3JMtKMpIpugGZmkzmNdLcG3/bhrvOe54jNfsU9q3PjgujLGKF9PntKpfmyKLuj1AXy1AhQJ/6YtQZSVjp1HRwG+8FS0M+iYQhDGJ4Iktbgh1/DWEa26gZoOOeLJkZAu0r/l2o/vG6At17BTZ3QS3es8r8kdPiAzr6P3HWEOE9fZ34D2uEwI4xWu2qm1pZ8eeqikEsAORdB0i57qEwiYbafe9/01Ib9VznLJZenzfVc8sfh+r2o0JbR0iywIvw6F++Bh48zVJntW4cPQa3uvkjGvW4yTX2HqbnNiK+dR552zq/RgjnqWbDk9vjctOlLpwS2/IRCvEknWNkxeUfw8r77Njg+GqOpPE0Rgf7cDzs24ZQMaqdcbJVffpm8R367Tvt46HZsKUbO3+hLbNBv3hte8D9Pxmri6gry6QSjM2DBQlqJIs31RVUPM56PZtv40FFWVYHuPq2PFD9lOUBDz+uJHw4dYYYzHlvcefeZ/Q633HOr7HOs9qGrKo2weMARUFLv/7H7fHIUvTKiJYaw3RDibqq+69z3pjmP/iX2YtsDpYYZoabLRYdKNF2F7kEouHzoaueOE61Mc1RFy4Nl3MTcHgJD79sUf3HR5sRgaIKUS7YoChngF4HUwZ9KeRydSBcMKEJA21bRWa3l+Hvn5PJXue8BnHba0inXbZ1fdc594OKZGNibx9EFjGkcIY1K9/Efrt12EuL+05O1anXGmMFziidyiKnJTwRtE7UbhkK2pFQiFlyRr5qA/mKPIDsGNuVJ8IrERgUSSwXB8oFV3+tef3M8DV4TdlPXuubOrls1zGzFDzU6hZDTq7bde3aVDjMltK9mUyIVRzWLCFfhINlLE7tvcZJn0EaTq++TAebDb/KIrxgoh4YnXRafOkFHuaN3XLDr+BG/UcjvFip2HHk+vfn1T/++83jgIAA81S9hy8stO8sfclGZcAKkBlacVfKWKwvOWFIBVFtOTHvmi7XlQ3IgSd8GsaLwTNchFCn1fAvaep4m9TZFG3J+iLS1zeL8CLK/iQQIwItGvxcOxefO0abBjq7BaoVOB33xCCUrKwm0FQZSHrCZRNWuIWhiMOzRwh2Fa4SyBK7w10ZIqITH3YpqS5jkNzvIU4XrvgP2s9eK1N2gAS7+ikz3pMfK4w4/V+F1Z9N3vItiNqoiIpmfpPYtT6u1qoDJFHV2AV0bVUWK2un353eonGPZORQZ28UX3VZzpF9Ewn+ilW5V0L1iHCOoYF5hnXiyc/+3Mo3/sq+ORU1jm78MhojHRgHYc6uvViIbpFxmEDMPnz7dBHZ+gzMC5ixYRx2Y3jHEevRNeNdl69tsGQDUfjPLCJoXCdMgBw+os/insf+SrhwXrpRSuR8oITfrOGCK2uMeJkK9zavie6FvOV85ymnKYTvvR/hzGE08+hE4WEwbrjz2yNOdE6Amidz3GLCJetomuObFkEFWoNr+n0+/QJw26CHCP5Dtz1kX56FIX8tgoRg1SWUGUJzE9AhYhE2PMuJJxdtEATh4U2EiZqxaEXgntCFnV7wtUX38TSvIjlm19qfcFW/6Dy5Gd2+yXQ6QnopffIlz/NaKklyQy4sb9OWzHyiA7vWxP9kJ2FKc42llhlIftN2B94ZAlGVIdiMWlXzMdlgHbZ1iL7qGyrv33kEQ1JjlwjMo0nPf68iUKUmMEuA6cNXWotmk8zb/pHt14oj9TZQDQO3bN1n7F20zDHvnbHyG7cQzUuBCd41lYIQFlOtCr8p+i028VqUt5W8Ek5M9lbuG/rZMbx4dHPfw702ddl7DDWQIb1frfbTkCnGhvW5eVtDLArw58fXUK9+pXAxUNwvZDx2yaKIR3CVN0WDoMZOF2GF3eaCOz2aXAbfHsOM+Hv4CYN5+KEMWm5VlbOqAws94JkXI/rxklq0l73Ca70lC/DIZmOE5ORKHfCPBWwcMZen4DH+DX6Ul6HBDOOX0eWc0xN7LJR0jPgGrh1dburru18G4QRb+KYKBwTg50+sZ0v1YvWVHP09+2Eniq98FO3bnlhSGUlTgnXlgsHjdYJui0cNkEWdXvC4vU3UfMvB176MpAL9fAhGwj73RwIOla9+DD+sfcSQ8+lHmsrOvdg/6IK+AFfqxnM+z4kZZqlJJphIxYPNiAXYmkzoPn001q3tmUAEBGa/SHH9x4iuz5h2JM8JdSNfu7+/ugM0B0ymhAS2idC5Y3I9rSBPMmOcT2CtCwAViELqNuWwWf6JG/tbSkXbwVvvOhjn+3TrntpahsGa883TTvZDCYQ2rpENpFo1t9ewa2hGyKlPoLcRgh261DqDd1AAI4Jv+lew2FsG0abDVcZAHB5/wJA9/swJrT2najC192TZ3kXHuuqIegX3w9z6x7QXAGk7FYPqrWdQ6Bb+3uNuTDyvBEb720jx2feyxn20+t68RJPqBNPzmvqk9TE0+HkM7HPg1y/Wg+rj2sT89kYp3rBaLrRO7FOVW0e9VwIAjALg2a0X59bHkFkN6dy11pdcxmzTcSfsRFVwmXZaL9fnze0jjwH7puX9F1D8htYNR/pa2MC1+4/82iRnO/h9TWEJBXjPO+/ZyPcPeodZGP3EF6CF/bUQF8ASNinKkFVCapmEhqqCHq5eiP1PmRRt0e8849/XCZpxkA30QA4If52n1hpNU8tIK2sYlEc/li9dK3BWN3o/OlXfiWql27j/O4HUC8uUVZNtCcRe8IigiyyB9m1XrIBe4u4YAcWDvv5yQbjQkB+f6G+DGiRB0xSZLe9hb379ckNu0TjBokOSfUItjTkjYcH8CFvZF87QWQbABpuM3axkrcFKcfvBdYAEW31QGUBoAohsMp6Md0rFVFfIu9gU1tRqEWg23+oa5+ue8jaOUoiI2S1izWs3DeZSLyDU4TgECH0CcAhD2Cv5y90tHU4LuDGvHD7EXybLL7PeHpxeb9/0rKJ8HFevn3iUIwRrCqc33kfmpMayohnTrFwmDNwEjfRXnuNF28MttsoceBNQLx6RDIqEOC8ZM5xh+Bi8/wbIk8QhGS4IKU7Y09k7E3CYtsiEXD76VKLj9K1hkmdeF9BW5569s9rH4+IjxZvsuUaIxupO14Yiw7y2ylBBuSSQFQhZPAORlaiwnpLI0+l64sxYF0H0ed5tLZrvZqQ2bvnuXNsxPbdG54/7CuB0FTxxczd+eUEzh1as7itEPS8NsK5qQicvByEDaCXgF7CXDyJym/Gk9ci6oioAPDPALzGzL+FiD4E4PsAvAjgxwH8bmZeEtEcwPcA+FUA3gHwbzPzZ66jj/vA4v5m7tN9gw44FKp86RyzD7yKB+plLCtGgRqKGxhmKAhxFbCb0trJp7KCS7GGUu5vJ77ESqdYNn13qbEJRkQhOaMc2Y3fSTan9YQmJOU3hG9lD4XfID4IQtM5R5FIZGv99GSlIxKK0ScevRdwQPj1efWGPJc2Q5zf0wnwYa6UEkPcViuZgQGaEUHoJvF2s1smAhXKhh+cgJWSga4o4PYVhF3rwU0TRKBugHppQxSW0XvoCr52X/YoBIs2WZCPrEyE1QRP4BQP4Ljw83frbY+KYoeCD9hE9LFbG5vRi2eRIxePljtv0zTd39LTBqYZnpi7eLw0MEb28lM2V6B7LRWjUNYYqmSCrMi9iphTxJ4b3figWIskYyOvlrvIclfYR9eN7wxl2kZRxx8EBqnEQOjGWecwY8hwk4jMsNWSO4hEY0/Eiudl27jjcPjlENFVV7Q19jkhaLnbCjjSdfCwGQ2ykSnB+Bu1k3AtxctGTPL+XTQLswynsTDsiERuCUAqClA1D3vsFkXg2PiNmgaonfG0BmrHp7VwqvUI9vHd5C2crlMIDnCutJcYXju81uXeYVG3OrpkbNnFOgJwSPhtY0C6Lk/dvwfgZwDctcd/FsBfYObvI6L/DMDvB/BX7Ot9Zv4wEX2zLfdvX1Mfd4768f4WQ24CVR6umKNK+lZfGTDN8O7lLbz9GDiba8xLhiKgKhhKARU5YjASugk3CBkU0DCWIDgmGDuSeyEI47M5unOOGJxIdHUV6yDqEnKSstZLSAQqLCFYYiEfFomOWCQ/BMfWzagvDB8iw+AgwDghUb8WzpItR5vzpuLQCTdPSE3nmh+o+45TctZtYvNtdQQgZJ9FMGCWQmQ9AlAsxNYrWJRQVADzOfj0FKoogbKS6wwhp6aGWdpsWE0N1AsJZQHGrZMjpOIH2pRMohBeP3C70JCh+xRFl9ySeH/qIbB0cO+zAg4RQD9hjAg+eXMr6rfeQOdM9sJtjWeOIw+NHzcF19crJEmd4snVHJ9/F9DGQClgXjIKBVSWK2cFg0j24lOWJwEDw0BBxu61bjnSRaXACT6gUAYEoLCC0C2bU8rA/cTDa1TGciHgODYab20fmIMxlBCJRTiR43jCeRTbnENeAKLDR2lZX4bb9eO69qnavhdeZKJQUJWEX4pAFcOkC3MltxeuFXyyFEGMkRIdFHGj+zs1rna4ltHx/Hn+jN4zN0DT5dhWHaXAUEBRSIK5ykbX2MQfLoQ0JPNYCp/WS1CztO8nNdp2xdMqQbWWAIx5M1kyM8a5nfaG1ttF3JtGTqXc2z7X7udQtE1f2YAuBw+ts1+VSXQMexd1RPQqgH8TwJ8B8O+TrIz99QB+py3y3QD+QwhhfZP9GwD+FoC/RETEG+WkvXnoy/Ut2vtESqEHJfJcVutLAHSCNx8ofPE+UBQF5pVcq0r5Gszsa6ksgZVCNEXBlswIpSWfsghWSkdsYgBk+zd765xbV1g4sUdBEPq/nfBLhCC1xGI/0XixGNVNRaJbaxkIiIIAdOvWrcVSkavRJxbjdQIAsWz/QM1CLI/1lXgVjfYL6km3iScWftIGRyJuwErZyqJm2u2mYZ0REaWkRNYazGYJmGXbG2n/ZhBQVlCqBE7PJDbdkjCMEe/e8hKoF5I23Wg/kPd51DoWtg6RBUthmgKcUzETD9ymPZgHkrLv2YvGbmbPMeIZIhxft1f09Y9Jfcsrhj1r0717fWLvUMLYDgXPKkceGj8eC6iscLFo8PAhZLIO4JwItQaICI3YGf2uOLPSGkMLaxwtRZA5/qxKRmnLFkpYsGHLl8YKQhLxJQKMYbjNjwBQkBvfgkD012BsBKIzdDpetvctRLwRkc+pEr/G7RKM9yQGsWRFowtDjaJiOmLOPcceIej52HG0bV8ZScqmbJI2Mg2ItQg8VUj0yfxM/nahlcaKPWtoZF2DarfIqt1+28A5gVvd+T4PYFTG8Sh03eJYjtplhs0oXoLmMxSnZyL6SjvxamrJ2FgvwYtLYLkEu+UoJvIN9kTIyHvscq4/N8K5hAHPXJ+xtXPPgUiX+Fwq/NLkKiYkAusTfO3zU/kX6OPPgeWNG+E6PHV/EcAfB3DHHr8I4AEzu9WgXwDwAfv3BwB8HgCYuSGih7b829fQz52D68MmLV3vt32q1jc3MBNUVaFZ1KgvgJPbCqQVrpbAE0NYNsDMtlvZMae0P+6yYFiOQ1m0icYdV0oIrizYk1pZwL8SALaWTAOGsTH0bBiaIxEWEVfrFdzxCvqyKhWCHLXjvIPt9luhLAPWSGUJjdyrL9sWjaQUVHUKUgWK03uy2apugGZhvVx2jYsPzXSvkehLrnWEW7y2IQn17IRzRp5ASq91PIHhvB/kXShrXQP1ZRB7xsgoW1agYgbcuofi+feIlXK5AC8uwRePJaNVRBAd8rHE4EMr/QDes/F3QiLuO8BsQqarAeKJCaeztiARVmN7BU4jkdVCzddPSc99l3o2FB/ahH1K2YxnkyMPnR8PFaRKXJ7X+OSnFnhSCwnePitRlcDtWwpVCdw6UShmBDDQ1CR5OIiwqAE3tS3t7K9Q8LxZKMeX8IIv5siqYJSFeAXDUCIizzDDWDHYGMtH3ptnPYBO+CUCsKCINxMDaressevrAUVVSwDKLkfkBaK0a8dWn7CFfRSH6FW3BUbEb61IHKCwHOiXepgmGGm98NOtrKPEGlAFVFGByhmoqGQ8Z0iCm6YGX13Ah2G6toYEX5+3b0zwAS3eHOJYct4+UwPLumVkZWPEWFpUoNkMdHZbQj+NAddX4Mtz8MUT28ei/94qikdKuaUjpJyCjwTgALd4PkGxlpHVRxWl0TC+/WBs9V5I1a7bj6lG0L5yuxsL9yrqiOi3AHiTmX+ciL5+h+1+DMDHAODlA8718izE94+iafsGJ3kGNQOqwDvvLvBTP1vj9NYMd26XOJ0DL9wtcGdGaAzh0QWs7Q+YVYGkysL9bV89WcEeW2JQQQAqCucAoCAFAlBGYZ9lAZQq2tkADG2F3rJhP1C2rJM9lksAbeulK+Pqo10mJrRAdkmZHiGYCr/Czg+V0YBxJGWguEGhSqjTU6hbzwmxXT4Rq6InLfmNUaEjorGvlky4aBMR9Yk6L+bsXNVZ5+LwlDTkJLihwvWB8JSW2APEUqprYHkeBmpVgeanoBdfAcoZ+OIx+NF96ZMjgoR4ugM7BdLhfoJgBMLx1lQfaWH7awf3mDA6wmxE5KUCb3i7gphEhuq4NQfdbQrGRF5cL0Zq4UzvkSF4ljnymefHTVGWQNPgTnGFgjXeeKfBk0ci7mYn8lnPZgWqqgABuHWmMCuB0xOFkxlwOhdvXt0Qzq+ERyv7FVEq4U3Lp4X35AUOVRGnul1/XOhnoYB5BSjFNrqe0WhgoRnaxOLOtksmzPO9oVSO+/jTjWgpp6ZCsMWx9v/KCj7llkwoed/K9p/smntjDGq9hDHGizrPo6yD0PNC0AlAsZY7LjRGW95d2HN2bdzsFOrU2nEWF+DFRcsYyr7diM/i4zgxits423FrJ8wz4k1vKG0LKOJw7PaM9PzbLMT4a4UwAGB2ApqfQj33EqA1zJMHwOWTTrt+/0nDwduWcq1DLPY8T6RLEXo4Nw2PNIlwUoFzGKsMpdH1LYysw0nDugbUtMw2HLnv0f7XAvifEtE3AjiBrBf4TgDPEVFpLZGvAnjNln8NwAcBfIGISgD3IIvBW2DmjwP4OAB8hE4OlhmuO9Z+U7j1bPvGFBKXKAeF88dLPHl4BWMYWhs8APDuwxIE4Lm7BV5+jvD4ivDkEqhr57kjb310JOVEnvvNVKU7pkjgOeJqk1XRuOtCTkAgo8oSV1Uw5pWEk1wuGbXmDimllkfXRkM8LPi4S1adsqmYiwjNCz/bb2MKe2+73swO1ooLsdA1ki2NVIHy7C7ADHPxyLZnyYsaX88N9m5gdQTG2j48Un4g9QOsIxM3cMfHKinjCcadt2RF3CIfAF0CcqIpDj9192QNLJ6ALx8BRKD5Laj3fTnMo3fAjx7YWyaiCxaObJWKBvN+womJwQk8L+58iuyEMKAiK6K7a0II8TqCFQTT51lMhVU3vGTYs9bxAMbPdwNxlwHgGebIY+HHQwMxQdc1Pv3Zx3h4WeJDr87x2jsaiyVjvhBxV59UqOYyNi1rG8liYyyrWYGyAO6cEV64TVhqwoOLNgc6o6izu8Viryv0HKd2+VQpCaecFVL3dMaYAZYrY1GnImOo4xh3zXGhdEaRGRV8QBg1m56lE0TsI1qkbDgfR9coRTibn0LXDRrLMYE3tV8Rr2y/nJjzWaJt9I1SOgg0d47tBtVL2ZKCqhnUyW2Yx+9EhlE7pqa8acJxJ0Kmj1vd9TQBSMdgGnh1Esc2S/DyCvzkvkTF3H4eOLsDvPO6FIkNm7atEALq5g89HAjIcogBfuNEsJEyXX5LuNA/S+6GVPq5Rw/fdfgyMfTGdbtcOhy9sopbt+HIvYo6Zv52AN8OANYK+b9l5t9FRP83AL8dkt3rWwD8gK3yg/b4H9vr/69jXCtwbDgkcuWGxf1vDIzWMNrANPID0KUsCmdDMFqhluROkVcrbsk70wEApT2OM183SZm0Ttua5BSa66dtowRqA9w7VQAMNAPMdiBwgsoeOzHHnkwMlFs86wjCDVzerti1OPoBNiW0VlinLeMHH/vWUs1hAHIi1EWGLC5Rnt2FUSUA9plEWRWdJ+bbo2TQU4U7BXbX3AzBOXCd1U5HDfkPMRE+HA+87Wt+wFZtwhgLafCD9dUT8OIC6r1fDv3kYau+F3fpgEsUCCe1qFG3bodoEnHXygQ2QjCtfm/p7Vol7vrrTCmTvXHrIHNkxiZgw+CmQUHK8iRgNENrGVS1Nigay3mFE0l2DKmNdYQoaANozWga53az42/Tz4mBM/vQ5VPv5LchmmVBmJcyvDU6CEOoKBJPtV78XyHDpfIcSgNl2tfb19JXjgyphkJZYyDCU5XQLsGY92oZGCvmXDv+2AusqC9J5I0f890WEMtLoJoDKoT8pZzqn0gcaugemkmI3Z93BaPxODUqmuSB93Cs52w/JwpRJmyMJFp59A7Uez7o16qNckHSTmdRmVLd5RBub0AkvEyqw9WDRkZSIQHLBHE3aAztE3drcGmKTeoM4abiMv4EgO8jov8IwD8H8F32/HcB+BtE9CkA7wL45hvqX8ZNgRmsNebzEtW8wmxW4O6dArdOCM/frUAELDXh9fsMVUjYiA+1LMn/PeSpcySiVDukRF4TT52Nx68KCTFxoSVlQT48xeUOeXDuMotxZ2G3tyqm4Zg954bWEfSWwRqDxsBavRYYUGWF8uQMplkCa7R/nCDg5Azq3ssSgnkE2JVY2qSdKYSTxdzOkDkyoxdsvRgf+oo7eOM+8OkvNlCzGYoKqOZCfGVVoKwKVAVwdqZQlYTbZxJ+WVUKy0ZE1Rv3ZcIacygQcaJfox541J2L+dOtv5PoFfHKzcqwxAGQ+zWacX4l5eMIGAUOf/sIlzYXxuvx0qiXwfDLqOxQGReGWRKgiGQtngIKpcCmxrJuUHje7PLx0LE/zybwbbouvqhA1RxKKZilTeY1lDUjPd/L4UN1J3B5X6hmZ+04t+7DxgDVHHR2BzQ/hXnw1ur7TEEfjwxxS8973oiHhrJ29rS3asuHm8S1iTpm/hEAP2L//gUAX9tT5grAv3Vdfco4PLDW4GWDD375Hczu3kFVEZgUFnXI4HtaEk7vxMLNvXIn3r/wKZphz9t1coq9UCsUQxGhLGwWTRdO4lM/y8JqYwc7bdhbrhQJkZ3Mw2Adx/MDI8JtJKlKmlWTqJukJc3qlSZSic85b5sLEVF2s9mCyK4nqEAG4OYKuHgXRSslc1gnR31x/faafIAmHK/aIqFvbUCa/jit05MpM11T115Izu1rqgTNToGTU1kTcHkO/cbngWYZtdO2fvYN4Ku2RmiRQJp2Oinb264vM0ImIySUHnfaGRBocbnu/n/dOkPkOWVT94w2MkdmTIG5WmJ++xRPVInyuRIfehG4c6uQRCln8jqfiYFTaxt9oQHNJHtm2+z2Jwq4fdcmQfGhk+LdqkoxTvokYjabdFVIpkonygDhJmbY3QjkD20AsPFDBhFjVgCnJePOrE9YGe8ompIwRaX1XeIUiPPLZ860gpMQrZcj58ELY7jbEsmn6NcGpjYoTY0S6E2YEidNAQIH+jV2UcIUYgZsZkwqKxDNpBP1FfjiAbC8kvcfceHKZGRshjm1k6QsFmqm244rA7SzSabcSiQirpyB5pIlk5eX4IsnMG99sdtOdNxuL/Uwui51z2/CtaG9Ed5LMnCGMtG9h8TwqAAc5/CpZTbFYa6gznhmwXUDrhtAldBKhNusZMzmYUuD0rraZ5Z4KsU2bt/4RCalkujswl5TUciCG8BFrAGwgo1ghJR0EFQF2pZBIgaK/pBH99onyIB+b9mQIOsec8eCNyjuQkwkAAaRksXhSkl2sKKQmHljQHoJXC1kU28twTWdrJeR+OoVb/ZafF5cmMmi7R6B5o/7SAg9xBBlv+xdDA47QJKCmK5LEW+zE/jsl8sr8IO3geVVL7mkxNK3ufnKfXZ8W92yG1kEJ4iyUXKaSCKtcgOEtilJ5a0MMjK2h17WODud4Vf90hlqY7cwAEnGSZKQQaMAJkY5k3XfRIEvQ9Znx5+Rx8xt/WNfHUcywnYGkikSYRy32xOUJMKKiAElr92tgJzR1R0HAabs3nh9WxqEV7cnbJtTZUsitDZNF243subCcj4zB35LPW0Rx/r+jiRB8SKOI7GllIgzVUCVpWRVBmwysMZmXz4HFlcA2O65F57laIKxvi0ORrJdtutwp8ygcdQKUJQVSMk2QaqcyTndgOsFeHEF8/h12eZgyKs3IuBW8hpP4K6YNycYTFe2l/ZtrH9D9+lrb8MymyKLuoyDgmkaNJdXePXlBrdOGSeVwayQtXSl3wjVep+QbqJq/N9wJORjoNnXAdriS5EWMmJLSj3CqiOyTHIcbx3QK7bI9tstOCaAY7EohCWXyaaDdrH0LkWzFHQr6sTSSKFNLyYJznTKrAGWJChc6yDetLMuNtE+cmtk2xrzurnzQwTTJ9ymeN3scbxlAYoSVBX+b5SVvH+tgfoKZrEEHj2EWX6pnVlsRxbBQ/K+DdcZ8b6FTvS0sz45rbzPimsZGRnj0OcXODsFbp0Bmg0KAualgVKEymYhVsReoMl6NuFH+eWJBy3mzzj7MhFChshUaNkwyVRsSV14/vTessSQaZVWeI2EShBkBgy2qfbZR1ywrdfi444hE9F90DKEdpYeJGNebGT150wDWCEJaxyFzY5NhRLvm51GU1PDrS+DuZL96XQDmKa1PQHF9+7bk27M2+bKuOtj3rakTjB2ug3I7WbkqpC/nUVcyzZB3CzBdQ2+OJf9Xk0Pp6NftEkf1ufYcBzdy7e32us22l7ar4l1V7U3XGcNbuTx9tdBFnUZhwVjwIsF7pSPcHJbQ6GB4gbM7MMcXCihD39wqfcjQaViaxyRvWY36naDNMs1ac+e82UcyJIeogXLTlBF7TtPICEQimuH3EaoRqpFAzextSg6orP/iLUVZfHgb68ZE8rbZ9ZCHPefkN+oUPPnBtIiGz1uCWyd3yBMkpQsslYFQCVIlZJp0pKQbIZKdhP0BlzXgG5gmhq4vJRMYnW8yep2gs2XSS2OSduda0l765DILshjCmls0/7ofTZoJyMjYzqaB49xq1rgldsazDXAjIJECJV2awAn6iTs0L4qx0v2X5/RMvY6tTjJeEHltioS8RXqsCsT89sEISWvHI3NFIysgOdlewBwCL+0rkFbNxhFgVDHc76/afu8r0Ph2Af2UCE8rBvA1CLyjAE3SzGMGg00Nuslp4It5s1hnmwfrynUYPlSWYFZKsuf9tiKNudlhUtq4nhTL8DLWrb+aRp5bnF0yTpCLZzoPb9tmOTQ/fYt2DYtE3Wqp+z6nDoVWdRlHBTYMOoHj/Gifgt6eQFlLXgivsR6CKN9bHxLYMXE4ARURywJ+cmC5Ji4IIOv83C1RJMLcwiev1hk+ftZpNY+jxHxlYqN3jJrLBTuDCQpqbQ8auOE0yKTVZ402fRHBBogWaxYSIcL8iTjiUfSZ8F74LQlzdpaCRvZa05e5d82JHIT5DFl/Vq3zm6tfFP7MFZ27PoqwZa9cxkZu0Hz+Alu4z5OqyWoWYrBk7W86tpHqBA3gc+YobQWtWKMN3TCbdTthI81dFoXH7zo8TZL4Upv4CRXB3BGUgcfUUKIJvHp2B0ZICM+DUZQjng8NoYm/O7asl6+Ni+1hSnA6M4NBvisYxS1x2saOMPbdWVg+Q+BK0nZ52p5sQhc6rYOEr6M3q8Xlg240WCzBIxslwDdWN60c5U0SsWhj4emeNJ8/ZsRaH1tbMNzNyHUOnWKElSWYG3Ay8VgvTFkUZdxUOCmQfP4HPO3PyNruJqlWJHcABYPziaQFgBr5RoQTtGPp2VNA7p1DAer3lAZX3aCoBprY9UEeui+E+r23TMMIiQrx9n+TSTdViSp9knBLowAK8kIhiqck3+q8165aQA21rJpZFPSZhmslVqLhdAYsXBOEWTJe72p+Pm+81MG8m0E2lgbhyzUjF6DyDIyMiajvv8Qp+dvAlfnQG33OXOhdS3Pl/sNOr60Asd5gxIvXDzxd0Kg7ZmxQioOEWS2Rk+gLZI4HAMj/Dk8rocyPeNZqNRfZ13eJLL3j719AJhCOk5ZYRiJL8uDToQpBBFG1kdJRes27MSo40P3WRgRZUbrMI9x4Zy2LLv5T/Rchgyc4XCEh0bE2Kp14FPa700ysgHHDra/45DHKW1N4lwbbeQjjEiBCru+spRQV7LrLaHK9t6wNgLJnD9Gc3U12r8hZFGXcVAwyxrNoydQb38R/OAt2XjTsBUZbAdfsSq6Yz+4Gm4PyAgWxVAHwZoY/z5boZXywonl0ZWThc8cBnRfv1vW3jzEvETtAwipuVonw3hDPfcfxASRx5HVkg1bq15EJLUBzFIGKevFc58BGx3EWiqgtySItcTXSDtpW7sQPtdpwdtGSK3T/yntjQmzKW2vaj8jI2N9NI/Pob70efC7b8j+Zj5kz/3WyOoqY71uaPOkX68dedES3mxxV4c3I15s8VHcXsSnMU9yVM7VT+7N0fvoWlct1rEL9Qq82Kib8IU/5rCOTDYChHg9a+FEJ4gjIcaOL52INgZwIa3ojoe94+cKz1dvW9sYFzfk1r7jsfsMlR+qsw7Hrrr3Sm8ZURDkhV1nOLNGbBfaWkg4q19LaQUbiqI1T2M2NnvqEtAyZ2KtZanIcgnWj2Wtv9beCL5LZFGXcVAwl1fg5RLN/UcAnYDJgGNLI4u4QLQ+jWNSiy2I7NZ1cWRJRKscM0eheVFdxOXt3/4lLdf/Nxvdfz29R/TSf8+B+6yBtUIA/K2mD/Zj91ntJVrPs7SRkNjAKre3vuy5XYdtvWVT7jFVtGVxl5GxGzQPHqF5/TWx8DcFAOU5ULw5EScyRFREHjT5LYZjAHIeDNYmXLPnw6trb+i6FWQdLuNhLozFaIujgeiPFq5lLNmI50Y4ZBVv7yi6YlJfNuDjSXX3wbFKWbsCyfedKIgoJYJLvKIKpJQvQ0pF1xXYhbC6Mp2uswgso6WfWnsvKWstWdmdELPbNbH958T+FCPolGexLbKoyzgo6IsrFLfO8Oif/hiAaZamcD1PHHeCDYUjsNlgtc7ntisxsk7ZXd9zFx6wTe+9S6HWrrOf/mZkZLTRPD7H8u13UH/m56wI6/6mdr2lSA6ZFmw9dm3ArZOefcszCnH+JF7QeB1k29NqQ0ydh7Vw7cg/8uXDOe/9jZZikF0fCP8qdWVZh7J5EKwwc8s8VrzXEDHkjPksYsqHrRoY5xH14ao2wogNTK2jc9Hfmz5nX3aTz3G3PD2ELOoyDgqsNUCEi3ceyw+2ZwJ8SATTZ/XZF1QxEnr5lGId69cU7OK7s+mAu28i6Nbdr8COsevPKSMjYxhPfv6zKO6+AlMvZXKsZNLtIyPj8MoEB0SfHtdIo1vhJhh45T2T6CFZ7RF7U+3/rFeUnbfVekWN28cvWgsZskWzT5DmN2iP1mJK8ThqKogvv5F7XN55iX101cjb2or7tuejzXl+8x9Yzn6Z8VRi8aW3sfyK51G//aUbEXD7EmqkdksJuxJ5u+5Xt/2bYexDEP+79krtXuTupr1DeNYZGc8KHnziX0KdnNjlA0ay5blwyzS08gaxb24Zwr4MoPt6PzfFkfvETXDCvqNADpV/Y2RRl3FwuPzMa8Cv/zCK99+2iUSSJCYrkcbsx6/xpTieP7zKwB3F9sfr7+L4/2Q9gi+bXINKyrYIN5T37bv6Sbtkwx5cOc3tPoYkKO5+tt8mylrmUk9PGHC3IcbrJPNDIMRDFjXXGe6YPXYZGfvH1YNLAJeD16f8Dm8y8oP2Jrpu3iB76Lx5CHy5L2QezqIu4wDBTYO3/uGPgZRqC6Cplsc4I5fbaNS++gE3yd7VjjdvNda+1ioTrlGhWtcozhjmY9OlTisW3Tdry5RF6E8c+65si6322vdw1+P2VOFi3KOFxu5vF2u/aoxnwG8sS1Y0JqEVIVVztE+QyyRGrgz7UA126bX76rhU2vGCfpfdFJEotlZpbozv53VZqfdFvk/rerNDJtuMjGPD4vHypruwEvsUKJ5vd4x1BNkm728TwbcLAdwWcnqw3D5wU97a68Ah8nUWdRkHieZRfe33pGq/g48qd9v+NoP9WuRVqLaQTAWiy0QFQFVl7/m+8sq2S0UFv1jbXie4xdRtERz2B5J+EQXRGkSy2snihxYZ9WUgbXlwgbYbuL9su3xSp+ewF3H9sS0ufJnhk4NbZvjXgfKxwWFqPyKc/8xPr1U+IyMjYPmwuZb77JsTY6zHj5sLk12IpCn8uYmYWVesTufx4ee1b9H1LOYCuElkUZdxkKgfDw9CuxZHHsPRLB1sQnab0NDOhaDt95S+hHuv9rJsQpQbWS13REAbW3o7mcNi3dP16HY8w0g0Vp8YmiTUaJo3cqhMLDL7yqZ/+5Tl3XOHsHYnI+NZgr68Js/3GpyYYl2O3IX/aG9zA4vN+HNCu44n6umfqyoIZgPb9y5F3BQe1Vva57MoXA9Z1GUcJHhkcNt2kFgFqiZM+Jv9TmQdIeh6x/exJD2FcFPiWouk1mx/GzLeyPLa8/3aB3nE7/FpDkPZVzhURkZGF/ryekPoHCZxo8OeOTLG3vgyATXTx3D3CW3Kbas4tO8bsAtRuxafjszTdsWnQ8L1WPl031yZRV3GQcJcIyF00HSHy31bAFNsI1y3FaVD73UKYXoiWvPz421E3Q5ChFRJ0HtI8tEiyGtOInKdFs7W5sIZGRl7xY3xYw83Olw3R8bYhaF3V8bc9DmsIzRbXLbBZ7wNj/b2YQvsoi998Jx6A0m5dsGp++bKLOoyDhK8I4vbrgaoGxWZa0JNCJccwxBBbkp6U8h+FfGNfo5rfDbbCNY+rPx+bfm92WaitA+RCuxmTUpGRsbm2AU/7nq93DFxZC8avRNhmvLnrrybu+BR6c/uOGusT5tw6qTv5FPIqQ674NYs6jKeauxKHO4L+1iIvmtydYPgWEjsGLYiOYcNxWK3L8PPZqPPYgPL7TrY2Mq7T2z4/bpJS35GRkYbh86NQ9jnOLcPYbqtkdXB8ehG/Blj4D0eC586bMonexObu8AOvn9Z1GVk3CBuiljXGaS2Jbp08N1UHKYw2HFsun2fuxYfKYnsjSB2SNb7wL7Xu2RkZDz9OAQxep386bCtcXUV9sWnDvvmVeD6udXhUDgWyKIuI+OZxKbEuMmguQtS6xs0d01uzgK67zCi604pomu+1tTkGRkZGU8zrpM/HXYtDlPsSyxeF68C18+tDoe0C2sWdRkZGZOxjZX0kAkN2D+pOVzX2pP4vR6bdTsjIyPjacMhrIXcJf9M8VBdF68C17+uM3hPb55fHbKoy8jIuBbclCCMcR3iMMV1klqM6yS4aeR+OMSXkZGRcYy4CS/hEPa1fn8K9sWrDlPWLh5icqC9ijoi+iCA7wHwCmTf2o8z83cS0QsA/iaArwDwGQC/g5nvExEB+E4A3wjgAsC3MvNP7LOPGRkZh49DIjLg+q2dfbgpsdiHQyS3Y0DmyIyMjOvAIXgJV+EmjK5D2Kdo3DrZzQj27alrAPwxZv4JIroD4MeJ6IcBfCuA/4aZv4OIvg3AtwH4EwC+AcBH7L+vA/BX7GtGRkbG2jgE7+AqHBKRAfu3gGa0kDkyIyPjKLCtMDw2Tk1xDBy7V1HHzK8DeN3+/ZiIfgbABwB8E4Cvt8W+G8CPQAjrmwB8DzMzgB8loueI6H22nYyMjIxrwzFYNmPcZChMxmbIHJmRkfGs4Ng4NcWhi0XgGtfUEdFXAPgVAH4MwCsRCb0BCT0BhMw+H1X7gj3XIiwi+hiAjwHAy3lZYEZGxoHi0MJG18ExENjThMyRGRkZGeM4Fm/hOtgl117LaE9EtwH8bQB/lJkfybIAATMzEa31jpj54wA+DgAfoZO8mCMjI+OpwrFbNMeQ1991kTkyIyMjY//YZcKuQ+TYvYs6IqogZPW9zPx37OkvuZARInofgDft+dcAfDCq/qo9l5GRkZGxBp5Gi+bTiMyRGRkZGceHXQnEXXLtXvfqs5m6vgvAzzDzn48u/SCAb7F/fwuAH4jO/x4S/KsAHua1AhkZGRnXD655Z/8y+pE5MiMjI+PZxi55c9+eul8L4HcD+Cki+kl77k8C+A4A309Evx/AZwH8DnvthyCpmj8FSdf8e/fcv4yMjIyMPSMLu0FkjszIyMjI2An2nf3yHwEY8iv+hp7yDOAP7rNPGRkZGRkZh4DMkRkZGRkZu8Jewy8zMjIyMjIyMjIyMjIy9oss6jIyMjIyMjIyMjIyMo4YWdRlZGRkZGRkZGRkZGQcMbKoy8jIyMjIyMjIyMjIOGJkUZeRkZGRkZGRkZGRkXHEyKIuIyMjIyMjIyMjIyPjiJFFXUZGRkZGRkZGRkZGxhEji7qMjIyMjIyMjIyMjIwjRhZ1GRkZGRkZGRkZGRkZR4ws6jIyMjIyMjIyMjIyMo4YWdRlZGRkZGRkZGRkZGQcMbKoy8jIyMjIyMjIyMjIOGJkUZeRkZGRkZGRkZGRkXHEyKIuIyMjIyMjIyMjIyPjiJFFXUZGRkZGRkZGRkZGxhEji7qMjIyMjIyMjIyMjIwjRhZ1GRkZGRkZGRkZGRkZR4ws6jIyMjIyMjIyMjIyMo4YWdRlZGRkZGRkZGRkZGQcMbKoy8jIyMjIyMjIyMjIOGJkUZeRkZGRkZGRkZGRkXHEOEhRR0S/mYg+SUSfIqJvu+n+ZGRkZGRkHAIyP2ZkZGRk9OHgRB0RFQD+MoBvAPBRAP8OEX30ZnuVkZGRkZFxs8j8mJGRkZExhIMTdQC+FsCnmPkXmHkJ4PsAfNMN9ykjIyMjI+OmkfkxIyMj4ykCVdT7bxOUO+7bLvABAJ+Pjr8A4OviAkT0MQAfA4CXD/ItZGRkZGRk7Bwr+RHIHJmRkZFxXdhUgO0DRznaM/PHAXwcAD5CJ3zD3cnIyMjIyDgYZI7MyMjIWI1DEmS7wCGKutcAfDA6ftWey8jIyMjIeJaR+TEjIyMjwtMmzLbBIYq6fwrgI0T0IQhZfTOA33mzXcrIyMjIyLhxZH7MyMh4KvE0iDNV3ux7ODhRx8wNEf0hAH8PQAHgv2DmT9xwtzIyMjIyMm4UmR8zMjIOGccqzG5ajO0KByfqAICZfwjAD910PzIyMjIyMg4JmR8zMjL2iWMSZocqxqi6mc0FDlLUZWRkZGRkZGRkZGRsh0MVaYcgyG5KfI1hm+eSRV1GRkZGxtrYeqLQ7KYfGRkZGc8KDkmg3YQou0kRdggidBWyqMvIyMh4xnBIE4OMjIyMZxE3OQ5ft0C5TjF2M2LzMDg1i7qMjIyMI8GhEEdGRkZGRsBNjM37Fi/7FmLXJb6exs9mCFnUZWRkZFwDnmZBdgxhKRkZGRnr4LrG7H2Nn7sWZfvr536f83Xy003zfBZ1GRkZGSO46UF6H8giLCMj41nEsQiIXQqy3fVpt8/uWEViikPi0yzqMjIynko8TWLskEijD4eYQSwjI+PZwL7G+l2Mu9uOjdv0YdvnskveOeTPaBWoOGz+jZFFXUZGxsHgaRFihyrCsvjKyMg4BhySV2ibcXPd+27zvp8aAbhHEaUOQKCR2l8fsqjLyMjYGY5VlB2aCDsE8XVozyQjI+PpwE0KiHXG1k3us85723f729wH2K242rWY2qcwGrxncfO8vApZ1GVkPOM4JiF2KELjpkXXTT6HY/q+ZGRkXC82HR82Ezi7FWj7EGT7EnnrCq5tRNWuBNS+RdEheOGGcF0iNIu6jIwjx6FOsg9BgN2U+Hqas20dwueakZGxe9zkuqddCrQp72NbkTdZ1K0hNNYRJeuIhG3F1K7E0nV71w5Z5O0LWdRlZNwQDkWM3fQk/WnclPQ6Ptvr3zz2ML6vGRkZ/Ti0zI5Tx/axdrcRVpvWXSXEpoiFMQGzjsjal9Db5j5TcBPJRUgdfnjkvpFFXUbGBrjJCe71T+b3P1DufxPVw5rsrItj3y8pIyNjHIc8Ru3Ki7aJyOqrM1h2REgMiZZNxdcqETRFYK0l2LYKn9yOw29i/dqz6GXbBbKoy7gRPItW/2PZYNThWIXKsex9s/fne4OkmAk541nDoYqyfSUGWfV++9pK6/SWGRg7+saUIbHRJ8bWEXUrBdvI9SkCah2RtIuxdF+iLHvGDg9Z1B05nkVxtAkOwQOxK/G16/eyj+/QoQurnT/DPYmY6xZHN2GRzci4aRyigWkTvtj3OrF16vaNiel4Fo83Q16xsTqDZXoF4PjzXFfcTR0r1xE+m46/N2VEexr5gg3fdBe2QhZ1R45DECuHjJvMUnhd6Yp3cd8xHKqH6hDTLe+b5A4hpXL2wmUcE25i3699eMc2Xh+2iUdtC29ZPEatEmTx9fSeqRiaJOZ6ygyJqrGxehehlZt6sa5LKB2rIDtE0XVIfcqi7shx06nVt8WxidJ9TxAOSdTt2vt0SGEkHXFE5P8RACglfxOF60q1j4mgSnvO1SUCQAChfa7vum+vp7w9J/2M+2HLwZV1x+F8p6w7lndm+7OTxziIVZ/T+c/89H47kJFhsV5I4fWmyF9XjK30pK3pHQv12u97SqjiKu9YLGpcvVFP3QoR1xKAQ2GXrg037ikFpRSgCCBlh007truxVdnx1L0SgQoCIYzbiMdkN87a+vDjaTwOu5eon9FYrFQoZy/2vp/+N7nm4M1jgiO6Fpdj98Lda/Exc1zYnrLnGO0ytg4zt+snf7Mry9KG0QZgY5uxbRl5ZRMds1n9LEbAZrv63fZuRuhlUXfkKE6PU9Qdg5jb9wap+0p13HsvFRFORC4tkWJfO+fi865e0SbPoTr+Hqmwif9WSt6fSgSSsqSpqKcNS9BWfAEEKmOSXg+eHJhBZAdjY0kmIh4Z+C1hMYMdkRhOSAn22Nj6CIRE7l4muocJbYJDHbmpfY3Pt8mQe85JW2gd+78zMp4RpELtJkIU10nsMUVQTQlVHBNF6b23EVRDdX0dpaDKsvUKpUBKgcpC6isFVRTta1XlrxERqCgAVYgxbegZWc5hO/Z2xIMfB4MgsDWSsd6N2cZesmWJousm3MvdA7CCA6GN+Jo7n56KzvdiV2P2iJAMl6LPOjYQxn+kwjKaAzDbYpFIthbGyKCYiGFvkETbEBkJcf8I7PfNzw86RtNxGK3Dd8M47mXAGPnbCURjhO+Z5dUYsNZRORPOGzmPEWFo9PXwbhZ1R47qTnHTXdgLbjLJQx8GRdWIWImFT+taUaC8dw/V889BlQrxABmE0/rvn1bp+4ic5DhYw+SwbVFzYkEViERMRFgI5335VtuI/rbXnPhxpMpO5BjA6GiQBbgliNzg6ixzJggZO/DCEe6OCPAQwlM6E7GhgtRXYENL8B5wXYSWkZFijCN3EZq4bkjiUN3rFmEtr1tVgJSIKioKL7aoLOV8oUBKzquy9Mci1ERseQObbV8pRGO3ifgmTIaDccv+7SfKDbC88mM7GyNDmJG2TPJeHPwoM2Fy3+uxHCo71s7KO+0AG96k4y3a1TA8wrFTujrkFZvSvU08YK37+bmYCsbjOBJHKTuZio3OZYjesYYGKa+8oQEUDBCd+1shyVqDm6Z1DKPDa6NFIDY1uK7Xfp9AFnVHj9m9U9z+JR8FqSJYp4AwgW+51NMfwya/8BFxs+Jc58s+NAFNRY77+wAm2Q5kCaslhIyzwAUCi0MG5K0woA2aR4/QfPHTYO0Gm9WelJt+/9e5lsq918E7xlxexCJ4hRU9Z+u6EajMNBk3hPJ2W9RtKsL2tT7M1VvpASsLFLMyCKhUUBVOcBXi9SqcMCu8IAuRDQjiixCJrMjbYDQI7L0QrA0IBoAG9BLc6EiM6ciZ431fw4Ky5zmE0EkAhbtWRNdHxvZjHde3DPnbRYjf1iJpD/eZ0v6k9vxcasz5YY3IIyIqBM2svmdv35Vq/U4BJYYREoOJKufye7XeaL66RPP2l1beqw+Zao8c9776K6GfvIvl229FLmsSbUex+zwdELeZoA98sRMxwn3ihAcPBgXoTYuZKdhE8MxPK7TVybOFm/hcj1XU7Tref7M+ZG9bxvFhfmfWOt5WfKXXfJ1OSGGBorLer7LtCZMwxALKXXeiy03sbHsezCAwCCZY+Y0RFo/FGIvAYtOAuAY3BtTEZXX0Bpy4I1l3NvLeSJGnKlIkM0dV2WZWewKHRFevt8yFnIztH7eHcXzjMXYdsTJh3dda4+wafd61qAIG5ngpRtqaJpLGy4z1daxuWi815PTVpVQb9r7/YqBf9jdqGt92EvfU6tum86O9iToi+j8B+K0AlgB+HsDvZeYH9tq3A/j9ADSAP8LMf8+e/80AvhPyVP4aM3/Hvvr3tODWl70Xlz/9U6heOAOwhSUh49rgCGl+Z+7P3dSEOYfF7R+7+b0NWxp3+d3ZVVtZAK5G5sjrwcm9uYRNuVDCSHx50ZV4vpzoosJa2MsiCTOMxIwTGMZ475YPC09f3fobNoCpQVwD2gBL7dfppB6vjsDqO6eissr1iQCEcLCO2EoTmRCBVCn3LQuA7Do3H1pmQ8+KEiAFKtwaaOv9K8rouRBahuQpIiyeICsFOjnF5GiizhAbRynFywyi804MR9E0LrrJraVK1+G1jo32ywT6rjMnbfh7jjyCSd6nbUXSCj7qaWNMjK68Z8/9NhFqgwJyTVEXzvVzau+9NxGWIyHApFa1t7nBe5+euh8G8O3M3BDRnwXw7QD+BBF9FMA3A/glAN4P4B8Q0VfZOn8ZwP8EwBcA/FMi+kFmzmnSBlDcOsPJWYnilXv+SzX05duZO3uP9a8bNy1uT56/0zm3889pi/Vl2zyf6/wu7PtzvMnfxb7DXBw2Effr9u3YxodrQObIa8C9X/bVKO7eA5pGLODEVjx1xRcbt/7Lii4ArDVIM/jSiTaLIdHlxE+EftFlE4A4j1crmZUN03LiSVnBVSh7ri1G/VpsVYbzVpCRiuoQdSebNhkFwDaHEwP2GblMhHLZ/n7J/u3WPAMAm3YSESeW5OJEbUYhgEgb0MXVYMlBkZGOMUTyWcbr1JNslmzYnyNAxGtZtLNfMrp1O225sizHcaIQxugk3yfKioVhR1i69YW6dRy/cmMiMRl5b3XTmQusI5K6a/OmC59enhgqG7U7yBdriK703uy+y6PtqcE2h+/T/WzX8RKmdby3fgPsTdQx89+PDn8UwG+3f38TgO9j5gWATxPRpwB8rb32KWb+BQAgou+zZTNhDaC8cwt3f9EHgA+/GixLWrd/+K2BQbfW2bGOs0NFA0CcKja2cAEbWV32blly2HEYRLj/SLvpoNE7EPTcqyxx+2t+ZRiMWwvHWay3zGDW4TPS0efjPtuIBPx3AJDvQZIa2Ncb6f/o+72GgXxlH7YY0Nv37KmzhRV1oz5M/a5M7MOYgN+m3U3DWzYp9ywhc+Q1QCm89Cs/Cv2FT4VzZAWVopBJL/G6Oc+VJEGI1r8osmtiyIskJ5qc4PKeKxtWGdqhKBmDC7EUb5rc1PWP2pN5J6Lc9XjttUtepSiMz05UuIm9Uu2xO82o1eNRYydY++pEf1NUNv2FU2s5hWm9Uh8PxXMRAPrO8+IZjecyvr122U57yf1aZdKwu75+pvdJx0Du6Uto0daJQl1TYZvcxz/nSGCitOI+TgLmBLj7DFwmaFemlQ1SyS0p2p4h7a9L3mG9zHBe5KaJ5iVa5hMuw6M77/rrH0PyjHqEYIcHekTX4LURYZle63DWSD9X9WlK+1PmE1NE4i4M1Ne1pu73Afib9u8PQAjM4Qv2HAB8Pjn/dfvv2vFCnc5B73sVRAR+8jD8aK1liAh2kIAdUNwP2w2IUWN+YLfXO5YlSxT+kPv/jmu0Bj4kpGNPmthChSh7Yvu8CM2kfjzgxsIz6g8bnbzfqIzPxGjb99UcoXbvx9pZyex1re2lNQYjpVC878tBt28DzUIGXcOtgdqROLnPzYeNJJZW/3nGg7Z7jlGK3/TzjJ9RH5H5Z98Wj+3PgG2il2gCEmW3DJMO+8yayKjAxhMIN5HlcdVgaYYH8pQo4+uDg+UYKQ3dZ4NBX9rfXKiuIwC3sRC2T7pzuwlTuWnP+IEjc+QeMHvpeZTPPYfy3teE7HUUeaz8upVEWCnV5hmyF2NOaHFplA6fEHlsorLOmMoMsE3KwMqLorC+2k3c5Z7+ektYRSI04m523iE4wUpg74mL9uB0b5Yg19NU9bHnCoBfTEQIZW05bs0TrEiyE39nXCbTyPvWIhbICZ5YlOnoXFFCv/fD4lm1nja304x4DmMxxzCWoyj2usaZkaNrHJdtcZW2ZSKkcw6HPrHYc21l2Y5Y7BuHkz74PlmB1cObqejlvn3cjPFCkGKxWCigmIPIfjf91kKFzfYYfhusNaAb+ZyN/C0ecXmFbry4ZWNkntPqZlsc+m9SjwBMPxuOnof7enY8XT1zAkrWvPl1cu5+tm5rPtDpS/s73zvX8O3YPrmfXfQ+nHfe91sVreNNsJWoI6J/AOC9PZf+FDP/gC3zpwA0AL53m3sl9/0YgI8BwMvPcK4XNZuhefnLoBeXoNM7MljqBgD8oBkPnh1L1ZC1y4WfgJNBiKMvZHx+YODrs255bejIww0siAZuin5pZNt3BBOFN8REmwod96NwTaeiJibdTl206nIsmqJ2iKgbVeKFjfN8WktYtBcKVSfgx/dRP/cySNehHgAy9vPr+6z6PqfotVXHe/Ti+lE/Tbtu3IfwuUXhJGIhsIkFCGBLBmXREqHe0uiEKJH0i8JEgv2kx1kUYZ+r8s889MWSrluPYoW0e4VhIZB4r5lGh+dvGvj9ZWL0EcQzaBnsa3+q15EK1SVe97PtFbBDC8ifXmSOvFlUz98DvfcD4Mfv2O+dASP2bAjYcUm691Ukmrw4cl9y522LRBMAsE+JjiCMbJ0gugAfZpkIKk6zMXSMeAFsB0+xwfX95sK4z0S2CHeuuT+Y4/bisq5Yez7AQLSeTXiSiEFUgBTL2iEiKOtNJGdo9LxsxZ+uJY27fVV3XsB9PgWDoSBr1xTbOQ0YyoS/5bHIvVVh+1DaV7AtQ76MnAvGUH89eg/+cTvxmBqGXZgu3Fjs+CP6LOx8hzgxfHIoE665xkM77hx5sdszX3N/u3newNyu5ekcFImujuXVuKxb3uM/6ug7BAn3ZbuuksoKVNi1mUUZCRWbql83QL0ENzWoXgJNHZ5l5AEMU4G28PPv2V034b15cZcaJF273jIQBJV/Sy55iWsLRRCbvl3bTiK+SIV7pMIs9DOIvZS/KVkUuk0Sua1Ge2b+N8auE9G3AvgtAH4Dh3fxGoAPRsVetecwcj6978cBfBwAPkInm0vaI4eqSjy+a0MvdQ35GmoZOCE/cmWM/OxYg1jDeczYDSjM9jx7IQBjBaC1XgGw1hb2ljFnfYkHlpRUKDlPLQGRCBGHPsvYqhCLnuO0bMfL11c/VB7oE/xADa3bRBoPPC71KLOE2wBhjUVZylqNsxM8ee9Xg1hEnIpFOAME8Wr50BNEf9vP0X1+7vNU3EjfjI6e/cBnEB+noSArxH+rTE+Yi7/uiMC3FxNPeB99oTd+ALdGCjfR8jZpUkBlQ6NoJq8cWd6VsvO2ZOLkYEUfayv6mgYu0QGbRj5fa4WMrY1StUcADnyPW6JnhbiTUJfk3FidiV63lmAbNLyoqHxaPyHIvnbXCT8dWVvytCFz5M2ivHsby+ffB9x9uWuAc14sAG662tYs3BtaKMInqhNfZ7Ztsv3PiqTWzUWqIMSltO7VgdcThJ43MR19ddNbrvhp9pgxw7WEYxTrIMRYA9pyFNA2OqsCigAqZ6D5GZRS4HqJ8+IlVCVBIcxXRHJZYykiDoR4ShVZ3nR9Afv+eAE4cpy+B29K7oRLFiCyxmb3zNzWFPZTDzqfvLdRCpDl+Oh5OkMxxxWtUHUTfiPGTNINXFgk6RpstBjzYw+oCXX8Z5MagQfEYksArhKLkQeQfPhmu0zI9MgACkmoU5ZQsxNJ419W9rttwPUSaJbgxZXsU9jUHc9aa+soWEGfeub61lYCQJygxCReMm+jic4r12wk9KL2Y7HHSSbzVKi1Mp2n84c0kdAWhs99Zr/8zQD+OIBfx8wX0aUfBPB/IaI/D1kE/hEA/wTyLf4IEX0IQlTfDOB37qt/TwOoLPCoeQ6PrwyaRjw+JcmXoVDyYyzsF6sgjcJ6xRTJl1VB9k5zg4Yi9lY1grFWtfbAkg5Y5MQFAPhBMrUoRZYqF/pgB+EgTIKgFAETqNKFULpwic6PpcdyFa71CMrofOvakLgBOoNaGDx7PGsmGSx7Bkh6/svw+Yt7UCT1S7IiHMZGBbHdy9J9RkJY5D1fhIK1/bwMnOPSEYVy1sfezyZ+7sYLVYJs6N0n8v1nwrr1uZHPHtb2hPVZETveYx0L2QGLY9+z7CUaI/8MwoAbLw5PBntmY8NIVFj7UigQlWA6gV8b4zcYjUWP8WsMuK7ltbGv9VKu+TWNw+sI+gTWkHdw1HO3hRDsaze1dvp5XqdudwbYbW91mWcVmSP3j9mLz+P85GVcXF52rrlJWOsb6iZxg+om8rQNgcbqT0A6HwXH8q9VjjsHbrwLNYaEWMyjlBoy3fmOR4F7BE67jBNyhWnAbPfCc8kn3DG5tYwuc6gGmRqolzCsAVJ40tzGg4eMSmlZYlYIF1bEKJTwZOEcqsQgRVAkCVuIOOFCAMQ2oCSaj9hnJwk02D43Nz9BmKc4YUmBR9P3vUo8ts5RWjeq47pr/1DGdx+gEoVSQKmg2L43Uv4VsLyu68hoqYFmCWoWrXtxHO4K9Ed1JWX8M3PG1pYHsJ9rQ/tOgGugroH60nsE2YleVQJlBXV6C7jzHFDOhFeXV6CrC/DVRbi345boWTqDi3++iWcNkUGW/fpZW9kbYu35IqqfCDZOPWtGhQ/KlxkTeeMiriPy1sA+4zL+EoA5gB+263p+lJn/18z8CSL6fsji7gbAH2SWUYCI/hCAvwcxCf8XzPyJPfbv6KHmc9y/mKNuAI0TEAGNHwgYxg48EhFnoOzfBRm71M6JOSf8gnXLnfOvrl1KBq6obHwufi1UuO42ISYbrufFhw2xVFGIhNRxQjI6R1Eb0X3kb2O1CAfR0vIwRgM6O2EZPF/tzcRd3Yj8uF+gtAZENxDGVjIgCEBVACenONd3UCr3+bRJRJF9H/b9iABvf06dzyj6rMLfbRJpiXMfYdQWiyr6/MjXsUTJ3BL7IXTFTWN6SM9aGJVeiqBtliIemqV9vnrweaYCMLZGbi4AIyEfE48TmX0CMC2rilbCBKpOQ7Y6VdrECFbA2LUFElrUgOsFWNeg5TL6jrqm24aAIWE1xQPYWjMwsF6AkjrxWoGOQEs9CT1pmTvrHnraS/M0PMPIHLlnlLdOcYm7eIxbLaEz5HDqPc1h/Oxej7mnC+opN1g2nehTu+1wbMddClzoeVQFOakiQ1/aZ8dzbMefRmvPP3KHLrfKsQlZPhP+deOmZwKiyKvZj9igSjF3VDO8+7gCCNBgsAFqZlkGZrnLsHsvwn2Go0AN+6wKMuEZURCCAKwwtHxnhWHhlzNyWHJpDeDeIG6faSwW3XNgL6zbojE+drweDqKykXHUfd6FnTcULqonEs3KRvYo0wDQrRBVotJu46GgVIhyYS0hkNTYEEi3BCTiSnYcWyRzF9dPFXnG+oSebad1rIPxNhVk5L4nRtvtPS7axspqDsxOoO6+IO9ueQk8fgDUC0CFtf5kBRm8YdK167gneNQ6nOq3DIn5WPl6bbgMmU40Uri3L5JwdbT1SXctXbu9dO/HdbDP7JcfHrn2ZwD8mZ7zPwTgh/bVp6cNal7h/ILxhbeBRwv5ElSlfDlO5zIgzSv5LlUFoyoZioCqtEm8LAGwIyyCH5SIRWyw8974AUuOvQCkWEDYfjmR58roIEK8YOgRGa06LWHRPqeoLZZiUonDJeKN171YVE48wosY7310oRKxoCQnW+wz0k0UAiEWMLEyWk9bJFDQESh2UJ6dAbMT/MsvKCw1oVDAfCafyaxyn5t8Vm7JWlUySks+xj87WHHO/tVZE1ufl30vjvziz0j1fF6pSI8FffezGBb0bnAsIKKxLOcgIlRzscp5cuUoxFE3kkK8uQKMCSQVPdP0eaZWxZbAniL83Pmhtaa6RxjG1kdtwNYKmq5FYGMQ0pMXoKoCzedAWYEK+bDZGFlrsFyC6yvx9i2ubBh0v2CLxROn78X9hnoWiwfR2CYNP2Esiq6IdWW2XByeEtmzjsyR+0dx+wzniwpfelzBObNcYJsc2HHSnmTARiu0fWNiAGt/b/0OBImxUf5uj53pHI1aBtR2O31l3LEavObaCNfT8TuuI9EfsEY9hdMT2Vbh4rK9jUAYzwNHDIk5fz92Sz+S8Mv4mhUSHd4sSqhqDiorPH6o8bm34PcFPJ0LV55UCjPLl3abQczsEi5FdgW8kuFLQ7ZpcALQ2+WiYwVbh7gjCtPPUanhz815B5WSvQYLO59QiltGVIraV05EhqkK/GIBNy/jBtoYNKaGMYzCRvcUpvFCzwm/IPii52sYSjftZ61KqNkZ6KyUr75uYOoluF6AdO251RtTvadLh44C7QQ37k2kx46fiKL6Pq7RtpuIPA2winioXgDLS/D5A+GW+RnUcy8BRQnz8B3QxWPYTxQxnNAKbSkv0FKxRYm4a3NWu7+UJFhiY8KAkPJmyntKbRVeuQrP7grqpwBUVbi4aIDGAHWBiyXDQKHRwKySL1tVObEHlIWcK+2nXtrfqT3tRV9ZSKhDPGgWyl1jFNbaFYsdwyIfjI2xdp52RiwkuiKgSAbPVNzFQmKKIBwTh/Iaeaosi/trJmnPefkib51iBqkChd28tpxby6WRBd9GL8HLq47Qk/btgDY/A6o5Lh5dgYoClw3wmAh1A0ApGAPM7OdWluHVfX5uru4+m9JGBxZFEO2lCp+lF/Cx2Vaxn8RoN7ExboITwlHkMxTSU5HA7ghB12x03pV1oaWlDzW1rxDiKZhRMENRhaI0oJlCibsgpWBYkqNQs/DhjeLh63muPSJ6pde0z4qYhpyU3D3fF1oCdAWhiTKmmiWgl3AwcZ2yAlQBVc2As9tAIcfQDbheghcX4MUlaGHFY1FEhBiRJtBdLB6LMfe7GFkk7tYNpJNY7lgX4clpncXh2VOXcV0oTk+w1AUentuvqvW+OC9MoYIYIHusCH4HgiCWuJUQU2iOoRmotfwL28xxxGvhHND1JIlQa5cNBjfy9/av7hr7jrXKxOgTc3LeQJEIJKUUyoLApoExBgWcpyeJ9Ig4MvYGAYi40b0GYaGc2OgRcT5ssCihikqGJl0DpgEVt3F1sQAvDE5OKxQASCssF8DyShaHNI14A7UJPFnZuY1SstZtVhDK0hm2LV8WQRASAcqGdSoVRKEP9IF4BxvAJouUYxM9Xyf0UpHnz1tB1/dZ9M1/Uk6dlUChCCdlhbIigDW0NtC8QKGsqKO2N89YElAqfBZkeZjdZ9JIhkoyjXBPUUKd3BJv4dW5zGNcmKzLYGn75N9QvG9jGmpvQ229B68VUuh42Z5LM0NGnq9YkMkzMsDyEubqXPr93Mvg+Sn4wVsdj1cv3HtKxV2KPYuvfSGLuiMGFQr1YolHjwy+8A5w61ThuTslyhnApHBxxXh8qWAYmM1USyAAQdS540K56+FvJ/jKIliW5LydsEeCLwyaEsYwU44YrYXMev8aLe5ysY5Je7Hwi4/jQa4YEH6x0Bgisn5PUre+HLuJavixu8l/KwTCAIXNqCbWL4WSSqjTO1BFCTRLmHoJXV/ZPlkyrOagao7XX3uMR1cK84pw63aFWQXcvlVKWLkScY5GyaThCjBQqBtAFe3PsSjan2dRoCMA3ecYPj95rQpGYUnOCXllJzaVFYKOBEnF1kl4AegEPdtwVmPs87LX3DrPWWHFnCWiKhJ5JVmBZzOdFaYGNPt1gyXNoCqFYnYr8ppKtjReLgA2YeLgxV4JKtpCz4cdahn6fJiJitb1qdSbl1gro1DNVesIoHUQUJ0F3pH1jw24boRILxF53RRQzkDVDOrsjoShGA2+vIC5eAQsr4L4SkUXLIh6PGepQAviLFgUXffaoS2tTGAdMdcfpiL3PD6CzDhu0KzC1YLx+tudCGQoRX4cdFEd6Xjp+KlQ5A1jTviVsgwX8wq4dSJc+OQKuKrhv/buN+hTDHnvS7t9+XtAHESGsjT0Pi0TR1UUxFBEUAWgiFCqsMWNMbLNgDEGum58OzPvWWsLtLC+S7f+lmtufEi9cQ2UkQRukq+qBBUEKkoQKhkP6gWwOAdfnttkbwCBoE5u4+rJBX76Zy6BYg4AODmrMCuBO7crnJ4qzCrg9KSQ+UopfMkM1A2wZIVlI595ZXnS8aaf0yTznqKI5kBW8M2iOY0ThkUhc5simh8Yhue+xv6Dn4t0xduYRzCdE2kr4JdNmHNVZYnTeQniGotlHRL62AHehcAWUfirz9yPNjwl1DJfITCKag51chvm8butSA/fmosSJQa776KbXPiw04jD0ju7c06wtZfky/WhazGMhnnndaiXPyjvnccKr4l1+WpqBMqeeTCLuiMGkYRuPXmyxLv3Ce/eB946ky/M7bMCt08JrzwHLGvgnScMreWHpLX8NLUd1LT9jjkrlzbUEgjuHNAVB43qEQyeCF0/7QCpxBtYlQqzmcQdaM04X3AgVT/IhWMnqExCaMoToyVKkA027Iq4jpcvjuGP6kud7poBP1ml9k/GrXOzDYDZoGiWABYS2jg7gZqdQF8+DsVUCSKF1z73Lh4vpb35yQwAMLOv1bxEWQCnJyWqErh1q8DZSYHbM+CkKoRErHevqYFFDTTGiT3lP4shQguTFwqfW1rGf66BiGJR35rgqK5nt1Syf2pRMOqGcaXFwFBZIaDta6kKVFYpFM6rZ685y7E2tYhobsIaAwCqOEVx61S+YM0Spl5ISCzEOuwEWmcdnhdU7guuB0NDSDuWjUReGj7iQ06cqHMzMxUslen6AT/Bs987UiFsMw5d0UugvgJfPLIxtAVQzVHcfRGYnYCvnsA8uu/fd7pInKG6a9066weCOBtcP9AT2sJJOMpai8MzMvYMKgpobXB5Fb6jhRsnC/Y/fzeZdwhet3Z7zDYqhWXKbrg9BspxJL5U2yDZObbiy/2dXpM+RGV94jMJDXPCTcZjJ1LtIgQOGZSNYVBd+yRXCiK+ClguTESce3UT9DgqwodbxtEPLjkJqSDgykI8ii6rYb2Qf03tIxaoibJhxpELukFhlnjxZIn5LcKjc43Hj2o8qBkPHlaoZsKbs5nlkKpAWQBnZwVmJeHsVOFWCZycyGbvy5pRM+H8Koy3qVG0UCGKyX0flOfA7vzHC0DFVvjZpRQl46QK3GtY5jkXyyCKYi9e65hiTx/5cwBQe8MZQy8B3TSYFcB8fop6ceFDSKWOHbPZjcsUvHeOH7wQjLgKAJka5uqJGJ9PzsCXTzAKz4UbCKoxITRVJJ3e9obRSUiTj42ILE6NtMn5/v1o+8uO7bE7acuiicii7shBZOd5CSktG+Ddx4yFZrz6krKellAHCINFirEtMtK6cYjKqjqNkai3RcOoFKMqgdsnhPNFGNxG25lQ5jraGG2/tX5JQ19doDg9sw8/xJozyWLf84fycOqFWCPnC+vFmstP82Iuax2qWYmysgRWSmDOyakQ2K1bCicV4ey2nG8MY9EAjy+Apfe+yoffEXBFV+ilBBaTXmy5lrKORBISJPZ/zwvGrAKeP5NQmWVNNsQlEI4L7avQJhqGPA8f+sfKi2+39YBqbIgJAcXJbSgC9OISZhm8S8p/+S3ZJWElQCDc9Jr7xrQywfn1A/Y43Z/NnVcGfpj1AjC+hnaYiV+Y7aq4cBR7wljyWlzAOLKdnaJ46f1AU8O8+wY4CW2JF4f7cEn3fFVyXtG09QNAO0QmFXcTFodnZOwd5CIKAmfF410ZjYNAd0mCi1CpSrZhcDJprwpgVjK0Ea9XrYGLhRiyZgVLpmmE8bFM1jLHwi1d51wqGx5JItRKm9BDBJwzDGmf5MRt6i2bO4dIEpV6ztIkXz6kUkdb6jSAE2akbMinGJtIiUCSMH7lxzyy+4JKBmADNAuJUKivgNqKtyQM3hvB4pD2+NxSvEaf+MSboNkt3Ltb4tUP3AYD+NKDBS5rbZuz/KgZCwCLpX2GlitnVYFqpjArgVtnhOdvEWalnRvVzsjtPmOCYcd13PpeeNEfzZh9kAaTJHS07VyqdhtlAZzOCM/fAi6XjMslQqhi6sRS7I3ijh87CZGDv0zCMAv5bGSj9uGxNd2uYfQ8A1TOgOUlWsm8vPCOXgevcfe4cy6tG64P7U/n+Wd2CnXneXBTw7z1GsAhYcpYkrOhZGQecTKyVWIuXlc+kKm6L+P0ShF3iFsaZFwPilLh9HSGk1P5oZ+eljidAXduF7h9Ki7xh+eMqif8svJr69oT8qrshum5ASoNvyxUsPwUHaukTLTdWr1CCREqBYAZjQYul1pi2wdizCWkEq1zQ+u6CNz1yI0kYhkOzUzajTI5pguR3TqCcCxr6UgVKKoKqprJWihdR+EpMvh+5atzGNR4/c0FCssejX11E2Af0tADvpRIvfMra4ErxEJ767TA3dsK73seWGrClx6wX7/lBFogJPjQ95TQvBMr8tL63BvO2Jd6cJ1ll8g7thSJgVZrCVW6e1rg4UVIsNMYFdZxqfZnYZzAct5TcvsDRWXtIGqMhlksoLhBeXJLVgIuLm1/nafVecUSUzypyBPX9paRD2mJBZF/w7YO7INJFokjEvMOrWtoiTteFXLSEkm2X8tLmLc+D7r1HOi5l8HvvtGp1vGkpaShBs5PhH9GU62lGRnXAcOYlQq3TsNvwAk3WWcOe459gqpCScKq0go4WYMnoeXabrXTaGBZBzE2K0SMueNUxJWkrUctCDSyHrbSbzVk/ARaPGyNvDb2VdcrhVrLo2bcujUryDgRaFbpkorGQygr0Oy+ZzaBFds9yKipw2bRSdbDThp8t88n4MUcG7brgQkue7AkkRLPHlQJJgU24vWqaw2gxltv13h8Rbhzq8BHvvIOPvWaDU20YUZKt/ktfPwMrRmXGqgN4cETxot3gedvE954MPy1ccMheQ7olumLZInLukiWk0q+R64/LeNoMt8piDtePPe9KnwZ+1nD4HQmiVjquvbeV7Regwc2TVbTTThmvy/lDOpkBl5cAFdPJJFLujY9fk2TkKVr0uOlCum1znZPkRhLxZzWwPwMND8VD+LVBcy7XwIvLkdFnLxEoikVc30ZpW3dQY9cer+4/sC2QdP2i03a2gBZ1B0xWBvM5jO8/32M+W2FkxmhrAhXS4nDfrKQiX45A06rbkjlkFWyUMHL4gcSb93k1nqrqhDroSLycefe0gS7rYLLpGkYutFoOAxiFWzIXo9AA5yo6wqyvte+7IxThNrQ/jIO7UQpXREHcp7QAgUVkk1LNz5bE9kwl0B6NahQoGIGduLPfijKedSK7qsXeo5oVPu1sGUbAyw1sGjIr5fzJLVBBNxQKNLQuTEsaoDOgLRammVsE/hQP2aYeinrGjfBgLWzZQVNxcuQmFlD5LSIbAiRRbNLNBqg2UA3Jra7IbKYyzhEmLrG/ITwwj0xPsoaOPYet5n9u3AePRibNl9DMwA2kohDGVRkUCnLVQVQKG25MBZqztMGe85NfkWoKbP0IZFss/OSbgBwO2Mh0sm3bPsja67ICzTnSfOv8bpwYoAbv2eZvGrZYoWNzThszyfp6CmZfLcyAPvoBgLIJkBSolRIFdJEUUiYeHECqMKvXUYjQo+bJXhhQ+W1hmlqOdYaKEvMXvwAyrJAWVWguYxpzz8/x/vfM8P9x8Z74tIwTBfhMnNRLZXCyZxwMgNunyrcOhFD5/3zkEQurK1r/y3X0DqOhVxs8JZ1bsFwXRViFGgMoJlhNOO8tqG5ZTRnSQzhfesmZ6q9Fv2k0CjLAvNCwegFmmWDiu2adONek6yYPUlrWtsflBVUcSJvaHEBPLkvfUwzSjsBGIu8oS0N+sTdmIiLjr0HujoBVbIpPSkFXlzCXDwG3vlSJM56BOCQwGLuirgxb1waJjnijVsrpHJASO4iiiWLuiMGG4OzswrvXAKzM8JlLZseqZks8D09C0KtLDj87QSZkg2unUDzGS6ViDeyfxNkgGHI326PO9kHz0DWkgFgDdOEtW9k/QKyFgB2I+3VHrT0NRVmnbqOeHh4Y9SucOPVYo4RWVDl74KEPFUhBEasfMgJLxsbelKLdStJn+9DY4oSSin8/Bc1niwqnN6uMD+T8MtqZsNJLDnF5FXajKYulLIqFaoSOD1RmJXkyasoZJH45QJ4vCDM531hl13vWxp26a2JkfgP4ZeuDPfXcdk2Id83QMju1glJljXF3gIpk6C2ZTu2RrZeOaTJ9lbr+DkToZzNoIoS+vxh9zPu7CsYDexJ+Ei8NQKAdohIuo3A0PFQ/db5LQfycgZ15wUwEcw7r3eTtcQYCjnxXeXVISe+rW4bY6EnOewy47phlkuczhp85L0yIdPGcRegSLwXxsDvpVqQhiqDUCvtJtelMt675scq50kz2go2u2ZNNzJxZuO9Iy3BRspuuaMk6yYb4RRrIGwJNQCABgyDTSMCkA2oqWWC2aSCze45FntFhjwnhCDKYBcGujW7JIINKECkwJVdv8EM1gYAe1HIpgHqBtzU4k1pRCSa5QJc202wB8LiuAkePFeGixLl5QKnZ3O8/N57uPP8Lbxwr4CmEm/f1zCqwu27VrydBFGnSNaez0rg7IRwUhHmM1nqsKjF0P3uhQi1+Ungu9hz63gyGLjlscxKEXGl20KhYIk6InmM2kiOaG0dmMsGqH30kZEtpYpIvCXRRr1bREWirlAKJ6WBUgrEDXRzBb1cojRLFOgXce47CoiQUzbpmAKAooRSkmGZ6ktJ0HX1ruXB7r6xg964Pk+dG+dTkccmbHieijBVSEKw+QyYzSWZjpZNx/nqAubRfUmIFtd1GAupHBFwY6GU0kZXqA2LsdVeuPYWQCsEYPbUPZvgusbtW4z3MnCxNNb6aGxa+7AFgRNnPjwEDAOXsj7a04zdPmcGgA0B0e3Bp29/MiIGKBZbXa+YLzsgpNK47mHxFW1U7o6j1OvWd2WJMRy7DUadOAPZ/emI4LmztVEqJ5N6lh99I+Qp6wfC3i+txeOplTMRBwoKqOa49+JzoFs29t/uE+QsjrN5ibIETuYKVUE4mSvM54SqJMwrl01MMn0ZQ6i1kNaDS6AobbrqCrhrjW/pousg8voEmTvuCjYXmtkNH0HSvoTCFgo4nRnMSsK8NLisDbRuMC+AyiYxKVXTyoQJAAXca3tS1EqU4iZKzFBliULNZY2pteYp06zcLD7e3Dz9nEb3uFtllYxJZB3r5AqRyC4vezkDzk5Bp3ckQcyTB+CLJ60+9C7QXiPkJJwaJr1QZgqRZW9exvVCP77EWbXA8moJIg0qCDOlLSey3Zya/DijOIQ6ghmqqX0oJFmhFsYdI5Nk6zULk2a76onIl6F4DPBeMvHScUuYGb/3aZphl6JwRjZaxBeECESXyZo3KHsMJQO9KuEz9wI2xJt9H1hrcG23jGka/8ra8px7tVliOt6K5LduIq9emDi3J9B9Y0x8bvbkCWZ3T/DRj76Eh4sS7zwxqOYVTu8Cd26XkhClEu/brAJOZsomsCEsG3ksywaoa9nSAAUwL4D5PIg4txfsLNq/123ZVBUyXyjIDXsSdQR2mbwNtJbVyyEs0tjNy1k8uT3rJh2nlu57Z19lCyCX8Mb+7YwI3EBrDVpegY18/0TIBe+bjxzSTtQ1QFFAgUBFAVIViJKMo1cXVpTpthE69samayH7uKxHvAHoCjgisCpkrR4poJqBSpn3YLmQrXsuzsEP3gXXVyu9b6OerwGPWux92yahyVj45CrvG09ofxtkUXfEMIsl7s6vcFayeMkYIGif4YrBUNGxiztPxVfL80Uu/joRca19vkRYkRVUQbQJFMVf1CDCyN7TbRAOgs+c5RSYl1WuTTJejLn+yhefLVGyFWXW0udj/WUAJnvMbL1t8YTdaARFF4RleMDRDywZsDoCICbgdABMFw5rBman+EUffh6PF4RZSTg9LfyCallmIElFDBMaDR9i2Wjg0jZXsJRVlawBiT1q3Xh/+xolMnHHaXpl2U/QemsBH1YkYZzWSCC62EXdwO3zFNY/Bos4s0ajGbpuMANQlt0tDZyIKzmINwA9m6o20h9VQFWlZFlrZGsDXD4AjAmeu3U2KjdNd01IZ01A9DmOibi0zsp4/6jdPhFXlEA1B81OQLMTOV5egi/OYR5+NprodUlJmuIu6fmLI+JrRMR12trEgpmRsWfoyyvcMg8xm8mmymyFGpih9BKkl/K30XYCHbxl5EWZJKCSMYisMIOEohkj+2Ya7ZOVoKmtMLMCLeaEeKKrZNtrNpCBlCEhZnDx8tZyB1jvGXz6eLB4SMQT1ogIc/c2GlzX9lwQai7NdSy6ALS9ZANGn1iU9Qo0690jVYBJhASjhCUzUOlCQqzQJHklJa4vWQ5hUVbQRuH09glwWuGV50t82Qy4faasc1GeSa1leUndAAvb7ZM5Y35i+ZCAWSleMmXDIlscZflJBBtseKvxok0MwLKmv3CGa+/RNZbzgjCT5Dhh6wsCrGeXwxyLZF7i5yl+/aSdizTWCGgNCQBQ6iUq9HjfTGPXSxby/FQh6xJJQWm7BKRegnUjSWuadtIaSr+TrTDJ1V43+RrqUEYpoKgAKoWjZoWINrftTV1b8VaDaxFxWC7lffcIt/S76NAn3KasefN1J6x5k7pdfuvWGTZaDnnbxkTd0NKPdZBF3RFDXy3wXPEAy2YJs7wAAJTOWmgthAWHwUSEGtlJPLW9ZUQ+3BAurBJB1DmhRNabFwal4NHiSEzFggoscdcyRjorYRSLnQxyMXrXMY2VSX/c6Y8krrtiseponSmemYEwO7NYQs3P8PLLJ3iRrGgjkvh7r4zl36wAZkjWOfokNTZsltr7yynFEmILK8JgeTQinFiEOeEXZwZl23/R3M6Ta8Lf0ffCfe7yNp1Vjn24bkUaswKo4r3oEG0+buqOiCu4EeEGK+BAsrhfsw11XQhR9VgaWwJuaE1A3+fYJ96GPushwdcn4PrEG9AVcKSAYiaWzGoGms3htkTgq0v59+BtO3nsIacxElwjpHJUvCXtTyLEnj5lZFwH6gePcHb+FsziXDxtEc+5UEZwEF9kvWYcizKjgbr2+6iF3zxEmFlRw3Zizc5QqQoQRMAwVeKpoGjcMBq8tCGLRoOXy1ZIpRdli6Wd5OqO4cY0MfeG8zLR7RFf8THE+kckQlKEWAEq/K7ckEWEIhTkfBSD78YtLWORex+maew6uUbGKr2wnj8jHkatpd9GS1+0bo0f6vQMz3/gQ7h1u8KHvqyChhg455V40U5mLAlsFDCz3rbC8o2KBBoz7Dp7u6UDM+DOEVAqHUQZJImN8h4zK9B8FJLlSApzG8lACm8cJqPBkOgmCcdtgkF9YE+/ztIPa2Dw8zBlPcCWC6GKoPcB8LIGzKVkGTUNqF7AGR0J8NwI3XT3Vh0xXnLrO17aiYXbr6iU309Rhn1NmYHa7hvbLIHFArxcBgOH+/4NGA8cYsF23UlKxjxsqwRb79YGI4JtyCOX19Q94+BG4+zRGzhjLVZIsCUqJ5KMWGWYrVXRCTJtxZgVWG6xqzsfewz8zRKBMiqkBur2eb46b6r/B9x/reeHsUm7vurAxLOnD+wEsIuDJMir0zRkaYACKYrhtQCDYJ48wcuvAsumHS5b+TUczhMWPGMhhMPeA0FQuWPntYQLqXUkRCaIMbYht8aKfd0WdZ11ju6ZUvDmdtdCmtZxXM8LNh0t4iZCycaTVgEGlPJRQqQZrBeyn5HRgN1gXLK6rfC6jYTCjgq3Ia9bT8jJJK+bq9sSbSWoLIGyAlQJKmdga3mmupY1BM0S5uKJvOfE6zsl5MShlxQHvG99Xre0nXC8miD76uY1dRnXjfrdB1D33wA9+JIfQ4L3zHKfC1dURRBq9lW8ZwWYSr/VCUh4k3UDNM5bdiWizIZRmuVSBEwjYxDbZCjxGjJ5DRPoVaGKbExLiPm1b84DVhRA6bxlygsxtgax1m+VAa6DJ8/UDdDYUExdh2t1A9YiyGA0TF379+BgdLvfMdZZK+TaoUvG2f3HuHdboygIiiQKqbCvChoF2XWMEGHmeLOwgq1QLoTRhT5S8JZZMUZ+HtTIx+44wHnJmEHs5lPSN59chI3Mn4i8R46sGGslD7NGhDhayf/PJbzx3yl7ya6hlDBYu37SNKDlQsSZFUmtJQNDPJcKNaUAtt8V71m14bk2T4D73vv6WoP1Uj73euET3UA3fs0k0G9YSD78yUJt6yiQGxBqU9v1/S1KCY0tKz8nIFWAihK8vELz9pudelOQRd0Rg+sG5dufk02JL+zm1oPehWjQGPAgSQGylkZb2jDi8EjE1xD9mNzaND9gyWu4H7XqxfcDQh1mDmW8RdAVthm2kuuMqA+tGE7qv7crNyTiHPoEonGCSYQvO0FsrIfOEgOzJXA2XlDDrplSL74PWBp84KvPRWyBbdishMIyGIqdCDP+fLw2UZ6GJZixtYvuXDLQhMQhUcbQ1rOCXSsSygIuHAl+j22fidOSFuKy9lwB9mRHRCDYrGumlnCTeiniTWsJhwLa4azA/sIkY8G2UZgkokxvZcg8Q3Zwdum7AXlvjYRF4eoKpl7Ke7d7OU3JjoUe0lvLkpm033d9Ha/bOusHBvuSkbEnNA8fg9963XqDAECBzQxOlHGtZXy2YYumttkYl27ttPU61bU3sAx5x0wTxonW5FUpMIKnS4QWZHwg1RJi3hsWr4Gz9zGa/Vo3vxauacBXGtwswM47Zj18po48ZtHvsE+ErZqIujp91zp19fDv24xc86AGy/uPcK+6xMzUKKiWpDVuewg0kRfMijtrzHbbQIQkNo33fBFrEFzmULfunmzSmlhgxdfcfMTxqe2jD1HkYLjzx9GcIFo/6cs4XnJeYqA914h4huy9vLdNHrh8R9CzlhIKIJt0RNm/ST4z971xW02wbgB95b/jbDORQuuIA/sNh2Ph+jtbq7ZSdG0m0Ab5h8e/1711lbK/Y/FcohDep2hOIMLNhqQCYlBhtuJY1tSaugYvakBfyLnlsmM8mYos6o4YZrGEfu2zoLM74IWORA0BEBd5yGDBYZLqtJIboRQiocfeWiWhzu7HZsJ83YoNcQglYZSwddgWTK6B2a4jGC8D53VyVrKWlVHaCPXl1adNTsqit+yaE8s13OWDrnXnuWoIdOsOXqAvyYJgIigjxCJCzYUIWYFmOSV40uy11iDUXrsY3dRe7Rd1rfcWef389yBqI32WDARvrxSIDATReka39qSu4UkPQCtZSeoN88ItieU3puUxk2uJQIuNFusINUawfqtocqXklUgGalYEn1SH2yTJdQ1cXcl6gcZaNCdYMMOf0W8oxsj6tlWhJ33tTQmP3IVgy6Iu4yaxfPs+Fq99Ec3rn/NjSSzK+jxnAGC0sevaxEhDSonoUgpMM5nI2ZBF2YhbvGVUFCLqIiEmoZS1hB82DXhpPWNGDDxOiBmXnMR6ybxYXEOEbSu+UtHV91sdEmasVxhJB9rrQ/3gEV5evomTxTmUXgAMFM3SCi4je73aEEUvwqBAztCpw7juhJ4TVGScUdFucO2im0z8tzPIWn4b4ZaWwZBiwzGsnZMcW8KdJFfGRvD4yB+4OZzbR1AJ1RABpfseWHHm100K14jQt15VGzbMtRWaUT8PKetjXzvdOqs9X1MEWauu43TnyS7ssSr8751cZI1SXqyle0Kx9cKLOJPPwDSNZBO118yytl79ptOfwd/SFssVsqg7YuiLSyzffBv64c95AcY6ChfgZAHpii/K2IC7yURsF5l89jUB3FUmvrX65wTW4g2Ur5S4++T1sO4wsfrF50VLWaueF1ZujUAkwuUmQfQgFX4RNgmFHSvb127azlhMfx9pAv2iLBZkaeirXYRPJFZKdgsKmaKsLkX423WXrVh0vyHtrPS1t24aLZng4MQpos9/ZB3aWou4B57jJLG0hUdttN1thNqE8JSMjH1BX1zi6sET6CWBjfWeKwqW9CGvWGPCBK1pwI31ijULu1bMwNRLv+5NvHkiFozuGg13LcJ2Kb6mhEQO9WMVTLMZf1++8S7mD76IORtgcQ6waa93dBugO4+X80ayCzs0PnrIiyIrugyAsLYypHb2ayF91JGNCiIFuDWRsXHarY80AMDixnNcZqLEbS6Kh8Xw7HMSuPBfY7Meu/maE5RuDlfb0N0ej9gUg54cm1F+SOtM/f6uW2Zo/tCqa5PoMEMElbJr+FT0W/WJdlRIKuSS7qiQhIeJZC7Q6oIztMhvl9yaTqNhdCMeMxOMK+xDUBuYerX3bBW/7XqenSKLuiNG/fAJrs4bLD/3uj+3yX4XuxJOebI28Vk+usDJvfeg+OxPR/sK9XuSAGvfGxNhfeJrrB9EHUGB2L8Xh9721O05CaDvs49CdL3lUgmZqnAs/Sl8ak5Zj8ghSxrFnrH2c2gRp983ye6dxDqQvbXKsj9260jHhM+wt2yTZCKD7fo2h0VdX1ubWD1X9mFTIp7QTh4fMm4CD//7n0Zx956EUEZiTESYTNrcZG0w8Y/hlUKq5bVIyo7VvSnxNSa4uF7NY5sKtilYvHEf9O4bwJP7kgxE2RVxdq88crxhPVtsrFeV3ZTW5hCwE3LYpQ8tD53lDlkvKIKQG3vORZk01kiuTZsrRrxZvsw1hLRvIr4EFASsF7LcOiay6zDJZmAjEu+o42eyYZ/O46jkOjMBiqAcd8fX3BKa3nmEFZ+e0230lf3buM3Ljf3M6tp/ps6zbeog0PznzcOfQ38fdjNnXmdevUtuzKLuiMF1jauHl7i6fyX7yGC9L0cOg2rDbRtwHag/+S/xwq/4qF1AT5AY2FRYRVA9n1USTtsun55w1j3r3evU4e6fytUZKBdfNAPPzoU1wsX0cyBNHYRV+1qweLK26xHdffvEwiqBBUwSSeHcBNE10G5/e7sRRUN11vGSrbr3uBVx/f5OvZ6RsS88ee1t4LW3J4mwTTxgfWGHY2vSOmUHrk0RTWPiax3RNUXE7eI+U3H1xXdRf/bTQFPD2IRRcfIZdga8nu0Z5NUeT1invNbaLG+gtAsYvDeP/PkgiijyANoso9YD2BZPZL2JaAklKao65WG3MvLJ12JPVNL/Plb2XkEf6YOId90/OTZNdN5uOs8tT6IVt2wTBzHg8wx4o6srZ1qRNn3PdwybRYttUmd9gbXufSatLd0QWdQdOR793KdRvfA+1O++E3k6gJYlxsH93XJ1TxQyfWFULCl3R8u26nH/6fjEQPnWnyvLcs8pHixHyoZbmHDOJ19J34sTKPGA2LdGMKqnip5nfP4uLv75j9loylDHk9QIjn6/rx1Zy9YpuysL3aq2JrWxgdia0v4u3uN1PMt9ElpGRoqrh4vWcSzChr6n63i+rsvjta7w2oXY4vpmvOuLL76FxeMrLD/9SfmMXNid3ccveIzQzgRq16GhsN4lL6JUV0hZjxJse5NC2llCa1lHxkcniqIwSlk64fbHJeF1dl7AhO9bAisOs5S2jNb+HmnZdK6xDq47cmKfhr19cMqxRrBlUXfkePLpL2J+5fYRc5kX7cVY/PT+8Kd+aUeEXyQKqVCjIrHjck8XFad/R/elVWXjflDyB1EkrHq8YS6DY1S+913EFjiXJdIe+/dOgSSGHhsVBR7/5E/i4vWu9TjFtgNCr+i+JjjP57F6abZ59vu2Ku7LI78OOeaogIxjQH0uUSzbiK9tvWbbtNt/r/1OFPcZWjkNjCef+gWUL70K47daiMLrGxtu1zQAN62QypDp0WWhbiKvUSSMnMdqJMHLqId1B0bATdu8buw7iulQ3/cqHKKBMou6I8fi4RKLh5/d+31UeX2hieuC+jxhe0av920F3MA4e+97Ub7nfTh/67G/ts2gtq8Bd1ft7qKdmxSn14UbSd6z4/rHSs4ZTy/qx+3oh3XE16GJrpsXW8Poe65UbT72P/zkZ4BPfmbSOrHrFl/AsOd2CvYlBjaZl0zBTcyxMjZDFnVHDn15Pa7dzXbM2B6HJiYdSa3zPNL30HzmNdz55b8MNRjm4mKwXicEtBVWasNEmSXqlkOtEKIRyk0J07hu8TXlftuI521xyELyJpKOZMGWcYwY4shdC69DE1zbrJM7hD5c3r/sb3NPod1TtmRYq71rHC834TwqdsNv+xKSKa4z58ExI4u6I8d1ibqbAh+YqIPlmXUskKkAVCXh4T/7BF74NV8FunvaL7b6QkCjNZIhlLUdBurL2fOkpoWE9mHlIBoLRSck3T52xgAF+RCYkNLZ+BAat6aAyBJqfN1mvNIuPbRLAe0WZkfbNqxDKtsQwyGLvENHznyZcVPQlzdlkuziEITWsaC+sGGzE4TaNl6zKTg0wZ5iE+M3FZuPyTHnmnr9+tcl0HYlXI8JWdQdObYhrEPzgvVBbzBgTAFVW/7Y1xjk0+esawawxIOf/Nluv3Zs9dqFFW1wAI5FZCoqo+xfVBbR3jGq9TeUgird3wVIVUBl95lTFMoU7Trk9qcb65/bj4Yla9dKgRmnUrab27J2dRnGC8tIZCLO8GX3p2IzOf/QdWEX34NDXD+QkbENssg6XCwfdjdrTnHoYuu60Gc4XhebGqp3MY/cV3inOpLokl2K3L2LOiL6YwD+EwAvM/PbJDO/7wTwjQAuAHwrM/+ELfstAP4DW/U/Yubv3nf/nmU80wNio69N1KbC1AnK+vH++7DNmoYU2/Z1ysC9SnxMGfy8dY7ICkBKBCFBzcpwPhaQbpNTv7lpCSoLAASlqC0oyZWX7GrSXvQ3rTlYxxnQfFY1e47s+U652FvqMrAiiNeo7XbWWA7tu/LuHBC1aa/LDkPJtaTv7Tcz8jYZ+vHjwevPGjJH7hdZuB0n0iikZ3q+sgL9huNp8HOEDZ6vKmmte+3y3mk/+qD3ZIjcuQjdYT/3KuqI6IMAfiOAz0WnvwHAR+y/rwPwVwB8HRG9AOBPA/jVkBnBjxPRDzLz/X328djxtBHWLkXIKlw3SbiBx63l0NiNhW0UybKEbZ7vmE94V5bBTZ5HZ4AdWSszxWN13esTfJ9Sj6dSSL2e6d9hn6SovlI24jZpNy7nziMK56VYDEfhvVGV4Uy1oaxvrw/2dH0/izogc2RGxhAOKWz20DFkOJ6EnnnQVD4fE3ST5hoT5mBT+rKJsNxqrrnF3HHfhvx9e+r+AoA/DuAHonPfBOB7WEzDP0pEzxHR+wB8PYAfZuZ3AYCIfhjAbwbwf91zHzMOCMcmUtcZGFIRqdAVH5uEm247gE/F2GC0L8ugo/VJ4m7CZ7FOe77dKVa5REiuE+4Yr0nYx1qDQ1hXcF2L6Y8QmSMzMnqQPXPrIzUcbwo3D9lqmcoWYrHdl/7vwdYOgBXfr32Jr62F8ArsTdQR0TcBeI2Z/0Vitf0AgM9Hx1+w54bO97X9MQAfA4CX87LAjBvENiJ0V6kj+sThPtAnODca9DcY7PsGws4AuIbVbyMRugY2TfCzi7COVECx2Y/Fex0BqrPRvYPMkRkZwzg2A+++MYWHdiGEYy7eZYZYqtRuhbpta5/i6zojxwDs5D1tNdoT0T8A8N6eS38KwJ+EhJXsHMz8cQAfB4CP0En+5WccJXhHg8Z1WjTTwWZXg/5GlsGB972JR3H0cxh5voOx/BMmJL333CIBj7/3FvH5a4nKnDhlJTJHZmRk7ALbiNxtIorWxRAv7WqukM4R9jX/USVdu2HBfU7bvKetRB0z/xt954nolwH4EABngXwVwE8Q0dcCeA3AB6Pir9pzr0HCS+LzP7JN/zIyDh3XNWjsyuK0jwF015ZBg+28h+tYybYKDdlALE6591p9SLGjNQ4ZgsyRGRkZN4115xnbzBd27S1Msev9JYcMyfs0lg8L3+3vuZe4DOb/P3v/HmXPkp2Fgd+OyDznVNXvdV99+/ZDT1oywghJyBIzeACbsZBksOQZjDWwUEvANLNGAjO2x0hm1jJjGw94Boy8wNgCyUgseYQG4SUNFhaCMa8ZC0kIIakl1LS61d339r3dfV+/R1WdczIj9vyxd0RG5sk871N1qn7xrVWVJzMjIyNf8cW3944I/jkA7wjrRPQrAL5cR/b6YQDfSkTfD+kE/pCZXyWiHwXwnxHRM3rYVwH49kOULyPjacOhxOMxeBr37T3cShR2sWMYRVew7Uug7UOQHbpPwNOAzJEZGRnHim3aC/us+w/lLezDVYnEFIcUjNcRbP8jkKGaPwwZrvmbAYCZ3ySi/wTAT2q6/zh0CM/IyDhO7EMs7koGu1SQfZX/Pir5ULHvq/Le11AnQZAdTHwduJ/DU4LMkRkZGTcKVxUeug4O7S1chn2LxE1xJaKOmT8n+c0AvmUg3XcD+O6rKFNGRsZxYFsyuE4v4aoKf9eK/VD9BprR0Q7ruc0j122GzJEZGRlPK67bM9iHq/QW7hN5WKyMjIwbieskgn17B7vYp7cwxb7F1mLoaxZzGRkZGRmHxTEKwRTXZdjMoi4jI+OpwTEQwaEFYcC+vYV9yB65jIyMjIybgOuMCroqZFGXkZGRsQTHIAQDDhUu2od9z1GUkZGRkZFx03BMbYBVyKIuIyMjY884NhK4zo7jwPV3Hs/IyMjIyLgqXNfAMVnUZWRkZBwBrnIuoW1wVWGjGRkZGRkZTyt2EYRZ1GVkZGTcQBzTENKrkPveZWRkZGRkHBZZ1GVkZGQ8ZTi28NCMjIyMjIyM3ZBFXUZGRkbGSmQhmJGRkZGRcbzIoi4jIyMj4yDI89ZlZGRkZGRcDfI40xkZGRkZGRkZGRkZGTcYWdRlZGRkZGRkZGRkZGTcYGRRl5GRkZGRkZGRkZGRcYORRV1GRkZGRkZGRkZGRsYNBjHf7I7sRPQZAB/rbH4ewOvXUJybiny/1ke+V5sh36/N8DTdr89m5heuuxC3HT0c+TS9Y/tAvl+bId+vzZDv12Z4mu7Xxhx540VdH4jop5j5y6+7HDcF+X6tj3yvNkO+X5sh36+MQyO/Y5sh36/NkO/XZsj3azPk+7UcOfwyIyMjIyMjIyMjIyPjBiOLuoyMjIyMjIyMjIyMjBuM2yrqvvO6C3DDkO/X+sj3ajPk+7UZ8v3KODTyO7YZ8v3aDPl+bYZ8vzZDvl9LcCv71GVkZGRkZGRkZGRkZDwtuK2euoyMjIyMjIyMjIyMjKcCWdRlZGRkZGRkZGRkZGTcYNwqUUdEX01Ev0REHyaib7vu8hwLiOhXiOjniOhniOindNuzRPRjRPTPdfmMbici+i/1Hv4sEX3Z9Zb+8CCi7yaiTxPRzyfbNr4/RPR+Tf/Piej913EtV4GB+/XHiegVfcd+hoi+Ntn37Xq/fomIfluy/dZ/r0T0XiL6n4joF4jog0T07+j2/H5lXDmehm9uU2R+XI7Mj5sh8+NmyBy5ZzDzrfgDYAH8MoDPAzAC8E8BfNF1l+sY/gD8CoDnO9v+cwDfpr+/DcCf0t9fC+BvAiAAvwHAP7ru8l/B/flNAL4MwM9ve38APAvgI7p8Rn8/c93XdoX3648D+Pd70n6RfotjAJ+r36h9Wr5XAC8B+DL9fRfAh/Se5Pcr/13p39PyzW1xXzI/Lr8/mR93v1+ZH4fvV+bIPf7dJk/dVwD4MDN/hJnnAL4fwNddc5mOGV8H4Hv09/cA+Ppk+/ey4McBPCCil66hfFcGZv77AN7sbN70/vw2AD/GzG8y81sAfgzAVx+88NeAgfs1hK8D8P3MPGPmjwL4MORbfSq+V2Z+lZl/Wn8/BvCLAN6N/H5lXD2eim9uT8j8qMj8uBkyP26GzJH7xW0Sde8G8Ilk/WXdlgEwgL9FRP+YiD6g215k5lf192sAXtTf+T4KNr0/+b4B36rhEN8dQiWQ71cEEX0OgC8F8I+Q36+Mq0d+h/qR+XFz5Pprc2R+XIHMkbvjNom6jGH8y8z8ZQC+BsC3ENFvSncyM0OILaMH+f6shb8A4PMBfAmAVwH86WstzZGBiO4A+EEAf4SZH6X78vuVkXGtyPy4A/L9WQuZH1cgc+R+cJtE3SsA3pusv0e3PfVg5ld0+WkA/z3Etf+pEDaiy09r8nwfBZven6f6vjHzp5jZMbMH8Bch7xiQ7xeIqISQ1fcx81/Xzfn9yrhq5HeoB5kft0KuvzZA5sflyBy5P9wmUfeTAN5HRJ9LRCMA3wDgh6+5TNcOIjojorvhN4CvAvDzkHsTRgd6P4Af0t8/DOAbdYSh3wDgYeICf5qw6f35UQBfRUTPaGjFV+m2pwKdfiX/JuQdA+R+fQMRjYnocwG8D8BP4Cn5XomIAHwXgF9k5j+T7MrvV8ZV46n45jZB5setkeuvDZD5cRiZI/eMqxqR5Sr+IKPifAgyatAfu+7yHMMfZPSkf6p/Hwz3BcBzAP4OgH8O4G8DeFa3E4A/r/fw5wB8+XVfwxXco/8nJCSigsRh//5t7g+A3wfp6PxhAN983dd1xffrr+j9+FlIpftSkv6P6f36JQBfk2y/9d8rgH8ZEjbyswB+Rv++Nr9f+e86/p6Gb27D+5H5cfU9yvy4+/3K/Dh8vzJH7vGP9EZkZGRkZGRkZGRkZGRk3EDcpvDLjIyMjIyMjIyMjIyMpw5Z1GVkZGRkZGRkZGRkZNxgZFGXkZGRkZGRkZGRkZFxg5FFXUZGRkZGRkZGRkZGxg1GFnUZGRkZGRkZGRkZGRk3GFnUZWRkZGRkZGRkZGRk3GBkUZeRkZGRkZGRkZGRkXGDkUVdRkZGRkZGRkZGRkbGDUYWdRkZGRkZGRkZGRkZGTcYWdRlZGRkZGRkZGRkZGTcYGRRl5GRkZGRkZGRkZGRcYORRV1GRkZGRkZGRkZGRsYNRhZ1GRkZGRkZGRkZGRkZNxhZ1GVkZGRkZGRkZGRkZNxgZFGXkZGRkZGRkZGRkZFxg5FFXUZGRkZGRkZGRkZGxg1GFnUZGRkZGRkZGRkZGRk3GFnUZWRkZGRkZGRkZGRk3GBkUZeRkZGRkZGRkZGRkXGDkUVdRkZGRkZGRkZGRkbGDUYWdRkZGRkZGRkZGRkZGTcYWdRlZGRkZGRkZGRkZGTcYGRRl5GRkZGRkZGRkZGRcYORRV1GRkZGRkZGRkZGRsYNRhZ1GRkZGRkZGRkZGRkZNxhZ1GVk3CAQ0d8loj+gv38PEf2tayjD5xARE1Fx1efOyMjIyMg4JhDRbyGil6+7HBkZWdRlPNUgojERfRcRfYyIHhPRzxDR1yT7fw8RPUn+LlTQ/HrdT0T0p4joDf37U0REO5aJiOgjRPQLy9Ix8/cx81ftcq6MjIyMjIx1cCx8qfn8fSL6jzrbv5GIfpmITne/2oyMm4cs6jKedhQAPgHgNwO4D+D/AuAHiOhzgCic7oQ/AP9HAB8B8NN6/AcAfD2AXwfgiwH8DgB/cMcy/SYA7wDweUT0L+2YV0ZGRkZGxj5wFHzJzAzgDwD4PxHRrwEAInoBwJ8G8AeY+WLbC8zIuMnIoi7jqQYznzPzH2fmX2Fmz8x/A8BHAfz6gUPeD+B7lVTC+p9m5peZ+RUIqXzTjsV6P4AfAvAj+rsXRPRNRPQPk/WvIqJfIqKHRPRfEdHfS0I1v4mI/iER/T+I6C0i+mjHwnpfLbCvEtErRPSfEpHVfVaPe52IPgLgX9/x+jIyMjIybhiOiS+Z+UMA/gSA7yIiA+C/BPCDAH6GiP4GEX1Gue5vENF7AICI/hUi+rmQBxH9GBH9ZLL+D4jo6/X3u4joBzWfjxLRH07SnRDRX9b8fwFANr5mHAWyqMvISEBELwL4AgAf7Nn32RAv2vcmm38NgH+arP9T3bbt+U8B/E4A36d/30BEozWOex7AXwPw7QCeA/BLAP6XnWRfqdufB/CfQ8gwhL78ZQA1gF8F4EsBfBXEEgoA/3sAv123f7mWLyMjIyPjKcZ18yWAPwOAINz3GwH8nyHt2v8WwGcD+CwAlwD+nKb/cQDvI6LniaiEeAvfRUR3iegEwm//QEXi/1vL924AvxXAHyGi36b5/EcAPl//fhuWGF8zMq4SWdRlZCi0kv8+AN/DzP+sJ8k3AvgHzPzRZNsdAA+T9YcA7uzQr+5/A2AG4G8B+B8AlFjPM/a1AD7IzH+dmWuI1fK1TpqPMfNfZGYH4HsAvATgRSXmrwXwR9QS+2kA/wWAb9DjfheAP8vMn2DmNwH837a8toyMjIyMW4Bj4Evlst8H4N8E8IeY+TEzv8HMP8jMF8z8GOLN+82a/hLAT0LE5q+HiLb/L0QQ/gYA/5yZ34B43l5g5v+YmefM/BEAfxFtTvwTzPwmM38CwrcZGdeOPHpdRgYAtcz9FQBzAN86kOwbAfxnnW1PANxL1u8BeJKEm6Tn+JsA/le6+geZ+ft6zvF+AD+gwqwmoh/Ubf/9ikt4F6SvAwDpc0CLo3G9luy/UB69A+BZiHh8NeFWk+TXyhvAx1aUJSMjIyPjluKI+BLM/EHlrQ/qcacQo+RXA3hGk90lIqsi8O8B+C0AXtbfb0FE30zXAfHyvYuI3k5OZQH8A/2dOTHjKJFFXcZTD7USfheAFwF8LTNXPWl+I6Qi/2udXR+EdPr+CV3/degJRQEAZv6avu3JOd4D4F8F8BVE9L/VzacAJkT0PDO/vuTwVwG8p3NN7xlO3sInIIT2vIrJvrzfm6x/1pr5ZmRkZGTcIhwLXy7BvwfgCwF8JTO/RkRfAuCfQMI0ARFufxrAxwH8SYio+4sQDvzzmuYTAD7KzO8bOEfgxFD2zIkZR4EcfpmRAfwFAL8awO/Q8Iw+vB/AD2o4R4rvBfDvEtG7iehdEEL5y1uW4/cC+BCEkL5E/74AYlH836049n8A8GuJ6OtJ5o/7FgDvXOekzPwqJNzzTxPRPSIyRPT5RPSbNckPAPjDRPQeInoGwLdtdlkZGRkZGbcEx8KXQ7gL6Uf3NhE9C+n/luL/B+HYrwDwE8z8QYhn7isB/H1N8xMAHhPRH9VBUSwR/YvJaNQ/AODbiegZNcb+oT1fQ0bGVsiiLuOphnbm/oMQAfUaNfPr/J4kzQQSQ/89PVn8N5AO1T8H4Och4uq/2bI47wfwXzHza+kfgP8aKzpiqxfv34IMgPIGgC8C8FMQ6+M6+EYAIwC/ALFc/jVInztArJg/Cul/8NMA/vomF5WRkZGRcfNxZHw5hD8L4ATA65CBUf7HdCczn0N47IPMPNfN/zOkz/mnNY2DDA72JZDRPV8H8Jcg0zgAwP8VEnL5UYhB9K/s+RoyMrYC9YQyZ2Rk3HBon4eXAfweZv6frrs8GRkZGRkZGRkZh0P21GVk3BIQ0W8jogdENAbwH0L6EPz4NRcrIyMjIyMjIyPjwMiiLiPj9uB/AeCXIaEivwPA1y/p85CRkZGRkZGRkXFLkMMvMzIyMjIyMjIyMjIybjCypy4jIyMjIyMjIyMjI+MG40bMU3efLL8D5XUXIyMjIyPjCvBhzF5n5heuuxw3BZkjMzIyMp4OLOPHvYg6InoAGe71XwTAAH4fgF8C8FcBfA6AXwHwu5j5LZ248jsAfC2ACwDfxMw/vSz/d6DEny0+ex9FzcjIyMg4cvz2+kMfu+4y7BOZIzMyMjIy9oFl/Liv8MvvAPA/MvO/AODXAfhFyATFf4eZ3wfg76CZsPhrALxP/z4AmcgyIyMjIyPjtiJzZEZGRkbGQbGzqCOi+wB+E4DvAgBmnjPz2wC+Ds3kk98D4Ov199cB+F4W/DiAB0T0EjIyMjIyMm4ZMkdmZGRkZFwF9uGp+1wAnwHw3xLRPyGiv0REZwBeZOZXNc1rAF7U3+8G8Ink+Jd1WwtE9AEi+iki+qmHcHsoZkZGRkZGxpUjc2RGRkZGxsGxD1FXAPgyAH+Bmb8UwDmaMBIAAMu8CRvNncDM38nMX87MX34fdg/FzMjIyMg4FKikvf3dMmSOzMjIyMg4OPYh6l4G8DIz/yNd/2sQAvtUCBnR5ad1/ysA3psc/x7dlpGRkZFxJHjKhdg+kTkyIyMjI+Pg2FnUMfNrAD5BRF+om34rgF8A8MMA3q/b3g/gh/T3DwP4RhL8BgAPkxCUjIyMjIw9I3vLrg+ZIzMyMjIyrgL7mqfuDwH4PiIaAfgIgG+GCMYfIKLfD+BjAH6Xpv0RyFDNH4YM1/zNeypDRkZGxq3HTRRcprh5Zd4zMkdmZGRkZBwUexF1zPwzAL68Z9dv7UnLAL5lH+fNyMjIuMm4SQItC7PtkTkyIyMjI+PQ2JenLiMjI+NW4KYIresSWVTua3rTjIyMjIyM24mDtSXq4V1Z1GVkZNxaHLtAe1qEWfbyZWRkZGTcZBx7ewLIoi4jI+OIceyV6HWIlasSZFd5bcf+nDMyMjIybh9uCvesy8dZ1GVkZBwUx15p3iZhdhXXcuzPMyMjIyPj6cSx89OhOTqLuoyMW46nvZLr4hCCap/XcIjndYh7fOzvVUZGRkbGceJY+OO2dYHIoi4j44bhGCrD2yDEAvZxLft8JsdWnoDcLy4jIyMjow/X3S652u4CxztYWBZ1GRnXgKuoAG+bBSrFsQifXctxbGIwgOzVvDvmis6TkZGRkbEZrlqo3VZhdpXXlUVdxq3AdVuJrhK7C4nDVmaHrMB2ec7XKcB2Ofc+BdZViCgyT8+3mJGRcfzYpe7mivdYkuvBdbSPDtsOuBmG43Ww72eTRV3GAo7Bg3Hbsc9KyZ7sntexCrEuNi3nNoJoG+GzrZAhu7/34Kq8Xlm0ZTzN6NZnt6HRf9uxE78dkBt9ffh3Z9/cvs+2y7H3RQ+4zvbspteVRV3GAuyJBQBw5VemPebY4mPCIcMFdxF1BxVzBxAZ6wqXbYTHJgJrVwG1T2F0rCGMVxXCmZFxndi00ZVF4NUjtGkCrkJM9aHbprqJfdP3VeZj7XoQcN3RX9teUxZ1GQuIL1Nhlye8AbjuD3NdbPMBh2srTw/3nK7CK7OLt2oTQbPptWzlsdujkCGTDSYZGceGdevqIeGwDidl4bdfdA2ftIOo2+nZbNCm2pfwvO7+58fujbvuqLJ9Gz+zqMtYwD7C+a4LN0XEBWwl5jqVQHlaAgDYDzQijiRcbp8epU0qwm3F0S737Vi8Z4d89kPvW0bGbca6Xh+D1ZEuuwi/gCwAV6O4o9FHTu5Vn7RaW0SdyGIf933ZOe0NGUztWARfwHVEiBwL3wNZ1GX0YHRfXgvvMlkA1/PBbtIYD6LuWHFsg3Ps0wN2LIL5GJFFX8ZtxCqvT2zsF6vFny3DMasF4FAeOfxzNYrJYlOXXf89X1VvxXbRePV5eUUbaidxuUfkgbxuD7Koy1jAnRfPBvcdQug9zY2/fVQwz/2az0bx7Auywh7MAJjB3kNWAICT32FTsy19Btw6BovHhH2t9W6y4f3e8WI+nZ/t43rOMXDeTdB/73vuUYKGcPuvIdz7Jk13nXVVj+duXqvBfr0G4Hp57RCGdE3HZmRcJ85eEldNeIcDJwaR0N0eEBr4aaO9EVh2YV97f5pqecN/pUDsNOD3ISKOXSg+eO89AP3PplsXdevX7v6F59pTl62qo4fE3jrtq2OpO2+6ONpGQN4ER0cWdRkLOHvX86DxBOwc4D2YGVy7KAI4ioFmnZ1rGqa8WSM14Fgqqy6O5UPuq4Tsvfu484VfgPq1l+UZEAEggAgMBohA1BmtjVnTJSCxPnPgIt3dPpZaCzkg3U39vxe26ZJ9OzNa+NGfD5J3ZVde6eRPSYbs/fJr6l7Pwj0j+QwoTU96mDyjZl+P93CN147ZR+HI3gFevsso6FvfrG7zHt6F/b4xAOgxzMlv7+FrrQc86/YVDZYNROexfvMZGUMY3x0BSMRcEAqV69/eEX39+9phgVFoDYT69fUJ28RDmGKXMNFYniPv9nDvV78PZnICN58DzoFrB1fVUhfWldRv2t7xYbtzQNKuGRJ/fXXYKuE3VEeuk9eytBmHhQme9T0aVveNLOoyWqCiwP0v+WK4t94AgwBDIDIqBIy2RU3TWI2iQYVEbMQuiglgu4+B1xGInPxI0kedGQmVW9uXeox693G7rR0axN0Tdn+3CsPg7vmCSG6lS8vLvddYvuOdsNOHKN7xvAprrw19BlxomDttvLfP0yIFLw2S3niQbtrWJaXX3t23JukseSdWEdfq/avft5aXco95LU+4xNK+5jfCnpGK+PBHRI1wJ9JwU/mW5RsmWCLAGDCM7Nft6W9GWJe0YV83fDU2blQwigDUd9F7MQh5J9+gd1FARqORd/DzWo5xbr37l5FxTZg8OIW9cxd+XsFXc/jpDADgqtDIbzf2F7Y7Xkv49e8fEH8AuOh4lHRft2/Wglet6PcSplhH+PWd+xhQ3LuDk3e9E+5Tr8BARoDkUQGglDqQCWRNrO9inah1XmwFhLo90rTWY7UDp/Wa9/B1qOPqxmCWGsjSY5mlXgzGc99+X7pY5Tlc55hD4NiEzmGvuc2BhzT8b3odWdRltDB5zztRUAVTenBdAS6IAn2xBqxTYb0r47ofOvUc28VGjdpW5j2eFFWZ1EnTJKXFY8P5qWffwnrXe0VRzFDPvm6+4g2CNLiReHniOUyznji4Qjr/xicx+bJ/BVzPgboGjBHSIWqW2vAPnjshpdRblqArNnzikY37We994wkKnp1UmIq3CEk66LGuOVf0+CIJF+UoQNnVSoDqVaqDQA1id3mojFzDGmmwhET7BNgGltZNz7nt9xGfCVhfH5b7tuxz8r4d9bpGGQa/TxV/YF0aA7I2CkGyFjAWMKNmn7FNA8paMDNmH/5nSwqckXG9uPeFnwd79z7c5RRUlmCto13twVUFP53CV3O4y6msz2bgao76cq71IkvjHotevVT49e1fx+sXt/eEewKL4i+AesNCFWsIvxSbisBD4vRz3oXRSQl+z7vB1QxwHn4+B7tKxNS8AlzPMwg83mnzNOKONcJCmT4YwsgAloDCAGYkwpBZ6kRQE5UR6j0y4GAcDyIztA0SRMMut4VjNJ5FI1mzTYRlsw1eIjHYpeuNqIw8PuCdXAe7iLt9CLFdBdY2ZTBFOHb3937h/BuGiWZRl9HC+MXncPZlXw5UU2kQEiE2soGmMZs2qtO+QTFsyzXp01DNJMyrt5EPFg9TWA8hYuD+vmKtY9LKKKwnadLyd9D7IQ+Eme0kSn1y35bluVKIyH0wz70I/zlfCDCDfA3WJRjifdOKmsEg5yDPqFlSEAJxX7j3XbEH0YEhJDHc/yA+ORxDWBDBabhnFJVADEUM+z1HL29zQm6EgnqgKAlVjPcxvE/BQ6RhM+zqeA8QPJnetTxF8HW0pMr+/nclkl7fc1nxPBfeiZ73YNN3oJf0u1iZx2qxua4gXUyXfOs9x0YB2cmjmIx6z5eRcQx48KVfDP/ax+ELAKgkXA+A9xVwWoBPCqA4AfMDFX0WVBTwoQ4LomI+h59NwXUFNw3CbyZCcF4BSASbisA+79+C4DugQAxY1ffP15sPRnWofnmTd7+A8a/79eDLJ8IPgT+8a4ygQNPucLXwQF0rT1TKD2pQrGoVRsItXFXCLYFLgscNSZ3cNYazB+Bj2yfWpY4jJ3R5qOlyoOLPsghHBGOaEXXBQRwiRlpw4GWGpE2MvbJfIrBa21Ok0U++HaIfu+gkXJsaYtk5KXsQkc41x8e8pOuAd3UvZ6w9eE3rmOUCax3xtmuk0Lpl2SSvVaI1i7qMFkYvPAd+9h3g+SVQVwB7kKu1ouNmGSo4z02jGQwYtW6ZUGFopSNbQVF4hYY7mkqEfatP06I4gOaJ2MCP6ThJFPouAU0YWjguJus2oFtNy1a6BQ9SWHYFbhBLQawytzxd6X2TULTEouZSMeIXwtBipdjZZt/1HlzcfQmunsO6WsQbO3H+QUQWiWtPlskdJvbyPEifC5rloqhrXytF0ew715ZcKyfCGpxYPBsByYkQj3kGKyKzkCR8Ex7qnWQX7n3cnhAgkVwlEchCSK4owSiF5AKxAQBJeA2lVtQ07JbRkHrtwF7DaepaiUiJ2VWxr0a4ttbt65D7qucqy34h2OTZc9yuQjDuN2t4HW1/nusMHDDQV5LMYRp2GRn7gD09gX3uBRTPvwCeTQEAPJtKRMHlJeAq8OwSXNfwF+eAn4noqwCqVKjVDvAAFSUwNsDZGfzdO6CiAJMBFaPIVX42b0RfXcNNp0BVoQ5ewPlcPDZovrFG8HXE3ZJwUKDdWNw0LDSMBJmGh67r1Wv6Au6vX144N1mL8sEdzJ95CXyvhqmnWpdXMPVcOLeaSduDpP4kpxEvIwtQAfKltmOUI1MjpTFNG0i7p4CobZgGJOopesR801cv8H6lQtLVjRctiMvQVnC1ZrlMKIZ1DXtntIR/9xjutGGaG9jJG4jrsa85mVZkEIV1aCRRiNwwRfM7pAvrQMyHWkK0E+Ifuo/4RhA2of3CwelvuOY++yjOXdNG6VxT7zu0V6E4zKerj22DzPIyZFGXEUFFAXvnFLN7L6KeXsC4OUJj3KgwMKlAIANEoaDiIL70sqTwnkbvnAoZZqkcmQF2cZ9s91oZueQYoBFHwQOlgil4mYIXioEYLojk/MBi5dUVLz2NbIoeSzReqpZQVAIpgjgFogWs46UiTgbICH0QVVBED1S0lqUVdhgIwzdWQQB05z7eKJ9DbbyIOSJY8noKOdZQeBZyH4kb4SG/G0FF4RlA0+ozIHJ663Q7+ZZOJjDIy/kpivbk3QjXhXDpKhyJ5B1JPXbMzfsUDg1WUaeGBu3cDjeXZaVLvZ4oihOBLOUSCyl8k4a670YgxyisCSAbL5asBdmRkpSJSzK2sYhC34vQn6yey/NTqy67CnC1WHm7JL1MACbl625vEc6AANzEGzgkAGPTKxGAfXm386LBfe3tqy2aGRnXheL+XfBz74C/eAzy8g3DMqgcgUaFhBQ7Bmwh36Cx0SjEl5fSaJ9dwk/FQ8fTS8DV8PMaqAGvwi945sgxTFGAyIBOCvDJXRGDpoihn17rKT+bgesK9YUsQ9inu5RlEGZDoZ++dmt7+wLW8fp1sdBY7kwNsGoagN48OwIy9CO0d85QPnOGJ6cvYD6foyymYAYKX8H6GiCChQMhtG0MDDup8qP3TOroGAmjYgt1MHRXmsaD6hD1UeuxSRSSEUM2kZFw1hidQkr5pmnTtKJTgkgCAOqPTvFJBEqlg8FUc+WeChwGiEkjqNBw3AKHdCJJ2v3vB4wG6n2McP2c08cxa49AaoyE7EeRqKH9xgoNFRLe3/SRtIC1ys3Q7gAdLnJO7kO4P7rOVR37RMr344SzQxeQnnLHW7TkHd5kkJy+/WSWT2C/N1FHRBbATwF4hZl/OxF9LoDvB/AcgH8M4Pcy85yIxgC+F8CvB/AGgH+bmX9lX+XI2B5mPEL54B7OR8/hku+hJBlN0ZKH1cayYR+9Qa1GP9cqGDT0T8WBCQKMREiQd+1GPAATLGDNDlln13jhglggRC9MEAEUvGhRIFDS4OyKONbyhqH/gwhsLDgUvUSpQOTGG9kJKY3bFzxWvmkAdxvqPtw/lnowVNSpGIHuh1SYcm3BGhgGr/F4VN3BvG76MRB55RBdQp8Zmu0AQPAw5LVLH4dsdd2LQNP7aiBeVKKw1PTh/oZnnd7z9L5ARDyn6ToEE8Qm+/B+MYySo/HyThhjASphrHRyF4FotJymIWIvA29QreLJO1A1l0aYq9rPRC2gzXoQgW2Cg6sbYcgecGiRH6dpQ6UP0n5kQjw0mei6lT5k1FTQ7GqgrsSqW9dALdZ5ns9EgIeEHfFHCUlsJPyS8gbypiQ9rRBi3PW2dbxs7XKtyCu8AysI6yYjc+TNhz07Qf3gJfiT+zB3zgFjtY4imHoO7x1odiF120wEG+q5cNOkAJkxcHYCG4QfQYSfji4tIq8Sj1xdg6cXYFfDT6cAM3w1B9wcPHPApYhAqsO3a2CKAqY0oNMJQGci/MjKMlRnVaXevzm4knPxfA4/n8vvqloQa93wz1Xiry9Nd3sXURAumXZ1qOFrByK27b0JRs8+wBN/H49rh0nhQASMjEOhPGhJxJpxuuSqvQ4xbksbiKS9QoDR9ofxTrcJX1LaPcEHw6EKwCAEvQhDCqGKrlLBKMJBDJaBp0JbpdtGCOdozo3CguxY+IYh71bsxlDEYziEk9a1erkqKdNcxAsrb6Juewf7BE1XCMZntSqMNDl2KGJkSBDGPoKRjtt5hjXuyWPBUwdEPobRPuDWggoLGp/od0qgomh4Ow37ChFWda3fVq3ir9a+m3XD6VjkwnjJK4wZ6xo89+mp+3cA/CKAe7r+pwD8F8z8/UT0XwP4/QD+gi7fYuZfRUTfoOn+7T2WI2NLUFmgfHAXF/UZHlVAaZ2KAqdCgUFwWtHJCxasWtayhvxJhWdJvDSGtOJjGbzBqDcIEFEhS24EYiICgiggL6KKvItLxMa1igEffodl6OuVCLVwLiDoRhCsWNA4eGJ6QhGhaRNPUsv7pglaYRnBjRXP3wgDZieVd6xMnYS6hiWwUIFTDGdMtnkPuvcs3j4v8egSYDCcBwrDrQjDwjAMAaURD14wVhXEKMJzo0RgB1Gu90/egTBip3pRg3cSwYPH+szVawcVhqAYUmf0nwXH2yOirBGUoQyk74uFGgfqGdh7kHq8xIuMRvS5CoCLgpF8LZVzMYIpRo031FhE0RlCKOsZ2FWg+awJLwYWRGewiLb3td+v7v5GlDv1sDaiS26zb87HAIpSxF9ZgMdjGFvIDMXGSFqnIq+uJER6LsIvgLokGcSSDaftiM5Q/k4oJRHLi4J+wSfn2kD0mU55TNsTfZvFXILMkTccxZ1TXI4foC7uwpSXYPaw9RTsPQwuAABlMQHIoOBaGoFeohqMek5QTUGzS/EKzC4AV4GqSwAEsh4YjUGjEmQL9S4UUkWQ0RCzGjzVEM/ZFP7yEuwq8GzWeP0wFyFWo+nfVTd1lilKEFnQSQk+uQMqS4Cshn+Wsf4Q4TeXMNBqHtfdXPr+sfYn7Bv5c8irN+ip6Pbb6w1/W97w7R5T3jlB+eAu3qpO8HAGzJwIJGscCA6egYKk24IlB0OEQiNdilIMmwU1ETCAGkUTz53xdWOEdG1BSFB+IiMjiRuvXkEVYix9/AxC1IpGMIXuKwjGToDi4CbaFlNhGPqjwWvfvvlU2hYhgqmeN3wV2g6u6U9IxoJLMTjwyZk2EAzINvIgisCqhq9mkk8lg81In8I65r1eeGjIs21UHOzPvuAVXBSBq/qLL/cKqtD2Ndg3UV7d8/R6EMmIN7AoQFb+YA3M+BTFvXtAEbYlcstrv9paRCBX2se2mgu3q8e+VV67HkfuRdQR0XsA/OsA/gSAf5dkaL5/FcDv1iTfA+CPQwjr6/Q3APw1AH+OiIjXHv8841AwhYW9c4ZX3izxy68BZEaoPVBYwngEWAOMCoYxwFiXpWoiGxruxBJ1oktihmcGwnYVBsyADUJCK8uCGkFIROotEuMJCCi04gtC0YZ1MEzoy6fXEsQbsVMBomJRvUUEXSahn9G71hGAQZAtbvft/SH0IEm/kNZIZWq1w3YIuyBVNVFQuhpgFXlOPnpoHwCKgsGBnnkOn3zlHB/6hEMNC2sJpxMLa4GTsUFhgdFI7ooxRrqcWSOh/EAT/k8k+1RYjQp5rkV4vpbjOhFQWhVdGn1YEEcRaYyKdIQ6W94BA8R3QXQ7qz5mvWq5V5ZYvbbAyAgpTooa1hDKiYcxhNKo99FX8M7B1FMwMyxLeuvDsorCL9w3oxZQYwxQlDAj8Z4ZQCrnQJTVXEYVnc8gg8o0VkrqkOSQp7Ud+rm4n1JRF0nRA37ejEaXCkYlDZqMgbMzUDmWD8R7+PklML0Ez6fa34cXPYcD4ZeDRLzk2LUttEP5pnnEY28nDWSOvB2wd8/w+uwZfOoR4J2DNcCkcDAGODlxUjfZWgxh6vGxPAezh/FzEBFKP8eIKxAZWHYgY2J9Zdxcowqk7xfNRfyRfs+mmgF0Aty/IyGYoSK3VpbGIgz85GdTaWyrscpNp+IRUq9faDiGEDw/n0koZyIEPTNoUoAnI6A4bUQfTPRcAJCGaV3DzcTg5KvQD7CCn1XRa4FkIKqF0SQVQ41v73hl/dFsl3Tjdz7A6MEZPvHJCh/+JINsgXkNTMYlTk9GKCxwMiLlS+G60mrbhRhO2zCOpY3jPGJ0S+DAkfXxd6GG03IU+NEnES1iDA/dG5hDW6jp9mBQSRgoEA2Ui0ttH4UuMYAal33rnTIa9kv1HKguwc7BVJcIfQqBhseosy5c5BLjpIv9DG0p3isiALZowhy19SWhirW2XULopxodEk6KfQvTZ72Kj9bwEq7jIUyPXcdLOGSQaOfpwfUUqJMtLR5NfofonaIUMTgZCZ8XJaiUbazXxXWlhhUJo/bnT7AM+/LU/VkA/wGAu7r+HIC3mTlc3ssA3q2/3w3gEwDAzDURPdT0r6cZEtEHAHwAAF7IXf+uBsbAnp7g4qLCx152uH+vwKggFKcGxhO8A6Y1QeZYNbLUsPAw32kQAaOSYwVpCCgLbfwbRmEY1spIrSJqWOoZMNgDlVZwHL//ECbRFoGh4W+JF/uPhX2QePVg+LLg2GVNI1+avEm9SU3MpC7Fq0LeJSGbjUBM+wQCbfHXFYSBvB2psAhhrFqJBsFB7AFjxMI3OoEZn6rwE9EhHaodeHyGajqFrWsUtgDXwOVji8s5w7PBdM5CvgDGpYi9sYq98YgwHjXCb2yAUvsiGCLUWvc7jXKQKB+C84DVYXZtMjpz+B0EfhCAhb4D1qhQNIlANCIC4zNC4zV0HphzhcoBlZcHNbJy/0oN1Z0UBYwpUU4mMEQAV3DOwdUzMDMKP28JPADwOv5wE9rpAOdhfCUDGgTBbQwwuQNzck9eFDcHphfSP66SuanIJKSH5IUK60ElB2EWvFeckFQQeqHPYboPTaMr9rmsReDHMJPgIbYlqByDTp8HipE0oC7OwVP5kzw6eWt/uPjKxwEAOCE3TRMMhTG007QW0cvnw/aGAON5Qv/3Tn+8iNvbp+7PInPkjUdxMsGsLrQ7k0XNwEXlUTngkfFSN5oCBOCkLGENYWxF9I1HTnsT1Ki4hmeG9TMVfiK0ChCoMCjsRMQeOxAZbegTrK9U9M1U7F2Kl8/JNrhK+heHCIlyDIxGIFuIdyh4C4g0TMyB5yL+/HQKnuqgLzP19rT6+AnnoLpUbyBifz44D7IFrIo9LkYoTifqubDS+Ccdvj/0ma8rsHMykExdwc2CGJC+TG5WqedRojJkkI5+b8xQY3t0/w6K0xM8fjTHR355imefH2MyIhTlCMYZTGfA5aXBvJJ7UjnhQCI1ihpgMhbumqhh21otAzFqDzhmTJ20YUijZWL7Q+vAIi6V+1T8FSThmoX14vAh1vYMABIPklcjOLFrlmiipqKxUkVfwXPAAYUjgAoUluSdNBaAlz5o2iVBpnioQfNL4azoyeuIvBBBFAYbgQ5MUmtfPbnpevPRTGUzPlHvX4kwQAqHPuWzKVCJ8OfZFDGMEYgRLgsGxWWib4XgGxxxvNtHMPCwbc5DHb4aNkgMR69wt6xOR1Cdtsd/aL3LRNKHtihF8I3HzTMZwM5MQES/HcCnmfkfE9Fv2TW/AGb+TgDfCQDvo0m2UF4BTFnATEaoK4d6OsXHHxdwHjiZlBhNpEV3NjEYlcDphFAWjZULRJjXQF0RphVgtIUeGv+N6OOFxn8QBKMoAE0UhNZQDO0khPm0Gc5Lo7P2KgoSLw/QL/yAxMvWTRePT7xrel9IhaElq55Cq55ENAIxeBBB2ocNGiYRhvN18N7Dadig9SosgvUtCAwrHQqCuPMaWmG4bj5m78SzpB2tp09m+PmffxuXtVjP7j8zwenY4M7dER5MCCcnjHnFmDuD83PGo8fyAIrSoij0d1iWsiwLQqlir7DAZESwRoRgUQJFIaLPOaByMh7I1Eun7ubZh+fcFYDcWg86wibbLTEKC9w7KTEZEdiLQPUsB3kb5oaS+zaiCgCjNEBhS5TjUjyD1RS+llHqvKoSq4KaVWGwCjN2WplTeCY6j1GwVgIwtgBNzkBE4hG7eCwVdBzkRr2C6che4Zn1rack0BWA4ZAgpiiQUyhnOz27SjyLl4/lwRgLjCYwdx8Az78k4u7hWyIIYx4DIs97cBjJrCPEoshbGIVL72cIqw7iTm5mK2UjJvvzuE3IHHl7QKMSVcX4xKeB85l8Q2cnFqUF7p6ogcxaMANTx9qdzqF2wNjKBz2yhQo9wrgYwxjCqJBGPpOIPcOVhHS6SkI8nRiRCmbAlChG0ki2k3sy0AfZJkwvhNtpGB6qGdjVoNklwHXTQK8r8RZYA4xOYScnQOx7BanAdeRFr/0DOXj9LoPXT7wvccCNOAhLJb9dIvw6YaCsIX5G+zDZkwKwErpK1oJNIQZJ7egtPIrY54tdLYJQ+y+xc/BzOa/XwULKe2cwo0K8kLNzfPSjczgHnNwZY3JSYlQA9+6WGI+Au2cFTsbChdM5Y3ppMK2E24HG4FnoKJ2jUjmxlL/CiDHbGqAomm4NzotB1DMwr0X4mySyCWhEnyG/0IYprQpANX7aIATJgwzBlKHXnETEsJ/DeQdrhPcKP0ehBk3r5oDzsE5Cg60dg0ZnMKf3RPSFPufzS3BdgeaSBwrptEiuUgM0FkI6F9bDaNA9o3aSLcHWgk5O48A/MFaiY6o5UEk/T55dQEJdlfs6/d2brgB+QYCt8u5F7ut0M0jFXjf0MQquTmRYw439oo69j10MVnqbu33VdfR5nl32p+9gH+a93wjg3yCirwUwgfQX+A4AD4ioUEvkewC8oulfAfBeAC8TUQHgPqQzeMZ1wxgYY0CuwpOHU7zrpVN87NUK57VHVcurUs3lxSxH6jlRETAZEyYj4GxCeHACMAhvPQE05D427IuCosAL20IFNw1pbLvR31R8WmFa0lBQg5NSBu2oncflfFHEmRgHj9Z6VwSG42rwgiAMff5s59j2khfyNgQYEvFlbAFbWhiuMJ/NGoERwgWDwAjz1iDcm1BB1oi99/Sj996BDGE+neHhm4/hrAwjVtcObwAYT2S9HBcYl4T7D0a4c2pw706J1992eHTuEjFndSnrVUfsRXGerAfr5agQkX/3VIhrOgceXS6KuqBzul6+RtyF7SzCsIJ6hYEHpwYnE8J0thDtJ8fGPltA5YF5LVbxk2KEsiwwm06H9UKoI7W8prM5HuYdvHrJyHvQaALz4AXw9An4Uj1hmrTbD60p6MKWZJ9eQzDEBTEXiSJYMYMYDZbIRnzFCj/c/NmFEiOAkzOYF14CTy+Atz4zkEcj7hb655m2EAviLnqow0fWEXetMnfSBnHX7Wt3y5A58paAyhJV5fH4CXA+l3d1Xsny4XnT2CcCziaM0gKnY8KoAKyxqBww8x4zJ437Uo14MQLBWIl0KUoYErFniKLhyXMF7xnGz1X0zVBEQ2HgtEL6EuvE11ajPprQ/qoRfc7pnLS19Cmu5gCcjugIHdxBDZbjEjwqQLaUPvK2AEDqffHq9ZuBfS0ePxWAfiaDvvgwUERXAAYvILMODtX0/Wv2S93GnhFHQLQWlki8j+MSZCdgo33ByAC2QPHMcyhGBfzFDI/eOsdnfdY9vPzqHOcPHepK+PH8QsX2RNo4JycFJiPg3pnF6ZhwMjGYzhiXFeFi1rR5GnEnbZJ0W1w3YtAeq9gbl2IEL8Nk1Syib+4ZVS1tHdsRfFYHwglev27bJl03BJyUBGsNitEJnPeY11PUahQoNUql0KXTOW1tXQGoYVwto6CPz4DTUrqpuBo0uwBXU8CVMg4A0OoGIpl1xV0YAbTobE+8gdUUmDXvBEBAMZbRZE/vAvZFeb9mU2A+lYiTat68I8lgZn1CL9zj1vqgF7Bt6GRDC42N0I98wRsY+Haw7zg15epGtnTEXnd/d4D2aDAewM6ijpm/HcC3A4BaIf99Zv49RPT/AvA7IaN7vR/AD+khP6zr/7Pu///kvgLHAyZC7Rivv1Xh2WcdygKYuabTswvz0IR1fYlnlfydT4GTEfDu56VBW9XaSCv0hXVNoy089aJpCutSPwQOnjyK6SsH2BDppiM1noyAeycG5zOO7eLgQte6NbaLTWcZvQrciLwgqMK2UHnG7UG0dUI+o/dDt/sk/NI4BlBjMjKg0QReLWBx4JY1BEcQPUHnwQAgC+ccqnkF1orF6bLWJRlCXQFzR3j9TeAdzzOef2Dx5qPlbvwUzG2pwyxdwCt9nm+fA0UBnI2BF58hPLqIgz3JJKkADAcxKttdFHm6DJUZEyjUlfqgnswMHANjazCfJ5ZOFQtGRbJJhTYD06oGlwCNJnDhnkfR3q/iuh6oGLbReUZcz8HzKcy956SBhOQNDpEo4VzhIuOz66nyohUwvLTt8Mb4wZi2JywVZl1CSEoLXD6BP38E8/y7wJNTYHoRvX194i712snptxR3SVni+bpMZdri7jYhc+RtAsEzo6oZVaXRAsqFVdVu2J+LYR2lGsJGBTS6xeJ0LIKv8oxZDTg30m4MjQETEC+NrMsyhHIGsTceexEBDBiI4COu4xIACqiXRr01hdX+fCc6AAg4ir84qrWbad8rHXm3Eq8fzWciDV0VuyQAkD5ZVIBOS+3XJxEusa+ftQhzssW+fmF+v+mlhFzW7T5+XfEnk1i3Q9LbIXReBKBP2g6lhx0XuJzVePmVJ5jWhM9+9wQf+eQ8PtE4omcUkR7nAB4+UsP1yGIyBt7xjEU5Bl5/rM9En+usoMTo2Y5MCtV+EHndyKVx0Yi+8H4wM2YVMA0G8WDUtsEA3d7eFYGTEL1iahSWcDYeoSwd5vMac5rHdwAQL54sdT0OQFYBTgeBMRZ2cg9093kYX4Evn4Cr2UIf9WYAt3YI56DYY24P3CIPQ5b1TP7C9qIEjSegO/dBxQh+dgFcPpEJ5ZkR56EDWiOGp+sbhXJq+l1DOZv9fuE83VDObl7rTgPUxSED8f8ogO8nov8UwD8B8F26/bsA/BUi+jCANwF8wwHLkLEJtBPbeGzxxf/CHTycFpg5j/GkwHgsr0o5UoIaGRgD3DkxQlRjwqgUS9TlHHh4Ke3XcRykQ04R+tYBfX2wuJU2WqDS8ExdWkMorMQiO8c4n2q/rdhglzxWeer6wjOHQjNN55hme49nT5eGZF4aSwbGGljDmM9mTV6hU3SoCGO/PNfKC0nsfHsAF0YxKnF69wQVS4jESD10o5MRyoJw/94IJxODe3cLjErC+YzwyhsO5aiInrnoqVvDQweINXpUAOORPNPTMWFUEma1CDwQFjyykYw6Ii4OsBKekfY7AJrGzaRg3BkTLufyDtie59Z6BtG7SyitwWw2i9NyLHhaO/0eF0YsVcR5FdM044lYtUNFzZ1lQHd/QLo+1G5fV+iwb8hnKK9iJH+hAdWdtmEdrCjPuuSTkTnyxoGFeyYjwty3G+qRz7R+C0a48CnWXrogVa4J3RyXwKQE7pzIZ/XwUrYHY6nj4PEhzUPr56oRe5ZCWGcpoZy2hLGEUsP1mB08M5yv4XXAFgCwamGyvgK8RI1Y/bYtCpA1sKaUQTeYQcbCIAitdH7QOo6wSJXkHb2B0It20DpHR5UelUBZaHcD9bYxALBO5l7pyL7a3yqMENgRfIPzrYV5/u6ewRQGo1GJz//ce3jxnXfw8U/OUI4kRB9ouM/qAzTKdUaf62RCOJsQyoJwOWuea4rupm71223PB9v23MnfrG6iVMqCcDYGXrjH+Myj5h0IBsHwnnWNkUED1NHQaXQGBcbYOpyMR/C1RDVF7jNdLhyo20OECjOK0QTm9B7847cAXy9EtCzU/qGPWrjocLOidy5BN0olZOFrYPoEfP5Q8rcj0Mkd0L3npBvEozfE0ww0BtOgHZdEo0jeut5jrGwMvJ2uBaGAgeu6efZ1K+h49Zp5X4f4tGvpX68dsFdRx8x/F8Df1d8fAfAVPWmmAP6tfZ43Yz8IsegzV+DltzxOTkd49lngzh2LO6ci3k4n0m+gsBQH0KiceFcuK+BCjTNlAZydNA37tB9VkYykaAxQJgNnyJI1dFGOJY1LB6QvHTNjXgNV3TTgLbFO+9MRZHGofvRu76Y3iahLG/+k1yDTMqDdlw6yjH+pwPBeRnz0Dr72cPUMFk3YZRBzYTCPIOaCVTUNcWiG608sX67CaDLGi++6D48SJxODu3fHGI8Io7EVi7I3uJwy3rowqGohsXIsgq4r4kI/gUkYOVPXR6UKa7VEeiJUtXS5qB3wZAbwrBHwk/GieO+uN53Jw3rY3wyccu+UMSlF3J1PPQrjdMAdDVtVt2UZ1iHW50lJsNbC+Dnq6TkMc9J/sbtMBq1JtlPnmSCMjGplxEwqx0I0j99cFIJBnHfnFOqyu1oZ02O6I1ZGdPZvJMjGp2LlNAX8m681/Wq6SK2ZQ6ODxaQD5Yz7F7cveOgCbqGHrg+ZI282/GyGojR4cA9wIay801aNBsWF+k4iS6zynNRjwqHzmjApZXTpWQV4bcjHKDMOHm71Jul+xxRD951+W5dxNGldWpZQTmtgDMGWE+mDxR7eM1wI6eQK1rb5J3YP4FqEn37zhg3IFDCjQgbeAFT0BZFVN9PPzC60f5a4LikOulGD4aQuqpEMxqGDe03GMPaO9H0Ook/ncfPzqQz9HgXgvOWtCUtzdgYD4HxuwMUYv/JpAtsJTiYlxhMRdeXIyiiYJxajgnDnxGJUApOJ9O2vPeFixnjziQykMlLDdmOopigAu8J+setB+50w+k6UVjy30j9P+pM/kbFzFvixi1A9d8fgavYTvCdcTGvcmRSo6ipGMoXoo7gMkRTUWdcQQXK19K+sZiju3Id7/GY8cUwTeCOIuThXUYcDDTfc0bX4xmjMtqiKoZFuDn7ypnDf+BTm2ZfAl4/Bj99qQh9D43MHcbfYf7wTfRIM1p3Bwfq7FbSPjUYf05e2QROWuRj50oc8ZFZGBDsHfznD/XslvuzXlBiNZej7oGAqL9/HdC4eGksi3spRMrxvoR6zINBC5950rjId0p4gQweHkS4JXqZb8TqUcE+/NwvAGA+YtlCjlqcNcY60ZlJtjutIlhKn3t7erTtl+gP9yAHEeWKgo3GFUTEhAq49+mUzpLFBI94az9ywiAMgo54Zo9M4SD8CIpLfkM63xckEn/u5JS4qGc1rbgyeXAK2tigMcDKxuDuWUS+tDXH9hHFJGI10wJcmHlXEOhHCXLAyCiXBVYAJISEJORVGuzl0PG1h9Etr0O7orWmtpjPJOvR1MwiOY4d5xWDjMLLNFAelho+UVMuAA9bDGIPSGBHR9RyuqgFf9U5z0LrHnWdi0v1EQkq2gLFW3o26kkFHHr8JdPsVdMWc74i67kTnYf4fYFHMdUNShsRcOkpmqPCLkUycOpoAxQg8v4R/+AYwvVyeR9pJfNVQzwMhKH0TnK8KV1nYnpFxhOB5hbKQ7gXP3V/+rnYb4QTRJWEalzBNl2NgXgMXMyT1YzA2tvOK1UZoyHtKPDamdUxoVAdPz7zWaAs1hFlDsMaI2CsJlk5g4OC8R+0dnHcwaNedwfDVrVNlBOGkDmWGgQUVI9hiJPWnjhDN80sRcJdPxFAWRloM8frJQC7sOnOs1ZX0pyMDjMcwkxOgKKHDKOvgHOrdqyrg3jMAPE7OTnByz+Id90YYlYSzE4uTEyv8VUo7x4Mwr2UwrssaOD+Xgb9i37kxMELjwQv94oyhlkgzRroiBA4M7aS0XRTaS8ZAB9JmVE6e64WMZQJDHKeMkvN0I4agz7FjoO5633TQsfGoQFXPQMlo4d3l2mDIPSeLRoEhFFSWK0ZplBN3BF/gvPgSd8LyOyKK4aTf+PQJ6Nl3ykiu2r+9KU/nmA3EXbeLwaC4C5cTr2dR3A11S9hW3A0hi7qMCHYe9fkFJpMCoxPgdCLfw6RklKWIk+58dEHwhHWkAojFc8GRyQAiHyulQo0XJkwnQJ2JsE2Y0DzoyiC8dFLrUBEllVT0mEhgPaCTZYuQZC1PstTJSOO8MewRAgjSUIQgzAhYCNcbmrculiMpV0tQaFgLyMQwTTISnxo/5zCEsJuD6go8czLvkE5CSi+8F3funOCBZ9yn4F2TO2wMteaggwq1MDddRYCrpVN/SkJFIeRDSKYlCIIsWJmpEe/hfQhlDvPOhcsO7wig89FxnDlQZ4Jg1Aw4pM9dfo9sjZMCKI2MFjextYYYSZ8SA+gIoRV85eBC3wA/F4+orxc9cl1hrROVW2JpMNgRoMOSg7105p5fAmHC4PD8AAk9Qo9Hrm/i8nQ9ijyXiLZu2hUiznvAWBFwxUjnuBkjdCzn2SX4zc/oaJcrRFxA6p0b6B8wdOyyeeuGztMcOyAIMzKOCO78AidljemcUTv5jB2HhrmIgLTu64NfHD4JpZGRewMWBGFX5HUa9ika74uer9MfGj6EfxFqB1Q6EIchr/ONGpTWwI7GMnqj85jXOueeju4bPHLWtMVeFH1JvWv9HHAMK0OByvD6JxPQ6X1poM4vwdVMBnDyLhF5Ku7SYfWdjsJYh3lcZ0B1GdOwc9L/yljQ2aloAj/H+GyCz/+8MdgYzGvAw+C8JunH6IQDRyWhGDdz75YltSOIAkeatrHSJCJc7isAQqs9xGiqvNpLlBFjMWqFqHkXmhEy+595E4XUFnOlivaT0sscw6WB8cB8NoVFLYbxOMJzu9vH0Nx4qTvQjE9AxQju/CHidE7AIo9dJYhEIMrw27KtL7xz36cN3jP0c1+EMQv3ZdDzNtC/vBl0ZbkAz6IuI4KrCvWjc7zz/hPcGdWwJM3sghwMdCLwrvAKE4UH0RY6KMf+S9KUJxYvl/E+Cidp3HMzAbO47aIgBMv2MDEnBYHWFV2pd2wh9kA8ccReChNHkNSaV8sN6datA2w0FVhjXyUVaInpVGvvJsaeQXE/mvKEfIgaz45z4MohTBSL0AehrjTEpIrXBiB6dCj8DvsmZ3jppRHuPIvoWRklE6H2ecJSK3DwPjZX6RsBxgyDINAa0cyi1lXMN8LWoPGKAsErm4hhXTcJgcV7rmGrIR2pcLdB2HsZ4ptcBa486FKErRnyvsX5/pw+eyvkZ6yW0UglSUb+nJP+Ia6WcJ66ajp6p2JryOM24FVby+vWJ9bSvI3VeWoKsUoHIaf58nwqE5M+egjMLlsetFWdwhfS9Rzb53mLZe/LI6ZbFH8rJxvPoi7jiFE9OsdzxWdw/2QGN4YYUML8WyFUTfvbBCt9EHHMwhkOhDCollfrlmxTYYjmu/CddIH++oThKnS9MUTtdQahZgM4oHZiECVilIXFyWSE6bzGPIx8ODB1UOhzRwXHSbTjYBxFGKUz1Nki9owZwZydobjzHGAIPLuAn09l3j2gCYOv6+Xzp6Xb4wAccxhr8dnvHeH+s43HbFRw0mffx2YAB4MjC0+FZ5FGzxvyzbpeezridXqvu/d4YUql5FkEfow8mM6dG9Olxm3NS/eJsZXi4DrwFZz3oPkM1tc4QeNhjQOidKZUWuBRlvkHTWFAtpS+ddNzcPVmPKYblbIwKmbXWJlyYdcY2uXJId6Mc7sCdHoPOLkLfvSGTuPR4dGVxtEBjlwDx2iEzKIuI8LPK1RvPcRdvI2TotLKlGWYW1+reHLRswUGiGv1aAShFcQdQi0p26MwSl3/AanAakQTsW+lCnk0G3zYEUe97LeUhA+Po2UpCJU4MlIQc+ybCib9DU6YNVQCqZUqWaYDbniHFhuHmP/OoBxDXpqW9WvBIsbAW5/BM++a4qRQMQwZnEV0UhBcwRIb5rkJ68HiKtNCBJEFBJJRb2gnHdCI58ZD6hOPXHo/NUwVKsI53D8GufAUtLzBSxpFOkcSj961uC6hkeLlleG6xdMJeXfsCFHM140glDmbVDjXcwSPZ3rvo2Fgk1DJTb1sLAITxgLWyLDG1oqH0CR9SJil/HUl0ynMdKjwuorn6gtlXFe8reNt2zZ0kvvKE5DDLjNuINzFJU4u3wBXcxktkT28sdLwV0+BV1MYK6e5sF3nOWUy8FQI5cVtGhph28IQMC1jZMtACAAcJEA0u0V0OxIEY90wTCMuFATAM2M2n8PViw3Y7jm8ltuwg1eRG6bvcTqMfsP/Yaj7Gt45eK3bLRHM2TMg9vDTJxIlEQsUvBVaV4d+W6YtLJohohlMQGkq3B3LtEOepY4PXTWsGnwNGGQoTv5NJjUypkI2FIXjvm5IZFx2hTQWtwdhKDTYtI+ibTkYVtO2iD5LDnnpJvY+jiIao1W4Xui7v9CPnGUEVKPhOIZKuYh6Lnx5IbxJ3skfsCikV0Wt9BlCu/zYTZN2LQjpyhFocgZMTgEY8MUj8Kc+3syH59bk4FWck85Tt+qYAUNnmlcXg4JwR6GYRV1GhJ/N4R4/wenl6zpkbdNQjY34IGS8kyolCp3gVesRRwjpQ8Net3VGsOoXVh2R1EofDkvWB2NeOq7soXR9H6VXMRn5i5q0vfEvad6p5470GBNqcqnE1dIL7SsnTKP7GbofeoxBQ8wE7zzu2Ue4eypWUg6CSEWSeEmdrKv3LTxXYtc843TUzSAmInk0AjGsR5HXJEg8p3q7UlGeCO820XU8oEhvKUl5yCSjdMn1i73AyUSI3oFcLUSvnk+qdchqJY4WCW0jqEP6rsXQ6/MkqEgr5BkW6iIl0/QBSWPhnWv6f9QVuKqAiwuwTjQq5R4WbVKc9vYW4awSbQHreN2WDNPcW57OcX3HDm0/RstnRkaAe3KO4o3X4M/fhnFz+aat9OliW4IMgcM8adrXi02BGLvOGtNABdiz9HtTIQiweuBYQzlZhRHDIQjDMJBFKphCHRsEYVtZBK9g9PkE+kLKJYhewiFYWhQpAY1QWy38GhHaLm+8Ju/gpxcw8LCn9+G9j4KhOV/Iq1uODrSf8bMnl+CTJFSRPFqRPywDpMW+8kATSYSmS4mSYzx56MrRCDG9D536dEHcDTT+03TrpGnnqdfW6qcv/Gohxk8LL907yOgAN1YupK4QRjHlaa3zFXIj4NK24CpP3CbRLAMiTpQ3yeAr5RhkC9BoIk+jmkmf9tdf1XLK8XvzzKV8t6bxcx3D51Dky8qByAbWh5BFXUYL8zcewr7+SjOyUBAi6kUjFSNSCQJNe5zRVKl6TBRCQlTUqooTkeSbw9DYxppCmaJJR2jHIwQMfRhDlpMVxzX1JveISG4nTEVQTNJTUTBDRjFTQetZhEkMwWOgFmEG9YwGT5JM7lq3zs3MsO/6XJxNPy1WR1e3xBXF/20B1pomoVuZdq8xeM98EHgcBWO4ftZ01LpPet/CMSHPltD3TQ5JutbUAW6uIq0bjtpDNul6Wv7UChg6MgdxHC3fEjwq4iuEZUK3Q7xnQXwDMU/ScGJWbyBcrcJSRJsPYbUqPntJYh1ySbGOYNswRLJv/6ahkuuQ0EKeWdRl3CBUbz8Gv/kpoK5hRqVUWUFwUC3fJkG+DSKp343VBq/wIpMKP5B45InAhXpGipEKxAJE1AhCXTIJF8ZBFVDBgzRsUIWfUoknSqiJ4YOA7AjDAEYaQtoRYtRHussR+KDpisGd5fJvncJEtMZAOse5pv5eGElR70s4tpURUNRvgrkJCTWcjCa90De+LcwarxupcZI7RkokYZbaruGkPURJnrFMgZ17Sjzg5WvfHFpsuxBAoY0GvX8sbQ1ytXCB03c0RHr0eNcIiWAL9yAVcOsM/gWsaSQFYAuwNaCilOdYlMLDzOBqBlQz+PPHwNufSSa/7QikdDCuTfqNp+vrdEHo6S++9Bzr8OmGPJpHv8zYCPPX38Ts539WPqhQATgfBUYIe2BteLNLPtC0cd4KUZRt8SVOK6NUDIV0Lmn4L6TdD6678bgybntJ+dKPnB7NcP+FF8BP3kYU3y6EfHJ8bi0vE5CIk7Au/2LF2PJAklrOkvXUmyaF6hwTM02EBbUWPXbVxfKpEYHDttB/haGhN0GUkfTHgHo6W7dPV2yp76x6m2sX7w17ndg29Pn0XuZGYiUx79ujS64QS0Mesbi/r99bTLtCiA2co/VODbw/61r/WqGTa55/afpBa2QWcRk3B1zXePJLH4b71CtACGHT0aJoNAKMhZmMZHj/0UhC2UrZTqWsU1nKbwBkTTToMTtpzKZT1kSBqOuFDMPfDD9cNKM/Whlki4tS6sboQRRBSOpBDEPPcxzkAVGEBM+htLeTAa7IqHBUMRGqZ+r3tsnFqXCJ/bPaYiAO0gEPIquBKhZUjkFkwNUU/tEbMeqCfJ2Exg+E/vW0MfjiEd5RvQmupiKUKAxExmoE7RrNElHX4s/QHtGlD547NEbZcDy320WhWRTmlkVz52XR4pOkHdUql28d1t7fnLuJsErFU8fY2eWxhe1dIZasr0jDgBgyYpSKeKmZjHQvsLpPBSK7Cqjm4Nl5nKoiiLfBaXsGvG5yzIBYGzo2bl481yrR1hzbEX/dsiw5Znh9vXZAF1nUZbQw/cSrmD86R/XKx+SFDB4LdYdHaIN6QZwMNOw3wlLBs+LFHty95DjuXNu64rGTjvvOsSqrTYVq9/5evA732iugOw/AHCzG+ll3bz0nJBQsXdReR3c9/uaeijUlqB7LYdp/rJunbEgWaUWarLtGeLUEWQi38On+JN0SC1nEkFgZ8O72VqpbCrDmXLvkubh9I6G1afoV7+qm5152TEbGseL8Qx/C6LM+TxqkdQ3PTgygtXhCrnOOUQAAd9NJREFU6LIC17V4b5xrhphXIWYKG+fQCg1cM1ZBOJ5E4QdTwJRlIgjHMlgSIKJOIyGo9jKwFs3A3msEjVNvTjKkShCfVvu2qbhDUUTxx7ZsCUBo+VhDyNmE4Y9tpz0QRF/DCZFSTOBXCwLpYSGaB2IoDoOEzS+b0XpZglJbXqRlHqT0pOl2dwHz5ssgW8hz8irI4jgBXYGjeQ9FJgzwXO++0NUBHQxFEK3THlhVZ/aVr8cL1corPSbtt6ndBjhM7QMjqsEY7W5gmrRBDIeuBd7JwGN1Dcxn8DoQGao6aRv0e9eaoi+KNjmuR8ytyGNdQ2tfFM3COeL65t63tY20W0axZFGX0UL96AkuP/0GzP0XxQuXWKeY0fHMJU3xwYb7FaKvf5vC2IHwkYVDBvLo5N1/qtXH0pIyrsbivaXRGNNf+UgTAoH1LTpXPdLgPgfD2EQMrD2a1Yo81yn/qjTLyr3tsUuP21KIDeYbiT7px6N9NIToTROqCtJ1K9vCvtAgJBMbuml5Zh/+xaVlzsi4Tjz5xKeAT3wKpixARQEzkulE7MkYsCXsuAQVE5ix9AXCSJpZxloZ8Mh7QIWgcSwCcHYp3gnyIgSDAFPx110nKw1qGo1A5Ug8XONxIwCNke1mpJ48FXGMxuvnAbADnEwSTtSJumAv3j80vBWEIMe5bDTskWRYLQrfdlGoJ5DaA2QxL4TrRUbsiqk+kbVMvLWOaTeuzflDyaPbr6sn7UIeAeuIuiHx1MojCKYgntAWUmkIZ7oOTUe26fEStiH9TZ3oFtLnbuQ5Jum5ex9Cd4Lw29UaqeXBXkI2fa2iTCNYUHe7hazpXUvvaTx2tShK80r3bxId08rzgF0Q1spzTfGWPXUZW+PRB38JAODdei/RMSBMCHoIdCeB3G/em/dVSGHv3MXoX/oSuLff2NzrkZ56WeO/tW+5N5KXpeWelXXO2xseY5K+eJ38uucZOkdKRFDv3h5f+W7/CUGwbDbbY2Wtc0BQHIY0IWANOZWfbfKntJFAcjyHBgGFKTdIB26R3zKdA2k/whDWCqCv70zr+Wr4TfSUBsL3YpFllkar01Dt0IDVtL6SgWzivuypy7hhuHx7CgCwZZiQOAie9nqzX5amkBBJMx6hOBHBZydjoChFIJaNEPSFBVhHNK5rOJ+IQFeDEELUHjf2lVTwQTyC6TqlYaLWyiiCUQSqd7DUOd7sKBpp5CBKwkC9zO/qPQAdqCrdz5zUNVisU9b1Ui30ZfeLAqx77JDn5/zxYvpl4iMKobTuDAOa6TMN9SYTONTnmobSurt7bUE0MYu3Nw3r9KkADuXXYxOPZTSpc3sZ84p/Polu0fo2DRWNxVsuiPqe2cqQxE0E0DV2ZzhEN4a+ttjW4m1DR0kWdRkLePvjDw+WNw15zHbEIUTdIcTcuuWkda/n9Sdwlxew9x6g3fruy3TwbJ3VxLNo2uRES9Iu9XoSDd/PYAXu9uPr/qREgMTtnWO7nlAivZeUHNNNt44Xtlvmofd44BnEirktVDndF7alk6Z6VhLvkLz25+CU/JN8OCF10bVtaznHxoNvrJzJaF/bYBdPbJ7SIOOm4Mlr5wCaOjrU6d36LXBdd7+xFI8Ngm9QIJYFqChRnI7bXsHJGFSWMGUJO9H+eURg50C1Gli8hL4RO/WmyPao00J5isYLuOARDOUpChGkI/UKpt5AW2i4qNV+fRZkualyqTNBdTA6dfvg9w3+sRAWGH7HGd5UTDHEWJWOJE2xbuQwtRAZ4TDbeK+SkzWLKIZECHEIcQ11pPdgHWmZg/cx7GPf9GsPOQ/Vb6uEUE+alXkuqcN3iSSRsiwev1F3hVZeOwifPdynK+tPDvQKs43zUMOLr6r+/Yos6jIWUE/d6kRbY/281xY2W+DYROA6YneozJdvPAHeeLLxOXe5Bztd6w7eyXXPu8m1Xde13BRcRb+3LOoybgqqxzrwR6GCp2zXH2F74Lo+8det7/uEX+vYGIbZTkfGtAWhtTAjEYB2okJwPAIVE9gTEYKI/fJksArvavH+sYPzOs9ZVQN1LQOLeNcIv3DerjcwLFUkUWGbepWkHx7ZZoqX6O0CNYO+hPDPTp0atV4UYIkYBKLhquXtCn3A2Ul+xThJG7xk9UBjez0BFtNv4dkZEl6b9JPetE/4UP7tPFfX9bsKw00E2apzbtNfexOhtvJ+DXjR1srL6qAxRSFh2sZG4wkVJaiQZbxfYQqkt99YWqQs6jIWEEjrUGhI7/DoEm7APq5wH9cRhWu1ujLdVIRtI1a2FXq7CPBNhNE+Rd2m96e/nJu9SYcM5b2JyGIu46bBXWrfoFD/69zYgWtCjdDlh5SLoiDs1FMLoi16+1xreyr6umGfxl6281jmDbQWdjICFSMJC52MdHTOE9BpATsey8iFsd5iEX1OBsFwLIPFoBJvIBFksBhDidDrD09FZz0IQnQ9nj317sb1KF2uTrNmlMIhhdc6g3GtdcyyMrXKsWb9uxext/pcKwXhDoNubSPQBvMkakb4tFb7uOrSWhgdiVb6jReapmgFBXElxhSuax1QpoKfzcD1uWyfzXUE+hx+mbEjAmntEynBuerqGnJUH64RPdSc30XsDYnQvvM156m7SZefYwthsU3Y7PoCcVgYrSrr0DnSHNcVnKvFZZPrruLskH1AUxy7iMyiLuOmgdUA5zQKilQsoe6EjnV5IBF/q4TfKm9fTJ94/VZ5+xbFX9h+oee0vZ5A2RfCQcWDUJxOQEUJMyrjxNB0ol7B0KA1FMO+ZdRJF0czZudA2g+XoOuQsMau6IvX2uoW0Nm3qp47RETFgb1ag4LrCgb0atKt3xbcZ55r88IywRNG7mSW96VUkRX6iurAXRwG+InbbGdpFnuzhJG4vQM7eY9ZR/zkqgamKsic9IX1Vd0azK7/mnd/rkAWdRk94DW8RpvCLQ8D7kUky11Q76/RuK5Y20a0RjG3RnlDOcJ5/IpjthGZC0JoC0+i3+KZA5sJkV3CVhfPu39vacy7e2820+GSxzWFeh67MMzIuEp061szMIl2l/P6xF9X+AUj5DrevrCfbPv8Q96+of3LvX6dfndmrtsftc/RFX+m6d9mx6X0x4ujhY61X14BKk5EKIYwtO5UCd6JMHQeDA9Kp7LRQZrCQE3wHoT2AE5xSoGeOuwq6rVNjVb7mP5lHx6xbfJsBooBkA7AFfrl6+ibre3MaAagMU0f/jDgDFF7kJpkULBmlOVOWZNJzpt3IfQjl3cnbGcNP4aftwbvkpHfRbAF4bbefdqfYN12oMIs6jIWsI6nbplHaW+oDxsGuimGPWV7wIrokFTgHqIc+3ie+7of25Rlk3NvGiq6jZDbtzBdB/v2/mUxl5GxCO4Y7YaMeAv1WA+fLYi3AR4YMnD21XvDffxW799l8Jf0eNk35Blc5TlM9hsDU0r4mikKEYJhihTdBmNhSgsypc7xZ5opH4xtnaspHLSBHwaVCoIwDHaig0gxi7AIA0wlg0+l0z3JPsTfEWHahnhbugOBdN8dFS5xlZqlSTNKBx5rhI5cV+e4ZLTkMHIyJdtboymbcP70uDURBuVyvhmYKwiqeP98MrgMN/fZu8b7pYN3NQN9cVucdfIevpfrYZdR3g/hydz1uCzqMrZCl9iOBVciNhWrPGS7oEvEy7yngxbhTTBwLZuIpVUeyrWfzZL7OlSeZedebFyt99yiR3SDSj82ajY4xuwYghjI3e1gA+kVlgec0uSqwk8zMq4LyziyWyetjLZYwxu4bhhot0tCn1dwMQxUt2/gFdw0HHQwz550Q2liORf65fWsq7fI6OTrcYRm/W0K23iKgKYPoLWqgRqvVDwekEFh0vIQgbednzYKx7DarIuG1OfhekZD1uPZOxUG3ExnwH3THwTBhETYbjCQzBbY57RZ+xrQ67pGcd7Xfc2iLuNW4ZjE5i4CcxPBuIkA3Lgc2I8XCUBsbOzi0euKt7Xu8ZaCdSOhuOJcy865rmgc9DCucfwqEcV+c0W4iydvFwGakXHTsYqnNhV9wGrhNyT6uuH8ANYOA13c3+4DCCwb/KVfeA2Jv7403e2rxJ1peRK7eazXT29ZvbdtnXgsoyhfxUjHzbkO01bbZ777zetqRGcWdRkZB8IuAnMTQbgPj+GQwNmnQAyNir16OHcQilsJxM55A3bpb7mrB3Odc+8sHHsz3cDwkD1zGRlrY1PRB+zu7WtFeOzR29fdt8rbF48fCPVMtzVpr07U9dVlq8TcVQ7Cday4rkGxDilUD3lNuU9dRsYtwlV5HAPxHjKUNGJFH8ndPHjrpx0MT93hHiyMdLcJOv1oNvXwLrur++z3uYvneZVj7iqnOcnIuOnYhh9WGrGW1M9DI3l20Ve3Dn3b++j7F/cNeO6a9P2DxfSlHTJADRm8Nply4eqm2sm4ClylZ3Nd7CzqiOi9AL4XwIuQaNzvZObvIKJnAfxVAJ8D4FcA/C5mfotkXNrvAPC1AC4AfBMz//Su5cjIyNgc24rHQ/Rd3EVYbiIKdvE+DgnCfZZ9H4L+EGL9kE2H46PG/SFzZMYxYp99/gL6vIG9nkBgIcoiiM6hkaC5xwvYty9Fdx7YIKp8tSS8ckgAdvuux+P9YtqBcgyNeryOMBsWe8trz6uOkrguT+Ntnx5nXc/dPjx1NYB/j5l/mojuAvjHRPRjAL4JwN9h5j9JRN8G4NsA/FEAXwPgffr3lQD+gi4zMjJuCLYRHoccxGYb8bKNd2hbQbhs8JpdhVffdexTGAbsVSAeQMgeMTJHZtwobBP+CSyvI4bCPxf6bS/p87eO4FtWzr50Q9P3pAKwlb5vegQVgt2IkdWCMGC1MFw853rpUiF5CK/ewrUccICt24RDidCdRR0zvwrgVf39mIh+EcC7AXwdgN+iyb4HwN+FENbXAfhelpkVf5yIHhDRS5pPRkbGLcW6DferGsF0U5GyS4jgNmJw3VFMDyVodxVay57jlYT7HgkyR2bcNuyzz9+Q2IvHYbivX98gL63zryH+huqpld6/tBwDDXR2K/ra9Yw6HIThSnEXPKAbeMaM3V+9G+4D3+YwixuIvfapI6LPAfClAP4RgBcTEnoNEnoCCJl9IjnsZd3WIiwi+gCADwDAC7nrX0bGU4O+BsNVTlUxhKVW6AP0CVtXCG4zhcVVeDaPzZt7DMgcmfE0YB+hnaG+WVYPDo7OPDCA1kKIZ5K2e951hSKwmQBsnWvZZOMrBGFzjvXrf/bb1a+9wnGPHrk8kNb+sDcmIKI7AH4QwB9h5keUzMvBzExEG70BzPydAL4TAN5Hk6fHrJuR8ZThNjTk/Q6jcO6KdcTfVnMXdrCtd22z/o63t6rPHJmRsf433ivAuhgY3KURZgPHXQ7Xid0cV08MT4MDQa1b963DgcN5tc++yQjG24ipffWZS8XoJgOd7YrbLiD3IuqIqISQ1fcx81/XzZ8KISNE9BKAT+v2VwC8Nzn8PbotIyPjFuA2iLQ+3KQRGvch4vYFX/ONuneHQObIjIztkIrAdblllfdP8l1uDFt3Cp5lNe1awhRYa2qeTfOK5VuWZ8fbtpYgHPDQbSqWls2NesjBVobmSN3E43nM2MfolwTguwD8IjP/mWTXDwN4P4A/qcsfSrZ/KxF9P6Tz98PcVyAj47hwG4XZTRcWxyTU1sFNv9/7QubIjIz9oOvl25Sn+gTatnO0bjLv6ro191oB9xtGhbQGmFkz74BN6vAgEDea63QwM73GK/CqBQHJ7nZ0DtyHp+43Avi9AH6OiH5Gt/2HEKL6ASL6/QA+BuB36b4fgQzV/GHIcM3fvIcyZGRkdHAbhNlNFwY3TYj14aY/gyNA5siMjAOA1/VeLcE6Xr3+cy+KgG2nvGn6D64WiJtOV2MK2jisfZcpcfbBeHEKiAOMpNkVitc9FcK+vZL7GP3yHwIYKtVv7UnPAL5l1/NmZNwE3BRhdewN95smjo79fu6Cm/JOHwsyR2ZkLOJY6pF91tVdobePEYx3nf5lK//TDn3EV05yv8H5u9jHs+qGnAbsxcO4DfbslcxDZmVkrIljIaEujkVAHKvwOpb7symO9X3LyMjIAI6vjrqOun7fvHdMfLWPAcB2DZntK08X+7hnvMQreBWCb19eySzqMp4qHAsJHUPFfd0i7BjuQR+O5R05BI71nmdkZFwPjqW+u+q66Sr575DXdojnd4jyHst7tg26gu/avHprIIu6jBuH664cboM1cAjH0Oi/7ue7DMdwf24ijvmZZmTcBlznN3ZV9eJtEWIBV/HMDn0dt+EaVuGYRVwXWdRtidxIuXoc1tq1f7I4VHlveyV6k7+t6yafjIxjwE3+hm8SDscx++PDm+b1uS1irg/Hyk83STT14Zjmvsui7inAsX7Iu+JYiWefFfZNC9tYB7fpfbzpZJSRcRtxm+qYdbEPPjxGHrxpohA4jvfvJnLTMYmjm4os6rbEMXy0m+K6+1Dtin3c831U5sdIfCmu8t28icTRRSaSjIz94rr58aZz3brY5T5fNxfeGOPnNfHDbeelQ04w/jQji7otYU/sVnN49OG6CfC6cEyV+nUTXBeHJJJjJ4tc2d8OXPf8PxnXB3tir7sI146bGAmxbZn3YnDdIy9dJcfdZL4i+3QYP54mZFG3JeyJAe1J1G2Cp0EAbkMsO4u6HUjgEARy1USRK/eMbcGufyakm9zYydgN9iTXJzdN1G3Dgfvgvn3WE9fFY8duKM04PhxiYnUgi7qtMXl+vPWxQ42gfeA2N853qTj3SRzXUYHfhjDH68CyuWduCg5V+e+K6Imz2SuT0cbpi5Ol+4/1nd4Gx9ag34Xr9nUtV81XZG5vu+cqwP5wbdKrwLHzfF99Zw9k9MyibktM7o9Xhhfd9A/l2HGIijx7F24G1g3toyvi+kN+63bNBtKVE5uW6zY10DP2g8l9MXqu+27kUN394aYbMJfhGPj5Nryr3e+SzNUb5vZ5Hzfh+etol1tLV8bPWdRtibN3vwAQgb0H1w5gLy8pe4AZYAbr0juO23bFbahQjhnHQBopbsrzvuqK8iruyyZiZVtSPDSxXcVzyTbyjC4mz5zB3r0Hrp28g96D2QOeAbBsR4cXOxx5nXXfbTJUHJswO3Zc57O/qneezOF4Ye1r2OK93MezGeLqw9/7q2kjZVG3BezZKe7/2i9C/fZbgDHiMSIDZlbvEQGG5CUhAyJA/wHJe7xVe2vZQUqI3Fkf+s0tQo07m33d47p5LduX5oHuOdJ0rGK4lcli+dLjerb1nos5WefksLQRgU6azn0KeWh+nPxGbJRgsIFylQ2TQzTg1y//6qb9Pslyn/d16L5tEx6xcbmWENshCOww72OOSMho48EXf5EYPasaMAbMYjBjVg5UXpTqkoQfCaDEMrFpfcZ9fLSQqPMjcqGuxq4R7e3NSsoP6XZ09q3Hxez9Sh5t8urw6ALn8cL1NTyu//q4O82fMZgv9x2/IMQ9Wpye8Cez3lufcOeesM96rdvkvwqu2SyP3cvj3f6Efrc820THrHtf1uHkre9PDxfvs80SuPjQbcIs6rbA6ee9F2cPRuDxmVggqwqA04flFl9QHypY36n3ex5u59ihF2DpR0C0mHcQleEclGyn9svMnoH48TT7mmQUF6GeRs++5gc15Q2Z6JffOrPuY9/Z0RHEkheBaPFczH1lIV1oKyK9F6T/0nsQ0qTbkjIwA5Q0RFrH63GEjk4dwMLzDSQYLNpBHLrgAfaaRNf1vrL3YOeSNJyQp1druf52Yb9Hy8OcvFPrh02tT1KbVGbrpt2mglws83Iv2zbn2IYMuucxa9bOuzQUjqWBcFM80hmrQUWBe1/0BfCvf1K40XvA1QASzvOVrIfnzs073PTVDOv9fBrT8+L7v/x9otb5ZJNyzwLt9XCM9wucmeYRK/6FJG0+AiD2kLQV3M13gZvTzVrmJZwn+zt8GfeH47m9Lc2rtS85Nr3WlPsGeJU6/NicJznHCnAiBqPBNxpPHRojKifcyA0XKvfJ8U1EFbwXwRrS1L7Z79u/FwXsOmVejXX4YmMjxxrn3rTe3Q/f9mE3wbMPvu3DEAdfN+cuQxZ1W2D0/LMY/6ovhL+8aCzhRFKxAAnphAa5k98hDDNWTE4qRa0spGJJKo7Y4O5UVIl1LFjGZDcDoQxRQHKTR8e7hHD+jvzoe+lWvsSr+hcu2c3p/QKaNvYqgRtuUzLwzKC1dm2xvN6189I8hu/V4Ae9QKydv1RoEoFIrN/QfoVERsJsyABULIhMsYyTpI/EagBDyfakcbGgNZt3j72Td9oHsZj8jgLSJ6FXSQiWHgf2eyWyTQhsVajkJpbHTb18S8vZsRSuS1Tp9WxKGOHatiGpcK5twrsW+3TkELHbgtELz6J4x4vgZ58FqkrrqCDmwlLfNw51StptITVYdTkxSRs5scOnYCBwAgfjmP5m12xv5YX20mteiXduXW4JGK7r0/SbedLb3ym3eLdP3Mp2jskBrMWFQ/XBwj1Y89q34cvBexGN1spjhqKRlaOoNLLbGNmn0VMyMqhyZOQ81vS0wJFkjHqXKUZkLd6T4IHsGksTvvMJL+p+eA9f1619cE7ycz3OgU40zHUIxm2E4ibhjkNcu6p8Kd9uG/65mTDcpdPBdoJw3evKom5DmFGJ4v4d8DPPgybn+iFW8iHWtRKCLmsHwIOMiqhCLXxeKwmtLOC1wY5QUTU/m8a1VDgsbiLdnnqT2qKAo0cqHi3Htc6HVpqAfu9Rd9MQGfr2Nu8BNAJTHEepxStY3aBE2ohPsao5wCvRuzoRBtyQYxC/rWvYzLrbOn4F6XXzXofs1xWR/ZVXaoHEIDmvPFffc1w3jyAEjRFBCcTfMPJHkP2mKJUYrYzGGo4hIxV8CFnuwNcV4LwYR5xrLbkWIcmuljSuFrGo/VmXVcjhGlcJh0b0DafbhbAkfX/Z+tAVhmtV6lsPXrINSV2tEMy4GSgf3IV7/l3A5ROgFk8d+bqpw9mDAleG+ixEEoBA8V20WPTkUOKl4mQ/gVIO7HJq2J5yLCjWpRy3q2cpnLKbR4IFETUkeFohikGIcSMAkmM5jdRIQhcjd3LCkexFvPpaBUQjFsBe2x+8WO8P8VuftzSuH45Ph86xeSRTIsCDKI9NhPW8uTyQdlm5WwbZwIdAFIdBDFLgvaIAQ7Zbo5xIBrCh607Y1jmNSwykLhhWA0+qQNTtkTudg3H1SlHEfnl9HPhknX7bQ/y5yJ1rtD1j2vWNH5twbIrAt4fi2aZ9sRnXrtt+CciibkPYs1OU9+9i9uAlcPkIAMNoKAkxg4hA7OUjjnGEQjDU9UhpZUCxIveNsFnwzMmSuFnn1v6Qh9N0DAQPIffklaL7sS3sb4cdtNIEUeiT30Qx5CNuCy8kA2S1wgoCNaQLYS2hcgSSZZ+HKoSP+KZ9yYHYXMszxCoIA+lxqOjqWsmxM9hNgkGCu0qhuDeB2E63FYGxkzvvXG8+8S3f1JNpDKAER8YCVpZkLagogPFY3h3dBmtBthBranp+V4PrWpZVrULQyba60mUNP69ap1/HStitWIdJaN1063vZNvGqbSrRNpFn25DTpsSUcXNRPvcMZnffibq8ANUzAID1cwAEo3U8sZMlgiBTTiFq6t/Ij1LPUDBsab3DCRc2SyBGoGhdxYEPw7Fp6F7kx8ANKrjCxQShlKJlsOzZHtdTjuwYU9mrV0gFpu6TOxG8R0k4Y8doK7tJwkWDcZgglUTkRzQCN80jRFykRlLWpQqFGHaYGs+C5zS59iGeatVlA7x47YbXlXmsz19dcRmE1+IpE+5tF3D1eYiEH0HCfcFAqpxoTybyO+yPXFm0r589OArAWkTgvNLfwo2oGw4F+iNPVk1psxiNsZhmlSDclV8l7aahneuz4SY8u6kJdFsRmEXdhjDjEcpn7uN88g44cwdEBgVqAAQbyCeSkBKIr3W9jsKMmZN1saYR6mRUIn2g+p/Q+UA6awROhBKJpVFFEzFaFseFzzN+8KlY6YrBjmeO2+TIHdKkKEpDSGo4PiHWjrhtyqPlcE7O07FmRkGZWhgD0XvfhFWEkENrpPFPIazCgENIolrGOIRdpF+eV9KrA7HVSnhCfl7FAup5v+jqsXyuS2QLFdASUbeJIOzNe508VxBcOj9irIxCXb9AWKGS7avmQuOiAqpUIG7gUQxiz1owqSgsS2AyEXFoRCSSLZJ8EtE3r2RZhb85uK4A5pVENVRO2sQKuBLrVPLrUcgmnrPGWrueMEuvdV1iytPA3HyUz97HefEsLoq7sGUFIkIBL21NBI4UgWB8Lazk68iDRoWY8UGQhe4LeqwVg2EItgt8ELgS7JUPU9HYXraa1EQi+ogCRaoIDND8I02quEl4MnadgArIlqE1pHfqdEuMs6lRtiVQA0cqeup0BtSIG7xSmiaIiSQssJ0Hq9FZRaVRLiys3EMTIjFUICRRGC0wwK5KOLKJoEBdR28RXNUOJxziqz16EJcKws65duXT/jxWlHONdIFTe72Rzku7A21xyAPnauVhpD0EqwbUQrjSjCaALVoc2SI4V4OrCr5Sw6jyYuTIqm0kXSvSRAXhkMdrXUMmhYEJ94LVXLWpkZI9rx2dsinPdpFF3YagUYni/l28/OR5TCshqsIwvGcYYngGDIlosySDWlgSq2RBDBjAEmsouFjrwtKShyElKmUQE8WdEEcgw0AmxF5J0et+SWfSyh7By6d5ckqsDYER2pU/xXMDSbT6wj5oCAwFMky8b02kDDfr6tEM2yJCeYKIdBKyQ3WlokqWVFcAWERzSB9+hwpYLUwLVtV4DOt9EesupX0wgkAES+VmRChgJNaxIAhj6ASCBU0JJYhA56RPiVex4CqgqmMIklxyP2H0EV0fyaXbtyK4NS2ehyC2dSyhK0NeBvIGi7Ux3oOwuS8toF5CITQqSlme3BUxaApQWSKMzCdENoefzeBnU/B8Jn9VhUAIqwhmnXDR4f3Ljg2EsF6/wU36MGzcTzAhsW36B2bcTJT37+KTj+7i0w+Bwso3Zw3DeV0yEm4Ur1hhPArjoTY4XQrnWCPvTnfdUJu3TAy/YxC82jSDwbSp3xkMo7wZ+9iFPCInBqHIrd+SJuEajcwhkHI26bmoidzR9aAYhUtDVE/ClxGNkTYKyQ5HR8Owq6KQIidCiuq5CNso7vTYaGCtm/IDSbrGcEst/lTDqkNipE343xhQGfpyj4UzQ59tKwZTMjaphH00osHVGqLrwNVcjaSVpmkbb1s81uHCTXg0pt9nRM4RROJsxqe+6Xdaz/S70DRD51BuBFmYsgROJqDiDqgcyfYg+r1XoTcDz5UnlSOHrrM7IMlQf8Jl3LeKY9bl1XW6X+zS7WKT/oHL8hxCFnUbwp5OYO+c4e0njLcvLObaD5wZKEqGJWBcMowBRoUYwUorgqfWvnVR/EGWBK/RFx5GyQiBlLRWt2FpvARomEb8EUQQBiIENIpN90XyC5EegRhIhGH4oBuBqJbRYGFkn4jGRkQCWCC8XqHI0PNACRBAQpZdD1wgSwMC2RJkSrUWsn4deiHBi1dVMUwE9Uytg/NWORasl4PrTWUfw2VdjSCM4dyCp5C5p/K3jdijcgyanGjIhFjIOPSZqCpwPQfXc6CupOKrq6bcCWnRgMCK29cUfdGD5jlaynqvAQD5gQrGtr1tMp1HyLdtxRqqCIdIioxdEB2LFWEn7xAC0r03ZvHYwXAMXwPzGn56gT7EcxWlENloBDMag+7ck9/lSNLVFdzFBXh2CT+dws8uRWAm6NNSjYWuX2mtsg6y5536M7SucYlnbZs+FENWyts0H1iGoLhzhscXFT71aUYNi1kFlCMJmy9LgjXAuCx0KSKuLIDCNuItcF+IyPdejKBeiCoRbMKFgBpLIRwZDadGOVB5swjdnQKf2iAQg31R38eWUVXraoQpbYQvDTeet8CTzAwiTkI+ExGYcGRjFFWjYtzX4cKF7WjWycCSGqDISJ1CBAuvUSfC36z9GsWrFiJLXCPyEi6M28L5O8KwFXmTpGu6evhmsI+EPznNg73wIoxwobWg0Rh0cqcJK9QpohqxVwHzefzN1bz1ztEAF3e7ksT6zfuVPNpwSmd7J9KEaJFHY9BsPN/yhjqnxm3TL/iG+HTIQLcLn8atKa96D8xnYO/Bl1hAPJaMGEFHY1A5gjk7g33mWeFHK+Ke51O4y0uw8iPPph3uHuKfYUE0eMQOvLo5b67mwlXl6GJTj921iToi+moA3wGJxfpLzPwnr6ssm8CORrCTEd56q8KHXzMYl8CdM4NRAVgycARcOkLlABBJX2WSPsul3m1rGIaAUalLHaywMIyykG2FRhDa+IELgdVB9LlEEPqmoW9IXgwhtfa2aGmk1LIpVlOQfBQNESIMICXbJAMhDFKhGLxtUrooiNrDDbdDacA+EW/LBWHoqxhI0bgagJOwVUD7Zch8R6YoADMG0Zn0wwKEfAMJqGgip/0fu+TkE/Ja8PIV7TQd8USR4LoC0olnrprFtL6b1ljAljC2AMYT4O4DoCjlZjsHrmZANRNhMJ0iFcNNJar+0lj/hnLruYKoHyApSat5ULsS426F4tt59wmkFkEBW5FUl3yG4+JXk9OwQBkiiO4oY51K39fwlxVwed57NBUlMBrDjCconnkWZnIKKgpwXcOdP4a/eAJ3/iQKvVUhkPsgpW3E3rDVsf/+LKZbnVf3mrPIE9xUfgQAczrB7HKOf/ahS9jJGOMSuHenxKgAxmThGDifE6oaABlUtdQZoXoqrNTpIxV8Ix2osLRWjKSBI61WnyY0tsUb6D1QkfymaDgNUTSatmMsjZyor2PKmU1kDSeRNU13OBGMJOVQbqTY3QFxyYkoRPQUBlFXJ8ZcToyi/SIvcKL1dfJbQsSFj3zDmwwQFaDSgpQvSSNLOIg8J9EkVE3lPCFaxXYiYDpevsh1RZcD6/X4k51wsnqLJItEmIV+1rYATU5AZ3cAq14hhvLjHDyfAvOpRvEkdVJH7EV+s3YDHtWXosONvSH1IW2nC8Igj4a8fJNXIwh9LGtanlXG0wZNPb09n4bjkrKu5FMG1FDNfecgEsE3GsOcTGAfPIAZnwAE+IsL+Mtz+Av5a86/mgOH+tntwqvbGknXEYOLaTYTe0O4FlFHRBbAnwfwrwF4GcBPEtEPM/MvXEd5NkJRwI7HKHiOiTF4622PT70ut3E0kQ/l9ERE3unEoCyAkzHhbCRCbe4A7wgXNfD4Uh50oR++NY21MjzfaL0kVkKzSmjiDSxN2A71xLGG+ns4AM4xPDehLgAWxF54lSKR9YhBEwUhxW2yDMeyhqBYJT5dN0EUariJacRk6IvHcdAXtfBprLhVMojkZOr2eiLQWL12jVhTMiJqPCu2FOturaEBs2kUiC2yMm3x04i0jjdooe9ChxwSr19XCLbWfQWuZ8AsyduLNRPFCFSOYCfPAc+PAe/hp+fgy3NQEBVDhBEHqemKqoSkuL+Sj5V/GHI75Bn6fPZZCWPl06mcumEincqLlljfFu1v/WEZi0jDPPpTDImTxQq416/Wmyd7tYzXFdzFk9Z2KkqY0zPYs7so3/EuwBi4R2+jfusN8PSylbZ19hXCJ72OTTueL9u/fqf11SJv3bzyqJg3nB8BFJMJfD3Hs+MpHk4dPv5JJ4YOAJOTEgTgzt0Co5JwdmJRFsDZqcVkJEZQx4TZHDi/IDgPFIW8E8EoWug7El67Uvdbq14/K9ExIgiFJwsLjIzwFLNUZ84DtWdUPmkAJl4/QKpQG3lRzrdMALaPXeTR0HU78KGEnBIMRoChpotbuJnU4Uj2cM6DOAxg4UTMATBG7rH1HZ5M1zkINif8SUbCvcoTmNEpyDwj0nM+A1ezKPKiIHMdj5QZ8OwZ2+PVUy7pev+GODL0ofS18LPnxYgSWwDlCDQ5Bd17BjAFuJ6DLs/BF48bA23gvCRKhbljyOwaGeMz6PBorN/CdFab82gjHFVYKsekPLrgiUO4PbuIvevnU/YMnk3FO/f4YZOWCDQ5gTk5Q/H8O2BOz+Avp3CP34Z7+82lIap9HLiKc66LVzdJ0y1HX1m6uC5P3VcA+DAzfwQAiOj7AXwdgKMnLVLT4VtvPME//TmHF54p8PxzE3z0k5XEGQN4MlGRV8pHV47koYxGBqMSOJsYnIyBOyeEWQW89Yi030FDYFHo6Ytno8jT7SHM0rTXrWlCPkcFozDAWC2dnoHLOcMFAtvAajlEWF3v38L27n7tTxDSiuCTfmuWGKYwKMbi0arm0tANpGWVyIyShTWNxy6kafrZBSulrqcje9kCZnwKuvMMuJqCLx6BnDwzZgbZTt+DYkDEdQitEXuJKGyFcGIhrHKp2APAbg52c8TwBzKg0QTmwbPA8y+BH78Ffvy2nr5jjTRBgIcse8Redyjj8PyGKpxO+nAu1pCa1jXsQk4bhpwsn9NntfVR8lqH0Pqte6uIhAyJh+/JQ/gnD2W7MbB37mH0rveCrMXsE78Cnl6utA4uI6NVBLAJGW0aerJuGdYpx1OOG8uPAABrUF9e4md/5pOoixO8+50TTKsCr36mwvh0DAB49FBClUcT4cxyVGA0srAWuHNmcTIi3L9jQBZ4eEl4ctmIt0JjKANXRm5MxF0j/JptIS2RcKKEfTLKAtBiwHnG40vESip46eTYRcGXbo+cF7i5s55yaJcnl/GqIcAYqwJTrt8YxqyqQb6CNSPNQ4VeR9Qt8GbgNSvHuSD+6kp4k0j6i589ABHBT8/hlYupCNEpbeNp7Iduk/1DIZy2K/a6xtOQrsMnrX6CCV9WM/D8UkICPYshdDyBeednySjHb386evDiOVPuS7sjdPOWh9Bej+XqyStgBY92xV4fjy6EVQ552fZoNL1qPl3IfzaFn03h335D1ssR7L0HKL/gi8QA+torA3luzs3d466KV9dNs67I6+K6RN27AXwiWX8ZwFemCYjoAwA+AAAvHFnXP4LWJTXw6us17t/zmJTAfOWRwLySYx9fAucz4B0PgMkIuJCRn2PDNliRuv1poyMntM95cbtnWXda0ZwrqZyNGPdPCW9fMGrXNK7jKMshL93gYwhIYzr0MfwjeHv0mOZHa3vY0B5mpdnFDDCxhJNq590KHqNRCVuUqOsaHAaoCPckrEevIcVt6JBjtOyFtETiEazn4NkFzGgCOr0HnIvFCM41+cYaznVulJY/fFyuW5t10qVpF7xZi8MeLwV7YHoOnp5Lf5LnX5KRxi6fNAN5BG+aN80xPSCihgC6lTj1HxsqlIVKjcxCB/LuNe93BMjlSM81VObFgzofwop829sH7stgegLAcI/ehnv0NmhygsnnfQGmv/TBOIz0ujBL5sxZde3Lnsm+nld3yolNy/EUYiU/AkfMkcaACfCe8fCxQ+2m+NVf8ACvfqZaSJo+b88MXwPnl4zzS8ajC+DBHcI7njF4ctlOBzRVVhhYILa5McyPoVfATD8xWwdhKJ69Z+8Q7p8Bb58rf6RdDJR/QvvdhHKE88bqI4mEaK3r/vgPa/Gq4+bbrokxqx0K8jg7KTG9rCNfLfAjOudXpLzZFEiOC7zpNdrAw8PeeUa6L2ioaHoORGNul/9NYvwMPNnh0S5/drmoryqIof2hc2QQkQn3+Qp8PgefPxJR8I73wr360YVzrM8LwYumhta+OuoAPLpundjNi+L7EESpGeTgberdffLpKvBsivozr6H+zGso3vkeFC++C/WnPrlRHmuXtwNjacmonNvz6rrYNo8jYoI2mPk7AXwnALyPJsfD9BoyeHY6wntf8nhw1+LJzGLmCWMNv+zz0JWFeOjGJXA6IRRWwkzePgcqJx64oqDEQ6fLDTx0gPTLC2EnhYajjKx8X84Djy5lLjZLfaEmnfXEWtiMxom4LT0m9b4B2veub3/iqVvs6wdYY1BYA2OAal5Jn74Vfe/AvNBPDwvHdNgdBBqdgMoS/vxh0y+ulbbzwS4ZsWpput40m1UwCyACnd4FipH0KwAWRdWqImxR2d6UIedvmjigcoR0kJ6rwk27TxkNjpYjvYchg3e+dBcvjSYwhvDx1xzKcYly3HjmgMZTN5lYnJ0anIwId04tRqV4pJ5cMj75pnjp1vHQAeKdW8ajKT+OCukWURYyKMu0BqbzJr0hbjxxifdO1rv8GfYvD9ck8GJXB711Q/3gQ1SLJcBag0lBqOtaB0PrePkGBjELWOTCBOmon7aUwS10NMp2Hh0OHsgHwDBP7sKfMY+O8Tb1thUlcHpPBr4aGAVzLexSJ+9wbK6bExgZfIUv+wcxy2hwXaLuFQDvTdbfo9uOHuycTFpcFCjGwCtvMsanBe7eB+6eFdKXTvvUnUyMhEMaGTiFQZjXwHkFuJmEiBgLnEoURCQcoBFcYQTN2IfOJuvUjKyZ9suW8EoRn84B53VDPgaALYbFG9Av7obCLU2XULTfgNUhmY0Ro6OMLkbafyD8Nk2ezGDIUMe+ruG8Hw67TAdKgYRnDoZd+sYTRrZo5mLxtYRsvPVWPH9MP9QZvBtmuRB22RMaEn+HZbuzeC8ZIRFP8VwAyjFofCoDqpgCfP4I/tVfWfTsLOS1hNC6I2cGDA0V3T1HSM5+MW03LGQgr02Gd96G6NYd+rnbmFg9yezytMvTM2g0RnH/AeyDZ8GzGS7/+S9s1ejYZXqEZdhXo2KdMuQGTAs3lh8BwM3nYFPi9N4ZXnvb4HLGODmb4OwecHZnhFEJ3L1TYlQCJycyqBVZA+cJs4oxY4PHF40HbjQOYZeyDH3rjCEZUEXmYMaoROxfXtqmj7oxDa8SZEoFZqCWwBDMawDzYBzlOHAZIBy4aXjlUF+7xuCpo1grb4dBV0zCl9IvPRWCwcvo4VyFmboaLdzKsMu4PU770+ZI6VsnvGxG0vfcAGBXw0+fAK5e4NehgcbS0TMXwi6HRp5e1Uc95dDuqNBpWlsAkxFofAKUE8BV8I/fBmY9QoC5qZeGuLh7SIdHW7w1xKPdY+N6/7l6DbMr+GuX6RJW5dWHbfl0E4Q+dubOXdgHz8GcnqF+/VOoX//MdnltgUNPO7QK23LidYm6nwTwPiL6XAhZfQOA331NZdkIXDm4yynu3B3jnS9ZfHYJnIyNjLRlpKM3k4zsdVETPAPjkVjYRjIoXhRm6SheRGI9bObgiWeMo3fJNxIGQpHRveZegiz6rIeWvOTdJZVUgAFxuGeTWCcBSqZRSObVCUsK69C8ujGcnIzuxUActdOD2cOn3rWOB67gtnjr7fANtAZKMewAY+S+xeGSCy1XMp/P5SOZOsAtklBc7xsRExie+26QlBZJaIFA0knTAQnXKErQuJS+AbYEyhJwHn4uQ//yo7fiHH5pnl2r4CAJ9VXyK6ZBiOiWv5tPer4rJJ91xNYuYm7o+LXTGgNzcgoancCc3YGZnMDPZ/CPH2H64V9q3q01zwscjnRW7V+flLKY2xI3lh8BwF9MUU7GeOYFwv0XZdTL0bjQEaEtqprBZDCtgdlURmMcjwijEeGkFL4UPqRmlEsj0x8E4QMgTiUUORGhehJecwxUTkI6+/rDGQgHA8OCzRpWb5hEwRAQR4UOfdILEwYF45hvKtji3HIIZWMg4fMwWjQzAy6MkelRczvCJSwJQKlh+xYO1vUbPxd4E15Hv2SQsTAwOlK0RgnUc+mfNn0i4ZdJXpEfA8d154XtM4QuiLYt+DPdH/qo2xJclDIAmi1Bhbww7CrwbAp//giYvtabR5+YGjas9vPTPnm0W4Y+Hl04R1y/GXy67jmoHAHjiQwmdnoHMFZGin7rDcw//tH+cy0py6aG1oCbKuYCrkXUMXNNRN8K4EchhqvvZuYPXkdZNoWbzuAvZ3j++TGKU6mYJ6VXL5qHIUJpfRzxEQCIFidC9Yw4EhchzJnShDkW8ABp2AV0GGUEkoAOm6yVfRBboEhARJycXwmlM0yyVEBhwnIRNAzECcxJR80kJ6NmhbJzHDY5HXq5UwErhoRbmnYxnFK9gOkkr8Y0SwBhaGaZ0oAAbxEnXtU+c3C1rAMSQw+sJ9Q2IRlgqdet5XHT+XdgC5AZAbYAjw3IFiCdfVNGTpwLqV4+lBGi4mSsi2QiWQ9sX0FSrQpqHbGWnGNZXqsmKl/H+7aKANausHsIZnOv2voeO5hCOumPZUoDGk9gRmP4Wua/48sLzF97ZelolwG7TKa6i2jbJM2qcmyaV57S4GbzIwC4i0s88/wdfLZQBJiAySiZw5WAIkzvk04grnxowjxvQfDodhkFEujO2UphUvIoolLjKAMEFIF/TIcn5eRJ+GNbgEn9wZDD9YICf3YH+gjcwel8r33hj8k8dV0O7EnbStfhWcNOpvoxJH38SAyblPJlUJmu1iE/hSNRzUWMJUJt5dQFmwi1rmduHf60BUBWphwoSsBYsLFi3Iz94aW/H0+n4PlDEaJxlMsBLg5IuXBLHu1u7+PRJs/lAnHhHN380nKtcWzvufry3JZPpUDbH0tGJjEfT2ADP44nYDLg+Qz+8hL+yRNUn3qtZejcNEJm2TGH5NVN0q3m6O08jNfWp46ZfwTAj1zX+beFv7xE/egcz5zNcVrWcJ5R6CiIRiv9IpkrDpSOKsmN2AtCC0mYRvReMVoVXyA46HxvgIgq7uxPj/cMgtPKdU2h1UpHjYUxEpp2sCbSY0hFaIgRIa34SPNOt3MTIqpMGkdpDKqTSQWqjgjFVsrkarB3OsG4l4nFvY8CLpBpKtqoS7ibDKO8hlgDqc3UGBGWQbAZNStbmRBWladehw7Q4mpwVQHTqZCRCjnJeolwWxEq2az2kE3f9fTltYt1cEOyWcc6uGuoxzqWxbWtb3FS1RHIhsnHZcqJMGS7n83gZ1PwfIr60dvg2UwmlF9Shl1IZijPTdOsl8d6JLOJpTGLuH7cVH4EgPrxOc7GNd79HETgMKMwInSEGwmGXOwjJuGHvs2XKW92vVWk3IdgfNTJwOHECEncERAqMFh4IRVc0QM10Ae7LcDa73+gPorcqIKxOzhXSJ9yaNzG8RcocK1cW8gjevjUeBs5BZD5zUgHwmAH9hWonoPZg6qEH/uueWHKAcbiNAQb8meal8TVSlmt1Yed8iSBjG3ugPeRI+FqiUpxtc6hV8vvTURbWp6wewsvW7Pef851+HRjL1tf2bcMnVwmGIfyWtfbtnBsUYAK5UZbCFeW8gdrIVMy6QiXsyn40SP4+TSJWNqRo3tw3cbRddPti1+PdqCUY4WfV6jffohnyieAmUEm1q5lyUIqhiupk1V4yZwyJGEQnFjbVOEY9lqha3oNoE+qbgRRlRJD8NCJaBChQcxRREH7sUUGiWQT1ttkqe68SIBIyJS9a7ZxkldHfMZjQmUW07smbcdbFrx+CGK2SyDeqWDz7eP7rIJ9Ii1dZwCkzYRAjiq+iAxQjmSfCdt0IvPWnCVyPqrFysle/9xMSUkFqKtiWZfG46fbV5EU1hNrvXkdmXVwo3RbhnT0pWnB6lyARSHCTJdUlCLMy1FrpCs/m4KrObiaw1+cwz18C34+W5hIfAjXFTK5SZp1yrJJXpsItxyOefNRv/0Ip+UU5ZmHQSWciBoI0R+QdeFMH7kTzC3DZow+UY4j5UkTBRh0mRgMw3rgxUCVXcNmyLOTLnJSp395s09FJKNRYB2+jCKKfcN/gdtSz1zCl1AO5Nb+5LjAkYF7I3cmUwcM9HNb9KItEWqehQ8Rloj8iBAdY1SoGRO5kmCadge0/vC1LJ0T/q9qwKlXzTsxbPp6YfToZd0Kdo1WWdgeypqer1uOnmO659olNLI373Xy3CWyZF3RRiTeU2NlTIKylO4hRSFRKWWhXlQ9vq6FH+dz+PkM/PBhXO9ryywr8zrXGnBIXl03zfp57d84miKLug3hLmeYv/E27s7eAKaPkRKDwYCXyCceM+aksveRyGLF3RVLqXUtEgd3Km6Ox8S8Qpr04+1+yN1OuUsqnq6VcvCYzrFRlAbLXWTPcC0dEKl+VZaOAtXE/ZFATKEes3CsDrwStiUk05o7jb0+Ey9967wHarFyshdvIHsvDXX2Ks6GBwJZS6DtGGu/kF9ynqH9u8Tcr5tnX7qNY9nXCOdYWsGRAROBrAWNrIgxazWUx4hgs4WG9BRogq0gXtNa/qAeVHd+rhPUVxLqMyS4E+zqbVt5jWvsXzfNvsrTRRZvGQAw+8xbuOvfhPcVTD2DDMKRiBUgDtZBSchiE2XimrQMhCllOOU2BtKoFMTuAmkjnkE+EU7BE8Vo5YPAxQlaInCBJ32LxRZGgBz6tpblGYRlTENJOuokDZwY0ig/RsMulAtNkyaMxhKMvGQa+u1GWzALDzKrAFNh5qvIl8yu2c5e6klmrNNXrbkFKwRaWqY0/ZK8ro1P1+S8Xfqq7dTlABQ5kayJHMkkYi3uK/R38A9713hJ60rm/ZvNwcqRCBy5pNyryr/OsTclZHKd8myaV8C6/JpF3YZw5xdw5+cYf+gnwA/flIqPHUS4YFGMIIk5TOZyoQWBI8dyWqmTSMZwTDw+2R9+xzlp0ElH1FRsSdhGC0OCrQ9DIm4Bev2JF43j8aGSj5m28mefkDUnxKHCV6yATWMA3sk29uIlCxZH8EaVfNy2YWXfbF9BTj15DeW5iTVrZxIAVj7XfQwe0jqVseIBM0b6E+oQdRKOowRkbFwaY8SrRhQnX22dL3hMK2l4eCd9RoSQpB+Gn1fN+7HBNa663kOn2yS2/hiF2E2ZBiNjP6gfPsLZJ34W/PAzwExDj3VSa/EEJZwYKDLlycCbhLZhLhUoCPVrm+s6DNns7zMqUpcLqbUIWNlYjT82+ZbCN9Hmvt7fUbgm+6IhuI5il13CfZE3WTgu8Cb7Jk1ncKZ1RNNi+RV9PLBh5Mja58Kw8FuV17LtB+1rvUE4IwD1girXGe3eUWrYKiAGSuVEYwJXmqbffvfddi7yIOtvVA7spvJbt/v5fKtBu4CrMWxukm5TvrrpPBuQRd2mYEb11iPUb77ZVJRBdLggNMKfa6yLnAiMjsWxFdoY9sd9vrNP/w0QALc8d4j5JBvWv9RDW9P35IZeq9Jf85zrhEGsc/5Vx20VErCl8FqapxIAAzLZZSvUhmIYKmCipTeIMZARsUUEhklEmuyDkTx6xa729WgEmRcroG731Uz2Owd4BzfXkJ3gWd3yHgzehy3T3VTi2PYccszmIi175p4eVG8+hH/1FWmYztXT4xOORBAgDY9FQx6jiWwBWlwpYe+aPt0vPxK+60S79HJlmxfZKefugCs1XqwhouL2oW9vA1Gy2lC3vQFz1fZlZTgEN7felziEqYncx8EzWlDDmcbEKZrieuTB0M2D2twYeLSvPKnx2jf8GIQ7V3WLH9n7aNBsfT9r3qd42jU4ZJ/hg/s2kkrazb7DTfLetg/4VfEskEXdVph+8tOYvvwK3GdebTYSyYML4x2D2t9V7DTdWFAWKuEFy+EwdmokbWBRXHUc9xHhUPYLx29wLHpe8sHbRT0k0/WKpj8TC3A3/CWEqrTy9s2RFDp/JxmH51ik7wCpozRU8ElaQmPB1j9KLNWkx3ByHLXIBo0IS/9WPGbmtHEVwm4aS24UX8xg11h6Q2iOEI+Lv13lGhKK4cTbC1tJczhDxDEJMuBmEMa25+siD5Bye1G99RDzh49Rf+KXpS8N9H0L9VKMLEnqSqC3rqAhbxoOaShYIRQGd29uiFuefpgf17526vvWe4izc5+lLRNSD3s3ucuX4ScRQvMy9hMMz9skCVve1xCCGlabLhcL6TT8NI4ZQEapUdKKE9foasORABpj4zrPRrkPMVJIw3xbkUIePhj0vQf7qvmdcqgKs3a00eZCNWDdOvRQvHUIQdYcczhhFnBVRlA5bneDz7rnzqJuC1x+/JOofQF+9j0AkFgQxfoXrZFLLYWd38eEIXG5rujsSbeMnPvz6KzzyiM6h/dZMnueRzvB8P4QxsLJOrhJ2rIAp/lw2Iqmz0HjfWXtJN70F0HSoZ31vNzkm2zzdUIsIV36N4CrbtBf1TFy3NV4kXYVJbs0SK9bkAXsQ5hlD97txPk/+2co3/3ZLVHH3bopGpGSujNZ9KzoYYd7ZxZ5ajDlGpuW5NV3HhpcabYa07sd2LReWG5QXegnONBlgpDyarOPQ19GRny+rUFjAOUsXQ8c55G8DzXYh3ckTYeV3BjmoW0Mi0mZPLfz6l7plURIHJ6nro6rt+Ojq+bd6+LcfZw/xap7kEXdNvAer/zNv3fdpdgYxm4iizYDmf3nvYzAVh97uGvt4pD3dRscmxfkKhruVxH6dIjrOPSzOuS9z33lMobwmX/yIeCffOjoRfux8dZwntuXcx/8dJV8etNw1e/4ITnjENdyCJ64aVx8le9IFnVbYv5kPrhv6OW46sb/ISrigwrDDfPehjwPQY5u6xwzDoXrErbX2Yi9LpHFR2ZEyLh+TB/OWuu7fBdXISgOwWub8tnSvDbguk3v1y7XfhXP5hAi+bpxrAax6+Kv6+Drq77Wq3rmWdRtifl5dd1FaOGmeeEAyGhNW6C51mE5tW2Zl93HVeJtnyTem/8tJLfrwLES6rq4KSLq2DzGGVeH2eNho+e2uGkcty2/LcM69+CQom4Xjtuev/bP8xnb4dg978Dx8/uh+TuLui1RP7le/wyV7crskKUxxaFE3XYf30YktGGlvw0Rx/LsQecvL+/+K6tjCx19GpHFT8ZtwyH4sct5h8B+ua59Dw5h9NunyNuE+7bjDbdRefZ//u1waGNtxjBuigHzENi2XZBF3ZZwl9dsDbhsrx6S8JbR86EEHzB8TX3l2bQcgxV1Nfxch4jELxFz+7QkHsLy6zplzyIvIyNjVxyEHy/7N++T+9aRoofkvC5WXdteuXAD7lvGeTHfHblvGd91eWsIe+GzK7jWjIx9IYu6LVE9Hp6gcVvsRBYDhHdoUHl1IYG73J9tiH9X8t6lsdF/7t2s34e2OF6nILwppHoIYZ6RcWzYhh+3rm+vifsCrpID+7DtfduEn7Y5x65iex/i+bq8o7vgGLjsJvJUNkgLsqg7Ivj65riaQ4XLS6x7+0bXOrcJmW5TRbmq/Tw2Jqme57kuUXXPvVM5lpQnYB8E6gbCBa4ifOWqKGhXwg1TWOwDN5F4MzKGcJP4D7geDuxD4MWNxWXnfi/jgK24cOB5XikHHoDzhnguxU6cd40D7QV+2ydPDZ5rz/y1724MN1UkZlG3JXhJhXOduIp+B8D1EHC3Et6ETP2azf5lFf02z7z7PHa5b00jYn/3PpRvn89z4TntUNmuS47rVOj7qKSHOoofg3X1JuGmEmbGerhufrwKHjwWEbovcZly5CrBswsXHgsHHlK27EOudLlvW9GySV27zkAo++K6PuF4nYbK28JJWdTdMlw3mXaxT3LdhQzKk6v/YPfdsOhe/z68a0Pvyy5lP0Q5d8G+KutjGwV2n7gthJaRARwfDwKHE5q7istQPx9sQLQDtgF2KfMhuC9g6JlsUt5gDD2GgVqOfWwA4Lg57CqNvlnUZRwUx0Kuo2f7X/VDWFuvW8RsgkMSxraV7DYV4D6I4iBzVR2pB++YCTAj4zbiWLiwi+AvORngyJuMYxBEwHb17VWM3B1w7BPU33S+usr38PZ9xRkZPSgm9rqLcKux01QQ25wvD4udkZGRsTOC2CzPyuE0V9DH6ipxDNERwNWIvV3PN1iOax0Y7Tie3zEii7qMpwLje6Pe7U/zPChXjX2SwFVW6sfqbbtNuAmT2mZk3GaM7y5y5FVM5HwbOPiQAmcfXHedHHbTvWxXhX0N9JJFXcZTgZNnz2BOTuErB7AHMwPeg53+Tv8GcBUEtw5uSgP4WMXQsVr5juX92hY7vZeZ+DMyrhVn73wGMAbwHt55gD3gGcw+cqOv16+jjoGnblqdeqzcdCxcfgzv1LZY9S7aPd3jLOoyngo8+JJfC65r0WxEUkmR0XUD0OoPipcIvsXEAJibD5kBRiIaOUkYt3GymdtLyUB+xTzbecWjW9uTMieitXUlfedC52c8rpu2udZOYfqPSa+7r0ytsnDr/NxZBxjsXM+95Z5rOk60SepwhL7v4Z77cJMJNyPjaYY9O8X9L/1iuCdPRFgQNZxInfUerKWdvG84rls/d+p97uEJ9gP1euCPHs6IebSSB+7oKfQQbzAn/D/Mj+jwY991tHi5VfYkr3AtIWnKpR0ODHm2eXbg/q6JY63Lr1Kk7/8eCL8fmot3EnVE9H8H8DsAzAH8MoBvZua3dd+3A/j9kBmT/zAz/6hu/2oA3wHAAvhLzPwndylDRsYq2NMT3P/898B9+mX42RwAAz5UplJJtD7gTsXR/bi7Fcug2AvbIxmSpCUskmT47WPSxWO9b7ajh2QD+XYroyQPUHu7XEtnu65QJPXkknxzbHsfNdtFKbeLR9Q5DzX3TRNS+E2k95yae5WUn9JzUZIXUZI9LdzjTSvp2IhISLbr1WWvolKt2g3JcvQGh23sVYQCTQMnWME9I/Ugi1XctdaHy7k50W1yL7a6bxviplnU10XmyIybgNPPey/uPjOCLwuph5xMHj/IfR3+DBXvMh6NebTsWBQPlrzaHAFqeIJSDgm8JTuS9Ka1jT239tMC/6Q81sPHaPM7LXBuU/6YNi0P0p+ExTZB53zKfTTUPugrb+A9at+Ppiy0WO5Q3jXrauG5hNeCuOzhRvYDXNj582qQBfskTeMVTr3EYrz1yslJmi2uJWATcbUpPx2SX1dhV0/djwH4dmauiehPAfh2AH+UiL4IwDcA+DUA3gXgbxPRF+gxfx7AvwbgZQA/SUQ/zMy/sGM5MjIGMXrxORQvvojyhReErIgi4cQPKjSyvWsa0d4D8BLzH8grVDDgpoLR7UgqPgBqCeT2tlaaxFrYFQ/h2BQDH38k1oh2Bd5UGt38vDQb+/L0qUWwL4EueqydCyJ3iNyHrsczuhSUVqrcSdtTrN5KeGXl2S13S4iSWkKpIdxIvKkIJglhIgKBtK+FkWPJgGjUPjY2QvQYao6X9AQmAtGwF4+9b94r7+Xa2Tfkyh5cO10PS/kTMerjNl/Vzf4l51sH65BVSEPm1g5klDky4+gxeu4ZjN73q8HzmdRFgR8Dt4RGunKf1B1hHdFYFeshsE6infBiYtxaNIylHJnyJgBfNwIizaMPHS5cVgdxuKYuFoyiaN+LViarzyN5rleuFs8NGfK24NPunqE6fPA6UqGIlL8AcGpkbf4IJKKdIfxFAIzR3wRLZWOMTb3BCQ/K6YyuU5snyfQ/E0BeE9fuapPyXTCaLrT7OpzIdZ3wo0O3jbCuIFtHQO7LsLmTqGPmv5Ws/jiA36m/vw7A9zPzDMBHiejDAL5C932YmT8CAET0/Zo2E1bGwVA+uA964V3A+dugaq4fqHysVFf6oYplktgB5KQCsQBggZIBKqSyTxrysZGfGPwkk1ABAkBSCQZLXWJRawyHRo9pnyOtRBYqsN46QEm0KYA28rm1LYrQ8HuBUCWvaGGLeXArjyg+g7DwoS+G10qVFyurrhBbRsT78JquTahrEG1LIDfCd12SjGsDhM0b5BURvJuMJnTKGJAxYG5+kzGALWQZ9oMAY1vbwnrvvdVnzM5JOLP3gHOy7p389g5wHm5eiYh0bklD5HZ66AIyR2YcO8x4hOLBXfCD54HLx/J917XU4075MXhVAEAb6wQDlAYSO6E8x1DuUs5oecnC73baKDki56HxRIW8Ihem2xIs1I09PBH4uCs6A9cFPgxpVHzGkMfIf6mniHVTh2PjOTzSPolBaMDVbW4P5ec+rkmuYck175NHmzy793mZsbQtktlzq43Se47g8e1u3pQDpbDtdTIqDHmBF0FGjK7KeyhLEZaRB628dZq24UazWI7UMOpcFIPRiOoazoR38FWV8KRLCtyT9xbYZ5+63wfgr+rvd0MILOBl3QYAn+hs/8q+zIjoAwA+AAAv5K5/GTtg/OLzcPffgXp0AlNPAWaQCjSCF4sS6xKyrS2oUm8aosWGorUxWBoTDx8zyLumQnep0EpEUjhWK3mKFspuBe7lfCkW0iT7qQn1JI92+AaR1B/ESdrws4Ca3+R+hOO4yXcxFIQiX4bKMFSg4hXtlDe1fCUWsEYY1I3VbGFbsAgPkNISoluoLHcRjOuKuI2E4nCadfKM71Z4v3x/OXnDc8a0lApAK8OCGysEaSzMaCTkZy1gLEbWAjbsb3sa2Tmwq8FVLd7zsF7XcG+/2X99Nx+ZIzOODvbsFMW9u5g+eCd4fAcAYFwFIgPDDjGknhrxRh1upDTiJPXOJbzIynUUDIfOi2AK65ETA4+mHrzGWNiSAN3+5QHc5oMkQLJZCyIxXJNFa10MrV0xiXbERsyyI1hTURr4teO9kvxV1IQ6NvBdvP4gBjgaooM4iBEVLtnec28WBEjrNoXzry8Y98qja+axbt79x8ozFaNze2uafuGMPeXs5WQiMBLRZy3IyB+IQGWhnCg8GfaDJG2aD7yTqJq6lufp6siVUEOqn1703puAlUxARH8bwDt7dv0xZv4hTfPHIK6O71uV37pg5u8E8J0A8D6a7CZdM55qFPfv4NMnn48nqFFaByKgIBEHhuQjNSz9lwhOfgMw3oEh4gwJ+RjvwEQwvhZrj4pAk9QYwZcX5Y/2FwhpG1mkBKFVCsVYeV2P1r+WySshTNa8pXzpgCHUS5aI5JoKUwrbglVSrzmev1uZdSo8CgIt/EbIA+L5TI8hDxQGYAJMAbBtCDSEaXAQhYheTBiLSJjRsslqDasbC3MUjA7e1UBdyba6EpIcICUeuNZlVtR1yXAZEW5MgksIcF2xth05xgIBcHqPq8W8YzGXkKK1QnRWCI9sAYwsMCqAi5slUDJHZtxkmPEI5TP38XF6H9y4BhFQGg8CYI1woYUTXQcv3IjAl8IppPsNyXbDXnkJkRcNIE4+9lKNi80x7m9zYTC4trdHj+ACP6ZL5cQ0skQ5kjTkkhOB2PBkk56BhhO76VpRLUjyb7DA22HpOlwYOFPbISAPYlKuK4T7YoQQxJvEUI8RNX0SDYU7nOTNKgrVcMYeqGuAHRCjLGrhz6pS0Twg5pZ5Erv8GdAnKpM82rzVz6NLvY/JOfr27cKja+fZ5yHmGlzNe/Nqpe4Tt2Sku4UaRslaGFsA5UjXC7gnjxaPS7CSPZn5f71sPxF9E4DfDuC3cnPXXgHw3iTZe3QblmzPyDgIygf3cFmP8HA2gjUyspYxDp6FUDwDliS8xBiHQj1Y1ogoK5TgTCHrhnRp2lZAiuTllBTUW6fiqBGIkIqVRexxEIpBZAVSQkMOlHgOo4NNTiZkQwARJyEuSWhnIED1vjV9pllDR7vhLCEmHk1oTDx3Wrk3whJ1FQlCxJOL6+Q6Iq8rnqIIDOQaLJPhPEnacGzow8FeCI41REJaJADEMmZDDH6wjBmTkJFaPOtaLGJ6DWEd9VwIvieMZRMBmG7vI69NiKtvPydlosFjCH1o8rIL5VvbmzfQCZ/MImm3+s7pvdemVIQpblb/usyRGTcZZjJCef8O3piOMK0LdcoxnBcOdF5EHqMxghbGg4hQKEfaKAJ13TKMqjajX3c0oKowjIZF8lEwBiGWCkRi1rqNQT50k0iFYLNuIm/66FkkSoypdlEgxn2U7ks8eJE/w//0ODTRNQGcDiYi10ROjF/karB3IFc1XjYgciCpdw5Aw5uRa5wabRujpWzvcGMqINUgKn3QrBhTTQEan4iAMLI9hh5GwZpwY+B0FYdcye/GeNsRYCs4sFcEbiAAZb1zrvT83fN1ztHdH7nJhnya4xb5tD9EcnF9kRPXDXkVA7QHUGnU72b2ul1Hv/xqAP8BgN/MzKlP8IcB/HdE9GcgncDfB+AnIPfofUT0uRCi+gYAv3uXMmRkrIK9e4aLS4NX3gBAJOODaMNxUjIMAeOCQQSMCkZh5UW1QaR5EX4gVvIJQy77aK0UYdiQl4g+jwKsERhCLgZChkZJMZCOgZCQAUcyApB4/8RSKAIxGTUKSMRSYnFMQju7xNcIRU2f7gvrHaLoHos0PRHIljBGrUtgCT8AS00ZylVVSShlHYmCXKXXkVxPFG91qxxdIUhdAvFerts7GVNQRZM8rnZaZgZsEcMgTFkCkxMNISzApPH0Gj7L9UxIrq7EEldXQDXTLDv3LTw1bm/vI62VhKUhGhzveUgX8k7ke/eYJYTVW96+vDrlCsKsGeSke0khT4rpyHaEGrePva196zJHZhw7irNTFHfP8MbbNT7z2GJeA2UpUmxcAtbI0hjhSWuAwqrh06LFiRwFmQeB1cnE8F6MoYDuI6Ag4UZZJzGmkvBow5liPA1jcoR9JgqtYOFkpJ5DEYaJMRWNABIqTzx1gWtZOWVBMA5wpA4QQpyUIzV+EoFgheetCCoLhvTn8iAyTff6EE7plFe8EyOjr8W7BjScmwpAvSZZLjGapnzuHZiVc+MANz3C0ASxZ8FFARqPQSQhhcKb6iVUTudqrsbQChw40tULIbCRx9STKKdrp+kKv0WeWhSOQyJtiEebctn2/eqeAwB3DZeJwbK/fNRZ5wWu6w4O1uXTLo/2lasPu8a5/DkAYwA/ph6CH2fm/wMzf5CIfgDSubsG8C3M8sUQ0bcC+FGIafi7mfmDO5YhI2MYxqA4O8V0WuNjL3ucnBYYFcDpiUFhgYoJtQeewKB2TRvec0NcZSHCb2RZ+tRqvVZaL+OpmBAZ2BCMY8CDUcPDu5T0nNSXmpYSogMacgjrNtlOKhBttIBKOUhFqHgQCUTSPzBEMrZDQJGIPw8EEowexfaw+kMW0bYwFIIxakU13gEuWFXruF3Y3sIUI8CeRPEXbjrXSgLVHJhfAr4G8UiOdalw7VnvePCQVNzUFYYpqUAreefloVeyXzRzkncQrMaCxmPw5ARUlBI+SiRlr+bg2QxczYD5tHX/uqKvEVd2QfB1J3ptLJzt7eHd4TS975JNf15pGGRanijQvI/l6I5QOUw+GEy3GLaC9jE2qk7cMmSOzDhqUFmAJhO8+eYUH/uUwbgk3L1TYFQCjgkVA5eXBlUNwJAstZFbWIn8GKn4GxUSCTgqxThqCCiVN0MjO4i9CiL2KCxV/AVhGOq31FhqB3jThuiZjjCM0YlqPLVWuZFYBRZF3vaJMAsCkbUOZ40nCNwYPIeAcOICP3aEolHB1axLfnHdVYAxMChgSuUZIBpJQzQM+xqoZmBXNbzmOiKvI/7SvujLo2TQz6OsnsVa93dEEbNXkVcARQEqSwmnN4Vs9x5wlYysWs/Bs6lwZYjIScoc4dv3s+vlWzBSeh+fY8MlA4ZU5cSu6OPu5N/JcbvwqKzTAo928xoSfd3yLxkIG8Duo1/+qiX7/gSAP9Gz/UcA/Mgu583IWBdkDMxkhIsnl/DnU3z80wXefOQxOSkBACcnJcoCODu1KAvgdGJwdmpQGMB7wrwGzplwOQeCPCqsLtXbZ/UjC1FjxogILAvx/AmxIVo4rWmIiiB9jxiM2ks9VCeiL4g6YxoSGSK28K1HgTggGIXMJFQmkF0y4rAKR0TrqKCZR0YqLh3yVwnOcg3rxfoXQmDiehB73CYf4yrAMQzPtXwEGp0AoxOYu8+KkHJzsVjOpzISW5fAYjjOgKgLo40Bg8JvwdsXztFHXr4G5nVCNprGWKAYwUzGwL17oGIs+2eX4Ok5+OIJ4nDJfefEInFFgggJut6+nnCTVX0Tul6+Jl0nb2sHvXzbhKT0WS7b6/1WyZuOzJEZxw4qS9hJCX/+CA9frfDa6xWonAAAJicjWAPcuTvCqATOzgqMS+DOWQECUDNhVsnycgYYJcOiIBQFxd9AwpOFifxoTSMIA0eOCh2EkERK1RCbG0NCQSvXeOpCnqErRJcboyDU/TEUdAmfxlBSgkbVhBBTjaqxuqSUT5uRon1YhigRZljrNG2tS11XjrTcGERt5DQZ2CPwqSELKkcwo1OQKWAMCQdUM3A9B8+ncpxv8xeloyyu8vYloZ6t7el61ziazr3q5kDd4SfPgC2lH/XkFHTnvvKjh59NgdkF+PIJwuBoaTkiBw30sUt5tMufAd2uEhuFeK4ZLRPRw6Mhr22iZQbLtQQ3q0d6RsYWoEIaqB/+6DkePHuGz3mHwSffqjDXCIRLALNKvXKlxWgUfhuMCuDOKeHOGDgZE6Zz4OGFOLfCgF9WLTyuaK/XDphVYVt7aTRNYRiWCGUhonBUMMZGQt9rx5hWhMoB1nMkJoc2UdkQNx+9fGqJov79jhhgIYsmzLMjFFud19GEwmhnbUMGxhBsIefzbo56ruStBBXAwbSkBEbdhrvX8nkZ4YlYRwCDiDUqSpiTu0BRANNzEUnx4WpeIX3MMzkHh/N3BU+IfQliT7fb/v3kADaBqLTM0brmgPmlVNgXoeIloByBJmegu88C3sG/9WlgPovnYKbGKql5M8L96FT2JjzHQBxtk50c3xllMnpSO+Y90yGfTt66UdMEI4F67rh9TGqNTPNM18l08lpIu8L8mJGRcRAYa0BFiccPL/HJT87w7neO4cjjE681gz1UOs9W+VAqyfFElicnFuOS8OCuxTvuEWzh8fpDxnRKKIpG4KXLwJuBf7uiLzharBGmCOJvXBLGJWMyBqwleAbmNYuY1PokCi3lxlqrcOvb22kJn9ZaV3bFXiMCodt1qecl0jITiSA0JF3YDAFcYzavEXo9hzo+eIdYOcqiinwZBF+cB87LCNneOUgEjIxMagig0SnMyV3p83bxSIRKnKKhKWwQYA1/6k2njnG0c1xrnQf4siFDLW/Knx40F+NsqztEOQKNT0Bn75FDHr8JBIGHhBei5yvci+Bda/g48Ce6kSJBaJk2ZzcCLGzviiUT+TNe/lY8ml5Act4NebQ3rx5kUZfxFIAABqZTh1c+NQe4wP2zET79poNTsgpLa7j5bRnTOVB7wttPxKL40rPAvTPgzceIgzqGes91172eGwCiOApx+LLuWcipnofzKzkZxqggPHdGeHTJqJKw+KaCa6/bWN+1RVxIaLQsQbB5mKRPgqYJRq2OEJRRMgEmDyT9EMJyMipgyxHquobXWj6M6BW9WqGgMWywE+OenjOkYelbEKyQZnIKnN4FLh7rTUY7T+qQgXoVWwgPKKQJDy5Unr5DJMn+UKkPi7tALLqh0nDMR28A5Rjm+XfB///bO5dYSa6zjv+/qu575xl7Jg6JsS3iEGcRCQHGSrKIIhbISbwx7LLCCUjZJBJIIJQQJCJASCAeAglFCsJSglCyARQvgOAgIjYk5KE4DyI7JrHjTMYej+dxx3Mf3V3nY3Eedaq6qruqu/pWd9//T7rq7upTr3O7z7//3/nOOddeBA4PMIUUxSXUV9mMTpm7XIjLgpDvUxTD2vLJ9DmnDNkC5q5s3urMHSGkBwTIMoMbeyPc3h/jF372tXjBGGQT2/aZrJhe5jVyNFKMRuoyWYALr0lxz10Jnn85L6vOlPh98t+oTo/Cd7+cXu6eZLZ3bpwB++48aWKPc+Gc4PwdwEs3fVvk27niy7JmiuTPw3ipUvtW1s2ynuaHds8UtpculNVgCHdTxalTuzg8cDrmdMqfO9ZMfx7junbCbwX3Opc2p+NZBmQHUM0ggx2k5y8iu3UtxDKBIO+5wPv/jb8Xv04uynWQFPcz5UqMyxQ1sUo/7bVEGjoe2bF3et2mmp6/CJw6A71+xR2r1IPoqTqWCSJcKlsMkk71lAUNKu4v0Yyiua4vpqOxBoZ9WupoU2jqyPZjFIkI7r37NM6+5hQOjxRXbwGDYYrB0EcT3eMwwWCQIE2A06cEuzvA+dPiUkQEewfAwcj2quURRfdYfp1EvWm+nQvRP/taoCH1ZJDa8XsD99oosHdgcDTJxwgAxRQSf4zCYymy6NtWv90jkeiUmTomasqJYDBIkSZANimauLp9wr7lxncegx1IOoQe3Z42OptAYY0/QgjpH+Mm1jp7bhdvfmOC8+dS/OhKhnQ4xHDXDlPwQw3843CYYDgAzp1NcGpHcO5MguFAkBnBD68oFAnSgQ9Q2vOkLuqYpMWeOd/LVtZR//s5SfK0zN2B1cadoW1KjbFa7vfNs1X8vjWZKFFTLGVNrtDJqu11ulo4JhRpItgZJDDG1OttWy2sPortpWoyLrm8/mzT8jHloOiy5zIZMBlBdk/XFi0HBfsmmOEW/79l72G6564ITR3ZblSh4zEmkmB4egcv7aWYZMDpcwMrSmfs49nTVpROn7YNcGYAAzum7nAC7B3maSKn7HCpID6DkpkbpnYc3WBgx9D5MXWJ5K/9JCwJrHmz4wXsQPHDCXAYCckwtaYujJ2LDKF9bUJZIB6vV2Pywhg8LbwX1iQXhHEEiR9XIDatRCSe7hmAyZCZMUaHY6Q6QYL6weGixddhprByOT9dczpAMtiBDHcgSWJ77F69jnh2zKnB4eWB4GG9orzM1GDxuqmYKxrdummbp2YPM8YK7O4ZO3307hlgMoK5eslOBFNFzaDwKerGBtRsK1zvvPKLCM2MWcNmXhMhpH+yDGY8wWRngLEIfvCSwakzuzh3B3DunB1Ld+7sADtDwdkzqQ1oDlKMJwqjCQ5Hir1DO9HYYJBgsGO1Mh9D50xb0Etx48utLxi6yVV8mqUfWxdSJcVnvdgJyMYZcHRgFSgRdZOVFY1ZWkrDLK4Da8eqhyBpQ10N2uhmsvZj7xKvl0EngVRSuGk2YYwim4yRGZOPkYfXPJ8hk2vgPN3Mx8whrGMmg6GdcGYyQnbrlWK5aJmEqdmjy+PjwusazYz1tGb89tS5ZpnMJAV2T9kUzOEpmP1bMFd/XFu8PDP0lB5XMUfTmi50XnWepmZu5pp8LVn17JeErDVqDLLDI1y8eAZvfssZDIeJ6xETTDIAiR37BuQTlAxSxVBiQ+aMmJtaeeAmQkndLJgDHw2MDJL93tlG36hNlbMz+No1eRJvSvxMlmKAZNqIpciFpdxrlrh1ddLECwXgZ8WMH71hE2fQxG7OZ9UC3ExfAKLlEhQKyexAb/WNeXn2SzUYwItRzYQo4XFc2A41gJvWWZKBm/p5AJEdu4RA5nLw928C4yOb5DJjDR/7aKZfV63fE5ctv18nGGqqzZskQDqADHeg6RAy3LEDw42BOdqH3r4FfflyUdxiA7eKgd3hWDXHmGvE8vfbLto681gtB30TQlaLjscw+we45y13ITsnODUETp1KXFNix3RLYgOc6pYESlLgtAC7O9bU7LgZ7vOgZT5r9CAtLkOQiLpAptfGfKmgTG17Y6Uh72WzBrB+cpP6ScRscDIsKeTMXBK/lzg9lOjR6ycAROdQp4224pxmwiCfqMPPmJnvEwc606xmMrFIM/MZMfM1+SRJIUli/wZ2dkyYzC4qPjqE3h4B2cgaz4oJwaaCn/P0c2qW6Ugj55m3eA1ZAGHx9HQADHaAnRQy3IUMduysmEeHMDeu2RmvSxOkzDVvq9JRT80ELW3XwCtcT80+dcfmRCmExKgiu3Ubg50Ud7wmb+x3hwZJAuy4ZQmGPoqY2BQJAysmfupia59sI65uyuMETnx8QxnNVJnCp0xqQTD8OnXBzLnLDILiplm25aKUkGgKZacs+WO5IXazZsEvV+DX6jHFBdAF04uce8JA35o1ekK5aDatYo+bW2tP3Li9JIGkKURSd++JPafJbE79+Mj2YGVjO12zyayJM8Y9tpySORalBcybffB59ImbsnloxXQwtL9q0gEAAYyBjg9hxmPg4DbM3nU7GUrhWNXRzbB8RLxt6jrmNOoVwjN3Vq6aY1UtCFt3zKZi0yRKyd48QvrBHI2QHR5huDvEhQvWtO3u+pTHfBkfmwbpzIgzZj6AmUi+DIHfnrhAZpChqOcrdT1eSFyvGdyEH7BmzvaA+fXpNMoScb1k4VheNy3xunUASloJF6z0epcvTaDq9DF6jQrNE0xrYXFJg2p9TEq9bUk0a7MkCRL3aO/dmbfhwGq3z1yZHLl14I5gFzB3GqnuN8asJQ0WMW9AtYGrKiOJnYgkHdiZU9OhM6BDOzmMMdCJ1Xg9PIDeuuGWNag2a/WaXKNrDXR0ant4Peca4n1aBEPDdZWutX7fag2cXg5otlbS1JGtZ3xrH+d2x/jJOxVABlUgTey6bGmYGtkakdSthSOIUxCjqJ/EAlJq3BEtbKq+QY+NlxMXhV1I3Bs1zQ1avsC4ex2ZrrLR8tStJeevEs6Sihrbc+d1T8Q1eOKOHQYVuGP50eQSlc+NZjiYiMsT9wO7XXpkWDx1bM+TTXJxCvccRw2j+5uz6PjcaGEkClMCYfNLrdi4CKhfbw7pwBq3JHHlFRhPbK9hNoEZjaAH+9a0+fvBHLGJrw8olq8QjjrTFso16H1rJTazrq/BsdqUm46W0swR0ieT2weY7L2Kuy4ozpzNYIwNbqoCAzcbmB+bNkiK2piWDFi8/mpaMliJ10LkBlDVBjrVmy8gXzDcGzDJTZfXUHG9ZEGDZ2ogpkxXbMRCGXtAV8ZqotU6L3iRjtoUGIgLXhaOFWaIzHU1cYP4RP2jNWwwk0gjs1wzTRYWHQ/XPMu0AfWBTzXtTJsn8QvgpgCsLtrZOu2EAiIJIGL1yBjArTOroxE027f3Mhnb3sSYOAg5z3jN6X0rlK85xrrrae0xG5YrQ1NHtp7JzT2cHe5j52yGRCeul21iRSFE0CbwC41ak6GQcS4YCrUTQIkiCbNk5dFAkbyxF4kbf7hjeMHwG3Kh8NG2eLPAu8fidrtLzZc6NNh+t8gYxrnyznQG8xgaJHWDF+KyXkht+YI5dXXjFzcVl1oyV2Tm9a7FDXS8jzOVEJfIkySAiusFHACS2G3OsEmSuB7BUEGAKnQSiabJoKMJYI5gJmMXCXXvVzX2NTNo9ZniUXXMLlMm25SpKldl3NhjR8h6oKMxJjf3cOH0Ae7YcemAbqL/RDNnwKyGiOt2E2ROR417hN1uJgiGyLbCUfAT7jHXRwkBxGmNFJhKgwQgz2JRP4GY5mcIxgwVbY/mZcK9mML7GgdP1R8r102nhFGbqtHyMwo/fMEfww5jGNusE699NevGIfz+iK69PK6tLuAZl5fE3WTi7jlx+ugDsHATnTjNFNffGfXoqclyrfRmzRk1hLXvorVR26RKerZUT6u2L2vammojTR3ZesbXb+Li9aeB0T4wHkF86l+85orGPUAamZ/c1ITXwdjAlcvHoRUMkDdIBXNUEpuC8VFnaEpGK0oFKVAXsanr/ZiKXsbHmt1gqJpi+akC7p4lsQ2gF4lgxCRE9vyfKpwxg3vPjpjXRBDW5vH5qWoANdDMPsIYO2I+c+Lj0yw1s2W88Bhj36u4/6ZpjXEd1O3bZVpG/THmi8DSQtGhAWvUUyd+cGoKSVNgmMLc2pt5XEJId2SHRxhdvYE37T8DHOy5niTfhjvD5ReXKwX8fK9aOdgHNc7oaDBCoUzQWKcZ5aBjhTEK+5f102tvQWcrmNW70VAvp485o/0r7xsbL2+0xOlcrIm+SDTQT51+IuhnEmZdtO1n6dSZC0hOvB5Oot60iX0vG9v22ZkznViDVr7eWWamdXpjOEZkdDo0Xvkxlzdgtcdeppet5nPWSF/FZRWlKfwavnXQ1JGtZ3TlFSTXLkNvXAHGNhKZN2KucTVwjar7IokARl3KoRc4RF1mLu0g9KjlAphHDMU1KFGZYiZHsTwkNObqopbhOFNl49OV7FbNtPltpt2dWjtzFs5wefNpjZfaiKITWlVnvIJxNS59UYPgBDHyYlM4xeoMWONzYL5g1B+reYPeSQRvGQFpsk+awg6ISfN01TRxz51Bcz2nkqbFtNbCZdrPiWbux8doDHP9eu21EEK6JXt1H9ntA6Qv/gB6+4bdOPG9Qb63DECcju/aF401DT7DxKf1Iyo7rWGK0o9WT6EpkuhB8usJpPn7Eh2n3P4N4n1iEY62zYxaYm7gs5qSDmRZ0EmrkfZRswzqhy1MlbFZRHng0m33Bs0fu4kByzeUXnZoxCrO3+gcWFxfmx6/bt/a66m7t6b66k14mtrvStDLFJIm9jEybJJG+hmWPnDncjqZXX+l+pocNHVk6xldu4Hs8iU7aHdU0eMTRdH8LI+qKPaixWmIU+kO8Re8ImqJqLHSioYn3lb3PLz2kU93LsDeS/S6UxYQskUb/VnlaxvoFpHZVlMXzzn3ovnubQzYvGNORfK8gCSJ/cHk00/dGEK42dPy1BzJt/n3JXFjKSQ3ZaUggRpjo4WZe/SG3PWY6ngCPRqFXlQ7k2kWykAVJlvBZ5UQ0hrNMoyv34TeeCXXRW82vNFQN3lIIZMFgBYzTTSLNaqkZeUUxdDr5wxeSfu0rHV1zwun0uJjVj5n1T5TL1rTOm28gUbOC1yGcjXB2uop+ZczOpV6u3AmRwud78KIhQKa62XQyASaatBP/17i3teyjkqSjysM6azpVGBAM+NSWY3TQxN00kwy6GgUUl0xKeql/4y0nSGapo5sPaMr1zC++Somzz8TvvCVjVX84zX0sgFT39TyF3eZcUAzd20XJWpdpkOa1EGbxqlpnc48pvt/hmP5lFAgiurmPbES7RMityKApC5I7HpuBdFqt5LvE0e0g8mCFQogn3wlsecVicslbjc3XtAt9YA4ZXXq5qOnftC5C0zoZBJ+SNkfY85MGVNhxkzeW2r8YxYCHk0N2Cr+v4SQ1XP04ss4eu45ZDeuAqj4fvrvdjnAM/U1ru/uqm8fZrQFTXXsmPVuWWqDkTEN29Nm2rtY4DC8X+jU9EMrgKB1gBuiEWkaorUiILATw0nQP6ReNxN32EjnvFHyOqhwi+ZGWhoHMgVQP1YjBCLLn1UTv4i0MQ/0q+8JdVroX6sZA0ZhfGAyaGUWNDNsm0NT7Vs08ElTR7YenUxw8MMXkNx5T/0AXD+Jhil98VEhOV0LSMUP9lpprEmtLG6fbUKbXVIyv1DbU7RI/1zgkt0pqno6S5FZH1UuRH7z6LH6cY3lsiF6HL3nIthhjTjbxRu9B3vf/tEf36Wh+p7afLC5yc9p8uPEn7k2jX3bKN8iZqvNPjRzhKwfB8//GCMzhJ57Q/GNchZKqbersn1pq491mta4fP5akna6tTLm3VOHvyHm1p7qwnpqd3cGKDredEaR77nNe1jVZIWy+aRsfsmI/C/MXqnxe7luamEspkInJmRV+XLhdWkmzFVoYFvDdZwBT5o6ciJ46b+fAtD/j0pJlmle5x27O0Hr8jqTdPljrbLe1pU+PqurSovs+3tHCKlHJxNc/rcv5q9b/hBuAvVp1v7L1w01chXH7/57sOprpqkjJ4LDm0d9X0IlXQiKR7o81hIis6i4LFMXfQlan5HhVQjOKqChI2T9Odo7rH3PB3u61Kt5dKFnfZultvXV5lx93xupp0/No6kjJ4Lxvp31sk1PxHEI2CoaVUm7MxrHYbT8OWZP1OuOuSZCn1N91RTLIjR2hKw3R7dGnR5vnbWt7965Wedvq3GL6FkX/5vjNPikOTR15EQwujlpvY8Mj6/RSgZdnqtoNLrswfO0adDbCkgb4V5EWCTprodrnYRtFf9nQsjJYLzfJKy2PMtpXU0QrWeNq6Op9jXRvPrrWT6wuMi9ls+6Sv1Zm7GSGwBNHTkRjG8dj2B1RbcmrzldGtm299Dm3IvUz7Ki02mq7DH15HXZa0sI2V5G19oHPlfBcWvfcQRvm97TqjRwUe1bLGjagRk+Bt1ap4Bsl9DUkRNBdjDb1PVlourIxvPLyHAFDd9ksTS5qvrLxrOPNSVgDc7tzzPv2JXnWfLesg4mEQni2uGEJLPESc3xBTOYckrI5qLj9Rij20T7PJ1o4IK64Gny26GxFra4Fm1j6hY0rm3OMXXOJUxTssJ0fa9TWU9x/lUb1k5MnYj8FoA/A/A6Vb0qdpGIvwLwCIB9AO9X1a+7so8B+D236x+p6qe6uAZClsEs2bAfJ15E1kWEgaIQNxbamjqfJZKtjeKM8zQ970IGso4Wn7OmgYZlzGanKTNcULwWaiRZd6iBizHLhC6jhfPa/zpd6lIDl9K+JbRupZp2TAHVOlYdaF3a1InIfQAeBvDDaPN7ATzg/t4O4BMA3i4iFwH8PoCHYFeg+JqIPKGq15e9DkJmoS0ap65YVVrHOopv3CgvK7QGS0SySnXTpge2lUg2PH+ZLq6nzFKfsxWYTFKEGkk2gVVp5Cp0cB01EJhuI5fRQm8WW/dG9qWBS2hfp1rX8rOxjK4tYj5XPfa9i566vwTwOwA+F217FMCnVVUBfElE7hSRuwH8IoAnVfUaAIjIkwDeA+AzHVwHIWtFH0ayL+JGeWkRnzSPZM2PZi53KQAgk+7SJcp31olROpjetIofUvP+KzR9tVAjyYnlpOpgzHKBt3Y9O9O9bYuf2tOFBnaifRVaV6ZtXbep3T41rul9LWXqRORRAJdU9SmbTRK4B8AL0esfuW112wkhW8KiIr6I8HURsZ3XUHeR4lMXbe064pynJR3fDyn/f1vX6HmfUCMJIYu0x4sawWXa4Tot7DLN1WvhJmpfn8m+TW31XFMnIl8A8IaKtz4G4Hdh00o6R0Q+COCDAPA6zudCyNZznMIXswoRLLMKUaxilcaqXvBPtpmjRhJCuuY4g6OeTdHCKg1chfZNp9Mef7DU0/T+5iqBqv5S5QlFfgbA/QB8BPJeAF8XkbcBuATgvqj4vW7bJdj0knj7F2vO+0kAnwSAB+TUyf7VQAippC8j6DmOnsIyq5gcoMm4jePoidvEFE5qJCFkXWijieuihX1q4LoFST2LGsiFw3uq+i0AP+Ffi8hzAB5yM3s9AeDDIvJZ2EHgN1X1soh8HsAfi8gFt9vDAD666DUQQkhb+oiAzmJZ4ejCCPVlFMtsUwonNZIQss70HRT19BEc9WxbkHRVORv/AjtV87Ow0zV/AABU9ZqI/CGAr7hyf+AHhBNCyDpzXKkXbUVz3YzQOk03vsZQIwkhG8e6ziS+TjqY9Dj6rjNTp6pvjJ4rgA/VlHscwONdnZcQQraJZURzVb2JbVgncV0nqJGEENKedelRbEqfPY8cXU0IIVvCslHUdTCFhBBCyDKs2zCLtixqDGnqCCGEANi8iCghhBDSFZueKUNTRwghZGFO+pIGhBBCyDpo4fLLxBNCCCGEEEII6Q2aOkIIIYQQQgjZYGjqCCGEEEIIIWSDoakjhBBCCCGEkA2Gpo4QQgghhBBCNhiaOkIIIYQQQgjZYGjqCCGEEEIIIWSDEdX+11WYh4i8DOD5vq+jxF0ArvZ9EWsM62c2rJ96WDezOQn181Oq+rq+L2JToEZuJKyfelg3s2H91HMS6qZWHzfC1K0jIvJVVX2o7+tYV1g/s2H91MO6mQ3rh2wC/JzOhvVTD+tmNqyfek563TD9khBCCCGEEEI2GJo6QgghhBBCCNlgaOoW55N9X8Caw/qZDeunHtbNbFg/ZBPg53Q2rJ96WDezYf3Uc6LrhmPqCCGEEEIIIWSDYU8dIYQQQgghhGwwNHWEEEIIIYQQssHQ1C2AiLxHRJ4WkWdF5CN9X08fiMhzIvItEfmGiHzVbbsoIk+KyPfc4wW3XUTkr119fVNEHuz36rtHRB4XkSsi8u1oW+v6EJHHXPnvichjfdzLKqipn4+LyCX3GfqGiDwSvfdRVz9Pi8i7o+1b990TkftE5D9F5H9F5Dsi8htuOz8/ZOPYxu/oIlAji1Aj66E+1kN9bImq8q/FH4AUwP8BeBOAHQBPAXhr39fVQz08B+Cu0rY/BfAR9/wjAP7EPX8EwL8CEADvAPDlvq9/BfXxLgAPAvj2ovUB4CKA77vHC+75hb7vbYX183EAv11R9q3ue7UL4H73fUu39bsH4G4AD7rn5wE84+qAnx/+bdTftn5HF6wLamTx3qmR7eqG+qjUx7Z/7Klrz9sAPKuq31fVEYDPAni052taFx4F8Cn3/FMAfjna/mm1fAnAnSJydw/XtzJU9b8AXCttblsf7wbwpKpeU9XrAJ4E8J6VX/wxUFM/dTwK4LOqeqSqPwDwLOz3biu/e6p6WVW/7p7fAvBdAPeAnx+yeWzld7RDqJFF2MaB+jgL6mM7aOracw+AF6LXP3LbThoK4N9F5Gsi8kG37fWqetk9fxHA693zk1pnbevjJNbTh12KxOM+fQInuH5E5I0Afh7Al8HPD9k8+BnMoUbOh23cbKiPEdTH+dDUkUV5p6o+COC9AD4kIu+K31Tb3831Mhysj0o+AeCnAfwcgMsA/rzXq+kZETkH4B8B/Kaq7sXv8fNDyMZBjWwB62MK6mME9bEZNHXtuQTgvuj1vW7biUJVL7nHKwD+Gbbr/yWfMuIer7jiJ7XO2tbHiaonVX1JVTNVNQD+FvYzBJzA+hGRIaxg/YOq/pPbzM8P2TT4GXRQIxvBNq4G6mMO9bE5NHXt+QqAB0TkfhHZAfA+AE/0fE3HioicFZHz/jmAhwF8G7Ye/IxCjwH4nHv+BIBfdbMSvQPAzajbfJtpWx+fB/CwiFxwqRYPu21bSWnMyK/AfoYAWz/vE5FdEbkfwAMA/gdb+t0TEQHwdwC+q6p/Eb3Fzw/ZNLbyO9oWamRj2MbVQH20UB9bclwzsmzTH+zsOs/AzjT0sb6vp4f7fxPszEpPAfiOrwMArwXwHwC+B+ALAC667QLgb1x9fQvAQ33fwwrq5DOwKRJj2FztX1+kPgD8GuzA52cBfKDv+1px/fy9u/9vwjbEd0flP+bq52kA7422b913D8A7YVNHvgngG+7vEX5++LeJf9v4HV2gDqiR03VCjWxXN9RHpT62/RN3o4QQQgghhBBCNhCmXxJCCCGEEELIBkNTRwghhBBCCCEbDE0dIYQQQgghhGwwNHWEEEIIIYQQssHQ1BFCCCGEEELIBkNTRwghhBBCCCEbDE0dIYQQQgghhGww/w/yndAv1HFX8wAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -551,7 +540,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -563,7 +552,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -597,17 +586,16 @@ "id": "e8241714", "metadata": {}, "source": [ - "In FLORIS, grid points are the points in space where the wind conditions are calculated. In a typical simulation, these are all located on a regular grid on each turbine rotor.\n", + "In FLORIS, grid points are the points in space where the wind conditions are calculated.\n", + "In a typical simulation, these are all located on a regular grid on each turbine rotor.\n", "\n", - "The parameter `turbine_grid_points` specifies the number of rows and columns which define the turbine grid. In the default yaml input file this value is 3, meaning there are 3x3 = 9 total grid points. Wake steering codes currently require greater values greater than 1 in order to compute gradients. However, it is likely 1x1 is suitable for non wind farm control applications, although retuning of some parameters could be warranted." - ] - }, - { - "cell_type": "markdown", - "id": "c771d0fb", - "metadata": {}, - "source": [ - "We can visualize the locations of the grid points in the current example using pyplot:" + "The parameter `turbine_grid_points` specifies the number of rows and columns which define the turbine grid.\n", + "In the example inputs, this value is 3 meaning there are 3 x 3 = 9 total grid points for each turbine.\n", + "Wake steering codes currently require greater values greater than 1 in order to compute gradients.\n", + "However, it is likely that a single grid point (1 x 1) is suitable for non wind farm control applications,\n", + "although retuning of some parameters could be warranted.\n", + "\n", + "We can visualize the locations of the grid points in the current example using pyplot" ] }, { @@ -635,7 +623,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -656,9 +644,9 @@ "print('xs has shape: ', xs.shape, ' of 2 wd x 2 ws x 4 turbines x 3 x 3 grid points')\n", "\n", "# Lets plot just one wd/ws conditions\n", - "xs = xs[0, 0, :, :, :]\n", - "ys = ys[0, 0, :, :, :]\n", - "zs = zs[0, 0, :, :, :]\n", + "xs = xs[1, 0, :, :, :]\n", + "ys = ys[1, 0, :, :, :]\n", + "zs = zs[1, 0, :, :, :]\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", @@ -666,40 +654,6 @@ "ax.set_zlim([0, 150])" ] }, - { - "cell_type": "code", - "execution_count": 13, - "id": "8dd8ce19", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Can further consider the points on just the 0th turbine\n", - "ys_turbine_0 = ys[0, :, :]\n", - "zs_turbine_0 = zs[0, :, :]\n", - "\n", - "fig, ax = plt.subplots()\n", - "ax.scatter(ys_turbine_0, zs_turbine_0, color='k')\n", - "\n", - "# Draw the rotor in the wind-direction rotated coordinate frame\n", - "circle = plt.Circle((np.mean(ys_turbine_0), fi.floris.turbine.hub_height), fi.floris.turbine.rotor_diameter / 2.0, color='r', fill=False)\n", - "ax.add_patch(circle)\n", - "ax.set_aspect('equal')\n", - "ax.grid(True)" - ] - }, { "cell_type": "markdown", "id": "307afc4e", @@ -730,7 +684,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "f63a2195", "metadata": {}, "outputs": [ @@ -754,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "ee1918d6", "metadata": {}, "outputs": [ @@ -783,7 +737,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "6a381dc7", "metadata": {}, "outputs": [], @@ -791,12 +745,12 @@ "# Define several models\n", "fi_jensen = FlorisInterface(\"inputs/jensen.yaml\")\n", "fi_gch = FlorisInterface(\"inputs/gch.yaml\")\n", - "fi_cc = FlorisInterface(\"inputs/cc.yaml\")\n" + "fi_cc = FlorisInterface(\"inputs/cc.yaml\")" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "id": "7547d804", "metadata": {}, "outputs": [], @@ -817,7 +771,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "id": "702bb7ee", "metadata": {}, "outputs": [ @@ -825,8 +779,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4.23 s, sys: 1.85 s, total: 6.08 s\n", - "Wall time: 5.18 s\n" + "CPU times: user 4.17 s, sys: 1.67 s, total: 5.84 s\n", + "Wall time: 4.9 s\n" ] } ], @@ -838,7 +792,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "8b688add", "metadata": {}, "outputs": [ @@ -846,8 +800,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6.98 s, sys: 2.95 s, total: 9.93 s\n", - "Wall time: 8.65 s\n" + "CPU times: user 6.57 s, sys: 2.55 s, total: 9.12 s\n", + "Wall time: 7.94 s\n" ] } ], @@ -859,28 +813,19 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "627f5242", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 10.7 s, sys: 5.83 s, total: 16.6 s\n", - "Wall time: 16.6 s\n" - ] - } - ], + "outputs": [], "source": [ - "%%time\n", - "fi_cc.calculate_wake()\n", - "cc_aep = fi_cc.get_farm_power().sum() / num_bins / 1E9 * 365 * 24" + "# %%time\n", + "# fi_cc.calculate_wake()\n", + "# cc_aep = fi_cc.get_farm_power().sum() / num_bins / 1E9 * 365 * 24" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "394ab742", "metadata": {}, "outputs": [ @@ -889,8 +834,7 @@ "output_type": "stream", "text": [ "Jensen 843.1 GWh\n", - "GCH 843.8 GWh\n", - "CC 839.1 GWh\n" + "GCH 843.8 GWh\n" ] } ], @@ -898,7 +842,7 @@ "# Show the results\n", "print('Jensen %.1f GWh' % jensen_aep)\n", "print('GCH %.1f GWh' % gch_aep)\n", - "print('CC %.1f GWh' % cc_aep)" + "# print('CC %.1f GWh' % cc_aep)" ] }, { @@ -919,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "32a93c6d", "metadata": {}, "outputs": [], @@ -934,7 +878,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "7d773cdc", "metadata": {}, "outputs": [], @@ -954,33 +898,10 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "1ccb9ab7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Serial Refine] Processing pass=0, turbine_depth=0 (0.0 %)\n", - "[Serial Refine] Processing pass=0, turbine_depth=1 (7.1 %)\n", - "[Serial Refine] Processing pass=0, turbine_depth=2 (14.3 %)\n", - "[Serial Refine] Processing pass=0, turbine_depth=3 (21.4 %)\n", - "[Serial Refine] Processing pass=0, turbine_depth=4 (28.6 %)\n", - "[Serial Refine] Processing pass=0, turbine_depth=5 (35.7 %)\n", - "[Serial Refine] Processing pass=0, turbine_depth=6 (42.9 %)\n", - "[Serial Refine] Processing pass=1, turbine_depth=0 (50.0 %)\n", - "[Serial Refine] Processing pass=1, turbine_depth=1 (57.1 %)\n", - "[Serial Refine] Processing pass=1, turbine_depth=2 (64.3 %)\n", - "[Serial Refine] Processing pass=1, turbine_depth=3 (71.4 %)\n", - "[Serial Refine] Processing pass=1, turbine_depth=4 (78.6 %)\n", - "[Serial Refine] Processing pass=1, turbine_depth=5 (85.7 %)\n", - "[Serial Refine] Processing pass=1, turbine_depth=6 (92.9 %)\n", - "CPU times: user 2.01 s, sys: 312 ms, total: 2.32 s\n", - "Wall time: 1.81 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "## Calculate the optimum yaw angles for 25 turbines and 72 wind directions\n", @@ -997,33 +918,10 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "686548be", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Wind Direction (Deg)')" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Show the results\n", "yaw_angles_opt = np.vstack(df_opt[\"yaw_angles_opt\"])\n", @@ -1056,7 +954,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.6" + "version": "3.10.2" } }, "nbformat": 4, From f0ff597c7016a411c20434106ff7ef7b874ab78b Mon Sep 17 00:00:00 2001 From: Paul Date: Mon, 28 Feb 2022 11:55:40 -0700 Subject: [PATCH 25/28] correct cp --- floris/turbine_library/iea_10MW.yaml | 102 +++++++++++++-------------- floris/turbine_library/nrel_5MW.yaml | 96 ++++++++++++------------- 2 files changed, 99 insertions(+), 99 deletions(-) diff --git a/floris/turbine_library/iea_10MW.yaml b/floris/turbine_library/iea_10MW.yaml index 7af856f8d..3576790a6 100644 --- a/floris/turbine_library/iea_10MW.yaml +++ b/floris/turbine_library/iea_10MW.yaml @@ -7,57 +7,57 @@ rotor_diameter: 198.0 TSR: 8.0 power_thrust_table: power: - - 0.0 - - 0.3251 - - 0.3762 - - 0.4027 - - 0.4156 - - 0.4230 - - 0.4274 - - 0.4293 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4298 - - 0.4305 - - 0.4312 - - 0.4313 - - 0.3514 - - 0.3112 - - 0.2750 - - 0.2426 - - 0.2138 - - 0.1884 - - 0.1661 - - 0.1465 - - 0.1294 - - 0.1144 - - 0.1013 - - 0.0899 - - 0.0800 - - 0.0713 - - 0.0637 - - 0.0571 - - 0.0513 - - 0.0462 - - 0.0417 - - 0.0378 - - 0.0344 + - 0.000000 + - 0.325100 + - 0.376200 + - 0.402700 + - 0.415600 + - 0.423000 + - 0.427400 + - 0.429300 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.429800 + - 0.430500 + - 0.438256 + - 0.425908 + - 0.347037 + - 0.307306 + - 0.271523 + - 0.239552 + - 0.211166 + - 0.186093 + - 0.164033 + - 0.144688 + - 0.127760 + - 0.112969 + - 0.100062 + - 0.088800 + - 0.078975 + - 0.070401 + - 0.062913 + - 0.056368 + - 0.050640 + - 0.045620 + - 0.041216 + - 0.037344 + - 0.033935 thrust: - 0.0 - 0.7701 diff --git a/floris/turbine_library/nrel_5MW.yaml b/floris/turbine_library/nrel_5MW.yaml index c839b9100..6d77fc1c4 100644 --- a/floris/turbine_library/nrel_5MW.yaml +++ b/floris/turbine_library/nrel_5MW.yaml @@ -7,54 +7,54 @@ rotor_diameter: 126.0 TSR: 8.0 power_thrust_table: power: - - 0.0 - - 0.0 - - 0.1780851 - - 0.28907459 - - 0.34902166 - - 0.3847278 - - 0.40605878 - - 0.4202279 - - 0.42882274 - - 0.43387274 - - 0.43622267 - - 0.43684468 - - 0.43657497 - - 0.43651053 - - 0.4365612 - - 0.43651728 - - 0.43590309 - - 0.43467276 - - 0.43322955 - - 0.43003137 - - 0.37655587 - - 0.33328466 - - 0.29700574 - - 0.26420779 - - 0.23839379 - - 0.21459275 - - 0.19382354 - - 0.1756635 - - 0.15970926 - - 0.14561785 - - 0.13287856 - - 0.12130194 - - 0.11219941 - - 0.10311631 - - 0.09545392 - - 0.08813781 - - 0.08186763 - - 0.07585005 - - 0.07071926 - - 0.06557558 - - 0.06148104 - - 0.05755207 - - 0.05413366 - - 0.05097969 - - 0.04806545 - - 0.04536883 - - 0.04287006 - - 0.04055141 + - 0.000000 + - 0.000000 + - 0.178085 + - 0.289075 + - 0.349022 + - 0.384728 + - 0.406059 + - 0.420228 + - 0.428823 + - 0.433873 + - 0.436223 + - 0.436845 + - 0.436575 + - 0.436511 + - 0.436561 + - 0.436517 + - 0.435903 + - 0.434673 + - 0.433230 + - 0.430466 + - 0.378869 + - 0.335199 + - 0.297991 + - 0.266092 + - 0.238588 + - 0.214748 + - 0.193981 + - 0.175808 + - 0.159835 + - 0.145741 + - 0.133256 + - 0.122157 + - 0.112257 + - 0.103399 + - 0.095449 + - 0.088294 + - 0.081836 + - 0.075993 + - 0.070692 + - 0.065875 + - 0.061484 + - 0.057476 + - 0.053809 + - 0.050447 + - 0.047358 + - 0.044518 + - 0.041900 + - 0.039483 thrust: - 1.19187945 - 1.17284634 From 70e9f2be19bc5749d76ea1a8b9897731cfce609e Mon Sep 17 00:00:00 2001 From: bayc Date: Mon, 28 Feb 2022 12:14:38 -0700 Subject: [PATCH 26/28] updating the examples for the latest code changes --- examples/00_getting_started.ipynb | 126 +++++++++----- examples/01_opening_floris_computing_power.py | 14 -- examples/02_visualizations.py | 3 - examples/04_sweep_wind_directions.py | 2 +- examples/05_sweep_wind_speeds.py | 2 +- examples/06_sweep_wind_conditions.py | 4 - examples/07_calc_aep_from_rose.py | 2 +- examples/08_opt_yaw_single_ws.py | 1 + examples/10_optimize_yaw.py | 6 +- examples/13_heterogeneous_inflow.py | 10 +- examples/14_multiple_turbine_types.py | 4 +- ...1_check_turbine.py => 15_check_turbine.py} | 4 +- ...streamlit_demo.py => 16_streamlit_demo.py} | 11 +- .../inputs/gch_multiple_turbine_types.yaml | 3 - .../inputs/turbine_definitions/iea_10MW.yaml | 164 ------------------ .../inputs/turbine_definitions/nrel_5MW.yaml | 155 ----------------- floris/tools/floris_interface.py | 12 +- .../yaw_optimization/yaw_optimization_base.py | 5 +- .../yaw_optimization_tools.py | 2 +- 19 files changed, 113 insertions(+), 417 deletions(-) rename examples/{11_check_turbine.py => 15_check_turbine.py} (98%) rename examples/{15_streamlit_demo.py => 16_streamlit_demo.py} (95%) delete mode 100644 examples/inputs/turbine_definitions/iea_10MW.yaml delete mode 100644 examples/inputs/turbine_definitions/nrel_5MW.yaml diff --git a/examples/00_getting_started.ipynb b/examples/00_getting_started.ipynb index fdf84a715..4bc946fce 100644 --- a/examples/00_getting_started.ipynb +++ b/examples/00_getting_started.ipynb @@ -265,16 +265,16 @@ "\n", "Turbine powers for 8 m/s\n", "Wind direction 0\n", - "[1691.32648289 1691.32648289 592.65288889 592.97819946]\n", + "[1691.32664838 1691.32664838 592.6531181 592.97842923]\n", "Wind direction 1\n", - "[1691.32648289 1691.32648289 1631.06709246 1629.75508349]\n", + "[1691.32664838 1691.32664838 1631.06744171 1629.75543674]\n", "\n", "Turbine powers for all turbines at all wind conditions\n", - "[[[1691.32648289 1691.32648289 592.65288889 592.97819946]\n", - " [2407.84258855 2407.84258855 861.30598083 861.73203268]]\n", + "[[[1691.32664838 1691.32664838 592.6531181 592.97842923]\n", + " [2407.84167188 2407.84167188 861.30649817 861.73255027]]\n", "\n", - " [[1691.32648289 1691.32648289 1631.06709246 1629.75508349]\n", - " [2407.84258855 2407.84258855 2321.41264704 2319.53233514]]]\n" + " [[1691.32664838 1691.32664838 1631.06744171 1629.75543674]\n", + " [2407.84167188 2407.84167188 2321.41247863 2319.53218301]]]\n" ] } ], @@ -468,23 +468,23 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "8bb179ff", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -501,16 +501,16 @@ "\n", "fig, axarr = plt.subplots(2, 2, figsize=(15,8))\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane( wd=[210] )\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[210] , height=90.0 )\n", "visualize_cut_plane(horizontal_plane, ax=axarr[0,0], title=\"210 - Aligned\")\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane( wd=[210], yaw_angles=yaw_angles[0:1,0:1] )\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[210], yaw_angles=yaw_angles[0:1,0:1] , height=90.0 )\n", "visualize_cut_plane(horizontal_plane, ax=axarr[0,1], title=\"210 - Yawed\")\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane( wd=[270] )\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[270] , height=90.0 )\n", "visualize_cut_plane(horizontal_plane, ax=axarr[1,0], title=\"270 - Aligned\")\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane( wd=[270], yaw_angles=yaw_angles[1:2,0:1] )\n", + "horizontal_plane = fi.calculate_horizontal_plane( wd=[270], yaw_angles=yaw_angles[1:2,0:1] , height=90.0 )\n", "visualize_cut_plane(horizontal_plane, ax=axarr[1,1], title=\"270 - Yawed\")" ] }, @@ -524,7 +524,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "3e517614", "metadata": {}, "outputs": [ @@ -534,7 +534,7 @@ "Text(0.5, 0.98, 'Wind direction 270')" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, @@ -600,7 +600,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "774acfea", "metadata": {}, "outputs": [ @@ -617,7 +617,7 @@ "(0.0, 150.0)" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -684,7 +684,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "f63a2195", "metadata": {}, "outputs": [ @@ -708,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "ee1918d6", "metadata": {}, "outputs": [ @@ -737,7 +737,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "6a381dc7", "metadata": {}, "outputs": [], @@ -750,7 +750,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "7547d804", "metadata": {}, "outputs": [], @@ -771,7 +771,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "702bb7ee", "metadata": {}, "outputs": [ @@ -779,8 +779,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4.17 s, sys: 1.67 s, total: 5.84 s\n", - "Wall time: 4.9 s\n" + "CPU times: user 3.11 s, sys: 156 ms, total: 3.27 s\n", + "Wall time: 2.5 s\n" ] } ], @@ -792,7 +792,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "8b688add", "metadata": {}, "outputs": [ @@ -800,8 +800,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6.57 s, sys: 2.55 s, total: 9.12 s\n", - "Wall time: 7.94 s\n" + "CPU times: user 4.81 s, sys: 78.1 ms, total: 4.89 s\n", + "Wall time: 4.04 s\n" ] } ], @@ -813,7 +813,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "627f5242", "metadata": {}, "outputs": [], @@ -825,7 +825,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "394ab742", "metadata": {}, "outputs": [ @@ -833,8 +833,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Jensen 843.1 GWh\n", - "GCH 843.8 GWh\n" + "Jensen 843.2 GWh\n", + "GCH 843.9 GWh\n" ] } ], @@ -863,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "32a93c6d", "metadata": {}, "outputs": [], @@ -878,7 +878,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "7d773cdc", "metadata": {}, "outputs": [], @@ -898,14 +898,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "1ccb9ab7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Serial Refine] Processing pass=0, turbine_depth=0 (0.0 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=1 (7.1 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=2 (14.3 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=3 (21.4 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=4 (28.6 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=5 (35.7 %)\n", + "[Serial Refine] Processing pass=0, turbine_depth=6 (42.9 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=0 (50.0 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=1 (57.1 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=2 (64.3 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=3 (71.4 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=4 (78.6 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=5 (85.7 %)\n", + "[Serial Refine] Processing pass=1, turbine_depth=6 (92.9 %)\n", + "CPU times: user 2.28 s, sys: 266 ms, total: 2.55 s\n", + "Wall time: 2.05 s\n" + ] + } + ], "source": [ "%%time\n", "## Calculate the optimum yaw angles for 25 turbines and 72 wind directions\n", - "df_opt = yaw_opt._optimize()" + "df_opt = yaw_opt.optimize()" ] }, { @@ -918,10 +941,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "686548be", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Wind Direction (Deg)')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Show the results\n", "yaw_angles_opt = np.vstack(df_opt[\"yaw_angles_opt\"])\n", @@ -954,7 +1000,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.2" + "version": "3.8.0" } }, "nbformat": 4, diff --git a/examples/01_opening_floris_computing_power.py b/examples/01_opening_floris_computing_power.py index e39ce0f07..5cbe863d7 100644 --- a/examples/01_opening_floris_computing_power.py +++ b/examples/01_opening_floris_computing_power.py @@ -76,17 +76,3 @@ print('The turbine power matrix should be of dimensions 3 WD X 3 WS X 2 Turbines') print(turbine_powers) print("Shape: ",turbine_powers.shape) - - - - -# # Make a small plot -# fig, ax = plt.subplots() -# ax.plot(wind_speeds, turbine_powers[:,:,0].flatten(), color='k', marker='o', label='Turbine 0' ) -# ax.plot(wind_speeds, turbine_powers[:,:,1].flatten(), color='r', marker='o', label='Turbine 1' ) -# ax.grid() -# ax.legend() -# ax.set_ylabel('Power (kW)') -# ax.set_xlabel('Wind Speed (m/s)') -# plt.show() - diff --git a/examples/02_visualizations.py b/examples/02_visualizations.py index bb60b1767..18d7bbd4d 100644 --- a/examples/02_visualizations.py +++ b/examples/02_visualizations.py @@ -85,11 +85,8 @@ # on the turbine grids fi.calculate_wake() - # Plot the values at each rotor fig, axes, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, n_cols=3, return_fig_objects=True) fig.suptitle("Rotor Plane Visualization, 10x10 Resolution") - - plt.show() diff --git a/examples/04_sweep_wind_directions.py b/examples/04_sweep_wind_directions.py index beda79178..d2d32938d 100644 --- a/examples/04_sweep_wind_directions.py +++ b/examples/04_sweep_wind_directions.py @@ -72,4 +72,4 @@ ax.legend() ax.set_xlabel('Wind Direction (deg)') ax.set_ylabel('Power (kW)') -plt.show() \ No newline at end of file +plt.show() diff --git a/examples/05_sweep_wind_speeds.py b/examples/05_sweep_wind_speeds.py index 7cdc805ba..70e353c7b 100644 --- a/examples/05_sweep_wind_speeds.py +++ b/examples/05_sweep_wind_speeds.py @@ -72,4 +72,4 @@ ax.legend() ax.set_xlabel('Wind Speed (m/s)') ax.set_ylabel('Power (kW)') -plt.show() \ No newline at end of file +plt.show() diff --git a/examples/06_sweep_wind_conditions.py b/examples/06_sweep_wind_conditions.py index 4ce8d0c4f..975701d6a 100644 --- a/examples/06_sweep_wind_conditions.py +++ b/examples/06_sweep_wind_conditions.py @@ -44,7 +44,6 @@ layout_y = [0, 0, 0, 0, 0] fi.reinitialize(layout = [layout_x, layout_y]) - # Define a ws and wd to sweep # Note that all combinations will be computed ws_array = np.arange(6, 9, 1.) @@ -65,7 +64,6 @@ # Collect the turbine powers turbine_powers = fi.get_turbine_powers() / 1E3 # In kW - # Show results by ws and wd fig, axarr = plt.subplots(num_ws, 1, sharex=True,sharey=True,figsize=(6,10)) for ws_idx, ws in enumerate(ws_array): @@ -78,7 +76,6 @@ ax.set_ylabel('Power (kW)') ax.set_xlabel('Wind Direction (deg)') - # Sum across wind speeds and directions to show energy produced by turbine as bar plot energy_by_turbine = np.sum(turbine_powers, axis=(0,1)) # Sum over wind direction (0-axis) and wind speed (1-axis) fig, ax = plt.subplots() @@ -86,4 +83,3 @@ ax.set_title('Energy Produced by Turbine') plt.show() - diff --git a/examples/07_calc_aep_from_rose.py b/examples/07_calc_aep_from_rose.py index d1701112c..b10c6771a 100644 --- a/examples/07_calc_aep_from_rose.py +++ b/examples/07_calc_aep_from_rose.py @@ -82,4 +82,4 @@ # Finally, calculate AEP in GWh aep = np.dot(df_wr["freq_val"], df_wr["farm_power"]) * 365 * 24 -print("Farm AEP: {:.3f} GWh".format(aep / 1.0e9)) \ No newline at end of file +print("Farm AEP: {:.3f} GWh".format(aep / 1.0e9)) diff --git a/examples/08_opt_yaw_single_ws.py b/examples/08_opt_yaw_single_ws.py index 7d2a87048..cc29d0e26 100644 --- a/examples/08_opt_yaw_single_ws.py +++ b/examples/08_opt_yaw_single_ws.py @@ -36,6 +36,7 @@ wind_directions=np.arange(0.0, 360.0, 3.0), wind_speeds=[8.0], ) +print(fi.floris.farm.rotor_diameters) # Initialize optimizer object and run optimization using the Serial-Refine method yaw_opt = YawOptimizationSR(fi)#, exploit_layout_symmetry=False) diff --git a/examples/10_optimize_yaw.py b/examples/10_optimize_yaw.py index 59ad138eb..9789ef33e 100644 --- a/examples/10_optimize_yaw.py +++ b/examples/10_optimize_yaw.py @@ -42,8 +42,8 @@ def load_floris(): # Specify wind farm layout and update in the floris object N = 5 # number of turbines per row and per column X, Y = np.meshgrid( - 5.0 * fi.floris.grid.reference_turbine_diameter * np.arange(0, N, 1), - 5.0 * fi.floris.grid.reference_turbine_diameter * np.arange(0, N, 1), + 5.0 * fi.floris.farm.rotor_diameters[0][0][0] * np.arange(0, N, 1), + 5.0 * fi.floris.farm.rotor_diameters[0][0][0] * np.arange(0, N, 1), ) fi.reinitialize(layout=(X.flatten(), Y.flatten())) @@ -134,7 +134,7 @@ def calculate_aep(fi, df_windrose, column_name="farm_power"): exploit_layout_symmetry=True, ) - df_opt = yaw_opt._optimize() + df_opt = yaw_opt.optimize() end_time = timerpc() t_tot = end_time - start_time t_fi = yaw_opt.time_spent_in_floris diff --git a/examples/13_heterogeneous_inflow.py b/examples/13_heterogeneous_inflow.py index e1b093198..2eb4ea34e 100644 --- a/examples/13_heterogeneous_inflow.py +++ b/examples/13_heterogeneous_inflow.py @@ -55,8 +55,8 @@ # Using the FlorisInterface functions for generating plots, run FLORIS # and extract 2D planes of data. -horizontal_plane_2d = fi_2d.calculate_horizontal_plane(x_resolution=200, y_resolution=100) -y_plane_2d = fi_2d.calculate_y_plane(x_resolution=200, z_resolution=100) +horizontal_plane_2d = fi_2d.calculate_horizontal_plane(x_resolution=200, y_resolution=100, height=90.0) +y_plane_2d = fi_2d.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) cross_plane_2d = fi_2d.calculate_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=500.0) # Create the plots @@ -90,9 +90,9 @@ # Using the FlorisInterface functions for generating plots, run FLORIS # and extract 2D planes of data. -horizontal_plane_3d = fi_3d.calculate_horizontal_plane(x_resolution=200, y_resolution=100) -y_plane_3d = fi_3d.calculate_y_plane(x_resolution=200, z_resolution=100) -cross_plane_3d = fi_3d.calculate_cross_plane(y_resolution=100, z_resolution=100) +horizontal_plane_3d = fi_3d.calculate_horizontal_plane(x_resolution=200, y_resolution=100, height=90.0) +y_plane_3d = fi_3d.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) +cross_plane_3d = fi_3d.calculate_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=500.0) # Create the plots fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) diff --git a/examples/14_multiple_turbine_types.py b/examples/14_multiple_turbine_types.py index 8d86e7481..feb23bf7c 100644 --- a/examples/14_multiple_turbine_types.py +++ b/examples/14_multiple_turbine_types.py @@ -32,8 +32,8 @@ # Using the FlorisInterface functions for generating plots, run FLORIS # and extract 2D planes of data. horizontal_plane = fi.calculate_horizontal_plane(x_resolution=200, y_resolution=100, height=90) -y_plane = fi.calculate_y_plane(x_resolution=200, z_resolution=100) -cross_plane = fi.calculate_cross_plane(y_resolution=100, z_resolution=100) +y_plane = fi.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) +cross_plane = fi.calculate_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=500.0) # Create the plots fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) diff --git a/examples/11_check_turbine.py b/examples/15_check_turbine.py similarity index 98% rename from examples/11_check_turbine.py rename to examples/15_check_turbine.py index f5c9d95fd..435bdde2b 100644 --- a/examples/11_check_turbine.py +++ b/examples/15_check_turbine.py @@ -38,7 +38,7 @@ fi.reinitialize(wind_speeds=ws_array) # Get a list of available turbine models -turbines = os.listdir('inputs/turbine_definitions') +turbines = os.listdir('../floris/turbine_library') turbines = [t.strip('.yaml') for t in turbines] # For each turbine model available plot the basic info @@ -47,8 +47,6 @@ # Set t as the turbine fi.reinitialize(turbine_type=[t]) - - # Create a figure fig, axarr = plt.subplots(1,2,figsize=(10,5)) diff --git a/examples/15_streamlit_demo.py b/examples/16_streamlit_demo.py similarity index 95% rename from examples/15_streamlit_demo.py rename to examples/16_streamlit_demo.py index 7a3a58452..3cd5090bb 100644 --- a/examples/15_streamlit_demo.py +++ b/examples/16_streamlit_demo.py @@ -31,7 +31,7 @@ # (with your FLORIS environment enabled) # pip install streamlit -# streamlit run 12_streamlit_demo.py +# streamlit run 16_streamlit_demo.py # """ @@ -130,7 +130,7 @@ ax_idx = floris_models_viz.index(fm) ax = axarr_viz[ax_idx, 0] - horizontal_plane_gch = fi.calculate_horizontal_plane(x_resolution=100, y_resolution=100, yaw_angles=yaw_angles_base) + horizontal_plane_gch = fi.calculate_horizontal_plane(x_resolution=100, y_resolution=100, yaw_angles=yaw_angles_base, height=90.0) visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - baseline' % fm) # Analyze the yawed case================================================== @@ -140,7 +140,6 @@ # Set the layout, wind direction and wind speed fi.reinitialize( layout=( X, Y ), wind_speeds=[wind_speed], wind_directions=[wind_direction], turbulence_intensity=turbulence_intensity ) - fi.calculate_wake(yaw_angles=yaw_angles_yaw) turbine_powers = fi.get_turbine_powers() / 1000. ax_turb_pow.plot(turbine_labels,turbine_powers.flatten(),color=color_dict[fm],ls='--',marker='o',label='%s - yawed' % fm) @@ -157,10 +156,10 @@ ax_idx = floris_models_viz.index(fm) ax = axarr_viz[ax_idx, 1] - horizontal_plane_gch = fi.calculate_horizontal_plane(x_resolution=100, y_resolution=100, yaw_angles=yaw_angles_yaw) + horizontal_plane_gch = fi.calculate_horizontal_plane(x_resolution=100, y_resolution=100, yaw_angles=yaw_angles_yaw, height=90.0) visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - yawed' % fm) -st.header("Visualizations") +st.header("Visualizations") st.write(fig_viz) st.header("Power Comparison") -st.write(fig_turb_pow) \ No newline at end of file +st.write(fig_turb_pow) diff --git a/examples/inputs/gch_multiple_turbine_types.yaml b/examples/inputs/gch_multiple_turbine_types.yaml index 08416505b..72b593766 100644 --- a/examples/inputs/gch_multiple_turbine_types.yaml +++ b/examples/inputs/gch_multiple_turbine_types.yaml @@ -28,9 +28,6 @@ farm: - nrel_5MW - nrel_5MW - iea_10MW - turbine_definitions: - nrel_5MW: !include turbine_definitions/nrel_5MW.yaml - iea_10MW: !include turbine_definitions/iea_10MW.yaml flow_field: air_density: 1.225 diff --git a/examples/inputs/turbine_definitions/iea_10MW.yaml b/examples/inputs/turbine_definitions/iea_10MW.yaml deleted file mode 100644 index 3576790a6..000000000 --- a/examples/inputs/turbine_definitions/iea_10MW.yaml +++ /dev/null @@ -1,164 +0,0 @@ -turbine_type: 'iea_10MW' -generator_efficiency: 1.0 -hub_height: 119.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 198.0 -TSR: 8.0 -power_thrust_table: - power: - - 0.000000 - - 0.325100 - - 0.376200 - - 0.402700 - - 0.415600 - - 0.423000 - - 0.427400 - - 0.429300 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.430500 - - 0.438256 - - 0.425908 - - 0.347037 - - 0.307306 - - 0.271523 - - 0.239552 - - 0.211166 - - 0.186093 - - 0.164033 - - 0.144688 - - 0.127760 - - 0.112969 - - 0.100062 - - 0.088800 - - 0.078975 - - 0.070401 - - 0.062913 - - 0.056368 - - 0.050640 - - 0.045620 - - 0.041216 - - 0.037344 - - 0.033935 - thrust: - - 0.0 - - 0.7701 - - 0.7763 - - 0.7824 - - 0.7820 - - 0.7802 - - 0.7772 - - 0.7719 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7675 - - 0.7651 - - 0.7587 - - 0.5056 - - 0.4310 - - 0.3708 - - 0.3209 - - 0.2788 - - 0.2432 - - 0.2128 - - 0.1868 - - 0.1645 - - 0.1454 - - 0.1289 - - 0.1147 - - 0.1024 - - 0.0918 - - 0.0825 - - 0.0745 - - 0.0675 - - 0.0613 - - 0.0559 - - 0.0512 - - 0.0470 - wind_speed: - - 0.0000 - - 4.0000 - - 4.5147 - - 5.0008 - - 5.4574 - - 5.8833 - - 6.2777 - - 6.6397 - - 6.9684 - - 7.2632 - - 7.5234 - - 7.7484 - - 7.9377 - - 8.0909 - - 8.2077 - - 8.2877 - - 8.3308 - - 8.3370 - - 8.3678 - - 8.4356 - - 8.5401 - - 8.6812 - - 8.8585 - - 9.0717 - - 9.3202 - - 9.6035 - - 9.9210 - - 10.2720 - - 10.6557 - - 10.7577 - - 11.5177 - - 11.9941 - - 12.4994 - - 13.0324 - - 13.5920 - - 14.1769 - - 14.7859 - - 15.4175 - - 16.0704 - - 16.7432 - - 17.4342 - - 18.1421 - - 18.8652 - - 19.6019 - - 20.3506 - - 21.1096 - - 21.8773 - - 22.6519 - - 23.4317 - - 24.2150 - - 25.0000 diff --git a/examples/inputs/turbine_definitions/nrel_5MW.yaml b/examples/inputs/turbine_definitions/nrel_5MW.yaml deleted file mode 100644 index 6d77fc1c4..000000000 --- a/examples/inputs/turbine_definitions/nrel_5MW.yaml +++ /dev/null @@ -1,155 +0,0 @@ -turbine_type: 'nrel_5MW' -generator_efficiency: 1.0 -hub_height: 90.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 126.0 -TSR: 8.0 -power_thrust_table: - power: - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - thrust: - - 1.19187945 - - 1.17284634 - - 1.09860817 - - 1.02889592 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 - wind_speed: - - 2.0 - - 2.5 - - 3.0 - - 3.5 - - 4.0 - - 4.5 - - 5.0 - - 5.5 - - 6.0 - - 6.5 - - 7.0 - - 7.5 - - 8.0 - - 8.5 - - 9.0 - - 9.5 - - 10.0 - - 10.5 - - 11.0 - - 11.5 - - 12.0 - - 12.5 - - 13.0 - - 13.5 - - 14.0 - - 14.5 - - 15.0 - - 15.5 - - 16.0 - - 16.5 - - 17.0 - - 17.5 - - 18.0 - - 18.5 - - 19.0 - - 19.5 - - 20.0 - - 20.5 - - 21.0 - - 21.5 - - 22.0 - - 22.5 - - 23.0 - - 23.5 - - 24.0 - - 24.5 - - 25.0 - - 25.5 diff --git a/floris/tools/floris_interface.py b/floris/tools/floris_interface.py index 4ec24322c..fa2366520 100644 --- a/floris/tools/floris_interface.py +++ b/floris/tools/floris_interface.py @@ -258,7 +258,7 @@ def get_plane_of_points( def calculate_horizontal_plane( self, - height=None, + height, x_resolution=200, y_resolution=200, x_bounds=None, @@ -294,8 +294,6 @@ def calculate_horizontal_plane( ws = self.floris.flow_field.wind_speeds self.check_wind_condition_for_viz(wd=wd, ws=ws) - # If height not provided, use the hub height - # Store the current state for reinitialization floris_dict = self.floris.as_dict() @@ -339,7 +337,7 @@ def calculate_horizontal_plane( def calculate_cross_plane( self, - downstream_dist=None, + downstream_dist, y_resolution=200, z_resolution=200, y_bounds=None, @@ -419,7 +417,7 @@ def calculate_cross_plane( def calculate_y_plane( self, - crossstream_dist=None, + crossstream_dist, x_resolution=200, z_resolution=200, x_bounds=None, @@ -455,10 +453,6 @@ def calculate_y_plane( ws = self.floris.flow_field.wind_speeds self.check_wind_condition_for_viz(wd=wd, ws=ws) - # If crossstream distance is not provided, use the default - if crossstream_dist is None: - crossstream_dist = 0.0 - # Store the current state for reinitialization floris_dict = self.floris.as_dict() diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py b/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py index 20df0847e..1d72c4bd2 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py +++ b/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py @@ -19,6 +19,7 @@ import pandas as pd from ....utilities import wrap_360 +from floris.tools import FlorisInterface from .yaw_optimization_tools import ( derive_downstream_turbines, @@ -117,7 +118,7 @@ def __init__( """ # Save turbine object to self - self.fi = copy.deepcopy(fi) + self.fi = FlorisInterface(fi.floris.as_dict()) self.nturbs = len(self.fi.layout_x) # # Check floris options @@ -251,7 +252,7 @@ def _reduce_control_problem(self): self.turbs_to_opt = (self.maximum_yaw_angle - self.minimum_yaw_angle >= 0.001) # Initialize subset variables as full set - self.fi_subset = copy.deepcopy(self.fi) + self.fi_subset = FlorisInterface(self.fi.floris.as_dict()) nwinddirections_subset = copy.deepcopy(self.fi.floris.flow_field.n_wind_directions) minimum_yaw_angle_subset = copy.deepcopy(self.minimum_yaw_angle) maximum_yaw_angle_subset = copy.deepcopy(self.maximum_yaw_angle) diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py b/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py index b8dcd3e51..2a25d8074 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py +++ b/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py @@ -53,7 +53,7 @@ def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=F # Get farm layout x = fi.layout_x y = fi.layout_y - D = np.ones_like(x) * fi.floris.turbine.rotor_diameter + D = np.ones_like(x) * fi.floris.farm.rotor_diameters[0][0][0] n_turbs = len(x) # Rotate farm and determine freestream/waked turbines From 79603d6cc444188a40baf65c6d1a519f92431e26 Mon Sep 17 00:00:00 2001 From: bayc Date: Mon, 28 Feb 2022 12:23:40 -0700 Subject: [PATCH 27/28] adding missing crossstream_dist --- examples/03_making_adjustments.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/03_making_adjustments.py b/examples/03_making_adjustments.py index fbb8a00cb..d3eef7310 100644 --- a/examples/03_making_adjustments.py +++ b/examples/03_making_adjustments.py @@ -48,7 +48,7 @@ # Change the wind shear, reset the wind speed, and plot a vertical slice fi.reinitialize( wind_shear=0.2, wind_speeds=[8.0] ) -y_plane = fi.calculate_y_plane() +y_plane = fi.calculate_y_plane(crossstream_dist=0.0) visualize_cut_plane(y_plane, ax=axarr[2], title="Wind shear at 0.2", minSpeed=MIN_WS, maxSpeed=MAX_WS) From 70a365ccbfe55bc2fc9e721730b783c9ecbf2eac Mon Sep 17 00:00:00 2001 From: Paul Date: Mon, 28 Feb 2022 13:08:06 -0700 Subject: [PATCH 28/28] ignore slsqp outputs --- .gitignore | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index ab6f7f523..c15d43fca 100644 --- a/.gitignore +++ b/.gitignore @@ -24,6 +24,8 @@ pip-wheel-metadata examples/cp_ct_cq_lut.p _site/ .jekyll-cache/ +examples/hist.hist +examples/SLSQP.out # Log files -*.log +*.log \ No newline at end of file