{ "cells": [ { "cell_type": "markdown", "id": "a88c4fda", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [ "reliability", "9" ] }, "source": [ "# System reliability analysis\n", "\n", "In this example, we will demonstrate how to perform a reliability analysis of a system consisting of two components. We will analyze two system configurations:\n", "* Parallel System: the system fails only when both components fail.\n", "* Series System: the system fails when at least one of the components fails.\n", "\n", "### Define Limit State Functions\n", "\n", "First, we import the necessary classes:" ] }, { "cell_type": "code", "execution_count": 72, "id": "c0d851fb", "metadata": {}, "outputs": [], "source": [ "from probabilistic_library import ReliabilityProject, ReliabilityMethod, DistributionType, CombineProject, CombinerMethod, CombineType, Stochast" ] }, { "cell_type": "markdown", "id": "580573d5", "metadata": {}, "source": [ "We consider two elements, each described by the following limit state functions:\n", "\n", "$Z_1 = 1.9 - (a+b)$\n", "\n", "$Z_2 = 1.85 - (1.5 \\cdot b + 0.5 \\cdot c)$" ] }, { "cell_type": "code", "execution_count": 73, "id": "ea8b7c51", "metadata": {}, "outputs": [], "source": [ "from utils.models import linear_a_b, linear_b_c" ] }, { "cell_type": "markdown", "id": "59e7d4b4", "metadata": {}, "source": [ "Note that both functions share a common variable $b$.\n", "\n", "We consider two system configurations:\n", "* Parallel system: the system fails only when both $Z_1$ and $Z_2$ are less than zero.\n", "* Series system: the system fails when either $Z_1$ or $Z_2$ is less than zero.\n", "\n", "In the first case we want to calculate the probability $P(Z_1<0 \\cap Z_2<0)$ and, in the second case, the probability $P(Z_1<0 \\cup Z_2<0)$." ] }, { "cell_type": "markdown", "id": "e2bf13ea", "metadata": {}, "source": [ "### Perform reliability calculations for each element\n", "\n", "First, we perform the reliability analysis of the individual elements (described by the limit state functions). \n", "\n", "We create a reliability project `ReliabilityProject()`. We assume that variables $a$ and $b$ are uniformly distributed over the interval $[-1, 1]$. The variable $c$ is normally distributed with a `mean` of $0.1$ and a `deviation` of $0.8$. We use the First Order Reliability Method (`FORM`) to run the reliability analysis.\n", "\n", "It is essential to define the limit state function model before specifying the random variables!\n", "\n", "Using `project.run()` we execute the reliability analysis for one limit state function. The results are stored in `project.design_point`. To combine the results later, we store the outputs in separate objects (`dp_Z1` and `dp_Z2`)." ] }, { "cell_type": "code", "execution_count": 74, "id": "25d5a13e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", "Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", "Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", "Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n" ] } ], "source": [ "project = ReliabilityProject()\n", "project.settings.reliability_method = ReliabilityMethod.form\n", "project.settings.relaxation_factor = 0.75\n", "project.settings.maximum_iterations = 50\n", "project.settings.epsilon_beta = 0.01\n", "\n", "project.model = linear_a_b\n", "\n", "project.variables[\"a\"].distribution = DistributionType.uniform\n", "project.variables[\"a\"].minimum = -1\n", "project.variables[\"a\"].maximum = 1\n", "\n", "project.variables[\"b\"].distribution = DistributionType.uniform\n", "project.variables[\"b\"].minimum = -1\n", "project.variables[\"b\"].maximum = 1\n", "\n", "project.run()\n", "dp_Z1 = project.design_point\n", "dp_Z1.identifier = \"Z1\"\n", "dp_Z1.print()\n", "\n", "project.model = linear_b_c\n", "\n", "project.variables[\"c\"].distribution = DistributionType.normal\n", "project.variables[\"c\"].mean = 0.1\n", "project.variables[\"c\"].deviation = 0.8\n", "\n", "project.run()\n", "dp_Z2 = project.design_point\n", "dp_Z2.identifier = \"Z2\"\n", "dp_Z2.print()" ] }, { "cell_type": "markdown", "id": "0846b4d1", "metadata": {}, "source": [ "### Perform reliability analysis of a system\n", "\n", "To perform the reliability analysis of a system, we create a new project using `CombineProject()`. We append the reliability results of the individual elements to this object." ] }, { "cell_type": "code", "execution_count": 75, "id": "d503ca4f", "metadata": {}, "outputs": [], "source": [ "combine_project = CombineProject()\n", "\n", "combine_project.design_points.append(dp_Z1)\n", "combine_project.design_points.append(dp_Z2)" ] }, { "cell_type": "markdown", "id": "7af1784e", "metadata": {}, "source": [ "The library offers the following methods for the reliability analysis of a system: `hohenbichler`, `hohenbichler_form`, `importance_sampling`, `directional_sampling`. The desired reliability method can be set using `combine_project.settings.combiner_method`.\n", "\n", "The type of system configuration (`series` or `parallel`) can be defined using `combine_project.combine_type`.\n", "\n", "Execute the reliability analysis of the system using `combine_project.run()`. The results will be stored in `combine_project.design_point`." ] }, { "cell_type": "code", "execution_count": 76, "id": "462b4ff2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Reliability (series - hohenbichler)\n", " Reliability index = 1.92\n", " Probability of failure = 0.02746\n", " Model runs = 0\n", "Alpha values:\n", " a: alpha = -0.0725, x = 0.95\n", " b: alpha = -0.7507, x = 0.95\n", " c: alpha = -0.6567, x = 0\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (series - importance_sampling)\n", " Reliability index = 1.919\n", " Probability of failure = 0.02749\n", " Model runs = 0\n", "Alpha values:\n", " a: alpha = -0.1006, x = 0.1531\n", " b: alpha = -0.7622, x = 0.8564\n", " c: alpha = -0.6395, x = 1.082\n", "\n", "Contributing design points:\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", "Reliability (series - directional_sampling)\n", " Reliability index = 1.998\n", " Probability of failure = 0.02288\n", " Convergence = 0.07704 (converged)\n", " Model runs = 1\n", "Alpha values:\n", " a: alpha = -0.08834, x = 0.1401\n", " b: alpha = -0.7648, x = 0.8734\n", " c: alpha = -0.6382, x = 1.12\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (parallel - hohenbichler)\n", " Reliability index = 3.117\n", " Probability of failure = 0.0009126\n", " Model runs = 0\n", "Alpha values:\n", " a: alpha = -0.5306, x = 0.95\n", " b: alpha = -0.8053, x = 0.95\n", " c: alpha = -0.2645, x = 0\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (parallel - importance_sampling)\n", " Reliability index = 3.123\n", " Probability of failure = 0.000894\n", " Convergence = 0.01692 (converged)\n", " Model runs = 21000\n", "Alpha values:\n", " a: alpha = -0.5401, x = 0.9084\n", " b: alpha = -0.7988, x = 0.9874\n", " c: alpha = -0.2649, x = 0.7618\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (parallel - directional_sampling)\n", " Reliability index = 3.144\n", " Probability of failure = 0.0008344\n", " Convergence = 0.09989 (converged)\n", " Model runs = 1\n", "Alpha values:\n", " a: alpha = -0.5342, x = 0.9069\n", " b: alpha = -0.7906, x = 0.9871\n", " c: alpha = -0.2993, x = 0.8527\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n" ] } ], "source": [ "def fault_tree(combine_project, combine_type):\n", "\n", " combine_algorithms = [CombinerMethod.hohenbichler, CombinerMethod.hohenbichler_form, CombinerMethod.importance_sampling, CombinerMethod.directional_sampling]\n", "\n", " combine_project.settings.combine_type = combine_type\n", " combine_algorithms = [CombinerMethod.hohenbichler, CombinerMethod.importance_sampling, CombinerMethod.directional_sampling]\n", "\n", " for combine_algorithm in combine_algorithms:\n", "\n", " combine_project.settings.combiner_method = combine_algorithm\n", " combine_project.run()\n", " dp = combine_project.design_point\n", " dp.identifier = str(combine_type) + ' - ' + str(combine_algorithm)\n", " \n", " dp.print()\n", "\n", "fault_tree(combine_project, CombineType.series)\n", "fault_tree(combine_project, CombineType.parallel)" ] }, { "cell_type": "markdown", "id": "44d980b5", "metadata": {}, "source": [ "### Uncorrelated $b$ variable\n", "\n", "In the previous calculations, the variable $b$ in the limit state function $Z_1$​ was assumed to be the same as the variable $b$ in the limit state function $Z_2$​, implying a perfect correlation (correlation coefficient of $1.0$). This section demonstrates the impact of this assumption on the reliability analysis results.\n", "\n", "To explore the effect of relaxing this assumption, we will now assume that the variable $b$ in $Z_1$ is not correlated with the variable $b$ in $Z_2$. Specifically, we set the correlation coefficient to $0.0$." ] }, { "cell_type": "code", "execution_count": 77, "id": "66b2a45f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Reliability (series - hohenbichler)\n", " Reliability index = 1.906\n", " Probability of failure = 0.0283\n", " Model runs = 0\n", "Alpha values:\n", " a: alpha = -0.09896, x = 0.95\n", " b: alpha = -0.7188, x = 0.95\n", " c: alpha = -0.6882, x = 0\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (series - importance_sampling)\n", " Reliability index = 1.907\n", " Probability of failure = 0.02827\n", " Model runs = 0\n", "Alpha values:\n", " a: alpha = -0.1006, x = 0.1521\n", " b: alpha = -0.7622, x = 0.8539\n", " c: alpha = -0.6395, x = 1.076\n", "\n", "Contributing design points:\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", "Reliability (series - directional_sampling)\n", " Reliability index = 1.901\n", " Probability of failure = 0.02866\n", " Convergence = 0.08284 (converged)\n", " Model runs = 1\n", "Alpha values:\n", " a: alpha = -0.09078, x = 0.137\n", " b: alpha = -0.7452, x = 0.8434\n", " c: alpha = -0.6607, x = 1.105\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (parallel - hohenbichler)\n", " Reliability index = 3.804\n", " Probability of failure = 7.12e-05\n", " Model runs = 0\n", "Alpha values:\n", " a: alpha = -0.5636, x = 0.95\n", " b: alpha = -0.7115, x = 0.95\n", " c: alpha = -0.4197, x = 0\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (parallel - importance_sampling)\n", " Reliability index = 3.799\n", " Probability of failure = 7.254e-05\n", " Convergence = 0.0349 (converged)\n", " Model runs = 21000\n", "Alpha values:\n", " a: alpha = -0.556, x = 0.9653\n", " b: alpha = -0.7186, x = 0.9937\n", " c: alpha = -0.4177, x = 1.37\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n", "Reliability (parallel - directional_sampling)\n", " Reliability index = 3.745\n", " Probability of failure = 9.029e-05\n", " Convergence = 0.09981 (converged)\n", " Model runs = 1\n", "Alpha values:\n", " a: alpha = -0.5543, x = 0.9621\n", " b: alpha = -0.7198, x = 0.993\n", " c: alpha = -0.4179, x = 1.352\n", "\n", "Contributing design points:\n", " Reliability (Z1)\n", " Reliability index = 2.772\n", " Probability of failure = 0.002783\n", " Convergence = 0.004051 (converged)\n", " Model runs = 21\n", " Alpha values:\n", " a: alpha = -0.7071, x = 0.95\n", " b: alpha = -0.7071, x = 0.95\n", "\n", " Reliability (Z2)\n", " Reliability index = 1.95\n", " Probability of failure = 0.02559\n", " Convergence = 0.007929 (converged)\n", " Model runs = 18\n", " Alpha values:\n", " b: alpha = -0.719, x = 0.8391\n", " c: alpha = -0.695, x = 1.184\n", "\n" ] } ], "source": [ "combine_project.correlation_matrix[\"b\"] = 0.0\n", "\n", "fault_tree(combine_project, CombineType.series)\n", "fault_tree(combine_project, CombineType.parallel)" ] }, { "cell_type": "markdown", "id": "8f4b9180", "metadata": {}, "source": [ "Additionally, let’s plot the limit state functions ($Z = 0$):" ] }, { "cell_type": "code", "execution_count": 78, "id": "709e1b27", "metadata": { "tags": [ "gallery", "reliability" ] }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXdxJREFUeJzt3QdcleX7P/APHDYCDgQX4lbcuEFJLffOUkPNlVrmzMqyb5lmZaVl7pmj1Fw5yplbENx74BYcoKKyN5z/6777ww8QkHM48Jzxeb9eT3genvNwc3HiXNzXPczUarUaREREREbKXOkGEBERERUmJjtERERk1JjsEBERkVFjskNERERGjckOERERGTUmO0RERGTUmOwQERGRUWOyQ0REREaNyQ4REREZNSY7RDp27949mJmZYdWqVTq75+HDh+U9xUfK3cyZM1GlShWoVCo0bNhQ6eYQkZ5gskOkAZHAiKTj9OnTSjcF69atw6+//qqz+z169AhTp07F+fPntb7Hrl275D2U8O+//2LSpElo2bIlVq5cie+//x6mYNGiRejTpw8qVqwoX5tDhgzR6PnfffcdevToAVdXV/n8vH5++/fvR9u2beHs7IzixYujWbNm+OOPP/K8v7+/v7yvOMLDwzVqG5GuWOjsTkQkubu7Iz4+HpaWljq752uvvSbvaWVllSXZuXz5MiZMmKCzZGfatGmoVKmS1r0iItlZsGCBIgnPwYMHYW5ujt9++y1LnIzdjz/+iOjoaJl4hIaGavz8L7/8EmXKlIGnpyf27t2b63V///03evXqBS8vL/nzFcnLxo0bMWjQIJnEfPTRRy89Jy0tDWPHjoW9vT1iY2M1bhuRrjDZIdIx8SZgY2Oj03uKN3Fd39PYPHnyBLa2tjpLdMQeyQkJCfKe+uzIkSMZvTrFihXT+Pl3796VCa5IWEqXLp3rdfPnz0fZsmVlUmltbS3Pvf/++6hVq5bs8cwp2Vm6dCnu37+P4cOHY86cORq3jUhXWMYiKoIxO6K0IN6IQkJC0K1bN/nv8uXLy14Q4dKlS3j99dflX8CiZ0j02uQ1ZqdNmzbYuXMngoODM0oE4g0rL/v27UOrVq1k+UF8/Zo1a+KLL77IuH/Tpk3lv4cOHZpxz/Tvwc/PL6NUIt7o3Nzc5Jub6G3K/D2mfz/pzxdH5r/yRdmtTp06MnETZRPxZvnixYss7RQlwo4dO8pSiUg0KleujGHDhuX5vYmvI0pXovcge9tTUlIwffp0VK1aVbZdxEl834mJiVnuIc6Ln43o3WjSpIn82kuWLMnz6544cQJdunRBiRIl5M+ufv36Rf6mLl4vmeOsqVe9btJFRUXJ7zM90REsLCwyfk7ZPX/+XPYaffPNN/I1R6Qk9uwQFZHU1FR07txZlqR++uknrF27FmPGjJFvkv/73/8wYMAA9O7dG4sXL5alAVEuEG/0ORHXR0ZG4sGDB5g9e7Y8l9df9VeuXJFv5OLNWLz5iDesW7du4dixY/LzHh4e8vyUKVMwcuRI+Pj4yPPe3t7y46ZNmxAXF4dRo0ahVKlSOHnyJObNmye/vvicIBIXUQoTSVVO4zjE50UCIpKpcePGyR4F0Vtw7tw52Q5R9hO9Mx06dJA9DJ9//rl8kxTJ45YtW/KMrfh6ohdBtGv58uVZ2i56FVavXo23334bH3/8sUxQZsyYgWvXrmHr1q1Z7nP9+nX4+vrKto4YMUImhLkR36eIqejtGD9+vCwFiXvu2LFDPs6NSPpEIpAfTk5OOi2HFoRIsEXJ7KuvvsLgwYNlgiWScpGcinJWduI6ERMRS5FsEilKTUT5tnLlSrX43+bUqVO5XnP37l15jbg23eDBg+W577//PuPcixcv1La2tmozMzP1+vXrM84HBQXJa7/++uuMc4cOHZLnxMd0Xbt2Vbu7u+er3bNnz5bPf/r0aa7XiO8pe7vTxcXFvXRuxowZsu3BwcEZ50aPHi3vkZ2fn588v3bt2izn9+zZk+X81q1bXxnf3IgY29vbZzl3/vx5eb/hw4dnOf/JJ5/I8wcPHsw4J2Ipzok2vUpKSoq6cuXK8jni55hZWlpans9Nf33k58j8884P8f2LOGhDvDayv+4yi4mJUfft21f+zNPbZ2dnp962bdtL1164cEGtUqnUe/fulY/FPV/1+iMqTOzZISpCopchnei1ED0Hooelb9++GefFOfG5O3fu6OzrppcRtm/fLntWxBggTWQuU4hSkShfiZ4TMa5F9MyI8lZeRO+P6KVo3759lhk5jRs3lj1Shw4dQv/+/TPaKXpHGjRoUOBeDTFgWpg4cWKW86KHZ9asWbIUKGYXpRM9aaKE9iriexY9U6JXLXuJ5lUlJdHbIXqF8kPEQF+I3sAaNWrIHjLRAyl6KkVv2sCBA+X306JFi4xrRc+d6MUUvXRE+oDJDlEREeNUsg8AFQlAhQoVXnqDFOezj2UpiH79+snyjki2RHnojTfekG9Y4o0rP4mPGGskSlxiRk72doly2qvcvHlTXufi4pLj50X5SmjdujXeeustOStMJBKidCJmAIlEKPNYkfwSY5rE91etWrWXEg6RpIjPZ5Zb2TC727dvy49169bV6nXQrl07GBpRcj1+/DjOnj2b8ZoRSboYgyXKdqI8KGzYsAEBAQFypiCRvmCyQ1RExEJ3mpwXvSa6Inpmjh49KntQRG/Gnj175JuSGBQt1qfJrQ2C+Ate9MiIcSafffaZnH0jxhk9fPhQDkoWY1BeRVwjEh0xTikn6UmgSPo2b94s31T/+ecfOVhYDE7++eef5TltZhul3zc/imLmlYjn06dP83VtyZIl9WIafVJSkpzSL9Yxypwci5430YMjxl6Ja0RbP/30UzmYXfxbjLcSIiIi5EcxM0tcV65cOcW+FzJNTHaIDJSmM3DEm5To0RHHL7/8IhfdEwOdRQIkehpyu5+YKXbjxg05yFcMnE6XUykmt3uImVBiQTqx4F9+EgpREhGHWPBODIIVg7fXr1+fpQyY35lKItESPUtiEHa6x48fyzdg8XltiO9HEL0XmvbSiDf8/PYgiZ+N6N1S2rNnz+SsNpGoZZecnCxjnP458f2Jn1n2GYVCo0aNZGmuIAtXEmmDyQ6RgRK9K/kpIQmiV0b0EmSWvnBg+hRscb/Mf4WnS+/1ydzTJP6d0xTrzPfIPJZFlDsWLlwoZ+VkX9lYvInGxMTI60WJTHzMnDRlb6cmxLRwMc1cTHnPPI1cJHtC165doQ3xpi0SFnFf0buV+XsVsckrEVVqzI54rYhFB8XsMVEm1YTolRPfo5i9Jmbtpfc2iZ+b6IETvX3pSWz2GW6CSFRFT+Lvv/8uy7ZERY3JDpEWVqxYIUtB2eU15VjXxOBe8QYiBt+KNXJEiad79+45XiveoEQZS7y5i94MMUZGJB/ijUesvZPeWyHe0MTUdwcHB5m4NG/eXL6Ric998sknsnTl6OiIv/76K8cxRaJN6QNUxUBfkSi98847ciyOmIIspnyLv+rFwFVRAhE9LmLwskicxPgh0Xsk2vXmm2/KrylWBl62bJn8miJx0ZRIFsQ0aTGQViRgoh1ierr4OmIsUObByZr2koltGkS8RTImBn2LJCIoKEhO889rJWJdj9kRycaFCxcyelkuXryIb7/9Vj4W20CI5QbSkxDRTrEeUeYtJcS0fTF2SSwtIIjXSfrz3333Xfl6ET9H8fMX6+aIHjfRwyd6ckRpSyw/sGbNmoz7ibhml96TI0peYl0eoiJXqHO9iIx06nlux/3793Odep59WrTQunVrdZ06dV46L6Y0i6nleU09F1OB+/fvry5evLj8XF7T0A8cOKDu2bOnuly5cmorKyv50dfXV33jxo0s123fvl1du3ZttYWFRZbv4erVq+p27dqpixUrpnZ2dlaPGDFCTi/O/n2KKdljx45Vly5dOmOKcmZLly5VN27cWE65d3BwUNerV089adIk9aNHj+Tnz549K9tVsWJFtbW1tdrFxUXdrVs39enTp1/5s8ktxsnJyepp06bJqeKWlpZqNzc39eTJk9UJCQl5xjw//P391e3bt5ffi/ja9evXV8+bN09dlNKXNcjpyPyzSX/tZl9aQLwG8zv1XSwR0KxZM/maEz/D5s2bqzdv3vzKNnLqOSnNTPyn6FMsIiIioqLB7SKIiIjIqDHZISIiIqPGZIeIiIiMGpMdIiIiMmpMdoiIiMioMdkhIiIio2ZyiwqKZc0fPXokF03TdLl9IiIiUoZYKUcsNCr2VsvPBsYmneyIRMfNzU3pZhAREZEWxP5rmm47omiyI5ZbF0f6zrh16tTBlClT5JLiuRFLy3/11VfyOdWrV8ePP/6o0TLyokcnPVhiCXpdEku1ix2k05fCp/xh3DTHmGmHcdMO46Ydxk23MYuKipKdFenv4waT7IjM7IcffpBJi+ieEvvV9OzZE+fOnZOJT3YBAQHw9fWV++t069ZN7qor9mE5e/Ys6tatm6+vmV66EolOYSQ7dnZ28r58Yecf46Y5xkw7jJt2GDftMG6FEzNthqAoOkBZbKInemVEslOjRg189913cjPD48eP53i92CywU6dO+PTTT+Hh4SF3UBa7D8+fP7/I205ERESGQW/G7IgddEWJKjY2Fl5eXjleExgYKHd4zkzsrLxt27Zc75uYmCiPzN1g6dmjOHQp/X66vq+xY9w0x5hph3HTDuOmHcZNtzErSBwVT3YuXbokk5uEhATZq7N161bUrl07x2vDwsLg6uqa5Zx4LM7nRpS8pk2b9tJ5URMUXWWFYd++fYVyX2PHuGmOMdMO46Ydxk07jJtuYhYXFweDTXZq1qyJ8+fPIzIyEps3b8bgwYNx5MiRXBMeTU2ePDlLb1D6ACcx+KkwxuyIH1D79u1Zn9UA46Y5xkw7jJt2TDFuotqQkpIix5NqSzxfjDX19vaGhYXib7d6T4zFEcf+/ftzfK2lV2a0oXj0raysUK1aNfnvxo0b49SpU3JszpIlS166tkyZMnj8+HGWc+KxOJ8ba2treWQnglhY/9MW5r2NGeOmOcZMO4ybdkwhbiK5EdWCiIgIndxLvD+FhoZyXbd8EnESa+jk9ForyGtP8WQnp0X/Mo+xyUyUuw4cOIAJEyZknBN/beQ2xoeIiEgT6YmOi4uLHOpQkCRFvJ/FxMTIIRqaLoJnitLS0vDw4UMUL168QD1qepfsiBKTWFOnYsWKclVEMZX88OHD2Lt3r/z8oEGDUL58eTnuRhg/fjxat26Nn3/+GV27dsX69etx+vRpLF26VMlvg4iIjKR0lZ7olCpVSidv3klJSbCxsWGyk0+lS5eWw1rEz8Jokp0nT57IhEZ08Tk5OaF+/foy0RG1OiEkJCTLC0TUPUVC9OWXX+KLL76QU9bFTKz8rrFDRESUm/TZPoU1eYVeTZSqRG+aUSU7v/32W56fF7082fXp00ceREREhYHja5SPva7LWOxXIyIiIqPGZIeIiIiMGpMdIiIiAyWGe6SvT5PT0bZt24xrx40bJ5d4EcuxNGzYsEjaJxYMHj16tBzwLWalvfXWWy8tIVMUmOzoUMDtZ0jU7ZgqIiKiXImJO2KST/ZDrFUnkp0PP/wwy/XDhg1Dv379iqx9H330Ef755x+5HZRYMPjRo0fo3bs3iprerbNjqC4/jMTwP86ilJUKdZvFoHaFEko3iYiIjJxYmDf7wrrXrl3DJ598ImctZ57QM3fuXPnx6dOnuHjxYqG3TUwhFxORxCzq119/XZ5buXKl3MhbbPjdokULFBUmOzqSkJyKEnZWCItORO8lx/FNj7ro06QCR/UTERkoMSMoPjm1QOvsxCelwiIpReN1dmwtVVq9f4h1gnr27Ik2bdpg+vTpKKjOnTvDz88v18+7u7vjypUrOX7uzJkzcjp/u3btMs7VqlVLrq0nNvZmsmOAmlQqib8/bIEhiw8hKBKY9NdFBNwOx3dv1oO9NcNMRGRoRKJTe8p/i9wWtavfdISdlYXGyVX//v3lPlxr167VyR/by5cvR3x8fK6fz2sLB7Eateh5Eisia7KBd2Hgu7AOlSpmjfc90vCgWA38evA2tp1/hIsPIjG/fyPULqfbTUeJiIgyE2Ur0WNy8uRJODg46OSe5cuXhzFgsqNj5mbAB62roEW10hi77hzuhMei18Jj+Lp7bfRvVpFlLSIiAyFKSaKHRVuipyU6KhoOjg5albE0IbZPmjVrFnbu3Cl3F9CVzgUoY4mxRGK7DFFay9y786oNvAsDk51C0rRSSewa74NPNl3AwaAn+N/Wy3K21g+968HBxrh3DSYiMgbij1NNS0nZk50UK5W8R2HujXX+/Hm89957+OGHH9Cxo/bJma7LWGKau/i82MBbTDkXrl+/LreCKuoNvJnsFKKS9lZYPqgJlvvfwU97rmPnxVA5a2tB/0aoW95J6eYREZGBCw8PR69eveSA5IEDB740FkalUsnNNYVbt27JXdjFNSKBEUmSULt2bTm2RtdlLLHnpUjCJk6ciJIlS8LR0RFjx46ViU5RDk4WmOwUMnNzM4x8raocwCzKWsHP4tB7YQC+6FILg70rsaxFRERaE2Wr4OBgeZQtWzbHMtO9e/fkv4cPHy7Xuknn6ekpP969exeVKlUqlPbNnj1b9mqJnp3ExETZ87Rw4UIUNS4qWEQaVSyBXeN80L62K5JS0zD1n6sYteYsIuP/22WXiIhIU4MHD5ZT5HM70hOd9NWWc7qmsBIdwcbGBgsWLMDz588RGxuLLVu2FPl4HYHJThFysrPE0ncbY0q32rBUmWHPlTB0neuH8/cjlG4aERGR0WKyU8RE2WpYq8rY/IE33Era4sGLeLy9KADL/e7ofEt7IiIiYrKjmAZuxbFznA+61CuDlDQ1vt15DSN+P40XsUlKN42IiMioMNlRkKONpZyZNb1nHVipzLH/2hNZ1joT/FzpphERERkNJjt6UNZ616sStnzojcrO9ngUmYC+S45j0eHbSEtjWYuIiKigmOzoCbHuzj9jW6FHg3JITVPjxz1BGLb6FJ7FJCrdNCIiIoPGZEePFLO2wJx3GmJG73qwtjDH4etP0WWuH07ceaZ004iIiAwWkx09LGv5NquIbaNbokppezyOSoTvsuOYd+Cm7PEhIiIizTDZ0VMeZR3xz5hW6O1ZHiLH+XnfDQxecRJPo1nWIiIi0gSTHT1mb22BX/o1xMy368sdcP1vhcuyVsCtcKWbRkREZDCY7BiAPk3c8PeYlqjhWkz27Az47QR+2XeDZS0iIhMntoAQwx9yO9q2bSuvu3DhAnx9feHm5gZbW1t4eHhgzpw5hd4+sU3EgAED5CagxYsXlxuDis1IixqTHQNR3dUB20e3Qr8mbhALLc89cBMDlh/H46gEpZtGREQK8fb2Rmho6EvHkiVLZLLz4YcfyuvOnDkDFxcXrFmzBleuXMH//vc/TJ48GfPnzy/U9olER3y9ffv2YceOHTh69ChGjhyJosZdzw2IrZUKP75dH15VS+GLrZdw/M5zdJnjh9n9GuK1GqWVbh4RERUxKyurlzbWvHbtGj755BN88cUX6NOnjzw3bNiwLNdUqVIFgYGBcmPOMWPGFErbRDv27NmDU6dOoUmTJvLcvHnz0KVLF8yaNQvlypVDUWGyY4B6eZZHvQpOGL32LILCojF45Ul82KYqPmpXAxYqdtYREemE6EaPi9P++WlpQGwsoFIB5hr+brazE9NzNf6SERER6NmzJ9q0aYPp06fneW1kZCRKliyZ5zV16tRBcHBwrp/38fHB7t27c/ycSKZE6So90RHatWsHc3NznDhxAm+++SaKCpMdA1W1dDE5PX36jqtYeyIECw7dxsm7zzHX1xNlnWyVbh4RkeETiU6xYlo/XaQ3xbV9shjXYm+v0VPS0tLQv39/WFhYYO3atbKMlZuAgABs2LABO3fuzPOeu3btQnJycq6fF+N/chMWFiZLZ5mJtokES3yuKDHZMWA2lip892Y9tKhSCpO3XMKpey9kWeuXvg3RtlbWFxgRERk3UbYSvSknT56Eg4NDrtddvnxZ9v58/fXX6NChQ573dHd3hzFgsmMEujcoh3rlnTDmz7O4/DAKQ1edwvuvVcEnHWvCkmUtIiLtiFJSAWYOiZ6WqKgoORNJlG40/toaWL9+vRwHI3pqqlevnut1V69exRtvvCEHCX/55ZevvG9BylhiLNGTJ0+ynEtJSZEztLKPMypsTHaMRCVne/w1yhszdgVhVcA9LDl6ByfvPcc8X09UKKHZ/zRERCSXtNe4lPTSmJ3U1P/uoWmyo4Hz58/LKd0//PADOnbsmOt1V65cweuvv47Bgwfju+++y9e9C1LG8vLykmOIxEywxo0by3MHDx6USWDz5s1RlJjsGBFrCxWm9qiDFlVK4tPNF3EuJAJd5/rLRQk71CnaLJqIiApfeHg4evXqJQckDxw48KWxMCqVCqVLl5alK5HoiGRo4sSJGdelf74wylhiLZ9OnTphxIgRWLx4sUyaxMyvd955p0hnYglMdoxQp7plUaecE8asO4sLDyIx8o8zGNqyEiZ39oCVBctaRETGQpStRJlJHGXLls0xWbl37x42b96Mp0+fynV2xJH984VFDJQWCY4onYlS3ltvvYW5c+eiqPGdz0i5lbTDpg+8MbxVZfl45bF7eHtxAEKeFWAaJRER6RVRklKr1bke6YnM1KlT8/x8YREzr9atW4fo6Gg51X3FihUoVoAZbtpismPERC/Ol91qY/mgJnCytcTFB5HoOtcPuy+FKt00IiKiIsNkxwS0q+2KXeN90KhicUQnpmDU2rOYsv0yEpJTlW4aERFRoWOyYyLKF7fFhve98EHrqvLx74HBeGtRAO6GxyrdNCIiokLFZMeEiDV3Pu9cCyuHNkVJeytceRSF7vP88feFR0o3jYiIqNAw2TFBbWu6YNc4HzSrVBIxiSkY9+c5uQIzy1pERGJLLLXSTYCpx95Mi33B8sJkx0SVcbLBuhHNMfb1anLdrD9PhqDXgmO49UT71UKJiAyZpaWl/BhXkM0/qUDEWjwi4RHr/+gS19kxYWKH9I871ESzyiXx0Ybzcgf1HvP98W2vuujdqILSzSMiKlLiDVbs0p2+xYGdnV2BehjESsFJSUlISEjQfLsIE5SWlibXAhLJJpMd0jmf6qVlWWv8+vMIvPMMEzdeQODtZ5jWsw7srPgSISLTkb5nU/Y9nbQheiji4+Pllgq6LssYKxEnsR6PruPFdzKSXBxtsGZ4c8w/eAtzDtzApjMPcP5+BBYMaIQarrnvnktEZEzEm6xYidjFxSXPPaHyQzz/6NGjeO211zJKZPTq+F+/fh26xmSHMqjMzTC+XXVZ1hq3/hxuPomRZa1vetZFn8YV+JcJEZkMUUYpaClFPF/s8m1jY8NkJ58KmmDmhkVEeolX1VLYPd4HPtWdkZCchkmbL8rSVmxiitJNIyIi0hiTHcqRczFrrB7aDJ92rAlzM2DruYfoPt8f10KjlG4aERGRRpjsUK7Mzc0wum01rB/phTKONrjzNBY9FxzDuhMhXIeCiIgMhqLJzowZM9C0aVM4ODjIwWC9evV65cCkVatWybEjmQ9RD6XCI8bwiL212tYsjaSUNHyx9RLGrT+P6ITCqa0SEREZTbJz5MgRjB49GsePH8e+ffvkwKQOHTogNjbv/ZocHR0RGhqacQQHBxdZm02V2F7it8FN8UWXWrAwN8M/Fx7JrSYuP4xUumlERET6Oxtrz549L/XaiB6eM2fOyKl6uRG9OelrIVDRlrVGvlYVjd1Lyi0m7j2LQ++FAfiymwfebeHO2VpERKSX9GrquVhISChZsmSe18XExMDd3V2uttioUSN8//33qFOnTo7XJiYmyiNdVNR/A2xFL5Kup7il36+wps7pi/rlimHbqBb4fOtlHAh6iinbr+DYzaf4vlcdONpqPr3SVOKmS4yZdhg37TBu2mHcdBuzgsTRTK0nI01F4tKjRw9ERETA398/1+sCAwNx8+ZN1K9fXyZHs2bNkos2XblyBRUqvLzFwdSpUzFt2rSXzq9bt04uBU7aE6+cI2Fm+DvYHKlqM5SyVmNwjVS4F1O6ZUREZGzi4uLQv39/+d4vhrMYZLIzatQo7N69WyY6OSUtuRGZnoeHB3x9fTF9+vR89ey4ubkhPDxc42Dlpy1i7FH79u1NagGpiw8iMX7jRTx4EQ9LlRk+7VADQ7wq5rusZapxKwjGTDuMm3YYN+0wbrqNmXj/dnZ21irZ0Ysy1pgxY7Bjxw7ZQ6NJoiOIYHh6euLWrVs5ft7a2loeOT2vsF58hXlvfdS4sjN2jvPB539dxO7LYfh+93WcvBeBWX3qo7idVb7vY2px0wXGTDuMm3YYN+0wbrqJWUFiqOhsLNGpJBKdrVu34uDBg6hcubLG90hNTcWlS5fkXiakHCdbSywc0Ajf9KwDK5U59l97jK5z/XEm+IXSTSMiIhOnaLIjpp2vWbNGjp8Ra+2EhYXJQ+wSm27QoEGYPHlyxuNvvvkG//77L+7cuYOzZ89i4MCBcur58OHDFfouKJ0oWw3yqoQtH3qjUik7PIyIR78lgVhy5DbS0vSiWkpERCZI0WRn0aJFsvbWpk0b2TOTfmzYsCHjmpCQELmWTroXL15gxIgRcpxOly5dZA0vICAAtWvXVui7oOzqlnfCP2NboXuDckhJU2PG7iC8t/oUnscmKd00IiIyQYqO2cnP2OjDhw9neTx79mx5kH5zsLHE3HcawrtqKUz9+woOXX+KLnP8MNfXU67ITEREVFS4NxYValnLt1lFbBvdElVK2yMsKgG+y45jwaFbLGsREVGRYbJDhc6jrCP+GdMKvT3LIzVNjZl7r2PwypMIj/m/JQGIiIgKC5MdKhL21hb4uW8D/PR2fdhYmsPvZrgsawXefqZ004iIyMgx2aEiLWv1beIme3lquBbDk+hEDFh+HPMO3garWkREVFiY7FCRq+7qgO2jW6FvkwoyyZl76DYWXjXH02iWtYiISPeY7JAibK1U+OntBpjdrwHsrFS4GWWO7gsC4X8zXOmmERGRkWGyQ4p607MCtn7QAuXs1HgWm4R3V5zArL3XkZKapnTTiIjISDDZIcWJaekf1U3FO00ryJ3U5x+6hf7LTiAsMkHpphERkRFgskN6wUoFTO9RG/N8PVHM2gIn7z1Hl7l+OHT9idJNIyIiA8dkh/SK2GJix9hWqFveUW4vMXTlKczYfQ3JLGsREZGWmOyQ3qnkbI+/RnljsJe7fLzkyB28s/S43FiUiIhIU0x2SC9ZW6gwrWddLBrQCA42FjgT/EIuQrjv6mOlm0ZERAaGyQ7ptc71ymLXOB80qOCEyPhkjPj9NKbvuIqkFJa1iIgof5jskN5zK2mHTR94471WleXj3/zvos+SQNx/Hqd004iIyAAw2SGDYGVhjq+61cayQU3gZGuJC/cj5GytPZdDlW4aERHpOSY7ZFDa13bFrvE+aFSxOKITUvDBmrP4evtlJKakKt00IiLSU0x2yOCUL26LDe974f3WVeTj1YHBeGtRAO6FxyrdNCIi0kNMdsggWarMMbmzB1YOaYoSdpa4/DAK3eb5458Lj5RuGhER6RkmO2TQ2tZykWWtZpVKIiYxBWP/PIcvtl5CQjLLWkRE9B8mO2TwyjrZYt2I5hjTthrMzIB1J0LQa8Ex3H4ao3TTiIhIDzDZIaNgoTLHJx1r4vdhzeBczApBYdHoPs8fW889ULppRESkMCY7ZFR8qpeWixB6VSmFuKRUfLThAiZtvoD4JJa1iIhMFZMdMjoujjZYM7w5JrSrLstaG08/QM8F/rj5OFrpphERkQKY7JBRUpmbYUK7Glg7vDlKO1jjxuMYdJ/vj02n7yvdNCIiKmJMdsioeVd1lmUtn+rOSEhOw6ebL2LixvOITUxRumlERFREmOyQ0RM9O6uHNsOnHWvC3AzYcvYhesz3R1BYlNJNIyKiIsBkh0yCubkZRrethvUjvVDG0Qa3n8ai5/xj+PNkCNRqtdLNIyKiQsRkh0xKs8ol5SKEbWqWRmJKGiZvuYRx688jOiFZ6aYREVEhYbJDJqekvRVWDG6KyZ1ryYHMYosJsSbP5YeRSjeNiIgKAZMdMtmy1vutq2Lj+14o52SDe8/i0HthAP4IvMeyFhGRkWGyQyatsXsJWdZq5+GKpNQ0fLX9CkavO4solrWIiIwGkx0yecXtrLBsUGN81a02LFVm2HUpDF3n+uHC/Qilm0ZERDrAZIcIgJmZGd5rVRmbP/BGhRK2uP88Hm8vDsAK/7ssaxERGTgmO0SZNHArjp3jfNCpThkkp6rxzY6rGPnHGUTEJSndNCIi0hKTHaJsnGwtsWhgI3zTsw6sVObYd/Uxus71x9mQF0o3jYiItMBkhyiXstYgr0rY8qE33EvZ4WFEPPouDsSSI7eRlsayFhGRIWGyQ5SHuuWdsGNsK3SrXxYpaWrM2B2E4b+fxvNYlrWIiAwFkx2iV3CwscQ8X098/2Y9WFmY42DQE3SZ44dT954r3TQiIsoHJjtE+Sxr9W9eEdtHt0SV0vYIi0rAO0uPY8GhWyxrERHpOSY7RBrwKOuIf8a0wpue5ZGapsbMvdcxeOVJhMckKt00IiLKBZMdIg3ZW1vgl74N8NPb9WFjaQ6/m+GyrBV4+5nSTSMiohww2SHSsqzVt4kb/h7TCtVdiuFJdCIGLD+OX/ffkD0+RESkP5jsEBVADVcHbB/TEn0aV4DIcX7dfxPv/nYCT6ITlG4aERH9f0x2iArIzsoCM/s0kKUtOysVAm4/k2Ut/5vhSjeNiIiY7BDpTu9GFWRZq1YZB4THJOHdFScwa+91pKSmKd00IiKTxmSHSIequRTDttEt4dusIsT+ofMP3UL/5ScQFsmyFhGRUpjsEOmYjaUKM3rXw1xfT9hbqXDy7nN0meuHw9efKN00IiKTpGiyM2PGDDRt2hQODg5wcXFBr169cP369Vc+b9OmTahVqxZsbGxQr1497Nq1q0jaS6SJHg3KYcc4H9Qu6yi3lxiy8hR+2B2EZJa1iIhMJ9k5cuQIRo8ejePHj2Pfvn1ITk5Ghw4dEBsbm+tzAgIC4Ovri/feew/nzp2TCZI4Ll++XKRtJ8qPys72cjPRQV7u8vHiI7flystiY1EiIjKBZGfPnj0YMmQI6tSpgwYNGmDVqlUICQnBmTNncn3OnDlz0KlTJ3z66afw8PDA9OnT0ahRI8yfP79I206kSVnrm551sXBAIzhYW+BM8At0neuH/VcfK900IiKTYAE9EhkZKT+WLFky12sCAwMxceLELOc6duyIbdu25Xh9YmKiPNJFRUXJj6IXSRy6lH4/Xd/X2JlK3NrXckbND1tgwsaLuPQwSu6ePszbHR+3ry43GNWEqcRM1xg37TBu2mHcdBuzgsTRTK0Wc0aUl5aWhh49eiAiIgL+/v65XmdlZYXVq1fLUla6hQsXYtq0aXj8+OW/lKdOnSo/l926detgZ2enw++AKH9S0oC/g81xJOy/BMe9mBqDq6eilI3SLSMi0l9xcXHo37+/7BhxdHQ0zJ4dMXZHjLvJK9HRxuTJk7P0BImeHTc3Nzk2SNNgvYrIOsXYo/bt28PS0lKn9zZmphi3HgD2X3uCz7ZcRnBMCmZfs8EPb9ZBh9qu+Xq+KcZMFxg37TBu2mHcdBuz9MqMNvQi2RkzZgx27NiBo0ePokKFCnleW6ZMmZd6cMRjcT4n1tbW8shOBLGwXnyFeW9jZmpx61y/POq5lcDYP8/hXEgERv95AUO8K2Fyl1qwtlDl6x6mFjNdYdy0w7hph3HTTcwKEkNFByiLCppIdLZu3YqDBw+icuXKr3yOl5cXDhw4kOWcyALFeSJDU6GEHTa+74WRr1WRj1cF3MPbiwIR/Cz3GYlERGRAyY4oXa1Zs0aOnxFr7YSFhckjPv7/puUOGjRIlqLSjR8/Xs7i+vnnnxEUFCTH5Jw+fVomTUSGyFJlji+6eGDFkCYoYWeJSw8j0XWuP3ZcfKR004iIjIKiyc6iRYvkQKM2bdqgbNmyGceGDRsyrhFT0UNDQzMee3t7y+Ro6dKlcrr65s2b5UysunXrKvRdEOnG67VcsWu8D5q4l0BMYgrGrDuH/229hITkVKWbRkRk0BQds5OfiWCHDx9+6VyfPn3kQWRsyjrZYv3IFvhl3w0sPHwba0+E4GxIBBb090SV0sWUbh4RkUHi3lhEesZCZY5JnWph9bBmKGVvhWuhUeg2zx/bzj1UumlERAaJyQ6Rnmpdo7Qsa7WoUhJxSamYsOE8Ptt8EfFJLGsREWmCyQ6RHnN1tMHa4S0w7o3qMDMDNpy+j14LjuHWkxilm0ZEZDCY7BDpOZW5GSa2r4G17zWHczFrXH8cjd6Lj+PkEzOlm0ZEZBCY7BAZCO9qztg93getqjkjPjkNa2+rMOmvS4hNTFG6aUREeo3JDpEBKe1gLQcuT3ijGsygxtbzoegx3x9BYdovo05EZOyY7BAZYFlrdJsqGFMnFa4O1rj9NBY95x/D+pMh+VrOgYjI1DDZITJQ1RyB7aO95KytxJQ0fL7lEsavPy8XJCQiov/DZIfIgIl1eFYOaYrPOtWSPT5/X3iE7vP8ceVRpNJNIyLSG0x2iAycubkZRrWpio3vt0A5JxvcDY/FmwsD8EfgPZa1iIiY7BAZj8buJbFznA/aebggKSUNX22/gtHrziIqIVnpphERKYrJDpERKWFvhWWDmuDLrh6wMDfDrkth6DbXHxcfRCjdNCIixTDZITIyZmZmGO5TBZs+8EL54rYIeR6HtxYFYIX/XZa1iMgkMdkhMlKeFUtg1zgfdKzjiuRUNb7ZcRXv/3EGkXEsaxGRaWGyQ2TEnOwssXhgY0ztXhtWKnP8e/Uxusz1w9mQF0o3jYioyDDZITKBstaQlpXx1yhvVCxph4cR8ei7OBBLj95GWhrLWkRk/JjsEJmIehWcsGNcK3StXxYpaWp8vysIw38/jRexSUo3jYioUDHZITIhjjaWmO/riW971YWVhTkOBj2RZa1T954r3TQiokLDZIfIBMtaA1u4Y9uHLVHF2R6hkQl4Z+lxLDh0i2UtIjJKTHaITFTtco74e2wr9GpYDqlpaszcex1DVp1CeEyi0k0jItIpJjtEJqyYtQVm92uIH9+qBxtLcxy98RRd5vjh+J1nSjeNiEhnmOwQmThR1urXtCK2j26Fai7F8CQ6Ef2XHcec/Tdljw8RkaFjskNEUs0yDvh7TEu83bgCRI4ze/8NDFpxAk+iE5RuGhFRgTDZIaIMdlYWmNWnAX7u0wC2liocu/UMXeb449itcKWbRkSkNSY7RPSStxpXwD9jW6Gmq4McsDzwtxP45d/rSElNU7ppREQaY7JDRDkS43e2j2kJ32ZuEPuHzj14C/2Xn8DjKJa1iMiwMNkholzZWKowo3d9zHmnIeytVDh59zk6z/HD4etPlG4aEVG+Mdkholfq2bC8LGvVLuuI57FJGLLyFH7cE8SyFhEZBCY7RJQvVUoXw5YPvfFuC3f5eNHh23Ll5UcR8Uo3jYgoT0x2iEijstb0XnWxcEAjOFhb4HTwC7m31oFrj5VuGhFRrpjsEJHGutQri53jfFC/ghMi4pLx3urT+HbHVSSlsKxFRPqHyQ4RaaViKTts+sALQ1tWko+X+99F3yWBuP88TummERFlwWSHiLRmbaHC193rYMm7jeFoY4Hz9yPQda4f9lwOU7ppREQZmOwQUYF1rFMGu8b7oKFbcUQlpOCDNWcw9e8rSExJVbppRERMdohINyqU+K+sNfK1KvLxqoB7eHtRIIKfxSrdNCIycUx2iEhnLFXm+KKLB1YMaYLidpa49DAS3eb6Y+fFUKWbRkQmjMkOEenc67VcsWucD5q4l0B0YgpGrzuLL7ddQkIyy1pEVPSY7BBRoShX3BbrR7bAh22qysdrjofgzYUBuPM0RummEZGJYbJDRIXGQmWOSZ1qYfWwZihlb4VroVHoNs8f2849VLppRGRCmOwQUaFrXaO0nK3VvHJJxCWlYsKG8/hs80XEJ7GsRUSFj8kOERUJV0cbrB3eHOPeqA4zM2DD6fvoteAYbj2JVrppRGTkmOwQUZGWtSa2r4E17zWHczFrXH8cje7zjmHzmQdKN42IjBiTHSIqci2rOWPX+FZoWa0U4pNT8cmmC5i48TziklKUbhoRGSEmO0SkCBcHG/w+rDk+bl8D5mbAlrMP0X2eP4LCopRuGhEZGSY7RKQYlbkZxr5RHetGtICrozVuP41Fz/nHsP5kCNRqtdLNIyIjYaHpEyIiIrB161b4+fkhODgYcXFxKF26NDw9PdGxY0d4e3sXTkuJyGi1qFJKLkI4ceMFHLnxFJ9vuYTAO8/w3Zv1UMxa419TRETa9ew8evQIw4cPR9myZfHtt98iPj4eDRs2xBtvvIEKFSrg0KFDaN++PWrXro0NGzbk97ZERFKpYtZYOaQpPutUS/b4bD//SJa1rjyKVLppRGTg8v0nk+i5GTx4MM6cOSMTmpyIBGjbtm349ddfcf/+fXzyySd53vPo0aOYOXOmvGdoaKjsMerVq1eu1x8+fBht27Z96bx4bpkyZfL7rRCRnjI3N8OoNlXRtFIJjP3zHO6Gx8pVl7/qVhsDm1eEmZizTkRUWMnO1atXUapUqTyvsbW1ha+vrzyePXv2ynvGxsaiQYMGGDZsGHr37p3fpuD69etwdHTMeOzi4pLv5xKR/mtSqaQsa4lZWgeCnuCrbZdx/M4zzOhdD442lko3j4iMNdl5VaKjzfWdO3eWh6ZEclO8eHGNn0dEhqOEvRWWD26C3/zv4ofdQXLn9EsPIjG/vyfqV+D//0SUfwUe+Sd6WM6fP48qVaqgqIixQomJiahbty6mTp2Kli1b5nqtuE4c6aKi/pvWmpycLA9dSr+fru9r7Bg3zZlSzAa3cEOD8g6YsPEiQp7H4a1FAfisYw0MaqF5WcuU4qZLjJt2GDfdxqwgcTRTF3B+p4ODAy5cuFDgZEf80nrVmB1RvhLjdpo0aSITmOXLl+OPP/7AiRMn0KhRoxyfI5KhadOmvXR+3bp1sLOzK1CbiajoxKUA626Z49KL/+ZV1C+ZBt+qabDjZC0ikxAXF4f+/fsjMjIyy1AWo0t2ctK6dWtUrFhRJj357dlxc3NDeHi4xsF6FZF17tu3T85Ks7TkuIL8Ytw0Z6oxE7+u/jhxHz/suY7kVDXKF7fBr33ro6Fb/spaphq3gmLctMO46TZm4v3b2dlZq2SnwH8TDRw4UOdJgyaaNWsGf3//XD9vbW0tj+xEEAvrxVeY9zZmjJvmTDFm7/lURbPKzhi97qwsa/kuPyWnqw/3qZzvspYpxk0XGDftMG66iVlBYljgFZQXLVokMy2liPFCYu0fIjId9So4Yce4VuharyxS0tT4btc1DF99Gi9ik5RuGhHpoXwnO+vXr8/3TcUaO8eOHXvldTExMTJZEYdw9+5d+e+QkBD5ePLkyRg0aFDG9WL9nu3bt+PWrVu4fPkyJkyYgIMHD2L06NH5bhsRGQcxBV3MzPq2V11YWZjLKepd5/rh9L3nSjeNiAw12RE9OB4eHvjpp59w7dq1lz4vami7du2Sg4fEYOH8rLNz+vRpuVihOISJEyfKf0+ZMiVjscD0xEdISkrCxx9/jHr16smxOmKs0P79++UqzkRkekTZamALd2z90BuVne3xKDIB/ZYex8LDt5CWxr21iEjDMTtHjhzB33//jXnz5skeF3t7e7i6usLGxgYvXrxAWFiYLGcNGTJE9rqIz71KmzZt8tzsb9WqVVkeT5o0SR5ERJnVKeeEf8a2wv+2XpLbTPy05zpO3HmOX/o2kNtQEJFp02iAco8ePeQhZjKJQcFiI1CxRYRIctJ7aMzNuZE6ERU9sWHor/0awrtqKUzZfkVuKNplrh/mvOMpNxolItOl1WwskdxoOkWciKgoylr9mlZEQ7cScrbWrScx6L/sOCa0q4HRbasp3TwiUgi7YYjI6NQs44C/x7TEW40qQAzd+WXfDQxacQJPo/9vzS0iMh1MdojIKNlZWeDnvg0wq08D2FqqcOzWM/RYGIjrkdw5ncjUMNkhIqP2duMK+GdsS9R0dUB4TBIWXTXHnAO3kMrZWkQmg8kOERm9ai4O2Da6Jfo2Lg81zDD/8B05ludxVILSTSMiQ0h2xNTxAm6vRURU6GytVPiuVx28Wy0V9lYqnLj7HJ3n+MlZW0Rk3LROdn777TfUrVtXrrMjDvFvsQs5EZE+a1Jaja2jWsCjrCOexyZh8IqT+HFPEFJS05RuGhHpU7IjVjgeP348unfvjk2bNslD/Pujjz7KWP2YiEhfidWWxarLA1tUlI8XHb6Nd5Yex6OIeKWbRkT6ss6O2Dpi2bJl8PX1zTgnFhusX78+xo4di2+++UaXbSQi0jkbSxW+7VVPLjg4+a9LOB38Qi5CKFZdfr3Wq1eAJyIj79lJTk5GkyZNXjrfuHFjpKSk6KJdRERFolv9cnIH9XrlnRARl4xhq07ju51XkcyyFpFpJzvvvvuu7N3JbunSpRgwYIAu2kVEVGTcS9lj8ygvDPGuJB8v87uLPosDcf95nNJNI6KiLGOJHckzL8kuBiP/+++/aNGihTx34sQJuUP5oEGDdNEuIqIiZW2hwtQedWRZa9LmCzh/PwJd5/phZp8G6FinjNLNI6KiSHbOnTv3UslKuH37dsZ+WeK4cuVKQdpDRKSoTnXLoE45R4z58xwu3I/A+3+ckT0+k7vUkgkRERlxsnPo0KHCbQkRkZ5wK2mHTe97YebeIFnSWhVwD2eCX2B+f09Z8iIiw8IVlImIcmBlYY7/da2N5YOaoLidJS49jES3uf7YeTFU6aYRkYaY7BAR5aFdbVfsGueDJu4lEJ2YgtHrzuLLbZeQkJyqdNOIKJ+Y7BARvUK54rb4c2QLjGpTVT5eczwEvRcG4G54rNJNI6J8YLJDRJQPlipzfNapFlYNbYqS9la4GhqFbnP9sP38Q6WbRkSvwGSHiEgDbWq6yLJWs8olEZuUivHrz2PylossaxHpMSY7REQaKuNkg3XDm2Pc69VgZgb8efI+es4/hltPYpRuGhHlgMkOEZEWLFTmmNihJv4Y1hzOxaxx/XE0us/zx19nHijdNCLKhskOEVEBtKrujF3jW6FltVKIT07Fx5su4JNNFxCXxH0CifQFkx0iogJycbDB78OaY2L7GjA3AzafeSDLWjceRyvdNCJiskNEpBsqczOMe6M61o1oARcHa9x8EoMe8/2x4VQI1Gq10s0jMmlMdoiIdEhsJLprvA9eq1EaCclp+OyvS/how3nEJLKsRaQUJjtERDomBiyvGtIUkzrVlD0+284/Qo95/rj6KErpphGZJCY7RESFwNzcDB+2qYYNI1ugrJMN7oTHotfCY1h7IphlLaIixmSHiKgQNalUUi5C+EYtFySlpOF/Wy9jzJ/nEJ2QrHTTiEwGkx0iokJWwt4Kywc3wf+6eMDC3EzunN5tnj8uP4xUumlEJoHJDhFRETAzM8OI16pg4wdeKF/cFsHP4uRmoquO3WVZi6iQMdkhIipCjSqWkGWtDrVdkZSahqn/XMWoNWcRGc+yFlFhYbJDRFTEnOwsseTdxvi6e21Yqsyw50oYus71w/n7EUo3jcgoMdkhIlKorDW0ZWX8NcobFUva4cGLeLy9KADL/e6wrEWkY0x2iIgUVL9CcewY1wpd65VFSpoa3+68hhG/n0ZEXJLSTSMyGkx2iIgU5mhjifn9PTG9V11YWZhj/7Un6DLHD2eCnyvdNCKjwGSHiEhPylrvtnDH1g+9UdnZHo8iE9B3yXEsPnIbaWksaxEVBJMdIiI9UqecE/4Z2wo9G5ZDapoaP+wOwrDVp/AsJlHpphEZLCY7RER6ppi1BX7t1xA/9K4HawtzHL7+FF3m+uHEnWdKN43IIDHZISLS07LWO80qYvuYlqha2h6PoxLhu+w45h+8ybIWkYaY7BAR6bFaZRxlWat3o/IQOc6sf29g8MqTeBrNshZRfjHZISLSc3ZWFvilb0PM6tMAtpYq+N0Ml2WtgFvhSjeNyCAw2SEiMhBvN66Av8e0RA3XYrJnZ8BvJ/DLvhtyIDMR5Y7JDhGRAanu6oDto1vhnaZuEAstzz1wEwOWH8fjqASlm0akt5jsEBEZGFsrFX54qz7mvNMQ9lYqHL/zXC5CePTGU6WbRqSXmOwQERmong3Ly8HLHmUd8Sw2SQ5cnrk3CCmpaUo3jUivMNkhIjJgVUoXk6suD2xRUZa1Fhy6Laeoh0bGK900Ir2haLJz9OhRdO/eHeXKlZNrSmzbtu2Vzzl8+DAaNWoEa2trVKtWDatWrSqSthIR6SsbSxW+7VVP7q8lFiQ8de+FLGsdCnqidNOI9IKiyU5sbCwaNGiABQsW5Ov6u3fvomvXrmjbti3Onz+PCRMmYPjw4di7d2+ht5WISN91q18OO8e1Qr3yTngRl4yhq05hxq5rSGZZi0ychZJfvHPnzvLIr8WLF6Ny5cr4+eef5WMPDw/4+/tj9uzZ6NixYyG2lIjIMLiXssfmUV6YsSsIqwLuYcnROzh57znm+XqiQgk7pZtHZHrJjqYCAwPRrl27LOdEkiN6eHKTmJgoj3RRUVHyY3Jysjx0Kf1+ur6vsWPcNMeYacdU4ia67P/XuQaaujth8tYrOBcSga5z/fDDm3XRzsNF4/uZStx0jXHTbcwKEkeDSnbCwsLg6uqa5Zx4LBKY+Ph42NravvScGTNmYNq0aS+d//fff2FnVzh/5ezbt69Q7mvsGDfNMWbaMaW4TfAAVt9UITgmBaPWnUfrsmnoUTENFloMYjCluOkS46abmMXFxcEkkh1tTJ48GRMnTsx4LBIjNzc3dOjQAY6Ojjr9WiLrFD+g9u3bw9LSUqf3NmaMm+YYM+2Yatz6paThl/038duxYBwJNccL8+L4tV99uOWzrGWqcSsoxk23MUuvzBh9slOmTBk8fvw4yznxWCQtOfXqCGLWljiyE0EsrBdfYd7bmDFummPMtGNqcRPf6lfd68Kraml8svkCLj6MQs+Fx/HTW/XRuV5ZDe5jWnHTFcZNNzErSAwNap0dLy8vHDhwIMs5kQGK80RElLd2tV2xa5wPGruXQHRCCkatPYsp2y8jITlV6aYRFSpFk52YmBg5hVwc6VPLxb9DQkIySlCDBg3KuP6DDz7AnTt3MGnSJAQFBWHhwoXYuHEjPvroI8W+ByIiQ1KuuC3Wj2yBUW2qyse/BwbjrUUBuBseq3TTiIwz2Tl9+jQ8PT3lIYixNeLfU6ZMkY9DQ0MzEh9BTDvfuXOn7M0R6/OIKejLly/ntHMiIg1YqszxWadaWDW0KUraW+HKoyh0n+ePvy88UrppRIVC0TE7bdq0gVqsb56LnFZHFs85d+5cIbeMiMj4tanpIsta49afw8m7zzHuz3MIvP0MX3evLVdlJjIWBjVmh4iIdKuMkw3WDW+Osa9Xg5kZ8OfJEPRacAy3nsQo3TQinWGyQ0Rk4ixU5vi4Q038Maw5nItZIygsGj3m+2PL2QdKN41IJ5jsEBGR1Kq6M3aNbwXvqqUQl5SKiRsv4NNNFxCXlKJ004gKhMkOERFlcHGwwR/vNcdH7WrA3AzYdOYB3lp8AqHaL15LpDgmO0RElIXK3Azj21XH2uEt4OJgjVtPY/HzJRU2nXmY56QSIn3FZIeIiHLkVbUUdo33QatqpZCcZoYvtl2Rpa3YRJa1yLAw2SEiolyJAcu/vdsI3Sqmyh6freceyjV5roVqv08RUVFjskNERHkyNzdD+/JqrBnWBGWdbHAnPBY9FxzD2hPBLGuRQWCyQ0RE+dLEvQR2jvPB67VckJSShv9tvYyxf55DdEKy0k0jyhOTHSIiyjexvcTyQU3wRZdasDA3w46Loeg2zx+XH0Yq3TQi/dwuQlGxsYBKx8uhJydDlZDw370LsBW9yWHcNMeYaYdx00ncxF/JIxuXQTMXa3y88QIehT7HgF8PYlKnmujfvCLMxFLMxNebrmMmzmnJTG1iBdeoqCg4OTlB/A3iqHRjiIiIKF/EkHgnAJGRkXB01OwdnGUsIiIiMmqmW8Z69AjQMDN8leTkZOzduxcdO3aEJbss841x0xxjph3GrXDjdulhhCxr3X8eD0uVGSa2r4HB3pVMtqzF15uOYxYVBZQrp8VdTTnZsbf/79Cl5GSk2tj8d1++sPOPcdMcY6Ydxq1Q41avhj02f+KCz/+6iF2XwjD1YDD8QxMwq099FLezgsnh6023MUtNhbZYxiIiIp1xtLHEgv6NML1XXVhZmGP/tcfoMscPZ4JfKN00MmFMdoiISKdE2erdFu7Y+qE3Kjvb41FkAvouCcTiI7eRlmZSc2JITzDZISKiQlGnnBP+GdsKPRqUQ2qaGj/sDsKw1afwPDZJ6aaRiWGyQ0REhaaYtQXmvNMQP/SuB2sLcxy+/lSWtU7efa5008iEMNkhIqJCL2u906wito9piaql7REWlYB3lgZi/sGbLGtRkWCyQ0RERaJWGUf8PaYVejcqD5HjzPr3BgavPImn0YlKN42MHJMdIiIqMvbWFvilb0PMfLs+bC1V8LsZji5z/RBwK1zpppERY7JDRERFrk8TN/w9piVquBaTPTsDfjuB2ftuyIHMRLrGZIeIiBRR3dUB20e3Qr8mbhC7NM45cBMDl5/Ak6gEpZtGRobJDhERKcbWSoUf366PX/s1hJ2VCoF3nqHzHD8cvfFU6aaREWGyQ0REiuvlWR47xraCR1lHPItNkgOXZ+4NQkpqmtJNIyPAZIeIiPRCldLF5KrLA5pXlGWtBYduw3fZcYRGxivdNDJwTHaIiEhv2Fiq8N2b9TC/v6dckPDUvRdyEcJDQU+UbhoZMCY7RESkd7rVLyfLWnXLO+JFXDKGrjqFGbuuIZllLdICkx0iItJLlZzt8dcobwzxriQfLzl6B/2WBOJhBMtapBkmO0REpLesLVSY2qMOFg9sBAcbC5wNiZBlrX1XHyvdNDIgTHaIiEjvdapbFrvG+aBBBSdExidjxO+n8c0/V5GUwrIWvRqTHSIiMghuJe2w6QNvDG9VWT5ecewu+iwOwP3ncUo3jfQckx0iIjIYVhbm+LJbbSwf1AROtpa48CBS7q21+1Ko0k0jPcZkh4iIDE672q7YNd4HjSoWR3RCCkatPYsp2y8jITlV6aaRHmKyQ0REBql8cVtseN8L77euIh//HhiMtxYF4F54rNJNIz3DZIeIiAyWpcockzt7YOXQpihpb4Urj6LQbZ4//r7wSOmmkR5hskNERAavbU0XOVurWaWSiElMwbg/z2Hylkssa5HEZIeIiIxCGScbrBvRHGNfrwYzM+DPkyHoteAYbj+NUbpppDAmO0REZDQsVOb4uENN/D6sGZyLWSEoLBrd5/lj67kHSjeNFMRkh4iIjI5P9dKyrOVVpRTiklLx0YYL+HTTBcQnsaxlipjsEBGRUXJxtMGa4c0xoV11WdbadOYBesz3x43H0Uo3jYoYkx0iIjJaKnMzTGhXA2uHN0dpB2vcfBIjE56Np+9DrVYr3TwqIkx2iIjI6HlXdcbu8T7wqe6MhOQ0TNp8ERM3XkBsYorSTaMiwGSHiIhMgnMxa6we2gyfdqwJczNg67mH6D7fH9dCo5RuGhUyJjtERGQyzM3NMLptNawf6YUyjja48zQWPRccw7oTISxrGTEmO0REZHKaVS4p99ZqU7M0klLS8MXWSxi3/jyiE5KVbhoZa7KzYMECVKpUCTY2NmjevDlOnjyZ67WrVq2CmZlZlkM8j4iISBNie4kVg5ticudaciDzPxceyTV5Lj+MVLppZGzJzoYNGzBx4kR8/fXXOHv2LBo0aICOHTviyZMnuT7H0dERoaGhGUdwcHCRtpmIiIynrPV+66rY+L6X3Fj03rM49F4YgNUB91jWMiKKJzu//PILRowYgaFDh6J27dpYvHgx7OzssGLFilyfI3pzypQpk3G4uroWaZuJiMi4NHYvgZ3jWqGdhyuSUtPw9d9X8OHas4iMZ1nLGFgo+cWTkpJw5swZTJ48OeOcubk52rVrh8DAwFyfFxMTA3d3d6SlpaFRo0b4/vvvUadOnRyvTUxMlEe6qKj/Rt0nJyfLQ5fS76fr+xo7xk1zjJl2GDftmErc7C3NsNC3PlYFhmDmvzew+3IYLj2IwK/9GqBBBSeN72cqcdOlvGJWkDiaqRXsp3v06BHKly+PgIAAeHl5ZZyfNGkSjhw5ghMnTrz0HJEE3bx5E/Xr10dkZCRmzZqFo0eP4sqVK6hQocJL10+dOhXTpk176fy6detkDxIREVF2wTHA6hsqPEs0g8pMjR7uaWhdRi1XYiZlxMXFoX///vK9XwxnMepkJ6dMz8PDA76+vpg+fXq+enbc3NwQHh6ucbDy05Z9+/ahffv2sLS01Om9jRnjpjnGTDuMm3ZMNW5R8cn4YtsV7L363xjSN2qVxg9v1kVxu/zFwFTjVhB5xUy8fzs7O2uV7ChaxhKNVqlUePz4cZbz4rEYi5MfIhienp64detWjp+3traWR07PK6wXX2He25gxbppjzLTDuGnH1OJWytISi99tgj+OB+PbHddwIOgpei06jrm+nnKMT36ZWtx0IaeYFSSGig5QtrKyQuPGjXHgwIGMc2IcjnicuacnL6mpqbh06RLKli1biC0lIiJTJCbEDPKqhC0fesO9lB0eRsSj35JALDlyG2lpnK1lKBSfjSWmnS9btgyrV6/GtWvXMGrUKMTGxsrZWcKgQYOyDGD+5ptv8O+//+LOnTtyqvrAgQPl1PPhw4cr+F0QEZExq1veCTvGtkK3+mWRkqbGjN1BeG/1KTyPTVK6aaTvZSyhX79+ePr0KaZMmYKwsDA0bNgQe/bsyZhOHhISImdopXvx4oWcqi6uLVGihOwZEmN+xLR1IiKiwuJgY4l5vp5yU9Gp/1zBoetP0WWOnyxriRWZSX8pnuwIY8aMkUdODh8+nOXx7Nmz5UFERKREWat/84rwrFgco9edlXtr+S47jonta2BU66pykULSP4qXsYiIiAyNR1lH/DOmFd70LI/UNDVm7r2OwStP4mn0/83+Jf3BZIeIiEgL9tYW+KVvA/z0dn3YWJrD72Y4usz1Q8DtcKWbRtkw2SEiIipAWatvEzf8PaYVqrsUkz07A5efwK/7b8geH9IPTHaIiIgKqIarA7aPaYk+jStA5Di/7r+JIatOI5KTtfQCkx0iIiIdsLOywMw+DWRpy85KheN3X+Cniyr433qmdNNMHpMdIiIiHerdqIIsa9V0LYaYZDMM+/0MZu29jpTUNKWbZrKY7BAREelYNZdi2Px+c3i7pEHsQDn/0C30X3YCoZHxSjfNJDHZISIiKgQ2lir0q5qG2X3qwd5KhZP3nstFCA9d/29jUSo6THaIiIgKkdhiYsc4H9Qp54gXcckYuvIUZuy+hmSWtYoMkx0iIqJCVtnZHn+N8sYgL3f5eMmRO3JDUbGxKBU+JjtERERFVNb6pmddLBrQCA42FjgbEiHLWvuuPla6aUaPyQ4REVER6lyvLHaO9UGDCk6IjE/GiN9PY/qOq0hKYVmrsDDZISIiKmIVS9lh0wfeGNaysnz8m/9d9FkSiPvP45RumlFiskNERKQAKwtzTOleG8sGNYGTrSUu3I+Qe2vtuRyqdNOMDpMdIiIiBbWv7Yqd41rBs2JxRCek4IM1Z/H19stITElVumlGg8kOERGRwiqUsMPG973wfusq8vHqwGC8tSgA98JjlW6aUWCyQ0REpAcsVeaY3NkDK4c0RQk7S1x+GIVu8/yx4+IjpZtm8JjsEBER6ZG2tVywa7wPmlYqgZjEFIxZdw5fbL2EhGSWtbTFZIeIiEjPlHWyxZ8jWmBM22owMwPWnQhBrwXHcPtpjNJNM0hMdoiIiPSQhcocn3Ssid+HNUMpeysEhUWj+zx/bD33QOmmGRwmO0RERHrMp3pp7B7vA68qpRCXlIqPNlzApM0XEJ/EslZ+MdkhIiLScy6ONlgzvDnGv1FdlrU2nn6Angv8cfNxtNJNMwhMdoiIiAyAytwMH7WvgbXvNUdpB2vceByD7vP9sfH0fajVaqWbp9eY7BARERkQ72rO2DXOBz7VnZGQnIZJmy/i440XEJuYonTT9BaTHSIiIgMjenZWD22GTzrUgLkZsOXcQ/SY749roVFKN00vMdkhIiIyQObmZhjzenU5Rd3V0Rq3n8bK6elimjrLWlkx2SEiIjJgzauUkmWtNjVLIzElTS5AOG79eUQnJCvdNL3BZIeIiMjAlSpmjRWDm+LzzrXkQOZ/LjySa/JcfhipdNP0ApMdIiIiIylrfdC6Kja+3wLlnGxw71kcei8MwO+B90y+rMVkh4iIyIg0di8p99Zq5+GCpNQ0TNl+BaPXnUVkvOmWtZjsEBERGZnidlZYNqgJvuzqAUuVGXZdCkO3eX64cD8CpojJDhERkREyMzPDcJ8q2PSBNyqUsMX95/F4e3EAfvO/a3JlLSY7RERERqyhW3HsHOeDTnXKIDlVjek7rmLkH2cQEZcEU8Fkh4iIyMg52Vpi0cBGmNajDqxU5th39TG6zvXH2ZAXMAVMdoiIiEykrDXYuxK2fOgN91J2eBgRj76LA7HkyG2kpRl3WYvJDhERkQmpW94JO8a2Qrf6ZZGSpsaM3UEY/vtpPI813rIWkx0iIiIT42BjiXm+nvj+zXqwsjDHwaAn6DLHD6fuPYcxYrJDRERkomWt/s0rYvvolqjibI+wqAS8s/Q4Fhy6ZXRlLSY7REREJsyjrCP+GdsKb3qWR2qaGjP3XsfglScRHpMIY8Fkh4iIyMTZW1vgl74N8NNb9WFjaQ6/m+GyrBV4+xmMAZMdIiIigihr9W3qhr/HtEJ1l2J4Ep2IAcuPY87+m7LHx5Ax2SEiIqIMNVwdsH1MS/RpXAEix5m9/wbe/e0EnkQnwFAx2SEiIqIs7KwsMLNPA1nasrNSIeD2M1nW8r8ZDkPEZIeIiIhy1LtRBVnWqlXGAeExSXh3xQn8/O91pKSmwZAw2SEiIqJcVXMphm2jW8K3WUWI/UPnHbyF/stPICzScMpaTHaIiIgoTzaWKszoXQ9zfT1hb6XCybvP0WWuHw5ffwJDwGSHiIiI8qVHg3LYMc4Hdco5yu0lhqw8hR92ByFZz8taepHsLFiwAJUqVYKNjQ2aN2+OkydP5nn9pk2bUKtWLXl9vXr1sGvXriJrKxERkSmr7GyPv0Z5Y5CXu3y8+MhtufKy2FhUXyme7GzYsAETJ07E119/jbNnz6JBgwbo2LEjnjzJuWssICAAvr6+eO+993Du3Dn06tVLHpcvXy7ythMREZlqWeubnnWxaEAjONhY4EzwC3Sd64f9Vx9DHyme7Pzyyy8YMWIEhg4ditq1a2Px4sWws7PDihUrcrx+zpw56NSpEz799FN4eHhg+vTpaNSoEebPn1/kbSciIjJlneuVxc6xPmhQwQkRccly9/Rvd1xFUop+lbUslPziSUlJOHPmDCZPnpxxztzcHO3atUNgYGCOzxHnRU9QZqInaNu2bTlen5iYKI90UVFR8mNycrI8dCn9frq+r7Fj3DTHmGmHcdMO46YdU4lbWUdLrHuvKWb+ewOrAkOw3P8uTt57hjVDm8LWSqWzmBUkjoomO+Hh4UhNTYWrq2uW8+JxUFBQjs8JCwvL8XpxPiczZszAtGnTXjr/77//yh6kwrBv375Cua+xY9w0x5hph3HTDuOmHVOJm6dIKmqaYe0tc9gnReDQ/r06jVlcXJxhJjtFQfQaZe4JEj07bm5u6NChAxwdHXX6tUTWKX5A7du3h6WlpU7vbcwYN80xZtph3LTDuGnHFOPWBcC7EfEoaW8lx/XoMmbplRmDS3acnZ2hUqnw+HHWAU3icZkyZXJ8jjivyfXW1tbyyE4EsbBefIV5b2PGuGmOMdMO46Ydxk07phY399KWhRKzgsRQ0QHKVlZWaNy4MQ4cOJBxLi0tTT728vLK8TnifObrBZEF5nY9ERERmTbFy1iixDR48GA0adIEzZo1w6+//orY2Fg5O0sYNGgQypcvL8feCOPHj0fr1q3x888/o2vXrli/fj1Onz6NpUuXKvydEBERkT5SPNnp168fnj59iilTpshBxg0bNsSePXsyBiGHhITIGVrpvL29sW7dOnz55Zf44osvUL16dTkTq27dugp+F0RERKSvFE92hDFjxsgjJ4cPH37pXJ8+feRBREREpPeLChIREREVJiY7REREZNSY7BAREZFRY7JDRERERo3JDhERERk1JjtERERk1JjsEBERkVFjskNERERGjckOERERGTW9WEG5KKnV6gJvFZ/X1vRxcXHy3qa0w21BMW6aY8y0w7hph3HTDuOm25ilv2+nv49rwuSSnejoaPnRzc1N6aYQERGRFu/jTk5OGj3HTK1NimTA0tLS8OjRIzg4OMDMzEyn9xZZp0ii7t+/D0dHR53e25gxbppjzLTDuGmHcdMO46bbmIl0RSQ65cqVy7JBeH6YXM+OCFCFChUK9WuIHxBf2Jpj3DTHmGmHcdMO46Ydxk13MdO0RycdBygTERGRUWOyQ0REREaNyY4OWVtb4+uvv5YfKf8YN80xZtph3LTDuGmHcdOfmJncAGUiIiIyLezZISIiIqPGZIeIiIiMGpMdIiIiMmpMdoiIiMioMdkpgO+++w7e3t6ws7ND8eLF8/UcMR58ypQpKFu2LGxtbdGuXTvcvHkTpuT58+cYMGCAXDBKxO29995DTExMns9p06aNXPE68/HBBx/AmC1YsACVKlWCjY0NmjdvjpMnT+Z5/aZNm1CrVi15fb169bBr1y6YIk3itmrVqpdeV+J5puTo0aPo3r27XJVWfP/btm175XMOHz6MRo0ayRkz1apVk3E0NZrGTcQs+2tNHGFhYTAVM2bMQNOmTeUOBi4uLujVqxeuX7/+yufp4ncbk50CSEpKQp8+fTBq1Kh8P+enn37C3LlzsXjxYpw4cQL29vbo2LEjEhISYCpEonPlyhXs27cPO3bskL80Ro4c+crnjRgxAqGhoRmHiKWx2rBhAyZOnCinYJ49exYNGjSQr5MnT57keH1AQAB8fX1l4nju3Dn5S0Qcly9fhinRNG6CSLozv66Cg4NhSmJjY2WcRJKYH3fv3kXXrl3Rtm1bnD9/HhMmTMDw4cOxd+9emBJN45ZOvLlnfr2JN31TceTIEYwePRrHjx+Xv//Fpp8dOnSQscyNzn63iannVDArV65UOzk5vfK6tLQ0dZkyZdQzZ87MOBcREaG2trZW//nnn2pTcPXqVbHUgfrUqVMZ53bv3q02MzNTP3z4MNfntW7dWj1+/Hi1qWjWrJl69OjRGY9TU1PV5cqVU8+YMSPH6/v27avu2rVrlnPNmzdXv//++2pTomnc8vv/rqkQ/29u3bo1z2smTZqkrlOnTpZz/fr1U3fs2FFtqvITt0OHDsnrXrx4UWTt0ndPnjyRMTly5Eiu1+jqdxt7doqQ+ItIdFmK0lXmfT5EV3tgYCBMgfg+RemqSZMmGedEPMSeZaKnKy9r166Fs7Mz6tati8mTJyMuLg7G2mN45syZLK8TER/xOLfXiTif+XpB9GiYyutK27gJooTq7u4uNx/s2bOn7HWk3PG1VjANGzaUwxjat2+PY8eOwZRFRkbKjyVLliz015vJbQSqpPTarKura5bz4rGp1G3F95m929bCwkK+2POKQf/+/eUbkqiPX7x4EZ999pnsDt6yZQuMTXh4OFJTU3N8nQQFBeX4HBE7U35daRu3mjVrYsWKFahfv778xTtr1iw5Dk8kPIW9YbChyu21Jnarjo+Pl2MR6WUiwRHDF8QfeomJiVi+fLkciyj+yBPjn0xNWlqaLIG2bNlS/gGbG139bmOyk83nn3+OH3/8Mc9rrl27JgdLkeZx01bmMT1igJr4xfHGG2/g9u3bqFq1qtb3JdPm5eUlj3Qi0fHw8MCSJUswffp0RdtGxkUk1uLI/FoTv79mz56NP/74A6Zm9OjRctyNv79/kXw9JjvZfPzxxxgyZEie11SpUkWre5cpU0Z+fPz4sXyzTicei65NU4ibiEH2waIpKSlyhlZ6fPJDlP6EW7duGV2yI0p1KpVKvi4yE49zi5E4r8n1xkibuGVnaWkJT09P+boiaPRaEwO92aujmWbNmhXZm70+GTNmTMbklFf1oOrqdxvH7GRTunRp2WuT12FlZaXVvStXrix/QAcOHMg4J7p+RTdm5r8ujTlu4vuMiIiQYyvSHTx4UHZppicw+SFmgQiZk0ZjIeLUuHHjLK8TER/xOLfXiTif+XpBzHYw9NdVYcctO1EGu3TpklG+rnSFrzXdEb/HTOm1plarZaKzdetW+XtfvCcW2etN62HUpA4ODlafO3dOPW3aNHWxYsXkv8URHR2dcU3NmjXVW7ZsyXj8ww8/qIsXL67evn27+uLFi+qePXuqK1eurI6Pj1ebik6dOqk9PT3VJ06cUPv7+6urV6+u9vX1zfj8gwcPZNzE54Vbt26pv/nmG/Xp06fVd+/elbGrUqWK+rXXXlMbq/Xr18tZeqtWrZIz2EaOHClfN2FhYfLz7777rvrzzz/PuP7YsWNqCwsL9axZs9TXrl1Tf/3112pLS0v1pUuX1KZE07iJ/3f37t2rvn37tvrMmTPqd955R21jY6O+cuWK2lSI31fpv7vEW8Ivv/wi/y1+vwkiXiJu6e7cuaO2s7NTf/rpp/K1tmDBArVKpVLv2bNHbUo0jdvs2bPV27ZtU9+8eVP+fylml5qbm6v379+vNhWjRo2Ssx8PHz6sDg0NzTji4uIyrims321Mdgpg8ODB8kWe/RBTDNOJx2J6a+bp51999ZXa1dVV/lJ+44031NevX1ebkmfPnsnkRiSIjo6O6qFDh2ZJEEVCkzmOISEhMrEpWbKkjFm1atXkL9rIyEi1MZs3b566YsWKaisrKzml+vjx41mm4ovXX2YbN25U16hRQ14vpgbv3LlTbYo0iduECRMyrhX/T3bp0kV99uxZtSlJnxKd/UiPk/go4pb9OQ0bNpRxE394ZP4dZyo0jduPP/6orlq1qkymxe+yNm3aqA8ePKg2JcghXtnfIwvrd5vZ/28AERERkVHimB0iIiIyakx2iIiIyKgx2SEiIiKjxmSHiIiIjBqTHSIiIjJqTHaIiIjIqDHZISIiIqPGZIeIiIiMGpMdIjI6z549g4uLC+7du5frNXv27JEb8Ir9s4jIuDHZISKj891336Fnz56oVKlSrtd06tRJ7nK+du3aIm0bERU9JjtEZFTi4uLw22+/4b333nvltUOGDMHcuXOLpF1EpBwmO0Skt0SpqVWrVihevDhKlSqFbt264fbt23k+Z9euXbC2tkaLFi1eef/u3bvj9OnTr7wnERk2JjtEpLdiY2MxceJEmZAcOHAA5ubmePPNN/McZ+Pn54fGjRvn6/4VK1aEq6urfA4RGS8LpRtARJSbt956K8vjFStWoHTp0rh69Srq1q2b43OCg4NRrly5fH8Nca14DhEZL/bsEJHeunnzJnx9fVGlShU4OjpmDDgOCQnJ9Tnx8fGwsbHJcq5OnTooVqyYPDp37pzlc7a2tnKcDxEZL/bsEJHeEmNq3N3dsWzZMtkDI8pXokcnKSkp1+c4OzvjxYsXL43jSU5OzkhuMnv+/LnsLSIi48Vkh4j0dq2c69evy0THx8dHnvP393/l8zw9PbFmzZos50TClJOEhAQ5OFk8h4iMF8tYRKSXSpQoIWdgLV26FLdu3cLBgwflYOVX6dixI65cufJS705Ojh8/LmdueXl56ajVRKSPmOwQkV4SM6/Wr1+PM2fOyNLVRx99hJkzZ77yefXq1UOjRo2wcePGV177559/YsCAAbCzs9NRq4lIH5mp1Wq10o0gItKlnTt34tNPP8Xly5dl0pST8PBw1KxZU05rr1y5cpG3kYiKDsfsEJHR6dq1q5zJ9fDhQ7i5ueV4jdg3a+HChUx0iEwAe3aIiIjIqHHMDhERERk1JjtERERk1JjsEBERkVFjskNERERGjckOERERGTUmO0RERGTUmOwQERGRUWOyQ0REREaNyQ4RERHBmP0/s2XqMxz1IHcAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "def linear_a_b_zero(a):\n", " b = 1.9 - a\n", " return b\n", "\n", "def linear_b_c_zero(c):\n", " b = (1.85 - 0.5 * c) / 1.5\n", " return b\n", "\n", "a = np.arange(-1.0, 2.0, 0.1)\n", "c = [1.184]\n", "\n", "b_z1 = [linear_a_b_zero(val) for val in a]\n", "b_z2 = [linear_b_c_zero(val) for val in c]\n", "\n", "plt.plot(a, b_z1, label='Z1 = 0')\n", "plt.axhline(y=b_z2, color='r', label='Z2 = 0')\n", "plt.grid()\n", "plt.legend()\n", "plt.xlabel('a (-)')\n", "plt.ylabel('b (-)')\n", "plt.title(f'Limit states for c = {c[0]}')\n", "plt.show()\n" ] } ], "metadata": { "kernelspec": { "display_name": "base", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.10" } }, "nbformat": 4, "nbformat_minor": 5 }