diff --git a/notebooks/contrib-dev/Membrane_Model_Transport_Parameters_Tiago_T_M_Zanon_and_Pratham_Singh.ipynb b/notebooks/contrib-dev/Membrane_Model_Transport_Parameters_Tiago_T_M_Zanon_and_Pratham_Singh.ipynb new file mode 100644 index 00000000..78dbf230 --- /dev/null +++ b/notebooks/contrib-dev/Membrane_Model_Transport_Parameters_Tiago_T_M_Zanon_and_Pratham_Singh.ipynb @@ -0,0 +1,990 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Empirical Estimation of Membrane Model Transport Parameters and Performing Model Comparison\n", + "Prepared by Tiago Thomaz Migliati Zanon (tmigliat@nd.edu) and Pratham Singh (psingh4@nd.edu)\n", + "\n", + "**Reference:** The problem is inspired by this research paper: *Haim, O.P., et al., “The adverse effect of concentration polarization on ion-ion selectivity in Nanofiltration” Environmental Science and Technology Letters, 2023 10 (4), 363-371, https://doi.org/10.1021/acs.estlett.3c00124\n", + "\n", + "**Objectives:**\n", + "\n", + "1. Apply knowledge of non-linear regression to find empirical parameters of a\n", + " membrane mass transport model.\n", + "2. Compare two membrane transport models.\n", + "3. Plot and visualize the data.\n", + "\n", + "**Target Audience:** Chemical engineering students.\n", + "\n", + "**Helpful Notebooks to Reference:**\n", + "https://ndcbe.github.io/data-and-computing/notebooks/15/Nonlinear-Regression.html\n", + "\n" + ], + "metadata": { + "id": "sf6fV-Z4IHkp" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Overview: Membrane Transport Model Problem" + ], + "metadata": { + "id": "wBmlIH--KzTE" + } + }, + { + "cell_type": "markdown", + "source": [ + "In the realm of pressure-driven membrane processes, the membrane transport model is crucial for design, development, and optimization. The prevalent Solution Diffusion (SD) model, widely integrated into industrial software, serves as a cornerstone. Another common membrane transport model is Speigler Kedem (SK) Model.\n", + "\n", + "\n", + "\n", + "To validate the applicability of these model, a researcher conducted a specific experiment focusing on Cesium Chloride salt within a nanofiltration filtration system. This experiment involved varied constant flux settings, allowing the observation and measurement of salt rejection across these different flux conditions. The outcomes provide insights into the performance and behavior of the membrane in relation to salt rejection at varying flux. The flux and rejection data is provided in the table below:\n", + "\n", + "\n", + "| Flux (m/s) | Rejection |\n", + "|-|-|\n", + "| 0.000101 | 0.711336|\n", + "| 9.66E-05 | 0.725415|\n", + "|0.000106 | 0.693630|\n", + "|7.97E-05 | 0.711082|\n", + "|7.62E-05\t | 0.728779|\n", + "|8.36E-05\t | 0.699976|\n", + "|5.54E-05\t | 0.702056|\n", + "|5.33E-05\t | 0.705363|\n", + "|5.75E-05\t | 0.669026|\n", + "|3.08E-05\t | 0.637065|\n", + "|2.94E-05\t | 0.646364|\n", + "|3.18E-05\t | 0.598409|\n", + "|4.62E-06\t | 0.408793|\n", + "|4.39E-06\t | 0.299547|\n", + "|4.71E-06\t | 0.290317|\n", + "\n", + "Based on the data provided above we will estimate the salt permeability $ω$ and mass transfer coefficient $k$ using the Solution Diffusion (SD) model and Speigler Kedem (SK) Model.\n" + ], + "metadata": { + "id": "ziHaTbw_LDMD" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Import Libraries" + ], + "metadata": { + "id": "5gDekyz_VVAD" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from scipy.optimize import curve_fit\n", + "from scipy.optimize import least_squares\n", + "from scipy.stats.distributions import t\n", + "import scipy.stats as stats\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import minimize, brute, fmin, fminbound" + ], + "metadata": { + "id": "5d_AcXtTUFcM" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "##1. Solution Diffusion Model" + ], + "metadata": { + "id": "jQDINZ5HYk6c" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Solution Diffusion Model:** The solution-diffusion model is a widely accepted theory that explains the mechanism of membrane transport, particularly in processes like nanofiltration, gas permeation, and dialysis. This model describes how substances move across a semipermeable membrane based on two steps: partioning and diffusion. The governing equation for the model is given below:\n", + "\n", + "$$\n", + "\\frac{Rs}{1 - Rs} = J \\omega e^{\\frac{J}{k}}\n", + "$$\n", + "\n", + "\n", + "The Solution Diffusion (SD) model, expressed by the equation, encapsulates the relationship between salt rejection **Rs** and volumetric flux **J**. In this equation, **Rs** denotes the salt rejection while **J** represents the volumetric flux. The exponent **k** embodies a crucial parameter called mass transfer coefficient." + ], + "metadata": { + "id": "5JtRc155X2WK" + } + }, + { + "cell_type": "markdown", + "source": [ + "###1a. Define SD Model" + ], + "metadata": { + "id": "RHh0b0DmVlnS" + } + }, + { + "cell_type": "code", + "source": [ + "# Add Given Values\n", + "J = np.array([0.000100556, 9.65556E-05, 0.000106222, 7.96667E-05, 7.62222E-05, 8.35556E-05, 5.54074E-05, 5.32593E-05, 5.74815E-05, 3.08148E-05, 2.94074E-05, 3.17778E-05, 4.62222E-06, 4.38889E-06, 4.71111E-06, ])\n", + "Rs = np.array([0.711335686, 0.725415137, 0.693629708, 0.711081808, 0.728778719, 0.699976459, 0.702056047, 0.705362585, 0.669026222, 0.637064923, 0.646363643, 0.598409327, 0.408793422, 0.299546904, 0.290317167, ])\n", + "\n", + "# Convert Rs to Y, where Y is Rs/1-Rs\n", + "Y = Rs/(1-Rs)\n", + "\n", + "# Print Y\n", + "print('Y =',Y)\n", + "\n", + "# Define SD model function\n", + "def SD_Model(theta, J_vals):\n", + " '''\n", + " Function to define SD model\n", + " Arguments:\n", + " J: Volumetric Flux in m/s\n", + " Omega: Salt permeability to be fitted\n", + " k: Mass Transfer coefficient to be fitted by regression\n", + " Returns:\n", + " model: computed value of Rejection by Passage i.e., Y\n", + "\n", + " '''\n", + " omega, k = theta\n", + " Y_vals = J_vals / (omega * np.exp(J_vals / k))\n", + " return Y_vals\n", + "\n", + "def regression_model(theta, J_vals, data):\n", + " Y_pred = SD_Model(theta, J_vals)\n", + " return data - Y_pred\n" + ], + "metadata": { + "id": "F4a5AsQBW-sg", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "543043ec-947c-444d-e32f-131de9c5a9a0" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Y = [2.46423147 2.64186135 2.26402405 2.46118738 2.68702631 2.33307179\n", + " 2.35633595 2.39400208 2.02138739 1.75531373 1.82776355 1.49009767\n", + " 0.69145615 0.42764734 0.40908016]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###1b. Perform Non-Linear Regresssion\n", + "\n" + ], + "metadata": { + "id": "hYlsSg-eYtDw" + } + }, + { + "cell_type": "markdown", + "source": [ + "Next, our approach involves non-linear regression through least squares. In Python, the `scipy.optimize` library offers a range of tools tailored for this purpose. Among these tools, the `least_squares` function in this problem. It facilitates the precise fitting of a user-defined function to our data by dynamically adjusting its parameters." + ], + "metadata": { + "id": "jml5leLeMZgC" + } + }, + { + "cell_type": "code", + "source": [ + "theta_guess = [1e-5, 1e-5]\n", + "J_pred = np.linspace(0, 1.2e-4, 100) # Continuous range of J values\n", + "result = least_squares(fun=regression_model, x0=theta_guess, args=(J, Y))\n", + "omega, k = result.x\n", + "\n", + "\n", + "# print the estimated parameters\n", + "print('\\nSalt Permeability:',omega,'m/s')\n", + "print('\\nMass Transfer Coefficient:',k,'m/s')" + ], + "metadata": { + "id": "GDe95X8EZbFH", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b6a28df8-0375-4a1a-dd44-b5be9ae49bdd" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Salt Permeability: 1.2295488069945402e-05 m/s\n", + "\n", + "Mass Transfer Coefficient: 8.285491906853397e-05 m/s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now calculate the jacobian, variance, and covariance matrix.\n", + "\n", + "$$\n", + "\\Sigma_{\\theta} \\approx \\hat{\\sigma}_e^2 (J^T J)^{-1}\n", + "$$\n", + "\n", + "where $J$ is the Jacobian of the residuals w.r.t. $\\theta$:\n", + "\n", + "$$\n", + "J_{i,j} = \\frac{\\partial(y_i - \\hat{y}_i)}{\\partial \\theta_j}\n", + "$$" + ], + "metadata": { + "id": "qdIPlIxeGK5B" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluating Jacobian Matrix\n", + "Jac = result.jac\n", + "print('Jacobian Matrix\\n', Jac)\n", + "# Finding variance using Jacobian Matrix\n", + "jac_inv = np.linalg.inv(np.dot(Jac.T, Jac))\n", + "vari = J.flatten() - SD_Model(result.x, J)\n", + "variance = np.var(vari)\n", + "print('\\nVariance',variance)\n", + "# Covariance Matrix\n", + "covari= variance * jac_inv\n", + "print('\\nCovariance Matrix\\n',covari)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z4au4c2jGYiC", + "outputId": "5461dbca-3b98-41e0-8ee4-0ec46f9836be" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Jacobian Matrix\n", + " [[197384.70973459 -35589.83511561]\n", + " [198907.69505805 -34437.50234604]\n", + " [194724.65384638 -37088.78140831]\n", + " [201222.36077487 -28744.03298721]\n", + " [200694.59280479 -27429.01189399]\n", + " [201368.16640416 -30169.13408157]\n", + " [187553.57907364 -18632.72308111]\n", + " [185017.40073627 -17668.11507392]\n", + " [189764.08532447 -19558.083397 ]\n", + " [140353.14381914 -7754.48768699]\n", + " [136237.44325176 -7183.30096279]\n", + " [143066.82308486 -8151.4492121 ]\n", + " [ 28880.52656727 -239.33983567]\n", + " [ 27499.96997012 -216.39442838]\n", + " [ 29404.36543629 -248.36727186]]\n", + "\n", + "Variance 0.6387460257033314\n", + "\n", + "Covariance Matrix\n", + " [[1.48583762e-11 1.02883711e-10]\n", + " [1.02883711e-10 7.97143553e-10]]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###1c. Plot Residuals" + ], + "metadata": { + "id": "PPgYgIquaVPF" + } + }, + { + "cell_type": "markdown", + "source": [ + "After conducting linear regression analysis, examining residuals becomes essential to evaluate the model's performance and assumptions. Residuals represent the discrepancies between the observed data points and the values predicted by the regression model. Analyzing these residuals helps in assessing the goodness-of-fit, identifying patterns or outliers that the model might have missed, and validating the assumptions underlying the regression analysis.\n", + "\n", + "$$\n", + "\\underbrace{e_i}_{\\mathrm{residual}} = \\underbrace{y_i}_\\mathrm{observation} - \\underbrace{\\hat{y}_i}_{\\mathrm{prediction}}\n", + "$$\n", + "\n", + "Now you should do the following:\n", + "\n", + "1. Calculate the residuals\n", + "\n", + "2. Plot the residuals vs. Volumetric Flux (m/s)" + ], + "metadata": { + "id": "fVBAB4GekkTT" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate the fitted values using the obtained parameters\n", + "fitted_values = SD_Model(result.x, J_pred)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Calculate residuals\n", + "sd_residuals = Y - SD_Model(result.x, J)\n", + "\n", + "# Plot residuals\n", + "plt.figure(figsize=(8, 5))\n", + "plt.scatter(J, sd_residuals, color='red', label='Residuals')\n", + "plt.axhline(y=0, color='black', linestyle='--')\n", + "plt.xlabel('Volumetric Flux (m/s)')\n", + "plt.ylabel('Residuals (dimensionless)')\n", + "plt.legend()\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.title('SD Model Residuals Plot')\n", + "plt.show()\n" + ], + "metadata": { + "id": "0FDyrZDHadWo", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "outputId": "4f6cee31-16b5-4170-b883-5809fe099b14" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###1d. Plot fitted model and Prediction Interval" + ], + "metadata": { + "id": "gKjZAu_ipjbj" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate standard deviation of residuals\n", + "residual_std = np.std(sd_residuals, ddof=len(result.x))\n", + "\n", + "# Degrees of freedom (modify this according to your specific case)\n", + "dof = len(J) - len(result.x)\n", + "\n", + "# Calculate t-distribution for 95% prediction interval\n", + "t_distribution = t.ppf(0.975, df=dof)\n", + "prediction_interval = t_distribution * residual_std * np.sqrt(1 + variance)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot the data points\n", + "plt.scatter(J, Rs, label='Data Points')\n", + "\n", + "# Plot the fitted model\n", + "plt.plot(J_pred, Rs_fitted, label='Solution Diffusion Fitted Model', color='red')\n", + "\n", + "# Plotting the prediction interval\n", + "plt.fill_between(J_pred, Rs_fitted - prediction_interval, Rs_fitted + prediction_interval,\n", + " color='lightgreen', alpha=0.2, label='95% Prediction Interval')\n", + "\n", + "plt.xlabel('Volumetric Flux (m/s)')\n", + "plt.ylabel('Rejection')\n", + "plt.legend(loc='lower right')\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.title('SD Model with Prediction Interval ')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "ukfdwBH3punS", + "outputId": "a8641468-da24-4df3-b085-1dbb7c09aba5" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##2. Speigler Kedem Film Model" + ], + "metadata": { + "id": "Q38Lw-DZcj0Z" + } + }, + { + "cell_type": "markdown", + "source": [ + "The Speigler-Kedem Film Model, unlike the Solution Diffusion Model, introduces a third parameter known as the reflection coefficient. This model accounts for the convective transport through the membrane along with diffusion.\n", + "\n", + "$$\n", + "\\frac{Rs}{1 - Rs} = \\frac{\\sigma}{1 - \\sigma} \\cdot \\left(1 - \\exp\\left(\\frac{-J(1 - \\sigma)}{\\omega}\\right) \\cdot \\exp\\left(\\frac{-J}{k}\\right)\\right)\n", + "$$\n", + "\n", + "Where:\n", + "- ${\\sigma}$ represents the reflection coefficient.\n", + "- $J $ stands for the volumetric flux\n", + "- $\\omega$ is the salt permeability\n", + "- $k$ denotes the mass transfer coefficient\n", + "- $R_s$ signifies salt rejection\n", + "\n", + "For further information about the model you can check the paper: Murthy, Z.V.P., Gupta, Sharad K., “Estimation of mass transfer coefficient using a combined nonlinear membrane transport and film theory model” Desalination, 1997, 113(3), 237-255, https://doi.org/10.1016/S0011-9164(97)00051-9\n" + ], + "metadata": { + "id": "AYNgyQ9GkZ3u" + } + }, + { + "cell_type": "markdown", + "source": [ + "###2a. Define SK Model" + ], + "metadata": { + "id": "0Sfgo1KUcxPT" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Define the SK Model equation\n", + "def sk_model(x, J):\n", + " '''\n", + " Function to define SK model\n", + " Arguments:\n", + " J: Volumetric Flux in m/s\n", + " x: Estimation Parameter (Reflection coefficient, Salt Permeability, Mass Transfer Coefficient)\n", + " Returns:\n", + " The computed value of Y\n", + " '''\n", + "\n", + " a1 = x[0] / (1 - x[0])\n", + " a2 = (1 - x[0]) / x[1]\n", + " return a1 * (1 - np.exp(-J * a2)) * (np.exp(-J / x[2]))\n", + "\n", + "def residual_func(x, J, Y):\n", + " return sk_model(x, J) - Y\n" + ], + "metadata": { + "id": "gFAGYGm2c2qe" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###2b. Parameter Estimation Using SK Model" + ], + "metadata": { + "id": "n-uxrv11dOEf" + } + }, + { + "cell_type": "markdown", + "source": [ + "For non linear regression here we will again use `least_squares` from `scipy.optimize`" + ], + "metadata": { + "id": "kNK8QE_watwZ" + } + }, + { + "cell_type": "code", + "source": [ + "# Initial guess for parameters x0 and parameter bounds\n", + "x0 = [0.5, 1e-5, 1e-5] # Initial guess for [reflection coefficient, salt permeability, mass transfer coefficient]\n", + "bounds = ([0, 1e-5, 1e-6], [1, 9e-4, 1e-4]) # Bounds for parameters: [0 to 1], [1e-5 to 1e-6], [1e-5 to 1e-6]\n", + "\n", + "# Perform least squares optimization\n", + "result = least_squares(residual_func, x0, bounds=bounds, args=(J, Y))\n", + "\n", + "# Obtained optimized parameters\n", + "optimized_params = result.x\n", + "\n", + "# Print Salt permeability and Mass Transfer Coefficient for SK Model\n", + "print('\\nSalt Permeability:', optimized_params[1], 'm/s')\n", + "print('\\nMass Transfer Coefficient:', optimized_params[2], 'm/s')" + ], + "metadata": { + "id": "FLCUvZX8fdcc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f1de587e-c0c4-46c7-ba06-575a0903a497" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Salt Permeability: 1.1625945932822965e-05 m/s\n", + "\n", + "Mass Transfer Coefficient: 9.999999999999999e-05 m/s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now calculate the jacobian, variance, and covariance matrix for SK model." + ], + "metadata": { + "id": "kcMEzdACKl23" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluating Jacobian Matrix\n", + "Jac = result.jac\n", + "print('Jacobian Matrix\\n', Jac)\n", + "# Finding variance using Jacobian Matrix\n", + "jac_inv = np.linalg.inv(np.dot(Jac.T, Jac))\n", + "vari = J.flatten() - sk_model(result.x, J)\n", + "variance = np.var(vari)\n", + "print('\\nVariance',variance)\n", + "# Covariance Matrix\n", + "covari= variance * jac_inv\n", + "print('\\nCovariance Matrix\\n',covari)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iINDYd5xPG9I", + "outputId": "7cbbd629-010d-4650-8165-f51acb40eec4" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Jacobian Matrix\n", + " [[ 1.23018700e+01 -1.66260409e+05 2.44379297e+04]\n", + " [ 1.20337228e+01 -1.69092330e+05 2.36431129e+04]\n", + " [ 1.26362022e+01 -1.61895625e+05 2.54737235e+04]\n", + " [ 1.06004280e+01 -1.77837380e+05 1.97272060e+04]\n", + " [ 1.02479548e+01 -1.78782104e+05 1.88243709e+04]\n", + " [ 1.09739760e+01 -1.76381100e+05 2.07061367e+04]\n", + " [ 7.71067446e+00 -1.75271284e+05 1.27913027e+04]\n", + " [ 7.41315326e+00 -1.73757778e+05 1.21299468e+04]\n", + " [ 7.99233013e+00 -1.76492844e+05 1.34257506e+04]\n", + " [ 4.06265061e+00 -1.38796710e+05 5.33001233e+03]\n", + " [ 3.84673652e+00 -1.35163587e+05 4.93790261e+03]\n", + " [ 4.21061236e+00 -1.41167194e+05 5.60248953e+03]\n", + " [ 4.46478520e-01 -3.03341873e+04 1.64900304e+02]\n", + " [ 4.21760656e-01 -2.88996516e+04 1.49095269e+02]\n", + " [ 4.55951389e-01 -3.08780776e+04 1.71118330e+02]]\n", + "\n", + "Variance 0.6376533479503876\n", + "\n", + "Covariance Matrix\n", + " [[ 2.60203040e+01 3.58103201e-04 -1.07015416e-02]\n", + " [ 3.58103201e-04 4.94179115e-09 -1.47159994e-07]\n", + " [-1.07015416e-02 -1.47159994e-07 4.40253694e-06]]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###2c. Residual Plot for SK Model" + ], + "metadata": { + "id": "mnrwztuY8pDA" + } + }, + { + "cell_type": "markdown", + "source": [ + "We will now plot the residual vs Volumetric flux plot for SK Model results." + ], + "metadata": { + "id": "ICzcw5n_ctJa" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate the fitted values using the obtained parameters\n", + "fitted_values = sk_model(result.x, J_pred)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Calculate residuals\n", + "sk_residuals = Y - sk_model(result.x, J)\n", + "\n", + "\n", + "# Plot the residuals vs Volumetric flux\n", + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(J, sk_residuals, color='green', label='Residuals')\n", + "plt.xlabel('Volumetric flux (m/s)')\n", + "plt.ylabel('Residuals (Dimensionless)')\n", + "plt.title('SK Model Residuals Plot')\n", + "plt.axhline(y=0, color='red', linestyle='--')\n", + "plt.ylim(-0.4, 0.5)\n", + "plt.legend()\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "o1RYa8338zAh", + "outputId": "aae38a0d-5d42-4466-9847-f8298e37eb44" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###2d. SK Model Fitting Plot and Prediction Interval" + ], + "metadata": { + "id": "VEt2motnc7NO" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate standard deviation of residuals\n", + "residual_std = np.std(sk_residuals, ddof=len(result.x))\n", + "\n", + "# Degrees of freedom (modify this according to your specific case)\n", + "dof = len(J) - len(result.x)\n", + "\n", + "# Calculate t-distribution for 95% prediction interval\n", + "t_distribution = t.ppf(0.975, df=dof)\n", + "prediction_interval = t_distribution * residual_std * np.sqrt(1 + variance)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot the data points\n", + "plt.scatter(J, Rs, label='Data Points')\n", + "\n", + "# Plot the fitted model\n", + "plt.plot(J_pred, Rs_fitted, label='Speigler Kedem Fitted Model', color='orange')\n", + "\n", + "# Plotting the prediction interval\n", + "plt.fill_between(J_pred, Rs_fitted - prediction_interval, Rs_fitted + prediction_interval,\n", + " color='lightgreen', alpha=0.2, label='95% Prediction Interval')\n", + "\n", + "plt.xlabel('Volumetric Flux (m/s)')\n", + "plt.ylabel('Rejection')\n", + "plt.legend(loc='lower right')\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.title('SK Model with Prediction Interval ')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "Lt5RYvAjdWw7", + "outputId": "0845ac24-ecdf-4fa0-f486-ad5c6aaceffe" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##3. Comparision: SD Model vs SK Model" + ], + "metadata": { + "id": "DhmSstOEfz_N" + } + }, + { + "cell_type": "markdown", + "source": [ + "Now we will do a statistical comparison of the SD model (two parameter model) and SK Model (three parameter model) using Akaike's Information Criterion." + ], + "metadata": { + "id": "vXHKDNANkj3R" + } + }, + { + "cell_type": "markdown", + "source": [ + "###3a. Akaike's Information Criterion (AIC)\n", + "\n", + "Akaike's Information Criterion (AIC) is a measure used for model selection that balances model fit and complexity. It quantifies the trade-off between the goodness of fit and the number of parameters in a statistical model.\n", + "\n", + "The equation for AIC is:\n", + "\n", + "$$\n", + "\\text{AIC} = 2k - 2\\ln(\\hat{L})\n", + "$$\n", + "\n", + "Where:\n", + "**k** is the number of estimated parameters in the model.\n", + "**L** is the maximum value of the likelihood function for the model.\n", + "\n", + "This way, lower AIC indicates a better trade-off between model fit and complexity. So, among competing models, the one with the lowest AIC is considered to be the best in balancing goodness of fit and simplicity.\n", + "\n", + "For small sample size AIC can be modified for better estimation by the following equation:\n", + "\n", + "$$\n", + "\\text{AICc} = AIC + {\\frac{((2k)^2 +2k)}{n - k -1}}\n", + "$$\n", + "\n", + "After the AIC is evaluated, we can perform f test if the error is higher for the preferred model justify the statistical comparison.\n" + ], + "metadata": { + "id": "SPvtCmxogAjw" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "\n", + "# Define a function for AIC\n", + "\n", + "def aic_f(k1,k2,rss_sd, rss_sk):\n", + " if k2+1 >= n:\n", + " print('number of observations should be 2 more than fitting parameter to perform AIC or f test')\n", + " else:\n", + " aic_sd = 2*k1 + n*np.log(rss_sd/n)\n", + " # AIC corrected for small no. of observation points\n", + " num = 2*(k1)**2 + 2*k1\n", + " denom = n - k1 - 1\n", + " #AIC for SD Model\n", + " AICc_sd = aic_sd + (num/denom)\n", + "\n", + " #AIC for SK Model\n", + " aic_sk = 2*k2 + n*np.log(rss_sk/n)\n", + " num = 2*(k2)**2 + 2*k2\n", + " denom = n - k2 - 1\n", + " AICc_sk = aic_sk + (num/denom)\n", + " print('AIC for SD model is ', AICc_sd)\n", + " print('AIC for SK model is ', AICc_sk)\n", + " if AICc_sd < AICc_sk:\n", + " print('AIC - SD model is better fit to the data than SK model' )\n", + " else:\n", + " print('AIC - SK model is better fit to the data than SD model' )\n", + "\n", + "\n", + " # F-Test\n", + " # calculated f is greater than f critical and p value less than alpha(0.05) then null hypothesis is rejected\n", + " if rss_sd > rss_sk:\n", + " n1 = (rss_sd - rss_sk)/ (fp2 - fp1)\n", + " d1 = (rss_sk) / (n - fp2)\n", + " ft = n1 / d1\n", + " p_value = 1-stats.f.cdf(ft, (fp2-fp1), (n-fp2))\n", + " f_critical = stats.f.ppf(q=1-alpha, dfn= fp2-fp1 , dfd= n-fp2)\n", + " print('\\nf=',ft, '\\nf*=',f_critical, '\\np_value=', p_value)\n", + "\n", + "\n", + " if ft < f_critical and p_value >= alpha :\n", + " print('F Test - SD model fits better to the data than SK model ')\n", + " else:\n", + " print ('F Test -SK model fits better to the data than SD model')\n", + " else:\n", + " print('f test - SD model has low error and fits better than SK model')\n", + "\n", + " return\n" + ], + "metadata": { + "id": "9hAjzLGYgY0m" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now call the AIC function to compare the model" + ], + "metadata": { + "id": "3gcR6yffcqGA" + } + }, + { + "cell_type": "code", + "source": [ + "fp1 = 2 # number of fitted parameter in SD MODEL\n", + "fp2 = 3 # number of fitted parameter in SK MODEL\n", + "\n", + "n = len(Y) # number of data points\n", + "p = len(optimized_params) # number of parameters\n", + "alpha = 0.05 # 95% confidence interval = 100*(1-alpha)\n", + "\n", + "# k1 for SD and k2 SK is number of fitted parameter + 1, used for AIC\n", + "k1= fp1+1\n", + "k2 = fp2 +1\n", + "\n", + "rss_sk = sum(sk_residuals)**2 # residual sum of squares for SK model\n", + "rss_sd = sum((sd_residuals)**2) # residual sum of squares for SD model\n", + "\n", + "\n", + "# Call the AIC function\n", + "aic_f(k1,k2,rss_sd, rss_sk)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yE6b-p78cxOt", + "outputId": "e9afc990-4f61-41b6-f3f3-da83b9386a48" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "AIC for SD model is -44.10766253375572\n", + "AIC for SK model is -58.221060291972066\n", + "AIC - SK model is better fit to the data than SD model\n", + "\n", + "f= 27.660085868866968 \n", + "f*= 4.747225346722511 \n", + "p_value= 0.00020131060639594356\n", + "F Test -SK model fits better to the data than SD model\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##4. Discussion" + ], + "metadata": { + "id": "mCoTrW86jKlB" + } + }, + { + "cell_type": "markdown", + "source": [ + "Question 1: According to your estimation, is there a significant difference when using three parameter model (SK Model) vs two parameter model (SD Model)? Which one do you think is better for this data?\n", + "\n", + "Answer: Although the models looks really similar in terms of output, the SK model here gives a better estimation than SD model. This can be verified by the AIC and f test results and we can conclude that convective transport is important to consider for this set of data.\n", + "\n", + "Question 2: Do the two membrane transport models give the same or different estimates for Salt Permeability and Mass Transfer Coefficient ?\n", + "\n", + "Answer: The two models gives different values for Salt Permeability and Mass Transfer Coefficient. However, the estimated values are close to each other.\n", + "\n", + "Question 3: Why do you think the residual are dimensionless for the data? Justify in one or two sentences\n", + "\n", + "Answer: Residual in the above data is for the rejection data. The rejection in itself is dimensionless.\n", + "\n", + "\n" + ], + "metadata": { + "id": "oZ83z-VmjNRn" + } + }, + { + "cell_type": "markdown", + "source": [ + "##References\n", + "1. Wijmans, J.G., Baker, R.W., “The solution-diffusion model: a review” Journal of Membrane Science, 1995 107, 1-21, https://doi.org/10.1016/0376-7388(95)00102-I\n", + "2. Haim, O.P., Shefer, I., Singh, P., Nir, O., Epsztein, R., “The adverse effect of concentration polarization on ion-ion selectivity in Nanofiltration” Environmental Science and Technology Letters, 2023 10 (4), 363-371, https://doi.org/10.1021/acs.estlett.3c00124\n", + "3. Murthy, Z.V.P., Gupta, Sharad K., “Estimation of mass transfer coefficient using a combined nonlinear membrane transport and film theory model” Desalination, 1997 109 (1), 39-49, https://doi.org/10.1016/S0011-9164(97)00051-9\n" + ], + "metadata": { + "id": "yLi3JSCfjz3i" + } + } + ] +} \ No newline at end of file diff --git a/notebooks/contrib-dev/Stochastic_Simu_Chem_Rxn.ipynb b/notebooks/contrib-dev/Stochastic_Simu_Chem_Rxn.ipynb new file mode 100644 index 00000000..777a6465 --- /dev/null +++ b/notebooks/contrib-dev/Stochastic_Simu_Chem_Rxn.ipynb @@ -0,0 +1,2654 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "Clm-BGLJK54N" + }, + "source": [ + "# Stochastic Simulation of Chemical Reactions\n", + "**Prepared by:** Raghav Saxena (rsaxena@nd.edu) and Sarah Nano (snano@nd.edu)\n", + "**Edited by:** Tiago Thomaz Migliati Zanon (tmigliat@nd.edu)\n", + "\n", + "**Reference:** [Chemical Reactor Analysis and Design Fundamentals by Rawlings et al. (Nob Hill Pub, LLC, 2002)](https://sites.engineering.ucsb.edu/~jbraw/chemreacfun/)\n", + "\n", + "**Intended Audience:** This problem is intended for Chemical and Biomolecular Engineering juniors and seniors from the University of Notre Dame who are either enrolled in or have taken Reaction Engineering.\n", + "\n", + "\n", + "## Learning Objectives\n", + "\n", + "After studying this notebook, completing the activities, and asking questions in class, you should be able to:\n", + "\n", + "* Understand stochastic simulations and how to use them to model chemical reactions.\n", + "* Highlight similarities and differences between stochastic and deterministic rate models for chemical reactions.\n", + "* Properly graph and visualize data using Matplotlib.\n", + "* To solve differential equations related to reaction kinects problems numerically.\n", + "\n", + "## Coding Resources\n", + "Relevant Modules in Class Website:\n", + "\n", + "* [Functions and Scope](https://ndcbe.github.io/data-and-computing/notebooks/01/Functions-and-Scope.html)\n", + "* [Visualization with matplotlib](https://ndcbe.github.io/data-and-computing/notebooks/01/Matplotlib.html)\n", + "* [Preparing Publication Quality Figures in Python](https://ndcbe.github.io/data-and-computing/notebooks/01/Publication-Quality-Figures.html)\n", + "* [Euler Forward Method](https://ndcbe.github.io/data-and-computing/notebooks/07/Forward-and-Backward-Euler.html)\n", + "* [Crank-Nicolson (Trapezoid Rule)](https://dcbe.github.io/data-and-computing/notebooks/07/Trapezoid-Rule.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "rsDgYreOSduc" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "l5G8OHITGIWE" + }, + "source": [ + "## 1. Introduction\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fZPqZ8Z_IDOO" + }, + "source": [ + "Kinetic reactions are mostly modeled using deterministic rate laws, which involve solving nonlinear differential equations. Deterministic models work excellently with large systems involving many thousands of atoms.\n", + "\n", + "\n", + "However, in some cases, we might want to model systems with only a few hundred atoms, such as when modeling reactions at an interface or a catalyst surface. For such systems, the random behavior of the molecules becomes essential. Such systems can be modeled using random simulation techniques (also called kinetic Monte Carlo) which we explain later below in detail." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CN-9WKlnT3u1" + }, + "source": [ + "**The objectives of this exercise are:**\n", + "\n", + "1. To perform random simulation on a two-reaction batch system using Gillespie algorithm.\n", + "\n", + "2. Compare reaction profiles (concentrations vs time) from random simulation with those of deterministic rate laws.\n", + "\n", + "3. Explore the effect of the number of molecules and rate constant on reaction profiles from the Gillespie algorithm.\n", + "\n", + "4. Discuss similarities and differences between the rate law model and the random simulation model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QM2N2vLsTafc" + }, + "source": [ + "## 1a. Random Simulation - Gillespie Algorithm\n", + "In a random simulation, one can directly capture the random nature of molecules by using random molecular motion and probability of collision as the basis of reaction rates.\n", + "\n", + "Through this exercise, we will highlight similarities and differences between a random simulation model and a deterministic model.\n", + "\n", + "We will use the following two reaction constant volume batch system for the purpose of this exercise.\n", + "\\begin{equation}\n", + "A \\xrightarrow{k_1} B\n", + "\\end{equation}\n", + "\\begin{equation}\n", + "B \\xrightarrow{k_2} C\n", + "\\end{equation}\n", + "\n", + "For stochastic (random) modeling, the systems are generally small and consist of about a few hundred molecules. Thus, we will model the system using the exact number of molecules instead of using concentrations. We will assume that these reactions are actual molecular events, i.e., a molecule of A converts to B in the first reaction, and a molecule of B converts to C in the second reaction.\n", + "\n", + "Which reaction takes place is governed by their probabilities; this is proportional to the rate constant and the number of molecules as shown below:\n", + "\n", + "\\begin{equation}\n", + "r1 = k_1x_a\n", + "\\end{equation}\n", + "\\begin{equation}\n", + "r2 = k_2x_b\n", + "\\end{equation}\n", + "\n", + "These reaction probabilities look very similar to rate equations from the deterministic models. However, **x$_i$** is the number of component **$i$** molecules in the reactor volume, not concentration **C$_i$**. \n", + "\n", + "Given these reaction probabilities, we will simulate the random behavior of this reaction network using the Gillespie algorithm. The basic idea behind the Gillespie algorithm is to (i) randomly choose the time at which the next reaction occurs and (ii) randomly choose which reaction occurs at that time. The choice is not made completely randomly but rather using reaction probabilities. The following protocol describes the Gillespie algorithm:\n", + "\n", + "1. Initialize the number of starting molecules x$_i$ for each species in the reaction network.\n", + "2. Compute total reaction probability, $r_{tot} = \\sum r_ix_i$, it is intuitive that a higher total reaction probability would mean that the time to the next reaction is smaller.\n", + "3. Select two random numbers, p1 and p2, from a uniform distribution on the interval (0,1).\n", + "4. Compute the time to next reaction $\\tau = -ln(p1)/r_{tot}$.\n", + "5. Select the reaction that takes place at this time. The idea here is to partition interval (0,1) by relative sizes of individual reaction probabilities, then select the reaction that occurs using the randomly generated number p2.\n", + "6. Update reaction time $t = t + \\tau$ and adjust number of molecules x$_i$ for each species. For example, if reaction 1 is selected in step 5, we will reduce the number of A molecules by 1 and increase the number of B molecules by 1.\n", + "7. Return to step 2 and continue until the total reaction probability is zero." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kMG0-L38Hnbo" + }, + "source": [ + "## 2. Random Simulation Model - Gillespie Algorithm\n", + "Complete the function \"Gillespie\" to perform stochastic simulation of the two reaction batch system.\n", + "\\begin{equation}\n", + "A \\xrightarrow{k_1} B\n", + "\\end{equation}\n", + "\\begin{equation}\n", + "B \\xrightarrow{k_2} C\n", + "\\end{equation}\n", + "**Write a pseudocode for the while loop to complete the code.** Submit this answer on an attached pdf file." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "SKnfMn39SpXn" + }, + "outputs": [], + "source": [ + "def gillespie(k1, k2, A, B, C):\n", + " \"\"\"\n", + " Function to implement Gillespie algorithm to perform stochastic simulation of the two reaction batch system\n", + "\n", + " Arguments:\n", + " k1,k2: Reaction rate constants of the two reactions\n", + " A,B,C: Initial number of A, B and C molecules\n", + "\n", + " Returns:\n", + " y: A numpy array of simulation time and number of A, B and C molecules\n", + " \"\"\"\n", + " # Random Simulation using Gillespie algorithm\n", + "\n", + " # Index counter\n", + " n = 0\n", + "\n", + " # Initialize list for storing simulation time\n", + " time = [0]\n", + "\n", + " # Initialize list for storing number of A, B and C molecules\n", + " x_a = [A]\n", + " x_b = [B]\n", + " x_c = [C]\n", + "\n", + " # Total reaction probability at time t = 0\n", + " r1 = k1 * x_a[0]\n", + " r2 = k2 * x_b[0]\n", + " rtot = r1 + r2\n", + "\n", + " while rtot != 0:\n", + " ### BEGIN SOLUTION ###\n", + "\n", + " # Generating two random numbers from a uniform distribution between 0 and 1\n", + " p = np.random.rand(2, 1)\n", + "\n", + " # Time to next reaction event using one of the two generated random numbers\n", + " tau = -np.log(p[0, 0]) / rtot\n", + "\n", + " # Determining which reaction to take place at that time using other random number\n", + "\n", + " if p[1, 0] < r1 / rtot:\n", + " # This means reaction A-->B takes place. Adjusting the number of molecules\n", + " x_a.append(x_a[n] - 1)\n", + " x_b.append(x_b[n] + 1)\n", + " x_c.append(x_c[n])\n", + "\n", + " else:\n", + " # This means reaction B-->C takes place. Adjusting the number of molecules\n", + " x_a.append(x_a[n])\n", + " x_b.append(x_b[n] - 1)\n", + " x_c.append(x_c[n] + 1)\n", + "\n", + " # Update simulation time with tau every iteration\n", + " time.append(time[n] + tau)\n", + "\n", + " # Update index counter\n", + " n += 1\n", + "\n", + " # Update total reaction probability\n", + " r1 = k1 * x_a[n]\n", + " r2 = k2 * x_b[n]\n", + " rtot = r1 + r2\n", + "\n", + " # Make a numpy array of simulation time, and number of A, B and C molecules.\n", + " y = np.array([time, x_a, x_b, x_c])\n", + "\n", + " ### END SOLUTION ###\n", + "\n", + " return y" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ih9h_XHiCXz0" + }, + "source": [ + "Initialize the number of molecules and rate constants in the next block and then run the Gillespie function. Plot the number of molecules of A, B, and C over time." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "Xv0izRelW7MZ" + }, + "outputs": [], + "source": [ + "# Define initial number of molecules and rate constants\n", + "\n", + "k1 = 0.5 # s-1\n", + "k2 = 1 # s-1\n", + "A = 1000\n", + "B = 0\n", + "C = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "VcdxHpaNVnjD" + }, + "outputs": [], + "source": [ + "# Run gillespie function\n", + "\n", + "x = gillespie(k1, k2, A, B, C)\n", + "time = x[0]\n", + "xa = x[1]\n", + "xb = x[2]\n", + "xc = x[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 552 + }, + "id": "nquXZWxeYRZf", + "outputId": "7acf34fc-29a2-4108-d127-3da94ff351ae" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAIXCAYAAABw5DFEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACg40lEQVR4nOzdd3hTZRvA4d9Jm+49oNDBKnvvvUGGoqCAA9wLBw5ExY04cC/cExTETxAVZKggU1r23hvaQnfTnabJ+f4IDdS20JK0p02f+7p69eSc95z3CRTy9J2KqqoqQgghhBC1kE7rAIQQQgghtCKJkBBCCCFqLUmEhBBCCFFrSSIkhBBCiFpLEiEhhBBC1FqSCAkhhBCi1pJESAghhBC1liRCQgghhKi1XLUOoDayWCwkJCTg6+uLoihahyOEEELUGKqqkpWVRf369dHp7G/PkURIAwkJCURGRmodhhBCCFFjnTlzhoiICLufI4mQBnx9fQHrX6Kfn5/G0QghhBA1R2ZmJpGRkbbPUntJIqSBou4wPz8/SYSEEEKIK+CooSUyWFoIIYQQtZYkQkIIIYSotSQREkIIIUStJYmQEEIIIWotSYSEEEIIUWtJIiSEEEKIWksSISGEEELUWpIICSGEEKLWkkRICCGEELWWJEJCCCGEqLUkERJCCCFErSWJkBBCCCFqrRqRCM2cOZNx48bRuHFjFEWhYcOGlyy/adMmhgwZgq+vL35+fgwfPpydO3eWWjYhIYHbbruN0NBQPD096dKlCwsWLCi1rNFo5MUXX6RRo0a4u7vTpEkTXn31VUwmk53vUAghhBBaqBG7zz/77LMEBQXRqVMnMjIyLlk2NjaWAQMGEB4ezowZMwD4+OOP6du3Lxs3bqRt27a2smlpafTp04ekpCSmTJlCREQEP/74I+PHj+fbb7/lzjvvLPbsG2+8kd9//5277rqLnj17EhMTwwsvvMDRo0eZPXu2o9+2EEIIISqbWgMcO3bMdty6dWu1QYMGZZbt2rWr6uvrq8bFxdnOxcXFqb6+vurQoUOLlX3yySdVQF28eLHtXGFhodq1a1c1KChIzcrKsp1funSpCqhTpkwp9owpU6aogPrvv/+W+/0YDAYVUA0GQ7nvEUIIIYTjP0NrRNdY48aNy1Xu6NGjbNmyhXHjxhEeHm47Hx4ezrhx41i5ciXnzp2znf/xxx9p0qQJo0aNsp1zcXFh8uTJpKWlsWzZsmJlAR577LFidRa9njt3bkXflhBCCCE0ViMSofLasmULAD179ixxrUePHqiqyrZt2wA4e/Ys8fHx9OjRo9SyFz+v6Dg8PJzIyMhiZSMjI6lfv36xskIIIURtdjrzNLuSd1FgLtA6lMuqEWOEyishIQGgWGtQkaJz8fHxFS5bVL5Vq1al1hseHk5cXFyZcRmNRoxGo+11ZmbmJd/HldiXYOBMWi7dGgUT5O3m8OcLIcSVUlWVQkshBZYCCszWL5PFRIGlAJPZZD1nsZ6LDogmxDMEgPjseGITYgnwCGBw1GDb897c/CbJeclkGjPJLLB+5RfmXzKGyR0nM6bpGAB2J+/msdWPEekbyZwRc2xl7v7zbk4YTlTovU1sNZG72twFWD/871hxB35ufvw2+jdbmSfWPMGOpB0Veu41Ta5hSucpABiMBsb8bo3977F/46JzAeCVmFdYfWZ1hZ7bN6IvL/d62fZ68ILBqKrKglELCPYMBuCj7R/x29HfynhC6dqEtOGjQR/ZXo9dMpa8wjyWjllKlF9UhZ5V1ZwqEcrNzQXA3d29xDUPD49iZSpStui4tLJF5S8u+18zZ87k5ZdfLvO6Izzx8y4Onsviuzu6MrBFnUqtSwihLZPZRFJeEql5qaiolywbHRCNt94bgOTcZBJyEghwD6CBXwMALKqFPSl7yrzfbDGTmJtIfHY88dnxZBVkUWAu4MEOD9IiqAUAK0+t5LNdn9Glbhee6f6M7d7e83uTV5iHyVL+mbVv9H2DqxtfDcDB1INMj5lOh9AOxRKhv07+RVJeUrmfCZBbeOH/aJPFRHJesu3PpUhafhrJeckVem6OKcd2XKgWkpyXTIGleCuIwWio8HOzC7Jtx6qqlnp/ZkFmhZ+baSz+i3hKXgoW1VLs5yjblF3h5xqMhmKvw33CySvMI9986QS1OnCqRMjLywugWOtLkfz8/GJlKlK26Li0skXlLy77X8888wxTpkyxvc7MzCzRxWavJqE+HDyXxdGkbEmEhKjGTGYT2aZsckw55JhybMdtQ9oS6BEIwM+Hfmbh4YVc1fAq7ml7D2D9oLn7z7tJzU8tVwJU5PsR39OxTkcAVpxcwVtb3mJko5G82e9NAMyqmYnLJlb4fYxtNtaWCGUVZHE4/TB1veoWK1PU8vNfroorehc9ep0eNxc33HRuttderhf+L63rXZcBEQNoHFB8nOi97e7FrJrxc/Ozfrn74enqiYJSZryhXqG245ZBLVk4aiF6F32xMu8NeK/CXTlBHkG243CfcBaOWohOKT7q5KWeLxVLxMrD393fduzj5sPCUQsBij378c6P234+ysvHzafY65+v+blEfXe3uZsbmt5Qoed6unoWe/3rdb9W6H4tOVUiVL9+faB4l1aRonNF3V4VKVtUvrSyReVL62Ir4u7uXmZrkqNE17H+cB9JyqrUeoQQl3c4/TArT60s1l0Tlx3HhvgN5BXmlXrP50M+p3d4b8D6W/qBtAO0C21nu25WzRxKP2R7rdfpCfEMwUVxuWQsbi4Xusp99D5E+EQU+/AGiPCJKPN+RVEI9Qwl3CeccN9wAtwD0Ov0RAdE28r0qt+LL4Z+QbBHcLF7F123CL3OmuDoXfTWhEent3XtXE6bkDbMGjyrxPmbWtxUrvvL4qX3onlQ8xLnG/k3suu57i7upT430s++X3xdda6lPre+T327nguU+ty63nWp6123lNLOyakSoa5duwIQExPDPfcUz5JjY2NRFIXOnTsDUK9ePcLDw4mNjS3xnKJzXbp0KfbsefPmcebMmWKtOWfOnCEhIYFrr73W4e+nIprWtSZChxOzL1NSCHElzBYz25O24+/uT7PAZgAUWgqJPRtLhE8EDf0b2so+sPIBknIv3XXj6eqJt94bH70P3nrvYgnL1Y2vpm1IW+p517Od89X78tmQzwjyCCLMO4xA90AUpewWkNKMaTrGNk6miF6nZ/kNyyv0nP8q64Mz0texLd9CVAanSoSio6NtK0O/8sortlafhIQEFixYwKBBgwgLC7OVv/nmm3nnnXdYsmSJbQq92Wxm1qxZBAQEMHLkyGJl582bxwcffMC7775rO//BBx8AMGHChCp4h2VrEmpNhE6l5lympBDicnJNufxx/A/isuNIzUslJS+FvSl7ySzI5Nom1/Jan9cAa9fPAysfoEVQC74Y+oWtpaWBXwNaBLWgkV8jW7LiorjQq34vWgS3wMvVC1dd2f/9NvBrYBvDU0TvoqdPeJ9KesdC1F41IhH64YcfOHXqFADJyckUFBTw6quvAtCgQQNuvfVWW9kPP/yQgQMH0rdvXyZPngzArFmzsFgsxRIYgGnTprFgwQJuueUWpkyZQnh4OPPnz2fLli18/fXX+Pr62speffXVXHPNNbz33nsYDAbbytLffPMNEydOpE8fbf+DCvW1dr2l55owmS3oXZxqZQQhKsWhtEMsO7GMcznnSM9PJ92YTlp+2iVbcy4eB6NTdLQMaomiKGw6u4kRjUYA8M1V31S4tUYIoQ1FVdXyjbjT0IABA1i7dm2p1/r378+aNWuKnYuJieH5559n06ZNKIpCr169mDlzJp06dSpxf3x8PNOmTWP58uVkZ2fTqlUrnn76aW688cYSZfPz83n11VeZO3cuZ8+eJTw8nDvvvJNp06ah1+tLlC9LZmYm/v7+GAwG/Pz8yn3fpZgtKk2fW4ZFhU3PDqaun4dDniuEs1hxcgVbz21lYORA21icv0/9zZQ1U0otH+AewLCGw6jnXY8QzxBCPENoFdzKNqBZCKENR3+G1ohEyNlURiIE0OXVlaRkG1n6SB9a1/e//A1COCFVVVl1ehX/JvzL7a1ut43dmREzgwWHF/BA+wd4sMODAJzJPMP3+78n3CecIM8gAt0DCfIMIsg9iBCvEPS68v+CI4SoGo7+DK0RXWOifEJ83EjJNpKSXf1X8hTCUfIL89mbspcdSTvYlbyLPSl7SMtPA6Br3a62RKhfRD+CPILoGtbVdm+kXyTP9XhOi7CFENWEJEJOJMTHHcgiKbP6L2AlREWti1vH7uTdHDccJy4rjkK1EIvFwqmsUxRaCouV1ev0XBd9HU0CmtjODYgcwIDIAVUctRCiupNEyIk0DvVmw9EUjibJFHpRcyXnJvNK7CucyznH/675n23Q8fyD89kQv6HUe0I8Q+hUpxMd63SkTUgbmgc1L7HAmxBClEYSIScSEWj9jz9RWoREDebr5su6uHWYVevWDmHe1iUv+kf0p65XXRr5N6KhX0PbujsRPhFE+EbILC0hxBWRRMiJeLu74qHXoZMPBFHDHMs4hp+bH6FeoXi4evByr5etA5gvWgHZ3tWEhRCiNDJrTAOVNWtMiJoi15TLkYwj/Bv/LytPr+RI+hHubnM3j3V+TOvQhBDVnMwaE0LUaFvPbeXxNY+TYcywndMpumKvhRCiqkgiJISoMofSDnHPX/dgVs3odXrahLRhXLNx9A3vS4BHgNbhCSFqIUmEnEhmvompP+8iJdvIwkm90OlkrJCoPs7lnGPskrGAdZfvn6/5GQ9XWQFdCKEt2ZDKiXjqXfj7QCLbT2eQliuLKorq45fDvzB04VDb69f7vC5JkBCiWpAWISeid9Hx5vXtCPDS4+0mf7VCe0fTj/Lkuic5mnEUsC50+PVVX9MmpI3GkQkhhJV8WjqZ8V0jtQ5B1FIpeSk8ve5pWga1ZGrXqQCE+4ZzMvMkAN3DuvNK71eo51NPwyiFEKI4SYSEEBWWnp/ORzs+wmA08N6A9wAwmo1sPreZbYnbuLHFjUT6RuLp6smngz9lX+o+RkePJsQzROPIhRCiOEmEnMzJlBx2xWUQ6utOrybyoSMcY2/KXn4+9DMFlgKSc5PZlbwLo9lI57qdbWUC3QN5q99beLh4EOoZajvfs35PetbvqUXYQghxWZIIOZmVBxJ5dekBrmlXTxIh4RBbz23lwVUPkleYV+x8s8BmPND+AdtrL70XIxqNqOrwhBDCLpIIOZlQX3cAUrKNGkcinMG2xG22JKhbWDf6RfTDW+9Np7qdaOTXSPb3EkLUeJIIOZlQn6JESKbPC/scTj/MgyutSVDPej35aNBHMuVdCOF0ZB0hJxMiLULCAebsm8O4JePILcylU51OkgQJIZyWJEJOJtjbDYCMXBMms0XjaERNlJqXyjtb38GiWmgW2Iw3+70pSZAQwmlJIuRkAr3ccDm/tUZajnSPics7lHaI2XtnE3s2FoDU/FSe6PwEAAtHLSTMO0zL8IQQolJJIuRkdDqFoPOtQseSsjWORtQE/5z+h3e3vcuqU6sA62ywpoFNeaHHCzIYWgjh9GSwtBNKPT8+KFnGCYlSqKrKsYxjRAdGAxDhG8GIRiNoG9rWVqZ3eG+twhNCiColLUJO6KpW1q6MjFyTxpGI6iYpN4nH1zzOuD/GcSD1AACjmozirX5vcW2TazWOTgghqp60CDmhEF9r11hylrQICTiXc44HVj7AycyTFFoKAdApOg6kHaBlcEuNoxNCCG1JIuSEGoX4AHDgbKbGkQitfb/ve97e+naxc62DW3Nfu/sYFDVIo6iEEKL6kETICXVpEAjAttPpGkcitHIu5xx3/3k3p7NO287d3OJmJnecjK+br4aRCSFE9SKJkBNqUscHXw9XujUMIt9kxkPvonVIoor9c/ofWxIU7hPOvJHzCPYM1jgqIYSofhRVVVWtg6htMjMz8ff3x2Aw4OfnVyl1mMwW9C4yFr42MllMdPqhEwDdw7rz6ZBPcXNx0zgqIYRwDEd/hsonpZOSJKj2mrNvju14XPNxkgQJIcQlSNeYk1NVVRbFq2UGRg5kf+p+Gvs3ZmiDoVqHI4QQ1Zp0jWmgKrrGftsRzwu/7aVnk2C+vK1LpdQhhBBCVDXpGhPl4uqikGUsxJAniyrWFh9t/4i4rDitwxBCiBpFusacVL9mofzzRH8CvWR8SG3wb/y/fLXnK/45/Q9fD/uaEM8QrUMSQogaQRIhJ+XnocfPQ691GKKKdKjTgR71ehDoEShJkBBCVIAkQkLUYMczjuOqcyXKL4pPBn+CWTVrHZIQQtQoMkbIif0Qc5KpC3ZxIiVH61CEg+WYcpi2fhrX/X4dn+36DAA3Fzc8XT01jkwIIWoWSYSc2M9b41i4LY7jydlahyIc7P1t77P0+FIAvPXeGkcjhBA1l3SNOTFvd+vWGrkF0l3iTA6mHeR/h/4HwBOdn+CONndoG5AQQtRg0iLkxLzcrHluniRCTkNVVR755xEAmgc259ZWt2ockRBC1GySCDkxTzdri1BOQaHGkQhH2ZG0g7M5ZwH4YugXuOhkQ10hhLCHJEJOLMTbuoZQUpZR40iEIxxJP8IdK+4AoHd4b9lNXgghHEASISfWMMQ6iPZYkgyWdgZvbn4TFZUgjyCe6vqU1uEIIYRTkETIiTUP8wVg/9lMjSMR9vr50M9sOrcJgG+HfUtj/8YaRySEEM5BZo05seZ1rYlQfEYe+SYzHnoZT1LTmC1mpq6dysrTKwG4rdVtNAloonFUQgjhPKRFyIkFebsR6KVHVWFvvEHrcMQVSMlLISkvCYChDYbyeOfHNY5ICCGci7QIOTFFUejeKJgV+86x43QGXRoGaR2SqKC63nWZO2Ium89tplPdTrjq5J+sEEI4krQIObkwfw8Ajsnq0jXGgdQDfL3naw6nHwbOJ7T1uqPXySa6QgjhaJIIObn+zUMB2HQiTeNIRHnlFuby8Y6PeXjVw+xM2ql1OEII4dSknd3JtQv3Z0SbMFrV80NVVRRF0TokcRmd63bmqa5PcTDtoPx9CSFEJVNUVVW1DqK2yczMxN/fH4PBgJ+fn9bhiGoiJS+FYI9gSX6EEOISHP0ZKl1jQlQDCdkJDPx5INcvvp7jhuNahyOEELWGJEK1gCHXxNGkLJKy8rUORZRiV/Iuhv0yDICThpPU866ncURCCFF7SCJUC8xcfoAh763jf5vPaB2K+I/sgmzu+fMe2+sHOjyAp6unhhEJIUTtIoOla4EALzf8POSvurrJMeXw8D8Pk2+2ttTNGT6HTnU7aRyVEELULvLpWAtMG9GCaSNaaB2GuEhiTiL3/HUPJzNPAtZVoyUJEkKIqiddY0Jo4L1t79mSoO71uvNCjxe0DUgIIWopaRESQgP7U/cD8HCHh7m//f0aRyOEELWXtAjVAvsTMpn49SYemb9D61AEEHs2lpOZJ9EpOsY0HaN1OEIIUatJi1AtUGC2sOFoCuEBMhupOvhmzzcAXNP4Gup41dE4GiGEqN2kRagW8Pe0btYZn5GncSQix5SDr5svjf0bc0PTG7QORwghaj1pEaoFQn3dbceZ+Sb8PGQXc6146715b8B7WFQLOkV+DxFCCK3J/8S1gI/7hXw3LbtAw0hEEUmChBCiepD/jWuJ6Do+ABxOzNI4ktopx5TDKzGv8POhn2UvMSGEqEYkEaolejQOAmDziTSNI6mdtiVuY/mJ5bwS+wqbzm7SOhwhhBDnyRihWqJxiLVF6KxBNl7VQr+Ifiy6bhHzD85nXLNxWocjhBDiPEmEaol6/h4AJBhk5lhVU1WVAksBYd5hPN75ca3DEUIIcRGHdY01bdqUI0eOALB06VJOnTrlqEcLB6h3fg2hsxnSIlSV8gvz6TW/FytOrNA6FCGEEKVwWIvQ/fffj15vnZY9ZswYzGYzPj4+tG7dmrZt29KmTRvb95CQEEdVK8qp/vkWoaSsfArNFlxdZHhYVZizbw7ZpmwOpB2gTUYbmgQ00TokIYQQF3FYIjR16lTbcU5ODgcOHGDv3r3s2bOHvXv38ueff3L69GkURSE0NJRz5845qmpRDkHebgBYVMjIMxHi436ZO4S9zmSd4es9XwNQYC6gsX9jjSMSQgjxX5UyRkiv19OuXTvatWtnO2c2m8nNzWXPnj3s27evMqoVl+DqosPfU48hz8Sp1FxJhCpZQnYCE5dNJN+cj6/el0ntJ6EoitZhCSGE+A+7+kceeOAB8vIuP/j22LFj9OnTB19fX3r16sW9995rT7WXlZ2dzeuvv07btm3x9fUlJCSEXr16MXv2bFRVLVZ206ZNDBkyBF9fX/z8/Bg+fDg7d+4s9bkJCQncdttthIaG4unpSZcuXViwYEGlvhdHuqZdPd66oR0Ngr20DsXpfbzjY9Ly0wjyCOL7Ed/LnmJCCFFNKep/M4MK0Ol0tGjRgnnz5tGxY8dSy3z99ddMmTKFnJwczGbzFQdaXhaLhf79+7Nx40Zuv/12evToQW5uLvPnz2fz5s089dRTvPnmmwDExsYyYMAAwsPDefjhhwH4+OOPSUpKYuPGjbRt29b23LS0NLp06UJSUhJTpkwhIiKCH3/8kbVr1/Ltt99y5513ljvGzMxM/P39MRgM+Pn5OfYPQGguITuBqxddTaFayI8jf6RtaNvL3ySEEKJcHP4ZqtpBURRVp9Op7u7u6syZM1WLxWK7lpKSoo4ePVrV6XS2clVh48aNKqA+9thjxc4bjUa1UaNGqr+/v+1c165dVV9fXzUuLs52Li4uTvX19VWHDh1a7P4nn3xSBdTFixfbzhUWFqpdu3ZVg4KC1KysrHLHaDAYVEA1GAwVfHeiuss15apjfh+jtpndRr17xd1ahyOEEE7H0Z+hDpk6VFBQwHPPPcfAgQM5ffo0K1asoG3btixevNhWpqpaPjIzMwGoX79+sfNubm6EhITg7e0NwNGjR9myZQvjxo0jPDzcVi48PJxx48axcuXKYgO6f/zxR5o0acKoUaNs51xcXJg8eTJpaWksW7asMt+WQ2TkFrDqQCJ/7ZOB6pXln9P/cCT9CC6KC1O6TNE6HCGEEJdhVyK0atUqGjZsCFgXjVu/fj2tW7fm6quv5ty5c6iqiqqqDB06lD179jgi3svq1q0bAQEBvPXWWyxYsIDTp09z8OBBnnnmGbZt28b06dMB2LJlCwA9e/Ys8YwePXqgqirbtm0D4OzZs8THx9OjR49Sy178vOrswNks7p6zlZnLD2oditNRVZVfj/zKtPXTAJjYciKtgltpHJUQQojLsWvW2MCBA9m9ezdPP/00n332GWCdOl/E19eXt956i/vvv9++KCsgMDCQxYsXc8899zB+/Phisfzyyy+MHj0asA58Boq1BhUpOhcfH1/hsqUxGo0YjUbb66JWq6oWFexFq3p+NA711qR+Z6WqKhOXT2R38m4APF09mdhqosZRCSGEKA+7p897e3vz4osvsmnTJrZt21ZsivDYsWO5++677a2iwnx8fGjTpg3XXnstvXr1Ii0tjU8++YRbbrmF33//naFDh5KbmwuAu3vJaeQeHtbFB4vKVKRsaWbOnMnLL79s35tygPAAT5Y92lfrMJyO0WzkpuY34aq40iywGTc2v5Ew7zCtwxJCCFEOdidCc+fO5fHHHyctLQ1FUWzT0xVFYfbs2Wzbto3Zs2fToUMHe6sqlz179tCrVy/ef/99Jk2aZDt/880306ZNG+69916OHTuGl5d1CvnFLTVF8vOt21AUlalI2dI888wzTJlyYbxIZmYmkZGRFX1roprycPXgmsbX0KFOByJ95e9VCCFqErvGCF1zzTXcfvvtpKam2sYD3X777XTt2tWWEO3evZvu3bvz4osvOiTgy3n//ffJz89n3LjiO3x7eXlx9dVXc+rUKU6ePGkbTF1al1bRuaJur4qULY27uzt+fn7FvoTzSMxJRFEUSYKEEKIGsisRunimVHBwMIsWLeK7775j48aNPPvss+h0OhRFwWQy8dprr9kdbHkUJSalrVlUWFho+961a1cAYmJiSpSLjY1FURQ6d+4MQL169QgPDyc2NrbUsgBdunRxzBuoZLd+s4m2L/3J2sPJWofiFFafXs2QhUM4kHqgxGKdQgghqj+7p8+rqspVV13Fnj17bAORXVxcePXVV1m9ejUNGjSwt4oKadXKOlNn9uzZxc5nZGTw+++/ExgYSHR0NNHR0baVoYsGQ4N1YPSCBQsYNGgQYWEXxnncfPPNHDt2jCVLltjOmc1mZs2aRUBAACNHjqzcN+Yg+SYzWcZCzmZcfkVwcXlnss4AcOMfN8oWGkIIUQPZtbK0l5cXb731lm1V5tJkZWXx0EMPMW/evCpZWfrUqVN06tSJ9PR0JkyYQO/evUlLS+Orr77i5MmTfPLJJzz44IMAbNy4kYEDBxIREcHkyZMBmDVrFomJifz777+0b9/e9tzU1FQ6d+5MamoqU6ZMITw8nPnz57NmzRq+/vrrCg0K13Jl6XvmbGHlgSTGdY7g7XHtL3+DuKwt57bg4eIhK0gLIUQVqFYrS+/fv7/cZRcsWGBPVRVy9OhR9bbbblPDw8NVV1dX1dfXV+3bt6/6yy+/lCi7ceNGddCgQaq3t7fq4+OjXnXVVeq2bdtKfW5cXJw6ceJENTg4WHV3d1c7duyo/vTTTxWOT8uVpZ9euEtt8PQf6uM/7ajyuoUQQgh7Ofoz1K4WIXFltGwRmr/5NM8s2sOgFnX49o6uVVq3M8kx5fDTwZ9oF9qOLnW7SLeYEEJUEUd/hto9fV7ULA2CrNP8jydnaxxJzfbV7q/4Zu83BLoHsu6mdVqHI4QQ4go5ZK8xUXM0C/MF4FRaLvmmyh+z5YwsqoVv9n4DQLoxXeNohBBC2EMSoVom2NsNV52CqkJ6boHW4dRI/5z+x3b8+3W/axiJEEIIe0kiVMsoioKPh7VHNCu/UONoah6TxcTnuz4HoIFfAxoHNNY4IiGEEPaQRKgWCvJyAyA1W1qEKur5Dc9zKP0QCgpv9H1D63CEEELYSRKhWijU17p5bFJWvsaR1CyJOYksO2FdTX1m35m0CWmjcURCCCHsJYlQLVTHzwOAbadkoG9FLDi8AIB2Ie24uvHVGkcjhBDCESpl+nx2djbLli3j1KlTREdHc91116HTSc5VXRSteFNQaNE0jprEaDbyxe4vALipxU0aRyOEEMJR7EqE/v77b95++20A7rnnHsaPH8+ZM2cYMGAAJ0+etJXr168ff/31F3q93q5ghWM8cVUzbukeRav6VbuYY032xuYL44EGRA7QLhAhhBAOZVczzdKlS1m5ciWrVq2iUaNGALz++uucOHHCVkZVVdatW8eXX35pX6TCYRoEe9OjcTB+HpKYlkdiTiILDy8EINQzFF83X40jEkII4Sh2JUKbN28GICgoiK5drds1LFmyBEVRUFWVi3fvWLhwoT1VCaGZOl51eKX3KwR7BDN7+GytwxFCCOFAdiVCZ86cQVEUW2vQuXPnSEhIAGDGjBkcPXoUPz8/VFVl//799kcrHObLdceYvngfGbKo4mUpisLo6NGsHr+aKL8orcMRQgjhQHYlQikpKQDUr18fgIMHD9quXX/99TRu3JgePXoAkJGRYU9VwsG+3XCS2RtPcio1V+tQqq0cUw5bz20lJc/6cy4bqwohhPOxa7B00QdDWloaAAcOHLCdj46OBsDT0xMADw8Pe6oSDjahexTZBYUEnl9cUZS0Pm49T657kkjfSJZdv0zrcIQQQlQCuxKhevXqceLECWJjY3njjTf44YcfAGjUqBFubtYP2KJWo5CQEDtDFY40eXBTrUOo9kK9Qmkd3Jo6XnW0DkUIIUQlsSsR6tWrFydOnMBsNvPcc88B1taggQMHAmCxWNi3b1+xcURC1BSd63bm22HfkpafpnUoQgghKoldY4Qef/xx29pARbPEXFxceOihhwBYu3atbWxQnz597ItUOJSqqpxKzeFwYpbWoVRrXnovInwjtA5DCCFEJbErEerUqRNLly5l8ODBtGjRgmuuuYY1a9bQvn17AE6dOsXVV1/NyJEjueaaaxwSsHCM72NO0f/tNby14pDWoVRLi48t5u9TfxdbAkIIIYTzUVT5n77KZWZm4u/vj8FgwM9Pm9Wdt51K54bPNlLH153Nzw3RJIbqrPu87uQW5vJA+wd4sMODWocjhBDiPEd/hjp0AzCj0cjJkydlzaAaIDLIOpsvJduI2SK58MV+PvQzuYXWZQUGRQ3SOBohhBCVySGbrsbGxjJ9+nTWrFmDyWRCURQKCwt59dVXOX78OK6urnz66ae4ulbKHq/iCgSdnzZvUSE5y0iYvyxvANYk6JXYVwAY0XAEzQObaxyREEKIymR3i9Ds2bPp168ff//9NwUFBcW21vD29mb27Nl88803LFmyxO5gheO4uuhoWc/apPjH7gSNo6ke0vLTeGfrOwC0DGrJm/3elEUUhRDCydmVCO3bt4/777+fwsJCoOTKu+PHj7edW7ZMFqSrbhoEeQFwJk1WlwZYdGQReYV5BHkEMXfkXEmChBCiFrArEXr33XdtXWGRkZGEh4cXux4eHk7jxo0B2Lp1qz1ViUrQJtzaIhR7XNbJsagWPtz+IQDjmo3DzUVW3BZCiNrArkRo9erVAPj7+7N9+3a6d+9eokx0dDSqqnLy5El7qhKVoE24PwCJWfkaR6K9k5knbce3trpVu0CEEEJUKbsSobNnz6IoCj179iQoKKjUMkUDpHNycuypSlSCokQoI9dEodmicTTaik2IBaBVcCv83f01jkYIIURVsSsRcnd3ByA3t+wxJocPHwbAx8fHnqpEJQj0ckN3fhhMWk6BtsFo7IPtHwAwIGKApnEIIYSoWnYlQo0bN0ZVVWJiYjhy5EiJ6/PmzePIkSMoikLTprLJZ3XjolMI8raOhTlwrvZutXEm6wx5hXkAdKvXTeNohBBCVCW7EqGhQ4cCYDKZ6NGjBxs3brRdGzJkCHfccUeJsqJ6qeNrXT9ob7xB40i0cybzDP7u/uh1ejrV6aR1OEIIIaqQXVtsxMfH06pVK7Kzs1FVFUVRbGsIXXzs6+vLgQMHqF+/vmOiruGqwxYbRT5adYSft57h1h4NuL9/E01j0ZJFtZCen06wZ7DWoQghhLiEarXFRnh4OD/88INtrBBYE6CL119xc3Njzpw5kgRVU48MbsqGpwfV2iQorzCPA6kH0Ck6SYKEEKIWsntl6WuvvZbNmzdz/fXX4+3tbVtZ2svLizFjxrBp0yZGjx7tgFCFcLwfD/zIoiOLMJqNWocihBBCAw7Z/KtNmzYsXLgQVVVJSUkBIDg4GJ3OoXu6ikqiqionU3NpEOSFTle7VlM+knGEQ2mHWHh4IRNaTtA6HCGEEFXMobugKopCaGioIx8pKpmqqvR5czXxGXn8/Xg/mtb11TqkKjW0wVDS8tII9wm/fGEhhBBOp0KJ0Pfff29XZbfddptd9wvHUxSFEF93EjPzicvIq3WJ0OCowQyOGqx1GEIIITRSoVljOp3Oro0ozWbzFd/rTKrTrDGA5CwjAV569C61pyvTZDHx0r8v8Xrf17UORQghRAVUi1ljRQOiy/NVVF5UX6G+7rUqCQJYe2Ytfxz/g9S8VK1DEUIIoaEKf/pVNKmRJEhUNyl5KTy+5nFUVH469JPW4QghhNBQhcYIFe02L5xLSraR15ceIDWngDl3Of8WE5/t/Mx2PLzhcA0jEUIIobUKJUL9+/evrDiEhvIKzCzaEQ9AZr4JPw+9xhFVHpPZxJLjSwB4rNNjNAmonQtJCiGEsKpdA0NEqcL8PWzHqw4kahhJ5VsXv468wjx83Xy5q81dWocjhBBCY3atI3T69OkKlY+KirKnOlFJ9C46+jYNYf2RFLafymBMxwitQ6o0vx39DQBfva9dMyCFEEI4B7sSoYYNG5b7w0RRFAoLC+2pTlSisZ0jWH8khYPnMrUOpdKYLWY2xG8AYFSTURpHI4QQojpwyMrSMjOs5mtax7qQ4uHEbFRVdcrWktNZpym0WJNx2U5DCCEEOGCMUFlJUNEu9M74geqMGod6o1PAkGciOds5NyDdcm4LAE0DmxLoEahxNEIIIaoDu1qEXnrppVLPJyYmEhMTw65du1AUhRtuuIE2bdrYU5WoZB56F+r5exKfkUdceh51fD0uf1MN882ebwDwdPHUOBIhhBDVRaUkQkXeeecdnnrqKdatW8dHH31kT1WiCtT1cyc+I4+kzHytQ3G4Q2mHSMhJAKB3eG+NoxFCCFFdVOr0+alTpxIUFERKSgovvvhiZVYlHKBoGv2OMxnaBlIJ/N39mdZtGvW968v4ICGEEDYOGSxdFovFYttzbOnSpZVZlXAAk9k63sticb7B72HeYUxoOUGSICGEEMXYlQitW7eu1PNms5n09HRmz55Neno6gO27qL66Nwri7/2JJBicq2vMWWfBCSGEsJ9didCAAQPK9QGjKAqNGjWypypRBeoHWAcRn83I0zgSx/p+//d8v+97bmh2Aw92eFDrcIQQQlQjlbqO0MXT5ydNmuSIqkQl6tIgkM8ndqZRiLfWoTjUmawzJOUlSauQEEKIEuxOhC61mKKqqnh5eTF16lQeeeQRe6sSlayOnwfD24RpHYbDPdf9OdqHtqdPeB+tQxFCCFHN2JUIfffdd2Vec3NzIywsjK5du+Lj42NPNULYRVEU2VJDCCFEqexKhG6//XZHxSGqiZ82n2b+5tOMbFuP+/s30Tocu+1K3kWb4Da46Fy0DkUIIUQ1VKnrCImaZ3e8gV1xBn7ackbrUOyWmJPIxGUTmbhsInFZcVqHI4QQohqq1HWERM0zoXsUbcP9ubZ9fa1DsdsnOz8B4FD6Ier71Pz3I4QQwvHsahF65513CAoKIigoiB9//LHE9fnz59uuv/vuu/ZUJapI6/r+3NwtCm/3mp8j/33qbwBaB7dGp0jjpxBCiJLs+nT4448/yMjIQKfTMX78+BLXx48fj6urKxkZGSxZssSeqoSokPzCfArMBQA80OEBjaMRQghRXdmVCB0+fBhFUejSpQuuriVbEFxcXOjcubOtrKgZVh9MYsrPO1mwteaOE9qeuJ0CSwF1vOrQs15PrcMRQghRTdmVCKWmpgLWLTXKUlhYWKysqP52nslg0fb4Gr35atH4oF71e8lCikIIIcpkVyLk7e2Nqqrs2rWLvLyS2zLk5uayc+dOW1lRM/h6WFv3DHkmjSO5MudyznEw7SAAfcP7ahyNEEKI6syuRKhZs2aAtbVn0qRJ5Obm2q7l5uYyadIkUlNTURSFpk2b2hepqDJRQV4ALN19VuNIrsyq06sosBTQwK8BQxoM0TocIYQQ1ZhdU4OGDRvG5s2bAZg7dy7Lli2jXbt2AOzevZu0tDRb2eHDh9tTlahCzer62o5PpOTUuL3HknKTAGtrkMwWE0IIcSl2fUo89NBDBAYG2l6npqayZs0a1qxZU2xMkL+/Pw8+KLt+1xQNgr1sx9/HnNQukCv0z+l/AAj1CtU4EiGEENWdXYlQnTp1mDt3Lh4eHqiqWmxQqqIoqKqKh4cHc+fOpW7dunYHK6qGoii0i/AHYM2hZI2jqbhCi3WAfqinJEJCCCEuze5+gxEjRrB582bGjh1rGzytqire3t6MHTuWzZs3M3LkSEfEKqpQt4ZBAKiqqnEkFZOen05ctnU7jX4R/TSORgghRHXnkOWDW7duzc8//4zFYrF1iQUHB6PTyfiMmmpE2zC+3nCCnIKyl0aojnz0Pnw77FtOGE7g7+6vdThCCCGqOYfuo2AymcjJySE3N5fQUOmWqMmah/kBkJxlJCO3gAAvN40jKh+9i56uYV3pGtZV61CEEE7KZDJdcv08UX46nQ69Xq/pem8OSYRiY2OZPn06a9aswWQyoSgKhYWFvPrqqxw/fhxXV1c+/fTTUlefFtWTj7sr/p56DHkmzhrya0QiZDQbcdO5yQKKQohKkZmZSUpKCkajUetQnIqLiwteXl7UqVMHN7eq/6yxOzOZPXs29913H2azucR4Em9vb2bPno2iKIwYMYIxY8bYW125paWl8frrr/Pbb78RFxeHr68vbdq0YcaMGfTte2GRvU2bNvHcc8+xadMmFEWhV69evPHGG3To0KHEMxMSEpg2bRrLly8nOzub1q1b8/TTTzNu3Lgqe19VqVldH7acTOfA2Uxa1vPTOpzLemvzW2xL3MZjnR9jQOQArcMRQjiRzMxM4uPj8fHxISQkRPNWDGegqipms5m8vDwMBgMnT54kIiICLy+vy9/sQHYlQvv27eP++++nsLAQRVFsM8WKjB8/nqlTpwKwbNmyKkuETp06xYABA8jOzubuu++mWbNmGAwGdu/eTXx8vK1cbGwsAwYMIDw8nBkzZgDw8ccf07dvXzZu3Ejbtm1tZdPS0ujTpw9JSUlMmTKFiIgIfvzxR8aPH8+3337LnXfeWSXvrSpF1/Fl++kM0nIKtA7lss5knuHXo79isphw1UnLoxDCsVJSUvDx8SEiIkISIAfz8fEhKCiIU6dOkZKSQlRUVNUGoNrhzjvvVBVFUXU6ndqgQQM1MjLS9rpIdHS0qtPp1A4dOthTVYX06dNHjYiIUBMSEi5ZrmvXrqqvr68aFxdnOxcXF6f6+vqqQ4cOLVb2ySefVAF18eLFtnOFhYVq165d1aCgIDUrK6vc8RkMBhVQDQZDue/RgiGvQC0oNGsdRrmZzCZ1X8o+1WKxaB2KEMKJFBQUqPv376/2/2fXdOnp6er+/ftVk8l0yXKO/gy1a1rX6tWrAeuCidu3b6d79+4lykRHR6OqKidPnrSnqnJbt24dGzZs4KmnnqJevXqYTKZiW38UOXr0KFu2bGHcuHGEh4fbzoeHhzNu3DhWrlzJuXPnbOd//PFHmjRpwqhRo2znXFxcmDx5MmlpaSxbtqxy35gG/Dz06F1qzsw/V50rrYJbyW9rQgiHKhoYrdfrNY7Eubm7uwMXNmuvKnZ9yp09exZFUejZsydBQUGllikaIJ2Tk2NPVeVWlJBERUUxatQoPD098fb2plmzZsydO9dWbsuWLQD07NmzxDN69OiBqqps27YNsL7P+Ph4evToUWrZi5/njI4kZpFXjafRZ+RnEJ8df/mCQghhB/klq3Jp9edrVyJUlL2V1uJS5PDhw4C1D7AqHDp0CIB7772XtLQ05syZw7fffoubmxu33nor3333HWAd+AwUaw0qUnSuaDxRRcqWxmg0kpmZWeyrphj/eQxD31/H7zurb6Lx1pa3GPHLCL7f973WoQghhKhh7EqEGjdujKqqxMTEcOTIkRLX582bx5EjR6p09/msrCwAfH19Wb16NRMmTODOO+9k/fr1BAQE8Oyzz2KxWGzJW1EydzEPDw/gQoJXkbKlmTlzJv7+/ravyMhIO95h1co2FjK2cwRh/h5ah1KmJceXoKJSYKn+g7qFEEJUL3YlQkOHDgWsi0v16NGDjRs32q4NGTKEO+64o0TZyubp6QnAzTffXGw9gsDAQK699lrOnTvHoUOHbNPzSlsPIj8/H8BWpiJlS/PMM89gMBhsX2fOnLmSt6aJRwY3pUmoDwOa19E6lFIdTj9sOx7XzDmXMRBCCFF57EqEHn30UXx9fQFIT0+3DS5WVZXVq1fbBpj5+PhU2e7zERERAISFhZW4Vq9ePVus9evXB0rv0io6V9TtVZGypXF3d8fPz6/YV00xvE0Yk/o31jqMMq2LWweAr95XttQQQgiNbN682baMTtFyNDWFXYlQeHg4P/zwQ7Euo6I/iCJubm7MmTPHlkxUtm7dugEQFxdX4lrRuTp16tC1q3ULhpiYmBLlYmNjURSFzp07A9YEKjw8nNjY2FLLAnTp0sUxb6AaUhQFs0XFYql+G7B+uP1DAB7sUDWJthBCiJJ++OEH2/G8efM0jKTi7J4bfe2117J582auv/76YrvPe3l5MWbMGDZt2sTo0aMdEGr5jB49Gl9fX+bOnUt2drbt/NmzZ/ntt99o1qwZ0dHRREdH06VLFxYsWGAbDA3WgdELFixg0KBBxVqVbr75Zo4dO8aSJUts58xmM7NmzSIgIICRI0dWzRvUwJhP/6Xliys4nlI1M//K66ThpO24Y92O2gUihBC1mMlk4qeffgKsvTGHDx9m06ZNGkdVfg5ZgrdNmzYsXLgQVVVJSUkBtNt9PjAwkHfeeYf777+fHj16cNddd1FQUMBnn31GQUEBs2bNspX98MMPGThwIH379mXy5MkAzJo1C4vFwrvvvlvsudOmTWPBggXccsstTJkyhfDwcObPn8+WLVv4+uuvbV2EzshoslBQaOFUag7Rdapm9l95fLXnKwC89d60Dm6tcTRCCFE7rVixgpSUFHr37s2wYcN48cUX+eGHH0pdW7A6cmimoigKoaGhhIaGapIEFbnvvvv45Zdf8PHx4YUXXuC1116jefPmrF69mquuuspWrlevXqxZs4aGDRvy/PPP88ILLxAdHc26deto3759sWcGBwfz77//Mnr0aD755BMeeeQRDAYDP/30E3fffXdVv8Uq1SjEG4DNJ9M0jqS4HUk7ALi11a0aRyKEELVX0Rp9EydOZOLEiQD873//w2QyaRlWuSmqqpZ74Mf339u3Tsttt91m1/3OIjMzE39/fwwGQ40YOD1/82meWbSHvk1D+OHu6pHh707ezYRlEwBYe+NagjxKX9BTCCHslZ+fz4kTJ2jUqJFtyRRhZTAYCAsLw2KxcPbsWYKCgujduzcbN25k8eLFxXZjuJzy/jk7+jO0Ql1jd9xxh10rP0oiVDM1CbV2h52oRmOEFhxeAEDXsK6SBAkhNJdbUPFtIdxcdLie38ao0GyhwGxBpyh46F3seq7eRWfbHslsUTEWmlFQ8HRzucydFbdw4ULy8/O57rrrbDtMTJw4kY0bN/LDDz9UKBHSyhWNEapAI5JtR3pZmrzmahBsXSPprCGffJO52D9SrRStH9SxjgySFkJor9WLf1b4nk9u6cTV7azLuvy5L5GHftxO90ZB/O/+C1s/9XlzNWk5FVssdsZ1rbmtZ0MANp9I4+avYmlax4e/p/SvcIyXUzRbrKhLDGD8+PE8+uijLFmyBIPBgL9/9V7apMIDeSqSBF1JeVH91PF1J8THDbNF5Y/dZ7UOh+yCbJJyk9ApOm5pcYvW4QghRK10+vRp1q1bR0BAQLGWn+DgYEaOHEl+fj4LFizQMMLyqVCLUNFu86J2URQF3fkWvV+2xTG2c4Sm8fi4+bBy7EqOZhwl2DNY01iEEAJg/4xhFb7HzeVCW8Sw1nXZP2OY7f/aIhueHljh5+ovem63RkHsnzEMBcf3ysybNw9VVRk7dmyJLagmTpzI77//zty5c7nnnnscXrcjVSgR6t/f8c1qomaY0L0B7688TMzx1GrR1emic6F5UHNNYxBCiCJebvatRuN60XghRz7XRafY/YyyFHWLrVmzhj59+hS7VlBg7c5bt24dp06dokGDBpUSgyM47E/HaDQSExPDqVOnAIiKiqJXr16lblQqap6bukXy/krruJyTqbm2KfVVLasgixxTDmHeJbdQEUIIUTW2bdvGgQMHADh69ChHjx4ttZyqqsybN49nn322KsOrEIcs9vP2228TFhbG4MGDueuuu7jrrrsYMmQIdevW5c0333REFUJjdf0uTGX8fWfJPdeqyme7PmPowqE8te4pzWIQQojarmjtoKlTp9p2lPjv15o1a4qVra7sToQefPBBpk2bhsFgKPGHkJmZybPPPsv999/viFiFxgY0DwWssxC0ctxwHC9XL65qcNXlCwshhHA4s9nM/PnzAev2U2Xp27cv4eHhHDhwgG3btlVVeBVmVyL0zz//8PnnnwOUOmakaOr8119/zapVq+ypSlQDz1/dktEd6jO+S6RmMXw+5HNib4llcNRgzWIQQoja7K+//iIxMZFmzZrRqVOnMsvpdDpuvPFGoPimrNWNXYnQF198YTv28vLivvvu48MPP+TDDz/kvvvuw8vLy5Ygffnll/ZFKjQXXceXD27qyOiO4ZrGoSiK5oO1hRCitipKai7VGlSkqMz8+fMpLKz44pBVoUJbbPxXgwYNOHPmDF5eXsTGxtKmTZti1/ft20e3bt3Iz88nPDyc06dP2x2wM6hpW2xUF9sSt9EyqCVeei+tQxFC1CKyxUbV0GqLDbtahBITE1EUhR49epRIggBat25Njx49UFWV5ORke6oS1URSVj6rDyWxVYMNWD/b9RmjfhvFvpR9VV63EEII52RXIuTm5gZAenp6mWUyMjIA0Ov19lQlqokVe89x53db+HLd8SqvOzk3maTcJLJMWVVetxBCCOdkVyLUsGFDVFVl586dfPLJJyWuf/rpp+zYsQNFUar1Ykqi/Or7e9IoxJu24VW7d4yqqhw3WJOvOl51qrRuIYQQzsuuBRUHDx7M3r17AXjkkUd4++23adGiBQAHDx7kzJkztrJDhw61pypRTQxuWYchrepWeb1f7fnKdhzmJYspCiGEcAy7EqFHH32Ur776iry8PFRV5fTp07bk5+Ix2J6enjzyyCP2RSqqBa1ma608tRIAXzdfGSwthBDCYezuGps9e7Zt/M/FH5JFx3q9nm+//ZaGDRvaU5WoRvIKzBw8l8neeEOV1RmXHQfAhwM/rLI6hRBCOD+7V5YeO3YssbGxjB49Gi8vL9uq0l5eXowePZqYmBjGjx/viFhFNbHhaArDP1jPs7/uqZL68grzyCqwDpBuGdSySuoUQghROzhk09UOHTqwaNEiLBYLqampAAQHB6PTOWQrM1HNhAd4ArA7zkC2sRAf98rZ2bhIWr51qr5ep8dbr81mr0IIIZyTQzMVnU5HaGgooaGhkgQ5saZ1fWzHqw8mVXp9e1OsA/Ib+DWQFaWFEEI4lMN+lS8sLCQ1NRWj0VhmmaioKEdVJzSkd9HRPsKfXXEGlu4+y6j29Su1vnkH5gHQo16PSq1HCCFE7WN3IrR27VpefvllNm7ciMlkKrOcoijVdp8RUXEDW9RhV5yBVQcTUVW1UltqUvOs3a3Ng5pXWh1CCCFqJ7v6r/7++2+GDh3K2rVrKSgosA2ULutLOI8bu1p3oDeZVdJyCiqtnrPZZzmdZd2jrkvdLpVWjxBCiNrJrkTopZdeklaeWqqevyf1/a2b4u2Ky6i0ekwWEy/0eIGhDYYS7qPtrvdCCCGcj11dY7t27bJ1iXTv3p0+ffrg4+NzmbuEs/D3ciPBkM/2UxkMalE5q01H+UUR7BnM8EbDZaC0EEJUI6X9n+zq6kpoaCg9e/bkiSeeoFevXhpEVjF2JULe3t7k5+fTvn17Nm7cKB9UtUzDYC8OnM1kSyXvRC9T5oUQovq6/fbbbcdZWVns2rWLRYsW8euvvzJ37lxuueUWDaO7PLu6xq666ipUVcXDw0OSoFooKti61YXZUjnjv04YTvDs+mdZcHhBpTxfCCGE/WbPnm37+uWXXzh8+DBPP/00qqryyCOPXHIiVXVgVyL0+uuvExwczKZNm3j//fer/ZsVjtW9URAAW0+lk28yO/z5u5N3s+T4EpYdX+bwZwshhKgcOp2OGTNm4OrqSmpqKvv27dM6pEuyq2ssKiqK1atX0717d6ZOncqMGTNo3Lgx/v7+JcoqisKqVavsqU5UM90bBduOd53JoHvj4EuUrrjowGge7PAgUb6y/pQQQtQkbm5u+Pv7k5qaWu0nVdmVCKWlpTFhwgTy8/NRVRWDwcCOHTtKdJNV9jozQhve7q4sf7Qvwd5uhPq6O/z5rYNb0zq4tcOfK4QQonKdOHGC1NRU9Ho90dHRWodzSXYlQk8//TR79uxBURRJdGqplvX8tA5BCCG0V5BT8Xtc3MHl/MewuRDMRlB0oPe087lu4KK3HlvMUJgPKODmVfFnVVB2djY7d+7k8ccfB+CBBx4gICCg0uu1h12J0OLFi1EUxbZYYmBgID4+PrLPmLDb4fTDbDm3hRZBLehct7PW4QghxKW9fgVbDY2bDa3HWI8PLoEFd0CDPnDn0gtlPmgLuakVe+7Id6DbvdbjUxthzjUQ2gIe2lTxGMuhtIYQX19fZs2axUMPPVQpdTqSXYlQbm4uAGFhYaxfv54mTZo4JChRcyRnGXnv78Nk5pn4ZEInhz13Xdw6Ptz+IVc1uEoSISGEqMYunj5vNBo5deoUmzZtYsaMGTRp0oQRI0ZoGN3l2ZUIderUiQ0bNtC2bVtJgmopvYvC/M3WLTDeKTDj6ebikOfGno0FoJ53PYc8TwghKtWzCRW/x+WisZUtRlmfofynR+WxPVfwXLcLxw16nY+t8oavzJ49u8S5HTt20L9/f6699lr27t1L8+bVd69Iu7fYANi0aRPHjx93SECiZgnwcuP5q1vy2pg2WBy4n1yeKQ+AUK9Qhz1TCCEqjZt3xb9cLmqLcHG1nrt4fNAVP1d/4X6dy/nzlT8+6GIdO3bk/vvvp7CwkM8++6xK664ou1qE4uLiGD58OMuXL6dz587cdNNNtGrVqtTp8wC33XabPdWJauqevo0d+ryUvBQOpB0AoG94X4c+WwghRNVo1KgRAEeOHNE4kkuzKxG64447bIOkDAYDX3755SXLSyLkvNJzCjCZLdTx87D7WbuSd2GymGjs35hG/o0cEJ0QQoiqVtRTVN33ILUrESpS2rpBF1+TdYScW8yxVDYcTcbfU899/ewfK5acmwxApG+k/NwIIUQNtGPHDlvjyMiRIzWO5tLsToTUy4wLudx1UfOdScvlk9XHaBHm65BE6FjGMQAa+zu2y00IIYTj3XHHHbbjgoICTp06RWxsLBaLhVGjRnHrrbdqF1w52JUIrV692lFxiBpsYIs6ABw8l0W2sRAfd/vy6xOGEwA0DpBESAghqrs5c+bYjnU6HQEBAfTr149bb72VO+64o9qvLWjXJ1b//v0dFYeowUJ93fFycyG3wExKltH+RCjTmgjJ+CAhhKi+nKXHp3qnaaLGCPGxroeRkm206znncs6RlJuEgkJDv4YOiEwIIYQomyRCwiHq+Vtni204mmLXc1aeWglAu9B2+LuXvgyDEEII4SiSCAmHMBZaAEjMzLfrOQsOLwCgZ/2edsckhBBCXI4kQsIhbu3RAIC49Dy7njOp/SQGRQ6iUx3H7VsmhBBClMUh6wgJEexj3dsmNbvArueMaDSCEY2q9wZ9QgghnIe0CAmHKBosnZRlX9eYEEIIUZUq1CK0bt06AEJDQ2nZsmWlBCRqpguzxgow5Jrw99Jf5o6SDqYdJDEnkWaBzajnI7vOCyGEqHwVahEaMGAAAwcOZPr06dabdTpcXFy48cYbKyM2UYPU8XW3HR84l3lFz/hs52c8/M/D/HjwR0eFJYQQQlzSFXWN/XcRJWdZVElcOZ1OYWDzUAD2xBmu6Bkz+84kwieCKL8oR4YmhBBClKlCXWNFG2DGx8dXSjCiZrurTyNGdwynd3TIFd3vpfdicNRgrml8jYMjE0IIIUpXoUTI398fg8FAbGwsERERtvPLly+nceNL7wulKArHjh27sihFjdC3aajdz5jadaoDIhFCCCHKp0KJUIcOHVi7di0ACQkJgLVbLCcnh5ycnEveW9SaJERpFh1ZRAO/BrQLaYfepeIDrYUQQogrUaExQo899hggY4JE6QoKLfy+M555m05V6GfEZDExfeN07lhxB4aCKxtfJIQQQlyJCrUIXXvttSxZsoTvv/+epKQk1qxZg6IoBAcH07p168qKUdQQZovKoz/tBGB0h3C8y7kLfXJuMioqrjpXgjyCKjFCIYQQjpaTk8MXX3zBkiVL2L9/P+np6Xh7e9OiRQuGDh3KPffcQ1RU9Z0EU+GVpUeOHMnIkSMB6/R5sE6r//nnnx0bmahxPPQ62kcG0CTEm0Jz+VuEYhJiAKjnXQ+dImt8CiFETbFx40ZuuOEGzp07h5eXFz169KBu3boYDAa2bNlCbGwsb731Fn/88QdDhgzROtxS2bXFxm233YaiKHTr1s1R8YgaTFEUfn+od4Xv25iwEYBAj0BHhySEEKKS7Ny5k8GDB5Ofn8/TTz/NCy+8gLe3t+26xWLht99+46mnniIuLk7DSC/NrkRo9uzZDgpD1GZHM44CcG3jazWORAghRHmoqsqtt95Kfn4+06dP56WXXipRRqfTcf311zN48GDOnDmjQZTl47BNV41GIzExMZw6dQqAqKgoevXqhbu7+2XuFM7EYlE5k57LmbQ8+jS9/HpCxzKOcdxwHBfFheGNhldBhEIIIey1YsUK9u7dS0REBM8999wly/r7++Pv719FkVWcQxKht99+m9dff53MzOJbK/j6+vLMM8/w9NNPO6IaUQOk5xbQ/+01ABx9bQSuLpce87M/dT8AwR7B+LtX338oQgghLli6dCkA48aNw9XVYW0qmrB7ZOqDDz7ItGnTMBgMqKpa7CszM5Nnn32W+++/3xGxihrA31OPq866ZtTR5OzLlt8QvwGApoFNKzUuIYQQjrNz504AOnXqpG0gDmBXGvfPP//w+eefoygKiqKUWDum6NzXX3/N+PHjGTx4sF3BiurP1UVHXT8P4jPy2HAkhRZhfpcsf8JwAoD6PvWrIjwhhKgUuabcCt/j5uKGq876MVxoKaTAXIBO0eHh6mHXc/UuevQ668K0ZosZo9mIoih4unpW+FllSU1NBSA01P4dBbRmVyL0xRdf2I69vLyYMGGCbT2hffv2MW/ePHJzrX+JX375pSRCtcSdvRvy6tIDvLr0APf0vfTWKwfSDgDQP6J/VYQmhBCVovuP3St8zzv932FYw2EArDq9iqlrp9Klbhe+G/6drczwX4aTbkyv0HOf7f4sN7e4GYDtSdu568+7aOLfhN9G/1bhGGsDuxKh2NhYADw9PYmJiaFNmzbFrk+ePJlu3bqRn59PTEyMPVWJGqR/s1BeXWpNcOLSc4kI9Cq1XGpequ1YusaEEKLmCA4OBiA5OVnjSOxnVyKUmJiIoij06NGjRBIE0Lp1a3r06MHq1aud4g9LlE/Tur62430JmWUmQkcyjtiOpWtMCFGTbbplU4XvcXNxsx0PjhrMpls2lVhUdsUNKyr83Iv3a+xUpxObbtnk8P0+O3TowL///sv27duZOHGiQ59d1ewaLO3mZv1LTE8vu9kuIyMDAL1eNtKsTa7vFA7AoXNZZZZpF9KOn67+iR9G/FBVYQkhRKXw0ntV+KtofBCAq84VL71XsfFBV/rcovFBAC46F7z0Xg4dHwRw9dVXA7BgwQIKCwsd+uyqZlci1LBhQ1RVZefOnXzyySclrn/66afs2LEDRVFo0KCBPVWJGqZFmLVV6FKJkJfei9YhrelQp0MVRSWEEMIRhg8fTuvWrYmLi+O11167ZNnMzEz27dtXRZFVnF2J0MWDnx955BEaNmzI8OHDGT58OA0bNmTy5Mm260OHDrWnKlHDND8/W+xQYtmJkBBCiJpJURTmzp2Lh4cH06dP55lnniEnJ6dYGVVVWbx4MV26dGHLli0aRXp5do0RevTRR/nqq6/Iy8tDVVVOnz5tW0b74qn0np6ePPLII/ZFKmqURsHW/WZOp+Wiqmqp/dPzDszDoloY2mAoYd5hVR2iEEIIO3To0IGVK1dyww038MYbb/DRRx/Rs2dP26arW7duJTExEQ8PDyIjI7UOt0x2JUINGzZk9uzZTJw4kYKCgmIfdkVrCOn1er799lsaNmxob6yiBqnrb91apaDQQnquiSBvt2LXjWYjb2x+A4CWQS0lERJCiBqod+/eHD16lC+++IIlS5awe/du0tPT8fHxoXnz5kyaNIl77rmHiIgIrUMtk90rS48dO5bY2FhGjx6Nl5eXbVVpLy8vRo8eTUxMDOPHj3dErFckNzeXxo0boygKDz/8cInrhw4dYvTo0QQGBuLt7U3fvn35559/Sn2WwWBg8uTJhIeH4+HhQevWrfnss89KLCQpwN3VhRAfazJ01pBX4rrRbOSDgR8wtMFQmgc1r+rwhBBCOIiPjw9PPPEEa9asISkpCZPJRHp6OrGxsUyfPr1aJ0HgoL3GOnTowKJFi7BYLLbVJoODg9Hp7M6z7Pbiiy+WOXX/2LFj9OrVC1dXV5566in8/f356quvGDZsGMuXL2fIkCG2sgUFBQwdOpQdO3YwefJkWrZsyfLly3nwwQdJTExk+vTpVfSOao5hreuSb7LgoXcpcc3PzY9+4f1oFtAMXzffUu4WQgghqoDqxLZt26a6uLio7777rgqoDz30ULHr48aNU3U6nbpjxw7buaysLDUqKkpt1qyZarFYbOc/+eQTFVA/+uijYs+4/vrrVb1er548ebLccRkMBhVQDQbDlb0xJ5CQlVDsz1cIIaqrvLw8df/+/WpeXp7WoTi18v45O/ozVPsmm0piNpu59957GT58ONdff32J6zk5OSxevJgBAwbQoUMH23kfHx/uueceDh8+XGyU+48//oiXlxf33ntvsec89thjmEwm/ve//1Xae3E253LOcfWvV/Pprk8ptNTs9SeEEELUbE6bCL3//vscPHiQjz/+uNTru3fvxmg00rNnzxLXevToAWBLhCwWC9u3b6djx454eBRf7Kpbt24oilKtpwZqxWJROZ2aS8yx1GLnv9j9BSaLic93fV5sQTEhhBCiqjnlp9CJEyd46aWXePHFF2nYsCEnT54sUSYhIQGA8PDwEteKzsXHxwPWlbPz8vJKLevu7k5ISIitbGmMRiNGo9H2OjMzs0Lvp6aKS8+j39urATgwYziebtaxQmcyrUsstApupVlsQgghBDhpi9CkSZNo3LgxU6ZMKbNMbm4uYE1k/quo1aeozKXKFpUvKlOamTNn4u/vb/uqzuspOFJEoHVJ90Et6pCRV2A7n5pvbSF6qMNDmsQlhBBCFHG6FqG5c+fy999/s27dukvub+blZd0I9OKWmiL5+fnFylyqbFH5ojKleeaZZ4olZZmZmbUiGdLpFPZMvwpvN1d0ugtrTB3NOApAiGeIVqEJIYQQgJ2J0Lp162zHRdPQtWQ0GpkyZQojR44kLCyMo0etH7hF3VYGg4GjR48SEhJC/fr1i127WNG5oq6wwMBAPD09Sy1rNBpJSUmhf//+Zcbl7u5eZmuSs/P1KJ6Mnss5ZzsO9ynZ1SiEENWVKmvGVSqt/nztylwGDBiAoihERUVx4sQJR8V0xfLy8khOTmbp0qUsXbq0xPW5c+cyd+5c3n77bSZNmoS7uzsxMTElysXGxgLQpUsXAHQ6HZ06dWLHjh0YjcZiSc3mzZtRVdVWVhRXaLYQn5GHIc9Eu4gAtpyzDiqv61UXf3d/jaMTQojLc3Gxjm80mUx4ejp2F3dxQVGvS1U3qthVW2BgIBkZGbRu3dpR8djF29ubBQsWlDifnJzMgw8+yPDhw7n77rtp164dPj4+jBo1ikWLFrFr1y7at28PQHZ2Nl9//TVNmzalW7dutmfcfPPN/Pvvv3z55ZfFNpP94IMPcHV15cYbb6z8N1gDxWfk0f/tNQAcfnUEvx79FYCBkQM1jEoIIcpPr9fj7u6OwWDA19e31L0ThX3MZjNpaWl4e3vXrESoR48eLF++nFOnTjkqHrvo9XrGjh1b4nzRrLEmTZoUuz5z5kxWrVrFVVddxeOPP46fnx9fffUV8fHxLF26tNgP+7333st3333HlClTOHnyJC1btmTZsmX8+uuvPP/887KXWhnC/C8sN7By/zmOZRwDoHNYZ61CEkKICiuaHRwXF4e/vz96vV4SIjupqorZbCYvLw+DwYDFYqFevXpVHoddidBLL73E33//zf79+5k7dy4TJ050VFxVIjo6mn///Zdp06bxxhtvUFBQQKdOnVixYkWx7TUA3NzcWLlyJc8//zzz588nNTWVJk2aMGvWLB56SGY/lcXd1YVALz3puSZ2Ju8mLT8NN50bgyIHaR2aEEKUm5+fHwApKSmXXC5FVJyLiwteXl7UqVMHNze3y9/gYIpqx+ik77//nj/++IOFCxeiKArDhg2jb9++1KtXr9R9xm677Ta7gnUWmZmZ+Pv7YzAYbP+4nNnMZQf4Yt1xolp/Q7rlCO1C2zFv5DytwxJCiCtiMpkwm81ah+EUdDpdhVvXHP0ZalcipNPpbMGrqnrZNyI/OFa1LRFafTCJO2dvwbvJW+jc0ni4w8Pc3/5+rcMSQghRAzn6M9RhCypenASpqmr7Knotaq/ujYMAlYK0XjT06sj45uO1DkkIIYQAHLCg4uWSHEmChJebK6BgSu/Dnm3gf0OA1iEJIYQQgJ2J0OrVqx0Vh3Byn0/szKS52wBYdySZAc3raByREEIIYWcidKnVlIW4WMP6GQT6Z5Ju8OH7mFOSCAkhhKgWHLpqkdFo5OzZs+Tm5tKqlewsLi54JeYVCuvvxtUygQ1HXck3mfHQu2gdlhBCiFrOIYOlY2NjGT58OP7+/jRp0oR27doB8Oqrr3LXXXdx3333UVhY6IiqRA2ld9Hj4eqBxRRIQaGFDUdStA5JCCGEsL9FaPbs2dx3332YzeYSA6O9vb2ZPXs2iqIwYsQIxowZY291ooaaPXw2qqry0Lzt1PX3ICrYS+uQhBBCCPvWEdq3bx+dOnXCZDKVWE/IbDYTHx9PVFQUAHfddRdfffWVY6Ku4WrbOkIXy8o3oXfRSbeYEEKIK1Kt1hF69913bUlQZGQk4eHhxa6Hh4fTuHFjALZu3WpPVcJJ+Hro8dC7EJ+RR1pOgdbhCCGEqOXsSoSKps/7+/uzfft2unfvXqJMdHQ0qqraNj4Vtc+aM2u47rfr+HD7hwAs3pXA60sP8NTC3doGJoQQotaza4zQ2bNnURSFnj17EhQUVHoFrtYqcnJy7KlK1GB/nfyL44bjNMtqBoC7q46le84S5udxmTuFEEKIymVXIuTu7o7JZCI3N7fMMocPHwbAx8fHnqpEDXYq8xQAuYXWn5M+0SHMuasb9fwlERJCCKEtu7rGGjdujKqqxMTEcOTIkRLX582bx5EjR1AUhaZNm9pTlajB/N39AWgZ1BIAb3dX+jcLpVldXy3DEkIIIexrERo6dCi7du3CZDLRo0cPPDwu/IY/ZMgQ1q5dW6ysqJ22JloHyncN66pxJEIIIURxdrUIPfroo/j6Wn+rT09P59y5c4B1Cv3q1asxm82AtVvswQcftDNUUROdyzlHXmEeAM0Cm9nOp+cU8Myi3Yz59F/ZmFcIIYRm7EqEwsPD+eGHH3B3d7edUxTFtqYQgJubG3PmzKF+/fr2VCVqqINpB23HgR6BtmNvd1d+2RbPjtMZrDmcrEVoQgghhP1bbFx77bVs3ryZ66+/Hm9vb1RVRVVVvLy8GDNmDJs2bWL06NEOCFXURIk5iQAMiBhQ7Lybq46GIdbVpV/4bW9VhyWEEEIADtp0tU2bNixcuBBVVUlJse4hFRwcjE7nkK3MRA22Jm4NAMGewSWu3dW7EdMW7SExM5+8AjOebrLatBBCiKrl0ExFURRCQ0MJDQ2VJEgAsD91PwAB7gElrt3YNZLwAE9MZpWY47IJqxBCiKrnkGxl//79PPDAA7Ro0QJvb2+8vb1p0aIFkyZNYt++fY6oQtRABqOBtPw0AMY2G1viuqIo9IkOAWDH6YyqDE0IIYQAHJAIffTRR3Ts2JEvv/ySw4cPk5eXR15eHocPH+arr76iU6dOfPDBBw4IVdQ0B9IOABDqGUqEb0SpZRqHegNwOq3sRTmFEEKIymJXIvT777/z2GOPYTKZgAszxi6eOWYymXjiiSf4/fff7Y9W1CgF5gI8XDxIz08vs0xUkHXA9Mr9iVUVlhBCCGFjVyL05ptvAtYESFVV3NzciI6OJjo6Gnd3d1RVtV0rKitqj34R/dg8YTNbJ24ts0zk+UQop8BMQkZeVYUmhBBCAHYmQrt27bK1/Dz11FMkJydz6NAhDh06RHJyMtOmTbMtlrd7t+w0XhspioKLruzZYK3q+dmOf90RXxUhCSGEEDZ2JUKenp6Adfr8G2+8UWxjVW9vb15//XXatm0LUGz7DSGK6HQKYzqGAzJgWgghRNWzKxHq168fqqoSGhpaZpnQ0FAURaF37972VCVqoI+2f8SklZPYEL/hkuVGtq0HwMoDMk5ICCFE1bIrEXrttdfw9PRk06ZNHDp0qMT1AwcOEBsbi16v5+WXX7anKlEDZZuyOZh6kAxjxiXLNavrQ7sIf14f07ZqAhNCCCHOq9DK0t9//32JcxMmTODrr7+mW7duTJgwgVatWgHWtYXmzZtHXl4eN954I7t376ZDhw4OCVrUDE92fZKYhBia+De5ZLkGwd78/lDvYnvUCSGEEFVBUSuw9bdOpyv1w6roEf+9VjRrrEjRbvS1XWZmJv7+/hgMBvz8/C5/Qw120nCShv4Ny10+PaeAAC+9JEVCCCFK5ejP0CvqGivaWPXiBKi0D66icxXItYSTqUgS9Oyve+j62krWym70QgghqkiFE6H/JjUXJ0VlfYnap/f83ty+/Ha2nit7DaH/+nPvOQotKidScioxMiGEEOKCCo0RWr16dWXFIZxIWn4amQWZbE/ajq+bb7nv+9/9PTBbIDLIsxKjE0IIIS6oUCLUv3//yopDOJEj6UcAqOddj+ZBzct9X3Sd8idNQgghhCM4ZPd5IS6WnGcd4xPpG3lF92fmm8gxFjoyJCGEEKJUFWoRupTCwkJSU1MxGo1llomKinJUdaIa++vkXwAEuAdU+N6H5m1n6Z6zvDamDRO6N3BwZEIIIURxdidCa9eu5eWXX2bjxo22XehLoygKhYXyW35tsDXROkA6yCOowvfW87duxfL8b3slERJCCFHp7EqE/v77b66++mrMZrPMDhMAJOcmk1WQBcAdbe6o8P0BXnoA5MdJCCFEVbBrjNBLL70krTyimG2J2wBoGdSScJ/wCt9/a4+GtuPur6/EWCiLcAohhKg8drUI7dq1y7ZoYvfu3enTp0+xHehF7ROXHQdA08CmV3S/v5eeYG83UnMKSMw0snBbnHSRCSGEqDR2JULe3t7k5+fTvn17Nm7cKNsiCNtO8xG+EVf8jPVPD6TnzH8w5Jl476/DkggJIYSoNHZ1jV111VWoqoqHh4ckQQKLarF1jTULaAbZybD1WzBmVeg5Xm6uPDXcuv5Qak4BWfllD8IXQggh7GFXIvT6668THBzMpk2beP/99y85a0w4v5OZJ23H3et1h3ei4Y/HYfHkCj9rbOcLLUqP/2+nA6ITQgghSrKraywqKorVq1fTvXt3pk6dyowZM2jcuDH+/v4lyiqKwqpVq+ypTlRzZouZ/hH9OZl5Eh+3i8aK7fsVxs2u0LPcXV0Y2zmChdviWHkgybGBCiGEEOfZlQilpaUxYcIE8vPzUVUVg8HAjh07SnSTqaoqXWe1QNPApnzsHg2nN0DyoeIXj/0DTQZV6HnPjGjBwm3WwdcJGXnUD5A9yIQQQjiWXV1jTz/9NHv27AGsLT5FX6KWUlVY+RKkn4BPuhW/9sMYsFRsKnywjzv+ntZ1hVYdSHRUlEIIIYSNXS1CixcvRlEU22KKgYGB+Pj4oNPJFma1zWOrH8MNhdvd9LQuKGOs2Lst4MkjFXruv9MGYVFVPFxdHBClEEIIUZxdiVBubi4AYWFhrF+/niZNmjgkKFHzbEzYSF5hHte5uABlJEI5FR/r4+Nu/RFNyykg0EUvLY5CCCEcyq6mm06dOgHQtm1bSYJqMVVV+WDgB4zPzKJT/vlNd8fNgcf3w/PJDqnjrRUHmbfptEOeJYQQQhSxe4sNgE2bNnH8+HGHBCSqIYsZ/v0Qlj9tXRPIbALzha1VFEWhV3A7XkhNx7Nok7DWo8E/HFzd4Oaf7Kp+zaEkjiZl89V6+RkTQgjhWHZ1jcXFxTF8+HCWL19O586duemmm2jVqlWp0+cBbrvtNnuqE1rZ+i38/aL1+PhaSD5gPX4xHYrGg6VcNEtswsLi90f1vHBsygN9xWZ/hQd4svVUOsse6SszEIUQQjiUotqxbbxOpys2WPpyH1Bms2ygCZCZmYm/vz8GgwE/Pz+tw7m8mE/gz2dLnn8+GVzd+O3ob+w9sYpBR9bTyysC7vijZNntP0DiPuh+HwQ1rnAIv2yLY2CLOgR5u13BGxBCCOEsHP0Z6pDpXf+dNq+qqu2r6LWooYzZENa25BpAEd1g7y8AfLv3W/6XsIaj/aeUngQBnImFTZ/BrivrJruhc4QkQUIIIRzOrq4xuHySI0lQDZa4Dz7rVfq1uM0Qtxlj8+GcMJwAoLt7aNnPKvo5WPum9bk3zoUKdHGpqsqeeAMfrTrC62PaUsfPo9z3CiGEEGWxKxFavXq1o+IQ1YkxG+aNhdMxly26Y89c23HTuTfBlIPgV69kwRFvws551uODf8DLATDdUKGwHvvfTo4n5+Ci28sXt3ap0L1CCCFEaexKhPr37++oOER1YS6E2E9LT4L6ToX170DjAXB8DQAHN7wJwYG0yzda+1nLauVx9y15bro/6L1h2mlwufSPoqIoXNu+Ph+sPMKf+xKZs/Ekt/dqWIE3JoQQQpQkS0CL4ta+AatfK35u8nZ4IQUGvwBTj8Ktv9kurfa2zgDrmp9vPeF+iYFrvR8tec6UA6teLldod/ZuZDt+afE+Yo6llus+IYQQoix2tQidPl2xBe6ioqLsqU5UNmMWrHu75PngixbL9Dk/Dih6COajK9nuYR2rE9j+VmhyHbh5lf38oTNgyMvWbrGL5WeUKzx/Tz3z7+3BzV/FAvDGioP8/lDvct0rhBBClMauRKhhw4blXtNFURQKCwsvX1Bo5/CfJc9d80HpZW/4hl0fNLO9HNZ1MniHXb4ORYFpZ+DMJus4JOvJcofYs0kwjwxuykerjrDrTIasKySEEMIuDukau3i6/KW+RDV3ccuMT5h1i4wud5Ze1jOAtR2vByDKJ4Kw8iRBRTz8oOlQGHx+kcbtc2D/75BRvhbGa9vXtx2v2Huu/PUKIYQQ/2F3IlRWglO0tpD8tl6D5KaDzhUm/AJTD1m3yLiEMx7WbrAWwa2urL7sizZh/fk2+KAt5KRc9rboOj624wfmbSffJAt1CiGEuDJ2dY0V7TX2X4mJicTExLBr1y4UReGGG26gTZs29lQlKpOqFh+3E9igXLcdTj8MwNhmYy9Tsgy9H4NNnxc/93YT6DDBOrA6tHmZt354Uwce/WknALP+OcKTw1pcWQxCCCFqNbu22Licd955h6eeeorQ0FB27txJvXqlrC9TC1W7LTYyzsAHFyWq57fOuBSzxUyXeV0otBTy1w1/Uc/nCv9uP+sDiXtKvzbtNHiUvm9dodnC4PfWcio1F1edwpHXRkjroxBC1ALVcouNskydOpWgoCBSUlJ48cUXK7MqYY+cpOKvL5MEAeQW5hLhE4GrzpU6XnWuvO7bF8OdK0q/lnyo9POAq4uOH+/tYX1Er4YUmC1XHoMQQohaq1JbhCwWC6GhoaSnpxMWFkZCQkJlVVWjVKsWoYSd8OVFC2OWozWoiKqqHE4/TPOgsruwrjgOgOs+hY4T7H+2EEIIp+Hoz1C7xgitW7eu1PNms5n09HRmz55Neno6gO27qGb+m3yUMwkC64B4hyRBAPU7WLfcOLEO5oyynks+6JhnCyGEEGWwKxEaMGBAucZlKIpCo0aNLltOaGziL1pHAI36wdXvwtInLtk1VkRVVWKOp7LucAqPDm6Kp5tLFQQphBDCWdi9+zxcfgo9wKRJkxxRlXCktRetIh0QBdFDyn3rO1ve4WD6Qe5sfSe9wx28urPv+YHXR/6EwoLLtlJN/XkXCYZ8XHTI7DEhhBAVUmnrCBVd8/T05IUXXuCRRx6xtyrhaKtfvXD88LYK3bojeQebzm4ix5Tj4KCA8M4XjpdNvWRRRVG4ul09nhrenIHN7Ri0LYQQolayq0Xou+++K/Oam5sbYWFhdO3aFR8fnzLLCY1cnMB2vadCY4MApnWdxnHDcdqHtndwYIDvRatUb58Doz4se1d7YNqIlqTlFBDq6+74WIQQQjg1uxKh22+/3VFxOMzhw4eZO3cuf/31F8eOHSM/P58mTZowbtw4HnvsMby9vYuVP3ToEE8//TRr166loKCATp068fLLLzNo0KASzzYYDDz//PMsWrSI1NRUmjRpwsMPP8ykSZNq3ho2ptwLx4MrvrRB29C2tA1t68CA/sPDH/IN1uM9C6DNWNCV3oDpolMI9XUn32Tmk9VHmTyoKW6ulboyhBBCCCfhdJ8W3377Le+//z5NmjThxRdf5O2336Z58+Y8//zz9OrVi7y8PFvZY8eO0atXL2JiYnjqqad4++23yc7OZtiwYaxcubLYcwsKChg6dCiff/45N954I7NmzaJ58+Y8+OCDvPzyy1X9Nu23Y+6FY/dqsKjjf922+MLxonthRiCY8sosnpptpMULK5j1z1Gm/bK7CgIUQgjhDCq0jtCMGTPsqqwqFlXcunUrTZs2xd+/+IrEzz//PK+99hqzZs3i4YcfBmD8+PH88ssvbNu2jQ4dOgCQnZ1N69at8fDw4ODBg7aWnk8//ZSHHnqIjz76iMmTJ9uee8MNN7BkyRKOHDlCgwbl25qiWqwjlJcBH3WA0BZwVxkLGpYh9mwsm89uplu9bvSo16NSwgNg98/WJKiIbz14ouwp9R1n/EV6rgmAEzNH1rxWOiGEEJfl6M/QCiVCOp3Org8Xs1m7zTH37NlDu3btuP/++/n888/JyckhODiY3r17s2rVqmJlX3nlFV588UU2bdpEt27dAOjTpw87duwgNTUVDw8PW9n169fTr18/3nzzTZ566qlyxVItEiE7vLPlHebsn8PElhN5utvTlVvZ9P9ssfHsWXDzKrXo0aRshry31vZakiEhhHA+NWKLDVVVS3xpLS4uDoC6desCsHv3boxGIz179ixRtkcPayvHli1bAOsK2du3b6djx47FkiCAbt26oSiKrWyNsfcX2PotZJyu8K2nsk4BEOUX5eioSnpgY/HXr9cDs6nUotF1fAjxuTBgetWBpFLLCSGEEEUqnAiVluSUlvQUrSFUHX4jN5vNvPLKK7i6unLLLbcA2Lb7CA8PL1G+6Fx8fDxgXRU7Ly+v1LLu7u6EhITYypbGaDSSmZlZ7Etz/34EfzwOSRVfvflM5hkAGviWryvQLnVbw0sZxc9llr1Vy9bnL6yFNG1RGZu5CiGEEOdVaNbY6tWrL1smLS2N999/nw0bNhRLgnRlzPipCo899hgxMTG8/vrrNG9u3RIiN9c6a8rdveSU66JWn6IylypbVL6oTGlmzpxZ/QZUWwqt3z0q1qxoUS2cybImQlXSIgTWqfP9noR1b4ObL+g9L1n8zRva8vQve0jJNnLgbCYt69W87kchhBBVo0KJUP/+/cu8lpGRwXvvvcesWbPIzMxEURRUVUWn0zF+/HjNdp9/4YUX+Pjjj7nvvvt45plnbOe9vKzjTIxGY4l78vPzi5W5VNmi8kVlSvPMM88wZcoU2+vMzEwiIyMr+E4cbPgbEL8NIrtX6LZzOecosBTgqnMlzDvs8jc4yqDnoekw+GYIvNPU2kpURmvjjV2jePoXa2vQiA/Xs/nZwdTx8yi1rBBCiNrN7maajIwMXnjhBRo2bMhrr71GZmYmqqqiKAo33XQTe/fuZf78+bRs2dIR8VbI9OnTefXVV7nzzjv5/PPPi12rX78+QKldWkXnirrCAgMD8fT0LLWs0WgkJSWl1G6zIu7u7vj5+RX70lTifljzBuQkX3KhwtIcST8CQIRPBK46h+zQUn4H/7hwnHXukkWfv/rCz9vHq49WVkRCCCFquCtOhNLT03n++edp2LAhr7/+erEE6Oabb2bv3r38+OOPtGihzd5P06dP5+WXX+b222/n66+/LjFWqW3btri7uxMTE1Pi3tjYWAC6dOkCWLv1OnXqxI4dO0q0Cm3evBlVVW1la4Tkg3BqA5yOrdBtuaZcHv7HuvRAA78qGB/0X30eu3D8Xgs4uLTMovf0bczHt3QE4PuYUyRm5ldycEIIIWqiCidCRQlQo0aNmDlzpi0B0ul03Hzzzezbt4958+ZplgCBdb2jl19+mVtvvZVvv/221PFJPj4+jBo1ijVr1rBr1y7b+ezsbL7++muaNm1qmzoPcPPNN5Obm8uXX35Z7DkffPABrq6u3HjjjZX3hhxt0X3W7/FbK3Tb3pS9tuOrG1/tyIjKxzMQel20Z91Pt4C5sPh2IRfp1ywUf089M65rXUUBCiGEqGkqtI7Qc889x8cff0x2drZtdpiLiws33XQTL7zwAs2aNau0QMvrk08+4eGHHyYqKopXXnmlRBJUt25dhg4dCsDRo0fp1q0ber2exx9/HD8/P7766iv27NnD0qVLGTZsmO2+goICevXqxa5du3jkkUdo2bIly5Yt49dff+X555/nlVdeKXeMmq8jVLQ2j38UPF7+mVUPrXqIdXHrGBQ5iA8HfVhJwV2G2QSvhJR+7a4/Iar4Ao9x6bkEeLnh417F3XhCCCEqhaM/Qyv06TBz5kzbIGiwTpEvSiTeeOONS96rKArffPPNlUdaTkXr+Zw+fbrUvdD69+9vS4Sio6P5999/mTZtGm+88YZtr7EVK1YwZMiQYve5ubmxcuVKnn/+eebPn2/ba2zWrFk89NBDlf6+KkWXOypU/HjGcQA61ulYCcGUk4se2o6HPT+XvPbtMLh/PdRrZzsVEWgdxH4yJYeP/jlC14ZB3Nytima7CSGEqPbsWlm6aEzQ5RSV03Jl6eqk2rQIjXgbut9XrltUVaXz3M6YLCb+vOFP6vvUr8QAy8FihrejIS+t5LXBL0GHCeBb13bqmUV7mL/5NDoFNk4bTJi/zCITQoiaSNMWof+qDosligq6OO9tdW25b8srzCM6IJrkvGRCPMvomqpKOhcYPwe2fgdu3rDjhwvXVr0Muakw7DXbqddGt6F9hD/9m4dKEiSEEMKmwi1CV1yRtAjZaNoilHoMZnWyHk89Cj6hVVt/ZVFVSDkMP02AVOsUf15MsyZMQgghnIamLUInTpywu0KhsYQdF46dJQkC63pIoc3hjqXw7vlB+x91hMd2lyiakm3kVGounRsEVnGQQgghqpsKJUINGmiwdoxwrJxk6/c2N2gbR2W5aFwQGacgJwW8L3TlbT6Rxk1fxmBRYcPTA22DqYUQQtRO2m0AJrRRkG39bsyu0G2f7vyUUb+OYs6+OZUQlIN1u//C8ZxRxS61i/DHcr4z+BnZlFUIIWo9SYRqmzZjodVoGPJShW6LSYjhZOZJAj1qQHdSzwcvHOdlFLvkoXdhUv8mAKw/kkIFhsgJIYRwQhUaLC0cQ/Pp81cgJS+FE4YTNAloQpBHkNbhXF7CTvjy/CbBTa+CG+eCqzsA+SYzLV5YAUCren4sfaSPzIAUQogawtGfodIiVJsUFsCSR2HdO9bjcjJbzAS6B9I1rGvNSIIA6neA4ecX+TzyFxz+03bJQ+9CrybBAOw/m8m/R1M1CFAIIUR1IIlQbZIZB9tmw7q3rSs0l4Oqqny37zuyTRUbU1Qt9HgAWlwDXe6ClsXHCn1/14V95N77+1BVRyaEEKKakESoNnHzhQHPWhODcnYFncs5x4fbP6TPT33ILqiBydBN8+Ca963v12yynXZ10XF7T+ssSFc71scSQghRs8knQG1ycAls/x76P13uWw6nHwYgOiAaHzefyoqscmUlWrcVeSUETv5rW117QIs6AJxJz9UyOiGEEBqSRKg2+eNxa/fY0ifKfcuRDOsqzU0Dm1ZWVJVvw/sXjmePtE2pbx8RgItO4awhn9UHkzQKTgghhJYkEaotiu0xdl25bytqEWoW2MzREVWdFlcXf31yPQBB3m5Mc/sf3+rf4tXFJVegFkII4fzs2nRV1CAXj++JHlLu25afWA7U8ESoUV+44Rv45e4L5z5oCxmnuRfABVrmP0S+aT8eetmbTAghahNpEaot8tIvHOs9y3VLVkGW7bhGJ0IAbcfCY3svvM44XexyPcs5PNa9XsVBCSGE0JokQrXFZ30uHJdzxtie5AtbUIR5hzk6oqoXEAkdJ5Z9ff07stK0EELUMpII1RZGQ4Vv+e3obwAMjBzo4GA0dN0n1llz13wAUT2t5wY+Z7u87eVeYLFoE5sQQogqJ2OEaoOLP9gf3lauW/IK81h+0jo+aEDkgEoISkMDn7V+73Kn9bvFwvZdO+iUtowu7Kdwzy+4th+Hqqqy9YYQQjg5aRGqDfIzLhwHRJXrlpWnVtqOhzQo/+DqGkmno9PkH20vXTd/DmYTg95dy7rDyRoGJoQQorJJIlQbZJ9fI8cjAFzdynXLCcMJAFoFt8LPrWZsDGsXRYF7/rEex2+FV0J4KOsDbvt2M0eTsi59rxBCiBpLEqHawJgJei/wqVPuW+Ky4wDoXLdzZUVV/YR3goZ9bS/HKqvpp9vFvE2nL3GTEEKImkwSodogshs8dxbuX1/uW65udDV3t7mbEQ1HVGJg1YyiwG2/Q5uxtlMPuCzhu39PYiw0axiYEEKIyqKoMl+4ymVmZuLv74/BYMDPrxZ0O9VEK56B2E8BaJj/I77ursy9pzvtIwO0jUsIIWo5R3+GSouQKFWuqZZvRHrRNiQ6LGQZC/n+s5kk7vxTw6CEEEI4mkyfrw3WvQ1xW6HLXdBs2OWLx61jX+o+bmh6A3W8yj+uyKlEdoeWo+DAEo57TCRb9cBHyYffPocWp8HDX+sIhRBCOIC0CNUGpzfB4RWQnViu4r8f/Z1Pd37K6N9HV25c1ZmiWPcnO89Hyb9w7Y0oSNhZ9TEJIYRwOGkRcnaqCt0nQevRxWZEXco1ja8hrzCPnvV7Vm5s1Z2rOzyyA8wmCo25uH494MK1L/tD44Fw229aRSeEEMIBZLC0Bqp0sPTZXfDDGGjYB8Z/X7l1ObnMtET8PvrP5rPjf4BW12oTkBBC1EIyWFpUzLHVkJsK+ZlaR1Lj+QXVZdfdpzjb9JYLJxfcDoVG7YISQghhF0mEnF3yIev3Br3KVfxQ2iF2Ju3EbJF1c0rTPjKAehM+g5cyyAlqzQnvDrB0Cmz55rL3CiGEqH4kEXJmqgq7zu+hFdS4XLfM2TeHW5ffyqe7Pq3EwGq+nXEG2p97no/TusGOudZk6KvB8PdLsPQJ65+9EEKIak8GSzuztOMXjsPLt1XGpnObAOge1r0yInIaLev5EhnkxTWR4XDg/Mn4rdYvgKie0HZsmfcLIYSoHiQRcmZzb7hwHNTossVzTDkk5Vo3aG0R3KKyonIK7q4urJ46ABgA6wth1cvFCxxeIYmQEELUANI15szST1So+Pp4615kge6BtWPHeQf53Wc8/yodi58c/KI2wQghhKgQaRGqDbxDy1UsNiEWAF8338qMxul0iAqkf96TAOhdFH6fEEGrgCjrRVW1Ls4ohBCiWpIWIWcWdX6m2Mi3y1V8W+I2APpH9q+siJxSg2Bvnhlh7Uo0mVVGfn+Gv1eu4OD8aRTOuxFSjsKqGWDKv8yThBBCVDVpEXJmbt6guIBn0GWLqqrKycyTALQIkvFBFXV//yYMblmXYR+sw2xRmbnqDP+4f2a9+PH5jVoPrYB7V4HeU7tAhRBCFCMtQs5s4kJ4NqFcawhtTdxqO+5dv3dlRuW0ouv4MPP6tgxqUYd0zwZcb5zOn+YuFwok7YO3GsPZ3doFKYQQohhpEXJ2eo9yFVt5aiUArjpXgj2DKzMipza+SyTju0QC8POWltz/SzN6mffyo9vr1gKmXPiiL7yQAi56DSMVQggB0iIkzvvxoHXhxUntJmkcifMY3zWSk29cjVfzwRwnovjFo6u0CUoIIUQxkgg5q6Mr4ZthsPLlyxaNy4qzHXes0/ESJcWVeGZkC+7z/QQe33fh5I4ftAtICCGEjSRCzmrvIjgTCxveu2zRYxnHbMfd6nWrzKhqpSahPqx4rB/4R3DuZmsX5NrDyWw+kWbdsHX7D5B+UtsghRCilpIxQs5IVeHYP9bjW3+7bPH+kf3ZNnEbeYV5lRtXLebqosNiUZnwRw7DC2+ke5eutNn2PBReD4sfthYKawvj5kBwE22DFUKIWkRRVdkdsqplZmbi7++PwWDAz68SVnA2xMP7razHj+2FgEjH1yGuSL7JzJm0XJp+FlF2oRdSwUV+RxFCiNI4+jNUusac0b8fXji+TBKUV5hHal5qJQckinjoXWha1xfqtAbgSfVRjG7/WefplWDY/zuYTRpEKIQQtYskQs5o8xflLrrp7CYG/DyAe/68pxIDEiXcs5LvOi1kYUF3ema+zqzOyyF6yIXrP98Gv94P5kKI3y5JkRBCVBJJhJxZt/svW+S44TgAIV4hlR2NuJibF8P796F9RABp+PHuv+lck/QAhV51L5TJToLTG+G7EbD2Le1iFUIIJyaJkDNzdb9skbva3MXmCZt5vvvzVRCQuFg9f09+fbAXbcKtfdx7k4z0T3uWdF0QRhdvLFe/b92frDAf4rde5mlCCCGuhCRCzsZiuXDc5a5y3eLp6omPm08lBSQuRVEUfnuwNx/e1IHGId7EE0q33A/onvMei057QsM+UK8DuF80IFDmNwghhMPI1BRnk5d+4dgv/JJFVVUl35yPp6tsAqolVxcd13UI59r29dkVZ+DO7zaTnuvKjCX7OJ7cAM/or7m3X2M8Nn0By5+y3vTITghqpGncQgjhDKRFyNlkJ1q/ewaBq9sli645s4Zu87ox6e9JyCoK2lMUhQ6RAayeOoD2Ef5k5hfy6ZpjzIk5RUq2EXQX/d7y2eU30hVCCHF5kgg5m5wk63efOpctuvjYYgC2J21HUZTKjEpUQICXG3Pv6c6Tw5rTrWEQXm4uRAR6Qde7OdN2srWQKRe2f289jt8OcTKGSAghroR0jTmb7PIlQjmmHFaetm73cHvr2ys7KlFBvh56HhoYzUMDo4udXx58G/cxy/pi8WQ4t/fCcgnPJoCbdxVHKoQQNZu0CDkbvSfU7wihLcssYlEtjFw00vb6hqY3VEVkwgHu6BPNW+2WXThx8ZpR6acg+XDVByWEEDWYJELOpuUouG8NjCx73ZkZMTNIy08DYGLLiYR5h1VRcMJebq46nrq+N4wpvmjmXktDPli0GvWzXqhH/tYoOiGEqHkkEaqFfjnyC2CdNj+1y1SNoxFXpP1N8EIq6h1LmdrsT64peJ1WCb+gWExs+eE5DHkmmWYvhBDlIGOEnI2qwiUGPv+w/wfb8Z83/ImLzqUqohKVwcUVpWEf3mkICTmxPHvsHt4ovBk3Cln0RjgoRk5M3ESj6BZaRyqEENWWtAg5m3eawYftreNFSvH70d8BaBbYjECPwKqMTFSiH+/twcZXb6Jfz1500x3ASzECsHj2Gwx6+x9WHUi0LpFgygdTHljMGkcshBDVg6LKAjJVLjMzE39/fwwGA35+fpe/obyM2TDz/CKK086AR/Fn55hy6PFjDwA+HvQx/SP7O65uUW3k5Bfg8VY4LpaCsgv1nQqDX4CUo+ATCh7+VRegEELYwdGfodIi5Ez0XvDYHrjrzxJJEMAnOz+xHUcHRpe4LpyDt4cbLjfPv2SZTUk6kuJPwJf94ZthF8YTHVwGbzWB6f6wcnrlByuEEBqTMULORKeDgCjrVyk61+1MSl4KZ7PPEu5z6e03RA0XPRhuXwL7foWt3144f8cyzsWf4K4lHii7trLXIxuSD1gXaHTzhoxTkJtiLbvhfWh1nXU5BiGEcFLSNaaBSusaKweD0YCvmy86RRoDa6v9CZmM/Gg9c+7sSv+kuaBamFVwLeuPptI/728eMrxb/IYGveGOpZcchC+EEFXF0Z+hkghpoNISoTNb4PByqNsG2lzvuOcKp2MyWzBbVDz01lmDj/9vJ7/uiLddb6aLY7b7e9RXzwGQ3/l+TENexdfz0vvXlcqYDXt/gaZXWVc8l5mKQgg7SCLkBCotEYr9HFY8Da3HwLjZxS49+s+jBHsGM7bZWFoFt3JcncIp7DqTQUJGHocTs1m6J4HDidl4YGSn+314KCYAfiwciNkzmEhPE/s6vMBDg5qCxQIph8E3DDwDrA9LOQIBDeDwCtj9Pzj4x4WKfOrCncshuEnVv0khhFNw9GeojBFyJrmp1u//mQGkqir/nPkHgDYhbSQREiW0jwygfWQAI9rCo0OaMjf2FDvPZNBi2xxudlnFTP033OK6Gkyw1diMzSfTeQjgtwdg909sdu3CD03e4dXr2uD/+0NwZlPpFWUnwqxO8Pg+8I+oyrcohBClkoEiziT5gPV7SLMSl+YMn0Pnup0Z3nB4FQclaqKJPRrwzrj2nJg5ktdffRf12o8pDOvA2UY3kNHpYSb2aGAtGGVdjuGb3D40CPLC3VWBYOuMxCyXAHICmlPYeDD0fhRcPS5UsODOCzPVTqyXPdKEEJqRrjENVFrX2NdDIG4L3DjXuucYkJSbRHx2PB3ryMwfUQlM+ZxIy2fF/mQ6NwymW6MgyM9k9aat3L08Bws6PPQ6ZlzXhvFdIuHAEvjfRHBxh0kbILQZzOoCqUfg+q+g3fgLCZIMzhZClEK6xkTZspOs373rAGCymBi8YDAdQjvw/YjvUeSDRTia3oNGdT14oG7AhXMefkS06MqNqSdYtD2efJOFpxbu5r2/DvPwoHaMv+ZjcHHHNbgpuoJcCIgEYyY0H2G9P+YT6/iiTrdZE6eUwxDUGLLOQWG+tcUzqDGkn4SkAxDVHUZ9qMW7F0I4AWkR0kCltQi9Vs+6Hszk7RDchPe2vcd3e78DYPvE7ehd9I6rS4hysFhU3v37EJ+sPlbiWsNgL2bd3Im2Ef5QkAtuXpCZAO+1rFgl3SfBiDetxwU58NUgqN8J+j9pTZiEEE5FWoRE6QpyrEkQWKcogy0J8nXzlSRIaEKnU3hyWAtu7BLF5Pnb2RVnsF07mZrLqI830CLMl/fGd6BVfcCvPox4C/YsgIQd1in3ne+wtv6kHgXPQHDzgfQT1oVDQ1tCaPMLFZ7dDckHrf8ehs64cD5hJ5hN1n8bPnVA71lFfwJCiOpOEqEKsFgsfPjhh3zxxRecPHmS0NBQxo8fz4wZM/D29tY2uKJuMVdPcPPhUNoh26XHOz+uUVBCWEUFe/H7w33ILSgEILfAzKB31pCZX8jBc1m283kFZrotbwg8yaZnBuLlbl23KDnLiKJAiI/7pSsKawO3LAD/cOseagDJh+D3hyBx74VyXiHQ7kYI72Qd3B0QBR4B1tXZhRC1iiRCFfD444/z0UcfMWbMGJ544gkOHDjARx99xI4dO1i5ciU6Lf8TzTi/27xffVAU9qTssV26rsl1GgUlRHFebq6276ueGMDOMxkARNfxsZXJyrcmRVy0+vm1H2/grCGfqCAvWtbzRacoNAzxplU9P4K9/7PIo64TZEFrPxP+nno4sJgCxQ2Ldzhu+SnozEbrNiKxnxS7TVVcMLkHYvIIwuQRzMEBX2Jx9Tp/UQVFQadTaFbXl6CL61RV6yQFUy4EN7WuqSSLRgpRY0giVE779u1j1qxZXH/99fzyyy+2840aNeKRRx7hp59+4pZbbtEuwOTzLUChLcgvzOflmJcBmNhyIm4uV7AasBCVLNTXnaGt6hY75+6qY/XUAQB4uF5IJnTnB/qfTsvldFpuuZ6/cFJPujQMgn5PMlc3lhl/7OfadvX4aEwjOLEOy6E/2bpjK42Vs4QomSiqGbf8FNzyUyhUddw8exfq+RVGfnN7gTAljd/NvUge9w6j2teH9e+SvnsF+SknqacmXahY52pdI6nxAPAMsg7yzjoLeelw7UdQr721XPx268y44Kbg7lPyDQghqoQkQuU0f/58VFXlscceK3b+3nvvZdq0acydO1fjROig9Xtoc97Z+o7tdIugFhoFJETF6XQKjUJKdjP/O20QZ9JyWX8kBRWVgkILR5KyOXg2kxyjudRnFW0fAhDorad5XV/qBXpaxxm1ug5z81G8cHIDAHrVhJ+aib9qIMCSgRd5NAu4sDBpRGY6JtxY7zOKR/3Pr4eUcpTA5M0lK7YUWsc0bZtd7PQp9+Z8FQM6F2sX3eT9dxBqPMW30R9zxr8TL41qDYZ4+PtFzqVnUpiXRbDeiKclF4xZqMZMKMjF7BFAoXc9Cn3qY/YKwRTUgtyO9+LiouCqU/Bf8TA6Uw7GYW/h4lcPT70LyrbZsOsna2wWE1jM548LrWOnbK9N57+boU5LuGflhTew5DEoyIZBz0NgQ+u5uK1wcr11OQRXN+t3F7cLx65u1tcXX9d7QlCjC8815VuTR52LLJkgNCGJUDlt2bIFnU5Ht27dip338PCgQ4cObNmyRaPIzks+xHpPD741bGFrvLWbTKfouLbJtdrGJYSDRAZ5cUv3qCu6d0zHCMZ0LL6Std5Fx5+P9yvfAzI3gtnI3KIEAKDz7WRHDeBUrgeuodE0jwgFr2D+2rST/y1ZylW6beSjJ1ENIlENZJexMUc3x9luH6H3xqQL4ud92Rx3OW1NhFZMgwOLCSslhKIUwTUvFde8VEixJlTrzW24dWW0rdwu96X4K7kM3zuI42p99r48DB9DHJyJLd97Pe9EQjIPf7QeF52Ci07h25TfCLSk89y5fpxwO8eHN3Uk9OR6WDm9Qs9NdqnLo2Hf216/mvQwjU1HeDvoZXZ49mDGdW2ITvoL/nqBbLOODCO4e3gRGuALLm6Y9d5sjDeTo/O58KX4kqPzZbtnDxQFFBRaGXfib07nqEdr0lzrMmVoM9r7ZsHJDRxOzGTDkWQiAz0Z2rIOoIJq4actp7FYLCgqKIqKgooCbAgYjaJTUIBWOZuoYzzNMe8OJHg256ZukXQNzIU9C0jKymf7qTQCPPT0aBwIKoDKv0eTMZrMtudZv6v8G3Yrha5eKECzjPVE5uzmlF9XTgR0Z2DzOvSoY4YN75NjNHHoXCbuLgqt6/udX2tL5WhiJnkFhbbncv65WxtOItezLgrQMGUNjZNXkRDYjSP1r6VdRADd6uthyaOYzGbi0nLRKdAgyNP23OSsfPJLee7eFo+Q6d8SBaiXuIYmJ+aRFtyJwy0eJDLIi05RgfDbg1hc3DmW40GBWwAtmjbFpW313vtSEqFySkhIICQkBHf3koM1w8PD2bhxIwUFBbi5leyGMhqNGI1G2+vMzEzHBxjWjueUeNKzT9lOLbp2kawdJIQj+NUreS6qBz5RPWj9n9P9unSgc9s2WFTIyC0gOdtIanYBbbKNZOSaKFqvJIY5xABXAa46xfoh1HwE1O/Av2cKOJ6lo0fLBjSNrA/uvsTGm3hp+XH81Uzqkkod0ghWMzijq4OXmwuFFhWzReW1wgm4YiFFtU4rdtUp0HYs1O/A1/+eZsPxDMZ3a8TI9pGgc+Vgci5Tf9mPGRcKccGMDhMuGFU3knIv/F/1rO42opQk/jrjQjKpGAvNUKcVtL+FfWdSOJ2cTtMgN6KD9WA2YczP4+jZVNwoRE8hbooJNwo5a/Ji47FU23ONbvmgg13n8tloSSXHWAj5BsiMwwfwAcg+/wW4AH1L+SvKUL3pYPzK9vpB/Wx6uexncsHDrLX04o5eDSFrO/w2iWZAM4AU4MiFZ9xUxl//tNNdsZzvJh2s/5VRLrFMN93GL2ZvejYJpiunYOV06gC2tftPXri/dxnPfeJkN5IJAGC660p6uv7FljPZfFEYSpCXGz18zRD7Kd5Ap6KbLuTSRFO6Kad6clC1/tLwiMtGhumXsjkun1d3NOX+fo3pVrcu7P0FPWBrmzt34f7QMp47Na4PGy0FAEx02cqr+o3sOGfi0Z29GNs5gk7hvrDzR3SoND1/j+VkOEgi5Bxyc3NLTYLA2ipUVKa0RGjmzJm8/PLLlRofI96g29pCknOTqetVl3vb3UuTANnYUoiq5qF3sXXLhfq607Sub/lv7mDtXu9NyQ/PHvXhz67dStwCMPOiY1UdgUX9f3t3HtXUmf4B/JuQhS2grGNYi4grxQoIVRFstYqOuKJnXIobzowjxwHtnHE6itU6U48dtYqjx71ubaVjbS3U01bRjiLixtiWuAPKoigKAQRCyPv7g19uiQlwAwlL83zO4Zyb9773ue/rSy6PN+99AyRrNGjQMEhFwsaPudz6Y7qPCtGqBsisRYB145Ia3r3U2CAPQYOGccmU9qfxtQbqBgYNG4L6BsYlfk52EqDnWCBgLFBcgfon1ahztQPkjR8pquvUuHezFIZsbbJ9X/0l8jV1mCmyxQyhBN5OtoBTDNArCIVPy1HwpALutoC/kwRQ16GhthI38x9CrKqApL4CYpUS4nolmECIj14fDMYABgbXH0NRWmGP6QGvYaTzq+jXSwZUuAO938SLeg3Ka+ohFVvB2c66cWK+QICHz2vQeE9EANbkfsi7g/qBCazAGOD0cCTuKHsixH0o3J36IdDDERC5A0GzUFmnxsPnNbAWi+Dnas/FVTyqhErN/j/mL/FnefZFrcgOYID9szeQVekMF4dQLHR8pXF9LVsAIxKhrFUj52EFpGIRwvycAQgAgQDZ+c+hrFU3xmSNMTUAwnv2w0ArJzAwiKpH4asaFyilvTHJTo4BcgdAbAuM+wBVdQ1I/+kRrIRCTAv2ahwQgQCnbz5FUUUtGBMAAkDDGtvtZh2ISCsXMAB1qgjsULmizMoNw6XO6ONmDzANEL0B9ZVPcOaaAjKNEmG9m3wM2kXRgoo8BQYGorS0FI8fP9bbN2PGDKSmpqKuro73HSEvLy/TL6hICCGE/MrRgoqdRC6XIzc3F3V1dXp3hoqKiuDi4mIwCQIAqVTa7N0kQgghhHQeWj2Mp9DQUGg0GmRn6z4lUltbi5ycHISEhHRSywghhBDSVpQI8TRz5kwIBAJs2bJFp3z37t148eIFZs+e3TkNI4QQQkib0UdjPAUGBuJPf/oTUlJSMHXqVIwfP55bWToyMrJz1xAihBBCSJtQImSELVu2wNfXF7t27UJaWhpcXFyQkJCAtWvXdu7XaxBCCCGkTeipsU5g6hnvhBBCiKUw9d9Quo1BCCGEEItFiRAhhBBCLBYlQoQQQgixWJQIEUIIIcRiUSJECCGEEItFiRAhhBBCLBYlQoQQQgixWJQIEUIIIcRiUSJECCGEEItFiRAhhBBCLBYlQoQQQgixWJQIEUIIIcRi0bfPdwLt99wqlcpObgkhhBDSvWj/dprqO+MpEeoElZWVAAAvL69ObgkhhBDSPVVWVsLR0bHdcQTMVCkV4U2j0aC4uBgymQwCgcAkMZVKJby8vPDw4UM4ODiYJGZXQP3qfn6tfaN+dS/Ur+7FmH4xxlBZWQm5XA6hsP0zfOiOUCcQCoXw9PQ0S2wHB4df1ZtDi/rV/fxa+0b96l6oX90L336Z4k6QFk2WJoQQQojFokSIEEIIIRaLEqFfCalUiuTkZEil0s5uiklRv7qfX2vfqF/dC/Wre+nMftFkaUIIIYRYLLojRAghhBCLRYkQIYQQQiwWJUKEEEIIsViUCBFCCCHEYlEi1IVpNBps3rwZ/fr1g7W1Nby8vLB8+XJUV1d3yPHmcPv2baxevRrh4eFwdXWFTCbD4MGDsX79et7tioqKgkAgMPhz5coVM/egZc21y97enneM9PR0DBs2DHZ2dnByckJsbCzy8vLM2OqWrVmzptl+CQQCiMXiVmN09pj985//RGxsLPz8/CAQCODr69ti/UuXLmH06NGQyWRwcHDAuHHjkJOTY9Q5TRGjNXz7VVtbi927d2PSpEnw9fWFjY0N/Pz88Lvf/Q4KhYL3+Q4cONDsOC5dutREvTJuvObNm9dsmz7//HPe5ywuLsbbb78NV1dX2NjYICQkBKmpqSbozS/49is/P7/F95xAIMCRI0daPV9HjZex1/Vbt25h8uTJ6NmzJ+zs7BAREYEzZ84YdU5TxNCilaW7sMTERGzduhVTpkzB8uXLoVAosHXrVly/fh3ff/99q0uLt/d4c9i3bx+2b9+OmJgYzJ49G2KxGBkZGfj73/+OY8eOISsrCzY2Nq3GcXFxwebNm/XK/fz8zNFso0RERGDx4sU6ZXySBQA4fvw4pk+fjqCgIGzcuBEVFRXYsmULhg8fjitXrkAul5ujyS2aOnUq/P399cpv3LiBjRs3YuLEibzidOaY/e1vf4OTkxOGDBmC8vLyFutmZWUhKioKHh4eWLt2LQAgJSUFERERyMzMRGBgYKvnM0UMPvj2Kz8/H4sXL8aIESOwcOFCyOVy3L9/Hzt27MDx48dx6tQpjBo1yqjz9u/fX6esb9++be2Gwfh8x0vr0KFDemVDhw7ldeyzZ88wYsQIlJaWIikpCZ6enjh69ChmzJiBffv2Yf78+cY0v1l8++Xq6mqwPwCwdOlS1NTUYOzYsUad15zjZcx1/d69exg2bBhEIhH+8pe/wNHREbt378bYsWPxzTffYPTo0a2ezxQxdDDSJf30009MIBCwqVOn6pRv3bqVAWBHjhwx6/HmcvnyZVZeXq5X/u677zIAbNu2ba3GiIyMZD4+PmZoXfsBYHFxcW06VqVSMblczry9vVllZSVXfv36dSYUCll8fLyJWmkaixcvZgDY119/3Wrdzh6ze/fucdsDBw5ssS2hoaFMJpOxwsJCrqywsJDJZDI2ZswYXuczRQw++Pbr6dOn7Pr163rlP//8M5NIJCw4OJjX+fbv388AsIyMjDa0lj9jxisuLo6190/ZO++8wwCwr776iitTq9UsNDSUOTk56bwf28OYfhmSmZnJALDp06fzqt9R42XMdT02NpYJhUKd38fKykrm7e3NAgICmEajafV8pojRFH001kV98sknYIzhz3/+s055fHw8bG1tcfjwYbMeby4hISEGvyNm5syZAICffvqJdyyNRgOlUgnWBZfCUqlUqKqqMuqYc+fOobi4GIsWLdL5KG3w4MGIiorCZ599hvr6elM3tU2qq6vx6aefwtPTE+PGjeN9XGeNGd+7Tnfv3sXly5cRGxsLDw8PrtzDwwOxsbH4/vvv8ejRI7PH4Itvv5ydnTF48GC98gEDBmDQoEFGve+0KisroVKpjD6Oj7bcJWSMQalUQqPRGH3s0aNH0bt3b527m1ZWVkhISMCzZ8+Qnp5udExD2nv3c8+ePQCARYsWGX2sOceL73W9uroaX331FaKionR+H+3t7bFo0SLcvn0bly9fbvFcpojxMkqEuqjLly9DKBTq3dq1trbG4MGDWx3o9h7f0QoLCwEA7u7uvOoXFRXB3t4ejo6OsLe3x9SpU3Hz5k1zNpG3zz//HLa2tpDJZHBzc0NCQgIqKipaPU47Jq+//rrevvDwcCiVSty+fdvk7W2L1NRUKJVKzJs3D1ZWVryO6cpjptXaGDDGcPXqVbPH6CgajQYlJSW833daMTExcHBwgLW1NYKCgjrtP1ZNOTo6wtHRETY2NhgzZgwuXbrE67iSkhIUFRUhPDxcb5+2rCtcL6uqqnDs2DH4+PhgzJgxRh3bWeP18nX9xo0bqKura/a9AbT+b22KGC+jOUJdVHFxMVxcXAwuN+7h4YHMzEyoVCpIJBKzHN+RGhoasG7dOohEIsyaNavV+q+88gqGDx+OV199FVZWVrh06RJSUlJw+vRpnD9/3mTzL9pi6NChiI2Nhb+/P5RKJdLT05GSkoJz584hMzOzxUnTxcXFAKBzF0FLW1ZUVISBAweap/FG2Lt3LwQCARYsWMCrflces6b4joG5Y3SUnTt3oqSkBKtWreJV39bWFrNmzcIbb7wBNzc35OXlYfv27Zg7dy7u3buH5ORkM7dY329+8xskJiYiODgYdnZ2+N///octW7YgIiIC6enprc4X6S7j9dlnn6GqqgorVqzgPb+zM8fL0HW9y76/jPogjXQYPz8/5uXlZXDf3LlzGQD2/Plzsx3fkZYuXcoAsH/84x9tjvHDDz8woVDIRo8ebcKWmcb69esZAPb++++3WG/BggUMgM48Aq29e/cyAOyLL74wUyv5u3nzJgPA3nzzzXbF6awxa2luxtq1axkAdvr0ab19p0+fZgDY5s2bW4xvihhtYeyckwsXLjCpVMqCgoJYTU1Nm89bW1vLBg0axEQiEcvLy2tznOa0ZS7N7du3ma2tLfP392+17g8//MAAsFWrVunta2hoYADYpEmTjDo/H8b2Kzw8nAmFQlZQUNCu85p7vLQMXdcPHjzIALC9e/fq1b937x4DwJYtW9ZiXFPEeBl9NNZF2draoq6uzuC+2tparo65ju8oq1atQkpKChYvXoyVK1e2OU5ERARGjhyJjIwM1NTUmLCF7ffOO+9AIpEgLS2txXra8TA0bl1pzPbu3QugbfMUmuqKY2aKMegO43j16lVMmDABcrkcaWlpsLa2bnMsqVSKFStWQK1W49tvvzVhK9uuT58+mDFjBu7evdvqx8ndYbxyc3ORlZWFMWPGwNvbu12xOmK8mruud9X3FyVCXZRcLsfTp08NDnZRURFcXFxa/Firvcd3hDVr1uD999/H/PnzsXPnznbH8/X1RUNDA54/f26C1pmOWCzmxqMl2kfjDd3W1ZYZuh3ckdRqNQ4ePAhnZ2dMmTKl3fG62piZYgy6+jheu3YNY8aMgaOjIzIyMkzSFu16OK39jnckvm3q6uMFmO4/H1rmHK+Wrutd9f1FiVAXFRoaCo1Gg+zsbJ3y2tpa5OTkICQkxKzHm9uaNWvw3nvvIS4uDnv27IFAIGh3zDt37kAkEsHJyckELTSd2tpaFBYWtjohNTQ0FABw8eJFvX1ZWVlwcHBAQECAWdrI18mTJ/H48WPMmTPH4PwzY3W1MWttDAQCAYKDg80ew1yuXbvGLfKYkZEBHx8fk8S9c+cOAP4PO3QEvm3q1asXPDw8kJWVpbdPW9aZ10uVSoVDhw7B1dUVkyZNMklMc41Xa9f1wMBASKXSZt8bQOv/1qaIoceoD9JIh7lx40aL6wAdOnSIK7t79y5TKBRtPr6jvffeewwAmzt3LmtoaGi2XnFxMVMoFKy6uporKy8vZ2q1Wq/u119/zQCw6Ohos7SZj6dPnxosX7FiBQPANmzYwJUZ6ptKpWK9evXSW0coJyeHCYVCtnDhQvM1nqcJEyYwAOzGjRsG93eHMWttbkZISAiTyWSsqKiIKysqKmIymUxvXtSTJ0+YQqHQW0PFmBim0lq/rl27xpycnJiXl5fBeWhNVVdXM4VCwYqLi3XKDf2Ol5eXM39/fyaRSNjDhw/b1PaWtNSvqqoqg/Obrl27xiQSCevfv79OeXP90r5HDa0j1KNHD6ZUKtvfkZfwnSOUmprKALCkpKRm63SF8eJ7XZ8+fToTCoUsJyeHK9OuAdSnTx+dNYDKy8uZQqFgT548aXMMPgSMdcFFWAgAICEhASkpKZgyZQrGjx/PrQw9fPhwnDlzhntywNfXFwUFBXprs/A9viNt374dS5cuhbe3N9atW6fXBnd3d+7R0Hnz5uHjjz9GRkYGoqKiAAAnTpxAUlISJk6cCD8/P4hEImRnZ+Pw4cNwcnLChQsXOu2uSWJiIrKysjBq1Ch4e3ujqqoK6enpyMjIQFhYGDIyMrjVVQ31DWh8LH3mzJkICgpCfHw8lEolNm/eDIFAgKtXr3bqLfri4mJ4e3sjODi42UeTu+qYHTp0CAUFBQCAbdu2QaVSYfny5QAAHx8fzJ07l6ubmZmJUaNGwdPTEwkJCdwxjx8/xoULFxAUFMTV1f4PeP/+/Zg3b16bYnREvwoKChAcHIxnz54hOTkZvXv31os1ZcoU2NnZAQDOnj2LUaNGIS4uDgcOHODqyOVyREZGIjAwEG5ubsjPz8e+fftQUlKCf/3rX0hKSurQfuXk5CA6OhqTJ09Gnz59uKfG9u3bB6FQiG+//RYjRozg4jbXr7KyMgQHB6OsrAxJSUnw8PDAJ598grNnz2LPnj1YuHBhh/arqejoaJw6dQq5ubl6q0O31q+OGi9jrut3797F0KFDIRaLkZiYCAcHB+zevRs//vgj0tLSdFbMPnDgAObPn4/k5GSsWbOGKzcmBi9GpU2kQ6nVavbhhx+ygIAAJpFImFwuZ4mJiXqrnPr4+BhcWZXv8R1Juwpscz+RkZF6dZuuipqbm8tiY2OZn58fs7OzYxKJhPn5+bElS5borOLbGU6cOMHeeustJpfLmVQqZba2tiwoKIitX79e73+thvqmdfLkSRYWFsZsbGxYjx492LRp09jdu3c7qBfN0z79tmvXrmbrdNUxi4yM5PU7p5WZmcneeOMNZmdnx+zt7dlbb73Frl69qlcvOTmZAWD79+9vc4yO6FdGRkaL7zsAOk8Qaeu/vEp6UlISGzJkCHNycmIikYg5Ozuz6OhodurUqU7pV0lJCZszZw7r27cvk8lkTCQSMS8vL/b222/r3SVvqV+MNa78PWfOHObs7MykUil77bXX2Kefftop/dJ68OABEwqFbNiwYS3G7ezxMua6zljjNSEmJoY5OjoyGxsbNnz4cPbdd9/pxdWujJ2cnKy3j28MPuiOECGEEEIsFk2WJoQQQojFokSIEEIIIRaLEiFCCCGEWCxKhAghhBBisSgRIoQQQojFokSIEEIIIRaLEiFCCCGEWCxKhAghhBBisSgRIoSYnK+vLwQCgdE/+fn5AKBT1vSrK7orjUaD1157jevT2bNn2xVvzZo1XKxly5aZppGEWChKhAghxMwOHz6MnJwcAEBYWJjO98u1RUJCAve9YDt37sT9+/fb2UJCLJeosxtACPn1GT9+PEpLS3XKzp07h6dPn3Kvo6OjYWtrq1NH+8d92rRpXFloaKgZW2p+arUaq1ev5l5rv2SzPZydnTFv3jxs374dKpUKycnJOHToULvjEmKJ6LvGCCEdIioqCufOneNe5+XlwdfXt/Ma1EG++OILTJ06FQAgk8lQWloKa2vrdse9cOEC983qEokERUVFcHFxaXdcQiwNfTRGCOlyWpoj1HT+UVRUFEpLSxEfHw93d3fY29sjIiKCm4PT0NCAjRs3IiAgAFKpFK+88gpWrVqF+vp6g+ctKyvDunXrEBYWhp49e0IikcDDwwMzZ87EhQsX2tSXXbt2cdsxMTEGk6A7d+7g97//Pfr27QtbW1tIJBL06tULISEh+MMf/oDU1FS9Y4YNGwZPT08AgEqlwscff9ym9hFi8dr0nfWEEGKkyMhIBoD7ycvLa7Zu03pxcXE6+3x8fLh9AwYMYL6+vjr1ATCxWMzOnDnDJk+erLcPAFuwYIHeOTMzM5m7u7vB+gCYQCBga9euNarP1dXVTCwWczH27NmjV+fHH39kMpms2fMCYL179zYYf/bs2VydiIgIo9pGCGlEd4QIId1Wbm4u8vPzMXToUAwZMoQrr6+vx4QJE3DixAl4enpi9OjRkEgk3P79+/cjLy+Pe/3o0SNMnDgRjx8/BtB4Ryo8PBzjx4+Hu7s7AIAxhtWrV+PYsWO825eZmalz98nQfKePPvoIlZWVOnViYmIQFhbGnbs5Q4cO5bazs7NRW1vLu22EkEaUCBFCurUNGzbg0qVLuHLlCjdnBgBqamoQGhqKW7du4bvvvsPmzZu5fYwxnflKH374IcrKygAAVlZWOH/+PC5evIi0tDTk5eUhJCSEq7tq1Srebbt+/brO6/79++vVKSws5Lbj4+ORnZ2NL7/8EllZWXj06BFu3LiBlStXGow/YMAAbruurg4///wz77YRQhrRU2OEkG7LwcGBW0dHIBAgNDQU58+f5/YnJiZyT6aNHDlS59iSkhJuOz09ndu2s7PDpk2bsGnTJq5MqVRy27dv38a9e/fQu3fvVtvX9Mk5BwcHiMVivTr+/v7c9jfffINNmzZh0KBB6NevH7y8vBAYGIjAwECD8Z2cnHRea+9oEUL4o0SIENJt+fn5QSqVcq/t7e119je9Y/Lyvrq6Om5bu5Aj0Jj0/Oc//2nxvAUFBbwSofLycm5bJpMZrLNs2TIcOHAAVVVVKCws1Hm83tnZGePGjcNf//pXDBo0SO9YBweHZs9HCOGHPhojhHRbjo6OOq+FQmGL+03lxYsXvOr16NGD2246D6gpf39/XL9+HQkJCejfvz+srKy4fWVlZThy5AgiIiLw4MEDvWMrKiqaPR8hhB9KhAghFs/Hx4fb9vPzA2OsxZ/f/va3vOK6ublx20qlEmq12mA9f39/bN26Fbm5uaipqcGtW7fw73//m0uKysvLcfToUb3jnj17pvPa1dWVV7sIIb+gRIgQYvGio6O57fv37+ODDz6ARqPRqVNWVobdu3cb9d1egwcP1nmtUCj06hw/fhwnT57kPqoTi8UICAjArFmzYGNjw9UrKCjQOzY3N5fbFovFBj8+I4S0jOYIEUIs3ooVK7B//35ujs3KlSuxY8cODBgwAEKhEHl5ebh16xY0Gg0iIyN5xx02bBhEIhF3J+jKlSt6E5/PnDmD7du3w87ODgMHDoS7uzvUajWuXLmCqqoqrl7TSdVa2dnZ3HZoaKhO4kQI4YcSIUKIxZPL5Th58iSmTZvGPen14MEDg/Nyms7haY2dnR1Gjx6NU6dOAQAyMjIwf/58g3Wrq6t1Epum+vbti/j4eJ2yl5cAiImJ4d0uQsgvKBEihBAAI0aMgEKhwM6dO5GWlgaFQgGlUgkbGxt4eXlhyJAhGDt2LKZMmWJU3MWLF3OJ0Jdffom6ujqdJ92WLFkCuVyO//73v7hz5w6ePHmC6upqODg4ICAgABMnTkRCQoLeE2Lnz59HUVERgMaPxZpLsAghLaMvXSWEEDNSq9Xw9/fn5vikpqZi+vTp7Y67ZMkS7NixAwAwe/ZsHD58uN0xCbFElAgRQoiZHTx4EHFxcQCA8PBwXLx4sV3xysrK4O3tjRcvXkAsFkOhUPBa14gQoo+eGiOEEDObM2cO9wRZVlYWzp49265427Zt49Yy+uMf/0hJECHtQHeECCGEEGKx6I4QIYQQQiwWJUKEEEIIsViUCBFCCCHEYlEiRAghhBCLRYkQIYQQQiwWJUKEEEIIsViUCBFCCCHEYlEiRAghhBCLRYkQIYQQQiwWJUKEEEIIsVj/B4pzg2DouZP5AAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ], + "source": [ + "# Plot number of A, B and C molecules vs Simulation time\n", + "\n", + "### BEGIN SOLUTION ###\n", + "fig = plt.figure(figsize=(6, 6))\n", + "plt.plot(time, xa, \"-.\", label=r\"A\")\n", + "plt.plot(time, xb, \"-.\", label=r\"B\")\n", + "plt.plot(time, xc, \"-.\", label=r\"C\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=15)\n", + "### END SOLUTION ###" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3ICN865nJ1Lz" + }, + "source": [ + "## 3a. Deterministic Equations\n", + "A deterministic rate model for the same reaction network would result in the following rate expressions:\n", + "\\begin{equation}\n", + "r1 = k_1C_a\n", + "\\end{equation}\n", + "\\begin{equation}\n", + "r2 = k_2C_b\n", + "\\end{equation}\n", + "\n", + "Where $C_i$ is the concentration of species $i$, unlike the number of molecules of the stochastic model.\n", + "\n", + "**Using these rate laws, write down the differential equations for the concentration of each species.** Submit this answer on an attached pdf file.\n", + "\n", + "**Answer:**\n", + "\\begin{equation}\n", + "\\frac{dC_a}{dt} = -k_1C_a\n", + "\\end{equation}\n", + "\\begin{equation}\n", + "\\frac{dC_b}{dt} = k_1C_a - k_2C_b\n", + "\\end{equation}\n", + "\\begin{equation}\n", + "\\frac{dC_c}{dt} = k_2C_b\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GkO3k1sgGCoA" + }, + "source": [ + "Note: These equations would be the same for the number of molecules, i.e., one can replace $C_i$ with $x_i$ in the differential equations above. Concentrations can be converted to the number of molecules using Avogadro's number $N_A$ and volume V of the reactor and these constants will cancel out in the equations." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ItSF2Lx5gGTm" + }, + "source": [ + "## 3b. Deterministic Rate Model - Solving Differential Equations" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "02wez7jgFL21" + }, + "source": [ + "**Solve the differential equations to find the analytical solution of the deterministic rate models.** Submit this answer on an attached pdf file. Add these solutions to the code below to plot these deterministic rate model profiles." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 552 + }, + "id": "qIOQXFQTPjoW", + "outputId": "f0ed3c02-3364-4ac9-96fc-678514c54754" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# Analytical solution from solving differential equations of deterministic rate models\n", + "# These models were solved mathematically on paper and in this section we are just plotting the obtained solutions\n", + "\n", + "t = np.linspace(0, 16, 1000)\n", + "\n", + "X_a = xa[0] * np.exp(-k1 * t)\n", + "\n", + "if k1 == k2:\n", + " X_b = xa[0] * k1 * t * np.exp(-k1 * t)\n", + " X_c = xa[0] * (1 + (k1**2) * (-t * (np.exp(-k1 * t) / k1) - (np.exp(-k1 * t) / k1**2)))\n", + "\n", + "else:\n", + " X_b = xa[0] * (k1 / (k1 - k2)) * (np.exp(-k2 * t) - np.exp(-k1 * t))\n", + " X_c = xa[0] * (1 + (k1 * k2 / (k1 - k2)) * ((np.exp(-k1 * t) / k1) - (np.exp(-k2 * t) / k2)))\n", + "\n", + "# Plot deterministic solution of number of A, B and C molecules vs time\n", + "\n", + "### BEGIN SOLUTION ###\n", + "fig = plt.figure(figsize=(6, 6))\n", + "plt.plot(t, X_a, label=r\"A\")\n", + "plt.plot(t, X_b, label=r\"B\")\n", + "plt.plot(t, X_c, label=r\"C\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=15)\n", + "### END SOLUTION ###" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3b-1. - Solving Differential Equations Numerically" + ], + "metadata": { + "id": "ayMYvWWhEH9A" + } + }, + { + "cell_type": "markdown", + "source": [ + "What if instead of solving on paper the found differential equations we decided to do it numerically coding? Two simple alternatives could bring expressive results. They are the Forward Euler Method and the Crank-Nicolson (Trapezoid Rule).\n" + ], + "metadata": { + "id": "hbppJVnlcvIo" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3b-1.1 - Forward Euler Method" + ], + "metadata": { + "id": "IZGXRXGFaUL-" + } + }, + { + "cell_type": "markdown", + "source": [ + "The Forward Euler Method is a numerical technique for approximating the solutions to ordinary differential equations (ODEs). It is well known to be a simple and straightforward method that's useful for solving ODEs when you can't find an exact analytical solution.\n", + "\n", + "Basically, it approximates the solution to a first-order ordinary differential equation of the form:\n", + "\n", + "\\begin{equation}\n", + "\\frac{dy}{dx} = f(x, y)\n", + "\\end{equation}\n", + "\n", + "The Forward Euler Method also works through an iterative approach that breaks down the continuous ODE into discrete steps, by using the following formula to update the solution at each step:\n", + "\n", + "\\begin{equation}\n", + "y_(n+1) = y_n + h * f(x_n, y_n)\n", + "\\end{equation}\n", + "\n", + "In this formula,\n", + "\n", + "$y_(n+1)$ is the new approximation of the solution at the next step.\n", + "\n", + "\n", + "$y_n$ is the previous approximation of the solution at the current step.\n", + "\n", + "$h$ is the step size, which represents the size of the interval over which you're approximating the solution.\n", + "\n", + "$x_n$ is the current value of the independent variable at the nth step.\n", + "\n", + "$f(x_n, y_n)$ is the rate of change of y at the current point $(x_n, y_n).$\n", + "\n", + "This way, by applying the formula and" + ], + "metadata": { + "id": "rbgjRVf7aVcq" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Now, implement the found differential equations into the Forward Euler Method to find and plot the numerically solution.**" + ], + "metadata": { + "id": "bQllXd0omV3H" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define the parameters and initial conditions\n", + "k1 = 0.5\n", + "k2 = 1.0\n", + "xa0 = 1000.0 # Initial concentration of Ca\n", + "t_max = 16.0 # Maximum time\n", + "h = 0.1 # Time step\n", + "\n", + "# Create arrays to store the results\n", + "t_values = np.arange(0, t_max + h, h)\n", + "Ca_values = [xa0] # Initial value\n", + "Cb_values = [0.0] # Initial value\n", + "Cc_values = [0.0] # Initial value\n", + "\n", + "# Numerically solve the differential equations using Forward Euler Method\n", + "\n", + "### BEGIN SOLUTION ###\n", + "for t in t_values[:-1]:\n", + " Ca_next = Ca_values[-1] - k1 * Ca_values[-1] * h\n", + " Cb_next = Cb_values[-1] + (k1 * Ca_values[-1] - k2 * Cb_values[-1]) * h\n", + " Cc_next = Cc_values[-1] + k2 * Cb_values[-1] * h\n", + "\n", + " # Print intermediate results\n", + " print(\"\\nt =\", t)\n", + " print(\"Ca =\", Ca_next)\n", + " print(\"Cb =\", Cb_next)\n", + " print(\"Cc =\", Cc_next)\n", + "\n", + " Ca_values.append(Ca_next)\n", + " Cb_values.append(Cb_next)\n", + " Cc_values.append(Cc_next)\n", + "### END SOLUTION ###\n", + "\n", + "# Plot the concentration profiles\n", + "fig = plt.figure(figsize=(6, 6))\n", + "plt.plot(t_values, Ca_values, label=r\"A\")\n", + "plt.plot(t_values, Cb_values, label=r\"B\")\n", + "plt.plot(t_values, Cc_values, label=r\"C\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=15)\n", + "plt.title('Forward Euler Method')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "8nuMtwo0cH4f", + "outputId": "6a4798e4-ace9-4b99-b5cb-a114d11fcb4f" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "t = 0.0\n", + "Ca = 950.0\n", + "Cb = 50.0\n", + "Cc = 0.0\n", + "\n", + "t = 0.1\n", + "Ca = 902.5\n", + "Cb = 92.5\n", + "Cc = 5.0\n", + "\n", + "t = 0.2\n", + "Ca = 857.375\n", + "Cb = 128.375\n", + "Cc = 14.25\n", + "\n", + "t = 0.30000000000000004\n", + "Ca = 814.50625\n", + "Cb = 158.40625\n", + "Cc = 27.0875\n", + "\n", + "t = 0.4\n", + "Ca = 773.7809375\n", + "Cb = 183.2909375\n", + "Cc = 42.928125\n", + "\n", + "t = 0.5\n", + "Ca = 735.091890625\n", + "Cb = 203.65089062500002\n", + "Cc = 61.25721875000001\n", + "\n", + "t = 0.6000000000000001\n", + "Ca = 698.3372960937501\n", + "Cb = 220.04039609375002\n", + "Cc = 81.62230781250001\n", + "\n", + "t = 0.7000000000000001\n", + "Ca = 663.4204312890625\n", + "Cb = 232.95322128906253\n", + "Cc = 103.62634742187501\n", + "\n", + "t = 0.8\n", + "Ca = 630.2494097246094\n", + "Cb = 242.8289207246094\n", + "Cc = 126.92166955078126\n", + "\n", + "t = 0.9\n", + "Ca = 598.736939238379\n", + "Cb = 250.05849913837892\n", + "Cc = 151.2045616232422\n", + "\n", + "t = 1.0\n", + "Ca = 568.8000922764601\n", + "Cb = 254.98949618645997\n", + "Cc = 176.2104115370801\n", + "\n", + "t = 1.1\n", + "Ca = 540.360087662637\n", + "Cb = 257.930551181637\n", + "Cc = 201.7093611557261\n", + "\n", + "t = 1.2000000000000002\n", + "Ca = 513.3420832795052\n", + "Cb = 259.1555004466051\n", + "Cc = 227.5024162738898\n", + "\n", + "t = 1.3\n", + "Ca = 487.67497911553\n", + "Cb = 258.90705456591985\n", + "Cc = 253.4179663185503\n", + "\n", + "t = 1.4000000000000001\n", + "Ca = 463.29123015975347\n", + "Cb = 257.4000980651044\n", + "Cc = 279.3086717751423\n", + "\n", + "t = 1.5\n", + "Ca = 440.1266686517658\n", + "Cb = 254.82464976658162\n", + "Cc = 305.0486815816527\n", + "\n", + "t = 1.6\n", + "Ca = 418.1203352191775\n", + "Cb = 251.34851822251176\n", + "Cc = 330.53114655831087\n", + "\n", + "t = 1.7000000000000002\n", + "Ca = 397.2143184582186\n", + "Cb = 247.11968316121946\n", + "Cc = 355.66599838056203\n", + "\n", + "t = 1.8\n", + "Ca = 377.3536025353077\n", + "Cb = 242.26843076800844\n", + "Cc = 380.377966696684\n", + "\n", + "t = 1.9000000000000001\n", + "Ca = 358.4859224085423\n", + "Cb = 236.909267817973\n", + "Cc = 404.6048097734848\n", + "\n", + "t = 2.0\n", + "Ca = 340.5616262881152\n", + "Cb = 231.1426371566028\n", + "Cc = 428.29573655528213\n", + "\n", + "t = 2.1\n", + "Ca = 323.5335449737094\n", + "Cb = 225.05645475534828\n", + "Cc = 451.4100002709424\n", + "\n", + "t = 2.2\n", + "Ca = 307.35686772502396\n", + "Cb = 218.72748652849893\n", + "Cc = 473.91564574647725\n", + "\n", + "t = 2.3000000000000003\n", + "Ca = 291.98902433877277\n", + "Cb = 212.22258126190025\n", + "Cc = 495.78839439932716\n", + "\n", + "t = 2.4000000000000004\n", + "Ca = 277.38957312183413\n", + "Cb = 205.59977435264886\n", + "Cc = 517.0106525255172\n", + "\n", + "t = 2.5\n", + "Ca = 263.52009446574243\n", + "Cb = 198.9092755734757\n", + "Cc = 537.5706299607821\n", + "\n", + "t = 2.6\n", + "Ca = 250.3440897424553\n", + "Cb = 192.19435273941525\n", + "Cc = 557.4615575181297\n", + "\n", + "t = 2.7\n", + "Ca = 237.82688525533254\n", + "Cb = 185.4921219525965\n", + "Cc = 576.6809927920712\n", + "\n", + "t = 2.8000000000000003\n", + "Ca = 225.9355409925659\n", + "Cb = 178.8342540201035\n", + "Cc = 595.2302049873308\n", + "\n", + "t = 2.9000000000000004\n", + "Ca = 214.6387639429376\n", + "Cb = 172.24760566772144\n", + "Cc = 613.1136303893412\n", + "\n", + "t = 3.0\n", + "Ca = 203.9068257457907\n", + "Cb = 165.75478329809619\n", + "Cc = 630.3383909561134\n", + "\n", + "t = 3.1\n", + "Ca = 193.71148445850116\n", + "Cb = 159.3746462555761\n", + "Cc = 646.9138692859229\n", + "\n", + "t = 3.2\n", + "Ca = 184.0259102355761\n", + "Cb = 153.12275585294356\n", + "Cc = 662.8513339114805\n", + "\n", + "t = 3.3000000000000003\n", + "Ca = 174.8246147237973\n", + "Cb = 147.011775779428\n", + "Cc = 678.1636094967749\n", + "\n", + "t = 3.4000000000000004\n", + "Ca = 166.08338398760745\n", + "Cb = 141.05182893767508\n", + "Cc = 692.8647870747177\n", + "\n", + "t = 3.5\n", + "Ca = 157.77921478822708\n", + "Cb = 135.25081524328795\n", + "Cc = 706.9699699684852\n", + "\n", + "t = 3.6\n", + "Ca = 149.89025404881573\n", + "Cb = 129.6146944583705\n", + "Cc = 720.495051492814\n", + "\n", + "t = 3.7\n", + "Ca = 142.39574134637496\n", + "Cb = 124.14773771497424\n", + "Cc = 733.456520938651\n", + "\n", + "t = 3.8000000000000003\n", + "Ca = 135.2759542790562\n", + "Cb = 118.85275101079557\n", + "Cc = 745.8712947101484\n", + "\n", + "t = 3.9000000000000004\n", + "Ca = 128.5121565651034\n", + "Cb = 113.73127362366883\n", + "Cc = 757.7565698112279\n", + "\n", + "t = 4.0\n", + "Ca = 122.08654873684823\n", + "Cb = 108.7837540895571\n", + "Cc = 769.1296971735948\n", + "\n", + "t = 4.1000000000000005\n", + "Ca = 115.98222130000582\n", + "Cb = 104.00970611744381\n", + "Cc = 780.0080725825504\n", + "\n", + "t = 4.2\n", + "Ca = 110.18311023500553\n", + "Cb = 99.40784657069972\n", + "Cc = 790.4090431942948\n", + "\n", + "t = 4.3\n", + "Ca = 104.67395472325525\n", + "Cb = 94.97621742538003\n", + "Cc = 800.3498278513648\n", + "\n", + "t = 4.4\n", + "Ca = 99.44025698709248\n", + "Cb = 90.7122934190048\n", + "Cc = 809.8474495939029\n", + "\n", + "t = 4.5\n", + "Ca = 94.46824413773786\n", + "Cb = 86.61307692645894\n", + "Cc = 818.9186789358033\n", + "\n", + "t = 4.6000000000000005\n", + "Ca = 89.74483193085096\n", + "Cb = 82.67518144069994\n", + "Cc = 827.5799866284492\n", + "\n", + "t = 4.7\n", + "Ca = 85.25759033430842\n", + "Cb = 78.8949048931725\n", + "Cc = 835.8475047725192\n", + "\n", + "t = 4.800000000000001\n", + "Ca = 80.994710817593\n", + "Cb = 75.26829392057067\n", + "Cc = 843.7369952618365\n", + "\n", + "t = 4.9\n", + "Ca = 76.94497527671335\n", + "Cb = 71.79120006939326\n", + "Cc = 851.2638246538935\n", + "\n", + "t = 5.0\n", + "Ca = 73.09772651287768\n", + "Cb = 68.45932882628959\n", + "Cc = 858.4429446608328\n", + "\n", + "t = 5.1000000000000005\n", + "Ca = 69.4428401872338\n", + "Cb = 65.26828226930452\n", + "Cc = 865.2888775434618\n", + "\n", + "t = 5.2\n", + "Ca = 65.97069817787211\n", + "Cb = 62.213596051735756\n", + "Cc = 871.8157057703922\n", + "\n", + "t = 5.300000000000001\n", + "Ca = 62.6721632689785\n", + "Cb = 59.29077135545579\n", + "Cc = 878.0370653755658\n", + "\n", + "t = 5.4\n", + "Ca = 59.538555105529575\n", + "Cb = 56.49530238335913\n", + "Cc = 883.9661425111113\n", + "\n", + "t = 5.5\n", + "Ca = 56.5616273502531\n", + "Cb = 53.822699900299696\n", + "Cc = 889.6156727494473\n", + "\n", + "t = 5.6000000000000005\n", + "Ca = 53.733545982740445\n", + "Cb = 51.26851127778238\n", + "Cc = 894.9979427394773\n", + "\n", + "t = 5.7\n", + "Ca = 51.04686868360342\n", + "Cb = 48.828337449141166\n", + "Cc = 900.1247938672554\n", + "\n", + "t = 5.800000000000001\n", + "Ca = 48.49452524942325\n", + "Cb = 46.497847138407224\n", + "Cc = 905.0076276121696\n", + "\n", + "t = 5.9\n", + "Ca = 46.06979898695209\n", + "Cb = 44.27278868703766\n", + "Cc = 909.6574123260103\n", + "\n", + "t = 6.0\n", + "Ca = 43.76630903760448\n", + "Cb = 42.1489997676815\n", + "Cc = 914.0846911947141\n", + "\n", + "t = 6.1000000000000005\n", + "Ca = 41.57799358572426\n", + "Cb = 40.12241524279358\n", + "Cc = 918.2995911714822\n", + "\n", + "t = 6.2\n", + "Ca = 39.49909390643805\n", + "Cb = 38.189073397800435\n", + "Cc = 922.3118326957616\n", + "\n", + "t = 6.300000000000001\n", + "Ca = 37.52413921111614\n", + "Cb = 36.34512075334229\n", + "Cc = 926.1307400355416\n", + "\n", + "t = 6.4\n", + "Ca = 35.64793225056034\n", + "Cb = 34.58681563856387\n", + "Cc = 929.7652521108758\n", + "\n", + "t = 6.5\n", + "Ca = 33.86553563803232\n", + "Cb = 32.9105306872355\n", + "Cc = 933.2239336747323\n", + "\n", + "t = 6.6000000000000005\n", + "Ca = 32.1722588561307\n", + "Cb = 31.312754400413567\n", + "Cc = 936.5149867434558\n", + "\n", + "t = 6.7\n", + "Ca = 30.56364591332417\n", + "Cb = 29.790091903178745\n", + "Cc = 939.6462621834971\n", + "\n", + "t = 6.800000000000001\n", + "Ca = 29.03546361765796\n", + "Cb = 28.33926500852708\n", + "Cc = 942.625271373815\n", + "\n", + "t = 6.9\n", + "Ca = 27.58369043677506\n", + "Cb = 26.95711168855727\n", + "Cc = 945.4591978746678\n", + "\n", + "t = 7.0\n", + "Ca = 26.20450591493631\n", + "Cb = 25.640585041540294\n", + "Cc = 948.1549090435235\n", + "\n", + "t = 7.1000000000000005\n", + "Ca = 24.894280619189495\n", + "Cb = 24.38675183313308\n", + "Cc = 950.7189675476775\n", + "\n", + "t = 7.2\n", + "Ca = 23.64956658823002\n", + "Cb = 23.192790680779247\n", + "Cc = 953.1576427309908\n", + "\n", + "t = 7.300000000000001\n", + "Ca = 22.467088258818517\n", + "Cb = 22.055989942112824\n", + "Cc = 955.4769217990687\n", + "\n", + "t = 7.4\n", + "Ca = 21.34373384587759\n", + "Cb = 20.973745360842468\n", + "Cc = 957.68252079328\n", + "\n", + "t = 7.5\n", + "Ca = 20.27654715358371\n", + "Cb = 19.9435575170521\n", + "Cc = 959.7798953293642\n", + "\n", + "t = 7.6000000000000005\n", + "Ca = 19.262719795904523\n", + "Cb = 18.963029123026075\n", + "Cc = 961.7742510810695\n", + "\n", + "t = 7.7\n", + "Ca = 18.299583806109297\n", + "Cb = 18.029862200518693\n", + "Cc = 963.6705539933721\n", + "\n", + "t = 7.800000000000001\n", + "Ca = 17.38460461580383\n", + "Cb = 17.14185517077229\n", + "Cc = 965.4735402134239\n", + "\n", + "t = 7.9\n", + "Ca = 16.51537438501364\n", + "Cb = 16.29689988448525\n", + "Cc = 967.1877257305011\n", + "\n", + "t = 8.0\n", + "Ca = 15.689605665762958\n", + "Cb = 15.492978615287406\n", + "Cc = 968.8174157189496\n", + "\n", + "t = 8.1\n", + "Ca = 14.905125382474811\n", + "Cb = 14.728161037046814\n", + "Cc = 970.3667135804784\n", + "\n", + "t = 8.200000000000001\n", + "Ca = 14.159869113351071\n", + "Cb = 14.000601202465873\n", + "Cc = 971.839529684183\n", + "\n", + "t = 8.3\n", + "Ca = 13.451875657683518\n", + "Cb = 13.308534537886839\n", + "Cc = 973.2395898044297\n", + "\n", + "t = 8.4\n", + "Ca = 12.779281874799342\n", + "Cb = 12.65027486698233\n", + "Cc = 974.5704432582183\n", + "\n", + "t = 8.5\n", + "Ca = 12.140317781059375\n", + "Cb = 12.024211474024066\n", + "Cc = 975.8354707449166\n", + "\n", + "t = 8.6\n", + "Ca = 11.533301892006406\n", + "Cb = 11.428806215674628\n", + "Cc = 977.0378918923191\n", + "\n", + "t = 8.700000000000001\n", + "Ca = 10.956636797406086\n", + "Cb = 10.862590688707485\n", + "Cc = 978.1807725138865\n", + "\n", + "t = 8.8\n", + "Ca = 10.408804957535782\n", + "Cb = 10.32416345970704\n", + "Cc = 979.2670315827572\n", + "\n", + "t = 8.9\n", + "Ca = 9.888364709658994\n", + "Cb = 9.812187361613127\n", + "Cc = 980.2994479287279\n", + "\n", + "t = 9.0\n", + "Ca = 9.393946474176044\n", + "Cb = 9.325386860934763\n", + "Cc = 981.2806666648892\n", + "\n", + "t = 9.1\n", + "Ca = 8.924249150467242\n", + "Cb = 8.862545498550089\n", + "Cc = 982.2132053509827\n", + "\n", + "t = 9.200000000000001\n", + "Ca = 8.47803669294388\n", + "Cb = 8.422503406218443\n", + "Cc = 983.0994599008377\n", + "\n", + "t = 9.3\n", + "Ca = 8.054134858296685\n", + "Cb = 8.004154900243792\n", + "Cc = 983.9417102414595\n", + "\n", + "t = 9.4\n", + "Ca = 7.651428115381851\n", + "Cb = 7.6064461531342475\n", + "Cc = 984.742125731484\n", + "\n", + "t = 9.5\n", + "Ca = 7.268856709612758\n", + "Cb = 7.228372943589916\n", + "Cc = 985.5027703467974\n", + "\n", + "t = 9.600000000000001\n", + "Ca = 6.905413874132121\n", + "Cb = 6.868978484711562\n", + "Cc = 986.2256076411564\n", + "\n", + "t = 9.700000000000001\n", + "Ca = 6.560143180425515\n", + "Cb = 6.527351329947011\n", + "Cc = 986.9125054896276\n", + "\n", + "t = 9.8\n", + "Ca = 6.232136021404239\n", + "Cb = 6.202623355973586\n", + "Cc = 987.5652406226224\n", + "\n", + "t = 9.9\n", + "Ca = 5.920529220334027\n", + "Cb = 5.893967821446439\n", + "Cc = 988.1855029582197\n", + "\n", + "t = 10.0\n", + "Ca = 5.624502759317325\n", + "Cb = 5.6005975003184965\n", + "Cc = 988.7748997403643\n", + "\n", + "t = 10.100000000000001\n", + "Ca = 5.343277621351459\n", + "Cb = 5.321762888252513\n", + "Cc = 989.3349594903962\n", + "\n", + "t = 10.200000000000001\n", + "Ca = 5.076113740283886\n", + "Cb = 5.056750480494834\n", + "Cc = 989.8671357792214\n", + "\n", + "t = 10.3\n", + "Ca = 4.822308053269691\n", + "Cb = 4.804881119459545\n", + "Cc = 990.3728108272709\n", + "\n", + "t = 10.4\n", + "Ca = 4.581192650606207\n", + "Cb = 4.565508410177076\n", + "Cc = 990.8532989392169\n", + "\n", + "t = 10.5\n", + "Ca = 4.352133018075897\n", + "Cb = 4.338017201689679\n", + "Cc = 991.3098497802346\n", + "\n", + "t = 10.600000000000001\n", + "Ca = 4.134526367172102\n", + "Cb = 4.121822132424506\n", + "Cc = 991.7436515004035\n", + "\n", + "t = 10.700000000000001\n", + "Ca = 3.9278000488134968\n", + "Cb = 3.9163662375406605\n", + "Cc = 992.155833713646\n", + "\n", + "t = 10.8\n", + "Ca = 3.731410046372822\n", + "Cb = 3.721119616227269\n", + "Cc = 992.5474703374\n", + "\n", + "t = 10.9\n", + "Ca = 3.544839544054181\n", + "Cb = 3.535578156923183\n", + "Cc = 992.9195822990227\n", + "\n", + "t = 11.0\n", + "Ca = 3.367597566851472\n", + "Cb = 3.359262318433574\n", + "Cc = 993.273140114715\n", + "\n", + "t = 11.100000000000001\n", + "Ca = 3.1992176885088983\n", + "Cb = 3.19171596493279\n", + "Cc = 993.6090663465584\n", + "\n", + "t = 11.200000000000001\n", + "Ca = 3.0392568040834536\n", + "Cb = 3.032505252864956\n", + "Cc = 993.9282379430517\n", + "\n", + "t = 11.3\n", + "Ca = 2.887293963879281\n", + "Cb = 2.8812175677826333\n", + "Cc = 994.2314884683382\n", + "\n", + "t = 11.4\n", + "Ca = 2.742929265685317\n", + "Cb = 2.737460509198334\n", + "Cc = 994.5196102251165\n", + "\n", + "t = 11.5\n", + "Ca = 2.605782802401051\n", + "Cb = 2.6008609215627665\n", + "Cc = 994.7933562760363\n", + "\n", + "t = 11.600000000000001\n", + "Ca = 2.475493662280998\n", + "Cb = 2.4710639695265426\n", + "Cc = 995.0534423681926\n", + "\n", + "t = 11.700000000000001\n", + "Ca = 2.3517189791669484\n", + "Cb = 2.347732255687938\n", + "Cc = 995.3005487651452\n", + "\n", + "t = 11.8\n", + "Ca = 2.234133030208601\n", + "Cb = 2.2305449790774916\n", + "Cc = 995.535321990714\n", + "\n", + "t = 11.9\n", + "Ca = 2.122426378698171\n", + "Cb = 2.1191971326801724\n", + "Cc = 995.7583764886217\n", + "\n", + "t = 12.0\n", + "Ca = 2.0163050597632624\n", + "Cb = 2.0133987383470635\n", + "Cc = 995.9702962018897\n", + "\n", + "t = 12.100000000000001\n", + "Ca = 1.9154898067750992\n", + "Cb = 1.9128741175005204\n", + "Cc = 996.1716360757245\n", + "\n", + "t = 12.200000000000001\n", + "Ca = 1.8197153164363442\n", + "Cb = 1.8173611960892233\n", + "Cc = 996.3629234874745\n", + "\n", + "t = 12.3\n", + "Ca = 1.728729550614527\n", + "Cb = 1.7266108423021183\n", + "Cc = 996.5446596070834\n", + "\n", + "t = 12.4\n", + "Ca = 1.6422930730838008\n", + "Cb = 1.6403862356026329\n", + "Cc = 996.7173206913136\n", + "\n", + "t = 12.5\n", + "Ca = 1.5601784194296107\n", + "Cb = 1.5584622656965597\n", + "Cc = 996.8813593148739\n", + "\n", + "t = 12.600000000000001\n", + "Ca = 1.4821694984581302\n", + "Cb = 1.4806249600983843\n", + "Cc = 997.0372055414435\n", + "\n", + "t = 12.700000000000001\n", + "Ca = 1.4080610235352236\n", + "Cb = 1.4066709390114525\n", + "Cc = 997.1852680374534\n", + "\n", + "t = 12.8\n", + "Ca = 1.3376579723584623\n", + "Cb = 1.3364068962870683\n", + "Cc = 997.3259351313545\n", + "\n", + "t = 12.9\n", + "Ca = 1.2707750737405392\n", + "Cb = 1.2696491052762846\n", + "Cc = 997.4595758209832\n", + "\n", + "t = 13.0\n", + "Ca = 1.2072363200535123\n", + "Cb = 1.206222948435683\n", + "Cc = 997.5865407315108\n", + "\n", + "t = 13.100000000000001\n", + "Ca = 1.1468745040508368\n", + "Cb = 1.1459624695947903\n", + "Cc = 997.7071630263544\n", + "\n", + "t = 13.200000000000001\n", + "Ca = 1.0895307788482949\n", + "Cb = 1.088709947837853\n", + "Cc = 997.8217592733138\n", + "\n", + "t = 13.3\n", + "Ca = 1.0350542399058802\n", + "Cb = 1.0343154919964825\n", + "Cc = 997.9306302680975\n", + "\n", + "t = 13.4\n", + "Ca = 0.9833015279105862\n", + "Cb = 0.9826366547921283\n", + "Cc = 998.0340618172971\n", + "\n", + "t = 13.5\n", + "Ca = 0.9341364515150569\n", + "Cb = 0.9335380657084448\n", + "Cc = 998.1323254827763\n", + "\n", + "t = 13.600000000000001\n", + "Ca = 0.887429628939304\n", + "Cb = 0.8868910817133532\n", + "Cc = 998.2256792893471\n", + "\n", + "t = 13.700000000000001\n", + "Ca = 0.8430581474923388\n", + "Cb = 0.8425734549889831\n", + "Cc = 998.3143683975185\n", + "\n", + "t = 13.8\n", + "Ca = 0.8009052401177218\n", + "Cb = 0.8004690168647017\n", + "Cc = 998.3986257430174\n", + "\n", + "t = 13.9\n", + "Ca = 0.7608599781118357\n", + "Cb = 0.7604673771841176\n", + "Cc = 998.4786726447039\n", + "\n", + "t = 14.0\n", + "Ca = 0.7228169792062439\n", + "Cb = 0.7224636383712977\n", + "Cc = 998.5547193824224\n", + "\n", + "t = 14.100000000000001\n", + "Ca = 0.6866761302459317\n", + "Cb = 0.6863581234944801\n", + "Cc = 998.6269657462595\n", + "\n", + "t = 14.200000000000001\n", + "Ca = 0.6523423237336351\n", + "Cb = 0.6520561176573287\n", + "Cc = 998.695601558609\n", + "\n", + "t = 14.3\n", + "Ca = 0.6197252075469534\n", + "Cb = 0.6194676220782777\n", + "Cc = 998.7608071703747\n", + "\n", + "t = 14.4\n", + "Ca = 0.5887389471696057\n", + "Cb = 0.5885071202477976\n", + "Cc = 998.8227539325826\n", + "\n", + "t = 14.5\n", + "Ca = 0.5593019998111255\n", + "Cb = 0.5590933555814981\n", + "Cc = 998.8816046446074\n", + "\n", + "t = 14.600000000000001\n", + "Ca = 0.5313368998205692\n", + "Cb = 0.5311491200139046\n", + "Cc = 998.9375139801655\n", + "\n", + "t = 14.700000000000001\n", + "Ca = 0.5047700548295407\n", + "Cb = 0.5046010530035425\n", + "Cc = 998.9906288921669\n", + "\n", + "t = 14.8\n", + "Ca = 0.4795315520880637\n", + "Cb = 0.4793794504446653\n", + "Cc = 999.0410889974672\n", + "\n", + "t = 14.9\n", + "Ca = 0.4555549744836605\n", + "Cb = 0.45541808300460196\n", + "Cc = 999.0890269425117\n", + "\n", + "t = 15.0\n", + "Ca = 0.43277722575947747\n", + "Cb = 0.43265402342832476\n", + "Cc = 999.1345687508122\n", + "\n", + "t = 15.100000000000001\n", + "Ca = 0.4111383644715036\n", + "Cb = 0.41102748237346615\n", + "Cc = 999.177834153155\n", + "\n", + "t = 15.200000000000001\n", + "Ca = 0.3905814462479284\n", + "Cb = 0.39048165235969473\n", + "Cc = 999.2189369013923\n", + "\n", + "t = 15.3\n", + "Ca = 0.371052373935532\n", + "Cb = 0.37096255943612166\n", + "Cc = 999.2579850666283\n", + "\n", + "t = 15.4\n", + "Ca = 0.3524997552387554\n", + "Cb = 0.3524189221892861\n", + "Cc = 999.295081322572\n", + "\n", + "t = 15.5\n", + "Ca = 0.3348747674768176\n", + "Cb = 0.3348020177322953\n", + "Cc = 999.3303232147908\n", + "\n", + "t = 15.600000000000001\n", + "Ca = 0.31813102910297675\n", + "Cb = 0.3180655543329066\n", + "Cc = 999.3638034165641\n", + "\n", + "t = 15.700000000000001\n", + "Ca = 0.3022244776478279\n", + "Cb = 0.3021655503547648\n", + "Cc = 999.3956099719974\n", + "\n", + "t = 15.8\n", + "Ca = 0.2871132537654365\n", + "Cb = 0.2870602192016797\n", + "Cc = 999.4258265270329\n", + "\n", + "t = 15.9\n", + "Ca = 0.2727575910771647\n", + "Cb = 0.27270985996978353\n", + "Cc = 999.454532548953\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3b-1.2 Crank-Nicolson (Trapezoid Rule)" + ], + "metadata": { + "id": "v9urNjZgaT1h" + } + }, + { + "cell_type": "markdown", + "source": [ + "Alternatively, the Trapezoid Rule is a numerical method used to approximate the solutions of ordinary differential equations (ODEs). It is a widely used method that provides a straightforward approach to solving ODEs when an exact analytical solution is not available.\n", + "\n", + "It also approximates the solution to a first-order ordinary differential equation of the form:\n", + "\n", + "\\begin{equation}\n", + "\\frac{dy}{dx} = f(x, y)\n", + "\\end{equation}\n", + "\n", + "The Trapezoid Rule also operates through an iterative approach that discretizes the continuous ODE into discrete steps by using the following formula to update the solution at each step:\n", + "\n", + "\\begin{equation}\n", + "y_{n+1} = y_n + \\frac{h}{2} \\left[f(x_n, y_n) + f(x_{n+1}, y_{n+1})\\right]\n", + "\\end{equation}\n", + "\n", + "In this formula:\n", + "\n", + "$y_{n+1}$ is the new approximation of the solution at the next step.\n", + "\n", + "$y_n$ is the previous approximation of the solution at the current step.\n", + "\n", + "$h$ is the step size, representing the size of the interval over which the solution is approximated.\n", + "\n", + "$x_n$ is the current value of the independent variable at the nth step.\n", + "\n", + "$f(x_n, y_n)$ and $f(x_{n+1}, y_{n+1})$ represent the rate of change of y at the current point $(x_n, y_n)$ and the predicted point $(x_{n+1}, y_{n+1})$, respectively." + ], + "metadata": { + "id": "r1EYn2umKwWW" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Now, implement the found differential equations into the Crank-Nicolson (Trapezoid Rule) to find and plot the numerically solution.**" + ], + "metadata": { + "id": "ZqnzYbpfnvHm" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define the parameters and initial conditions\n", + "k1 = 0.5\n", + "k2 = 1.0\n", + "xa0 = 1000.0 # Initial concentration of Ca\n", + "t_max = 16.0 # Maximum time\n", + "dt = 0.1 # Time step\n", + "\n", + "# Define the rate equations\n", + "RHS_Ca = lambda Ca, Cb, t: -k1 * Ca\n", + "RHS_Cb = lambda Ca, Cb, t: k1 * Ca - k2 * Cb\n", + "RHS_Cc = lambda Cb, t: k2 * Cb\n", + "\n", + "# Function to perform Crank-Nicolson method\n", + "def crank_nicolson(RHS_Ca, RHS_Cb, RHS_Cc, Ca0, Cb0, Cc0, dt, numsteps, LOUD=False):\n", + " numsteps = int(numsteps)\n", + " Ca = np.zeros(numsteps+1)\n", + " Cb = np.zeros(numsteps+1)\n", + " Cc = np.zeros(numsteps+1)\n", + " t = np.arange(numsteps+1) * dt\n", + " Ca[0] = Ca0\n", + " Cb[0] = Cb0\n", + " Cc[0] = Cc0\n", + " for n in range(1, numsteps+1):\n", + " if LOUD:\n", + " print(\"\\nt =\", t[n])\n", + "\n", + " # Crank-Nicolson Method\n", + "### BEGIN SOLUTION ###\n", + " Ca_half = Ca[n-1] + 0.5 * dt * RHS_Ca(Ca[n-1], Cb[n-1], t[n])\n", + " Cb_half = Cb[n-1] + 0.5 * dt * RHS_Cb(Ca[n-1], Cb[n-1], t[n])\n", + " Cc_half = Cc[n-1] + 0.5 * dt * RHS_Cc(Cb[n-1], t[n])\n", + "\n", + " Ca[n] = Ca[n-1] + dt * RHS_Ca(Ca_half, Cb_half, t[n] + 0.5 * dt)\n", + " Cb[n] = Cb[n-1] + dt * RHS_Cb(Ca_half, Cb_half, t[n] + 0.5 * dt)\n", + " Cc[n] = Cc[n-1] + dt * RHS_Cc(Cb_half, t[n] + 0.5 * dt)\n", + "\n", + " if LOUD:\n", + " print(\"Ca =\", Ca[n])\n", + " print(\"Cb =\", Cb[n])\n", + " print(\"Cc =\", Cc[n])\n", + "\n", + " return t, Ca, Cb, Cc\n", + "\n", + "# Perform the Crank-Nicolson method\n", + "t, Ca, Cb, Cc = crank_nicolson(RHS_Ca, RHS_Cb, RHS_Cc, xa0, 0.0, 0.0, dt, t_max / dt, True)\n", + "### END SOLUTION ###\n", + "\n", + "# Plot the concentration profiles\n", + "fig = plt.figure(figsize=(6, 6))\n", + "plt.plot(t, Ca, label=r\"A\")\n", + "plt.plot(t, Cb, label=r\"B\")\n", + "plt.plot(t, Cc, label=r\"C\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=15)\n", + "plt.title('Crank-Nicolson (Trapezoid Rule)')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "y8QFkj-FKvMX", + "outputId": "c94287a4-09e1-4f2d-a026-5a2d7d950288" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "t = 0.1\n", + "Ca = 951.25\n", + "Cb = 46.25\n", + "Cc = 2.5\n", + "\n", + "t = 0.2\n", + "Ca = 904.8765625\n", + "Cb = 85.8515625\n", + "Cc = 9.271875000000001\n", + "\n", + "t = 0.30000000000000004\n", + "Ca = 860.763830078125\n", + "Cb = 119.54620507812501\n", + "Cc = 19.689964843750005\n", + "\n", + "t = 0.4\n", + "Ca = 818.8015933618165\n", + "Cb = 147.9996427368164\n", + "Cc = 33.198763901367194\n", + "\n", + "t = 0.5\n", + "Ca = 778.8850156854279\n", + "Cb = 171.80925036980287\n", + "Cc = 49.305733944769294\n", + "\n", + "t = 0.6000000000000001\n", + "Ca = 740.9143711707633\n", + "Cb = 191.51080356012264\n", + "Cc = 67.57482526911414\n", + "\n", + "t = 0.7000000000000001\n", + "Ca = 704.7947955761886\n", + "Cb = 207.58456688855878\n", + "Cc = 87.62063753525271\n", + "\n", + "t = 0.8\n", + "Ca = 670.4360492918494\n", + "Cb = 220.4607923295444\n", + "Cc = 109.10315837860627\n", + "\n", + "t = 0.9\n", + "Ca = 637.7522918888717\n", + "Cb = 230.52468433798572\n", + "Cc = 131.72302377314261\n", + "\n", + "t = 1.0\n", + "Ca = 606.6618676592892\n", + "Cb = 238.1208828257374\n", + "Cc = 155.21724951497345\n", + "\n", + "t = 1.1\n", + "Ca = 577.0871016108989\n", + "Cb = 243.55751033653448\n", + "Cc = 179.35538805256672\n", + "\n", + "t = 1.2000000000000002\n", + "Ca = 548.9541054073676\n", + "Cb = 247.10982530406778\n", + "Cc = 203.93606928856474\n", + "\n", + "t = 1.3\n", + "Ca = 522.1925927687585\n", + "Cb = 249.0235192752721\n", + "Cc = 228.7838879559696\n", + "\n", + "t = 1.4000000000000001\n", + "Ca = 496.7357038712815\n", + "Cb = 249.51769235967632\n", + "Cc = 253.74660376904234\n", + "\n", + "t = 1.5\n", + "Ca = 472.5198383075565\n", + "Cb = 248.78753788955385\n", + "Cc = 278.6926238028898\n", + "\n", + "t = 1.6\n", + "Ca = 449.4844961900631\n", + "Cb = 247.00676431177072\n", + "Cc = 303.5087394981663\n", + "\n", + "t = 1.7000000000000002\n", + "Ca = 427.57212700079754\n", + "Cb = 244.32977965094292\n", + "Cc = 328.0980933482597\n", + "\n", + "t = 1.8\n", + "Ca = 406.72798580950865\n", + "Cb = 240.89366145789023\n", + "Cc = 352.37835273260123\n", + "\n", + "t = 1.9000000000000001\n", + "Ca = 386.8999965012951\n", + "Cb = 236.81993296308045\n", + "Cc = 376.2800705356246\n", + "\n", + "t = 2.0\n", + "Ca = 368.03862167185696\n", + "Cb = 232.2161641697727\n", + "Cc = 399.74521415837046\n", + "\n", + "t = 2.1\n", + "Ca = 350.0967388653539\n", + "Cb = 227.17741482596767\n", + "Cc = 422.7258463086785\n", + "\n", + "t = 2.2\n", + "Ca = 333.02952284566794\n", + "Cb = 221.78753459002337\n", + "Cc = 445.1829425643088\n", + "\n", + "t = 2.3000000000000003\n", + "Ca = 316.7943336069416\n", + "Cb = 216.1203342355833\n", + "Cc = 467.0853321574752\n", + "\n", + "t = 2.4000000000000004\n", + "Ca = 301.3506098436032\n", + "Cb = 210.24064041252393\n", + "Cc = 488.40874974387293\n", + "\n", + "t = 2.5\n", + "Ca = 286.6597676137275\n", + "Cb = 204.2052452786008\n", + "Cc = 509.1349871076717\n", + "\n", + "t = 2.6\n", + "Ca = 272.6851039425583\n", + "Cb = 198.06376122926864\n", + "Cc = 529.2511348281731\n", + "\n", + "t = 2.7\n", + "Ca = 259.3917051253586\n", + "Cb = 191.85938996983143\n", + "Cc = 548.74890490481\n", + "\n", + "t = 2.8000000000000003\n", + "Ca = 246.7463595004974\n", + "Cb = 185.6296142847453\n", + "Cc = 567.6240262147575\n", + "\n", + "t = 2.9000000000000004\n", + "Ca = 234.71747447484813\n", + "Cb = 179.4068200545925\n", + "Cc = 585.8757054705595\n", + "\n", + "t = 3.0\n", + "Ca = 223.27499759419928\n", + "Cb = 173.21885534386792\n", + "Cc = 603.5061470619329\n", + "\n", + "t = 3.1\n", + "Ca = 212.39034146148205\n", + "Cb = 167.08953272493218\n", + "Cc = 620.5201258135859\n", + "\n", + "t = 3.2\n", + "Ca = 202.0363123152348\n", + "Cb = 161.03908040865718\n", + "Cc = 636.9246072761082\n", + "\n", + "t = 3.3000000000000003\n", + "Ca = 192.1870420898671\n", + "Cb = 155.08454721441436\n", + "Cc = 652.7284106957187\n", + "\n", + "t = 3.4000000000000004\n", + "Ca = 182.81792378798608\n", + "Cb = 149.24016592570135\n", + "Cc = 667.9419102863127\n", + "\n", + "t = 3.5\n", + "Ca = 173.90555000332176\n", + "Cb = 143.51767913795408\n", + "Cc = 682.5767708587243\n", + "\n", + "t = 3.6\n", + "Ca = 165.42765444065984\n", + "Cb = 137.92663130750208\n", + "Cc = 696.6457142518383\n", + "\n", + "t = 3.7\n", + "Ca = 157.36305628667768\n", + "Cb = 132.4746303511699\n", + "Cc = 710.1623133621526\n", + "\n", + "t = 3.8000000000000003\n", + "Ca = 149.69160729270214\n", + "Cb = 127.16758182106761\n", + "Cc = 723.1408108862305\n", + "\n", + "t = 3.9000000000000004\n", + "Ca = 142.39414143718292\n", + "Cb = 122.00989838535367\n", + "Cc = 735.5959601774637\n", + "\n", + "t = 4.0\n", + "Ca = 135.45242704212026\n", + "Cb = 117.00468708021478\n", + "Cc = 747.5428858776652\n", + "\n", + "t = 4.1000000000000005\n", + "Ca = 128.8491212238169\n", + "Cb = 112.15391655829244\n", + "Cc = 758.9969622178909\n", + "\n", + "t = 4.2\n", + "Ca = 122.56772656415582\n", + "Cb = 107.45856634185618\n", + "Cc = 769.9737070939882\n", + "\n", + "t = 4.3\n", + "Ca = 116.59254989415322\n", + "Cb = 102.91875989297205\n", + "Cc = 780.4886902128749\n", + "\n", + "t = 4.4\n", + "Ca = 110.90866308681325\n", + "Cb = 98.53388313574429\n", + "Cc = 790.5574537774426\n", + "\n", + "t = 4.5\n", + "Ca = 105.5018657613311\n", + "Cb = 94.30268990561369\n", + "Cc = 800.1954443330553\n", + "\n", + "t = 4.6000000000000005\n", + "Ca = 100.35864980546621\n", + "Cb = 90.22339565604196\n", + "Cc = 809.4179545384919\n", + "\n", + "t = 4.7\n", + "Ca = 95.46616562744974\n", + "Cb = 86.29376062222079\n", + "Cc = 818.2400737503295\n", + "\n", + "t = 4.800000000000001\n", + "Ca = 90.81219005311156\n", + "Cb = 82.51116352337937\n", + "Cc = 826.6766464235092\n", + "\n", + "t = 4.9\n", + "Ca = 86.38509578802237\n", + "Cb = 78.87266677861474\n", + "Cc = 834.742237433363\n", + "\n", + "t = 5.0\n", + "Ca = 82.17382236835628\n", + "Cb = 75.37507411484238\n", + "Cc = 842.4511035168015\n", + "\n", + "t = 5.1000000000000005\n", + "Ca = 78.16784852789891\n", + "Cb = 72.01498135846883\n", + "Cc = 849.8171701136324\n", + "\n", + "t = 5.2\n", + "Ca = 74.35716591216384\n", + "Cb = 68.78882112382962\n", + "Cc = 856.8540129640068\n", + "\n", + "t = 5.300000000000001\n", + "Ca = 70.73225407394585\n", + "Cb = 65.69290204050338\n", + "Cc = 863.574843885551\n", + "\n", + "t = 5.4\n", + "Ca = 67.28405668784099\n", + "Cb = 62.723443097575554\n", + "Cc = 869.9925002145836\n", + "\n", + "t = 5.5\n", + "Ca = 64.00395892430873\n", + "Cb = 59.87660362511852\n", + "Cc = 876.119437450573\n", + "\n", + "t = 5.6000000000000005\n", + "Ca = 60.88376592674868\n", + "Cb = 57.14850938098154\n", + "Cc = 881.9677246922699\n", + "\n", + "t = 5.7\n", + "Ca = 57.91568233781968\n", + "Cb = 54.535275163900415\n", + "Cc = 887.5490424982801\n", + "\n", + "t = 5.800000000000001\n", + "Ca = 55.09229282385097\n", + "Cb = 52.03302433145404\n", + "Cc = 892.8746828446951\n", + "\n", + "t = 5.9\n", + "Ca = 52.406543548688234\n", + "Cb = 49.63790556306901\n", + "Cc = 897.9555508882429\n", + "\n", + "t = 6.0\n", + "Ca = 49.85172455068968\n", + "Cb = 47.34610717370428\n", + "Cc = 902.8021682756062\n", + "\n", + "t = 6.1000000000000005\n", + "Ca = 47.42145297884356\n", + "Cb = 45.153869252671775\n", + "Cc = 907.4246777684848\n", + "\n", + "t = 6.2\n", + "Ca = 45.10965714612494\n", + "Cb = 43.05749387393947\n", + "Cc = 911.8328489799358\n", + "\n", + "t = 6.300000000000001\n", + "Ca = 42.91056136025135\n", + "Cb = 41.0533535989235\n", + "Cc = 916.0360850408254\n", + "\n", + "t = 6.4\n", + "Ca = 40.8186714939391\n", + "Cb = 39.13789846993739\n", + "Cc = 920.0434300361237\n", + "\n", + "t = 6.5\n", + "Ca = 38.82876125860957\n", + "Cb = 37.30766167188802\n", + "Cc = 923.8635770695026\n", + "\n", + "t = 6.6000000000000005\n", + "Ca = 36.93585914725235\n", + "Cb = 35.55926402126935\n", + "Cc = 927.5048768314786\n", + "\n", + "t = 6.7\n", + "Ca = 35.1352360138238\n", + "Cb = 33.88941742480918\n", + "Cc = 930.9753465613672\n", + "\n", + "t = 6.800000000000001\n", + "Ca = 33.42239325814989\n", + "Cb = 32.29492743509166\n", + "Cc = 934.2826793067587\n", + "\n", + "t = 6.9\n", + "Ca = 31.793051586815082\n", + "Cb = 30.77269501694738\n", + "Cc = 937.4342533962378\n", + "\n", + "t = 7.0\n", + "Ca = 30.243140321957846\n", + "Cb = 29.31971762622758\n", + "Cc = 940.4371420518148\n", + "\n", + "t = 7.1000000000000005\n", + "Ca = 28.7687872312624\n", + "Cb = 27.93308969162651\n", + "Cc = 943.2981230771113\n", + "\n", + "t = 7.2\n", + "Ca = 27.36630885373836\n", + "Cb = 26.610002580367876\n", + "Cc = 946.023688565894\n", + "\n", + "t = 7.300000000000001\n", + "Ca = 26.032201297118615\n", + "Cb = 25.347744119718328\n", + "Cc = 948.6200545831632\n", + "\n", + "t = 7.4\n", + "Ca = 24.76313148388408\n", + "Cb = 24.143697738336822\n", + "Cc = 951.0931707777793\n", + "\n", + "t = 7.5\n", + "Ca = 23.55592882404473\n", + "Cb = 22.995341284324464\n", + "Cc = 953.4487298916309\n", + "\n", + "t = 7.6000000000000005\n", + "Ca = 22.40757729387255\n", + "Cb = 21.90024557042571\n", + "Cc = 955.6921771357019\n", + "\n", + "t = 7.7\n", + "Ca = 21.315207900796263\n", + "Cb = 20.85607269107687\n", + "Cc = 957.828719408127\n", + "\n", + "t = 7.800000000000001\n", + "Ca = 20.276091515632444\n", + "Cb = 19.860574150836396\n", + "Cc = 959.8633343335313\n", + "\n", + "t = 7.9\n", + "Ca = 19.287632054245364\n", + "Cb = 18.911588839104937\n", + "Cc = 961.8007791066498\n", + "\n", + "t = 8.0\n", + "Ca = 18.347359991600904\n", + "Cb = 18.007040881898817\n", + "Cc = 963.6455991265003\n", + "\n", + "t = 8.1\n", + "Ca = 17.45292619201036\n", + "Cb = 17.144937397729972\n", + "Cc = 965.4021364102597\n", + "\n", + "t = 8.200000000000001\n", + "Ca = 16.602096040149853\n", + "Cb = 16.323366181326104\n", + "Cc = 967.074537778524\n", + "\n", + "t = 8.3\n", + "Ca = 15.792743858192548\n", + "Cb = 15.540493335957056\n", + "Cc = 968.6667628058503\n", + "\n", + "t = 8.4\n", + "Ca = 15.022847595105661\n", + "Cb = 14.79456087248254\n", + "Cc = 970.1825915324117\n", + "\n", + "t = 8.5\n", + "Ca = 14.29048377484426\n", + "Cb = 14.083884290870335\n", + "Cc = 971.6256319342854\n", + "\n", + "t = 8.6\n", + "Ca = 13.593822690820602\n", + "Cb = 13.4068501578242\n", + "Cc = 972.9993271513551\n", + "\n", + "t = 8.700000000000001\n", + "Ca = 12.931123834643097\n", + "Cb = 12.761913692281354\n", + "Cc = 974.3069624730755\n", + "\n", + "t = 8.8\n", + "Ca = 12.300731547704245\n", + "Cb = 12.147596368866868\n", + "Cc = 975.5516720834288\n", + "\n", + "t = 8.9\n", + "Ca = 11.701070884753664\n", + "Cb = 11.562483547905837\n", + "Cc = 976.7364455673404\n", + "\n", + "t = 9.0\n", + "Ca = 11.130643679121922\n", + "Cb = 11.00522213927464\n", + "Cc = 977.8641341816034\n", + "\n", + "t = 9.1\n", + "Ca = 10.588024799764728\n", + "Cb = 10.474518306202938\n", + "Cc = 978.9374568940323\n", + "\n", + "t = 9.200000000000001\n", + "Ca = 10.071858590776198\n", + "Cb = 9.969135214102778\n", + "Cc = 979.959006195121\n", + "\n", + "t = 9.3\n", + "Ca = 9.580855484475858\n", + "Cb = 9.487890828586412\n", + "Cc = 980.9312536869377\n", + "\n", + "t = 9.4\n", + "Ca = 9.11378877960766\n", + "Cb = 9.029655766027712\n", + "Cc = 981.8565554543645\n", + "\n", + "t = 9.5\n", + "Ca = 8.669491576601786\n", + "Cb = 8.593351199311934\n", + "Cc = 982.7371572240862\n", + "\n", + "t = 9.600000000000001\n", + "Ca = 8.246853862242448\n", + "Cb = 8.177946820795134\n", + "Cc = 983.5751993169623\n", + "\n", + "t = 9.700000000000001\n", + "Ca = 7.8448197364581285\n", + "Cb = 7.782458863948309\n", + "Cc = 984.3727213995935\n", + "\n", + "t = 9.8\n", + "Ca = 7.462384774305795\n", + "Cb = 7.405948184684409\n", + "Cc = 985.1316670410098\n", + "\n", + "t = 9.9\n", + "Ca = 7.098593516558387\n", + "Cb = 7.047518402951033\n", + "Cc = 985.8538880804906\n", + "\n", + "t = 10.0\n", + "Ca = 6.752537082626166\n", + "Cb = 6.70631410481151\n", + "Cc = 986.5411488125624\n", + "\n", + "t = 10.100000000000001\n", + "Ca = 6.42335089984814\n", + "Cb = 6.381519104925877\n", + "Cc = 987.195129995226\n", + "\n", + "t = 10.200000000000001\n", + "Ca = 6.110212543480543\n", + "Cb = 6.072354769075895\n", + "Cc = 987.8174326874436\n", + "\n", + "t = 10.3\n", + "Ca = 5.812339681985867\n", + "Cb = 5.7780783961496605\n", + "Cc = 988.4095819218645\n", + "\n", + "t = 10.4\n", + "Ca = 5.528988122489055\n", + "Cb = 5.497981658807289\n", + "Cc = 988.9730302187037\n", + "\n", + "t = 10.5\n", + "Ca = 5.2594499515177136\n", + "Cb = 5.231389101885715\n", + "Cc = 989.5091609465966\n", + "\n", + "t = 10.600000000000001\n", + "Ca = 5.003051766381225\n", + "Cb = 4.977656697464266\n", + "Cc = 990.0192915361545\n", + "\n", + "t = 10.700000000000001\n", + "Ca = 4.75915299277014\n", + "Cb = 4.736170455400293\n", + "Cc = 990.5046765518296\n", + "\n", + "t = 10.8\n", + "Ca = 4.5271442843725955\n", + "Cb = 4.506345088052884\n", + "Cc = 990.9665106275745\n", + "\n", + "t = 10.9\n", + "Ca = 4.306446000509432\n", + "Cb = 4.287622727840092\n", + "Cc = 991.4059312716505\n", + "\n", + "t = 11.0\n", + "Ca = 4.096506757984597\n", + "Cb = 4.079471696218844\n", + "Cc = 991.8240215457965\n", + "\n", + "t = 11.100000000000001\n", + "Ca = 3.8968020535328476\n", + "Cb = 3.8813853226348414\n", + "Cc = 992.2218126238323\n", + "\n", + "t = 11.200000000000001\n", + "Ca = 3.7068329534231212\n", + "Cb = 3.6928808119604257\n", + "Cc = 992.6002862346164\n", + "\n", + "t = 11.3\n", + "Ca = 3.526124846943744\n", + "Cb = 3.5134981589200045\n", + "Cc = 992.9603769941363\n", + "\n", + "t = 11.4\n", + "Ca = 3.354226260655236\n", + "Cb = 3.342799107993752\n", + "Cc = 993.302974631351\n", + "\n", + "t = 11.5\n", + "Ca = 3.1907077304482936\n", + "Cb = 3.1803661572896504\n", + "Cc = 993.6289261122621\n", + "\n", + "t = 11.600000000000001\n", + "Ca = 3.0351607285889393\n", + "Cb = 3.025801604880367\n", + "Cc = 993.9390376665307\n", + "\n", + "t = 11.700000000000001\n", + "Ca = 2.8871966430702285\n", + "Cb = 2.8787266361139707\n", + "Cc = 994.2340767208158\n", + "\n", + "t = 11.8\n", + "Ca = 2.746445806720555\n", + "Cb = 2.7387804504251414\n", + "Cc = 994.5147737428542\n", + "\n", + "t = 11.9\n", + "Ca = 2.612556573642928\n", + "Cb = 2.6056194261955787\n", + "Cc = 994.7818240001615\n", + "\n", + "t = 12.0\n", + "Ca = 2.485194440677835\n", + "Cb = 2.478916322237984\n", + "Cc = 995.0358892370841\n", + "\n", + "t = 12.100000000000001\n", + "Ca = 2.3640412116947904\n", + "Cb = 2.3583595145067258\n", + "Cc = 995.2775992737984\n", + "\n", + "t = 12.200000000000001\n", + "Ca = 2.2487942026246692\n", + "Cb = 2.243652266669471\n", + "Cc = 995.5075535307058\n", + "\n", + "t = 12.3\n", + "Ca = 2.139165485246717\n", + "Cb = 2.1345120332072622\n", + "Cc = 995.7263224815459\n", + "\n", + "t = 12.4\n", + "Ca = 2.0348811678409393\n", + "Cb = 2.030669793745233\n", + "Cc = 995.9344490384137\n", + "\n", + "t = 12.5\n", + "Ca = 1.9356807109086935\n", + "Cb = 1.9318694173520794\n", + "Cc = 996.1324498717391\n", + "\n", + "t = 12.600000000000001\n", + "Ca = 1.8413162762518946\n", + "Cb = 1.8378670555831589\n", + "Cc = 996.3208166681649\n", + "\n", + "t = 12.700000000000001\n", + "Ca = 1.7515521077846148\n", + "Cb = 1.7484305630794088\n", + "Cc = 996.5000173291359\n", + "\n", + "t = 12.8\n", + "Ca = 1.666163942530115\n", + "Cb = 1.6633389445719033\n", + "Cc = 996.6704971128979\n", + "\n", + "t = 12.9\n", + "Ca = 1.5849384503317718\n", + "Cb = 1.5823818271795904\n", + "Cc = 996.8326797224886\n", + "\n", + "t = 13.0\n", + "Ca = 1.507672700878098\n", + "Cb = 1.5053589569253738\n", + "Cc = 996.9869683421965\n", + "\n", + "t = 13.100000000000001\n", + "Ca = 1.4341736567102907\n", + "Cb = 1.4320797184330754\n", + "Cc = 997.1337466248566\n", + "\n", + "t = 13.200000000000001\n", + "Ca = 1.364257690945664\n", + "Cb = 1.362362676804784\n", + "Cc = 997.2733796322495\n", + "\n", + "t = 13.3\n", + "Ca = 1.297750128512063\n", + "Cb = 1.2960351407145665\n", + "Cc = 997.4062147307734\n", + "\n", + "t = 13.4\n", + "Ca = 1.2344848097471\n", + "Cb = 1.2329327457903656\n", + "Cc = 997.5325824444626\n", + "\n", + "t = 13.5\n", + "Ca = 1.174303675271929\n", + "Cb = 1.1728990573910842\n", + "Cc = 997.6527972673371\n", + "\n", + "t = 13.600000000000001\n", + "Ca = 1.1170563711024224\n", + "Cb = 1.115785191920258\n", + "Cc = 997.7671584369774\n", + "\n", + "t = 13.700000000000001\n", + "Ca = 1.0625998730111794\n", + "Cb = 1.0614494558513206\n", + "Cc = 997.8759506711376\n", + "\n", + "t = 13.8\n", + "Ca = 1.0107981292018844\n", + "Cb = 1.0097570016722122\n", + "Cc = 997.979444869126\n", + "\n", + "t = 13.9\n", + "Ca = 0.9615217204032925\n", + "Cb = 0.9605794999889392\n", + "Cc = 998.077898779608\n", + "\n", + "t = 14.0\n", + "Ca = 0.9146475365336321\n", + "Cb = 0.9137948270586422\n", + "Cc = 998.1715576364079\n", + "\n", + "t = 14.100000000000001\n", + "Ca = 0.8700584691276175\n", + "Cb = 0.8692867670527517\n", + "Cc = 998.2606547638198\n", + "\n", + "t = 14.200000000000001\n", + "Ca = 0.8276431187576462\n", + "Cb = 0.8269447283798925\n", + "Cc = 998.3454121528627\n", + "\n", + "t = 14.3\n", + "Ca = 0.787295516718211\n", + "Cb = 0.7866634734263439\n", + "Cc = 998.4260410098557\n", + "\n", + "t = 14.4\n", + "Ca = 0.7489148602781982\n", + "Cb = 0.7483428610990585\n", + "Cc = 998.502742278623\n", + "\n", + "t = 14.5\n", + "Ca = 0.7124052608396361\n", + "Cb = 0.7118876015825145\n", + "Cc = 998.5757071375781\n", + "\n", + "t = 14.600000000000001\n", + "Ca = 0.6776755043737038\n", + "Cb = 0.6772070227460089\n", + "Cc = 998.6451174728805\n", + "\n", + "t = 14.700000000000001\n", + "Ca = 0.6446388235354857\n", + "Cb = 0.6442148476624219\n", + "Cc = 998.7111463288023\n", + "\n", + "t = 14.8\n", + "Ca = 0.6132126808881309\n", + "Cb = 0.612828982723008\n", + "Cc = 998.7739583363891\n", + "\n", + "t = 14.9\n", + "Ca = 0.5833185626948345\n", + "Cb = 0.5829713158553983\n", + "Cc = 998.83371012145\n", + "\n", + "t = 15.0\n", + "Ca = 0.5548817827634613\n", + "Cb = 0.5545675243737715\n", + "Cc = 998.890550692863\n", + "\n", + "t = 15.100000000000001\n", + "Ca = 0.5278312958537426\n", + "Cb = 0.5275468920110733\n", + "Cc = 998.9446218121354\n", + "\n", + "t = 15.200000000000001\n", + "Ca = 0.5020995201808726\n", + "Cb = 0.5018421347032569\n", + "Cc = 998.9960583451161\n", + "\n", + "t = 15.3\n", + "Ca = 0.47762216857205503\n", + "Cb = 0.47738923471481287\n", + "Cc = 999.0449885967134\n", + "\n", + "t = 15.4\n", + "Ca = 0.45433808785416735\n", + "Cb = 0.45412728271336317\n", + "Cc = 999.0915346294328\n", + "\n", + "t = 15.5\n", + "Ca = 0.4321891060712767\n", + "Cb = 0.4319983274188489\n", + "Cc = 999.1358125665101\n", + "\n", + "t = 15.600000000000001\n", + "Ca = 0.41111988715030195\n", + "Cb = 0.4109472324698548\n", + "Cc = 999.1779328803801\n", + "\n", + "t = 15.700000000000001\n", + "Ca = 0.3910777926517247\n", + "Cb = 0.39092154016592007\n", + "Cc = 999.2180006671827\n", + "\n", + "t = 15.8\n", + "Ca = 0.3720127502599531\n", + "Cb = 0.3718713417602999\n", + "Cc = 999.2561159079801\n", + "\n", + "t = 15.9\n", + "Ca = 0.3538771286847804\n", + "Cb = 0.35374915399259427\n", + "Cc = 999.2923737173229\n", + "\n", + "t = 16.0\n", + "Ca = 0.33662561866139734\n", + "Cb = 0.3365098015649689\n", + "Cc = 999.3268645797739\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAItCAYAAADbrGvgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtWUlEQVR4nOzdd3hURffA8e/d9E4qCSEhhNCLSA29CIgoTQELCliwoCj2roC+6vuKFSuigAL6E0WkqoAgJSR0kF4TSKhpm153fn8suxKTQMJussnmfJ5nn2zunb33bAjsYebMjKaUUgghhBBC2BmdrQMQQgghhKgKkuQIIYQQwi5JkiOEEEIIuyRJjhBCCCHskiQ5QgghhLBLkuQIIYQQwi5JkiOEEEIIuyRJjhBCCCHskiQ5QgghhLBLkuQIUQtMnToVTdNITk6ulvutX78eTdNYv359lVx/7ty5aJpGfHx8lVzfGrZu3YqzszMJCQm2DqXGqMyfW0REBBMmTKjymMoyYcIEIiIirum10dHRPPfcc9YNSNiMJDlC/Mvx48d56KGHiIyMxNXVFW9vb3r06MFHH31Ebm6urcO7Jn379kXTNIYOHVrqXHx8PJqmMWPGDBtEVnO9/PLL3HnnnTRq1Mj84X61x7V+sNZl//4Zent706dPH1asWGGTeJ5//nk+/fRTzp07Z5P7C+tytHUAQtQkK1asYPTo0bi4uDBu3DjatGlDQUEBmzZt4tlnn2X//v3MmjXL1mFes+XLl7Njxw46dux4xXa9e/cmNzcXZ2fnaoqsZtm9ezdr1qwhJiYGMP48vvvuuxJtHnjgAbp06cKDDz5oPubp6VmtcVa3e+65hzvuuAMXFxerXnfgwIGMGzcOpRQJCQl8/vnnDB06lFWrVnHjjTda9V5XM3z4cLy9vfnss8+YPn16td5bWJ8kOUJccvLkSe644w4aNWrEn3/+SUhIiPnco48+yrFjx674v0uDwUBBQQGurq7VEW6lhYeHk5mZybRp01i6dOkV2+p0uhr7PqrDnDlzCA8PJzo6GoDIyEgiIyNLtHn44YeJjIzk7rvvLvc6RUVFGAwGu0kWHRwccHBwsPp1mzVrVuLneNttt9GqVSs++uijak9ydDodo0aN4ttvv2XatGlomlat9xfWJcNVQlzyv//9j6ysLL7++usSCY5JVFQUTzzxhPl7TdN47LHHWLBgAa1bt8bFxYXffvsNgBkzZtC9e3f8/f1xc3OjY8eO/PTTT6WuabrGkiVLaNOmDS4uLrRu3dp8nStJSEggKiqKNm3acP78+au29/Ly4sknn2TZsmXs3Lnzim3Lq8mJi4tjyJAh+Pr64uHhQbt27fjoo49KtPnzzz/p1asXHh4e1KtXj+HDh3Pw4MGrxrd9+3ZuvPFGAgICcHNzo3Hjxtx3330l2mRnZ/P0008TFhaGi4sLzZs3Z8aMGSilSrSz5OcKsGTJEvr371+pD7jLh/0+/PBDmjRpgouLCwcOHKCgoIDXXnuNjh074uPjg4eHB7169WLdunXlXuODDz6gUaNGuLm50adPH/bt21fqnocOHWLUqFH4+fnh6upKp06dSiWwVxpeu7y2piJ/bmXV5CilePPNN2nYsCHu7u7069eP/fv3V/jnVpaWLVsSEBDA8ePHr3hvqHj9mMFg4MMPP6R169a4urpSv359HnroIdLS0kq1HThwIAkJCezevdui9yFsT3pyhLhk2bJlREZG0r179wq/5s8//+THH3/kscceIyAgwFyT8dFHHzFs2DDGjh1LQUEBP/zwA6NHj2b58uXcfPPNJa6xadMmFi9ezKRJk/Dy8uLjjz/mtttu49SpU/j7+5d53+PHj9O/f3/8/PxYvXo1AQEBFYr3iSee4IMPPmDq1KlX7c35t9WrV3PLLbcQEhLCE088QXBwMAcPHmT58uXm5G/NmjXcdNNNREZGMnXqVHJzc5k5cyY9evRg586d5dasXLhwgUGDBhEYGMgLL7xAvXr1iI+PZ/HixeY2SimGDRvGunXruP/++2nfvj2///47zz77LElJSXzwwQclrnktP1eApKQkTp06RYcOHSr18zGZM2cOeXl5PPjgg7i4uODn50dGRgazZ8/mzjvvZOLEiWRmZvL1119z4403snXrVtq3b1/iGt9++y2ZmZk8+uij5OXl8dFHH9G/f3/+/vtv6tevD8D+/fvp0aMHoaGhvPDCC3h4ePDjjz8yYsQIfv75Z0aOHAlQapgN4JVXXuHChQvm4bVr/XMDeO2113jzzTcZMmQIQ4YMYefOnQwaNIiCgoJr+vkB6PV60tLSaNKkyTVf498eeugh5s6dy7333svjjz/OyZMn+eSTT9i1axebN2/GycnJ3NY0nLt582auv/56q8UgbEAJIZRer1eAGj58eIVfAyidTqf2799f6lxOTk6J7wsKClSbNm1U//79S13D2dlZHTt2zHxsz549ClAzZ840H3v99dcVoC5evKgOHjyoGjRooDp37qxSU1MrFGufPn1U69atlVJKTZs2TQFqx44dSimlTp48qQD17rvvmtuvW7dOAWrdunVKKaWKiopU48aNVaNGjVRaWlqJaxsMBvPz9u3bq6CgIJWSklLi/eh0OjVu3DjzsTlz5ihAnTx5Uiml1C+//KIAtW3btnLfw5IlSxSg3nzzzRLHR40apTRNK/EzrOjPtSxr1qxRgFq2bNkV23l4eKjx48ebvzf9HL29vdWFCxdKtC0qKlL5+fkljqWlpan69eur++67r9Q13NzcVGJiovl4XFycAtSTTz5pPnbDDTeotm3bqry8PPMxg8Ggunfvrpo2bVpu3P/73/8UoL799lvzsWv9c7tw4YJydnZWN998c4nfg5deekkBJX4+5QHU/fffry5evKguXLigtm/frgYPHlzqd/Lf9zb59++qUkqNHz9eNWrUyPz9xo0bFaAWLFhQ4rW//fZbmceVUsrZ2Vk98sgjV41f1GwyXCUEkJGRARiHdCqjT58+tGrVqtRxNzc38/O0tDT0ej29evUqc5howIABJf7H2q5dO7y9vTlx4kSptvv27aNPnz5ERESwZs0afH19KxUvGHtzfH19mTZtWoVfs2vXLk6ePMmUKVOoV69eiXOmIZ2zZ8+ye/duJkyYgJ+fX4n3M3DgQFauXFnu9U3XXL58OYWFhWW2WblyJQ4ODjz++OMljj/99NMopVi1alWJ45X5uV4uJSUF4Jp+tmCsJwkMDCxxzMHBwVyXYzAYSE1NpaioiE6dOpX5OzFixAhCQ0PN33fp0oWuXbuaf4apqan8+eefjBkzhszMTJKTk0lOTiYlJYUbb7yRo0ePkpSUVOq669at48UXX2Ty5Mncc889gGV/bmvWrKGgoIDJkyeXGNqbMmVKBX5S//j6668JDAwkKCiITp06sXbtWp577jmeeuqpSl2nPIsWLcLHx4eBAweaf1bJycl07NgRT0/PUsOGYPzzr64lG0TVkSRHCMDb2xuAzMzMSr2ucePGZR5fvnw50dHRuLq64ufnR2BgIJ9//jl6vb5U2/Dw8FLHfH19y6wVGDp0KF5eXvz+++/mmE2ysrI4d+6c+XHx4sUyY/Px8WHKlCksXbqUXbt2VeRtmmsj2rRpU24b03oyzZs3L3WuZcuWJCcnk52dXeZr+/Tpw2233ca0adMICAhg+PDhzJkzh/z8/BLXb9CgQalEtGXLliXub1KZn2tZ1L/qfCqqvN+JefPm0a5dO1xdXfH39ycwMJAVK1aU+TvRtGnTUseaNWtmrkc5duwYSileffVVAgMDSzxef/11wDgEeLnExERuv/12evTowfvvv28+bsmfm+m1/443MDCwUkni8OHDWb16NStWrDCvCZWTk4NOZ52PqKNHj6LX6wkKCir188rKyir1swLjn78UHdd+UpMjBMYkp0GDBmUWd17J5T02Jhs3bmTYsGH07t2bzz77jJCQEJycnJgzZw4LFy4s1b682SplfcjedtttzJs3jwULFvDQQw+VODdjxowSvTONGjUqd9E2U23OtGnT+PDDD6/wDquHpmn89NNPxMbGsmzZMn7//Xfuu+8+3nvvPWJjY69panZlfq6XM9XrVDQZ+reyfifmz5/PhAkTGDFiBM8++yxBQUE4ODjw9ttvlyiurSiDwQDAM888U+7so6ioKPPzgoICRo0ahYuLCz/++COOjjXrn/6GDRsyYMAAAIYMGUJAQACPPfYY/fr149ZbbwUoN+EoLi6+6vUNBgNBQUEsWLCgzPP/7nkDSE9Pr3Ctm6i5atZvuhA2dMsttzBr1iy2bNlCt27drvk6P//8M66urvz+++8l1hOZM2eOxTG+++67ODo6motp77rrLvO5cePG0bNnT/P3ZX3Ymph6c6ZOncr48eOvel/TsM++ffvMH0b/1qhRIwAOHz5c6tyhQ4cICAjAw8PjiveJjo4mOjqa//znPyxcuJCxY8fyww8/8MADD9CoUSPWrFlDZmZmid6cQ4cOlbi/pVq0aAEYlxSwlp9++onIyEgWL15c4sPa1Ovyb0ePHi117MiRI+YCYNN0dicnp3L/PC73+OOPs3v3bjZs2GAuXDax5M/N9NqjR4+WmGJ/8eLFa04SwVgk/MEHH/DKK68wcuRINE0z9wylp6eXaFuRFambNGnCmjVr6NGjxxX/XpgkJSVRUFBg7iUUtZcMVwlxyXPPPYeHhwcPPPBAmVOyjx8/Xmq6dFkcHBzQNK3E/zDj4+NZsmSJxTFqmsasWbMYNWoU48ePLzFDKjIykgEDBpgfPXr0uOK1TPU1FVnwrEOHDjRu3JgPP/yw1IeMqWckJCSE9u3bM2/evBJt9u3bxx9//MGQIUPKvX5aWlqpHhbTjCPTkNWQIUMoLi7mk08+KdHugw8+QNM0brrppqu+j4oIDQ0lLCyM7du3W+V68E+v0uXvMS4uji1btpTZfsmSJSVqarZu3UpcXJz5PQYFBdG3b1++/PJLzp49W+r1lw9Vzpkzhy+//JJPP/2ULl26lGpryZ/bgAEDcHJyYubMmSXem6W9g46Ojjz99NMcPHiQX3/9Ffgn0d6wYYO5XXFxcYUW5xwzZgzFxcW88cYbpc4VFRWV+p3esWMHQKVmWoqaSXpyhLikSZMmLFy4kNtvv52WLVuWWPE4JiaGRYsWVWgvnptvvpn333+fwYMHc9ddd3HhwgU+/fRToqKi2Lt3r8Vx6nQ65s+fz4gRIxgzZgwrV66kf//+lb6Oj48PTzzxRIUKkHU6nXkV2vbt23PvvfcSEhLCoUOH2L9/P7///jtg7Gm66aab6NatG/fff795KrKPjw9Tp04t9/rz5s3js88+Y+TIkTRp0oTMzEy++uorvL29zR+yQ4cOpV+/frz88svEx8dz3XXX8ccff/Drr78yZcoUq043Hj58OL/88ovV6jJuueUWFi9ezMiRI7n55ps5efIkX3zxBa1atSIrK6tU+6ioKHr27MkjjzxCfn4+H374If7+/iX2VPr000/p2bMnbdu2ZeLEiURGRnL+/Hm2bNlCYmIie/bsITk5mUmTJtGqVStcXFyYP39+ifuMHDkSDw+Pa/5zCwwM5JlnnuHtt9/mlltuYciQIezatYtVq1ZZPNQzYcIEXnvtNf773/8yYsQIWrduTXR0NC+++CKpqan4+fnxww8/UFRUdNVr9enTh4ceeoi3336b3bt3M2jQIJycnDh69CiLFi3io48+YtSoUeb2q1evJjw8XKaP2wMbzeoSosY6cuSImjhxooqIiFDOzs7Ky8tL9ejRQ82cObPEdF1APfroo2Ve4+uvv1ZNmzZVLi4uqkWLFmrOnDnmaeCXK+8ajRo1KjH99vIp5CY5OTmqT58+ytPTU8XGxl7xPV0+hfxyaWlpysfH56pTyE02bdqkBg4cqLy8vJSHh4dq165dqSnZa9asUT169FBubm7K29tbDR06VB04cKBEm39PB965c6e68847VXh4uHJxcVFBQUHqlltuUdu3by/xuszMTPXkk0+qBg0aKCcnJ9W0aVP17rvvlpi+rFTFf67l2blzpwLUxo0by21T3hTyy3+OJgaDQb311luqUaNGysXFRV1//fVq+fLlpaY6X36N9957T4WFhSkXFxfVq1cvtWfPnlLXPX78uBo3bpwKDg5WTk5OKjQ0VN1yyy3qp59+KnG98h6XT8e+lj83pZQqLi5W06ZNUyEhIcrNzU317dtX7du3r8I/6yv9PZo6dWqJ38Pjx4+rAQMGKBcXF1W/fn310ksvqdWrV191CrnJrFmzVMeOHZWbm5vy8vJSbdu2Vc8995w6c+ZMifcTEhKiXnnllavGLmo+TalrnEIghBB27IYbbqBBgwZlLqZXVeLj42ncuDHvvvsuzzzzTLXdV/xjyZIl3HXXXRw/frzMlc9F7SI1OUIIUYa33nqL//u//6tQYauwH//973957LHHJMGxE1KTI4QQZejatatFWxOI2qm8YnBRO0lPjhBCCCHsktTkCCGEEMIuSU+OEEIIIeySJDlCCCGEsEtSeGwDBoOBM2fO4OXlJRvACSGEEJWglCIzM5MGDRpcdRNXSXJs4MyZM4SFhdk6DCGEEKLWOn36NA0bNrxiG0lybMC0ueDp06fx9va2cTRCCCFE7ZGRkUFYWFiJjXrLI0mODZiGqLy9vSXJEUIIIa5BRco9pPBYCCGEEHZJkhwhhBBC2CVJcoQQQghhlyTJEUIIIYRdkiRHCCGEEHZJkhwhhBBC2CVJcoQQQghhlyTJEUIIIYRdkiRHCCGEEHZJkhwhhBBC2CVJcoQQQghhlyTJEUIIIYRdqhVJzttvv83o0aOJjIxE0zQiIiKu2D4uLo4BAwbg5eWFt7c3gwcPZvfu3WW2PXPmDOPGjSMwMBA3Nzc6derEokWLymybn5/Pa6+9RuPGjXFxcaFJkya8+eabFBYWWvgOhRBCCGFttWIX8pdeegk/Pz86dOhAenr6FdvGxsbSt29fQkNDmT59OgCffPIJvXr1IiYmhrZt25rbpqam0rNnTy5cuMBTTz1Fw4YNWbhwIWPGjOGbb77h3nvvLXHt22+/nV9//ZX77ruPbt26sWXLFl599VWOHTvG3Llzrf22hRBCCGEJVQscP37c/Lx169aqUaNG5bbt3Lmz8vLyUomJieZjiYmJysvLSw0cOLBE22effVYBaunSpeZjRUVFqnPnzsrPz09lZmaaj69YsUIB6qmnnipxjaeeekoBavPmzRV+P3q9XgFKr9dX+DVCCCGEqNxnaK0YroqMjKxQu2PHjrFt2zZGjx5NaGio+XhoaCijR49mzZo1nDt3znx84cKFNGnShKFDh5qPOTg4MHnyZFJTU1m5cmWJtgBTpkwpcU/T9/Pnz6/s2xJCCCFEFaoVSU5Fbdu2DYBu3bqVOhcdHY1Sih07dgBw9uxZkpKSiI6OLrPt5dczPQ8NDSUsLKxE27CwMBo0aFCibXVTShF7IoUft58mr7DYZnEIIYSou5RSGJSBYkMxhYZCCooLyCvKI7co12Yx1YqanIo6c+YMQIleHBPTsaSkpEq3NbVv1apVmfcNDQ0lMTGx3Ljy8/PJz883f5+RkXHF93EtHpi3naz8IjqE1yMqyMvq1xdCiLpGKUWxKqbIUESRoYhCQ2GZX03PTY+yzpm+FhuKKVbGh0EZKDIUGRMDVUyxofif52V8f9X2l9qY7mFqrzAmHwZlMCYiGL+Wddz03HTu38cNyoBCmZ+brmU6XhZ/V3/W376+ev/wLrGrJCcnJwcAFxeXUudcXV1LtKlMW9Pzstqa2l/e9t/efvttpk2bVpG3cE00TaOhrxuHzmVyOjVXkhwhhN0pNBSSW5RLTmEOuUW5JR45hTnkF+cbew6K8ygoLjB/n1+cX+L55cfKa3N5YlLeB7eoOFv+DO0qyXF3dwco0WtikpeXV6JNZdqanpfV1tT+8rb/9uKLL/LUU0+Zv8/IyCg17GWpMD93Y5KTVn6yJYQQ1UUpRW5RLpkFmWQXZpNZmElWQRZZhVn/fL30PLMgk5yiHHKKcsgt/FcCU2RMaooMRbZ+SwDoNB1OOiccdY6lvpZ1rNQ5zREHnQM6TYeD5oCDzgEH7bLvNQd0Oh2OmqPx2GXnyzpW6hpltP/3w/Q+dJoODe2f55qGDuPXso6b2muaVur1V3yNptnsz8uukpwGDRoAJYeZTEzHTENRlWlral9WW1P7soa9TFxcXMrtBbKWcD9jknU6VZIcIYT1KKXILMxEn6cnPT+d9Px09AV69PmXvs9LNz83Hc8oyCC7MBuDMlg9HkfNETdHN9wc3XB3cjc/d3V0xdnBGRcHF1wcXMzPLz92pXPODs64OrjipHMyPhzKTlZMSYKoHewqyencuTMAW7Zs4YEHHihxLjY2Fk3T6NixIwAhISGEhoYSGxtb6jqmY506dSpx7QULFnD69OkSvTCnT5/mzJkzDBs2zOrvpzLCfN2M8aTarsBLCFE7FBuKSctPIyU3xfjISyE5N5mU3BSS8y59zU0mNS8Vfb6eYnXtExocNAc8nT3xdLr0cPbEy8kLD2cPPJ088XL2wsPJAw8nD9wd/0la3BzdcHO6lMxcOu7u6I6Tg5MVfxLC3tlVkhMVFWVesfiNN94w99acOXOGRYsW0b9/f4KDg83t77zzTmbMmMGyZcvM08iLi4uZOXMm9erVY8iQISXaLliwgA8//JD33nvPfPzDDz8EYOzYsdXwDssXZurJkeEqIeq0IkMRybnJnMs+x7mcc5zPPm98nn2O8znG5yl5KZXuZXFzdMPHxYd6LvX++ersY35ez7We+ZyXs5cxkXHywM3RzabDFaJuqxVJznfffUdCQgIAFy9epKCggDfffBOARo0acc8995jbfvTRR/Tr149evXoxefJkAGbOnInBYCiRnAC88MILLFq0iLvuuounnnqK0NBQvv/+e7Zt28bs2bPx8vqngPfmm2/mlltu4f3330ev15tXPP7666+5++676dmzZ1X/GK4oTIarhKgTlFIk5yZzOvN0iUdiViLnss+RnJtcoQRGQ8PX1Rc/Vz8C3ALwd/MnwPXSV7cA/F398XfzNycwLg5VO+QuRFXQlFI1vnS8b9++/PXXX2We69OnD+vXry9xbMuWLbzyyivExcWhaRrdu3fn7bffpkOHDqVen5SUxAsvvMCqVavIysqiVatWPP/889x+++2l2ubl5fHmm28yf/58zp49S2hoKPfeey8vvPACTk4V70LNyMjAx8cHvV6Pt7d3hV93JTkFRbR67XcA9rw+CB836dIVorZSSnE+5zwn9Cc4lXGqRDKTlJV01XVHHDVHgtyDCPYIpr57feNXj/oEuwcT7BFMoHsgfq5+OOpqxf9zhSihMp+htSLJsTdVkeQAdHpzNclZBSyf3JM2oT5Wu64QomoYlIGkrCROpJ/ghP4Ex9OPc0JvfJ5dmF3u63SajmD3YMK8wmjo1dD8tYFHA+p71Mff1R8HnUM1vhMhqk9lPkMljbcjDX3dSc4qIDEtR5IcIWqY3KJcjqUd41DaIQ6nHuZg6kGOph0tt1fGQXMgzCuMCO8IcyJjeoR6hkoBrhAVIEmOHQnzc2f36XSZYSWEjeUV5XEw9SB7L+7lQMoBDqce5mTGyTJrZZx0TjT2aUykTySR9SJp4tOESJ9IGnk3kkRGCAtJkmNHzNPIZYaVENVGKUViZiJ7kvew9+Je9l7cy+HUwxSp0ovX+bn60cKvBc39mtPCtwUt/FoQ7h0utTFCVBH5m2VHZIaVEFXPoAwcTTvKtnPb2HpuK7sv7CYtP61UO39Xf9oFtqNNQBta+BkTmkC3QJlOLUQ1kiTHjoT5mtbKkeEqIaxFKcXx9ONsPbeVbee2sf38dtLz00u0cdI50dK/Je0C2nFd4HW0C2xHiEeIJDRC2JgkOXYkzM84XJWYloNSSv6BFeIa6fP1bEraxIbEDcSejSU1L7XEeTdHNzrU70CX4C50rN+Rln4tcXZwtlG0QojySJJjRxrUc0OnQV6hgYtZ+QR5udo6JCFqBaUUR9KOsDFpIxsSN7Dn4p4SRcKuDq60D2pPl+AudA7uTOuA1jjppChYiJpOkhw74uSgI8THjaT0XE6n5kqSI8QVFBYXEncujj9P/cnGpI2cyz5X4nxT36b0Du1Nz9CetAtsJz01QtRCkuTYmYa+xiQnMS2Hjo18bR2OEDVKYXEhW85u4Y/4P1h3eh0ZBRnmc64OrnQJ6UKfhn3oFdqLEM8QG0YqhLAGSXLsTJifO3EnU2WGlRCXGJSBbee2sfzEctaeWktmQab5nL+rPzeE30CfsD50Ce6Cq6P0fgphTyTJsTPmGVayIKCo446nH2fZ8WWsOLmixFBUgFsAA8IHMChiEB2COsj2B0LYMUly7Ey4vywIKOqu7MJsVpxYweKji9mfst983MvJixsb38iQxkMksRGiDpEkx86YenJOyXCVqEMOphxk0ZFFrDixgpwi4+++o+ZIz9CeDG0ylD5hfXBxcLFxlEKI6iZJjp0J9zcmOWfScykoMuDsqLNxREJUjcLiQn6L/42FBxeyL2Wf+XiEdwSjmo1iaJOh+Ln62TBCIYStSZJjZwI9XXBzciC3sJgz6blEBHjYOiQhrCo9L50fj/zID4d+4GLuRQAcdY4MDB/I6Oaj6VS/kyyEKYQAJMmxO5qmEe7nzuHzmSSk5kiSI+xGvD6e7w58x9LjS8krzgMgyC2IO1veyciokfi7+ds4QiFETSNJjh0K9zcmOadSsoFAW4cjhEWOpR1j1t5Z/Bb/GwoFQEu/ltzT6h4GRwzGyUFWHhZClE2SHDsUfmk38oQUKT4Wtdeh1EPM2juL1Qmrzcf6NOzD+NbjZUhKCFEhkuTYoUb+MsNK1F5H0o4wc9dM1p9ebz42sNFAHmz3IC38WtgsLiFE7SNJjh0y9eRIkiNqk7NZZ/lk9ycsO74MhUKn6bgx4kYebPsgUb5Rtg5PCFELSZJjhxr5G4uNT6XmoJSSbn1Ro6XnpTP779l8f+h7CgwFAAxqNIjHrn+Mxj6NbRydEKI2kyTHDoXWc0OnQU5BMRez8mU3clEjFRoKWXhwIV/u+ZLMQuN+Up2DO/NkhydpG9jWxtEJIeyBJDl2yNlRR4iPcTfy06k5kuSIGif2bCxvx73NCf0JAJr5NuPJjk/So0EP6XkUQliNJDl2qpG/O0npuSSk5NCxkaz6KmqGs1lnmbF9Bn8k/AGAr4svT3R4ghFRI2Q/KSGE1UmSY6fC/dyJOZ4i08hFjVBkKGLe/nl8ufdLcoty0Wk6bm9+O4+2fxQfFx9bhyeEsFOS5Ngp0x5Wp2WGlbCxw6mHeXXzqxxMPQhAh6AOvNT1JZr7NbdxZEIIeydJjp1q5GecYZUgSY6wkYLiAr7c+yXf/P0NRaoIb2dvnu38LMObDJe6GyFEtZAkx07JqsfClvZe3Mtrm1/juP44AAPCB/By9MsEuAXYODIhRF0iSY6dMg1XJWflk51fhIeL/FGLqldkKOKrvV/xxd4vMCgDfq5+vNz1ZQZFDLJ1aEKIOkg++eyUj5sT9dydSM8p5HRaDi2CvW0dkrBzZ7LO8MLGF9h1YRcANzW+iZe6vEQ913q2DUwIUWdJkmPHwv3cSc/Rk5AiSY6oWqtOruKNLW+QWZiJh5MHr0S/wi2Rt9g6LCFEHSdJjh0L93Nnb6KeU1KXI6pITmEOb8W9xa/HfwWgXWA73un1DmFeYTaOTAghJMmxaxGX9rCKT8m2cSTCHiVkJDBl3RSOpR9Dp+mY2HYiD1/3MI46+WdFCFEzyL9GdiwiQJIcUTX+Ov0XL258kczCTALcAni397t0Cu5k67CEEKIESXLsWMSlGVbxyTJcJazDoAx8secLPt/zOQDtA9vzXt/3CHIPsnFkQghRmiQ5dszUk3NGn0teYTGuTrI3kLh2+nw9L258kY1JGwG4o/kdPNf5OZwcnGwcmRBClE2SHDvm7+GMp4sjWflFJKblEBXkZeuQRC2VmJnIpLWTOKk/iYuDC69Gv8rwqOG2DksIIa5IZ+sARNXRNI2IAOOQ1UkZshLX6O+LfzN25VhO6k9S370+3970rSQ4QohaQZIcO9fINMMqWYqPReWtTVjLfb/fR2peKi38WrDw5oW08m9l67CEEKJCZLjKzjWWaeTiGiil+O7Ad8zYPgOFoldoL97t8y4eTh62Dk0IISpMkhw718g0w0qSHFFBBmXgf9v+x4KDCwAY02wML3Z9Uda/EULUOvKvlp1rbForR2pyRAUUGYp4PeZ1lh5fCsDTHZ9mfOvxaJpm48iEEKLyJMmxc6aaHJlGLq6msLiQ5zc+z+qE1ThoDrzZ803Zf0oIUatJ4bGdC/A0TiNXChLTpDdHlC2vKI8n1j3B6oTVOOmceK/Pe5LgCCFqPUly7JxMIxdXk12YzaNrH2Vj0kZcHVyZ2X8mNzS6wdZhCSGExSTJqQNMQ1YJUnws/iWzIJMHVz/I1nNb8XDy4PMBn9MjtIetwxJCCKuQmpw6wDSN/KSslSMuk1OYw6NrH2Xvxb14O3vz5cAvaRPQxtZhCSGE1UiSUwfINHLxb/nF+Tyx7gl2XdiFl5MXXw36Shb5E0LYHRmuqgNkGrm4XGFxIU+vf5rYs7G4O7rz+cDPJcERQtglSXLqgH9PIxd1V5GhiBc2vsBfiX/h4uDCJzd8wnWB19k6LCGEqBKS5NQBl08jP5UqvTl1lUEZeD3mdf5I+ANHnSMf9vuQzsGdbR2WEEJUGUly6gBN08xDVlJ8XHe9u+1dlh5fioPmwIw+M+gZ2tPWIQkhRJWSJKeOiAw0JjknLkqSUxfNPzCf+QfnA/Bmzze5IVzWwRFC2D9JcuqIf3pysmwciahuaxPW8r9t/wPgyY5PykrGQog6Q5KcOiIy0BOQ4aq6Zs/FPTy/8XkUitub3869re+1dUhCCFFtJMmpIyIDZLiqrjmVcYrJayeTX5xP74a9eaHLC7KbuBCiTpEkp46IuJTkpGQXoM8ptHE0oqql5aUxae0k0vLTaOXfind7v4ujTtb+FELULZLk1BGeLo7U93YB4ITU5di1wuJCpqybQkJGAg08GvDpDZ/i7uRu67CEEKLaSZJTh8g08rrhf9v+x84LO/F08uSzAZ8R4BZg65CEEMImJMmpQ6T42P79cvQXfjj8AwDv9HqHJvWa2DgiIYSwHUly6hApPrZv+5L38WbsmwBMaj+JPmF9bByREELYliQ5dYhpuOqE9OTYnZTcFKasm0KBoYC+YX15qN1Dtg5JCCFsTpKcOsQ0XBWfnI3BoGwcjbCWQkMhz/z1DOdzzhPhHcHbPd9Gp8lfbSGEkH8J65CGvm446jRyC4s5l5Fn63CElby//X22n9+Oh5MHH/X/CE9nT1uHJIQQNYIkOXWIk4OOcH/jVGIpPrYPqxNWm/ekeqvnW0T6RNo4IiGEqDkkyaljIqUux26cyTrD6zGvA3Bfm/voH97fxhEJIUTNIklOHWMuPr4oCwLWZkWGIl7Y+AKZBZm0C2jHY9c/ZuuQhBCixrFaktO0aVOOHj0KwIoVK0hISLDWpYUVmYqPZRp57fbFni/YdWEXnk6e/Lf3f3HSOdk6JCGEqHGstpnNQw89hJOT8R/akSNHUlxcjKenJ61bt6Zt27a0adPG/DUgQFZgtZV/hqukJ6e22nZuG7P2zgLgtW6v0dCroY0jEkKImslqSc4zzzxjfp6dnc3BgwfZt28ff//9N/v27eP333/n1KlTaJpGYGAg586ds9atRSU0CTL25CSm5ZJXWIyrk4ONIxKVkZ6XzgsbX0ChGBk1kpsa32TrkIQQosaqkpocJycn2rVrx1133cXbb7/NsmXLOH78OHq9no0bN/LGG29UxW3NsrKyeOutt2jbti1eXl4EBATQvXt35s6di1Il14eJi4tjwIABeHl54e3tzeDBg9m9e3eZ1z1z5gzjxo0jMDAQNzc3OnXqxKJFi6r0vVibv4cz9dydUEqGrGobpRSvxrzKhZwLRHhH8EKXF2wdkhBC1GgWJTmPPPIIubm5V213/PhxevbsiZeXF927d2fixImW3PaKDAYDN910E6+++iqdO3fmvffe45VXXqG4uJh7772XF17454MhNjaWPn36cPLkSaZPn860adM4evQovXr14u+//y5x3dTUVHr27MnixYt55JFH+Oijj/D09GTMmDHMmTOnyt6PtWmaRpNLdTnHpfi4Vll0ZBHrT6/HSefEu33elZ3FhRDiapQFNE1TLVu2VDt37iy3zVdffaW8vLyUTqez5FYVFhMTowA1ZcqUEsfz8/NV48aNlY+Pj/lY586dlZeXl0pMTDQfS0xMVF5eXmrgwIElXv/ss88qQC1dutR8rKioSHXu3Fn5+fmpzMzMCseo1+sVoPR6fSXfnXU8u2i3avT8cvX+H4dtcn9ReYmZiarL/C6qzdw2at6+ebYORwghbKYyn6EWD1cdPnyYbt268c4775QYCkpJSWHkyJE89NBDZGVVX49BRkYGAA0aNChx3NnZmYCAADw8jIW3x44dY9u2bYwePZrQ0FBzu9DQUEaPHs2aNWtK1A0tXLiQJk2aMHToUPMxBwcHJk+eTGpqKitXrqzKt2VVUUHSk1ObKKV4PeZ1copy6BDUgbtb3W3rkIQQolawSk1OQUEBL7/8Mv369ePUqVP89ttvtG3blqVLl5rbeHt7W+NWV9WlSxfq1avH//73PxYtWsSpU6c4dOgQL774Ijt27GDq1KkAbNu2DYBu3bqVukZ0dDRKKXbs2AHA2bNnSUpKIjo6usy2l1+vNvhnuEpqcmqDRUcWEXc2DlcHV97o8YbsSyWEEBVk0eyqtWvX8sADD3Dy5EmUUmzcuJHWrVuTk5NToldn4MCBfP311xYHWxG+vr4sXbqUBx54gDFjxpiPe3l58fPPPzNixAjAWEQMlOjFMTEdS0pKqnTbsuTn55Ofn2/+3tTbZCtNzGvlZFFsUDjoNJvGI8qXlJXEe9vfA+CJDk8Q7h1u44iEEKL2sOi/hP369WPv3r1MmjQJTTN+UGZnZ5sTHC8vLz7//HN+//13GjasvrU8PD09adOmDc888wyLFy9m9uzZREVFcdddd7F69WoAcnJyAHBxcSn1eldX1xJtKtO2LG+//TY+Pj7mR1hYmAXvznJhfu44O+jILzJwJv3qhePCNv49THVXy7tsHZIQQtQqFvd7e3h48Nprr9GhQweUUmiaZn6MGjWK+++/3xpxVtjff/9N9+7dGThwIO+++y4jR47k/vvvZ9OmTQQHBzNx4kSKi4txdzfOTLm8h8UkL8+4Q7epTWXaluXFF19Er9ebH6dPn7bsTVrIQaeZt3c4JnU5NZYMUwkhhGUs/ldz/vz5tG7dmp07d6JpGkopc0/O3Llz6dSpU7nrzlSFDz74gLy8PEaPHl3iuLu7OzfffDMJCQnEx8ebC5PLGmYyHTMNRVWmbVlcXFzw9vYu8bC1JkHGJOf4BUlyaiIZphJCCMtZlOTccsstjB8/npSUFHNyM378eDp37mxOdPbu3UvXrl157bXXrBLw1ZiSjuLi4lLnioqKzF87d+4MwJYtW0q1i42NRdM0OnbsCEBISAihoaHExsaW2RagU6dO1nkD1UTWyqm5lFK8seUNGaYSQggLWZTkXD5t2t/fn8WLFzNnzhxiYmJ46aWX0Ol0aJpGYWEh//nPfywOtiJatWoFGHuRLpeens6vv/6Kr68vUVFRREVFmVcsNhUWg7HIeNGiRfTv35/g4GDz8TvvvJPjx4+zbNky87Hi4mJmzpxJvXr1GDJkSNW+MSszTyO/IDOsaprVCavZfGYzzjpnpveYLsNUQghxjTSl/rXPQSXodMZ/fAcNGsTcuXNLJAUAmzZtYty4ccTHx6NpWpm9K9aWkJBAhw4dSEtLY+zYsfTo0YPU1FS++uor4uPj+fTTT5k0aRIAMTEx9OvXj4YNGzJ58mQAZs6cyfnz59m8eTPXXXed+bopKSl07NiRlJQUnnrqKUJDQ/n+++9Zv349s2fPrlTtUUZGBj4+Puj1epsNXe1L0nPLzE34eTiz89WBNolBlJZdmM2wJcO4kHOBR657hEntJ9k6JCGEqFEq9RlqyaqDbm5uaubMmVdsk5GRoe65555qW/FYKaWOHTumxo0bp0JDQ5Wjo6Py8vJSvXr1Uj///HOptjExMap///7Kw8NDeXp6qkGDBqkdO3aUed3ExER19913K39/f+Xi4qKuv/569cMPP1Q6PluveKyUUtn5harR88tVo+eXq5SsfJvFIUr639b/qTZz26ibfr5J5RXl2TocIYSocSrzGWpRT87Bgwdp2bJlhdr+9NNPjBo16lpvZVdqQk8OQI93/iQpPZefHu5Gpwg/m8UhjA6nHub25bdTrIr5fMDn9AztaeuQhBCixqnMZ6hFg/0VTXAASXBqoMhA4wyrozLDyuYMysCbsW9SrIoZ2GigJDhCCGEFUtFYhzUN8gLgmCQ5Nrfk2BJ2X9yNu6M7z3d+3tbhCCGEXZAkpw5rWt84w+rI+UwbR1K3peWl8f6O9wGY1H4S9T3q2zgiIYSwD5Lk1GHNLiU50pNjWx/t/Ah9vp5mvs0Y23KsrcMRQgi7IUlOHRZ1abjqrD6PjLxCG0dTNx1IOcDio4sBeCX6FRx1Fu2ZK4QQ4jKS5NRhPm5O1Pc2bjoqvTnVTynFjO0zUCiGNB7C9UHX2zokIYSwK5Lk1HHm4uPzkuRUt/Wn17Pt3DZcHFyY0mGKrcMRQgi7I0lOHWfa3kGKj6tXYXEh7+0wbsA5rtU4QjxDbByREELYnyopAMjKymLlypUkJCQQFRXF8OHDzVtAiJqlWX1jT46slVO9fjzyIwkZCfi5+nF/24pvCSKEEKLiLEpyVq9ezbvvvgvAAw88wJgxYzh9+jR9+/YlPj7e3K5379788ccfODk5WRSssD7TNPKj0pNTbfT5ej7f8zkAj13/GB5OHjaOSAgh7JNF3SsrVqxgzZo1rF27lsaNGwPw1ltvcfLkSXMbpRQbNmxg1qxZlkUqqkTTS8NVZ/R5ZMoMq2oxa+8s9Pl6oupFMTJqpK3DEUIIu2VRkrN161YA/Pz86Ny5MwDLli1D0zSUUly+LdZPP/1kya1EFann7kygl3GG1fGL2TaOxv6dyjjFwkMLAXim0zMyZVwIIaqQRUnO6dOn0TTN3Itz7tw5zpw5A8D06dM5duwY3t7eKKU4cOCA5dGKKtFMVj6uNh/u/JAiQxE9QnvQI7SHrcMRQgi7ZlGSk5ycDECDBg0AOHTokPncrbfeSmRkJNHR0QCkp6dbcitRhWQPq+qx+8JuViesRqfpeKbjM7YORwgh7J5FSY6maQCkpqYCcPDgQfPxqKgoANzc3ABwdXW15FaiCsk08urxya5PABgRNYIo3ygbRyOEEPbPoiQnJCQEpRSxsbG88847fPKJ8R/xxo0b4+zsDPzT2xMQEGBhqKKqmKeRy4KAVSbubBxx5+Jw0jnxcLuHbR2OEELUCRYlOd27dweguLiYl19+mUOHDqFpGv369QPAYDCwf//+EnU7ouYxzbBKSs8lK7/IxtHYH6WUuRdnVLNRsvCfEEJUE4uSnCeffNK89o1pNpWDgwOPPvooAH/99Ze5Fqdnz56WRSqqjK/HPzOsZL0c69uUtIndF3fj4uDCxLYTbR2OEELUGRYlOR06dGDFihXccMMNtGjRgltuuYX169dz3XXXAZCQkMDNN9/MkCFDuOWWW6wSsKgaLYKNQ1aHz0mSY01KKWbumgnAnS3uJNA90MYRCSFE3WHxIh0DBgxgwIABZZ6bMGECEyZMsPQWoho0r+/FxqPJHJIkx6r+PPUnB1MP4u7ozr1t7rV1OEIIUadYdUOp/Px84uPjZU2cWqjZpZ4cmWFlPcWGYj7ZbazFubvV3fi5+tk4IiGEqFusstxqbGwsU6dOZf369RQWFqJpGkVFRbz55pucOHECR0dHPvvsMxwdZXXXmkqGq6zv9/jfOZZ+DC9nL8a3Hm/rcIQQos6xOOuYO3cuDz74IMXFxSW2cQDw8PBg7ty5aJrGTTfdxMiRsk9PTdU0yAtNg5TsApKz8gnwdLF1SLVakaGIz/Z8BsCE1hPwdva2cURCCFH3WDRctX//fh566CGKiozTjk2LA5qMGTPGfGzlypWW3EpUMTdnBxr5uQPSm2MNy08sJyEjAV8XX8a2HGvrcIQQok6yKMl57733zMNTYWFhhIaGljgfGhpKZGQkANu3b7fkVqIaNL80ZCXFx5YpNhQz++/ZANzb5l48nDxsHJEQQtRNFiU569atA8DHx4edO3fStWvXUm2ioqJQShEfH2/JrUQ1aH5p5eMjkuRYZM2pNSRkJODt7M2Y5mNsHY4QQtRZFiU5Z8+eRdM0unXrhp9f2TNHTMXG2dnZltxKVIPmwca6kUMyw+qaKaXMvThjW46VXhwhhLAhi5IcFxdjcWpOTk65bY4cOQKAp6enJbcS1aB5sPHP6Oj5TAwGdZXWoiybz2zmUOoh3BzduKvFXbYORwgh6jSLkpzIyEiUUmzZsoWjR4+WOr9gwQKOHj2Kpmk0bdrUkluJahDh74Gzo46cgmIS03JtHU6t9NXerwAY3Ww09Vzr2TYYIYSo4yxKcgYOHAhAYWEh0dHRxMTEmM8NGDCgxGrHprai5nJ00BEVaOzNOXQuw8bR1D47z+9k54WdOOocGddqnK3DEUKIOs+iJOeJJ57Ay8tYrJqWlsa5c+cAY13CunXrKC4uBoxDVZMmTbIwVFEdmsvKx9fMVIszvMlw6nvUt3E0QgghLEpyQkND+e6778y1OWBcK+fy9XKcnZ2ZN28eDRo0sORWoprINPJrcyj1EBuTNqLTdNzX5j5bhyOEEAIr7F01bNgwtm7dyq233oqHhwdKKZRSuLu7M3LkSOLi4hgxYoQVQhXVwbS9w8GzMlxVGV///TUANza6kXDvcBtHI4QQAqy0d1WbNm346aefUEqRnJwMgL+/PzqdVff/FNWgZYhxGvnJ5GzyCotxdXKwcUQ1X0JGAn8k/AHA/W3vt3E0QgghTKyahWiaRmBgIIGBgZLg1FJBXi74eThjUFKXU1Fz9s3BoAz0btib5n7NbR2OEEKISyrVk/Ptt99adLNx42TGSU2naRotQ7zYfCyFg2czaNewnq1DqtFS81JZdnwZAPe3kV4cIYSoSSqV5EyYMKHUJpyVIUlO7dAy2PtSkiM9OVfz4+EfKTAU0DagLdcHXW/rcIQQQlzmmmpylKr4ariapqGUsig5EtXLVJdzQIqPr6iguID/O/x/ANzd8m75HRdCiBqm0oUzlUlwrqW9sL0WIf/MsJI/v/L9Hv87ybnJBLkFMTBCFrsUQoiaplI9OaZdx4V9iwryxFGnkZlXRFJ6Lg193W0dUo2jlOK7A98BcGfLO3HSOdk4IiGEEP9WqSSnT58+VRWHqEFcHB2ICvLk0LlMDp7NlCSnDDvO7+Bg6kFcHFwY1XSUrcMRQghRBpnnLcpkqsuRRQHLNv/gfACGNhkqG3EKIUQNZdFigKdOnapU+/BwWQm2tmgZ4sUvu2SjzrKczjzNn6f+BIwFx0IIIWomi5KciIiICs8o0TSNoqIiS24nqtE/PTkyjfzfvj/0PQpFjwY9aFKvia3DEUIIUQ6rbOsgM3DsT4tgY5ITn5JNTkER7s5W+VWp9bIKslh8dDEAd7eSXhwhhKjJLK7JKS/BMe1GLmuH1E6BXi4EeLqglOxIfrklx5aQXZhNY5/GdG/Q3dbhCCGEuAKL/nv++uuvl3n8/PnzbNmyhT179qBpGrfddhtt2rSx5FbCBlo18GbDkYscOJNBh3BfW4djc8WGYhYcXAAYa3F0mtTtCyFETVYlSY7JjBkzeO6559iwYQMff/yxJbcSNtD6UpKz/4wUHwPEnIkhMSsRL2cvbom8xdbhCCGEuIoq/a/oM888g5+fH8nJybz22mtVeStRBVo3MNbl7D+jt3EkNcOPR34EYHiT4bg7ydpBQghR01VpkmMwGFBKoZRixYoVVXkrUQVaN/ABjDU5hcUGG0djW+eyz7EhcQMAo5uPtnE0QgghKsKi4aoNGzaUeby4uJi0tDTmzp1LWloagPmrqD0a+bnj6eJIVn4Rxy9mmWdc1UU/H/0ZgzLQObgzkT6Rtg5HCCFEBViU5PTt27dCs6c0TaNx48aW3ErYgE6n0SrEm63xqexLyqizSU6RoYjFR4zTxkc3k14cIYSoLawyXGUakvr3AzAnQQ8//LA1biWqWSupy+GvxL+4kHsBP1c/bgi/wdbhCCGEqCCLV3i70kKASinc3d155plnePzxxy29lbCBf4qP6+4Mq0WHFwEwImoEzg7ONo5GCCFERVmU5MyZM6fcc87OzgQHB9O5c2c8PT0tuY2woTahxuLjg2cyMBgUOl3dWtzxdOZpNp/ZDMCoZrLbuBBC1CYWJTnjx4+3VhyihooK8sTZUUdmfhGnUnOICPCwdUjV6qcjPwHQo0EPwrzCbByNEEKIypAlW8UVOTnoaF7fC6h7Q1aFxYUsObYEkIJjIYSojSTJEVfVJrRuFh+vPbWW1LxUgtyC6B3W29bhCCGEqCSLkpwZM2bg5+eHn58fCxcuLHX++++/N59/7733LLmVsKFWlxYF3FfHenJMKxzf2uxWnHRONo5GCCFEZVmU5Cxfvpz09HR0Oh1jxowpdX7MmDE4OjqSnp7OsmXLLLmVsCHTDKsDZ/RXnE1nT07oT7Dt3DZ0mo7bmt5m63CEEEJcA4uSnCNHjqBpGp06dcLRsXQNs4ODAx07djS3FbVTqxBvHHQayVkFnMvIs3U41WLJ0SUA9A7tTbBHsG2DEUIIcU0sSnJSUlIA4zYO5SkqKirRVtQ+rk4ONA0yLgOwN9H+63KKDEUsO2HseRzRdIRtgxFCCHHNLEpyPDw8UEqxZ88ecnNzS53Pyclh9+7d5rai9mp7ab2cfUn2n+TEnIkhOTcZXxdfeodKwbEQQtRWFiU5zZo1A4y9NA8//DA5OTnmczk5OTz88MOkpKSgaRpNmza1LFJhU+0aGpOcutCTY5o2fnPkzTg5SMGxEELUVhYtBnjjjTeydetWAObPn8/KlStp164dAHv37iU1NdXcdvDgwZbcSthY24b1APg7yVh8XJGNWWuj9Lx01p9eDxi3cRBCCFF7WdST8+ijj+Lr62v+PiUlhfXr17N+/foSNTg+Pj5MmjTJklsJG2sR7IWjTiM1u4Ck9NJDk/Zi5cmVFBoKaeHXguZ+zW0djhBCCAtYlOQEBQUxf/58XF1dS/3vXtM0lFK4uroyf/586tevb3GwwnZcnRxoHmxc+die63J+Pf4rIL04QghhDyxe8fimm25i69atjBo1ylyIrJTCw8ODUaNGsXXrVoYMGWKNWIWNmYqP7bUu50jaEQ6kHMBR58iQxvI7K4QQtZ1FNTkmrVu35scff8RgMJiHqfz9/dHpZNcIe9K2oQ8/bDvN33bak/PrMWMvTt+GffF19b1KayFEXVVYWHjFpVNExel0OpycnKqsztMqSY5JYWEh2dnZ5OTkEBgYaM1LixqgXWg9wNiTY2/Fx4WGQpafWA7A8KjhNo5GCFETZWRkkJycTH5+vq1DsSsODg64u7sTFBSEs7OzVa9tlSQnNjaWqVOnsn79egoLC9E0jaKiIt58801OnDiBo6Mjn332WZmrIleV1NRU3nrrLZYsWUJiYiJeXl60adOG6dOn06tXL3O7uLg4Xn75ZeLi4tA0je7du/POO+/Qvn37Utc8c+YML7zwAqtWrSIrK4vWrVvz/PPPM3p03dihulmwJ84OOvS5hSSm5RLm527rkKxmU+ImUvNS8XP1o0doD1uHI4SoYTIyMkhKSsLT05OAgIAq7X2oK5RSFBcXk5ubi16vJz4+noYNG+Lubr3PFouzjrlz5/Lggw9SXFxcal8jDw8P5s6di6Zp3HTTTYwcOdLS21VIQkICffv2JSsri/vvv59mzZqh1+vZu3cvSUlJ5naxsbH07duX0NBQpk+fDsAnn3xCr169iImJoW3btua2qamp9OzZkwsXLvDUU0/RsGFDFi5cyJgxY/jmm2+49957q+W92ZKLowMtQrzYm6hnb6LerpIcU8Hx0MihshmnEKKU5ORkPD09adiwoSQ3Vubp6Ymfnx8JCQkkJycTHh5uvYsrC+zbt085OzsrTdOUTqdTOp3O/FwppRITE83HH3jgAUtuVSk9e/ZUDRs2VGfOnLliu86dOysvLy+VmJhoPpaYmKi8vLzUwIEDS7R99tlnFaCWLl1qPlZUVKQ6d+6s/Pz8VGZmZoXj0+v1ClB6vb7Cr6kpXly8VzV6frl6a8UBW4diNSm5Kar9vPaqzdw26kjqEVuHI4SoYQoKCtSBAwdq5b/ZtUlaWpo6cOCAKiwsvGK7ynyGWlQZ/N5775mHp8LCwggNDS1xPjQ0lMjISAC2b99uya0qbMOGDWzatInnnnuOkJAQCgsLS6zEbHLs2DG2bdvG6NGjS8QdGhrK6NGjWbNmDefOnTMfX7hwIU2aNGHo0KHmYw4ODkyePJnU1FRWrlxZtW+shrju0srHexLTbRuIFa08sZIiVURr/9Y09ZWVuYUQJZmKjJ2cpJe3Krm4uAD/7HlpDRYlOevWrQOMi/3t3LmTrl27lmoTFRWFUor4+HhLblVhpmQjPDycoUOH4ubmhoeHB82aNWP+/Pnmdtu2bQOgW7dupa4RHR2NUoodO3YAcPbsWZKSkoiOji6z7eXXs3ftw4yzjv5O1FNsUFdpXTuYCo6HNRlm40iEEDWZDFNVrar4+VqU5Jw9exZN0+jWrRt+fn5ltjEVG2dnZ1tyqwo7fPgwABMnTiQ1NZV58+bxzTff4OzszD333MOcOXMAYxExUKr36fJjpvqdyrQtS35+PhkZGSUetVVUkCfuzg5kFxRz7EKWrcOxWLw+nv0p+3HQHBjcWLYeEUIIe2JRkmPqWiprOMjkyJEjgLGwqDpkZmYC4OXlxbp16xg7diz33nsvGzdupF69erz00ksYDAZzzKb3cDlXV1fgn/dVmbZlefvtt/Hx8TE/wsLCLHiHtuWg08yLAu45nW7bYKxg1clVAEQ3iMbPtexEXQghRO1kUZITGRmJUootW7Zw9OjRUucXLFjA0aNHq3UXcjc3NwDuvPPOEvPtfX19GTZsGOfOnePw4cPmKWplrXeQl5cHYG5TmbZlefHFF9Hr9ebH6dOnr+Wt1Rjtw+sBsKuWJzlKKVaeNA5v3tz4ZhtHI4QQwtosSnIGDhwIGBcBjI6OJiYmxnxuwIABTJgwoVTbqtawYUMAgoODS50LCQkBIC0tjQYNGgBlDzOZjpmGoirTtiwuLi54e3uXeNRm7S/tSF7be3IOph4kPiMeFwcX+of3t3U4QghRa23duhVN09A0zbwkS01gUZLzxBNP4OVl3LQxLS3NPBtJKcW6devMFemenp7Vtgt5ly5dAEhMTCx1znQsKCiIzp07A7Bly5ZS7WJjY9E0jY4dOwLG5Cg0NJTY2Ngy2wJ06tTJOm+gFjD15Bw+n0luQe1d2nzlCWMvTt+wvng4edg4GiGEqL2+++478/MFCxbYMJKSLEpyQkND+e6770rUqpgyORNnZ2fmzZtn7g2paiNGjMDLy4v58+eTlfVPYezZs2dZsmQJzZo1IyoqiqioKDp16sSiRYvMhcVgLDJetGgR/fv3L9EbdOedd3L8+HGWLVtmPlZcXMzMmTOpV69endqENNjblSAvF4oNin1nauc+VsWGYnM9zk2Nb7JxNEIIUXsVFhbyww8/AMZRlCNHjhAXF2fjqIws3kFz2LBhbN26lVtvvbXELuTu7u6MHDmSuLg4RowYYYVQK8bX15cZM2aYp3y///77vPPOO0RHR1NQUMDMmTPNbT/66CPy8/Pp1asXH374IR9++CG9evXCYDDw3nvvlbjuCy+8QKNGjbjrrrt4/fXXmTVrFgMGDGDbtm3MmDHD3KNVF2iaRvuwekDtHbLaeWEnF3Iv4OXkRa/QXld/gRBCiDL99ttvJCcn06NHD/OozeU9OzZl8RKFlzEYDOrChQvqwoULqri42JqXrrSff/5Zde3aVbm7uytPT081cOBAtWnTplLtYmJiVP/+/ZWHh4fy9PRUgwYNUjt27CjzmomJieruu+9W/v7+ysXFRV1//fXqhx9+qHRstXnFY5NP/jyqGj2/XE1aUPbPqqabGjNVtZnbRr22+TVbhyKEqOFyc3PVgQMHVG5urq1DqZHGjBmjAPX555+rEydOKEAFBASogoKCSl2noj/nynyGakop+1jRrRbJyMjAx8cHvV5fa4uQY44lc9fsOBr6urHp+dpVtFtYXEjfH/uSUZDB7EGz6RpSehFLIYQwycvL4+TJkzRu3Ni8bIgw0uv1BAcHYzAYOHv2LH5+fvTo0YOYmBiWLl1aYpeAq6noz7kyn6GV2qDz22+/rUzzUsaNG2fR60XN0bahD5oGiWm5JGflE+BZeg2hmmrzmc1kFGQQ6BZIp/p1p2BcCGF9SilyC2vXBAw3JwerrS78008/kZeXx/Dhw82LAt99993ExMTw3XffVSrJqQqVSnImTJhg0Q9Gkhz74eXqRFSgJ0cvZLHrVDoDW9W3dUgVZppVdWPEjTjoHGwcjRCiNsstLKbVa7/bOoxKOTD9RtydK/XxXy5T7c3dd99tPjZmzBieeOIJli1bhl6vx8fHxyr3uhbXVHisLhUXV+Rhai/sT4dw4z5WO0+l2TiSisspzGHdaeOeazdHygKAQghxrU6dOsWGDRuoV69eiR4bf39/hgwZQl5eHosWLbJhhJXsyYHKJyyS4NivDo3q8X/bT7MzofYkOetOryOvOI9wr3Ba+7e2dThCiFrOzcmBA9NvtHUYleLmZJ0e7AULFqCUYtSoUaW2Pbr77rv59ddfmT9/Pg888IBV7nctKpXkmHYdFwL+6cnZm6inqNiAo4PFKxJUOdM2DkMih8iOwkIIi2maZrWhn9rGNFS1fv16evbsWeJcQUEBABs2bCAhIYFGjRpVe3xQySSnT58+VRWHqIWaBHri7epIRl4Rh85l0ibUduOuFaHP1xOTZNx65KYIWQBQCCGu1Y4dOzh48CAAx44d49ixY2W2U0qxYMECXnrppeoMz8xq//XOz89n/fr1zJs3j3nz5rFu3boyN7QU9kOn02h/qTdnRy0Yslp/ej1FqoioelFE1ou0dThCCFFrzZ8/H4Bnnnmm3Jrc9evXl2hrC1ZJct59912Cg4O54YYbuO+++7jvvvsYMGAA9evX57///a81biFqqI61qPh4dcJqAAY1GmTjSIQQovYqLi7m+++/B4xbHpWnV69ehIaGcvDgQXbs2FFd4ZVgcZIzadIkXnjhBfR6faksLiMjg5deeomHHnrIGrGKGqhDo3pAzU9ysgqyiDljHKoa2GigjaMRQoja648//uD8+fM0a9aMDh06lNtOp9Nx++23A7bb5sGiJOfPP//kiy++ACiziFPTNJRSzJ49m7Vr11pyK1FDtQ+rh6bB6dRcLmTm2Tqccv2V+BeFhkIa+zSmSb0mtg5HCCFqLVPCcqVeHBNTm++//56ioqIqjassFpWEf/nll+bn7u7ujB07ltatjdNy9+/fz4IFC8jJyQFg1qxZ3HDDDZbcTtRAXq5ONAvy4vD5THYmpDO4TfDVX2QDpqGqgY0GyqwqIYSwwMKFC1m4cGGF2nbq1MmmS8lYlOTExsYC4ObmxpYtW2jTpk2J85MnT6ZLly7k5eWxZcsWS24larAOjXw5fD6TXafSamSSk1OYw6akTYDU4wghRF1i0XDV+fPn0TSN6OjoUgkOQOvWrYmOjkYpxcWLFy25lajBOoTXA2ruDKsNSRvIL84n3CucZr7NbB2OEEKIamJRkuPs7AxAWlr5H27p6ekAODk5WXIrUYN1bHRpUcAkPflFNW+jutXxMlQlhBB1kUVJTkREBEopdu/ezaefflrq/GeffcauXbvQNM1mqx2Kqtc4wAN/D2cKigzsS9LbOpwScoty2Zi0EYCBETKrSggh6hKLkpzLC4kff/xxIiIiGDx4MIMHDyYiIoLJkyebzw8cKB8w9krTNDpFGHtztsXXrCGrzUmbyS3KJdQzlFZ+rWwdjhBCiGpkUZLzxBNP4O7uDhiXbj516hSrV69m9erVnDp1ylxR7ebmxuOPP255tKLG6hzhB8C2k6k2jqSkPxL+AGSoSggh6iKLh6vmzp1rrre5/EPE9NzJyYlvvvmGiIgIS24larhOl5Kc7QlpGAw1Y+f5/OJ8/jr9FwADGg2wcTRCCCGqm8UrHo8aNYrY2FhGjBiBu7u7ebVjd3d3RowYwZYtWxgzZow1YhU1WOsG3rg5OaDPLeTYxSxbhwNATFIMOUU51HevT9uAtrYORwghRDWzyv7w7du3Z/HixRgMBlJSUgDw9/dHp7Pa/p+ihnNy0HF9eD1ijqewLT6VZvW9bB1SiQUAdZr8LgohRF1j1X/5dTodgYGBBAYGSoJTB5mHrGpA8XFhcSHrT68HZK8qIYSoq6zSkwNQVFRESkoK+fn55bYJDw+31u1EDdT50gyrrTWg+DjuXByZhZkEuAXQPqi9rcMRQghhAxYnOX/99RfTpk0jJiaGwsLCcttpmmaTzblE9bk+3BedBknpuZxJz6VBPTebxbLu1DoA+oX1k6EqIYSooyxKclavXs3NN99McXGxTTfgEjWDp4sjrRv48HeSnu0JaQyzUZJjUAbzUFW/sH42iUEIIYTtWfRf3Ndff116Z0QJncxDVik2i+FgykEu5F7A3dGdriFdbRaHEELYM03TSj2cnJxo0KABt912GzExMbYO0bKenD179pjXw+natSs9e/bE09PTKoGJ2qlrYz/mbI4n7oTt6nL+PP0nAD1Ce+Ds4GyzOIQQoi4YP368+XlmZiZ79uxh8eLF/PLLL8yfP5+77rrLZrFZlOR4eHiQl5fHddddR0xMjKwoK+jS2B+AoxeySMnKx9/TpdpjWHf6n3ocIYQQVWvu3LklvjcYDLz00kv897//5fHHH2f06NE226TbouGqQYMGoZTC1dVVEhwBgJ+HM80vrZFji1lWiZmJHE07ioPmQO+Gvav9/kIIUdfpdDqmT5+Oo6MjKSkp7N+/33axWPLit956C39/f+Li4vjggw+uOLtK1B1dI43r5cTZIMkx9eJ0qN8BHxefar+/EEIIcHZ2xsfH+G+wLWt3LRquCg8PZ926dXTt2pVnnnmG6dOnExkZaX5jl9M0jbVr11pyO1FLdG3sz7dbEog9Uf3FxzJUJYQQtnfy5ElSUlJwcnIiKirKZnFYlOSkpqYyduxY8vLyUEqh1+vZtWtXqaErpZQMZ9UhXRobe3IOncskLbsAX4/qKf7V5+vZeX4nAH3D+lbLPYUQdZxSUJhj6ygqx8kdqugzOSsri927d/Pkk08C8Mgjj1CvXr0quVdFWJTkPP/88/z999/mqWNCAAR6uRAV5MmxC1lsjU/lxtbB1XLfDYkbKFbFRNWLIswrrFruKYSo4wpz4K0Gto6icl46A84eVrtcWZ//Xl5ezJw5k0cffdRq97kWFiU5S5cuRdM080KAvr6+eHp6yr5Vgq6N/Th2IYu4E9WX5MhQlRBCVL/Lp5Dn5+eTkJBAXFwc06dPp0mTJtx00002i82iJCcnx9hFFxwczMaNG2nSpIlVghK1X9dIfxbEnSKumhYFLCguYHPSZgD6h/evlnsKIQRO7saekdrEyd2ql/v3FHKAXbt20adPH4YNG8a+ffto3ry5Ve9ZURZ1uXTo0AGAtm3bSoIjSoi+VJdz4GwG+pyqn3UXdzaOnKIcgtyCaOXfqsrvJ4QQgLG2xdmjdj2qobzk+uuv56GHHqKoqIjPP/+8yu9XHou3dQCIi4vjxIkTVglI2Icgb1ciAz1QimrpzTENVfUN6ysbcgohRA3QuHFjAI4ePWqzGCwarkpMTGTw4MGsWrWKjh07cscdd9CqVasyp5ADjBs3zpLbiVqmexN/TlzMJuZ4CoOqsC6nxIac4VKPI4QQNYGp88OW2z1ZlORMmDDBXFWt1+uZNWvWFdtLklO3dG8SwPzYU8QcT67S+xxIOcDF3Iu4O7rTJbhLld5LCCHE1e3atcucEwwZMsRmcViU5JiUtS7O5edknZy6qVukcR+rI+ezuJCZR5CXa5XcxzRUJRtyCiFE9ZswYYL5eUFBAQkJCcTGxmIwGBg6dCj33HOPzWKzOMm5PKG5lvPCfvl6ONMqxJsDZzPYcjyF4e1Dq+Q+GxM3ArIAoBBC2MK8efPMz3U6HfXq1aN3797cc889TJgwwabLyliU5Kxbt85acQg71SPKnwNnM4g5VjVJzoWcCxxMPYiGRo8GPax+fSGEEGWrDZ0YFiU5ffr0sVYcwk51bxLAVxtPEnOiaupyNiVtAqBNQBv83fyr5B5CCCFqJ5lrK6pU58Z+OOo0TqfmcjrV+vu7mIaqeoX2svq1hRBC1G6S5Igq5eniyHVh9QCsPsuqsLiQLWe3ANC7YW+rXlsIIUTtJ0mOqHI9mhiHkTYfs+6igDsv7CS7MBt/V39a+re06rWFEELUfpLkiCrXrUkAYOzJMRisV6i2IXEDAD1De8oqx0IIIUqRTwZR5To0qoe7swPJWQUcPJdhtetuTLpUj9NQ6nGEEEKUJkmOqHIujg5EX1oYcONR69TlnM48zUn9SRw0B7o36G6VawohhLAvlUpyNmzYwIYNGzh48GBVxSPsVK+mxiGrTVZKckyzqq4Puh4vZy+rXFMIIYR9qVSS07dvX/r168fUqVONL9bpcHBw4Pbbb6+K2IQd6dU0EICt8ankFhRbfL0NScZ6HJlVJYQQojzXNFz171UOa8Oqh8K2mgR60MDHlYIiA1vjUy26Vk5hDtvObgNkfRwhhBDlq1SSY9pkMykpqUqCEfZL0zRzb87GIxctuta2c9soMBTQwKMBTeo1sUZ4Qggh7FCltnXw8fFBr9cTGxtLw4YNzcdXrVpFZGTkFV+raRrHjx+/tiiFXejVLID/237a4uJj09TxXg17ye72QgghylWpJKd9+/b89ddfAJw5cwYwDlVlZ2eTnZ19xdfKh5Ho0SQATYPD5zM5n5FHfW/XSl9DKWWeOi71OEIIIa6kUsNVU6ZMAaQGR1wbXw9n2oX6ALDhGoesjqUf42z2WVwcXOgc3Nma4QkhhLAzlerJGTZsGMuWLePbb7/lwoULrF+/Hk3T8Pf3p3Xr1lUVo7AjvZsFsidRz19HLjK6U1ilX2/qxekc3Bk3RzdrhyeEEKKSsrOz+fLLL1m2bBkHDhwgLS0NDw8PWrRowcCBA3nggQcIDw+3SWyVSnIAhgwZwpAhQwDjFHIwTi3/8ccfrRuZsEt9mwcy889jbDyaTFGxAUeHyk3wM62PI0NVQghhezExMdx2222cO3cOd3d3oqOjqV+/Pnq9nm3bthEbG8v//vc/li9fzoABA6o9vkonOZcbN24cmqbRpUsXa8Uj7Fz7MF/quTuRnlPI7tPpdIrwq/Brswqy2H1hNwA9G/SsogiFEEJUxO7du7nhhhvIy8vj+eef59VXX8XDw8N83mAwsGTJEp577jkSExNtEqNFSc7cuXOtFIaoKxx0xqnky/acYf3hi5VKcrad20aRKiLMK4ww78oPdQkhhLAOpRT33HMPeXl5TJ06lddff71UG51Ox6233soNN9zA6dOnbRClhUnO5fLz89myZQsJCQkAhIeH0717d1xcXKx1C2En+jU3JjnrDl/gmRubV/h1m89sBpC9qoQQwsZ+++039u3bR8OGDXn55Zev2NbHxwcfH59qiqwkqyQ57777Lm+99RYZGSV3mPby8uLFF1/k+eeft8ZthJ3o3cy4KOD+MxlcyMgjqIJTyWPOxADQo0GPKotNCCHE1a1YsQKA0aNH4+hotf4Sq7M4skmTJvHll1+WOa08IyODl156iRMnTvDll19aeithJwI8XWjX0Ie9iXrWH7nImArMsjqdcZrTmadx1BzpEiI1YEKImkEpRW5Rrq3DqBQ3RzeL167bvXs3AB06dLBCRFXHoiTnzz//5IsvvkDTNDRNK5XomI7Nnj2bMWPGcMMNN1gUrLAffZsHGZOcwxcqlOSYhqraB7XHw8njKq2FEKJ65Bbl0nVhV1uHUSlxd8Xh7uRu0TVSUlIACAwMtEZIVcaiJOfy3hl3d3fGjh1rXi9n//79LFiwgJycHABmzZolSY4w69s8kI/XHmXj0WQKiw04XWUquSnJ6REqQ1VCCCEqxqIkJzY2FgA3Nze2bNlCmzZtSpyfPHkyXbp0IS8vjy1btlhyK2FnrmtYDz8PZ1KzC9gen0a3Jv7lti0sLmTr2a2AFB0LIWoWN0c34u6Ks3UYlWKNhVT9/Y3/Zl+8aNmGy1XNoiTn/PnzaJpGdHR0qQQHoHXr1kRHR7Nu3boa/4MQ1ctBp9G3eSCLdyax9uD5KyY5ey7uIacoBz9XP1r4tajGKIUQ4so0TbN46Kc2at++PZs3b2bnzp3cfffdtg6nXJVbbvZfnJ2dAUhLSyu3TXp6OgBOTk6W3ErYoQEt6wOw5uD5K+6HZppVFR0SjU6z6FdWCCGEFdx8880ALFq0iKKiIhtHUz6LPjEiIiJQSrF7924+/fTTUuc/++wzdu3ahaZpNGrUyJJbCTvUu1kgzg464lNyOH6x/F3spR5HCCFqlsGDB9O6dWsSExP5z3/+c8W2GRkZ7N+/v5oiK8miJOfyQuLHH3+ciIgIBg8ezODBg4mIiGDy5Mnm8wMHDrTkVsIOebo40jXSuOLx2oPny2yTmpfKwZSDgNTjCCFETaFpGvPnz8fV1ZWpU6fy4osvkp1d8j+rSimWLl1Kp06d2LZtm03itCjJeeKJJ3B3N45FKqU4deoUq1evZvXq1Zw6dco8BOHm5sbjjz9uebTC7piGrNYevFDm+S1ntqBQNPdtToBbQHWGJoQQ4grat2/PmjVrqF+/Pu+88w5BQUEMGDCAsWPHcssttxASEsLw4cM5ffo0YWG22YrH4uGquXPnmuttLl9cyPTcycmJb775hoiICEtudc1ycnKIjIxE0zQee+yxUucPHz7MiBEj8PX1xcPDg169evHnn3+WeS29Xs/kyZMJDQ3F1dWV1q1b8/nnn1+xnkRc2Q0tgwDYnpBKWnZBqfOmepzuodKLI4QQNU2PHj04duwYM2bMoHPnzuzdu5cff/yRzZs3ExERweuvv87Ro0dttoSMxSsejxo1iqioKKZPn87q1avN3VUeHh4MHDiQV155xaYrIr722mvlzuw6fvw43bt3x9HRkeeeew4fHx+++uorbrzxRlatWlViW/iCggIGDhzIrl27mDx5Mi1btmTVqlVMmjSJ8+fPM3Xq1Gp6R/aloa87LYK9OHQuk3WHL3Brh4bmc0op2cpBCCFqOE9PT55++mmefvppW4dSilU2nGjfvj2LFy/GYDCYV0H09/dHp7PtTJidO3fy4Ycf8r///a/MH/6LL75Ieno6O3bsoH379gCMGzeO1q1b8+ijj3Lo0CFzj9Ts2bPZtm0bH3/8sbnWaOLEidx222289dZb3HvvvVJcfY0GtKzPoXOZrDl4vkSScyTtCMm5ybg5unF90PU2jFAIIURtZNUsRKfTERgYSGBgoM0TnOLiYiZOnMjgwYO59dZbS53Pzs5m6dKl9O3b15zggDEjfeCBBzhy5EiJQqmFCxfi7u7OxIkTS1xnypQpFBYW8n//939V9l7s3YBWxrqcvw5fJK+w2Hzc1IvTObgzzg7ONolNCCFE7WW3i4588MEHHDp0iE8++aTM83v37iU/P59u3bqVOhcdHQ1gTnIMBgM7d+7k+uuvx9W15I7ZXbp0QdM0m1WO24N2oT6E+LiSXVDM5mPJ5uOmqeMyq0oIIcS1sMsk5+TJk7z++uu89tpr5RY8nzlzBoDQ0NBS50zHkpKSAONih7m5uWW2dXFxISAgwNy2LPn5+WRkZJR4iH/odBqDLvXm/L7/HGDc9G7n+Z2AJDlCCCGujV0mOQ8//DCRkZE89dRT5bYxbRzq4uJS6pypt8bU5kptTe1Nbcry9ttv4+PjY37YaipdTXZj62AA1hy8QFGxgZ3nd1JoKCTEI4QI7wjbBieEEKJWsrskZ/78+axevZrPP//8iltJmNb3yc/PL3UuLy+vRJsrtTW1N7Upy4svvoherzc/Tp8+XbE3U4d0aexHPXcnUrML2BafRuxZ4+av3Rp0K7E0gRBCCFFRVpldVVPk5+fz1FNPMWTIEIKDgzl27Bjwz7CTXq/n2LFjBAQE0KBBgxLnLmc6Zhqe8vX1xc3Nrcy2+fn5JCcn06dPn3LjcnFxKbcXSBg5OugY0LI+P+1I5Pf959ivGZOc6JBoG0cmhBBGsiZa1aqKn69FPTkbNmwwP2rCBl25ublcvHiRFStW0LRpU/Ojb9++gLGXp2nTpsyePZu2bdvi4uLCli1bSl0nNtb4AdupUyfAOGusQ4cO7Nq1q1RvztatW1FKmduKa2casvr90HEOpR4CoEtwF1uGJIQQODg4AFBYWGjjSOyb6fPV0dF6/S8WXalv375omkZ4eDgnT560VkzXzMPDg0WLFpU6fvHiRSZNmsTgwYO5//77adeuHZ6engwdOpTFixezZ88errvuOgCysrKYPXs2TZs2pUuXfz5g77zzTjZv3sysWbNK7Mn14Ycf4ujoyO233171b9DO9WoagLuzAxcL9+AGNPdtjr+bv63DEkLUcU5OTri4uKDX6/Hy8pIh9CpQXFxMamoqHh4eNSfJ8fX1JT09ndatW1srHos4OTkxatSoUsfj4+MBaNKkSYnzb7/9NmvXrmXQoEE8+eSTeHt789VXX5GUlMSKFStK/CJPnDiROXPm8NRTTxEfH0/Lli1ZuXIlv/zyC6+88orNtq2wJ65ODvRtHsjai8ZhRhmqEkLUFKZZtImJifj4+ODk5CTJjoWUUhQXF5Obm4ter8dgMBASEmLVe1iU5ERHR7Nq1SoSEhKsFU+1ioqKYvPmzbzwwgu88847FBQU0KFDB3777bcSWzoAODs7s2bNGl555RW+//57UlJSaNKkCTNnzuTRRx+10TuwPze1CeavrUcB6BrS1cbRCCGEkbe3NwDJyclXXDJEVJ6DgwPu7u4EBQXh7GzdhV81ZUGlz9atW+nZsyfFxcXMmzePu+++25qx2a2MjAx8fHzQ6/XmvzjC6EjKSW5bPgylHJjb/zc6hQfbOiQhhCihsLCQ4uLiqzcUV6XT6SrdK1aZz1CLenIOHTrEiBEj+Omnnxg/fjwLFy6kV69ehISElLmtw7hx4yy5nagDdicbV44uzgln7YF0SXKEEDWOk5PTFZcoETWHRT05Op3OnH0ppa6aiUnmayQ9OeV7av1TrE5YTf6FgYQwlPXP9JVxbyGEEGaV+Qy12mKAl38QKaXMD9P3QlxNsaGYree2AuCQ34yElBz2n5EtMIQQQlwbi5OcyxOayxOby88LURGH0g6hz9fj6eRJ34gOAKz4+6yNoxJCCFFbWVSTs27dOmvFIQSxZ4yLMHYO7syggIas2neRlX+f5bkbm8uQlRBCiEqzKMm50lYGQlSWab+q6JBo+jcJws3JgYSUHPYm6rkurJ5tgxNCCFHrWHWDzvz8fOLj4zlw4IA1LyvqgLyiPHae3wlAdINo3J0dGdCqPgBL95yxZWhCCCFqKaskObGxsQwePBgfHx+aNGlCu3btAHjzzTe57777ePDBB2vE3lai5tp9cTcFhgKC3INo7N0YgOHXGTdRXbbnDMUGqe0SQghRORZvEDF37lwefPBBiouLSxUZe3h4MHfuXDRN46abbmLkyJGW3k7YKVM9TnRItLn+pnezQHzcnLiQmU/ciRS6RwXYMkQhhBC1jEU9Ofv37+ehhx4y99L8uzh0zJgx5mMrV6605FbCzl1ej2Pi7KhjSFvjYoC/7pYhKyGEEJVjUZLz3nvvUVhYiKZphIWFERoaWuJ8aGgokZGRAGzfvt2SWwk7ps/XcyDFWMf17005h11n/J1aue8s+UWymKQQQoiKsyjJMU0h9/HxYefOnXTtWnpDxaioKJRS5p3Ahfi3ree2olA08WlCoHtgiXNdGvsR7O1KZl4Rfx2+aKMIhRBC1EYWJTlnz55F0zS6deuGn59fmW0cHY1lP9nZ2ZbcStixuLNxQNm7jjvoNG5pFwLAkt2y868QQoiKsyjJcXFxASAnJ6fcNkeOHAHA09PTklsJO7btnHFTzi7BXco8P+J645DVmoMX0OcUVltcQgghajeLkpzIyEiUUmzZsoWjR4+WOr9gwQKOHj2Kpmk0bdrUklsJO5Wcm8wJ/Qk0NDoFdyqzTesG3rQI9qKgyMDyv6UAWQghRMVYlOQMHDgQgMLCQqKjo4mJiTGfGzBgABMmTCjVVojLmXpxmvs1x8fFp8w2mqZxawdjb87inTJkJYQQomIsSnKeeOIJvLy8AEhLS+PcuXOAcVPOdevWUVxsnA3j6enJpEmTLAxV2CPTruOdgztfsd2I9qHoNNiRkEZ8stR3CSGEuDqLkpzQ0FC+++47c20OGP/Xffl6Oc7OzsybN48GDRpYcithp65Wj2MS5O1Kr6bGmVeLdyZWeVxCCCFqP4u3dRg2bBhbt27l1ltvxcPDA6UUSinc3d0ZOXIkcXFxjBgxwgqhCntzPvs8CRkJ6DQdHet3vGp785DVriQMss2DEEKIq7B4WweANm3a8NNPP6GUIjk5GQB/f390Oqvu/ynsjGmoqqVfS7ycva7aflCrYDxdHElMyyXuZCrdmvhXdYhCCCFqMatmIZqmERgYSGBgoCQ44qoqOlRl4ubsYF4zZ9H201UWlxBCCPtglUzkwIEDPPLII7Ro0QIPDw88PDxo0aIFDz/8MPv377fGLYQdqmjR8eXGdA4DjNs8ZOTJmjlCCCHKZ3GS8/HHH3P99dcza9Ysjhw5Qm5uLrm5uRw5coSvvvqKDh068OGHH1ohVGFPkrKSSMpKwlFzpEP9DhV+3fVh9Wga5EleoYGlsmmnEEKIK7Aoyfn111+ZMmUKhYXG/1GbZlZdPsOqsLCQp59+ml9//dXyaIXd2HrW2IvTOqA1Hk4eFX6dpmncfqk35/+2yZCVEEKI8lmU5Pz3v/8FjB88SimcnZ2JiooiKioKFxcXlFLmc6a2QkDl63Eud2uHhjg5aPydpOfAmQxrhyaEEMJOWJTk7Nmzx9xj89xzz3Hx4kUOHz7M4cOHuXjxIi+88AJKGaf67t271/JohV1QSl1TPY6Jn4czA1vVB+BHKUAWQghRDouSHDc3N8A4hfydd94psQmnh4cHb731Fm3btgXA1dXVklsJO3I68zTnc87jqHOkfVD7a7rGmE7GIatfdiWRV1hsxeiEEELYC4uSnN69e6OUIjAwsNw2gYGBaJpGjx49LLmVsCOmXpx2Ae1wc3S7pmv0ahpIaD039LmFrNh71prhCSGEsBMWJTn/+c9/cHNzIy4ujsOHD5c6f/DgQWJjY3FycmLatGmW3ErYEVOS0yWk8vU4Jg46jbu6hgOwIC7BKnEJIYSwL5Va8fjbb78tdWzs2LHMnj2bLl26MHbsWFq1agUY185ZsGABubm53H777ezdu5f27dtbJWhReymlLCo6vtzoTg35YPURdp5K58CZDFo18LZGiEIIIeyEpkyVwRWg0+lKbL5pYrrEv8+ZZleZmHYlr+syMjLw8fFBr9fj7V23PphP6E8wfMlwnHXOxNwVg4uDy9VfdAWPLtzJir1nGds1nP+MbGulKIUQQtRUlfkMvabhKtMmnJcnN2UlP6ZjlcijhJ3bdtbYi9M+qL3FCQ7A2EtDVkt2JZGVX2Tx9YQQQtiPSic5/05YLk94ynsIYWLJ1PGydIv0JzLQg+yCYpbsSrLKNYUQQtiHStXkrFu3rqriEHWAUort57cD0DWkq1WuqWkaY7s24o3lB/h2Szxju4aX2asohBCi7qlUktOnT5+qikPUAcfSj5Gal4qboxtt/NtY7bqjOjbkvT8Oc+R8FltOpNC9SYDVri2EEKL2ssou5EJUhGmo6vqg63FycLLadX3cnLitQ0MA5m6Ot9p1hRBC1G6V6sm5kqKiIlJSUsjPzy+3TXh4uLVuJ2oh06ac1qrHudz47o34LjaBNQfPczo1hzA/d6vfQwghRO1icZLz119/MW3aNGJiYsy7kZdF0zSKimT2S11lUAZzPY6l6+OUJSrIi15NA9h4NJn5sQm8OKSl1e8hhBCidrFouGr16tUMHDiQv/76i4KCApllJcp1OPUwGQUZeDh50Mq/VZXcY0L3CAC+33qKnAJJqIUQoq6zKMl5/fXXpXdGVIipHqdDUAccdVYbJS2hX/MgGvm7k5FXxM87ZTq5EELUdRZ92uzZs8c8Xbdr16707NmzxE7kQphYayuHK9HpNO7tHsHUZQf4ZtNJ7uoSjoNOppMLIURdZVGS4+HhQV5eHtdddx0xMTGyPokoU5GhiB3ndwDQOcT6RceXG90pjPdXH+FkcjZrDp7nxtbBVXo/IYQQNZdFw1WDBg1CKYWrq6skOKJch1IPkVWYhZezFy18W1TpvTxcHBkb3QiA2RtPVOm9hBBC1GwWJTlvvfUW/v7+xMXF8cEHH1xxdpWou0z1OB3rd8RB51Dl95vQPQInB41t8WnsPp1e5fcTQghRM1k0XBUeHs66devo2rUrzzzzDNOnTycyMhIfH59SbTVNY+3atZbcTtRSpiSna7B1tnK4mvrergy7LpSfdyby1YYTfDq2Q7XcVwghRM1iUZKTmprK2LFjycvLQymFXq9n165dpYaulFIynFVHFRoK2Xl+J1A1iwCWZ2Lvxvy8M5FV+84Sn5xNRIBHtd1bCCFEzWDRcNXzzz/P33//DRh7akwPIUz2J+8ntyiXei71aOrbtNru2yLYm37NAzEo+HLD8Wq7rxBCiJrDop6cpUuXommaeaE/X19fPD090elkSyxhZBqq6hzcGZ1Wvb8Xk/pFse7wRX7ekcSUAc2o7+1arfcXQghhWxYlOTk5OQAEBwezceNGmjRpYpWghP24PMmpbp0j/OgS4cfW+FRmbzzByzdXzUrLQgghaiaL/mvdoYOxoLNt27aS4IhSCooL2H1hN1C1iwBeySP9jL+XC+JOkZ5TYJMYhBBC2IbF2zoAxMXFceKErEkiStp7cS/5xfn4u/oT6RNpkxj6NgukVYg3OQXFzNkcb5MYhBBC2IZFw1WJiYkMHjyYVatW0bFjR+644w5atWpV5hRygHHjxllyO1HLmLZy6Bzc2WYF6Zqm8Wi/KB5duJNvNp/kvp6N8XFzskksQgghqpdFSc6ECRPMH156vZ5Zs2Zdsb0kOXWLLetxLndTm2Ca1ffkyPks5m6O54kB1TfLSwghhO1YZbrLv6eOK6XMD9P3om7JK8hhz8U9AHSxcZKj02lM7m9MbL7edIKMPFmZWwgh6gKLenLg6gmMJDh1RG4aHF0Dh1dC/Cb2GDIpDA4kqKiIRjOjwTsUQjtA1ABo0h88g6o1vCFtQ/h47VGOXjD25jx+g/TmCCGEvbMoyVm3bp214hC1VX4WbP4IYmZCUa758NZ6xrqsLnn5aEV5kHrc+Ph7EaBBs8HQ9UGI7AfVUK/joNOYfENTHv9+F19vOsmEHhF4u0ptjhBC2DOLkpw+ffpYKw5RGx34FVY+B1nnjN8HtoAWN0PTG9m29wNI2U+XAe9AYGdIi4f4jXB0NZzbC0dWGR9BrWDAVGg6qMqTnZsv9eYcu5DF7I0neWpgsyq9nxBCCNvSlIwnVbuMjAx8fHzQ6/V4e3vbOpzKUwo2zIB1bxq/r9cIBr0BLYeBppFTmEOP73tQpIpYdesqGno1LPn6i0dg21eweyEUZBmPNeoJg9+CkOuqNPRVf5/lkQU78XB2YMNz/fD3dKnS+wkhhLCuynyGWtSTc+rUqUq1Dw8Pt+R2oiYoLoRlU2D3fOP33R6DG14Dx3+ShV0XdlGkimjg0aB0ggMQ2AyGvAv9XoJNH0DsF5CwCWb1gx6PQ5/nwcmtSsIf3CaYtqE+/J2k5/P1x3nlFlkFWQgh7JVFSU5ERESF1z/RNI2ioiJLbidsTal/EhxNZ0xUOj9QqlmFp467+cLA6dB5IvzxChxYYkx6Di6DW2dBaEervwVN03jmxuaM/2Yr38YmcH+vxoT4VE1CJYQQwrasMoX88injV3qIWm7Lp5cSHAe4fUGZCQ78swhgl5AKbuVQLwzGzDNe0zMYUo7B14Ng88dgMFgrerPeTQPo0tiPgiIDH689avXrCyGEqBksTnLKS15Ma+fYaqVbYWVH/oDVrxqf3/gWtBhSZrOsgiwOpBwArmG/qpa3wKOx0Go4GIqM91s4BnJSLYm8FE3TeO7G5gD8uD2RYxcyrXp9IYQQNYNFw1Wmvav+7fz582zZsoU9e/agaRq33XYbbdq0seRWwpb0ifDz/aAM0GE8dH2o3KY7L+ykWBUT5hVGsEdw5e/l5guj58GOufDbC3BsNXzVD+5YCPVbX/t7+JdOEX4MbFWf1QfO886qQ8web9sFC4UQQlhflSQ5JjNmzOC5555jw4YNfPzxx5bcStjSyucgPwMadoYhM6441XvrWWM9jkW7jmsadLoXGnaCH+4yTj+fPRBu/RJaDr326/7LCze14M9DF1hz8AKxJ1KIjvS32rWFEELYnlVqcsrzzDPP4OfnR3JyMq+99lpV3kpUlYPL4fAK0DnCsJng6HzF5lbdryq4LTz4FzTuA4XZ8H/3QOznll/3kiaBntzZJQyAt1YexGCQujEhhLAnVZrkGAwGc9HxihUrqvJWoirkZ8LKZ43PezwBQS2v2Fyfr+dQ6iHAwp6cy7n7wd2LodP9gDIOYf32ktUKkp+4oRkezg7sTdSzbO8Zq1xTCCFEzWDRcNWGDRvKPF5cXExaWhpz584lLS0NwPxV1CLr3obMM+AbAb2fvWrzHed3oFA09mlMoHug9eJwcISb3wOfhrB2GsR+ChlJMPJLcHK16NKBXi483KcJ760+wjurDjGoVTBuzg5WClwIIYQtWZTk9O3bt0KzpzRNo3HjxpbcSlS3jLOwbbbx+ZD3KrQ4n3nquLV6cS6nadDrKfAJgyWPGNfUyTpvLEh297Po0hN7R/LDttMkpefyxV/HeVK2exBCCLtQpevkAOYk6OGHH7bGrUR1ifkYivMhLBqibqjQS6xaj1OedqPhnsXg4gOntsA3N0KGZcNMrk4OvHyzcSjui7+Ok5See5VXCCGEqA2qbJ0c0zk3NzdeffVVHn/8cUtvJapL1kXYPsf4vM+zFdo4MzUvlSNpR4AqTnIAGveG+34D71BIPgLfDIbUkxZd8qY2wXRt7Ed+kYG3Vh60UqBCCCFsyaLhqjlz5pR7ztnZmeDgYDp37oynp6clt6mUI0eOMH/+fP744w+OHz9OXl4eTZo0YfTo0UyZMgUPD48S7Q8fPszzzz/PX3/9RUFBAR06dGDatGn079+/1LX1ej2vvPIKixcvJiUlhSZNmvDYY4/x8MMP29eih1tmQlEuNOgATSrWi7P93HYAoupF4edq2fBRhdRvZUx05g2DtJPGRGfcrxDU4poup2karw1txS0zN7Fi71nu7JxMz6YBVg5aCCFEdbIoyRk/fry14rCab775hk8//ZRhw4YxduxYnJycWLduHa+88go//vgjsbGxuLkZ60uOHz9O9+7dcXR05LnnnsPHx4evvvqKG2+8kVWrVjFgwADzdQsKChg4cCC7du1i8uTJtGzZklWrVjFp0iTOnz/P1KlTbfSOrSwnFbZeqsXp81yFenHgn6GqKqnHKU+9cGOi8+0IuHgQ5g4xzsRq0P6aLte6gQ/3RDfi2y0JvPrrPlY90QtXJylCFkKIWkvZmW3btqn09PRSx19++WUFqJkzZ5qPjR49Wul0OrVr1y7zsczMTBUeHq6aNWumDAaD+finn36qAPXxxx+XuO6tt96qnJycVHx8fIVj1Ov1ClB6vb4S76yabJih1OveSn3eQ6nL3v/VDPtlmGozt41aE7+mCoMrR3aKUl/2Mcb9VkOlErZc86X0uQWq85urVaPnl6v3/jhsvRiFEEJYRWU+QzWlKr5z5vTp0y1KqGy5IODff/9Nu3bteOihh/jiiy/Izs7G39+fHj16sHbt2hJt33jjDV577TXi4uLo0sXYM9GzZ0927dpFSkoKrq7/TFveuHEjvXv35r///S/PPfdchWLJyMjAx8cHvV6Pt7e39d6kpQwGmNnBOPwz/DO4fmyFXpacm0y/H/uhobHxjo34uPhUcaBlyMuAhbfDqRhwcoc7v4fIvtd0qRV7z/Lowp04OWiseqI3UUHVN9wqhBDiyirzGVqp4aqpU6daVHtiyyQnMTERgPr16wOwd+9e8vPz6datW6m20dHRAGzbto0uXbpgMBjYuXMnHTp0KJHgAHTp0gVN09i2bVsVv4NqEL/RmOA4e0HrERV+mWnqeHO/5rZJcABcveHun+HHe+DYGmPCc/sCaDrg6q/9lyFtg+nbPJD1hy/y8i9/88OD0fZVcyWEEHVElax4rMqZTm4rxcXFvPHGGzg6OnLXXXcBcOaMcdpxaGhoqfamY0lJSYBxIcPc3Nwy27q4uBAQEGBuW5b8/HwyMjJKPGqknd8av7YdBc4eV257mbizcQB0De5aFVFVnLO7cd2c5kOgKA9+uBMOraz0ZTRN443hbXB10hF3MpWfd5b/ZyuEEKLmqnSSU1YCU1ZCo2ma+WFrU6ZMYcuWLUyfPp3mzZsDkJOTAxiTlH8z9daY2lypram9qU1Z3n77bXx8fMyPsLCwa38zVSUnFQ4uNT7vWLmCcnPRcUg1Fh2Xx9HFuIt5q+FQXGDs2dm/pNKXCfNz54kbjIsC/mfFAVKzC6wcqBBCiKpWqeGqdevWXbVNamoqH3zwAZs2bSqR4Oh0VbpNVrleffVVPvnkEx588EFefPFF83F3d3fA2Mvyb3l5eSXaXKmtqb2pTVlefPFFnnrqKfP3GRkZNS/R2fujMSkIbgsh7Sv8sjNZZzideRoHzYGO9TtWXXyV4egMt30DDg/D34vgp3uhuNC4kGAlPNCrMUt2JXH4fCZvrzzIu6Ovq6KAhRBCVIVKJTl9+vQp91x6ejrvv/8+M2fOJCMjA03TUEqh0+kYM2aMTepxpk6dyptvvsm9997LF198UeJcgwYNAMocZjIdMw1P+fr64ubmVmbb/Px8kpOTr/izcXFxKbcXqEZQCnbOMz7vML7C08bhn6GqNgFt8HCq+BBXlXNwNO5t5eACu+fD4onGFZyvv7vCl3By0PHWrW247fMtLNqRyMgOoXRvImvnCCFEbWFx90p6ejqvvvoqERER/Oc//yEjIwOlFJqmcccdd7Bv3z6+//57Wra88g7W1jZ16lSmTZvG+PHjmT17dqlhs7Zt2+Li4sKWLVtKvTY2NhaATp06AcZeqA4dOrBr165SvTlbt25FKWVuWytdOGB8OLhA28r1dthkfZyK0jnAsJnQ6T5Awa+PwvZvKnWJjo38GNs1HIBnF+0lM6+wCgIVQghRFa45yUlLS+OVV14hIiKCt956q0Ryc+edd7Jv3z4WLlxIixbXtgKtJaZPn860adO45557+Oabb8ocKvP09GTo0KGsX7+ePXv2mI9nZWUxe/ZsmjZtap4+DnDnnXeSk5PDrFmzSlznww8/xNHRkdtvv73q3lBVO7jc+LVJf3CrV+GXKaXYetaY5HQNsXHRcXl0Orj5fej6iPH75U9C7BdXfs2/vDSkJeF+7iSl5zJt2YEqCFIIIURVqPSKx2lpabz33nt88sknZGZmmguNdTodt99+O6+99pq5uNcWPv30U15//XXCw8MZMGAACxcuLHG+fv36DBw4EDAWBK9du5ZBgwbx5JNP4u3tzVdffUVSUhIrVqwo0fszceJE5syZw1NPPUV8fDwtW7Zk5cqV/PLLL+Zkr9Y6uMz4teUtlXpZfEY8F3Iv4Kxzpn1Qe+vHZS2aBoPfNtbqbP4IfnveOHTV44kKvdzDxZH3xlzHmC+38NOORAa2qs+NrYOrOGghhBAWq8wqgy+99JLy9vZWOp1OaZqmNE1Tjo6O6u6771aHD9eM1WHHjx+vgHIfffr0KdH+wIEDatiwYcrHx0e5ubmpHj16qNWrV5d57bS0NPXoo4+qkJAQ5ezsrFq2bKlmzpxZYmXkiqhRKx6nHDeuFDzVV6ms5Eq99IeDP6g2c9uo+3+7v4qCszKDQak//2N8v697K7X+v5V6+VsrD6hGzy9XHab/oS5m5lVRkEIIIa6kylY81ul05oJiME4Tj46OrlDPjaZpfP3115VOwuxRjVrxePPHsPpV487e45dV6qVPrX+K1QmrmXz9ZB5s92AVBVgFNrwLf75pfN7rGej/SoWKrfOLihk2czOHz2cysFV9Zt3TsUYskSCEEHVJla14bGL6h10pRWxsrLlQtzzqUq2OJDk10KFL9TgthlbqZQZlMK90XCOLjq+k97Pg6Ap/vAIbZxiHrga+cdVEx8XRgfdvv44Rn25m9YHz/LwziVEdG1ZT0EIIISrLotlV8r/YWi7zHJw2TgGnxc2VeunRtKOk56fj7uhO64DWVRBcFes+GYbMMD6PmQmrnjPu3XUVrRv4MGWAcZHAaUv3k5hW/iKQQgghbKtKVjz+90PUUKZenNBO4FN6y4orMa2P07F+R5x0TtaOrHp0mQhDPwI02DoLlk+pUKLzcJ8mdGzkS2Z+EVN+2E1h8dVfI4QQovpVarjq5MmTVRWHsIXDq4xfKzmrCiDu3KX9qmrq1PGK6jgBHJyNa+jsnGdcGXn4J8Y1dsrhoNN4f8x13PLxJrYnpDHj98O8OKR614ESQghxdZVKcho1alRVcYjqVlQACTHG51EDK/XSQkMh289tB2phPU5Z2t9lTHQWPwh7FhprdEZ+CQ7l91A18vfg3dHteHj+Tr7ccIJOEX4MbFW/GoMWQghxNbbZUErYXuI2KMwBj0AIalWplx5IOUBOUQ7ezt4097PdmkhW1XYUjJ4LOifY97Nxv6uiK2/KObhNCPf1aAzA0z/u5nSq1OcIIURNIklOXXVivfFr497GVYErwbTKcZfgLug0O/oVajUMbp9v7NU5uMy4g3lh3hVf8sJNLbg+vB4ZeUU8unAn+UXF1RSsEEKIq7GjTyhRKaYkJ7JvpV9qN/U4ZWk+GO78wTjF/Mhv8MOdUFB+D42zo45P7upAPXcn9ibqeXP5wWoMVgghxJVIklMX5WVA0g7j80omOfnF+ey+sBuALiF2UI9TlqgbYOwicHKH43/CwjFQkF1u89B6bnxwe3sAvotNYOmeM9UUqBBCiCuRJKcuStgMqhj8IqFeeKVeuvfiXvKL8wl0C6Sxd+MqCrAGaNwb7l4Mzl4QvxHm32ZMDsvRr3kQj/WLAuD5n/ayL0lfXZEKIYQohyQ5ddGJv4xfG/ep9EtjzxpXt+4c3Nn+F4Ns1A3G/QquPnBqC3w3AnLTym3+5MBm9GoaQG5hMRO/3c6FjCvX8wghhKhakuTURRbU42w5swWA7g26Wy+emqxhRxi3FNz8jEN884ZBTmqZTR10Gp/c1YEmgR6c1ecx8dvt5BZIIbIQQtiKJDl1TeY5uHgQ0IxDMpWgz9ezL3kfANEh0VUQXA3VoD1MWG6cbn9uL8y9GTLKrrvxcXPimwmd8XV3Yk+inmcW7cFgkFW/hRDCFiTJqWviNxm/hrQDd79KvTT2bCwKRVS9KOp71LGF7+q3hgkrwDMYLhyArwfBxcNlNm3k78GX93TCyUFjxd9n+XDNkWoOVgghBEiSU/ecNq5xQ3i3Sr/UNFTVrUHlX2sXApvD/X+Af1PQn4Zvbvzn5/kvXRr78dbItgB8/OcxluxKqs5IhRBCIElO3ZO4zfi1YedKvUwpVffqccri2wju+924qWlumrFGx7QH2L+M7hTGQ30iAXju571sOZ5SnZEKIUSdJ0lOXVKYa6wpgUonOQkZCZzJPoOTzomO9TtWQXC1iIc/jF8KTQdBUS78MBZ2fltm0+dvbMGNretTUGRg4rfb+TtRppYLIUR1kSSnLjmzGwxF4Fm/0uvjxJwxbubZoX4H3BzdqiC4WsbZA+5YCO3vNq45tHQy/PkmqJJFxjqdxkd3XE+3SH+y8osYP2crxy5k2ShoIYSoWyTJqUsuH6qq5Bo35nqckDpaj1MWBycY/gn0esb4/YZ34ef7S+135erkwFfjO9GuoQ+p2QWM+zqOpPRcGwQshBB1iyQ5dUnipSLZSg5VFRYXsvWc8bV1uh6nLJoGN7wKwz8FnaNxB/N5QyE7uUQzTxdH5t7bhSaBHpzR53HP7DiSs/JtFLQQQtQNkuTUFUrB6Us9OWGV23Nqz8U95BTl4OfqR3O/5lUQnB24/m645xfj6siJW2H2DXCx5NRxPw9n5j/QldB6bpxIzmb8N1vJyCu0UcBCCGH/JMmpK/SJkHXO2NsQ0r5SLzXV40SHRKPT5FemXI17w/1rwDcC0uLh6wFwfF2JJiE+bnx3fxcCPJ3ZfyaDcV9vRZ8riY4QQlQF+cSqK0xDVfXbgLN7pV5q2q9KhqoqILAZPLAWwrpCnh7m3wpbPi1RkBwZ6Mm393XF192J3afTGTs7lrTsAhsGLYQQ9kmSnLri9LWtj3P5Vg51dhHAyvIIMO53dd1doAzw+0vwy8PGKfyXtGrgzfcPRuPv4cy+pAzu/CpWanSEEMLKJMmpKxKvrR7n8q0cgtyDqiAwO+XkCiM+g8HvgOYAe3+AOTcZhw0vaRHszQ8PRhPo5cKhc5ncOStWdi4XQggrkiSnLigquGwRwE6Vemmd38rBEpoG0Y8YC5Ld/ODMLpjVFxJizE2a1vfi/x6MJtjblaMXsrh9Vixn9TK9XAghrEGSnLog+TAUF4CLD/g2rvDLlFLmomOpx7FAZB94cJ2xHir7Isy9BTZ/bK7TiQz05MeHuhFaz42TydmM+nwLxy5k2jhoIYSo/STJqQvOGWtqCG5TqUUA4zPiOZt9VrZysAbfCOPmnm1GGVdIXv0q/HCXcf8rINzfnf97KJrGAR4kpedy62cxbD2ZatuYhRCilpMkpy4497fxa3DbSr1MtnKwMmcPuG023PIBODjD4ZXwZW9I2gFAQ193fn6kOx3C65GRV8Tds+NYsfesjYMWQojaS5KcusBUj1PJJEd2Ha8Cmgad7oP7Vxt7d9JPwTeDIW4WKIWfhzMLJ0YbN/UsNvDowp3M3ngC9a89sYQQQlydJDn2Tqlr6snJL843b+XQo0GPqoisbmvQHh78C1rcYqyXWvUsfH8HZF3E1cmBz8Z2ZEL3CADeXHGQacsOUFRssGnIQghR20iSY+8ykiAv3bjScWCLCr9s27lt5BblUt+9Ps18m1VdfHWZWz24fb5xmrmDMxz5DT7vBkdX46DTeH1oK14e0hKAuTHxjPtmK6myaKAQQlSYJDn2ztSLE9AcHF0q/LINiRsA6NWwF1oldywXlWCaZj5xHQS2NM6+WjAKVj6HVpTHxN6RfD62A+7ODsQcT2HozE3sS9LbOmohhKgVJMmxd9cwVKWUMic5vUN7V0VU4t+C2xinmXd92Pj91i9hVj84s4ub2oaw5NEeRPi7k5Sey22fx/DLrsQrX08IIYQkOXbvGoqOT+pPkpSVhLPOma4hXasoMFGKkxvc9F8Y+zN4BMHFg/DVDbB2Os38nfn10Z70bR5IfpGBJ/9vD9OXHaBQ6nSEEKJckuTYO/MaORVPcky9OJ2DO+PuVLnNPIUVNB0Ak7ZA65HGNXU2vgdf9sYndS9fj+/M5P5RAHyz+SSjvthCQkq2jQMWQoiaSZIce5aXAWknjc8rk+Qk/VOPI2zEIwBGz4Ux34JHIFw8BF8PwGHNazzdL5wv7+mIt6sje06nc/PHm2T4SgghyiBJjj07v9/41TsU3P0q9JLMgkx2nd8FQO+GUo9jc62Gw6Nboe1o447mMR/DZ9240WUfq6b0pkuEH1n5RTz5f3uY8sMuMvMKbR2xEELUGJLk2LPzlR+qijkTQ5EqorFPY8K8wqooMFEp7n7GlZLv+B68Qoy9c/NvI/SPh/n+jnCeHNAMnQZLdp/h5o83sSNBtoMQQgiQJMe+mWZW1W9T4ZesO70OgD4N+1RFRMISLYYYe3WiJ4GmgwNLcPisK094rObHiZ0JrefGqdQcRn2xhWnL9pNTUGTriIUQwqYkybFnFw8bvwa1rFDzwuJCNpw21uPcEH5DVUUlLOHqDYPfNq6W3LAzFGTC7y/S6feR/D5CMapjQ5SCOZvjufHDDWw+lmzriIUQwmYkybFXSkHypSQnsHmFXrLt/DYyCzPxd/WnbUDl9rkS1SykHdz3Bwz9CFzrwfl9eP5wKzOK3uHHUUGE1nPjdGouY2fH8eLivWRIrY4Qog6SJMde5aRAbhqggX9UhV7y56k/Aegb1hcHnUMVBiesQqeDjhPg8V3Q5UHQHODwSrqsvIl1bf9gYidfAL7fepob3vuLn3ckYjDIRp9CiLpDkhx7ZRqqqhduXGTuKgzKwLpTxnocGaqqZdz9YMi7xrV1mg4CQyHO2z7n5eN38VePv2nu78jFzHyeXrSH0V9ukW0hhBB1hiQ59so0VBVQsc019yfv50LuBdwd3WWV49oqsDmMXQR3/2zcjDU3jUY73uY33RPMa/s3Ps6KHQlpDP1kEy/98jdpstmnEMLOSZJjry4eMX6tYD3O2lNrAeMCgM4OzlUVlagOUQPg4c0w/DPwCUPLPEufo2+zw/clpkfsQ1MGFv5/e3ceHlV1P378fWfLJJPJAoGQDULYN0VIAmUxoKKAhQp8lQpVqjZqtVRcfi3aIgit1qKiLOL2rUWxtPKg8lWUVsuiIWAAQWSLBJJACFv2fSYzc35/DBmJCZBAkmGGz+t55pk755577+cw5OaTc8699+ujpCzcyGubD1NT6/R2xEII0SokyfFXBWeTnCb25Gw45p6PI0NVfkJvgOumw8ydMG4hWDpiKM3l7pPPsq/jHGaGf01VTQ1/+ewgoxZu4p8ZR3HIc7CEEH5Gkhx/1YwkJ6s4i+zSbAw6AyNiRrRyYKJNGQJgyP3wyG64cS6Ywwgsy+bx6lf4Nnw2DwdvorisjNkffMctL3/J+r0nUEomJwsh/IMkOf7IVgGlx9zLTRiu+iznMwBGxIzAarK2ZmTCW0wWGPkYPLoXxswHS0cs1fn8P8cbfBPyBI8EfsqZM6d5cOU3jF+cxqffnZArsYQQPk+SHH9UmOV+D4q46DOrlFKsz14PwLj4ca0dmfC2ACsMfwRm7XEPY4XEYLEX8KhayY6g3/KngHeoPHmIh977hptf/pIPd+XJMJYQwmdJkuOPmjFUtb9oP0fLj2LWmxkVN6p14xJXDmOgexjrt7vhZ8ugY19Mrmp+oa1nc8Bj/K95Ee3PbOfRf+3mhhc3s3JbrjwmQgjhcwzeDkC0grp75HS4eJLz2RH3UFVKXApBxqDWjEpciQwmuO4XMHA6HNkEW5ehZX3OjWznxoDtHCaWd0pv5K8fjWDhv8O4M7kzd/+kC9FhF7/3khBCeJskOf7Ic4+cC8/HcSkX63NkqEoAmgbdRrtfZzJh26uw53261ebxjHEFTxpXsbZ2GO99eSNvftWNcf2juGd4PIM6h6NpmrejF0KIRkmS448KDrnfLzJctfv0bk5VnSLYGMyIWLmqSpzVoZf7mVhj5sOe92HH3zCf3s9UwyamGjZx0BXHmn0jeXDPcNpFdubO5DgmXRdLaJDR25ELIUQ9kuT4G6cDCg+7ly8yXPVp9qcA3ND5BgL0Aa0dmfA15lBIToWkX8GxDNjxv7DvI3pzjD/o/sFswyq+LLqGNeuu56XPkrhxQBd+nhRHctd20rsjhLgiSJLjb4qzwVULxiAIiT1vtRpHjSfJGd91fFtFJ3yRpkHnIe7XuL/Cvg/h21Xoj33NaP23jNZ/S4Uy8/newbz+7U+YHZrMrQPjue26GLp3DPZ29EKIq5gkOf6m7vLx9t3cT6k+j/8e/S/l9nKiLFEMjRraRsEJnxcYBon3uF8FWfDtKtSefxJcmsck/RYm6bdQWhXEv79K4k+bh1DaaRi3XteFn14TTadQs7ejF0JcZSTJ8TdF2e73dgkXrPbBoQ8AmNR9EnqdvrWjEv4oojvcOAfthj9C3nbY+wFq34eEVpzkDsNm7mAzFYVmvvzPNfz1s0EURKcw4ppejOsfRVw7uZJPCNH6JMnxN8Vnk5zwruetcrTsKBknM9DQmNRjUhsFJvyWpkFcMsQlo93yZzi6FfZ+gOvgOoIrTjJen8F4fQbOM6+z44tevPvv68iJSKHfgERG9+5A/+hQdDqZwyOEaHmS5Pibup6c8PjzVvkw60MAhscMp5OlUxsEJa4aOj3Ej4D4EehufRFO7IbMz6jdvw7jmb0M0Q4yRHcQSleR82UkWzb15z3TQIzdUkju34Pre0QQFmTydiuEEH5Ckhx/U9eT067xnhyHy8FHWR8BMKXHlDYKSlyVNA2ir4Po6zCOfgpKjsH367Hv/wR9bhrxulPE604x3fVfXN+/xN7MeP7p6s/JiKF07JvCT3rH0j8mFKNebswuhLg0kuT4E5cTSo66l88zXLXp2CYKqgtoZ25HSmxK28UmRFgcJKdiSk4FWznkbMF5eCO2zA0ElX7PNVo21+iyoeRjbFuM7Errzt+03pR3GExYz+EM7BnPNbFhmAyS9AghmkaSHH9Slg9OO+iMENrw8nGlFG/vfRtw9+IY9XLzNuElAVboNRZ9r7EEjQfKT8KRzVQd/AKyNxFUc5qh2gGGcgAKPoQCyEyL5UN6Udh+EIHdhtOzV38GxIURYpb/x0KIxkmS40/qhqrCOrvnRvzIjlM72FOwhwB9ANP6TGvj4IS4AGsnuHYqQddOBaWgMAtXbjpl33+FduxrQquO0kuXRy/yoPi/sGMhhdut7FJdyTP3xt7xGkISEunZow+9okKkt0cIAUiS418uMun4b3v/BsBt3W8jIjCijYISopk0DSJ6oIvoQdjgGe6yijOoY9soOfgVjpythJfup71WToq2B+x7IO99yIOCzSFsU105FdwbR8d+BMddS0y3fvSODifIJKc7Ia428lPvTy4w6TizKJO042noNB0z+s1o48CEuEzBHdD6TCC8zwT359oaOL2PiuwdlB3JwHBqD+0qDxOhlXG99i1UfQs5QA7YvjSSpaLJM3WlMrQn+k79CIu/li7xPYhtF4RBJjYL4bckyfEnRee/R05dL87NXW4mzhrXllEJ0fKMZogZTHDMYIJHPOAuq61BndpL0aGvqcjegbHwIO2rjhBADf20XPo5cqFwExQC+6BSBZBJFKdNcVQGd0WL6E5QdB86dulHfEwklgA5PQrh6+Sn2J8U57jff9STs69wH59lfwbAvf3vbeOghGgjRjNabCLtYxNpP/psmcsFJTmUHd1D8ZHdOE7uw1LyPR3sR7FoNvqRQ7/aHCj+CoqBQ+7NTqkwDmmdKAmIwhYcC2FdCOiQQFhUNzrGdaNTWLDcwFAIHyBJjj9p5G7HLuXi2W3PolCM6zqOPu37eCk4IbxAp4N2CYS0SyBk4G0/lDvsuIqyKczdR9nxAzhOf4+pNJvw6lzCXCVEaiVEUgK2g2DD3ftz+OymSkc+7Thj6ES5OYba4Gg0azTG8BiCO3QmNLILHSOjCJarvoTwOkly/EVVEdSUupfPmXj84aEP2VOwB4vRwhOJT3gnNiGuNAYTuo696NCxFx2SfrSuuoSK/EyKjh+i6vQRnEU5GMuPYa3Op73jJCbNQSwFxDoLoHIvVAKn6u/CpozkEU6xIYJKUwdsQZEoaxR6ayQBoZEEhkdhbR9FeIcoQoLMaJr0CgnRGiTJaQaXy8Urr7zC66+/Tk5ODh06dOCOO+5g/vz5WCwW7wZX14sTHAkm98MPS2pKePmblwF46NqH6BjU0UvBCeFDAsMI7jaE4G5DGq5zuXCUnaDo+CFK8rOwnTmCKj2OsfIkQbbThDoKCFNlBGi1xHKaWOdpqMb9Kmz8cMXKSokulHJ9ODWmdtjN7XEFtkcLDMdgaYfR2p6A4PYEhkUQHBZBaFgHzAFGSYyEaAJJcprh0UcfZfHixUyaNInHH3+cAwcOsHjxYnbt2sUXX3yBTufFqzR+NOnY4XIwJ30OJbYSuod1584+d3ovNiH8hU6HISyGjmExdOw3qvE6DhuVhccpPplLRcFRbIV5uMry0VWcIMBWRGBtMVZHMaGqDL2mCNfKCVfl4MgDB1B18TBKlYVyLZgqvZVqfQh2YwgOUygukxUVEIwWYEVnDsEQGIIxKARjUCgBllCCgsMItIZhCQ7FZJLhNOH/JMlpon379rFkyRImT57MmjVrPOVdu3blt7/9Lf/85z+ZNs2LN9g75/Jxl3IxL30em45twqQzMW/YPIw6OaEJ0SYMAVgiE7BEJly4nstJTdkZSs7kU1F0gpqSk9hLT+GqOINWVYjeVkJAbRkBjlKCnBUEq3KCqQYgVKsklEpwngInYMc9bNYMlSqAKi2IKi0Imy4Iuz4Ih86M02DGqQ/EZTCjDIFgCAJTIJoxEJ0pyP0KsGAICMJgtmAyWzCagzEFnv0cYMFkDsJkMqGXydnCyyTJaaJVq1ahlGLWrFn1ylNTU5k9ezYrV670cpKTA4A9rDOLti9k7eG16DU9C1MWcm2Ha70XlxCicTo95rBOdArr1ORNlMNOVVkhZcVnqCotoKasEHtFAY6KYlR1Mdgr0NnK0ddWYHBUYnRWEuCswuyqJFBVYVHVGDUnABbNhgUbqGJ3ouRs2eY5lUY1RmoxUKsZqcVIrWbEoRlx1r3rjDh1JlyaCafOiNKbUDoTLr0JpTeBPgClN6J0JtCbQGdA0xvR9AbQ69HpTGh6A5regM5gRNMZ0BkM6PTucr3BiM5gRK83nX03oDca0elNGIxGdHoDOr0RvcGIZjCi1xvRGwxoOj16nR69XifDgj5Okpwm2r59OzqdjuTk5HrlZrOZgQMHsn37di9F5pZTdIg14WGszV9LscPd3z1/+Hxu6HyDV+MSQrQczWDC0i4KS7uoS9uBUjjs1VSVl1JZXoytshRbZQn2ylIc1eU47dW47FUoexXUVkFtNZqjGq22Gp2zBr2zBr2zGqPLhtFVg8lVg0nZCMCGWdkwa7WeQ+k1RSB2ArGfc/yzLx/hUhoOdCg0nOhwoeFCh9J0OM+Wu9B5Xko7ux4dLu3s+9lyhf7sej1oP+xH1avnfsfzrgEaCu2H5bPveJIvXb0yhYam1d+G864/O8XC815X1ti2unOWce8H3dll3Q/xnN1eaXi20wVYGDJ1dlt8ZQ1IktNE+fn5REREEBAQ0GBdTEwM6enp2O12TCZTg/U2mw2bzeb5XFZW1qKxldpKmaTl4wgLAUcVHYM6MvO6mUzsNrFFjyOE8HGahiEgiJCAIEIiLjFRugDlcuKwVWGz1VBrq8Zhq6HW/sPLWWvDWfdea8NVa8PlqEHV2nA5bCiHHeWwgcOOctrQnHZ0Ths6Vy2ay4GmHOByoHM50JQTTbmXdcqJTtW9n13GiV450eMuN+BEf7asbtmAE4PmOm97dJpC15wuLnWe5atcAWGAJDlXtKqqqkYTHHD35tTVaSzJee6553jmmWdaLbZQo5Ub9GHY7RVMuX4+I7qNx6CTr1YI0bY0nR5joBVjoNXboTSZy+nC6XLgrLWjnA6czlpcTicupxOny4lyOnG5zr7OWVYuJy6XC5fz7LLTiVINy1HnrnOXo1wolwOlFCin+6aVyoWmnCjlApcTTbnLlMJdD5f74bXKBaiz26pzygCl3NuDe7+Ks3Xrys7ug3O2RdUvP7tOKYVWd1zPtu79aZy7n7q+ph/KtLrj4l7nNAbjraclasr9rycuYsCAAZw+fZpTp041WHfHHXewevVqbDZbk3ty4uLiKC0tJSQkpEXic7qc6Bt58rgQQgjhT8rKyggNDW3S71D5c7+JoqOj2b9/PzabrUGPzvHjx4mIiGg0wQEICAg4by9QS5EERwghhKhPHr/bRElJSbhcLjIyMuqV19TUsHv3bhITE70UmRBCCCEaI0lOE02dOhVN03j55Zfrlb/55ptUVVUxffp07wQmhBBCiEbJcFUTDRgwgIcffpilS5cyefJkxo8f77njcUpKinfvkSOEEEKIBiTJaYaXX36Z+Ph43njjDdatW0dERAQzZ85k/vz53n2kgxBCCCEakKurvKA5M8OFEEII8YPm/A6V7gchhBBC+CVJcoQQQgjhlyTJEUIIIYRfkiRHCCGEEH5JkhwhhBBC+CVJcoQQQgjhlyTJEUIIIYRfkiRHCCGEEH5JkhwhhBBC+CVJcoQQQgjhlyTJEUIIIYRfkiRHCCGEEH5JnkLuBXXPRC0rK/NyJEIIIYRvqfvd2ZTni0uS4wXl5eUAxMXFeTkSIYQQwjeVl5cTGhp6wTqaakoqJFqUy+UiPz8fq9WKpmktss+ysjLi4uI4duzYRR897yukTb5B2nTl87f2gLTJV7RGm5RSlJeXEx0djU534Vk30pPjBTqdjtjY2FbZd0hIiN/8cNSRNvkGadOVz9/aA9ImX9HSbbpYD04dmXgshBBCCL8kSY4QQggh/JIkOX4iICCAuXPnEhAQ4O1QWoy0yTdIm658/tYekDb5Cm+3SSYeCyGEEMIvSU+OEEIIIfySJDlCCCGE8EuS5AghhBDCL0mSI4QQQgi/JEmOj3O5XCxatIjevXtjNpuJi4vj8ccfp7Ky0tuhXZLvv/+ep59+mqFDh9KhQwesVisDBw7kz3/+s8+26ceqqqpISEhA0zR+85vfeDucS1ZUVMQTTzxB9+7dMZvNdOjQgdGjR/PVV195O7RLUlFRwbPPPsuAAQOwWq1EREQwbNgw/v73vzfpGTne9Nxzz3H77bd7/l/Fx8dfsP7XX3/NTTfdhNVqJSQkhLFjx7J79+42ibWpmtqmmpoa3nzzTX72s58RHx9PYGAgCQkJ3HnnnRw4cKBtg76I5n5P5/r973+PpmkEBwe3XoDNdCnteffddxk+fDghISEEBwfTv39/FixY0GoxytVVPu6RRx5h8eLFTJo0iXHjxnHgwAGWLFnCyJEj+eKLLy56y+srzezZs1m2bBkTJ05k6NChGI1GNm7cyPvvv88111zDtm3bCAwM9HaYl+WJJ57g9ddfp6KigocffpilS5d6O6Rmy83NZdSoUVRUVHDffffRs2dPSktL2bNnD7fccgs///nPvR1is7hcLlJSUkhPT2fGjBkMHTqUqqoqVq1aRUZGBr/73e94/vnnvR3meWmaRrt27Rg0aBA7d+4kJCSEnJycRutu27aNUaNGERMT40myly5dyunTp0lPT2fAgAFtGPn5NbVNBw8epE+fPowYMYKbb76Z6Ohojhw5wvLly6msrGT9+vWMHj267RvQiOZ8T+favXs3SUlJmM1mlFJUVFS0frBN0Nz23HvvvaxYsYIpU6YwevRodDod2dnZFBQU8NZbb7VOkEr4rL179ypN09TkyZPrlS9evFgB6r333vNSZJdu+/btqqSkpEH5H/7wBwWoJUuWeCGqlrNz506l1+vViy++qAD18MMPezukSzJixAgVGxur8vPzvR1Ki0hPT1eAmjVrVr1ym82munbtqkJDQ70TWBMdPnzYs9yvXz/VpUuX89ZNSkpSVqtV5eXlecry8vKU1WpVY8aMac0wm6WpbSooKFC7du1qUL5v3z5lMpnU4MGDWynC5mvO91TH4XCoxMRENWHCBJWSkqIsFksrRtg8zWnPW2+9pQD1zjvvtEFkP/CtP/NFPatWrUIpxaxZs+qVp6amEhQUxMqVK70T2GVITExs9JkkU6dOBWDv3r1tHVKLcTqdpKamMnbsWCZPnuztcC7Zl19+SVpaGr/73e+IioqitraWqqoqb4d1WcrKygCIjo6uV24ymYiIiMBisXgjrCZLSEhoUr2srCy2b9/O7bffTkxMjKc8JiaG22+/nS+++IKTJ0+2VpjN0tQ2tW/fnoEDBzYo79u3L/3797+izhlNbdO5Fi9ezP79+1myZEkrRHR5mtoepRTPPfccgwYN4q677gLcTxBXbTCQJEmOD9u+fTs6nY7k5OR65WazmYEDB7J9+3YvRdby8vLyAIiMjPRyJJdu0aJFHDx40CeHp8716aefAtC5c2cmTJhAYGAgFouFnj17+mRiDZCcnExYWBh//etfWb16NUePHuXgwYM8+eST7Ny5k3nz5nk7xBZRd074yU9+0mDd0KFDUUqxc+fOtg6rVbhcLk6cOOHT54zc3FzmzJnD3Llz6dKli7fDuWSZmZkcPnyYYcOGsWDBAtq3b09ISAhhYWE8+OCDrTr8Jk8h92H5+flEREQ0ervsmJgY0tPTsdvtmEwmL0TXcpxOJwsWLMBgMDBt2jRvh3NJsrOzmTt3Lk8//TTx8fFNGoe/UmVmZgLuHsMePXqwYsUK7HY7L774InfddRe1tbXcc889Xo6yecLDw/m///s/fvWrX3HHHXd4yq1WK2vWrOG2227zXnAtKD8/H6BeL06durLjx4+3aUyt5bXXXuPEiRPMmTPH26Fcsl//+tckJCTw2GOPeTuUy1J3zvjXv/6F3W7nj3/8I127duWTTz7h9ddfJzMzkw0bNqBpWosfW5IcH1ZVVXXe54GYzWZPHV9PcmbNmsXWrVt59tln6dWrl7fDuSQPPvigX5yswN3NDO4EYOPGjZ7/X7fddhsJCQk89dRTzJgxw+cmvddd6TFx4kSGDRtGUVERy5YtY9q0aaxdu5YxY8Z4O8TLVjes2Nh549xzhq9LT0/nscce49prr+Wpp57ydjiXZNWqVaxfv560tDQMBt/+VV13zjhz5gyff/45N910EwBTpkxBKcWKFStYv34948aNa/Fj+9ZZSNQTFBSEzWZrdF1NTY2nji+bM2cOS5cu5f777+fJJ5/0djiXZOXKlXz++ecsX74co9Ho7XAuW93VbXfeeWe9BDo8PJyJEydy8uRJz19uvuK7775j2LBhjBkzhoULFzJp0iTuu+8+0tLS6NSpE6mpqTidTm+HednqzgeNnTf85Zyxc+dObr31VqKjo1m3bp0nefMlRUVFzJo1i/vuu49hw4Z5O5zLVnfOiImJ8SQ4dWbMmAHApk2bWuXYkuT4sOjoaAoKCho9YR0/fpyIiAif7sWZN28ef/rTn7jnnnt47bXXvB3OJbHZbDz22GOMHz+eTp06kZWVRVZWFrm5uQCUlpaSlZVFSUmJdwNthtjYWAA6derUYF1UVBQAxcXFbRrT5Vq0aBE1NTXcfvvt9cqDgoK49dZbyc3N9ekhxjp1E6sbG5KqK2tsKMtXfPPNN4wZM4bQ0FA2btzos2155plnqKysJDU11XPOyMrKorq6GqUUWVlZHDt2zNthNpk3zxmS5PiwpKQkXC4XGRkZ9cpramrYvXs3iYmJXors8s2bN49nnnmGGTNm8NZbb7XKWG1bqK6u5syZM6xbt44ePXp4XqNGjQLcvTw9evRovXtEtIK6ie51k8HPVVfWsWPHNo3pctX9gm+st8bhcNR792VJSUkAbN26tcG6bdu2oWkagwcPbuuwWsQ333zjucHhxo0bfXqibm5uLpWVlQwZMqTeeSMjI4Oqqip69OjRKkM7rWXAgAGYzeZGk+tWP2e06QXrokXt2bPngvfJeffdd70U2eV55plnFKDuuusu5XQ6vR3OZbHb7Wr16tUNXq+++qoC1NixY9Xq1atVZmamt0NtsqKiImW1WlVMTIwqLy/3lOfn5yuLxaJ69uzpxeguzaxZsxSgnn/++XrlxcXFKioqSoWHhyuHw+Gl6JrnYvcrSUxMVFarVR0/ftxTdvz4cWW1WtWNN97YBhE238Xa9M0336h27dqpuLi4evduuZJdqE3p6emNnjf69u2rzGazWr16tfrPf/7TtgFfxMW+o+nTpytAffDBB/XKJ0+erAC1ZcuWVolL7njs42bOnMnSpUuZNGkS48eP58CBAyxevJjhw4ezYcMGn5v8uWzZMn7zm9/QuXNnFixY0CD+yMhIv5gAmpOTQ9euXX32jsdvvPEGDzzwAP369ePee+/FbrezfPlyTpw4wSeffMLNN9/s7RCbJTc3l0GDBlFcXMz06dMZPnw4RUVFvPnmm+Tk5LBs2TIeeughb4d5Xu+++65nCHTJkiXY7XYef/xxALp06eK5Nwm4J+WOHj2a2NhYZs6c6dnm1KlTbNmyhWuvvbbtG9CIprYpNzeXwYMHU1RUxNy5c+nWrVuDfU2aNOmKuNdRc76nxowaNYodO3ZcMXc8bk57jh49SnJyMqWlpcycOZP4+Hg+/fRT1q1bx913382KFStaJ8hWSZ1Em3E4HOqFF15QPXv2VCaTSUVHR6tHH3203l/YvmTGjBkKOO8rJSXF2yG2iOzsbJ++47FSSq1Zs0YNGTJEBQUFqeDgYDVmzBiVlpbm7bAuWVZWlrr77rtVTEyMMhgMymq1qpEjR6o1a9Z4O7SLSklJadbPTHp6urrhhhuUxWJRwcHB6uabb1Y7d+5s+8AvoKlt2rhx4wXPGYDKzs72WjvO1dzvqbHtr6Q7Hje3PdnZ2WratGkqIiJCGY1G1bt3b/XCCy+0ao+99OQIIYQQwi/51liGEEIIIUQTSZIjhBBCCL8kSY4QQggh/JIkOUIIIYTwS5LkCCGEEMIvSZIjhBBCCL8kSY4QQggh/JIkOUIIIYTwS5LkCCGEEMIvSZIjhGhx8fHxaJrW7FdOTg5AvbJf/vKXXm1LS3C5XFx33XWeNm3atOmy9jdv3jzPvh555JGWCVIIPyRJjhBCtLKVK1eye/duAIYMGcKoUaMua38zZ870PHDytdde48iRI5cZoRD+yeDtAIQQ/mf8+PGcPn26XtnmzZspKCjwfB43bhxBQUH16tT94p4yZYqnLCkpqRUjbX0Oh4Onn37a87nuKc2Xo3379vzyl79k2bJl2O125s6dy7vvvnvZ+xXC38gDOoUQbWLUqFFs3rzZ8zk7O5v4+HjvBdRGPvzwQyZPngyA1Wrl9OnTmM3my97vli1bGDFiBAAmk4njx48TERFx2fsVwp/IcJUQ4opzoTk55873GTVqFKdPnyY1NZXIyEiCg4MZOXKkZ86L0+lk4cKF9OzZk4CAALp27cqcOXOora1t9LiFhYUsWLCAIUOGEB4ejslkIiYmhqlTp7Jly5ZLassbb7zhWZ44cWKjCc6hQ4d44IEH6NWrF0FBQZhMJqKiokhMTOTBBx9k9erVDbYZNmwYsbGxANjtdlasWHFJ8Qnh15QQQrSBlJQUBXhe2dnZ5617br0ZM2bUW9elSxfPur59+6r4+Ph69QFlNBrVhg0b1G233dZgHaDuvffeBsdMT09XkZGRjdYHlKZpav78+c1qc2VlpTIajZ59vPXWWw3qfPfdd8pqtZ73uIDq1q1bo/ufPn26p87IkSObFZsQVwPpyRFC+Kz9+/eTk5NDcnIygwYN8pTX1tZy66238tFHHxEbG8tNN92EyWTyrH/77bfJzs72fD558iQTJkzg1KlTgLsnaejQoYwfP57IyEgAlFI8/fTTvP/++02OLz09vV6vUWPzi1555RXKy8vr1Zk4cSJDhgzxHPt8kpOTPcsZGRnU1NQ0OTYhrgaS5AghfNrzzz/P119/zY4dOzxzVACqq6tJSkoiMzOTzz//nEWLFnnWKaXqzQ964YUXKCwsBECv15OWlsbWrVtZt24d2dnZJCYmeurOmTOnybHt2rWr3uc+ffo0qJOXl+dZTk1NJSMjg7Vr17Jt2zZOnjzJnj17ePLJJxvdf9++fT3LNpuNffv2NTk2Ia4GcnWVEMJnhYSEeO4To2kaSUlJpKWledY/+uijniu4rr/++nrbnjhxwrP86aefepYtFgsvvfQSL730kqesrKzMs/z9999z+PBhunXrdtH4zr3CLCQkBKPR2KBO9+7dPcufffYZL730Ev3796d3797ExcUxYMAABgwY0Oj+27VrV+9zXU+UEMJNkhwhhM9KSEggICDA8zk4OLje+nN7On68zmazeZbrbkII7oRmzZo1Fzxubm5uk5KckpISz7LVam20ziOPPMLf//53KioqyMvLq3eJefv27Rk7diyzZ8+mf//+DbYNCQk57/GEEDJcJYTwYaGhofU+63S6C65vKVVVVU2qFxYW5lk+d97Nubp3786uXbuYOXMmffr0Qa/Xe9YVFhby3nvvMXLkSI4ePdpg29LS0vMeTwghSY4QQtClSxfPckJCAkqpC75++tOfNmm/HTt29CyXlZXhcDgarde9e3cWL17M/v37qa6uJjMzk1dffdWT8JSUlPCPf/yjwXZFRUX1Pnfo0KFJcQlxtZAkRwhx1Rs3bpxn+ciRI/zlL3/B5XLVq1NYWMibb77ZrGdFDRw4sN7nAwcONKjzwQcf8PHHH3uGz4xGIz179mTatGkEBgZ66uXm5jbYdv/+/Z5lo9HY6JCWEFczmZMjhLjqPfHEE7z99tueOS1PPvkky5cvp2/fvuh0OrKzs8nMzMTlcpGSktLk/Q4bNgyDweDpwdmxY0eDScQbNmxg2bJlWCwW+vXrR2RkJA6Hgx07dlBRUeGpd+4E5ToZGRme5aSkpHpJkRBCkhwhhCA6OpqPP/6YKVOmeK6IOnr0aKPzYM6dM3MxFouFm266ifXr1wOwceNG7rnnnkbrVlZW1ktaztWrVy9SU1Prlf34MviJEyc2OS4hrhaS5AghBDBixAgOHDjAa6+9xrp16zhw4ABlZWUEBgYSFxfHoEGDuOWWW5g0aVKz9nv//fd7kpy1a9dis9nqXRH20EMPER0dzVdffcWhQ4c4c+YMlZWVhISE0LNnTyZMmMDMmTMbXEmVlpbG8ePHAfdQ1fmSJyGuZvKATiGEaEUOh4Pu3bt75tSsXr2a//mf/7ns/T700EMsX74cgOnTp7Ny5crL3qcQ/kaSHCGEaGXvvPMOM2bMAGDo0KFs3br1svZXWFhI586dqaqqwmg0cuDAgSbdt0eIq41cXSWEEK3sF7/4hedKq23btnmekn6plixZ4rlXz69//WtJcIQ4D+nJEUIIIYRfkp4cIYQQQvglSXKEEEII4ZckyRFCCCGEX5IkRwghhBB+SZIcIYQQQvglSXKEEEII4ZckyRFCCCGEX5IkRwghhBB+SZIcIYQQQvil/w/fY/G81nBSFAAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3b-1.3 The convergence difference between the Forward Euler Method and the Crank-Nicolson (Trapezoid Rule)." + ], + "metadata": { + "id": "MbPgBJepqeDn" + } + }, + { + "cell_type": "markdown", + "source": [ + "The convergence difference between the Forward Euler Method and the Trapezoid Rule it is defined by their order of convergence.\n", + "\n", + "But **what is convergence?** In numerical methods, convergence refers to how quickly the numerical solution approaches the exact solution as you use smaller time steps.\n", + "\n", + "The **Forward Euler Method** is a first-order method, which means its **convergence is linear**. This way, when you reduce the step size $h$ in the Euler Method, the error in the approximation decreases linearly. Therefore, the Forward Euler Method is relatively less accurate for solving ODEs.\n", + "\n", + "Analogously the **Trapezoid Rule** is a second-order method, which means its **convergence is quadratic**.\n", + "This way, when you reduce the step size $h$ in the Trapezoid Rule, the error in the approximation decreases quadratically. This results in a **much faster convergence compared to the Euler Method.**" + ], + "metadata": { + "id": "xf-z6yaHrJZX" + } + }, + { + "cell_type": "markdown", + "source": [ + "Now, go back to the respective Forward Euler Method and Crank-Nicolson (Trapezoid Rule) codes change the step size $h$, and observe the graphical difference in both cases. **After that, come back and describe in a few sentences the difference you observed.**" + ], + "metadata": { + "id": "60otxH7hrJ6e" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Your Answer**" + ], + "metadata": { + "id": "6UiitI2_uAyH" + } + }, + { + "cell_type": "markdown", + "metadata": { + "id": "avlhWMB84eAe" + }, + "source": [ + "## 3c. Stochastic vs Deterministic Solution\n", + "Plot the stochastic solution and deterministic solution for the species profiles in the same plot starting with 1000 molecules of A. **Write a few sentences to explain what you observe.** Submit your answer on an attached pdf file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 316 + }, + "id": "-lmg13md6E1C", + "outputId": "fb997f24-9d4c-4c7a-956e-0e16999d81f5" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### BEGIN SOLUTION ###\n", + "\n", + "fig = plt.figure(figsize=(15, 4))\n", + "\n", + "# Creating a subplot\n", + "plt.subplot(1, 3, 1)\n", + "plt.title(\"Stochastic vs. deterministic\", fontsize=13, fontweight=\"bold\")\n", + "plt.plot(t, X_a, \"c\", label=r\"A$_{deterministic}$\", linewidth=3)\n", + "plt.plot(time, xa, \"k-.\", label=r\"A$_{stochastic}$\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of A molecules\", fontsize=15, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=15)\n", + "\n", + "plt.subplot(1, 3, 2)\n", + "plt.title(\"Stochastic vs. deterministic\", fontsize=13, fontweight=\"bold\")\n", + "plt.plot(t, X_b, \"r\", label=r\"B$_{deterministic}$\", linewidth=3)\n", + "plt.plot(time, xb, \"k-.\", label=r\"B$_{stochastic}$\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of B molecules\", fontsize=15, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=15)\n", + "\n", + "plt.subplot(1, 3, 3)\n", + "plt.title(\"Stochastic vs. deterministic\", fontsize=13, fontweight=\"bold\")\n", + "plt.plot(t, X_c, \"g\", label=r\"C$_{deterministic}$\", linewidth=3)\n", + "plt.plot(time, xc, \"k-.\", label=r\"C$_{stochastic}$\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of C molecules\", fontsize=15, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=15)\n", + "\n", + "plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9, wspace=0.4, hspace=0.4)\n", + "\n", + "### END SOLUTION ###" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i37i8E7r7MXE" + }, + "source": [ + "**Answer:** For N = 1000 molecules, we see that the profiles for the stochastic solution are similar to the deterministic solution with little noise. For even larger systems, the profiles will be even more accurate. Intuitively this is what we would expect; the random behavior becomes less important for large systems. In the next section, we will see that random behavior is important for small systems." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YhLRGavgfvHG" + }, + "source": [ + "## 3d. Effect of number of molecules in stochastic simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aesb6BjnDXxy" + }, + "source": [ + "\n", + "**How does changing the starting number of molecules affect the reaction profiles?** Run the Gillespie function with A = 100 and A = 1000 molecules and create a subplot for the species profile. Submit this answer in a few sentences on an attached pdf file." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 729 + }, + "id": "rA7OYZnLz6Oa", + "outputId": "e8a1f568-1b63-429d-9f5c-2ba12bc25099" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "### BEGIN SOLUTION ###\n", + "\n", + "# stochastic model for with 100 total molecules\n", + "x = gillespie(k1, k2, 100, 0, 0)\n", + "# stochastic model for with 1000 total molecules\n", + "y = gillespie(k1, k2, 1000, 0, 0)\n", + "\n", + "### END SOLUTION ###\n", + "\n", + "# creating a subplot for the two stochastic simulations\n", + "fig = plt.figure(figsize=(8, 8))\n", + "\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(x[0], x[1], \"-.\", label=r\"A\")\n", + "plt.plot(x[0], x[2], \"-.\", label=r\"B\")\n", + "plt.plot(x[0], x[3], \"-.\", label=r\"C\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "plt.title(\"N=100 molecules\", fontsize=14, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=13)\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(y[0], y[1], \"-.\", label=r\"A\")\n", + "plt.plot(y[0], y[2], \"-.\", label=r\"B\")\n", + "plt.plot(y[0], y[3], \"-.\", label=r\"C\")\n", + "leg = plt.legend(fontsize=13)\n", + "plt.subplots_adjust(hspace=0.5)\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number of molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "plt.title(\"N=1000 molecules\", fontsize=14, fontweight=\"bold\")\n", + "plt.xticks(fontsize=13)\n", + "plt.yticks(fontsize=13)\n", + "leg = plt.legend(fontsize=13)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GYu8xOxB2G0q" + }, + "source": [ + "**Answer:** For N = 100 molecules, we can see more noise in the species profile compared to N = 1000 molecules, where the profile is smoother and closer to the analytical solution. This reinforces our idea that stochastic modeling is important if the system of interest is small." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dS55dJKRH6_r" + }, + "source": [ + "## 4. Effect of rate constants k1 and k2\n", + "Plot reaction profiles using different rate constant values (using the same number of starting molecules. *Hint:* Change the value of one rate constant while keeping the other the same; this will make any changes obvious.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i_eHPDS6Dd5b" + }, + "source": [ + "**How does changing the rate constant affect the reaction profiles?** Submit this answer in a few sentences on an attached pdf file." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 725 + }, + "id": "9N5NTozx4pxA", + "outputId": "5858abf4-41d9-4ad4-e064-7a24c3c6b9fe" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "### BEGIN SOLUTION ###\n", + "\n", + "# stochastic model with 400 total molecules, k1 = 2 and k2 = 1\n", + "e = gillespie(2, 1, 400, 0, 0)\n", + "# stochastic model with 400 total molecules, k1 = 1 and k2 = 1\n", + "f = gillespie(1, 1, 400, 0, 0)\n", + "\n", + "### END SOLUTION ###\n", + "\n", + "# creating a subplot for the two stochastic simulations\n", + "fig = plt.figure(figsize=(8, 8))\n", + "\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(e[0], e[1], \"-.\", label=r\"A\")\n", + "plt.plot(e[0], e[2], \"-.\", label=r\"B\")\n", + "plt.plot(e[0], e[3], \"-.\", label=r\"C\")\n", + "leg = plt.legend(fontsize=15)\n", + "plt.title(\"k1 = 2 and k2 = 1\", fontsize=14, fontweight=\"bold\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "leg = plt.legend(fontsize=13)\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(f[0], f[1], \"-.\", label=r\"A\")\n", + "plt.plot(f[0], f[2], \"-.\", label=r\"B\")\n", + "plt.plot(f[0], f[3], \"-.\", label=r\"C\")\n", + "plt.subplots_adjust(hspace=0.5)\n", + "leg = plt.legend(fontsize=15)\n", + "plt.title(\"k1 = 1 and k2 = 1\", fontsize=14, fontweight=\"bold\")\n", + "plt.xlabel(\"Time (s)\", fontsize=15, fontweight=\"bold\")\n", + "plt.ylabel(\"Number molecules x$_i$\", fontsize=15, fontweight=\"bold\")\n", + "leg = plt.legend(fontsize=13)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T3wxijtF-6-q" + }, + "source": [ + "**Answer:** We see that for the top figure with higher k1, the maximum in B was reached faster and in a steeper way than the bottom figure with lower k1; this makes sense because a higher k1 means a higher probability of the first reaction, meaning faster conversion of A to B molecules. With the same logic, we can explain the decay in A and growth in C is also fast in the top figure compared to the bottom figure.\n", + "\n", + "All of these characteristics would also be expected in the deterministic model. This exercise shows us the beauty of the Gillespie algorithm and how it can capture features of deterministic models while keeping the random behavior of the system into account." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LhKZC4yM45J6" + }, + "source": [ + "## 5. Final Discussion" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H9fS7IBv4-jg" + }, + "source": [ + "Through this project, we aimed to highlight the importance of stochastic (random) modeling (aka KMC simulations in the present time). We used the famous Gillespie algorithm for stochastic modeling and compared it to well-known deterministic reaction engineering models for a simple two irreversible reactions constant volume batch system. it is also presented in the notebook two different options to solve differential equations through numerical coding. Besides that, we showed that the stochastic solution has more noise in the profiles for smaller systems because of the random behavior of the molecules moving in the gas phase and colliding with each other. We showed that this random behavior becomes less critical for larger systems, and profiles were closer to deterministic models as captured by the Gillespie algorithm." + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file