Optimizing_a_Cantilever_Beam_Design_with_OpenMDAO_A_Step_by_Step_Python_Tutorial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOWOzTlJg4srYO4nVLbl88C",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jman4162/Engineering-System-Optimization-MDAO-/blob/main/Optimizing_a_Cantilever_Beam_Design_with_OpenMDAO_A_Step_by_Step_Python_Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Optimizing a Cantilever Beam Design with OpenMDAO: A Step-by-Step Python Tutorial\n",
        "\n",
        "Name: John Hodge\n",
        "\n",
        "Date: 04/21/24"
      ],
      "metadata": {
        "id": "lRTSMldcD-jB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "OpenMDAO is an open-source high-performance computing platform for systems analysis and multidisciplinary optimization, developed by NASA. It is particularly well-suited for solving complex engineering problems involving multiple disciplines. In this tutorial, we will go through a basic example of how to use [OpenMDAO](https://openmdao.org/) to optimize an engineering system design. Specifically, we will focus on optimizing the design of a simple cantilever beam to minimize its mass under constraints on its maximum displacement when a load is applied at the end.\n",
        "\n",
        "## Step 1: Define the Problem\n",
        "\n",
        "For our example, the cantilever beam is defined by its length ($L$), width ($b$), and height ($h$). The goal is to minimize the mass of the beam, which is directly proportional to its volume (assuming constant material density), subject to constraints on its maximum displacement under a given load.\n",
        "\n",
        "The mass of the beam can be calculated as:\n",
        "\n",
        "$ \\text{Mass} = \\rho \\times L \\times b \\times h $\n",
        "\n",
        "where \\( $\\rho$ \\) is the material density (constant).\n",
        "\n",
        "The displacement ( $d$ ) at the free end of the beam under a load \\( $P$ \\) can be approximated by:\n",
        "\n",
        "$ d = \\frac{4 \\times P \\times L^3}{E \\times b \\times h^3} $\n",
        "\n",
        "where \\($E$\\) is the modulus of elasticity (constant)."
      ],
      "metadata": {
        "id": "31QVYXwwDyea"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Initialize Environment and Import Libraries"
      ],
      "metadata": {
        "id": "eM2UfnP2EJpU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 236,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H0iyhz-FrU3m",
        "outputId": "6891b172-315e-4947-bf8b-34c9d8024849"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: openmdao in /usr/local/lib/python3.10/dist-packages (3.31.1)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (3.7.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.25.2)\n",
            "Requirement already satisfied: networkx>=2.0 in /usr/local/lib/python3.10/dist-packages (from openmdao) (3.3)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from openmdao) (1.11.4)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from openmdao) (2.31.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from openmdao) (24.0)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.2.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (4.51.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.4.5)\n",
            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (9.4.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (3.1.2)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (2.8.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->openmdao) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->openmdao) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->openmdao) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->openmdao) (2024.2.2)\n"
          ]
        }
      ],
      "source": [
        "!pip install openmdao matplotlib numpy"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import openmdao.api as om\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "YxnfLRHsrvPL"
      },
      "execution_count": 237,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define Engineering System Components"
      ],
      "metadata": {
        "id": "7pee4RH8QoAR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class BeamMass(om.ExplicitComponent):\n",
        "    def setup(self):\n",
        "        # Inputs\n",
        "        self.add_input('rho', val=7850)  # Material density\n",
        "        self.add_input('L', val=2.0)    # Length\n",
        "        self.add_input('b', val=5.0)    # Width\n",
        "        self.add_input('h', val=5.0)    # Height\n",
        "\n",
        "        # Outputs\n",
        "        self.add_output('mass', val=0.0)\n",
        "\n",
        "        # Partial derivatives\n",
        "        self.declare_partials(of='mass', wrt='b')\n",
        "        self.declare_partials(of='mass', wrt='h')\n",
        "\n",
        "    def compute(self, inputs, outputs):\n",
        "        rho = inputs['rho']\n",
        "        L = inputs['L']\n",
        "        b = inputs['b']\n",
        "        h = inputs['h']\n",
        "        outputs['mass'] = rho * L * b * h\n",
        "\n",
        "    def compute_partials(self, inputs, partials):\n",
        "        rho = inputs['rho']\n",
        "        L = inputs['L']\n",
        "        b = inputs['b']\n",
        "        h = inputs['h']\n",
        "        partials['mass', 'b'] = rho * L * h\n",
        "        partials['mass', 'h'] = rho * L * b\n"
      ],
      "metadata": {
        "id": "8FfkNrSdryB9"
      },
      "execution_count": 238,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define the Constraint\n"
      ],
      "metadata": {
        "id": "crKav11_Q0-1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding a scaling factor for numerical reasons\n",
        "scale_fac = 1e12"
      ],
      "metadata": {
        "id": "9DBXK6GEVvh1"
      },
      "execution_count": 239,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class BeamDisplacement(om.ExplicitComponent):\n",
        "    def setup(self):\n",
        "        # Inputs\n",
        "        self.add_input('P', val=1000)    # Applied load\n",
        "        self.add_input('L', val=2.0)    # Length\n",
        "        self.add_input('b', val=5.0)    # Width\n",
        "        self.add_input('h', val=5.0)    # Height\n",
        "        self.add_input('E', val=2.1e11)    # Modulus of elasticity\n",
        "\n",
        "        # Outputs\n",
        "        self.add_output('disp', val=0.0)\n",
        "\n",
        "        # Partial derivatives\n",
        "        self.declare_partials(of='disp', wrt=['b', 'h'])\n",
        "\n",
        "    def compute(self, inputs, outputs):\n",
        "        P = inputs['P']\n",
        "        L = inputs['L']\n",
        "        b = inputs['b']\n",
        "        h = inputs['h']\n",
        "        E = inputs['E']\n",
        "        outputs['disp'] = (4 * P * L**3) / (E * b * h**3) * scale_fac\n",
        "\n",
        "    def compute_partials(self, inputs, partials):\n",
        "        P = inputs['P']\n",
        "        L = inputs['L']\n",
        "        b = inputs['b']\n",
        "        h = inputs['h']\n",
        "        E = inputs['E']\n",
        "        partials['disp', 'b'] = - (4 * P * L**3) / (E * b**2 * h**3) * scale_fac\n",
        "        partials['disp', 'h'] = -3 * (4 * P * L**3) / (E * b * h**4) * scale_fac\n"
      ],
      "metadata": {
        "id": "5ivOTyhBr03o"
      },
      "execution_count": 240,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setup the Optimization Problem\n"
      ],
      "metadata": {
        "id": "1aea8n3gQ8R9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a problem and model\n",
        "prob = om.Problem()\n",
        "model = prob.model\n",
        "\n",
        "# Add components\n",
        "model.add_subsystem('comp', BeamMass(), promotes=['b', 'h'])\n",
        "model.add_subsystem('disp', BeamDisplacement(), promotes=['b', 'h'])\n",
        "\n",
        "# Setup the optimizer\n",
        "prob.driver = om.ScipyOptimizeDriver()\n",
        "prob.driver.options['optimizer'] = 'SLSQP'\n",
        "prob.driver.options['tol'] = 1e-9\n",
        "prob.driver.options['disp'] = True\n",
        "prob.driver.options['maxiter'] = 1000\n",
        "\n",
        "print(prob.driver.options)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7W_lJIr2r29q",
        "outputId": "2c1cb79a-4d46-4c6c-bc37-bcb7c3d78f80"
      },
      "execution_count": 241,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=======================  =======  =======================  ================  =======================\n",
            "Option                   Default  Acceptable Values        Acceptable Types  Description            \n",
            "=======================  =======  =======================  ================  =======================\n",
            "debug_print              []       ['desvars', 'nl_cons',   ['list']          List of what type of   \n",
            "                                  'ln_cons', 'objs',                         Driver variables to    \n",
            "                                  'totals']                                  print at each          \n",
            "                                                                             iteration.             \n",
            "disp                     True     [True, False]            ['bool']          Set to False to prevent\n",
            "                                                                             printing of Scipy      \n",
            "                                                                             convergence messages   \n",
            "invalid_desvar_behavior  warn     ['warn', 'raise',        N/A               Behavior of driver if  \n",
            "                                  'ignore']                                  the initial value of a \n",
            "                                                                             design variable exceeds\n",
            "                                                                             its bounds. The default\n",
            "                                                                             value may beset using  \n",
            "                                                                             the `OPENMDAO_INVALID_D\n",
            "                                                                             ESVAR_BEHAVIOR`        \n",
            "                                                                             environment variable to\n",
            "                                                                             one of the valid       \n",
            "                                                                             options.               \n",
            "maxiter                  1000     N/A                      N/A               Maximum number of      \n",
            "                                                                             iterations.            \n",
            "optimizer                SLSQP    ['shgo', 'CG', 'TNC',    N/A               Name of optimizer to   \n",
            "                                  'trust-constr',                            use                    \n",
            "                                  'Powell',                                                         \n",
            "                                  'dual_annealing', 'diff                                           \n",
            "                                  erential_evolution',                                              \n",
            "                                  'SLSQP', 'L-BFGS-B',                                              \n",
            "                                  'COBYLA', 'Nelder-                                                \n",
            "                                  Mead', 'basinhopping',                                            \n",
            "                                  'BFGS', 'Newton-CG']                                              \n",
            "singular_jac_behavior    warn     ['error', 'warn',        N/A               Defines behavior of a  \n",
            "                                  'ignore']                                  zero row/col check     \n",
            "                                                                             after first call       \n",
            "                                                                             tocompute_totals:error \n",
            "                                                                             - raise an error.warn -\n",
            "                                                                             raise a warning.ignore \n",
            "                                                                             - don't perform check. \n",
            "singular_jac_tol         1e-16    N/A                      N/A               Tolerance for zero     \n",
            "                                                                             row/column check.      \n",
            "tol                      1e-09    N/A                      N/A               Tolerance for          \n",
            "                                                                             termination. For       \n",
            "                                                                             detailed control, use  \n",
            "                                                                             solver-specific        \n",
            "                                                                             options.               \n",
            "=======================  =======  =======================  ================  =======================\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define the Design Variables, Objective, and Constraints\n"
      ],
      "metadata": {
        "id": "GVEIvu1KRIMr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Design variables\n",
        "model.add_design_var('b', lower=1.0, upper=10.0)\n",
        "model.add_design_var('h', lower=1.0, upper=10.0)\n",
        "\n",
        "# Objective\n",
        "model.add_objective('comp.mass')\n",
        "\n",
        "# Constraints\n",
        "max_disp = 200\n",
        "model.add_constraint('disp.disp', upper=max_disp) # Limit maximum displacement\n"
      ],
      "metadata": {
        "id": "pNMuTqtxsF6b"
      },
      "execution_count": 242,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setup Problem and Define Constants"
      ],
      "metadata": {
        "id": "ZyODPXufRP4Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Set constant values\n",
        "model.set_input_defaults('comp.rho', 7850)  # density of steel in kg/m^3\n",
        "model.set_input_defaults('comp.L', 2.0)     # length of the beam in meters\n",
        "model.set_input_defaults('disp.P', 1000)    # load in newtons\n",
        "model.set_input_defaults('disp.E', 2.1e11)  # modulus of elasticity of steel in Pascals\n",
        "\n",
        "# Setup the problem\n",
        "prob.setup()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ll1p5BOPsIKs",
        "outputId": "e57c398f-905c-4f90-8006-0e2bef857ef5"
      },
      "execution_count": 243,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<openmdao.core.problem.Problem at 0x783a61798790>"
            ]
          },
          "metadata": {},
          "execution_count": 243
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get and print initial values\n",
        "b_init = prob.get_val('disp.b')\n",
        "h_init = prob.get_val('disp.h')\n",
        "\n",
        "(b_init, h_init)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lZcLz4ZW9Uah",
        "outputId": "17ed1cc5-033c-44d9-ba34-30ae67170610"
      },
      "execution_count": 244,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([5.]), array([5.]))"
            ]
          },
          "metadata": {},
          "execution_count": 244
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Investigate the initial values\n",
        "print(\"Initial width  (b): {:.2f} m\".format(b_init[0]))\n",
        "print(\"Initial height (h): {:.2f} m\".format(h_init[0]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fRRS2KqK6OIz",
        "outputId": "9d1ad9f8-b37b-40c9-b6e3-10230be2c675"
      },
      "execution_count": 245,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial width  (b): 5.00 m\n",
            "Initial height (h): 5.00 m\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### View outputs of initial system parameters"
      ],
      "metadata": {
        "id": "mokesNtFR5a8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Run the model to compute initial outputs\n",
        "prob.run_model()\n",
        "\n",
        "# Get initial mass and displacement\n",
        "initial_mass = prob.get_val('comp.mass')\n",
        "initial_disp = prob.get_val('disp.disp')\n",
        "\n",
        "# Output the initial values\n",
        "print(\"Initial Mass:\", initial_mass, \"kg\")\n",
        "print(\"Initial Displacement:\", initial_disp, \"meters\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vveof3DtC5gI",
        "outputId": "796d9bc3-141c-4edf-d68f-4cf4e1c0b620"
      },
      "execution_count": 246,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial Mass: [392500.] kg\n",
            "Initial Displacement: [243.80952381] meters\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "(b_init, h_init, initial_mass, initial_disp)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t3jURSw8dV58",
        "outputId": "fea70a70-6c44-4f42-ec12-09d1793ab5d4"
      },
      "execution_count": 247,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([5.]), array([5.]), array([392500.]), array([243.80952381]))"
            ]
          },
          "metadata": {},
          "execution_count": 247
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make a copy of initial_mass and initial_disp\n",
        "initial_mass_copy = initial_mass.copy()\n",
        "initial_disp_copy = initial_disp.copy()"
      ],
      "metadata": {
        "id": "J7RHXsr_W8dh"
      },
      "execution_count": 248,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Run the Optimization"
      ],
      "metadata": {
        "id": "e2kKswoDRTPO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Run the optimizer\n",
        "prob.run_driver()\n",
        "\n",
        "# Run the model to compute values\n",
        "prob.run_model()\n",
        "\n",
        "# Get and print results\n",
        "b_opt = prob.get_val('disp.b')\n",
        "h_opt = prob.get_val('disp.h')\n",
        "mass_opt = prob.get_val('comp.mass')\n",
        "disp_opt = prob.get_val('disp.disp')\n",
        "\n",
        "print(\"Optimized width (b): {:.2f} m\".format(b_opt[0]))\n",
        "print(\"Optimized height (h): {:.2f} m\".format(h_opt[0]))\n",
        "print(\"Optimized mass: {:.2f} kg\".format(mass_opt[0]))\n",
        "print(\"Resulting displacement: {:.4e} m\".format(disp_opt[0]))\n",
        "\n",
        "print('mass_opt:', mass_opt)\n",
        "print('disp_opt:', disp_opt)\n",
        "\n",
        "(b_opt, h_opt, mass_opt, disp_opt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "13CxNBG-sJ0-",
        "outputId": "ac416854-0909-4e24-9029-d78866ebad2e"
      },
      "execution_count": 249,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimization terminated successfully    (Exit mode 0)\n",
            "            Current function value: 143673.59340666395\n",
            "            Iterations: 11\n",
            "            Function evaluations: 7\n",
            "            Gradient evaluations: 7\n",
            "Optimization Complete\n",
            "-----------------------------------\n",
            "Optimized width (b): 1.00 m\n",
            "Optimized height (h): 9.15 m\n",
            "Optimized mass: 143673.59 kg\n",
            "Resulting displacement: 1.9884e+02 m\n",
            "mass_opt: [143673.59340666]\n",
            "disp_opt: [198.83772194]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([1.]),\n",
              " array([9.15118429]),\n",
              " array([143673.59340666]),\n",
              " array([198.83772194]))"
            ]
          },
          "metadata": {},
          "execution_count": 249
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Analyze results"
      ],
      "metadata": {
        "id": "B98VRppzR_81"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Values - assuming these are arrays of data points; for a single run, you can use lists of single values\n",
        "b_init = float(b_init)\n",
        "h_init = float(h_init)\n",
        "initial_mass = float(initial_mass_copy)\n",
        "initial_disp = float(initial_disp)\n",
        "\n",
        "b_values = [b_init, b_opt]  # Example values from lower bound to optimized\n",
        "h_values = [h_init, h_opt]  # Example values from lower bound to optimized\n",
        "mass_values = [initial_mass, mass_opt]  # Initial and optimized masses\n",
        "disp_values = [initial_disp, disp_opt]  # Initial and optimized displacements\n",
        "\n",
        "# Plot width vs. mass\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(b_init, initial_mass_copy[0], 'o', label='Initial')\n",
        "plt.plot(b_opt[0], mass_opt[0], 'o', label='Optimized')\n",
        "plt.title('Width vs. Mass')\n",
        "plt.xlabel('Width (m)')\n",
        "plt.ylabel('Mass (kg)')\n",
        "plt.grid(True)\n",
        "plt.legend(loc='best')\n",
        "\n",
        "# Plot height vs. displacement\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(h_init, initial_disp_copy[0], 'o', label='Initial')\n",
        "plt.plot(h_opt[0], disp_opt[0], 'o', label='Optimized')\n",
        "plt.title('Height vs. Displacement')\n",
        "plt.xlabel('Height (m)')\n",
        "plt.ylabel('Displacement (scaled m)')\n",
        "plt.grid(True)\n",
        "plt.legend(loc='best')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 650
        },
        "id": "Y4NGU35duqa6",
        "outputId": "97974cc3-a908-48e5-9318-0d9a5dfe32a2"
      },
      "execution_count": 250,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-250-2416891d5e19>:2: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  b_init = float(b_init)\n",
            "<ipython-input-250-2416891d5e19>:3: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  h_init = float(h_init)\n",
            "<ipython-input-250-2416891d5e19>:4: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  initial_mass = float(initial_mass_copy)\n",
            "<ipython-input-250-2416891d5e19>:5: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  initial_disp = float(initial_disp)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Simulated data based on the optimization scenario"
      ],
      "metadata": {
        "id": "VfnX_ATkRwf3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assuming material properties and initial settings\n",
        "rho = 7850  # density of steel in kg/m^3\n",
        "L = 2.0  # length of the beam in meters\n",
        "P = 1000  # load in newtons\n",
        "E = 2.1e11  # modulus of elasticity of steel in Pascals\n",
        "\n",
        "# Simulated optimized values (normally obtained from optimization results)\n",
        "# b_opt = b_opt[0]  # optimized width in meters\n",
        "# h_opt = h_opt[0]  # optimized height in meters\n",
        "mass_opt = rho * L * b_opt[0] * h_opt[0]  # optimized mass\n",
        "disp_opt = (4 * P * L**3) / (E * b_opt[0] * h_opt[0]**3) * scale_fac # optimized displacement\n",
        "\n",
        "# Simulated ranges for width and height from initial to optimized\n",
        "b_values = np.linspace(0.1, 10, 50)\n",
        "h_values = np.linspace(0.1, 10, 50)\n",
        "mass_values = rho * L * b_values * h_opt[0]\n",
        "disp_values = (4 * P * L**3) / (E * b_values * h_opt[0]**3) * scale_fac\n",
        "\n",
        "(h_opt[0], h_opt[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iueegr5FsMIg",
        "outputId": "99a3de14-a04c-44bf-db52-77777cab65a0"
      },
      "execution_count": 251,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(9.151184293418085, 9.151184293418085)"
            ]
          },
          "metadata": {},
          "execution_count": 251
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot width vs. mass\n",
        "plt.figure(figsize=(12, 6))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(b_values, mass_values, 'o-', label=f'Height={h_opt} m')\n",
        "plt.plot(b_opt, mass_opt, 'r*', label='Optimized Value', markersize=10)\n",
        "plt.title('Width vs. Mass')\n",
        "plt.xlabel('Width (m)')\n",
        "plt.ylabel('Mass (kg)')\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Plot height vs. displacement\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.loglog(h_values, (4 * P * L**3) / (E * b_opt[0] * h_values**3) * scale_fac, 'o-', label=f'Width={b_opt} m')\n",
        "plt.loglog(h_opt, disp_opt, 'r*', label='Optimized Value', markersize=10)\n",
        "plt.title('Height vs. Displacement')\n",
        "plt.xlabel('Height (m)')\n",
        "plt.ylabel('Displacement (m)')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 491
        },
        "id": "9mZHsn4jHYKV",
        "outputId": "6eb8c90d-9964-4a4e-f65d-b158ddd298e4"
      },
      "execution_count": 252,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD3I0lEQVR4nOzdd1gUV9sG8Ht2KUtdBWkqKmLFgqig2DFiS4gaE7FjL8EYW4opKokliZpoEuxR7C22kIIaS2wIWEhE1FiwRFFUlF535/uDj31dlt6Gcv+ui/fNzpw9++yMA3OeOUUQRVEEERERERERERFROZJJHQAREREREREREVU/TEoREREREREREVG5Y1KKiIiIiIiIiIjKHZNSRERERERERERU7piUIiIiIiIiIiKicsekFBERERERERERlTsmpYiIiIiIiIiIqNwxKUVEREREREREROWOSSkiIiIiIiIiIip3TEoRUak7efIkBEHAyZMnCyzbo0cP9OjRo1D19ujRAy1btixZcERERET5GDNmDBo0aFDs95qampZuQJVIUe4BiyMgIACCIODu3btlUj8RlT8mpYhIy549eyAIAg4cOKCzz9nZGYIg4MSJEzr76tWrh06dOpX48x89eoQFCxYgPDy8xHVVBD169IAgCGjcuHGu+48ePQpBECAIAn7++edyjo6IiKhyyk5OXLhwIdf9Ff1BVnJyMhYsWFBmyZvScPfuXc09iiAI0NfXR61atdCpUyd88sknuH//vtQh0isiIyOxYMECJuyo0mFSioi0dOnSBQBw5swZre3x8fGIiIiAnp4ezp49q7XvwYMHePDggea93bp1Q0pKCrp161bkz3/06BH8/PyqTFIKABQKBW7duoXQ0FCdfdu3b4dCoZAgKiIiIsrN+vXrcePGjTL9jOTkZPj5+VXopFS2YcOGYevWrfjpp5/w+eefo2HDhlixYgWaN2+OXbt2aZUtyT0glUxkZCT8/PyYlKJKR0/qAIioYqlduzYcHBx0klLBwcEQRRHvvPOOzr7s19lJKZlMxkTLKxwdHZGZmYmdO3fCzc1Nsz01NRUHDhzA66+/jn379kkYIREREWXT19eXOoQKpW3bthg5cqTWtnv37qF3797w8fFB8+bN4ezsDID3gERUdOwpRUQ6unTpgsuXLyMlJUWz7ezZs2jRogX69euH8+fPQ61Wa+0TBAGdO3cGkPd8AuvWrYOjoyOMjIzg5uaG06dPa+0/efIkXF1dAQBjx47VdBcPCAjQKhcZGQkPDw8YGxujTp06+Oabbwr8Ti1btoSHh4fOdrVajTp16uDtt9/WbNu1axfatWsHMzMzmJubo1WrVli5cmWBn5GfYcOGYffu3VrHLTAwEMnJyRgyZIhO+Xv37uHdd99F06ZNYWRkBEtLS7zzzjs6T78yMjLg5+eHxo0bQ6FQwNLSEl26dMHRo0c1ZR4/foyxY8eibt26MDQ0hJ2dHQYMGMAnaUREVO1s27YN7dq1g5GRESwsLDB06FA8ePBAq0xuc0o9f/4co0aNgrm5OWrUqAEfHx/8/fffud6nAMDDhw8xcOBAmJqawsrKCnPmzIFKpQKQNSzOysoKAODn56e531mwYEGuMV+4cAGCIGDz5s06+w4fPgxBEPDrr78CABISEjBjxgw0aNAAhoaGsLa2hqenJy5dulTEI5W/+vXrIyAgAOnp6Vr3YbndA968eRODBw+Gra0tFAoF6tati6FDhyIuLk5TRhAETJs2Ddu3b0fTpk2hUCjQrl07nDp1qsBYDh06hNdffx21a9eGoaEhHB0d8eWXX2qO96tCQkLQv39/1KxZEyYmJmjdurXOPd7169fx9ttvw8LCAgqFAu3bt8cvv/yiVSZ7+OiZM2cwffp0WFlZoUaNGpg8eTLS09Px8uVLjB49GjVr1kTNmjXx4YcfQhRFrTrUajVWrFiBFi1aQKFQwMbGBpMnT8aLFy+0yjVo0ABvvPEGzpw5Azc3NygUCjRs2BBbtmzRiuedd94BAHh4eGj+TVWGnnhETEoRkY4uXbogIyMDISEhmm1nz55Fp06d0KlTJ8TFxSEiIkJrX7NmzWBpaZlnnT/99BMmT54MW1tbfPPNN+jcuTPefPNNrRvB5s2b44svvgAATJo0CVu3bsXWrVu1uoC/ePECffv2hbOzM5YvX45mzZrho48+wh9//JHvd/L29sapU6fw+PFjre1nzpzBo0ePMHToUABZczwNGzYMNWvWxNdff42vvvoKPXr00BmyWFTDhw9HdHS01s3Bjh078Nprr8Ha2lqnfFhYGM6dO4ehQ4fi+++/x5QpU3Ds2DH06NEDycnJmnILFiyAn58fPDw88OOPP+LTTz9FvXr1tG4+Bw8ejAMHDmDs2LFYtWoVpk+fjoSEBM4FQURElV5cXByePXum85ORkaFTdtGiRRg9ejQaN26Mb7/9FjNmzMCxY8fQrVs3vHz5Ms/PUKvV8PLyws6dO+Hj44NFixYhOjoaPj4+uZZXqVTo06cPLC0tsWzZMnTv3h3Lly/HunXrAABWVlZYvXo1AGDQoEGa+5233nor1/rat2+Phg0bYs+ePTr7du/ejZo1a6JPnz4AgClTpmD16tUYPHgwVq1ahTlz5sDIyAjXrl3L9zgWh7u7OxwdHbUehOWUnp6OPn364Pz583jvvffg7++PSZMm4c6dOzrH/K+//sKMGTMwcuRIfPHFF3j+/Dn69u2rdc+Zm4CAAJiammLWrFlYuXIl2rVrh3nz5uHjjz/WKnf06FF069YNkZGReP/997F8+XJ4eHhoEnoAcPXqVXTs2BHXrl3Dxx9/jOXLl8PExAQDBw7Mdb7V9957Dzdv3oSfnx/efPNNrFu3Dp9//jm8vLygUqmwePFidOnSBUuXLsXWrVu13jt58mR88MEH6Ny5M1auXImxY8di+/bt6NOnj86/31u3buHtt9+Gp6cnli9fjpo1a2LMmDG4evUqgKxhk9OnTwcAfPLJJ5p/U82bN8/32BFVCCIRUQ5Xr14VAYhffvmlKIqimJGRIZqYmIibN28WRVEUbWxsRH9/f1EURTE+Pl6Uy+XixIkTNe8/ceKECEA8ceKEKIqimJ6eLlpbW4tt2rQR09LSNOXWrVsnAhC7d++u2RYWFiYCEDdt2qQTV/fu3UUA4pYtWzTb0tLSRFtbW3Hw4MH5fqcbN26IAMQffvhBa/u7774rmpqaisnJyaIoiuL7778vmpubi5mZmQUcpcLp3r272KJFC1EURbF9+/bi+PHjRVEUxRcvXogGBgbi5s2bNcdr7969mvdlx/Oq4OBgne/v7Owsvv7663l+/osXL0QA4tKlS0vl+xAREVUEmzZtEgHk+5P991cURfHu3buiXC4XFy1apFXPlStXRD09Pa3tPj4+Yv369TWv9+3bJwIQV6xYodmmUqnEnj176tyz+Pj4iADEL774QutzXFxcxHbt2mleP336VAQgzp8/v1Dfd+7cuaK+vr4YGxur2ZaWlibWqFFDHDdunGabUqkUfX19C1VnQaKiogq8hxgwYIAIQIyLixNFUfce8PLlyzr3OLnJPmcXLlzQbLt3756oUCjEQYMGabZln/eoqCjNttzumSZPniwaGxuLqampoiiKYmZmpujg4CDWr19ffPHihVZZtVqt+e/XXntNbNWqleZ92fs7deokNm7cWCeOPn36aL3f3d1dFARBnDJlimZbZmamWLduXa373dOnT4sAxO3bt2vFEhQUpLO9fv36IgDx1KlTmm0xMTGioaGhOHv2bM22vXv3ah17osqCPaWISEfz5s1haWmpmSvq77//RlJSkmZ1vU6dOml6DgUHB0OlUmnmk8rNhQsXEBMTgylTpsDAwECzfcyYMVAqlUWKzdTUVGteAwMDA7i5ueHOnTv5vq9JkyZo06YNdu/erdmmUqnw888/w8vLC0ZGRgCAGjVqICkpKd+nfsU1fPhw7N+/H+np6fj5558hl8sxaNCgXMtmxwNkDdF7/vw5GjVqhBo1amj1gqpRowauXr2Kmzdv5lmPgYEBTp48qdMdnIiIqLLz9/fH0aNHdX5at26tVW7//v1Qq9UYMmSIVo8qW1tbNG7cONeVhbMFBQVBX18fEydO1GyTyWTw9fXN8z1TpkzRet21a9cC71Xy4+3tjYyMDOzfv1+z7ciRI3j58iW8vb0122rUqIGQkBA8evSo2J9VFKampgCyhg3mJvs+7/Dhw1o9vXPj7u6Odu3aaV7Xq1cPAwYMwOHDh3Mdipft1XumhIQEPHv2DF27dkVycjKuX78OALh8+TKioqIwY8YM1KhRQ+v9giAAAGJjY3H8+HEMGTJEU8+zZ8/w/Plz9OnTBzdv3sTDhw+13jt+/HjN+wGgQ4cOEEUR48eP12yTy+Vo37691vnfu3cvlEolPD09tf49tmvXDqampjr/Hp2cnNC1a1fNaysrKzRt2rRE/6aIKopqnZQ6deoUvLy8ULt2bQiCgIMHDxa5DlEUsWzZMjRp0gSGhoaoU6cOFi1aVPrBEpUjQRDQqVMnzdxRZ8+ehbW1NRo1agRAOymV/f/5JaXu3bsHAGjcuLHWdn19fTRs2LBIsdWtW1frjz8A1KxZs1AJF29vb5w9e1ZzQ3Hy5EnExMRo3cy9++67aNKkCfr164e6deti3LhxCAoKKlKMecmeP+GPP/7A9u3b8cYbb8DMzCzXsikpKZg3bx7s7e1haGiIWrVqwcrKCi9fvtSag+GLL77Ay5cv0aRJE7Rq1QoffPAB/vnnH81+Q0NDfP311/jjjz9gY2ODbt264ZtvvtEZxkhERFQZubm5oVevXjo/NWvW1Cp38+ZNiKKIxo0bw8rKSuvn2rVriImJyfMz7t27Bzs7OxgbG2ttz74vykmhUGjmjMpW2HuVvDg7O6NZs2ZaD9d2796NWrVqoWfPnppt33zzDSIiImBvbw83NzcsWLCgTBMXiYmJAJDn/YyDgwNmzZqFDRs2oFatWujTpw/8/f217mWy5bxPBLIeKiYnJ+Pp06d5xnD16lUMGjQISqUS5ubmsLKy0jzAzP6c27dvA8iaYzQvt27dgiiK+Pzzz3X+jcyfPx8AdP6d1KtXT+t1dhLO3t5eZ/ur5//mzZuIi4uDtbW1zmclJiYW+DlAyf9NEVUU1Xr1vaSkJDg7O2PcuHF5juEuyPvvv48jR45g2bJlaNWqFWJjYxEbG1vKkRKVvy5duiAwMBBXrlzRzCeVrVOnTvjggw/w8OFDnDlzBrVr1y5ycqm45HJ5rtvFHJNH5sbb2xtz587F3r17MWPGDOzZswdKpRJ9+/bVlLG2tkZ4eDgOHz6MP/74A3/88Qc2bdqE0aNH5zrBaFHY2dmhR48eWL58Oc6ePZvvinvvvfceNm3ahBkzZsDd3R1KpRKCIGDo0KFak6V369YNt2/fxqFDh3DkyBFs2LAB3333HdasWYMJEyYAAGbMmAEvLy8cPHgQhw8fxueff44lS5bg+PHjcHFxKdF3IiIiqgzUajUEQcAff/yR671Edo+f0pDXvUpJeXt7Y9GiRXj27BnMzMzwyy+/YNiwYdDT+1+TbsiQIejatSsOHDiAI0eOYOnSpfj666+xf/9+9OvXr9RjioiIgLW1NczNzfMss3z5cowZM0ZzrzJ9+nQsWbIE58+fR926dUv0+S9fvkT37t1hbm6OL774Ao6OjlAoFLh06RI++ugjrXumgmSXnTNnjmaOrpxyJiLzOte5bX/1XlWtVsPa2hrbt2/P9f05k5oluf8lquiqdVKqX79++f5yTktLw6effoqdO3fi5cuXaNmyJb7++mv06NEDAHDt2jWsXr0aERERaNq0KYCspwFEVUF2z6czZ87g7NmzmDFjhmZfu3btYGhoiJMnT2pWMclP/fr1AWQ9FXr1aV5GRgaioqI0ywgD0OkFVZocHBzg5uaG3bt3Y9q0adi/fz8GDhwIQ0NDrXIGBgbw8vKCl5cX1Go13n33Xaxduxaff/55nk9FC2v48OGYMGECatSoke9x+/nnn+Hj44Ply5drtqWmpuY6EauFhQXGjh2LsWPHIjExEd26dcOCBQs0SSkAcHR0xOzZszF79mzcvHkTbdq0wfLly7Ft27YSfR8iIqLKwNHREaIowsHBAU2aNCnSe+vXr48TJ04gOTlZq7fUrVu3ih1Pce53vL294efnh3379sHGxgbx8fGahVpeZWdnh3fffRfvvvsuYmJi0LZtWyxatKjUk1LBwcG4ffu21rQKeWnVqhVatWqFzz77DOfOnUPnzp2xZs0aLFy4UFMmt6kI/v33XxgbG+skabKdPHkSz58/x/79+7UWxomKitIq5+joCCAridarV69c68p+wKqvr59nmdLi6OiIP//8E507d9YaflgSZXkPTVSWqvXwvYJMmzYNwcHB2LVrF/755x+888476Nu3r+YXZmBgIBo2bIhff/0VDg4OaNCgASZMmMCeUlQltG/fHgqFAtu3b8fDhw+1ekoZGhqibdu28Pf3R1JSUr5D97LrsrKywpo1a5Cenq7ZHhAQoJNkMTExAYB8V8EpCW9vb5w/fx4bN27Es2fPtIbuAVlLPr9KJpNp5qVIS0sDkJVMu379OqKjo4v8+W+//Tbmz5+PVatWac2vlZNcLtd5+vXDDz/ozKmQM15TU1M0atRIE2tycjJSU1O1yjg6OsLMzExThoiIqKp76623IJfL4efnp/P3VRRFnb+nr8peDW39+vWabWq1Gv7+/sWOJzu5VZT7nebNm6NVq1bYvXs3du/eDTs7O61EjEql0hkWZ21tjdq1a2v9zX/27BmuX79e4BxP+bl37x7GjBkDAwMDfPDBB3mWi4+PR2Zmpta2Vq1aQSaT6dyHBAcHa82b+eDBAxw6dAi9e/cusEfSq+c0PT0dq1at0irXtm1bODg4YMWKFTrHPPu91tbW6NGjB9auXZvrPV5+QwiLasiQIVCpVPjyyy919mVmZhbrPris76GJykq17imVn/v372PTpk24f/8+ateuDSCrK2dQUBA2bdqExYsX486dO7h37x727t2LLVu2QKVSYebMmXj77bdx/Phxib8BUckYGBjA1dUVp0+fhqGhodbEk0DWEL7sXjwFJaX09fWxcOFCTJ48GT179oS3tzeioqKwadMmnWF/jo6OqFGjBtasWQMzMzOYmJigQ4cOpdYLcciQIZgzZw7mzJkDCwsLnSdh2Ynlnj17om7durh37x5++OEHtGnTRrOs7sOHD9G8eXP4+PggICCgSJ+vVCqxYMGCAsu98cYb2Lp1K5RKJZycnBAcHIw///wTlpaWWuWcnJzQo0cPtGvXDhYWFrhw4QJ+/vlnTJs2DUDWE8bXXnsNQ4YMgZOTE/T09HDgwAE8efIk16erREREVZGjoyMWLlyIuXPn4u7duxg4cCDMzMwQFRWFAwcOYNKkSZgzZ06u7x04cCDc3Nwwe/Zs3Lp1C82aNcMvv/yieRBdnB4qRkZGcHJywu7du9GkSRNYWFigZcuW+c55BGQ9XJs3bx4UCgXGjx8Pmex/fQwSEhJQt25dvP3223B2doapqSn+/PNPhIWFafW8/vHHH+Hn54cTJ05oRoDk59KlS9i2bRvUajVevnyJsLAw7Nu3D4IgYOvWrTqTyr/q+PHjmDZtGt555x00adIEmZmZ2Lp1K+RyOQYPHqxVtmXLlujTpw+mT58OQ0NDTWLJz88vz/o7deqEmjVrwsfHB9OnT9fElDPxKJPJsHr1anh5eaFNmzYYO3Ys7OzscP36dVy9ehWHDx8GkDVxfpcuXdCqVStMnDgRDRs2xJMnTxAcHIz//vsPf//9d4HHqzC6d++OyZMnY8mSJQgPD0fv3r2hr6+PmzdvYu/evVi5ciXefvvtItXZpk0byOVyfP3114iLi4OhoSF69uwJa2vrUomZqKwwKZWHK1euQKVS6XTvTUtL0zQK1Wo10tLSsGXLFk25n376Ce3atcONGzc0Q/qIKqsuXbrg9OnTmuF6r+rcuTOWL18OMzMzreF3eZk0aRJUKhWWLl2KDz74AK1atcIvv/yCzz//XKucvr4+Nm/ejLlz52LKlCnIzMzEpk2bSi0pVbduXc1E7RMmTIC+vr7W/pEjR2LdunVYtWoVXr58CVtbW3h7e2PBggVaN35lbeXKlZDL5di+fTtSU1PRuXNn/PnnnzpzHEyfPh2//PILjhw5grS0NNSvXx8LFy7UPLW0t7fHsGHDcOzYMWzduhV6enpo1qwZ9uzZo3MzSEREVJV9/PHHaNKkCb777jtNosPe3h69e/fGm2++mef75HI5fvvtN7z//vvYvHkzZDIZBg0ahPnz56Nz585QKBTFimfDhg147733MHPmTKSnp2P+/PmFSkp99tlnSE5O1untbWxsjHfffRdHjhzRrDbYqFEjrFq1ClOnTi1WjACwc+dO7Ny5E3p6ejA3N0fjxo0xY8YMTJkyJdcJuF/l7OyMPn36IDAwEA8fPoSxsTGcnZ3xxx9/oGPHjlplu3fvDnd3d/j5+eH+/ftwcnJCQEBAvkkvS0tL/Prrr5g9ezY+++wz1KxZEyNHjsRrr72mc8/Up08fnDhxAn5+fli+fDnUajUcHR21VlV0cnLChQsX4Ofnh4CAADx//hzW1tZwcXHBvHnzinH08rZmzRq0a9cOa9euxSeffAI9PT00aNAAI0eOROfOnYtcn62tLdasWYMlS5Zg/PjxUKlUOHHiBJNSVOEJImdHA5D1hOPAgQMYOHAggKzVLEaMGIGrV6/qdBc1NTWFra0t5s+fj8WLFyMjI0OzLyUlBcbGxjhy5Ag8PT3L8ysQEREREVE5OXjwIAYNGoQzZ84UK4lA/yMIAnx9ffHjjz9KHQoRlTP2lMqDi4sLVCoVYmJi0LVr11zLdO7cGZmZmbh9+7Zm8rx///0XwP8mdiYiIiIiosotJSVFa0JqlUqFH374Aebm5mjbtq2EkRERVW7VOimVmJiotWpGVFQUwsPDYWFhgSZNmmDEiBEYPXo0li9fDhcXFzx9+hTHjh1D69at8frrr6NXr15o27Ytxo0bhxUrVkCtVsPX1xeenp5FXtWDiIiIiIgqpvfeew8pKSlwd3dHWloa9u/fj3PnzmHx4sWltnoaEVF1VK2TUhcuXICHh4fm9axZswBAM3nxpk2bsHDhQsyePRsPHz5ErVq10LFjR7zxxhsAsibMCwwMxHvvvYdu3brBxMQE/fr105pIkIiIiIiIKreePXti+fLl+PXXX5GamopGjRrhhx9+0CwsQkRExcM5pYiIiIiIiIiIqNyV31JSRERERERERERE/49JKSIiIiIiIiIiKnfVbk4ptVqNR48ewczMDIIgSB0OERERVVCiKCIhIQG1a9eGTMbneADvo4iIiKhwCnsfVe2SUo8ePYK9vb3UYRAREVEl8eDBA9StW1fqMCoE3kcRERFRURR0H1XtklJmZmYAsg6Mubl5ierKyMjAkSNH0Lt3b+jr65dGeFREPAfS4vGXFo+/9HgOpFXWxz8+Ph729vaae4fqzN/fH/7+/sjMzARQOvdRueE1RVQ58dolqnwqyn1UtUtKZXc1Nzc3L5WklLGxMczNzfnLVyI8B9Li8ZcWj7/0eA6kVV7Hn8PUAF9fX/j6+iI+Ph5KpbJU7qNyw2uKqHLitUtU+VSU+yhOkEBEREREREREROWOSSkiIiIiIiIiIip3TEoREREREREREVG5q3ZzShWWSqVCRkZGvmUyMjKgp6eH1NRUqFSqcoqMXsVzIK2SHH8DAwMusU5EREREVEyFabMS5aWkbWl9fX3I5fISx8GkVA6iKOLx48d4+fJlocra2triwYMHnARVIjwH0irJ8ZfJZHBwcICBgUEZRUdEREREVPUUpc1KlJfSaEvXqFEDtra2JWqLMymVQ/bFbW1tDWNj43wPrlqtRmJiIkxNTdnjQyI8B9Iq7vFXq9V49OgRoqOjUa9ePSYUiYiIiIgKqShtVqK8lKQtLYoikpOTERMTAwCws7MrdhxMSr1CpVJpLm5LS8sCy6vVaqSnp0OhUDAhIhGeA2mV5PhbWVnh0aNHyMzM5NLBRERERESFUNQ2K1FeStqWNjIyAgDExMTA2tq62EP52Ip/RfZ4XGNjY4kjIar6softcS4wIiIiIqLCYZuVKpLsf4clmduMSalcsPsjUdnjdUZEREREVDy8l6aKoDT+HTIpRURERERERERE5Y5JKdLRoEEDrFixotDl7969C0EQEB4eXmYxAcDJkychCAIEQcDAgQPL9LOqsx49emiOc1mfUyIiIiIiorxktwHzW2kwICAANWrUKLAuQRBw8ODBUottzJgxmnZTSeutzm0wJqXKiEotIvj2cxwKf4jg28+hUotl+nljxozJNVFTmIs4p7CwMEyaNKn0gkPhf1EUxo0bNxAQEKB5nZCQgJkzZ6J+/fowMjJCp06dEBYWlm8d0dHRGD58OJo0aQKZTIYZM2bkGnP2L4bsH4VCoVVm//796N27NywtLfP8BbJu3Tr06NED5ubmeZ6Lf//9FwMGDECtWrVgbm6OLl264MSJE7nG/vz5c9StW1enrv3798PT0xNWVlYwNzeHu7s7Dh8+rPXehIQEzJgxI99jtX//foSGhuZ+4IiIqFry9/eHk5MTXF1dpQ6FiIhKSXm2WdesWQMzMzNkZmZqtiUmJkJfXx89evTQKpvdhr19+zY6deqE6OhoKJXKQn/WggUL0KZNm1KKPH99+/ZFdHQ0+vXrp9m2aNEidOrUCcbGxoVuA1fnNhiTUmUgKCIaXb4+jmHrz+P9XeEYtv48unx9HEER0VKHVihWVlYVeuI8a2trrYv7/fffx59//omtW7fiypUr6N27N3r16oWHDx/mWUdaWhqsrKzw2WefwdnZOc9y5ubmiI6O1vzcu3dPa39SUhK6dOmCr7/+Os86kpOT0bdvX3zyySd5lnnjjTeQmZmJ48eP4+LFi3B2dsYbb7yBx48f65QdP348WrdurbP91KlT8PT0xO+//46LFy/Cw8MDXl5euHz5sqbMhAkTcPTo0XyPlYWFBaysrPKMlYiIqh9fX19ERkYW+NCHiIgqh/Jus3p4eCAxMREXLlzQbDt9+jRsbW0REhKC1NRUzfYTJ06gXr16cHR0hIGBAWxtbSvsHFqGhoawtbWFoaGhZlt6ejreeecdTJ06tdD1VOc2GJNSpSwoIhpTt11CdFyq1vbHcamYuu1ShUhMnTlzBl27doWRkRHs7e0xffp0JCUlafbnHL53/fp1dOnSBQqFAk5OTvjzzz9z7aJ4584deHh4wNjYGM7OzggODgaQlekeO3Ys4uLiND2OFixYUCrfJSUlBb/88gu++uordOvWDY0aNcKCBQvQqFEjrF69Os/3NWjQACtXrsTo0aPzzboLggBbW1vNj42Njdb+UaNGYd68eejVq1eedcyYMQMff/wxOnbsmOv+Z8+e4ebNm/j444/RunVrNG7cGF999RWSk5MRERGhVXb16tV4+fIl5syZo1PPihUr8OGHH8LV1RWNGzfG4sWL0bhxYwQGBmqO1b59+/DNN98U6VjlRRAErF27Ft7e3jA1NUXz5s0RHByMW7duoUePHjAxMUGnTp1w+/btItdNRERERERlQ4o2a9OmTWFnZ4eTJ09qtp08eRIDBgyAg4MDzp8/r7Xdw8ND8985R4gEBASgXr16MDY2xqBBg/D8+XOtfX5+fvj77781bc9XR9k8e/YMgwYNgrGxMRo3boxffvml1L+rn58fZs6ciVatWpV63dltsDfeeAPGxsZVog3GpFQBRFFEcnpmnj8p6SrNfyekZmD+L1eRW6fH7G0LfolEQmpGvnVm/4hi6XefvH37Nvr27YvBgwfjn3/+we7du3HmzBlMmzYt1/IqlQoDBw6EsbExQkJCsG7dOnz66ae5lv30008xZ84chIeHo0mTJhg2bBgyMzPRqVMnrFixQqvXUXZSZcqUKTA1Nc33Jz+ZmZlQqVQ6w+qMjIxw5syZYhwhbYmJiahfvz7s7e0xYMAAXL16tcR15mRpaYmmTZtiy5YtSEpKQmZmJtauXQtra2u0a9dOUy4yMhJffPEFtmzZApms4EtXrVYjISEBFhYWAMrmWC1atAhDhw7FpUuX0KxZMwwfPhyTJ0/G3LlzceHCBYiimOe/LSIiIiIiKrmC2qyv/kjZZvXw8NCaouTEiRPo0aMHunfvrtmekpKCkJAQTVIqp5CQEIwfPx7Tpk1DeHg4PDw8sHDhQs1+b29vzJ49Gy1atNC0Pb29vTX7/fz8MGTIEPzzzz/o378/RowYgdjYWM3+gtqmU6ZMKfT3LStffvklRo8ejfDw8CrRBtOTOoCKLiVDBad5hwsuWAgigMfxqWi14Eihykd+0QfGBoU/Rb/++qtOEkelUmm9XrJkCUaMGKGZQ6lx48b4/vvv0b17d6xevVonYXH06FHcvn0bJ0+ehK2tLYCsRISnp6fO58+ZMwevv/46gKyLvUWLFrh16xaaNWsGpVKp6XX0qi+++CLXXj+FZWZmBldXVyxatAgtWrSAjY0Ndu7cieDgYDRq1KjY9QJZ2fyNGzeidevWiIuLw7Jly9CpUydcvXoVdevWLVHdrxIEAX/++ScGDhwIMzMzyGQyWFtbIygoCDVr1gSQNdxw2LBhWLp0KerVq4c7d+4UWO+yZcuQmJiIIUOGAMg6Vu7u7vjyyy/RvHnzUjlWY8aMwaBBg2Bubo6PPvoI7u7u+Pzzz9GnTx8AWUMrx44dW6y6iYjyo1KLCImKxcVnAiyjYuHeyBpyWcXs2k+Fw3NKRFQ8laXN6uHhgRkzZiAzMxMpKSm4fPkyunfvjoyMDKxZswYAEBwcjLS0tDyTUitXrkTfvn3x4YcfAgCaNGmCc+fOISgoCEDWA3dTU1Po6enptD2BrPbLsGHDAACLFy/G999/j9DQUPTt2xcACpxk3NzcvFDftSyNHTtW08arCm0wJqWqEA8PD51hWCEhIRg5cqTm9d9//41//vkH27dv12wTRRFqtRpRUVFo3ry51vtv3LgBe3t7rQvazc0t189/dZ4jOzs7AEBMTAyaNWuWZ8zW1tawtrYuxLfL29q1azFjxgzUqVMHcrkcbdu2xbBhw3Dx4sUS1evu7g53d3fN606dOqF58+ZYu3YtvvzyyxLV/SpRFOHr6wtra2ucPn0aRkZG2LBhA7y8vBAWFgY7OzvMnTsXzZs31zqX+dmxYwf8/Pxw6NAhreO7detWjBs3rtSO1atdUrOHNubclpqaivj4+ArxC5yIqoagiGj4BUb+/7ADObbcvAA7pQLzvZzQt6Wd1OFRMfCcEhFVfT169EBSUhLCwsLw4sULNGnSBFZWVujevTvGjh2L1NRUnDx5Eg0bNkS9evVyrePatWsYNGiQ1jZ3d3dNUqogr7ZZTUxMYG5ujpiYGM22knZsKA+vfoeq0AZjUqoARvpyRH7RJ9d9arUaCfEJMDPP6t0SGhWLMZsKngA0YKwr3BwsCvXZRWFiYqJzEf33339arxMTEzF58mRMnz5d5/15XfiFpa+vr/nv7Ino1Gp1vu+ZMmUKtm3blm+ZxMTEfPc7ODjgxIkTSElJQXx8POzs7ODt7Y2GDRsWMvLC0dfXh4uLC27dulWq9R4/fhy//vorXrx4ofmlsWrVKhw9ehSbN2/Gxx9/jOPHj+PKlSv4+eefAUDTTbZWrVr49NNP4efnp6lv165dmDBhAvbu3asz15WjoyP++usvJCUllcqxyu2cF+ffARFRYWXPg5FzsED2PBirR7ZlEqOS4TklIiqZ/NqsOUnZZm3UqBHq1q2LEydO4MWLF+jevTsAoHbt2rC3t8e5c+dw4sQJ9OzZs9B1FtWrbRUgq73yaluloOljRo4cqenVJZWq1gZjUqoAgiDk2R1RrVYj00AOYwM9yGQydG1sBTulAo/jUnMdoysAsFUq0LWxlWTd0du2bYvIyMhCZ4CbNm2KBw8e4MmTJ5osbHFW3jEwMNAZSgiUfPjeq0xMTGBiYoIXL17g8OHD+Oabb0ql3mwqlQpXrlxB//79S7Xe5ORkANCZJ0omk2l+kezbtw8pKSmafWFhYRg3bhxOnz4NR0dHzfadO3di3Lhx2LVrl2YoZW7K+lgREZUFlVqEX2BknvNgCAD8AiPh6WTLYV+VBM8pEVHJ5ddmzUnqNquHhwdOnjyJFy9e4IMPPtBs79atG/744w+Ehobmu2pd8+bNERISorXt1UnSgbzbnoVRGYbvVTVMSpUiuUzAfC8nTN12CQKgdZFnX87zvZwkvan66KOP0LFjR0ybNg0TJkyAiYkJIiMjcfToUfz444865T09PeHo6AgfHx988803SEhIwGeffQYARVqWs0GDBkhMTMSxY8fg7OwMY2NjGBsbl8rwvWPHjsHIyAjNmzfHrVu38MEHH6BZs2Za42jnzp2Lhw8fYsuWLZpt2b9wEhMT8fTpU4SHh8PAwABOTk4AshJmHTt2RKNGjfDy5UssXboU9+7dw4QJEzR1xMbG4v79+3j06BGArOGOADSr9QHA48eP8fjxY00PqytXrsDMzAz16tWDhYUF3N3dUbNmTfj4+GDevHkwMjLC+vXrERUVpUksvZp4ArJWjQCyfinXqFEDQNaQPR8fH6xcuRIdOnTA48ePAWSNq85eYfDw4cMQRRFNmzbN81gREVVUoVGxOisFvUoEEB2XitCoWLg7WpZfYFRsPKdEROVL6jarh4cHfH19kZGRoekpBQDdu3fHtGnTkJ6enud8UgAwffp0dO7cGcuWLcOAAQNw+PBhnaF7DRo0QFRUFMLDw1G3bl2YmZnB0NCwUPGVxvC9+/fva9qJKpVK0+5s1KiRpidWs2bNsGTJEp2hiNURV98rZX1b2mH1yLawVWpPGG6rVFSI7uetW7fGX3/9hX///Rddu3aFi4sL5s2bh9q1a+daXi6X4+DBg0hMTISrqysmTJigWX0v56To+enUqROmTJkCb29vWFlZlWrPnPj4eLz33nto1qwZRo8ejS5duuDw4cNaXRijo6Nx//59rfe5uLjAxcUFFy9exI4dO+Di4qLVC+rFixeYOHEimjdvjv79+yM+Ph7nzp3TJK0A4JdffoGLi4smeTR06FC4uLhodelcs2YNXFxcMHHiRABZTwFcXFw0y4/WqlULQUFBSExMRM+ePdG+fXucOXMGhw4dgrOzc6GPw7p165CZmQlfX1/Y2dlpft5//31Nmbi4OPj6+uZ7rIiIKqqYhLyTF8UpR9LjOSUiKn9Stlk9PDyQkpKCRo0aaUbiAFlJqYSEBDRt2lQzP3FuOnbsiPXr12PlypVwdnbGkSNHNJ0msg0ePBh9+/aFh4cHrKyssHPnzjL7PrmZN28eXFxcMH/+fCQmJmranRcuXNCUuXHjBuLi4so1ropKEIuyhmMVEB8fD6VSibi4OJ2ud6mpqYiKioKDg0OhEi5qtVozeVjOoVcqtYjQqFjEJKTC2kwBNweLKtPt/OzZs+jSpQtu3bql04OnLJ08eRIeHh548eKFpndQfueAiu/u3btwcHDA5cuX0aZNmzzLleT4F/V6I10ZGRn4/fff0b9/fyYWJcJzUL6Cbz/HsPXnCyy3c2LHUulVk989Q3VV2sekvM8pEZUN/j0sP6V5D12V26zlYcyYMXj58iUOHjxYKvUVtg1WWkqjLZ3fv8fC3jNw+F4ZkcuEKnPzdODAAZiamqJx48a4desW3n//fXTu3LlcE1Kvqlu3Lry8vMo9411d9OvXD6dOnZI6DCIiHcYGcggCkNfjtOx5MAozMStVDG4OFvnObQIASiN9nlMiojJQldqsUvn1119hamqKXbt24Y033ih2PdW5DcakFBUoISEBH330Ee7fv49atWqhV69eWL58ebnH0aFDB9y8eRNAwasiUPFt2LBBM6l6SVdkJCIqLRfvvcCYTaGahFRFnbuRiia/uU2yxaVkIODcXYzv4lDe4REREeXpm2++0QwdzG/IYWFU5zYYk1JUoNGjR2P06NFShwEjI6NSmXiO8lenTh2pQyCiaiy3oQQhUc8xYfMFJKer4NqgJoa51cPSwze0Jsi2VSow38tJ8rkbqeiy5zbxC4zUOqd2SgVa1lHiaOQTfPlrJFLSM+Hr0ahIC60QERGVldJYtCtbdW6DMSlFREREFUJQRLROYqKmsT4SUjORqRbRtXEtrB3VDsYGehjQpg6Cb8XgyOkQ9O7aAe6NrNlDqhLr29IOnk62OudUJgDfH7uF7/78F8uO/IvENBU+6tuUiSkiIqIqgkkpIiIiklxQRDSmbrukM3zrRXIGAKB1HSXWj24Phb4cQNawrw4OFnh+TUQHTsxaJeR1Tt/v1RjGBnIs+v0a1vx1GynpmZjv1QIynnMiIqJKT9Llyk6dOgUvLy/Url0bgiAUadb6s2fPQk9Pr1xmpSciIqKyo1KL8AuMzHOiawB4mpgGfTlXWa2uJnZriEWDWkIQgM3B9/Dhvn+gUlerBaSJiIiqJEnv7pKSkuDs7Ax/f/8ive/ly5cYPXo0XnvttTKKjIiIiMpLaFSs1pC93ETHpSI0KracIqravvvuO7Ro0QJOTk6YPn06xLyWM6xgRnSoj2+HOEMuE/Dzxf8wfddlpGeqpQ6LiIiISkDS4Xv9+vVDv379ivy+KVOmYPjw4ZDL5UXqXUVEREQVT0xC/gmpopajvD19+hQ//vgjrl69Cn19fXTr1g3nz5+Hu7u71KEVyiCXujDSl+O9nZfx2z/RSE1XwX9EW82wTiIiIqpcKl0/+E2bNuHOnTuYP3++1KEU7Nw5oGPHrP8nIiKiXFmbKUq1HOUvMzMTqampyMjIQEZGRqmtHFRe+ra0w/rR7WGoJ8Ox6zEYvzkMSWmZUodFRFQ5sc1KEqtUE53fvHkTH3/8MU6fPg09vcKFnpaWhrS0NM3r+Ph4ANDciL0qIyMDoihCrVZDrS64O3h2d/fs9+QkfP89hJAQiD/8ALFjx0LFW5H5+fnh0KFDuHTpUrHruHv3LhwdHXHx4sVSmQ8st3MQEBCAWbNmITa27IZ5lPb3qKwKugbyo1arIYoiMjIyIJfzCXdxZP8Oy/m7jMoPz0HpaFPHFMYGciSnq3LdLwCwVRrCpa6Z1rEu6+NfEc/rqVOnsHTpUly8eBHR0dE4cOAABg4cqFXG398fS5cuxePHj+Hs7IwffvgBbm5uAAArKyvMmTMH9erVg56eHqZMmQJHR0cJvknJ9Ghqjc3j3DA+IAxnbz3H6I2h2DjGFUojfalDIyKqXH74AQgJAX78EejUSepoSmzBggU4ePAgwsPDi13H3bt34eDggMuXL5dZWy8gIAAzZszAy5cvy6R+oHy+R2moNEkplUqF4cOHw8/PD02aNCn0+5YsWQI/Pz+d7UeOHIGxsbHWNj09Pdja2iIxMRHp6emF/oyEhASdbcLz5zDfty/rxc8/I2HhQoiWloWuszj+++8/fPXVVzh27BieP38OGxsbvP766/jwww9hYWFRpLpq1qyJbdu24fXXX9dsmzhxInx8fDSJveJQKpW4fv06LC0tS1RPTq+eg9TUVIiimGv9MTExaNGiBdasWYPBgwfr7H/vvffwzz//4K+//sr38xITEwFkzYtWmt+jssrtGihIeno6UlJScOrUKWRm8gl3SRw9elTqEKo9noPiU4vA3igZktOzO2+LyEpDQfNaBNDPJhmHg/7ItY6yOv7JycllUm9JZM/HOW7cOLz11ls6+3fv3o1Zs2ZhzZo16NChA1asWIE+ffrgxo0bsLa2xosXL/Drr7/i7t27MDIyQr9+/XDq1Cl069ZNgm9TMh0bWmLbhA7w2RiKi/deYMSG89gyrgMsTAykDo2IqHJ49gz4+ees/967F/j+e6BWrTL9yAcPHmD+/PkICgrCs2fPYGdnh4EDB2LevHmwLGJ7WRAEnYczc+bMwXvvvVeiGO3t7REdHY1aZXws8vLkyRPUrVsXW7duxdChQ3X2jx8/HpcvXy5RZ5GKpNIkpRISEnDhwgVcvnwZ06ZNA/C/nhZ6eno4cuQIevbsqfO+uXPnYtasWZrX8fHxsLe3R+/evWFubq5VNjU1FQ8ePICpqSkUioKHCIiiiISEBJiZmUEQcixLvGEDkN1zRK2G2cGDwMyZRfvSRXDnzh289tpraNKkCXbs2AEHBwdcvXoVH330EY4fP45z584VOTFlZGSkdYxyHq/iqlmzZqnUA+R+DhQKBQRByDVec3Nz9O/fH7t27cLYsWO19iUlJeHgwYNYsmRJgd/V1NQUAGBiYlJqx6UyyvcaKEBqaiqMjIzQrVu3Ql1vpCsjIwNHjx6Fp6cn9PXZO0AKPAclk6lSY+6Bqzj3JBqCAAxztcfx6zF4HP+/Hs52SgU+7dcMfVrY6Ly/rI9/RXzoUNB8nN9++y0mTpyo+Ru3Zs0a/Pbbb9i4cSM+/vhj/Pnnn2jUqJHmnuD111/H+fPn80xKFaXHeWkoau+3lnam2DbOFWM2X0DEw3gMWXMOm8e2h7WZYanHRkR5Y8/h8lPU0T35CgiAoFZDACCq1RA3by7zNmvnzp3RpEkTbN++XavN+scffxSrzZrzOBgbG8PY2LhEx0YQBM3Q9hIf4zxk15tb/VZWVujfvz9++uknDBkyRGtfUlIS9uzZgyVLlhQY26ufkVvZkox6efUz8hr9UtjfB5UmKWVubo4rV65obVu1ahWOHz+On3/+GQ4ODrm+z9DQEIaGujcm+vr6OjewKpUKgiBAJpNBJit4uq3sEyc8egTZ06faO1evBv7/JAuiCGHVKsDDQ7uMjQ1Qp06Bn1MY7733HgwMDHDkyBEYGRkBABo0aIB27drB0dERn3/+OVavXq3ZPn78eERGRuKXX35BjRo18Mknn8DX11ezH4CmJ1H9+vVx9+5dna6QY8aMwcuXL+Hm5oaVK1ciLS0Ns2bNwieffIK5c+fip59+grGxMb788kvNzXHOLoRjxozB5s2bdb7PiRMn0KNHD6SlpeHTTz/Fzp078fLlS7Rs2RJff/01evToASDrHOzYsQNfffUVnj17hj59+qBLly4AkOc5nDBhAgYOHIj//vsP9erV02zft28fMjMzMXLkSBw5cgQLFy5EREQE5HI53N3dsXLlSs0Qh+y6s/+t5Nb98uDBgxg0aJDWqkaHDh2Cn58fIiMjUbt2bfj4+ODTTz8t9HDUikZzDfz/dVMUMpkMgiDkei1S0fAYSo/noHBUahGhUbGISUhFTWN9bD9/H4cjn0BPJuBb7zZ407m2VhlrMwXcHCwgl+Wf9C6r41/Zzml6ejouXryIuXPnarbJZDL06tULwcHBALKe/p47dw6pqanQ19fHyZMnMWnSpDzrLEqP89JU1N5vUxoD/pFy3HqahAErT8K3hQoWzEsRlTv2HC57xR3dk1ub1djfH0J2W0UUIf74I5Lbt9cqo7aygli7donjBrIWLNPT08OePXs0bdbOnTtj3759aNu2LT788EN8++23AIDWrVtj1KhRuH79OoKCgqBUKjFz5kxMnDhRsx/4X5vV3t4e//zzD7766iv89ttvOH36NADg3XffRVxcHNq2bYu1a9ciLS0Nvr6+mDVrFvz8/LBt2zYYGxvjk08+wYgRIwAA9+/fh7OzM06dOoVWrVrh3Xffxc6dO3W+T2BgILp06YK0tDQsXLgQ+/btQ1xcHJo3b44FCxZo2qUAsGPHDixevBixsbHo2bMnOnbsmOfoHgAYOnQoRo4ciatXr8Le3l6rnszMTHh5eWH//v1YtmwZrl27BrlcDldXV3z11Vea3EjO0T07duzA3Llzce/ePU19v/32G0aOHIkXL15otv3+++/4+uuvcePGDdja2mLYsGGYPXt2rm3W/Ea/FLbHuaQt4cTERNy6dUvzOioqCuHh4bCwsEC9evUwd+5cPHz4EFu2bIFMJkPLli213m9tbQ2FQqGzvbwJw4cDZ87k2ChoklIQReDOHaBdO+0y3boBBQwTK4zY2FgcPnwYixYt0lzc2WxtbTFixAjs3r0bq1at0vRmWbp0KT755BP4+fnh8OHDeP/999GkSRN4enoiLCwM1tbW2LRpE/r27ZvvfD/Hjx9H3bp1cerUKZw9exbjx4/HuXPn0K1bN4SEhGD37t2YPHkyPD09UbduXZ33r1y5El999ZXm9VdffYWdO3eiWbNmAIBp06YhMjISu3btQu3atXHgwAH07dsXV65cQePGjRESEoL33nsPixcvxqBBgxAUFFTgJPj9+/eHjY0NAgICMG/ePM32TZs24a233kKNGjWQlJSEWbNmoXXr1khMTMS8efMwaNAghIeHFzn5ku306dMYPXo0vv/+e3Tt2hW3b9/WNAQqxcT9REQlEBQRDb/ASETHaa+gpycTsHpkO3g6ZfWEkssEuDuW7XD3qurZs2dQqVSwsdHuVWZjY4Pr168DADp27Ij+/fvDxcUFMpkMr732Gt5888086yxKj/PSUJLeb716JmP0pov470UK1t02xZax7dDA0qTUYyQiXew5XH6KOronm+DlBSFHm1UUBE1SShBFyO7ehdn/P/zXlOnaFeLJkyUNG7GxsTh+/DgWLlyo83fK3Nwcw4cPx759+7B+/XrNA+8ffvgBc+fOxaJFi3DkyBFN+yy7zWpra4uffvpJ02Y1NzeHoaGh5r+BrAdMp0+fRoMGDfDXX3/h7NmzmDhxIi5evKhZgXbPnj2YOXMmvLy8ULduXZ1RMf7+/li2bJkm3q+//hq7du1C27ZtYW5ujkmTJuHatWvYuXMnateujYMHD+Ltt9/G33//rdNmHTBgAA4fPowFCxbkOboHAN5++23Mnj0b+/fvx+eff67Zvnv3bgwaNAj29vYIDQ3FnDlzNG3W+fPnw8fHB5cuXYJMJtP5HjlHFL3aeSJ72+nTpzF16lSsWLFC02adMmUKDA0NtdrO2fIb/VLoHueihE6cOCEia/IIrR8fHx9RFEXRx8dH7N69e57vnz9/vujs7Fykz4yLixMBiHFxcTr7UlJSxMjISDElJaVQdalUKvHFixeiatMmUVQoRFEQRDErBZX/jyBkld+8uUix5+X8+fMiAPHAgQO57v/2229FAOKTJ09EURTF+vXri3379tUq4+3tLfbr10/zOrf6ch5vHx8fsX79+qJKpdJsa9q0qdi1a1fN68zMTNHExETcuXOnKIqiGBUVJQIQL1++rBPnvn37RIVCIZ45c0YURVG8d++eKJfLxYcPH2qVe+2118S5c+eKoiiKQ4cOFT09PbVi8Pb2FpVKZa7HItvHH38sOjg4iGq1WhRFUbx165YoCIL4559/5lr+6dOnIgDxypUruX6PTZs26XzmgQMHxFcvsddee01cvHixVpmtW7eKdnZ2+cZakWmugVeOf2EV9XojXenp6eLBgwfF9PR0qUOptngOCuePK4/EBh/9KtbP4+ePK4+KVW9ZH//87hkqgpx/qx8+fCgCEM+dO6dV7oMPPhDd3NxK5TPL+piU9Jw+epkseiw7Idb/6Fex3ZdHxevR8aUcIRHlhn8Py0+x76E3b2ab9f+Vd5t12LBhYv/+/XW+i9RtVpVKJW7btq1Ebdb8/j0W9p6heF0+SkmPHj0giqLOT0BAAICsGelP5pOVXbBgQYlm1S81o0cDFy8CjRsDBfWikcmAJk2yyo8eXaphiK9kOgvi7u6u8/ratWtF/swWLVpo9RyysbFBq1atNK/lcjksLS0RExOTbz2XL1/GqFGj8OOPP6Jz584AgCtXrkClUqFJkyYwNTXV/Pz111+4ffs2AOD69eton6OLac7vlptx48YhKioKJ06cAJDVS6pBgwaaeclu3ryJYcOGoWHDhjA3N9cMabx//36Bdefl77//xhdffKH1XSZOnIjo6OgKOZkuEVFpUKlF+AVGIq+/UAIAv8BIqNSF/xtGuatVqxbkcjmePHmitf3JkyewtbUtUd3+/v5wcnKCq6trieopa3ZKI+yZ7I7mduZ4lpgG73XB+Oe/l1KHRUQkPbZZNa/Lu8167do1dOjQId/vlpvq0matnBPZVEROTsClS8D48cDu3XmXGzIE+OknoBTnYWjUqBEEQcC1a9cwaNAgnf3Xrl1DzZo1YWVlVWqfmS1n99zsOYJybstv4rTHjx/jzTffxIQJEzB+/HjN9sTERMjlcly8eFFnCGF2V8Tiaty4Mbp27YpNmzahR48e2LJlCyZOnKgZ3ujl5YX69etj/fr1qF27NtRqNVq2bJnnuG2ZTKbzCzbnxG6JiYnw8/PLdbUkTvRNRFVVaFSszpC9V4kAouNSERoVy2F7JWRgYIB27drh2LFjmpWI1Go1jh07plkkprh8fX3h6+uL+Ph4KJXKUoi27NQyNcSuiR3hsykU4Q9eYvj6EGwa6wrXBkWbPJeIqMphmxUA26yvqghtVialSpOJCdC9O7Bnz//mk3qVIGTtL+WJQS0tLeHp6YlVq1Zh5syZWvNKPX78GNu3b8fo0aO1Vkc7f/68Vh3nz59H8+bNNa/19fWhUqlKNc7cpKamYsCAAWjWrJlmUrtsLi4uUKlUiImJQdeuXXN9f7NmzXDhwgWtbTm/W17Gjx+PqVOn4s0338TDhw8xZswYAMDz589x48YNrF+/XvO5Z3LOGZaDlZUVEhISkJSUBBOTrPkrcvbia9u2LW7cuIFGjRoVKj4ioqogJiHvhFRxylV3Bc3HOWvWLPj4+KB9+/Zwc3PDihUrkJSUpLPibFWnNNbHtgkdMD4gDCFRsRj9UyjWj26PLo2lWd6biKjCYJu1yEraZm3evDlCQkK0tlWUNmvOxeSkaLNKOnyvSrp4EchrYnC5PGt/Gfjxxx+RlpaGPn364NSpU3jw4AGCgoLg6emJOnXqYNGiRVrlz549i2+++Qb//vsv/P39sXfvXrz//vua/Q0aNMCxY8fw+PFjrZn4S9vkyZPx4MEDfP/993j69CkeP36Mx48fIz09HU2aNMGIESMwevRo7N+/H1FRUQgNDcWSJUvw22+/AchadfDYsWNYvnw5bt68iR9//BFBQUGF+ux33nkH+vr6mDx5Mnr37q1Z1aBmzZqwtLTEunXrcOvWLRw/flxrktfcdOjQQbNqw+3bt7Fjxw7NMNRs8+bNw5YtW+Dn54erV6/i2rVr2LVrFz777LOiHzgiokoi/3Xz/sfajD1GC+PChQtwcXGBi4sLAGDWrFlwcXHRTD7q7e2NZcuWYd68eWjTpg3Cw8MRFBSkM6lsdWBqqIeAsW7o3sQKKRkqjAsIw9HIJwW/kYioqmObtUhK2madPn06goKCsGzZsgrXZs25qqAUbVYmpUrb+fNAZiagpwcoFMDMmVn/L5dnbf//JZlLW+PGjXHhwgU0bNgQQ4YMgaOjIyZNmgQPDw8EBwfDwkK7y/rs2bM1N7YLFy7Et99+iz59+mj2L1++HEePHoW9vb3mxrcs/PXXX4iOjoaTkxPs7Ow0P+fOnQOQNW529OjRmD17Npo2bYqBAwciLCwM9erVA5C1itDKlSvx/fffw9nZGUeOHCn0BWNsbIyhQ4fixYsXGDdunGa7TCbDrl27cPHiRbRs2RIzZ87E0qVL863LwsIC27Ztw++//45WrVph586dWLBggVaZPn364Ndff8WRI0fg6uqKjh074rvvvkP9+vWLcMSIiCqPWzGJWPRb/nM/CADslAq4OXBoVWEUNB8nkLVy7b1795CWloaQkBCdeSyKo7LMKZWTkYEc60a3Q98WtkhXqTFl20X88vcjqcMiIpIW26xFUhpt1vXr12PlypUVqs26a9cufPTRR1plpGizCmJRZhqrArLnQoiLi9NZfjE1NRVRUVFwcHAo1HhJtVqN+Ph4mJubZ02clpoKmJoCKhXQtCmwf3/WuN3ISGDQIODff7Mu9MTErIteIg0aNMCMGTMwY8YMyWIoLTrngMpVSY5/Ua830pWRkYHff/8d/fv35/LLEuE5yNvVR3EY/VMonielw85cgej4VAiA1oTn2b2oVo9si74t7Yr8GWV9/PO7Z6iuyvqYlNU5zVSp8cHP/+DA5YcQBODrt1pjiKt9qdVPVN3x72H5KfE9NNus9P9Koy2d37/Hwt4zcE6p0pSSArRsCbRtC/z44//G4WZPKDdtGhAenvWLgI1wIiKqIlRqEaFRsYhJSIW1mQJ6cgHjA8IQn5qJlnXMsWVcB4RGPYdfYKTWpOe2SgXmezkVKyFFVBR6chmWv+MMIwM5doTcx4f7/kFSeibGdnaQOjQiovLFNitVMExKlaaaNbMu5NyyjCYmwKZNgFpd8BKcRERElURQRLROsim7R1S7+jWxaawrzBX66NvSDp5OtlrJKzcHC8hlhZ11iqhkZDIBiwa2hLG+HBvORMEvMBLJ6Sr4enABEiKqRthmpQqGSanSVtDFWwEu7rt370odAhERVQFBEdGYuu0Scs4DkP16tHt9mCv+N4xDLhPg7mhZbvER5SQIAj59vTlMDPWw8thNLD18A0lpmfigT1OtFZ+IiKo0tlmpApH+XxsRERFVOiq1CL/ASJ2EVDYBwFd/XIdKXa2mrqyyKutE57kRBAEzPZvgk/7NAACrTt6GX2Ak1Py3SkREVO6YlCIiIqIiC42K1Rqyl5MIIDouFaFRseUXFJUZX19fREZGIiwsTOpQSs2kbo74cmBLAEDAubv4eP8/TKISERGVMyalcqFWq6UOgajKq2YLfxJVOTEJeSekilOOSAqjOtbHsnecIROAPRf+w4zd4chQ8T6QiCo+tlmpIiiNf4ecU+oVBgYGkMlkePToEaysrGBgYJDv/AJqtRrp6elITU0t9hKKVDI8B9Iq7vEXRRFPnz6FIAhcNpiokrI2K9yKPIUtRySVt9vVhbGBHO/vuozAvx8hJV2FH4e7QKEvlzo0IiIdRW2zEuWlJG1pURSRnp6Op0+fQiaTwcDAoNhxMCn1CplMBgcHB0RHR+PRo0cFlhdFESkpKTAyMuIvAonwHEirJMdfEATUrVsXcjlv+okqG1EUEXznWb5lBAC2yqwV9ogquv6t7GCkL8fkbRfx57UnmLD5AtaNbgdjA94qE1HFUtQ2K1FeSqMtbWxsjHr16pWogwj/0uZgYGCAevXqITMzEyqVKt+yGRkZOHXqFLp168beHhLhOZBWSY6/vr4+E1JElZAoilj8+zWsPx2l2SYAWhOeZ9/WzPdyglzGBwZVgb+/P/z9/Qu8N6rMPJpZI2CsKyZsvoAzt55h9E+h2DjWVWsFSSKiiqAobVaivJS0LS2Xy6Gnp1fiziFMSuUie0hRQSdGLpcjMzMTCoWCCRGJ8BxIi8efqGpTqUWERsUiJiEV1mYKtK9fEwsCr2J7yH0AwLw3nFC7hgJ+gZFak57bKhWY7+WEvi3tpAqdSpmvry98fX0RHx8PpVIpdThlppNjLWwd3wFjNoXiwr0XGLE+BFvGuaGmSfGHJRARlYXCtlmJ8lJR2nJMShEREZGOoIhonWSTkb4MKRlqCAKwZFArDHWrBwDwdLLVSl65OViwhxRVWu3q18TOiR0xemMorjyMw9B157F1ghvnRyMiIioDnBmaiIiItARFRGPqtktaCSkASMnIWmFlbKcGmoQUAMhlAtwdLTGgTR24O1oyIUWVXss6SuyZ3BHWZoa48SQBQ9YE4+HLFKnDIiIiqnKYlCIiIiINlVqEX2Ck1hxROf0R8RgqdX4liCq/RtZm2DvFHXVqGOHu82QMWROMu8+SpA6LiIioSmFSioiIiDRCo2J1ekjlFB2XitCo2HKKiEg69S1NsHeKOxrWMsHDlyl4Z20w/n2SIHVYREREVQaTUkRERKQRk5B/Qqqo5ahq8Pf3h5OTE1xdXaUOpdzVrmGE3ZPd0czWDE8T0uC9NhgRD+OkDouIiKhKYFKKiIiINAo7mTMnfa5efH19ERkZibCwMKlDkYSVmSF2TeoI57pKvEjOwLB153HxHnsLEhERlRSTUkRERKRRz8I434nKBQB2yqwV9oiqkxrGBtg2oQPcHCyQkJaJkRtCcfbWM6nDIiIiqtSYlCIiIiIAwIPYZAxbfz7PScyzU1XzvZy4wh5VS2YKfWwe64aujWshJUOFsQFhOHbtidRhERERVVpMShEREVUzKrWI4NvPcSj8IYJvP4dKLeL200QMWRuM+7HJqGdhjIUDW8JOqT1Ez1apwOqRbdG3pZ1EkRNJz8hAjg0+7dHbyQbpmWpM3noRv/7zSOqwiIiIKiU9qQMgIiKi8hMUEQ2/wEitFfZqmRogLVONhNRMNLI2xfYJHWBjrsAwt3oIjYpFTEIqrM2yhuyxhxQRYKgnh/+Itpiz928cCn+E6TsvIzldhSHt7aUOjYiIqFJhUoqIiKiaCIqIxtRtl5BzcN6zxHQAgH1NI+ye1BGWpoYAALlMgLujZTlHSVQ56Mtl+HZIGxgbyLEz9AE+/PkfpGaoMNq9gdShERERVRocvkdERFQNqNQi/AIjdRJSr0pXqVHD2KDcYqLKw9/fH05OTnB1dZU6lApFLhOweFArjOvsAACYd+gqVp+8LXFURERElQeTUkRERNVAaFSs1pC93DyJT0NoFJe5J12+vr6IjIxEWFiY1KFUOIIg4PM3mmN6z0YAgK+DrmP5kRsQxfxSwERERAQwKUVERFQtxCTkn5Aqajki+h9BEDCrd1N81LcZAOCH47fw5a/XmJgiIiIqAJNSRERE1YC1maLgQkUoR0S6pvZwxBcDWgAANp6NwicHrkClZmKKiIgoL0xKERERVQNuDhZQGunnuV8AYKfMWmGPiIpvtHsDLH27NWQCsDP0AWbtCUeGSi11WERERBUSk1JERETVQMC5u4hLych1n/D//z/fywlymZBrGSIqvHfa2+P7YS7Qkwk4FP4I726/hLRMldRhERERVThMShEREVVhoijih2M38eWvkQAATycb2Cq1h+jZKhVYPbIt+ra0kyJEoirpjda1sXZUOxjoyXA08gkmbL6AlHQmpoiIiF6lJ3UAREREVHpUahGhUbGISUiFtZkhTtx4inWn7gAAZnk2wXs9G0Et4pUyWUP22EOKqPS91twGm8a4YuKWCzh98xl8NobipzHtYabIeygtERFRdcKkFBERURURFBENv8BIRMfprqD32evNMaFrQwCAXADcHS3LOzyiaqlzo1rYOt4NYzaGIfRuLEZuCMHmcW6oYWwgdWhERESS4/A9IiKiKiAoIhpTt13KNSEFAHVrGpVzRFSV+Pv7w8nJCa6urlKHUim1q2+BnZM6oqaxPv7+Lw5D153H04Q0qcMiIiKSHJNSRERElZxKLcIvMBJ5LTwvAPALjOTS9FRsvr6+iIyMRFhYmNShVFot6yixe7I7rM0Mcf1xArzXBuPRyxSpwyIiIpIUk1JERESVXGhUbJ49pABABBAdl4rQqNjyC4qIdDSxMcOeye6oU8MId54l4Z01wbj3PEnqsIiIiCTDpBQREVElF5OQd0KqOOWIqOw0qGWCPVPc4VDLBA9fpuCdNcG4+SRB6rCIiIgkwaQUERFRJWdiWLh1S6zNFGUcCREVRp0aRtg9uSOa2pghJiEN3uvOI+JhnNRhERERlTsmpYiIiCqx2KR0fHvkRr5lBAB2SgXcHCzKJygiKpC1mQK7JnVE67pKxCalY9j687h474XUYREREZUrJqWIiIgqqSfxqfBeG4zI6ASY/n9vKSFHmezX872cIJfl3EtEUqppYoBtEzrAtUFNJKRmYtRPITh3+5nUYREREZUbJqWIiIgqAZVaRPDt5zgU/hDBt5/j3vMkDFkbjJsxibA1V+DQtM5YM7ItbJXaQ/RslQqsHtkWfVvaSRQ5EeXHXKGPzePc0LVxLSSnqzB2UxhOXI+ROiwiIqJyUbhJKIiIiEgyQRHR8AuM1FphTyYAahGwtzDCjgkdYW9hDEcrU3g62SI0KhYxCamwNssassceUkQVm7GBHtaPbo9pOy7jz2tPMGnrBawc6oL+rZhMJiKiqo09pYiIiCqwoIhoTN12SSshBWQlpADg3R6NYG9hrNkulwlwd7TEgDZ14O5oyYQUUSWh0Jdj9ci28HKujQyViGk7LmHfxf+kDouIiKhMMSlFRERUQanUIvwCIyHmU+b7YzehUudXgogqC325DCu828C7vT3UIjB779/Yev6e1GERERGVGSaliIiIKqjQqFidHlI5RcelIjQqtpwiIqKyJpcJWPJWK4zp1AAA8PnBCKz967a0QREREZURJqWIiIgqqJiE/BNSRS1HRJWDTCZgvpcTfD0cAQBL/riOb4/+C1Fkr0giIqpamJQiIiKqoKzNFAUXKkI5Iqo8BEHAB32a4YM+TQFkDdVd9Ns1JqaIiKhKYVKKiIiognocl5LvfgGAnTJrhT2isuTv7w8nJye4urpKHUq14+vRCAu8nAAAG85E4dODEVBzHjkiIqoimJQiIiKqgHaH3cesvX9rXudcQy/79XwvJ66wR2XO19cXkZGRCAsLkzqUamlMZwd8M7g1BAHYEXIfs/f+jUyVWuqwiIiISoxJKSIiIgmp1CKCbz/HofCHCL79HCq1iI1novDRvisQRWBEh3pYNbwtbJXaQ/RslQqsHtkWfVvaSRQ5EZWnIa72WDnUBXoyAQcuP8S0HZeRlqmSOiwiIqIS0ZM6ACIiouoqKCIafoGRWivsmRrqITEtEwAwsasDPunfHIIgoE9LW4RGxSImIRXWZllD9thDiqh6edO5Noz05fDdfglBVx9j0paLWDOyHYwM5FKHRkREVCyS9pQ6deoUvLy8ULt2bQiCgIMHD+Zbfv/+/fD09ISVlRXMzc3h7u6Ow4cPl0+wREREpSgoIhpTt13SSkgB0CSk3mhtp0lIAVnLxLs7WmJAmzpwd7RkQoqomvJ0ssHGMa4w0pfjr3+fYsymUM3vDSIiospG0qRUUlISnJ2d4e/vX6jyp06dgqenJ37//XdcvHgRHh4e8PLywuXLl8s4UiIiotKjUovwC4xEflMVX7z3ApzLmIhy06VxLWwZ7wYzQz2ERMVixIYQxCVnSB0WERFRkUk6fK9fv37o169focuvWLFC6/XixYtx6NAhBAYGwsXFpZSjIyIiKhuhUbE6PaRyio5LRWhULNwdLcspKiKqTFwbWGDHxI4YtTEEfz94iaHrz2PreDfUMjWUOjQiIqJCq9QTnavVaiQkJMDCgkthExFR5RGTkH9CqqjliKh6alVXid2T3FHL1BDXouMxZG0wouNSpA6LiIio0Cr1ROfLli1DYmIihgwZkmeZtLQ0pKWlaV7Hx8cDADIyMpCRUbJuztnvL2k9VHw8B9Li8ZcWj7/0insOLI0L9+fX0liP5zcfZX0N8NhTZdDU1gx7p7hjxPrzuPM0Ce+sCcaOCR1Rz9JY6tCIiIgKVGmTUjt27ICfnx8OHToEa2vrPMstWbIEfn5+OtuPHDkCY+PS+WN99OjRUqmHio/nQFo8/tLi8ZdeUc9BSiagJ8iRKeY1WbmIGgbA08jz+P1ayeOr6srqGkhOTi6TeolKm0MtE+yZ4o6RG0Jw93kyhqwNxrYJHdDI2lTq0IiIiPJVKZNSu3btwoQJE7B371706tUr37Jz587FrFmzNK/j4+Nhb2+P3r17w9zcvERxZGRk4OjRo/D09IS+vn6J6qLi4TmQFo+/tHj8pVecc5CQmoGJWy8jU3yZ637h//934VvO6NPCprRCrZLK+hrI7l1NVBnUrWmMPZPdMWJDCG7GJMJ7bTC2jHdDi9pKqUMjIiLKU6VLSu3cuRPjxo3Drl278PrrrxdY3tDQEIaGuhM+6uvrl9oNbGnWRcXDcyAtHn9p8fhLr7DnIDYpHT4Bl3DlYRzMFXqY0t0RW8/f05r03FapwHwvJ/RtaVeWIVcpZXUN8LqiysbaXIHdk90xemMIIh7GY9i689g8zg0u9WpKHRoREVGuJE1KJSYm4tatW5rXUVFRCA8Ph4WFBerVq4e5c+fi4cOH2LJlC4CsIXs+Pj5YuXIlOnTogMePHwMAjIyMoFTyKRAREVUcKrWI0KhYxCSkwtpMgQaWxvDZFIp/nyTCwsQAW/+/B8Pk7o5a5dwcLCCX5TWsj4gofxYmBtgxsSPGbgrDxXsvMHJDCDb4uHIlTyIiqpAkTUpduHABHh4emtfZw+x8fHwQEBCA6Oho3L9/X7N/3bp1yMzMhK+vL3x9fTXbs8sTERFVBEER0fALjNTqASWXCVCpRdiYG2L7hA5oZG2m2c7GIhGVJnOFPraOd8PELRdw9tZzjNkUijWj2sGjad7zsBIREUlB0qRUjx49IIpinvtzJppOnjxZtgERERGVUFBENKZuu4Scf91U6qwt0zwaaxJSRERlxdhADz/5uMJ3+yUcux6DSVsu4IdhLhwaTEREFYpM6gCIiIiqCpVahF9gpE5C6lWrTt7SJKiIiMqSQl+ONaPa4fXWdshQifDdcRkHLv8ndVhEREQaTEoRERGVktCoWK0he7mJjktFaFRsOUVEpOvGjRto06aN5sfIyAgHDx6UOiwqI/pyGb4f6oJ32tWFSi1i1p6/sT3kntRhERERAaiEq+8RERFVVDEJ+SekilqOqCw0bdoU4eHhALIWnWnQoAE8PT2lDYrKlFwm4OvBrWFsIMfm4Hv49EAEUtJVmNC1odShERFRNceeUkRERKXE2kxRquWIytovv/yC1157DSYmJlKHQmVMJhOw4M0WmNrDEQCw8LdrWPnnzXzndyUiIiprTEoRERGVkoSUjHz3CwDslAq4OViUT0BUJZ06dQpeXl6oXbs2BEHIdeidv78/GjRoAIVCgQ4dOiA0NDTXuvbs2QNvb+8yjpgqCkEQ8FHfZvigT1MAwHd//oslf1xnYoqIiCTDpBQREVEpCPz7Ed7dcUnzWsixP/v1fC8nyGU59xIVXlJSEpydneHv75/r/t27d2PWrFmYP38+Ll26BGdnZ/Tp0wcxMTFa5eLj43Hu3Dn079+/PMKmCsTXoxE+f8MJALDu1B18figCai7AQEREEmBSioiIqIhUahHBt58j8J9o3IwTsOfif3h/12VkqkUMbFMb/sNdYKvUHqJnq1Rg9ci2XI6dSqxfv35YuHAhBg0alOv+b7/9FhMnTsTYsWPh5OSENWvWwNjYGBs3btQqd+jQIfTu3RsKBYeTVkfjuzjgq7daQRCAbefvY87PfyNTpZY6LCIiqmY40TkREVERBEVEwy8w8pVV9uRAZCQAYJibPRYObAW5TEDflnYIjYpFTEIqrM2yhuyxhxSVtfT0dFy8eBFz587VbJPJZOjVqxeCg4O1yu7ZsweTJk3Kt760tDSkpaVpXsfHxwMAMjIykJGR/3DV4siusyzqJl2DXexgIAc+2BeB/ZceIik1A9++0xoGenxuTUXDa5eo8inr67aw9TIpRUREVEhBEdGYuu0S8hrk0q2xlSbxJJcJcHe0LL/giAA8e/YMKpUKNjY2WtttbGxw/fp1zeu4uDiEhoZi3759+da3ZMkS+Pn56Ww/cuQIjI2NSyfoXBw9erTM6iZtcgBjGwvY9K8MhyNj8M7KIxjbRA0DudSRUWXEa5eo8imr6zY5OblQ5ZiUIiIiKgSVWoRfYGSeCSkBwBe/RqJ3C1v2iKIKT6lU4smTJwWWmzt3LmbNmqV5HR8fD3t7e/Tu3Rvm5ualHldGRgaOHj0KT09P6Ovrl3r9lLv+ADrdeoZ3d4Qj8iWw76klVo9wgakhmwpUOLx2iSqfsr5us3tXF4R/aYiIiAohNCr2lSF7ukQA0XGpCI2KZQ8pkkytWrUgl8t1Ek5PnjyBra1tkeszNDSEoaGhznZ9ff0ybXiWdf2kq2dzO2wZZ4hxAWE4H/UC47ZcQsAYNyiNeR6o8HjtElU+ZXXdFrZODhgnIiIqhJiEvBNSxSlHVBYMDAzQrl07HDt2TLNNrVbj2LFjcHd3L3a9/v7+cHJygqura2mESRWUm4MFtk/oAKWRPi7ff4lh68/jeWJawW8kIiIqJialiIiICsHSxKBQ5azNuJIZla3ExESEh4cjPDwcABAVFYXw8HDcv38fADBr1iysX78emzdvxrVr1zB16lQkJSVh7Nixxf5MX19fREZGIiwsrDS+AlVgzvY1sGtSR9QyNUBkdDy8153H43x6iRIREZUEk1JEREQFSMtUIeDc3XzLCADslFmr7BGVpQsXLsDFxQUuLi4AspJQLi4umDdvHgDA29sby5Ytw7x589CmTRuEh4cjKChIZ/Jzorw0tzPHnsnusFMqcCsmEUPWBuNBbOEmrCUiIioKJqWIiIjykZKuwoTNF/DntRjo/f8E5jmnMc9+Pd/LiZOcU5nr0aMHRFHU+QkICNCUmTZtGu7du4e0tDSEhISgQ4cO0gVMlVJDK1PsmeyOehbGuB+bjHfWBOP200SpwyIioiqGSSkiIqL/p1KLCL79HIfCHyL49nO8TE6Hz8ZQnL75DMYGcmwe54Y1I9vCVqk9RM9WaYjVI9uib0s7iSInKlucU6p6srcwxt4p7mhkbYrH8anwXhuMa9GFW02JiIioMLj6HhEREYCgiGj4BUZqrbCnLxeQoRJhZqiHgHGuaFc/a2iep5Nt1mp8L5Nw52o4pnl3g8KwcHNOEVVGvr6+8PX1RXx8PJRKpdThUDmyMVdg96SOGL0xFFcfxWPouvPYPM4NbexrSB0aERFVAewpRURE1V5QRDSmbruklZACgAyVCAB4r2cjTUIKAOQyAe6OlvBqbYfGSpFD9oioSrM0NcSOiR3Rtl4NxKVkYMT68wi581zqsIiIqApgUoqIiKo1lVqEX2AkxHzKbDp3Fyp1fiWIiKo2pZE+to7vAPeGlkhKV8FnUyj++vep1GEREVElx6QUERFVa6FRsTo9pHKKjktFaFRsOUVEVPFwTikCABNDPWwa64qezayRmqHGxM0XcPjqY6nDIiKiSoxJKSIiqtZiEvJPSBW1HFFV5Ovri8jISISFhUkdCklMoS/HmpHt0L+VLdJVary7/RIOXn4odVhERFRJMSlFRETVmrWZouBCRShHRFTVGejJ8P1QFwxuWxcqtYiZe8KxM/S+1GEREVElxNX3iIioWpPLAAHIc04pAYCtUgE3B4s8ShARVT96chmWvt0axgZybD1/D3P3X0FyugrjuzhApRYRGhWLmIRUWJtl/f7kghBERJQbJqWIiKjaOnfrGSZsuaBJSOVMTmU3oeZ7ObFBRUSUg0wm4IsBLWBsKMfav+7gy18j8ff9Fwi99wKPX5mrz06pwHwvJ/RtaSdhtEREVBFx+B4REVV5KrWI4NvPcSj8IYJvP4dKLeL49ScYExCG5HQVujauhZVD28BWqT1Ez1apwOqRbdmQomqPE51TXgRBwMd9m2GWZxMAwC//RGslpADgcVwqpm67hKCIaClCJCKiCow9pYiIqEoLioiGX2Ck1gp7NYz1EZ+SAbUI9Gpugx+Hu0ChL8cbrWtzyAlRLnx9feHr64v4+HgolUqpw6EKRhAE+Ho0wvrTd5CQmqmzX0RWz1O/wEh4Otny9yoREWkwKUVERFVWUEQ0pm67pDNf1MvkDABA+/o1sXpkW+jLszoOy2UC3B0tyzlKIqLKLzQqNteEVDYRQHRcKkKjYvl7loiINDh8j4iIqiSVWoRfYGSeE5gDwMOXKZAJfGJPRFRSMQmpBRcqQjkiIqoemJQiIqIqKTQqVmvIXm6yn9oTEVHJWJspCi5UhHJERFQ9MClFRERVEp/aExGVHzcHC9gpFciv76mtedZcfURERNmYlCIioiqJT+2JSg9X36OCyGUC5ns5AUCeiSljQzkS0/Ked4qIiKofJqWIiKhKale/JowM5HnuFwDYKfnUnqgwfH19ERkZibCwMKlDoQqsb0s7rB7ZFrZK7WR/LVMDGOnLcOdpEoavP4/YpHSJIiQiooqGq+8REVGVk6lS48Of/0ZKuirX/dlP8ed7OXFpciKiUtS3pR08nWwRGhWLmIRUWJtlJf9vPE7AqJ9CcPVRPLzXBmPbhA6wMWdPVSKi6o49pYiIqEpJy1TBd8clHAx/BD2ZgPFdHGCX46m9rVKB1SPbom9LO4miJCKquuQyAe6OlhjQpg7cHS0hlwlwqm2O3ZPdYWuuwM2YRAxZG4z/XiRLHSoREUmMPaWIiKjSUqlFrafxreoo8e6OSzj171MY6Mmwanhb9HKywSf9m+s8tWcPKSKi8tXI2hR7p7hj+IbzuPc8GUPWZPWYamhlKnVoREQkESaliIioUgqKiIZfYCSi4/63ep6BXEC6SoSRvhzrR7dHl8a1APzvqT0REUnL3sIYeyd3wogN53H7aRKGrD2PbRPc0MzWXOrQiIhIAhy+R0RElU5QRDSmbruklZACgHSVCADw9XDUJKSIiKhisVUqsHuyO5rbmeNZYhqGrjuPf/57KXVYREQkASaliIioUlGpRfgFRkLMp8z2kPtQqfMrQUREUqplaohdEzuijX0NvEzOwPD1IQi7Gyt1WEREVM6YlCIiokolNCpWp4dUTtFxqQiNYuOGqLT4+/vDyckJrq6uUodCVYjSWB/bJnRAx4YWSEzLxKifQnD65lOpwyIionLEpBQREVUqMQn5J6SKWo6ICubr64vIyEiEhYVJHQpVMaaGeggY64YeTa2QmqHG+IALOBr5ROqwiIionDApRURElYq1maJUyxERkbQU+nKsHdUOfVvYIl2lxpRtF/HL34+kDouIiMoBk1JERFSpmBjKIRPy3i8AsFMq4OZgUW4xERFRyRjqyfHjcBe85VIHKrWI93ddxu6w+1KHRUREZYxJKSIiqjQu3X+BkRtCkD2Hec7cVPbr+V5OkOeXuSIiogpHTy7DsnecMaJDPYgi8NG+K9h0NkrqsIiIqAzpSR0AERFRblRqEaFRsYhJSIW1mQJqtYhJWy8gKV2FdvVrYkSHelh6+IbWpOe2SgXmezmhb0s7CSMnIqLikskELBzYEsYGcqw/HQW/wEgkp6vg69FI6tCIiKgMMClFREQVTlBENPwCI3NdZa9zI0usH90exgZ6GNCmjlbiys3Bgj2kiIgqOUEQ8En/5jAx1MOKP29i6eEbSErLxAd9mkIQ+DueiKgqYVKKiIgqlKCIaEzddgliHvu929vD2CDrz5dcJsDd0bL8giMionIhCAJm9GoCYwM5Fv9+HatO3kZyugrz3nCCjA8fiIiqDM4pRUREFYZKLcIvMDLPhJQAYMkf16FS51WCiIiqkkndHPHlwJYAgIBzd/Hx/n/4N4CIqAphUoqIiCqM0KjYXIfsZRMBRMelIjQqtvyCIiL4+/vDyckJrq6uUodC1dCojvWx/B1nyARgz4X/8P6uy8hQqaUOi4iISgGTUkREVGHEJOSdkCpOOSIqHb6+voiMjERYWJjUoVA1NbhdXfgPbwt9uYBf/4nG1G0XkZqhkjosIiIqISaliIiowrA2MyxkOUUZR0JERBVNv1Z2WDeqPQz1ZPjzWgwmbL6A5PRMqcMiIqISYFKKiIgqBFEUcex6TL5lBAB2yqxV9oiIqPrxaGaNTWNdYWwgx5lbzzD6p1DEp2ZIHRYRERUTk1JERCQ5tVrEZwcjsOF0lGZbzrWVsl/P93KCnCsvERFVW50ca2HbhA4wU+jhwr0XGLE+BC+S0qUOi4iIioFJKSIiKlcqtYjg289xKPwhgm8/R1qGCnP2/o3tIfchCMBXb7XCmpFtYavUHqJnq1Rg9ci26NvSTqLIiYioomhbryZ2TuwICxMDXHkYh6HrznO+QSKiSkhPyg8/deoUli5diosXLyI6OhoHDhzAwIED833PyZMnMWvWLFy9ehX29vb47LPPMGbMmHKJl4iISiYoIhp+gZFaK+wp9GRIzVRDLhPw7RBnDGhTBwDg6WSL0KhYxCSkwtosa8gee0gREVG2lnWU2DO5I0ZsCMGNJwkYsiYY2yd2RJ0aRlKHRkREhSRpT6mkpCQ4OzvD39+/UOWjoqLw+uuvw8PDA+Hh4ZgxYwYmTJiAw4cPl3GkRERUUkER0Zi67ZJWQgoAUjOzlvWe2NVBk5ACALlMgLujJQa0qQN3R0smpIiISEcjazPsndwJdWsa4e7zZAxZE4y7z5KkDouIiApJ0qRUv379sHDhQgwaNKhQ5desWQMHBwcsX74czZs3x7Rp0/D222/ju+++K+NIiYioJFRqEX6BkRDzKXMo/BFU6vxKEBER6apnaYw9k93RsJYJHr5MwTtrg/HvkwSpwyIiokKoVHNKBQcHo1evXlrb+vTpg+DgYIkiIiKiwgiNitXpIZVTdFwqQqNiyykiIiKqSmrXMMLuye5oZmuGpwlp8F4bjCv/xUkdFhERFUDSOaWK6vHjx7CxsdHaZmNjg/j4eKSkpMDISHf8eFpaGtLS0jSv4+PjAQAZGRnIyCjZ8rHZ7y9pPVR8PAfS4vGXVmU6/tEvCzeUIvplEjIyzMs4mtJTmc5BVVTWx5/nlahysTIzxK5JHeGzMRR//xeH4evPY9NYV7RvYCF1aERElIdKlZQqjiVLlsDPz09n+5EjR2BsbFwqn3H06NFSqYeKj+dAWjz+0qoMx/9OnABAXnC5q+H4/b/LZR9QKasM56AqK6vjn5ycXCb1ElHZqWFsgG0TOmD85gsIjYrFqJ9CscGnPTo3qiV1aERElItKlZSytbXFkydPtLY9efIE5ubmufaSAoC5c+di1qxZmtfx8fGwt7dH7969YW5esqfxGRkZOHr0KDw9PaGvr1+iuqh4eA6kxeMvrcp0/O8+T8Lqa2ehymPKKAGArdIQ07y7VaoJzSvTOaiKyvr4Z/euJqLKxUyhj81j3TBp6wWcvvkMYwPCsGp4W/Rysin4zUREVK4qVVLK3d0dv//+u9a2o0ePwt3dPc/3GBoawtDQUGe7vr5+qd3AlmZdVDw8B9Li8ZdWRT/+t2ISMWrjxXwTUgAw36sFFIYG5RZXaaro56CqK6vjz3NKVHkZGcixwac93ttxGUcin2DKtotYMbQN3mhdW+rQiIjoFZJOdJ6YmIjw8HCEh4cDAKKiohAeHo779+8DyOrlNHr0aE35KVOm4M6dO/jwww9x/fp1rFq1Cnv27MHMmTOlCJ+IiF6hUosIvv0ch8IfIvj2c6jUIq5Fx8N7bTAex6eisbUpvnqrFeyUCq332SoVWD2yLfq2tJMociIqiL+/P5ycnODq6ip1KESFZqgnh/+IthjQpjYy1SKm77yMPRceSB0WERG9QtKeUhcuXICHh4fmdfYwOx8fHwQEBCA6OlqToAIABwcH/Pbbb5g5cyZWrlyJunXrYsOGDejTp0+5x05ERP8TFBENv8BIrRX2LE0MkJKhQnK6Ci1qm2PLODdYmhrinfb2CI2KRUxCKqzNFHBzsKhUQ/aIqiNfX1/4+voiPj4eSqVS6nCICk1fLsO3Q9rA2ECOnaEP8OHP/yAlXQWfTg2kDo2IiCBxUqpHjx4QxTzGcwAICAjI9T2XL1e+SXCJiKqqoIhoTN12CTl/mz9PSgcAONQyxo6JHaE0yhoKJZcJcHe0LOcoiYioupLLBCwe1ApG+nrYeDYK83+5iuR0Fab2cJQ6NCKiak/S4XtERFS5qdQi/AIjdRJSr0pJV8PUsFJNYUhERFWMIAj4/I3mmN6zEQDg66DrWH7kRr4PyImIqOwxKUVERMUWGhWrNWQvN4/jUxEaFVtOEREREeVOEATM6t0UH/VtBgD44fgtfPnrNSamiIgkxKQUEREVW0xC/gmpopYjIiIqa1N7OOKLAS0AABvPRmHu/itQqZmYIiKSApNSRERUbNZmioILFaEcERFReRjt3gBL324NmQDsCnuAWXvCkaFSSx0WEVG1w6QUEREVm5uDBcwUec8XJQCwU2atsEdERFSRvNPeHt8Pc4GeTMCh8Ed4d/slpGWqpA6LiKhaYVKKiIiKRRRF+J+4hYTUzFz3C/////O9nCCXCbmWISIiktIbrWtj7ah2MNCT4WjkE0zYfAEp6UxMERGVFyaliIioyERRxFdB1/Ht0X8BAG+2toOtUnuInq1SgdUj26JvSzspQiQiIiqU15rbYNMYVxgbyHH65jP4bAxFQmqG1GEREVULXKObiIgKpFKLCI2KRUxCKqxMDfHblWhsD7kPAPjs9eaY0LWhVhlrs6whe+whRURElUHnRrWwdbwbxmwMQ+jdWIzcEILN49xQw9hA6tCIiKo0JqWIiChfQRHR8AuMRHSc7gp6iwe1wvAO9QAAcpkAd0fL8g6PiIioVLSrb4Gdkzpi1E8h+Pu/OAxddx5bx3eAlZmh1KEREVVZHL5HRER5CoqIxtRtl3JNSAGAhYl+OUdERERUdlrWUWL3ZHdYmxni+uMEeK8NxqOXKVCpRQTffo5D4Q8RfPs5VGpR6lCJiKoE9pQiIqJcqdQi/AIjkddttwDALzASnk62HKZHRERVRhMbM+yZ7I4RG0Jw51kS3vj+DOQyAU8T0zRl7JQKzPdy4ryJREQlxJ5SRESUq9Co2Dx7SAGACCA6LhWhUbHlFxQREVE5aFDLBHumZPWYik1O10pIAcDjuFRM3XYJQRHREkVIRFQ1MClFRES5iknIOyFVnHJERESVia25Is992b2I/QIjOZSPiKgEmJQiIqJcKfQK9yfC2izvm3YiqniioqLg4eEBJycntGrVCklJSVKHRFQhZa0om5bnfvYYJiIqOc4pRUREOp7Ep2Lp4Rv5lhEA2CoVcHOwKJ+giKhUjBkzBgsXLkTXrl0RGxsLQ0OuLEaUG/YYJiIqe+wpRUREWv57kYwha4Nx62kSahhlra6Xcxrz7NfzvZw4yTlRJXL16lXo6+uja9euAAALCwvo6fEZJVFuCtsTmD2GiYiKj0kpIqJqLOcS1zefJOCdNcG49zwZ9SyMEfheF6wZ2Ra2Su0bblulAqtHtuWqQ0Tl7NSpU/Dy8kLt2rUhCAIOHjyoU8bf3x8NGjSAQqFAhw4dEBoaqtl38+ZNmJqawsvLC23btsXixYvLMXqiysXNwQJ2SoXOg5lX1TTWZ49hIqIS4KMxIqJqKigiGn6BkVor7MkEQC0CjlYm2D6hI2yVCthbGMPTyfb/59ZIhbVZ1pA99pAiKn9JSUlwdnbGuHHj8NZbb+ns3717N2bNmoU1a9agQ4cOWLFiBfr06YMbN27A2toamZmZOH36NMLDw2FtbY2+ffvC1dUVnp6eEnwboopNLhMw38sJU7ddgoD/TW7+qpfJGTh4+SEGt6tb3uEREVUJTEoREVVDQRHRmLrtks4NdvYCQpO7O2r1jpLLBLg7WpZfgESUq379+qFfv3557v/2228xceJEjB07FgCwZs0a/Pbbb9i4cSM+/vhj1KlTB+3bt4e9vT0AoH///ggPD88zKZWWloa0tP9N9BwfHw8AyMjIQEZGRml9LY3sOsuibqLieK1pLfww1BkLf7+Ox/H/uxZszQ3hUMsEwXdiMXvv30hITccIN3sJI5UWr12iyqesr9vC1sukFBFRNaNSi/ALjMz1iS+QNV/Ud0f/xeC2ddkbiqgSSU9Px8WLFzF37lzNNplMhl69eiE4OBgA4OrqipiYGLx48QJKpRKnTp3C5MmT86xzyZIl8PPz09l+5MgRGBsbl/6X+H9Hjx4ts7qJiuMjJ+B2vID4DMBcH3A0TwKQBP1kGU49lmFB4DVc+jsCr9XJ669r9cBrl6jyKavrNjk5uVDlmJQiIqpmQqNitYbs5fTqEtfsHUVUutLS0spstbtnz55BpVLBxsZGa7uNjQ2uX78OANDT08PixYvRrVs3iKKI3r1744033sizzrlz52LWrFma1/Hx8bC3t0fv3r1hbm5e6t8hIyMDR48ehaenJ/T19Uu9fqLS9roo4rs/b2H1qSj8cl+Oeg0bYnpPRwhC9Xqow2uXqPIp6+s2u3d1QZiUIiKqZrjENVH5+eOPP7Br1y6cPn0aDx48gFqthomJCVxcXNC7d2+MHTsWtWvXLteYChoC+CpDQ8Nck2j6+vpl2vAs6/qJStNH/Z1gamSApYdv4MeTd5CaKeLT15tXu8QUwGuXqDIqq+u2sHVy9T0iomqGS1wTlb0DBw6gSZMmGDduHPT09PDRRx9h//79OHz4MDZs2IDu3bvjzz//RMOGDTFlyhQ8ffq0xJ9Zq1YtyOVyPHnyRGv7kydPYGtrW+L6iShvvh6NMN/LCQCw4UwUPj0YAbW6eg/lIyIqDPaUIiKqZu4+T8x3vwDAVqngEtdEJfDNN9/gu+++Q79+/SCT6T4DHDJkCADg4cOH+OGHH7Bt2zbMnDmzRJ9pYGCAdu3a4dixYxg4cCAAQK1W49ixY5g2bVqJ6vb394e/vz9UKlWJ6iGqysZ2doCJgR4+2v8PdoTcR2q6Ct+83Rp6cvYDICLKC5NSRETVyMYzUfji10jN65xLXGcPNJjv5cRJzolKIHti8YLUqVMHX331VaHrTUxMxK1btzSvo6KiEB4eDgsLC9SrVw+zZs2Cj48P2rdvDzc3N6xYsQJJSUma1fiKy9fXF76+voiPj4dSqSxRXURV2RBXeygM5Ji1Oxz7Lz9EcroKK4e1gaGeXOrQiIgqJCaliIiqIJVaRGhULGISUmFtltXrac1ft7H08A0AwKRuDeFiXwNf/BqpNem5rVKB+V5O6NvSTqrQiSgfFy5cgIeHh+Z19iTkPj4+CAgIgLe3N54+fYp58+bh8ePHaNOmDYKCgnQmPyeisvOmc20Y6cvhu/0Sgq4+xqQtF7F2VDso9JmYIiLKiUkpIqIqJigiGn6B2skmE0M5ktKyht3M6NUY77/WGIIgoHcLW53kFXtIEZUuURTx888/48SJE4iJiYFardbav3///kLX1aNHD4hi/vPUTJs2rcTD9YioZDydbPDTmPaYtOUi/vr3KXw2huKnMa4wNWTzi4joVRzgTERUhQRFRGPqtktaCSkAmoTU4LZ1MKNXE82KQHKZAHdHSwxoUwfujpZMSBGVgRkzZmDUqFGIioqCqakplEql1k9l4O/vDycnJ7i6ukodClGl0bWxFbaMd4OZoR5ComIxckMI4pIzpA6LiKhCYaqeiKiKUKlF+AVGIr8+FOduP4dKLTL5RFSOtm7div3796N///5Sh1JsnFOKqHhcG1hg+8QOGL0xFOEPXmLo+vPYOt4NtUwNpQ6NiKhCYE8pIqIqIjQqVqeHVE7RcakIjYotp4iICACUSiUaNmwodRhEJJHWdWtg9yR31DI1xLXoeHivDcbjAv5eExFVF0xKERFVETEJhbvBLWw5IiodCxYsgJ+fH1JSUqQOhYgk0tTWDHunuKO2UoHbT5PwztpzeBCbLHVYRESSY1KKiKiKsDZTlGo5IiodQ4YMwYsXL2BtbY1WrVqhbdu2Wj+VAeeUIio5h1om2DPFHfUtjfEgNgXvrAnGrZhEqcMiIpIU55QiIqoimtmZQV8uIEOV+6xSAgBbZdYKe0RUfnx8fHDx4kWMHDkSNjY2moUGKhPOKUVUOurWNMbeye4YsSEEN2MS4b02GFvHd4BTbXOpQyMikgSTUkREVUBsUjp8Nobmm5ACgPleTpzknKic/fbbbzh8+DC6dOkidShEVAFYmyuwe7I7Rm8MQcTDeAxdF4zN49zgUq+m1KEREZU7Dt8jIqrkYhLSMHRdMK48jIOliQE+6d8MdkrtIXq2SgVWj2yLvi3tJIqSqPqyt7eHuTl7QRDR/1iYGGDHxI5oV78m4lMzMXJDCM7feS51WERE5Y49pYiIKhGVWkRoVCxiElJhaayHZ6nA8A1huBebDBtzQ2yf0AGNrM0wvktDTTlrs6whe+whRSSN5cuX48MPP8SaNWvQoEEDqcMhogrCXKGPLePcMHHLBZy7/Rw+G0OxdlQ79GhqLXVoRETlhkkpIqJKIigiGn6BkYh+ZRlpAXKISEbdmkbYMaEj6lkaAwDkMgHujpZShUpErxg5ciSSk5Ph6OgIY2Nj6Ovra+2PjY2VKLLC8/f3h7+/P1QqldShEFUpJoZ62DjGFb7bL+HY9RhM3HIBPwxzYc9mIqo2mJQiIqoEgiKiMXXbJeScMUr8/9mifD0cNQkpIqpYVqxYIXUIJcaJzonKjkJfjjWj2mHG7nD89k80fHdcxrJ3VBjkUlfq0IiIyhyTUkREFZxKLcIvMFInIfWq74/dwpD29ThEj6gC8vHxkToEIqrg9OUyfD/UBUb6cvx88T/M2vM3UtLVGN6hntShERGVKU50TkRUwYVGxWoN2ctNdFwqQqMq/hAgouoiKSmpTMsTUdUjlwn4ZnBr+LjXhygCnxy4gg2n70gdFhFRmWJSioiogotJyD8hVdRyRFT2GjVqhK+++grR0dF5lhFFEUePHkW/fv3w/fffl2N0RFRRyWQCFrzZAlO6OwIAFv52DSv/vAlRzK+/NBFR5cXhe0REFZy1maJUyxFR2Tt58iQ++eQTLFiwAM7Ozmjfvj1q164NhUKBFy9eIDIyEsHBwdDT08PcuXMxefJkqUMmogpCEAR81LcpTA3lWHbkX3z3579ITs/Ex/2aQRA4TJ+IqhYmpYiIKriY+Px7QAkAbJUKuDlYlE9ARFSgpk2bYt++fbh//z727t2L06dP49y5c0hJSUGtWrXg4uKC9evXo1+/fpDL5VKHWyCuvkdUvgRBwLSejWFkoIcvf43E2lN3kJSeiS/ebAkRWUP7YxJSYW2W9fefc0oSUWXFpBQRUQW2J+wBPtr/j+a1AOSY8FwEIGC+lxNvSIkqoHr16mH27NmYPXu21KGUCFffI5LG+C4OMDaQ45MDV7Dt/H3cfJKIe8+T8fiVB1Z2SgXmezmhb0s7CSMlIioezilFRFRBqNQigm8/x6Hwhwi+/Rwbz9zBh/v+gSgCw9zqYdXwtrBVag/Rq2EA/DDUmTeiREREVdQwt3pY4d0GMgEIiYrVSkgBwOO4VEzddglBEXnPYUdEVFGxpxQRUQUQFBENv8DIXFfZm9DFAZ++3hyCIKBPS1tNl31LYz08jTyPPi1sJIiYiIiIyssbrWtjwS9X8SI5Q2dfVp9pwC8wEp5Otuw5TUSVCpNSREQSC4qIxtRtl5DXujrt6tfUTGwqlwlwd7QEAGRkZOD3a+UUJBEREUkmNCo214RUNhFAdFwqQqNiNfcJRESVAYfvERFJSKUW4RcYmWdCSgDwxa+RUKm5FDQREVF1FZOQ/6InRS1HRFRRMClFRCSh0KjYXIfsZXv1yScRVU7379+HKOomlkVRxP379yWIiIgqG2szRcGFilCOiKiiYFKKiEhCfPJJVPU5ODjg6dOnOttjY2Ph4OAgQURF5+/vDycnJ7i6ukodClG15OZgATulAvnNFmVjZgg3B4tyi4mIqDQUKSl17do1zJ8/Hz179oSjoyPs7OzQunVr+Pj4YMeOHUhLSyurOImIqqQaxvqFKscnn0SVlyiKmnnhXpWYmAiFonJc276+voiMjERYWJjUoRBVS3KZgPleTgCQZ2JKJYp49DKl/IIiIioFhZro/NKlS/jwww9x5swZdO7cGR06dMCgQYNgZGSE2NhYRERE4NNPP8V7772HDz/8EDNmzIChoWFZx05EVKklp2di/ak7+ZYRANgqFXzySVQJzZo1CwAgCAI+//xzGBsba/apVCqEhISgTZs2EkVHRJVN35Z2WD2yrc5qvdZmhlCLIp4lpmPI2mBsm9ABjlamEkZKRFR4hUpKDR48GB988AF+/vln1KhRI89ywcHBWLlyJZYvX45PPvmktGIkIqpyElIzMC4gDGF3X8BAT4b0TDUEQGvC8+wnofO9nLi8M1EldPnyZQBZPaWuXLkCAwMDzT4DAwM4Oztjzpw5UoVHRJVQ35Z28HSyRWhULGISUmFtlvXg6lliGkZsCMGtmER4rw3G1vEd0NzOXOpwiYgKVKik1L///gt9/YKHmLi7u8Pd3R0ZGXkvV5qTv78/li5disePH8PZ2Rk//PAD3Nzc8iy/YsUKrF69Gvfv30etWrXw9ttvY8mSJZWm+zsRVT8qtah189jY2hTjNofhn//iYKbQQ8BYNzxNSNV58mmrVGC+lxP6trSTMHoiKq4TJ04AAMaOHYuVK1fC3JwNRCIqOblMgLujpdY2G3MFdk/qiFE/hSIyOh5D153HlnFucLavIU2QRESFVKikVGESUsUpv3v3bsyaNQtr1qxBhw4dsGLFCvTp0wc3btyAtbW1TvkdO3bg448/xsaNG9GpUyf8+++/GDNmDARBwLffflukGImIykNQRLROsklPJiBTLcLCxABbxrmhZR0lAOT65JM9pIgqv02bNkkdAhFVA5amhtg5qSPGbArF5fsvMWJDCH7yaY8ODS0LfjMRkUQKlZR61ffff5/rdkEQoFAo0KhRI3Tr1g1yubzAur799ltMnDgRY8eOBQCsWbMGv/32GzZu3IiPP/5Yp/y5c+fQuXNnDB8+HADQoEEDDBs2DCEhIUX9GkREZS4oIhpTt11CzoXgM9VZW6Z5NNIkpIDcn3wSUeWXlJSEr776CseOHUNMTAzUarXW/jt38p9bjoiosJRG+tg2vgMmbL6A4DvP4bMpFGtHtUf3JlZSh0ZElKsiJ6W+++47PH36FMnJyahZsyYA4MWLFzA2NoapqSliYmLQsGFDnDhxAvb29nnWk56ejosXL2Lu3LmabTKZDL169UJwcHCu7+nUqRO2bduG0NBQuLm54c6dO/j9998xatSoPD8nLS1Na1XA+Ph4AEBGRkaRhhnmJvv9Ja2Hio/nQFo8/nlTqUUs+OWqTkLqVetP38Zw1zrF7g3F4y89ngNplfXxL616J0yYgL/++gujRo2CnZ1drivxERGVFhNDPWwa64qp2y7ixI2nmLj5An4Y7oI+LWylDo2ISEeRk1KLFy/GunXrsGHDBjg6OgIAbt26hcmTJ2PSpEno3Lkzhg4dipkzZ+Lnn3/Os55nz55BpVLBxsZGa7uNjQ2uX7+e63uGDx+OZ8+eoUuXLhBFEZmZmZgyZUq+k6ovWbIEfn5+OtuPHDmitQpOSRw9erRU6qHi4zmQFo+/rptxAh7H599jNDouDT/uDkJjZX6pq4Lx+EuP50BaZXX8k5OTS6WeP/74A7/99hs6d+5cKvURERVEoS/H2lHtMWP3Zfx+5THe3X4J3w5xxoA2daQOjYhIS5GTUp999hn27dunSUgBQKNGjbBs2TIMHjwYd+7cwTfffIPBgweXaqAAcPLkSSxevBirVq1Chw4dcOvWLbz//vv48ssv8fnnn+f6nrlz52qWZAayekrZ29ujd+/eJZ5wNCMjA0ePHoWnp2eR592i0sFzIC0e/7wF/hMNRF4psFzDFm3Qv3XxJjLn8Zcez4G0yvr4Z/euLqmaNWvCwsKiVOoiIiosAz0Zvh/qAiP9K9h36T/M2B2O5HQVhrnVkzo0IiKNIieloqOjkZmZqbM9MzMTjx8/BgDUrl0bCQkJ+dZTq1YtyOVyPHnyRGv7kydPYGube9fSzz//HKNGjcKECRMAAK1atUJSUhImTZqETz/9FDKZTOc9hoaGMDQ01Nmur69fajewpVkXFQ/PgbR4/HXZ1TApdLmSHjsef+nxHEirrI5/adX55ZdfYt68edi8eXOp9dIub/7+/vD394dKpZI6FCIqAj25DEvfbg1jAzm2nr+HufuvIDldhfFdHKQOjYgIAKCbxSnA/7V353FR1fsfx98zA4IokhuLpmFqFuGuGG0uF9fCbDXL3Mr6GbRxu6W3rkSb1S2vWVy9LWZdW2xP0ygjrUwUFcmI1DRSM9AEFQXZZub3B5fJcQBBmTksr+fj4b3Nme/5zodzODPD53y/n+/QoUN1xx13aMuWLY5tW7Zs0YwZMzRs2DBJ0g8//KAuXap/o2vWrJn69++v5ORkxzabzabk5GRFRkZWuk9hYaFL4qmioLrdfmbTXwCgLlmtNlVXNcYkKSSgfIU9AI3bc889p88//1xBQUHq2bOn+vXr5/SvIYiJiVFmZqY2btxodCgAaslsNunRqy7UHZefK0l67NNMvZD8M38/AagXaj1S6tVXX9Utt9yi/v37O+4glpWV6S9/+YteffVVSVLLli313HPPnbKvuLg4TZ48WQMGDFBERITmzZungoICx2p8kyZNUseOHTVnzhxJUnR0tObOnau+ffs6pu/94x//UHR0dI1W+wMAT/hq23793wmr7pkkp4LnFcmq+Oiw0y5yDqDhGDdunNEhAGjiTCaTZo4+Xy18vDR31Q49t2qHCkqsenBUDxZfAGCoWielgoODtWrVKm3fvl3bt2+XJPXo0UM9evRwtBk6dGiN+ho/frz++OMPzZ49Wzk5OerTp4+SkpIcxc/37NnjNDLq4Ycflslk0sMPP6x9+/apffv2io6O1hNPPFHbHwMAzpjVZldqVp4OHC1SoH/5qKekjBzd884WldnsGh4WpLG9Q/Tkym3KPlLk2C84wFfx0WEaFX56taQANCzx8fFGhwAAMplMuvsv3eXXzKLHV/ykhV/vUmFJmR6JvlBmbpIBMEitk1IZGRkKDw93SURJ0scff1zru4GxsbGKjY2t9Lk1a9Y4Pfby8lJ8fDxf7gAYLikjWwnLM52STQHNvZV/vFR2SWN7d9BzN/SWt8WsMT07uCSvGCEFNC2HDx/W+++/r127dulvf/ub2rRpo7S0NAUFBaljR1bDAuA5t112rvyaeemhj3/QGym7VVhi1VPX9JSXpdaVXQDgjNU6KTVy5EitXbvWpWbUBx98oEmTJqmgoKDOggOA+igpI1szTpieV+HI8VJJ0iVd2+pf4/s4Ek8Ws0mRXdt6OEoA9cXWrVsVFRWlgIAA/frrr5o+fbratGmjDz/8UHv27NEbb7xhdIgAmpibBnVW82Zm3f/eVr2/+TcdL7HqX+P7qJkXiSkAnlXrd53bbrtNUVFRjpX2JGnp0qWaNGmSFi9eXJexAUC9Y7XZlbA80yUhdaJfDpKcB/CnuLg4TZkyRT///LN8fX0d28eMGaNvvvnGwMgANGVX9z1biTf1k7fFpBU/ZOv/lmxWUSkrbALwrFonpRISEjRmzBhFRUUpLy9Pb731lqZOnao33nhD119/vTtiBIB6IzUrz2nKXmWyjxQpNSvPQxEBqO82btyoO+64w2V7x44dnW7yAYCnjQoP1suTBsjHy6yvth3QtMUbVVBcZnRYAJqQ0xqf+cILL6h379666KKLNH36dL399tu69tpr6zo2AKh3DhytPiFV23YAGj8fHx/l5+e7bN+xY4fat29vQEQA8KchPQL1+rQItWhm0bpdubrl1Q06crxUVptdKbty9Un6PqXsypXVVt04cQA4PTWqKbVs2TKXbddcc42+/fZbTZgwQSaTydFm7NixdRshANQjgf6+p25Ui3YAGr+xY8fq0Ucf1bvvviupfAWsPXv26MEHH+SmHoB64aJz2+rN6Rdp0qsblLbnsK6c/62Ky2w6cLTY0SaE1YMBuEGNklLVrai3aNEiLVq0SFL5lyyrlXnIABqvfp3Pkq+3WUWltkqfN0kKDihfYQ8AJOm5557Tddddp8DAQB0/flyDBw9WTk6OIiMj9cQTTxgdHgBIkvp0Okvv3B6pG/6Tor2Hjrs8n3OkSDOWpGnBxH4kpgDUmRolpWy2yv/4AoCmpLjMqrvf2VJtQkqS4qPDHCvvAUBAQIBWrVqltWvXauvWrTp27Jj69eunqKgoo0MDACc9gv3V3NusY8Wuz9lV/l0nYXmmhocF810HQJ2oUVIKAJq64yVW3bFks77Z8YeaeZl16yVd9HH6Pqei58EMawdQjUsvvVSXXnqp0WEAQJVSs/L0x7GSKp+3688FXSK7tvVcYAAarRolpd555x3deOONNepw79692rNnjy655JIzCgwAjGK12ZWalacDR4sU6O+rC0L8dft/Nys1K0/NvS16ZfIAXdKtne4f2cOpXUSXNtw1BFCpjRs3avXq1Tpw4IDLCPS5c+caFFXNJSYmKjExkTINQCPHgi4APK1GSakFCxYoISFBU6dOVXR0tC644AKn548cOaLvvvtOS5Ys0apVq/Tqq6+6JVgAcLekjGwlLM90GgHlbTGp1GqXv4+XXps6UANCy+tFWcwm7hICOKUnn3xSDz/8sHr06KGgoCCZTH8mr0/87/osJiZGMTExys/PV0BAgNHhAHATFnQB4Gk1Skp9/fXXWrZsmV544QXNmjVLLVq0UFBQkHx9fXXo0CHl5OSoXbt2mjJlijIyMhQUFOTuuAGgziVlZGvGkjSdvOBxqbV8y13DujkSUgBQU88//7wWLVqkKVOmGB0KAFQroksbhQT4KudIkcv3oQptWzRjQRcAdabGNaXGjh2rsWPH6uDBg1q7dq12796t48ePq127durbt6/69u0rs9nszlgBwG2sNrsSlmdW+QVMkl5b96tuvexcpugBqBWz2UxZAwANgsVsUnx0mGYsSZNJqvR7UX5RqdbtOqjLurf3dHgAGqFaFzpv166dxo0b54ZQAMA4qVl5TlP2KkNhTwCn47777lNiYqLmzZtndCgAcEqjwkO0YGI/l3IGwQG+atuimX78PV+3Lt6kF2/qqxEXBhsYKYDGgNX3AEAU9gTgPvfff7+uuOIKde3aVWFhYfL29nZ6/sMPPzQoMgCo3KjwEA0PC3ZZ0MVqs+ued7bos4wczXgzTXNv6K2r+nQ0OlwADRhJKQAQhT0BuM/dd9+t1atXa+jQoWrbtm2DKW4OoGmrbEEXi9mkFyb01QPvb9WHW/bp3qXpKiq16po+IQZFCaChIykFAJK8LKYqaydIkknlw9Yp7Amgtl5//XV98MEHuuKKK4wOBQDOmJfFrGev763mzSx6c8MePfjBD8o/XqJAowMD0CBRmRxAk7du10FNXpTqSEidPIah4nF8dBhFzgHUWps2bdS1a1ejwwCAOmM2m/T4uHBNv6yLJOmJldv1xW98RwJQe2eclLJarUpPT9ehQ4fqIh4AcCurza6UXbn6JH2fUnblKjlzv6a+tlGFJVZd2q2dnr+xj4IDnKfoBQf4asHEfhoVztB0ALX3yCOPKD4+XoWFhUaHAgB1xmQy6e9jLtC9Ud0lSSv2WvTcqp9lt1e3ljEAOKv19L17771XPXv21K233iqr1arBgwdr3bp18vPz06effqohQ4a4IUwAOHNJGdkuK8lUiLogSC/e1Fe+3hZd2auDS2FPRkgBOF3z58/Xrl27FBQUpNDQUJdC52lpaQZFBgBnxmQy6d6o8+TrZdJTSTu08JssFZXZNfvKMJn57gSgBmqdlHr//fc1ceJESdLy5cuVlZWlbdu26b///a8eeughfffdd3UeJACcqaSMbM1YklZlzahxfTvI19siqfLCngBwusaNG2d0CADgVrdeEqpd23/Se1kWLV73qwqKy/TUtb24qQfglGqdlDp48KCCg4MlSStXrtT111+v8847T9OmTdPzzz9f5wECwJmy2uxKWJ5ZbRHzJ1b8pNHhIXx5AlDn4uPjjQ4BANzu0mC7BvYN18yPMvTe5t90vNSqf43vI28LZYwBVK3W7xBBQUHKzMyU1WpVUlKShg8fLkkqLCyUxWKp8wAB4EylZuVVOmWvgl1S9pEipWbleS4oAE3K4cOH9corr2jWrFnKyyt/r0lLS9O+ffsMjgwA6s7VfTso8aZ+8raY9OnWbM1YsllFpVajwwJQj9U6KTV16lTdcMMNCg8Pl8lkUlRUlCRpw4YNOv/88+s8QAA4UweOVp2QOp12AFAbW7du1Xnnnaenn35azz77rA4fPixJ+vDDDzVr1ixjgwOAOja6Z4heumWAfLzM+vKnA7r19Y0qLCkzOiwA9VStk1KPPPKIXnnlFd1+++367rvv5OPjI0myWCyaOXNmnQcIAGcq0N+nhu18T90IAGopLi5OU6ZM0c8//yxf3z/fZ8aMGaNvvvnGwMgAwD2Gnh+o16YOlF8zi77bmatJr6Yqv6jUZRVkq42V+oCmrtY1pSTpuuuuc3p8+PBhTZ48uU4CAoC6ZLPZtez736ttY5IUHFC+yh4A1LWNGzfqP//5j8v2jh07Kicnx4CIAMD9Lu7aTktuG6Qpi1K1afchXTl/rYpKrTpwtNjRJiTAV/HRYRoVHmJgpACMVOuRUk8//bSWLl3qeHzDDTeobdu2Ovvss7V169Y6DQ4AzkSZ1ab73/teb6fudWw7uYx5xeP46DCKnANwCx8fH+Xn57ts37Fjh9q3b29ARFJoaKh69eqlPn36aOjQoYbEAKDx69e5td6+/SK19PHSnrxCp4SUJOUcKdKMJWlKysg2KEIARqt1UmrhwoXq1KmTJGnVqlVatWqVPvvsM40aNUr3339/nQcIADVx8nDw4yVW3fX2Fn24ZZ8sZpOev7GPFk7sp+AA5yl6wQG+WjCxH3foALjN2LFj9eijj6q0tFSSZDKZtGfPHj344IO69tprDYtr3bp1Sk9P1+rVqw2LAUDjd35wK/l6V/5nZ8XkvYTlmUzlA5qoWk/fy8nJcSSlPv30U91www0aMWKEQkNDNWjQoDoPEABOJSkjWwnLM51W2PPxMqu4zKZmFrNevKmvRlwYLEkaHhas1Kw8HThapED/8il7jJAC4E7PPfecrrvuOgUGBur48eMaPHiwcnJyFBkZqSeeeMLo8ADArVKz8nTwWEmVz5+4CnJk17aeCwxAvVDrkVKtW7fW3r3lU2GSkpIcq+/Z7XZZrSz3CcCzkjKyNWNJmlNCSpKKy2ySpP8bcq4jISVJFrNJkV3b6qo+HRXZtS0JKQBuFxAQoFWrVunTTz/V/PnzFRsbq5UrV+rrr79WixYtat3fN998o+joaHXo0EEmk0kff/yxS5vExESFhobK19dXgwYNUmpqqtPzJpNJgwcP1sCBA/Xmm2+e7o8GAKfEKsgAqlPrkVLXXHONbrrpJnXv3l25ubkaPXq0JGnLli3q1q1bnQcIAFWx2uxKWJ6p6gZ7v7fpN93zl/NIPgEw3CWXXKJLLrnkjPspKChQ7969NW3aNF1zzTUuzy9dulRxcXFauHChBg0apHnz5mnkyJHavn27AgMDJUlr165Vx44dlZ2draioKPXs2VO9evU649gA4GQ1Xd2YVZCBpqnWSal//etfCg0N1d69e/XMM8+oZcuWkqTs7GzdeeeddR4gAFQlNSvPZYTUyRgODsBod999t7p166a7777bafuLL76onTt3at68ebXqb/To0Y6bgpWZO3eupk+frqlTp0oqrwe6YsUKLVq0SDNnzpRUvvKfJIWEhGjMmDFKS0urNClVXFys4uI/CxNXFGwvLS111MiqSxV9uqNvAO5T3bXb92x/Bbfy0f784ipvJLZt0Ux9z/bn2gc8yN2fuTXtt9ZJKW9v70oLmt9333217QoAzgjDwQE0BB988IGWLVvmsv3iiy/WU089VeukVHVKSkq0efNmzZo1y7HNbDYrKipKKSkpkspHWtlsNvn7++vYsWP66quvdMMNN1Ta35w5c5SQkOCy/YsvvpCfn1+dxX2yVatWua1vAO5T1bU7JtikRfkVlWNOHL1ul2TSkcJizX8nST3Ootg54Gnu+swtLCysUbtaJ6UqZGZmas+ePSopcS5aN3bs2NPtEgBqheHgABqC3NxcBQQEuGxv1aqVDh48WKevdfDgQVmtVgUFBTltDwoK0rZt2yRJ+/fv19VXXy1Jslqtmj59ugYOHFhpf7NmzVJcXJzjcX5+vjp16qQRI0aoVatWdRq7VH5XddWqVRo+fLi8vb3rvH8A7nGqa3eMpH4/7tfjK7cpJ//P0ZfBrXzV2s9bP+Uc0ys/e2v++F76y/mBHowcaLrc/ZlbMbr6VGqdlPrll1909dVX64cffpDJZJLdXp7NNpnKM94UOwfgKW1aNJPZJFW1grBJUnBA+Qp7AGCUbt26KSkpSbGxsU7bP/vsM5177rkej+fcc8/V999/X6O2Pj4+8vHxcdnu7e3t1qSRu/sH4B7VXbtX9jlbo3t1dFkFucxm091vb9HnP+5X7Nvf61/j+yi6dwcPRw40Xe76zK1pn7VOSt1zzz3q0qWLkpOT1aVLF6Wmpio3N1d//etf9eyzz9Y6UAA4HT9l52viKxuqTUhJUnx0GEXOARgqLi5OsbGx+uOPPzRs2DBJUnJysp577rk6nbonSe3atZPFYtH+/fudtu/fv1/BwcFV7AUAnlGxCrLzNosSb+qn+9/7Xh+n/6573tmi46VW3TCgk0FRAvAk86mbOEtJSdGjjz6qdu3ayWw2y2w269JLL9WcOXNcCngCwJmy2uxK2ZWrT9L3KWVXrqw2u9L3HtaNL61XbkGJLuzQSv+8rpdCApyn6AUH+GrBxH4aFR5iUOQAUG7atGl67rnn9Oqrr2ro0KEaOnSolixZogULFmj69Ol1+lrNmjVT//79lZyc7Nhms9mUnJysyMjI0+43MTFRYWFhVU7zA4Az4WUx67kb+mhCRCfZ7NID72/V6+t+NTosAB5Q65FSVqtV/v7+ksrvxv3+++/q0aOHzjnnHG3fvr3OAwTQdCVlZCtheabTCnttWjRTQXGZists6n9Oay2aMlABzb11Tb+zXYaDM0IKQH0xY8YMzZgxQ3/88YeaN2/uWL34dBw7dkw7d+50PM7KylJ6erratGmjzp07Ky4uTpMnT9aAAQMUERGhefPmqaCgwLEa3+mIiYlRTEyM8vPzK62PBQBnymI26cmre8qvmZdeXZul+GU/qqCkTHcO6WZ0aADcqNZJqfDwcH3//ffq0qWLBg0apGeeeUbNmjXTSy+9ZEhdBACNU1JGtmYsSXNZOjivoHxxhR5BLfXGtAi18Cl/G6tsODgA1Dft27c/4z42bdqkoUOHOh5XFCKfPHmyFi9erPHjx+uPP/7Q7NmzlZOToz59+igpKcml+DkA1Dcmk0kPX3GBWjSzaP5XO/VM0nYVFlv11xHnOWoYA2hcap2Uevjhh1VQUCBJevTRR3XllVfqsssuU9u2bbV06dI6DxBA02O12ZWwPNMlIXWiI0Vl8vW2eCwmADgT77//vt59991KVy5OS0urVV9DhgxxLDRTldjYWJfC6mciMTFRiYmJLGgDwO1MJpPiRvSQn4+Xnvpsm15cvVMFJWWafWUYiSmgEap1TamRI0fqmmuukVS+msy2bdt08OBBHThwwFG8EwDORGpWntOUvcrkHClSalaehyICgNM3f/58TZ06VUFBQdqyZYsiIiLUtm1b/fLLLxo9erTR4dVITEyMMjMztXHjRqNDAdBE/N/grnrsqgslSa9996tmffiDrDZ7pfVGATRctR4pVZk2bVhuHUDdOXC0+oRUbdsBgJH+/e9/66WXXtKECRO0ePFiPfDAAzr33HM1e/Zs5eWRXAeAqtwSGarmzbz0wPvf652Ne7XzwDH9dui4cvL//A4YEuCr+OgwFrcBGqgaJ6WmTZtWo3aLFi067WAAQJIC/X1P3agW7QDASHv27NHFF18sSWrevLmOHj0qSbrlllt00UUX6cUXXzQyPACo167rf7aae1t019tp2rT7kMvzOUeKNGNJGqsuAw1UjafvLV68WKtXr9bhw4d16NChKv8BwJkaGNpaLX2qzpmbVH5XLKILozQB1H/BwcGOEVGdO3fW+vXrJZWvmneq2lAAAGlUeLACmntX+lzFu2jC8kym8gENUI1HSs2YMUNvv/22srKyNHXqVE2cOJFpewDqnN1u1z8/365jxWWVPl9R3jI+OkwWM8UuAdR/w4YN07Jly9S3b19NnTpV9913n95//31t2rTJUaezvqPQOQAjpWbl6VBhaZXP2yVl/6/eKKsxAw1LjUdKJSYmKjs7Ww888ICWL1+uTp066YYbbtDnn3/OXT4AdcJms+sfn2ToP9/8Ikm6rl9HhQQ4T9ELDvBleDaABuWll17SQw89JKm8YPiiRYt0wQUX6NFHH9WCBQsMjq5mKHQOwEjUGwUar1oVOvfx8dGECRM0YcIE7d69W4sXL9add96psrIy/fjjj2rZsqW74gTQyFhtdqVm5enA0SIF+vuqX+ezNOujH/Rh2j6ZTNKTV/fUhIjOLu0iurRhhBSABsVsNsts/vM+4I033qgbb7zRwIgAoGGh3ijQeJ326ntms1kmk0l2u52h3ABqJSkjWwnLM5V95M+7Wb7eZhWV2mQxm/Tc9b01rm9HSZLFbGIYNoAGZ+vWrTVu26tXLzdGAgANX0SXNgoJ8FXOkSJVNUcn0N+HeqNAA1SrpFRxcbE+/PBDLVq0SGvXrtWVV16pF198UaNGjXK6AwgAVUnKyNaMJWkuXyiKSm2SpNsu7eJISAFAQ9WnTx/HzbvqmEwmbu4BwClYzCbFR4dpxpI0maRKE1NlVrt+O1Soc9q28HR4AM5AjZNSd955p9555x116tRJ06ZN09tvv6127dq5MzYAjYzVZlfC8swq73BJ0rLvf9cDo85nih6ABi0rK8voEOoUhc4BGG1UeIgWTOznMto+0N9HknTgaLGuX5iiN28bpO5B/kaFCaCWapyUWrhwoTp37qxzzz1XX3/9tb7++utK23344Yd1FhyAxiU1K8/pS0RlWDkFQGNwzjnnGB1CnYqJiVFMTIzy8/MVEBBgdDgAmqhR4SEaHhbsUm80t6BYt7ySqu37j2r8S+v1xrQIhXfkvQpoCGqclJo0aZJMJkYuADh9rJwCoKnavn27XnjhBf3000+SpAsuuEB33XWXevToYXBkANCwVFZvNNDfV+/cfpEmv5aqrb8d0YSX12vx1Aj1P6e1QVECqKkaJ6UWL17sxjAANAWsnAKgKfrggw904403asCAAYqMjJQkrV+/XuHh4XrnnXd07bXXGhwhADR8rVs005u3DdK0xRu18ddDuuXVDXpl0gBd3I2SM0B9RnVyAB4TEuArSzUjLk3/a8PKKQAakwceeECzZs1SSkqK5s6dq7lz52rdunX6+9//rgceeMDo8ACg0fD39dbr0yJ0Wfd2Kiyxasrijfpq236jwwJQDcOTUomJiQoNDZWvr68GDRqk1NTUatsfPnxYMTExCgkJkY+Pj8477zytXLnSQ9ECOF27/jimCS+vl7WKlagqUlXx0WEUOQfQqGRnZ2vSpEku2ydOnKjs7GwDIgKAxsuvmZdenjRAURcEqaTMptvf2KwVW8vfa602u1J25eqT9H1K2ZUrq636FVIBuF+Np++5w9KlSxUXF6eFCxdq0KBBmjdvnkaOHKnt27crMDDQpX1JSYmGDx+uwMBAvf/+++rYsaN2796ts846y/PBA6iS1WZ3KkDp7+ulKa+l6uCxEnVt30K3XXau5if/7FT0PDjAV/HRYRoVHmJg5ABQ94YMGaJvv/1W3bp1c9q+du1aXXbZZQZFVTusvgegIfH1tmjBxH7667vfa9n3v+uut9OUmnWOvsjc7/T9M4Tvn4DhDE1KzZ07V9OnT9fUqVMlla/wt2LFCi1atEgzZ850ab9o0SLl5eVp3bp18vb2liSFhoZ6MmQAp5CUke2yVK9Jkl1SWEgr/ffWCLVt6aMbBnRyWTmFEVIAGqOxY8fqwQcf1ObNm3XRRRdJKq8p9d577ykhIUHLli1zalsfsfoegIbG22LWv8b3UXNvi5Zu2qvXU3a7tMk5UqQZS9K0YGI/ElOAQQxLSpWUlGjz5s2aNWuWY5vZbFZUVJRSUlIq3WfZsmWKjIxUTEyMPvnkE7Vv31433XSTHnzwQVkslkr3KS4uVnFxseNxfn6+JKm0tFSlpaVn9DNU7H+m/eD0cQ6MdfLx//zH/brrne918kDoisdTIjurlY/Z0X5A51aSWkmSbNYy2bgBXyv8/huPc2Asdx//uur3zjvvlCT9+9//1r///e9Kn5Mkk8nESCQAqEMWs0mPjwvX8q2/q7DE9f3VrvKbpwnLMzU8LJgbpIABDEtKHTx4UFarVUFBQU7bg4KCtG3btkr3+eWXX/TVV1/p5ptv1sqVK7Vz507deeedKi0tVXx8fKX7zJkzRwkJCS7bv/jiC/n5+Z35DyJp1apVddIPTh/nwFirVq2SzS4lpFn+l4Cq7APdric//UHev6eLz/u6xe+/8TgHxnLX8S8sLKyTfmw2W530AwCovU27D1WakKpgl5R9pEipWXmK7NrWc4EBkGTw9L3astlsCgwM1EsvvSSLxaL+/ftr3759+uc//1llUmrWrFmKi4tzPM7Pz1enTp00YsQItWrV6oziKS0t1apVqzR8+HDHdEJ4FufAWCce/7Tfjurw+k3VtDbpcInUPuwiDWJ1vTrB77/xOAfGcvfxrxhd7Q6HDx+mJiYAeMCBo0WnblSLdgDqlmFJqXbt2slisWj/fuclOvfv36/g4OBK9wkJCZG3t7fTVL0LLrhAOTk5KikpUbNmzVz28fHxkY+Pj8t2b2/vOvsCW5d94fRwDozl7e2t3MKyGrXNLSzjXNUxfv+NxzkwlruOf131+fTTTys0NFTjx4+XJF1//fX64IMPFBISopUrV6p379518joAAFeB/r512g5A3TIb9cLNmjVT//79lZyc7Nhms9mUnJysyMjISve55JJLtHPnTqdh8Dt27FBISEilCSkAnsMHPgBUbuHCherUqZOk8qmGX375pZKSkjR69Gj97W9/Mzg6AGjcIrq0UUiAb6XFJSqEBJQvugPA8wxLSklSXFycXn75Zb3++uv66aefNGPGDBUUFDhW45s0aZJTIfQZM2YoLy9P99xzj3bs2KEVK1boySefVExMjFE/AoD/yfj9SLXPm8QHPoCmKScnx5GU+vTTT3XDDTdoxIgReuCBB7Rx40aDo6uZxMREhYWFaeDAgUaHAgC1YjGbFB8dJqnyqqeSFNTKR2XU/wMMYWhSavz48Xr22Wc1e/Zs9enTR+np6UpKSnIUP9+zZ4+ys7Md7Tt16qTPP/9cGzduVK9evXT33Xfrnnvu0cyZM436EYAmz26X/r3mFz2x4ifHtpM/8Csex0eHsaoJgCandevW2rt3ryQpKSlJUVFRkiS73d5gVtuLiYlRZmZmg0miAcCJRoWHaMHEfgoOcB6x39rPW15mk9L3HtHtb2zW8WoKogNwD8MLncfGxio2NrbS59asWeOyLTIyUuvXr3dzVAAqY7XZlZqVpwNHixTo76s+HVvq0z1mffn7TknSfVHn6byglnr000xlH/mzWGRwgK/io8M0KjzEqNABwDDXXHONbrrpJnXv3l25ubkaPXq0JGnLli3q1q2bwdEBQNMwKjxEw8OCnb7LRnRpo5RduZr+xiZ9veMPTXktVa9OGaiWPob/mQw0GVxtAGokKSNbCcudk01+zSwqLCkfcPnQmAs0/fJzJUkjLnT9wGeEFICm6l//+pdCQ0O1d+9ePfPMM2rZsqUkKTs7W3feeafB0QFA02ExmxTZta3Ttku7t9N/b43Q1Nc2akNWnm5+ZYNenzpQZ/lRsxjwBJJSAE4pKSNbM5akyX7S9sISqyS7bhxwtiMhJVX+gQ8ATZW3t7fuv/9+l+333XefAdEAAE42ILSN3pp+kW5ZtEHf7z2sG19ar//eOkjt/V1XcQdQt0hKAaiW1WZXwvJMl4TUib7++aCsNjujoQDgf5YtW6bRo0fL29tby5Ytq7bt2LFjPRQVAKAqPc8O0NLbIzXx1Q3alnNU419K0Zu3DVKgvy8zAAA3IikFoFqpWXlOU/ZcmZR9pFipWXmMjgKA/xk3bpxycnIUGBiocePGVdnOZDI1mGLnANDY9Qj217t3ROrml9frlz8KdOX8tTKbTPrjWLGjTQi1UoE6ZejqewDqvwNHq0tI1b4dADQFNptNgYGBjv+u6h8JKQCoX7q0a6H3Zlys9i2bKbegxCkhJUk5R4o0Y0makjKyq+gBQG2QlAJQrUB/31M3qkU7AAAAoD4LbuUrk6nyKXoVJS0SlmfKaquuwAWAmiApBaBa3QJbyqvaefN2hQT4KKJLG4/FBAANhc1m06JFi3TllVcqPDxcPXv21NixY/XGG2/IbuePGQCoj8prSBVX+bxdUvaRIqVm5XkuKKCRIikFoEoH8ot008vrVVbFXaCKVNVDo8+n4CMAnMRut2vs2LG67bbbtG/fPvXs2VMXXnihdu/erSlTpujqq682OsQaS0xMVFhYmAYOHGh0KADgdpSvADyHQucAZLXZXVYVyT5yXDe/skG7cwsV1MpH/ze4q1765henoufBAT4aHVSokRcGGRg9ANRPixcv1jfffKPk5GQNHTrU6bmvvvpK48aN0xtvvKFJkyYZFGHNxcTEKCYmRvn5+QoICDA6HABwK8pXAJ5DUgpo4pIyspWwPNMp2dS+pY/KbDYdKixVpzbN9eatF6lzWz9Nigx1Sl71Pdtfnyd9ZmD0AFB/vf322/r73//ukpCSpGHDhmnmzJl68803G0RSCgCakogubRQS4KucI0WqaqJ1az9vylcAdYDpe0ATlpSRrRlL0pwSUpL0x7FiHSosVVArH717R6Q6t/WTJFnMJkV2baur+nRUZNe2TNkDgGps3bpVo0aNqvL50aNH6/vvv/dgRACAmrCYTYqPDpP0Z7mKkx0uLNUn6fs8FxTQSJGUApooq82uhOWZVd79qcCwZAA4PXl5eQoKqnp6c1BQkA4dOuTBiAAANTUqPEQLJvZTcIDzd+GQAF9FnttWdklx736vJet3GxMg0EgwfQ9oolKz8lxGSJ1sf36xUrPyFNm1rYeiAoDGw2q1ysur6q9aFotFZWVlHowIAFAbo8JDNDws2KX2qknSo59mavG6X/Xwxxk6XmLV9MvPNTpcoEEiKQU0UawqAgDuZbfbNWXKFPn4+FT6fHFx1cuNAwDqh4ryFSeLjw6TXzOL/r1ml55Y+ZMKSsoUO7SbNv56yCmBRbkLoHokpYAmilVFAMC9Jk+efMo2FDkHgIbJZDLpgVHnq4WPl/75+XbN+/JnvfzNLyoosTrahAT4Kj46TKPCQwyMFKjfSEoBTVRElzY6q7m3Dh8vrfR5k6TgAF9WFQGA0/Taa68ZHQIAwM1ihnbTrwcL9N7m35wSUpKUc6RIM5akacHEfiSmgCpQ6Bxooj7Y/Fu1CSmpfFgyQ44BAACAylltdq3debDS5yoWFEpYnimr7VTLCwFNE0kpoAla/F2WHvhgqyTp0m7tFNzKeYpecIAvd3QAAACAUzjV4kF2SdlHipSalee5oIAGhOl7QCNntdmdVgzZtDtPz32xQ5J066Vd9PAVF8hml8uqIoyQAgAAAKrH4kHAmSEpBTRiSRnZSlieWendm7v/0l33RXWXyWSSxaRKVxUBAAAAUDUWDwLODNP3gEYqKSNbM5akVTmcOCzEXyYTo6EAAKeWmJiosLAwDRw40OhQAKBeiejSRiEBvqruW7W3xaQeQf4eiwloSEhKAY2Q1WZXwvJMVVVO0SQKLgIAai4mJkaZmZnauHGj0aEAQL1iMZsUHx0mSVUmpkqtdk18dYNyjxV7LjCggSApBTRCFFwEAAAAPGNUeIgWTOyn4ADnKXohAb56+MoL1K6ljzKz83XDf1KU87/v6FabXSm7cvVJ+j6l7MrlZjGaLGpKAY0QBRcBAAAAzxkVHqLhYcGVLh40rEegbn5lg3b9UaDr/7NOd1zeVYmrdzrdRA4J8FV8dBirX6PJYaQU0AgFNPeuUTsKLgIAAAB1w2I2KbJrW13Vp6Miu7Z1rGZ9bvuWeveOSJ3T1k97847r4Y8zXGY15Bwp0owlaUrKyDYidMAwJKWARia/qFQvfvVztW1MKr8bE9GljWeCAgAAAJqwTm389Pb0ixyJqpNVTN6j7iuaGpJSQCNyqKBEN7+8QZt2H5avd/nlffLHXsXj+OiwKj8UAQAAANSt3bmF1SacqPuKpoiaUkADZbXZneash7bz05RFG7V9/1G1adFMb0yL0G+HCpWwPNNpeHAw89UBAAAAj6PuK+CKpBTQACVlZLskmyxmk6w2uwL9ffTmbYPUPchf4R0Dqiy4CAAAAMBzalrPlbqvaEpISgENTFJGtmYsSdPJA38rhgLfNaybugf5O7ZXFFwEAAAAYJyILm0UEuCrnCNFLt/lK1D3FU0NNaWABsRqsytheWaVH2KS9O81uyiOCAAAANQzFrNJ8dFhklzrvlYYFR7MrAY0KSSlgAYkNSvPZfnYk1EcEQAAAKifRoWHaMHEfgoOcJ6i19zbIklavO5XvbVhj6TyG9Ipu3L1Sfo+pezK5cYzGiWm7wENCMURAQAAgIZtVHiIS93XAee01qOfZuq/63fr7x/9oLTdefpuV67TDekQFixCI0RSCmhAKI4IAAAANHyV1X199KoL5edj0X++/kXvp+1z2SfnSJFmLEnTgon9SEyh0WD6HtCAHCsqrfZ5kyiOCAAAADREJpNJfxvRQy19Kh87UjF5L2F5JlP50GiQlAIaiE+3/q4Zb6Y5Hp9c/rDicXx0GMURAQAAgAZo46+HdKy4rMrn7aKGLBoXklJAPVNZQcN3N+3V3W9vUZnNrqv6dNCLN/V1KY4YHODLUF4AAACgAaOGLJoaakoB9UhSRrYSlmc6FTRs5eul/KLyuyUTIjrp8XE9ZTGbNDo8xKk4YkSXNoyQAgDUSGFhoS644AJdf/31evbZZ40OBwDwP9SQRVNDUgqoJ5IysjVjSZpOnh1ekZAadn6gnry6p0ym8sRTZcURAQCoiSeeeEIXXXSR0WEAAE4S0aWNQgJ8lXOkyOXvggrB1JBFI8L0PaAesNrsSlieWeUHjyT9lJ0v6hkCAM7Uzz//rG3btmn06NFGhwIAOInFbFJ8dJgk1xqyFQJ8vVRUavVcUIAbkZQC6oHUrDynKXuVoaAhAOCbb75RdHS0OnToIJPJpI8//tilTWJiokJDQ+Xr66tBgwYpNTXV6fn7779fc+bM8VDEAIDaGhUeogUT+7nUkG3bopl8vMzavv+Ybnl1g44cL620Hi3QkDB9D6gHKGgIAKiJgoIC9e7dW9OmTdM111zj8vzSpUsVFxenhQsXatCgQZo3b55Gjhyp7du3KzAwUJ988onOO+88nXfeeVq3bp0BPwEAoCZGhYdoeFiwSw3ZH/Yd0aRXNyhtz2FdOf9bFZfZdOBosWO/kABfxUeHsfgRGgySUkA9QEFDAEBNjB49utppd3PnztX06dM1depUSdLChQu1YsUKLVq0SDNnztT69ev1zjvv6L333tOxY8dUWlqqVq1aafbs2ZX2V1xcrOLiP//Yyc/PlySVlpaqtLS0Dn8yOfo98f8BNAxcu+4zoHMrSa0kSTZrmS4MbqEl0wbqpldTtffQcZf2OUeKNGNJml64sbdGXhjk4WjRkLj7uq1pvySlgHqgd6cA+XiZVVxmq/R5kyhoCACoXklJiTZv3qxZs2Y5tpnNZkVFRSklJUWSNGfOHMfUvcWLFysjI6PKhFRF+4SEBJftX3zxhfz8/Or4J/jTqlWr3NY3APfh2vUMm10y2Sz/e+Rcecr+v/99+MN0lf5qFYtz41Tcdd0WFhbWqB1JKcBgx0us+r8ladUmpCQpPjpMFj5VAABVOHjwoKxWq4KCnO+MBwUFadu2bafV56xZsxQXF+d4nJ+fr06dOmnEiBFq1arVGcVbmdLSUq1atUrDhw+Xt7d3nfcPwD24dj1rQ1aejq7fVE0Lkw6XSO3DLtIgbmqjCu6+bitGV58KSSnAQEeLSnXr65uUmpWn5t4W3XH5uVq6aa9T0fNg5oUDANxgypQpp2zj4+MjHx8fl+3e3t5u/cPT3f0DcA+uXc/ILSyrcTvOB07FXddtTfskKQV4iNVmdypUeF5QS01bvFHf/3ZE/j5eem3qQA0IbaO7/tLdpaAhI6QAAKfSrl07WSwW7d+/32n7/v37FRwcfEZ9JyYmKjExUVYrS5ADgNGoR4vGhKQU4AFJGdlKWJ7pNALKy2xSmc2u1n7e+u+tgxTeMUCSZDGbFNm1rVGhAgAaqGbNmql///5KTk7WuHHjJEk2m03JycmKjY09o75jYmIUExOj/Px8BQQE1EG0AIDTFdGljUICfJVzpOh/NaRctW3RTBFd2rjcGOeGN+obklKAmyVlZGvGkjSXD4wyW/mWu4Z1dySkAACozrFjx7Rz507H46ysLKWnp6tNmzbq3Lmz4uLiNHnyZA0YMEARERGaN2+eCgoKHKvxAQAaPovZpPjoMM1YkiaTVGliKr+oVM8n79B7m35zujEeQmkQ1DNmowMAGjOrza6E5ZlV3sGQpJe//UVWW3UtAAAot2nTJvXt21d9+/aVJMXFxalv376OFfTGjx+vZ599VrNnz1afPn2Unp6upKQkl+LnAICGbVR4iBZM7KfgAOcpesEBvrqwQyuVWu2an7zTKSElSTlHijRjSZqSMrI9GS5QJUZKAW6UmpXn8kFwsuwjRUrNymPKHgDglIYMGSK7vfobGbGxsWc8Xe9k1JQCgPpnVHiIhocFu0zPKymzqe+jX6ioktW97Spf3TtheaaGhwUzlQ+GIykFuNGBo9UnpGrbDgAAI1BTCgDqp8rq0abvPVxpQqqCXdwYR/3B9D3AjVgZAwAAAIAncWMcDUm9SEolJiYqNDRUvr6+GjRokFJTU2u03zvvvCOTyeRYYQaob2w2u6obEGtSebHBiC5tPBUSAAAAgEaMG+NoSAxPSi1dulRxcXGKj49XWlqaevfurZEjR+rAgQPV7vfrr7/q/vvv12WXXeahSIHaWb3tgKa9vtFR5Pzk5FTF4/joMOZyAwAAAKgTEV3aKCTAt9qb4yEBvup/Tmul7MrVJ+n7lLIrl8WXYAjDk1Jz587V9OnTNXXqVIWFhWnhwoXy8/PTokWLqtzHarXq5ptvVkJCgs4991wPRgtUzmqzO72hr/j+d93+300qLrMp6oIgzb+xT6UrYyyY2I/lWAEA9V5iYqLCwsI0cOBAo0MBAJyCxWxSfHSYJNcb4xXatmimy59ZrQkvr9c976RrwsvrdenTX7EqHzzO0ELnJSUl2rx5s2bNmuXYZjabFRUVpZSUlCr3e/TRRxUYGKhbb71V3377bbWvUVxcrOLiYsfj/Px8SVJpaalKS0vPKP6K/c+0H5y++nAOPv9xvx5fuU05+cUuz10RHqx/Xhcub4tZIy5or027D+nA0WIF+vtowDmtZTGbGvTvT304/k0Zx994nANjufv4c17/RKFzAGhYRoWHaMHEfkpYnum0GnhAc28dOV6qjN/zXfbJOVKkGUvSuHEOjzI0KXXw4EFZrVYFBQU5bQ8KCtK2bdsq3Wft2rV69dVXlZ6eXqPXmDNnjhISEly2f/HFF/Lz86t1zJVZtWpVnfSD02fUOfg+16RFOyoGHJ58H8KuwJJ9WvX5b05bLZJyJX3+kwcC9BCuAWNx/I3HOTCWu45/YWGhW/oFAMATRoWHaHhYsFKz8nTgaJEC/cun7A184ksdOe5648Wu8r9oEpZnanhYMCVG4BGGJqVq6+jRo7rlllv08ssvq127djXaZ9asWYqLi3M8zs/PV6dOnTRixAi1atXqjOIpLS3VqlWrNHz4cHl7e59RXzg9Rp4Dq82uOc99I8l1hJQkmWRS0n4/PXjz5Y32DZ1rwFgcf+NxDozl7uNfMboaAICGymI2KbJrW8fjlF25lSakKtglZR8pUmpWntN+gLsYmpRq166dLBaL9u/f77R9//79Cg4Odmm/a9cu/frrr4qOjnZss9lskiQvLy9t375dXbt2ddrHx8dHPj4+Ln15e3vX2RfYuuwLp8eIc7BpV26lU/YqlL+hF2vLb0cb/Rs614CxOP7G4xwYy13Hn3MKAGhsDhwtOnWjWrQDzpShhc6bNWum/v37Kzk52bHNZrMpOTlZkZGRLu3PP/98/fDDD0pPT3f8Gzt2rIYOHar09HR16tTJk+GjieMNHQDQVFDoHAAah0B/31M3qkU74EwZPn0vLi5OkydP1oABAxQREaF58+apoKBAU6dOlSRNmjRJHTt21Jw5c+Tr66vw8HCn/c866yxJctkOuFv7lq4j8CrDGzoAoKGj0DkANA4RXdooJMBXOUeKZK+iTVArH/U/p7VSduU6alFFdGnTaEuSwFiGJ6XGjx+vP/74Q7Nnz1ZOTo769OmjpKQkR/HzPXv2yGw2dEAX4KLMatN7m/ZW28YkKTig/A0cAAAAAIxmMZsUHx2mGUvSZJIqTUwVl9l06dNf6cDRP0uVhAT4Kj46jFX5UOcMT0pJUmxsrGJjYyt9bs2aNdXuu3jx4roPCKhGcZlV97ydrqQfc2Q2STa7XN7QK+4hxEeHcUcBAAAAQL0xKjxECyb2U8LyTGUf+bPUSHt/HxUUl+pwoWsh9JwjRZqxJE0LJvYjMYU6VS+SUkB9ZbXZnZZQ7XV2gO58M01f7/hDzSxmJd7cT1abzeUNPZg7CQAAAADqqVHhIRoeFuz0t07/c1rrkqe+UmGJ62JOdpXfeE9YnqnhYcHceEedISkFVCEpI9sl2dTMYlKJ1a7m3ha9NKm/LuveXpJc3tCZcw0AAACgPrOYTU6rhKfsytUfx061uniRUrPyGv3q4vAcklJAJZIysjVjSZrLHOsSa/mWmKFdHQkpyfUNHQCAxiQxMVGJiYmyWq1GhwIAcBNWF4cRqCAOnMRqsytheWaVq1FI0psb9shqq64FAACNR0xMjDIzM7Vx40ajQwEAuElNVw0/eLRYn6TvU8quXP4mwhljpBRwktSsPKcpe5Vh2CoAAACAxiSiSxuFBPgq50hRlTfoTSbpsRU/OR6zKh/OFCOlgJMwbBUAAABAU2MxmxQfHSbpz9XET2Y/KVtVsSpfUka2e4NDo0VSCjhJTYet1rQdAAAAADQEo8JDtGBiPwUHOP+tU9UaThU5qoTlmUzlw2lh+h5wkpY+XjKbpKreU02SggPKV9gDAAAAgMZkVHiI0+riB48WO03ZOxmr8uFMkJQCTrBlzyFNXpTqSEiZJKf51BU3COKjw2Sp6nYBAAAAADRgJ64u/kn6vhrtQ3kTnA6m76FJstrsStmV67RqxPpfcjXxlQ3KLypT/3Naa+4NvV2GrQYH+GrBxH4U8gMANCmJiYkKCwvTwIEDjQ4FAOBhrMoHd2KkFJqcpIxsJSzPdFphr7Wft44WlanMZtfFXdvq5UkD1MLHS1f16egYthroXz5ljxFSAICmJiYmRjExMcrPz1dAQIDR4QAAPKhGq/KJVflwehgphSYlKSNbM5akOSWkJOlQYanKbHb17NhKi6YMVAuf8nxtxbDVq/p0VGTXtiSkAAAAADQpNVqV76THrMqHmiIphSbDarMrYXlmldl9STp4rETeFi4LAAAAAKjAqnxwF6bvoclIzcpzGSF1MlaNAAAAAABXrMoHdyAphSajpqtBsGoEAAAAALg6nVX5vtv5BzV6USWSUmgyarpqRE3bAQAAAEBTVdO/m15cvcvx3xRAx8konoMmY2Boa7VoZqnyeZPK3yQjurTxXFAAAAAA0ABVrMpXm3FPFEDHyUhKoUmw2ex6ZPmPKiixVvp8xRtpfHQYw0kBAAAA4BRqsirfySiAjpORlEKjV2a16f73v9eS9XtkMkk3D+qskJNWjQgO8NWCif0YRgoAQCUSExMVFhamgQMHGh0KAKAeqWpVvuqcWAAdoKYUGhWrze5YDSLQ31d9Op2lv76XrpU/5MhiNmnuDb11VZ+OLu0ouAcAQNViYmIUExOj/Px8BQQEGB0OAKAeOXlVvp/3H9OLq3eecj8KoEMiKYVGJCkjWwnLM5V95M/V83y8zCous6mZxawXbuqrkRcGS3JeNQIAAAAAcPpO/PsqZVdujZJSFECHxPQ9NBKf/7hfM5akOSWkJKm4zCZJumPwuY6EFAAAAADAPSiAjtogKYUGz2aXHl+5TdWVyXt/828U0gMAAAAAN6MAOmqDpBQavF35JuXkF1fbhkJ6AAAAAOAZFEBHTVFTCg1efmnN2h04WnTqRgAAAACAM3a6BdA/+98UPoqfNw2MlEKD18q7Zu0C/WuepQcAAAAAnJmKAuhX9emoS7q1q9E+b6Ts1oSX1+vSp7+ixlQTQFIKDV5Lb7uqS6CbVL6aQ0SXNh6LCQAAAADwp9oWQKf4edNAUgoN2raco3ox06KqauFVvOHFR4cx9BMAAAAADFLbAugUP28aSEqhwbDa7ErZlatP0vcpZVeu0nYf0sRFG3Ws1KQLgv31z+t6KeSkQnrBAb5aMLGfRoWHGBQ1AAAAAECqfQF0ip83fhQ6R4OQlJGthOWZyj7yZ7Fyk8rfpEJb2rVk2gC1beWna/qd7SikF+jvS3E8AAAAAKhHTiyA/llGtt5I2X3KfSh+3niRlEK9l5SRrRlL0nTygM2Kx5cF29SqeXm184pCegAAAACA+unEv9tqkpR6I2W33kjZrZAAX8VHhzETphFh+h7qNavNroTlmS4JqQomScv3mJljDAAAAAANDMXPQVIK9VpqVp7TlL2T2SUdLjFp0+5DngsKAIAmJjExUWFhYRo4cKDRoQAAGhGKn4OkFOq1A0erTkg5tyt2cyQAADRdMTExyszM1MaNG40OBQDQyFD8vGmjphTqtUD/mr0xBfr7uDkSAAAAAIA7UPy86WKkFOotu92ujb/mVtvGJOmsZnYNOKe1Z4ICAAAAANS5iuLno2tYxPyNlN2a8PJ6Xfr0V9SYasBISqFestvtejppu+au+tmx7eTcd8Xja0JtZMYBAAAAoBGg+HnTQlIKhrPa7ErZlatP0vcpZVeuSstsemTZj1r49S5J0kNjLtDCSuYYBwf46oUbe6t3WwrcAQAAAEBjQPHzpoWaUjBUUka2EpZnOq2w19zbouOlVplM0uPjwnXzoHMkyTHH+MDRIgX6+yqiSxvZrGVaeerpxgAAAACABqKi+PnJfytWpaL4+eLvsjTlki7MpGlASErBMEkZ2ZqxJE0n57KPl1olSZMjz3EkpKQ/5xifyGZ1d5QAAAAAAE87neLnj634Sa+szVJ8dJhG1bA2FYzF9D0YwmqzK2F5pktC6kSf/7if4ZcAAAAA0ETVtvi5RI2phoakFAyRmpV3ymGY2UeKlJqV56GIAAAAAAD1UW2Kn1NjqmEhKQVDHDh66nnBtWkHAAAAAGicTqf4eUWNKRJT9RtJKRgi0N/31I1q0Q4AAAAA0HhVFD8/eVX26jy24idd+vRXTOWrx0hKwRChbf3kVc2KCCZJIQHlK+wBAAAAADAqPERrHxymf1xxQY33ocZU/UZSCh7326FC3fjyepVVMYyyIlUVHx3GUp4AAAAAAAeL2aQpl3ShxlQjQVIKbmO12ZWyK1efpO9Tyq5cWW12/fLHMd2wMEW7cwvVqU1zPXZVuEJOGn4ZHOCrBRP7sYQnAAAAAMAFNaYaDy+jA0DjlJSRrYTlmU4r7LVr2UzFZTYdLSrTue1b6M3bBikkoLluGtRZqVl5OnC0SIH+5VP2GCEFAAAAAKhKRY2pk//urM5jK37SK2uzFB8dxiCIeoKRUqhzSRnZmrEkzeWN4eCxEh0tKlPHs5rr3TsiFRLQXFJ5ljuya1td1aejIru2JSEFAIAbHT58WAMGDFCfPn0UHh6ul19+2eiQAAA4LdSYavhISqFOWW12JSzPVHUDIstsNrX2a+axmAAAwJ/8/f31zTffKD09XRs2bNCTTz6p3Nxco8MCAOC0UGOqYSMphTqVmpV3yqGT+/OLlZqV56GIAADAiSwWi/z8/CRJxcXFstvtstv5Ug4AaLioMdVwkZRCnTpwtGZzeWvaDgAAOPvmm28UHR2tDh06yGQy6eOPP3Zpk5iYqNDQUPn6+mrQoEFKTU11ev7w4cPq3bu3zj77bP3tb39Tu3btPBQ9AADuUVFjKvikhbSq89iKn3Tp018xlc9AJKVQpwL9a/YGUNN2AADAWUFBgXr37q3ExMRKn1+6dKni4uIUHx+vtLQ09e7dWyNHjtSBAwccbc466yx9//33ysrK0ltvvaX9+/d7KnwAANyGGlMNT71ISp3qbt6JXn75ZV122WVq3bq1WrduraioqGrbw7MiurRRQHPvKp83SQoJKF9hDwAA1N7o0aP1+OOP6+qrr670+blz52r69OmaOnWqwsLCtHDhQvn5+WnRokUubYOCgtS7d299++237g4bAACPOJ0aU3ZJMz/4Qd/tPMh0Pg/zMjqAirt5Cxcu1KBBgzRv3jyNHDlS27dvV2BgoEv7NWvWaMKECbr44ovl6+urp59+WiNGjNCPP/6ojh07GvAT4ERvpPyqI8dLK32u4g0hPjqMFfYAAHCDkpISbd68WbNmzXJsM5vNioqKUkpKiiRp//798vPzk7+/v44cOaJvvvlGM2bMqLS/4uJiFRcXOx7n5+dLkkpLS1VaWvnn/Zmo6NMdfQNwH65d1EcPje6hu975Xiap2oW4Khw+XqqbX9mg4FY+enjM+Rp5YZC7QzSUu6/bmvZreFLqxLt5krRw4UKtWLFCixYt0syZM13av/nmm06PX3nlFX3wwQdKTk7WpEmTPBIzKpe4eqf++fl2SVLUBYHK+D1fOScUPQ8O8FV8dJhGhYcYFSIAAI3awYMHZbVaFRTk/EU6KChI27ZtkyTt3r1bt99+u6PA+V133aWePXtW2t+cOXOUkJDgsv2LL75wFEt3h1WrVrmtbwDuw7WL+mbqeSZ9+KtZh0tqPigiJ79Ise+ka9p5NvVu2/hHTbnrui0sLKxRO0OTUjW5m3cqhYWFKi0tVZs2lU8Hc+cdvqZ8R8Bqs2vT7kM6cLRY7Vs207c7c/XSt79Kku4aeq7uGtpVNrscbQL9fTTgnNaymE11erya8jmoDzj+xuL4G49zYKz6coevoYmIiFB6enqN2s6aNUtxcXGOx/n5+erUqZNGjBihVq1a1XlspaWlWrVqlYYPHy5v76rLAQCoX7h2UV+NkfSAza431u/Wk5/tqOFeJpkkfbbfTw/cfHmjneXj7uu2IvdyKoYmpWpyN+9UHnzwQXXo0EFRUVGVPu+JO3xN7Y7A97lVZ5uvOseqbkU79NkJF7xFUq6kz39yX0xN7RzUNxx/Y3H8jcc5MJbRd/jqk3bt2slisbgULt+/f7+Cg4Nr3Z+Pj498fHxctnt7e7v1D0939w/APbh2UR95S7r1sm56bd0e5RwpqtFUPruk7CPFejP1N025pEujTUxJ7rtua9qn4dP3zsRTTz2ld955R2vWrJGvb+WrubnzDl9TvCPw+Y/79VrK91VeyMMj+3l07m1TPAf1CcffWBx/43EOjFVf7vDVJ82aNVP//v2VnJyscePGSZJsNpuSk5MVGxt72v0mJiYqMTFRVqu1jiIFAMBzLGaT4qPDNGNJWo1rTEnSYyt+0itrsyhD40aGJqXO5G7es88+q6eeekpffvmlevXqVWU7T9zhayp3BKw2u574bHuVF7BJ0hOfbdfoXh09nkluKuegvuL4G4vjbzzOgbGMvsPnaceOHdPOnTsdj7OyspSenq42bdqoc+fOiouL0+TJkzVgwABFRERo3rx5KigocNTvPB0xMTGKiYlRfn6+AgIC6uLHAADAo0aFh2jBxH5KWJ6p7BNqH59KzpEizViSpgUT+5GYcgOzkS9+4t28ChV38yIjI6vc75lnntFjjz2mpKQkDRgwwBOhQlJqVl61F2/5EMcipWbleS4oAACamE2bNqlv377q27evJCkuLk59+/bV7NmzJUnjx4/Xs88+q9mzZ6tPnz5KT09XUlKSS7kEAACamlHhIVr74DC9eesgndW8Zjef7P/7N/ODH/TdzoOy2hp/8XNPMnz63qnu5k2aNEkdO3bUnDlzJElPP/20Zs+erbfeekuhoaHKycmRJLVs2VItW7Y07OdoCg4crVk2uabtAABA7Q0ZMkR2e/VfiGNjY89ouh4AAI2VxWzSJd3b6alre2rGkjRJNZvOd/h4qW5+ZYNCWFW+Thk6Uko69d28PXv2KDs729F+wYIFKikp0XXXXaeQkBDHv2effdaoH6HJaOlTsxxmoH/l9b0AAEDDlJiYqLCwMA0cONDoUAAAqBMV0/mCA2r392vFdL6kjOxTN8YpGT5SSqr+bt6aNWucHv/666/uDwguDhWU6F+rql9C0yQpOMBXEV3aeCYoAADgEdSUAgA0RqPCQzQ8LFiLv8vSYytqtly8XeV/+yYsz9TwsOBGvTKfJxg+Ugr134GjRbrxpfXK+D3fMVrq5Muu4nF8dBgXJQAAAACgQbCYTZpySReFBPi6/J1blYp6yut35boztCaBpBScWG12pezK1Sfp+5SyK1d78go1/j/rtX3/UQX6++ijOy/WwkqGOAYH+LIaAQAAAACgwbGYTYqPDpPkOgCjOjFvMY3vTNWL6XuoH5Iysl2WxzSbJJtd6nhWc701fZDOadtC3YP8NTwsWKlZeTpwtEiB/uVT9hghBQBA45SYmKjExERZrVajQwEAwC0qakyd/DdxdQ4fL9WMJWkM0DgDJKUgqTwhNWNJmsuqAxWrXcYM7apz2rZwbLeYTYrs2tZzAQIAAMNQUwoA0BRU1JhavytXMW+l6fDx0lPuY5f0949+0LDzg9TMi8lotcURa8rWrZMuukjWtd8pYXlmtctgvvDVTlltNVkoEwAAAACAhsliNumS7u301LU9azyVL6+gVBfNSWYq32kgKdWUvfCCtGGD8p6ee8rhidlHipSaleehwAAAAAAAME7FdL6zmnvXqH1eQYlmLKHGVG2RlGqqDh6U3n9fktT2s2VqXXjklLscOFqzebUAAAAAADR0o8JDlHhzvxq3t0ua+cEP+m7nQWYa1RBJqabq9dclm02SZLJZdU3GV6fcJdDf95RtAABA45OYmKiwsDANHDjQ6FAAAPCoi85tq5AA3xpP5Tt8vFQ3v7JBlz79FaOmaoCkVFOwb5+Ulub879//lux/Zm4npa3QhTk7nf4FHT0oqXxJzJCA8hX2AABA0xMTE6PMzExt3LjR6FAAAPAoi9mk+OiwWu+Xc6SI6Xw1wOp7TcGECdK33zpvM5kcSSmT3a7OR3K04vV7nZps6HShbrzpaUlSfHSYLOaa5oYBAAAAAGgcKupL/f2jH5RXcOoV+SQ5FhJjZb7qcVSagttuk93XV3bTCUklu/P81hPTTTaZVGTx1tJeIxQc4KsFE/tpVHiIZ2IFAAAAAKCeGRUeovWzotSmRbNa7cfKfNUjKdUEJPUbrpvuSFTWWR1kNVU/2sluNqv43K5at/RzXf/8Q1r74DASUgAAAACAJq+Zl1lPXh0uk1TjGlMSK/NVh6RUI5eUka0ZS9KU4hukK6Y8rxU9Lq22vemGG9T8h+817Nqhiuzalil7AAAAAAD8T8VUvuCA2i0EZlf5VL6SMpt7AmugSEo1YlabXQnLMx1zWY8381Vq556yVZXTNZmkwYMlPz+PxQgAAOo/Vt8DAOBPo8JDtPbBYXrz1kE6q7l3jfdjKp8rklKNWGpWnrKPFDltC8/ZKau5/LRX5Gcd1aUsFmnzZo/FBwAAGgZW3wMAwJnFbNIl3dvpqWt7MpXvDJCUasQOHC1y2db3923ytllVZjKrxOKtVwZcJVszn/KEVFmZlJJiQKQAAAAAADQ8FdP52rSo+YgppvL9iaRUIxbo7zzH1aesRF1zf5Mk7W4doiunPK/H/zJdP3zyldS1a3mjbdukItdkFgAAAAAAcHU6K/Mxla8cSalGrGfHADXz+vMU+5SVaEf7c7S0Z5SumPK8drXrrJAAX/UcESmlpUlTpkg9e5KUAgAAAACgFk5cma+m8gpK9H9L0vT8lztktdlPvUMj5GV0AHCPo0WlunXxJqfhgPm+LXXFlOdlN5kdF0p8dFj5CnstWkivvSbZbJKZXCUAAAAAALVRMZXv7x/9oLyC0hrv968vf9bbqXv1yNgwjQoPcWOE9Q/Zh0bocGGJbn5lg1J/zZO/r5f+NvI8hfxvuUq7qfyUBwf4asHEfq6/8CSkAAAAAAA4LaczlU+ScvKLmmQBdEZKNXBWm12pWXk6cLRIgf6+6tKuhaa8lqptOUfV2s9b/711kMI7Buj/BndzahfRpU35CCkAAAAAAFBnKqbyzViSptpMyrNLemTZjxoeFtxk/l4nKdWAJWVkK2F5prKP/FkDymI2yWqzK9DfR0tuG6Tzgvwd2yO7tjUqVAAA0IAlJiYqMTFRVqvV6FAAAGgQTncqX05+sV78aqfuieruxujqD+ZqNVBJGdmasSTNKSElyVEcLXZoN0dCCgAA4EzExMQoMzNTGzduNDoUAAAajNOdyvevL3c0mWl8JKUaIKvNroTlmdUOA1zw9a4mW70fAAAAAID64HRW5ZOkv3/0g9PCZY0VSakGKDUrz2WE1MmyjxQpNSvPQxEBAAAAAIDKVEzlC27lU+N98gpKddGc5EY/YoqkVAN04Gj1CanatgMAAAAAAO4zKjxE3838i+6LOq/G++QVlOj/lqTp+S93NNqZUCSlGqBAf986bQcAAAAAANzLYjbpnqjuuq+WRcz/9eXPuuSprxrlqCmSUg1QYXFZtc+bJIUE+CqiSxvPBAQAAAAAAGokdlh3Bbeq3SCSnPwizViS1ugSUySlGpiVP2Tr/97c7Hh8crG0isfx0WGymGtbSg0AAAAAALiTxWzSI2PDal383C7pkWU/NqqpfCSl6jGrza6UXbn6JH2fUnbl6r1NexX7VppKrXZF9+6gF2/qq+AA5+xqcICvFkzsp1HhIQZFDQAAAAAAqlNR/LxNC+9a7ZeTX6wXv9rppqg8z8voAFC5pIxsJSzPrHSVvfEDOunJa3rKYjZpdHiIUrPydOBokQL9y6fsMUIKAADUpcTERCUmJspqtRodCgAAjcao8BANOz9IF81JVl5BSY33+9eXOyTZFTuse4P/+5+RUvVQUka2ZixJqzQhJUmDz2vv+MWzmE2K7NpWV/XpqMiubRv8LyQAAKh/YmJilJmZqY0bNxodCgAAjUozL7OevDq81lP5Gkvxc5JS9YzVZlfC8kxVNUPUJOmxFZmNag4pAAAAAABNVcVUvuBWPrXaLye/SP+3JE0rt/7upsjcj6RUPZOalVflCCmpvLBZ9pEipWbleS4oAAAAAADgNqPCQ/TdzL/ovqjzar1v7NtbtHJrwxwxRVKqnjlwtOqE1Om0AwAAAAAA9Z/FbNI9Ud11X1T3Wu1ns0t3vpXWIKfykZSqZ9q2aFajdoH+vqduBAAAAAAAGpTYYd0V3Kr2f/P//aMfVFJmc0NE7kNSqh4pLrPqvym7q21jkhQSUL7KHgAAAAAAaFwsZpMeGRtW6+LneQWlumhOcoMaMUVSqp44XmLV7W9s1ueZ++X1vxX0Tv4FrHgcHx3GKnsAAAAAADRSp1v8PK+gRC899aYO9eonrVvnpujqDkkpA1htdqXsytUn6fuUsitXR46Xasprqfp6xx9q7m3R4qkRWjixn4IDnIfrBQf4asHEfhoVHmJQ5AAAAAAAwBNOt/j5lLTlav3DFu17/J9uiqzueBkdQFOTlJGthOWZTivseVtMKrXa5e/jpUVTB2pgaPnUvOFhwUrNytOBo0UK9C+fsscIKQAAAAAAmoaK4ufdA1so9u0tstmrb9+68IhGb/9OkhT4+XKt+jpDwweHeyDS08NIKQ9KysjWjCVpTgkpSSq1lv9WxQ7r5khISeW/fJFd2+qqPh0V2bUtCSkAAAAAAJqgMb066MUJ/U7Z7tqMZFls5cXOLTabUh+dp5Vb62+NKUZKeYjVZlfC8kxVl9RcvO5X3XbZuSSfAAAAAACAkzG9QrTQ3E9//+gH5RWUKujoQbUrOOzU5pa0lZIj82DXxM0rdOfcnjo8qLPGD+xcnm8ICpICAz0dfqVISnlIalaeywipk2UfKVJqVp4iu7b1UFQAAAAAAKChGBUeomHnB+miOcl64c1/KuK3H52et+nPKXFmSZ2P5GjF6/dKr5/Q6PLLpS+/9EzAp8D0PQ85cLT6hFRt2wEAAHhKYmKiwsLCNHDgQKNDAQCgyWvmZdaTV4frnd4jVGTxlu2E505O8pw4D8smk4os3vp+xDUeiLJmSEp5SKC/76kb1aIdAACAp8TExCgzM1MbN240OhQAAKDyEVNRT96vsVOf16+tO8pqqr4MkNVkVlabDrpyyvO6+lg3fZaR46FIq0dSykO8LCZV9ytikhQSUL7CHgAAAAAAQHXG9Oqge+8apyumPK8VPS6ttu2n51+qK6Y8r53tOstml+5eulVbDhpfz5qklAek7MrVlEWpjlJjJ5/2isfx0WEUOQcAAAAAADUypleInpsSqY2de8pWxVAYm0xK7RSuIm/nmVmv/2w2fMQUSak6ZLXZlbIrV5+k71PKrlxZbXat3n5AU15LVUGJVZd0a6vnb+yj4ADnX4TgAF8tmNhPo8JDDIocAAAAAAA0RGN6ddDtLQ7Jai5P8VTUmKr4f6vZrPCcnS772WXS3Uu3auXW3z0TaCVYfa+OJGVkK2F5ptMKe2f5eetoUamsNukv5wcq8eZ+8vW26MpeHZSalacDR4sU6F8+ZY8RUgAAAAAA4HR02rFVsllVZraozGTWkr5jNHHLSnnZrPK2WdXv921V7hv79ha9KJPG9PL8QBlGStWBz3/crxlL0pwSUpJ0uLA8IdXvnLO08Jb+8vW2SJIsZpMiu7bVVX06KrJrWxJSAAAAAADg9BQVSdvKk06W7t303n8+0eN/ma4rpzyvPWeVJ5q65v4mn7KSSne32aU730pTUka2x0KuQFLqDNns0uMrtznqRVUm+3CRzKeohA8AAAAAAFBrx49L4eHS1KkypaXplltH69839dUv7TvriinP692ef9H29qFVJqUqJCzPlNVWXXaj7jF97wztyjcpJ7+42jbZR4qUmpWnyK5tPRQVAAAAAABoElq3ltLSJPOf447G9OqgF2XSnW+l6YEx98lkt8luqn5ckhG5i3oxUioxMVGhoaHy9fXVoEGDlJqaWm379957T+eff758fX3Vs2dPrVy50kORusovrVm7A0eLTt0IAAAAAACgtsyu6Z0xvUL075v6ymzSKRNSFTyduzA8KbV06VLFxcUpPj5eaWlp6t27t0aOHKkDBw5U2n7dunWaMGGCbr31Vm3ZskXjxo3TuHHjlJGR4eHIy7Xyrlm7QH/fUzcCAAAAAACoI2N6ddCLE/rVuL2ncxeGJ6Xmzp2r6dOna+rUqQoLC9PChQvl5+enRYsWVdr++eef16hRo/S3v/1NF1xwgR577DH169dPL774oocjL9e1lV3BrXxUVcUok6SQgPIV9gAAAAAAADzpxBFTVTEqd2FoUqqkpESbN29WVFSUY5vZbFZUVJRSUlIq3SclJcWpvSSNHDmyyvbuZjZJD485X5JcElMVj+Ojw1hhDwAAAAAAGKK6EVNG5i4MLXR+8OBBWa1WBQUFOW0PCgrStv8tZ3iynJycStvn5ORU2r64uFjFxX8WIs/Pz5cklZaWqrS0hgWhqlCx/7Dz2uiFG3vr8ZXbnIqeBwf46KHR5+svPdqd8WuhchXHleNrDI6/sTj+xuMcGMvdx5/zCgAAGpMxvUK00NxPCcszlX3kz9pRwQG+io8O06jwEI/H1OhX35szZ44SEhJctn/xxRfy8/Ork9dYtWqVJOnBsPLV+PJLy2tNdW1VIOvuzVq5u05eBtWoOAcwBsffWBx/43EOjOWu419YWOiWfgEAAIwyKjxEw8OClbLzgL74doNGXDZIkd0CDZvdZWhSql27drJYLNq/f7/T9v379ys4OLjSfYKDg2vVftasWYqLi3M8zs/PV6dOnTRixAi1atXqjOIvLS3VqlWrNHz4cHl717DiOeoU58BYHH9jcfyNxzkwlruPf8XoagAAgMbEYjZpUJc2yv3JrkFd2hhabsjQpFSzZs3Uv39/JScna9y4cZIkm82m5ORkxcbGVrpPZGSkkpOTde+99zq2rVq1SpGRkZW29/HxkY+Pj8t2b2/vOvsCW5d94fRwDozF8TcWx994nANjuev4c04BAADcy/DV9+Li4vTyyy/r9ddf108//aQZM2aooKBAU6dOlSRNmjRJs2bNcrS/5557lJSUpOeee07btm3TI488ok2bNlWZxAIAAMCf9u7dqyFDhigsLEy9evXSe++9Z3RIAACgiTK8ptT48eP1xx9/aPbs2crJyVGfPn2UlJTkKGa+Z88emc1/5s4uvvhivfXWW3r44Yf197//Xd27d9fHH3+s8PBwo34EAACABsPLy0vz5s1Tnz59lJOTo/79+2vMmDFq0aKF0aEBAIAmxvCklCTFxsZWOdJpzZo1Ltuuv/56XX/99W6OCgAAoPEJCQlRSEj56jrBwcFq166d8vLySEoBAACPM3z6HgAAAGrum2++UXR0tDp06CCTyaSPP/7YpU1iYqJCQ0Pl6+urQYMGKTU1tdK+Nm/eLKvVqk6dOrk5agAAAFckpQAAABqQgoIC9e7dW4mJiZU+v3TpUsXFxSk+Pl5paWnq3bu3Ro4cqQMHDji1y8vL06RJk/TSSy95ImwAAAAX9WL6HgAAAGpm9OjRGj16dJXPz507V9OnT3csGrNw4UKtWLFCixYt0syZMyVJxcXFGjdunGbOnKmLL764yr6Ki4tVXFzseJyfny9JKi0tVWlpaV38OE4q+nRH3wDch2sXaHjcfd3WtF+SUgAAAI1ESUmJNm/e7LRysdlsVlRUlFJSUiRJdrtdU6ZM0bBhw3TLLbdU29+cOXOUkJDgsv2LL76Qn59f3QZ/glWrVrmtbwDuw7ULNDzuum4LCwtr1I6kFAAAQCNx8OBBWa1WxyrGFYKCgrRt2zZJ0nfffaelS5eqV69ejnpU//3vf9WzZ0+X/mbNmqW4uDjH4/z8fHXq1EkjRoxQq1at6jz+0tJSrVq1SsOHD5e3t3ed9w/APbh2gYbH3ddtxejqUyEpBQAA0IRceumlstlsNWrr4+MjHx8fl+3e3t5u/cPT3f0DcA+uXaDhcdd1W9M+KXQOAADQSLRr104Wi0X79+932r5//34FBwcbFBUAAEDlSEoBAAA0Es2aNVP//v2VnJzs2Gaz2ZScnKzIyMjT7jcxMVFhYWEaOHBgXYQJAAAgiel7AAAADcqxY8e0c+dOx+OsrCylp6erTZs26ty5s+Li4jR58mQNGDBAERERmjdvngoKChyr8Z2OmJgYxcTEKD8/XwEBAXXxYwAAAJCUAgAAaEg2bdqkoUOHOh5XFCKfPHmyFi9erPHjx+uPP/7Q7NmzlZOToz59+igpKcml+DkAAIDRSEoBAAA0IEOGDJHdbq+2TWxsrGJjYz0UEQAAwOlpckmpii9xNV2esDqlpaUqLCxUfn4+q0wYhHNgLI6/sTj+xuMcGMvdx7/iu8KpEkBNQWJiohITE1VWViapbr5HVYZrCmiYuHaBhqe+fI8y2ZvYN63ffvtNnTp1MjoMAADQQOzdu1dnn3220WHUC3yPAgAAtXGq71FNLills9n0+++/y9/fXyaT6Yz6ys/PV6dOnbR37161atWqjiJEbXAOjMXxNxbH33icA2O5+/jb7XYdPXpUHTp0kNnMgsXSn9+jhg0bpk2bNtV4v4EDB2rjxo2nbMc1dWo1PZZGMypOd75uXfZ9pn2d7v613Y9rt+40hGuX69a9fTW167am36Oa3PQ9s9lc53c7W7VqxZuvwTgHxuL4G4vjbzzOgbHcefxZac5ZxfcoLy+vWh1zi8VSq/ZcU1Wr7bE0ilFxuvN167LvM+3rdPev7X5cu3WnIVy7XLfu7aspXrc1+R7FbT8AAADUSkxMjFvbo2oN5VgaFac7X7cu+z7Tvk53f65d4zSEY8l1696+uG4r1+Sm79Wl/Px8BQQE6MiRI/U+691YcQ6MxfE3FsffeJwDY3H8Gx/OKdAwce0CDU99uW4ZKXUGfHx8FB8fLx8fH6NDabI4B8bi+BuL4288zoGxOP6ND+cUaJi4doGGp75ct4yUAgAAAAAAgMcxUgoAAAAAAAAeR1IKAAAAAAAAHkdSCgAAAAAAAB5HUgoAAAAAAAAeR1LqDCQmJio0NFS+vr4aNGiQUlNTjQ6pSZgzZ44GDhwof39/BQYGaty4cdq+fbvRYTVZTz31lEwmk+69916jQ2lS9u3bp4kTJ6pt27Zq3ry5evbsqU2bNhkdVpNgtVr1j3/8Q126dFHz5s3VtWtXPfbYY2LdEPf55ptvFB0drQ4dOshkMunjjz92et5ut2v27NkKCQlR8+bNFRUVpZ9//tmYYOFRV199tVq3bq3rrrvO6FAAVOHTTz9Vjx491L17d73yyitGhwOghjz1GUtS6jQtXbpUcXFxio+PV1pamnr37q2RI0fqwIEDRofW6H399deKiYnR+vXrtWrVKpWWlmrEiBEqKCgwOrQmZ+PGjfrPf/6jXr16GR1Kk3Lo0CFdcskl8vb21meffabMzEw999xzat26tdGhNQlPP/20FixYoBdffFE//fSTnn76aT3zzDN64YUXjA6t0SooKFDv3r2VmJhY6fPPPPOM5s+fr4ULF2rDhg1q0aKFRo4cqaKiIg9HCk+755579MYbbxgdBoAqlJWVKS4uTl999ZW2bNmif/7zn8rNzTU6LAA14KnPWC+3v0IjNXfuXE2fPl1Tp06VJC1cuFArVqzQokWLNHPmTIOja9ySkpKcHi9evFiBgYHavHmzLr/8coOianqOHTumm2++WS+//LIef/xxo8NpUp5++ml16tRJr732mmNbly5dDIyoaVm3bp2uuuoqXXHFFZKk0NBQvf3224yWdaPRo0dr9OjRlT5nt9s1b948Pfzww7rqqqskSW+88YaCgoL08ccf68Ybb/RkqPCwIUOGaM2aNUaHAaAKqampuvDCC9WxY0dJ5e/nX3zxhSZMmGBwZABOxVOfsYyUOg0lJSXavHmzoqKiHNvMZrOioqKUkpJiYGRN05EjRyRJbdq0MTiSpiUmJkZXXHGF03UAz1i2bJkGDBig66+/XoGBgerbt69efvllo8NqMi6++GIlJydrx44dkqTvv/9ea9eurTJpAvfKyspSTk6O03tRQECABg0axGeywU417VKiFAJQ353pdfz77787ElKS1LFjR+3bt88ToQNNWkP6DCYpdRoOHjwoq9WqoKAgp+1BQUHKyckxKKqmyWaz6d5779Ull1yi8PBwo8NpMt555x2lpaVpzpw5RofSJP3yyy9asGCBunfvrs8//1wzZszQ3Xffrddff93o0JqEmTNn6sYbb9T5558vb29v9e3bV/fee69uvvlmo0Nrkio+d/lMrn9ONe2yJqUQ+vTpo/DwcJd/v//+u6d+DKBJq4vrGIDnNaRrl+l7aNBiYmKUkZGhtWvXGh1Kk7F3717dc889WrVqlXx9fY0Op0my2WwaMGCAnnzySUlS3759lZGRoYULF2ry5MkGR9f4vfvuu3rzzTf11ltv6cILL1R6erruvfdedejQgeMPnKC6aZdSzUohpKeneyJUAFU40+u4Q4cOTiOj9u3bp4iICLfHDTR1dfEZ7CmMlDoN7dq1k8Vi0f79+52279+/X8HBwQZF1fTExsbq008/1erVq3X22WcbHU6TsXnzZh04cED9+vWTl5eXvLy89PXXX2v+/Pny8vKS1Wo1OsRGLyQkRGFhYU7bLrjgAu3Zs8egiJqWv/3tb47RUj179tQtt9yi++67j5GDBqn43OUzuWGhFALQ8NXkOo6IiFBGRob27dunY8eO6bPPPtPIkSONChmA6t9nMEmp09CsWTP1799fycnJjm02m03JycmKjIw0MLKmwW63KzY2Vh999JG++uorCjx72F/+8hf98MMPSk9Pd/wbMGCAbr75ZqWnp8tisRgdYqN3ySWXaPv27U7bduzYoXPOOcegiJqWwsJCmc3OH58Wi0U2m82giJq2Ll26KDg42OkzOT8/Xxs2bOAzuR6rq1IIUVFRuv7667Vy5UqdffbZJLQAD6rJdezl5aXnnntOQ4cOVZ8+ffTXv/5Vbdu2NSJcAP9T089gT33GMn3vNMXFxWny5MkaMGCAIiIiNG/ePBUUFDiGv8F9YmJi9NZbb+mTTz6Rv7+/48IJCAhQ8+bNDY6u8fP393ep39WiRQu1bduWul4ect999+niiy/Wk08+qRtuuEGpqal66aWX9NJLLxkdWpMQHR2tJ554Qp07d9aFF16oLVu2aO7cuZo2bZrRoTVax44d086dOx2Ps7KylJ6erjZt2qhz586699579fjjj6t79+7q0qWL/vGPf6hDhw4aN26ccUHDI7788kujQwBwCmPHjtXYsWONDgNALXnqM5ak1GkaP368/vjjD82ePVs5OTnq06ePkpKSXLKNqHsLFiyQVL5E5Ylee+01TZkyxfMBAR42cOBAffTRR5o1a5YeffRRdenSRfPmzaPQtoe88MIL+sc//qE777xTBw4cUIcOHXTHHXdo9uzZRofWaG3atElDhw51PI6Li5MkTZ48WYsXL9YDDzyggoIC3X777Tp8+LAuvfRSJSUlUfeuHqMUAtDwcR0DDVN9u3ZNdrvd7vFXBQAAQJNhMpn00UcfOY1eGzRokCIiIvTCCy9IKi+F0LlzZ8XGxnq8yCqAU+M6Bhqm+n7tMlIKAAAAde5U0y4phQDUf1zHQMPUkK5dRkoBAACgzq1Zs8Zp2mWFimmXkvTiiy/qn//8p6MUwvz58zVo0CAPRwqgKlzHQMPUkK5dklIAAAAAAADwOPOpmwAAAAAAAAB1i6QUAAAAAAAAPI6kFAAAAAAAADyOpBQAAAAAAAA8jqQUAAAAAAAAPI6kFIAGac2aNTKZTDp8+HCVbRYvXqyzzjrrlH2ZTCZ9/PHHtY5h+/btCg4O1tGjR2u974kuuugiffDBB2fUBwAAAAA0NCSlABhq4cKF8vf3V1lZmWPbsWPH5O3trSFDhji1rUhE7dq1SxdffLGys7MVEBBQ49d65JFH1KdPnzqKXJo1a5buuusu+fv7n1E/Dz/8sGbOnCmbzVZHkQEAAABA/UdSCoChhg4dqmPHjmnTpk2Obd9++62Cg4O1YcMGFRUVObavXr1anTt3VteuXdWsWTMFBwfLZDIZEbb27NmjTz/9VFOmTDnjvkaPHq2jR4/qs88+O/PAAAAAAKCBICkFwFA9evRQSEiI1qxZ49i2Zs0aXXXVVerSpYvWr1/vtH3o0KGO/z55+t7ixYvVuXNn+fn56eqrr1Zubq7TcwkJCfr+++9lMplkMpm0ePFix/MHDx7U1VdfLT8/P3Xv3l3Lli2rNu53331XvXv3VseOHZ1e46yzztKnn36qHj16yM/PT9ddd50KCwv1+uuvKzQ0VK1bt9bdd98tq9Xq2M9isWjMmDF65513anv4AAAAAKDBIikFwHBDhw7V6tWrHY9Xr16tIUOGaPDgwY7tx48f14YNGxxJqZNt2LBBt956q2JjY5Wenq6hQ4fq8ccfdzw/fvx4/fWvf9WFF16o7OxsZWdna/z48Y7nExISdMMNN2jr1q0aM2aMbr75ZuXl5VUZ87fffqsBAwa4bC8sLNT8+fP1zjvvKCkpSWvWrNHVV1+tlStXauXKlfrvf/+r//znP3r//fed9ouIiNC3335bswMGAABQR0JDQzVv3rwat//1119lMpmUnp5eZzFcfvnleuutt86oj4ULFyo6OrqOIgLgKSSlABhu6NCh+u6771RWVqajR49qy5YtGjx4sC6//HLHCKqUlBQVFxdXmZR6/vnnNWrUKD3wwAM677zzdPfdd2vkyJGO55s3b66WLVvKy8tLwcHBCg4OVvPmzR3PT5kyRRMmTFC3bt305JNP6tixY0pNTa0y5t27d6tDhw4u20tLS7VgwQL17dtXl19+ua677jqtXbtWr776qsLCwnTllVe6JOEkqUOHDtq7dy91pQAAwClNmTJF48aNc9lek4VgTrZx40bdfvvtdRecar7YjCQtW7ZM+/fv14033nhGrzlt2jSlpaVxkw9oYEhKATDckCFDVFBQoI0bN+rbb7/Veeedp/bt22vw4MGOulJr1qzRueeeq86dO1fax08//aRBgwY5bYuMjKxxDL169XL8d4sWLdSqVSsdOHCgyvbHjx+Xr6+vy3Y/Pz917drV8TgoKEihoaFq2bKl07aT+27evLlsNpuKi4trHDMAAMCZat++vfz8/Ax7/fnz52vq1Kkym8/sT9NmzZrppptu0vz58+soMgCeQFIKgOG6deums88+W6tXr9bq1as1ePBgSeWjhzp16qR169Zp9erVGjZsmNti8Pb2dnpsMpmqHbXUrl07HTp0qEb91KTvvLw8tWjRwmn0FgAAwJlau3atLrvsMjVv3lydOnXS3XffrYKCAsfzJ0/f27Ztmy699FL5+voqLCxMX375pUwmkz7++GOnfn/55RcNHTpUfn5+6t27t1JSUiSVj9aaOnWqjhw54qjj+cgjj1Qa2x9//KGvvvrKZdqdyWTSf/7zH1155ZXy8/PTBRdcoJSUFO3cuVNDhgxRixYtdPHFF2vXrl1O+0VHR2vZsmU6fvz46R8wAB5FUgpAvTB06FCtWbNGa9as0ZAhQxzbL7/8cn322WdKTU2tcuqeJF1wwQXasGGD07YTi6RL5XfQTiwwfib69u2rzMzMOulLkjIyMtS3b9866w8AAGDXrl0aNWqUrr32Wm3dulVLly7V2rVrFRsbW2l7q9WqcePGyc/PTxs2bNBLL72khx56qNK2Dz30kO6//36lp6frvPPO04QJE1RWVqaLL75Y8+bNU6tWrRx1PO+///5K+1i7dq0j6XSyxx57TJMmTVJ6errOP/983XTTTbrjjjs0a9Ysbdq0SXa73eXnGDBggMrKyly+EwKov7yMDgAApPKkVExMjEpLSx0jpSRp8ODBio2NVUlJSbVJqbvvvluXXHKJnn32WV111VX6/PPPlZSU5NQmNDRUWVlZSk9P19lnny1/f3/5+PicVrwjR47UbbfdJqvVKovFclp9nOjbb7/ViBEjzrgfAADQNHz66adO5QEkudx8mzNnjm6++Wbde++9kqTu3btr/vz5Gjx4sBYsWOBSimDVqlXatWuX1qxZo+DgYEnSE088oeHDh7u8/v33368rrrhCUvmCMRdeeKF27typ888/XwEBATKZTI4+qrJ7924FBQVVOnVv6tSpuuGGGyRJDz74oCIjI/WPf/zDUTP0nnvu0dSpU5328fPzU0BAgHbv3l3t6wKoPxgpBaBeGDp0qI4fP65u3bopKCjIsX3w4ME6evSoevTooZCQkCr3v+iii/Tyyy/r+eefV+/evfXFF1/o4Ycfdmpz7bXXatSoURo6dKjat2+vt99++7TjHT16tLy8vPTll1+edh8V9u3bp3Xr1rl8sQIAAKjK0KFDlZ6e7vTvlVdecWrz/fffa/HixWrZsqXj38iRI2Wz2ZSVleXS5/bt29WpUyenZFJERESlr39iPc6K72jV1eOsTFU1Ok/uv+K7Yc+ePZ22FRUVKT8/32m/5s2bq7CwsFZxADAOI6UA1AuhoaGy2+0u288555xKtw8ZMsRl+7Rp0zRt2jSnbX/9618d/+3j46P333/fpa/K+j/VqjVeXl76+9//rrlz5zru2E2ZMkVTpkxxavfII4+41FFYvHix0+P58+drypQpOvvss6t9TQAAgAotWrRQt27dnLb99ttvTo+PHTumO+64Q3fffbfL/lUtHlNTJ9bMNJlMklTrVYSrqtFZVf81ec28vDy1b9++VnEAMA5JKQA4TXfccYcOHz6so0ePyt/f/7T7CQwMVFxcXB1GBgAAIPXr10+ZmZkuyauq9OjRQ3v37tX+/fsdo5M2btxY69etaR3Pvn37KicnR4cOHVLr1q1r/Ton27Vrl4qKiqjTCTQgTN8DgNPk5eWlhx566IwSUlL5aK4TpywCAADUhQcffFDr1q1TbGys0tPT9fPPP+uTTz6pstD58OHD1bVrV02ePFlbt27Vd9995yiHUDEyqSZCQ0N17NgxJScn6+DBg1VOp+vbt6/atWun7777rvY/XCW+/fZbnXvuueratWud9AfA/UhKAQAAAEAj1KtXL3399dfasWOHLrvsMvXt21ezZ89Whw4dKm1vsVj08ccf69ixYxo4cKBuu+02x+p7VdV+qszFF1+s//u//9P48ePVvn17PfPMM1W+3tSpU/Xmm2/W/oerxNtvv63p06fXSV8APMNkr6yYCgAAAACgyfvuu+906aWXaufOnW4ZgZSTk6MLL7xQaWlpOuecc067nx9//FHDhg3Tjh07FBAQUIcRAnAnklIAAAAAAEnSRx99pJYtW6p79+7auXOn7rnnHrVu3Vpr165122t+/PHHatu2rS677LLT7uPLL7+U1Wp1LEADoGEgKQUAAAAAkCS98cYbevzxx7Vnzx61a9dOUVFReu6559S2bVujQwPQCJGUAgAAAAAAgMdR6BwAAAAAAAAeR1IKAAAAAAAAHkdSCgAAAAAAAB5HUgoAAAAAAAAeR1IKAAAAAAAAHkdSCgAAAAAAAB5HUgoAAAAAAAAeR1IKAAAAAAAAHkdSCgAAAAAAAB73//7ilPm6O38iAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion\n",
        "\n",
        "This basic example demonstrates the use of OpenMDAO for solving a simple structural optimization problem. In practice, OpenMDAO can be used for much more complex systems and analyses, including aerospace applications, vehicle design, and much more.\n",
        "\n",
        "In a real-world application, you would typically refine the problem by including more detailed models of the physics involved, possibly dynamic behaviors, other disciplines like heat transfer or fluid dynamics, and you might utilize gradient-enhanced optimization techniques provided by OpenMDAO's advanced capabilities.\n",
        "\n",
        "This tutorial provides a foundation that can be expanded upon to tackle more complex and multidisciplinary engineering optimization problems."
      ],
      "metadata": {
        "id": "2jwomxFYsQ_4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here are the plots generated based on the simulated optimization results for a cantilever beam:\n",
        "\n",
        "1. **Width vs. Mass**: This plot shows the relationship between the width of the beam and its mass, holding height constant at the optimized value. As expected, the mass increases linearly with the width because the volume (and thus mass) of the beam is directly proportional to its width.\n",
        "\n",
        "2. **Height vs. Displacement**: This plot illustrates how displacement at the end of the beam decreases as the height increases, with width held constant at the optimized value. The displacement decreases sharply as height increases due to its cubic relationship in the beam’s bending equation.\n",
        "\n",
        "These plots help visualize the trade-offs and impacts of different design variables on the system's objectives and constraints. If you have specific results from an actual OpenMDAO run, similar plots can be generated to analyze those results in detail."
      ],
      "metadata": {
        "id": "mkOJ5yvCvbpR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Appendix\n",
        "\n",
        "## Example openMDAO Usage"
      ],
      "metadata": {
        "id": "Bb3vGi38iLrS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# build the model\n",
        "prob = om.Problem()\n",
        "\n",
        "prob.model.add_subsystem('paraboloid', om.ExecComp('f = (x-3)**2 + x*y + (y+4)**2 - 3'))\n",
        "\n",
        "# setup the optimization\n",
        "prob.driver = om.ScipyOptimizeDriver()\n",
        "prob.driver.options['optimizer'] = 'SLSQP'\n",
        "\n",
        "prob.model.add_design_var('paraboloid.x', lower=-50, upper=50)\n",
        "prob.model.add_design_var('paraboloid.y', lower=-50, upper=50)\n",
        "prob.model.add_objective('paraboloid.f')\n",
        "\n",
        "prob.setup()\n",
        "\n",
        "# set initial values\n",
        "prob.set_val('paraboloid.x', 3.0)\n",
        "prob.set_val('paraboloid.y', -4.0)\n",
        "\n",
        "# run the optimization\n",
        "prob.run_driver()\n",
        "\n",
        "# minimum value\n",
        "print('paraboloid.f:', prob.get_val('paraboloid.f'))\n",
        "\n",
        "# location of the minimum\n",
        "print('paraboloid.x:', prob.get_val('paraboloid.x'))\n",
        "print('paraboloid.y:', prob.get_val('paraboloid.y'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kGVJzzmyh4zQ",
        "outputId": "b80547f9-441c-4573-ee71-c92d17be163f"
      },
      "execution_count": 253,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimization terminated successfully    (Exit mode 0)\n",
            "            Current function value: -27.33333333333333\n",
            "            Iterations: 5\n",
            "            Function evaluations: 6\n",
            "            Gradient evaluations: 5\n",
            "Optimization Complete\n",
            "-----------------------------------\n",
            "paraboloid.f: [-27.33333333]\n",
            "paraboloid.x: [6.66666667]\n",
            "paraboloid.y: [-7.33333333]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Simpler Cantilever Beam Design Example Using openMDAO"
      ],
      "metadata": {
        "id": "s9r3DdXtX1Bw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Optimizing a Cantilever Beam Design with OpenMDAO: A Step-by-Step Python Tutorial\n",
        "\n",
        "# Define constants\n",
        "E = 200e9  # Modulus of elasticity (Pa)\n",
        "P = 50e3   # Applied load (N)\n",
        "rho = 7800 # Material density (kg/m^3)\n",
        "max_displacement = 0.01  # Maximum allowable displacement (m)\n",
        "\n",
        "class BeamDesign(om.ExplicitComponent):\n",
        "   \"\"\"\n",
        "   Define the cantilever beam design problem using OpenMDAO.\n",
        "   \"\"\"\n",
        "\n",
        "   def setup(self):\n",
        "       # Define design variables\n",
        "       self.add_input('beam_length', val=5.0, desc='Beam length (m)')\n",
        "       self.add_input('beam_width', val=0.1, desc='Beam width (m)')\n",
        "       self.add_input('beam_height', val=0.2, desc='Beam height (m)')\n",
        "\n",
        "       # Define outputs\n",
        "       self.add_output('mass', val=0.0, desc='Beam mass (kg)')\n",
        "       self.add_output('displacement', val=0.0, desc='Beam end displacement (m)')\n",
        "\n",
        "       # Specify partial derivative calculation method\n",
        "       self.declare_partials('*', '*', method='fd')\n",
        "\n",
        "   def compute(self, inputs, outputs):\n",
        "       # Compute the mass and displacement of the beam\n",
        "       L = inputs['beam_length']\n",
        "       b = inputs['beam_width']\n",
        "       h = inputs['beam_height']\n",
        "\n",
        "       outputs['mass'] = rho * L * b * h\n",
        "       outputs['displacement'] = (4 * P * L**3) / (E * b * h**3)\n",
        "\n",
        "# Create the design problem\n",
        "prob = om.Problem()\n",
        "model = prob.model\n",
        "\n",
        "# Add the design component to the model\n",
        "model.add_subsystem('beam', BeamDesign(), promotes=['*'])\n",
        "\n",
        "# Set up the design optimization problem\n",
        "model.add_design_var('beam_length', lower=1.0, upper=10.0)\n",
        "model.add_design_var('beam_width', lower=0.05, upper=1.0)\n",
        "model.add_design_var('beam_height', lower=0.05, upper=1.0)\n",
        "\n",
        "# Define the objective function and constraints\n",
        "model.add_objective('mass')\n",
        "model.add_constraint('displacement', upper=max_displacement)\n",
        "\n",
        "# Set up the optimization driver\n",
        "prob.driver = om.ScipyOptimizeDriver()\n",
        "prob.driver.options['optimizer'] = 'SLSQP'\n",
        "prob.driver.options['disp'] = True\n",
        "\n",
        "prob.setup()\n",
        "\n",
        "# Set initial values for the design variables\n",
        "prob.set_val('beam_length', 5.0)\n",
        "prob.set_val('beam_width', 0.1)\n",
        "prob.set_val('beam_height', 0.2)\n",
        "\n",
        "# Run the optimization\n",
        "prob.run_driver()\n",
        "\n",
        "# Print the optimized design\n",
        "print(f\"Optimized beam design:\")\n",
        "print(f\"  Length: {prob.get_val('beam_length')[0]:.4f} m\")\n",
        "print(f\"  Width: {prob.get_val('beam_width')[0]:.4f} m\")\n",
        "print(f\"  Height: {prob.get_val('beam_height')[0]:.4f} m\")\n",
        "print(f\"  Mass: {prob.get_val('mass')[0]:.4f} kg\")\n",
        "print(f\"  Displacement: {prob.get_val('displacement')[0]:.6f} m\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nRrPKjirh5Nd",
        "outputId": "64d557aa-d456-4822-b2c3-ea86002a94d5"
      },
      "execution_count": 254,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimization terminated successfully    (Exit mode 0)\n",
            "            Current function value: 49.13691125414173\n",
            "            Iterations: 5\n",
            "            Function evaluations: 16\n",
            "            Gradient evaluations: 5\n",
            "Optimization Complete\n",
            "-----------------------------------\n",
            "Optimized beam design:\n",
            "  Length: 1.0000 m\n",
            "  Width: 0.0500 m\n",
            "  Height: 0.1260 m\n",
            "  Mass: 49.1369 kg\n",
            "  Displacement: 0.010000 m\n"
          ]
        }
      ]
    }
  ]
}