"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -261,43 +267,16 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "For each RocketPy object, we will create a ``Stochastic`` couterpart that extends the initial model, allowing us to define the uncertainties of each input parameter.\n",
- "\n",
- "The idea of the ``Stochastic`` classes is to take the standard classes and add uncertainties to the input parameters. This is done by constructing distributions for each parameter, and then sampling from these distributions to create a new object for each simulation.\n",
- "\n",
- "In terms of initialization parameters, the ``Stochastic`` classes are very similar to the standard classes. The main difference is that they receive the standard object as an argument. The rest of the parameters are the same as the standard classes. **The standard object received will be used as the default nominal value for all the distribuitions.**\n",
- "\n",
- "Here is a better explanation of the parameters:\n",
+ "For each RocketPy object, we will create a ``Stochastic`` counterpart that extends the initial model, allowing us to define the uncertainties of each input parameter.\n",
"\n",
- "- All ``Stochastic`` classes **must** receive the standard object as an argument. This is the only mandatory parameter.\n",
- "\n",
- "- The remaining parameters are the same as the standard classes, and they are optional. They need only be passed if you want to define the standard deviation for a (possibly) chosen distribuition of that parameter. If you don't pass a parameter, it will be considered as a deterministic value taken from the standard object.\n",
- "\n",
- "- Some ``Stochastic`` classes have additional parameters that are not present in the standard classes. These are used for specific purposes, such as changing the total impulse of a motor, or a multiplication factor for the drag curves or wind speeds.\n"
+ "Please refer to the [Working with Stochastic Objects]() page on RocketPy`s documentation for a more detailed explanation."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- " \n",
- "\n",
- "#### **Important**\n",
- "\n",
- "\n",
- "Furthermore, the optional parameters (which define the uncertainties) can be passed in a few different ways:\n",
- "\n",
- "- **As a single value:** This will define the standard deviation for that parameter. The default distribuition used will be a normal distribuition and the nominal value will be the value of that same parameter from the standard object.\n",
- "\n",
- "- **As a tuple of two numbers:** The first number will define the nominal value of the distribuition, and the second number will define the standard deviation. The default distribuition used will be a normal distribuition.\n",
- "\n",
- "- **As a tuple of two numbers and a string:** The first number will define the nominal value of the distribuition, the second number will define the standard deviation, and the string will define the distribuition type. The distribuition type can be distributions *\"normal\"*, *\"binomial\"*, *\"chisquare\"*, *\"exponential\"*, *\"gamma\"*, *\"gumbel\"*, *\"laplace\"*, *\"logistic\"*, *\"poisson\"*, *\"uniform\"* and *\"wald\"*.\n",
- "\n",
- "- **As a tuple of a number and a string:** The number will define the standard deviation, and the string will define the distribuition type. The nominal value will be the value of that same parameter from the standard object.\n",
- "\n",
- "- **As a list of values:** The values will be randomly chosen from this and used as the parameter value during the simulation. You can not define standard deviations when using lists.\n",
- "\n",
- "
"
+ "### Stochastic Environment"
]
},
{
@@ -311,44 +290,44 @@
"\n",
"Since the ensemble member is a discrete value, **only list type inputs are permitted**. The list will contain the ensemble numbers to be randomly selected during the Monte Carlo simulation. This means that in each iteration, a different ensemble member will be chosen.\n",
"\n",
- "The wind velocities factor are also special inputs. They are used to scale the wind velocities in each axis. The factor inputs can only be tuples or lists, since it has no nominal value to get from the standard. Lets scale the wind by a factor of 1.00000 ± 0.2"
+ ""
]
},
{
"cell_type": "code",
- "execution_count": 44,
+ "execution_count": 7,
"metadata": {},
"outputs": [
{
- "data": {
- "text/plain": [
- "object: \n",
- "last_rnd_dict: {}\n",
- "elevation: [113]\n",
- "gravity: ['Function from R1 to R1 : (height (m)) → (gravity (m/s²))']\n",
- "latitude: [39.3897]\n",
- "longitude: [-8.288964]\n",
- "wind_velocity_x_factor: 1.00000 ± 0.20000 (numpy.random.normal)\n",
- "wind_velocity_y_factor: 1.00000 ± 0.20000 (numpy.random.normal)\n",
- "datum: ['SIRGAS2000']\n",
- "timezone: ['UTC']\n",
- "ensemble_member: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]"
- ]
- },
- "execution_count": 44,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reporting the attributes of the `StochasticEnvironment` object:\n",
+ "\n",
+ "Constant Attributes:\n",
+ "\tdatum SIRGAS2000\n",
+ "\televation 113\n",
+ "\tgravity Function from R1 to R1 : (height (m)) → (gravity (m/s²))\n",
+ "\tlatitude 39.3897\n",
+ "\tlongitude -8.288964\n",
+ "\ttimezone UTC\n",
+ "\n",
+ "Stochastic Attributes:\n",
+ "\twind_velocity_x_factor 1.00000 ± 0.00000 (normal)\n",
+ "\twind_velocity_y_factor 1.00000 ± 0.00000 (normal)\n",
+ "\n",
+ "Stochastic Attributes with choice of values:\n",
+ "\tensemble_member [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]\n"
+ ]
}
],
"source": [
"stochastic_env = StochasticEnvironment(\n",
" environment=env,\n",
" ensemble_member=list(range(env.num_ensemble_members)),\n",
- " wind_velocity_x_factor=(1, 0.2),\n",
- " wind_velocity_y_factor=(1, 0.2),\n",
")\n",
"\n",
- "stochastic_env"
+ "stochastic_env.visualize_attributes()"
]
},
{
@@ -359,7 +338,7 @@
"\n",
"#### NOTE\n",
"\n",
- "Always check the printing of the object to see if the uncertainties were correctly set.\n",
+ "Always check the `.visualize_attributes()` method of each stochastic object to verify the uncertainties were correctly set.\n",
"\n",
"\n",
"\n"
@@ -376,14 +355,14 @@
},
{
"cell_type": "code",
- "execution_count": 45,
+ "execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "[3.740092684250815, 4.9381130538062425, 3.9988061871142895, 2.767140726386856, 3.6032724506858345]\n"
+ "[1.3204824786686544, 0.8213012810128237, 0.5276783044255233, 1.7781228206802893, 1.7781228206802893]\n"
]
}
],
@@ -424,53 +403,48 @@
},
{
"cell_type": "code",
- "execution_count": 51,
+ "execution_count": 9,
"metadata": {},
"outputs": [
{
- "data": {
- "text/plain": [
- "object: \n",
- "last_rnd_dict: {}\n",
- "thrust_source: ['../../../data/motors/Cesaroni_M1670.eng', [[0, 6000], [1, 6000], [2, 6000], [3, 6000], [4, 6000]], 'Function from R1 to R1 : (Scalar) → (Scalar)']\n",
- "total_impulse: 6500.00000 ± 1000.00000 (numpy.random.normal)\n",
- "burn_start_time: 0.00000 ± 0.10000 (numpy.random.binomial)\n",
- "burn_out_time: [3.9]\n",
- "dry_mass: [1.815]\n",
- "dry_I_11: [0.125]\n",
- "dry_I_22: [0.125]\n",
- "dry_I_33: [0.002]\n",
- "dry_I_12: [0]\n",
- "dry_I_13: [0]\n",
- "dry_I_23: [0]\n",
- "nozzle_radius: 0.03300 ± 0.00050 (numpy.random.normal)\n",
- "grain_number: [5]\n",
- "grain_density: 1815.00000 ± 50.00000 (numpy.random.normal)\n",
- "grain_outer_radius: 0.03300 ± 0.00038 (numpy.random.normal)\n",
- "grain_initial_inner_radius: 0.01500 ± 0.00038 (numpy.random.normal)\n",
- "grain_initial_height: 0.12000 ± 0.00100 (numpy.random.normal)\n",
- "grain_separation: 0.00500 ± 0.00100 (numpy.random.normal)\n",
- "grains_center_of_mass_position: 0.39700 ± 0.00100 (numpy.random.normal)\n",
- "center_of_dry_mass_position: [0.317]\n",
- "nozzle_position: 0.00000 ± 0.00100 (numpy.random.normal)\n",
- "throat_radius: 0.01100 ± 0.00050 (numpy.random.normal)\n",
- "interpolate: ['linear']\n",
- "coordinate_system_orientation: ['nozzle_to_combustion_chamber']"
- ]
- },
- "execution_count": 51,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reporting the attributes of the `StochasticSolidMotor` object:\n",
+ "\n",
+ "Constant Attributes:\n",
+ "\tburn_out_time 3.9\n",
+ "\tcenter_of_dry_mass_position 0.317\n",
+ "\tcoordinate_system_orientation nozzle_to_combustion_chamber\n",
+ "\tdry_I_11 0.125\n",
+ "\tdry_I_12 0\n",
+ "\tdry_I_13 0\n",
+ "\tdry_I_22 0.125\n",
+ "\tdry_I_23 0\n",
+ "\tdry_I_33 0.002\n",
+ "\tdry_mass 1.815\n",
+ "\tgrain_number 5\n",
+ "\tinterpolate linear\n",
+ "\tthrust_source [[0, 0], [0.055, 100.0], [0.092, 1500.0], [0.1, 2000.0], [0.15, 2200.0], [0.2, 1800.0], [0.5, 1950.0], [1.0, 2034.0], [1.5, 2000.0], [2.0, 1900.0], [2.5, 1760.0], [2.9, 1700.0], [3.0, 1650.0], [3.3, 530.0], [3.4, 350.0], [3.9, 0.0]]\n",
+ "\n",
+ "Stochastic Attributes:\n",
+ "\tburn_start_time 0.00000 ± 0.10000 (binomial)\n",
+ "\tgrain_density 1815.00000 ± 50.00000 (normal)\n",
+ "\tgrain_initial_height 0.12000 ± 0.00100 (normal)\n",
+ "\tgrain_initial_inner_radius 0.01500 ± 0.00038 (normal)\n",
+ "\tgrain_outer_radius 0.03300 ± 0.00038 (normal)\n",
+ "\tgrain_separation 0.00500 ± 0.00100 (normal)\n",
+ "\tgrains_center_of_mass_position 0.39700 ± 0.00100 (normal)\n",
+ "\tnozzle_position 0.00000 ± 0.00100 (normal)\n",
+ "\tnozzle_radius 0.03300 ± 0.00050 (normal)\n",
+ "\tthroat_radius 0.01100 ± 0.00050 (normal)\n",
+ "\ttotal_impulse 6500.00000 ± 1000.00000 (normal)\n"
+ ]
}
],
"source": [
"stochastic_motor = StochasticSolidMotor(\n",
" solid_motor=motor,\n",
- " thrust_source=[\n",
- " \"../../../data/motors/Cesaroni_M1670.eng\",\n",
- " [[0, 6000], [1, 6000], [2, 6000], [3, 6000], [4, 6000]],\n",
- " Function([[0, 5900], [1, 6000], [2, 6100], [3, 5900], [4, 5800]]),\n",
- " ],\n",
" burn_start_time=(0, 0.1, \"binomial\"),\n",
" grains_center_of_mass_position=0.001,\n",
" grain_density=50,\n",
@@ -483,7 +457,7 @@
" nozzle_radius=0.5 / 1000,\n",
" nozzle_position=0.001,\n",
")\n",
- "stochastic_motor"
+ "stochastic_motor.visualize_attributes()"
]
},
{
@@ -497,7 +471,7 @@
"Pay special attention to how different input types are interpreted in the `StochasticSolidMotor` object by checking the printed object:\n",
"\n",
"\n",
- "- ``thrust_source`` was given as a list of 3 items, and is saved as is. This means that the simulation will randomly chose one item of that list, as desired\n",
+ "\n",
"\n",
"- ``burn_start_time`` was given as a tuple of 3 items, specifying the nominal value, the standard deviation and the distribuition type\n",
"\n",
@@ -521,14 +495,14 @@
},
{
"cell_type": "code",
- "execution_count": 56,
+ "execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "[5922.730109775586, 5397.418437730037, 8888.401049795124, 2867.149759762836, 6583.48945300187]\n"
+ "[7027.588437139979, 6191.531179311793, 6629.281021408857, 5157.516419345492, 6866.985893654466]\n"
]
}
],
@@ -558,40 +532,33 @@
},
{
"cell_type": "code",
- "execution_count": 60,
+ "execution_count": 11,
"metadata": {},
"outputs": [
{
- "data": {
- "text/plain": [
- "object: \n",
- "last_rnd_dict: {}\n",
- "radius: 0.06350 ± 0.00001 (numpy.random.normal)\n",
- "mass: 15.42600 ± 0.50000 (numpy.random.normal)\n",
- "I_11_without_motor: 6.32100 ± 0.00000 (numpy.random.normal)\n",
- "I_22_without_motor: 6.32100 ± 0.01000 (numpy.random.normal)\n",
- "I_33_without_motor: 0.03400 ± 0.01000 (numpy.random.normal)\n",
- "I_12_without_motor: [0]\n",
- "I_13_without_motor: [0]\n",
- "I_23_without_motor: [0]\n",
- "power_off_drag: ['Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power Off)']\n",
- "power_on_drag: ['Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power On)']\n",
- "power_off_drag_factor: 1.00000 ± 0.00000 (numpy.random.normal)\n",
- "power_on_drag_factor: 1.00000 ± 0.00000 (numpy.random.normal)\n",
- "center_of_mass_without_motor: 0.00000 ± 0.00000 (numpy.random.normal)\n",
- "coordinate_system_orientation: ['tail_to_nose']\n",
- "motors: Components:\n",
- "\n",
- "aerodynamic_surfaces: Components:\n",
- "\n",
- "rail_buttons: Components:\n",
- "\n",
- "parachutes: []"
- ]
- },
- "execution_count": 60,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reporting the attributes of the `StochasticRocket` object:\n",
+ "\n",
+ "Constant Attributes:\n",
+ "\tI_12_without_motor 0\n",
+ "\tI_13_without_motor 0\n",
+ "\tI_23_without_motor 0\n",
+ "\tcoordinate_system_orientation tail_to_nose\n",
+ "\tpower_off_drag Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power Off)\n",
+ "\tpower_on_drag Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power On)\n",
+ "\n",
+ "Stochastic Attributes:\n",
+ "\tI_11_without_motor 6.32100 ± 0.00000 (normal)\n",
+ "\tI_22_without_motor 6.32100 ± 0.01000 (normal)\n",
+ "\tI_33_without_motor 0.03400 ± 0.01000 (normal)\n",
+ "\tcenter_of_mass_without_motor 0.00000 ± 0.00000 (normal)\n",
+ "\tmass 15.42600 ± 0.50000 (normal)\n",
+ "\tpower_off_drag_factor 1.00000 ± 0.00000 (normal)\n",
+ "\tpower_on_drag_factor 1.00000 ± 0.00000 (normal)\n",
+ "\tradius 0.06350 ± 0.00001 (normal)\n"
+ ]
}
],
"source": [
@@ -604,7 +571,7 @@
" inertia_33=0.01,\n",
" center_of_mass_without_motor=0,\n",
")\n",
- "stochastic_rocket"
+ "stochastic_rocket.visualize_attributes()"
]
},
{
@@ -618,7 +585,7 @@
},
{
"cell_type": "code",
- "execution_count": 61,
+ "execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
@@ -668,7 +635,7 @@
},
{
"cell_type": "code",
- "execution_count": 62,
+ "execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
@@ -706,99 +673,37 @@
},
{
"cell_type": "code",
- "execution_count": 66,
+ "execution_count": 14,
"metadata": {},
"outputs": [
{
- "data": {
- "text/plain": [
- "object: \n",
- "last_rnd_dict: {}\n",
- "radius: 0.06350 ± 0.00001 (numpy.random.normal)\n",
- "mass: 15.42600 ± 0.50000 (numpy.random.normal)\n",
- "I_11_without_motor: 6.32100 ± 0.00000 (numpy.random.normal)\n",
- "I_22_without_motor: 6.32100 ± 0.01000 (numpy.random.normal)\n",
- "I_33_without_motor: 0.03400 ± 0.01000 (numpy.random.normal)\n",
- "I_12_without_motor: [0]\n",
- "I_13_without_motor: [0]\n",
- "I_23_without_motor: [0]\n",
- "power_off_drag: ['Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power Off)']\n",
- "power_on_drag: ['Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power On)']\n",
- "power_off_drag_factor: 1.00000 ± 0.00000 (numpy.random.normal)\n",
- "power_on_drag_factor: 1.00000 ± 0.00000 (numpy.random.normal)\n",
- "center_of_mass_without_motor: 0.00000 ± 0.00000 (numpy.random.normal)\n",
- "coordinate_system_orientation: ['tail_to_nose']\n",
- "motors: Components:\n",
- "\tComponent: object: \n",
- "last_rnd_dict: {}\n",
- "thrust_source: ['../../../data/motors/Cesaroni_M1670.eng', [[0, 6000], [1, 6000], [2, 6000], [3, 6000], [4, 6000]], 'Function from R1 to R1 : (Scalar) → (Scalar)']\n",
- "total_impulse: 6500.00000 ± 1000.00000 (numpy.random.normal)\n",
- "burn_start_time: 0.00000 ± 0.10000 (numpy.random.normal)\n",
- "burn_out_time: [3.9]\n",
- "dry_mass: [1.815]\n",
- "dry_I_11: [0.125]\n",
- "dry_I_22: [0.125]\n",
- "dry_I_33: [0.002]\n",
- "dry_I_12: [0]\n",
- "dry_I_13: [0]\n",
- "dry_I_23: [0]\n",
- "nozzle_radius: 0.03300 ± 0.00050 (numpy.random.normal)\n",
- "grain_number: [5]\n",
- "grain_density: 1815.00000 ± 50.00000 (numpy.random.normal)\n",
- "grain_outer_radius: 0.03300 ± 0.00038 (numpy.random.normal)\n",
- "grain_initial_inner_radius: 0.01500 ± 0.00038 (numpy.random.normal)\n",
- "grain_initial_height: 0.12000 ± 0.00100 (numpy.random.normal)\n",
- "grain_separation: 0.00500 ± 0.00100 (numpy.random.normal)\n",
- "grains_center_of_mass_position: 0.39700 ± 0.00100 (numpy.random.normal)\n",
- "center_of_dry_mass_position: [0.317]\n",
- "nozzle_position: 0.00000 ± 0.00100 (numpy.random.normal)\n",
- "throat_radius: 0.01100 ± 0.00050 (numpy.random.normal)\n",
- "interpolate: ['linear']\n",
- "coordinate_system_orientation: ['nozzle_to_combustion_chamber'] Position: (-1.255, 0.001, )\n",
- "aerodynamic_surfaces: Components:\n",
- "\tComponent: object: \n",
- "last_rnd_dict: {}\n",
- "length: 0.55829 ± 0.00100 (numpy.random.normal)\n",
- "kind: ['vonKarman']\n",
- "base_radius: [0.0635]\n",
- "bluffness: [0]\n",
- "rocket_radius: [0.0635]\n",
- "name: ['Nose Cone'] Position: (1.134, 0.001, )\n",
- "\tComponent: object: \n",
- "last_rnd_dict: {}\n",
- "n: [4]\n",
- "root_chord: 0.12000 ± 0.00050 (numpy.random.normal)\n",
- "tip_chord: 0.06000 ± 0.00050 (numpy.random.normal)\n",
- "span: 0.11000 ± 0.00050 (numpy.random.normal)\n",
- "rocket_radius: [0.0635]\n",
- "cant_angle: [0.5]\n",
- "sweep_length: [0.06]\n",
- "sweep_angle: [None]\n",
- "airfoil: [('../../../data/calisto/NACA0012-radians.csv', 'radians')]\n",
- "name: ['Fins'] Position: (-1.04956, 0.001, )\n",
- "\tComponent: object: \n",
- "last_rnd_dict: {}\n",
- "top_radius: 0.06350 ± 0.00100 (numpy.random.normal)\n",
- "bottom_radius: 0.04350 ± 0.00100 (numpy.random.normal)\n",
- "length: 0.06000 ± 0.00100 (numpy.random.normal)\n",
- "rocket_radius: [0.0635]\n",
- "name: ['Tail'] Position: [-1.194656]\n",
- "rail_buttons: Components:\n",
- "\tComponent: object: \n",
- "last_rnd_dict: {}\n",
- "buttons_distance: 0.69980 ± 0.00100 (numpy.random.normal)\n",
- "angular_position: [45]\n",
- "name: ['Rail Buttons'] Position: (-0.618, 0.001, )\n",
- "parachutes: [StochasticParachute(parachute=Parachute Main with a cd_s of 10.0000 m2, cd_s=(10.0, 0.1, ), trigger=[800], sampling_rate=[105], lag=(1.5, 0.1, ), noise=[(0, 8.3, 0.5)]), StochasticParachute(parachute=Parachute Drogue with a cd_s of 1.0000 m2, cd_s=(1.0, 0.07, ), trigger=['apogee'], sampling_rate=[105], lag=(1.5, 0.2, ), noise=[(0, 8.3, 0.5)])]"
- ]
- },
- "execution_count": 66,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reporting the attributes of the `StochasticRocket` object:\n",
+ "\n",
+ "Constant Attributes:\n",
+ "\tI_12_without_motor 0\n",
+ "\tI_13_without_motor 0\n",
+ "\tI_23_without_motor 0\n",
+ "\tcoordinate_system_orientation tail_to_nose\n",
+ "\tpower_off_drag Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power Off)\n",
+ "\tpower_on_drag Function from R1 to R1 : (Mach Number) → (Drag Coefficient with Power On)\n",
+ "\n",
+ "Stochastic Attributes:\n",
+ "\tI_11_without_motor 6.32100 ± 0.00000 (normal)\n",
+ "\tI_22_without_motor 6.32100 ± 0.01000 (normal)\n",
+ "\tI_33_without_motor 0.03400 ± 0.01000 (normal)\n",
+ "\tcenter_of_mass_without_motor 0.00000 ± 0.00000 (normal)\n",
+ "\tmass 15.42600 ± 0.50000 (normal)\n",
+ "\tpower_off_drag_factor 1.00000 ± 0.00000 (normal)\n",
+ "\tpower_on_drag_factor 1.00000 ± 0.00000 (normal)\n",
+ "\tradius 0.06350 ± 0.00001 (normal)\n"
+ ]
}
],
"source": [
- "stochastic_rocket"
+ "stochastic_rocket.visualize_attributes()"
]
},
{
@@ -819,24 +724,22 @@
},
{
"cell_type": "code",
- "execution_count": 67,
+ "execution_count": 15,
"metadata": {},
"outputs": [
{
- "data": {
- "text/plain": [
- "object: , environment= , rail_length= 5, inclination= 84, heading = 133,name= Flight)>\n",
- "last_rnd_dict: {}\n",
- "rail_length: [5]\n",
- "inclination: 84.70000 ± 1.00000 (numpy.random.normal)\n",
- "heading: 53.00000 ± 2.00000 (numpy.random.normal)\n",
- "initial_solution: None\n",
- "terminate_on_apogee: None"
- ]
- },
- "execution_count": 67,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reporting the attributes of the `StochasticFlight` object:\n",
+ "\n",
+ "Constant Attributes:\n",
+ "\trail_length 5\n",
+ "\n",
+ "Stochastic Attributes:\n",
+ "\theading 53.00000 ± 2.00000 (normal)\n",
+ "\tinclination 84.70000 ± 1.00000 (normal)\n"
+ ]
}
],
"source": [
@@ -845,7 +748,7 @@
" inclination=(84.7, 1), # mean= 84.7, std=1\n",
" heading=(53, 2), # mean= 53, std=2\n",
")\n",
- "stochastic_flight"
+ "stochastic_flight.visualize_attributes()"
]
},
{
@@ -868,17 +771,9 @@
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": 16,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "c:\\mateus\\github\\rocketpy\\rocketpy\\simulation\\monte_carlo.py:97: UserWarning: This class is still under testing and some attributes may be changed in next versions\n",
- " warnings.warn(\n"
- ]
- },
{
"name": "stdout",
"output_type": "stream",
@@ -888,6 +783,14 @@
"\n",
"The following error file was imported: monte_carlo_analysis_outputs/monte_carlo_class_example.errors.txt\n"
]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "C:\\Users\\guiga\\Documents\\github\\RocketPy\\rocketpy\\simulation\\monte_carlo.py:105: UserWarning: This class is still under testing and some attributes may be changed in next versions\n",
+ " warnings.warn(\n"
+ ]
}
],
"source": [
@@ -912,16 +815,15 @@
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "Keyboard Interrupt, files saved.age Time per Iteration: 2.184 s | Estimated time left: 2116 s\n",
- "Completed 32 iterations. Total CPU time: 68.9 s. Total wall time: 69.6 s\n",
- "Saving results. \n",
+ "Completed 1000 iterations. Total CPU time: 1021.7 s. Total wall time: 1262.5 sme left: 0 s \n",
+ "Saving results.\n",
"Results saved to monte_carlo_analysis_outputs/monte_carlo_class_example.outputs.txt\n"
]
}
@@ -957,7 +859,7 @@
},
{
"cell_type": "code",
- "execution_count": 24,
+ "execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
@@ -967,16 +869,16 @@
},
{
"cell_type": "code",
- "execution_count": 22,
+ "execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "31"
+ "1000"
]
},
- "execution_count": 22,
+ "execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
@@ -987,7 +889,7 @@
},
{
"cell_type": "code",
- "execution_count": 23,
+ "execution_count": 20,
"metadata": {},
"outputs": [
{
@@ -996,24 +898,26 @@
"text": [
"Monte Carlo Simulation by RocketPy\n",
"Data Source: monte_carlo_analysis_outputs/monte_carlo_class_example\n",
- "Number of simulations: 31\n",
+ "Number of simulations: 1000\n",
"Results: \n",
"\n",
" Parameter Mean Std. Dev.\n",
"------------------------------------------------------------\n",
- " out_of_rail_velocity 23.690 2.184\n",
- " x_impact 1514.914 386.644\n",
- " apogee_time 25.657 2.347\n",
- " impact_velocity -5.322 0.066\n",
- " y_impact -283.937 203.440\n",
- " out_of_rail_time 0.341 0.064\n",
- " frontal_surface_wind 0.887 0.591\n",
- " apogee_y 751.781 141.018\n",
- " t_final 304.216 37.176\n",
- " max_mach_number 0.866 0.144\n",
- " apogee_x 87.831 126.183\n",
- " lateral_surface_wind -5.351 0.415\n",
- " apogee 3367.587 688.136\n"
+ " apogee 3406.545 643.312\n",
+ "out_of_rail_stability_margin 2.673 0.078\n",
+ " lateral_surface_wind -1.808 0.643\n",
+ " impact_velocity -5.440 0.083\n",
+ " x_impact 877.812 221.423\n",
+ " max_mach_number 0.831 0.131\n",
+ " out_of_rail_time 0.361 0.026\n",
+ " apogee_y 452.203 107.950\n",
+ " out_of_rail_velocity 25.664 2.207\n",
+ " apogee_x 342.921 124.187\n",
+ " initial_stability_margin 2.600 0.079\n",
+ " t_final 300.315 35.615\n",
+ " apogee_time 25.615 2.107\n",
+ " frontal_surface_wind 0.793 0.410\n",
+ " y_impact 325.183 165.888\n"
]
}
],
@@ -1031,14 +935,29 @@
},
{
"cell_type": "code",
- "execution_count": 26,
+ "execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "6637e2fc301847c786b94e55e1367974",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABLAAAAOECAYAAACxbcj6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAABcSAAAXEgFnn9JSAAEAAElEQVR4nOzdd3gU5f7+8XsT0kinNwklgAZEBEEwhCZNQXpVBFTOVxQFFQWPDUQ8KIIKHkUPIE0PFooIKkoHI0gVlI50pAWSQAgh7fn9wW/3sO5uSGWX5P26rr2UZ+aZ+ezs7OzunZlnLMYYIwAAAAAAAMBDebm7AAAAAAAAACArBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWABwgwwcOFAWi0UDBw50dylAvrpZ9+2s6s7tNAAFi/efI45X+YttBnguAizgBktOTtYPP/ygsWPHqlu3boqIiJDFYpHFYtHo0aPdXV6Wzp07pxkzZqhfv36KiopSYGCg/Pz8VKlSJXXp0kULFy50d4mF1tatW/X666+rU6dOuvXWW1WyZEn5+PioZMmSio6O1ptvvqnz58+7rb7Ro0fb9mOLxaIvvvjiun06dOhg1+fw4cMFX2g2zZw5U6NHj9bq1avdXYokKSMjQ1999ZX69++vmjVrKiwsTL6+vipTpoyaNm2qf/7zn/rjjz/cXaZb/H3fu94Dnik+Pl4BAQG212n//v3uLgmF0LXHC3g2V8d2f39/VapUSZ06ddJXX30lY4y7S802T/tuAdyMirm7AKCo2bhxo+6//353l5Er5cqVU3p6uu3f/v7+8vHx0YkTJ3TixAktWrRI9913n+bNm6fixYu7sdLC59NPP9WHH35o+7e/v78CAgJ0/vx5/fLLL/rll1/0/vvv69tvv1WTJk3cWOlVM2bMUJ8+fVxO/+uvv/Tjjz/ewIpyZubMmVqzZo0kqUWLFm6tZcOGDRowYID27dtna/Px8VFwcLDOnTun2NhYxcbG6q233lK3bt00d+5c+fr6urFi9ylbtuwNWU/58uVVq1YtlS9f/oasryj4/PPPlZKSYvv3p59+qnHjxrmxIqBwKAzHq2uP7YmJibbvnYsXL9bMmTO1cOFC+fn55dv6CmqbedJ3C+BmxRlYgBuEh4fr3nvv1QsvvKC5c+eqXLly7i4pW9LT09WoUSN99NFH+vPPP3X58mUlJSXp0KFDeuyxxyRJP/zwgx5//HE3V1r4NGrUSO+8847Wr1+v+Ph4Xb58WRcuXNDFixc1a9YslS5dWnFxcerSpYsSExPdVmepUqUUGBio5cuX6/jx4y7nmz17tjIyMlSlSpUbV9xNaPHixWrRooX27dunkiVLaty4cdq3b59SU1N17tw5paamatOmTXrxxRcVEhKiBQsWKDk52d1lu82pU6eu+8gP48aN0549ewhY8tH06dMlSU8//bQkadasWcrIyHBnSUChUBiOV9cewy9duqQ//vhDbdq0kXT1e+crr7ySr+srDNsMKKwIsIAbLCYmRufPn9fy5cs1fvx49enTJ1//alSQVq5cqV9//VVPPPGEqlWrZmuvUqWKpk2bZguuPvvsMx07dsxdZRZK/fv31/PPP6/GjRsrLCzM1h4UFKT+/fvrs88+kySdOXNGS5YscVOVUmBgoHr06KHMzEzNnDnT5XwzZsyQJMaXyML+/fvVr18/XblyRVFRUfrtt9/04osvqkaNGrZ5vL29ddddd2ncuHE6dOiQOnfu7MaKgdzZunWrfvvtN4WFhWn8+PGqWrWqTp48qe+//97dpQHwMF5eXqpdu7a+/fZbRUZGSpI++eQTuysEABReBFjADebt7Z0vy1myZIl69uypKlWqqHjx4lmO+TJt2rR8WWfLli2znG49C0uSNm/efMPrj4+P1/Tp09WrVy/dfvvtKlGihPz9/RUREaEHH3xQGzZscNm3RYsWtnHIjDGaOnWq7r77boWEhCg4OFhNmjSxhURZ+fzzzxUdHa3g4GCFhobq7rvv1n/+858CH6OhcePGtv/P6swnqeD3nUceeUSSXAZYP//8s/bt26dq1aqpWbNm113e6tWr1bNnT1WsWFF+fn4qVaqU7r33Xs2YMcPlGRq5fT1nzpwpi8ViO8X/9ddfd9gmzsbqOnz4sJ555hnVrl1bQUFBKl68uG699VYNGzZMR48eve5zdOaVV17RhQsX5O/vr4ULF6pSpUpZzl+iRAl98803Cg0NtWvPr/dFWlqaJk6cqLvuukthYWGyWCw5GscjN6+jp8pqgN9rt1lqaqreeust1a1bV4GBgQoPD1ebNm30ww8/ZLn8L7/8Uvfdd5/Kli0rHx8fhYWFqUaNGurUqZM+/PBDu0vtrpWX/TC368wP1rOvevfuLX9/f/Xv31/S1csIs5If21rK/b5pjNGMGTPUpEkTp8f87AwEnZfXrCCOO1LR/ix15WbeJtk9XuWmtvx4D+SWv7+/evbsKUm6ePGi9uzZ4zBPbt/b+b3NcvPdwp3HZMCjGQBuFxERYSSZUaNGXXfe5ORk06lTJyPJSDIWi8WEhYWZYsWK2dr+/ti0aVPBPwljzI4dO2zr/Prrr294/aNGjbL18fb2NuHh4cbPz89uXZMmTXLat3nz5kaSeeWVV0znzp2NJFOsWDETEhJiV8trr73mtH9mZqZ55JFH7NYVHh5uvLy8jCTTp08fM2DAACPJDBgwIFvPJyeWLFniEds+IiLCZGZmmurVqxtJZs2aNQ7zPvroo0aSGTNmjFm1apVtXYcOHXKY99lnn3Wo19vb29bWqlUrc+HCBYd+uX09v/jiC1O2bFnj4+NjJJnAwEBTtmxZu8fRo0ft+nz22Wd2+5mfn58JCAiw/Ts4ONj8+OOP2dqOVqdOnbLtO4899liO+v5dfrwvRo4cae655x7bdgwPDzcWi8WsWrXKGGOuu2/n9nXM6fPLqazqzu006zb75z//aWJiYmzbLCwszG7fc3W8v/Y4IskEBQWZ4sWL27U5e6/kZT/MzToPHTp03eeSHZcvX7Ztm9jYWGOMMX/++aexWCymWLFi5tSpUy775nVbG5P7fTM9Pd307t3b5TG/b9++131f5OU1K4jjjlVh/izN7fHiZt4m2Tle5aa2/HgPZCU7r9WHH35om8d6/LDKy+dOfm+znH63yO3nAFAUEGABHiAnAVaXLl1sX6BeffVVc/r0aWPM1R8B7733nu2D7e677zYzZswwM2bMMCkpKQX8DK6aPHmybf179uy54fV/8sknZtSoUWbz5s3mypUrxpirX/wOHjxohg0bZiwWi/H29jZbt2516Gv9QhIeHm5CQ0PNzJkzTXJysjHGmGPHjpkHHnjASDJeXl5m3759Dv0nTZpkq/2pp54yZ8+eNcYYk5CQYEaPHm378pTbL3LOpKSkmEOHDpkPPvjAhIeHG0kmMjLS5fYqyG1/bYBljDFvvPGG0+ealJRkgoKCjJeXlzl69GiWAdYHH3xgm/Z///d/5uTJk7ZlvPfee7bgrXfv3g715PX1tPa/3nvyp59+Ml5eXqZYsWJmxIgR5tChQyYzM9NkZmaaPXv2mJ49expJJiQkxBw5ciRb29IYY+bOnWt77kuWLMl2P2fy430RFBRkgoKCzIwZM2zbMS4uzpw7d84Yk/WX/by8jtnhqQFWaGio8fPzMx9//LG5fPmyMcaYo0ePmh49etjqXbRokV3fdevW2fbLt99+27Z9jbm6vX/88UczYMAAc+LECbt+edkPc7vO/AqwPvvsM9ux61rWQGr8+PEu++ZlWxuTt31z3Lhxtr7PPfeciYuLM8YYk5iYaP71r3/Zfsy72k/y8poV1HHHqjB/lub2eHEzb5PsHK9yU1te3wPXk53X6oUXXrDNs3v3blt7Xj93CmqbZee7RW6PyUBRQYAFeIDsBlizZ8+2fSBPmzbN6TzWv4aVLFmyACp1LT4+3pQvX95IMjExMU7ncXf9Q4YMMZLzM1qsXyokmZUrVzpMT0lJMRUqVDCSzNixY+2mXb582ZQoUcJIMg8//LDTdb/44ou25ec1wLr2r77XPqKjo13+WCnobf/3AOvo0aPGy8vLBAYGmosXL9rm+/TTT40k06ZNG2OMcRlgJScn27Zp3759na7z2sB08+bNdtPy8npe2z+r92RGRoapUaOGkWQ++eQTl/NZz3obNmyYy3n+7pVXXrHVX9BfUrP7vvj2229dLsPVl/28vo7Zce2PnL//Rfvvj6FDh2ar7rxMu3abTZ8+3WF6RkaGadasmZFkateubTft7bffNpJM27Zts/3887of5madxuRfgNWyZUsjXT0j81pTp041ksytt97qsm9etnVe9s2kpCTb2RauzpC8dr/8+36Sl9esII872XUzf5bmJfDOiidvk+wer3JSW17fA9lxvdcqMTHRVluJEiVMRkaGMSZ/PncKYptd2zerY2Zuj8lAUcEYWMBNwhijN954Q5LUpUsXu/GmrvXAAw9Iks6dO6eTJ0/ekNoyMzP18MMP6+TJk/L399e///1vh3k8of4OHTpIujoGkyvR0dFOx/ry8/NTu3btJEk7duywm/bTTz/p/PnzkqTXXnvN6XJffPFF+fv756ruvytXrpzKli2rwMBAW1vLli31/vvvq3Llyg7zu2Pb33LLLWrdurUuXbqkr776ytZuHbz90UcfzbL/smXLbNt09OjRTud58sknbbe4/u9//+t0nty8ntm1du1a7d+/X6VKldKgQYNczmcdz+fHH3/M9rLPnTtn+/8SJUrkqr7sys77onbt2rb9Iyfy63XMrtOnT2f5uJF36Lzlllts48Fdy8vLy3bHrJ07d+r333+3TbPeoOHs2bPZHhcsr/thbtYpXb15h7n6h1CXr+31HDx4UKtXr5bFYtHDDz9sN61Xr14KCAjQnj179Msvv2S5nNxs67zsmz/99JMuXLggSXr55Zed9h0+fLiKFy/udFpeXrOCPO5kV2H5LM1PN/s2yWlteX0P5EVCQoJWrFihVq1a6a+//pIkDRs2TF5eV3/W3qjPnYL6fpHbYzJQVBBgATeJ9evXa//+/ZKk559/3uV8JUuWtP1/WlpagdclXf3iYL3z3Ycffqi6des6zHOj6j948KCef/55NWjQQGFhYfL29rYNkHn//fdLynqQ87vvvtvltAoVKkiS7YuRlXXA+ltuucV2R5y/Cw0NVYMGDXL0XFw5fPiwTp06paSkJJ0+fVoTJkzQb7/9pkaNGjn9guuufcf6g9I6EPOBAwe0bt06hYeHq0uXLln2vXab1qxZ0+k83t7eatWqld38f5eb1zO7YmNjJUmJiYmqUKGCypUr5/Txj3/8Q5J05MiRXK0nP+T1fREdHZ2r9ebX65hd1kDF1SOrO2PmN+tAv87ExMSoWLFikuyf87333it/f39t27ZNMTExmj59ug4dOpTlevK6H+ZmnfllxowZMsYoJiZGVapUsZsWEhJiO05YB3l3JTfbOi/75tatWyVJlStXVtWqVZ32DQ4OdnnMz8trdqOOO0XhszSnCvM2yWlteX0P5NS1g52Hh4erdevW2rJliySpX79+diHajfrcKajvF+48JgM3g2LuLgBA9qxYsULS1bNvmjRp4nK+M2fOSLr6l+dy5coVeF3PP/+87Yyr9957z+WZNTei/oULF6pv3766cuWKrS0kJET+/v6yWCxKTU1VfHy8Ll265HIZwcHBLqdZfwT9Pdyx1lyxYsUs67veXeRyo0yZMho+fLhiYmLUpEkTvfHGG2rUqJE6duxom8dd+07Xrl0VHh6u2NhY7d+/3xYe9O3b97p/Lc7pNrXO/3e5eT2zy/qX37S0NJ0+ffq681++fDnby742TDx//rzty3Bu5Mf7okyZMrlad369jjejrJ6zv7+/SpYsqdOnT9s95+rVq2vatGkaPHiw1q9fr/Xr10uSSpcurZYtW+rBBx9Up06d7MKavO6HuVlnfsjMzLQdE6xnC/3dgAEDNHfuXH311VeaNGmSgoKCnM6Xm22dl33z7NmzknTd96WrZeflNSvI445VUfwsvZ7Cvk1yWlte3wM5VbZsWdv/W+8meOedd+qhhx5yOAvqRn3uFNT3C3cdk4GbBWdgATcJ66UPjRo1sp0m7Yz1Fr1169aVr69vgdY0YsQITZw4UZI0YcIEPfPMMy7nLej6z507p4EDB+rKlStq1aqVVq9ereTkZCUmJur06dM6deqUvv7662wv72bTqFEjNW3aVJL0n//8x26au/YdPz8/9e3bV5I0bdo0zZ49W5KcXupzM7Ke2n/33Xdf98wf6yO7ateubfv/bdu25brG/HpfeHt757oG5MxDDz2kI0eO6OOPP1bv3r11yy236OzZs/rqq6/UpUsXNW/e3HbpjpQ/+2FO15kffvzxR9vZKoMGDXK4pbzFYlH79u0lSUlJSXaXInuK3P6AzMtrVpDHHYnPUmfYJq7dqBDl1KlTtseRI0e0ZcsWTZs2zeklfIWBO47JwM2CAAu4SZw4cUKSVKpUKZfzZGRk6Ntvv5Uk2+nsBeWFF17QO++8I0kaP368hg8fnuX8BV3/999/rwsXLig8PFyLFy9W8+bNFRAQYDfPqVOncrTM7LKenWJ9jq5cb3peWf/aeODAAafrdce+Yw2r3n//fR0/flx16tTRXXfddd1+1m2a1eUY107P7RlCeWE9S60gLg1s2bKlLWxcuHBhrpfjzveFdHO8jgUlq/f7lStXbOOcOXvOJUqU0OOPP64vvvhCR48e1YEDB/Tiiy/KYrFo3bp1duO65Nd+mJN15ofrXRaYk/lzs63zsm+WLl1a0v/OhsppXXl5zQryuCPxWeoM28RRXt8DBamwfO7c6GMycLMgwAJuEtbTka8d3PnvPvnkE8XFxcnb29s2/kVBeP755zVhwgRJV8OrF1544bp9Crr+Y8eOSZJq1arlctDQ5cuX52iZ2WUNZI4dO6Y///zT6TwXLlywjddQUA4ePCjJ8bR2d+47d911l26//XalpqZKuv7g7df2k65+wdy3b5/TeTIyMrRq1SpJUsOGDfOh2v+xhkdZnb1gHRfq1KlTeR676e/Kli2r7t27S7o6wKyrbeDMtTW7830huf91dKc1a9a43H/WrVun9PR0ScpWoFu9enWNGzdODz74oKSrgxRbFdR+mNU68+rs2bO2wHzevHm6ePGiy8fGjRslSb/88ov27t3rdHm52dZ52Tfr168v6WqIdPjwYad9k5KSXB7z8/KaFeRxR+Kz1Bm2iaO8vgcKkid/7mTnu4UrBXlMBm4mBFjATeLWW2+VJK1atUoJCQkO0/fs2aMRI0ZIkoYOHeowIG5+ef755+0uG8xOeCUVfP2hoaGSpH379iklJcVh+m+//ZbnO5y50qZNG4WHh0uS7W5/fzd+/PhcjUUiXf2idb0vOytWrLD90GvRooXdNHfvO2+//baGDx+u4cOHq1+/ftnq06ZNG9s4UK7+yvjJJ5/Y/vprvVQxv4SEhEiS0+1l1bJlS9ugus8++6wtpHMlp4O5jh07VkFBQbp8+bK6det23b9kx8fHq3v37nZ32nPn+0Jy/+voTkePHtWsWbMc2jMzM/Wvf/1LkhQVFaXbb7/dNu3a8XWcsZ71ce2lwHndD3OzzryaM2eO0tLSFBoaqgceeEBBQUEuHw0bNrQdw1ydhZWbbZ2XfbNt27a2Y4R1+X/33nvvKTk52em0vLxmBX3cKcyfpbnFNnGU1/dAQfLkz53sfLdwxzEZuJmw5wNuEB8fr7i4ONsjMzNTkpScnGzXnpSUZOvz0EMPSbr6l7aePXvq6NGjkqSUlBTNmTNHMTExunTpkqKjo/Xmm286Xe/hw4dtY4vk5tTja8e8evfdd6972eC18qP+rLRt21ZeXl46f/68HnroIduP/dTUVH311Vdq27ZtlgNu5kVAQIBeffVVSdKsWbP0zDPP2M52unDhgt544w3961//st0aOaeOHTumO++8U5988okOHjzocIbNW2+9pc6dO8sYoxIlSujZZ5+161/Q2/567rvvPk2YMEETJkywXXZwPQEBAbZ9dO7cuRo8eLBtwOLk5GRNnjzZNuZa79698/2uVHXq1JF09dIRV8FRsWLF9PHHH6tYsWL6+eef1axZM61YscJu0NaDBw/q448/VsOGDfXRRx/lqIaaNWtqzpw58vX11c6dO1WvXj29/fbbdpeIZmRkaNu2bXrttddUrVo1LViwwG4Z7nxfSO5/Hd0pNDRUTzzxhKZOnWr70Xvs2DH17dvX9pf/sWPH2vV56qmn1KtXL82fP99uYOGkpCR9/PHHtnHkOnToYJuW1/0wN+uU8vZ5Yg2iOnfunK3x9nr27ClJmj17tu1sqmvlZlvnZd8MDAzUyJEjJUlTp07ViBEjbEHRxYsX9fbbb2v06NG24OHv8vKaFfRxpzB/lv7dtd+3nD2sIUNR2ibZldf3QEHy5M+d7Hy3yO0xGSgyDIAbLiIiwki67mPAgAF2/Z566im76WFhYaZYsWK2f3ft2tUkJia6XO+hQ4ds844aNSpHNR85csTW18vLy5QtWzbLxzvvvOOwjLzWfz0jR460W35oaKjx8fExkkzVqlXN559/bpv2d82bN7/udhk1apSRZJo3b+4wLSMjwzz88MN22yg8PNx4e3sbSaZPnz5mwIABTl/X67n2dZNkfH19TalSpUxgYKBde9WqVc3WrVudLqOgt71120REROSo36pVq2w1HDp0yGH6s88+a5tusVhMeHi4Xd0tW7Y0Fy5ccOiX19dz3759xt/f325/j4iIMBEREebYsWN28y5cuNAEBwfbavLx8TElS5Y0fn5+dtt87NixOdo2Vj///LOJjIx02AdKlChhvLy87LZP3759TWpqql3/gn5fGGOuu2/n9nXMDuvrKOm6x6WyZcua2NjYbNWd22nWbfbPf/7TNG3a1LZPhIeH270Or7zyisvlWh9BQUEmLCzMrq1p06YmKSnJoW9u98PcrjO3nyfr16+39Vu8eHG2+uzYscPW55tvvrG152VbW+V230xLSzM9evRwecx/+OGHTf/+/Y0k8/jjjztdd16OHQV53Cmsn6XXrjs7jzvuuKNQbJPsHK9yU1t+vAeycu1rlRt5+dwpqG2Wne8WefkcAIoCzsACbiIffPCBPv/8czVv3lxhYWFKTk5WuXLl1KtXL/34449asGCB7fRkZ679a0/jxo1ztG7rWWLW/z99+nSWj2vPHsuv+q/nrbfe0uzZs9WoUSMFBAQoLS1NkZGReumll7Rt27br3u45L7y8vDR79mzNnj1bjRs3VkBAgNLT01W/fn19/PHHebq8oEKFCvr66681ZMgQ3XXXXSpVqpQuXLigzMxMVa5cWQ888ICmTZumnTt36s4773S6jILe9gXl3Xff1cqVK9W9e3eVLVtWSUlJCg4OVsuWLfXpp59q2bJlBfKX7xo1amjVqlXq1KmTSpcurXPnzunIkSM6cuSIwxkgXbp00YEDBzRq1Cg1atRIQUFBSkhIkJ+fn+644w4NGjRICxcuzPbltn8XHR2tPXv2aO7cuXrooYcUGRkpf39/Xbx4USVKlFDTpk318ssva/fu3frvf/8rHx8fu/7ufF9Y3ajX8XrHpdOnT1/3kqv84uvrqxUrVuhf//qXatWqpStXrig0NFT33nuvvvvuO6eXA7366quaPHmyunbtqltvvVXFihVTUlKSypQpozZt2ujTTz/V6tWrFRgY6NA3t/thXtaZG9azr0JDQ9W2bdts9bn99tt122232fW/Vm62tVVu981ixYrpq6++0rRp02zvrfT0dN111122u65az+BxdXZMXo4dBXncKayfpXnBNnGUH++BguSu7w9Zyc53ixt9TAZuNhZjcjGKHICb0tixY/Xqq6+qadOmWrdunbvLAYBCp0WLFlqzZo1GjRrFXaIKmCdva2OMKleurOPHj2v27Nl6+OGH3V0ScEPxHgBQEDgDCyhCVq5cKcn1gJsAACDv5syZo+PHj6tYsWJq3bq1u8sBbjjeAwAKAgEWUERcuXJF69evV/v27RUTE+PucgAAuKn17dtX8+bNU1xcnK3t9OnTeuutt/SPf/xDktS/f3+VL1/eXSUCBYr3AIAbrZi7CwBwY/j5+d3w2ywDAFBY/fDDD/riiy8kScWLF5ePj48SExNt02NiYvTee++5qzygwPEeAHCjEWABAAAAOTR58mT98MMP2rZtm86cOaOkpCSVLl1a9erVU58+ffTwww873FQBKEx4DwC40RjEvQC8++67+vnnn/X777/rzJkzSklJUbly5dS8eXO98MILuv322+3mHz16tF5//XWXyxs5cqTeeustp9NiY2P15ptvasOGDUpNTVVUVJSeeuop9e/f3+Xyjh8/rldffVU//vijzp8/r8qVK6tv37765z//KX9//9w9aQAAAAAAgAJCgFUASpUqpUuXLqlu3bqqWLGiJGnnzp3at2+ffHx8tGDBAnXs2NE2vzXAio6OVmRkpMPyOnTooJ49ezq0z58/X71791ZmZqaaNWumUqVKacWKFUpISNDw4cM1YcIEhz4HDhxQkyZNFBcXpzp16igqKkqbN2/WwYMHFR0drRUrVsjPzy8ftwYAAAAAAEDecAlhAVi0aJEaNGjgcDbTRx99pCFDhmjQoEG2u3Jca9CgQRo4cGC21nH+/Hk9+uijysjI0Pz589WtWzdJVwdObNq0qSZOnKiOHTuqRYsWdv0GDhyouLg4DR06VJMmTZIkpaenq1evXlq4cKHGjRvncbeiBgAAAAAARRt3ISwA0dHRTi/Fe/LJJ1W9enWdPn1au3btytM6pk2bpgsXLqhz58628EqSypYtq/Hjx0uSJk6caNdn48aNio2NVZkyZWzzSFKxYsU0ZcoU+fj4aPLkyUpPT89TbQAAAAAAAPmJAOsGsw5k6Ovrm6flfPfdd5KkHj16OEzr0KGD/P39tXz5cqWkpDj0eeCBBxwuEyxbtqxiYmIUHx+vn3/+OU+1AQAAAAAA5CcCrBtozpw52rt3r2rUqKEaNWo4TF+5cqWeeeYZDR48WGPHjtWWLVtcLmv79u2SpPr16ztM8/X1VZ06dZSSkqJ9+/Zlq8+17Tt27Mj+kwIAAAAAAChgjIFVgN555x3t3LlTly5d0u7du7Vz505VqFBBc+fOlbe3t8P8c+bMsfv3q6++qu7du2vmzJkKCgqytV+4cEGJiYmSpEqVKjldd6VKlbR582YdOXJEdevWlSQdPXr0un0k6ciRIzl8pgAAAAAAAAWHAKsA/fjjj1qxYoXt3xEREZo9e7YaNGhgN19kZKQmTJig++67TxEREYqPj9fatWs1YsQIzZ8/XxkZGVq4cKFt/qSkJNv/Fy9e3Om6AwMDJUkXL1506JeTPlmpXbu20/a9e/cqICBAlStXztZyAAAAAADIi6NHjyowMFCnTp1ydykoIFxCWICWL18uY4wtkKpRo4aaN2+uN998026+fv36afjw4YqKilJgYKAqVaqkBx98UJs2bVLJkiX1zTffaMOGDW56FjlnjFFaWpq7y8gzY4x27dolY4y7SwEAAAAAZCEtLU2XLl1ydxkoQJyBdQOEhYUpJiZG33//vZo0aaJXX31Vbdu2VcOGDbPsV758eT3yyCOaMGGCli5dqsaNG0uS3eWEycnJCgkJcehrfeMGBwfb2qz9kpOTna7PWZ+s7Ny502m79cwsV9NvFmlpafL19dX27dttg+8DAAAAADyPqyuEUHhwBtYN5OPjo969e8sYo8WLF2erj3Ww95MnT9raQkJCFBoaKkk6fvy4037W9oiICFub9ZK+nPQBAAAAAABwNwKsG6xUqVKSpLNnz2Zr/vj4eEn/G5/K6o477pAkbd261aFPWlqa/vjjD/n7+6tmzZrZ6nNtu3XQdwAAAAAAAE9AgHWDrVmzRpJUvXr1685rjLEN3l6/fn27aR06dJAkzZs3z6HfkiVLlJKSotatW8vf39+hz+LFi3XlyhW7PqdPn9a6desUHh6u6OjoHDwjAAAAAACAgkWAlc9iY2O1dOlSZWZm2rWnpaXpgw8+0Jw5cxQQEKDevXtLunom1ocffuhw57+kpCQ98cQT+vXXX1WuXDl169bNbvqgQYMUEhKiRYsWacGCBbb2M2fOaMSIEZKk4cOH2/Vp1KiRoqOjdebMGY0cOdLWnp6erieffFJpaWkaOnQo4z0BAAAAAACPYjHcYi1fzZw5U4888ohKlSqlBg0aqGTJkoqLi9Pvv/+ukydPyt/fX7NmzVKvXr0kSYcPH1bVqlUVFBSkhg0bqnz58jp79qy2bt2qc+fOKSwsTEuWLHF6VtT8+fPVq1cvGWPUokULlSxZUsuXL1dCQoKee+45TZw40aHP/v371aRJE507d0633367oqKitGnTJh08eFD33HOPVq5cKT8/vzxtg8I2iHtqaiqhHgAAAAB4sMLyOxSuEWDls0OHDmnatGlas2aNDh48qLi4OPn6+qpKlSpq1aqVhg4dqsjISNv8Fy9e1JtvvqkNGzbowIEDiouLk7e3t6pWrar27dvr2WefVcWKFV2uLzY2VmPHjtWGDRuUmpqqqKgoPfXUUxowYIDLPseOHdNrr72mpUuX6vz586pcubL69u2rl156ye6Sw9wqLAcOAiwAAAAAuDkUlt+hcI0AC/musBw4CLAAAIC7GGPE13QARZHFYpHFYslxv8LyOxSuFXN3AQAAAACky5cvKzExURcvXlR6erq7ywEAtylWrJiCg4MVGhqqgIAAd5cDD0GABQAAALjZhQsXdOLECXeXAQAeIT09XfHx8YqPj1fFihUVEhLi7pLgAQiwAAAAADe6fPmyLbwKCgpSeHi4/P395eXFDcMBFD2ZmZlKSUlRfHy8kpKSdOLECfn4+HAmFgiwAAAAAHdKTEyUdDW8qlSpUq7GfgGAwsLLy0tBQUEKDAzU8ePHlZSUpMTERAIsiD/rAAAAAG508eJFSVJ4eDjhFQD8fxaLReHh4ZL+d5xE0UaABQAAALiJMcY2YLu/v7+bqwEAz2I9Lqanp3NnVhBgAQAAAO5y7Q8yxrwCAHvXHhcJsMCnJAAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAACPY7FYiuRdGS0Wi6pUqZIvyzp8+LBtO1of3t7eKlWqlNq2bav58+fneR0DBw6UxWLR6tWr814wAGSBAAsAAAAACrHAwEANGDBAAwYMUJ8+fVS5cmUtW7ZMPXr00Isvvuju8mxatGghi8Wiw4cPu7sUAB6IAAsAAAAACrFSpUpp5syZmjlzpj7//HNt3bpVM2bMkCSNHz9ev//+e66XPW7cOO3evVuNGjXKr3IBwCkCLAAAAKAIMsZo79693Jq+iBo4cKBatmwpY4wWLVqU6+WUL19et956q4oXL56P1QGAIwIsAAAAoAiaNGmSbr31Vk2aNMndpeRZQkKCPvjgA7Vr104RERHy8/NTyZIl1b59ey1btsxpnypVqrgcY2v16tWyWCwaOHCgXfu14z2tXbtWrVq1UnBwsEJCQtShQwft2rXLZY1Lly5Vp06dVLZsWfn5+emWW25Rx44dXY5DlZGRobfffls1a9a0zT9y5EhduXIlexslG+68805J0rFjx2xt6enp+uCDD9SgQQMFBQUpKChIjRo10pQpU5SRkeGwDFdjYF27fadNm6a6desqICBA5cqV0+OPP66EhATbvNaxutasWSNJqlq1qt24XQAgEWABAAAARdK0adMkSdOnT3dzJXm3YcMGDR06VPv27VOtWrXUtWtX1apVSz/99JPatWunTz/9NF/Xt3jxYrVq1UrJycm6//77Vb58eX3//fdq1qyZTp065TD/8OHDdd999+m7775TjRo11L17d1WvXl2xsbF64403nK7jwQcf1NixY1WrVi21bdtWFy9e1Pjx4/XYY4/l2/O4ePGiJMnPz0/S1dCsc+fOGjp0qA4cOKA2bdqodevW2rNnj5588kn17NlTmZmZOVrHiBEjNGTIEJUvX1733XefjDH6z3/+o06dOtnO/gsKCtKAAQNUtmxZSVL37t1tY3YNGDAg354vgJtbMXcXAAAAAODG2rNnj3bu3ClJ+uOPP7R3717VqlXLzVXlXq1atbR+/Xo1btzYrn3btm1q1aqVnn32WfXq1UtBQUH5sr73339f8+fPV5cuXSRdDX569+6t+fPn66OPPtKYMWNs83722Wd69913VaFCBX333XeqV6+ebdrly5f1888/Oyz/yJEjKl68uPbv369y5cpJkg4dOqT69evr888/1+uvv67q1avn6TmkpKTYzk6rW7eu7Xl9//33ql27tlasWGELlE6ePKmWLVtq4cKF+uijj/TUU09lez1z5szRjh07bPtXXFycmjRponXr1mnVqlVq1aqVbYyuFi1a6PTp05owYUK+3YkRQOHBGVgAAABAIXfmzBl9++23tsfEiRPtpk+cONFu+pkzZ9xUae5UrVrVIbySrl4iN2TIEF24cEGrVq3Kt/X17dvXFl5Jkre3t/75z39KktauXWs377/+9S9J0rvvvmsXXklSQECA2rRp43QdkydPtoVX0tXn2K9fP0nSunXrcl17Wlqafv/9d/Xo0UOHDx9WyZIl1bNnT9s6rbVawyvp6jhX77zzjiTl+JLTN954wy4cLVWqlAYPHizJcVsBQFY4AwsAAAAo5Jo3b649e/a4nD516lRNnTrV9u9bb71Vu3fvvhGl5ZuMjAytWLFCv/zyi06ePGkbK2r//v12/80Pbdu2dWirWbOmpKtnK1n99ddf2r17t8LCwtSrV69sL9/Hx0ctW7bM1jqy48iRI07Hkipbtqzmz5+v0NBQHT16VEePHlXp0qWdPr+OHTsqLCxMBw4c0KlTp+zCtaxkd1sBwPUQYAEAAACFXPfu3fXmm2/maP6byfHjx9WxY0dt377d5TzW8Z7yQ6VKlRzagoODJclukHXr4OjVqlXL0WDk5cqVk7e3d7bWkR2BgYHq0aOHpKtni4WFhal+/frq2rWr7e6Bf/31lyQpIiLC6TIsFosiIiKUkJCgEydOZDvAyu62AoDrIcACAAAACrmxY8eqbt26+r//+z8lJia6nC80NFRTp061XVJ2sxg0aJC2b9+u7t27a8SIEapVq5aCg4Pl5eWl//znP3r88cdtA4Znx/UGKvfyKtiRWPJ7+dYxpvIqN3cELOhtBaDoIMACAAAAioBevXqpUaNGql+/vuLj4x2mh4eHa+vWrTfd4NmXLl3SsmXLVLZsWX355ZcOZy4dPHjQaT9fX19JUlJSksPg7tYzp/LqlltusdVgjMlVAHSjVKhQQdLVyw1dsU6rWLHiDakJAK5FHA4AAAAUEcWKFXMaXklSfHy8fHx8bnBFeZeYmKjMzEyVL1/eIbxKS0vTwoULnfYrX768JGnfvn0O06x358urChUq6LbbblNCQoK+/vrrfFlmQalcubIqV66ss2fPasWKFQ7Tv/vuO8XHxysyMjLblw/mlDVUTE9PL5DlA7i5EWABAAAARYSrMCe70z1RmTJlFBoaqj/++EOxsbG29oyMDI0cOdJpQCVdHdheksaNG6eMjAxb+9y5czV37tx8q+/FF1+UJD333HPasWOH3bSUlJR8C8vyw9NPPy3paq1nz561tZ86dUovvPCCJGnYsGEFtn7rWWB79+4tsHUAuHkRYAEAAABFxLUBVadOnbRnzx516tTJ1rZgwQJ3lJWlxo0bu3xMmzZNxYoV04gRI5Senq7mzZurbdu26tOnjyIjI/Xxxx9ryJAhTpc7ZMgQlS5dWvPmzVNUVJR69uypevXq6eGHH87XkKZ///56+umndeLECdWvX18xMTF68MEH1bJlS5UvX94WDHmCZ599Vvfdd5927NihGjVqqFu3buratatq1qyp3bt3q0uXLnryyScLbP3WffHBBx9Uz549NWjQIA0aNKjA1gfg5sIYWAAAAEARERISIn9/f02cOFFPPPGELBaLvvnmG3300Ud6/vnnFRoa6u4SHfz6668up7Vv316S9NJLL6lSpUp6//33FRsbq4CAADVt2lRjxozR1q1bnfYtW7as1q5dqxdeeEFr1qzRiRMn1KBBAy1btkwWi0Xvvfdevj2HyZMnq3Xr1vroo4+0adMmbdy4UWXKlFHTpk316KOP5tt68srb21vffvutPvroI82cOVM//vijJCkqKkqPPPKIHn/88QIdlL1bt2567733NHXqVC1evNh2l8Jp06YV2DoB3DwsJie34wCyoXbt2pKknTt3urmSvElLS5Ovr69SU1NvyvEgAACA58vMzLRdLlWrVq0Cv2NbamqqMjIyFBAQ4DDt8uXL8vb2to1DBADulpNjZGH5HQrXOAMLAAAAKCKyCqechVoAAHgKxsACAAAAAACARyPAAgAAAAAAgEcjwAIAAAAAAIBHI8ACAAAAAACARyPAAgAAAAAAgEcjwAIAAAAAAIBHI8ACAAAAAACARyPAAgAAAAAAgEcjwAIAAAAAAIBHI8ACAAAAAACARyPAAgAAAAAAgEcjwAIAAAAAAIBHI8ACAAAA4JFWrVql7t27q2LFivL19VV4eLhq1aqlnj176t///rcSExPt5m/RooUsFosOHz7snoKzMHr0aFksFs2cOdPdpeTYzJkzZbFYNHr06Fz137hxoywWiywWi8aMGZO/xQEoMgiwAAAAAHicMWPGqFWrVlqwYIFCQ0PVsWNHtW3bVgEBAVqwYIGefvpp7d69291luoXFYlGVKlXcXUa2zZkzx/b/n3/+uRsrAXAzK+buAgAAAADgWlu2bNHo0aPl4+Ojr776Sl26dLGbfurUKX322WcKCwuza589e7aSk5NVsWLFG1csspSWlqYvvvhCklSuXDnt27dPv/76q+6++243VwbgZsMZWAAAAAA8yoIFC2SMUa9evRzCK+lqEPL888/r1ltvtWuvXLmybr31Vvn4+NygSnE9S5cuVVxcnKKjo/Xkk09Ksj8jCwCyiwALAAAAgEc5e/asJKl06dI56udqDCzrJXfp6el64403FBkZqYCAAN12222aMWOGbb6VK1eqZcuWCgkJUXh4uPr3769z5845rKdKlSqyWCxOa1i9erUsFosGDhyYrZoPHDig0aNHq0mTJipXrpx8fX1VqVIl9e/fX/v27bOb1zoWlSQdOXLENq6UxWJRixYt7OZNTk7WuHHjdOeddyooKEhBQUFq3LixZs2a5bKW2NhYtW7dWsHBwQoLC1O7du3066+/Zut5uPLZZ59Jkvr166d+/fpJkr788kulpaU5nd+6bY0xmjRpkqKiouTv76+KFStq6NChSkhIcNovOTlZb7zxhurUqaOAgACFhoaqWbNmtrO/nNmxY4ceeOABhYWFKTg4WM2aNdOyZcuyfA2NMZo7d65atWql8PBw+fv767bbbtPo0aOVnJzsdD3p6emaMmWKmjRpopCQEAUEBKhevXp6//33lZ6ensXWA3AtAiwAAAAAHuWWW26RJM2fP19nzpzJt+X26tVLEydO1O23365mzZrp0KFDevTRRzVjxgzNmzdP7dq1U3p6utq1a6fAwEDNmTNHXbp0kTEm32r4u2nTpmnMmDG6dOmSGjZsqE6dOikkJERz5sxRw4YNtWPHDtu8kZGRGjBggCQpMDBQAwYMsD3at29vm+/MmTNq0qSJXnrpJZ06dUrNmzdXs2bNtGfPHg0cOFBPP/20Qx1LlixRixYttGLFCkVFRem+++7TsWPH1KxZM61fvz5Xzy0xMVHffvutfH191atXL1WtWlX33HOP4uLitHTp0iz7Pv3003rhhRdUqVIlde7cWRkZGfrggw/UvHlzXbhwwW7eixcvqlmzZnrttdd05swZdezYUdHR0dq4caP69u2rYcOGOSx//fr1atKkiZYsWaKIiAh17NhRKSkpat++vRYsWOC0pszMTD300EN68MEHtWnTJtWrV0/333+/Ll26pNdff10tW7bU5cuX7fpcvnxZbdu21ZNPPql9+/apcePGatOmjU6ePKlnn31W3bt3V2ZmZg63LFBEGSCfRUVFmaioKHeXkWepqalGkklNTXV3KQAAoJDKyMgwu3btMrt27TIZGRnuLsdj/PnnnyYgIMBIMsHBwWbAgAFm6tSpZuvWrSY9Pd1lv+bNmxtJ5tChQ3btkowkU6dOHXPmzBlb+8qVK40kU758eVOyZEmzZMkS27TExERTu3ZtI8msXLnSbnkRERHG1U+pVatWGUlmwIABdu2jRo0yksyMGTPs2tevX28OHjzosJxPP/3USDItW7Z0mCbJREREOF2/Mcbcf//9RpIZNmyYSUlJsbWfOnXK3HXXXUaS+eGHH2ztFy5cMKVLlzaSzKeffmprz8zMNCNHjrRtv1GjRrlcpzPTpk0zkkznzp1tbR999JGRZHr27Om0j3XbhoSEmM2bN9vaL168aFq1amV7Xtd66qmnbNvqwoULtvbdu3ebMmXKGElm8eLFtvaMjAxTs2ZNI8m8+eabTmt29hqOHz/eSDItWrQwJ0+etLVfuXLFPPbYY0aSGTlypF2fJ5980kgyvXv3NgkJCbb2Cxcu2F6nKVOmON+AyNExsrD8DoVrBFjId4XlwEGABQAAChoBlmvLly83t9xyiy1MsD7CwsLME088Yf766y+HPtcLsJYvX+7Q58477zSSTL9+/RymTZo0yWlwk58BVlaio6ONxWKxCz6sz8dVgLVt2zYjyTRs2NDpPrV161YjyXTq1MnWZg3LmjVr5jB/amqqqVSpUq4CLOvr8fXXX9va4uLijI+Pj/H393d4Xsb8b9u+9NJLDtN27txpLBaLCQoKMpcvXzbGGJOUlGQCAgKMl5eX2b17t0OfyZMnG0mmdevWtrZly5YZSaZGjRpOt1F0dLTDa5iWlmZKlSplAgMDzalTpxz6JCcnm3Llypnw8HDbMk+fPm18fHzMLbfcYpKTkx36nDx50vj6+pq6des6TMNVBFi4FpcQAgAAAEXQuiPr1GhqI607ss7dpTh177336sCBA1qwYIEGDx6s+vXrq1ixYkpISNCUKVNUr1497d27N9vL8/HxcRgnSpKqVasmSWrbtq3LaSdPnszdk8impKQkzZ07VyNHjtQ//vEPDRw4UAMHDtTJkydljNGff/6Z7WX99NNPkqQuXbrIy8vx5551TKyNGzfa2tatu7oP9OnTx2F+Hx8f9ejRI6dPSUePHtXatWsVFhamBx54wNZesmRJ3X///UpJSdHXX3/tsr+zWqKionTHHXcoKSlJ27Ztk3T1jpWXL19W/fr1HQb1l6SHH35Y0tXxvayX6sXGxkqSunfv7nQb9e7d26Ft69atiouL0z333KOyZcs6TA8ICFCDBg0UHx+v/fv3S7o6HlpaWprat2+vgIAAhz7lypVTjRo19PvvvztcegjAEQEWAAAAUMRkmkw98d0T2vTXJj35/ZPKNJ45Bo+vr6+6du2qKVOmaMuWLTp79qymTJmi8PBwnTlzRk899VS2l1WuXDl5e3s7tAcFBUmSKlas6HLalStXcvkMrm/lypWqVq2aHnzwQY0fP17Tpk3TrFmzNGvWLB08eFDS1TGesss6gP3LL79sN8j7tY+kpCTFxcXZ+vz111+SpIiICKfLrFKlSo6f1+effy5jjHr06CE/Pz+7adbB3K0DvDtzvVqsNVv/66rGsLAwhYaG6vLly4qPj5f0v0DSOtba31WuXNmhzbpdly1b5nK7fvfdd5Jk27bWPlOnTnXZZ+fOnTLG6Pz58y63BYCrirm7AAAAAAA31vxd87Xz7E5J0h9n/tCC3QvUIyrnZ9ncaGFhYRo8eLAqVKigzp07a9WqVUpOTlbx4sWv29fZmTY5mZ5dORmQOykpSb169dL58+f12muvqU+fPoqIiFBAQIAsFosefPBBzZ07N0eDyFvX37RpU1WvXj3H9eeXOXPmSLp6FlLTpk3tpqWmpkqS1q5dqyNHjrgMq/KLqztG5oR1u0ZGRio6OjrLeUuWLGnXp169errjjjuy7PP3kA+AIwIsAAAAoAjJNJl6fc3rdm2vr3ld3W7rJi/LzXGBRqtWrSRJGRkZSkhIyFaAlZ98fX0lXQ2grGdpWR07dizby1m3bp3OnTunHj166PXXX3eYbj0DKycqVaok6eolhMOHD89Wn/Lly0uSjhw54nS6q3ZXtmzZot27d0uSDhw4oAMHDjidzxijzz//XC+99JLTdd5+++0ua6lQoYLdf13VmJiYqISEBAUEBCg8PFzS/56vq9fKWbt1u956662aOXOm036u+jRt2lQffPBBtvoAcO3m+IQCAAAAkC+uPfvKynoWlqe43hlH1kDE19dXpUqVuhEl2bEGIPv27XOYtmzZsmwvx3pJmzXouNaBAwe0detWp/18fHyUnp7udFqbNm0kSQsXLsx2HTExMZKkr776ymFaenq65s+fn+1lSf+7NPD555+XuXrjMIfH6tWr7eb9O2e17NmzR7/99puCgoJUr149SVKDBg0UEBCgLVu22MaeclZLdHS07Sw76xlUCxcudLqvOVt3w4YNFRoaqjVr1mT7cr+WLVvK29tbS5YsUVpaWrb6AHCNAAsAAAAoQj7Y6PxMEFft7vDqq6/qhRdecDp4+YkTJ/T4449Lkjp16mQ7G+pGat68uSRp3LhxysjIsLXPnTtXc+fOzfZyatasKUlasGCBzp49a2tPSEjQY4895jL0qFChgk6fPq2EhASHaXfffbfatGmj2NhYDRkyRBcuXHCYZ/v27Vq6dKnt3z179lTJkiW1evVqzZo1y9ZujNGoUaN09OjRbD+njIwM2zbo27evy/liYmJUsWJF7d69W1u2bHGY/sEHH9gGapek5ORkPf300zLG6JFHHrENih4YGKhHH31UmZmZGjJkiC5dumTrs2/fPo0dO1aSNHToUFt7q1atVKNGDe3du1fjx4+3W+/MmTNtg9pfy8/PTyNGjNDFixfVrVs3p2fHnThxwnbppHR1XLVHH31Uhw8fVt++fXX69GmHPgcOHMhxQAgUVVxCCAAAABQh7SPb6/iF4zL635knFlnUrno7N1ZlLykpSZMmTdKECRNUs2ZNRUVFyd/fX8ePH9evv/6qtLQ0RUZG6v3333dLfUOGDNHHH3+sefPmKSoqSnXr1tX+/fv1xx9/aNiwYXrvvfeytZy77rpLbdq00bJly1SzZk3bXRJXr16tUqVKqXPnzlq0aJFDv06dOumDDz5Q/fr1dc8998jf31+1atXSCy+8IOnqWUft27fXRx99pP/+97+qV6+eKlSooMTERO3YsUPHjh3TsGHD1L59e0lScHCwpk+fru7du2vgwIGaMmWKqlWrpu3bt2v//v36xz/+oalTp2brOf300086ffq0atasqfr167ucz8vLS71799a7776rOXPmqEGDBnbT+/Xrp7vvvlutWrVSaGio1q5dq1OnTql27dp644037OYdN26cNmzYoGXLlqlatWpq3ry5Ll26pJUrVyolJUVDhw61uxOil5eXZs2apdatW+vFF1/U3LlzFRUVpT///FObNm3SkCFD9OGHHzqEoy+++KL27NmjOXPm6LbbbtOdd96pqlWrKjU1VXv37tWuXbtUt25d250PJWnSpEk6fPiw5s+fr6VLl6pevXqqXLmyLl26pF27dunAgQPq3Lmzunfvnq3tCxRlnIEFAAAAFCEvxbykg8MO6tCwQ7bHwWEH9VKM4zhE7vLKK69ozpw56tevn/z8/LRu3TrNmzdPu3btUqNGjTR+/Hj99ttvTu8ceCOULVtWa9euVceOHXXy5En98MMPCg0N1bJly9SpU6ccLWvRokV6+eWXVbp0af3www/asmWL+vTpow0bNigsLMxpn3Hjxumpp55Senq6vvzyS02fPt12BzxJKlOmjH755RdNnjxZUVFR2rZtm+bNm6cdO3aoWrVqeuedd/T888/bLdM6KH7Lli31xx9/6LvvvlP58uW1Zs0a3XPPPdl+PtYzkLI6+8rKOs/cuXMdLomcPHmyxo0bpyNHjmjRokWyWCwaMmSI1q1bp9DQULt5g4ODtWbNGr3++usqVaqUvv32W61bt0533XWX/vvf/2rSpEkO627SpIl++eUXdezYUYcOHdK3334rHx8fff/992rSpImk/w3GbuXl5aXZs2dr0aJFatOmjQ4dOqT58+fr559/lr+/v1544QV9+umndn0CAgL0ww8/aNasWbr77ru1e/duzZs3T5s3b1bp0qX1+uuvO5wFBsA5i8nJLS2AbKhdu7YkaefOndeZ07OlpaXJ19dXqamp8vHxcXc5AACgEMrMzNTevXslSbVq1cq3O+EBN6sqVaroyJEjObrzYn4bPHiwPvnkE33xxRfq3bu32+pAzo6RheV3KFzjExIAAAAAUKScP39ehw8fdmj/8ssvNW3aNIWFhaljx443vjAALjEGFgAAAACgSNm3b5+aNGmiunXrqlq1apKk3bt3a+/evfL29tYnn3yiwMBAN1cJ4FqcgQUAAAAAKFKqVaumIUOGKC0tTatWrdKSJUuUmJiobt26ad26derVq5e7SwTwN5yBBQAAAADwCM4u6ysIZcqU0b///e8bsi4A+YMzsAAAAAAAAODRCLAAAAAAAADg0QiwAAAAAAAA4NEIsAAAAAAAAODRCLAAAAAAAADg0QiwAAAAAAAA4NEIsAAAAAAAAODRCLAAAAAAAADg0QiwAAAAAAAA4NEIsAAAAAAAAODRCLAAAAAAeKRVq1ape/fuqlixonx9fRUeHq5atWqpZ8+e+ve//63ExES7+Vu0aCGLxaLDhw+7p+AsjB49WhaLRTNnznR3KTk2c+ZMWSwWjR49Ott9LBaLLBZLwRVVACwWi6pUqWLXtnr1alksFg0cONAtNWXF+rpc+/Dx8VGlSpXUt29fbd26Nc/rqFKlyk33OqLwIsACAAAA4HHGjBmjVq1aacGCBQoNDVXHjh3Vtm1bBQQEaMGCBXr66ae1e/dud5fpFs6CFhRd1atX14ABAzRgwAB17txZxYoV0xdffKHGjRvr22+/dXd5Nuy3yKti7i4AAAAAAK61ZcsWjR49Wj4+Pvrqq6/UpUsXu+mnTp3SZ599prCwMLv22bNnKzk5WRUrVrxxxaJQa9SokXbv3q3Q0FB3l+JS06ZN7c7sS0tL05NPPqlp06Zp8ODBat++vXx9fXO17BUrVigtLS2fKgXyhgALAAAAgEdZsGCBjDHq1auXQ3glSeXKldPzzz/v0F65cuUbUB2KkuLFi+vWW291dxk54uPjo/fff19ffPGFTp48qY0bN6pp06a5Wlb16tXzuTog97iEEAAAAIBHOXv2rCSpdOnSOernagws66VL6enpeuONNxQZGamAgADddtttmjFjhm2+lStXqmXLlgoJCVF4eLj69++vc+fOOawnq3GBcjpm0oEDBzR69Gg1adJE5cqVk6+vrypVqqT+/ftr3759dvNaxzySpCNHjtiNfdSiRQu7eZOTkzVu3DjdeeedCgoKUlBQkBo3bqxZs2a5rCU2NlatW7dWcHCwwsLC1K5dO/3666/Zeh55kZCQoA8++EDt2rVTRESE/Pz8VLJkSbVv317Lli1z2ufa1/qbb75R48aNFRgYqBIlSqhv3746fvy4037nz5/XU089pQoVKsjf319RUVGaNGmSjDFO53f1el47ptnvv/+uTp06KTw8XIGBgWrevLl++eUXp8tLS0vT22+/rVq1asnf31+VK1fWc889p6SkpHwdwy0wMFA1a9aUJB07dszWfu7cOb3wwguqUaOG/P39VaJECbVv314//fST0+U429cPHz5s2+cuX76sF1980fa6RUZG6u2337bbnjnZb4GscAYWAAAAAI9yyy23SJLmz5+vf/7znypTpky+LLdXr162kKp69epas2aNHn30UUlScHCw+vbtq8aNG6tdu3Zav3695syZo0OHDmnt2rUFNpD1tGnTNH78eNWpU0cNGzaUn5+fdu3apTlz5mjRokVat26d6tatK0mKjIzUgAEDNGvWLAUGBqpHjx625Vx7ltCZM2fUpk0b7dixQ+XKlVPz5s1ljNEvv/yigQMHavPmzfrggw/s6liyZIm6du2q9PR0NWrUSNWqVdP27dvVrFmzAh/AfMOGDRo6dKiqVKmiWrVqqUmTJjp69Kh++ukn/fTTT5o2bZrtdfq7jz76SO+++65iYmJ0//3369dff9UXX3yhLVu2aPv27QoICLDNGx8fr6ZNm2r37t0qV66cOnfurPPnz+v555/XgQMHclX75s2bNWTIEFWvXl3t2rXTnj17tHbtWt17773atGmT6tSpY5vXGKPevXtr4cKFCgwMVNu2beXj46MZM2bo559/VrFi+fvz/OLFi5IkPz8/SdKJEyfUrFkzHTx4UJUrV1aXLl109uxZLV++XD/++KPeffddPfvss9lefmpqqtq2batdu3apRYsWunTpktasWaMXX3xRFy9e1NixYyVlf78Frssg302cONF07drVREZGmpCQEOPr62sqV65sHn74YbNjxw6X/WbMmGEaNmxoAgMDTXh4uLnvvvtMbGxsluv6+eefzX333WfCw8NNYGCgadiwoZk1a1aWfY4dO2YGDhxoypcvb/z8/EyNGjXMa6+9Zi5fvpyr5/t3UVFRJioqKl+W5U6pqalGkklNTXV3KQAAoJDKyMgwu3btMrt27TIZGRnuLsdj/PnnnyYgIMBIMsHBwWbAgAFm6tSpZuvWrSY9Pd1lv+bNmxtJ5tChQ3btkowkU6dOHXPmzBlb+8qVK40kU758eVOyZEmzZMkS27TExERTu3ZtI8msXLnSbnkRERHG1U+pVatWGUlmwIABdu2jRo0yksyMGTPs2tevX28OHjzosJxPP/3USDItW7Z0mCbJREREOF2/Mcbcf//9RpIZNmyYSUlJsbWfOnXK3HXXXUaS+eGHH2ztFy5cMKVLlzaSzKeffmprz8zMNCNHjrRtv1GjRrlcp7Mas/tz8+DBg2b9+vUO7Vu3bjVhYWEmJCTEXLx40W6a9bUuXry4+eWXX2ztly5dMvfcc4+RZKZPn27XZ/DgwUaSad++vbl06ZKt/ddffzVBQUFOt+v1Xk9JZtKkSXbTnnnmGSPJPPzww3btc+bMMZJM1apVzbFjx2ztcXFxpl69erbl/X3/dWXGjBlOazPGmJ07dxpvb28jyezfv98YY0zHjh2NJPPggw+aK1eu2OZdt26dKV68uPH29jbbtm2zW46zff3QoUO2Wps3b24SExNt0zZt2mS8vb1N8eLFHV6z6+23zuTkGFlYfofCNQKsAlCyZEnj7+9vGjVqZLp27Wq6du1qatasaSQZHx8fs3jxYoc+w4YNM5JMQECA6dy5s2nXrp0pVqyY8fb2NgsXLnS6nnnz5hlvb29jsVhM8+bNTffu3U1YWJiRZIYPH+60z/79+02pUqVsH+C9evUy1apVM5JMdHS03QdcbhWWAwcBFgAAKGjuCLDGjjWmalVjqlT536Nq1avtnmT58uXmlltusf1Qtj7CwsLME088Yf766y+HPtcLsJYvX+7Q58477zSSTL9+/RymTZo0yWlwk58BVlaio6ONxWIxCQkJDs/HVRCwbds2I8k0bNjQ6T61detWI8l06tTJ1mYNy5o1a+Ywf2pqqqlUqVKBBlhZefnll40k8+2339q1W1/rl19+2aHPvHnzHF6DpKQkExAQYLy8vMyBAwcc+liDupwGWNHR0Q7LiouLc7qs6OhoI8nMmTPHoc+yZcvyJcBKSkoyy5cvN7Vq1TKSTOvWrY0xV0NhSSYoKMicO3fOYVnPPfeckWQGDRpk155VgOXl5WX27NnjsCxrULZq1Sq7dgIs5BWXEBaARYsWqUGDBvL397dr/+ijjzRkyBANGjRIx48ft50iunz5ck2aNEklS5bU+vXrVaNGDUnS+vXr1aJFCz3yyCNq0aKF3V1Wzp8/r0cffVQZGRmaP3++unXrJkk6ffq0mjZtqokTJ6pjx44O1xQPHDhQcXFxGjp0qCZNmiRJSk9PV69evbRw4UKNGzdOo0ePLpgNAwAAALf78Ufp0CHH9p9+kl5++cbX48q9996rAwcO6LvvvtNPP/2kjRs3aseOHUpISNCUKVM0f/58rV27VrVq1crW8nx8fJyOt1OtWjVt27ZNbdu2dTpNkk6ePJmn53I9SUlJWrx4sX777TedP3/edte3kydPyhijP//8U/Xr18/WsqxjGXXp0kVeXo5DHlvHxNq4caOtbd26dZKkPn36OMzv4+OjHj166P3338/p08qRjIwMrVixQr/88otOnjypK1euSJL2799v99+/c/a6Wcd+uvZ127Jliy5fvqxGjRo5HZi8b9++evvtt3Nct7P1lyxZUiVKlLBbf1pamjZt2iSLxWJ3CZ1V69atVaJECZ0/fz7HNcyaNcvp2GZ33XWX5syZI0n6+eefJUnt27dXiRIlHOZ9+OGH9e6779r2heyIiIhw+v5ztv2B/ECAVQCio6Odtj/55JN699139eeff2rXrl22a9nfffddSdIrr7xiC68kqUmTJho8eLAmT56s6dOna/jw4bZp06ZN04ULF9S5c2dbeCVJZcuW1fjx49WtWzdNnDjR7kN648aNio2NVZkyZTR+/Hhbe7FixTRlyhQtWbJEkydP1iuvvJLv118DAADAMzz9tOTsN+rTT9/4Wq7H19dXXbt2VdeuXSVdHez7iy++0EsvvaQzZ87oqaeecjnI99+VK1dO3t7eDu1BQUGSpIoVK7qcZg1TCsLKlSvVp08f28D1zljHMsoO6wDgL7/8sl7OIpFMSUmx/f9ff/0l6Wog4UyVKlWyvf7cOH78uDp27Kjt27e7nMfVNqhUqZJDW3BwsCT7162gnqOz9VtruDaMOnfunFJTU1W6dGmHEx2sKleunKsAq3r16ra7DPr4+Khs2bKKiYlRmzZtbCGm9fm7ep7W9hMnTmR7vVk9d6lg3zcomkgpbjAfHx9JVz+MJeny5ctauXKlJDlN4nv06KHJkydr8eLFdgHWd99957JPhw4d5O/vr+XLlyslJcV2gLT2eeCBB2wD+VlZD3IrV67Uzz//zN0gAAAACqnu3aXataWdO//XVqeOdM3fRD1WWFiYBg8erAoVKqhz585atWqVkpOTVbx48ev2dXY2Uk6mZ1dmZma2501KSlKvXr10/vx5vfbaa+rTp48iIiIUEBAgi8WiBx98UHPnznV5h7ys1t+0aVOnZxp5okGDBmn79u3q3r27RowYoVq1aik4OFheXl76z3/+o8cff9zlNsiv1y233L1+6eprPXPmzDwtIzc3KfCE546ihQDrBpozZ4727t2rGjVq2M602rt3r65cuaLSpUs7TbCtpwrv2LHDrt361wlnpxL7+vqqTp062rx5s/bt22c70yurPtb2lStXaseOHQRYAAAAhZSXlzRqlNSr1//aRo262n6zaNWqlaSrl50lJCRkK8DKT9Y/RiclJdnO0rI6duxYtpezbt06nTt3Tj169NDrr7/uMP3gwYM5rs36m6JLly52fwDPSvny5SVJR44ccTrdVXt+uHTpkpYtW6ayZcvqyy+/dDhLLjfbwBl3Pkfp6mWFPj4+iouLszvJ4Fo52XdyqkKFCpJcP0/rmXvOzkQEPMVN9DF183nnnXc0cOBA9ezZU3Xq1FH//v1Vvnx5zZ0713ZgPnr0qCTXp18GBgYqLCxM8fHxttNmL1y4oMTExCz7WduvPUBdb13O+gAAAKDwsZ6FJXnm2VfXO+PowIEDkq4GSaVKlboRJdmxhiH79u1zmJbdSxolKT4+XpLz7+cHDhzQ1q1bnfbz8fFRenq602lt2rSRJC1cuDDbdcTExEiSvvrqK4dp6enpmj9/fraXlVOJiYnKzMxU+fLlHcKrtLS0HD2PrDRo0EABAQHasmWL01Dsiy++yJf1uOLj46NGjRrJGKMFCxY4TF+5cqXOnTtXYOu3XmK4dOlSJSQkOEz/7LPPJP1vXygIWe23QHYQYBWgH3/8UbNmzdK8efO0c+dORUREaO7cuWrQoIFtnqSkJEnK8q9GgYGBkv533be1T1b9/t4nO+ty1icrtWvXdvr4888/s9UfAAAA7uHlJU2ZIjVsKH30keedffXqq6/qhRdecPq98sSJE3r88cclSZ06dbKdDXUjNW/eXJI0btw4ZWRk2Nrnzp2ruXPnZns51sGuFyxYYDcGVkJCgh577DHbYO5/V6FCBZ0+fdppEHH33XerTZs2io2N1ZAhQ3ThwgWHebZv366lS5fa/t2zZ0+VLFlSq1evthsM3BijUaNG2f4QXhDKlCmj0NBQ/fHHH4qNjbW1Z2RkaOTIkU5DwtwICgrSww8/rIyMDD399NO6fPmybdrmzZv173//O1/Wk5XBgwdLkl577TW7sabOnz+vF154oUDXXa1aNXXo0EEXL17UsGHD7Pat9evXa8qUKfL29taQIUMKrIas9lsgOzzso6pwWb58uYwxio+P19q1a1WjRg01b95cb775prtLAwAAQBEXEyNt3Hj1v54mKSlJEyZMUGRkpGrVqqWuXbuqb9++iomJUdWqVbVx40ZFRkYW+J3xXBkyZIhKly6tefPmKSoqSj179lS9evX08MMPa9iwYdlezl133aU2bdro6NGjqlmzpm3A+qpVq+qvv/5S586dnfbr1KmT0tPTVb9+ffXr10+DBg3SO++8Y5v+2Wef6c4779RHH32kiIgItWzZUg899JA6duyoypUrq169enYBVnBwsKZPny5vb28NHDhQjRs31oMPPqg6deronXfe0T/+8Y9cb6vGjRu7fEybNk3FihXTiBEjlJ6erubNm6tt27bq06ePIiMj9fHHH+droDJu3DjVqlVL33//vapXr64+ffqoXbt2atKkifr3759v63HloYceUteuXfXnn3/q1ltvVZcuXdS9e3dFRkbKy8tLjRs3lqQCC2U/+eQTVa1aVbNnz1aNGjXUt29ftW7dWjExMbp06ZLGjx+vevXqFci6pevvt8D1EGDdAGFhYYqJidH333+vBg0a6NVXX9WmTZsk/e/OJsnJyS77X7p0SdL/7uZw7XX2rvr9vU921uWsT1Z27tzp9HGzDBYJAAAAz/TKK69ozpw56tevn/z8/LRu3TrNmzdPu3btUqNGjTR+/Hj99ttvbhuvp2zZslq7dq06duyokydP6ocfflBoaKiWLVumTp065WhZixYt0ssvv6zSpUvrhx9+0JYtW9SnTx9t2LBBYWFhTvuMGzdOTz31lNLT0/Xll19q+vTpths2SVfPavrll180efJkRUVFadu2bZo3b5527NihatWq6Z133tHzzz9vt0zroPgtW7bUH3/8oe+++07ly5fXmjVrdM899+R4G1n9+uuvLh/Hjx+XJL300kuaNWuW6tatq9jYWC1fvlx33HGHNmzYoLvuuivX6/67EiVKKDY2Vk888YSMMfrmm2909OhRvfXWW/rggw/ybT2uWCwWffnllxo3bpzKly+vH374Qb/++qv69eunlStXKi4uThaLReHh4QWy/ooVK2rTpk0aPny4ihUrpgULFmjLli2699579eOPP+q5554rkPVaXW+/Ba7HYnJySwvk2TvvvKMRI0bo1Vdf1ZgxY/Tbb7/pzjvvVOnSpXXmzBmH+S9duqSgoCCFh4fb3VI1LCxMiYmJ2rlzp6Kiohz6NWzYUJs3b9b27dttg7h36dJFixYt0ocffqgnn3zSoc8LL7ygCRMmaNKkSRo6dGiun2Pt/z+gws5rb21zE0pLS5Ovr69SU1Ntd48EAADIT5mZmdq7d68kqVatWtzVCyiijh8/rqpVqyoyMlK7d+92dzkeIyfHyMLyOxSu8Ql5g1kHmbRe416rVi35+fnp7NmzdtdBW1kHbrSGUFZ33HGH3fRrpaWl6Y8//pC/v7/tuvrr9clqXQAAAACAvNuxY4fD2GanT5/WwIEDlZ6ern79+rmpMsDzEWDdYGvWrJEk22V2AQEBttsAf/311w7zz5s3T5L0wAMP2LV36NDBbvq1lixZopSUFLVu3dru9qzWPosXL9aVK1fs+pw+fVrr1q1TeHi4oqOjc/XcAAAAAACujRgxQmXLllWrVq3Ut29ftWjRQpGRkVqxYoUaNmyo4cOHu7tEwGMRYOWz2NhYLV26VJmZmXbtaWlp+uCDDzRnzhwFBASod+/etmnWa43Hjh2r/fv329rXr1+vTz75RGFhYXrsscfsljdo0CCFhIRo0aJFdrdhPXPmjEaMGCFJDge/Ro0aKTo6WmfOnNHIkSNt7enp6XryySeVlpamoUOHcrkcAAAAABSAgQMHqmHDhtqzZ48WLlyoTZs2KTIyUmPHjtXq1avtTkAAYI8xsPLZzJkz9cgjj6hUqVJq0KCBSpYsqbi4OP3+++86efKk/P39NWvWLPXq1cuu3zPPPKNJkyapePHiatOmjVJTU7Vs2TIZYzRv3jx16dLFYV3z589Xr169ZIxRixYtVLJkSS1fvlwJCQl67rnnNHHiRIc++/fvV5MmTXTu3DndfvvtioqK0qZNm3Tw4EHdc889Wrlypfz8/PK0DQrLtceMgQUAAAoaY2ABgGuMgYVr8QmZz5o3b66XXnpJtWrV0o4dO/T1118rNjZWJUqU0NNPP63ff//dIbySpPfff18zZszQbbfdpmXLlmn9+vVq3bq11q5d6zS8kqTu3btr7dq1ateunbZt26bvv/9ekZGRmjlzptPwSpJq1Kihbdu2aeDAgTp79qwWLlwoLy8vvfrqq1qxYkWewysAAAAAAID8xhlYyHeFJfnmDCwAAFDQOAMLAFzjDCxci09IAAAAAAAAeDQCLAAAAMBNLBaL7f8zMjLcWAkAeJ5rj4vXHi9RNBFgAQAAAG5isVhsY5BeuHDBzdUAgGexHhf9/PwIsKBi7i4AAAAAKMrCw8N16tQpnTlzRunp6QoODubHGoAiyxijK1eu6OLFizp//rykq8dJgAALAAAAcKPQ0FClpKQoISFB58+ft/1gAwBIYWFhCg0NdXcZ8AAEWAAAAIAbeXl5qVy5cgoMDNTFixd16dIlxsMCUKR5e3srMDBQwcHBCg4O5oxUSCLAAgAAANzOYrEoJCREISEhkq5eQmOMcXNVAHDjWSwWAis4RYAFAAAAeBh+wAEAYI+7EAIAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFg5bPk5GR98803euyxx1SrVi35+/srMDBQd9xxh8aMGaOkpCSHPqNHj5bFYnH5ePHFF12uLzY2Vvfff79KlCihoKAgNWrUSLNnz86yxuPHj+uRRx5RhQoV5O/vr5o1a2rUqFFKSUnJ8/MHAAAAAADIb8XcXUBh89///lf/+Mc/JEm33XabOnXqpAsXLuiXX37RqFGjNHfuXK1Zs0ZlypRx6BsdHa3IyEiH9gYNGjhd1/z589W7d29lZmaqWbNmKlWqlFasWKEBAwZox44dmjBhgkOfAwcOqEmTJoqLi1OdOnUUExOjzZs3a8yYMVqxYoVWrFghPz+/PG4FAAAAAACA/EOAlc98fHz0f//3f3rmmWd022232dpPnjypDh06aNu2bXrmmWf03//+16HvoEGDNHDgwGyt5/z583r00UeVkZGh+fPnq1u3bpKk06dPq2nTppo4caI6duyoFi1a2PUbOHCg4uLiNHToUE2aNEmSlJ6erl69emnhwoUaN26cRo8enavnDgAAAAAAUBC4hDCfDRgwQJ988oldeCVJ5cuX14cffihJWrBggVJTU/O0nmnTpunChQvq3LmzLbySpLJly2r8+PGSpIkTJ9r12bhxo2JjY1WmTBnbPJJUrFgxTZkyRT4+Ppo8ebLS09PzVBsAAAAAAEB+IsC6ge644w5J0pUrV3Tu3Lk8Leu7776TJPXo0cNhWocOHeTv76/ly5fbjWtl7fPAAw84XCZYtmxZxcTEKD4+Xj///HOeagMAAAAAAMhPBFg30MGDByVdvcywRIkSDtNXrlypZ555RoMHD9bYsWO1ZcsWl8vavn27JKl+/foO03x9fVWnTh2lpKRo37592epzbfuOHTuy+YwAAAAAAAAKHmNg3UDWMafat2/vdKD0OXPm2P371VdfVffu3TVz5kwFBQXZ2i9cuKDExERJUqVKlZyuq1KlStq8ebOOHDmiunXrSpKOHj163T6SdOTIkZw8LQAAAAAAgAJFgHWDfP/995o+fbp8fHz0xhtv2E2LjIzUhAkTdN999ykiIkLx8fFau3atRowYofnz5ysjI0MLFy60zZ+UlGT7/+LFiztdX2BgoCTp4sWLDv1y0icrtWvXdtr+559/qnr16tlaBgAAAAAAwPUQYN0Ae/bsUb9+/WSM0TvvvGMbC8uqX79+dv8ODAzUgw8+qJYtW+r222/XN998ow0bNqhx48Y3smwAAAAAAACPQIBVwE6cOKH27dsrPj5ezz33nIYNG5btvuXLl9cjjzyiCRMmaOnSpbYA69rLCZOTkxUSEuLQ99KlS5Kk4OBgW5u1X3JystP1OeuTlZ07dzptd3VmFgAAAAAAQG4wiHsBOn/+vNq2basjR47YgqicqlGjhiTp5MmTtraQkBCFhoZKko4fP+60n7U9IiLC1la5cuUc9wEAAAAAAHA3AqwCkpSUpPvuu0+7du1St27dNHXqVFkslhwvJz4+XtL/xqeysl6GuHXrVoc+aWlp+uOPP+Tv76+aNWtmq8+17dZB3wEAAAAAADwBAVYBuHLlijp37qyNGzeqXbt2mjt3rry9vXO8HGOMbfD2+vXr203r0KGDJGnevHkO/ZYsWaKUlBS1bt1a/v7+Dn0WL16sK1eu2PU5ffq01q1bp/DwcEVHR+e4VgAAAAAAgIJCgJXPMjIy1LdvX61cuVIxMTFasGCBfH19Xc5/9uxZffjhhw53/ktKStITTzyhX3/9VeXKlVO3bt3spg8aNEghISFatGiRFixYYGs/c+aMRowYIUkaPny4XZ9GjRopOjpaZ86c0ciRI23t6enpevLJJ5WWlqahQ4fKx8cn188fAAAAAAAgv1mMMcbdRRQmkyZN0jPPPCNJ6tq1q9MB1iVpwoQJKlWqlA4fPqyqVasqKChIDRs2VPny5XX27Flt3bpV586dU1hYmJYsWeL0rKj58+erV69eMsaoRYsWKlmypJYvX66EhAQ999xzmjhxokOf/fv3q0mTJjp37pxuv/12RUVFadOmTTp48KDuuecerVy5Un5+fnnaBtZB3F0N8n6zSEtLk6+vr1JTUwn1AAAAAMCDFZbfoXCNACufjR49Wq+//vp15zt06JCqVKmiixcv6s0339SGDRt04MABxcXFydvbW1WrVlX79u317LPPqmLFii6XExsbq7Fjx2rDhg1KTU1VVFSUnnrqKQ0YMMBln2PHjum1117T0qVLdf78eVWuXFl9+/bVSy+9ZHfJYW4VlgMHARYAAAAA3BwKy+9QuEaAhXxXWA4cBFgAAAAAcHMoLL9D4RpjYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFgAQAAAAAAwKMRYAEAAAAAAMCjEWABAAAAAADAoxFg5bPk5GR98803euyxx1SrVi35+/srMDBQd9xxh8aMGaOkpCSXfWfOnKlGjRopKChIJUqU0P33369ffvkly/XFxsbq/vvvV4kSJRQUFKRGjRpp9uzZWfY5fvy4HnnkEVWoUEH+/v6qWbOmRo0apZSUlFw9ZwAAAAAAgIJkMcYYdxdRmEybNk3/+Mc/JEm33Xab6tSpowsXLuiXX37RxYsXdeutt2rNmjUqU6aMXb9nnnlGkyZNUkBAgNq2bauUlBStWLFCxhjNmzdPXbp0cVjX/Pnz1bt3b2VmZqpZs2YqVaqUVqxYoYSEBA0fPlwTJkxw6HPgwAE1adJEcXFxqlOnjqKiorR582YdPHhQ0dHRWrFihfz8/PK0DWrXri1J2rlzZ56W425paWny9fVVamqqfHx83F0OAAAAAMCFwvI7FK5xBlY+8/Hx0f/93/9p165d2rVrl7766istXbpUe/fu1Z133qk9e/bomWeeseuzfPlyTZo0SSVLltT27dv1zTffaOnSpVq7dq28vb31yCOPKCEhwa7P+fPn9eijjyojI0Pz5s3T6tWrNW/ePO3Zs0eRkZGaOHGiVq9e7VDfwIEDFRcXp6FDh+r333/Xl19+qb1796pr166KjY3VuHHjCm7jAAAAAAAA5AIBVj4bMGCAPvnkE91222127eXLl9eHH34oSVqwYIFSU1Nt0959911J0iuvvKIaNWrY2ps0aaLBgwcrISFB06dPt1vetGnTdOHCBXXu3FndunWztZctW1bjx4+XJE2cONGuz8aNGxUbG6syZcrY5pGkYsWKacqUKfLx8dHkyZOVnp6el00AAAAAAACQrwiwbqA77rhDknTlyhWdO3dOknT58mWtXLlSktSjRw+HPta2xYsX27V/9913Lvt06NBB/v7+Wr58ud24VtY+DzzwgMNlgmXLllVMTIzi4+P1888/5+r5AQAAAAAAFAQCrBvo4MGDkq5eZliiRAlJ0t69e3XlyhWVLl1alSpVcuhTv359SdKOHTvs2rdv3243/Vq+vr6qU6eOUlJStG/fvmz1yWpdAAAAAAAA7kSAdQNNmjRJktS+fXvbGVBHjx6VJKfhlSQFBgYqLCxM8fHxunjxoiTpwoULSkxMzLKftf3IkSO2tuuty1kfAAAAAAAAdyvm7gKKiu+//17Tp0+Xj4+P3njjDVt7UlKSJKl48eIu+wYGBiohIUEXL15UcHCwrU9W/QIDAyXJFnplZ13O+mTFepeHv/vzzz9VvXr1bC0DAAAAAADgejgD6wbYs2eP+vXrJ2OM3nnnHdtYWAAAAAAAALg+zsAqYCdOnFD79u0VHx+v5557TsOGDbObHhQUJElKTk52uYxLly5JkoKDg+36WPuFhIRct0921uWsT1Z27tzptN3VmVkAAAAAAAC5wRlYBej8+fNq27atjhw5okceeUQTJkxwmKdy5cqSpOPHjztdxqVLl5SQkKDw8HBbsBQSEqLQ0NAs+1nbIyIisr0uZ30AAAAAAADcjQCrgCQlJem+++7Trl271K1bN02dOlUWi8Vhvlq1asnPz09nz57ViRMnHKZv3bpVklS3bl27dutliNbp10pLS9Mff/whf39/1axZM1t9sloXAAAAAACAOxFgFYArV66oc+fO2rhxo9q1a6e5c+fK29vb6bwBAQFq1aqVJOnrr792mD5v3jxJ0gMPPGDX3qFDB7vp11qyZIlSUlLUunVr+fv7O/RZvHixrly5Ytfn9OnTWrduncLDwxUdHZ3dpwoAAAAAAFDgCLDyWUZGhvr27auVK1cqJiZGCxYskK+vb5Z9nnvuOUnS2LFjtX//flv7+vXr9cknnygsLEyPPfaYXZ9BgwYpJCREixYt0oIFC2ztZ86c0YgRIyRJw4cPt+vTqFEjRUdH68yZMxo5cqStPT09XU8++aTS0tI0dOhQ+fj45O7JAwAAAAAAFACLMca4u4jCZNKkSXrmmWckSV27dnU6wLokTZgwQaVKlbL9+5lnntGkSZNUvHhxtWnTRqmpqVq2bJmMMZo3b566dOnisIz58+erV69eMsaoRYsWKlmypJYvX66EhAQ999xzmjhxokOf/fv3q0mTJjp37pxuv/12RUVFadOmTTp48KDuuecerVy5Un5+fnnaBtZB3F0N8n6zSEtLk6+vr1JTUwn1AAAAAMCDFZbfoXCNACufjR49Wq+//vp15zt06JCqVKli1zZz5kz9+9//1u7du+Xr66vGjRvr1Vdf1T333ONyObGxsRo7dqw2bNig1NRURUVF6amnntKAAQNc9jl27Jhee+01LV26VOfPn1flypXVt29fvfTSS3aXHOZWYTlwEGABAAAAwM2hsPwOhWsEWMh3heXAQYAFAAAAADeHwvI7FK4xBhYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPBoBFgAAAAAAADwaARYAAAAAAAA8GgEWAAAAAAAAPFoxdxdwIx05ckS//fabzp49q4SEBIWFhal06dKqV6+eIiIi3F0eAAAAAAAAnCj0Adb27dv1n//8R999952OHTvmcr5bbrlFHTt21KBBg1SvXr0bVyAAAAAAAACyZDHGGHcXURBWr16tf/7zn9q4caOMMfLx8VHdunV16623qkSJEgoJCVFiYqLi4+O1e/du/f7770pLS5PFYtHdd9+tcePGqXnz5u5+Gjel2rVrS5J27tzp5kryJi0tTb6+vkpNTZWPj4+7ywEAAAAAuFBYfofCtUJ5BlbHjh31ww8/KDQ0VI8++qgefPBB3XPPPfLz83PZ58qVK4qNjdXnn3+uhQsXqlWrVrr//vu1ePHiG1g5AAAAAAAA/q5QnoFVoUIFjRgxQoMHD5a/v3+O+6ekpGjKlCl655139NdffxVAhYVbYUm+OQMLAAAAAG4OheV3KFwrlAFWSkpKroKrglpOUVNYDhwEWAAAAABwcygsv0Phmpe7CygI+RU6EV4BAAAAAAC4X6EMsAAAAAAAAFB4FMpB3F1JTk7W5s2bdfLkSV25csXlfP3797+BVQEAAAAAACArRSLAMsbotdde0/vvv6/k5OQs57NYLARYAAAAAAAAHqRIBFhjxozRm2++KV9fX3Xp0kXVqlVTUFCQu8sCAAAAAABANhSJAGv69OkKCQnR+vXrddttt7m7HAAAAAAAAORAkRjEPS4uTs2bNye8AgAAAAAAuAkViQCrRo0ayszMdHcZAAAAAAAAyIUiEWA98cQTWrVqlQ4fPuzuUgAAAAAAAJBDRSLAGjx4sB577DHFxMRo5syZOnHihLtLAgAAAAAAQDYViQBLkh5//HGFhobqscceU+XKleXt7e30UaxYkRjXHgAAAAAA4KZRJNKa9evXq23btrp06ZIsFotKlCihoKAgd5cFAAAAAACAbCgSAdaIESN06dIljRo1Ss8++6xCQkLcXRIAAAAAAACyqUgEWNu2bVPjxo01atQod5cCAAAAAACAHCoSY2AFBwerSpUq7i4DAAAAAAAAuVAkAqz7779fGzZsUEZGhrtLAQAAAAAAQA4ViQDrrbfekpeXlx577DElJia6uxwAAAAAAADkQJEYA2vkyJG6/fbbNWfOHC1atEh33XWXKlasKC8vx/zOYrFo+vTpbqgSAAAAAAAAzliMMcbdRRQ0Z0GVKxaLhUsN86h27dqSpJ07d7q5krxJS0uTr6+vUlNT5ePj4+5yAAAAAAAuFJbfoXCtSJyBtWrVKneXAAAAAAAAgFwqEgFW8+bN3V0CAAAAAAAAcqlIDOIOAAAAAACAm1ehDLDS0tI8ajkAAAAAAADIvUIZYFWvXl2ffPKJ0tPTc9U/LS1NH330kapXr57PlQEAAAAAACCnCmWAFRkZqSeeeEKVKlXSM888ow0bNigzMzPLPpmZmVq/fr2efvppVapUSU899ZRq1KhxgyoGAAAAAACAKxZjjHF3EQXhu+++00svvaTff/9dFotFAQEBuvPOO1WrVi2Fh4crODhYFy9e1Pnz57V371799ttvunz5sowxqlevnt58803dd9997n4aN6XCcvvStLQ0+fr6KjU1VT4+Pu4uBwAAAADgQmH5HQrXCm2AZRUbG6tp06bp+++/19mzZ13OV6ZMGd1///36xz/+oSZNmtzACgufwnLgIMACAAAAgJtDYfkdCteKubuAghYdHa3o6GhJ0t69e7Vjxw6dOXNGiYmJCg0NVZkyZXTHHXeoZs2abq4UAAAAAAAAzhT6AOtatWrVUq1atdxdBgAAAAAAAHKgUA7iDgAAAAAAgMKDAAsAAAAAAAAejQALAAAAAAAAHo0ACwAAAAAAAB6NAAsAAAAAAAAejQALAAAAAAAAHo0ACwAAAAAAAB6NAAsAAAAAAAAerZi7C7iRkpOTtXnzZp08eVJXrlxxOV///v1vYFUAAAAAAADISpEJsF577TW99957Sk5OdjmPMUYWi4UACwAAAAAAwIMUiQBr/PjxGjt2rLy9vdWhQwfVrFlTwcHB7i4LAAAAAAAA2VAkAqypU6cqICBA69atU/369d1dDgAAAAAAAHKgSAzifuzYMTVv3pzwCgAAAAAA4CZUJAKscuXKKTAw0N1lAAAAAAAAIBeKRIDVp08frV69WpcuXXJ3KQAAAAAAAMihIhFgjR49Wrfddps6deqkAwcOuLscAAAAAAAA5EChHMS9VatWDm2ZmZlavXq1brvtNkVERKhSpUry8nLM7ywWi1asWHEjygQAAAAAAEA2FMoAa/Xq1S6nZWRk6ODBgzp48KDT6RaLpYCqAgAAAAAAQG4UygDr0KFD7i4BAAAAAAAA+aRQBlgRERHuLgEAAAAAAAD5pEgM4j5mzBh9++23151v8eLFGjNmzA2oCAAAAAAAANlVJAKs0aNH65tvvrnufN9++61ef/31gi8IAAAAAAAA2VYkAqzsysjIcHpnQgAAAAAAALgPac01du7cqfDwcHeXAQAAAAAAgGsUykHcJenRRx+1+/fPP//s0GaVnp6uvXv3avPmzerSpcsNqA4AAAAAAADZVWgDrJkzZ9r+32Kx6MCBAzpw4ECWferWrat33nmngCsDAAAAAABAThTaAGvVqlWSJGOMWrVqpfbt22vkyJFO5/X19VWFChUUERFxI0sEAAAAAABANhTaAKt58+a2/x8wYIBiYmLs2gAAAAAAAHBzKBKDuP/222/6/vvv3V0GAAAAAAAAcqFIBFj79u2Tr6+vu8sAAAAAAABALhSJAKtGjRo6d+6cu8sAAAAAAABALhSJAOuxxx7TmjVrtGfPHneXAgAAAAAAgBwqEgHW008/rYEDB6p58+Z67733dODAAaWmprq7LAAAAAAAAGSDxRhj3F1EQfP29pYkGWNksViynNdisSg9Pf1GlFVo1a5dW5K0c+dON1eSN2lpafL19VVqaqp8fHzcXQ4AAAAAwIXC8jsUrhWJM7BuueUWVa5cWREREapcuXKWj1tuuSXP69uyZYveeustdevWTZUqVZLFYskyOBs9erRtHmePF1980WXf2NhY3X///SpRooSCgoLUqFEjzZ49O8v6jh8/rkceeUQVKlSQv7+/atasqVGjRiklJSXXzxkAAAAAAKCgFHN3ATfC4cOHb+j63njjDS1atCjH/aKjoxUZGenQ3qBBA6fzz58/X71791ZmZqaaNWumUqVKacWKFRowYIB27NihCRMmOPQ5cOCAmjRpori4ONWpU0cxMTHavHmzxowZoxUrVmjFihXy8/PLce0AAAAAAAAFpUgEWDdakyZNVLduXTVs2FANGzZUlSpVdOXKlev2GzRokAYOHJitdZw/f16PPvqoMjIyNH/+fHXr1k2SdPr0aTVt2lQTJ05Ux44d1aJFC7t+AwcOVFxcnIYOHapJkyZJktLT09WrVy8tXLhQ48aN0+jRo3PydAEAAAAAAApUkbiE0Jn4+HjFx8cXyLJHjhypMWPG6IEHHlC5cuUKZB3Tpk3ThQsX1LlzZ1t4JUlly5bV+PHjJUkTJ06067Nx40bFxsaqTJkytnkkqVixYpoyZYp8fHw0efJkxgADAAAAAAAepUgFWN9//73atWunoKAglSpVSqVKlVJQUJDat2+v77//3t3l5ch3330nSerRo4fDtA4dOsjf31/Lly+3G9fK2ueBBx5wuEywbNmyiomJUXx8vH7++ecCrBwAAAAAACBnikyA9eyzz+qBBx7QsmXLlJycrJCQEIWGhio5Ofn/sXff4VGV6fvA75lk0gmhJEiThABSIlhWBNkEdFVYxVWpuqti++0iCvgFFZciRSKigIt9V7FuwwDiurpSFg0RCyguSGgCoYMJIaGkTjLn98fLmTl15sxkkkwm9+e65opz5pR3SpC5ed7nxdq1a3HLLbdgypQpjTrGDRs24NFHH8X48eMxf/58fP/996b7btu2DQBwxRVX6B6LiopCRkYGKisrsXfvXkvHKLdv37494OdARERERERERBRszSLAWr58OZYuXYrk5GS8+OKL7umDp0+fRmlpKV566SWkpKRg6dKl+OCDDxptnO+//z6WLl2KP//5z5g1axZ+8YtfYNSoUTh//rxqv7Nnz+LMmTMAgE6dOhmeS95+6NAh97bDhw/7fQwRERERERERUWNrFk3cX331VcTExGDjxo3o0aOH6rHExEQ8/PDDuOGGG3DZZZfh1VdfxZgxYxp0fN26dcOiRYvw61//Gl26dEFJSQk2btyIJ554AitXrkRtbS0+/PBD9/7KQCsuLs7wnPHx8QCAc+fO6Y7z5xhv+vTpY7h9//79SE9Pt3QOIiIiIiIiIiJfmkWAtW3bNlx33XW68EqpR48euO666xql/9Ndd92luh8fH4/f/va3uPbaa3HppZdi9erV+OabbzBgwIAGHxsRERERERERUWNrFgFWdXW1u7rIm/j4eFRXVzfAiKxp37497rvvPixatAifffaZO8BKSEhw7yP389IqKysDALRo0cK9TT6uvLzc8HpGx3iTn59vuN2sMouIiIiIiIiIKBDNogdWeno6cnNz3QGNkfLycuTm5obc1Lfu3bsDAE6cOOHeJjegB4CjR48aHidv79Kli3vbxRdf7PcxRERERERERESNrVkEWGPGjEFhYSFuu+02/PTTT7rH9+/fjxEjRqCoqAhjx45thBGaKykpAQBdBVm/fv0AAFu3btUd43Q6sWPHDsTExKimTXo7Rrm9b9++dR84EREREREREVGQNIsA67HHHsMVV1yB//73v+jduzeuvvpqjB07FmPHjsWAAQPQs2dPrF27FldeeSWmTp3a2MN1kyTJ3bz9iiuuUD128803AwBWrFihO+7f//43Kisrcf311yMmJkZ3zMcff4yqqirVMT///DPy8vLQqlUrDBo0KKjPg4iIiIiIiIioLppFgBUbG4svvvgCDz/8MKKiorBlyxbk5OQgJycHmzdvRlRUFB5++GFs2LABsbGxDTq2oqIivPLKK7qV/86fP4+HHnoI3377LS666CKMGDFC9fiDDz6IxMREfPTRR1i1apV7e2FhIZ544gkA0IVx/fv3x6BBg1BYWIhp06a5t9fU1GDChAlwOp2YNGkSHA5HsJ8mEREREREREVHAbJIkSY09iIZUXl6O77//HsePHwcAdOjQAVdeeSXi4uKCdo1PPvkETz/9tPv+5s2bIUkSrr76ave2WbNm4eabb8bBgweRlpaGhIQEXHXVVWjfvj2KioqwdetWFBcXIykpCf/+978Nq6JWrlyJMWPGQJIkDBkyBG3atMH69etRWlqKKVOmYPHixbpjfvrpJwwcOBDFxcW49NJL0bt3b2zZsgUHDhzANddcgw0bNiA6OrpOz19u4m7W5L2pcDqdiIqKQnV1NUM9IiIiIiKiEBYu30PJXLNYhVApLi4OmZmZ9XqNoqIifPvtt7rtym1FRUUAgDZt2mDatGn45ptvsHfvXnz11VeIiIhAWloa7r33Xvzf//0fOnbsaHidkSNHYuPGjZg/fz6++eYbVFdXo3fv3njkkUcwbtw4w2O6d++OH374AU899RQ+++wzfPjhh7j44osxa9YsTJ8+vc7hFRERERERERFRsDW7Ciyqf+GSfLMCi4iIiIiIqGkIl++hZC4sK7DmzZtXp+OfeuqpII2EiIiIiIiIiIjqKiwrsOx2O2w2G/x5ajabzf3ftbW19TGsZiNckm9WYBERERERETUN4fI9lMyFZQXWggUL/Nr/2LFjWLZsGSoqKlRBFhERERERERERNb6wDLCmTZtmab+ff/4ZzzzzDN58801UVlYiMTERjz76aP0OjoiIiIiIiIiI/BKWAZYvRUVFePbZZ/H666+jsrISCQkJmDp1KqZOnYqkpKTGHh4RERERERERESk0qwCruLgYCxcuxGuvvYaysjIkJCTgySefxNSpU9G6devGHh4RERERERERERloFgFWSUkJnn/+ebz88ss4f/484uPj8cQTT+Dxxx9HmzZtGnt4RERERERERETkRVgHWGfOnMGiRYvw0ksv4ezZs4iLi8PUqVMxbdo0tG3btrGHR0REREREREREFoRlgHX27FksWbIES5cuxZkzZxAbG4v/+7//w7Rp05CSktLYwyMiIiIiIiIiIj+EZYDVpUsXnD17FjExMZg8eTKefPJJtGvXrrGHRUREREREREREAbBJkiQ19iCCzW63w2azwWazwW63+3WszWZDVVVVPY2seejTpw8AID8/v5FHUjdOpxNRUVGorq6Gw+Fo7OEQERERERGRiXD5HkrmwrICCwAkSYIkSXC5XI09FCIiIiIiIiIiqoOwDLAYWhERERERERERhQ//5tcRERERERERERE1MAZYREREREREREQU0hhgERERERERERFRSGOARUREREREREREIY0BFhERERERERERhTQGWEREREREREREFNIYYBERERERERERUUhjgEVERERERERERCGNARYREREREREREYU0BlhERERERERERBTSGGAREREREREREVFIY4BFREREREREREQhjQEWERERERERERGFNAZYREREREREREQU0hhgERERERERERFRSGOARUREREREREREIY0BFhERERERERERhTQGWEREREREREREFNIYYBERERERERERUUhjgEVERERERERERCGNARYREREREREREYU0BlhERERERERERBTSGGAREREREREREVFIY4BFREREREREREQhjQEWERERERERERGFNAZYREREREREREQU0hhgERERERERERFRSGOARUREREREREREIY0BFhERERERERERhTQGWEREREREREREFNIYYBERERERERERUUhjgEVERERERERERCGNARYREREREREREYU0BlhERERERERERBTSGGAREREREREREVFIY4BFREREREREREQhjQEWERERERERERGFNAZYREREREREREQU0hhgERERERERERFRSGOARUREREREREREIY0BFhERERERERERhTQGWEREREREREREFNIYYBERERERERERUUhjgEVERERERERERCGNARYREREREREREYU0BlhERERERERERBTSGGAREREREREREVFIY4BFREREREREREQhjQEWERERERERERGFNAZYREREREREREQU0hhgERERERERERFRSGOARUREREREREREIY0BFhERERERERERhTQGWEREREREREREFNIYYBERERERERERUUhjgEVERERERERERCGNARYREREREREREYU0BlhERERERERERBTSGGAREREREREREVFIY4BFREREREREREQhjQEWERERERERERGFNAZYREREREREREQU0hhgERERERERERFRSGOAVQ++//57PPvssxgxYgQ6deoEm80Gm83m87h33nkH/fv3R0JCAlq3bo2bbroJX331lddjNm3ahJtuugmtW7dGQkIC+vfvj/fee8/rMUePHsV9992HDh06ICYmBj169MDs2bNRWVnp1/MkIiIiIiIiImoINkmSpMYeRLi57bbb8NFHH+m2e3upH330USxduhSxsbG48cYbUVlZif/+97+QJAkrVqzAbbfdpjtm5cqVGDt2LFwuF7KystC2bVv897//RWlpKaZOnYpFixbpjtm3bx8GDhyIU6dOISMjA71798Z3332HAwcOYNCgQfjvf/+L6OjoOj3/Pn36AADy8/PrdJ7G5nQ6ERUVherqajgcjsYeDhEREREREZkIl++hZI4VWPVg4MCBmDVrFv71r3/hxIkTPgOh9evXY+nSpWjTpg22bduG1atX47PPPsPGjRsRERGB++67D6WlpapjTp8+jfvvvx+1tbVYsWIFvvjiC6xYsQK7d+9Gt27dsHjxYnzxxRe6a9177704deoUJk2ahB9//BHLly/Hnj17cPvtt2PTpk1YsGBBEF8JIiIiIiIiIqK6Y4BVD6ZNm4Z58+bhlltuwUUXXeRz/yVLlgAAZs6cie7du7u3Dxw4EOPHj0dpaSmWLVumOubNN9/E2bNnceutt2LEiBHu7e3atcNzzz0HAFi8eLHqmM2bN2PTpk1ISUlx7wMAkZGReO211+BwOPDiiy+ipqbG/ydNRERERERERFRPGGA1soqKCmzYsAEAMGrUKN3j8raPP/5Ytf2TTz4xPebmm29GTEwM1q9fr+prJR9zyy236KrC2rVrh8zMTJSUlODLL7+swzMiIiIiIiIiIgouBliNbM+ePaiqqkJycjI6deqke/yKK64AAGzfvl21fdu2barHlaKiopCRkYHKykrs3bvX0jHerkVERERERERE1JgYYDWyw4cPA4BheAUA8fHxSEpKQklJCc6dOwcAOHv2LM6cOeP1OHn7oUOHLF/L6BgiIiIiIiIiosYW2dgDaO7Onz8PAIiLizPdJz4+HqWlpTh37hxatGjhPsbbcfHx8QDgDr2sXMvoGG/kVR609u/fj/T0dEvnICIiIiIiIiLyhRVYREREREREREQU0liB1cgSEhIAAOXl5ab7lJWVAQBatGihOkY+LjEx0ecxVq5ldIw3+fn5htvNKrOIiIiIiIiIiALBCqxGdvHFFwMAjh49avh4WVkZSktL0apVK3ewlJiYiJYtW3o9Tt7epUsXy9cyOoaIiIiIiIiIqLExwGpkl1xyCaKjo1FUVIRjx47pHt+6dSsAoG/fvqrt/fr1Uz2u5HQ6sWPHDsTExKBHjx6WjvF2LSIiIiIiIiKixsQAq5HFxsbiuuuuAwDk5OToHl+xYgUA4JZbblFtv/nmm1WPK/373/9GZWUlrr/+esTExOiO+fjjj1FVVaU65ueff0ZeXh5atWqFQYMG1eEZEREREREREREFFwOsEDBlyhQAwPz58/HTTz+5t3/99df485//jKSkJDzwwAOqYx588EEkJibio48+wqpVq9zbCwsL8cQTTwAApk6dqjqmf//+GDRoEAoLCzFt2jT39pqaGkyYMAFOpxOTJk2Cw+EI+nMkIiIiIiIiIgqUTZIkqbEHEW4++eQTPP300+77mzdvhiRJuPrqq93bZs2a5a6IAoBHH30US5cuRVxcHG644QZUV1dj3bp1kCQJK1aswG233aa7zsqVKzFmzBhIkoQhQ4agTZs2WL9+PUpLSzFlyhQsXrxYd8xPP/2EgQMHori4GJdeeil69+6NLVu24MCBA7jmmmuwYcMGREdH1+n5y03czZq8NxVOpxNRUVGorq5mqEdERERERBTCwuV7KJnjKoT1oKioCN9++61uu3JbUVGR6rE//elPuOyyy/Dyyy9j3bp1iIqKwvXXX49Zs2bhmmuuMbzOyJEjsXHjRsyfPx/ffPMNqqur0bt3bzzyyCMYN26c4THdu3fHDz/8gKeeegqfffYZPvzwQ1x88cWYNWsWpk+fXufwioiIiIiIiIgo2FiBRUEXLsk3K7CIiIiIiIiahnD5Hkrm2AOLiIiIiIiIiIhCGgMsIiIiIiIiIiIKaQywiIiIiIiIiIgopDHAIiIiIiIiIiKikMYAi4iIiIiIiIiIQhoDLCIiIiIiIiIiCmkMsIiIiIiIiIiIKKQxwCIiIiIiIiIiopDGAIuIiIiIiIiIiEIaAywiIqJ6kp0NdO0KpKV5bl27iu1ERERERGRdZGMPgIiIKFytWQMUFOi3r10LzJjR8OMhIiIiImqqWIFFRERhq7EroCZO9G87EREREREZY4BFRERhS66AOnjQcysoEBVQDWHkSKBPH/W2jAxgxIiGuT4RERERUbhggEVERGGrsSug7HZg9mz1ttmzxXYiIiIiIrKOf4UmIqKwFcwKKO10xFatAIdD/PQ2PVE5BlZfEREREREFhgEWERGFrWBWQGmnI5aWAjU14qe36Yl2O/Daa8BVVwGvvsrqKyIiIiKiQPCv0UREFNaCVQFlddqh0X6ZmcDmzeInERERERH5jwEWERGFtWBVQBlNR4yOVt/nFEEiIiIiovrBAIuIiMJeMCqgjKYjPvyw+j4btBMRERER1Q/+NZuIiHTyDuWh/xv9kXcor7GHElK00xEXLmSDdiIiIiKihsAAi4iIVFySCw998hC2HN+CCZ9OgEtyNfaQQoZ2OmJkJBu0ExERERE1hMjGHgAREYWWlTtXIr8oHwCwo3AHVu1ahVG9RzXyqEKHPB3R7D4REREREQUf/62YiIjcXJILc3PnqrbNzZ3LKiwiIiIiImpUDLCIiMhNWX0lk6uwmoPsbKBrVyAtzXPr2lVsJyIiIiKixsMAi4iI3F7a/JJf25sKq8HUmjVAQQFw8KDnVlAArF3bCIMmIiIiIiI3BlhERBY0l1X5hnUbhrSkNKQmpbpvaUlpGJo+tLGHVidWg6mJE42PN9tOAivXiIiIiKi+2SRJkhp7EBRe+lxYUz4/P9/HnqHN6XQiKioK1dXVcDgcjT0cakQuyYW+r/VFflE+MlIysG38NthtzP9DVXY2sGwZoPy/W3k5UFio3zcnBxil6E/vcgF9+wLKP74yMoBt27jCoDdZWUCeQbablQXk5jb8eIiIiKj5CZfvoWSOfx0nIvLBaFU+Cl1G1VaFhUBcnHq/jAxgxAj1NrsdmD1bvW32bIZXvrByjYiIiIjqG/9KTkTkBVfla3rMQpPx49X3zYKpkSOBC/+AZxhykZ7yNZPxtSMiIiKiYGKARUTkRXNflS9YGrJHklmYsnChtWDKbgdeew246irg1Vebd/WV1feNlWtEREREVN/4V0siIi/CdVW+hqAMP55+uuFW9zMLUyIjrQdTmZnA5s3iZ3Pmz6qMrFwjIiIiovoU2dgDICIKZcO6DcPRs0chwdMR3AZbk1+VryHI4Yc39dUjSQ5T8vPVYYocTJE1EycaN2c3et/kyrWpU4HFi1l9RURERETBxVUIKejCZfUHrkJIVDc5OcCYMeaPB7q6n9EqgzYb8MADwIwZnm15eZ4wpblXUgWKqzISERFRUxEu30PJHP/6SURE9cKoF5VSoD2SrE5r4zTAugtmb6uG7INGREREROGHARYRNWl5h/LQ/43+yDtkMM8pjK/dFBiFH507i5916ZFkNu3QaHtzDU2C+byD1dvKn35ajaG5flaIiIiImgoGWETUZLkkFx765CFsOb4FEz6dAJfkcj9W3+GSt2uThzb8eP/9uq/uZ7bKoFGwEuqhSX0J5vMO1qqM/gSPjaG5flaIiIiImgoGWETUZK3cuRL5RWKO+47CHVi1axWAhgmXzK5NatrwY/Bg4NZbgXHjAq908WdaW6iHJvUl2M87GNMx/QkeG0Nz/awQERERNRVs4k5BFy7N89jEPbS5JBf6vtbXHSIBQEZKBraN34aVO1dizApP9/Cc0TkY1XtUg1zbbuO/C/iSlWW8sl1WFpCba+0cyubi3pqKN9cm5KH6vLWN/XNygFHB+9Wsk1B9zYiIiMiacPkeSub4VzIiapKUFVCyHYU7sGLnCkxbP021fW7uXLgkV9CmFZpdm1VY1gSj0sXqtLZgNiFvSkLheRv1lJo2DUhJEY+HUvUVEBqvGRERERGZYwUWBV24JN+swAptWW9nIe+wPojq2bYndp/ardu+fNRyzMudh/yi/DpXS5ldu1+7foiKiMLiGxcjswuXvjPT0JUuVqu1wk1jP2+zSrt+/YCoKGDx4tBbIbKxXzMiIiIKXLh8DyVz/GsZEYUMfyqkhnUbhrSkNKQmpbpvaUlpKC4vNtx/zhdz6tyzSh5fz7Y9Da994twJNnW3oKErXYLVhLypaeznbVZRN3Nm3ftp1ZfGfs2IiIiIyBwrsCjowiX5ZgVWw1L2lQq0QsoludB+UXsUlhe6tznsDnRK7ISy6jLVdrNr5B3Kw+///XtAAv5yy1/clVS+xpeTn1OvfbcaQ96hPExdO9Wwoiw7G1i2DFD+H8RmAx54AJgxw/e5WenS8Or6nvmLPaWIiIioIYXL91Ayx79CElFICMaqfit3rlSFVADgdDlxe8/bdduNriGvXrj71G7sLt6Nhz55yF1J5W18LsmFublzVeeS+241Vb5WclyzBigoAA4e9NwKCoC1a62dn5UuDa+u75m/2FOKiIiIiIKJf40kokYXrADopc0vGW5/84c3Le2vbc6eX5SPVbtW+RxfODZ19xUoBqMRe2Zm6E4ls8qoUXnXrmJ7qI0hGO+Zv0aOBC78Y2jINW0nIiIioqaFARYRNbpAAyBtzyyzvlhXd7zacPvQ9KHucxmFVIDonZWzM8fr+MyCM7Pt/gjWyon+MHotHn7yOLp2ldwByeOPA9qZtYEGFKEQAgWqoaua6jIGZZgkq+9QiZV2RERERBQskY09ACIibwGQWR8peYpbflE+Jnw6AdvGb8P0zOmYnjnd67WUfZ0AoP8b/bH4xsU4ef6kLqQCRBXW3C/0wZZyfMO6DcPRs0chwdNcyAabKiALhNFzDHTlRH8YBYqF2y4DDtu8Hmc0PcxK3yU5gNFau7Z+ejMF08SJxivt1WdVU6BjkKf0jfG0amuQKX1ypR0RERERUV0wwCKiRhdIAGQ0xc0s7JJDq+dveB4Pf/ow8ovy8dAnDwGAOxxqFdPK9FoVNRVIS0ozHZ+V4CwQ/jzHYDIMFK9+CTicpdvcuTNw5Ih5JY+VcCoUQqBAyVVNyl6hKSnAE0+IKjWZWbN0fxqrm+173336MZi9H8rxckofERERETUlXIWQgi5cVn/gKoTB5W1FO38pVwSUma0qqNy3c2JnHDl7xPCcd2bciX/t+RfKnGXubXabHS2jW+Kxax4LekDl6/Xw5zkG43pKz+Q9gze3vukO7CprKnG6rBTxy/ah5HBHz3gygJdfFkHN4sXGvaxyctQVP8rtoy5kcU19tTrtc+zVC9i1S79fVhaQm6velpoKHDqk3zc1VR/8ZWUZB31ZWcAjj6jHoHx9tfLygKlTzd8zIiIioqYoXL6Hkrkm8NWAiJo6Xyva+cufnlnKfc3CKwDY/vN2pCalqrb1Tu6NU0+cCii88ta7ysrrEczG8P6+/tMzp+PA5AMomFyA/ZP2o01sG1RLlUi4cYlqv9mzgcGDvTdit9J3qSmtVmfUr+uJJ0TVFSCem/a5yIwqyuLijPeNjbV2vLzdn2bp4dA8n4iIiIianxD8ekBE4cbXinb+sto03awxu5H8ovwGC4ysvB7+Nob3FpjV5fVXBYAdXkDnbmcAWJ9+ZjWc8ieAacym70YN0w8eBNq39zQqHz3aerN0s7Brzhz9Nm9hIJulExEREVG4419xiaheGYVIc3Pn1qkKy2y1QW3PLKMqJn/5s5KgHCLNz52vCoyyN2a7wyWrr4fV5wh4D8zq8vrrjrVLiPzNJFx1leRXSGIlnPIngGnMlf/MqqBmzvRUNflTUTZ6tOgjptS5s/H0P1/nZWUVEREREYUz9sCioAuXucfsgRUcOfk5GLNC3wQpZ3SOXw3J5R5O9/S7B+9te89nL6e8Q3m46e834Xz1ea/ntdvs6JzYGWerzgIAWsa0dD9WVVMFu82Of4z8h8++UcqeVdER0aiqrXI/Jt/PSMnAzMyZuGPlHbrj/X09VMdqXmPluery+gfrvQOC23fJSl+t+mK1X5dyP1/9vJYvB+64Q33f6Pn5e14iIiKi5iRcvoeSOQZYFHTh8gcHA6zg6Pd6P2z/ebtue1aXLOTem2twhJ5ROOStoXnuwVz8+m+/RkVNBWywITE6EWeqzpie3yiQUV4zIyUDL//6ZTy+7nHTAM0s7NHq2bYndp/ardvuz+thNk6Z8rXJejsLeYf10wqzumThxmO5hqvapacD+/cDx8+dQFVN5YVHJOCKZUDWMwGPNRDalfdKS4Hz50WQ41IUkdntwMUXm6/gF0zaAM0sOLMa2rlcQLduooosLQ3Yt897KMUm7ERERER64fI9lMxFNvYAiCh8uSQXTp47CQBw2B3omChWsLPBZjgVzoxyKqBc2SRPzft478eqMMkluXD3h3ejoqYCACBBcv+3mfs/uh/t4tupAilt36gxOWNQWF6I745/BwkSJnw6wR0S+dNrq6SiBKktU1FZW4nTFafROrY1YiNj/Xo9lLw1ex/VexSGdRuGo2ePulcUBDyv/2dv6Ve6A4DiYuDsWQBor9oefeg36JD0j4DHGgh5uqAvLpeYSgiIqYT1EWDJYZrLBTgcgNMpfhqtOAh4pvT5YrcD777rCaV8VVRZPa832mAQaJjwj4iIiIgoUKzAoqALl+SbFVh1521qm1VGFUYyo2qs5fnLcccK/RQ9JbvNDrvNjgRHAsqcZXC6nEhLSkOb2DZYMnQJBl08yPSaqud34fmYVV/FRsYahmfLRy3HvNx57uous0oyK7xVWPmqkjKbijdlCrBkifH+9T1Fz+iaZtPpvB1TH+PMyhLVT0bbc/0oSAuF8ChYz4WIiIgoVITL91Ayx84ZRFQvgtW83VsjdmU11qpdq+CSXHh87eM+z9k7uTeqZlbhL7f8BU6XEwBQUFqA7058hwmfTkBOfo6l5u/3fHgPcg/mmjZ6V/bBUprzxZygrcroT7N3LbNV7RYutL6KXn0zGmN0tPn+9TlOswbuZtvNNGYTelmwnktDa8wVKImIiIiocbECi4IuXJJvVmDVTbAagJtVGGllpGRgZtZMn9VXsjmD52DhpoWGFVJmfaqMdE7sjKHpQ/HOtndQ46rRPZ4Sl4K4qDjPBgkorylHYVmhaux1qcKqC7N+TmbbG6N6SDsWswox5TiDRft8jx0TUwdlgTRSb8wm9DKrzehDDSvHiIiIyEy4fA8lcwywKOjC5Q8OBlh1YxY89WvXT1QmScBfbvmLu++UvMqgtjn6M3nP4M2tb6K0shTnqs/BJblMq7h6te2FXadMGhJpREVEobq22vCxdvHtEBsZC9iAo2eOokbSB1NKnRM748jZI4aPaafyBXNlv2AwW9XObHtjBAjasfzwA3DZZeK+XJ0V7FX55ODq+HGgyriQDkBgoVOohEdWm9GHklAI/4iIiCg0hcv3UDIXwv/OSkRNmdHUttSWqThx/gR2n9qN3cW78dAnD7kDqYc+eQhbjm/BhE8nqAKq6ZnTcWDyAZyedhpVM6vQq20v02tW1FQgLSkNSTFJPsdnFl4BwM9lP+P+y+9HweQCJMX6PpcyvIq0R+KihItMp/KZTTc0217f7HbgtdeAq64CXn3VE6CYbW+MqWfasURGeu6/9prxOLX8nXomT/PzFl7J0xX9PbfdDsyerd42e3bDVz4pp2fWx9TL+pjuZzbttTGmtxIRERFRw2IFFgVduCTfrMAKPqPqo5zROdhZuBOzc2erto3qPUpXlWVWvZQcl4yEqAQ8eMWDmJ453XQ/f8Q54nDmyTPouKSjarqfFX2S+2D7Q9sNpwTKFWXaVQHlsYe6UKkeUrIyrdGsciwmBrjoIv1xPXqYN49PSwPatBHTGDMzA6tKM6twC+Q5AoFP68zL86x+mJnpfV9f49Beq76q9Zpi5RgRERHVv3D5HkrmGGBR0IXLHxwMsILLbDXB3m17Y3/JflXD84yUDPzwhx9w2euXuVfqe/nXL2P4P4bjfPV53bmV0/S8rVrojR12uKCemjim9xh8sPMDv84jq88pgWbTLRtKsAOEuvbVMgtKoqOB9u3Ff5eXA4UWc8isLODzz/VBnUz7fAOd1mYlPPI1lTErS7xuDTWt059Qqr6m+/kb/hEREVHzEC7fQ8kc/8pHRAHLO5SH/m/0R94h303WzVYT3Hlqp261vh2FOzBt3TTVSn13f3g3zlefh8Pu8LrinrdVC73RhlcAkLMzx3DfSHukz/PJKy768xopmR3nbbqlVXWd2hXsqWd1XZXPbPpiVZXnfIWFQFyc+vHOnc3PZzTNDxDPd9cu9ev3xBP6AMXhENu9vaaZmcDmzd4rn3xNZZw4sWGndfpzrfqa7mc2vZWIiIiIwhv/2kdEAfE3SPG3x9Pr37+uui/3mXK6nLj/svuRHJeM9257DwcmH1BNvfN2HRtsfo1BOc1PKd4Rr7pvNFVwR+EOrNi5IqCwydtrqwzodhTuwKpdq6w+HbdAAyM5+EpPB4qLgago8XPBAr+HoArRdpss+Nihg7WgzSgoMTJ+vPr+okXeAxbledPSPIHJunX618+leWudTv9CODPeQih5rLt3i8BMyeEQQVuw+RNK1WevLyvhHxERERGFFwZYRBQQf4OUji06Wj53C0cLlDvLTR/PzsvGluNbMG71OFz1l6tUVUo92/b0O6jy15mqM6r7ZsHUnC/mBBQ2mb22LsmFublzVfvOzZ2L+fNdflVUBVqxowy+Tp4EqquBEycCC2mU5yoq0j+ekQEcO2YtaDMKSjp10p9v4UJP+JKSAjz5pH5aYUaGcSP7d9/1BCb+VDbVtQrKWzgnh0Hr1onATMnpBNavr9u1jfgbStV3o3giIiIiaj4YYBGR38yCFG8VRsfOHbN8/iqXl6XfAPeUw4LSAnx34juMWz3OvZrhV0e+cldORdoi0aVlF6QmpSIlLsW0osqX5Lhk95TF6IhoS8c47A6cKj+l2ubrNQK8v7ZG0yN3FO7A31cXGwY9c+YArVvrg63duwOb2hXMqWq+jpk9O/DpahkZorpKez7l6oUXXSReI214dvy4+r5RpY9ZFVJqqn5bMKbLmU1llM/d0CtD+hNKcbofEREREQUL/ypJRH4zC1K8VRgN6zYMaUlpSI5L9nl+Z63T5z5KBaUFWLFzhW5cNVINjp87jqkDp+KStpf4dU6lDgkd3FMWnxr8FNKS0uCwe2/s73Q5UVSuTkesVGF5e21Np0de/bLh5poaoKREH2y99VZgU7uC2dPI6FzR0epzWrme2bTGvXuNQxY5kJo503hcVkIfux249FL1tp9/Fo3ilYI1XU47lfEXv1CHQfXVa8pIdjbQrZvntT51Stz3t9dXXfuwEREREVHzwwCLiPxmFqSYbc87lIfVu1fj3dveRc+2PX2eP5BKqd+u+C3u+vAu3Xany4nH1j6GG7regLSkNLSLb+f3uQ+eOejuR/XkL5/EwusXwunyL2ST+eoF5u21lUNAbRP7346JNm1IbiQ2NrCpXcHsaWR0rhkz1JU6Vq5nNq1x/Xp15c+CBfrG69q+Uf6EPsc0BYVFRepG8cEMkLRTGbdsUYdB9dFrKjtbVO85HOrbnDni9ZZf65MnA+v1VdfG/URERETU/DDAIiK/KYOUixIuQlREFNontFetBijTNiQfmj7UfayvKiZ/1KIW1bXVho9V1VahtKoU+ybtgyPC/2vKPa98VkKZkKcgyismeluZ0CykGpo+FNMzp+PA5AMomFzgvh2YfAAzB0/H88/rr2sWYFT98o949buX8XOr1XBEuXDqlKhgslIFE8yeRtpzzZjhfbqe0fW8TZ9TVv4YBSbavlH+hD5m142KqltzezPyc9m40bhyac+e4L0v2dnA00+L6r2aGv3NiL/TFRt62mN9YBUZERERUcOySZIUWFMYIhN9LnyLys/P97FnaHM6nYiKikJ1dTUc2lKNZiTvUB5+//HvARvwl+F/QWaXTPf2qWunoqisCAfPHERGSga2jd+mW5EvJz8HY1aM8dwfnYNRvUfpttc3G2y4u+/deG/7e34dF2GLQK1U676fkZKBsX3G4q0f3sL56vO6aYJGlK+NS3Kh72t9kV+Ub/qaBcLlEj2Yjhzxvp8tsgrS9FhEO6JQ9cZa4HCWbp+sLCA31/wceXnA1KnA4sV1XwXOyrm87eNyAX37Aso/bjIygG3b1GFUTg4wxuDj1qkTcPSo8THeGF1XKzVVhGbBlJUlXg+j7fPnB+d9MbuGTH7NZP6+doD19y2UeXsvvP3+EBERUf0Il++hZK6J/DWRiBqDS3Jh/L/HY3fxbuw+tRsTPp3gbpYuV1UdPHMQgHF/J5fkwhPrnlBtm5s7F18c/ALjVo9rqKcBQExL9De8AqAKrwDxPHu27Yl9k/YZ9vOKsEXotilfG39Xb7TKbgcef34bbI5KADCdUij94mXALolG+FfLlWTqf8fwVQVj1NPICqOKlXHjgFtv9X4ub9ezOn3OrE/UX/8aWINxs+bqSrGx1s9nldWKs/q4BmDeIN/f0Kk+pj02tHCoIiMiIiJqSliBRUEXLsk3K7D01VOAqKCSJMmwekpbUbR8x3LcsfIO3X5tYtuguKJYtz05LhnF5cVwwftKfQ0h0h4JO+yodumnJWZ1ycIjVz3iVwVZVpcsfD7uc3f1lSxYVVjuyq5lk2Dbfi/atXWguNimniYXUQ1MjwUiLry+Lhvw2nagKMMznnqsgqmvihVlNU9KChAfDyj/z2azAQ88APTooa7CyskBRo0KznWNLF9uXPXlTXY2sGyZ8fhnzGiYyiVvzysnR0xPlB+vy7WV12lq1VdAeFSRERERhZNw+R5K5vhXLCIy5JJcmPPFHN32OV/MMdwO6CuK5uQa72cUXgFAr+ReGNB5gL9DrRc1rhrc3ut2w35Ul7S5BPf/636vxzvsDl0PK1+rN5r1xvLWM0vmPvepnpBqonDypE3X4wmZT3vCKwCwS8CQuapd6qsKJjsb2LrV+LEOHep23rZtgd27xf3CQuPm4PPni3387RPlrc+Rsrl6Sor6uM6dAwvHfDU3b4jKJbPqMvk1Uz5vfyvXtNcJxnkaSzhUkRERERE1JazAoqALl+Q73Cuw5B5Wi29c7O5rpRRoj6qsLlnIvTcXLsmF9ovbo7Cs0P2Yw+6AJEmokWpU2zq06AC7zY5fpf0Kb/3wVkhUYAFAr7a9sPPhnaptyh5WdptdVTklT6+Uyf2+ZFlvZyHvsD6E0lZn+dszS7kP8keJMhlIAGzufaJa/4zqfi8BP9yv2g5IQHU8UN4uaNUjRlVEJ04AVVXG+wdagSU3Gzc7r9F1/O0TZbVqbPly4I471Pf9rb4CzHt1KavF6lq55KvKS3uNqCgR2v3lL3WfnhhumnoVGRERUTgJl++hZI5/zSJqhrQrAypDF5m/K+1FR0S7K40AURGkDK8AwOlyqsIreduiGxdh36R9+GjPRyETXgGiUkz72iirqFySCxG2CLww9AVUzaxCr7a9VPvOzZ2rOn5Yt2Fotfl5RL50CJEvHnbffpy+Gr+bnG/YG0vbMyt7Y7auGmt+7nxPZVevlUDyDihDqthY4J7ZaxHxv98DpV2B0jTFrSsiImzo2PN40KpgjKqIvIVM/vYMkqui/Amv5Ov42yfKbGy7dqlXnBs9WlRnAeKnHDZpK7hatQIcDvHT6P7jj4v7StpqsbpWLvmq8tJeY/168XzNVkBszqvuNfUqMiIiIqKmhBVYFHThknyHcwWWtrpq3pB5mDV4lmqfZ/KewTN5z6DMWebeZrfZER0RDbvNrtqeEpeCyQMmY3rmdPe2vq/1xY+FP1oaT+bFmXj4qocN+2U1NmUVlarSSSE6Ihpv3/o2frvqt7rjta+tWUVPXLctKL+rv/t+RkoGfvjDD7js9ctU14uOiEZVbZW7GgsAWixogXJnuedk7iqsC88hBxgx0oXY9gWo/jldd+1evYCdO3WbA2ZWRWTE4QBmzRI3q3ytkmck0OoYX32ulJVYRqslBjJWLbn6ykrllNXz+aryMpKaChw6ZLw92KstEhEREfkrXL6Hkjn+WyFRM+OSXJibq+57lJ2XjRqXujLqyV8+idSkVNW23sm9cfaPZ3Xb46PisXr3auQdynP3a9p/er/lMZVVl+GxdY/59TyCKTkuGTbVtDqP+Rvnu//bqIcVAFTVVmHq2qmGxz+76Vm4JJf7dbn+jl2G+5VfvlB1f0fhDkxbN013varaKvfj2Ruz0eOlHqrwKjkuGV0Gfg/HRXsAeKp3Vu5cierMPxpee84cw81+k6uNnnhCX0VkxukEnnnGvyqeQFZ5C7Q3ka/VBpVjMaruCnRFOnkVSWX1lVnl1NNP+1cJZbYio6+eYHFxxtvrY7VFIiIiIiItBlhEzYxRCFNVW4Vp66f53M8sVCkoLcCW41swbvU4jP/3eGw5vgXlNeWwauuJrTh69qifzyR4XJILEjxlLXab3R1onTh/wj0N0Nu0yp/P/2y4vdxZjhU7V7inbL78n3VwONSFr7YIJ3Cqp+7YN3940+u4s/Oysb9EHRS2S2iHA4/uw38/uMQ9rQm2C6Fl7xVA4mHV/oE2GzeiDFh0DeS9qKxUT1/zxSiA0UpNBWJixH9bbdju7Xq9e+u3Z2SIxvDeptVZGWtEhPq+wwHU1AAdO6qnpZmFYVVV4nWfM8fa9L5Am4+bBXmnThlPhwx0iqG3xvlERERE1HwxwAoRQ4YMgc1mM7199tlnhse988476N+/PxISEtC6dWvcdNNN+Oqrr7xea9OmTbjpppvQunVrJCQkoH///njvvffq42lRCDILYV7/7nVVvyaz/byFKgWlBdh5KoC5aMbFTw1GuyqiMtAqLCt096Ma1m0Y0pLSkBiVqDuHt95dj619zB36FW2/DE6n+glLtQ7EHL5Ft9rh1R2vdq+CmByXrDuvXI2lJPfPUlYDucNIuwTcqK50W7TIemWSr2DBLGBp08b3uf2pVPJVFQWo+27t2iVWKgw0ALHbgddfB9I1sy9nzxbBm7+rBmpddJH6vtMpmt6np6uruXyFYTU1xtVZvoI1OeDz9f6OHu2pDFMqKhLXKy0VYygtNR6D1RDKSo8uIiIiImp+GGCFmJEjR2LcuHG6W8eOHXX7Pvroo7jvvvuwY8cOXH/99ejfvz/WrVuHrKwsrF692vD8K1euxODBg/HZZ5+hb9++GDZsGH766SeMGzcOjz3WeFO4qOEM6zYMrWJa6baXO8vdQQ0A9GzbEw67AxG2CETaI3FRwkXuUKV9QntERUQZniccyc3Yp2dOx4HJB/wO3I6cPeK5c7UcDKqrsFqcvRqVi3bhxPwvcf3Rz3Fg8gGsvXstDkw+gPduew8VNRWWr6cNH1X3e68Akg4AAGKSj/tVfeUrWDAKWGJjRW8leXunTvrzOhxi2qFZuGEUrEybBqSkeB+v3CuqthYoKalbAJKZCezdqw99zIK3Dh08Y/Y2pTIjA3j+eePHtOe2EoZpVVWZB2va5uO+3l+73XysVsZgNYQye00DnY5JREREROGBAVaIWbRoEd555x3d7dJLL1Xtt379eixduhRt2rTBtm3bsHr1anz22WfYuHEjIiIicN9996G0tFR1zOnTp3H//fejtrYWK1aswBdffIEVK1Zg9+7d6NatGxYvXowvvvii4Z4sNQi595K8at2Tv3zSsHIH8AQdLsmFdfvXwelyolaqRY2rBjERMXj71rdRWlmK6IhoVNdW42zV2QZ7Ho1JuSogAFzd8WpE2iPdN78YrBIIiCqWk0djUHWqI/6++pS7Gk5eMfJ89Xk47A7TaixA9L9SrgQpkyvHUpNSkdq6Cy66+0lEXbwNdz/1X7+qr/bsMX5MDhaMApaEBBH07N4tpspp/lgCICqOvIUbZsFKYaF/fa3qGoAYhT5m/aSOHlWP2WhKZXq6OM/YsZ4VDJXnMJr2aFaF1amT76mKgPeeXVaCI+Vqi6mp+mtGR1u/vplAe3QRERERUXhjgNVELVmyBAAwc+ZMdO/e3b194MCBGD9+PEpLS7Fs2TLVMW+++SbOnj2LW2+9FSMU3wTatWuH5557DgCwePHiBhg9NRQ5/NhyfAsmfDoBLsmFlTtX6pp+y1PWhqYPRd6hPPR4qQcOnjmoOtfBMwdx14d3YcvxLe7HaqXaBnw2jWv+xvnuIHDt3Wux4Z4NuPyiy7Hhng3Ivi4baUlpsNu8/JG6cTrwp/3Ai/uBMm3pkKT6WX75s+7ATNmLzOly4vkbnkfPtvp+WQDQK7kXDkw+oFoNEoC7cqxgcgEKJhfgxIsfoOpQP/zlkbstP/81a0RgpBUXpw4WRo5UN/suKhKhVW2tuJ0/b36NQCpvXOYzN1X69PEvAJGrvmJjxUp/8m3IEOCHH4B588R+CxaI56hUWGhcaQZ4tmdkiIquzEwRhC1U9/A37Uklh2ja6YyLF+vDQ+0YfIVAVoIjux14910R4r33nv6aDz9sfn6rIVSgPbqIiIiIKLzxr4NNUEVFBTZs2AAAGGUw/0fe9vHHH6u2f/LJJ6bH3HzzzYiJicH69etRWVkZ7CFTI1GGHzsKd2DFzhW6FQjbJbTD/kn7cWDyAQzqPAg3/vVGXWNwWWM2Wm9sJ86dcAeBNa4aVTD45C+fxMLrF6p6iMnuzLgTaUlpiD54K1DaFShNA8o9AZbNJsFTjWUDUn4Eeq3C3Ny5qHHV6N6vublzMTR9qKeiStEzS1t5FUxmIVJkpAhT5P5GdruY3ucvmw24804x1U6+tW4tzjlypHHvJX/MmeNfr6/580UFlfaPQ5dL9Hlav16M74039MFeYSFw7JhxRdSJE+JndLR6PEY9qbRj6tpVNEi/7jrg0CHPY5GRIgzTnmPRIvU5fIVAVoMjZeWW9poLF3rua98zf0IoX68HERERETU/NkmSJN+7UX0bMmQIcnNzMXPmTBQXF8Nut6NHjx647bbbcPHFF6v2/d///ofLL78cycnJKDQoiSgrK0NCQgJatWqF06dPu7cnJSXhzJkzyM/PR2+DJbWuuuoqfPfdd9i2bRv69u0b8HPpc+FbR35+vo89Q5vT6URUVBSqq6vhMGtgE8JyD+bi13/7tap3UufEzup+TBfMGzIPM7JmIPVPqYaPk9qUAVOw5Jsl7vvzhszDc189h/PV+vKirC5ZyL03F1OWfI0Xpg6EqLKyuX/2yPoBezde7jlg9Cigz0r1dTZOB7Y+ADnoSo5PQUJUPB54AJgxI/DnkZ0NLFvm6RUFiCApPR3Yv1+9HQDKy42rsGSpqeJ4lws4fty/lQjNZGUBubnA8uXAHXcY7yMHHWZ/5PTuDfz4o/XwJCsLyMuztm+vXqJJvFZOjnj9xowxPq5lS/10yrw8YOpUUU2lbN5uZUyRF2aySpKodIuIABITRRBYWChCoG3bfL8GLhfQt694La0eI4+7Xz/gv/8FKiqA06dFwFdcLD4HVs9ldF6j14OIiIhIK1y+h5I5P5u3UH2bP3++6v5jjz2GWbNmYdasWe5thw8fBgB0MpmjEh8fj6SkJJSUlODcuXNo0aIFzp49izNnzng9rlOnTvjuu+9w6NChOgVY1Phckgt3fXiXrvG3WTj17KZn0b1Nd4ZXFr2y5RXV/ey8bMO+Yg67Azd2vREAsKXlk0DyK0BRxoVHRbXV4V9lAbu+FtsvVF/J3Cs+7hsqqrcuKCoFiiB6RtUlwJJ7S2kVFwNnDdqb+cpxY2JErysjrVuLUMOI3W4+FbBDB/Fz9Gjg8ceBIwYf0TlzgHbtgN//Xoz7+HH18a+/7glOzEI7ZRg4caL1AGvOHDGdUPn3JIdDjBUQUxArDPrvP/CAfptc2WTE15hqatT35cb1/foBXbqIEMhKeCRPUZSDIyvHyOPOylJ/nk6eFD9btPD0DPOHt9eDiIiIiJofTiEMEVlZWXj//fexf/9+lJeXY8+ePcjOzkZkZCSeeuopLF261L3v+QtNZOKUjWY04uPjAQDnzp1THePtOO0xvvTp08fwtn+/8fQzajgrd640ne5nM1hCr9xZjkc+faS+hxU2tGGVWVN8p8uJS9peAgD4dY+hSBz6J9Xjcdc/j0rpPDD8IaDDZuDmCYBdcjdj79+hPxx2h8HKheJnXZuSmx3/4IPG251OT38rbbPujAwR5hjp3Bl4+WXzcXjrY/X11yL8io5WB1PK644YIcKOXbtEwKWcenbkiLp6x9dKe4AI4awUXfbpA4wapZ9253R6zt2tmwjIlKKj9T2vfBk50nzVxZYtzY+bOVPdqN0KbXN3q8w+T2+9xQoqIiIiIqo7BlghYt68ebjrrrvQtWtXxMbGokePHpg+fTpWr14NAJgzZw4qjP4Zn0jDJbl0fZMcdgcuSrgIkfZISDCeNVxcUWz5GslxyYiwRdRpnI0pOS4ZSTFJ3puu+0Nu0P6nA4rbfmDjdPfKjk/+8kl0uvrbCysQAkj5EZJcbdXlS+D3V4uf8DRj//2Vv4fT5TRYudAWlL5AZk27Fy40b0L+5JNAx46iskipsBD46Sf9+WJjgfffFyvtpaZ6tqel6RuRG4mLE5VENTWiqkhJruw5d+4MNm3ahDfeeAMzZvwR7dvPQ2LiblRU3If09DR06NABXbp0Qffu3VFQMOXC0eow8IYbdrv/jF23ztr0R7mv1siR5q/XU08Bjz6q3vbww54pf1bZ7UCbNsaPdeggpklqBbt3lNyHKy3Nc5N7nwFcPZCIiIiI6henEIa4G2+8Eb/4xS/w3Xff4dtvv8WQIUOQkJAAACgvLzc9rqysDADQokULAHAfIx+XmJjo8xhfzOYW97GyljvVG2XjdpnT5YTD7kCNq8bkKP+0jmmNovIi3zuGqPPV5/Gf3/0HmV0y0fe1vrrXy2+aKX6ymEO/wdB0Udm4cudK7CzeIaqt1iwGhk5FRW0ZImwRqtUcHXYHbuh6gzqItEvAkLmisdIFgazKZjR9TvvHyM8/A927A1UGRWUZGWKa3bp1+ulshYVi++zZ6r5PLVoA994r+j3JxZ12u5hWFxsrKp3MwqI+fYBZs8x7X507NwpZWStNnu1sw2mQwJ8ATAPQ7sJ9G4BqzJoVhVmz5iMiYiHi4sYBWAZPvzLjscnBjN0O/PWvwK9/rZ4uKIc3t90mgraqqsCqr9zPaLbxazFnjqjy0vbbCvbKfWZTTuWprHITeOU4uHogEREREQUL/1rZBHTv3h0AcOLC8lVyU/ejR42niJWVlaG0tBStWrVyh1GJiYloeWGeidlx8vYuXboEb/DU4OSKHy1lf6tIW92y659O/lSn4xuFIrSpqKnA3R/ejZz8nLqHV4DpFL/pUxMxPXM6AMX7oqm2UoZXgAgbe7btqQ8i3VVYgVe1GE2fKyz0TAsEgKIisb3IIJ+UwwizqWK7dgFPPOGZfhcXJ85/8KAIsOQKKpdL9EcqKDCfFgcABw/ei9/+1gFgh8GjPwJYpdkWASAaQALs9jaIjOyImJhuiIvrg9jYSxAdnQ6HozOAM5rjogB0BXAjamtrce7c2xeuaRxexcaKPlHKYGbwYODdd9X7ya9XZKRYETA+Xvz0t/pKNnq0qHpSSksT0xhHjlRXYdVH5ZPZ+67cztUDiYiIiKi+sAKrCSgpKQHg6VF1ySWXIDo6GkVFRTh27Bg6duyo2n/r1q0AoGvE3q9fP2zcuBFbt27VrULodDqxY8cOxMTEoEePHvX1VKgBDOs2DEfPHnVPFZQkCcfPHRdT0S6Ij4rHmSrPl/i2cW1xqvyU5Wu4HF6aFoUqTRZx5OwRzMmdE5RTt71yI07/5xRc59t6LmavxryZLWArdmHmTLvufQGAE+dOGPbPemnzS5AkSbf6IGqiYYusRnR0FLp181RSlZYC588DCQlAUtKFEWgakwPmjcCffFKEL0bt66KigOpqdRghhxTaIsyiIk/w1aIF8Nhj+v5QWhMnHsL06e3hckVpHvkRZWXvQYSBcwHkqB7t0GETund/AW3apKJNm65ISemK6Oh47xeTz/yjqpjN7YorIlBS8lv8/PM2lJcvAvCOZg9RkVVb+1u8/XYMfvGLVxCrmEupfF0yMkQvra5dPe9TcjKwZAlw5oz6fbHSWB4QYdjCheoKp+ee8wRpr78uGtkDgTVN98XofdeGVIE0gSciIiIissImSdqF0imUFBUVIS0tDWVlZThy5Ih7BcGbbroJ//nPf/DCCy/gUU2DlcmTJ+PFF1/EokWLMHXqVPf25557DtOmTcOtt97q7q0l+/DDDzFixAgMHz4cH3/8cZ3GHC7LlzqdTkRFRaG6uhoOKx2dQ0zeoTxMXTsVw3sMx+wvvKcIUfYoVLuqvZ9Qnk1lPquq3sTFxqGyqhIub92+A5ASn4IzFWdQ5TJuwm5VVpcsFC7MNVyB76I+e3BixyWGxz2T9wze3PomKmoqcLriNFrHtkZsZCwevEJ0UZ937/WoOtBfd1x0tPEUP924soDcXM99lwvo21cfQGzbJv7b6LGXXxYr6i1erG7EnZOjn7KmlJMjgo1WrYxXNBR+BNAPwAwATyu274PdPgXx8UfRtm0fpKcPwQ8/jENxsfg3l+Rk0Ucq0HDE5QL+9CcR/MlSUoAJEzzndLmAV15xoahIe5FqAMcu/LeE6OijiIwcgKoqEcBJkqg0a9ECiIhQX0NJW4WlXUUQED3DbDZ1sAWIaZ+FheL9GTMGePttsY8cZAKeMFMZhFkNyrzRvu85OaICjIiIiKixhcv3UDLHACsEfPXVVygsLMQtt9yCiAhPY+yDBw/irrvuwqZNm/Cb3/wGH330kfux9evX44YbbkCbNm3w9ddfu6cZfv3117j22msRGxuLgoICJMnlGABOnz6NtLQ0nD17FitXrsSIC/9sXlhYiEGDBmHfvn34/PPPMWTIkDo9n3D5gyPUAyw5oFp842JkdlEv8eWSXO7eTtER0aar5FkVWRWJmujg9M8KRHR0NKpMEhsbbKaN6a34VdqvkHc4D61jW6PWVet3by+H3YGnBj+F7idmavoTXUj6Ro9G1T/+hqgIbYWRoHyvMlIysG38NndzebOQqGNH4Ngx/XYto3DBWwChfSwlRT29UBl2KMMwbaAmh2J2O9CrFwyDPWEUgJUA4mCz/Q+S1B2tW1dh0qRoXTh18CDwr3+J//7Nb9QN4b3JzQW2btWHNh07Ajt2qLfJqwVKkgifYmJEWOQ9N62FmLqoFxur7onlr169xLRMrX79RGXc4sXivTCqqlOSg8ysLON9tUGnzCzwKivzBGjy+1zfghG+ERERUXgLl++hZI7F/SFg7969uP3229GpUyfcfPPN+N3vfodf/vKX6NWrFzZt2oQ+ffrgjTfeUB1z/fXXY/LkySguLsZll12G2267DTfddBOysrJQU1ODt99+WxVeAUDr1q3x1ltvwW63Y9SoUbjuuuswevRoXHLJJdi3bx+mTJlS5/CKGoZLcuGhTx7CluNbMOHTCXBJ6m/Yyv5JcnjlsDuQmpSK6Iho0/PGRMYYbq+JbLzwCoBpeAWgTuEVAGwo2IDq2mq0jWuLnm17Gu4THRENh904xJR7Vl3UPw8RrY8oHrEBKT8CvVZi5AcjTa+vfK92FO7Aql2evk5mq7otWuT7eTkconJKuUqc9pza6V8jR3p6Utlsnv5V8q2gQDTsBjxTxa66Cpg+XX3t2bOBlStz0K1bN+zebVamdQydOtnRt+8+tGpVhvj47oiIAKqro7F0qT5QSU0FJk0SNyvhVW4u8MILwBdfiFUMS0s9t5ISEQwpgxdJEkGVyyX+u6ZGVDP5LvozX43z8st9j1OmXcUwI8N8+uXMmcDmzaIizqwvlZK8j5UeVrLsbODpp/U90woKgPbtxfteH9MUzRj1b1N+HomIiIgo/LECKwTs2rULL730Er799lscOXIEJSUliI+PR69evTB69Gg89NBDqj4rSu+88w5efvll7Nq1C1FRURgwYABmzZqFa665xvR6mzZtwvz58/HNN9+guroavXv3xiOPPIJx48YF5fmES/IdyhVYOfk5GLPCEwzMGzIPswbPAqCu6NEdNzoHe4v34s2tb0KChMNnDuvCL1ONMHWwof0q7Vc4UHJAFYrZYENaUho2HNxgelzWxVkorihG/he91M2VRo8C+qyEDTZUz6pGpF09b8z9Xq281d3ryhHhQMcWHWGz2fDAA0CPHuqqqORkURV19KinKTogggSzsCU6GujQwVOtkpfn6VGUqS7eQ79+wPbt5q+RUVWXshorNnYfqqp6weVe8dIGYB9Ek3QhIkLCPffYkJYmqmoOHdJfp0sXMd5AmZ23LuR+YHrGvxy//KUYwxFFrhkZqZ8umJEhQillBZ88BdNoWufYscBbb3mqkY4dM1/JUVkl5W0KqTaIMqvWksfW0NMGzaoROYWRiIiIZOHyPZTMMcCioAuXPzhCNcAyCqiiI6Jxfvp5RNojdeGWknKK2j9+/Ad+u+q3DTXsJkH5OspckgstFrRAubPc8BiH3YERvUZgef5ywGUDXtsOFGWI6qvx/QC7+CN2ysApWHzjYtWx7vfqrVzgcJbu3FlZwOefi35K5caX94s8VUw7HUvZBN7hMF6BEBCPdewIPPigZ9pWbW0tJk+ejDff3IOqqmwAUwGIFRbt9jbo3PlX6NXrRXz2WTv3ecaO9VSB7dgBfPCB/lrx8cCAAWJ1P2+sThH0R0SE6N11SrGuQUqKeP1WrLB+ngkTPkdW1rWqYOrRR0X/LSVtWKUMlYymfL74ou9pg8r9lQGPtymkys9FWZnx56BzZ1H91NDN2f0J34iIiKh5CpfvoWSOf+0jamKUU85kVbVVmLZ+GgCxgp0Z5RS1P/z7D/U3yBAXYYuAzaBiRvk6ylbuXGkaXgFiCuGmI5vEHbsEDH8I6LAZuHmCO7wCgGVbl+mOdb9XV8vvmaT6OXGi+HI+bZruUABAYqLpsAzJU8W007FKS0VVUGmpeXgFiCqfgwfFtK2NGzeiV69eiIyMxCuvvIKqqvUArgbwA+Li3kRCQjkSE0/hzJnl+Oabdu6QwW4HPvpITI976inj8AoQAcr334tpgEuWeG4vvKCeXvj998ZTBI8e9UyH9NfVVwPXXafedu21IjAxKYZ198/yqMarr6bikUfOoVUrsSUtDXj+eUC5CKw8jXPBAuD0aVHldeoUkJ4upn/u2aOf8ult2mCfPuZTRAHvU0iVnwuzz8E11wDduonnIt+001Trg92un1I5e7b38Co7W4ytocdKRERERPWDARZRE2MWUL3+3etwSS4M6zYMaUlppr2uXtr8Eqprq3Gu+lx9DrNh+VlHmhCVYNo76/XvXkfuwVz0f6M/cg/mYm7uXO8ne28tjj52AJhXLW7vbgBOXg7kPoVIe6T71r+jfjVB+b3qMvB7OC7aA880NJsqXJg507gX1kcfmQcqWsrzWemb5M13392DwYMHY7e7O7sdMTHdcd11r2DevPNITn4A58/HqkIll0uEPC4XUFmpX1nPiMNhHE7t2+fZR7uan/LYQFr62e3A9deLkEkOwFJSREN1ux24xGBBSbtdTHlUiwKQhlOnWiAxsRRXXQX86ldiSujp02LcDgdQXCzCqzfeAE6cEFMUT5709HhavFgfbD3xhHk4t3u3uEVEiAo2bcCj7F2m7WHl63PRubOYrthYvai8hW9G2DeLiIiIKLwwwCJqYoZ1G4aUOP2313JnOVbtWoXMizPRNq4t7ul3jwhHWnZxNyB32B24oesNGLHcxze/psakN5fdZkeETd9k+0zVGdNTlTvLcdeHd2HL8S24+8O7DXuJJcclIzUpFalJqcCx/oDLobtFnBgI5yyn+7b2bvGtOe9QHvq/0R95h/Lc79X7I97F315UJyPK6hKz6pMhQ4B33zV9Kqbn27PH97Sr6Av5p3727EmUl88BcABAASIiTiIxsQqDBu3FkCETAIgKJiOdO1sbKyACmnbtjB87ftxTiXXttcb7DBmiDqFsNt/POSICGDZMhEt2u2isbrOJaqR584A5c4D//U9/nNz4XV8RJ1K6I0d+jw0bzmPPHhGgnDwpKt6cThFarV1rHkRWVemDrYMHgTZtjPevrfXc3n9fX3WUnQ2MGyee0z33qB83WjRAZrOJ8e7da/x4XUNRK7yFb/6MqSHGSkRERETBxwCLqImZnjkdl7Q1KAMB8HTu0xj616HYcnwLvj76NfZN2ofnb3geTpfo8Ox0OdGjTQ98+tOnDTnk+uWlkufSlEvRNq6t36c8evYoAODI2SOGj/dK7oWCyQUomFyAa26Vq5DU0/8G/EbfgEm7euT4f493//ftI1wBTf3SbldOT5Npz7d2re/V9WJjRdWPJGlXoGwL0ZA9DUAqamvb4ezZSHz/vWcPZXAk83c637XXAmfPGj/mdHoqsfr00QdHLVuK7XY7MHy4CKbkVQbN2Gyi39aAAZ5txcXiOOUKhWYOHwYqKnRnBfAzXK5n0bp1KdwFaxoTJ4pwzMj48cbb+/Y1ChfVqqr0VUfeqpKMglKZJIkArbBQLCKgZKUaKlgyMz0rMPpitopnQ42ViIiIiIKLARZRE9SzbU9ER0TjooSL3JVAaUlpOFh6EBU14lv0jsIdWLFzhW4K3GNrHzOdPtfk1ABXplxp+JANNuQX5ePnsp/9OqVRxRYgqtfk13lo+lD39ty/XX2hWskz/S86GvjirwN051D2L9tRuAM7T+10//fqPau8VpfI1ScdO4pgJT1dVM+kp4spZh07iuO0QUjr1ur909JEBZY3cXFiul51NVBTo52jZzxnTzmVz27XT9+79lp1OOSN3S6ClhMnvO9XVCQaomtX9bvxRs/rl5oKdw8qbyQJ2L9fvc2skszseKOVACMjqwF0hdPZybCvlByojB4tKr6UOncGnntOH8I4HMDq1eYrDxqRq458VSUpQx+zijltqOarF1VjCaRvFhERERGFLq5CSEEXLqs/NIVVCGMjY/Gf3/0Hg1MHY/mO5bhj5R2qfTsndjatIgoH13S6Bv/7+X9em6wHU87oHIzqPUq3fcoUMaVNNmiQmOamXhlPQlnGSyi8crLhuZUrRBqRV4g7flxU1mjJKwwqV2vLyBDhjdGKdXFx+pUNU1MBm+0Ujh17HdXVMyGqyUzmZ2qMGSOCMnlFwMpKcRPPXVRJydPQysosndIvkZEiyGrVCpg8WTxneSzV1dZWcYyP11c1GR0bG2tUbaUXHQ0MH16LlSsjYPZaKlcBXL4cqhULly8Xr6t25UB/KVfrs7KaX14eMHWqaDj/8MP6fX/4AbjsMv2KiaFI+/sQymMlIiKiugmX76Fkjn+NIwphyn5JMmUVT0VNBe7+8G58XvA57vnwHt3x4RxeAcB3J76rc3gVHRHtrmKLiYjxuu/c3LlwSfp5ZM895+kZFR0tghr9NC0bCrf3Mz23coVII/LUL6PwCvBU0Gj7BJlV3BhNTTt//iEUFCSjuvopADtgNbxKTBTTBvft8zRdl8MrQIRIZ86I7fX1TyZZWWIcTqeoyvriC89YrIRXDocI1pQN40tLRaildfPNYlqiLy1bApdeGoHIyENQvpbyZ0U7nW30aBEiAqJSTg62rFRFKWn3sdJPTRnqyNP0Bg823jcy0r9eVI3J375ZRERERBS6+Fc5ohCl7ZfkklxwSS7dlMAjZ49g5AcjUe2qbqSRNp7q2sCfc1JMEqIionBPv3vc/axmDZ6FtKQ0pCalIjkuWXeMWcgUGQksWiTCjkWLgEmTTC7a33gFSZnZCpOA98bT2iBk40axYt0994gV67Rf2h0OYOVKbV+qH3Hq1J8BAHZ7G/TufcjrWJWGDRPXsDLlLjbWc11tOGTT5GXJyUBbgxZm2vBIPl95OXD+vAieamu9jyNZ8/ZedZXxfkOGqPdNSRGvd1aW9/MDIhD7058Ah0M9N3DGDE+gsmCBaKIuTwetrBQB169+5XksPV1Ut0VFiSozs35iHToAPXuK5u2B9FMzYravP72oGltTGisRERERmTNZgJyIGpu2X9KqXasgSZLhqngllSWG54iwRaBW8vFNvomLiYzBRQkX4cS5E6iqNSlPMlBdW43q2mp8ffRruCQX7DY7pmdOx/TM6QCArLezUHRY37Topc0vGU4jfOQRcQPEtKU+fdRTr9qlFSJ24A+APRVnKs/gXPU5AEBCVAKSYpJgg03VW0spOxt4803PFDCtjAx1SCVXa5lxOoFDh4CePStx6tRhuFw1ACYAiEC3bnfhd797EzZbBJYsMW+kLmvZ0tM4Xm7eXlhovv+vfgUkJIgx3ngj8Ne/eno5aauzrrtObPvgA882m00fThUViYorX43plU6fFueSJPFzxw7965uSIt7HFi2Af/1LbBs+XOynDdu0IiOVUyU9iZvdXoEZM2Ixa5a4P2OG8Xv1/vvip7bi7sQJoFcv/WusnR732mtiGuDixfoAc8EC8fyjokTQmZ4uns8DD4jxKMkVTGbnIiIiIiJqKAywiBpQ3qE8TF07FYtvXIzMLpm6+zKjSqu5uXPRKsZCN+pwYLH1UkJUAqpqqjB14FRsOrwJ/8z/p+VLyFMP5XBQG0oN6zYMO1b8Bue+HQNInsH8GJ2A7GP6L/pK8jQtZd+il59LwahRni7hck8rObSRALxpAySDEGHNGjEN0cyxY+r7Eyca973S2r07EmI1wXMA/o4WLdrB5YrCiy+KcfmqYmrdGrjtNvX0tCFD1IGTUnS0CLnsduAPfxA9uyIijJuR22wimMrKEhVjZiGXvM3fqYnK5yZJxkHdtdeKsaam6qvqtA3fta66Cvj6a9UoAdgQF/ci7PZp7q1m75XZVFFANOqfN08EpGlpokpNGy7JVUeA/rN24oTn/CdPeo5Zu9b4c608FxERERFRY2ETdwq6cGmeF+wm7srm6xkpGfjhDz/gstcvc99/+dcv4/F1j2PxjYtx8vxJjFmh79r8q7RfYUPBhvBZRbCObLBBgoToiGh0TeqKXcW7AjqPWQP1rCzjcEFumO6Nr+bR/pzbVxNvZSNw+dqpqcCRAFqgRUR4D67kKqWUFGDCBH1FjsslAhOjUMpu9zRzv+IK0TPrkJeZil26AN26AZs2qXtqNRabTdyiosS4duww3s/hAP74RxEqqRvWSwBqkJTkcFdwtWwpAkirKwrKn6U//EFUabVqBcTEeMZnVEVl9lnTSk4W1XFG5yAiIiIKdeHyPZTMMcCioAuXPziCHWDl5OeoQqkpA6ZgyTdL3Pc7JXbC0bNHERsZi+6tu2N74XbdOeIccQ224l6oirRHIiYyBuXOcsOG6oEyWmHQLDjSBkZm/t//A957T1QqaUOGHj2sn9to5TiZ2cpq2hXtgiEyErjhBmD7dmDoUE/D8dxcz4p/AHDunO/qrYgI8Zp4W5EwLk5UCvk6l5nERNEzykoTd39dfLHotWVWuXXttcCLL4opesEkfz6CGYBqRUcD7dubB2JmtJVegP/nICIiIgpUuHwPJXMMsCjowuUPjmAGWMrqK1l0RLRpz6aW0S3FdEHFNLpyZzkKy7w0F2oGIu2RWH/3ekz4ZAJ2ntoZ1HNndclC7r3qb/5GwZFZYGR4Ti8hw+ef68/drp1ocq7kK/C64w7g22/1ocF99wFvvBFYFZYR+ZxyaKW0bJn3SqrGYLcD48aJpu45OcE//9ix4vOhPbdcmZaXJ6YQqsMz33NjtX24OncWPbh27lR/9vwJV40+x74q7WRWqg2V+wZasUhERERUV+HyPZTMsQcWUQNQNmSXeWs4fqbqDP5yy18wpo/4hioHYM09wKpx1eDuD+/GkbPWUhkbbIiyR6HKZfxaR0dEo32L9qYN1I16Wc2ebb2RtVl/o927ReNsbfVRq1biMa21a8WUNLkxfHS0qEzKyACOHjVuAr5+vZhidsMNEpxOGzzhicUGYxqSBHz4oZj6N3iw+rEWLfw+XYP48EPxMybG+hREs0b5Wp99JkI9+b1QmjvXrCeX53WXV/ZT/v0qNhZ4/HHR30q2aJGohtI2UZdXB9SGq7t3i5ULtYHm1Ver97Va1eZt9UtAXXVlVk23e7fo1aUcD6uyiIiIiMhfrMCioAuX5DuYFVhZb2ch77CFJjQKnRM74+CjB2G32XXTD5uTLi27oNxZjqJy/YqAPm2cjvgdk1HuLIf7jzqbBPsVb6PlDa/gsWsec686aMZXLytfx7Zvr14xTl75TisuDnjrLeNpf3JVTV6eCDLuuUdMTVy8WDThNqvE6dFjOy6//FG4XP8GEGdt0D506SLCB6U33wQOHw7K6Q3FxgIVFYEf364dUFICVFd73y8yEvjFL4BvvrF+7pQUsaJfTY347zNnvDdgl+XkiM+B8r3LyQFGjBD9tQoKROizb5/5501bhZWTI6YtGoWmmZlinPn5oqrLSmWelc+7r/5acXHGUzhZlUVERETBFi7fQ8kcF8QmagDDug1DWlIaUpNSkZqUiqSYJETaI9EqphWiI6INjzly9ghW7VoFAJi/cX5DDjekPHfDc0iJTwns4H1DUVaYAqkkFShNE7eSrvil82l8dMdHWL17NfIOeQ8W7XbgtdfEqnKvvmo9vJKPbd1avc3snwyefBIYPdpTmSPLyBChBuBZDe6RR8TPzExPJY72mMrKv6Nfv35wuT4H8JH1Qftw6pQ+eBgwIGinN1SX8AoQ0wgjLdQb9+8P3HijmF5nVVGRqGay2YBOnUSFmjlR2tWunai0evxx0fAdED937RKfmXffFZ+3d981/7xlZwPTpqmPf+IJoGNH4/0nTfJ8jt9/X4RtWtprWak29FWhNX58YMcREREREWmxAouCLlyS72A3cTfzTN4zmJc7z3BKYVaXLHw+7nO0X9wehWWF7lX3mpOUuBQUlgc4dTJ/1IUmRerpc8s/cGFekWdFSKMVCOtCO62qyEfxmLfeRlYaxmuPufnmd/DJJ/dduBeFli0P4syZ9j7HnZIixuxrvIAn2IiKElP0zp5VT71r21aEOkVFYqW9M2d8n7MxRUSIKW2RkaICa9064Mor/avG6tJF9N1STgFUO4GrrmqPqirRCF8rWP2miot9923r1ct4uqpcMWWl+kr+nB89ql5FUe6vlZEB/PADcNllgfeRIyIiIrIqXL6Hkjn+9ZGokU3PnI6nBj+lqtBKTUpFWlIahqYPxcqdK929r5pEeBXkIZqFVw67A8lxyd4P7rUSSN4BT+8hG6I7/ITanjnunmQ7Cne4K92CITsbmD9fTAE7eNA4DOrcWX1fWemirKhSVl8ZXadrVzHN7IknPJU4QC0++WQwgAMACpCQcAadO/sOrwCxct4tt4jAyReXS9wqK8VqfNq+Ue3bi8qpiIi6V1A1hKwsT5XWgAHArFnATTfp3ytvBgwQ5+jRw/jxrl2XYvNmYOZM48flqiTleyvfunYV27X7Gp1j9mz1NqNKqjlzjI93OEQoWVwMLFhgvI88vqefFp9zZXgFiEo0uWIxMtLaeIiIiIiIfGEFFgVduCTfDVWB5Y3R6oUkpMSn4JI2l/juLeauwrpg9Ch0HrhZ1Qg+GFVYcjXK8eO+eyAtXy6qdMz6asm9rhYvFtMEjfjqPaTUsqVoNl7opZCtZUvg//7P08TcvBF549P2ERs4UKz4J0tMFBVh3sTEiOCltlZUnsnVQhUV6l5ZVhq6A0ByMvDww+L1czpFuKN2AF9/fQoDBvQ3XBXQ4fBM/zt50rjpvLJCy9sKmYDvvm0ul1hI4OBB8+dkVhHm67O3fLm6ItCoj9yCBZ4qRZk/zd2VVY6BHE9EREThJ1y+h5I5/hsoUQgzWr2QhMKyQnRK7IS0pDR3TzH5Fu+I9+zorsICkPIj0GuVbhXDYFRhrVkjqlF8hVcZGWJKoLe+WnKvK6PwSq5+0U//Mk+boqKAIUO8j6u2FvjTn4AlS4ClS0UVTX1zOESDdn96TgEitJAz5ZQU4IYbPD2dUlJEFZu295hWy5Ziul/HjsDw4cD+/aLRe2Wlp7rMangFANdd53kfHQ7g8svVj8fFzcWAAf0BeFa3VHI6RZh08KD5iom7dnmqsRYsMK9ssttFqBcdLXqWpafrq7jsduC557w/J29VXmYiI4E9e9TbjPrIyb8v8nM+eFDcf/ppfbWZEbPj1671fhwRERERNV2swKKgC5fkOxQqsAJZvbApi7RHolOiSE7Kqst8rjyY1SULufeqS0QMq9YO/RKR65ei7W3PoiTlX6b9xrTn8oe2D5WRFi2ATz7RB1P+VJN4r35xAtB/VuXm8K++Kqqw5Corby6+WPQ28ifECVRUlFjFz9/AaM8eYOhQIDVVBBhr1njuu1zAK6+Y9/PKyFC/Xzt2AB98YO3abdqI11A+t80mnoM8lS4qSoRHZ8/WQJIiAfyIjz8+guHDb3Kfw6iCSqlTJ/H6m8nKAj7/3LzSyluPLKMqruhodfjqrU+Vr7Fb6eXl6/fF1znMjrfSM46IiIjCU7h8DyVzrMAiqkd5h/LQ/43+Ple6MyOvXpgYlRjkkTWeSLv5cnA1rhosvH4hCiYXoE1cG9P9kuOS3T3CtAyr1rp8ifb/dxuOLf2nrt9Y0ubnEfnSIfz4x49M+w1ZYbQaoNZbb4nwStvjSO4lZKWaxPvqbfrwqmVLMS67XVQadewoQh5fq/INHAgMHqzeFm28YKYpq32OqqtFKGI0JpvNeNsXXwAnTgDvvAM88wzw4YdAz54ivJKv3a6d+TW1Uwx79xZTD624/nrRK0werySJ8EfZF+zMGVwIryrRqtVMVXglj2/gQBF2aZ93SgqwaJH3MUyc6H2FTLPPye7d6ios+fjp09X7eetTZVRBph2bL75+X3ydw2z1TbOecURERETU9LECi4IuXJLvulZgKSuBfPVYyjuUh99//HvABvxl+F+Q2SVTdZ4WC1qg3Fke8HOxKsoehWpXte8d61Gvtr2wY8IOtFrYCmerjBsZeXs9vVWt3XH6R3z7cQYkSTQeP39eVP4Y8WdFOJm3qpI+fcTKc3a79f5VyclAfLy6GsvlEg3SjftZyasteoweDVx6qX7PgweBf/zDuMF6dDTwxz8CGzeKoEiujEpIEK+ZVQMHiudcVmb9mLro0kW8TrI33wQOHzbed+xYfQDy44/qdmkym03cXC7x/iUmihUK27SxUrVVjQ4dgKioKPe55PfS7HPQq5eoCAukOkrmcomKv3KDPza0n23taoIOh6gA89ZPyqwKy58VBs1+X6yeI5AVO4mIiCh8hcv3UDLHCiyieqKsBPLWY8kluTD+3+Oxu3g3dp/ajQmfToBLEolB3qE89HipR4OEVwCCGl7ZYAuoKXpxeTFy8nNMwyvA++s5rNswREcYlwp9+lmtu9KptNQ8vAKsVZFoeasqmTPH84Xc6rmLivS9gRYsEMGJMXV4ZbMB69YZB3GpqaL6x0hVlWgyv2GDelqfP+GV3S56UyUkWNvfqNLKXwMGiJ+5ucALL4iV9IwkJoqQSKtPH+MqLEnyvA4ul/js7Nsnqrbk3lvmonD8eJRhZZ3Z50D+rJhVR/38s3FfKyW7HfjDH4zPr13tULuaoNPpu5+UPL70dPV2f1YYNPt9sXoOqyt2EhEREVF4YAUWBV24JN91qcAy6sNkVjWUk5+DMSvUZQg5o3MwoteIJr0CYa+2vdA2rm1APbx6tu2J3ad0XcpVsi7OQu596mRGriQprSjFuepzYqNNQsLVH8AGoPrrh1BWEq8/mUZGhqjQeestdV+qM2fEz5YtPdu0vary8oApU0TzbHmFN2X1FeC7h5A3qanAs88Cd9yh3KqvvFLSVibJXnxRjNNf2lX+tKsCymJigG7dRDWRLz16AHv3+j8Wmd0uGtXbbCLA8hZOjh4NnD4NbN2qX3UwIsIT5HgjV3D50ztLJlcKGX0OIiPFNE+7XV11F0jPqZoaESAqq7fk1Q7lirJDh3yP0xujFQatBliA5/eluFiEZv6ew8qKnURERNQ8hMv3UDLHCiyiemDUh8moasgluTDnizm64+fmzkXOzpwmG14BwOmK07gx/UakJaUh0uaj4ZJGZU2laRWVrGNiR902eWWykpNJqDndWdyKL0bf848h49xjlsIrQFSArF2r70tVUiJu3npVZWYCW7YA770nejL17CkqVZRfyH31EPImNlYEMHb7QcVWG+K9PDW5MkkpN9d4epkvNpvooaVklu9WVgLnzplXKcmrD6akiEDI39UIlVwuEUj5Cq9athRhSW6u8aqDVsKrlBRRHffCC8C//qV8RJvi6VM9hwN47DHzlQRrakSopPxcLVggAjezvmVmlVyRkfrqLXm1w4ICIC7O5AnCekWTtz5cVsi/L+++G9g5vK3YSUREREThhRVYFHThknzXpQLLrA+TdqU7o+orWUpcCgrLDRsdNRk5o3MgSZLpc1SSm7u3iGqBx655DACw9NulKPzPg8DWB6CuMJKQet1/UbDy/6mv52VlMknyvUogIL7UnzsHrFxpbX/5/P723gm0Cmv5cqC6+q+4++6PAHgaNpmtLOhwiCoebSiwbJlx9Y2vFQojI8WtstKzvyQZV2AB4vW02bz3wUpIEONMSACOHDHfz9cY27b1XlFmswH33iumRnqrPPIlJUVUbZWWetvLe1Uc4FlJMDXV+HmnpACTJolg1lvPNPn1iIkBLrpIbJMrA//4R6BVK33TekCEhjt2GH8G2U+KiIiImppw+R5K5vwriyAiS4Z1G4ajZ49CUlRg2GDTrZr30uaXTM9hJbyS+0zVSrV+j9EGm2p8Vh/zx0vfvoTiCpNGRBfERMRg1uBZmJ45XffYZ/s+Q+G+oUBpV/2B+/V/fMk9cZT/z1JWkmgfM/LkkyIQMDqXmf/3/4A9e8wbXhuRK1duu01U11jRpo0IFRITxwMov3ATZTRmodNVV+nDq9xc86Dn6qtFqHHunPHjNTXqCidvYRdgrcpL7q3lcokqrNpa82mJgFgdMS9PPY6UFLHdqAm7zGYDVq8WU+i8SU4WP4uKjB8/dQpo3dr7OVq0sJm+hjJ5JcH33weuu07/WhYWiiqsiRO9B1jycZWVnmmrgDh2xgwxhfTHH/XHHT8uKsC0QS37SRERERFRKOIUQqJ6MD1zOg5MPoCCyQXu24HJB3QhzbBuw9AqphUi7ZGItEf63fS8T0of/G3k3wIao7eAKhjhVUxEDDq06OBzGuTtvW43DK8A8fqkXLfcPSrlz+dnXqzb32hqntwQ2ugx7dS2jAxPCOXPNL/SUs90L7kxdlqa52bWaDszUzQCN2I0nc5uB8aO/R/KysoASEhLM0glNOe4/nr99n37zCuibrgBGDbM62nrTVSUmJ7ocIgxJCWJ7S1bekIlOajSBizXXisCR29N1V0uMW3w7Fnv+113HdCunffzmDWIl/35z55rREbqm9QrQ6LBg4HJk43PM3Gi98UBvJGnFs6aZfz4pEnqc6elBT4VkIiIiIiovnEKIQVduJRu1mUKYSCMGr9bEWmPRI3LS9MfjeiIaEiSFNQVB43cmXEnjp496rOJu1lze5nRVDtvjZ69NZXWPjZzproZunbalHb/0lLg6FHj55GcLKbAmTXGNmu0bTbtsWNH4NgxoytVAjgOm+0fuPbaGfjiC/MqqGuvFTcts8bjkZFAixbA5ZcDmzapm383FHlKIiCCrNpa0fdLfqxbN9G/SZJEEOVyeRq4Dxliran6pZcCBw4Yh3gpKcCECaKB/+HDgT2HlBTgxAnxOm7fbryP8rOWnQ288Yb+cxMf7wnuysrMK8IAfcWa8rPvconnvHOn53HlwgJshE5EREThIFy+h5I5/hsrUQjIO5SHzi90Dqhpu5XwqmV0S6QmpSItKQ0zs2YiKTYJAGC32WGvpz8Gjp07hmHdhiEtKQ3Jccmm+xk1t1fyVlVltr9ZU2ntY6NHe6pPlBUxchVVerqotImKEj8HDTJ/vkVFIlg5ftz4cbNG2yNH6quw+vQBnn/e7EoxALoiOnoE9u83D6/kSiVZbq5oOr5kiagWM3r9ampEhdL+/Z7qp4bmcnl6alVXiwDr/Hlxa9VKvA8lJSJMlJ+7yyXGnJsrnpu22knJbhdBjlF4FRUFDB8u9jFqfK9m/m8/Lpf47Jw8afx4RATw+OOeCr35841Dz7Iyz2IByvDKZhMrQSrdfLP6vvJ3xG4H5sxRPz5njudxNkInIiIioqaAFVgUdOGSfAdSgZV3KA9T107F4hsXI7OLtW+DgVZe+SNndA5G9R6FvEN5uO+j+7C/ZL/7sUcHPIo/ffOnoFwnOiIa7Vu0hw02PHjFg+6pgWZN7WXa5vZa3qqq6sqo+iQry7jnUFaWCKmsNBpX8jVmbRVWTg6waxcwd64IcNREc/CbbipCQkKyYbWR3S6ap9fUiBAoKkqsPqc/l7GxY0WA5KuSSeatX5U8Hl+9suo6rrFjgW++qVtz9rg48VrZbKJ6ascO0YfKnKiGAwx6tCnOqewDFqzXQslmE/2vrrjC/HekPn+HiIiIiEJBuHwPJXP86ytRgPIO5aH/G/2Rd0gkHS7JhYc+eQhbjm/BhE8nwCVZ+5a6cufKeg2vAGBu7lx8XvA5bnz/RlV4BQAvb37Z8JgIW4TlvlwOuwNpSWm4p989SI5Lxru3vYvpmdPdlUw7pv8LkS8ehn3pQWDpftjzZiLSHomkmCSkJaXpmttreauqqiuj6hOzaqmJE0XD7ago/64xezawYIFo/O1wqG+tWwO7d+srwdatMwucbAAK0b9/Mnr3Nu7l5HKJiqXKSvHflZXWwyubTQRo3pqha5mFV0lJQIcOIvjzxuj91PYAS0kBevWC4XOWH7v6au/XadnS++Pl5aKyq6QE2LjR01zeXCVuvDECV10F3H+/8R7jx6vvP/qo8X5mTeE7dfI1BhG29ezpqRY8dUpMtczONq8mXLDA93mJiIiIiEIJAyyiABiFVcogyte0OOV55ubOre/hYkfhDozKGYXK2krdY2ZTEP856p+omlmFXm17qbY77A6kJqWqpgU6XU48e/2z+OrIV6rXZM0aUbFUcjIJNac7w1XSBSjpil86n4ZzlhMl00oMm9sbachpTkZNs+VgafBgMU3NKMQyChv69BHHrVkjghF5FT/5VlICrF+vD+jMQjQAsNnOuXsXmTVjD5Qkeabx1dXQoSLAGTLEuCk9IF7HLl302yM1i0xee62nGf+QIcaP9e6tn1qndOaM9bHX1FhZQTEJlZVdcOutwIYNIpBUatcOWLhQHU4q78syMoCXDXLkjAxg0SL1ts6d9fvExYnfs5MnRcXdyZPi/tq1cP8OHjzoefzECc+iA0RERERETQUDLKIAaMOqFTtX6IKoublzfVZhNUT1lex0xWm/9n9p80uG43O6nFh4/UKkxKvLYB5b+5guwPNWyRTKfPXdGjwY+Otf1Y937qwPG9LTRTDlK5CaOFFU/Jw6Bdxzj+iL9MQT5qFPmzb/BuB9NcGGJodLyvty3ya7HbhYv2gkABGUGTVLr6ryBEJyhZXcx2vNGnWfq9WrRW+vpUv1AU8goqN1ozT4b/Fz927xvh88KKZpKhUVAd27A6dPi6b8r74qgjmjz9b+/fr3u7AQ+OkndQCm7Y02e7ZYTdDIxIneqwmJiIiIiJoS9sCioAuXucdmPbCMelZ1TuyMI2f1jZHk3lNmfPWGqm92m90wZIu0R2LukLn4bN9nhuPr1bYXdp3a5fXcGSkZ+OH323BZP7vlFQRDia+eQcrHY2OB//xHVIcpjxkzBnj7bU8107Fj+pBDPveQIcZ9t/SccDjOID6+LaqrrVQJNZ6ICLGqIQCcO2d9GqPsuuuAPXtEJVdqKrBsme8eV126iOCnoiKgIQPQ963yEP3HtHz1AAPUq1AafbbM3v/UVBHmFReLaYbR0WKhAKfTcyxgvlKnt8f8+R3Mzhavv/J52mzAAw8AM2ZYPw8RERFRfQmX76FkLsS/QhKFHqOqJKPwChBVTN70bNsTEbYI2Ay+FDeEi1tejLSkNKQmpbpvaUlpmDtkLqZnTnevIqh9vMLpOx3YUbgDq/es8msFwfoi9wGSV31LSxP3s7PN90lPV1fOaMes7Mu1Zo2oytL26lq3zjN9y6hCB/C8HmYVMfreSA44nW1RWmocsqSkAMkXZneaTaez272v1Ocvs+vU1oqeUqWlvsMrbdVTSooIff7wBxHi5OaKCjVfTp3y//OlfM1SUkSAZcz4RbPyz0DK99eop5vZ+x8TI6b8yVMDDx0Sn6MWLTzHeqsY9HcVTzPKqYjyTZ6maIWV30EiIiIiIm9YgUVBFy7Jt1kFllnVVExEDC5qcZH7vnYlPi1lJVd0RDSqaquC/yS8iLZH46khT1nqP6X1TN4zeHPrmzhffR5F5UWm+2V1ycLn9+Q2+upn3lYVlKtizPaJjhaNyAOpNNGuLqiVkgLEx4sARJLE6obKFerkJu/FxaInE3AIQBeYVQIBYjW++HhgxQoRGlVUBH/VOyW7XVSg1fU6bduqA6qxY9W9oqxUXwVKfs3WrAGuvbYMq1YtRHn5PL/OIb8GRhwO8Rmy20Uwun+/6H2mbBIfHy8CSWXImZEBzJwJ3HGH/pw5OcAoRXGnt4rBp58WN6dTPRZ/PtNmn2XtOMzUx+8XERERkVK4fA8lcwywKOjC5Q8OswBLDm8kRV8cX2GVkZz8HIxZ4SXdqGeDOg/Cl/d/GfDxRlMpHXYHOrToAJvNpnpN8vKAqVOBxYvr1oTdaBqT3JhbucKcdmqTlS/fvsImZdhllTJUkKWlicblNpv4uX277/PY7aJ3UnX1CYjC2Xbux+TKoaIiEYhNmCD2r8/AR+ZwGFeVASKYqPIjk42L86yaGB8PPP64CDy2bhXvd31Nl7TbRQXZlVcCNTUvIjd3OoDyC7cYy+e55BIx3dGXxETg7Flr50xOFq+LPGVQZhYEm/2eWQlwfTH6LPsTSNfH7xcRERGRUrh8DyVzDLAo6MLlDw6zACsYjMIfreiIaMQ6YlFaWRrUa8viHHE498dzsNsCK4cyC+B89f3yxVuvnTVrrPaJMu85JNN++TbaR8lqpYnRccov7vJ5srOBF18U/Zr8Uw3AswSisnqoXTsxrUuSROBR1wbv2rDFbldXWV1zDfDVV/rjbDYx9S3QPlQJCSIcO3vWet+siAj1vi1b+rfqoN2+BS5Xf/f9Tp0+wNGjoy0fv3w5MG2amFqXmioq5o4e1e83ZYpoOG+mc2dRieeN8jNkpS+VWXiknS7pq6eV2WcZ8D2W+vr9IiIiIpKFy/dQMsceWER+yjuUh/5v9EfeoTzD+1aO/X8f/T+fqw+O6DUCxU8UIyUuxet+MhtssNvsiLRHwm6zu/87JjLGMKQqd5Zj1a5Vls5txKy/l6++X75467Xjz8pp2p5DvvoAGe0jy8gARozQb7fS12fkSPUqcvJ51qwJJLwClOGVvDpfaqroFVVcLKamlZYGZ3XCmhrPa5SSIqazpaR47l9/vWelQCVJEqFaoMrLxfOwEl7ZbGKM2nHceKNnrN6JxMXlWggAiIuLw5dffomCgtGGz81IZKQIryorRVXd9deLVSpjY9X7ORxiaqfZeeWKtshI82tpP0NW+lIpP4OyuDjx+fOnp5XZZ9nKWAL5/SIiIiIiUmKAReQHl+TCQ588hC3Ht2DCpxNQ46pR3Tda0c/o2Le3ve3zWj8W/oicnTkoLLeWcvxz1D9R+1QtnLOcqH2q1v3fFTMqMKjzIMNj6hI2mTV4H5o+NOBzAuYh1cSJxl/EMzKA3r3127RfiL19+TbaR8ms6bWVAMGoYbe355mQYLzdQwQuNtthDB+uHtfVV/s61j/l5aJyJioKGD5cBCvDh4vKrPJyUUFm1gy+uDjw6/rTS0uSxP6VlZ5tdru4/pAhVs5gA/AjbLbVGDduHMrKyjBo0CBERorAzoqaGvHenzwppjru3Sua+r/7rno/pxM4fNh82qXTKc4h+p2ppaVZ/wxptxuFR+PHWztWex6jz7LVsfj7+0VEREREpMQphBR04VK6aTSFUDttbsqAKVjyjWc+kLfpc2ZT7pLjRBMjo2boPdv2xO5Tuy2Nt3NiZxx89KBhtVWw+nY1BF/T/YymMUmS+dQmJSu9uPLyxDQvudG2wyFWIgQC663lz/OMiBBN24vM++Jf8COAK3DPPbno1u0a1TlffTXQyi5zckP13FzRk8qfqX2NyW73NMj3ZtCgPyE3dyIiIiJU25XvkT89veT339e0OcBzXl9TB40+U/70pdI2ef/hB+CyywLvaaVldSzy72BRkQj9GmthByIiIgo/4fI9lMwxwKKgC5c/OLQBllHfKu3qgRkpGdg2fpsuRPLW8yojJQNJ0Un48oi+oXpyXLIq2EqOS8a5qnOorK3U7QvUvf9UsFnt0aPlrdeO0WprgH7bggWBXVse89GjxpUy/vbW8vYa7NgB/POf5mMxY7ONgSTlwGZ7Bi1bPgnlioTB6H2l1BCN4eVeW96awgePvIKj+Nm5s4SDB22mAYocuNxzD/CnP4lgU9a1qwg5S0o82+x2cUtIAJKSxMqK58/r+4e1agV06ybO+957wPPPAw8/rP4syeGWcrVKmc0mVjTcvl0dWKakAJMmGX/GtQGut9+zQPhzvmAt7EBEREQkC5fvoWSOARYFXbj8waENsKyuGmgUIvk69s6MO/HN0W9UFVKQgPKachSWeb6dZqRkYEDHAVj2wzL1vhdkdclC7r2hs5RXoKufuVxA+/bii7lRBVRWlv7Lr/YLcaDXNjtOpm1crW3Erg0QzM4XHe1ZXc+Xrl3FvgUFIiD73e+ewx//OA1ALoAs3f5yEOQtELLZjCuT4uPVAVh8vKdnU7DDMUA0Wx8xQky77NED+Pxz68fGxlptFC+HVocBXKw6/j//EdP9rFAGlhER4jU0mu5nRa9ewM6d6m3aAGjePODjj0WIZbRapdmKhlZX9DMKg+tSCRXs8xERERH5I1y+h5I5/tWSyCKr/aKM9vN17LFzx3Bg8gEUTC5w35674TlVeAUAOwp3YM3+NZAgwWF3BL3/VLBZ7dGjZbcDF10k/tvp1PeXyswENm9WV25kZgK33gqMGyf6Be02mXnp7drZ2cCePeaPGzWu1k7XKyxU98Ayu15VlbXwKiJCBAMVFeK/Dx4E/vznJxARcQaA3NtMnURlZorQz1sTcjm80jYMv+kmT/Nzh0MEVqWlwWsMr1VRIXpFnTgBfPGFeU8tLbtdBHvWiD5XWVkfq7a+95718Eq+5muvieqq2trAwysAmDNHv03bp23GDPE5N+vF9eCDxtutLnbgradVIIJ9PiIiIiIiJS9rHRGR0rBuw3D07FF35dOZyjM4V30OCVEJSIpJAiD6ShmFSPKxpZWlOFd9zr09ISoBrWJaGR5jFnodOSsa5ThdTjx/w/NepwzmHcrD1LVTsfjGxcjs0vDzdOQv5NopdlZWHJs507i/lLcv53JTdTO+ru1rZUBts+mJE42rq4waV5v9Q5Cv3ke1tSK0kp0/L25AomIvT+rjcIgKnCFDRHVYebn5uQHxenzxhXjeKSlirC1aiNciKsr762mmbVsRRPnu5WUtxDPicmlfU7nKylhKSgauv/5S7N7teY/vuMMTmLVoAVx5pZgi6G3aaWYm8NZbxp9NmZV+WX/4g6eResuWnu1VVSJ8VAZARp8h5YqGyio7f1f0k8PgYAn2+YiIiIiIZJxCSEEXLqWbRk3cG5K28bokSTh+7jicLs+3VbOeW4C675a3/QJltb9VoH12/GlQbXYto8e9Xdvb8UbXfvppcdNO02vZUjRjl1+LO+807nVltwNt2lgLeqzq3v0A7r5blCb9+KN4Tmbk/laHD4vAauhQIDXV8/ibb4rH/DV2rJh6+K9/if5QodLwPSZGvDc//2z8uNUpeb6as0+ZAixZYvyYFfL1brhBhIvyNa2szljXPlZERERETVW4fA8lcyzwJwqivEN56P9Gf+Qd8tJEyaLpmdNV0wqfv+F5VXgFiCmFq3atMjx+5c6V7qbx3vYLlFztJE/vU07xU9JOi7JaHWK3i4onJW0FlJbyWrLoaP21s7PF9LO0NM+ta1cxfVCePqcUFQUMGKC/9rp1xj2mzpxRvxZHjxqP1+XyL7xyOPRT/tQq8dNPl2DJkkEoKTmKPn1EKGPm/HnRmPzvfxdT+P7+dxG8LFkCvPCC92PNJCeL/k6pqaIX2MiR/p8jMJLmp15lpQgWzVidkmf02ZRlZAALF3o+h507m1/PjHy9zZvFNMWaGmvhlb/VV/XN7PcsO7uxR0ZERERETREDLKIgcUkuPPTJQ9hyfAsmfDoBLsnCN04/mE0pNNruklyYmztXtW1u7tygjslsKt+uXeovqXXpi+Nv+GUULMyYob+2Wfg2f756RTlZdTWwd69+u69eQ/LjkyZ5388qp9NX36UvAexBaelf8cILTjz99M9wOtUHyIEeIKYXlpaKYMflEj/lflclJcC5c+Yh1sCB6vstWoipg7fcIl7n3FwRgq1da72vlfJcycnard6eeC080we9X2zOHKB3b/125ZQ8JbPPnTYsTU0Vn7MBA0Qz+uJiEXxWV5v3IsvI0I9Feb0HHjA+rkUL9f20tNDsO2U15CYiIiIisiKE/qpL1LQFu+JJW801rNswpCWlWWrcrhyLLNhVWEbVToCoKNJ+STVqum5FIOGXWSNs5bW9NVY3W7Vv1y4RFLRuLW5pacATT5iHEw6HeDw72/i1Sk3VbzMKNKyGP3FxwKBB1wHoCiANQBpqa9uhoiISQCUAIClJQlKStfMBIowZarAuQEqKmN4mV6ulpIgVICdN8kxB/P57EYKVlhqvdiiLiNBvi419GSUlD2u2mpeedexocBIDGRliep1RA3WnU0yX1L7/ZlV/8mczOVlUxVVWis/++++Lz//JkyK8+vln88/U7Nn6sSiv99xz6sARENfSbisrEwsY+Pv7Vd8CXcSBiIiIiMgIe2BR0IXL3GN/emAp+03J6tJ3qq79q7LezkLeYf00xqwuWci9N9fgiMB46xlVX714rPTeyssTgcrixeov9cpjjx0zDxaCKSZGrKhYVqaeLihXGCm35eQAK1ca98vyJSlJhGbifHJDc/nnOgCZAEpgs0VDklpD2/TcbldPU4uP94RzZ86oX++MDM/rV1EBxMaKfVu1EqGVJIleUlamvaWkfIri4jTU1rYG0A6AE4A857IjgKgL/619Tp5xxsVZm4qZkyOmib75ppjWaVbNFhEh+nZ567km96eyuhKh3KxfbvAunxvw9NMyut6UKaKSTdahA3D8uP782j5doSCQPnZEREREgQqX76Fkjn+FJAqCYFc81bWay59qrboYOdJ4OlZ99uKxMi3JrOJLeay38Eq5KlxdVVaK62kDlqIi9Tb5Nfv668CuU1qqPJ9nOl3btidgt8cBiAHQ/kJ4pdxHkKQK1f2KCs90QmV45XCIcKqkRPTQqq0VP0tKgAMHPFVX3sOrygs/f0Rh4XDU1vYGMArAWQAOyBVknvBK/ZyUtMGgGZtNVMS98YZ4P7wFT7W1Ypqet6o/uT+VFRkZojLrqquARYvUFYW+qgyVVVjR0eJ4I6FY1RRIHzsiIiIiIjP8ayRREPjTn8qXYPSv0jaAL5hcgAOTD2B65nS/x+ON3Q68/jqQnq7eXp9fUusyLaljR+PtcXHq++3b+zcmM1YbeKene8KL2NjgXFv22mvt8c9/Drpwz6zReSUkSX1hTwClPqZFi1WorX3Dx/nM/AxgM4CpF35OgM0GxMXFoVu3kxg4cJnF8/hPkkR4qX2vzbz1lvcpeRkZ1q89ezYweLAIvR55RB+ueptiGxkpQqv4ePFz7FjjqaeN0bzdSpP2QBdxICIiIiLSYoBFFATBrHhqiP5VwZSZKRqcN9SXVKN+UlavabYaYHq6evz9+tVtjLLKSn2PLG1PK4dDVPzMmye+/J865d81tP2QlH205NfF85p5qpgcDteF8VTAbn/uwnZtIHUY6sqnH3H69CgcO/YHADugr4ryHmRFRv4fOncehZtuOojhw2vRpUsuunRxISWlDDU1P+HEif8LavWbkTlz9J8f7Xti5fNktTdZ587qcwWyMt8jj4gqt0ceCa2qJivVkHVZxIGIiIiISIk9sCjowmXusT89sIKpofpXBZtZ36n6oO295avfVna2GNeZM8ZT23JygHbtPOOfPh348svAxib3OIqLE6v8ackr02nZbN6bnRuJiQGuuQbYsMGzTW4qbrcD//iH573Qvmbz5gEffyye76BB+l5F0dE/wW7fiYqKWxVXPA8gGsA5iF5V7RSPOSGm/xmLjAQ6dQIefFD0KsvKEp8ZrZ49gd27rb4CntfbCodD9JCqqAAKCz3bx4wBPvjAc99K/zZv/d9ksbHAf/4jqq9kZs/bnx5Wyt5SjdlTyuw1qK/+d0RERETehMv3UDLHfwslCjEN1b8q2AJdaTAQ/k5LWrNG9GYyCq9iY8XxyvFPmhT42GbMENUm06YZP/7QQ8bbA/mnhHff1YdhRUXAiROi0fd113maq0+b5lk1ULs6o1FVz1//2h2/+MWt6o1IgAip5IbrgsMBJCZ6D3lrakSFjlydYzblc+5c82mUiYnq+w6HvgJN1qmTfpvTCRw6JMIreSphRgbwt7/5X0E4ciTQq5d6m7Yqq6oKuP56sWqlXGFl9rx37fJdiSULlaqmulRDEhERERH5ixVYFHThknw3VgUWWWNU8WW2QuHVV5uv7DdlijiHkssFXHopsHOnZ1tqqgg9du70rCgnk1etczhEcJKeDuzbp1/psFUrEZ507y7CHJn2fFa0bCnOZ7WJOSCmRkZFGVfJGVX1rFzpu8oIALp0EcGQFXJ1jrcV6vr1A3bs0B9rtTqrXTvxvp88ab6PsgItMzOwCkJtBdIll4hVDo1ER4veajabeM+UFWBKobiaoDf+VkMSERER1Zdw+R5K5liBRURNklHFl1lPnuPH9ZUigAgVFi7Ub7fbRa8kpeefFw3rr7pKrCinPF9trfjpdIrrbd5svNLhRReJqXTPPafevmiR8fi8KS83Xt3Qm5kzPa+Z3IspNlaEKhERnjBp1y5g6FDjChutuDjjs2w+pwAAK4tJREFU1xAQYZlSu3bA44+Lvk/p6foQR+7l9NRTxuebO9e4skrr9Gnv4ZVctXXqFHDPPWI899wj7m/c6Pv8Mm0l4Ny55vtWVXk+j23amO8XiqsJesMm7URERETUUBhgEVHYMFtlsEMH/RQ5QEyji4w0Psboi/nGjSLkuO0275VADz5ovF0OxbTnHjVKPz6zccm04ZgvDgfw2GOiasvhENcrKBCN5rVqa0VFktHUQq3x44HRo42nkr33nnpbq1bqcFEZvinDj5EjPY3oZX36iNfpr3/1PWXO12szYQKwbp3vBuS+aKfyjR6tH7cRo0byQNMMgEJlOiMRERERhT9OIaSgC5fSTU4hbHoyM42br2dmAl98oZ6y1qcPsH27+MJtNvXwV78STbhdLlG1c+KE74bhGRnADz8Al12mnh4nNzGXVVWpG60rp9TFxoqeVdoqMK1OncxXVqyriAgxtVE55U3bMD06WqyOFxlpPJVsxAjPc3I4xLRHo1UW09OBt99WV9Pdead62qfdLm4JCeK1OnvW+/i9NcuvrgY+/LB+GpD7au4uT5PctAm47z5g/37ja5t9Jh94QASvRERERKQWLt9DyRz/rZSIwoZZ8/VJkzyVIj17ittrr3mqRcymHu7dK6bZnTghtllZ7W72bBHoaCuX5Cbm8u3ECRHmjBsH3HAD0K0bUFwsgpeWLUWDdrnpep8+xhVOixaptwWz+qW21vM6tG8vKmymT1fvo6xgU1aVyVMF09PFc7LZRFWUUXjlcIjXZtw4dQNzbTDncon9SktFeKVtmK49Z0yM8WOjRokx11cDcm31WOfO6sflaZKZmeLzZTb9zuwz6U+FGBERERFROGGARURhw2zqmRwMZGaK/k533SUCk7Q0cTObDjhxon89iZQhxJ49IkgBRDWTkaoqT8+sggLRt6m6WvxUBkevvaYPxGbPBn76SR3kmK2ymJpq/TkYkXtnzZypDlyUlUDKqWSAJ3Q5edL7CovyyoAFBcDTT3tW4vO1EuTo0d7PaVSh5XAAf/+7OH+3bvoeXBkZdQ8B7XbRK00OSpX90rQhlbfpd2afu6bWI4uIiIiIKFh8dFkhImo67HYxZU25emBhIdC2rfjvli3FTytTAVNSPGFDnz7q6YBG0tPVIcTatZ5eTHKTdzMPPggsWaLffvw4EB8P/OY3Yqqe3S5CKocDeOIJ8d++JoG/957Yx8pqgkaUoYscuMir9WnDHrlH2OnTgV1LDvTWrgX++Efz1z0jA/jb38Rj+fmegMjXezRrlqi+kqubtI4fD2zcWnJQKvP2msmLEWjJFWLaVRqbWo8sIiIiIqJgYYBFRGHl2DH1fWWj8JIS6+dp08bTH0u70l9EhAil5J5Qcl8jZThh1lBeKyICWLlShFLa5uNFRcarDMqrHfbq5fvcjz8uAiyj8wOiOuvkSU8z96QkMU1PJk95k5kFLoB5MOSviRM9DeSNgrfCQqB7dzHmqCgRmN18s6g2Ky5Wj0H5HskVYxMniib1RtetD95eMzNGz1/7XhARERERNSf8qzARhZVghRByA/U1a/RTzWprgRYtRA8qs9XXrDZXr60VU+j8XVVQHqPRanbKcx886Dl/ixae6YRpacAvfiEqtNau9Ux5GzlS/VzuvFOEX61bq3tUGQnGay/3z0pLE1Vm2mmYcXHi/ZCnJ1ZXi4q6vXuBLVuAhQvV55sxQ/8eBbP/VXa2mPYoT0dNS/NMg6wro5UwiYiIiIiaKwZYRBR09fml3hezcELbG0vbXFspLc2zGpxZKPPWW8Ajj4jKGuXqefJz37PH/7HLIiM9wY1M20dLnkZoVKFlJjbWU7VUUSGqlTZu9Ex527VLBEHKXlo1NeJWUgK8+ab6fW3VSoyjVStx//HH9eOWtW6tvt+pk3H41qqVunG5HOylpYkgato04/N36CDGphyD/FP7HsnVTUqzZwMLFohxOhzqm7fwrj6brXvrkUVERERE1Nzwr8NEFHSNuYKaWTghV1TJFi3yBCjaMOu55wKv1pGfu1Gw1Lu351xGzdXT0oCEBBEYaSuyLrpIfV9ufl5YKKqSAE9Dd6PATq5c0jaK174n3qqoYmLU72tpqWdlQGWll1ZaGvDyy+ptixeLcOYXvxCPy+PWvk+yBQtEEGWz6UMyhwP46isxNuUYnE5g/Xrj8xlVN61ZI4I6ObRThndmn936brYuTz9UBnBERERERM0RAywiCrrGXkHNKJzQbhs1SgQoHTuKoENZtfP4456KG7NAzKwaxttzLCoSVU9RUcDvfieCMqXnnhOVXUYqK81XM3zySVGl8+KLnmodbRA0fry18RoFdoDYZhYuacmBoDxN8d13gbFj1dMXR40SocyWLeJxedyjR3sPDNet04dkTqdodm/l+cmMqpu8vXdmjwVzOiIREREREZmzSZKvNayI/NPnwre5fF9LgoU4p9OJqKgoVFdXw2E2L4oMuVxiNUDtCmraRuf1KS/Ps/KbXL1itC0ry7ihd1YWkJsr/lv5fHw9j/nzgXnzfPe0ysoCPv9cf15A/9opySsRyszGox3zDz8Al12mf0/GjhWhmfL/BOXl+r5fyckiJDp2TP3c5CbpynO+/LIIAZWvM2D8+hvJyVE3L8/J8Uzp1D4mS0kRP5Xj9vcz53IBl16qXsXSynm8jZeIiIiIGka4fA8lc6zAIqKg87dqqT4YTb0y2malWsyfXkRr11pryN6hA9Ctm6ci69QpcX/BAv1rp5SQoL5v9rpqxxwZafyerF2rn+6pnJYoKypS96SSPfyw/pyDBxtPe7M6Hc5b8/KRI/VjA8SY27TRj8Wfz5zdblxl5us8Dd1svTF7zBERERERNRZWYFHQhUvyzQqsuvGnaqmusrOBZcvUVUQ2G/DAA2IVOqvjlNVlvGYVQko2m6hcqqzUPyZXZhlVAsni4kSVVCAVRtr3ZOVK4/HOmwf8/e/A2bPA8ePG59NWdgXzffZWrTVlCvDCC/pjli8X467LWLRVWFbPY7W6LBisVA0SERERNTfh8j2UzLECi4jqRUOuoFaXpvHBrhYz6yGlJEnG4RUgKr8WLBCNw83G4HCoq7aMKm+MqnS6dQMGDlS/J0bjdThEIFhZ6VmJT0nubSVXdtXH++ytWuu550QAqKTsa1aXsdjtwOuvAz17ipvV8zRks/XG7jFHRERERNQYWIFFQRcuyTcrsJoOs6onq72Igl0tZqUKCwA6dQKOHvXcl689ZIhxhY0Zo8obf6p0rI5XuX999Hjyp5Ju3jx18Nic+k6FQo85IiIiolATLt9DyRz/qktETZKywuiJJ/RVQv70Igp2tZiyqklekU8rIwNYtEi9Ta788reSxmh/f6p0rIxX3l6fPZ78qaSbObNh+06FklDoMUdERERE1ND4110iapK0YYe2ubj2C72vxtfBnAKmDMTef994SuHs2cDo0cYhjNk0xD59gN691dtSUkSAp31ee/boz2EW9Pgab0aG2F7f00G9hW7a9y89HTh9GujYMXhjakrN0Ru6cTwRERERUWPjFEIKunAp3eQUwtDmbdqb0XSqxmx8nZcnGo8XF4vQTTk+s+bf2ueXng68/TZw8qR6e69ewK5d+mtmZQGPPKLe12iandG0vfJysaqft+Pqg7epcWbTKoP5/jW15ugN2TieiIiIKNSFy/dQMscKrGaqoqICTz31FHr06IGYmBh06NAB999/P44dO9bYQyOyxKhKSdlcXFuR05iNrzMzgS1bgHff1VcxmVV+aSts9u4V+2i3a6eSySZOtFalYzRtr7BQrHTo7bj64G1qXEO8f02tOXpDNo4nIiIiImpsDLCaocrKSlx33XV4+umncf78edx6663o3Lkz3n77bVx++eU4cOBAYw8xJMjFiSxSDE1GYcdzz4mgyOgLvVHg1dBTr/wJHMz6cmm3K6chyuTnZaW3l1k48+ST3o+rr+l2ZqFbQ7x/ofAZISIiIiIiYwywmqH58+fjm2++wcCBA7F3714sX74c3377LRYvXoyioiLcf//9jT3EkPDSSy+pflJoUAYnjz/uad7erp33oMGsumfBgsCCmIbol2QWeCm3Gz2vn38WUw67dgU2bvQempmFNjNmeD/On4br/vAW3NV343I2RyciIiIiCl3sgdXMVFdXIyUlBWfOnMHWrVtx+eWXqx7v168ftm/fju+++w5XXnllQNcIl7nHffr0wc6dO9GnTx/s2LGjsYdDF5j1KerXD/jf/7wfq+yxVNfeSqHUL8nlAlq0EL2rAhmPtt+WlZ5XZj3I6rNfltH7F+xwqSGuQURERETBFy7fQ8kc/1rezGzatAlnzpxBenq6LrwCgFEXvnl+/PHHDT20kLJ7927s3LkTgPgDcM+ePY08IpKZTXmbOdP3sUbVPb76HplVWnXs6N/4gsloRb6oqMDHE8iKdnv2eKrfZA4HsHu372MDZWVKZFO4BhERERER+S+ysQdADWvbtm0AgCuuuMLwcXn79u3bG2xMoaCwsBDffPON+742wFu8eDGGDx/uvj9gwACkpKQ02PjIQw5btCvVWe1TJE+/k8lBjNPp2aYMYuSpclqdO9dtHHVhNqa4OHUVltXxyKGNvKKdldBm7Vr1awaI++vWWQsTA6V9/5rqNYiIiIiIyD8MsJqZw4cPAwA6depk+Li8/dChQw02plAwePBg7PZSOvLGG2/gjTfecN/v2bMndu3a1RBDIw25T5Fy+lpd+hT5CmImTjSeKjhxIiBJwRuHP8zGNH48sGRJYOPxN7Tx9roQEREREREFGwOsZub8+fMAgLi4OMPH4+PjAQDnzp3zea4+2s7PF+zfvx9du3aFU5sKhLDbbrsNzz77rF/7N6XnF25+8xugd29g505RBXXLLfoQyqqHHjIOYh56SJxTeS2ZfE0geOPwh9mY5s8HPvusYcbj7XXhrwYRERERNTRJkmCz2Rp7GFSPGGBRvdi1axeizJryhIFnn33Wr8CL6k9+PhATE/zz3nmnf9esr3FYlZ8vphA25nga+zUgIiIiouatd+/ejT0EqkcMsJqZhIQEAEC50XJlAMrKygAALVq08Hkus9Ud+vTpA0mS3P22mpKDBw+if//+KC0t1T2WlJSEzZs3IzU1tcHHRfVrxQrgt7/13P/HP0SvLZnLBVxxhaey6fvvG7+5d0OMacEC4O23xVRJmc0G3Hcf8Mc/qscQGwtUVOjP8ctfAhs2BHdcRERERERa/fr1a+whUD1jgNXMXHzxxQCAo0ePGj4ub+/SpUudrmOz2eDQLlHWBMTGxhqGVwBQWlqKuLi4Jvm8yLuxY8XKfvn5ovH5mDH6MOj11z1NzqOjG2ecWvU9pvXrgYMH9dv/+1/gqafUYxg+XPTc0po8Wb9aIRERERFRsHH6YPjjAuHNjJxKb9261fBxeXvfvn0bbEyh5MMPP6zT49Q0yavwXXUV8OqrxpVMcpPzzMyGH5+Z+h6TWUN25XZ5DDNnikowpYZalZGIiIiIiMIfA6xmZtCgQWjZsiX279+P//3vf7rHV6xYAQC4Re5Q3cwoA6rhw4erfgLAqlWrGnxM1DBCMaBqbCNHWg+l5NUhlQJZlTE7G+jaFUhL89y6dhXbiYiIiIio+WKA1cxERUXhkUceAQA8/PDD7p5XALBkyRJs374dgwcPxpVXXtlYQ2xUiYmJiImJwSuvvIKVK1cCAFauXImXX34ZMTExaNmyZSOPkKjh+BtKKQOvQKuv1qwBCgrE1EX5VlAArF3r/7mIiIiIiCh82CRJ2Z6XmoPKykoMGTIE3377Ldq3b4/MzEwcOnQI3377LZKTk/HNN9+ga9euAZ+/z4VvsGZN3kNZdXU1amtrERsbC6fTiaioKFRXV8PhcKCiogIRERFhvboikZbLBfTt6+kPtm2b96qqvDxPX65AqtlyckQPMqPto0b5fz4iIiIiah6a8vdQsoYVWM1QTEwMPv/8c8yaNQtxcXFYvXo1Dh06hHvvvRdbt26tU3jV1EVFRSE2NtbwsdjYWIZX1OxY6Q+mVNepmP5MWyQiIiIiouaDFVgUdOGSfGsrsCh0ZGcDy5YByj+9bDbggQeAGTMab1wUHNoqLFZfEREREZEv4fI9lMyxAouImhz2SQpvweilRURERERE4YUBFhE1ORMn+redmhZ/py0SEREREVH4i2zsARAR+Uuu0FFWB7NSJ7zIvbSIiIiIiIgAVmARURNktwOzZ6u3zZ7NSh1ZdjbQtSuQlua5de0qthMRERERETVF/LpHRE0S+ySZY48wIiIiIiIKNwywiKhJYp8kc+wRRkRERERE4YY9sIioyWKfJGPsEUZEREREROGGNQtEFBTsuxQ62COMiIiIiIjCDb/OEFFQsO9SaGGPMCIiIiIiCicMsIgoKNh3KbSwRxgREREREYUT9sAioqBg36XQwx5hREREREQULvhv8kQUFOy7RERERERERPWFXy2JKGjYd4mIiIiIiIjqAwMsIgoa9l0iIiIiIiKi+sAeWEQUVOy7RERERERERMHG+ggiIiIiIiIiIgppDLCIiIiIiIiIiCikMcAiIiIiIiIiIqKQxgCLiIiIiIiIiIhCGgMsIiIiIiIiIiIKaQywiIiIiIiIiIgopDHAIiIiIiIiIiKikMYAi4iIiIiIiIiIQhoDLCIiIiIiIiIiCmkMsIiIiIiIiIiIKKQxwCIiIiIiIiIiopDGAIuIiIiIiIiIiEJaZGMPgMLP4cOH4XQ60adPn8YeSp1IkgQA6NevH2w2WyOPhoiIiIiIiMzs378fDoejsYdB9YgVWBR08fHxYfEHx4EDBxAdHc3wqpnZv38/9u/f39jDoAbG97354XvePPF9b574vjc/fM+bJ6fTiYqKisYeBtUjVmBR0J08ebKxhxAUcgVZfn5+I4+EGhLf9+aJ73vzw/e8eeL73jzxfW9++J43T019BhD5xgosIiIiIiIiIiIKaQywiIiIiIiIiIgopDHAIiIiIiIiIiKikMYAi4iIiIiIiIiIQhoDLCIiIiIiIiIiCmk2SZKkxh4EERERERERERGRGVZgERERERERERFRSGOARUREREREREREIY0BFhERERERERERhTQGWEREREREREREFNIYYBERERERERERUUhjgEVERERERERERCGNARYREREREREREYU0BlhEGhUVFXjqqafQo0cPxMTEoEOHDrj//vtx7Nixxh4aWTBkyBDYbDbT22effWZ43DvvvIP+/fsjISEBrVu3xk033YSvvvrK67U2bdqEm266Ca1bt0ZCQgL69++P9957rz6eVrP3/fff49lnn8WIESPQqVMn9/vpS0O9r0ePHsV9992HDh06ICYmBj169MDs2bNRWVnp1/MkNX/f9zlz5nj9/X/yySdNj+X7HhrKy8uxevVqPPDAA7jkkksQExOD+Ph49OvXD/PmzcP58+dNj+Xve9MVyPvO3/emb8mSJRgxYgS6d++Oli1bIjo6Gl26dME999yDH3/80fQ4/q43bf6+7/xdJxWJiNwqKiqkAQMGSACk9u3bS2PGjJH69+8vAZCSk5Ol/fv3N/YQyYfBgwdLAKSRI0dK48aN0922b9+uO2by5MkSACk2Nla69dZbpaFDh0qRkZFSRESE9OGHHxpeZ8WKFVJERIRks9mkwYMHSyNHjpSSkpIkANLUqVPr+Vk2P7feeqsEQHfzpqHe159++klq27atBEDKyMiQxowZI3Xt2lUCIA0aNEiqrKys69Nvtvx932fPnu1+3Y1+/z/44APD4/i+h4433njD/T736tVLGj16tDR06FCpRYsWEgCpZ8+e0s8//6w7jr/vTVsg7zt/35u+Nm3aSDExMVL//v2l22+/Xbr99tulHj16SAAkh8Mhffzxx7pj+Lve9Pn7vvN3nZQYYBEpzJgxQwIgDRw4UDp37px7++LFiyUA0uDBgxtvcGSJHGAVFBRY2n/dunUSAKlNmzbS3r173du/+uorKSoqSkpKSpJKSkpUxxQXF0uJiYkSAGnlypXu7SdPnpS6desmAZA+//zzIDwbkj377LPSrFmzpH/961/SiRMnpOjoaK9BRkO+r4MGDZIASJMmTXJvczqd0u233y4BkGbPnh3w827u/H3f5b/kvv3225avwfc9tLzzzjvS73//e2nnzp2q7cePH5cuv/xyCYB05513qh7j73vTF8j7zt/3pu/LL7+UKioqdNtfeeUVCYDUrl07yel0urfzdz08+Pu+83edlBhgEV1QVVUltWzZUgIgbd26Vfd43759JQDSd9991wijI6v8DbB+/etfSwCkF154QffYpEmTJADSokWLVNsXLlwoAZBuvfVW3TGrVq2SAEjDhw8PYPRkla8go6He12+//VYCIKWkpOj+Ve7kyZOSw+GQWrVqpfqLGAWuPgIsvu9Nx1dffSUBkKKjo6Wqqir3dv6+hzez952/7+EtPT1dAiBt27bNvY2/6+HP6H3n7zopsQcW0QWbNm3CmTNnkJ6ejssvv1z3+KhRowAAH3/8cUMPjepJRUUFNmzYAMDz/iqZveeffPKJ6TE333wzYmJisH79es6VbyQN+b7Kx9xyyy2Ijo5WHdOuXTtkZmaipKQEX375ZR2eEdUnvu9NR79+/QAAVVVVKC4uBsDf9+bA6H0PFN/3psPhcAAAoqKiAPB3vbnQvu+B4vsevhhgEV2wbds2AMAVV1xh+Li8ffv27Q02JgrcsmXLMGHCBDzyyCN48cUXcfjwYd0+e/bsQVVVFZKTk9GpUyfd42bvubfPSlRUFDIyMlBZWYm9e/cG46mQnxryfeWfG6Fpw4YNePTRRzF+/HjMnz8f33//vem+fN+bjgMHDgAQX3Bat24NgL/vzYHR+67E3/fw8/7772PPnj3o3r07unfvDoC/682B0fuuxN91AoDIxh4AUaiQAw6j/ykqtx86dKjBxkSBmz9/vur+Y489hlmzZmHWrFnubb7e8/j4eCQlJaGkpATnzp1DixYtcPbsWZw5c8brcZ06dcJ3332HQ4cOoW/fvsF4OuSHhnxf+edGaHr//fdV92fNmoWRI0finXfeQUJCgns73/emZenSpQCAYcOGuf91nL/v4c/ofVfi73vT9/zzzyM/Px9lZWXYtWsX8vPz0aFDB/zjH/9AREQEAP6uhyMr77sSf9cJYAUWkZu8RHNcXJzh4/Hx8QCAc+fONdiYyH9ZWVl4//33sX//fpSXl2PPnj3Izs5GZGQknnrqKfdfhAHf7zmgf9+VS3nzsxKaGvJ95Z8boaVbt25YtGgR8vPzcf78eRw5cgR/+9vf0LFjR6xcuRJ33323an++703Hp59+imXLlsHhcODpp592b+fve3gze98B/r6HkzVr1uDdd9/FihUrkJ+fjy5duuAf//gHrrzySvc+/F0PP1bed4C/66TGAIuIwsq8efNw1113oWvXroj9/+3de0zX1R/H8ReI3FT4ctFBXvBupekKTQMc3gLUeS11MQtotmqL3PCGOEJruqgwp222Gop/tSYN4+t1uZXincy8jEynqEleUEEUFTXP749ffJM7KOAHeT627x9+zud8zvnw5gB7+fmer4eH+vbtq6SkJG3YsEGStHjxYt2+ffvJThJAk5g5c6bmzJmj559/Xu3atVOXLl0UHR2t3Nxc+fn5acOGDdq3b9+TniYa6Pjx45o5c6aMMfr8888deyLh6VZX3VnvT4/t27fLGKOioiLt3LlTffr0UXh4uJYuXfqkp4YmVN+6s9bxMAIs4F/lj57eunWr2vbS0lJJUocOHZptTmg8ERERGjx4sIqLi7V//35Jdddcqlr3hx9R5nvFmpqzrvzcaBkCAwMVFxcnSdq6davjOHW3voKCAkVFRamoqEgJCQmaPXt2hXbW+9OprrrXhvXectlsNg0fPlybN29WcHCwkpOTlZubK4m1/jSrre61Ya23TgRYwL+6desmSTp//ny17eXHg4KCmm1OaFzlG0JeuHBBUt01Ly0tVXFxsXx8fBy/rLy8vOTt7V1rP75XnqzmrCs/N1qOyutfou5Wd+3aNUVEROjs2bOKi4vTF198UeUc1vvTpz51rwvrvWVr27atZsyYIWOM41MFWetPv+rqXhfWeutDgAX8q/zR9N9++63a9vLjbMrdchUVFUn67z3s/fr1k5ubmwoLC1VQUFDl/JpqXtv3yr1793Ts2DG5u7urb9++jTp/1E9z1pWfGy1H5fVfjrpb082bNzV27Fjl5eVp6tSp+vbbb+Xk5FTlPNb706W+da8L673l8/f3lyQVFhZKYq23FpXrXhfWeutDgAX8KzQ0VN7e3jp16pR+//33Ku2ZmZmSpAkTJjTzzNAYCgsLlZOTI+m/j8H18PDQqFGjJEnr16+v0qemmo8fP75C+8M2btyoO3fuaMyYMXJ3d2+8G0C9NWddy/vY7XaVlZVV6HPp0iXl5OTIx8dHoaGhj3FHeFzGGGVlZUmq+vHY1N16ysrKNGnSJB04cECRkZE1fiKVxHp/mjSk7rVhvT8dduzYIUnq1auXJNZ6a1G57rVhrbdSBoDDokWLjCQTEhJibt686TielpZmJJnw8PAnNznUaffu3SYrK8vcv3+/wvH8/HwTGhpqJJmJEydWaPvpp5+MJOPn52dOnDjhOL5nzx7j5uZmbDabKSoqqtDn6tWrxsvLy0gyP/zwg+P4pUuXTO/evY0k8/PPPzf6/eE/bm5uprZfYc1Z1/LvrdmzZzuO3bt3z0ydOtVIMikpKY96m6iktrpfvnzZfPXVV6akpKTC8Rs3bph3333XSDIBAQGmtLS0Qjt1t5b79++bKVOmGElm+PDhVepVHdZ7y9fQurPeW75du3aZLVu2mH/++afC8bt375qVK1caZ2dn4+HhYc6dO+doY623fA2tO2sdlRFgAQ+5ffu2GTp0qJFkAgMDzfTp0x3/7tixozl16tSTniJqsXbtWscvsnHjxpno6GgTGhpq3N3djSTTv39/c+nSpSr9Zs+ebSQZT09PM2nSJDN27Fjj4uJi2rRpY7KysqodKzMz0zg7OxsnJyczcuRI8/rrrxubzWYkmYSEhCa+09Zn48aNZujQoY6Xk5OTkVTh2MaNGyv0aa66njhxwvj5+RlJ5oUXXjAzZswwPXv2dIThd+7caewvR6vRkLrn5+cbSaZ9+/Zm5MiRJjo62rz66quO2thsNrNr165qx6Hu1rFixQojyUgyU6ZMMTExMdW+CgsLK/RjvbdsDa07673lK/+bzd/f30RGRpro6GgTERFhAgMDjSTj7u5uvv/++yr9WOstW0PrzlpHZQRYQCW3bt0yycnJplevXsbV1dUEBASY2NhY89dffz3pqaEOeXl55v333zcvvfSS6dixo3FxcTHe3t5m2LBhJi0tzdy6davGvmvXrjXBwcHG09PT2Gw2ExUVZXbv3l3reLt27TJRUVHGZrMZT09PM3jwYJORkdHYtwXz3x88tb3Wrl1bbb/mqOu5c+dMbGysCQgIMK6urqZ3794mOTnZ3L59+3Fuu9VrSN1LSkrMggULTHh4uOncubNxc3Mznp6epn///mbOnDnm/PnztY5F3a0hJSWlzppLMvn5+VX6st5brobWnfXe8p0+fdokJSWZ0NBQExgYaNq2bWvatWtn+vfvb+Lj483Jkydr7Mtab7kaWnfWOipzMsYYAQAAAAAAABbFJu4AAAAAAACwNAIsAAAAAAAAWBoBFgAAAAAAACyNAAsAAAAAAACWRoAFAAAAAAAASyPAAgAAAAAAgKURYAEAAAAAAMDSCLAAAAAAAABgaQRYAAAAAAAAsDQCLAAAAAAAAFgaARYAAAAAAAAsjQALAAC0Ck5OTnW+YmNjn/Q0G6S4uFh+fn6aNm1ak45z6NAhOTk56bPPPmvScQAAAGriZIwxT3oSAAAATc3JyUmSFBMTU+M5YWFhmjVrVrPMJyMjQ3FxcUpJSdHixYsf6Rrz5s1TWlqajhw5ogEDBjTuBCuZNGmSdu7cqVOnTsnX17dJxwIAAKjM5UlPAAAAoDllZGQ86Sk0igsXLmjVqlWaMGFCk4dXkrRw4UJlZ2crNTVVqampTT4eAADAw3gLIQAAQAu0Zs0alZWV6a233mqW8YYNG6bevXtrzZo1unv3brOMCQAAUI4ACwAAoAY5OTn64IMPNHDgQPn4+MjDw0PPPvusEhMTVVxcXG2fPXv2aPLkyQoKCpKbm5sCAgL08ssvKzExUTdv3pQkjRgxQnFxcZKkJUuWVNiHqz5PiBljlJ6erg4dOmj8+PFV2hcvXuy41sGDBzV27FjZbDb5+vpq+vTpOn/+vCSptLRU8+fPV/fu3eXu7q4BAwYoMzOzxnHfeOMNXblyRVlZWXXOEQAAoDERYAEAANRg3rx5Sk9Pl4eHh0aPHq3Ro0erpKREqampCgsLcwRS5ex2u4YPH67s7GwFBgZq6tSpevHFF3Xt2jWlpqbqypUrkqSoqCiFhoZKkgYNGqSYmBjHq3fv3nXOKy8vT/n5+Ro2bJjc3d1rPG///v0KDQ1VYWGhIiMj5efnp/Xr12v06NG6fv26Ro4cqXXr1mnIkCF65ZVXlJeXp+nTp2vbtm3VXm/EiBGSpE2bNtXnywcAANBo2AMLAACgBikpKQoJCZG3t7fjWFlZmT788EN98803Wr58uT766CNH2xdffKEHDx4oMzNTr732WoVr5ebmys/PT5KUmJiogIAA7d69W5MnT27wJu45OTmSpCFDhtR63tdff63Vq1frvffekyTdu3dP48aN0/bt2xUSEqKAgACdPn1a7dq1kySlp6dr1qxZWrZsmSIjI6tcb/DgwXJ2dtaOHTsaNF8AAIDHxRNYAACgVXn47XqVXxs2bKhw7tixYyuEV5Lk5uamFStWyMXFRT/++GOFtsLCQknSmDFjqow7ZMgQdejQoVHu4ciRI5Kkfv361XpeWFiYI7ySpLZt2yo+Pl6SdPz4ca1evdoRXklSbGys/P39tXfvXt27d6/K9by8vBQYGKhz586pqKioMW4FAACgXngCCwAAtCoxMTE1tnXr1q3KsYKCAtntdh0/flwlJSV68OCBJMnV1VUnT56scG5wcLD++OMPvfnmm0pOTlZwcLCcnRv//wsvX74sSfLx8an1vIiIiCrHevbsKUnq3r27+vbtW6GtTZs2CgoK0sGDB3XlyhUFBgZW6e/r66uCggIVFhbWOT4AAEBjIcACAACtSn02SS+3fPlyJSYmVvs0UnWWLVumo0ePym63y263y8fHR2FhYZo4caJmzpxZ635VDXH9+nVJqvOJrs6dO1c51r59+xrbHm4vKyurtt3Ly0uSatzEHgAAoCnwFkIAAIBq7Nu3T3PmzJGnp6cyMjJ05swZ3blzR8YYGWOqfTqpa9eu+vXXX7Vt2zbFx8era9eustvteueddzRw4EBdvXq1UeZW/rbGGzdu1HpebU9/PeqTYeXhmc1me6T+AAAAj4IACwAAoBpZWVmSpKVLlyomJkZBQUFyc3OTJN2+fVsXL16stp+Li4siIiK0cuVKHT58WGfOnNGoUaN08uRJpaamNsrcOnXqJEm6du1ao1yvIcr3vurYsWOzjw0AAFovAiwAAIBqlAc1Xbp0qdK2fv16GWPqdZ2goCAtWLBAknTs2DHHcVdXV0nS/fv3Gzy3QYMGSZL+/PPPBvd9HCUlJfr777/VrVs39r8CAADNigALAACgGuUbnKenp1fYAysvL88RSFX25ZdfVvtk1ubNmyX9/y2G5Z555hlJjxZCDR8+XJKUm5vb4L6PIzc3V8YYhYeHN+u4AAAAbOIOAABaldjY2BrbunXrpo8//liSFBcXp7S0NNntdvXr109DhgzRtWvXtGPHDk2ePFkHDhzQ2bNnK/RfsmSJ5s6dq0GDBqlPnz4yxujw4cM6ceKEfH19NXfuXMe5w4YNU6dOnZSZmakRI0aoZ8+ecnZ21ttvv62QkJBa7+G5555Tjx49tH//ft25c6fRNoevyy+//CJJGj9+fLOMBwAAUI4ACwAAtCrr1q2rsW3QoEGOAMvPz0+5ublasGCBduzYoezsbPXo0UOffPKJ5s6dq169elXpv2rVKm3dulUHDx7Uli1bJP3/qauEhAQlJCRU+OQ/d3d3bdq0SUlJSTpw4IB27twpY4zCwsLqDLCcnJw0a9YsLVq0SHa7XdOmTXuUL0WDfffdd/L399eUKVOaZTwAAIByTqa+GzgAAADAMi5evKgePXpozJgxstvtTT7e3r17FRISovnz5zfaZvQAAAD1xR5YAAAALVBAQIDi4+O1adMmHT16tMnH+/TTT2Wz2Wrc/wsAAKApEWABAAC0UElJSfLx8dGSJUuadJxDhw4pOztbCxculK+vb5OOBQAAUB3eQggAAAAAAABL4wksAAAAAAAAWBoBFgAAAAAAACyNAAsAAAAAAACWRoAFAAAAAAAASyPAAgAAAAAAgKURYAEAAAAAAMDSCLAAAAAAAABgaQRYAAAAAAAAsDQCLAAAAAAAAFgaARYAAAAAAAAsjQALAAAAAAAAlkaABQAAAAAAAEsjwAIAAAAAAIClEWABAAAAAADA0giwAAAAAAAAYGkEWAAAAAAAALA0AiwAAAAAAABYGgEWAAAAAAAALI0ACwAAAAAAAJZGgAUAAAAAAABLI8ACAAAAAACApRFgAQAAAAAAwNIIsAAAAAAAAGBpBFgAAAAAAACwNAIsAAAAAAAAWBoBFgAAAAAAACyNAAsAAAAAAACWRoAFAAAAAAAASyPAAgAAAAAAgKURYAEAAAAAAMDSCLAAAAAAAABgaQRYAAAAAAAAsDQCLAAAAAAAAFgaARYAAAAAAAAsjQALAAAAAAAAlkaABQAAAAAAAEv7HxVdoAODmHvIAAAAAElFTkSuQmCC",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1051,14 +970,29 @@
},
{
"cell_type": "code",
- "execution_count": 27,
+ "execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a76c44781f3c4823a5bd254b083af1e6",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1066,9 +1000,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "0fed13c8dfd6431b9413e6ef7794a801",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1076,9 +1025,24 @@
},
{
"data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGzCAYAAAABsTylAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwEUlEQVR4nO3dd3zT5eL+/ystbSnQFsoUKUPKYQ8BlaGogKCignoEjigUEFGKBeoAVLZaQBlHRT2oDPm4qAgOBGQJiOy9pEzhMAQstCxLae7fH/6a7wlpoe+akDfk9Xw88pDcuZNcyd3KxXskDmOMEQAAgA0F+TsAAABAbigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqwGVUrFhRcXFx/o5x3XvzzTd10003KTg4WPXq1fN3nOuKw+HQ0KFD/R0DyDeKCgLGlClT5HA4tHbt2hxvv+uuu1SrVq2//Tw//PADfzFY8OOPP+qll15S06ZNNXnyZL3xxhv+jnTN4WcO17MC/g4A2NnOnTsVFGStz//www+aMGECf3Hk0aJFixQUFKSPP/5YoaGh/o5zTbrcz9z58+dVoAD/q8e1iy0qwGWEhYUpJCTE3zEsOXv2rL8jWHLs2DGFh4dTUnykYMGCFBVc0ygqwGVceoxKZmamhg0bpipVqqhgwYIqXry4br/9ds2fP1+SFBcXpwkTJkj669iA7Eu2s2fP6vnnn1dMTIzCwsJUtWpVvfXWW7r0S8zPnz+vhIQElShRQhEREXrooYd06NAhj+MNhg4dKofDoe3bt+vxxx9XsWLFdPvtt0uSNm/erLi4ON10000qWLCgypQpo27duumPP/5we67sx0hJSdETTzyhqKgolSxZUoMGDZIxRgcPHlTbtm0VGRmpMmXKaMyYMXl67y5evKgRI0aocuXKCgsLU8WKFfXyyy8rIyPDNcfhcGjy5Mk6e/as672aMmVKro+5bNkyPfbYYypfvrzCwsIUExOjfv366fz5827z4uLiVKRIEe3du1etW7dW4cKFVbZsWQ0fPtzjvfb2mkjSoUOH1K1bN5UuXVphYWGqWbOmJk2a5PF6MjIyNGTIEMXGxrpez0svveT2Hl3JlX7mcvuZ+Tvr7Y3cQF5RsxFw0tLSdOLECY/xzMzMK9536NChSkpK0lNPPaVbb71V6enpWrt2rdavX6977rlHPXv21OHDhzV//nxNmzbN7b7GGD300ENavHixunfvrnr16mnevHl68cUXdejQIY0bN841Ny4uTtOnT9eTTz6pRo0aacmSJWrTpk2uuR577DFVqVJFb7zxhusv2Pnz52vv3r3q2rWrypQpo23btmnixInatm2bVq5c6faXmSR16NBB1atX18iRIzV79my99tprio6O1n/+8x81b95co0aN0qeffqoXXnhBt9xyi5o1a3bZ9+qpp57S1KlT9c9//lPPP/+8Vq1apaSkJO3YsUMzZ86UJE2bNk0TJ07U6tWr9dFHH0mSmjRpkutjJicn69y5c3r22WdVvHhxrV69Wu+8847++9//Kjk52W1uVlaW7r33XjVq1EijR4/W3LlzNWTIEF28eFHDhw/32Zr8/vvvatSokRwOh3r37q2SJUtqzpw56t69u9LT09W3b19JktPp1EMPPaSff/5ZTz/9tKpXr64tW7Zo3LhxSklJ0axZsy77/ma73M/c5eR3vb2VG8gzAwSIyZMnG0mXvdSsWdPtPhUqVDBdunRxXa9bt65p06bNZZ8nPj7e5PSrNWvWLCPJvPbaa27j//znP43D4TC7d+82xhizbt06I8n07dvXbV5cXJyRZIYMGeIaGzJkiJFk/vWvf3k837lz5zzGPv/8cyPJLF261OMxnn76adfYxYsXTbly5YzD4TAjR450jZ88edKEh4e7vSc52bhxo5FknnrqKbfxF154wUgyixYtco116dLFFC5c+LKPd7nXlJSUZBwOh/ntt9/cHlOSee6551xjTqfTtGnTxoSGhprjx48bY3yzJt27dzc33HCDOXHihNvcjh07mqioKNdrmDZtmgkKCjLLli1zm/fBBx8YSWb58uV5ek+Myf1nzhiT689Mftfbm7mBvGDXDwLOhAkTNH/+fI9LnTp1rnjfokWLatu2bdq1a5fl5/3hhx8UHByshIQEt/Hnn39exhjNmTNHkjR37lxJUq9evdzmPffcc7k+9jPPPOMxFh4e7vrzn3/+qRMnTqhRo0aSpPXr13vMf+qpp1x/Dg4OVsOGDWWMUffu3V3jRYsWVdWqVbV3795cs0h/vVZJSkxMdBt//vnnJUmzZ8++7P1z87+v6ezZszpx4oSaNGkiY4w2bNjgMb93796uP2dv4bhw4YIWLFjgyunNNTHGaMaMGXrwwQdljNGJEydcl9atWystLc313icnJ6t69eqqVq2a27zmzZtLkhYvXpyv9yiv8rve/s6NwMOuHwScW2+9VQ0bNvQYL1asWI67hP7X8OHD1bZtW/3jH/9QrVq1dO+99+rJJ5/MU8n57bffVLZsWUVERLiNV69e3XV79n+DgoJUqVIlt3mxsbG5PvalcyUpNTVVw4YN0xdffKFjx4653ZaWluYxv3z58m7Xo6KiVLBgQZUoUcJj/NLjXC6V/RouzVymTBkVLVrU9VqtOnDggAYPHqxvv/1WJ0+edLvt0tcUFBSkm266yW3sH//4hyRp//79rpzeXJPjx4/r1KlTmjhxoiZOnJjja8hei127dmnHjh0qWbLkZef5Sn7X29+5EXgoKoAFzZo10549e/TNN9/oxx9/1EcffaRx48bpgw8+cPsX6tX2v1sasrVv316//PKLXnzxRdWrV09FihSR0+nUvffeK6fT6TE/ODg4T2OSPA40zc2lx8H8HVlZWbrnnnuUmpqq/v37q1q1aipcuLAOHTqkuLi4HF/T1Zad4YknnlCXLl1ynJNdap1Op2rXrq2xY8fmOC8mJsY3If9/+V1vf+dG4KGoABZFR0era9eu6tq1q86cOaNmzZpp6NChrqKS21/OFSpU0IIFC3T69Gm3f8H/+uuvrtuz/+t0OrVv3z5VqVLFNW/37t15znjy5EktXLhQw4YN0+DBg13j+dlllR/Zr2HXrl2urRPSXweanjp1yvVardiyZYtSUlI0depUde7c2TWefcbVpZxOp/bu3evaiiJJKSkpkv46mys7pzfXpGTJkoqIiFBWVpZatmx52ddTuXJlbdq0SS1atPjbhc6bhfBKvJkbyAuOUQEsuHSXR5EiRRQbG+t2WmbhwoUlSadOnXKbe//99ysrK0vvvvuu2/i4cePkcDh03333SZJat24tSXrvvffc5r3zzjt5zpn9L+NLt3yMHz8+z4/xd9x///05Pl/2v8IvdwZTbnJ6TcYY/fvf/871Pv/7Xhtj9O677yokJEQtWrRw5fTmmgQHB+vRRx/VjBkztHXrVo88x48fd/25ffv2OnTokD788EOPeefPn7f0eTi5/cz5gjdzA3nBFhXAgho1auiuu+5SgwYNFB0drbVr1+qrr75yO2izQYMGkqSEhAS1bt1awcHB6tixox588EHdfffdeuWVV7R//37VrVtXP/74o7755hv17dtXlStXdt3/0Ucf1fjx4/XHH3+4ToXN3hqQl3/FRkZGqlmzZho9erQyMzN144036scff9S+fft88K54qlu3rrp06aKJEyfq1KlTuvPOO7V69WpNnTpV7dq109133235MatVq6bKlSvrhRde0KFDhxQZGakZM2Z4HKuSrWDBgpo7d666dOmi2267TXPmzNHs2bP18ssvu46v8MWajBw5UosXL9Ztt92mHj16qEaNGkpNTdX69eu1YMECpaamSpKefPJJTZ8+Xc8884wWL16spk2bKisrS7/++qumT5+uefPm5XgsVU5y+5nzBW/mBvLEL+caAX6QfXrymjVrcrz9zjvvvOLpya+99pq59dZbTdGiRU14eLipVq2aef31182FCxdccy5evGiee+45U7JkSeNwONxOGz19+rTp16+fKVu2rAkJCTFVqlQxb775pnE6nW7Pe/bsWRMfH2+io6NNkSJFTLt27czOnTuNJLfTR7NPNc0+3fZ//fe//zUPP/ywKVq0qImKijKPPfaYOXz4cK6nq176GLmdNpzT+5STzMxMM2zYMFOpUiUTEhJiYmJizMCBA82ff/6Zp+fJyfbt203Lli1NkSJFTIkSJUyPHj3Mpk2bjCQzefJkj8fcs2ePadWqlSlUqJApXbq0GTJkiMnKynJ7TG+viTHG/P777yY+Pt7ExMSYkJAQU6ZMGdOiRQszceJEt3kXLlwwo0aNMjVr1jRhYWGmWLFipkGDBmbYsGEmLS0tT++JMZf/mfPFensrN5AXDmPyeFQcAL/auHGjbr75Zv3f//2fOnXq5O84thYXF6evvvpKZ86c8enzsCaA73GMCmBDl34kvPTX8R5BQUFX/ERY+AZrAvgHx6gANjR69GitW7dOd999twoUKKA5c+Zozpw5evrppzn900/8sSZpaWk5FqT/VaZMGZ88N2AXFBXAhpo0aaL58+drxIgROnPmjMqXL6+hQ4fqlVde8Xe0gOWPNenTp4+mTp162Tnsvcf1jmNUAMCmtm/frsOHD192zpU+rwW41lFUAACAbXEwLQAAsK1r+hgVp9Opw4cPKyIigo9yBgDgGmGM0enTp1W2bFkFBV1+m8k1XVQOHz7MGRAAAFyjDh48qHLlyl12zjVdVLK/ROzgwYOKjIz0cxoAAJAX6enpiomJcfsy0Nxc00Ule3dPZGQkRQUAgGtMXg7b4GBaAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWwX8HQAAgEBRccBsf0ewbP/INn59fraoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA26KoAAAA2/JrUcnKytKgQYNUqVIlhYeHq3LlyhoxYoSMMf6MBQAAbKKAP5981KhRev/99zV16lTVrFlTa9euVdeuXRUVFaWEhAR/RgMAADbg16Lyyy+/qG3btmrTpo0kqWLFivr888+1evXqHOdnZGQoIyPDdT09Pf2q5AQAAP7h110/TZo00cKFC5WSkiJJ2rRpk37++Wfdd999Oc5PSkpSVFSU6xITE3M14wIAgKvMr1tUBgwYoPT0dFWrVk3BwcHKysrS66+/rk6dOuU4f+DAgUpMTHRdT09Pp6wAAHAd82tRmT59uj799FN99tlnqlmzpjZu3Ki+ffuqbNmy6tKli8f8sLAwhYWF+SEpAADwB78WlRdffFEDBgxQx44dJUm1a9fWb7/9pqSkpByLCgAACCx+PUbl3LlzCgpyjxAcHCyn0+mnRAAAwE78ukXlwQcf1Ouvv67y5curZs2a2rBhg8aOHatu3br5MxYAALAJvxaVd955R4MGDVKvXr107NgxlS1bVj179tTgwYP9GQsAANiEX4tKRESExo8fr/Hjx/szBgAAsCm+6wcAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANgWRQUAANiW5aKyfv16bdmyxXX9m2++Ubt27fTyyy/rwoULXg0HAAACm+Wi0rNnT6WkpEiS9u7dq44dO6pQoUJKTk7WSy+95PWAAAAgcFkuKikpKapXr54kKTk5Wc2aNdNnn32mKVOmaMaMGd7OBwAAApjlomKMkdPplCQtWLBA999/vyQpJiZGJ06c8G46AAAQ0CwXlYYNG+q1117TtGnTtGTJErVp00aStG/fPpUuXdrrAQEAQOCyXFTGjx+v9evXq3fv3nrllVcUGxsrSfrqq6/UpEkTrwcEAACBq4DVO9SpU8ftrJ9sb775poKDg70SCgAAQMrn56icOnVKH330kQYOHKjU1FRJ0vbt23Xs2DGvhgMAAIHN8haVzZs3q0WLFipatKj279+vHj16KDo6Wl9//bUOHDigTz75xBc5AQBAALK8RSUxMVFdu3bVrl27VLBgQdf4/fffr6VLl3o1HAAACGyWi8qaNWvUs2dPj/Ebb7xRR48e9UooAAAAKR9FJSwsTOnp6R7jKSkpKlmypFdCAQAASPkoKg899JCGDx+uzMxMSZLD4dCBAwfUv39/Pfroo14PCAAAApflojJmzBidOXNGpUqV0vnz53XnnXcqNjZWERERev31132REQAABCjLZ/1ERUVp/vz5Wr58uTZt2qQzZ86ofv36atmypS/yAQCAAGa5qGRr2rSpmjZt6s0sAAAAbizv+klISNDbb7/tMf7uu++qb9++3sgEAAAgKR9FZcaMGTluSWnSpIm++uorr4QCAACQ8lFU/vjjD0VFRXmMR0ZG6sSJE14JBQAAIOWjqMTGxmru3Lke43PmzNFNN93klVAAAABSPg6mTUxMVO/evXX8+HE1b95ckrRw4UKNGTNG48eP93Y+AAAQwCwXlW7duikjI0Ovv/66RowYIUmqWLGi3n//fXXu3NnrAQEAQODK1+nJzz77rJ599lkdP35c4eHhKlKkiLdzAQAA5P9zVCTx3T4AAMCnLB9M+/vvv+vJJ59U2bJlVaBAAQUHB7tdAAAAvMXyFpW4uDgdOHBAgwYN0g033CCHw+GLXAAAANaLys8//6xly5apXr16PogDAADw/1je9RMTEyNjjNcCHDp0SE888YSKFy+u8PBw1a5dW2vXrvXa4wMAgGuX5aIyfvx4DRgwQPv37//bT37y5Ek1bdpUISEhmjNnjrZv364xY8aoWLFif/uxAQDAtc/yrp8OHTro3Llzqly5sgoVKqSQkBC321NTU/P8WKNGjVJMTIwmT57sGqtUqZLVSAAA4Dpluah489Nnv/32W7Vu3VqPPfaYlixZohtvvFG9evVSjx49cpyfkZGhjIwM1/X09HSvZQEAAPZjuah06dLFa0++d+9evf/++0pMTNTLL7+sNWvWKCEhQaGhoTk+T1JSkoYNG+a15wcAXJsqDpjt7wi4ShwmH0fG7tmzR5MnT9aePXv073//W6VKldKcOXNUvnx51axZM8+PExoaqoYNG+qXX35xjSUkJGjNmjVasWKFx/yctqjExMQoLS1NkZGRVl8GAOAaRVG5evaPbOP1x0xPT1dUVFSe/v62fDDtkiVLVLt2ba1atUpff/21zpw5I0natGmThgwZYumxbrjhBtWoUcNtrHr16jpw4ECO88PCwhQZGel2AQAA1y/LRWXAgAF67bXXNH/+fIWGhrrGmzdvrpUrV1p6rKZNm2rnzp1uYykpKapQoYLVWAAA4Dpkuahs2bJFDz/8sMd4qVKldOLECUuP1a9fP61cuVJvvPGGdu/erc8++0wTJ05UfHy81VgAAOA6ZLmoFC1aVEeOHPEY37Bhg2688UZLj3XLLbdo5syZ+vzzz1WrVi2NGDFC48ePV6dOnazGAgAA1yHLZ/107NhR/fv3V3JyshwOh5xOp5YvX64XXnhBnTt3thzggQce0AMPPGD5fgAA4PpneYvKG2+8oWrVqikmJkZnzpxRjRo11KxZMzVp0kSvvvqqLzICAIAAZWmLijFGR48e1dtvv63Bgwdry5YtOnPmjG6++WZVqVLFVxkBAECAslxUYmNjtW3bNlWpUkUxMTG+ygUAAGBt109QUJCqVKmiP/74w1d5AAAAXCwfozJy5Ei9+OKL2rp1qy/yAAAAuFg+66dz5846d+6c6tatq9DQUIWHh7vdbuXbkwEAAC7Hr9+eDAAAcDmWikpmZqaWLFmiQYMGqVKlSr7KBAAAIMniMSohISGaMWOGr7IAAAC4sXwwbbt27TRr1iwfRAEAAHBn+RiVKlWqaPjw4Vq+fLkaNGigwoULu92ekJDgtXAAACCwWS4qH3/8sYoWLap169Zp3bp1brc5HA6KCgAA8BrLRWXfvn2+yAEAAODB8jEqAAAAV4vlLSrdunW77O2TJk3KdxgAAID/ZbmonDx50u16Zmamtm7dqlOnTql58+ZeCwYAAGC5qMycOdNjzOl06tlnn1XlypW9EgoAAEDy0jEqQUFBSkxM1Lhx47zxcAAAAJK8eDDtnj17dPHiRW89HAAAgPVdP4mJiW7XjTE6cuSIZs+erS5dungtGAAAgOWismHDBrfrQUFBKlmypMaMGXPFM4IAAACssFxUFi9e7IscAAAAHiwfo7Jv3z7t2rXLY3zXrl3av3+/NzIBAABIykdRiYuL0y+//OIxvmrVKsXFxXkjEwAAgKR8FJUNGzaoadOmHuONGjXSxo0bvZEJAABAUj6KisPh0OnTpz3G09LSlJWV5ZVQAAAAUj6KSrNmzZSUlORWSrKyspSUlKTbb7/dq+EAAEBgs3zWz6hRo9SsWTNVrVpVd9xxhyRp2bJlSk9P16JFi7weEAAABC7LW1Rq1KihzZs3q3379jp27JhOnz6tzp0769dff1WtWrV8kREAAAQoy1tUJKls2bJ64403vJ0FAADAjeUtKpMnT1ZycrLHeHJysqZOneqVUAAAAFI+ikpSUpJKlCjhMV6qVCm2sgAAAK+yXFQOHDigSpUqeYxXqFBBBw4c8EooAAAAKR9FpVSpUtq8ebPH+KZNm1S8eHGvhAIAAJDyUVT+9a9/KSEhQYsXL1ZWVpaysrK0aNEi9enTRx07dvRFRgAAEKAsn/UzYsQI7d+/Xy1atFCBAn/d3el0qnPnzhyjAgAAvMpyUQkNDdWXX36pESNGaNOmTQoPD1ft2rVVoUIFX+QDAAABLF+foyJJ0dHRuvvuu3M8AwgAAMAbLB2jcurUKcXHx6tEiRIqXbq0SpcurRIlSqh37946deqUjyICAIBAlectKqmpqWrcuLEOHTqkTp06qXr16pKk7du3a8qUKVq4cKF++eUXFStWzGdhAQBAYMlzURk+fLhCQ0O1Z88elS5d2uO2Vq1aafjw4Ro3bpzXQwIAgMCU510/s2bN0ltvveVRUiSpTJkyGj16tGbOnOnVcAAAILDluagcOXJENWvWzPX2WrVq6ejRo14JBQAAIFkoKiVKlND+/ftzvX3fvn2Kjo72RiYAAABJFopK69at9corr+jChQset2VkZGjQoEG69957vRoOAAAENksH0zZs2FBVqlRRfHy8qlWrJmOMduzYoffee08ZGRmaNm2aL7MCAIAAk+eiUq5cOa1YsUK9evXSwIEDZYyRJDkcDt1zzz169913FRMT47OgAAAg8Fj6ZNpKlSppzpw5OnnypHbt2iVJio2N5dgUAADgE/n6CP1ixYrp1ltv9XYWAAAAN5Y+Qh8AAOBqoqgAAADboqgAAADbylNRqV+/vk6ePCnpr9OUz50759NQAAAAUh6Lyo4dO3T27FlJ0rBhw3TmzBmfhgIAAJDyeNZPvXr11LVrV91+++0yxuitt95SkSJFcpw7ePBgrwYEAACBK09FZcqUKRoyZIi+//57ORwOzZkzRwUKeN7V4XBQVAAAgNfkqahUrVpVX3zxhSQpKChICxcuVKlSpXwaDAAAwPIHvjmdTl/kAAAA8JCvT6bds2ePxo8frx07dkiSatSooT59+qhy5cpeDQcAAAKb5c9RmTdvnmrUqKHVq1erTp06qlOnjlatWqWaNWtq/vz5vsgIAAAClOUtKgMGDFC/fv00cuRIj/H+/fvrnnvu8Vo4AAAQ2CxvUdmxY4e6d+/uMd6tWzdt377dK6EAAACkfBSVkiVLauPGjR7jGzdu5EwgAADgVZZ3/fTo0UNPP/209u7dqyZNmkiSli9frlGjRikxMdHrAQEAQOCyXFQGDRqkiIgIjRkzRgMHDpQklS1bVkOHDlVCQoLXAwIAgMBluag4HA7169dP/fr10+nTpyVJERERXg8GAACQr89RyUZBAQAAvmT5YFpfGTlypBwOh/r27evvKAAAwCZsUVTWrFmj//znP6pTp46/owAAABvxe1E5c+aMOnXqpA8//FDFihXzdxwAAGAjlopKZmamWrRooV27dnktQHx8vNq0aaOWLVtecW5GRobS09PdLgAA4Ppl6WDakJAQbd682WtP/sUXX2j9+vVas2ZNnuYnJSVp2LBhXnt+IL8qDpjt7wiW7R/Zxt8RLON9BmB5188TTzyhjz/++G8/8cGDB9WnTx99+umnKliwYJ7uM3DgQKWlpbkuBw8e/Ns5AACAfVk+PfnixYuaNGmSFixYoAYNGqhw4cJut48dOzZPj7Nu3TodO3ZM9evXd41lZWVp6dKlevfdd5WRkaHg4GC3+4SFhSksLMxqZAAAcI2yXFS2bt3qKhcpKSlutzkcjjw/TosWLbRlyxa3sa5du6patWrq37+/R0kBAACBx3JRWbx4sVeeOCIiQrVq1XIbK1y4sIoXL+4xDgAAAlO+T0/evXu35s2bp/Pnz0uSjDFeCwUAACDlY4vKH3/8ofbt22vx4sVyOBzatWuXbrrpJnXv3l3FihXTmDFj8h3mp59+yvd9AQDA9cfyFpV+/fopJCREBw4cUKFChVzjHTp00Ny5c70aDgAABDbLW1R+/PFHzZs3T+XKlXMbr1Klin777TevBQMAALC8ReXs2bNuW1KypaamcuowAADwKstF5Y477tAnn3ziuu5wOOR0OjV69GjdfffdXg0HAAACm+VdP6NHj1aLFi20du1aXbhwQS+99JK2bdum1NRULV++3BcZAQBAgLK8RaVWrVpKSUnR7bffrrZt2+rs2bN65JFHtGHDBlWuXNkXGQEAQICyvEVFkqKiovTKK694OwsAAICbfBWVkydP6uOPP9aOHTskSTVq1FDXrl0VHR3t1XAAACCwWd71s3TpUlWsWFFvv/22Tp48qZMnT+rtt99WpUqVtHTpUl9kBAAAAcryFpX4+Hh16NBB77//vuuLA7OystSrVy/Fx8d7fNEgAABAflneorJ79249//zzbt9uHBwcrMTERO3evdur4QAAQGCzXFTq16/vOjblf+3YsUN169b1SigAAAApj7t+Nm/e7PpzQkKC+vTpo927d6tRo0aSpJUrV2rChAkaOXKkb1ICAICAlKeiUq9ePTkcDhljXGMvvfSSx7zHH39cHTp08F46AAAQ0PJUVPbt2+frHAAAAB7yVFQqVKjg6xwAAAAe8vWBb4cPH9bPP/+sY8eOyel0ut2WkJDglWAAAACWi8qUKVPUs2dPhYaGqnjx4nI4HK7bHA4HRQUAAHiN5aIyaNAgDR48WAMHDlRQkOWzmwEAAPLMctM4d+6cOnbsSEkBAAA+Z7ltdO/eXcnJyb7IAgAA4Mbyrp+kpCQ98MADmjt3rmrXrq2QkBC328eOHeu1cAAAILDlq6jMmzdPVatWlSSPg2kBAAC8xXJRGTNmjCZNmqS4uDgfxAEAAPh/LB+jEhYWpqZNm/oiCwAAgBvLRaVPnz565513fJEFAADAjeVdP6tXr9aiRYv0/fffq2bNmh4H03799ddeCwcAAAKb5aJStGhRPfLII77IAgAA4MZyUZk8ebIvcgAAAHjg42UBAIBtWd6iUqlSpct+XsrevXv/ViAAAIBslotK37593a5nZmZqw4YNmjt3rl588UVv5QIAALBeVPr06ZPj+IQJE7R27dq/HQgArmUVB8z2dwTL9o9s4+8IQK68dozKfffdpxkzZnjr4QAAALxXVL766itFR0d76+EAAACs7/q5+eab3Q6mNcbo6NGjOn78uN577z2vhgMAAIHNclFp166d2/WgoCCVLFlSd911l6pVq+atXAAAANaLypAhQ3yRAwAAwAMf+AYAAGwrz1tUgoKCLvtBb5LkcDh08eLFvx0KAABAslBUZs6cmettK1as0Ntvvy2n0+mVUAAAAJKFotK2bVuPsZ07d2rAgAH67rvv1KlTJw0fPtyr4QAAQGDL1zEqhw8fVo8ePVS7dm1dvHhRGzdu1NSpU1WhQgVv5wMAAAHMUlFJS0tT//79FRsbq23btmnhwoX67rvvVKtWLV/lAwAAASzPu35Gjx6tUaNGqUyZMvr8889z3BUEAADgTXkuKgMGDFB4eLhiY2M1depUTZ06Ncd5X3/9tdfCAQCAwJbnotK5c+crnp4MAADgTXkuKlOmTPFhDAAAAE98Mi0AALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtvxaVpKQk3XLLLYqIiFCpUqXUrl077dy505+RAACAjfi1qCxZskTx8fFauXKl5s+fr8zMTLVq1Upnz571ZywAAGATBfz55HPnznW7PmXKFJUqVUrr1q1Ts2bN/JQKAADYhV+LyqXS0tIkSdHR0TnenpGRoYyMDNf19PT0q5ILAAD4h22KitPpVN++fdW0aVPVqlUrxzlJSUkaNmzYVU4GANe3igNm+zsCkCvbnPUTHx+vrVu36osvvsh1zsCBA5WWlua6HDx48ComBAAAV5sttqj07t1b33//vZYuXapy5crlOi8sLExhYWFXMRkAAPAnvxYVY4yee+45zZw5Uz/99JMqVarkzzgAAMBm/FpU4uPj9dlnn+mbb75RRESEjh49KkmKiopSeHi4P6MBAAAb8OsxKu+//77S0tJ011136YYbbnBdvvzyS3/GAgAANuH3XT8AAAC5sc1ZPwAAAJeiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANsq4O8AdlZxwGx/RwgI+0e28XeEgMDPM4BrEVtUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbdmiqEyYMEEVK1ZUwYIFddttt2n16tX+jgQAAGzA70Xlyy+/VGJiooYMGaL169erbt26at26tY4dO+bvaAAAwM/8XlTGjh2rHj16qGvXrqpRo4Y++OADFSpUSJMmTfJ3NAAA4GcF/PnkFy5c0Lp16zRw4EDXWFBQkFq2bKkVK1Z4zM/IyFBGRobrelpamiQpPT3dJ/mcGed88rhw56v18yV+NgAECl/8Pzr7MY0xV5zr16Jy4sQJZWVlqXTp0m7jpUuX1q+//uoxPykpScOGDfMYj4mJ8VlG+F7UeH8nAADkxpf/jz59+rSioqIuO8evRcWqgQMHKjEx0XXd6XQqNTVVxYsXl8Ph8GMy70lPT1dMTIwOHjyoyMhIf8cJaKyFfbAW9sFa2MO1vg7GGJ0+fVply5a94ly/FpUSJUooODhYv//+u9v477//rjJlynjMDwsLU1hYmNtY0aJFfRnRbyIjI6/JH77rEWthH6yFfbAW9nAtr8OVtqRk8+vBtKGhoWrQoIEWLlzoGnM6nVq4cKEaN27sx2QAAMAO/L7rJzExUV26dFHDhg116623avz48Tp79qy6du3q72gAAMDP/F5UOnTooOPHj2vw4ME6evSo6tWrp7lz53ocYBsowsLCNGTIEI9dXLj6WAv7YC3sg7Wwh0BaB4fJy7lBAAAAfuD3D3wDAADIDUUFAADYFkUFAADYFkUFAADYFkUFAADYFkXFD5KSknTLLbcoIiJCpUqVUrt27bRz5063OX/++afi4+NVvHhxFSlSRI8++qjHJ/ji77vSWqSmpuq5555T1apVFR4ervLlyyshIcH1hZjwnrz8XmQzxui+++6Tw+HQrFmzrm7QAJDXtVixYoWaN2+uwoULKzIyUs2aNdP58+f9kPj6lZe1OHr0qJ588kmVKVNGhQsXVv369TVjxgw/JfY+ioofLFmyRPHx8Vq5cqXmz5+vzMxMtWrVSmfPnnXN6devn7777jslJydryZIlOnz4sB555BE/pr4+XWktDh8+rMOHD+utt97S1q1bNWXKFM2dO1fdu3f3c/LrT15+L7KNHz/+uvl+LzvKy1qsWLFC9957r1q1aqXVq1drzZo16t27t4KC+GvFm/KyFp07d9bOnTv17bffasuWLXrkkUfUvn17bdiwwY/JvcjA744dO2YkmSVLlhhjjDl16pQJCQkxycnJrjk7duwwksyKFSv8FTMgXLoWOZk+fboJDQ01mZmZVzFZ4MltLTZs2GBuvPFGc+TIESPJzJw50z8BA0hOa3HbbbeZV1991Y+pAlNOa1G4cGHzySefuM2Ljo42H3744dWO5xNUXxvI3o0QHR0tSVq3bp0yMzPVsmVL15xq1aqpfPnyWrFihV8yBopL1yK3OZGRkSpQwO8f7Hxdy2ktzp07p8cff1wTJkzI8YtL4RuXrsWxY8e0atUqlSpVSk2aNFHp0qV155136ueff/ZnzICQ0+9FkyZN9OWXXyo1NVVOp1NffPGF/vzzT911111+SuldFBU/czqd6tu3r5o2bapatWpJ+mt/Y2hoqMc3Q5cuXVpHjx71Q8rAkNNaXOrEiRMaMWKEnn766aucLrDkthb9+vVTkyZN1LZtWz+mCyw5rcXevXslSUOHDlWPHj00d+5c1a9fXy1atNCuXbv8Gfe6ltvvxfTp05WZmanixYsrLCxMPXv21MyZMxUbG+vHtN7DPwn9LD4+Xlu3buVfIjZwpbVIT09XmzZtVKNGDQ0dOvTqhgswOa3Ft99+q0WLFl0/+92vETmthdPplCT17NnT9QWyN998sxYuXKhJkyYpKSnJL1mvd7n9P2rQoEE6deqUFixYoBIlSmjWrFlq3769li1bptq1a/sprRf5e99TIIuPjzflypUze/fudRtfuHChkWROnjzpNl6+fHkzduzYq5gwcOS2FtnS09NN48aNTYsWLcz58+evcrrAktta9OnTxzgcDhMcHOy6SDJBQUHmzjvv9E/Y61xua7F3714jyUybNs1tvH379ubxxx+/mhEDRm5rsXv3biPJbN261W28RYsWpmfPnlczos+w68cPjDHq3bu3Zs6cqUWLFqlSpUputzdo0EAhISFauHCha2znzp06cOCAGjdufLXjXteutBbSX1tSWrVqpdDQUH377bcqWLCgH5Je/660FgMGDNDmzZu1ceNG10WSxo0bp8mTJ/sh8fXrSmtRsWJFlS1b1uM02ZSUFFWoUOFqRr3uXWktzp07J0keZ1sFBwe7tnxd8/xakwLUs88+a6KiosxPP/1kjhw54rqcO3fONeeZZ54x5cuXN4sWLTJr1641jRs3No0bN/Zj6uvTldYiLS3N3HbbbaZ27dpm9+7dbnMuXrzo5/TXl7z8XlxKnPXjE3lZi3HjxpnIyEiTnJxsdu3aZV599VVTsGBBs3v3bj8mv/5caS0uXLhgYmNjzR133GFWrVpldu/ebd566y3jcDjM7Nmz/ZzeOygqfiApx8vkyZNdc86fP2969eplihUrZgoVKmQefvhhc+TIEf+Fvk5daS0WL16c65x9+/b5Nfv1Ji+/Fzndh6LifXldi6SkJFOuXDlTqFAh07hxY7Ns2TL/BL6O5WUtUlJSzCOPPGJKlSplChUqZOrUqeNxuvK1zGGMMb7cYgMAAJBfHKMCAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABs6/8DhagaJnXz3CMAAAAASUVORK5CYII=",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "64a3d86674b342eb995b30e5373d6354",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1086,9 +1050,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "7b11444e315f430aabba44f1e917017c",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1096,9 +1075,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "b141ce8032c8457994ec93b337219d9e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1106,9 +1100,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "e2443183fd8d4c8ebb761a25be566fda",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+J0lEQVR4nO3deVyU5f7/8feAsrgAoghi5IJ7Ghp9U9Jc0kIx0/SklLll2ilcaVFzxSzN3NIs63cM2kyPpnbS3HI9JVqhpqnlhulJ0dxANAGZ+/dHMY8m0ESZe8T79Xw85pFz3dfc1+eaQXl33cvYDMMwBAAAAMvwcHcBAAAAMBcBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQKoWrVqurdu7e7y7jlvf7666pevbo8PT3VsGFDd5dzy+rdu7fKlCnj7jJcZty4cbLZbDp16pS7SwFuOgRAWFZSUpJsNpu+++67Are3bNlS9evXv+FxvvjiC40bN+6G92MVq1ev1osvvqimTZsqMTFRr776qrtLAoBbTgl3FwAUJz/99JM8PAr3/01ffPGFZs+eTQi8RuvWrZOHh4fmzp0rLy8vd5cDALckVgCBQvD29lbJkiXdXUahXLhwwd0lFMrJkyfl6+tL+EOxcfHiRXeXABQaARAohL+eA5iTk6OEhATVrFlTPj4+Kl++vJo1a6Y1a9ZI+v0cq9mzZ0uSbDab45HnwoULeu655xQWFiZvb2/Vrl1bU6ZMkWEYTuP+9ttvGjRokCpUqKCyZcvq4Ycf1i+//CKbzea0sph3ztOePXv0+OOPq1y5cmrWrJkkaefOnerdu7eqV68uHx8fhYSE6Mknn9Tp06edxsrbx759+/TEE0/I399fQUFBGj16tAzD0NGjR9WxY0f5+fkpJCREU6dOvab37vLly3r55ZcVHh4ub29vVa1aVS+99JKysrIcfWw2mxITE3XhwgXHe5WUlHTFfeYdpt+5c6datGihUqVKqUaNGlq0aJEkaePGjWrcuLF8fX1Vu3Ztffnll06v//nnn/Xss8+qdu3a8vX1Vfny5fXoo4/q8OHDjj6GYahVq1YKCgrSyZMnHe3Z2dlq0KCBwsPDrzlkHz58WDabTVOmTNHs2bNVvXp1lSpVSg8++KCOHj0qwzD08ssv67bbbpOvr686duyoM2fOOO3js88+U/v27RUaGipvb2+Fh4fr5ZdfVm5ubr7xtm7dqpiYGJUrV06lS5fWnXfeqTfeeCNfv19++UWdOnVSmTJlFBQUpOeff77A/V1N3mexZ88etWrVSqVKlVLlypU1efJkp355p178+T2WpA0bNshms2nDhg359nm9n2+eU6dOqWvXrvLz81P58uU1ePBgXbp0KV+/jz76SJGRkfL19VVgYKBiY2N19OjRAueZkpKi5s2bq1SpUnrppZcK9V4BNwMCICwvPT1dp06dyvfIycn529eOGzdOCQkJatWqld58802NHDlSt99+u7Zt2yZJevrpp/XAAw9Ikj788EPHQ/o9WDz88MOaPn262rZtq2nTpql27dp64YUXFB8f7zRO7969NWvWLMXExOi1116Tr6+v2rdvf8W6Hn30UV28eFGvvvqq+vXrJ0las2aNDh06pD59+mjWrFmKjY3V/PnzFRMTky9wSlK3bt1kt9s1adIkNW7cWBMmTNCMGTP0wAMPqHLlynrttddUo0YNPf/889q0adPfvldPPfWUxowZo7vuukvTp09XixYtNHHiRMXGxjr6fPjhh7rvvvvk7e3teK+aN29+1f2ePXtWDz30kBo3bqzJkyfL29tbsbGxWrBggWJjYxUTE6NJkybpwoUL+sc//qHz5887Xvvtt99q8+bNio2N1cyZM/XPf/5Ta9euVcuWLR2rOjabTe+9954uXbqkf/7zn47Xjh07Vrt371ZiYqJKly79t/P/s48//lhvvfWWBg4cqOeee04bN25U165dNWrUKK1cuVLDhg1T//799fnnn+v55593em1SUpLKlCmj+Ph4vfHGG4qMjNSYMWM0fPhwp35r1qxR8+bNtWfPHg0ePFhTp05Vq1attGzZMqd+ubm5io6OVvny5TVlyhS1aNFCU6dO1bvvvluoOUm/fxZt27ZVRESEpk6dqjp16mjYsGFasWJFoff1531e7+ebp2vXrrp06ZImTpyomJgYzZw5U/3793fq88orr6hnz56qWbOmpk2bpiFDhmjt2rVq3ry5zp0759T39OnTateunRo2bKgZM2aoVatW1z0/wG0MwKISExMNSVd93HHHHU6vqVKlitGrVy/H84iICKN9+/ZXHScuLs4o6K/a0qVLDUnGhAkTnNr/8Y9/GDabzThw4IBhGIaRkpJiSDKGDBni1K93796GJGPs2LGOtrFjxxqSjMceeyzfeBcvXszX9sknnxiSjE2bNuXbR//+/R1tly9fNm677TbDZrMZkyZNcrSfPXvW8PX1dXpPCrJjxw5DkvHUU085tT///POGJGPdunWOtl69ehmlS5e+6v7ytGjRwpBkzJs3z9H2448/GpIMDw8PY8uWLY72VatWGZKMxMRER1tB70lycrIhyfjggw+c2t955x1DkvHRRx8ZW7ZsMTw9PfN9Jn8nNTXVkGQEBQUZ586dc7SPGDHCkGREREQYOTk5jvbHHnvM8PLyMi5dunTVmp9++mmjVKlSjn6XL182qlWrZlSpUsU4e/asU1+73e74c69evQxJxvjx4536NGrUyIiMjCzU3PI+iz+/b1lZWUZISIjRpUsXR1ve37vU1FSn169fv96QZKxfvz7fPq/38837WX744Yedxnr22WcNScb3339vGIZhHD582PD09DReeeUVp367du0ySpQo4dSeV9OcOXOu/c0BbkKsAMLyZs+erTVr1uR73HnnnX/72oCAAO3evVv79+8v9LhffPGFPD09NWjQIKf25557ToZhOFZNVq5cKUl69tlnnfoNHDjwivv+80pVHl9fX8efL126pFOnTqlJkyaS5Fix/LOnnnrK8WdPT0/dfffdMgxDffv2dbQHBASodu3aOnTo0BVrkX6fq6R8K5vPPfecJGn58uVXff3VlClTxmkVsXbt2goICFDdunXVuHFjR3ven/9c65/fk5ycHJ0+fVo1atRQQEBAvvekf//+io6O1sCBA9WjRw+Fh4df9xXKjz76qPz9/fPV9sQTT6hEiRJO7dnZ2frll18KrPn8+fM6deqU7rvvPl28eFE//vijJGn79u1KTU3VkCFDFBAQ4DT2n09ByPPXn5f77rvvbz/TgpQpU0ZPPPGE47mXl5fuueee69rXn/d5vZ9vnri4OKfneX938n4uFy9eLLvdrq5duzodBQgJCVHNmjW1fv16p9d7e3urT58+1z0n4GbAVcCwvHvuuUd33313vvZy5cr97f3Dxo8fr44dO6pWrVqqX7++2rZtqx49elxTePz5558VGhqqsmXLOrXXrVvXsT3vvx4eHqpWrZpTvxo1alxx33/tK0lnzpxRQkKC5s+f73Qum/T7YfC/uv32252e+/v7y8fHRxUqVMjX/tfzCP8qbw5/rTkkJEQBAQGOuV6P2267LV+o8ff3V1hYWL426fdDinl+++03TZw4UYmJifrll1+cDoUX9J7MnTtX4eHh2r9/vzZv3uwUxgqjoPdW0jXVvHv3bo0aNUrr1q1TRkaGU/+8mg8ePChJ13QbIx8fHwUFBTm1lStXzmnMa1XQZ1GuXDnt3Lmz0Pu62j6v9fPNU7NmTafn4eHh8vDwcJyHuH//fhmGka9fnr9e+FW5cmUuUkKxRwAEbkDz5s118OBBffbZZ1q9erX+9a9/afr06ZozZ47TCprZCgomXbt21ebNm/XCCy+oYcOGKlOmjOx2u9q2bSu73Z6vv6en5zW1SSrwHMKCFLT6dKOuVNO11Dpw4EAlJiZqyJAhioqKkr+/v2w2m2JjYwt8TzZs2OC4aGXXrl2KiooyteZz586pRYsW8vPz0/jx4xUeHi4fHx9t27ZNw4YNK7Dm663lelzLe36ln4ErXXRyI5/vlfy1BrvdLpvNphUrVhS437/eLPt6gz9wMyEAAjcoMDBQffr0UZ8+fZSZmanmzZtr3LhxjgB4pV94VapU0Zdffqnz5887rQLmHcarUqWK4792u12pqalOKxQHDhy45hrPnj2rtWvXKiEhQWPGjHG0X8+h6+uRN4f9+/c7Vjgl6cSJEzp37pxjrmZbtGiRevXq5XQl86VLl/Kd9C9Jx48f18CBA/Xggw/Ky8tLzz//vKKjo02tfcOGDTp9+rQWL17sdHFMamqqU7/w8HBJ0g8//KA2bdqYVt+1KFeunCTle49vZBX47+zfv99pVfzAgQOy2+2qWrWqpN/fL8MwVK1aNdWqVctldQA3E84BBG7AXw99lilTRjVq1HC6tUneFaJ//YUXExOj3Nxcvfnmm07t06dPl81mU7t27SRJ0dHRkqS33nrLqd+sWbOuuc68VY2/ro7MmDHjmvdxI2JiYgocb9q0aZJ01SuaXcnT0zPfezJr1qwCV6P69esnu92uuXPn6t1331WJEiXUt2/fa179LAoFfY7Z2dn5fjbuuusuVatWTTNmzMj3c2dmvQXJC6d/vnI8Nzf3uq46vlZ5t2LKk/d3J+/vWOfOneXp6amEhIR8749hGH97igNQHLECCNyAevXqqWXLloqMjFRgYKC+++47LVq0SAMGDHD0iYyMlCQNGjRI0dHR8vT0VGxsrDp06KBWrVpp5MiROnz4sCIiIrR69Wp99tlnGjJkiOMXZWRkpLp06aIZM2bo9OnTatKkiTZu3Kh9+/ZJurbDqn5+fmrevLkmT56snJwcVa5cWatXr863cuQqERER6tWrl959913HYcxvvvlG77//vjp16uS222g89NBD+vDDD+Xv76969eopOTlZX375pcqXL+/ULzExUcuXL1dSUpJuu+02Sb+HiCeeeEJvv/12vgt0XOXee+9VuXLl1KtXLw0aNEg2m00ffvhhvtDi4eGht99+Wx06dFDDhg3Vp08fVapUST/++KN2796tVatWmVJvQe644w41adJEI0aM0JkzZxQYGKj58+fr8uXLLhszNTVVDz/8sNq2bavk5GR99NFHevzxxxURESHp91A6YcIEjRgxQocPH1anTp1UtmxZpaamasmSJerfv3++2/EAxR0BELgBgwYN0n/+8x+tXr1aWVlZqlKliiZMmKAXXnjB0adz584aOHCg5s+fr48++kiGYSg2NlYeHh76z3/+ozFjxmjBggVKTExU1apV9frrrzuujs3zwQcfKCQkRJ988omWLFmiNm3aaMGCBapdu7Z8fHyuqdZ58+Zp4MCBmj17tgzD0IMPPqgVK1YoNDS0SN+TK/nXv/6l6tWrKykpSUuWLFFISIhGjBihsWPHmjJ+Qd544w15enrq448/1qVLl9S0aVN9+eWXjlVXSfrf//6noUOHqkOHDurVq5ejvXv37vr000/14osvql27dgVeeFPUypcvr2XLlum5557TqFGjVK5cOT3xxBNq3bq1U83S7yvH69evV0JCgqZOnSq73a7w8HDHfSHd6eOPP9bTTz+tSZMmKSAgQH379lWrVq0c98wsagsWLHDcK7FEiRIaMGCAXn/9dac+w4cPV61atTR9+nQlJCRI+v2inAcffFAPP/ywS+oC3MlmuPt4AIDrsmPHDjVq1EgfffSRunfv7u5yAADFCOcAAsXAb7/9lq9txowZ8vDw+NtvygAA4K84BAwUA5MnT1ZKSopatWqlEiVKaMWKFVqxYoX69++f735oMF9ubq5+/fXXq/YpU6ZMvtuJFAdnzpxRdnb2Fbd7enrmu48ggJsfh4CBYmDNmjVKSEjQnj17lJmZqdtvv109evTQyJEjnb45Au5x+PDhvz0HcOzYsRo3bpw5BRWhli1bauPGjVfcXqVKFccNlQEUHwRAALhBly5d0ldffXXVPtWrV1f16tVNqqjopKSkXPVbQXx9fdW0aVMTKwJQFAiAAAAAFsNFIAAAABbDyUM3wG6369ixYypbtqxLvuMUAAAUPcMwdP78eYWGhsrDw5prYQTAG3Ds2DGuwAQAoJg6evSo49t9rIYAeAPKli0r6fcfID8/PzdXAwAArkVGRobCwsIcv8etiAB4A/IO+/r5+REAAQAoZqx8+pY1D3wDAABYGAEQAADAYgiAAAAAFkMABAAAsBgCIAAAgMUQAAEAACyGAAgAAGAxBEAAAACLIQACAABYDAEQAADAYgiAAAAAFkMABAAAsBgCIAAAgMUQAAEAACymhLsLAICbVdXhy91dQqEdntTe3SUAKAZYAQQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZTLAPgxIkT9X//938qW7asKlasqE6dOumnn35y6nPp0iXFxcWpfPnyKlOmjLp06aITJ0449Tly5Ijat2+vUqVKqWLFinrhhRd0+fJlM6cCAABgumIZADdu3Ki4uDht2bJFa9asUU5Ojh588EFduHDB0Wfo0KH6/PPPtXDhQm3cuFHHjh1T586dHdtzc3PVvn17ZWdna/PmzXr//feVlJSkMWPGuGNKAAAAprEZhmG4u4gb9euvv6pixYrauHGjmjdvrvT0dAUFBWnevHn6xz/+IUn68ccfVbduXSUnJ6tJkyZasWKFHnroIR07dkzBwcGSpDlz5mjYsGH69ddf5eXl9bfjZmRkyN/fX+np6fLz83PpHAGYr+rw5e4uodAOT2rv7hKAmx6/v4vpCuBfpaenS5ICAwMlSSkpKcrJyVGbNm0cferUqaPbb79dycnJkqTk5GQ1aNDAEf4kKTo6WhkZGdq9e3eB42RlZSkjI8PpAQAAUNwU+wBot9s1ZMgQNW3aVPXr15ckpaWlycvLSwEBAU59g4ODlZaW5ujz5/CXtz1vW0EmTpwof39/xyMsLKyIZwMAAOB6xT4AxsXF6YcfftD8+fNdPtaIESOUnp7ueBw9etTlYwIAABS1Eu4u4EYMGDBAy5Yt06ZNm3Tbbbc52kNCQpSdna1z5845rQKeOHFCISEhjj7ffPON0/7yrhLO6/NX3t7e8vb2LuJZAAAAmKtYrgAahqEBAwZoyZIlWrdunapVq+a0PTIyUiVLltTatWsdbT/99JOOHDmiqKgoSVJUVJR27dqlkydPOvqsWbNGfn5+qlevnjkTAQAAcINiuQIYFxenefPm6bPPPlPZsmUd5+z5+/vL19dX/v7+6tu3r+Lj4xUYGCg/Pz8NHDhQUVFRatKkiSTpwQcfVL169dSjRw9NnjxZaWlpGjVqlOLi4ljlAwAAt7RiGQDffvttSVLLli2d2hMTE9W7d29J0vTp0+Xh4aEuXbooKytL0dHReuuttxx9PT09tWzZMj3zzDOKiopS6dKl1atXL40fP96saQAAALjFLXEfQHfhPkLArY37AAK3Jn5/F9NzAAEAAHD9CIAAAAAWQwAEAACwGAIgAACAxRAAAQAALIYACAAAYDHF8j6AAIqf4nhLFQC4VbECCAAAYDEEQAAAAIshAAIAAFgMARAAAMBiCIAAAAAWQwAEAACwGAIgAACAxRAAAQAALIYACAAAYDEEQAAAAIshAAIAAFgMARAAAMBiCIAAAAAWQwAEAACwGAIgAACAxRAAAQAALIYACAAAYDEEQAAAAIshAAIAAFgMARAAAMBiCIAAAAAWQwAEAACwGAIgAACAxRAAAQAALIYACAAAYDEEQAAAAIshAAIAAFgMARAAAMBiCIAAAAAWQwAEAACwmBLuLgAAUHSqDl/u7hIK7fCk9u4uAbAcVgABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGJMC4Dbtm3Trl27HM8/++wzderUSS+99JKys7PNKgMAAMDyTAuATz/9tPbt2ydJOnTokGJjY1WqVCktXLhQL774olllAAAAWJ5pAXDfvn1q2LChJGnhwoVq3ry55s2bp6SkJH366admlQEAAGB5pgVAwzBkt9slSV9++aViYmIkSWFhYTp16pRZZQAAAFieaQHw7rvv1oQJE/Thhx9q48aNat++vSQpNTVVwcHBZpUBAABgeaYFwBkzZmjbtm0aMGCARo4cqRo1akiSFi1apHvvvdesMgAAACyvhFkD3XnnnU5XAed5/fXX5enpaVYZAAAAlmfqfQDPnTunf/3rXxoxYoTOnDkjSdqzZ49OnjxpZhkAAACWZtoK4M6dO9W6dWsFBATo8OHD6tevnwIDA7V48WIdOXJEH3zwgVmlAAAAWJppK4Dx8fHq06eP9u/fLx8fH0d7TEyMNm3aZFYZAAAAlmdaAPz222/19NNP52uvXLmy0tLSzCoDAADA8kwLgN7e3srIyMjXvm/fPgUFBZlVBgAAgOWZFgAffvhhjR8/Xjk5OZIkm82mI0eOaNiwYerSpYtZZQAAAFieaQFw6tSpyszMVMWKFfXbb7+pRYsWqlGjhsqWLatXXnnFrDIAAAAsz7SrgP39/bVmzRp9/fXX+v7775WZmam77rpLbdq0MasEAAAAyMQAmKdp06Zq2rSp2cMCAADgD6YdAh40aJBmzpyZr/3NN9/UkCFDzCoDAADA8kwLgJ9++mmBK3/33nuvFi1aZFYZAAAAlmdaADx9+rT8/f3ztfv5+enUqVOF2temTZvUoUMHhYaGymazaenSpU7be/fuLZvN5vRo27atU58zZ86oe/fu8vPzU0BAgPr27avMzMxCzwsAAKC4MS0A1qhRQytXrszXvmLFClWvXr1Q+7pw4YIiIiI0e/bsK/Zp27atjh8/7nh88sknTtu7d++u3bt3a82aNVq2bJk2bdqk/v37F6oOAACA4si0i0Di4+M1YMAA/frrr7r//vslSWvXrtXUqVM1Y8aMQu2rXbt2ateu3VX7eHt7KyQkpMBte/fu1cqVK/Xtt9/q7rvvliTNmjVLMTExmjJlikJDQwtVDwAAQHFiWgB88sknlZWVpVdeeUUvv/yyJKlq1ap6++231bNnzyIfb8OGDapYsaLKlSun+++/XxMmTFD58uUlScnJyQoICHCEP0lq06aNPDw8tHXrVj3yyCNFXg8AAMDNwtTbwDzzzDN65pln9Ouvv8rX11dlypRxyTht27ZV586dVa1aNR08eFAvvfSS2rVrp+TkZHl6eiotLU0VK1Z0ek2JEiUUGBh41e8lzsrKUlZWluN5QV9tBwAAcLMz/T6Aklz+3b+xsbGOPzdo0EB33nmnwsPDtWHDBrVu3fq69ztx4kQlJCQURYkAAABuY9pFICdOnFCPHj0UGhqqEiVKyNPT0+nhStWrV1eFChV04MABSVJISIhOnjzp1Ofy5cs6c+bMFc8blKQRI0YoPT3d8Th69KhL6wYAAHAF01YAe/furSNHjmj06NGqVKmSbDabWUPrf//7n06fPq1KlSpJkqKionTu3DmlpKQoMjJSkrRu3TrZ7XY1btz4ivvx9vaWt7e3KTUDAAC4imkB8KuvvtJ///tfNWzY8Ib3lZmZ6VjNk6TU1FTt2LFDgYGBCgwMVEJCgrp06aKQkBAdPHhQL774omrUqKHo6GhJUt26ddW2bVv169dPc+bMUU5OjgYMGKDY2FiuAAYAALc80w4Bh4WFyTCMItnXd999p0aNGqlRo0aSfr/FTKNGjTRmzBh5enpq586devjhh1WrVi317dtXkZGR+u9//+u0evfxxx+rTp06at26tWJiYtSsWTO9++67RVIfAADAzcxmFFUq+xurV6/W1KlT9c4776hq1apmDOlyGRkZ8vf3V3p6uvz8/NxdDnBTqzp8ubtLwE3q8KT27i4BFsPvbxMPAXfr1k0XL15UeHi4SpUqpZIlSzptP3PmjFmlAAAAWJppAbCw3/YBAAAA1zAtAPbq1cusoQAAAHAVpl0EIkkHDx7UqFGj9Nhjjznuw7dixQrt3r3bzDIAAAAszbQAuHHjRjVo0EBbt27V4sWLlZmZKUn6/vvvNXbsWLPKAAAAsDzTAuDw4cM1YcIErVmzRl5eXo72+++/X1u2bDGrDAAAAMszLQDu2rVLjzzySL72ihUr6tSpU2aVAQAAYHmmBcCAgAAdP348X/v27dtVuXJls8oAAACwPNMCYGxsrIYNG6a0tDTZbDbZ7XZ9/fXXev7559WzZ0+zygAAALA80wLgq6++qjp16igsLEyZmZmqV6+emjdvrnvvvVejRo0yqwwAAADLM+U+gIZhKC0tTTNnztSYMWO0a9cuZWZmqlGjRqpZs6YZJQAAAOAPpgXAGjVqaPfu3apZs6bCwsLMGBYAAAAFMOUQsIeHh2rWrKnTp0+bMRwAAACuwrRzACdNmqQXXnhBP/zwg1lDAgAAoACmfRdwz549dfHiRUVERMjLy0u+vr5O28+cOWNWKQAAAJZmWgCcMWOGWUMBt7yqw5e7uwQAQDFmSgDMycnRxo0bNXr0aFWrVs2MIQEAAHAFppwDWLJkSX366admDAUAAIC/YdpFIJ06ddLSpUvNGg4AAABXYNo5gDVr1tT48eP19ddfKzIyUqVLl3baPmjQILNKAQAAsDTTAuDcuXMVEBCglJQUpaSkOG2z2WwEQAAAAJOYFgBTU1PNGgoAAABXYdo5gAAAALg5mLYC+OSTT151+3vvvWdSJQAAANZmWgA8e/as0/OcnBz98MMPOnfunO6//36zygAAALA80wLgkiVL8rXZ7XY988wzCg8PN6sMAAAAy3PrOYAeHh6Kj4/X9OnT3VkGAACApbj9IpCDBw/q8uXL7i4DAADAMkw7BBwfH+/03DAMHT9+XMuXL1evXr3MKgMAAMDyTAuA27dvd3ru4eGhoKAgTZ069W+vEAYAAEDRMS0Arl+/3qyhAAAAcBWmnQOYmpqq/fv352vfv3+/Dh8+bFYZAAAAlmdaAOzdu7c2b96cr33r1q3q3bu3WWUAAABYnmkBcPv27WratGm+9iZNmmjHjh1mlQEAAGB5pgVAm82m8+fP52tPT09Xbm6uWWUAAABYnmkBsHnz5po4caJT2MvNzdXEiRPVrFkzs8oAAACwPNOuAn7ttdfUvHlz1a5dW/fdd58k6b///a8yMjK0bt06s8oAAACwPNNWAOvVq6edO3eqa9euOnnypM6fP6+ePXvqxx9/VP369c0qAwAAwPJMWwGUpNDQUL366qtmDgkAAIC/MG0FMDExUQsXLszXvnDhQr3//vtmlQEAAGB5pgXAiRMnqkKFCvnaK1asyKogAACAiUwLgEeOHFG1atXytVepUkVHjhwxqwwAAADLMy0AVqxYUTt37szX/v3336t8+fJmlQEAAGB5pgXAxx57TIMGDdL69euVm5ur3NxcrVu3ToMHD1ZsbKxZZQAAAFieaVcBv/zyyzp8+LBat26tEiV+H9Zut6tnz56cAwgAAGAi0wKgl5eXFixYoJdfflnff/+9fH191aBBA1WpUsWsEgAAACCT7wMoSYGBgWrVqlWBVwQDAADA9Uw5B/DcuXOKi4tThQoVFBwcrODgYFWoUEEDBgzQuXPnzCgBAAAAf3D5CuCZM2cUFRWlX375Rd27d1fdunUlSXv27FFSUpLWrl2rzZs3q1y5cq4uBQAAADIhAI4fP15eXl46ePCggoOD82178MEHNX78eE2fPt3VpQAAAEAmHAJeunSppkyZki/8SVJISIgmT56sJUuWuLoMAAAA/MHlAfD48eO64447rri9fv36SktLc3UZAAAA+IPLA2CFChV0+PDhK25PTU1VYGCgq8sAAADAH1weAKOjozVy5EhlZ2fn25aVlaXRo0erbdu2ri4DAAAAfzDlIpC7775bNWvWVFxcnOrUqSPDMLR371699dZbysrK0ocffujqMgAAAPAHlwfA2267TcnJyXr22Wc1YsQIGYYhSbLZbHrggQf05ptvKiwszNVlAAAA4A+mfBNItWrVtGLFCp09e1b79++XJNWoUYNz/wAAANzA1K+CK1eunO655x4zhwQAAMBfmPJVcAAAALh5EAABAAAshgAIAABgMS4NgHfddZfOnj0r6ffbwVy8eNGVwwEAAOAauDQA7t27VxcuXJAkJSQkKDMz05XDAQAA4Bq49Crghg0bqk+fPmrWrJkMw9CUKVNUpkyZAvuOGTPGlaUAAADgDy4NgElJSRo7dqyWLVsmm82mFStWqESJ/EPabDYCIAAAgElcGgBr166t+fPnS5I8PDy0du1aVaxY0ZVDAgAA4G+YdiNou91u1lAAAAC4ClO/CeTgwYOaMWOG9u7dK0mqV6+eBg8erPDwcDPLAAAAsDTT7gO4atUq1atXT998843uvPNO3Xnnndq6davuuOMOrVmzxqwyAAAALM+0FcDhw4dr6NChmjRpUr72YcOG6YEHHjCrFAAAAEszbQVw79696tu3b772J598Unv27CnUvjZt2qQOHTooNDRUNptNS5cuddpuGIbGjBmjSpUqydfXV23atNH+/fud+pw5c0bdu3eXn5+fAgIC1LdvX+5TCAAALMG0ABgUFKQdO3bka9+xY0ehrwy+cOGCIiIiNHv27AK3T548WTNnztScOXO0detWlS5dWtHR0bp06ZKjT/fu3bV7926tWbNGy5Yt06ZNm9S/f/9C1QEAAFAcmXYIuF+/furfv78OHTqke++9V5L09ddf67XXXlN8fHyh9tWuXTu1a9euwG2GYWjGjBkaNWqUOnbsKEn64IMPFBwcrKVLlyo2NlZ79+7VypUr9e233+ruu++WJM2aNUsxMTGaMmWKQkNDb2CmAAAANzfTAuDo0aNVtmxZTZ06VSNGjJAkhYaGaty4cRo0aFCRjZOamqq0tDS1adPG0ebv76/GjRsrOTlZsbGxSk5OVkBAgCP8SVKbNm3k4eGhrVu36pFHHimyegAAAG42pgVAm82moUOHaujQoTp//rwkqWzZskU+TlpamiQpODjYqT04ONixLS0tLd9h5xIlSigwMNDRpyBZWVnKyspyPM/IyCiqsgEAAExj2jmAf1a2bFmXhD9Xmzhxovz9/R2PsLAwd5cEAABQaG4JgK4UEhIiSTpx4oRT+4kTJxzbQkJCdPLkSaftly9f1pkzZxx9CjJixAilp6c7HkePHi3i6gEAAFzvlguA1apVU0hIiNauXetoy8jI0NatWxUVFSVJioqK0rlz55SSkuLos27dOtntdjVu3PiK+/b29pafn5/TAwAAoLgx9avgikpmZqYOHDjgeJ6amqodO3YoMDBQt99+u4YMGaIJEyaoZs2aqlatmkaPHq3Q0FB16tRJklS3bl21bdtW/fr105w5c5STk6MBAwYoNjaWK4ABAMAtz5QVwJycHLVu3TrfzZiv13fffadGjRqpUaNGkqT4+Hg1atRIY8aMkSS9+OKLGjhwoPr376//+7//U2ZmplauXCkfHx/HPj7++GPVqVNHrVu3VkxMjJo1a6Z33323SOoDAAC4mdkMwzDMGCgoKEibN29WzZo1zRjOFBkZGfL391d6ejqHg2GqqsOXu7sEoMgcntTe3SXAYvj9beI5gE888YTmzp1r1nAAAAC4AtPOAbx8+bLee+89ffnll4qMjFTp0qWdtk+bNs2sUgAAACzNtAD4ww8/6K677pIk7du3z2mbzWYzqwwAAADLMy0Arl+/3qyhAAAAcBWm3wfwwIEDWrVqlX777TdJkknXoAAAAOAPpgXA06dPq3Xr1qpVq5ZiYmJ0/PhxSVLfvn313HPPmVUGAACA5ZkWAIcOHaqSJUvqyJEjKlWqlKO9W7duWrlypVllAAAAWJ5p5wCuXr1aq1at0m233ebUXrNmTf38889mlQEAAGB5pgXACxcuOK385Tlz5oy8vb3NKgMAcJMpjjc25+bVKO5MOwR833336YMPPnA8t9lsstvtmjx5slq1amVWGQAAAJZn2grg5MmT1bp1a3333XfKzs7Wiy++qN27d+vMmTP6+uuvzSoDAADA8kxbAaxfv7727dunZs2aqWPHjrpw4YI6d+6s7du3Kzw83KwyAAAALM+0FUBJ8vf318iRI80cEgAAAH9hagA8e/as5s6dq71790qS6tWrpz59+igwMNDMMgAAACzNtEPAmzZtUtWqVTVz5kydPXtWZ8+e1cyZM1WtWjVt2rTJrDIAAAAsz7QVwLi4OHXr1k1vv/22PD09JUm5ubl69tlnFRcXp127dplVCgAAgKWZtgJ44MABPffcc47wJ0menp6Kj4/XgQMHzCoDAADA8kwLgHfddZfj3L8/27t3ryIiIswqAwAAwPJcegh4586djj8PGjRIgwcP1oEDB9SkSRNJ0pYtWzR79mxNmjTJlWUAAADgT2yGYRiu2rmHh4dsNpv+bgibzabc3FxXleEyGRkZ8vf3V3p6uvz8/NxdDiykOH51FnAr4avgijd+f7t4BTA1NdWVuweKBGEKAGA1Lg2AVapUceXuAQAAcB1MvRH0sWPH9NVXX+nkyZOy2+1O2wYNGmRmKQAAAJZlWgBMSkrS008/LS8vL5UvX142m82xzWazEQABAABMYloAHD16tMaMGaMRI0bIw8O0u88AAADgL0xLYhcvXlRsbCzhDwAAwM1MS2N9+/bVwoULzRoOAAAAV2DaIeCJEyfqoYce0sqVK9WgQQOVLFnSafu0adPMKgUAAMDSTA2Aq1atUu3atSUp30UgAAAAMIdpAXDq1Kl677331Lt3b7OGBAAAQAFMOwfQ29tbTZs2NWs4AAAAXIFpAXDw4MGaNWuWWcMBAADgCkw7BPzNN99o3bp1WrZsme644458F4EsXrzYrFIAAAAszbQAGBAQoM6dO5s1HAAAAK7AtACYmJho1lAAAAC4Cr6WAwAAwGJMWwGsVq3aVe/3d+jQIbNKAQAAsDTTAuCQIUOcnufk5Gj79u1auXKlXnjhBbPKAAAAsDzTAuDgwYMLbJ89e7a+++47s8oAAACwPLefA9iuXTt9+umn7i4DAADAMtweABctWqTAwEB3lwEAAGAZph0CbtSokdNFIIZhKC0tTb/++qveeusts8oAAACwPNMCYKdOnZyee3h4KCgoSC1btlSdOnXMKgMAAMDyTAuAY8eONWsoAAAAXIXbzwEEAACAuVy+Aujh4XHVG0BLks1m0+XLl11dCgAAAGRCAFyyZMkVtyUnJ2vmzJmy2+2uLgMAAAB/cHkA7NixY762n376ScOHD9fnn3+u7t27a/z48a4uAwAAAH8w9RzAY8eOqV+/fmrQoIEuX76sHTt26P3331eVKlXMLAMAAMDSTAmA6enpGjZsmGrUqKHdu3dr7dq1+vzzz1W/fn0zhgcAAMCfuPwQ8OTJk/Xaa68pJCREn3zySYGHhAEAAGAem2EYhisH8PDwkK+vr9q0aSNPT88r9lu8eLEry3CJjIwM+fv7Kz09XX5+fu4uB9ep6vDl7i4BQDFzeFJ7d5eAG8DvbxNWAHv27Pm3t4EBAACAeVweAJOSklw9BAAAAAqBbwIBAACwGAIgAACAxRAAAQAALIYACAAAYDEEQAAAAIshAAIAAFgMARAAAMBiCIAAAAAWQwAEAACwGAIgAACAxRAAAQAALIYACAAAYDEEQAAAAIshAAIAAFgMARAAAMBiCIAAAAAWc8sGwHHjxslmszk96tSp49h+6dIlxcXFqXz58ipTpoy6dOmiEydOuLFiAAAAc9yyAVCS7rjjDh0/ftzx+Oqrrxzbhg4dqs8//1wLFy7Uxo0bdezYMXXu3NmN1QIAAJijhLsLcKUSJUooJCQkX3t6errmzp2refPm6f7775ckJSYmqm7dutqyZYuaNGlidqkAAACmuaVXAPfv36/Q0FBVr15d3bt315EjRyRJKSkpysnJUZs2bRx969Spo9tvv13JyclX3F9WVpYyMjKcHgAAAMXNLRsAGzdurKSkJK1cuVJvv/22UlNTdd999+n8+fNKS0uTl5eXAgICnF4THBystLS0K+5z4sSJ8vf3dzzCwsJcPAsAAICid8seAm7Xrp3jz3feeacaN26sKlWq6N///rd8fX2va58jRoxQfHy843lGRgYhEAAAFDu37ArgXwUEBKhWrVo6cOCAQkJClJ2drXPnzjn1OXHiRIHnDObx9vaWn5+f0wMAAKC4sUwAzMzM1MGDB1WpUiVFRkaqZMmSWrt2rWP7Tz/9pCNHjigqKsqNVQIAALjeLXsI+Pnnn1eHDh1UpUoVHTt2TGPHjpWnp6cee+wx+fv7q2/fvoqPj1dgYKD8/Pw0cOBARUVFcQUwAAC45d2yAfB///ufHnvsMZ0+fVpBQUFq1qyZtmzZoqCgIEnS9OnT5eHhoS5duigrK0vR0dF666233Fw1AACA69kMwzDcXURxlZGRIX9/f6Wnp3M+YDFWdfhyd5cAoJg5PKm9u0vADeD3t4XOAQQAAMDvCIAAAAAWc8ueAwgAgKsUx1NHOGyNP2MFEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAspoS7C8Ctperw5e4uAQAA/A1WAAEAACyGAAgAAGAxBEAAAACLIQACAABYDAEQAADAYgiAAAAAFkMABAAAsBgCIAAAgMUQAAEAACyGAAgAAGAxBEAAAACLIQACAABYDAEQAADAYgiAAAAAFkMABAAAsBgCIAAAgMUQAAEAACyGAAgAAGAxBEAAAACLIQACAABYDAEQAADAYgiAAAAAFkMABAAAsBgCIAAAgMUQAAEAACyGAAgAAGAxBEAAAACLIQACAABYDAEQAADAYgiAAAAAFkMABAAAsJgS7i4AV1Z1+HJ3lwAAAG5BrAACAABYDAEQAADAYgiAAAAAFkMABAAAsBgCIAAAgMUQAAEAACyGAAgAAGAxBEAAAACLIQACAABYDAEQAADAYgiAAAAAFkMABAAAsJgS7i4AAAC4XtXhy91dQqEdntTe3SXcslgBBAAAsBgCIAAAgMUQAAEAACyGAAgAAGAxBEAAAACLIQACAABYDAEQAADAYgiAAAAAFmP5ADh79mxVrVpVPj4+aty4sb755ht3lwQAAOBSlg6ACxYsUHx8vMaOHatt27YpIiJC0dHROnnypLtLAwAAcBlLB8Bp06apX79+6tOnj+rVq6c5c+aoVKlSeu+999xdGgAAgMtY9ruAs7OzlZKSohEjRjjaPDw81KZNGyUnJxf4mqysLGVlZTmep6enS5IyMjJcUqM966JL9gsAQHHgqt+vefs1DMMl+y8OLBsAT506pdzcXAUHBzu1BwcH68cffyzwNRMnTlRCQkK+9rCwMJfUCACAlfnPcO3+z58/L39/f9cOcpOybAC8HiNGjFB8fLzjud1u15kzZ1S+fHnZbDY3VlY4GRkZCgsL09GjR+Xn5+fuckzDvJm3FTBv5m0VNzJ3wzB0/vx5hYaGuqi6m59lA2CFChXk6empEydOOLWfOHFCISEhBb7G29tb3t7eTm0BAQGuKtHl/Pz8LPcPhsS8rYZ5Wwvztp7rnbtVV/7yWPYiEC8vL0VGRmrt2rWONrvdrrVr1yoqKsqNlQEAALiWZVcAJSk+Pl69evXS3XffrXvuuUczZszQhQsX1KdPH3eXBgAA4DKWDoDdunXTr7/+qjFjxigtLU0NGzbUypUr810Ycqvx9vbW2LFj8x3OvtUxb+ZtBcybeVuFledeFGyGla+BBgAAsCDLngMIAABgVQRAAAAAiyEAAgAAWAwBEAAAwGIIgLeo2bNnq2rVqvLx8VHjxo31zTffXLFvUlKSbDab08PHx8fEaotOYeYtSefOnVNcXJwqVaokb29v1apVS1988YVJ1Radwsy7ZcuW+T5vm82m9u3bm1hx0Sjs5z1jxgzVrl1bvr6+CgsL09ChQ3Xp0iWTqi06hZl3Tk6Oxo8fr/DwcPn4+CgiIkIrV640sdqisWnTJnXo0EGhoaGy2WxaunTp375mw4YNuuuuu+Tt7a0aNWooKSnJ5XUWtcLO+/jx43r88cdVq1YteXh4aMiQIabUWdQKO+/FixfrgQceUFBQkPz8/BQVFaVVq1aZU2wxRQC8BS1YsEDx8fEaO3astm3bpoiICEVHR+vkyZNXfI2fn5+OHz/uePz8888mVlw0Cjvv7OxsPfDAAzp8+LAWLVqkn376Sf/v//0/Va5c2eTKb0xh57148WKnz/qHH36Qp6enHn30UZMrvzGFnfe8efM0fPhwjR07Vnv37tXcuXO1YMECvfTSSyZXfmMKO+9Ro0bpnXfe0axZs7Rnzx7985//1COPPKLt27ebXPmNuXDhgiIiIjR79uxr6p+amqr27durVatW2rFjh4YMGaKnnnqq2IWCws47KytLQUFBGjVqlCIiIlxcnesUdt6bNm3SAw88oC+++EIpKSlq1aqVOnToUOx+zk1l4JZzzz33GHFxcY7nubm5RmhoqDFx4sQC+ycmJhr+/v4mVec6hZ3322+/bVSvXt3Izs42q0SXKOy8/2r69OlG2bJljczMTFeV6BKFnXdcXJxx//33O7XFx8cbTZs2dWmdRa2w865UqZLx5ptvOrV17tzZ6N69u0vrdCVJxpIlS67a58UXXzTuuOMOp7Zu3boZ0dHRLqzMta5l3n/WokULY/DgwS6rxyyFnXeeevXqGQkJCUVf0C2CFcBbTHZ2tlJSUtSmTRtHm4eHh9q0aaPk5OQrvi4zM1NVqlRRWFiYOnbsqN27d5tRbpG5nnn/5z//UVRUlOLi4hQcHKz69evr1VdfVW5urlll37Dr/bz/bO7cuYqNjVXp0qVdVWaRu55533vvvUpJSXEcLj106JC++OILxcTEmFJzUbieeWdlZeU7pcPX11dfffWVS2t1t+TkZKf3SZKio6Ov+e8Fije73a7z588rMDDQ3aXctAiAt5hTp04pNzc337eZBAcHKy0trcDX1K5dW++9954+++wzffTRR7Lb7br33nv1v//9z4ySi8T1zPvQoUNatGiRcnNz9cUXX2j06NGaOnWqJkyYYEbJReJ65v1n33zzjX744Qc99dRTrirRJa5n3o8//rjGjx+vZs2aqWTJkgoPD1fLli2L1SHg65l3dHS0pk2bpv3798tut2vNmjWO0wBuZWlpaQW+TxkZGfrtt9/cVBXMMmXKFGVmZqpr167uLuWmRQCEoqKi1LNnTzVs2FAtWrTQ4sWLFRQUpHfeecfdpbmU3W5XxYoV9e677yoyMlLdunXTyJEjNWfOHHeXZpq5c+eqQYMGuueee9xdistt2LBBr776qt566y1t27ZNixcv1vLly/Xyyy+7uzSXeuONN1SzZk3VqVNHXl5eGjBggPr06SMPD/75x61p3rx5SkhI0L///W9VrFjR3eXctCz9XcC3ogoVKsjT01MnTpxwaj9x4oRCQkKuaR8lS5ZUo0aNdODAAVeU6BLXM+9KlSqpZMmS8vT0dLTVrVtXaWlpys7OlpeXl0trLgo38nlfuHBB8+fP1/jx411Zoktcz7xHjx6tHj16OFY7GzRooAsXLqh///4aOXJksQhE1zPvoKAgLV26VJcuXdLp06cVGhqq4cOHq3r16maU7DYhISEFvk9+fn7y9fV1U1Vwtfnz5+upp57SwoUL850CAGc3/794KBQvLy9FRkZq7dq1jja73a61a9cqKirqmvaRm5urXbt2qVKlSq4qs8hdz7ybNm2qAwcOyG63O9r27dunSpUqFYvwJ93Y571w4UJlZWXpiSeecHWZRe565n3x4sV8IS8v/BvF5CvRb+Tz9vHxUeXKlXX58mV9+umn6tixo6vLdauoqCin90mS1qxZc83/DqL4+eSTT9SnTx998sknxfK2VqZz91UoKHrz5883vL29jaSkJGPPnj1G//79jYCAACMtLc0wDMPo0aOHMXz4cEf/hIQEY9WqVcbBgweNlJQUIzY21vDx8TF2797trilcl8LO+8iRI0bZsmWNAQMGGD/99JOxbNkyo2LFisaECRPcNYXrUth552nWrJnRrVs3s8stMoWd99ixY42yZcsan3zyiXHo0CFj9erVRnh4uNG1a1d3TeG6FHbeW7ZsMT799FPj4MGDxqZNm4z777/fqFatmnH27Fk3zeD6nD9/3ti+fbuxfft2Q5Ixbdo0Y/v27cbPP/9sGIZhDB8+3OjRo4ej/6FDh4xSpUoZL7zwgrF3715j9uzZhqenp7Fy5Up3TeG6FHbehmE4+kdGRhqPP/64sX379mL373lh5/3xxx8bJUqUMGbPnm0cP37c8Th37py7pnDTIwDeombNmmXcfvvthpeXl3HPPfcYW7ZscWxr0aKF0atXL8fzIUOGOPoGBwcbMTExxrZt29xQ9Y0rzLwNwzA2b95sNG7c2PD29jaqV69uvPLKK8bly5dNrvrGFXbeP/74oyHJWL16tcmVFq3CzDsnJ8cYN26cER4ebvj4+BhhYWHGs88+W+yCkGEUbt4bNmww6tata3h7exvly5c3evToYfzyyy9uqPrGrF+/3pCU75E31169ehktWrTI95qGDRsaXl5eRvXq1Y3ExETT675R1zPvgvpXqVLF9NpvRGHn3aJFi6v2R342wygmxz4AAABQJDgHEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAiyEAAgAAWAwBEAAAwGIIgAAAABZDAAQAALAYAiAAAIDFEAABAAAshgAIAABgMQRAAAAAi/n/o2MFSZdomUAAAAAASUVORK5CYII=",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1116,9 +1125,24 @@
},
{
"data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGzCAYAAAABsTylAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3/UlEQVR4nO3dd3hUZcL+8XuSkEJJQglNIl16R1AwdGERUdwVAVmpAq/EpURRIksJKAFUQBRRVwgsvopL9bcgvYvSQar0AEoXSAhogMzz+4Mr8zokgRycZA7k+7muuXSeeWbmnnMSuDltHMYYIwAAABvy8XYAAACAjFBUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUAACAbVFUYGulSpVSt27dvB3jgffuu++qTJky8vX1Vc2aNe84d+bMmapYsaJy5cql0NDQbMnnaQ6HQyNGjPB2jHTdvHlTb7zxhsLDw+Xj46N27dp5O5LHjRgxQg6Hw/avCXugqCDbTJ8+XQ6HQ1u3bk338SZNmqhq1ap/+n2+/fZb2/4lZEfLli3TG2+8oYYNGyouLk6jR4/OcO5PP/2kbt26qWzZsvrXv/6lzz77LBuT3vLll19q4sSJ2f6+2WXatGl699139fzzz2vGjBkaOHCgtyMBXuXn7QDAnRw4cEA+Ptb69LfffqvJkydTVjJp1apV8vHx0dSpU+Xv73/HuWvWrJHT6dQHH3ygcuXKZVNCd19++aX27NmjAQMGeOX9s9qqVav00EMPacKECd6OkmX++c9/avDgwd6OgfsEW1RgawEBAcqVK5e3Y1hy9epVb0ew5Ny5cwoKCrprSUmdK+muu3yMMfrtt988ES9H+OPyOnfu3H27Sy2z/Pz8FBgY6O0YuE9QVGBrtx+jcuPGDcXExKh8+fIKDAxUwYIF9cQTT2j58uWSpG7dumny5MmSbh2HkHpLdfXqVb322msKDw9XQECAKlSooPfee0+3f4n4b7/9pn79+qlQoULKly+fnnnmGf3yyy9pjm1I3S++b98+vfjii8qfP7+eeOIJSdKuXbvUrVs3lSlTRoGBgSpatKh69OihX3/91e29Ul/j4MGD+vvf/66QkBCFhYVp6NChMsbo5MmTevbZZxUcHKyiRYvq/fffz9Syu3nzpkaNGqWyZcsqICBApUqV0ltvvaXk5GTXHIfDobi4OF29etW1rKZPn57huhg+fLgkKSwszG1ZlCpVSk8//bSWLl2qunXrKigoSJ9++qkk6ejRo2rfvr0KFCig3Llz67HHHtOiRYvcXnvNmjVyOBz6z3/+o3feeUclSpRQYGCgmjdvrsOHD7vmNWnSRIsWLdLx48ddeUuVKiVJun79uoYNG6Y6deooJCREefLkUUREhFavXp2p5XU3s2bNUp06dZQvXz4FBwerWrVq+uCDD1yPZ3SMROouz/j4eNdYRsvL4XBo9erV2rt3r+vzrVmzRpL03nvvqUGDBipYsKCCgoJUp04dzZkzJ92sX3zxherVq6fcuXMrf/78atSokZYtW+Y2Z/HixYqIiFCePHmUL18+tWnTRnv37s308jDGqFChQoqKinKNOZ1OhYaGytfXV5cvX3aNjx07Vn5+fkpKSspwWTkcDr366qtasGCBqlatqoCAAFWpUkVLlixJ897fffedHn30UQUGBqps2bKunzU8mNj1g2yXkJCgCxcupBm/cePGXZ87YsQIxcbG6uWXX1a9evWUmJiorVu3avv27XryySfVp08fnTp1SsuXL9fMmTPdnmuM0TPPPKPVq1erZ8+eqlmzppYuXapBgwbpl19+cdvU3q1bN/3nP//RSy+9pMcee0xr165VmzZtMszVvn17lS9fXqNHj3aVnuXLl+vo0aPq3r27ihYtqr179+qzzz7T3r17tXHjxjR/UHfo0EGVKlXSmDFjtGjRIr399tsqUKCAPv30UzVr1kxjx47V//7v/+r111/Xo48+qkaNGt1xWb388suaMWOGnn/+eb322mvatGmTYmNjtX//fs2fP1/SrQNjP/vsM23evFmff/65JKlBgwbpvt7EiRP173//W/Pnz9eUKVOUN29eVa9e3fX4gQMH1KlTJ/Xp00e9evVShQoVdPbsWTVo0EDXrl1Tv379VLBgQc2YMUPPPPOM5syZo+eee87tPcaMGSMfHx+9/vrrSkhI0Lhx49S5c2dt2rRJkjRkyBAlJCTo559/dq2vvHnzSpISExP1+eefq1OnTurVq5euXLmiqVOnqlWrVtq8efNdDxK+k+XLl6tTp05q3ry5xo4dK0nav3+/NmzYoP79+9/Ta96+vEqUKKGZM2fqnXfeUVJSkmJjYyVJlSpVkiR98MEHeuaZZ9S5c2ddv35ds2bNUvv27bVw4UK3n82YmBiNGDFCDRo00MiRI+Xv769NmzZp1apVatmypaRb671r165q1aqVxo4dq2vXrmnKlCl64okntGPHDlf5uxOHw6GGDRtq3bp1rrFdu3YpISFBPj4+2rBhgyvX+vXrVatWLde6ysh3332nefPmqW/fvsqXL58mTZqkv/3tbzpx4oQKFiwoSdq9e7datmypsLAwjRgxQjdv3tTw4cNVpEiRzC983F8MkE3i4uKMpDveqlSp4vackiVLmq5du7ru16hRw7Rp0+aO7xMZGWnS+9FesGCBkWTefvttt/Hnn3/eOBwOc/jwYWOMMdu2bTOSzIABA9zmdevWzUgyw4cPd40NHz7cSDKdOnVK837Xrl1LM/bVV18ZSWbdunVpXqN3796usZs3b5oSJUoYh8NhxowZ4xq/dOmSCQoKclsm6dm5c6eRZF5++WW38ddff91IMqtWrXKNde3a1eTJk+eOr3d71vPnz7uNlyxZ0kgyS5YscRsfMGCAkWTWr1/vGrty5YopXbq0KVWqlElJSTHGGLN69WojyVSqVMkkJye75n7wwQdGktm9e7drrE2bNqZkyZJpst28edPtucbcWl5FihQxPXr0cBu/fT3eTf/+/U1wcLC5efNmhnNSl83tUn/ujx075hrLaHkZY0zjxo3T/B4Yk/bn6fr166Zq1aqmWbNmrrFDhw4ZHx8f89xzz7mWbSqn02mMubX8Q0NDTa9evdweP3PmjAkJCUkzfifvvvuu8fX1NYmJicYYYyZNmmRKlixp6tWrZ958801jjDEpKSkmNDTUDBw40PW89JaVJOPv7+/6PTTGmB9//NFIMh9++KFrrF27diYwMNAcP37cNbZv3z7j6+ub7vLH/Y9dP8h2kydP1vLly9Pc/viv84yEhoZq7969OnTokOX3/fbbb+Xr66t+/fq5jb/22msyxmjx4sWS5NrU3LdvX7d5//jHPzJ87f/5n/9JMxYUFOT6/99//10XLlzQY489Jknavn17mvkvv/yy6/99fX1Vt25dGWPUs2dP13hoaKgqVKigo0ePZphFuvVZJbltlpdufVZJaXa9eELp0qXVqlWrNDnq1avn2h0m3doC0rt3b8XHx2vfvn1u87t37+52rExERIQk3fXzSreWWepznU6nLl68qJs3b6pu3brpLm8rQkNDdfXqVdcuRk9Ib3ndyR9/ni5duqSEhARFRES4fbYFCxbI6XRq2LBhaQ5CT92Ct3z5cl2+fFmdOnXShQsXXDdfX1/Vr1/f0q6yiIgIpaSk6Pvvv5d0a8tJRESEIiIitH79eknSnj17dPnyZde6vJMWLVqobNmyrvvVq1dXcHCwa/2npKRo6dKlateunR5++GHXvEqVKllalri/UFSQ7erVq6cWLVqkueXPn/+uzx05cqQuX76sRx55RNWqVdOgQYO0a9euTL3v8ePHVbx4ceXLl89tPHXT+vHjx13/9fHxUenSpd3m3eksl9vnStLFixfVv39/FSlSREFBQQoLC3PNS0hISDP/j3/wSlJISIgCAwNVqFChNOOXLl3KMMsfP8PtmYsWLarQ0FDXZ/Wk9JbB8ePHVaFChTTjty/zVLcvg9Sfibt93lQzZsxQ9erVXccvhYWFadGiRekubyv69u2rRx55RK1bt1aJEiXUo0ePdI+dsCK95XUnCxcu1GOPPabAwEAVKFBAYWFhmjJlittnO3LkiHx8fFS5cuUMXye15Ddr1kxhYWFut2XLlrkOmM6M2rVrK3fu3K5SklpUGjVqpK1bt+r33393PfbHspqR29e/dOtnIHX9nz9/Xr/99pvKly+fZl56P2d4MHCMCu4rjRo10pEjR/TNN99o2bJl+vzzzzVhwgR98sknblskstsf/7Wb6oUXXtD333+vQYMGqWbNmsqbN6+cTqf+8pe/yOl0ppnv6+ubqTFJaQ7+zUh2XgArvWVg1Z/5vF988YW6deumdu3aadCgQSpcuLB8fX0VGxurI0eO/KlchQsX1s6dO7V06VItXrxYixcvVlxcnLp06aIZM2ZIynhZp6SkpDtuZXmtX79ezzzzjBo1aqSPP/5YxYoVU65cuRQXF6cvv/zS0mdJ/dmbOXOmihYtmuZxP7/M/7WQK1cu1a9fX+vWrdPhw4d15swZRUREqEiRIrpx44Y2bdqk9evXq2LFigoLC7vr6/3Zn3c8mCgquO8UKFBA3bt3V/fu3ZWUlKRGjRppxIgRrqKS0V8YJUuW1IoVK3TlyhW3rSo//fST6/HU/zqdTh07dsztX25/PPvkbi5duqSVK1cqJiZGw4YNc43fyy6re5H6GQ4dOuTaeiFJZ8+e1eXLl12fNTtyHDhwIM347cvciozW75w5c1SmTBnNmzfPbU7qmUp/lr+/v9q2bau2bdvK6XSqb9+++vTTTzV06FCVK1fOtfXn8uXLbqcXe2Lr1dy5cxUYGKilS5cqICDANR4XF+c2r2zZsnI6ndq3b1+GBw+n7lopXLiwWrRo8aezRUREaOzYsVqxYoUKFSqkihUryuFwqEqVKlq/fr3Wr1+vp59++k+/j3TrbLOgoKB0f4/S+znDg4FdP7iv3H5qb968eVWuXDm3U27z5MkjSW6nR0rSU089pZSUFH300Udu4xMmTJDD4VDr1q0lybWv++OPP3ab9+GHH2Y6Z+q/DG//l2B2XVH1qaeeSvf9xo8fL0l3PIPJ0zk2b96sH374wTV29epVffbZZypVqtQdd1FkJE+ePOnuyklvmW/atMntve/V7T93Pj4+rmOqUn/2UgvAH8+CuXr1qmuLy5/h6+srh8PhtnUmPj5eCxYscJvXrl07+fj4aOTIkWm22qUul1atWik4OFijR49O90y78+fPW8oWERGh5ORkTZw4UU888YSrJEZERGjmzJk6depUpo5PyQxfX1+1atVKCxYs0IkTJ1zj+/fv19KlSz3yHrAftqjgvlK5cmU1adJEderUUYECBbR161bNmTNHr776qmtOnTp1JEn9+vVTq1at5Ovrq44dO6pt27Zq2rSphgwZovj4eNWoUUPLli3TN998owEDBrj+oqlTp47+9re/aeLEifr1119dpycfPHhQUuZ2pwQHB6tRo0YaN26cbty4oYceekjLli3TsWPHsmCppFWjRg117dpVn332mS5fvqzGjRtr8+bNmjFjhtq1a6emTZtmS47Bgwfrq6++UuvWrdWvXz8VKFBAM2bM0LFjxzR37lzLVx2Wbq2fr7/+WlFRUXr00UeVN29etW3bVk8//bTmzZun5557Tm3atNGxY8f0ySefqHLlyq7rd9yrl19+WRcvXlSzZs1UokQJHT9+XB9++KFq1qzp2mLVsmVLPfzww+rZs6cGDRokX19fTZs2TWFhYW5/qd6LNm3aaPz48frLX/6iF198UefOndPkyZNVrlw5t2O0ypUrpyFDhmjUqFGKiIjQX//6VwUEBGjLli0qXry4YmNjFRwcrClTpuill15S7dq11bFjR1fGRYsWqWHDhmnK/J08/vjj8vPz04EDB9S7d2/XeKNGjTRlyhRJ8lhRkW6dfr1kyRJFRESob9++unnzpj788ENVqVIl08er4T7jvROOkNOknqa5ZcuWdB9P77TM209Pfvvtt029evVMaGioCQoKMhUrVjTvvPOOuX79umvOzZs3zT/+8Q8TFhZmHA6H2ymLV65cMQMHDjTFixc3uXLlMuXLlzfvvvuu69TNVFevXjWRkZGmQIECJm/evKZdu3bmwIEDRpLb6cIZna5rjDE///yzee6550xoaKgJCQkx7du3N6dOncrwFOfbXyOj04YzOn31djdu3DAxMTGmdOnSJleuXCY8PNxER0eb33//PVPvk547nZ6c0WnjR44cMc8//7wJDQ01gYGBpl69embhwoVuc1JPT549e7bb+LFjx4wkExcX5xpLSkoyL774ogkNDTWSXKcqO51OM3r0aFOyZEkTEBBgatWqZRYuXGi6du2a5nTm29fB3cyZM8e0bNnSFC5c2Pj7+5uHH37Y9OnTx5w+fdpt3rZt20z9+vVdc8aPH5/h6ckZLa+M1u/UqVNN+fLlTUBAgKlYsaKJi4vL8JToadOmmVq1apmAgACTP39+07hxY7N8+XK3OatXrzatWrUyISEhJjAw0JQtW9Z069bNbN26NdPLJdWjjz5qJJlNmza5xn7++WcjyYSHh6eZn9HpyZGRkWnm3v5ngDHGrF271tSpU8f4+/ubMmXKmE8++STDZYH7n8MYjlICMmPnzp2qVauWvvjiC3Xu3NnbcQAgR+AYFSAd6X1PzcSJE+Xj43PXK8ICADyHY1SAdIwbN07btm1T06ZN5efn5zoltXfv3goPD/d2PHhISkrKXQ8ezZs3710v/f6guX79ui5evHjHOSEhIR45JR24G3b9AOlYvny5YmJitG/fPiUlJenhhx/WSy+9pCFDhli6zgTsLT4+/q4XXhs+fLjbF1HmBGvWrLnrAddxcXFuXxgKZBWKCoAc6/fff9d33313xzllypRRmTJlsimRPVy6dEnbtm2745wqVaqoWLFi2ZQIORlFBQAA2BYH0wIAANu6r3e2O51OnTp1Svny5cvW7zQBAAD3zhijK1euqHjx4ne98ON9XVROnTrFGRgAANynTp48qRIlStxxzn1dVFK/WO7kyZMKDg72choAAJAZiYmJCg8Pd/uC2Izc10UldXdPcHAwRQUAgPtMZg7b4GBaAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgW14tKqVKlZLD4Uhzi4yM9GYsAABgE179rp8tW7YoJSXFdX/Pnj168skn1b59ey+mAgAAduHVohIWFuZ2f8yYMSpbtqwaN27spUQAAMBObPPtydevX9cXX3yhqKioDL9NMTk5WcnJya77iYmJ2RUPAAB4gW2KyoIFC3T58mV169YtwzmxsbGKiYnJvlAAAHhQqcGLvB3Bsvgxbbz6/rY562fq1Klq3bq1ihcvnuGc6OhoJSQkuG4nT57MxoQAACC72WKLyvHjx7VixQrNmzfvjvMCAgIUEBCQTakAAIC32WKLSlxcnAoXLqw2bby7eQkAANiL14uK0+lUXFycunbtKj8/W2zgAQAANuH1orJixQqdOHFCPXr08HYUAABgM17fhNGyZUsZY7wdAwAA2JDXt6gAAABkhKICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsi6ICAABsy+tF5ZdfftHf//53FSxYUEFBQapWrZq2bt3q7VgAAMAG/Lz55pcuXVLDhg3VtGlTLV68WGFhYTp06JDy58/vzVgAAMAmvFpUxo4dq/DwcMXFxbnGSpcu7cVEAADATry66+f//b//p7p166p9+/YqXLiwatWqpX/9618Zzk9OTlZiYqLbDQAAPLi8ukXl6NGjmjJliqKiovTWW29py5Yt6tevn/z9/dW1a9c082NjYxUTE+OFpIC7UoMXeTuCZfFj2ng7AgBY5tUtKk6nU7Vr19bo0aNVq1Yt9e7dW7169dInn3yS7vzo6GglJCS4bidPnszmxAAAIDt5tagUK1ZMlStXdhurVKmSTpw4ke78gIAABQcHu90AAMCDy6tFpWHDhjpw4IDb2MGDB1WyZEkvJQIAAHbi1aIycOBAbdy4UaNHj9bhw4f15Zdf6rPPPlNkZKQ3YwEAAJvwalF59NFHNX/+fH311VeqWrWqRo0apYkTJ6pz587ejAUAAGzCq2f9SNLTTz+tp59+2tsxAACADXn9EvoAAAAZoagAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADboqgAAADbslxUtm/frt27d7vuf/PNN2rXrp3eeustXb9+3aPhAABAzma5qPTp00cHDx6UJB09elQdO3ZU7ty5NXv2bL3xxhseDwgAAHIuy0Xl4MGDqlmzpiRp9uzZatSokb788ktNnz5dc+fO9XQ+AACQg1kuKsYYOZ1OSdKKFSv01FNPSZLCw8N14cIFz6YDAAA5muWiUrduXb399tuaOXOm1q5dqzZt2kiSjh07piJFing8IAAAyLksF5WJEydq+/btevXVVzVkyBCVK1dOkjRnzhw1aNDA4wEBAEDO5Wf1CdWrV3c76yfVu+++K19fX4+EAgAAkO7xOiqXL1/W559/rujoaF28eFGStG/fPp07d86j4QAAQM5meYvKrl271Lx5c4WGhio+Pl69evVSgQIFNG/ePJ04cUL//ve/syInAADIgSxvUYmKilL37t116NAhBQYGusafeuoprVu3zqPhAABAzma5qGzZskV9+vRJM/7QQw/pzJkzll5rxIgRcjgcbreKFStajQQAAB5Qlnf9BAQEKDExMc34wYMHFRYWZjlAlSpVtGLFiv8L5Gc5EgAAeEBZ3qLyzDPPaOTIkbpx44YkyeFw6MSJE3rzzTf1t7/9zXIAPz8/FS1a1HUrVKiQ5dcAAAAPJstF5f3331dSUpIKFy6s3377TY0bN1a5cuWUL18+vfPOO5YDHDp0SMWLF1eZMmXUuXNnnThxIsO5ycnJSkxMdLsBAIAHl+X9LCEhIVq+fLk2bNigH3/8UUlJSapdu7ZatGhh+c3r16+v6dOnq0KFCjp9+rRiYmIUERGhPXv2KF++fGnmx8bGKiYmxvL7AJBKDV7k7QiWxY9p4+0IALzMYYwx3g6R6vLlyypZsqTGjx+vnj17pnk8OTlZycnJrvuJiYkKDw9XQkKCgoODszMqcrj78S/9+xFFBQ+a+/HPjqz4PUxMTFRISEim/v62vOunX79+mjRpUprxjz76SAMGDLD6cm5CQ0P1yCOP6PDhw+k+HhAQoODgYLcbAAB4cFkuKnPnzlXDhg3TjDdo0EBz5sz5U2GSkpJ05MgRFStW7E+9DgAAeDBYLiq//vqrQkJC0owHBwfrwoULll7r9ddf19q1axUfH6/vv/9ezz33nHx9fdWpUyersQAAwAPIclEpV66clixZkmZ88eLFKlOmjKXX+vnnn9WpUydVqFBBL7zwggoWLKiNGzfe0/VYAADAg8fyWT9RUVF69dVXdf78eTVr1kyStHLlSr3//vuaOHGipdeaNWuW1bcHAAA5iOWi0qNHDyUnJ+udd97RqFGjJEmlSpXSlClT1KVLF48HBAAAOdc9Xa/+lVde0SuvvKLz588rKChIefPm9XQuAACAeysqqTiWBAAAZCXLB9OePXtWL730kooXLy4/Pz/5+vq63QAAADzF8haVbt266cSJExo6dKiKFSsmh8ORFbkAAACsF5XvvvtO69evV82aNbMgDgAAwP+xvOsnPDxcNvp6IAAA8ACzXFQmTpyowYMHKz4+PgviAAAA/B/Lu346dOiga9euqWzZssqdO7dy5crl9vjFixc9Fg4AAORslouK1avPAgAA3CvLRaVr165ZkQMAACANy8eoSNKRI0f0z3/+U506ddK5c+ck3fpSwr1793o0HAAAyNksF5W1a9eqWrVq2rRpk+bNm6ekpCRJ0o8//qjhw4d7PCAAAMi5LBeVwYMH6+2339by5cvl7+/vGm/WrJk2btzo0XAAACBns1xUdu/ereeeey7NeOHChXXhwgWPhAIAAJDuoaiEhobq9OnTacZ37Nihhx56yCOhAAAApHsoKh07dtSbb76pM2fOyOFwyOl0asOGDXr99dfVpUuXrMgIAAByKMtFZfTo0apYsaLCw8OVlJSkypUrq1GjRmrQoIH++c9/ZkVGAACQQ1m6jooxRmfOnNGkSZM0bNgw7d69W0lJSapVq5bKly+fVRkBAEAOZbmolCtXTnv37lX58uUVHh6eVbkAAACs7frx8fFR+fLl9euvv2ZVHgAAABfLx6iMGTNGgwYN0p49e7IiDwAAgIvl7/rp0qWLrl27pho1asjf319BQUFuj/PtyQAAwFP49mQAAGBblorKjRs3tHbtWg0dOlSlS5fOqkwAAACSLB6jkitXLs2dOzersgAAALixfDBtu3bttGDBgiyIAgAA4M7yMSrly5fXyJEjtWHDBtWpU0d58uRxe7xfv34eCwcAAHI2y0Vl6tSpCg0N1bZt27Rt2za3xxwOB0UFAAB4jOWicuzYsazIAQAAkIblY1QAAACyi+UtKj169Ljj49OmTbvnMAAAAH9kuahcunTJ7f6NGze0Z88eXb58Wc2aNfNYMAAAAMtFZf78+WnGnE6nXnnlFZUtW9YjoQAAACQPHaPi4+OjqKgoTZgwwRMvBwAAIMmDB9MeOXJEN2/e9NTLAQAAWN/1ExUV5XbfGKPTp09r0aJF6tq1q8eCAQAAWC4qO3bscLvv4+OjsLAwvf/++3c9IwgAAMAKy0Vl9erVWZEDAAAgDcvHqBw7dkyHDh1KM37o0CHFx8ffc5AxY8bI4XBowIAB9/waAADgwWK5qHTr1k3ff/99mvFNmzapW7du9xRiy5Yt+vTTT1W9evV7ej4AAHgwWS4qO3bsUMOGDdOMP/bYY9q5c6flAElJSercubP+9a9/KX/+/JafDwAAHlyWi4rD4dCVK1fSjCckJCglJcVygMjISLVp00YtWrS469zk5GQlJia63QAAwIPL8sG0jRo1UmxsrL766iv5+vpKklJSUhQbG6snnnjC0mvNmjVL27dv15YtWzI1PzY2VjExMVYjw+ZKDV7k7QgAAJuyXFTGjh2rRo0aqUKFCoqIiJAkrV+/XomJiVq1alWmX+fkyZPq37+/li9frsDAwEw9Jzo62u06LomJiQoPD7f2AQAAwH3D8q6fypUra9euXXrhhRd07tw5XblyRV26dNFPP/2kqlWrZvp1tm3bpnPnzql27dry8/OTn5+f1q5dq0mTJsnPzy/d3UgBAQEKDg52uwEAgAeX5S0qklS8eHGNHj36T71x8+bNtXv3brex7t27q2LFinrzzTddu5UAAEDOZbmoxMXFKW/evGrfvr3b+OzZs3Xt2rVMX0Y/X758abbA5MmTRwULFrS0ZQYAADy4LO/6iY2NVaFChdKMFy5c+E9vZQEAAPgjy1tUTpw4odKlS6cZL1mypE6cOPGnwqxZs+ZPPR8AADxYLG9RKVy4sHbt2pVm/Mcff1TBggU9EgoAAEC6h6LSqVMn9evXT6tXr1ZKSopSUlK0atUq9e/fXx07dsyKjAAAIIeyvOtn1KhRio+PV/PmzeXnd+vpTqdTXbp04RgVAADgUZaLir+/v77++muNGjVKP/74o4KCglStWjWVLFkyK/IBAIAc7J6uoyJJBQoUUNOmTdM9AwgAAMATLB2jcvnyZUVGRqpQoUIqUqSIihQpokKFCunVV1/V5cuXsygiAADIqTK9ReXixYt6/PHH9csvv6hz586qVKmSJGnfvn2aPn26Vq5cqe+//1758+fPsrAAACBnyXRRGTlypPz9/XXkyBEVKVIkzWMtW7bUyJEjNWHCBI+HBAAAOVOmd/0sWLBA7733XpqSIklFixbVuHHjNH/+fI+GAwAAOVumi8rp06dVpUqVDB+vWrWqzpw545FQAAAAkoWiUqhQIcXHx2f4+LFjx1SgQAFPZAIAAJBkoai0atVKQ4YM0fXr19M8lpycrKFDh+ovf/mLR8MBAICczdLBtHXr1lX58uUVGRmpihUryhij/fv36+OPP1ZycrJmzpyZlVkBAEAOk+miUqJECf3www/q27evoqOjZYyRJDkcDj355JP66KOPFB4enmVBAQBAzmPpyrSlS5fW4sWLdenSJR06dEiSVK5cOY5NAQAAWeKeLqGfP39+1atXz9NZAAAA3Fi6hD4AAEB2oqgAAADboqgAAADbylRRqV27ti5duiTp1mnK165dy9JQAAAAUiaLyv79+3X16lVJUkxMjJKSkrI0FAAAgJTJs35q1qyp7t2764knnpAxRu+9957y5s2b7txhw4Z5NCAAAMi5MlVUpk+fruHDh2vhwoVyOBxavHix/PzSPtXhcFBUAACAx2SqqFSoUEGzZs2SJPn4+GjlypUqXLhwlgYDAACwfME3p9OZFTkAAADSuKcr0x45ckQTJ07U/v37JUmVK1dW//79VbZsWY+GAwAAOZvl66gsXbpUlStX1ubNm1W9enVVr15dmzZtUpUqVbR8+fKsyAgAAHIoy1tUBg8erIEDB2rMmDFpxt988009+eSTHgsHAAByNstbVPbv36+ePXumGe/Ro4f27dvnkVAAAADSPRSVsLAw7dy5M834zp07ORMIAAB4lOVdP7169VLv3r119OhRNWjQQJK0YcMGjR07VlFRUR4PCAAAci7LRWXo0KHKly+f3n//fUVHR0uSihcvrhEjRqhfv34eDwgAAHIuy0XF4XBo4MCBGjhwoK5cuSJJypcvn8eDAQAA3NN1VFJRUAAAQFayfDAtAABAdqGoAAAA26KoAAAA27JUVG7cuKHmzZvr0KFDWZUHAADAxVJRyZUrl3bt2pVVWQAAANxY3vXz97//XVOnTs2KLAAAAG4sn5588+ZNTZs2TStWrFCdOnWUJ08et8fHjx+f6deaMmWKpkyZovj4eElSlSpVNGzYMLVu3dpqLAAA8ACyXFT27Nmj2rVrS5IOHjzo9pjD4bD0WiVKlNCYMWNUvnx5GWM0Y8YMPfvss9qxY4eqVKliNRoAAHjAWC4qq1ev9tibt23b1u3+O++8oylTpmjjxo3pFpXk5GQlJye77icmJnosCwAAsJ97vjLt4cOHdeTIETVq1EhBQUEyxljeovJHKSkpmj17tq5evarHH3883TmxsbGKiYm55/cAADwYSg1e5O0IyCaWD6b99ddf1bx5cz3yyCN66qmndPr0aUlSz5499dprr1kOsHv3buXNm1cBAQH6n//5H82fP1+VK1dOd250dLQSEhJct5MnT1p+PwAAcP+wXFQGDhyoXLly6cSJE8qdO7drvEOHDlqyZInlABUqVNDOnTu1adMmvfLKK+ratav27duX7tyAgAAFBwe73QAAwIPL8q6fZcuWaenSpSpRooTbePny5XX8+HHLAfz9/VWuXDlJUp06dbRlyxZ98MEH+vTTTy2/FgAAeLBY3qJy9epVty0pqS5evKiAgIA/HcjpdLodMAsAAHIuy0UlIiJC//73v133HQ6HnE6nxo0bp6ZNm1p6rejoaK1bt07x8fHavXu3oqOjtWbNGnXu3NlqLAAA8ACyvOtn3Lhxat68ubZu3arr16/rjTfe0N69e3Xx4kVt2LDB0mudO3dOXbp00enTpxUSEqLq1atr6dKlevLJJ63GAgAADyDLRaVq1ao6ePCgPvroI+XLl09JSUn661//qsjISBUrVszSa3EpfgAAcCf3dB2VkJAQDRkyxNNZAAAA3NxTUbl06ZKmTp2q/fv3S5IqV66s7t27q0CBAh4NBwAAcjbLB9OuW7dOpUqV0qRJk3Tp0iVdunRJkyZNUunSpbVu3bqsyAgAAHIoy1tUIiMj1aFDB02ZMkW+vr6Sbl3+vm/fvoqMjNTu3bs9HhIAAORMlreoHD58WK+99pqrpEiSr6+voqKidPjwYY+GAwAAOZvlolK7dm3XsSl/tH//ftWoUcMjoQAAAKRM7vrZtWuX6//79eun/v376/Dhw3rsscckSRs3btTkyZM1ZsyYrEkJAABypEwVlZo1a8rhcMgY4xp744030sx78cUX1aFDB8+lAwAAOVqmisqxY8eyOgcAAEAamSoqJUuWzOocAAAAadzTBd9OnTql7777TufOnZPT6XR7rF+/fh4JBgAAYLmoTJ8+XX369JG/v78KFiwoh8PheszhcFBUAACAx1guKkOHDtWwYcMUHR0tHx/LZzcDAABkmuWmce3aNXXs2JGSAgAAspzlttGzZ0/Nnj07K7IAAAC4sbzrJzY2Vk8//bSWLFmiatWqKVeuXG6Pjx8/3mPhAABAznZPRWXp0qWqUKGCJKU5mBYAAMBTLBeV999/X9OmTVO3bt2yIA4AAMD/sXyMSkBAgBo2bJgVWQAAANxYLir9+/fXhx9+mBVZAAAA3Fje9bN582atWrVKCxcuVJUqVdIcTDtv3jyPhQMAADmb5aISGhqqv/71r1mRBQAAwI3lohIXF5cVOQAAANLg8rIAAMC2LG9RKV269B2vl3L06NE/FQgAACCV5aIyYMAAt/s3btzQjh07tGTJEg0aNMhTuQAAAKwXlf79+6c7PnnyZG3duvVPBwIAAEjlsWNUWrdurblz53rq5QAAADxXVObMmaMCBQp46uUAAACs7/qpVauW28G0xhidOXNG58+f18cff+zRcAAAIGezXFTatWvndt/Hx0dhYWFq0qSJKlas6KlcAAAA1ovK8OHDsyIHAABAGlzwDQAA2Famt6j4+Pjc8UJvkuRwOHTz5s0/HQoAAECyUFTmz5+f4WM//PCDJk2aJKfT6ZFQAAAAkoWi8uyzz6YZO3DggAYPHqz//ve/6ty5s0aOHOnRcAAAIGe7p2NUTp06pV69eqlatWq6efOmdu7cqRkzZqhkyZKezgcAAHIwS0UlISFBb775psqVK6e9e/dq5cqV+u9//6uqVatmVT4AAJCDZXrXz7hx4zR27FgVLVpUX331Vbq7ggAAADwp00Vl8ODBCgoKUrly5TRjxgzNmDEj3Xnz5s3L9JvHxsZq3rx5+umnnxQUFKQGDRpo7NixqlChQqZfAwAAPLgyXVS6dOly19OTrVq7dq0iIyP16KOP6ubNm3rrrbfUsmVL7du3T3ny5PHoewEAgPtPpovK9OnTPf7mS5YsSfMehQsX1rZt29SoUSOPvx8AALi/WL6EflZKSEiQpAy/hTk5OVnJycmu+4mJidmSCwAAeIdtiorT6dSAAQPUsGHDDM8iio2NVUxMTDYnA+AtpQYv8naEHCF+TBtvRwAyZJvv+omMjNSePXs0a9asDOdER0crISHBdTt58mQ2JgQAANnNFltUXn31VS1cuFDr1q1TiRIlMpwXEBCggICAbEwGAAC8yatFxRijf/zjH5o/f77WrFmj0qVLezMOAACwGa8WlcjISH355Zf65ptvlC9fPp05c0aSFBISoqCgIG9GAwAANuDVY1SmTJmihIQENWnSRMWKFXPdvv76a2/GAgAANuH1XT8AAAAZsc1ZPwAAALejqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANvyalFZt26d2rZtq+LFi8vhcGjBggXejAMAAGzGq0Xl6tWrqlGjhiZPnuzNGAAAwKb8vPnmrVu3VuvWrb0ZAQAA2JhXi4pVycnJSk5Odt1PTEz0YhoAAJDV7quiEhsbq5iYmGx7v1KDF2XbewEAgLTuq7N+oqOjlZCQ4LqdPHnS25EAAEAWuq+2qAQEBCggIMDbMQAAQDa5r7aoAACAnMWrW1SSkpJ0+PBh1/1jx45p586dKlCggB5++GEvJgMAAHbg1aKydetWNW3a1HU/KipKktS1a1dNnz7dS6kAAIBdeLWoNGnSRMYYb0YAAAA2xjEqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtmxRVCZPnqxSpUopMDBQ9evX1+bNm70dCQAA2IDXi8rXX3+tqKgoDR8+XNu3b1eNGjXUqlUrnTt3ztvRAACAl3m9qIwfP169evVS9+7dVblyZX3yySfKnTu3pk2b5u1oAADAy/y8+ebXr1/Xtm3bFB0d7Rrz8fFRixYt9MMPP6SZn5ycrOTkZNf9hIQESVJiYmKW5HMmX8uS1wUAO8mqP0OzEn8+Z5+s+PlIfU1jzF3nerWoXLhwQSkpKSpSpIjbeJEiRfTTTz+lmR8bG6uYmJg04+Hh4VmWEQAedCETvZ0AdpaVPx9XrlxRSEjIHed4tahYFR0draioKNd9p9OpixcvqmDBgnI4HF5M9uBITExUeHi4Tp48qeDgYG/HwV2wvu4frKv7B+sq6xljdOXKFRUvXvyuc71aVAoVKiRfX1+dPXvWbfzs2bMqWrRomvkBAQEKCAhwGwsNDc3KiDlWcHAwv6D3EdbX/YN1df9gXWWtu21JSeXVg2n9/f1Vp04drVy50jXmdDq1cuVKPf74415MBgAA7MDru36ioqLUtWtX1a1bV/Xq1dPEiRN19epVde/e3dvRAACAl3m9qHTo0EHnz5/XsGHDdObMGdWsWVNLlixJc4AtskdAQICGDx+eZhcb7In1df9gXd0/WFf24jCZOTcIAADAC7x+wTcAAICMUFQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVRyoMmTJ6tUqVIKDAxU/fr1tXnz5jvOnz17tipWrKjAwEBVq1ZN3377bTYlhWRtfU2fPl0Oh8PtFhgYmI1pc65169apbdu2Kl68uBwOhxYsWHDX56xZs0a1a9dWQECAypUrp+nTp2d5TlhfV2vWrEnze+VwOHTmzJnsCZzDUVRymK+//lpRUVEaPny4tm/frho1aqhVq1Y6d+5cuvO///57derUST179tSOHTvUrl07tWvXTnv27Mnm5DmT1fUl3brs9+nTp12348ePZ2PinOvq1auqUaOGJk+enKn5x44dU5s2bdS0aVPt3LlTAwYM0Msvv6ylS5dmcVJYXVepDhw44Pa7Vbhw4SxKCDcGOUq9evVMZGSk635KSoopXry4iY2NTXf+Cy+8YNq0aeM2Vr9+fdOnT58szYlbrK6vuLg4ExISkk3pkBFJZv78+Xec88Ybb5gqVaq4jXXo0MG0atUqC5PhdplZV6tXrzaSzKVLl7IlE9yxRSUHuX79urZt26YWLVq4xnx8fNSiRQv98MMP6T7nhx9+cJsvSa1atcpwPjznXtaXJCUlJalkyZIKDw/Xs88+q71792ZHXFjE79b9p2bNmipWrJiefPJJbdiwwdtxcgyKSg5y4cIFpaSkpPl6giJFimS4r/XMmTOW5sNz7mV9VahQQdOmTdM333yjL774Qk6nUw0aNNDPP/+cHZFhQUa/W4mJifrtt9+8lArpKVasmD755BPNnTtXc+fOVXh4uJo0aaLt27d7O1qO4PXv+gHgOY8//rjbN483aNBAlSpV0qeffqpRo0Z5MRlw/6pQoYIqVKjgut+gQQMdOXJEEyZM0MyZM72YLGdgi0oOUqhQIfn6+urs2bNu42fPnlXRokXTfU7RokUtzYfn3Mv6ul2uXLlUq1YtHT58OCsi4k/I6HcrODhYQUFBXkqFzKpXrx6/V9mEopKD+Pv7q06dOlq5cqVrzOl0auXKlW7/Cv+jxx9/3G2+JC1fvjzD+fCce1lft0tJSdHu3btVrFixrIqJe8Tv1v1t586d/F5lF28fzYvsNWvWLBMQEGCmT59u9u3bZ3r37m1CQ0PNmTNnjDHGvPTSS2bw4MGu+Rs2bDB+fn7mvffeM/v37zfDhw83uXLlMrt37/bWR8hRrK6vmJgYs3TpUnPkyBGzbds207FjRxMYGGj27t3rrY+QY1y5csXs2LHD7Nixw0gy48ePNzt27DDHjx83xhgzePBg89JLL7nmHz161OTOndsMGjTI7N+/30yePNn4+vqaJUuWeOsj5BhW19WECRPMggULzKFDh8zu3btN//79jY+Pj1mxYoW3PkKOQlHJgT788EPz8MMPG39/f1OvXj2zceNG12ONGzc2Xbt2dZv/n//8xzzyyCPG39/fVKlSxSxatCibE+dsVtbXgAEDXHOLFClinnrqKbN9+3YvpM55Uk9hvf2Wun66du1qGjdunOY5NWvWNP7+/qZMmTImLi4u23PnRFbX1dixY03ZsmVNYGCgKVCggGnSpIlZtWqVd8LnQA5jjPHOthwAAIA74xgVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgWxQVAABgW/8ft3plF5TOOWQAAAAASUVORK5CYII=",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1e090e37cc3a4837b5dcce88290514ca",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1126,9 +1150,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "3dff7b1c54a54759968be8570e103f04",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1136,9 +1175,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "20af2b4fe4cd48419458f7edb24d7a8f",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1146,9 +1200,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "403f4eb1e48c4bfbb8aaf0c63039fefd",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1156,9 +1225,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "848ef50677a44953885e686448caf873",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1166,9 +1250,24 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "d92cc040949f498db4ea629de588b897",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
]
},
"metadata": {},
@@ -1176,9 +1275,74 @@
},
{
"data": {
- "image/png": "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",
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a04cb0098fd54e1d84ebfe36bd951d48",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
"
+ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "5ae4bb20613f4ee3b22f37c6fb4b6e31",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "image/png": "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",
+ "text/html": [
+ "\n",
+ " \n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " Figure\n",
+ "
\n",
+ "
\n",
+ "
+ ../notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb
+ ../notebooks/monte_carlo_analysis/monte_carlo_analysis.ipynb
../notebooks/monte_carlo_analysis/parachute_drop_from_helicopter.ipynb
.. toctree::
diff --git a/docs/user/stochastic.rst b/docs/user/stochastic.rst
new file mode 100644
index 000000000..1d325b21e
--- /dev/null
+++ b/docs/user/stochastic.rst
@@ -0,0 +1,249 @@
+.. _stochastic_usage:
+
+Working with Stochastic objects
+===============================
+
+For each RocketPy object (e.g. Environment, SolidMotor, Rocket, etc.), we can
+create a ``Stochastic`` counterpart that extends the initial model, allowing us
+to define the uncertainties of each input parameter.
+
+The idea of the ``Stochastic`` classes is to take the deterministic classes and
+assign uncertainties to their input parameters. This will reflect the inherent
+uncertainties in the real-world data and provide a more realistic simulation.
+
+.. seealso::
+ For ``Stochastic`` class API details, see :ref:`stochastic_reference`.
+
+.. note::
+ In this tutorial, classes without the ``Stochastic`` prefix are considered \
+ deterministic. For instance, ``SolidMotor`` is a deterministic class, while \
+ its stochastic counterpart is named ``StochasticSolidMotor``.
+
+Initialization Parameters
+-------------------------
+
+In terms of initialization parameters, the ``Stochastic`` classes are very
+similar to the deterministic classes.
+We will separate the parameters into three categories: the "deterministic object",
+the "optional parameters", and the "additional parameters".
+Let's take a look at their nuances:
+
+.. note::
+ In Python, we use the terms "argument", "parameter", and "initialization parameter"
+ interchangeably to refer to the values passed to a function or class during initialization.
+
+ For the sake of clarity, we will use the term "argument" from now on.
+
+Arguments
+^^^^^^^^^
+
+1. **Deterministic Object**: \
+ All ``Stochastic`` classes **must** receive a \
+ deterministic object as an argument. This is the only mandatory argument.
+
+2. **Optional Arguments**: \
+ The remaining parameters are the same as in the \
+ deterministic classes, and they are optional. They only need to be passed \
+ if you want to define the uncertainty for that argument. If you don't pass an \
+ argument, it will not be varied during the simulation, and the nominal value \
+ will be taken from the deterministic object.
+
+3. **Additional Arguments**: \
+ Some ``Stochastic`` classes may present additional \
+ arguments that are not present in the deterministic classes. These are used \
+ for specific purposes, such as a multiplication factor for the drag curves.
+
+
+Specifying Uncertainties
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Furthermore, the optional arguments - which define the uncertainties - can be
+passed in a few different ways:
+
+1. **As a single value**: \
+ This will be the standard deviation for that parameter. \
+ The default distribution used will be a normal distribution, and the nominal \
+ value will be the value of that same argument from the deterministic object.
+
+2. **As a tuple of two numbers**: \
+ The first number will be the nominal value of \
+ the distribution, and the second number will be the standard deviation. The \
+ default distribution used will be a normal distribution.
+
+3. **As a tuple of two numbers and a string**: \
+ The first number will be the \
+ nominal value of the distribution, the second number will be the standard \
+ deviation, and the string will be the distribution type. The distribution \
+ type can be one of the following: *"normal"*, *"binomial"*, *"chisquare"*, \
+ *"exponential"*, *"gamma"*, *"gumbel"*, *"laplace"*, *"logistic"*, \
+ *"poisson"*, *"uniform"*, and *"wald"*.
+
+3. **As a tuple of a number and a string**: \
+ The number will be the standard \
+ deviation, and the string will be the distribution type. The nominal value \
+ will be taken from the standard object.
+
+4. **As a list of values**: \
+ The values will be randomly chosen from this list and \
+ used as the parameter value during the simulation. You cannot assign standard \
+ deviations when using lists, nor can you assign different distribution types.
+
+.. note::
+ In statistics, the terms "Normal" and "Gaussian" refer to the same type of \
+ distribution. This distribution is commonly used and is the default for the \
+ ``Stochastic`` classes in RocketPy.
+
+ In this context, a "distribution" refers to a function that describes the \
+ probability of a parameter assuming a certain value. The type of distribution \
+ determines the shape of this function. We use the term "distribution" to \
+ simplify the explanation of the stochastic classes.
+
+Examples
+--------
+
+Here is a better explanation of the arguments with examples:
+
+Example 1: Stochastic Solid Motor
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Consider the ``StochasticSolidMotor`` object:
+
+.. jupyter-execute::
+
+ from rocketpy import SolidMotor, StochasticSolidMotor
+
+ motor = SolidMotor(
+ thrust_source="../data/motors/Cesaroni_M1670.eng",
+ dry_mass=1.815,
+ dry_inertia=(0.125, 0.125, 0.002),
+ nozzle_radius=33 / 1000,
+ grain_number=5,
+ grain_density=1815,
+ grain_outer_radius=33 / 1000,
+ grain_initial_inner_radius=15 / 1000,
+ grain_initial_height=120 / 1000,
+ grain_separation=5 / 1000,
+ grains_center_of_mass_position=0.397,
+ center_of_dry_mass_position=0.317,
+ nozzle_position=0,
+ burn_time=3.9,
+ throat_radius=11 / 1000,
+ coordinate_system_orientation="nozzle_to_combustion_chamber",
+ )
+
+ stochastic_motor = StochasticSolidMotor(
+ solid_motor=motor,
+ burn_start_time=(0, 0.1, "binomial"),
+ grains_center_of_mass_position=0.001,
+ grain_density=10,
+ grain_separation=1 / 1000,
+ grain_initial_height=1 / 1000,
+ grain_initial_inner_radius=0.375 / 1000,
+ grain_outer_radius=0.375 / 1000,
+ total_impulse=(6500, 100),
+ throat_radius=0.5 / 1000,
+ nozzle_radius=0.5 / 1000,
+ nozzle_position=0.001,
+ )
+
+ stochastic_motor.visualize_attributes()
+
+Interpreting the Output
+"""""""""""""""""""""""
+
+To illustrate the example above, you can notice that:
+
+- The ``burn_start_time`` argument was specified as a tuple of 3 items (0, 0.1, "binomial"), meaning the nominal value is 0, the standard deviation is 0.1, and the distribution type is binomial. You can check that it was correctly set being reading the ``burn_start_time: 0.00000 ± 0.10000 (numpy.random.binomial)`` line in the output.
+- ``total_impulse`` was given as a tuple of 2 numbers (6500, 100), indicating a nominal value of 6500 and a standard deviation of 1000, with the default distribution being normal, which is the default distribution type.
+
+.. note::
+ Always remember to run ``stochastic_object.visualize_attributes()`` to check \
+ if the uncertainties were correctly set.
+
+Sampling a Stochastic Object
+""""""""""""""""""""""""""""
+
+Continuing with the example, you can use the ``stochastic_motor`` object to generate
+a random `SolidMotor` object considering the uncertainties defined in the initialization.
+
+.. jupyter-execute::
+
+ sampled_motor = stochastic_motor.create_object()
+ print(sampled_motor)
+
+This will create a new ``SolidMotor`` object in memory and assign it to the
+variable ``sampled_motor``. This behaves exactly like a ``SolidMotor`` object, but
+considering that each parameter was randomly sampled from the defined distributions.
+We can compare the nominal values of the ``motor`` object with the sampled values
+of the ``sampled_motor`` object:
+
+.. jupyter-execute::
+
+ print("Deterministic Motor with nominal values:\n")
+ motor.prints.all()
+ print("\n\nSampled Motor considering uncertainties:\n")
+ sampled_motor.prints.all()
+
+As you can notice, the values from the ``sampled_motor`` object are slightly different
+from the nominal values of the ``motor`` object.
+
+.. important::
+ If you run the ``create_object()`` method multiple times, you will get different
+ results each time, as the values are always randomly sampled from the defined
+ distributions.
+
+
+Determining Uncertainties
+-------------------------
+
+Determining the uncertainties for each parameter is crucial for accurate simulations.
+Here are some practical methods:
+
+1. **Empirical Measurements**: \
+ For geometric properties and other parameters that \
+ can be measured, you can take multiple measurements and calculate the standard \
+ deviation. This method provides a direct and reliable estimate of uncertainty. \
+ Some examples include: rocket mass, dimensions or positions and material density.
+
+2. **Historical Data**: \
+ Use historical data from previous experiments or similar \
+ projects to base your standard deviations. For example, if you are designing a \
+ rocket with similar characteristics to a previous project, you can use the \
+ uncertainties from that project as a starting point.
+
+3. **Literature Review**: \
+ Review literature and technical documents to find \
+ estimation values for uncertainties. For example, for aerodynamic coefficients, \
+ you can find typical values in textbooks or research papers, these usually \
+ come from wind tunnel tests. A good resource to base your uncertainties is the \
+ `RocketPy article `_.
+
+5. **Rule of Thumb**: \
+ In the absence of specific data, you can use general rules \
+ of thumb. For example, assigning a standard deviation of 10% of the nominal \
+ value is a common practice.
+
+As your rocket project evolves, you will likely gather more data and refine your
+models. Consequently, the uncertainties should decrease, resulting in stochastic
+models with less variance. This iterative process will enhance the accuracy and
+reliability of your simulations over time.
+
+.. Determining Which Arguments to Vary
+.. -----------------------------------
+
+.. Choosing which arguments to vary is crucial for effective Monte Carlo simulations.
+.. RocketPy offers a ``Sensitivity Analysis toolkit``, which can help you to identify
+.. which parameters most significantly impact your simulation results.
+
+
+Conclusion
+----------
+
+The ``Stochastic`` classes in RocketPy provide a powerful way to introduce and
+manage uncertainties in your simulations. By defining distributions for each
+input parameter, you can perform more realistic and robust Monte Carlo simulations,
+better reflecting the inherent uncertainties in rocketry.
+
+.. note::
+ See the ``MonteCarlo`` class documentation for more information on how to run \
+ Monte Carlo simulations with stochastic objects.
diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py
index e03a3f4f3..587f98b11 100644
--- a/rocketpy/plots/monte_carlo_plots.py
+++ b/rocketpy/plots/monte_carlo_plots.py
@@ -4,7 +4,7 @@
class _MonteCarloPlots:
- """Class to plot the monte carlo analysis results."""
+ """Class to plot the Monte Carlo analysis results."""
def __init__(self, monte_carlo):
self.monte_carlo = monte_carlo
@@ -18,62 +18,51 @@ def ellipses(
ylim=(-3000, 3000),
save=False,
):
- """A function to plot the error ellipses for the apogee and impact
- points of the rocket. The function also plots the real landing point, if
- given
+ """
+ Plot the error ellipses for the apogee and impact points of the rocket.
Parameters
----------
image : str, optional
- The path to the image to be used as the background
+ Path to the background image, usually a map of the launch site.
actual_landing_point : tuple, optional
- A tuple containing the actual landing point of the rocket, if known.
- Useful when comparing the Monte Carlo results with the actual landing.
- Must be given in tuple format, such as (x, y) in meters.
- By default None.
+ Actual landing point of the rocket in (x, y) meters.
perimeter_size : int, optional
- The size of the perimeter to be plotted. The default is 3000.
+ Size of the perimeter to be plotted. Default is 3000.
xlim : tuple, optional
- The limits of the x axis. The default is (-3000, 3000).
+ Limits of the x-axis. Default is (-3000, 3000). Values in meters.
ylim : tuple, optional
- The limits of the y axis. The default is (-3000, 3000).
- save : bool
- Whether save the output into a file or not. The default is False.
- If True, the image will not be displayed, and the .savefig() method
- will be called. If False, the image will be displayed, and the
- .show() method will be called.
+ Limits of the y-axis. Default is (-3000, 3000). Values in meters.
+ save : bool, optional
+ Whether to save the plot as a file. Default is False. If True, the
+ plot is saved and not displayed. If False, the plot is displayed.
Returns
-------
None
"""
+
# Import background map
if image is not None:
- # TODO: use the optional import function
try:
from imageio import imread
img = imread(image)
except ImportError:
raise ImportError(
- "The 'imageio' package could not be. Please install it to add background images."
+ "The 'imageio' package is required to add background images. Please install it."
)
except FileNotFoundError:
raise FileNotFoundError(
"The image file was not found. Please check the path."
)
- (
- impact_ellipses,
- apogee_ellipses,
- apogee_x,
- apogee_y,
- impact_x,
- impact_y,
- ) = generate_monte_carlo_ellipses(self.monte_carlo.results)
+ impact_ellipses, apogee_ellipses, apogee_x, apogee_y, impact_x, impact_y = (
+ generate_monte_carlo_ellipses(self.monte_carlo.results)
+ )
# Create plot figure
- plt.figure(num=None, figsize=(8, 6), dpi=150, facecolor="w", edgecolor="k")
+ plt.figure(figsize=(8, 6), dpi=150)
ax = plt.subplot(111)
for ell in impact_ellipses:
@@ -81,13 +70,11 @@ def ellipses(
for ell in apogee_ellipses:
ax.add_artist(ell)
- # Draw launch point
+ # Draw points
plt.scatter(0, 0, s=30, marker="*", color="black", label="Launch Point")
- # Draw apogee points
plt.scatter(
apogee_x, apogee_y, s=5, marker="^", color="green", label="Simulated Apogee"
)
- # Draw impact points
plt.scatter(
impact_x,
impact_y,
@@ -96,8 +83,8 @@ def ellipses(
color="blue",
label="Simulated Landing Point",
)
- # Draw real landing point
- if actual_landing_point != None:
+
+ if actual_landing_point:
plt.scatter(
actual_landing_point[0],
actual_landing_point[1],
@@ -108,11 +95,8 @@ def ellipses(
)
plt.legend()
-
- # Add title and labels to plot
ax.set_title(
- "1$\\sigma$, 2$\\sigma$ and 3$\\sigma$ "
- + "Monte Carlo Ellipses: Apogee and Landing Points"
+ "1$\\sigma$, 2$\\sigma$ and 3$\\sigma$ Monte Carlo Ellipses: Apogee and Landing Points"
)
ax.set_ylabel("North (m)")
ax.set_xlabel("East (m)")
@@ -133,35 +117,33 @@ def ellipses(
perimeter_size - dy,
],
)
+
plt.axhline(0, color="black", linewidth=0.5)
plt.axvline(0, color="black", linewidth=0.5)
plt.xlim(*xlim)
plt.ylim(*ylim)
- # Save plot and show result
if save:
plt.savefig(
- str(self.monte_carlo.filename) + ".png",
- bbox_inches="tight",
- pad_inches=0,
+ f"{self.monte_carlo.filename}.png", bbox_inches="tight", pad_inches=0
)
else:
plt.show()
def all(self, keys=None):
- """Plot the results of the Monte Carlo analysis.
+ """
+ Plot the histograms of the Monte Carlo simulation results.
Parameters
----------
keys : str, list or tuple, optional
The keys of the results to be plotted. If None, all results will be
- plotted. The default is None.
+ plotted. Default is None.
Returns
-------
None
"""
-
if keys is None:
keys = self.monte_carlo.results.keys()
elif isinstance(keys, str):
@@ -170,19 +152,14 @@ def all(self, keys=None):
keys = list(set(keys).intersection(self.monte_carlo.results.keys()))
if len(keys) == 0:
raise ValueError(
- "The selected 'keys' are not available in the results. "
- "Please check the documentation."
+ "The specified 'keys' are not available in the results."
)
else:
- raise ValueError(
- "The 'keys' argument must be a string, list or tuple. "
- "Please check the documentation."
- )
+ raise ValueError("The 'keys' argument must be a string, list, or tuple.")
+
for key in keys:
plt.figure()
- plt.hist(
- self.monte_carlo.results[key],
- )
+ plt.hist(self.monte_carlo.results[key])
plt.title(f"Histogram of {key}")
plt.ylabel("Number of Occurrences")
plt.show()
diff --git a/rocketpy/simulation/monte_carlo.py b/rocketpy/simulation/monte_carlo.py
index 2ea28eaa9..5bc8dcef9 100644
--- a/rocketpy/simulation/monte_carlo.py
+++ b/rocketpy/simulation/monte_carlo.py
@@ -1,4 +1,17 @@
-"""Defines the MonteCarlo class."""
+"""
+Monte Carlo Simulation Module for RocketPy
+
+This module defines the `MonteCarlo` class, which is used to perform Monte Carlo
+simulations of rocket flights. The Monte Carlo simulation is a powerful tool for
+understanding the variability and uncertainty in the performance of rocket flights
+by running multiple simulations with varied input parameters.
+
+Notes
+-----
+This module is still under active development, and some features or attributes may
+change in future versions. Users are encouraged to check for updates and read the
+latest documentation.
+"""
import json
import warnings
@@ -16,7 +29,6 @@
generate_monte_carlo_ellipses_coordinates,
)
-# TODO: Let Functions and Flights be json serializable
# TODO: Create evolution plots to analyze convergence
@@ -26,12 +38,8 @@ class MonteCarlo:
Attributes
----------
filename : str
- When running a new simulation, this parameter represents the
- initial part of the export filenames. For example, if the value
- is 'filename', the exported output files will be named
- 'filename.outputs.txt'. When analyzing the results of a
- previous simulation, this parameter should be set to the .txt
- file containing the outputs of the previous monte carlo analysis.
+ Represents the initial part of the export filenames or the .txt file
+ containing the outputs of a previous simulation.
environment : StochasticEnvironment
The stochastic environment object to be iterated over.
rocket : StochasticRocket
@@ -39,9 +47,7 @@ class MonteCarlo:
flight : StochasticFlight
The stochastic flight object to be iterated over.
export_list : list
- The list of variables to export. If None, the default list will
- be used. Default is None. # TODO: improve docs to explain the
- default list, and what can be exported.
+ The list of variables to export at each simulation.
inputs_log : list
List of dictionaries with the inputs used in each simulation.
outputs_log : list
@@ -49,20 +55,28 @@ class MonteCarlo:
errors_log : list
List of dictionaries with the errors of each simulation.
num_of_loaded_sims : int
- Number of simulations loaded from output_file being currently used.
+ Number of simulations loaded from output_file currently being used.
results : dict
- Monte carlo analysis results organized in a dictionary where the keys
- are the names of the saved attributes, and the values are a list with
- all the result number of the respective attribute
+ Monte Carlo analysis results organized in a dictionary where the keys
+ are the names of the saved attributes, and the values are lists with all
+ the result numbers of the respective attributes.
processed_results : dict
- Creates a dictionary with the mean and standard deviation of each
- parameter available in the results
+ Dictionary with the mean and standard deviation of each parameter
+ available in the results.
prints : _MonteCarloPrints
- Object with methods to print information about the monte carlo
- simulation.
+ Object with methods to print information about the Monte Carlo simulation.
+ Use help(MonteCarlo.prints) for more information.
plots : _MonteCarloPlots
- Object with methods to plot information about the monte carlo
- simulation.
+ Object with methods to plot information about the Monte Carlo simulation.
+ Use help(MonteCarlo.plots) for more information.
+ number_of_simulations : int
+ Number of simulations to be run.
+ total_wall_time : float
+ The total elapsed real-world time from the start to the end of the
+ simulation, including all waiting times and delays.
+ total_cpu_time : float
+ The total CPU time spent running the simulation, excluding the time
+ spent waiting for I/O operations or other processes to complete.
"""
def __init__(self, filename, environment, rocket, flight, export_list=None):
@@ -72,13 +86,8 @@ def __init__(self, filename, environment, rocket, flight, export_list=None):
Parameters
----------
filename : str
- When running a new simulation, this parameter represents the
- initial part of the export filenames. For example, if the value
- is 'filename', the exported output files will be named
- 'filename.outputs.txt'. When analyzing the results of a
- previous simulation, this parameter should be set to the .txt
- file containing the outputs of the previous monte carlo
- analysis.
+ Represents the initial part of the export filenames or the .txt file
+ containing the outputs of a previous simulation.
environment : StochasticEnvironment
The stochastic environment object to be iterated over.
rocket : StochasticRocket
@@ -86,9 +95,13 @@ def __init__(self, filename, environment, rocket, flight, export_list=None):
flight : StochasticFlight
The stochastic flight object to be iterated over.
export_list : list, optional
- The list of variables to export. If None, the default list will
- be used. Default is None. # TODO: improve docs to explain the
- default list, and what can be exported.
+ The list of variables to export. If None, the default list will be
+ used, which includes the following variables: `apogee`, `apogee_time`,
+ `apogee_x`, `apogee_y`, `t_final`, `x_impact`, `y_impact`,
+ `impact_velocity`, `initial_stability_margin`,
+ `out_of_rail_stability_margin`, `out_of_rail_time`,
+ `out_of_rail_velocity`, `max_mach_number`, `frontal_surface_wind`,
+ `lateral_surface_wind`. Default is None.
Returns
-------
@@ -100,7 +113,6 @@ def __init__(self, filename, environment, rocket, flight, export_list=None):
UserWarning,
)
- # Save and initialize parameters
self.filename = filename
self.environment = environment
self.rocket = rocket
@@ -117,7 +129,6 @@ def __init__(self, filename, environment, rocket, flight, export_list=None):
self._inputs_dict = {}
self._last_print_len = 0 # used to print on the same line
- # Checks export_list
self.export_list = self.__check_export_list(export_list)
try:
@@ -137,7 +148,7 @@ def __init__(self, filename, environment, rocket, flight, export_list=None):
def simulate(self, number_of_simulations, append=False):
"""
- Runs the monte carlo simulation and saves all data.
+ Runs the Monte Carlo simulation and saves all data.
Parameters
----------
@@ -150,6 +161,20 @@ def simulate(self, number_of_simulations, append=False):
Returns
-------
None
+
+ Notes
+ -----
+ If you need to stop the simulations after starting them, you can
+ interrupt the process and the files will be saved with the results
+ until the last iteration. You can then load the results and continue
+ the simulation by running the ``simulate`` method again with the
+ same number of simulations and setting `append=True`.
+
+ Important
+ ---------
+ If you use `append=False` and the files already exist, they will be
+ overwritten. Make sure to save the files with the results before
+ running the simulation again with `append=False`.
"""
# Create data files for inputs, outputs and error logging
open_mode = "a" if append else "w"
@@ -159,34 +184,51 @@ def simulate(self, number_of_simulations, append=False):
# initialize counters
self.number_of_simulations = number_of_simulations
- self.iteration_count = self.num_of_loaded_sims if append else 0
- self.start_time = time()
- self.start_cpu_time = process_time()
+ self.__iteration_count = self.num_of_loaded_sims if append else 0
+ self.__start_time = time()
+ self.__start_cpu_time = process_time()
# Begin display
- print("Starting monte carlo analysis", end="\r")
+ print("Starting Monte Carlo analysis", end="\r")
try:
- while self.iteration_count < self.number_of_simulations:
+ while self.__iteration_count < self.number_of_simulations:
self.__run_single_simulation(input_file, output_file)
except KeyboardInterrupt:
print("Keyboard Interrupt, files saved.")
error_file.write(json.dumps(self._inputs_dict, cls=RocketPyEncoder) + "\n")
self.__close_files(input_file, output_file, error_file)
except Exception as error:
- print(f"Error on iteration {self.iteration_count}: {error}")
+ print(f"Error on iteration {self.__iteration_count}: {error}")
error_file.write(json.dumps(self._inputs_dict, cls=RocketPyEncoder) + "\n")
self.__close_files(input_file, output_file, error_file)
raise error
+ finally:
+ self.total_cpu_time = process_time() - self.__start_cpu_time
+ self.total_wall_time = time() - self.__start_time
+
+ self.__terminate_simulation(input_file, output_file, error_file)
- self.__finalize_simulation(input_file, output_file, error_file)
+ # Auxiliary methods
def __run_single_simulation(self, input_file, output_file):
- """Runs a single simulation and saves the inputs and outputs to the
- respective files."""
- # Update iteration count
- self.iteration_count += 1
- # Run trajectory simulation
+ """
+ Runs a single simulation and saves the inputs and outputs to the
+ respective files.
+
+ Parameters
+ ----------
+ input_file : str
+ The file object to write the inputs.
+ output_file : str
+ The file object to write the outputs.
+
+ Returns
+ -------
+ None
+ """
+ self.__iteration_count += 1
+
monte_carlo_flight = Flight(
rocket=self.rocket.create_object(),
environment=self.environment.create_object(),
@@ -207,7 +249,6 @@ def __run_single_simulation(self, input_file, output_file):
for item in d.items()
)
- # Export inputs and outputs to file
self.__export_flight_data(
flight=monte_carlo_flight,
inputs_dict=self._inputs_dict,
@@ -215,12 +256,12 @@ def __run_single_simulation(self, input_file, output_file):
output_file=output_file,
)
- average_time = (process_time() - self.start_cpu_time) / self.iteration_count
+ average_time = (process_time() - self.__start_cpu_time) / self.__iteration_count
estimated_time = int(
- (self.number_of_simulations - self.iteration_count) * average_time
+ (self.number_of_simulations - self.__iteration_count) * average_time
)
self.__reprint(
- f"Current iteration: {self.iteration_count:06d} | "
+ f"Current iteration: {self.__iteration_count:06d} | "
f"Average Time per Iteration: {average_time:.3f} s | "
f"Estimated time left: {estimated_time} s",
end="\r",
@@ -228,17 +269,47 @@ def __run_single_simulation(self, input_file, output_file):
)
def __close_files(self, input_file, output_file, error_file):
- """Closes all the files."""
+ """
+ Closes all the files.
+
+ Parameters
+ ----------
+ input_file : str
+ The file object to write the inputs.
+ output_file : str
+ The file object to write the outputs.
+ error_file : str
+ The file object to write the errors.
+
+ Returns
+ -------
+ None
+ """
input_file.close()
output_file.close()
error_file.close()
- def __finalize_simulation(self, input_file, output_file, error_file):
- """Finalizes the simulation, closes the files and prints the results."""
+ def __terminate_simulation(self, input_file, output_file, error_file):
+ """
+ Terminates the simulation, closes the files and prints the results.
+
+ Parameters
+ ----------
+ input_file : str
+ The file object to write the inputs.
+ output_file : str
+ The file object to write the outputs.
+ error_file : str
+ The file object to write the errors.
+
+ Returns
+ -------
+ None
+ """
final_string = (
- f"Completed {self.iteration_count} iterations. Total CPU time: "
- f"{process_time() - self.start_cpu_time:.1f} s. Total wall time: "
- f"{time() - self.start_time:.1f} s\n"
+ f"Completed {self.__iteration_count} iterations. Total CPU time: "
+ f"{process_time() - self.__start_cpu_time:.1f} s. Total wall time: "
+ f"{time() - self.__start_time:.1f} s\n"
)
self.__reprint(final_string + "Saving results.", flush=True)
@@ -260,20 +331,48 @@ def __export_flight_data(
input_file,
output_file,
):
- """Exports the flight data to the respective files."""
- # Construct the dict with the results from the flight
+ """
+ Exports the flight data to the respective files.
+
+ Parameters
+ ----------
+ flight : Flight
+ The Flight object containing the flight data.
+ inputs_dict : dict
+ Dictionary containing the inputs used in the simulation.
+ input_file : str
+ The file object to write the inputs.
+ output_file : str
+ The file object to write the outputs.
+
+ Returns
+ -------
+ None
+ """
results = {
export_item: getattr(flight, export_item)
for export_item in self.export_list
}
- # Write flight setting and results to file
input_file.write(json.dumps(inputs_dict, cls=RocketPyEncoder) + "\n")
output_file.write(json.dumps(results, cls=RocketPyEncoder) + "\n")
def __check_export_list(self, export_list):
- """Checks if the export_list is valid and returns a valid list. If no
- export_list is provided, the default list is used."""
+ """
+ Checks if the export_list is valid and returns a valid list. If no
+ export_list is provided, the standard list is used.
+
+ Parameters
+ ----------
+ export_list : list
+ The list of variables to export. If None, the default list will be
+ used. Default is None.
+
+ Returns
+ -------
+ list
+ Validated export list.
+ """
standard_output = set(
{
"apogee",
@@ -293,6 +392,9 @@ def __check_export_list(self, export_list):
"lateral_surface_wind",
}
)
+ # NOTE: exportables needs to be updated with Flight numerical properties
+ # example: You added the property 'inclination' to Flight, so you may
+ # need to add it to exportables as well. But don't add other types.
exportables = set(
{
"inclination",
@@ -360,9 +462,10 @@ def __check_export_list(self, export_list):
return export_list
def __reprint(self, msg, end="\n", flush=False):
- """Prints a message on the same line as the previous one and replaces
- the previous message with the new one, deleting the extra characters
- from the previous message.
+ """
+ Prints a message on the same line as the previous one and replaces the
+ previous message with the new one, deleting the extra characters from
+ the previous message.
Parameters
----------
@@ -377,7 +480,6 @@ def __reprint(self, msg, end="\n", flush=False):
-------
None
"""
-
len_msg = len(msg)
if len_msg < self._last_print_len:
msg += " " * (self._last_print_len - len_msg)
@@ -386,26 +488,50 @@ def __reprint(self, msg, end="\n", flush=False):
print(msg, end=end, flush=flush)
+ # Properties and setters
+
@property
def input_file(self):
- """String containing the filepath of the input file"""
+ """String representing the filepath of the input file"""
return self._input_file
@input_file.setter
def input_file(self, value):
- """Setter for input_file. Sets/updates inputs_log."""
+ """
+ Setter for input_file. Sets/updates inputs_log.
+
+ Parameters
+ ----------
+ value : str
+ The filepath of the input file.
+
+ Returns
+ -------
+ None
+ """
self._input_file = value
self.set_inputs_log()
@property
def output_file(self):
- """String containing the filepath of the output file"""
+ """String representing the filepath of the output file"""
return self._output_file
@output_file.setter
def output_file(self, value):
- """Setter for input_file. Sets/updates outputs_log, num_of_loaded_sims,
- results, and processed_results."""
+ """
+ Setter for output_file. Sets/updates outputs_log, num_of_loaded_sims,
+ results, and processed_results.
+
+ Parameters
+ ----------
+ value : str
+ The filepath of the output file.
+
+ Returns
+ -------
+ None
+ """
self._output_file = value
self.set_outputs_log()
self.set_num_of_loaded_sims()
@@ -414,46 +540,96 @@ def output_file(self, value):
@property
def error_file(self):
- """String containing the filepath of the error file"""
+ """String representing the filepath of the error file"""
return self._error_file
@error_file.setter
def error_file(self, value):
- """Setter for input_file. Sets/updates inputs_log."""
+ """
+ Setter for error_file. Sets/updates errors_log.
+
+ Parameters
+ ----------
+ value : str
+ The filepath of the error file.
+
+ Returns
+ -------
+ None
+ """
self._error_file = value
self.set_errors_log()
- # setters for post simulation attributes
+ # Setters for post simulation attributes
+
def set_inputs_log(self):
- """Sets inputs_log from a file into an attribute for easy access"""
+ """
+ Sets inputs_log from a file into an attribute for easy access.
+
+ Returns
+ -------
+ None
+ """
self.inputs_log = []
with open(self.input_file, mode="r", encoding="utf-8") as rows:
for line in rows:
self.inputs_log.append(json.loads(line))
def set_outputs_log(self):
- """Sets outputs_log from a file into an attribute for easy access"""
+ """
+ Sets outputs_log from a file into an attribute for easy access.
+
+ Returns
+ -------
+ None
+ """
self.outputs_log = []
with open(self.output_file, mode="r", encoding="utf-8") as rows:
for line in rows:
self.outputs_log.append(json.loads(line))
def set_errors_log(self):
- """Sets errors_log log from a file into an attribute for easy access"""
+ """
+ Sets errors_log from a file into an attribute for easy access.
+
+ Returns
+ -------
+ None
+ """
self.errors_log = []
with open(self.error_file, mode="r", encoding="utf-8") as errors:
for line in errors:
self.errors_log.append(json.loads(line))
def set_num_of_loaded_sims(self):
- """Number of simulations loaded from output_file being currently used."""
+ """
+ Determines the number of simulations loaded from output_file being
+ currently used.
+
+ Returns
+ -------
+ None
+ """
with open(self.output_file, mode="r", encoding="utf-8") as outputs:
self.num_of_loaded_sims = sum(1 for _ in outputs)
def set_results(self):
- """Monte carlo results organized in a dictionary where the keys are the
- names of the saved attributes, and the values are a list with all the
- result number of the respective attribute"""
+ """
+ Monte Carlo results organized in a dictionary where the keys are the
+ names of the saved attributes, and the values are lists with all the
+ result numbers of the respective attributes. For instance:
+
+ .. code-block:: python
+
+ {
+ 'apogee': [1000, 1001, 1002, ...],
+ 'max_speed': [100, 101, 102, ...],
+ }
+
+ Returns
+ -------
+ None
+ """
self.results = {}
for result in self.outputs_log:
for key, value in result.items():
@@ -463,27 +639,41 @@ def set_results(self):
self.results[key] = [value]
def set_processed_results(self):
- """Creates a dictionary with the mean and standard deviation of each
- parameter available in the results"""
+ """
+ Creates a dictionary with the mean and standard deviation of each
+ parameter available in the results.
+
+ Returns
+ -------
+ None
+ """
self.processed_results = {}
for result, values in self.results.items():
mean = np.mean(values)
stdev = np.std(values)
self.processed_results[result] = (mean, stdev)
+ # Import methods
+
def import_outputs(self, filename=None):
- """Import monte carlo results from .txt file and save it into a
- dictionary.
+ """
+ Import Monte Carlo results from .txt file and save it into a dictionary.
Parameters
----------
- filename : str
+ filename : str, optional
Name or directory path to the file to be imported. If none,
self.filename will be used.
Returns
-------
None
+
+ Notes
+ -----
+ Notice that you can import the outputs, inputs, and errors from the a
+ file without the need to run simulations. You can use previously saved
+ files to process analyze the results or to continue a simulation.
"""
filepath = filename if filename else self.filename
@@ -500,12 +690,12 @@ def import_outputs(self, filename=None):
)
def import_inputs(self, filename=None):
- """Import monte carlo results from .txt file and save it into a
- dictionary.
+ """
+ Import Monte Carlo inputs from .txt file and save it into a dictionary.
Parameters
----------
- filename : str
+ filename : str, optional
Name or directory path to the file to be imported. If none,
self.filename will be used.
@@ -525,12 +715,12 @@ def import_inputs(self, filename=None):
print(f"The following input file was imported: {self.input_file}")
def import_errors(self, filename=None):
- """Import monte carlo results from .txt file and save it into a
- dictionary.
+ """
+ Import Monte Carlo errors from .txt file and save it into a dictionary.
Parameters
----------
- filename : str
+ filename : str, optional
Name or directory path to the file to be imported. If none,
self.filename will be used.
@@ -549,12 +739,12 @@ def import_errors(self, filename=None):
print(f"The following error file was imported: {self.error_file}")
def import_results(self, filename=None):
- """Import monte carlo results from .txt file and save it into a
- dictionary.
+ """
+ Import Monte Carlo results from .txt file and save it into a dictionary.
Parameters
----------
- filename : str
+ filename : str, optional
Name or directory path to the file to be imported. If none,
self.filename will be used.
@@ -562,49 +752,61 @@ def import_results(self, filename=None):
-------
None
"""
- # select file to use
filepath = filename if filename else self.filename
self.import_outputs(filename=filepath)
self.import_inputs(filename=filepath)
self.import_errors(filename=filepath)
+ # Export methods
+
def export_ellipses_to_kml(
self,
filename,
origin_lat,
origin_lon,
- type="all",
+ type="all", # TODO: Don't use "type" as a parameter name, it's a reserved word
resolution=100,
color="ff0000ff",
):
- """Generates a KML file with the ellipses on the impact point.
+ """
+ Generates a KML file with the ellipses on the impact point, which can be
+ used to visualize the dispersion ellipses on Google Earth.
Parameters
----------
- results : dict
- Contains results from the Monte Carlo simulation.
- filename : String
+ filename : str
Name to the KML exported file.
origin_lat : float
Latitude coordinate of Ellipses' geometric center, in degrees.
origin_lon : float
- Latitude coordinate of Ellipses' geometric center, in degrees.
- type : String
+ Longitude coordinate of Ellipses' geometric center, in degrees.
+ type : str, optional
Type of ellipses to be exported. Options are: 'all', 'impact' and
- 'apogee'. Default is 'all', it exports both apogee and impact
- ellipses.
- resolution : int
- Number of points to be used to draw the ellipse. Default is 100.
- color : String
- Color of the ellipse. Default is 'ff0000ff', which is red.
- Kml files use an 8 digit HEX color format, see its docs.
+ 'apogee'. Default is 'all', it exports both apogee and impact ellipses.
+ resolution : int, optional
+ Number of points to be used to draw the ellipse. Default is 100. You
+ can increase this number to make the ellipse smoother, but it will
+ increase the file size. It is recommended to keep it below 1000.
+ color : str, optional
+ Color of the ellipse. Default is 'ff0000ff', which is red. Kml files
+ use an 8 digit HEX color format, see its docs.
Returns
-------
None
- """
+ Notes
+ -----
+ - For further understanding on .kml files, see the official documentation:\
+ https://developers.google.com/kml/documentation/kmlreference
+ - You can set a pair of origin coordinates different from the launch site\
+ to visualize the dispersion as if the rocket was launched from that\
+ point. This is useful to visualize the dispersion ellipses in a\
+ different location. However, this approach is not accurate for\
+ large distances offsets, as the atmospheric conditions may change.
+ """
+ # TODO: The lat and lon should be optional arguments, we can get it from the env
(
impact_ellipses,
apogee_ellipses,
@@ -622,19 +824,18 @@ def export_ellipses_to_kml(
apogee_ellipses, origin_lat, origin_lon, resolution=resolution
)
- # Prepare data to KML file
+ # TODO: Non-iterable value output is used in an iterating context PylintE1133:
kml_data = [[(coord[1], coord[0]) for coord in output] for output in outputs]
- # Export to KML
kml = simplekml.Kml()
for i in range(len(outputs)):
if (type == "all" and i < 3) or (type == "impact"):
- ellipse_name = "Impact σ" + str(i + 1)
+ ellipse_name = "Impact \u03C3" + str(i + 1)
elif type == "all" and i >= 3:
- ellipse_name = "Apogee σ" + str(i - 2)
+ ellipse_name = "Apogee \u03C3" + str(i - 2)
else:
- ellipse_name = "Apogee σ" + str(i + 1)
+ ellipse_name = "Apogee \u03C3" + str(i + 1)
mult_ell = kml.newmultigeometry(name=ellipse_name)
mult_ell.newpolygon(
@@ -653,12 +854,18 @@ def export_ellipses_to_kml(
kml.save(filename)
def info(self):
- """Print information about the monte carlo simulation."""
+ """
+ Print information about the Monte Carlo simulation.
+
+ Returns
+ -------
+ None
+ """
self.prints.all()
def all_info(self):
- """Print and plot information about the monte carlo simulation
- and its results.
+ """
+ Print and plot information about the Monte Carlo simulation and its results.
Returns
-------
diff --git a/rocketpy/stochastic/__init__.py b/rocketpy/stochastic/__init__.py
index 74364e8ef..692eca85f 100644
--- a/rocketpy/stochastic/__init__.py
+++ b/rocketpy/stochastic/__init__.py
@@ -1,6 +1,9 @@
-"""The rocketpy.stochastic module contains classes that are used to generate
+"""
+The rocketpy.stochastic module contains classes that are used to generate
randomized objects based on the provided information. Each of the classes
-defined here represent one different rocketpy class."""
+defined here represent one different rocketpy class plus the uncertainties
+associated with each input parameter.
+"""
from .stochastic_aero_surfaces import (
StochasticEllipticalFins,
diff --git a/rocketpy/stochastic/stochastic_aero_surfaces.py b/rocketpy/stochastic/stochastic_aero_surfaces.py
index 5d933204a..31c1e9efc 100644
--- a/rocketpy/stochastic/stochastic_aero_surfaces.py
+++ b/rocketpy/stochastic/stochastic_aero_surfaces.py
@@ -1,5 +1,7 @@
-"""Defines the StochasticNoseCone, StochasticTrapezoidalFins,
-StochasticEllipticalFins, StochasticTail and StochasticRailButtons classes."""
+"""
+Defines the StochasticNoseCone, StochasticTrapezoidalFins,
+StochasticEllipticalFins, StochasticTail and StochasticRailButtons classes.
+"""
from rocketpy.rocket.aero_surface import (
EllipticalFins,
@@ -13,43 +15,41 @@
class StochasticNoseCone(StochasticModel):
- """A Stochastic Nose Cone class that inherits from StochasticModel. This
- class is used to receive a NoseCone object and information about the
- dispersion of its parameters and generate a random nose cone object based
- on the provided information.
+ """The ``StochasticNoseCone`` class inherits from the StochasticModel. This
+ class is used to store a ``NoseCone`` object along with the uncertainty
+ of its parameters.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and
+ :class:`NoseCone `
Attributes
----------
object : NoseCone
- NoseCone object to be used for validation.
+ NoseCone object to be used as a base for the Stochastic nose cone.
length : tuple, list, int, float
- Length of the nose cone in meters. Follows the standard input format of
- Stochastic Models.
- kind : list
- List of strings representing the kind of nose cone. Follows the standard
- input format of Stochastic Models.
+ Length of the nose cone in meters.
+ kind : list[str]
+ List with a string representing the kind of nose cone.
base_radius : tuple, list, int, float
- Base radius of the nose cone in meters. Follows the standard input
- format of Stochastic Models.
+ Nose cone base radius in meters.
bluffness : tuple, list, int, float
- Bluffness of the nose cone. Follows the standard input format of
- Stochastic Models.
+ Bluffness of the nose cone.
rocket_radius : tuple, list, int, float
- Rocket radius of the nose cone in meters. Follows the standard input
- format of Stochastic Models.
- name : list
- List of names. This attribute can not be randomized.
+ The reference rocket radius used for lift coefficient normalization, in
+ meters.
+ name : list[str]
+ List with the name of the NoseCone. This attribute can not be randomized.
"""
+ # TODO: Never vary the kind of the nose cone. Fixed parameter.
+
def __init__(
self,
nosecone,
length=None,
- kind=None,
+ kind=None, # TODO: Never vary the kind of the nose cone. Fixed parameter.
base_radius=None,
bluffness=None,
rocket_radius=None,
@@ -58,27 +58,22 @@ def __init__(
See Also
--------
- :ref:`stochastic_model`
+ See the :ref:`stochastic_model` and :ref:`nose_cone_class` for further
+ information.
Parameters
----------
nosecone : NoseCone
- NoseCone object to be used for validation.
+ NoseCone object to be used as a base for the Stochastic nose cone.
length : tuple, list, int, float
- Length of the nose cone in meters. Follows the standard input format
- of Stochastic Models.
- kind : list
- List of strings representing the kind of nose cone. Follows the
- standard input format of Stochastic Models.
+ Length of the nose cone in meters.
base_radius : tuple, list, int, float
- Base radius of the nose cone in meters. Follows the standard input
- format of Stochastic Models.
+ Nose cone base radius in meters.
bluffness : tuple, list, int, float
- Bluffness of the nose cone. Follows the standard input format of
- Stochastic Models.
+ Bluffness of the nose cone.
rocket_radius : tuple, list, int, float
- Rocket radius of the nose cone in meters. Follows the standard input
- format of Stochastic Models.
+ The reference rocket radius used for lift coefficient normalization,
+ in meters.
"""
self._validate_kind(kind)
super().__init__(
@@ -95,6 +90,7 @@ def _validate_kind(self, kind):
"""Validates the kind input. If the kind input argument is not None, it
must be a list of strings."""
if kind is not None:
+ # TODO: Never vary the kind of the nose cone. It is a fixed parameter.
assert isinstance(kind, list) and all(
isinstance(member, str) for member in kind
), "`kind` must be a list of strings"
@@ -114,52 +110,43 @@ def create_object(self):
class StochasticTrapezoidalFins(StochasticModel):
"""A Stochastic Trapezoidal Fins class that inherits from StochasticModel.
- This class is used to receive a TrapezoidalFins object and information about
- the dispersion of its parameters and generate a random trapezoidal fins
- object based on the provided information.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and
+ :class:`TrapezoidalFins `
Attributes
----------
object : TrapezoidalFins
TrapezoidalFins object to be used for validation.
- n : list of ints
- List of integers representing the number of fins. Follows the standard
- input format of Stochastic Models.
+ n : list[int]
+ List with an integer representing the number of fins. This attribute
+ can be randomized.
root_chord : tuple, list, int, float
- Root chord of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Root chord of the fins in meters.
tip_chord : tuple, list, int, float
- Tip chord of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Tip chord of the fins in meters.
span : tuple, list, int, float
- Span of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Span of the fins in meters.
rocket_radius : tuple, list, int, float
- Rocket radius of the fins in meters. Follows the standard input format
- of Stochastic Models.
+ Rocket radius of the fins in meters.
cant_angle : tuple, list, int, float
- Cant angle of the fins in degrees. Follows the standard input format of
- Stochastic Models.
+ Cant angle of the fins in degrees.
sweep_length : tuple, list, int, float
- Sweep length of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Sweep length of the fins in meters.
sweep_angle : tuple, list, int, float
- Sweep angle of the fins in degrees. Follows the standard input format of
- Stochastic Models.
+ Sweep angle of the fins in degrees.
airfoil : list
List of tuples in the form of (airfoil file path, airfoil name).
- name : list
- List of names. This attribute can not be randomized.
+ name : list[str]
+ List with the object name. This attribute can not be randomized.
"""
def __init__(
self,
trapezoidal_fins,
- n=None,
+ n=None, # TODO: Never vary the number of fins. It is a fixed parameter.
root_chord=None,
tip_chord=None,
span=None,
@@ -179,33 +166,24 @@ def __init__(
----------
trapezoidal_fins : TrapezoidalFins
TrapezoidalFins object to be used for validation.
- n : list of ints
- List of integers representing the number of fins. Follows the
- standard input format of Stochastic Models.
root_chord : tuple, list, int, float
- Root chord of the fins in meters. Follows the standard input format
- of Stochastic Models.
+ Root chord of the fins in meters.
tip_chord : tuple, list, int, float
- Tip chord of the fins in meters. Follows the standard input format
- of Stochastic Models.
+ Tip chord of the fins in meters.
span : tuple, list, int, float
- Span of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Span of the fins in meters.
rocket_radius : tuple, list, int, float
- Rocket radius of the fins in meters. Follows the standard input
- format of Stochastic Models.
+ Rocket radius of the fins in meters.
cant_angle : tuple, list, int, float
- Cant angle of the fins in degrees. Follows the standard input format
- of Stochastic Models.
+ Cant angle of the fins in degrees.
sweep_length : tuple, list, int, float
- Sweep length of the fins in meters. Follows the standard input
- format of Stochastic Models.
+ Sweep length of the fins in meters.
sweep_angle : tuple, list, int, float
- Sweep angle of the fins in degrees. Follows the standard input
- format of Stochastic Models.
- airfoil : list
+ Sweep angle of the fins in degrees.
+ airfoil : list[tuple]
List of tuples in the form of (airfoil file path, airfoil name).
"""
+ # TODO: never vary the number of fins. It is a fixed parameter.
self._validate_positive_int_list("n", n)
self._validate_airfoil(airfoil)
super().__init__(
@@ -237,37 +215,31 @@ def create_object(self):
class StochasticEllipticalFins(StochasticModel):
"""A Stochastic Elliptical Fins class that inherits from StochasticModel.
- This class is used to receive a EllipticalFins object and information about
- the dispersion of its parameters and generate a random elliptical fins
- object based on the provided information.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and
+ :class:`EllipticalFins `
Attributes
----------
object : EllipticalFins
EllipticalFins object to be used for validation.
- n : list of ints
- List of integers representing the number of fins. Follows the standard
- input format of Stochastic Models.
+ n : list[int]
+ List with an integer representing the number of fins. This attribute
+ can be randomized.
root_chord : tuple, list, int, float
- Root chord of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Root chord of the fins in meters.
span : tuple, list, int, float
- Span of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Span of the fins in meters.
rocket_radius : tuple, list, int, float
- Rocket radius of the fins in meters. Follows the standard input format
- of Stochastic Models.
+ Rocket radius of the fins in meters.
cant_angle : tuple, list, int, float
- Cant angle of the fins in degrees. Follows the standard input format of
- Stochastic Models.
+ Cant angle of the fins in degrees.
airfoil : list
List of tuples in the form of (airfoil file path, airfoil name).
- name : list
- List of names. This attribute can not be randomized.
+ name : list[str]
+ List with the fins object name. This attribute can not be randomized.
"""
def __init__(
@@ -290,24 +262,18 @@ def __init__(
----------
elliptical_fins : EllipticalFins
EllipticalFins object to be used for validation.
- n : list of ints
- List of integers representing the number of fins. Follows the
- standard input format of Stochastic Models.
root_chord : tuple, list, int, float
- Root chord of the fins in meters. Follows the standard input format
- of Stochastic Models.
+ Root chord of the fins in meters.
span : tuple, list, int, float
- Span of the fins in meters. Follows the standard input format of
- Stochastic Models.
+ Span of the fins in meters.
rocket_radius : tuple, list, int, float
- Rocket radius of the fins in meters. Follows the standard input
- format of Stochastic Models.
+ Rocket radius of the fins in meters.
cant_angle : tuple, list, int, float
- Cant angle of the fins in degrees. Follows the standard input format
- of Stochastic Models.
- airfoil : list
+ Cant angle of the fins in degrees.
+ airfoil : list[tuple]
List of tuples in the form of (airfoil file path, airfoil name).
"""
+ # TODO: never vary the number of fins. It is a fixed parameter.
self._validate_positive_int_list("n", n)
self._validate_airfoil(airfoil)
super().__init__(
@@ -335,33 +301,26 @@ def create_object(self):
class StochasticTail(StochasticModel):
- """A Stochastic Tail class that inherits from StochasticModel. This class
- is used to receive a Tail object and information about the dispersion of its
- parameters and generate a random tail object based on the provided
- information.
+ """A Stochastic Tail class that inherits from StochasticModel.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`Tail `
Attributes
----------
object : Tail
Tail object to be used for validation.
top_radius : tuple, list, int, float
- Top radius of the tail in meters. Follows the standard input format of
- Stochastic Models.
+ Top radius of the tail in meters.
bottom_radius : tuple, list, int, float
- Bottom radius of the tail in meters. Follows the standard input format
- of Stochastic Models.
+ Bottom radius of the tail in meters.
length : tuple, list, int, float
- Length of the tail in meters. Follows the standard input format of
- Stochastic Models.
+ Length of the tail in meters.
rocket_radius : tuple, list, int, float
- Rocket radius of the tail in meters. Follows the standard input format
- of Stochastic Models.
- name : list
- List of names. This attribute can not be randomized.
+ Rocket radius of the tail in meters.
+ name : list[str]
+ List with the name of the tail object. This cannot be randomized.
"""
def __init__(
@@ -376,24 +335,20 @@ def __init__(
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`Tail `
Parameters
----------
tail : Tail
Tail object to be used for validation.
top_radius : tuple, list, int, float
- Top radius of the tail in meters. Follows the standard input format
- of Stochastic Models.
+ Top radius of the tail in meters.
bottom_radius : tuple, list, int, float
- Bottom radius of the tail in meters. Follows the standard input
- format of Stochastic Models.
+ Bottom radius of the tail in meters.
length : tuple, list, int, float
- Length of the tail in meters. Follows the standard input format of
- Stochastic Models.
+ Length of the tail in meters.
rocket_radius : tuple, list, int, float
- Rocket radius of the tail in meters. Follows the standard input
- format of Stochastic Models.
+ Rocket radius of the tail in meters.
"""
super().__init__(
tail,
@@ -410,7 +365,7 @@ def create_object(self):
Returns
-------
- tail : Tail
+ Tail
Tail object with the randomly generated input arguments.
"""
generated_dict = next(self.dict_generator())
@@ -418,30 +373,24 @@ def create_object(self):
class StochasticRailButtons(StochasticModel):
- """A Stochastic RailButtons class that inherits from StochasticModel. This
- class is used to receive a RailButtons object and information about the
- dispersion of its parameters and generate a random rail buttons object based
- on the provided information.
+ """A Stochastic RailButtons class that inherits from StochasticModel.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`RailButtons `
Attributes
----------
object : RailButtons
RailButtons object to be used for validation.
rail_buttons : list
- List of RailButton objects. Follows the standard input format of
- Stochastic Models.
+ List of RailButton objects.
buttons_distance : tuple, list, int, float
- Distance between the buttons in meters. Follows the standard input
- format of Stochastic Models.
+ Distance between the buttons in meters.
angular_position : tuple, list, int, float
- Angular position of the buttons in degrees. Follows the standard input
- format of Stochastic Models.
- name : list
- List of names. This attribute can not be randomized.
+ Angular position of the buttons in degrees.
+ name : list[str]
+ List with the name of the object. This attribute can not be randomized.
"""
def __init__(
@@ -461,11 +410,9 @@ def __init__(
rail_buttons : RailButtons
RailButtons object to be used for validation.
buttons_distance : tuple, list, int, float
- Distance between the buttons in meters. Follows the standard input
- format of Stochastic Models.
+ Distance between the buttons in meters.
angular_position : tuple, list, int, float
- Angular position of the buttons in degrees. Follows the standard
- input format of Stochastic Models.
+ Angular position of the buttons in degrees.
"""
super().__init__(
rail_buttons,
diff --git a/rocketpy/stochastic/stochastic_environment.py b/rocketpy/stochastic/stochastic_environment.py
index 27c55aab5..e36c19cf4 100644
--- a/rocketpy/stochastic/stochastic_environment.py
+++ b/rocketpy/stochastic/stochastic_environment.py
@@ -5,43 +5,40 @@
class StochasticEnvironment(StochasticModel):
"""A Stochastic Environment class that inherits from StochasticModel. This
- class is used to receive a Environment object and information about the
- dispersion of its parameters and generate a random environment object based
- on the provided information.
+ class is used to store an Environment object and the uncertainty of their
+ parameters.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`Environment `
Attributes
----------
object : Environment
- Environment object to be used for validation.
+ Environment object to be used as a base for the stochastic model.
elevation : tuple, list, int, float
- Elevation of the launch site in meters. Follows the standard input
- format of Stochastic Models.
+ Elevation of the launch site in meters.
gravity : tuple, list, int, float
- Gravitational acceleration in meters per second squared. Follows the
- standard input format of Stochastic Models.
+ Gravitational acceleration in meters per second squared.
latitude : tuple, list, int, float
- Latitude of the launch site in degrees. Follows the standard input
- format of Stochastic Models.
+ Latitude of the launch site in degrees.
longitude : tuple, list, int, float
- Longitude of the launch site in degrees. Follows the standard input
- format of Stochastic Models.
- ensemble_member : list
- List of integers representing the ensemble member to be selected.
- wind_velocity_x_factor : tuple, list, int, float
- Factor to be multiplied by the wind velocity in the x direction.
- wind_velocity_y_factor : tuple, list, int, float
- Factor to be multiplied by the wind velocity in the y direction.
- date : list
+ Longitude of the launch site in degrees.
+ ensemble_member : list[int]
+ List of integers representing the ensemble members to be selected.
+ date : list[tuple]
List of dates, which are tuples of four elements
(year, month, day, hour). This attribute can not be randomized.
- datum : list
+ datum : list[str]
List of datum. This attribute can not be randomized.
- timezone : list
- List of timezones. This attribute can not be randomized.
+ timezone : list[pytz.timezone]
+ List with the timezone. This attribute can not be randomized.
+ wind_velocity_x_factor : tuple, list, int, float
+ Factor to multiply the wind velocity in the x direction. This should
+ be used only when the wind velocity is defined as a constant value.
+ wind_velocity_y_factor : tuple, list, int, float
+ Factor to multiply the wind velocity in the y direction. This should
+ be used only when the wind velocity is defined as a constant value.
"""
def __init__(
@@ -69,27 +66,23 @@ def __init__(
List of dates, which are tuples of four elements
(year, month, day, hour).
elevation : int, float, tuple, list, optional
- Elevation of the launch site in meters. Follows the standard
- input format of Stochastic Models.
+ Elevation of the launch site in meters.
gravity : int, float, tuple, list, optional
- Gravitational acceleration in meters per second squared. Follows
- the standard input format of Stochastic Models.
+ Gravitational acceleration in meters per second squared.
latitude : int, float, tuple, list, optional
- Latitude of the launch site in degrees. Follows the standard
- input format of Stochastic Models.
+ Latitude of the launch site in degrees.
longitude : int, float, tuple, list, optional
- Longitude of the launch site in degrees. Follows the standard
- input format of Stochastic Models.
+ Longitude of the launch site in degrees.
ensemble_member : list, optional
List of integers representing the ensemble member to be selected.
- wind_velocity_x_factor : int, float, tuple, list, optional
- Factor to be multiplied by the wind velocity in the x direction.
- Follows the factor input format of Stochastic Models.
- wind_velocity_y_factor : int, float, tuple, list, optional
- Factor to be multiplied by the wind velocity in the y direction.
- Follows the factor input format of Stochastic Models.
+ wind_velocity_x_factor : tuple, list, int, float, optional
+ Factor to multiply the wind velocity in the x direction. This should
+ be used only when the wind velocity is defined as a constant value.
+ wind_velocity_y_factor : tuple, list, int, float, optional
+ Factor to multiply the wind velocity in the y direction. This should
+ be used only when the wind velocity is defined as a constant value.
"""
- # Validate in StochasticModel
+
super().__init__(
environment,
date=None,
@@ -105,28 +98,6 @@ def __init__(
)
self._validate_ensemble(ensemble_member, environment)
- def __str__(self):
- # special str for environment because of datetime
- s = ""
- for key, value in self.__dict__.items():
- if key.startswith("_"):
- continue # Skip attributes starting with underscore
- if isinstance(value, tuple):
- try:
- # Format the tuple as a string with the mean and standard deviation.
- value_str = (
- f"{value[0]:.5f} ± {value[1]:.5f} "
- f"(numpy.random.{value[2].__name__})"
- )
- except AttributeError:
- # treats date attribute
- value_str = str(value)
- else:
- # Otherwise, just use the default string representation of the value.
- value_str = str(value)
- s += f"{key}: {value_str}\n"
- return s.strip()
-
def _validate_ensemble(self, ensemble_member, environment):
"""Validates the ensemble member input argument. If the environment
does not have ensemble members, the ensemble member input argument
@@ -138,7 +109,7 @@ def _validate_ensemble(self, ensemble_member, environment):
Parameters
----------
ensemble_member : list
- List of integers representing the ensemble member to be selected.
+ List of integers representing the ensemble members to be selected.
environment : Environment
Environment object to be used for validation.
@@ -182,8 +153,8 @@ def _validate_ensemble(self, ensemble_member, environment):
setattr(self, "ensemble_member", environment.ensemble_member)
def create_object(self):
- """Creates a Environment object from the randomly generated input
- arguments.The environment object is not recreated to avoid having to
+ """Creates an Environment object from the randomly generated input
+ arguments. The environment object is not recreated to avoid having to
reestablish the atmospheric model. Instead, attributes are changed
directly.
@@ -193,8 +164,14 @@ def create_object(self):
Returns
-------
- obj : Environment
+ Environment
Environment object with the randomly generated input arguments.
+
+ Notes
+ -----
+ This method is overwriting the create_object method from the
+ `StochasticModel` class to handle the special case of the ensemble
+ member attribute.
"""
generated_dict = next(self.dict_generator())
for key, value in generated_dict.items():
diff --git a/rocketpy/stochastic/stochastic_flight.py b/rocketpy/stochastic/stochastic_flight.py
index 78ed65774..df1c31d45 100644
--- a/rocketpy/stochastic/stochastic_flight.py
+++ b/rocketpy/stochastic/stochastic_flight.py
@@ -6,33 +6,27 @@
class StochasticFlight(StochasticModel):
- """A Stochastic Flight class that inherits from StochasticModel. This
- class is used to receive a Flight object and information about the
- dispersion of its parameters and generate a random flight object based on
- the provided information.
+ """A Stochastic Flight class that inherits from StochasticModel.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`Flight `
Attributes
----------
flight : Flight
The Flight object to be used as a base for the Stochastic flight.
- rail_length : int, float, tuple, list, optional
- The rail length of the flight. Follows the standard input format of
- Stochastic Models.
- inclination : int, float, tuple, list, optional
- The inclination of the flight. Follows the standard input format of
- Stochastic Models.
- heading : int, float, tuple, list, optional
- The heading of the flight. Follows the standard input format of
- Stochastic Models.
- initial_solution : tuple, list, optional
+ rail_length : int, float, tuple, list
+ The rail length of the flight.
+ inclination : int, float, tuple, list
+ The inclination of the launch rail.
+ heading : int, float, tuple, list
+ The heading of the launch rail.
+ initial_solution : tuple, list
The initial solution of the flight. This is a tuple of 14 elements that
represent the initial conditions of the flight. This attribute can not
be randomized.
- terminate_on_apogee : bool, optional
+ terminate_on_apogee : bool
Whether or not the flight should terminate on apogee. This attribute
can not be randomized.
"""
@@ -50,21 +44,18 @@ def __init__(
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`Flight `
Parameters
----------
flight : Flight
The Flight object to be used as a base for the Stochastic flight.
rail_length : int, float, tuple, list, optional
- The rail length of the flight. Follows the standard input format of
- Stochastic Models.
+ The rail length of the flight.
inclination : int, float, tuple, list, optional
- The inclination of the flight. Follows the standard input format of
- Stochastic Models.
+ The inclination of the launch rail.
heading : int, float, tuple, list, optional
- The heading of the flight. Follows the standard input format of
- Stochastic Models.
+ The heading of the launch rail.
initial_solution : tuple, list, optional
The initial solution of the flight. This is a tuple of 14 elements
that represent the initial conditions of the flight. This attribute
@@ -102,25 +93,19 @@ def _validate_initial_solution(self, initial_solution):
else:
raise TypeError("`initial_solution` must be a tuple of numbers")
- # TODO: these call dict_generator a lot of times unnecessarily
+ # TODO: these methods call dict_generator a lot of times unnecessarily
def _randomize_rail_length(self):
- """Randomizes the rail length of the flight. Follows the standard input
- format of Stochastic Models.
- """
+ """Randomizes the rail length of the flight."""
generated_dict = next(self.dict_generator())
return generated_dict["rail_length"]
def _randomize_inclination(self):
- """Randomizes the inclination of the flight. Follows the standard input
- format of Stochastic Models.
- """
+ """Randomizes the inclination of the flight."""
generated_dict = next(self.dict_generator())
return generated_dict["inclination"]
def _randomize_heading(self):
- """Randomizes the heading of the flight. Follows the standard input
- format of Stochastic Models.
- """
+ """Randomizes the heading of the flight."""
generated_dict = next(self.dict_generator())
return generated_dict["heading"]
diff --git a/rocketpy/stochastic/stochastic_generic_motor.py b/rocketpy/stochastic/stochastic_generic_motor.py
index e4220e68a..bf8b79aa1 100644
--- a/rocketpy/stochastic/stochastic_generic_motor.py
+++ b/rocketpy/stochastic/stochastic_generic_motor.py
@@ -7,71 +7,53 @@
class StochasticGenericMotor(StochasticMotorModel):
"""A Stochastic Generic Motor class that inherits from StochasticModel.
- This class is used to receive a GenericMotor object and information about
- the dispersion of its parameters and generate a random generic motor object
- based on the provided information.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and
+ :class:`GenericMotor `
Attributes
----------
object : GenericMotor
- GenericMotor object to be used for validation.
+ GenericMotor object to be used as a base for the stochastic model.
thrust_source : list
List of strings representing the thrust source to be selected.
total_impulse : int, float, tuple, list
- Total impulse of the motor in newton seconds. Follows the standard
- input format of Stochastic Models.
+ Total impulse of the motor in newton seconds.
burn_start_time : int, float, tuple, list
- Burn start time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn start time of the motor in seconds.
burn_out_time : int, float, tuple, list
- Burn out time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn out time of the motor in seconds.
dry_mass : int, float, tuple, list
- Dry mass of the motor in kilograms. Follows the standard input
- format of Stochastic Models.
+ Dry mass of the motor in kilograms.
dry_I_11 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows the
- standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_22 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows the
- standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_33 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows the
- standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_12 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows the
- standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_13 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows the
- standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_23 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows the
- standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
chamber_radius : int, float, tuple, list
- Chamber radius of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Chamber radius of the motor in meters.
chamber_height : int, float, tuple, list
- Chamber height of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Chamber height of the motor in meters.
chamber_position : int, float, tuple, list
- Chamber position of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Chamber position of the motor in meters.
nozzle_radius : int, float, tuple, list
- Nozzle radius of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Nozzle radius of the motor in meters.
nozzle_position : int, float, tuple, list
- Nozzle position of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Nozzle position of the motor in meters.
center_of_dry_mass_position : int, float, tuple, list
- Center of dry mass position of the motor in meters. Follows the
- standard input format of Stochastic Models.
- interpolation_method : str, optional
+ Center of dry mass position of the motor in meters.
+ interpolation_method : str
Interpolation method to be used. This attribute can not be randomized.
- coordinate_system_orientation : str, optional
+ coordinate_system_orientation : str
Coordinate system orientation to be used. This attribute can not be
randomized.
"""
@@ -102,7 +84,8 @@ def __init__(
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and
+ :class:`GenericMotor `
Parameters
----------
@@ -110,55 +93,38 @@ def __init__(
GenericMotor object to be used for validation.
thrust_source : list, optional
List of strings representing the thrust source to be selected.
- Follows the 1d array like input format of Stochastic Models.
total_impulse : int, float, tuple, list, optional
- Total impulse of the motor in newton seconds. Follows the standard
- input format of Stochastic Models.
+ Total impulse of the motor in newton seconds.
burn_start_time : int, float, tuple, list, optional
- Burn start time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn start time of the motor in seconds.
burn_out_time : int, float, tuple, list, optional
- Burn out time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn out time of the motor in seconds.
dry_mass : int, float, tuple, list, optional
- Dry mass of the motor in kilograms. Follows the standard input
- format of Stochastic Models.
+ Dry mass of the motor in kilograms.
dry_I_11 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_22 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_33 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_12 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_13 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_23 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
chamber_radius : int, float, tuple, list, optional
- Chamber radius of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Chamber radius of the motor in meters.
chamber_height : int, float, tuple, list, optional
- Chamber height of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Chamber height of the motor in meters.
chamber_position : int, float, tuple, list, optional
- Chamber position of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Position of the motor chamber in meters.
nozzle_radius : int, float, tuple, list, optional
- Nozzle radius of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Nozzle radius of the motor in meters.
nozzle_position : int, float, tuple, list, optional
- Nozzle position of the motor in meters. Follows the standard input
- format of Stochastic Models.
+ Nozzle position of the motor in meters.
center_of_dry_mass_position : int, float, tuple, list, optional
- Center of dry mass position of the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Center of dry mass position of the motor in meters.
"""
super().__init__(
generic_motor,
@@ -185,16 +151,16 @@ def __init__(
)
def create_object(self):
- """Creates and returns a GenericMotor object from the randomly generated
- input arguments.
+ """Creates a `GenericMotor` object from the randomly generated input
+ arguments.
Returns
-------
- generic_motor : GenericMotor
+ GenericMotor
GenericMotor object with the randomly generated input arguments.
"""
generated_dict = next(self.dict_generator())
- generic_motor = GenericMotor(
+ return GenericMotor(
thrust_source=generated_dict["thrust_source"],
burn_time=(
generated_dict["burn_start_time"],
@@ -225,4 +191,3 @@ def create_object(self):
],
interpolation_method=generated_dict["interpolate"],
)
- return generic_motor
diff --git a/rocketpy/stochastic/stochastic_model.py b/rocketpy/stochastic/stochastic_model.py
index c60d712f6..abb3472f2 100644
--- a/rocketpy/stochastic/stochastic_model.py
+++ b/rocketpy/stochastic/stochastic_model.py
@@ -1,5 +1,7 @@
-"""Defines the StochasticModel class, which will be used as a base class for all
-other Stochastic classes."""
+"""
+Defines the `StochasticModel` class, which is used as a base class for all other
+Stochastic classes.
+"""
from random import choice
@@ -10,17 +12,27 @@
from ..tools import get_distribution
# TODO: Stop using assert in production code. Use exceptions instead.
+# TODO: Each validation method should have a test case.
class StochasticModel:
- """Base class for all Stochastic classes. This class is used to validate
- the input arguments of the child classes. The input arguments are validated
- and saved as attributes of the class in the correct format. The attributes
- are then used to generate a dictionary with the randomly generated input
- arguments. The dictionary is saved as an attribute of the class.
+ """
+ Base class for all Stochastic classes. This class validates input arguments,
+ saves them as attributes, and generates a dictionary with randomly generated
+ input arguments.
+
+ See also
+ --------
+ :ref:`Working with Stochastic Models `
+
+ Notes
+ -----
+ Please notice that the methods starting with an underscore are not meant to
+ be called directly by the user. These methods may receive breaking changes
+ without notice, so use them at your own risk.
"""
- # List of arguments that are validated in child classes
+ # Arguments that are validated only in child classes
exception_list = [
"initial_solution",
"terminate_on_apogee",
@@ -29,33 +41,32 @@ class StochasticModel:
]
def __init__(self, object, **kwargs):
- """Initialize the StochasticModel class with validated input arguments.
+ """
+ Initialize the StochasticModel class with validated input arguments.
Parameters
----------
object : object
The main object of the class.
**kwargs : dict
- Dictionary with input arguments for the class. Arguments should be
- provided as keyword arguments, where the key is the argument name,
- and the value is the argument value. Valid argument types include
- tuples, lists, ints, floats, or None. The arguments will then be
- validated and saved as attributes of the class in the correct
- format. See each validation method for more information. None values
- are allowed and will be replaced by the value of the attribute in
- the main object. When saved as an attribute, the value will be saved
- as a list with one item. If in the child class constructor an
- argument of the original class is not allowed, then it has to be
- passed as None in the super().__init__ call.
+ Dictionary of input arguments for the class. Valid argument types
+ include tuples, lists, ints, floats, or None. Arguments will be
+ validated and saved as class attributes in a specific format, which
+ is described in the
+ ":ref:`Working with Stochastic Models `" page.
Raises
------
AssertionError
If the input arguments do not conform to the specified formats.
"""
+ # TODO: don't use "object" as a variable name, it's a built-in function.
+ # We can simply change to "obj". Pylint W0622
+
self.object = object
self.last_rnd_dict = {}
+ # TODO: This code block is too complex. Refactor it.
for input_name, input_value in kwargs.items():
if input_name not in self.exception_list:
if input_value is not None:
@@ -73,69 +84,30 @@ def __init__(self, object, **kwargs):
f"'{input_name}' must be a tuple, list, int, or float"
)
else:
- # if input_value is None, then the value will be taken from
- # the main object and saved as a one item list.
attr_value = [getattr(self.object, input_name)]
setattr(self, input_name, attr_value)
- def __str__(self):
- # TODO: This method with a StochasticRocket with added motor, aero surfaces,
- # and/or parachutes is a mess right now
- s = ""
- for key, value in self.__dict__.items():
- if key.startswith("_"):
- continue # Skip attributes starting with underscore
- if isinstance(value, tuple):
- # Format the tuple as a string with the mean and standard deviation.
- value_str = (
- f"{value[0]:.5f} ± {value[1]:.5f} "
- f"(numpy.random.{value[2].__name__})"
- )
- else:
- # Otherwise, just use the default string representation of the value.
- value_str = str(value)
- s += f"{key}: {value_str}\n"
- return s.strip()
-
- # TODO: elaborate a short, concise version of the __str__ method
- # def __repr__(self):
- # return f"{self.__class__.__name__}(object={self.object}, **kwargs)"
+ def __repr__(self):
+ return f"'{self.__class__.__name__}() object'"
def _validate_tuple(self, input_name, input_value, getattr=getattr):
- """Validator for tuple arguments. Checks if input is in a valid format.
- Tuples are validated as follows:
- - Must have length 2 or 3;
- - First item must be either an int or float;
- - If length is two, then the type of the second item must be either
- an int, float or str:
- - If the second item is an int or float, then it is assumed that
- the first item is the nominal value and the second item is the
- standard deviation;
- - If the second item is a string, then it is assumed that the
- first item is the standard deviation, and the second item is
- the distribution function string. In this case, the nominal
- value will be taken from the main object;
- - If length is three, then it is assumed that the first item is the
- nominal value, the second item is the standard deviation and the
- third item is the distribution function string.
-
- Tuples are always saved as a tuple with length 3, where the first item
- is the nominal value, the second item is the standard deviation and the
- third item is the numpy distribution function.
+ """
+ Validate tuple arguments.
Parameters
----------
input_name : str
Name of the input argument.
input_value : tuple
- Value of the input argument.
+ Value of the input argument. This is the tuple to be validated.
+ getattr : function
+ Function used to get the attribute value from the object.
Returns
-------
tuple
- Tuple with length 3, where the first item is the nominal value, the
- second item is the standard deviation and the third item is the
- numpy distribution function.
+ Validated tuple in the format (nominal value, standard deviation, \
+ distribution function).
Raises
------
@@ -148,7 +120,7 @@ def _validate_tuple(self, input_name, input_value, getattr=getattr):
], f"'{input_name}': tuple must have length 2 or 3"
assert isinstance(
input_value[0], (int, float)
- ), f"'{input_name}': First item of tuple must be either an int or float"
+ ), f"'{input_name}': First item of tuple must be an int or float"
if len(input_value) == 2:
return self._validate_tuple_length_two(input_name, input_value, getattr)
@@ -156,17 +128,8 @@ def _validate_tuple(self, input_name, input_value, getattr=getattr):
return self._validate_tuple_length_three(input_name, input_value, getattr)
def _validate_tuple_length_two(self, input_name, input_value, getattr=getattr):
- """Validator for tuples with length 2. Checks if input is in a valid
- format. If length is two, then the type of the second item must be
- either an int, float or str:
-
- - If the second item is an int or float, then it is assumed that the
- first item is the nominal value and the second item is the standard
- deviation;
- - If the second item is a string, then it is assumed that the first
- item is the standard deviation, and the second item is the
- distribution function string. In this case, the nominal value will
- be taken from the main object;
+ """
+ Validate tuples with length 2.
Parameters
----------
@@ -174,13 +137,14 @@ def _validate_tuple_length_two(self, input_name, input_value, getattr=getattr):
Name of the input argument.
input_value : tuple
Value of the input argument.
+ getattr : function
+ Function to get the attribute value from the object.
Returns
-------
tuple
- Tuple with length 3, where the first item is the nominal value, the
- second item is the standard deviation and the third item is the
- numpy distribution function.
+ Validated tuple in the format (nominal value, standard deviation, \
+ distribution function).
Raises
------
@@ -206,10 +170,8 @@ def _validate_tuple_length_two(self, input_name, input_value, getattr=getattr):
return (input_value[0], input_value[1], get_distribution("normal"))
def _validate_tuple_length_three(self, input_name, input_value, getattr=getattr):
- """Validator for tuples with length 3. Checks if input is in a valid
- format. If length is three, then it is assumed that the first item is
- the nominal value, the second item is the standard deviation and the
- third item is the distribution function string.
+ """
+ Validate tuples with length 3.
Parameters
----------
@@ -217,13 +179,14 @@ def _validate_tuple_length_three(self, input_name, input_value, getattr=getattr)
Name of the input argument.
input_value : tuple
Value of the input argument.
+ getattr : function
+ Function to get the attribute value from the object.
Returns
-------
tuple
- Tuple with length 3, where the first item is the nominal value, the
- second item is the standard deviation and the third item is the
- numpy distribution function.
+ Validated tuple in the format (nominal value, standard deviation, \
+ distribution function).
Raises
------
@@ -231,23 +194,19 @@ def _validate_tuple_length_three(self, input_name, input_value, getattr=getattr)
If the input is not in a valid format.
"""
assert isinstance(input_value[1], (int, float)), (
- f"'{input_name}': Second item of a tuple with length 3 must be "
- "an int or float."
+ f"'{input_name}': Second item of a tuple with length 3 must be an "
+ "int or float."
)
assert isinstance(input_value[2], str), (
- f"'{input_name}': Third item of tuple must be a "
- "string containing the name of a valid numpy.random "
- "distribution function."
+ f"'{input_name}': Third item of tuple must be a string containing the "
+ "name of a valid numpy.random distribution function."
)
dist_func = get_distribution(input_value[2])
return (input_value[0], input_value[1], dist_func)
def _validate_list(self, input_name, input_value, getattr=getattr):
- """Validator for list arguments. Checks if input is in a valid format.
- Lists are validated as follows:
- - If the list is empty, then the value will be taken from the object
- passed and returned as a list with one item.
- - Else, the list is returned as is.
+ """
+ Validate list arguments.
Parameters
----------
@@ -255,11 +214,13 @@ def _validate_list(self, input_name, input_value, getattr=getattr):
Name of the input argument.
input_value : list
Value of the input argument.
+ getattr : function
+ Function to get the attribute value from the object.
Returns
-------
list
- List with the input value.
+ Validated list.
Raises
------
@@ -267,19 +228,15 @@ def _validate_list(self, input_name, input_value, getattr=getattr):
If the input is not in a valid format.
"""
if not input_value:
- # if list is empty, then the value will be taken from the object
- # passed and saved as a list with one item.
return [getattr(self.object, input_name)]
else:
- # else, the list is saved as is.
return input_value
def _validate_scalar(self, input_name, input_value, getattr=getattr):
- """Validator for scalar arguments. Checks if input is in a valid format.
- Scalars are validated as follows:
- - The value is assumed to be the standard deviation, the nominal
- value will be taken from the object passed and the distribution
- function will be set to "normal".
+ """
+ Validate scalar arguments. If the input is a scalar, the nominal value
+ will be taken from the object passed, and the standard deviation will be
+ the scalar value. The distribution function will be set to "normal".
Parameters
----------
@@ -287,18 +244,14 @@ def _validate_scalar(self, input_name, input_value, getattr=getattr):
Name of the input argument.
input_value : float
Value of the input argument.
+ getattr : function
+ Function to get the attribute value from the object.
Returns
-------
tuple
- Tuple with length 3, where the first item is the nominal value, the
- second item is the standard deviation and the third item is the
- numpy distribution function.
-
- Raises
- ------
- AssertionError
- If the input is not in a valid format.
+ Validated tuple in the format (nominal value, standard deviation, \
+ distribution function).
"""
return (
getattr(self.object, input_name),
@@ -307,10 +260,8 @@ def _validate_scalar(self, input_name, input_value, getattr=getattr):
)
def _validate_factors(self, input_name, input_value):
- """Validator for factor arguments. Checks if input is in a valid format.
- Factors can only be tuples of two or three items, or lists. Currently,
- the supported factors are: wind_velocity_x_factor,
- wind_velocity_y_factor, power_off_drag_factor, power_on_drag_factor.
+ """
+ Validate factor arguments.
Parameters
----------
@@ -322,15 +273,13 @@ def _validate_factors(self, input_name, input_value):
Returns
-------
tuple or list
- Tuple or list in the correct format.
+ Validated tuple or list.
Raises
------
AssertionError
- If input is not a tuple, list, int, or float
+ If the input is not in a valid format.
"""
- # Save original value of attribute that factor is applied to as an
- # private attribute
attribute_name = input_name.replace("_factor", "")
setattr(self, f"_{attribute_name}", getattr(self.object, attribute_name))
@@ -342,12 +291,8 @@ def _validate_factors(self, input_name, input_value):
raise AssertionError(f"`{input_name}`: must be either a tuple or list")
def _validate_tuple_factor(self, input_name, factor_tuple):
- """Validator for tuple factors. Checks if input is in a valid format.
- Tuple factors can only have length 2 or 3. If length is two, then the
- type of the second item must be either an int, float or str. If length
- is three, then it is assumed that the first item is the nominal value,
- the second item is the standard deviation and the third item is the
- distribution function string.
+ """
+ Validate tuple factors.
Parameters
----------
@@ -359,12 +304,12 @@ def _validate_tuple_factor(self, input_name, factor_tuple):
Returns
-------
tuple
- Tuple in the correct format.
+ Validated tuple.
Raises
------
AssertionError
- If input is not in a valid format.
+ If the input is not in a valid format.
"""
assert len(factor_tuple) in [
2,
@@ -386,8 +331,8 @@ def _validate_tuple_factor(self, input_name, factor_tuple):
return (factor_tuple[0], factor_tuple[1], dist_func)
def _validate_list_factor(self, input_name, factor_list):
- """Validator for list factors. Checks if input is in a valid format.
- List factors can only be lists of ints or floats.
+ """
+ Validate list factors.
Parameters
----------
@@ -399,12 +344,12 @@ def _validate_list_factor(self, input_name, factor_list):
Returns
-------
list
- List in the correct format.
+ Validated list.
Raises
------
AssertionError
- If input is not in a valid format.
+ If the input is not in a valid format.
"""
assert all(
isinstance(item, (int, float)) for item in factor_list
@@ -412,9 +357,8 @@ def _validate_list_factor(self, input_name, factor_list):
return factor_list
def _validate_1d_array_like(self, input_name, input_value):
- """Validator for 1D array like arguments. Checks if input is in a valid
- format. 1D array like arguments can only be lists of strings, lists of
- Functions, or lists of lists with shape (n,2).
+ """
+ Validate 1D array-like arguments.
Parameters
----------
@@ -423,38 +367,30 @@ def _validate_1d_array_like(self, input_name, input_value):
input_value : list
Value of the input argument.
- Returns
- -------
- None
-
Raises
------
AssertionError
- If input is not in a valid format.
+ If the input is not in a valid format.
"""
if input_value is not None:
error_msg = (
- f"`{input_name}` must be a list of path strings, "
- + "lists with shape (n,2), or Functions."
+ f"`{input_name}` must be a list of path strings, lists "
+ "with shape (n,2), or Functions."
)
- # Inputs must always be a list
if not isinstance(input_value, list):
raise AssertionError(error_msg)
for member in input_value:
- # if item is a list, then it must have shape (n,2)
if isinstance(member, list):
- if len(np.shape(member)) != 2 and np.shape(member)[1] != 2:
+ if len(np.shape(member)) != 2 or np.shape(member)[1] != 2:
raise AssertionError(error_msg)
-
- # If item is not a string or Function, then raise error
elif not isinstance(member, (str, Function)):
raise AssertionError(error_msg)
def _validate_positive_int_list(self, input_name, input_value):
- """Validates the input argument: if it is not None, it must be a list
- of positive integers.
+ """
+ Validate lists of positive integers.
Parameters
----------
@@ -466,7 +402,7 @@ def _validate_positive_int_list(self, input_name, input_value):
Raises
------
AssertionError
- If input is not in a valid format.
+ If the input is not in a valid format.
"""
if input_value is not None:
assert isinstance(input_value, list) and all(
@@ -474,20 +410,20 @@ def _validate_positive_int_list(self, input_name, input_value):
), f"`{input_name}` must be a list of positive integers"
def _validate_airfoil(self, airfoil):
- """Validates the input argument: if it is not None, it must be a list
- of tuples with two items, where the first can be a 1D array like or
- a string, and the second item must be a string.
+ """
+ Validate airfoil input.
Parameters
----------
- airfoil : list
+ airfoil : list[tuple]
List of tuples with two items.
Raises
------
AssertionError
- If input is not in a valid format.
+ If the input is not in a valid format.
"""
+ # TODO: The _validate_airfoil should be defined in a child class.
if airfoil is not None:
assert isinstance(airfoil, list) and all(
isinstance(member, tuple) for member in airfoil
@@ -496,35 +432,33 @@ def _validate_airfoil(self, airfoil):
assert len(member) == 2, "`airfoil` tuples must have length 2"
assert isinstance(
member[1], str
- ), "`airfoil` tuples must have a string as second item"
- # if item is a list, then it must have shape (n,2)
+ ), "`airfoil` tuples must have a string as the second item"
if isinstance(member[0], list):
if len(np.shape(member[0])) != 2 and np.shape(member[0])[1] != 2:
raise AssertionError("`airfoil` tuples must have shape (n,2)")
-
- # If item is not a string or Function, then raise error
- elif not isinstance(member[0], (str, Function)):
+ elif not isinstance(member[0], str) and not callable(member[0]):
raise AssertionError(
- "`airfoil` tuples must have a string as first item"
+ "`airfoil` tuples must have a string or Function as "
+ "the first item"
)
def dict_generator(self):
- """Generator that yields a dictionary with the randomly generated input
- arguments. The dictionary is saved as an attribute of the class.
- The dictionary is generated by looping through all attributes of the
- class and generating a random value for each attribute. The random
- values are generated according to the format of each attribute. Tuples
- are generated using the distribution function specified in the tuple.
- Lists are generated using the random.choice function.
-
- Parameters
- ----------
- None
+ """
+ Generate a dictionary with randomly generated input arguments.
+ The last generated dictionary is saved as a class attribute called
+ `last_rnd_dict`.
Yields
- -------
+ ------
dict
Dictionary with the randomly generated input arguments.
+
+ Notes
+ -----
+ 1. The dictionary is generated by iterating over the class attributes and:
+ a. If the attribute is a tuple, the value is generated using the\
+ distribution function specified in the tuple.
+ b. If the attribute is a list, the value is randomly chosen from the list.
"""
generated_dict = {}
for arg, value in self.__dict__.items():
@@ -534,3 +468,69 @@ class and generating a random value for each attribute. The random
generated_dict[arg] = choice(value) if value else value
self.last_rnd_dict = generated_dict
yield generated_dict
+
+ def visualize_attributes(self):
+ """
+ This method prints a report of the attributes stored in the Stochastic
+ Model object. The report includes the variable name, the nominal value,
+ the standard deviation, and the distribution function used to generate
+ the random attributes.
+ """
+
+ def format_attribute(attr, value):
+ if isinstance(value, list):
+ return (
+ f"\t{attr.ljust(max_str_length)} {value[0]}"
+ if len(value) == 1
+ else f"\t{attr} {value}"
+ )
+ elif isinstance(value, tuple):
+ nominal_value, std_dev, dist_func = value
+ return (
+ f"\t{attr.ljust(max_str_length)} "
+ f"{nominal_value:.5f} ± "
+ f"{std_dev:.5f} ({dist_func.__name__})"
+ )
+ return None
+
+ attributes = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+ max_str_length = max(len(var) for var in attributes) + 2
+
+ report = [
+ f"Reporting the attributes of the `{self.__class__.__name__}` object:"
+ ]
+
+ # Sorting alphabetically makes the report more readable
+ items = attributes.items()
+ items = sorted(items, key=lambda x: x[0])
+
+ to_exclude = ["object", "last_rnd_dict", "exception_list", "parachutes"]
+ items = [item for item in items if item[0] not in to_exclude]
+
+ constant_attributes = [
+ attr for attr, val in items if isinstance(val, list) and len(val) == 1
+ ]
+ tuple_attributes = [attr for attr, val in items if isinstance(val, tuple)]
+ list_attributes = [
+ attr for attr, val in items if isinstance(val, list) and len(val) > 1
+ ]
+
+ if constant_attributes:
+ report.append("\nConstant Attributes:")
+ report.extend(
+ format_attribute(attr, attributes[attr]) for attr in constant_attributes
+ )
+
+ if tuple_attributes:
+ report.append("\nStochastic Attributes:")
+ report.extend(
+ format_attribute(attr, attributes[attr]) for attr in tuple_attributes
+ )
+
+ if list_attributes:
+ report.append("\nStochastic Attributes with choice of values:")
+ report.extend(
+ format_attribute(attr, attributes[attr]) for attr in list_attributes
+ )
+
+ print("\n".join(filter(None, report)))
diff --git a/rocketpy/stochastic/stochastic_motor_model.py b/rocketpy/stochastic/stochastic_motor_model.py
index cc7764a15..a99368ab3 100644
--- a/rocketpy/stochastic/stochastic_motor_model.py
+++ b/rocketpy/stochastic/stochastic_motor_model.py
@@ -5,7 +5,7 @@
class StochasticMotorModel(StochasticModel):
"""Stochastic Motor Model class that inherits from StochasticModel. This
- class is used to standardize the input of the motor stochastic model.
+ class makes a common ground for other stochastic motor classes.
See Also
--------
@@ -14,5 +14,6 @@ class is used to standardize the input of the motor stochastic model.
def __init__(self, object, **kwargs):
self._validate_1d_array_like("thrust_source", kwargs.get("thrust_source"))
+ # TODO: never vary the grain_number
self._validate_positive_int_list("grain_number", kwargs.get("grain_number"))
super().__init__(object, **kwargs)
diff --git a/rocketpy/stochastic/stochastic_parachute.py b/rocketpy/stochastic/stochastic_parachute.py
index 03dae2f28..4cf7746d7 100644
--- a/rocketpy/stochastic/stochastic_parachute.py
+++ b/rocketpy/stochastic/stochastic_parachute.py
@@ -6,37 +6,29 @@
class StochasticParachute(StochasticModel):
- """A Stochastic Parachute class that inherits from StochasticModel. This
- class is used to receive a Parachute object and information about the
- dispersion of its parameters and generate a random parachute object based
- on the provided information.
+ """A Stochastic Parachute class that inherits from StochasticModel.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`Parachute `
Attributes
----------
object : Parachute
Parachute object to be used for validation.
cd_s : tuple, list, int, float
- Drag coefficient of the parachute. Follows the standard input format of
- Stochastic Models.
+ Drag coefficient of the parachute.
trigger : list
- List of callables, string "apogee" or ints/floats. Follows the standard
- input format of Stochastic Models.
+ List of callables, string "apogee" or ints/floats.
sampling_rate : tuple, list, int, float
- Sampling rate of the parachute in seconds. Follows the standard input
- format of Stochastic Models.
+ Sampling rate of the parachute in seconds.
lag : tuple, list, int, float
- Lag of the parachute in seconds. Follows the standard input format of
- Stochastic Models.
- noise : list
+ Lag of the parachute in seconds.
+ noise : list[tuple]
List of tuples in the form of (mean, standard deviation,
- time-correlation). Follows the standard input format of Stochastic
- Models.
- name : list
- List of names. This attribute can not be randomized.
+ time-correlation).
+ name : list[str]
+ List with the name of the parachute object. This cannot be randomized.
"""
def __init__(
@@ -59,21 +51,18 @@ def __init__(
parachute : Parachute
Parachute object to be used for validation.
cd_s : tuple, list, int, float
- Drag coefficient of the parachute. Follows the standard input
- format of Stochastic Models.
+ Drag coefficient of the parachute.
trigger : list
- List of callables, string "apogee" or ints/floats. Follows the
- standard input format of Stochastic Models.
+ List of callables, string "apogee" or ints/floats.
sampling_rate : tuple, list, int, float
- Sampling rate of the parachute in seconds. Follows the standard
- input format of Stochastic Models.
+ Sampling rate of the parachute in seconds.
lag : tuple, list, int, float
- Lag of the parachute in seconds. Follows the standard input format
- of Stochastic Models.
+ Lag of the parachute in seconds. Pay special attention to ensure
+ the lag will not assume negative values based on its mean and
+ standard deviation.
noise : list
List of tuples in the form of (mean, standard deviation,
- time-correlation). Follows the standard input format of Stochastic
- Models.
+ time-correlation).
"""
self.parachute = parachute
self.cd_s = cd_s
@@ -94,17 +83,6 @@ def __init__(
name=None,
)
- def __repr__(self):
- return (
- f"StochasticParachute("
- f"parachute={self.object}, "
- f"cd_s={self.cd_s}, "
- f"trigger={self.trigger}, "
- f"sampling_rate={self.sampling_rate}, "
- f"lag={self.lag}, "
- f"noise={self.noise})"
- )
-
def _validate_trigger(self, trigger):
"""Validates the trigger input. If the trigger input argument is not
None, it must be:
diff --git a/rocketpy/stochastic/stochastic_rocket.py b/rocketpy/stochastic/stochastic_rocket.py
index f629280d7..19975a6db 100644
--- a/rocketpy/stochastic/stochastic_rocket.py
+++ b/rocketpy/stochastic/stochastic_rocket.py
@@ -29,16 +29,15 @@
from .stochastic_parachute import StochasticParachute
from .stochastic_solid_motor import StochasticSolidMotor
+# TODO: Private methods of this class should be double underscored
+
class StochasticRocket(StochasticModel):
- """A Stochastic Rocket class that inherits from StochasticModel. This
- class is used to receive a Rocket object and information about the
- dispersion of its parameters and generate a random rocket object based on
- the provided information.
+ """A Stochastic Rocket class that inherits from StochasticModel.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`Rocket `
Attributes
----------
@@ -55,45 +54,32 @@ class is used to receive a Rocket object and information about the
A list of StochasticParachute instances containing all the parachutes of
the rocket.
radius : tuple, list, int, float
- The radius of the rocket. Follows the standard input format of
- Stochastic Models.
+ The radius of the rocket.
mass : tuple, list, int, float
- The mass of the rocket. Follows the standard input format of
- Stochastic Models.
+ The mass of the rocket.
inertia_11 : tuple, list, int, float
- The inertia of the rocket around the x axis. Follows the standard input
- format of Stochastic Models.
+ The inertia of the rocket around the x axis.
inertia_22 : tuple, list, int, float
- The inertia of the rocket around the y axis. Follows the standard input
- format of Stochastic Models.
+ The inertia of the rocket around the y axis.
inertia_33 : tuple, list, int, float
- The inertia of the rocket around the z axis. Follows the standard input
- format of Stochastic Models.
+ The inertia of the rocket around the z axis.
inertia_12 : tuple, list, int, float
- The inertia of the rocket around the xy axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the xy axis.
inertia_13 : tuple, list, int, float
- The inertia of the rocket around the xz axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the xz axis.
inertia_23 : tuple, list, int, float
- The inertia of the rocket around the yz axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the yz axis.
power_off_drag : list
- The power off drag of the rocket. Follows the 1d array like input format
- of Stochastic Models.
+ The power off drag of the rocket.
power_on_drag : list
- The power on drag of the rocket. Follows the 1d array like input format
- of Stochastic Models.
+ The power on drag of the rocket.
power_off_drag_factor : tuple, list, int, float
- The power off drag factor of the rocket. Follows the factor input
- format of Stochastic Models.
+ The power off drag factor of the rocket.
power_on_drag_factor : tuple, list, int, float
- The power on drag factor of the rocket. Follows the standard input
- format of Stochastic Models.
+ The power on drag factor of the rocket.
center_of_mass_without_motor : tuple, list, int, float
- The center of mass of the rocket without the motor. Follows the
- standard input format of Stochastic Models.
- coordinate_system_orientation : list
+ The center of mass of the rocket without the motor.
+ coordinate_system_orientation : list[str]
The orientation of the coordinate system of the rocket. This attribute
can not be a randomized.
"""
@@ -126,45 +112,35 @@ def __init__(
rocket : Rocket
The Rocket object to be used as a base for the Stochastic rocket.
radius : int, float, tuple, list, optional
- The radius of the rocket. Follows the standard input format of
- Stochastic Models.
+ The radius of the rocket.
mass : int, float, tuple, list, optional
- The mass of the rocket. Follows the standard input format of
- Stochastic Models.
+ The mass of the rocket.
inertia_11 : int, float, tuple, list, optional
- The inertia of the rocket around the x axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the x axis.
inertia_22 : int, float, tuple, list, optional
- The inertia of the rocket around the y axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the y axis.
inertia_33 : int, float, tuple, list, optional
- The inertia of the rocket around the z axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the z axis.
inertia_12 : int, float, tuple, list, optional
- The inertia of the rocket around the xy axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the xy axis.
inertia_13 : int, float, tuple, list, optional
- The inertia of the rocket around the xz axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the xz axis.
inertia_23 : int, float, tuple, list, optional
- The inertia of the rocket around the yz axis. Follows the standard
- input format of Stochastic Models.
+ The inertia of the rocket around the yz axis.
power_off_drag : list, optional
- The power off drag of the rocket. Follows the 1d array like input
- format of Stochastic Models.
+ The power off drag of the rocket.
power_on_drag : list, optional
- The power on drag of the rocket. Follows the 1d array like input
- format of Stochastic Models.
+ The power on drag of the rocket.
power_off_drag_factor : int, float, tuple, list, optional
- The power off drag factor of the rocket. Follows the factor input
- format of Stochastic Models.
+ The power off drag factor of the rocket. This represents a factor
+ that multiplies the power off drag curve.
power_on_drag_factor : int, float, tuple, list, optional
- The power on drag factor of the rocket. Follows the standard input
- format of Stochastic Models.
+ The power on drag factor of the rocket. This represents a factor
+ that multiplies the power on drag curve.
center_of_mass_without_motor : int, float, tuple, list, optional
- The center of mass of the rocket without the motor. Follows the
- standard input format of Stochastic Models.
+ The center of mass of the rocket without the motor.
"""
+ # TODO: mention that these factors are validated differently
self._validate_1d_array_like("power_off_drag", power_off_drag)
self._validate_1d_array_like("power_on_drag", power_on_drag)
super().__init__(
@@ -189,45 +165,6 @@ def __init__(
self.rail_buttons = Components()
self.parachutes = []
- def __str__(self):
- # special str for rocket because of the components and parachutes
- s = ""
- for key, value in self.__dict__.items():
- if key.startswith("_"):
- continue # Skip attributes starting with underscore
- if isinstance(value, tuple):
- # Format the tuple as a string with the mean and standard deviation.
- value_str = (
- f"{value[0]:.5f} ± {value[1]:.5f} "
- f"(numpy.random.{value[2].__name__})"
- )
- s += f"{key}: {value_str}\n"
- elif isinstance(value, Components):
- # Format Components as string with the mean and std deviation
- s += f"{key}:\n"
- if len(value) == 0:
- s += "\tNone\n"
- for component in value:
- s += f"\t{component.component.__class__.__name__} "
- if isinstance(component.position, tuple):
- s += f"at position: {component.position[0]:.5f} ± "
- s += f"{component.position[1]:.5f} "
- s += f"(numpy.random.{component.position[2].__name__})\n"
- elif isinstance(component.position, list):
- s += f"at position: {component.position}\n"
- else:
- s += f"at position: {component.position:.5f}\n"
- else:
- # Otherwise, just use the default string representation of the value.
- value_str = str(value)
- if isinstance(value, list) and len(value) > 0:
- if isinstance(value[0], (StochasticParachute)):
- value_str = ""
- for parachute in value:
- value_str += f"\n\t{parachute.name[0]} "
- s += f"{key}: {value_str}\n"
- return s.strip()
-
def add_motor(self, motor, position=None):
"""Adds a stochastic motor to the stochastic rocket. If a motor is
already present, it will be replaced.
@@ -237,8 +174,7 @@ def add_motor(self, motor, position=None):
motor : StochasticMotor or Motor
The motor to be added to the stochastic rocket.
position : tuple, list, int, float, optional
- The position of the motor. Follows the standard input format of
- Stochastic Models.
+ The position of the motor.
"""
# checks if there is a motor already
if len(self.motors) > 0:
@@ -252,7 +188,6 @@ def add_motor(self, motor, position=None):
if not isinstance(motor, (Motor, StochasticMotorModel)):
raise TypeError("`motor` must be a StochasticMotor or Motor type")
if isinstance(motor, Motor):
- # create StochasticMotor
# TODO implement HybridMotor and LiquidMotor stochastic models
if isinstance(motor, SolidMotor):
motor = StochasticSolidMotor(solid_motor=motor)
@@ -269,8 +204,7 @@ def _add_surfaces(self, surfaces, positions, type, stochastic_type, error_messag
surfaces : StochasticAeroSurface or AeroSurface
The aerodynamic surface to be added to the stochastic rocket.
positions : tuple, list, int, float, optional
- The position of the aerodynamic surface. Follows the standard input
- format of Stochastic Models.
+ The position of the aerodynamic surface.
type : type
The type of the aerodynamic surface to be added to the stochastic
rocket.
@@ -284,7 +218,6 @@ def _add_surfaces(self, surfaces, positions, type, stochastic_type, error_messag
if not isinstance(surfaces, (type, stochastic_type)):
raise AssertionError(error_message)
if isinstance(surfaces, type):
- # create StochasticSurfaces
surfaces = stochastic_type(component=surfaces)
self.aerodynamic_surfaces.add(
surfaces, self._validate_position(surfaces, positions)
@@ -298,8 +231,7 @@ def add_nose(self, nose, position=None):
nose : StochasticNoseCone or NoseCone
The nose cone to be added to the stochastic rocket.
position : tuple, list, int, float, optional
- The position of the nose cone. Follows the standard input format of
- Stochastic Models.
+ The position of the nose cone.
"""
self._add_surfaces(
surfaces=nose,
@@ -317,8 +249,7 @@ def add_trapezoidal_fins(self, fins, position=None):
fins : StochasticTrapezoidalFins or TrapezoidalFins
The trapezoidal fins to be added to the stochastic rocket.
position : tuple, list, int, float, optional
- The position of the trapezoidal fins. Follows the standard input
- format of Stochastic Models.
+ The position of the trapezoidal fins.
"""
self._add_surfaces(
fins,
@@ -336,8 +267,7 @@ def add_elliptical_fins(self, fins, position=None):
fins : StochasticEllipticalFins or EllipticalFins
The elliptical fins to be added to the stochastic rocket.
position : tuple, list, int, float, optional
- The position of the elliptical fins. Follows the standard input
- format of Stochastic Models.
+ The position of the elliptical fins.
"""
self._add_surfaces(
fins,
@@ -355,8 +285,7 @@ def add_tail(self, tail, position=None):
tail : StochasticTail or Tail
The tail to be added to the stochastic rocket.
position : tuple, list, int, float, optional
- The position of the tail. Follows the standard input format of
- Stochastic Models.
+ The position of the tail.
"""
self._add_surfaces(
tail,
@@ -380,7 +309,6 @@ def add_parachute(self, parachute):
"`parachute` must be of Parachute or StochasticParachute type"
)
if isinstance(parachute, Parachute):
- # create StochasticParachute
parachute = StochasticParachute(parachute=parachute)
self.parachutes.append(parachute)
@@ -396,15 +324,13 @@ def set_rail_buttons(
rail_buttons : StochasticRailButtons or RailButtons
The rail buttons to be added to the stochastic rocket.
lower_button_position : tuple, list, int, float, optional
- The position of the lower button. Follows the standard input format
- of Stochastic Models.
+ The position of the lower button.
"""
if not isinstance(rail_buttons, (StochasticRailButtons, RailButtons)):
raise AssertionError(
"`rail_buttons` must be of RailButtons or StochasticRailButtons type"
)
if isinstance(rail_buttons, RailButtons):
- # create StochasticRailButtons
rail_buttons = StochasticRailButtons(rail_buttons=rail_buttons)
self.rail_buttons.add(
rail_buttons, self._validate_position(rail_buttons, lower_button_position)
diff --git a/rocketpy/stochastic/stochastic_solid_motor.py b/rocketpy/stochastic/stochastic_solid_motor.py
index 482973840..8550c1e11 100644
--- a/rocketpy/stochastic/stochastic_solid_motor.py
+++ b/rocketpy/stochastic/stochastic_solid_motor.py
@@ -6,14 +6,11 @@
class StochasticSolidMotor(StochasticMotorModel):
- """A Stochastic Solid Motor class that inherits from StochasticModel. This
- class is used to receive a SolidMotor object and information about the
- dispersion of its parameters and generate a random solid motor object based
- on the provided information.
+ """A Stochastic Solid Motor class that inherits from StochasticModel.
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`SolidMotor `
Attributes
----------
@@ -22,68 +19,49 @@ class is used to receive a SolidMotor object and information about the
thrust_source : list
List of strings representing the thrust source to be selected.
total_impulse : int, float, tuple, list
- Total impulse of the motor in newton seconds. Follows the standard
- input format of Stochastic Models.
+ Total impulse of the motor in newton seconds.
burn_start_time : int, float, tuple, list
- Burn start time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn start time of the motor in seconds.
burn_out_time : int, float, tuple, list
- Burn out time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn out time of the motor in seconds.
dry_mass : int, float, tuple, list
- Dry mass of the motor in kilograms. Follows the standard input
- format of Stochastic Models.
+ Dry mass of the motor in kilograms.
dry_I_11 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_22 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_33 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_12 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_13 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_23 : int, float, tuple, list
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
nozzle_radius : int, float, tuple, list
- Nozzle radius of the motor in meters. Follows the standard input
- format of Stochastic Models.
- grain_number : int, float, tuple, list
- Number of grains in the motor. Follows the standard input format of
- Stochastic Models.
+ Nozzle radius of the motor in meters.
+ grain_number : list[int]
+ Number of grains in the motor. This attribute can not be randomized.
grain_density : int, float, tuple, list
Density of the grains in the motor in kilograms per meters cubed.
- Follows the standard input format of Stochastic Models.
grain_outer_radius : int, float, tuple, list
- Outer radius of the grains in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Outer radius of the grains in the motor in meters.
grain_initial_inner_radius : int, float, tuple, list
- Initial inner radius of the grains in the motor in meters. Follows
- the standard input format of Stochastic Models.
+ Initial inner radius of the grains in the motor in meters.
grain_initial_height : int, float, tuple, list
- Initial height of the grains in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Initial height of the grains in the motor in meters.
grain_separation : int, float, tuple, list
- Separation between grains in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Separation between grains in the motor in meters.
grains_center_of_mass_position : int, float, tuple, list
Position of the center of mass of the grains in the motor in
- meters. Follows the standard input format of Stochastic Models.
+ meters.
center_of_dry_mass_position : int, float, tuple, list
Position of the center of mass of the dry mass in the motor in
- meters. Follows the standard input format of Stochastic Models.
+ meters.
nozzle_position : int, float, tuple, list
- Position of the nozzle in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Position of the nozzle in the motor in meters.
throat_radius : int, float, tuple, list
- Radius of the throat in the motor in meters. Follows the standard
- input format of Stochastic Models.
+ Radius of the throat in the motor in meters.
"""
def __init__(
@@ -101,7 +79,7 @@ def __init__(
dry_inertia_13=None,
dry_inertia_23=None,
nozzle_radius=None,
- grain_number=None,
+ grain_number=None, # TODO: can't vary the number of grains.
grain_density=None,
grain_outer_radius=None,
grain_initial_inner_radius=None,
@@ -116,7 +94,7 @@ def __init__(
See Also
--------
- :ref:`stochastic_model`
+ :ref:`stochastic_model` and :class:`SolidMotor `
Parameters
----------
@@ -124,70 +102,48 @@ def __init__(
SolidMotor object to be used for validation.
thrust_source : list, optional
List of strings representing the thrust source to be selected.
- Follows the 1d array like input format of Stochastic Models.
total_impulse : int, float, tuple, list, optional
- Total impulse of the motor in newton seconds. Follows the standard
- input format of Stochastic Models.
+ Total impulse of the motor in newton seconds.
burn_start_time : int, float, tuple, list, optional
- Burn start time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn start time of the motor in seconds.
burn_out_time : int, float, tuple, list, optional
- Burn out time of the motor in seconds. Follows the standard input
- format of Stochastic Models.
+ Burn out time of the motor in seconds.
dry_mass : int, float, tuple, list, optional
- Dry mass of the motor in kilograms. Follows the standard input
- format of Stochastic Models.
+ Dry mass of the motor in kilograms.
dry_I_11 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_22 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_33 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_12 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_13 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
dry_I_23 : int, float, tuple, list, optional
- Dry inertia of the motor in kilograms times meters squared. Follows
- the standard input format of Stochastic Models.
+ Dry inertia of the motor in kilograms times meters squared.
nozzle_radius : int, float, tuple, list, optional
- Nozzle radius of the motor in meters. Follows the standard input
- format of Stochastic Models.
- grain_number : int, float, tuple, list, optional
- Number of grains in the motor. Follows the standard input format of
- Stochastic Models.
+ Nozzle radius of the motor in meters.
grain_density : int, float, tuple, list, optional
Density of the grains in the motor in kilograms per meters cubed.
- Follows the standard input format of Stochastic Models.
grain_outer_radius : int, float, tuple, list, optional
- Outer radius of the grains in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Outer radius of the grains in the motor in meters.
grain_initial_inner_radius : int, float, tuple, list, optional
- Initial inner radius of the grains in the motor in meters. Follows
- the standard input format of Stochastic Models.
+ Initial inner radius of the grains in the motor in meters.
grain_initial_height : int, float, tuple, list, optional
- Initial height of the grains in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Initial height of the grains in the motor in meters.
grain_separation : int, float, tuple, list, optional
- Separation between grains in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Separation between grains in the motor in meters.
grains_center_of_mass_position : int, float, tuple, list, optional
Position of the center of mass of the grains in the motor in
- meters. Follows the standard input format of Stochastic Models.
+ meters.
center_of_dry_mass_position : int, float, tuple, list, optional
Position of the center of mass of the dry mass in the motor in
- meters. Follows the standard input format of Stochastic Models.
+ meters.
nozzle_position : int, float, tuple, list, optional
- Position of the nozzle in the motor in meters. Follows the
- standard input format of Stochastic Models.
+ Position of the nozzle in the motor in meters.
throat_radius : int, float, tuple, list, optional
- Radius of the throat in the motor in meters. Follows the standard
- input format of Stochastic Models.
+ Radius of the throat in the motor in meters.
"""
super().__init__(
solid_motor,
@@ -223,11 +179,11 @@ def create_object(self):
Returns
-------
- solid_motor : SolidMotor
+ SolidMotor
SolidMotor object with the randomly generated input arguments.
"""
generated_dict = next(self.dict_generator())
- solid_motor = SolidMotor(
+ return SolidMotor(
thrust_source=generated_dict["thrust_source"],
dry_mass=generated_dict["dry_mass"],
dry_inertia=(
@@ -264,4 +220,3 @@ def create_object(self):
],
interpolation_method=generated_dict["interpolate"],
)
- return solid_motor
diff --git a/tests/unit/test_stochastic_model.py b/tests/unit/test_stochastic_model.py
new file mode 100644
index 000000000..77c94fb40
--- /dev/null
+++ b/tests/unit/test_stochastic_model.py
@@ -0,0 +1,20 @@
+import pytest
+
+
+@pytest.mark.parametrize(
+ "fixture_name",
+ [
+ "stochastic_rail_buttons",
+ "stochastic_main_parachute",
+ "stochastic_environment",
+ "stochastic_tail",
+ "stochastic_calisto",
+ ],
+)
+def test_visualize_attributes(request, fixture_name):
+ """Tests the visualize_attributes method of the StochasticModel class. This
+ test verifies if the method returns None, which means that the method is
+ running without breaking.
+ """
+ fixture = request.getfixturevalue(fixture_name)
+ assert fixture.visualize_attributes() is None
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ " 
\n",
+ "