From e8d75874452992a88a722be60e35dea1c8a73dfd Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Thu, 28 Nov 2024 18:22:40 -0300 Subject: [PATCH 01/18] ENH: implementing a draft version of the Multivarite Rejectio Sampler (MRS). --- .../multivariate_rejection_sampler.py | 220 ++++++++++++++++++ 1 file changed, 220 insertions(+) create mode 100644 rocketpy/simulation/multivariate_rejection_sampler.py diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py new file mode 100644 index 000000000..160ba78cf --- /dev/null +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -0,0 +1,220 @@ +""" +Multivariate Rejection Sampling Module for RocketPy + +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 +from random import random + +from rocketpy._encoders import RocketPyEncoder + + +class MultivariateRejectionSampler: + """Class that performs Multivariate Rejection Sampling (MRS) from MonteCarlo + results. + """ + + def __init__( + self, + montecarlo_filepath, + mrs_filepath, + distribution_dict, + ): + """Initializes Multivariate Rejection Sampler (MRS) class + + Parameters + ---------- + montecarlo_filepath : str + Filepath prefixes to the files created from a MonteCarlo simulation + results. + mrs_filepath : str + Filepath prefix to MRS obtained samples. The files created follow the same + structure as those created by the MonteCarlo class. + distribution : dict + Dictionary whose keys contain the name whose distribution changed. The values + are tuples or lists with two entries. The first entry is a probability + density (mass) function for the old distribution, while the second entry + is the probability density function for the new distribution. + + Returns + ------- + None + """ + self.montecarlo_filepath = montecarlo_filepath + self.mrs_filepath = mrs_filepath + self.distribution_dict = distribution_dict + self.original_sample_size = 0 + self.sup_ratio = 1 + self.expected_sample_size = None + self.final_sample_size = None + # TODO: is there a better way to construct input/output_list? + # Iterating and appending over lists is costly. However, the + # alternative, reading the file twice to get the number of lines, + # also does not seem to be a good option. + self.output_list = [] + self.input_list = [] + self.__setup_input() + self.__load_output() + + def __setup_input(self): + """Loads, validate and compute information from monte carlo + input with a single read from the file. + + This function does three things: + 1) Load: Loads the input data from MonteCarlo into python + objects so the sampling process does not require reading from + disk; + 2) Validate: Validates that the keys in 'distribution_dict' exist in + the input json created by the monte carlo; + 3) Compute: Computes the supremum of the probability ratios, used in the + sample function. + + While these three tasks could be disentangled to get clearer + code, the implementation as done here only requires a single + read from disk. + """ + input_filename = f"{self.montecarlo_filepath}.inputs.txt" + + try: + input_file = open(input_filename, "r+", encoding="utf-8") + except FileNotFoundError as e: + raise FileNotFoundError( + f"Input file from monte carlo {input_filename} " "not found!" + ) from e + + for line in input_file.readlines(): + try: + # loads data + line_json = json.loads(line) + self.input_list.append(line_json) + self.original_sample_size += 1 + + prob_ratio = 1 + for parameter in self.distribution_dict.keys(): + # checks dictionary keys + if parameter not in line_json.keys(): + raise ValueError( + f"Parameter key {parameter} from 'distribution_dict' " + "not found in input file!" + ) + parameter_value = line_json[parameter] + + prob_ratio *= self.__compute_probability_ratio( + parameter, parameter_value + ) + # updates the supremum of the ratio + self.sup_ratio = max(self.sup_ratio, prob_ratio) + except Exception as e: + raise ValueError( + "An error occurred while reading " + f"the monte carlo input file {input_filename}!" + ) from e + + self.expected_sample_size = self.original_sample_size // self.sup_ratio + input_file.close() + + def __load_output(self): + """Load data from monte carlo outputs.""" + output_filename = f"{self.montecarlo_filepath}.outputs.txt" + sample_size_output = 0 # sanity check + + try: + output_file = open(output_filename, "r+", encoding="utf-8") + except FileNotFoundError as e: + raise FileNotFoundError( + f"Output file from monte carlo {output_filename} " "not found!" + ) from e + + for line in output_file.readlines(): + try: + line_json = json.loads(line) + self.output_list.append(line_json) + sample_size_output += 1 + except Exception as e: + raise ValueError( + "An error occurred while reading " + f"the monte carlo output file {output_filename}!" + ) from e + + if self.original_sample_size != sample_size_output: + raise ValueError( + "Monte carlo input and output files have a different " + "number of samples!" + ) + + output_file.close() + + def sample(self): + """Performs rejection sampling and saves data + + Returns + ------- + None + """ + + mrs_input_file = open(f"{self.mrs_filepath}.inputs.txt", "w+", encoding="utf-8") + mrs_output_file = open( + f"{self.mrs_filepath}.outputs.txt", "w+", encoding="utf-8" + ) + mrs_error_file = open(f"{self.mrs_filepath}.errors.txt", "w+", encoding="utf-8") + + # compute sup ratio + for line_input_json, line_output_json in zip(self.input_list, self.output_list): + acceptance_prob = 1 / self.sup_ratio # probability the sample is accepted + for parameter in self.distribution_dict.keys(): + parameter_value = line_input_json[parameter] + acceptance_prob *= self.__compute_probability_ratio( + parameter, + parameter_value, + ) + # sample is accepted, write output + if random() < acceptance_prob: + mrs_input_file.write( + json.dumps(line_input_json, cls=RocketPyEncoder) + "\n" + ) + mrs_output_file.write( + json.dumps(line_output_json, cls=RocketPyEncoder) + "\n" + ) + + mrs_input_file.close() + mrs_output_file.close() + mrs_error_file.close() + + def __compute_probability_ratio(self, parameter, parameter_value): + """Computes the ratio of the new probability to the old probability + + Parameters + ---------- + parameter : str + Name of the parameter to evaluate the probability. + parameter_value : any + Value of the parameter to be passed to the density functions. + + Returns + ------- + float + The ratio of the new probability density function (numerator) + to the old one (denominator). + + Raises + ------ + ValueError + Raises exception if an error occurs when computing the ratio. + """ + try: + old_pdf = self.distribution_dict[parameter][0] + new_pdf = self.distribution_dict[parameter][1] + probability_ratio = new_pdf(parameter_value) / old_pdf(parameter_value) + except Exception as e: + raise ValueError( + "An error occurred while evaluating the " + "ratio for 'distribution_dict' probability " + f"parameter key {parameter}!" + ) from e + + return probability_ratio From fed170b4ac802c3ad48aabb1b5bfe4b0578887c3 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Thu, 28 Nov 2024 18:23:22 -0300 Subject: [PATCH 02/18] MNT: quick notebook to test MRS during development --- test_mrs.ipynb | 176 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 test_mrs.ipynb diff --git a/test_mrs.ipynb b/test_mrs.ipynb new file mode 100644 index 000000000..09015b197 --- /dev/null +++ b/test_mrs.ipynb @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quick test notebook for MRS" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "# We import these lines for debugging purposes, only works on Jupyter Notebook\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "from rocketpy.simulation.multivariate_rejection_sampler import MultivariateRejectionSampler\n", + "from rocketpy import MonteCarlo\n", + "from scipy.stats import norm\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "montecarlo_filepath = \"docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example\"\n", + "mrs_filepath = \"mrs\"\n", + "old_mass_pdf = norm(15.426, 0.5).pdf\n", + "new_mass_pdf = norm(15, 0.5) .pdf\n", + "distribution_dict = {\n", + " \"mass\": (old_mass_pdf, new_mass_pdf),\n", + "}\n", + "mrs = MultivariateRejectionSampler(\n", + " montecarlo_filepath=montecarlo_filepath,\n", + " mrs_filepath=mrs_filepath,\n", + " distribution_dict=distribution_dict,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "107.0" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mrs.expected_sample_size" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [], + "source": [ + "mrs.sample()" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The following input file was imported: mrs.inputs.txt\n", + "A total of 109 simulations results were loaded from the following output file: mrs.outputs.txt\n", + "\n", + "The following error file was imported: mrs.errors.txt\n" + ] + } + ], + "source": [ + "mrs_results = MonteCarlo(mrs_filepath, None, None, None)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A total of 109 simulations results were loaded from the following output file: mrs.outputs.txt\n", + "\n", + "The following input file was imported: mrs.inputs.txt\n", + "The following error file was imported: mrs.errors.txt\n" + ] + } + ], + "source": [ + "mrs_results.import_results()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MRS mass mean after resample: 15.029610376989238\n", + "MRS mass std after resample: 0.5213162519453568\n" + ] + } + ], + "source": [ + "mrs_mass_list = []\n", + "for single_input_dict in mrs_results.inputs_log:\n", + " mrs_mass_list.append(single_input_dict[\"mass\"])\n", + "\n", + "print(f\"MRS mass mean after resample: {np.mean(mrs_mass_list)}\")\n", + "print(f\"MRS mass std after resample: {np.std(mrs_mass_list)}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "testnotebook", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 36ea7f1f1e25b580d9d3ab96e4634fc406d9f9f6 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Thu, 19 Dec 2024 21:56:02 -0300 Subject: [PATCH 03/18] MNT: refactoring class to match review suggestions --- .vscode/settings.json | 1 + .../notebooks/test_mrs.ipynb | 98 ++++--- .../multivariate_rejection_sampler.py | 257 ++++++++++-------- 3 files changed, 203 insertions(+), 153 deletions(-) rename test_mrs.ipynb => docs/notebooks/test_mrs.ipynb (62%) diff --git a/.vscode/settings.json b/.vscode/settings.json index 4b885192a..5c973672e 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -294,6 +294,7 @@ "statsmodels", "STFT", "subintervals", + "supremum", "suptitle", "supxlabel", "supylabel", diff --git a/test_mrs.ipynb b/docs/notebooks/test_mrs.ipynb similarity index 62% rename from test_mrs.ipynb rename to docs/notebooks/test_mrs.ipynb index 09015b197..d25e7c9a2 100644 --- a/test_mrs.ipynb +++ b/docs/notebooks/test_mrs.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -29,11 +29,13 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "from rocketpy.simulation.multivariate_rejection_sampler import MultivariateRejectionSampler\n", + "from rocketpy.simulation.multivariate_rejection_sampler import (\n", + " MultivariateRejectionSampler,\n", + ")\n", "from rocketpy import MonteCarlo\n", "from scipy.stats import norm\n", "import numpy as np" @@ -41,66 +43,47 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ - "montecarlo_filepath = \"docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example\"\n", - "mrs_filepath = \"mrs\"\n", + "monte_carlo_filepath = (\n", + " \"monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example\"\n", + ")\n", + "mrs_filepath = \"monte_carlo_analysis/monte_carlo_analysis_outputs/mrs\"\n", "old_mass_pdf = norm(15.426, 0.5).pdf\n", - "new_mass_pdf = norm(15, 0.5) .pdf\n", + "new_mass_pdf = norm(15, 0.5).pdf\n", "distribution_dict = {\n", " \"mass\": (old_mass_pdf, new_mass_pdf),\n", "}\n", "mrs = MultivariateRejectionSampler(\n", - " montecarlo_filepath=montecarlo_filepath,\n", + " monte_carlo_filepath=monte_carlo_filepath,\n", " mrs_filepath=mrs_filepath,\n", - " distribution_dict=distribution_dict,\n", ")" ] }, { "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "107.0" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mrs.expected_sample_size" - ] - }, - { - "cell_type": "code", - "execution_count": 90, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ - "mrs.sample()" + "mrs.sample(distribution_dict=distribution_dict)" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The following input file was imported: mrs.inputs.txt\n", - "A total of 109 simulations results were loaded from the following output file: mrs.outputs.txt\n", + "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt\n", + "A total of 116 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", "\n", - "The following error file was imported: mrs.errors.txt\n" + "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt\n" ] } ], @@ -110,17 +93,17 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "A total of 109 simulations results were loaded from the following output file: mrs.outputs.txt\n", + "A total of 116 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", "\n", - "The following input file was imported: mrs.inputs.txt\n", - "The following error file was imported: mrs.errors.txt\n" + "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt\n", + "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt\n" ] } ], @@ -130,15 +113,15 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MRS mass mean after resample: 15.029610376989238\n", - "MRS mass std after resample: 0.5213162519453568\n" + "MRS mass mean after resample: 15.041934326472004\n", + "MRS mass std after resample: 0.48924085702427966\n" ] } ], @@ -150,11 +133,38 @@ "print(f\"MRS mass mean after resample: {np.mean(mrs_mass_list)}\")\n", "print(f\"MRS mass std after resample: {np.std(mrs_mass_list)}\")" ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "107.0" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mrs.expected_sample_size" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "testnotebook", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -168,7 +178,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index 160ba78cf..e1e63893e 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -9,118 +9,109 @@ """ import json +from dataclasses import dataclass from random import random from rocketpy._encoders import RocketPyEncoder +@dataclass +class SampleInformation: + """Sample information used in the MRS""" + + inputs_json: dict = None + outputs_json: dict = None + probability_ratio: float = None + acceptance_probability: float = None + + class MultivariateRejectionSampler: """Class that performs Multivariate Rejection Sampling (MRS) from MonteCarlo - results. + results. The class currently assumes that all input variables are independent + when performing the + + Attributes + ---------- """ def __init__( self, - montecarlo_filepath, + monte_carlo_filepath, mrs_filepath, - distribution_dict, ): """Initializes Multivariate Rejection Sampler (MRS) class Parameters ---------- - montecarlo_filepath : str + monte_carlo_filepath : str Filepath prefixes to the files created from a MonteCarlo simulation - results. + results and used as input for resampling. mrs_filepath : str Filepath prefix to MRS obtained samples. The files created follow the same - structure as those created by the MonteCarlo class. - distribution : dict - Dictionary whose keys contain the name whose distribution changed. The values - are tuples or lists with two entries. The first entry is a probability - density (mass) function for the old distribution, while the second entry - is the probability density function for the new distribution. + structure as those created by the MonteCarlo class but now containing the + selected sub-samples. Returns ------- None """ - self.montecarlo_filepath = montecarlo_filepath + self.monte_carlo_filepath = monte_carlo_filepath self.mrs_filepath = mrs_filepath - self.distribution_dict = distribution_dict + self.distribution_dict = None self.original_sample_size = 0 self.sup_ratio = 1 self.expected_sample_size = None self.final_sample_size = None - # TODO: is there a better way to construct input/output_list? - # Iterating and appending over lists is costly. However, the - # alternative, reading the file twice to get the number of lines, - # also does not seem to be a good option. - self.output_list = [] - self.input_list = [] + self.input_variables_names = set() + self.output_variables_names = set() + self.all_sample_list = [] + self.accepted_sample_list = [] self.__setup_input() self.__load_output() def __setup_input(self): - """Loads, validate and compute information from monte carlo - input with a single read from the file. - - This function does three things: - 1) Load: Loads the input data from MonteCarlo into python - objects so the sampling process does not require reading from - disk; - 2) Validate: Validates that the keys in 'distribution_dict' exist in - the input json created by the monte carlo; - 3) Compute: Computes the supremum of the probability ratios, used in the - sample function. - - While these three tasks could be disentangled to get clearer - code, the implementation as done here only requires a single - read from disk. + """Loads input information from monte carlo in a SampleInformation + object """ - input_filename = f"{self.montecarlo_filepath}.inputs.txt" + input_filename = f"{self.monte_carlo_filepath}.inputs.txt" try: input_file = open(input_filename, "r+", encoding="utf-8") except FileNotFoundError as e: raise FileNotFoundError( - f"Input file from monte carlo {input_filename} " "not found!" + f"Input file from monte carlo {input_filename} not found!" ) from e - for line in input_file.readlines(): - try: - # loads data + try: + for line in input_file.readlines(): + sample_info = SampleInformation() line_json = json.loads(line) - self.input_list.append(line_json) - self.original_sample_size += 1 + sample_info.inputs_json = line_json + self.all_sample_list.append(sample_info) - prob_ratio = 1 - for parameter in self.distribution_dict.keys(): - # checks dictionary keys - if parameter not in line_json.keys(): + # sets and validates input variables names + if not self.input_variables_names: + self.input_variables_names = set(line_json.keys()) + else: + if self.input_variables_names != set(line_json.keys()): raise ValueError( - f"Parameter key {parameter} from 'distribution_dict' " - "not found in input file!" + "Input file from Monte Carlo contains different " + "variables for different lines" ) - parameter_value = line_json[parameter] - - prob_ratio *= self.__compute_probability_ratio( - parameter, parameter_value - ) - # updates the supremum of the ratio - self.sup_ratio = max(self.sup_ratio, prob_ratio) - except Exception as e: - raise ValueError( - "An error occurred while reading " - f"the monte carlo input file {input_filename}!" - ) from e + self.original_sample_size += 1 + except Exception as e: + raise ValueError( + "An error occurred while reading " + f"the monte carlo input file {input_filename}!" + ) from e - self.expected_sample_size = self.original_sample_size // self.sup_ratio input_file.close() def __load_output(self): - """Load data from monte carlo outputs.""" - output_filename = f"{self.montecarlo_filepath}.outputs.txt" + """Loads output information from monte carlo in a SampleInformation + object. + """ + output_filename = f"{self.monte_carlo_filepath}.outputs.txt" sample_size_output = 0 # sanity check try: @@ -130,91 +121,139 @@ def __load_output(self): f"Output file from monte carlo {output_filename} " "not found!" ) from e - for line in output_file.readlines(): - try: + try: + for line in output_file.readlines(): + if sample_size_output > self.original_sample_size: + raise ValueError( + "Monte carlo output has more lines than the input file!" + ) line_json = json.loads(line) - self.output_list.append(line_json) + self.all_sample_list[sample_size_output].outputs_json = line_json sample_size_output += 1 - except Exception as e: - raise ValueError( - "An error occurred while reading " - f"the monte carlo output file {output_filename}!" - ) from e - - if self.original_sample_size != sample_size_output: + except Exception as e: + raise ValueError( + "An error occurred while reading " + f"the monte carlo output file {output_filename}!" + ) from e + if self.original_sample_size > sample_size_output: raise ValueError( - "Monte carlo input and output files have a different " - "number of samples!" + "Monte carlo output file has fewer lines than the input file!" ) output_file.close() - def sample(self): + def __validate_distribution_dict(self, distribution_dict): + """Checks that the variables passed in the distribution dictionary were + in the input file. + + """ + input_variables_names = set(distribution_dict.keys()) + for variable in input_variables_names: + if variable not in self.input_variables_names: + raise ValueError( + f"Variable key {variable} from 'distribution_dict' " + "not found in input file!" + ) + + def sample(self, distribution_dict): """Performs rejection sampling and saves data + Parameters + ---------- + distribution : dict + Dictionary whose keys contain the name whose distribution changed. + The values are tuples or lists with two entries. The first entry is + a probability density (mass) function for the old distribution, + while the second entry is the probability density function for the + new distribution. + Returns ------- None """ + self.__validate_distribution_dict(distribution_dict) + mrs_input_file = open(f"{self.mrs_filepath}.inputs.txt", "w+", encoding="utf-8") mrs_output_file = open( f"{self.mrs_filepath}.outputs.txt", "w+", encoding="utf-8" ) mrs_error_file = open(f"{self.mrs_filepath}.errors.txt", "w+", encoding="utf-8") - # compute sup ratio - for line_input_json, line_output_json in zip(self.input_list, self.output_list): - acceptance_prob = 1 / self.sup_ratio # probability the sample is accepted - for parameter in self.distribution_dict.keys(): - parameter_value = line_input_json[parameter] - acceptance_prob *= self.__compute_probability_ratio( - parameter, - parameter_value, - ) - # sample is accepted, write output - if random() < acceptance_prob: - mrs_input_file.write( - json.dumps(line_input_json, cls=RocketPyEncoder) + "\n" - ) - mrs_output_file.write( - json.dumps(line_output_json, cls=RocketPyEncoder) + "\n" - ) + self.__setup_probabilities(distribution_dict) + + try: + for sample in self.all_sample_list: + if random() < sample.acceptance_probability: + mrs_input_file.write( + json.dumps(sample.inputs_json, cls=RocketPyEncoder) + "\n" + ) + mrs_output_file.write( + json.dumps(sample.outputs_json, cls=RocketPyEncoder) + "\n" + ) + except Exception as e: + raise ValueError( + "An error occurred while writing the selected sample to the " + "output files" + ) from e mrs_input_file.close() mrs_output_file.close() mrs_error_file.close() - def __compute_probability_ratio(self, parameter, parameter_value): - """Computes the ratio of the new probability to the old probability + def __setup_probabilities(self, distribution_dict): + """Computes the probability ratio, probability ratio supremum and acceptance + probability for each sample. Parameters ---------- - parameter : str - Name of the parameter to evaluate the probability. - parameter_value : any - Value of the parameter to be passed to the density functions. + distribution : dict + Dictionary whose keys contain the name whose distribution changed. The values + are tuples or lists with two entries. The first entry is a probability + density (mass) function for the old distribution, while the second entry + is the probability density function for the new distribution. + """ + self.sup_ratio = 1 + for sample in self.all_sample_list: + sample.probability_ratio = self.__compute_probability_ratio( + sample, distribution_dict + ) + self.sup_ratio = max(self.sup_ratio, sample.probability_ratio) - Returns - ------- - float - The ratio of the new probability density function (numerator) - to the old one (denominator). + for sample in self.all_sample_list: + sample.acceptance_probability = sample.probability_ratio / self.sup_ratio + self.expected_sample_size = self.original_sample_size // self.sup_ratio + + def __compute_probability_ratio(self, sample, distribution_dict): + """Computes the ratio of the new probability to the old probability + for the given sample + + Parameters + ---------- + sample: SampleInformation + Sample information used to extract the values to evaluate the + distributions pdf. + distribution : dict + Dictionary whose keys contain the name whose distribution changed. The values + are tuples or lists with two entries. The first entry is a probability + density (mass) function for the old distribution, while the second entry + is the probability density function for the new distribution. Raises ------ ValueError Raises exception if an error occurs when computing the ratio. """ + probability_ratio = 1 try: - old_pdf = self.distribution_dict[parameter][0] - new_pdf = self.distribution_dict[parameter][1] - probability_ratio = new_pdf(parameter_value) / old_pdf(parameter_value) + for variable in distribution_dict.keys(): + value = sample.inputs_json[variable] + old_pdf = distribution_dict[variable][0] + new_pdf = distribution_dict[variable][1] + probability_ratio *= new_pdf(value) / old_pdf(value) except Exception as e: raise ValueError( - "An error occurred while evaluating the " - "ratio for 'distribution_dict' probability " - f"parameter key {parameter}!" + "An error occurred while evaluating the probability ratio" ) from e return probability_ratio From 717b3aeb4ee3a1f7b7d8d8611503bc56dcf2ce51 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Fri, 21 Feb 2025 19:56:00 -0300 Subject: [PATCH 04/18] ENH: add comparison prints, plots and ellipses to MonteCarlo and finally checks in MRS --- docs/notebooks/test_mrs.ipynb | 295 +++++++++++++++++- rocketpy/plots/monte_carlo_plots.py | 224 +++++++++++++ rocketpy/prints/monte_carlo_prints.py | 58 ++++ rocketpy/simulation/monte_carlo.py | 48 +++ .../multivariate_rejection_sampler.py | 16 +- 5 files changed, 619 insertions(+), 22 deletions(-) diff --git a/docs/notebooks/test_mrs.ipynb b/docs/notebooks/test_mrs.ipynb index d25e7c9a2..558189ac0 100644 --- a/docs/notebooks/test_mrs.ipynb +++ b/docs/notebooks/test_mrs.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -81,10 +81,18 @@ "output_type": "stream", "text": [ "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt\n", - "A total of 116 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", + "A total of 113 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", "\n", "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lprates/Desktop/Work/RocketPy/RocketPy/rocketpy/simulation/monte_carlo.py:133: UserWarning: This class is still under testing and some attributes may be changed in next versions\n", + " warnings.warn(\n" + ] } ], "source": [ @@ -93,14 +101,14 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "A total of 116 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", + "A total of 113 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", "\n", "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt\n", "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt\n" @@ -113,15 +121,15 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MRS mass mean after resample: 15.041934326472004\n", - "MRS mass std after resample: 0.48924085702427966\n" + "MRS mass mean after resample: 15.027532656859725\n", + "MRS mass std after resample: 0.4560120026589398\n" ] } ], @@ -136,16 +144,16 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "107.0" + "np.float64(111.0)" ] }, - "execution_count": 37, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -154,6 +162,261 @@ "mrs.expected_sample_size" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.inputs.txt\n", + "A total of 1000 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.outputs.txt\n", + "\n", + "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.errors.txt\n" + ] + } + ], + "source": [ + "original_results = MonteCarlo(monte_carlo_filepath, None, None, None)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparison of Monte Carlo Simulation by RocketPy\n", + "Original data Source: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs\n", + "Comparison data Source: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example\n", + "Original number of simulations: 113\n", + "Comparison number of simulations: 1000\n", + "Results: \n", + "\n", + " Parameter Source Mean Median Std. Dev. 95% PI Lower 95% PI Upper\n", + "--------------------------------------------------------------------------------------------------------------------------------------------\n", + " initial_stability_margin Original 2.556 2.568 0.086 2.392 2.710\n", + " initial_stability_margin Other 2.596 2.596 0.085 2.425 2.763\n", + " apogee Original 3203.634 3367.672 680.251 1855.810 4155.730\n", + " apogee Other 3221.616 3300.831 594.740 1981.254 4149.382\n", + " frontal_surface_wind Original -3.789 -3.845 0.483 -4.569 -2.954\n", + " frontal_surface_wind Other -3.839 -3.933 0.481 -4.608 -2.928\n", + " x_impact Original 324.695 322.132 191.745 -6.640 725.390\n", + " x_impact Other 312.319 306.587 195.323 -59.172 717.304\n", + " apogee_y Original 858.244 871.212 136.406 592.627 1071.250\n", + " apogee_y Other 876.923 885.545 123.791 628.347 1094.965\n", + " out_of_rail_velocity Original 25.700 26.078 2.586 20.821 29.656\n", + " out_of_rail_velocity Other 25.690 25.896 2.194 21.244 29.632\n", + " impact_velocity Original -5.291 -5.193 1.103 -5.339 -5.022\n", + " impact_velocity Other -5.259 -5.247 0.378 -5.404 -5.085\n", + " max_mach_number Original 0.861 0.883 0.152 0.575 1.095\n", + " max_mach_number Other 0.859 0.871 0.131 0.596 1.092\n", + " y_impact Original -1910.501 -1946.274 570.613 -2798.655 -895.268\n", + " y_impact Other -1839.493 -1840.286 486.133 -2737.980 -863.422\n", + " apogee_x Original 441.655 438.452 123.850 211.294 668.057\n", + " apogee_x Other 446.565 441.278 124.777 221.778 697.555\n", + " lateral_surface_wind Original -5.290 -5.190 0.630 -6.687 -4.276\n", + " lateral_surface_wind Other -5.259 -5.131 0.621 -6.700 -4.258\n", + " out_of_rail_stability_margin Original 2.630 2.637 0.085 2.471 2.778\n", + " out_of_rail_stability_margin Other 2.669 2.671 0.084 2.497 2.831\n", + " apogee_time Original 24.618 25.362 2.434 19.598 27.503\n", + " apogee_time Other 24.782 25.198 2.015 20.216 27.553\n", + " t_final Original 300.349 310.959 43.098 224.124 357.220\n", + " t_final Other 299.027 303.558 34.327 228.105 353.583\n", + " out_of_rail_time Original 0.362 0.354 0.034 0.319 0.427\n", + " out_of_rail_time Other 0.361 0.356 0.027 0.320 0.420\n" + ] + } + ], + "source": [ + "mrs_results.compare_info(original_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAMWCAYAAACHiaukAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaO5JREFUeJzt3XlcFWX///H3AVlFQAEFFQSXhHLB3HIhtCzS0tyq2yyXcrlv9S61vNPbErTMynKpXMpSzKwsb7NSQ80lrcxyaTM0RVFTUQkVBQWF+f3hl/PryCI4cA7o6/l4nEeda66Z+cyc8XDeZ2auYzEMwxAAAAAAXCMnRxcAAAAAoGIjVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAQClKTk6WxWJRfHy8o0uxkZCQoMjISLm7u8tisej06dOF9v3xxx/Vtm1bVa5cWRaLRT/99JPd6iwtHTp0UIcOHRxdRqEWLVqk8PBwubi4yNfX19HllLqNGzfKYrFo48aN5XqZAEoPoQJAuRQfHy+LxWLzqF69ujp27Kgvv/zS7vXkfaDJe7i4uKhu3brq16+f9u/fXyrr+O677xQXF1fkB/5r8ddff+nBBx+Uh4eHZs2apUWLFqly5coF9r148aIeeOABpaWlafr06Vq0aJHq1KlTqvVcTVnth/Ji9+7dGjBggOrVq6d58+bp7bffdnRJAGBaJUcXAABFmTRpksLCwmQYho4fP674+Hh16dJFX3zxhe677z671/PEE0+oZcuWunjxonbs2KG3335bK1eu1K+//qqaNWuaWvZ3332niRMnasCAAaX67fWPP/6os2fP6vnnn1enTp2K7JuUlKSDBw9q3rx5GjRoUKnVUBJltR/Ki40bNyo3N1czZ85U/fr1HV1Ombj99tt1/vx5ubq6OroUAHZCqABQrnXu3FktWrSwPn/88cdVo0YNffjhhw4JFVFRUerdu7ckaeDAgbrpppv0xBNPaOHChRo3bpzd6ymOEydOSFKxPqCXpG9GRkahZzyQX97+Ksk+rqicnJzk7u7u6DIA2BGXPwGoUHx9feXh4aFKlWy/E8nIyNBTTz2l4OBgubm5qWHDhnr11VdlGIYk6fz58woPD1d4eLjOnz9vnS8tLU1BQUFq27atcnJySlzPHXfcIUk6cOBAkf3Wr1+vqKgoVa5cWb6+vrr//vuVmJhonR4XF6cxY8ZIksLCwqyXWSUnJxe53E8++UTNmzeXh4eH/P399cgjj+jIkSPW6R06dFD//v0lSS1btpTFYtGAAQMKXNaAAQMUHR0tSXrggQdksVis9yUMGDBAXl5eSkpKUpcuXVSlShX17dtX0tX3fR6LxaIRI0Zo+fLlatSokdzc3HTLLbcoISGh2PthwYIFuuOOO1S9enW5ubnp5ptv1pw5c4rcR8W1bds2xcTEyN/fXx4eHgoLC9Njjz1mnV7YNf0F3UdT2P4KDQ1VbGysJCkgIEAWi0VxcXGSpM8++0z33nuvatasKTc3N9WrV0/PP/98gcfl1q1b1aVLF1WtWlWVK1dWkyZNNHPmTJs+u3fvVu/evVWtWjW5u7urRYsW+vzzz0u0T3r27Klbb73Vpq1r166yWCw2y9q6dassFov10sSC9lWHDh3UqFEj/f777+rYsaM8PT1Vq1YtvfLKK/nW++eff6p79+6qXLmyqlevrlGjRikrK6tEtQOwL85UACjXzpw5o9TUVBmGoRMnTuiNN97QuXPn9Mgjj1j7GIahbt26acOGDXr88ccVGRmp1atXa8yYMTpy5IimT58uDw8PLVy4UO3atdP48eM1bdo0SdLw4cN15swZxcfHy9nZucT1JSUlSZL8/PwK7fPVV1+pc+fOqlu3ruLi4nT+/Hm98cYbateunXbs2KHQ0FD17NlTf/zxhz788ENNnz5d/v7+ki5/8CxMfHy8Bg4cqJYtW2rKlCk6fvy4Zs6cqW+//VY7d+6Ur6+vxo8fr4YNG+rtt9+2XkpWr169Apc3dOhQ1apVSy+++KL1Mq8aNWpYp1+6dEkxMTFq3769Xn31VXl6ehZr3//dN998o2XLlmnYsGGqUqWKXn/9dfXq1UuHDh2Sn5/fVffDnDlzdMstt6hbt26qVKmSvvjiCw0bNky5ubkaPnx4MV6xgp04cUJ33323AgICNHbsWPn6+io5OVnLli275mUWtL8GDBig9957T59++qnmzJkjLy8vNWnSRNLl19PLy0ujR4+Wl5eX1q9frwkTJig9PV1Tp061Lnft2rW67777FBQUpCeffFKBgYFKTEzUihUr9OSTT0qSdu3apXbt2qlWrVoaO3asKleurI8//ljdu3fX//73P/Xo0aNY2xAVFaXPPvtM6enp8vb2lmEY+vbbb+Xk5KTNmzerW7dukqTNmzfLyclJ7dq1K3J5p06d0j333KOePXvqwQcf1NKlS/XMM8+ocePG6ty5s6TLXwDceeedOnTokJ544gnVrFlTixYt0vr160v8GgCwIwMAyqEFCxYYkvI93NzcjPj4eJu+y5cvNyQZL7zwgk177969DYvFYuzbt8/aNm7cOMPJycnYtGmT8cknnxiSjBkzZly1ng0bNhiSjPnz5xsnT540jh49aqxcudIIDQ01LBaL8eOPPxqGYRgHDhwwJBkLFiywzhsZGWlUr17d+Ouvv6xtP//8s+Hk5GT069fP2jZ16lRDknHgwIGr1pOdnW1Ur17daNSokXH+/Hlr+4oVKwxJxoQJE6xtefsyr8bibOcnn3xi096/f39DkjF27Fib9pLse0mGq6urTdvPP/9sSDLeeOMNa1tR+yEzMzNfW0xMjFG3bl2btujoaCM6Ovqq25vn008/veo+yts3GzZssGkv6DUvbH8ZhmHExsYakoyTJ0/atBe0bUOHDjU8PT2NCxcuGIZhGJcuXTLCwsKMOnXqGKdOnbLpm5uba/3/O++802jcuLF1vrzpbdu2NRo0aFDoNl7pxx9/NCQZq1atMgzDMH755RdDkvHAAw8YrVu3tvbr1q2b0axZM+vzgvZVdHS0Icl47733rG1ZWVlGYGCg0atXL2vbjBkzDEnGxx9/bG3LyMgw6tevX+D+B1A+cPkTgHJt1qxZWrt2rdauXav3339fHTt21KBBg2y+QV61apWcnZ31xBNP2Mz71FNPyTAMm9Gi4uLidMstt6h///4aNmyYoqOj881XlMcee0wBAQGqWbOm7r33XmVkZGjhwoU293383bFjx/TTTz9pwIABqlatmrW9SZMmuuuuu7Rq1apir/vvtm3bphMnTmjYsGE2167fe++9Cg8P18qVK69puVfzr3/9y+Z5Sfa9JHXq1MnmTEmTJk3k7e1d7BG0PDw8rP+fdxYrOjpa+/fv15kzZ0q6OVZ59zesWLFCFy9evOblXOnK/VWUv2/b2bNnlZqaqqioKGVmZmr37t2SpJ07d+rAgQMaOXJkvnsyLBaLpMuX9K1fv14PPvigdTmpqan666+/FBMTo71799pcIleUZs2aycvLS5s2bZJ0+YxE7dq11a9fP+3YsUOZmZkyDEPffPONoqKirro8Ly8vm7OMrq6uatWqlc3rv2rVKgUFBVnvXZIkT09PDRkypFg1A3AMLn8CUK61atXK5gN7nz591KxZM40YMUL33XefXF1ddfDgQdWsWVNVqlSxmTciIkKSdPDgQWubq6ur5s+fr5YtW8rd3V0LFiywfhgrjgkTJigqKkrOzs7y9/dXREREvvs7/i5v3Q0bNsw3LSIiQqtXr76mG56LWm54eLi++eabEi2vOCpVqqTatWvnq6O4+16SQkJC8i23atWqOnXqVLFq+PbbbxUbG6stW7YoMzPTZtqZM2fk4+NTrOVcKTo6Wr169dLEiRM1ffp0dejQQd27d9fDDz8sNze3a1pmQfurKLt27dKzzz6r9evXKz093WZaXmDKu9yuUaNGhS5n3759MgxDzz33nJ577rkC+5w4cUK1atW6ak3Ozs5q06aNNm/eLOlyqIiKilL79u2Vk5Oj77//XjVq1FBaWlqxQkXt2rXz/XurWrWqfvnlF+vzgwcPqn79+vn6FXSsAyg/CBUAKhQnJyd17NhRM2fO1N69e3XLLbeUeBmrV6+WJF24cEF79+5VWFhYsedt3LjxVYdlvV65ubnJycncCe7C7lsxrripuyBJSUm68847FR4ermnTpik4OFiurq5atWqVpk+frtzc3Guuy2KxaOnSpfr+++/1xRdfaPXq1Xrsscf02muv6fvvv5eXl1eh4bOwG/xLsr9Onz6t6OhoeXt7a9KkSapXr57c3d21Y8cOPfPMMyXatry+Tz/9tGJiYgrsU5KhbNu3b6/JkyfrwoUL2rx5s8aPHy9fX181atRImzdvtt53U5xQYeb1B1C+ESoAVDiXLl2SJJ07d06SVKdOHX311Vc6e/aszTfmeZeM/P3H23755RdNmjRJAwcO1E8//aRBgwbp119/veZvuK8mb9179uzJN2337t3y9/e3nqUoyRmTvy83bwSqPHv27LHbD9aVZN8XV2H74YsvvlBWVpY+//xzmzMeGzZsKPE6CnPbbbfptttu0+TJk/XBBx+ob9+++uijjzRo0CBVrVpVkvL9KN+VZ2OuxcaNG/XXX39p2bJluv32263tV44qlnfp2G+//VZouK1bt64kycXFpVQCcFRUlLKzs/Xhhx/qyJEj1vBw++23W0PFTTfdZHNTvxl16tTRb7/9JsMwbI6Fgv4NASg/uKcCQIVy8eJFrVmzRq6urtZLbLp06aKcnBy9+eabNn2nT58ui8ViHVXm4sWLGjBggGrWrKmZM2cqPj5ex48f16hRo8qs3qCgIEVGRmrhwoU2H0Z/++03rVmzRl26dLG25YWL4vySdIsWLVS9enXNnTvXZqjNL7/8UomJibr33ntLbRuKUtx9XxKF7Ye8b7n//q32mTNntGDBghKv40qnTp3K9215ZGSkJFn3b506deTs7Gy9vyDP7NmzTa+/oG3Lzs7Ot+xbb71VYWFhmjFjRr79kzdv9erV1aFDB7311ls6duxYvnWdPHmyRLW1bt1aLi4uevnll1WtWjXr2cGoqCh9//33+vrrr4t1lqK4unTpoqNHj2rp0qXWtszMTH55HCjnOFMBoFz78ssvrd96nzhxQh988IH27t2rsWPHytvbW9LlcfM7duyo8ePHKzk5WU2bNtWaNWv02WefaeTIkdZvd1944QX99NNPWrdunapUqaImTZpowoQJevbZZ9W7d2+bD/ilaerUqercubPatGmjxx9/3DqkrI+Pj/U3CiSpefPmkqTx48frH//4h1xcXNS1a9cC77fI+5A3cOBARUdHq0+fPtYhZUNDQ8s0KP1dcfd9SRS2H+6++265urqqa9euGjp0qM6dO6d58+apevXqBX54LomFCxdq9uzZ6tGjh+rVq6ezZ89q3rx58vb2th4XPj4+euCBB/TGG2/IYrGoXr16WrFihfXH7Mxo27atqlatqv79++uJJ56QxWLRokWL8gUdJycnzZkzR127dlVkZKQGDhyooKAg7d69W7t27bJe2jdr1iy1b99ejRs31uDBg1W3bl0dP35cW7Zs0Z9//qmff/652LV5enqqefPm+v77762/USFdPlORkZGhjIyMUg0VgwcP1ptvvql+/fpp+/btCgoK0qJFi+Tp6Vlq6wBQBhwz6BQAFK2gIWXd3d2NyMhIY86cOTbDZxqGYZw9e9YYNWqUUbNmTcPFxcVo0KCBMXXqVGu/7du3G5UqVTL+/e9/28x36dIlo2XLlkbNmjXzDdH5d4UNtXqlgoYXNQzD+Oqrr4x27doZHh4ehre3t9G1a1fj999/zzf/888/b9SqVctwcnIq1vCyS5YsMZo1a2a4ubkZ1apVM/r27Wv8+eefNn1Ka0jZypUrFzjP1fZ9HknG8OHD881fp04do3///jZthe2Hzz//3GjSpInh7u5uhIaGGi+//LIxf/78fPuqpEPK7tixw+jTp48REhJiuLm5GdWrVzfuu+8+Y9u2bTb9Tp48afTq1cvw9PQ0qlatagwdOtT47bffChxStrD9VdiQst9++61x2223GR4eHkbNmjWN//znP8bq1asLHEb1m2++Me666y6jSpUqRuXKlY0mTZrYDMtrGIaRlJRk9OvXzwgMDDRcXFyMWrVqGffdd5+xdOnSYu+XPGPGjDEkGS+//LJNe94wr0lJSTbthQ0pe8stt+Rbdv/+/Y06derYtB08eNDo1q2b4enpafj7+xtPPvmkkZCQwJCyQDlmMQzujgIAAABw7binAgAAAIAp3FMBALiunTx5stBhX6XLv13y9x8mvFGkpKQUOd3Dw6PMRkUDcP3h8icAwHUtNDS0yGFfo6OjtXHjRvsVVE5cbQjj/v37Kz4+3j7FAKjwOFMBALiuLV68WOfPny90et7vT9xo1q5dW+T0mjVr2qkSANcDzlQAAAAAMIUbtQEAAACYwuVPxZCbm6ujR4+qSpUqV70GFQAAALheGIahs2fPqmbNmnJyKvx8BKGiGI4eParg4GBHlwEAAAA4xOHDh1W7du1CpxMqiqFKlSqSLu9Mb29vB1cDAAAA2Ed6erqCg4Otn4cLQ6gohrxLnry9vQkVAAAAuOFc7RYAbtQGAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmFLJ0QUAQEkcOnRIqampji4DuOH4+/srJCTE0WUAKKfsGiqSk5MVFhamnTt3KjIysljzxMfHa+TIkTp9+rRD6wDgeIcOHVLDhhG6cCHT0aVUeIFeFg1t7qq3tmcr5Zzh6HJQAbi7e2rPnkSCBYACXVOoOHz4sGJjY5WQkKDU1FQFBQWpe/fumjBhgvz8/AqdLzg4WMeOHZO/v3+x1/XQQw+pS5cu11ImgOtMamrq/wWK9yVFOLqcCi3I6w/FdRiqz/fEK+XcTY4uB+Veoi5ceESpqamECgAFKnGo2L9/v9q0aaObbrpJH374ocLCwrRr1y6NGTNGX375pb7//ntVq1Yt33zZ2dlydXVVYGBgidbn4eEhDw+PkpZ5XcnMzNTu3bsVHh4uT09PR5cDlAMRkm51dBEVXN4tdeGSIh1YBwCgKBXlc2CJb9QePny4XF1dtWbNGkVHRyskJESdO3fWV199pSNHjmj8+PGSpNDQUD3//PPq16+fvL29NWTIECUnJ8tiseinn36yLu/zzz9XgwYN5O7uro4dO2rhwoWyWCzWy53i4+Pl6+tr7R8XF6fIyEgtWrRIoaGh8vHx0T/+8Q+dPXvW2ichIUHt27eXr6+v/Pz8dN999ykpKena9lA5sHv3bjVv3ly7d+92dCkAAACwo4ryObBEoSItLU2rV6/WsGHD8p09CAwMVN++fbVkyRIZxuXrc1999VU1bdpUO3fu1HPPPZdveQcOHFDv3r3VvXt3/fzzzxo6dKg1lBQlKSlJy5cv14oVK7RixQp9/fXXeumll6zTMzIyNHr0aG3btk3r1q2Tk5OTevToodzc3JJsLgAAAIBiKNHlT3v37pVhGIqIKPha5oiICJ06dUonT56UJN1xxx166qmnrNOTk5Nt+r/11ltq2LChpk6dKklq2LChfvvtN02ePLnIOnJzcxUfH68qVapIkh599FGtW7fOOl+vXr1s+s+fP18BAQH6/fff1ahRo6tuZ1ZWlrKysqzP09PTrzpPWTp//rwkKTEx0aF1AI72//8NnHdoHcCNh79DgKPk/bvL+zxYXl3Tjdp5ZyKupkWLFkVO37Nnj1q2bGnT1qpVq6suNzQ01BooJCkoKEgnTpywPt+7d68mTJigrVu3KjU11XqG4tChQ8UKFVOmTNHEiROv2s9e8sLYI4884thCgHIjWVI7RxcB3ECSJfF3CHCk5ORktWtXfv/2lShU1K9fXxaLRYmJierRo0e+6YmJiapataoCAgIkSZUrVy6dKq/g4uJi89xisdhc2tS1a1fVqVNH8+bNU82aNZWbm6tGjRopOzu7WMsfN26cRo8ebX2enp6u4ODg0in+GoSGhkqS3n///ULPEgE3gsTExP/7UBPq6FKAG0yoJP4OAY6Q97cv7/NgeVWiUOHn56e77rpLs2fP1qhRo2zuq0hJSdHixYvVr18/WSyWYi2vYcOGWrVqlU3bjz/+WJKS8vnrr7+0Z88ezZs3T1FRUZKkb775pkTLcHNzk5ubm6k6SlPefo6IiNCttzLiDSDd2CPCAfbH3yHA0cr7aKglHv3pzTffVFZWlmJiYrRp0yYdPnxYCQkJuuuuu1SrVq2r3g/xd0OHDtXu3bv1zDPP6I8//tDHH3+s+Ph4SSp2MLlS1apV5efnp7ffflv79u3T+vXrbc46AAAAAChdJQ4VDRo00LZt21S3bl09+OCDqlevnoYMGaKOHTtqy5YtBf5GRWHCwsK0dOlSLVu2TE2aNNGcOXOsoz9d65kCJycnffTRR9q+fbsaNWqkUaNGWW8Er6jCw8O1fft2hYeHO7oUAAAA2FFF+RxoMYp717WdTJ48WXPnztXhw4cdXYpVenq6fHx8dObMGXl7ezu6HOCGtWPHDjVv3lz8orZ5zQL/0I6hQ3XrW29pZwq/qI2rSZT0iLZv387lT8ANprifg69p9KfSNHv2bLVs2VJ+fn769ttvNXXqVI0YMcLRZQEoh/z9/eXu7qkLFxiBxqxj5yyK2+iqY+cellSuvltCOeXu7il/f39HlwGgnHJ4qNi7d69eeOEFpaWlKSQkRE899ZTGjRvn6LIAlEMhISHasydRqampji7lutHN0QWgwvD391dISIijywBQTpW7y5/KIy5/AgAAwI2ouJ+DS3yjNgAAAAD8HaECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKZUcXQAAlKZDhw4pNTXV0WUAKCX+/v4KCQlxdBkAroJQAeC6cejQIUU0bKjMCxccXQr+T6CXRUObu+qt7dlKOWc4uhxUQJ7u7krcs4dgAZRzFSZUxMfHa+TIkTp9+rSjSwFQTqWmpirzwgW9LynC0cVAkuThZVFEBzc9tOeizhMqUEKJkh65cEGpqamECqCcs3uoOHz4sGJjY5WQkKDU1FQFBQWpe/fumjBhgvz8/CRJoaGhGjlypEaOHGnv8gBcByIk3eroImCDkAcA1ze73qi9f/9+tWjRQnv37tWHH36offv2ae7cuVq3bp3atGmjtLQ0e5YjSbp48aLd11lRZGZmaseOHcrMzHR0KQAAAKbx2abs2DVUDB8+XK6urlqzZo2io6MVEhKizp0766uvvtKRI0c0fvx4dejQQQcPHtSoUaNksVhksVhslrF69WpFRETIy8tL99xzj44dO2Yz/Z133lFERITc3d0VHh6u2bNnW6clJyfLYrFoyZIlio6Olru7uxYvXmyXba+Idu/erebNm2v37t2OLgUAAMA0PtuUHbtd/pSWlqbVq1dr8uTJ8vDwsJkWGBiovn37asmSJdq7d68iIyM1ZMgQDR482KZfZmamXn31VS1atEhOTk565JFH9PTTT1uDweLFizVhwgS9+eabatasmXbu3KnBgwercuXK6t+/v3U5Y8eO1WuvvaZmzZrJ3d297DceAAAAuI7ZLVTs3btXhmEoIqLgK2sjIiJ06tQp5eTkyNnZWVWqVFFgYKBNn4sXL2ru3LmqV6+eJGnEiBGaNGmSdXpsbKxee+019ezZU5IUFham33//XW+99ZZNqBg5cqS1T0GysrKUlZVlfZ6enl7yDb4OnD9/XpKUmJjo4EqA4sk7Vs87uA4ApSPv3zJ/h1BarH8nzvOXorTZ/UZtw7j20T88PT2tgUKSgoKCdOLECUlSRkaGkpKS9Pjjj9uc4bh06ZJ8fHxsltOiRYsi1zNlyhRNnDjxmuu8XiQnJ0uSHnnkEccWApRQsqR2ji4CgGnJ//df/g6htCUnJ6tdO/5SlCa7hYr69evLYrEoMTFRPXr0yDc9MTFRVatWVUBAQKHLcHFxsXlusVisIeXcuXOSpHnz5ql169Y2/ZydnW2eV65cuchax40bp9GjR1ufp6enKzg4uMh5rkehoaGSpPfff7/QM0xAeZKYmKhHHnlEoY4uBECpCP2///J3CKXF+nfi/z7joPTYLVT4+fnprrvu0uzZszVq1Cib+ypSUlK0ePFi9evXTxaLRa6ursrJySnR8mvUqKGaNWtq//796tu3r6la3dzc5ObmZmoZ14O81ygiIkK33soAnag4PK7eBUAFkPdvmb9DKG1X3t8L8+w6+tObb76prKwsxcTEaNOmTTp8+LASEhJ01113qVatWpo8ebKky9+Qb9q0SUeOHFFqamqxlz9x4kRNmTJFr7/+uv744w/9+uuvWrBggaZNm1ZWmwQAAADc8OwaKho0aKBt27apbt26evDBB1WvXj0NGTJEHTt21JYtW1StWjVJ0qRJk5ScnKx69eoVeTnUlQYNGqR33nlHCxYsUOPGjRUdHa34+HiFhYWV1SZd18LDw7V9+3aFh4c7uhQAAADT+GxTdiyGmTunbxDp6eny8fHRmTNn5O3t7ehyABRix44dat68ud4Xv+BcXngEOiliqJcS3zqn8ym5ji4HFUyipEckbd++ncufAAcp7udgu4/+BABlxd/fX57u7nrkwgVHl4L/E3jO0NCNWXrrnKEURxeDCsnT3V3+/v6OLgPAVRAqAFw3QkJClLhnT4nuxYJ9dHN0Aaiw/P39FRIS4ugyAFwFoQLAdSUkJIQPIAAA2Jldb9QGAAAAcP0hVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAlEqOLqAiMAxDkpSenu7gSgAAAAD7yfv8m/d5uDCEimI4e/asJCk4ONjBlQAAAAD2d/bsWfn4+BQ63WJcLXZAubm5Onr0qKpUqSKLxeLoclCBpKenKzg4WIcPH5a3t7ejy0EFxrGE0sTxhNLCsXT9MwxDZ8+eVc2aNeXkVPidE5ypKAYnJyfVrl3b0WWgAvP29ubNFqWCYwmlieMJpYVj6fpW1BmKPNyoDQAAAMAUQgUAAAAAUwgVQBlyc3NTbGys3NzcHF0KKjiOJZQmjieUFo4l5OFGbQAAAACmcKYCAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIoI1lZWYqMjJTFYtFPP/1UZN8OHTrIYrHYPP75z3/ap1CUeyU5li5cuKDhw4fLz89PXl5e6tWrl44fP26fQlFudevWTSEhIXJ3d1dQUJAeffRRHT16tMh5eF9CYa7leOK96fpHqADKyH/+8x/VrFmz2P0HDx6sY8eOWR+vvPJKGVaHiqQkx9KoUaP0xRdf6JNPPtHXX3+to0ePqmfPnmVcIcq7jh076uOPP9aePXv0v//9T0lJSerdu/dV5+N9CQW5luOJ96YbgAGg1K1atcoIDw83du3aZUgydu7cWWT/6Oho48knn7RLbahYSnIsnT592nBxcTE++eQTa1tiYqIhydiyZYsdqkVF8dlnnxkWi8XIzs4utA/vSyiuqx1PvDfdGDhTAZSy48ePa/DgwVq0aJE8PT2LPd/ixYvl7++vRo0aady4ccrMzCzDKlERlPRY2r59uy5evKhOnTpZ28LDwxUSEqItW7aUZamoQNLS0rR48WK1bdtWLi4uRfblfQlXU5zjifemGwOhAihFhmFowIAB+uc//6kWLVoUe76HH35Y77//vjZs2KBx48Zp0aJFeuSRR8qwUpR313IspaSkyNXVVb6+vjbtNWrUUEpKShlUiYrkmWeeUeXKleXn56dDhw7ps88+K7I/70soSkmOJ96bbgyECqAYxo4dm++GxSsfu3fv1htvvKGzZ89q3LhxJVr+kCFDFBMTo8aNG6tv375677339OmnnyopKamMtgiOUtbHEm4cxT2W8owZM0Y7d+7UmjVr5OzsrH79+skwjEKXz/vSjaWsjydc/ywGRwBwVSdPntRff/1VZJ+6devqwQcf1BdffCGLxWJtz8nJkbOzs/r27auFCxcWa30ZGRny8vJSQkKCYmJiTNWO8qUsj6X169frzjvv1KlTp2y+EaxTp45GjhypUaNGldp2wPGKeyy5urrma//zzz8VHBys7777Tm3atCnW+nhfur6V5fHEe9ONoZKjCwAqgoCAAAUEBFy13+uvv64XXnjB+vzo0aOKiYnRkiVL1Lp162KvL2/Y0KCgoBLXivKtLI+l5s2by8XFRevWrVOvXr0kSXv27NGhQ4eK/cERFUdxj6WC5ObmSro8XHFx8b50fSvL44n3phsDZyqAMpScnKywsDDt3LlTkZGRkqQjR47ozjvv1HvvvadWrVopKSlJH3zwgbp06SI/Pz/98ssvGjVqlGrXrq2vv/7asRuAcqM4x5Ik/etf/9KqVasUHx8vb29v/fvf/5Ykfffdd44qHQ62detW/fjjj2rfvr2qVq2qpKQkPffcczp+/Lh27dolNzc33pdQbNdyPEm8N90IOFMB2NnFixe1Z88e6ygqrq6u+uqrrzRjxgxlZGQoODhYvXr10rPPPuvgSlHeXXksSdL06dPl5OSkXr16KSsrSzExMZo9e7YDq4SjeXp6atmyZYqNjVVGRoaCgoJ0zz336Nlnn5Wbm5sk3pdQfNdyPEm8N90IOFMBAAAAwBRGfwIAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQJAhRAaGqoBAwY4uozr3tSpU1W3bl05OzsrMjKyyL6LFi1SeHi4XFxc5Ovra5f6SpvFYlFcXJyjyyjQpUuX9J///EfBwcFycnJS9+7dHV1SqYuLi5PFYin3ywRwdYQKAHYXHx8vi8Wibdu2FTi9Q4cOatSoken1rFq1qtx+YCyP1qxZo//85z9q166dFixYoBdffLHQvrt379aAAQNUr149zZs3T2+//bYdK73sgw8+0IwZM+y+XnuZP3++pk6dqt69e2vhwoUaNWqUo0sCgEJVcnQBAFAce/bskZNTyb4HWbVqlWbNmkWwKKb169fLyclJ7777rlxdXYvsu3HjRuXm5mrmzJmqX7++nSq09cEHH+i3337TyJEjHbL+srZ+/XrVqlVL06dPd3QpZebZZ5/V2LFjHV0GgFLAmQoAFYKbm5tcXFwcXUaJZGRkOLqEEjlx4oQ8PDyuGijy+kq66mVPhmHo/PnzpVHeDeHv++vEiRMV9rKy4qpUqZLc3d0dXQaAUkCoAFAhXHlPxcWLFzVx4kQ1aNBA7u7u8vPzU/v27bV27VpJ0oABAzRr1ixJl6+bz3vkycjI0FNPPaXg4GC5ubmpYcOGevXVV2UYhs16z58/ryeeeEL+/v6qUqWKunXrpiNHjuS7Fj/vOu7ff/9dDz/8sKpWrar27dtLkn755RcNGDBAdevWlbu7uwIDA/XYY4/pr7/+sllX3jL++OMPPfLII/Lx8VFAQICee+45GYahw4cP6/7775e3t7cCAwP12muvFWvfXbp0Sc8//7zq1asnNzc3hYaG6r///a+ysrKsfSwWixYsWKCMjAzrvoqPjy/0tYiNjZUkBQQE2OyL0NBQ3XfffVq9erVatGghDw8PvfXWW5Kk/fv364EHHlC1atXk6emp2267TStXrrRZ9saNG2WxWPTxxx9r8uTJql27ttzd3XXnnXdq37591n4dOnTQypUrdfDgQWu9oaGhkqTs7GxNmDBBzZs3l4+PjypXrqyoqCht2LChWPvraj766CM1b95cVapUkbe3txo3bqyZM2dapxd2TX/eZX/JycnWtsL2l8Vi0YYNG7Rr1y7r9m3cuFGS9Oqrr6pt27by8/OTh4eHmjdvrqVLlxZY6/vvv69WrVrJ09NTVatW1e233641a9bY9Pnyyy8VFRWlypUrq0qVKrr33nu1a9euYu8PwzDk7++v0aNHW9tyc3Pl6+srZ2dnnT592tr+8ssvq1KlSjp37lyh+8pisWjEiBFavny5GjVqJDc3N91yyy1KSEjIt+5vvvlGLVu2lLu7u+rVq2c91gDYH5c/AXCYM2fOKDU1NV/7xYsXrzpvXFycpkyZokGDBqlVq1ZKT0/Xtm3btGPHDt11110aOnSojh49qrVr12rRokU28xqGoW7dumnDhg16/PHHFRkZqdWrV2vMmDE6cuSIzeUmAwYM0Mcff6xHH31Ut912m77++mvde++9hdb1wAMPqEGDBnrxxRetAWXt2rXav3+/Bg4cqMDAQO3atUtvv/22du3ape+//z7fh6qHHnpIEREReumll7Ry5Uq98MILqlatmt566y3dcccdevnll7V48WI9/fTTatmypW6//fYi99WgQYO0cOFC9e7dW0899ZS2bt2qKVOmKDExUZ9++qmkyzddv/322/rhhx/0zjvvSJLatm1b4PJmzJih9957T59++qnmzJkjLy8vNWnSxDp9z5496tOnj4YOHarBgwerYcOGOn78uNq2bavMzEw98cQT8vPz08KFC9WtWzctXbpUPXr0sFnHSy+9JCcnJz399NM6c+aMXnnlFfXt21dbt26VJI0fP15nzpzRn3/+aX29vLy8JEnp6el655131KdPHw0ePFhnz57Vu+++q5iYGP3www9XvQG9KGvXrlWfPn1055136uWXX5YkJSYm6ttvv9WTTz55Tcu8cn/Vrl1bixYt0uTJk3Xu3DlNmTJFkhQRESFJmjlzprp166a+ffsqOztbH330kR544AGtWLHC5ticOHGi4uLi1LZtW02aNEmurq7aunWr1q9fr7vvvlvS5de9f//+iomJ0csvv6zMzEzNmTNH7du3186dO61BrSgWi0Xt2rXTpk2brG2//PKLzpw5IycnJ3377bfWujZv3qxmzZpZX6vCfPPNN1q2bJmGDRumKlWq6PXXX1evXr106NAh+fn5SZJ+/fVX3X333QoICFBcXJwuXbqk2NhY1ahRo/g7H0DpMQDAzhYsWGBIKvJxyy232MxTp04do3///tbnTZs2Ne69994i1zN8+HCjoLe55cuXG5KMF154waa9d+/ehsViMfbt22cYhmFs377dkGSMHDnSpt+AAQMMSUZsbKy1LTY21pBk9OnTJ9/6MjMz87V9+OGHhiRj06ZN+ZYxZMgQa9ulS5eM2rVrGxaLxXjppZes7adOnTI8PDxs9klBfvrpJ0OSMWjQIJv2p59+2pBkrF+/3trWv39/o3LlykUu78paT548adNep04dQ5KRkJBg0z5y5EhDkrF582Zr29mzZ42wsDAjNDTUyMnJMQzDMDZs2GBIMiIiIoysrCxr35kzZxqSjF9//dXadu+99xp16tTJV9ulS5ds5jWMy/urRo0axmOPPWbTfuXreDVPPvmk4e3tbVy6dKnQPnn75kp5x/2BAwesbYXtL8MwjOjo6Hz/Dgwj//GUnZ1tNGrUyLjjjjusbXv37jWcnJyMHj16WPdtntzcXMMwLu9/X19fY/DgwTbTU1JSDB8fn3ztRZk6darh7OxspKenG4ZhGK+//rpRp04do1WrVsYzzzxjGIZh5OTkGL6+vsaoUaOs8xW0ryQZrq6u1n+HhmEYP//8syHJeOONN6xt3bt3N9zd3Y2DBw9a237//XfD2dm5wP0PoGxx+RMAh5k1a5bWrl2b7/H3b70L4+vrq127dmnv3r0lXu+qVavk7OysJ554wqb9qaeekmEY+vLLLyXJernFsGHDbPr9+9//LnTZ//znP/O1eXh4WP//woULSk1N1W233SZJ2rFjR77+gwYNsv6/s7OzWrRoIcMw9Pjjj1vbfX191bBhQ+3fv7/QWqTL2yrJ5tIU6fK2Ssp3+VFpCAsLU0xMTL46WrVqZb0kTLp8ZmHIkCFKTk7W77//btN/4MCBNvd2REVFSdJVt1e6vM/y5s3NzVVaWpouXbqkFi1aFLi/S8LX11cZGRnWy+xKQ0H7qyh/P55OnTqlM2fOKCoqymbbli9frtzcXE2YMCHfAAd5Z8bWrl2r06dPq0+fPkpNTbU+nJ2d1bp16xJdLhYVFaWcnBx99913ki6fkYiKilJUVJQ2b94sSfrtt990+vRp62tZlE6dOqlevXrW502aNJG3t7f19c/JydHq1avVvXt3hYSEWPtFRESUaF8CKD2ECgAO06pVK3Xq1Cnfo2rVqledd9KkSTp9+rRuuukmNW7cWGPGjNEvv/xSrPUePHhQNWvWVJUqVWza8y4vOXjwoPW/Tk5OCgsLs+lX1GhHV/aVpLS0ND355JOqUaOGPDw8FBAQYO135syZfP3//iFJknx8fOTu7i5/f/987adOnSq0lr9vw5U1BwYGytfX17qtpamgfXDw4EE1bNgwX/uV+zzPlfsg75i42vbmWbhwoZo0aWK93yYgIEArV64scH+XxLBhw3TTTTepc+fOql27th577LECr/UviYL2V1FWrFih2267Te7u7qpWrZoCAgI0Z84cm21LSkqSk5OTbr755kKXkxfI77jjDgUEBNg81qxZY70ZvzhuvfVWeXp6WgNEXqi4/fbbtW3bNl24cME67e/BsjBXvv7S5WMg7/U/efKkzp8/rwYNGuTrV9BxBqDscU8FgArp9ttvV1JSkj777DOtWbNG77zzjqZPn665c+fafNNvb3//FjnPgw8+qO+++05jxoxRZGSkvLy8lJubq3vuuUe5ubn5+js7OxerTVK+G8sLY88fAytoH5SUme19//33NWDAAHXv3l1jxoxR9erV5ezsrClTpigpKclUXdWrV9dPP/2k1atX68svv9SXX36pBQsWqF+/flq4cKGkwvd1Tk5Oge0l2V+bN29Wt27ddPvtt2v27NkKCgqSi4uLFixYoA8++KBE25J37C1atEiBgYH5pleqVPyPCC4uLmrdurU2bdqkffv2KSUlRVFRUapRo4YuXryorVu3avPmzQoPD1dAQMBVl2f2eAdgf4QKABVWtWrVNHDgQA0cOFDnzp3T7bffrri4OGuoKOzDXZ06dfTVV1/p7NmzNmcrdu/ebZ2e99/c3FwdOHDA5hvRv49CdDWnTp3SunXrNHHiRE2YMMHafi2XbV2LvG3Yu3ev9ayAJB0/flynT5+2bqs96tizZ0++9iv3eUkU9vouXbpUdevW1bJly2z65I1YZZarq6u6du2qrl27Kjc3V8OGDdNbb72l5557TvXr17eeVTl9+rTNkLClcVbof//7n9zd3bV69Wq5ublZ2xcsWGDTr169esrNzdXvv/9e6I3peZcXVa9eXZ06dTJdW1RUlF5++WV99dVX8vf3V3h4uCwWi2655RZt3rxZmzdv1n333Wd6PdLlUcc8PDwK/HdU0HEGoOxx+ROACunK4Vi9vLxUv359m2FSK1euLEk2Q1pKUpcuXZSTk6M333zTpn369OmyWCzq3LmzJFmvzZ49e7ZNvzfeeKPYdeZ943rlN6z2+iXoLl26FLi+adOmSVKRI1mVdh0//PCDtmzZYm3LyMjQ22+/rdDQ0CIv0ylM5cqVC7ycqaB9vnXrVpt1X6srjzsnJyfrPUB5x17eh/W/j4aUkZFhPZNhhrOzsywWi81Zj+TkZC1fvtymX/fu3eXk5KRJkyblOxuWt19iYmLk7e2tF198scAR106ePFmi2qKiopSVlaUZM2aoffv21kAXFRWlRYsW6ejRo8W6n6I4nJ2dFRMTo+XLl+vQoUPW9sTERK1evbpU1gGgZDhTAaBCuvnmm9WhQwc1b95c1apV07Zt27R06VKNGDHC2qd58+aSpCeeeEIxMTFydnbWP/7xD3Xt2lUdO3bU+PHjlZycrKZNm2rNmjX67LPPNHLkSOuHwubNm6tXr16aMWOG/vrrL+uQsn/88Yek4l1S5O3trdtvv12vvPKKLl68qFq1amnNmjU6cOBAGeyV/Jo2bar+/fvr7bff1unTpxUdHa0ffvhBCxcuVPfu3dWxY0e71DF27Fh9+OGH6ty5s5544glVq1ZNCxcu1IEDB/S///2vxL+WLl1+fZYsWaLRo0erZcuW8vLyUteuXXXfffdp2bJl6tGjh+69914dOHBAc+fO1c0332z9fYRrNWjQIKWlpemOO+5Q7dq1dfDgQb3xxhuKjIy0ngm6++67FRISoscff1xjxoyRs7Oz5s+fr4CAAJsPwNfi3nvv1bRp03TPPffo4Ycf1okTJzRr1izVr1/f5p6i+vXra/z48Xr++ecVFRWlnj17ys3NTT/++KNq1qypKVOmyNvbW3PmzNGjjz6qW2+9Vf/4xz+sNa5cuVLt2rXLF7yL0qZNG1WqVEl79uzRkCFDrO2333675syZI0mlFiqky0PmJiQkKCoqSsOGDdOlS5f0xhtv6JZbbin2/VUASpHjBp4CcKPKG1rzxx9/LHB6QUNpXjmk7AsvvGC0atXK8PX1NTw8PIzw8HBj8uTJRnZ2trXPpUuXjH//+99GQECAYbFYbIaZPHv2rDFq1CijZs2ahouLi9GgQQNj6tSp1uE282RkZBjDhw83qlWrZnh5eRndu3c39uzZY0iyGeK1sCFWDcMw/vzzT6NHjx6Gr6+v4ePjYzzwwAPG0aNHCx2W9splFDbUa2FDjl7p4sWLxsSJE42wsDDDxcXFCA4ONsaNG2dcuHChWOspSFFDyhY21G9SUpLRu3dvw9fX13B3dzdatWplrFixwqZP3pCyn3zyiU37gQMHDEnGggULrG3nzp0zHn74YcPX19eQZB1eNjc313jxxReNOnXqGG5ubkazZs2MFStWGP379883BO2Vr8HVLF261Lj77ruN6tWrG66urkZISIgxdOhQ49ixYzb9tm/fbrRu3draZ9q0aYUOKVvY/irs9X333XeNBg0aGG5ubkZ4eLixYMGCQoexnT9/vtGsWTPDzc3NqFq1qhEdHW2sXbvWps+GDRuMmJgYw8fHx3B3dzfq1atnDBgwwNi2bVux90ueli1bGpKMrVu3Wtv+/PNPQ5IRHBycr39hQ8oOHz48X98r3wMMwzC+/vpro3nz5oarq6tRt25dY+7cuYXuCwBly2IY3PUEACXx008/qVmzZnr//ffVt29fR5cDAIDDcU8FABTh/Pnz+dpmzJghJyenq/6SNQAANwruqQCAIrzyyivavn27OnbsqEqVKlmHER0yZIiCg4MdXR5KSU5OzlVvTPby8pKXl5edKiofsrOzlZaWVmQfHx+fUhlGGEDFxuVPAFCEtWvXauLEifr999917tw5hYSE6NFHH9X48eNLNI4/yrfk5OSr/ghdbGys4uLi7FNQObFx48ar3sy/YMECDRgwwD4FASi3CBUAgBvehQsX9M033xTZp27duqpbt66dKiofTp06pe3btxfZ55ZbblFQUJCdKgJQXhEqAAAAAJjCjdoAAAAATOGC4GLIzc3V0aNHVaVKlWL92BUAAABwPTAMQ2fPnlXNmjWL/KFSQkUxHD16lFFeAAAAcMM6fPiwateuXeh0QkUxVKlSRdLlnent7e3gagAAAAD7SE9PV3BwsPXzcGEIFcWQd8mTt7c3oQIAAAA3nKvdAsCN2gAAAABMIVQAAAAAMIVQAQAAAMAU7qkAAACAXeTm5io7O9vRZeBvXFxc5OzsbHo5hAoAAACUuezsbB04cEC5ubmOLgVX8PX1VWBgoKnfYyNUAAAAoEwZhqFjx47J2dlZwcHBRf6IGuzHMAxlZmbqxIkTkqSgoKBrXhahAgAAAGXq0qVLyszMVM2aNeXp6enocvA3Hh4ekqQTJ06oevXq13wpFDERAAAAZSonJ0eS5Orq6uBKUJC8oHfx4sVrXgahAgAAAHZh5pp9lJ3SeF0IFQAAAABMIVQAAAAAZSA5OVkWi0U//fRTseeJj4+Xr6+vw+soKW7UBgAAgEPExVWM9R0+fFixsbFKSEhQamqqgoKC1L17d02YMEF+fn6FzhccHKxjx47J39+/2Ot66KGH1KVLl2sr1IE4UwEAAAAUYv/+/WrRooX27t2rDz/8UPv27dPcuXO1bt06tWnTRmlpaQXOl52dLWdnZwUGBqpSpeJ/j+/h4aHq1auXVvl2Q6gAAAAACjF8+HC5urpqzZo1io6OVkhIiDp37qyvvvpKR44c0fjx4yVJoaGhev7559WvXz95e3tryJAhBV529Pnnn6tBgwZyd3dXx44dtXDhQlksFp0+fVpS/suf4uLiFBkZqUWLFik0NFQ+Pj76xz/+obNnz1r7JCQkqH379vL19ZWfn5/uu+8+JSUl2WP3WBEqAAAAgAKkpaVp9erVGjZsmPX3HPIEBgaqb9++WrJkiQzDkCS9+uqratq0qXbu3Knnnnsu3/IOHDig3r17q3v37vr55581dOhQaygpSlJSkpYvX64VK1ZoxYoV+vrrr/XSSy9Zp2dkZGj06NHatm2b1q1bJycnJ/Xo0cOuv17OPRUAAABAAfbu3SvDMBQREVHg9IiICJ06dUonT56UJN1xxx166qmnrNOTk5Nt+r/11ltq2LChpk6dKklq2LChfvvtN02ePLnIOnJzcxUfH68qVapIkh599FGtW7fOOl+vXr1s+s+fP18BAQH6/fff1ahRo+JvsAmcqQAAAACKkHcm4mpatGhR5PQ9e/aoZcuWNm2tWrW66nJDQ0OtgUKSgoKCdOLECevzvXv3qk+fPqpbt668vb0VGhoqSTp06FCx6i4NhAoAAACgAPXr15fFYlFiYmKB0xMTE1W1alUFBARIkipXrlwmdbi4uNg8t1gsNpc2de3aVWlpaZo3b562bt2qrVu3Srp8s7i9ECoAAACAAvj5+emuu+7S7Nmzdf78eZtpKSkpWrx4sR566KFi/yJ1w4YNtW3bNpu2H3/80VSNf/31l/bs2aNnn31Wd955p/WSLHsjVAAAAACFePPNN5WVlaWYmBht2rRJhw8fVkJCgu666y7VqlXrqvdD/N3QoUO1e/duPfPMM/rjjz/08ccfKz4+XpKKHUyuVLVqVfn5+entt9/Wvn37tH79eo0ePfqalmUGoQIAAAAoRIMGDbRt2zbVrVtXDz74oOrVq6chQ4aoY8eO2rJli6pVq1bsZYWFhWnp0qVatmyZmjRpojlz5lhHf3Jzc7um+pycnPTRRx9p+/btatSokUaNGmW9EdyeLEZx7zy5gaWnp8vHx0dnzpyRt7e3o8sBbkj2/tXV8uZG334AFduFCxd04MABhYWFyd3d3dHllCuTJ0/W3LlzdfjwYYfVUNTrU9zPwQwpCwAAANjJ7Nmz1bJlS/n5+enbb7/V1KlTNWLECEeXZRqhAgAAALCTvXv36oUXXlBaWppCQkL01FNPady4cY4uyzRCBQAAAGAn06dP1/Tp0x1dRqnjRm0AAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAMpAfHy8fH19HV2GXfA7FQAAAHCMuLgKsb7Dhw8rNjZWCQkJSk1NVVBQkLp3764JEybIz89PkhQaGqqRI0dq5MiRpVdvBcKZCgAAAKAQ+/fvV4sWLbR37159+OGH2rdvn+bOnat169apTZs2SktLs3tNFy9etPs6r4ZQAQAAABRi+PDhcnV11Zo1axQdHa2QkBB17txZX331lY4cOaLx48erQ4cOOnjwoEaNGiWLxSKLxWKzjNWrVysiIkJeXl665557dOzYMZvp77zzjiIiIuTu7q7w8HDNnj3bOi05OVkWi0VLlixRdHS03N3dtXjxYrtse0lw+RMAAABQgLS0NK1evVqTJ0+Wh4eHzbTAwED17dtXS5Ys0d69exUZGakhQ4Zo8ODBNv0yMzP16quvatGiRXJyctIjjzyip59+2hoMFi9erAkTJujNN99Us2bNtHPnTg0ePFiVK1dW//79rcsZO3asXnvtNTVr1kzu7u5lv/ElRKgAAAAACrB3714ZhqGIiIgCp0dEROjUqVPKycmRs7OzqlSposDAQJs+Fy9e1Ny5c1WvXj1J0ogRIzRp0iTr9NjYWL322mvq2bOnJCksLEy///673nrrLZtQMXLkSGuf8ohQAQAAABTBMIxrntfT09MaKCQpKChIJ06ckCRlZGQoKSlJjz/+uM0ZjkuXLsnHx8dmOS1atLjmGuyBUAEAAAAUoH79+rJYLEpMTFSPHj3yTU9MTFTVqlUVEBBQ6DJcXFxsnlssFmtIOXfunCRp3rx5at26tU0/Z2dnm+eVK1e+pm2wF27UBgAAAArg5+enu+66S7Nnz9b58+dtpqWkpGjx4sV66KGHZLFY5OrqqpycnBItv0aNGqpZs6b279+v+vXr2zzCwsJKc1PKHKECAAAAKMSbb76prKwsxcTEaNOmTTp8+LASEhJ01113qVatWpo8ebKky79TsWnTJh05ckSpqanFXv7EiRM1ZcoUvf766/rjjz/066+/asGCBZo2bVpZbVKZIFQAAAAAhWjQoIG2bdumunXr6sEHH1S9evU0ZMgQdezYUVu2bFG1atUkSZMmTVJycrLq1atX5OVQVxo0aJDeeecdLViwQI0bN1Z0dLTi4+Mr3JkKi2HmzpMbRHp6unx8fHTmzBl5e3s7uhzghmTvH10tb2707QdQsV24cEEHDhxQWFhYuRwO9UZX1OtT3M/BnKkAAAAAYAqhAgAAAIApDCkL3Aiug2tnOmwsfNrGDnH2KgMAABSAMxUAAAAATCFUAAAAwC4YH6h8Ko3XhVABAACAMpX369DZ2dkOrgQFyczMlJT/179LgnsqAAAAUKYqVaokT09PnTx5Ui4uLnJy4nvt8sAwDGVmZurEiRPy9fW1hr9rQagAAABAmbJYLAoKCtKBAwd08OBBR5eDK/j6+iowMNDUMggVAAAAKHOurq5q0KABl0CVMy4uLqbOUOQhVAAAAMAunJyc+EXt6xQXtAEAAAAwhVABAAAAwBRCBQAAAABTKmSomDVrlkJDQ+Xu7q7WrVvrhx9+KLL/jBkz1LBhQ3l4eCg4OFijRo3ShQsX7FQtAAAAcH2rcKFiyZIlGj16tGJjY7Vjxw41bdpUMTExOnHiRIH9P/jgA40dO1axsbFKTEzUu+++qyVLlui///2vnSsHAAAArk8VLlRMmzZNgwcP1sCBA3XzzTdr7ty58vT01Pz58wvs/91336ldu3Z6+OGHFRoaqrvvvlt9+vS56tkNAAAAAMVToUJFdna2tm/frk6dOlnbnJyc1KlTJ23ZsqXAedq2bavt27dbQ8T+/fu1atUqdenSpdD1ZGVlKT093eYBAAAAoGAV6ncqUlNTlZOToxo1ati016hRQ7t37y5wnocfflipqalq3769DMPQpUuX9M9//rPIy5+mTJmiiRMnlmrtAAAAwPWqQp2puBYbN27Uiy++qNmzZ2vHjh1atmyZVq5cqeeff77QecaNG6czZ85YH4cPH7ZjxQAAAEDFUqHOVPj7+8vZ2VnHjx+3aT9+/LgCAwMLnOe5557To48+qkGDBkmSGjdurIyMDA0ZMkTjx4+Xk1P+XOXm5iY3N7fS3wAAAADgOlShzlS4urqqefPmWrdunbUtNzdX69atU5s2bQqcJzMzM19wcHZ2liQZhlF2xQIAAAA3iAp1pkKSRo8erf79+6tFixZq1aqVZsyYoYyMDA0cOFCS1K9fP9WqVUtTpkyRJHXt2lXTpk1Ts2bN1Lp1a+3bt0/PPfecunbtag0XAAAAAK5dhQsVDz30kE6ePKkJEyYoJSVFkZGRSkhIsN68fejQIZszE88++6wsFoueffZZHTlyRAEBAeratasmT57sqE0AAAAArisWg2uArio9PV0+Pj46c+aMvL29HV0OUHJxcY6uwLSNG4uY1iHOXmXAQa6DQxgAKqTifg6uUPdUAAAAACh/CBUAAAAATCFUAAAAADClwt2oDQBX6rAxztEllDnuGwEAlGecqQAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgSiVHFwCgeOLirn3eDhtLqwoAAID8OFMBAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEyp5OgCAABX12FjnKNLKHMbO8Q5ugQAwDXiTAUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADClQoaKWbNmKTQ0VO7u7mrdurV++OGHIvufPn1aw4cPV1BQkNzc3HTTTTdp1apVdqoWAAAAuL5VcnQBJbVkyRKNHj1ac+fOVevWrTVjxgzFxMRoz549ql69er7+2dnZuuuuu1S9enUtXbpUtWrV0sGDB+Xr62v/4gEAAIDrUIULFdOmTdPgwYM1cOBASdLcuXO1cuVKzZ8/X2PHjs3Xf/78+UpLS9N3330nFxcXSVJoaKg9SwYAAACuaxXq8qfs7Gxt375dnTp1srY5OTmpU6dO2rJlS4HzfP7552rTpo2GDx+uGjVqqFGjRnrxxReVk5Njr7IBAACA61qFOlORmpqqnJwc1ahRw6a9Ro0a2r17d4Hz7N+/X+vXr1ffvn21atUq7du3T8OGDdPFixcVGxtb4DxZWVnKysqyPk9PTy+9jQAAAACuMxXqTMW1yM3NVfXq1fX222+refPmeuihhzR+/HjNnTu30HmmTJkiHx8f6yM4ONiOFQMAAAAVS4U6U+Hv7y9nZ2cdP37cpv348eMKDAwscJ6goCC5uLjI2dnZ2hYREaGUlBRlZ2fL1dU13zzjxo3T6NGjrc/T09MJFgAAQIqLc3QFZet63z6UmQp1psLV1VXNmzfXunXrrG25ublat26d2rRpU+A87dq10759+5Sbm2tt++OPPxQUFFRgoJAkNzc3eXt72zwAAAAAFKxChQpJGj16tObNm6eFCxcqMTFR//rXv5SRkWEdDapfv34aN26ctf+//vUvpaWl6cknn9Qff/yhlStX6sUXX9Tw4cMdtQkAAADAdaVCXf4kSQ899JBOnjypCRMmKCUlRZGRkUpISLDevH3o0CE5Of3/rBQcHKzVq1dr1KhRatKkiWrVqqUnn3xSzzzzjKM2AQAAALiuVLhQIUkjRozQiBEjCpy2cePGfG1t2rTR999/X8ZVAQAAADemCnf5EwAAAIDyhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMKWSowsAAOCGEBfn6AoAoMxwpgIAAACAKXYLFfv377fXqgAAAADYkd1CRf369dWxY0e9//77unDhgr1WCwAAAKCM2S1U7NixQ02aNNHo0aMVGBiooUOH6ocffrDX6gEAAACUEbuFisjISM2cOVNHjx7V/PnzdezYMbVv316NGjXStGnTdPLkSXuVAgAAAKAU2f1G7UqVKqlnz5765JNP9PLLL2vfvn16+umnFRwcrH79+unYsWP2LgkAAACACXYPFdu2bdOwYcMUFBSkadOm6emnn1ZSUpLWrl2ro0eP6v7777d3SQAAAABMsNvvVEybNk0LFizQnj171KVLF7333nvq0qWLnJwu55qwsDDFx8crNDTUXiUBAAAAKAV2CxVz5szRY489pgEDBigoKKjAPtWrV9e7775rr5IAAAAAlAK7hYq1a9cqJCTEemYij2EYOnz4sEJCQuTq6qr+/fvbqyQAAAAApcBu91TUq1dPqamp+drT0tIUFhZmrzIAAAAAlDK7hQrDMApsP3funNzd3e1VBgAAAIBSVuaXP40ePVqSZLFYNGHCBHl6elqn5eTkaOvWrYqMjCzrMgAAAACUkTIPFTt37pR0+UzFr7/+KldXV+s0V1dXNW3aVE8//XRZlwEAAACgjJR5qNiwYYMkaeDAgZo5c6a8vb3LepUAAAAA7Mhuoz8tWLDAXqsCAAAAYEdlGip69uyp+Ph4eXt7q2fPnkX2XbZsWVmWAgAAAKCMlGmo8PHxkcVisf4/AABASW3c6OgKHK9DB0dXABStTEPF3y954vInAAAA4Ppkt9+pOH/+vDIzM63PDx48qBkzZmjNmjX2KgEAAABAGbBbqLj//vv13nvvSZJOnz6tVq1a6bXXXtP999+vOXPm2KsMAAAAAKXMbqFix44dioqKkiQtXbpUgYGBOnjwoN577z29/vrr9ioDAAAAQCmzW6jIzMxUlSpVJElr1qxRz5495eTkpNtuu00HDx60VxkAAAAASpndQkX9+vW1fPlyHT58WKtXr9bdd98tSTpx4gQ/iAcAAABUYHb78bsJEybo4Ycf1qhRo3TnnXeqTZs2ki6ftWjWrJm9ygAAlFMdNsYVPrGISQAAx7NbqOjdu7fat2+vY8eOqWnTptb2O++8Uz169LBXGQAAAABKmd1ChSQFBgYqMDDQpq1Vq1b2LAEAAABAKbNbqMjIyNBLL72kdevW6cSJE8rNzbWZvn//fnuVAgAAAKAU2S1UDBo0SF9//bUeffRRBQUFyWKx2GvVAAAAAMqQ3ULFl19+qZUrV6pdu3b2WiUAAAAAO7DbkLJVq1ZVtWrV7LU6AAAAAHZit1Dx/PPPa8KECcrMzLTXKgEAAADYgd0uf3rttdeUlJSkGjVqKDQ0VC4uLjbTd+zYYa9SAAAAAJQiu4WK7t2722tVAAAAAOzIbqEiNjbWXqsCAFxnNm50dAWO1aGDoysAgKLZ7Z4KSTp9+rTeeecdjRs3TmlpaZIuX/Z05MgRe5YBAAAAoBTZ7UzFL7/8ok6dOsnHx0fJyckaPHiwqlWrpmXLlunQoUN677337FUKAAAAgFJktzMVo0eP1oABA7R37165u7tb27t06aJNmzbZqwwAAAAApcxuoeLHH3/U0KFD87XXqlVLKSkp9ioDAAAAQCmzW6hwc3NTenp6vvY//vhDAQEB9ioDAAAAQCmzW6jo1q2bJk2apIsXL0qSLBaLDh06pGeeeUa9evWyVxkAAAAASpndQsVrr72mc+fOKSAgQOfPn1d0dLTq16+vKlWqaPLkyfYqAwAAAEAps9voTz4+Plq7dq2+/fZb/fzzzzp37pxuvfVWderUyV4lAAAAACgDdgkVubm5io+P17Jly5ScnCyLxaKwsDAFBgbKMAxZLBZ7lAEAAACgDJT55U+GYahbt24aNGiQjhw5osaNG+uWW27RwYMHNWDAAPXo0aOsSwAAAABQhsr8TEV8fLw2bdqkdevWqWPHjjbT1q9fr+7du+u9995Tv379yroUAAAAAGWgzM9UfPjhh/rvf/+bL1BI0h133KGxY8dq8eLFZV0GAAAAgDJS5qHil19+0T333FPo9M6dO+vnn38u6zIAAAAAlJEyDxVpaWmqUaNGodNr1KihU6dOlXUZAAAAAMpImYeKnJwcVapU+K0bzs7OunTpUlmXAQAAAKCMlPmN2oZhaMCAAXJzcytwelZWVlmXAAAAAKAMlXmo6N+//1X7MPITAACF27jR0RUAQNHKPFQsWLCgTJY7a9YsTZ06VSkpKWratKneeOMNtWrV6qrzffTRR+rTp4/uv/9+LV++vExqAwAAAG4kZX5PRVlYsmSJRo8erdjYWO3YsUNNmzZVTEyMTpw4UeR8ycnJevrppxUVFWWnSgEAAIDrX4UMFdOmTdPgwYM1cOBA3XzzzZo7d648PT01f/78QufJyclR3759NXHiRNWtW9eO1QIAAADXtwoXKrKzs7V9+3Z16tTJ2ubk5KROnTppy5Ythc43adIkVa9eXY8//vhV15GVlaX09HSbBwAAAICCVbhQkZqaqpycnHy/fVGjRg2lpKQUOM8333yjd999V/PmzSvWOqZMmSIfHx/rIzg42HTdAAAAwPWqwoWKkjp79qweffRRzZs3T/7+/sWaZ9y4cTpz5oz1cfjw4TKuEgAAAKi4ynz0p9Lm7+8vZ2dnHT9+3Kb9+PHjCgwMzNc/KSlJycnJ6tq1q7UtNzdXklSpUiXt2bNH9erVs5nHzc2t0N/VAAAAAGCrwoUKV1dXNW/eXOvWrVP37t0lXQ4J69at04gRI/L1Dw8P16+//mrT9uyzz+rs2bOaOXMmlzYBAIByz16/VbIxzj7rKam4OEdXgKupcKFCkkaPHq3+/furRYsWatWqlWbMmKGMjAwNHDhQ0uUf06tVq5amTJkid3d3NWrUyGZ+X19fScrXDgAAAKDkKmSoeOihh3Ty5ElNmDBBKSkpioyMVEJCgvXm7UOHDsnJ6bq/XQQAAAAoFypkqJCkESNGFHi5kyRtvMo5wvj4+NIvCAAAALhB8XU+AAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADClkqMLAAAAQPnQYWOco0soWFxpLqs0F4Y8nKkAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYUsnRBQAOFxfn6AqKpcNGR1cAAABQMM5UAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwpZKjCwCKIy6u7JbdYWPZLRsAAOBGwJkKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAphAoAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYUmFDxaxZsxQaGip3d3e1bt1aP/zwQ6F9582bp6ioKFWtWlVVq1ZVp06diuwPAAAAoPgqZKhYsmSJRo8erdjYWO3YsUNNmzZVTEyMTpw4UWD/jRs3qk+fPtqwYYO2bNmi4OBg3X333Tpy5IidKwcAAACuPxUyVEybNk2DBw/WwIEDdfPNN2vu3Lny9PTU/PnzC+y/ePFiDRs2TJGRkQoPD9c777yj3NxcrVu3zs6VAwAAANefChcqsrOztX37dnXq1Mna5uTkpE6dOmnLli3FWkZmZqYuXryoatWqlVWZAAAAwA2jkqMLKKnU1FTl5OSoRo0aNu01atTQ7t27i7WMZ555RjVr1rQJJn+XlZWlrKws6/P09PRrLxgAAAC4zlW4MxVmvfTSS/roo4/06aefyt3dvcA+U6ZMkY+Pj/URHBxs5yoBAACAiqPChQp/f385Ozvr+PHjNu3Hjx9XYGBgkfO++uqreumll7RmzRo1adKk0H7jxo3TmTNnrI/Dhw+XSu0AAADA9ajChQpXV1c1b97c5ibrvJuu27RpU+h8r7zyip5//nklJCSoRYsWRa7Dzc1N3t7eNg8AAAAABatw91RI0ujRo9W/f3+1aNFCrVq10owZM5SRkaGBAwdKkvr166datWppypQpkqSXX35ZEyZM0AcffKDQ0FClpKRIkry8vOTl5eWw7QAAAACuBxUyVDz00EM6efKkJkyYoJSUFEVGRiohIcF68/ahQ4fk5PT/T8LMmTNH2dnZ6t27t81yYmNjFRcXZ8/SAQAAgOtOhQwVkjRixAiNGDGiwGkbN260eZ6cnFz2BQEAAAA3qAp3TwUAAACA8oVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUyo5ugCUc3Fxjq5AktRho6MrAAAAQGE4UwEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMCUSo4uAAAAACjKxo2luKy40luWvcTFObqCq+NMBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMYUjZCsJRQ4l12OiY9QIAAKDi4EwFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTCBUAAAAATCFUAAAAADCFUAEAAADAFEIFAAAAAFMIFQAAAABMIVQAAAAAMIVQAQAAAMAUQgUAAAAAUwgVAAAAAEwhVAAAAAAwhVABAAAAwBRCBQAAAABTKmyomDVrlkJDQ+Xu7q7WrVvrhx9+KLL/J598ovDwcLm7u6tx48ZatWqVnSoFAAAArm8VMlQsWbJEo0ePVmxsrHbs2KGmTZsqJiZGJ06cKLD/d999pz59+ujxxx/Xzp071b17d3Xv3l2//fabnSsHAAAArj8VMlRMmzZNgwcP1sCBA3XzzTdr7ty58vT01Pz58wvsP3PmTN1zzz0aM2aMIiIi9Pzzz+vWW2/Vm2++aefKAQAAgOtPJUcXUFLZ2dnavn27xo0bZ21zcnJSp06dtGXLlgLn2bJli0aPHm3TFhMTo+XLlxfYPysrS1lZWdbnZ86ckSSlp6ebrP7a/a0cu8q45KAVAwAAlIGsLMd9nrtWDvwIav38axhGkf0qXKhITU1VTk6OatSoYdNeo0YN7d69u8B5UlJSCuyfkpJSYP8pU6Zo4sSJ+dqDg4OvsWoAAACUC9++5OgKSuylclDy2bNn5ePjU+j0Chcq7GHcuHE2ZzZyc3OVlpYmPz8/WSwWB1aGiiY9PV3BwcE6fPiwvL29HV0OKjCOJZQmjieUFo6l659hGDp79qxq1qxZZL8KFyr8/f3l7Oys48eP27QfP35cgYGBBc4TGBhYov5ubm5yc3OzafP19b32onHD8/b25s0WpYJjCaWJ4wmlhWPp+lbUGYo8Fe5GbVdXVzVv3lzr1q2ztuXm5mrdunVq06ZNgfO0adPGpr8krV27ttD+AAAAAIqvwp2pkKTRo0erf//+atGihVq1aqUZM2YoIyNDAwcOlCT169dPtWrV0pQpUyRJTz75pKKjo/Xaa6/p3nvv1UcffaRt27bp7bffduRmAAAAANeFChkqHnroIZ08eVITJkxQSkqKIiMjlZCQYL0Z+9ChQ3Jy+v8nYdq2basPPvhAzz77rP773/+qQYMGWr58uRo1auSoTcANws3NTbGxsfkupwNKimMJpYnjCaWFYwl5LMbVxocCAAAAgCJUuHsqAAAAAJQvhAoAAAAAphAqAAAAAJhCqAAAAABgCqECKCNZWVmKjIyUxWLRTz/9VGTfDh06yGKx2Dz++c9/2qdQlHslOZYuXLig4cOHy8/PT15eXurVq1e+H//Ejadbt24KCQmRu7u7goKC9Oijj+ro0aNFzsP7EgpzLccT703XP0IFUEb+85//XPUn7f9u8ODBOnbsmPXxyiuvlGF1qEhKciyNGjVKX3zxhT755BN9/fXXOnr0qHr27FnGFaK869ixoz7++GPt2bNH//vf/5SUlKTevXtfdT7el1CQazmeeG+6ARgASt2qVauM8PBwY9euXYYkY+fOnUX2j46ONp588km71IaKpSTH0unTpw0XFxfjk08+sbYlJiYakowtW7bYoVpUFJ999plhsViM7OzsQvvwvoTiutrxxHvTjYEzFUApO378uAYPHqxFixbJ09Oz2PMtXrxY/v7+atSokcaNG6fMzMwyrBIVQUmPpe3bt+vixYvq1KmTtS08PFwhISHasmVLWZaKCiQtLU2LFy9W27Zt5eLiUmRf3pdwNcU5nnhvujEQKoBSZBiGBgwYoH/+859q0aJFsed7+OGH9f7772vDhg0aN26cFi1apEceeaQMK0V5dy3HUkpKilxdXeXr62vTXqNGDaWkpJRBlahInnnmGVWuXFl+fn46dOiQPvvssyL7876EopTkeOK96cZAqACKYezYsfluWLzysXv3br3xxhs6e/asxo0bV6LlDxkyRDExMWrcuLH69u2r9957T59++qmSkpLKaIvgKGV9LOHGUdxjKc+YMWO0c+dOrVmzRs7OzurXr58Mwyh0+bwv3VjK+njC9c9icAQAV3Xy5En99ddfRfapW7euHnzwQX3xxReyWCzW9pycHDk7O6tv375auHBhsdaXkZEhLy8vJSQkKCYmxlTtKF/K8lhav3697rzzTp06dcrmG8E6depo5MiRGjVqVKltBxyvuMeSq6trvvY///xTwcHB+u6779SmTZtirY/3petbWR5PvDfdGCo5ugCgIggICFBAQMBV+73++ut64YUXrM+PHj2qmJgYLVmyRK1bty72+vKGDQ0KCipxrSjfyvJYat68uVxcXLRu3Tr16tVLkrRnzx4dOnSo2B8cUXEU91gqSG5urqTLwxUXF+9L17eyPJ54b7oxcKYCKEPJyckKCwvTzp07FRkZKUk6cuSI7rzzTr333ntq1aqVkpKS9MEHH6hLly7y8/PTL7/8olGjRql27dr6+uuvHbsBKDeKcyxJ0r/+9S+tWrVK8fHx8vb21r///W9J0nfffeeo0uFgW7du1Y8//qj27duratWqSkpK0nPPPafjx49r165dcnNz430JxXYtx5PEe9ONgDMVgJ1dvHhRe/bssY6i4urqqq+++kozZsxQRkaGgoOD1atXLz377LMOrhTl3ZXHkiRNnz5dTk5O6tWrl7KyshQTE6PZs2c7sEo4mqenp5YtW6bY2FhlZGQoKChI99xzj5599lm5ublJ4n0JxXctx5PEe9ONgDMVAAAAAExh9CcAAAAAphAqAAAAAJhCqAAAAABgCqECAAAAgCmECgAAAACmECoAAAAAmEKoAAAAAGAKoQIAAACAKYQKAAAAAKYQKgAAAACYQqgAAAAAYAqhAgAAAIAp/w/idEsw8AXtHQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "original_results.compare_plots(mrs_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "original_results.compare_ellipses(mrs_results, ylim = (-4000, 3000))" + ] + }, { "cell_type": "code", "execution_count": null, @@ -164,7 +427,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "dev-py3-12", "language": "python", "name": "python3" }, @@ -178,7 +441,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.2" } }, "nbformat": 4, diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index e20474773..6b44f1cbd 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -195,3 +195,227 @@ def all(self, keys=None): plt.tight_layout() plt.show() + + def plot_comparison(self, other_monte_carlo): + """ + Plot the histograms of the Monte Carlo simulation results. + + Parameters + ---------- + other_monte_carlo : MonteCarlo + MonteCarlo object which the current one will be compared to. + + Returns + ------- + None + """ + # TODO: understand why this validation is failing + # if not isinstance(other_monte_carlo, MonteCarlo): + # raise TypeError( + # "Argument 'other_monte_carlo' must be an MonteCarlo object!" + # ) + original_parameters_set = set(self.monte_carlo.processed_results.keys()) + other_parameters_set = set(other_monte_carlo.processed_results.keys()) + intersection_set = original_parameters_set.intersection(other_parameters_set) + + fill_colors = ["red", "blue"] + for key in intersection_set: + # Create figure with GridSpec + fig = plt.figure(figsize=(8, 8)) + gs = fig.add_gridspec(2, 1, height_ratios=[1, 3]) + + # Create subplots using gridspec + ax1 = fig.add_subplot(gs[0]) + ax2 = fig.add_subplot(gs[1]) + + # Plot boxplot + bp = ax1.boxplot( + [other_monte_carlo.results[key], self.monte_carlo.results[key]], + vert=False, + tick_labels=["Other", "Original"], + patch_artist=True + ) + for patch, color in zip(bp['boxes'], fill_colors): + patch.set_facecolor(color) + ax1.set_title(f"Box Plot of {key}") + + # Plot histogram + ax2.hist(self.monte_carlo.results[key], alpha=0.5, color="blue", label="Original", density=True) + ax2.hist(other_monte_carlo.results[key], alpha=0.5, color="red", label="Other", density=True) + ax2.set_title(f"Histogram of {key}") + ax2.set_ylabel("Density") + + plt.tight_layout() + plt.legend() + plt.show() + + # pylint: disable=too-many-statements + def ellipses_comparison( + self, + other_monte_carlo, + image=None, + perimeter_size=3000, + xlim=(-3000, 3000), + ylim=(-3000, 3000), + save=False, + ): + """ + Plot the error ellipses for the apogee and impact points of the rocket. + + Parameters + ---------- + other_monte_carlo : MonteCarlo + MonteCarlo object which the current one will be compared to. + image : str, optional + Path to the background image, usually a map of the launch site. + actual_landing_point : tuple, optional + Actual landing point of the rocket in (x, y) meters. + perimeter_size : int, optional + Size of the perimeter to be plotted. Default is 3000. + xlim : tuple, optional + Limits of the x-axis. Default is (-3000, 3000). Values in meters. + ylim : tuple, optional + 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 + """ + # TODO: understand why this validation is failing + # if not isinstance(other_monte_carlo, MonteCarlo): + # raise TypeError( + # "Argument 'other_monte_carlo' must be an MonteCarlo object!" + # ) + + imageio = import_optional_dependency("imageio") + + # Import background map + if image is not None: + try: + img = imageio.imread(image) + except FileNotFoundError as e: + raise FileNotFoundError( + "The image file was not found. Please check the path." + ) from e + + try: + original_apogee_x = np.array(self.monte_carlo.results["apogee_x"]) + original_apogee_y = np.array(self.monte_carlo.results["apogee_y"]) + other_apogee_x = np.array(other_monte_carlo.results["apogee_x"]) + other_apogee_y = np.array(other_monte_carlo.results["apogee_y"]) + except KeyError: + print("No apogee data found. Skipping apogee ellipses.") + original_apogee_x = np.array([]) + original_apogee_y = np.array([]) + other_apogee_x = np.array([]) + other_apogee_y = np.array([]) + try: + original_impact_x = np.array(self.monte_carlo.results["x_impact"]) + original_impact_y = np.array(self.monte_carlo.results["y_impact"]) + other_impact_x = np.array(other_monte_carlo.results["x_impact"]) + other_impact_y = np.array(other_monte_carlo.results["y_impact"]) + except KeyError: + print("No impact data found. Skipping impact ellipses.") + original_impact_x = np.array([]) + original_impact_y = np.array([]) + other_impact_x = np.array([]) + other_impact_y = np.array([]) + + if len(original_apogee_x) == 0 and len(original_impact_x) == 0: + raise ValueError("No apogee or impact data found. Cannot plot ellipses.") + + original_impact_ellipses, original_apogee_ellipses = generate_monte_carlo_ellipses( + original_apogee_x, + original_apogee_y, + original_impact_x, + original_impact_y, + apogee_rgb=(0, 1, 0), + impact_rgb=(0, 0, 1) + ) + + other_impact_ellipses, other_apogee_ellipses = generate_monte_carlo_ellipses( + other_apogee_x, + other_apogee_y, + other_impact_x, + other_impact_y, + apogee_rgb=(174 / 255, 159 / 255, 15 / 255), + impact_rgb=(102 / 255, 23 / 255, 204 / 255) + ) + + # Create plot figure + plt.figure(figsize=(8, 6), dpi=150) + ax = plt.subplot(111) + + # Draw ellipses and points for original monte carlo + for ell in original_impact_ellipses: + ax.add_artist(ell) + for ell in original_apogee_ellipses: + ax.add_artist(ell) + + plt.scatter(0, 0, s=30, marker="*", color="black", label="Launch Point") + plt.scatter( + original_apogee_x, original_apogee_y, s=5, marker="^", color="green", label="Original Apogee" + ) + plt.scatter( + original_impact_x, + original_impact_y, + s=5, + marker="v", + color="blue", + label="Original Landing Point", + ) + + # Draw ellipses and points for other monte carlo + for ell in other_impact_ellipses: + ax.add_artist(ell) + for ell in other_apogee_ellipses: + ax.add_artist(ell) + + plt.scatter( + other_apogee_x, other_apogee_y, s=5, marker="^", color="#ae9f0f", label="Other Apogee" + ) + plt.scatter( + other_impact_x, + other_impact_y, + s=5, + marker="v", + color="#6617cc", + label="Other Landing Point", + ) + + plt.legend() + ax.set_title("1$\\sigma$, 2$\\sigma$ and 3$\\sigma$ Monte Carlo Ellipses") + ax.set_ylabel("North (m)") + ax.set_xlabel("East (m)") + + # Add background image to plot + # TODO: In the future, integrate with other libraries to plot the map (e.g. cartopy, ee, etc.) + # You can translate the basemap by changing dx and dy (in meters) + dx = 0 + dy = 0 + if image is not None: + plt.imshow( + img, + zorder=0, + extent=[ + -perimeter_size - dx, + perimeter_size - dx, + -perimeter_size - dy, + 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) + + if save: + plt.savefig( + f"{self.monte_carlo.filename}.png", bbox_inches="tight", pad_inches=0 + ) + else: + plt.show() diff --git a/rocketpy/prints/monte_carlo_prints.py b/rocketpy/prints/monte_carlo_prints.py index ad2c5c402..a06d8c5bc 100644 --- a/rocketpy/prints/monte_carlo_prints.py +++ b/rocketpy/prints/monte_carlo_prints.py @@ -34,3 +34,61 @@ def all(self): print( f"{key:>25} {'N/A':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15}" ) + + def print_comparison(self, other_monte_carlo): + """Print the mean and standard deviation of each parameter in the results + dictionary or of the variables passed as argument. + + Parameters + ---------- + other_monte_carlo : MonteCarlo + MonteCarlo object which the current one will be compared to. + + Returns + ------- + None + + """ + # TODO: understand why this validation is failing + # if not isinstance(other_monte_carlo, MonteCarlo): + # raise TypeError( + # "Argument 'other_monte_carlo' must be an MonteCarlo object!" + # ) + original_parameters_set = set(self.monte_carlo.processed_results.keys()) + other_parameters_set = set(other_monte_carlo.processed_results.keys()) + intersection_set = original_parameters_set.intersection(other_parameters_set) + symmetric_diff_set = original_parameters_set.symmetric_difference(other_parameters_set) + print("Comparison of Monte Carlo Simulation by RocketPy") + print("Original data Source: ", self.monte_carlo.filename) + print("Comparison data Source: ", other_monte_carlo.filename) + print("Original number of simulations: ", self.monte_carlo.num_of_loaded_sims) + print("Comparison number of simulations: ", other_monte_carlo.num_of_loaded_sims) + if len(symmetric_diff_set) > 0: + print( + f"The following parameters were not in both simulations: {symmetric_diff_set}\n" + ) + print("Results: \n") + print( + f"{'Parameter':>35} {'Source':>15} {'Mean':>15} {'Median':>15} {'Std. Dev.':>15} {'95% PI Lower':>15} {'95% PI Upper':>15}" + ) + print("-" * 140) + for parameter in intersection_set: + original_value = self.monte_carlo.processed_results[parameter] + try: + print( + f"{parameter:>35} {'Original':>15} {original_value[0]:>15.3f} {original_value[1]:>15.3f} {original_value[2]:>15.3f} {original_value[3]:>15.3f} {original_value[4]:>15.3f}" + ) + except TypeError: + print( + f"{parameter:>35} {'Original':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15}" + ) + + other_value = other_monte_carlo.processed_results[parameter] + try: + print( + f"{parameter:>35} {'Other':>15} {other_value[0]:>15.3f} {other_value[1]:>15.3f} {other_value[2]:>15.3f} {other_value[3]:>15.3f} {other_value[4]:>15.3f}" + ) + except TypeError: + print( + f"{parameter:>35} {'Other':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15} {'N/A':>15}" + ) diff --git a/rocketpy/simulation/monte_carlo.py b/rocketpy/simulation/monte_carlo.py index 40b13c2e3..c31c33764 100644 --- a/rocketpy/simulation/monte_carlo.py +++ b/rocketpy/simulation/monte_carlo.py @@ -1018,3 +1018,51 @@ def all_info(self): self.info() self.plots.ellipses() self.plots.all() + + def compare_info(self, other_monte_carlo): + """ + Prints the comparison of the information of the Monte Carlo simulation + against the information of another Monte Carlo simulation. + + Parameters + ---------- + other_monte_carlo : MonteCarlo + MonteCarlo object which the current one will be compared to. + + Returns + ------- + None + """ + self.prints.print_comparison(other_monte_carlo) + + def compare_plots(self, other_monte_carlo): + """ + Plots the comparison of the information of the Monte Carlo simulation + against the information of another Monte Carlo simulation. + + Parameters + ---------- + other_monte_carlo : MonteCarlo + MonteCarlo object which the current one will be compared to. + + Returns + ------- + None + """ + self.plots.plot_comparison(other_monte_carlo) + + def compare_ellipses(self, other_monte_carlo, **kwargs): + """ + Plots the comparison of the ellipses of the Monte Carlo simulation + against the ellipses of another Monte Carlo simulation. + + Parameters + ---------- + other_monte_carlo : MonteCarlo + MonteCarlo object which the current one will be compared to. + + Returns + ------- + None + """ + self.plots.ellipses_comparison(other_monte_carlo, **kwargs) diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index e1e63893e..ddb229be9 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -105,7 +105,8 @@ def __setup_input(self): f"the monte carlo input file {input_filename}!" ) from e - input_file.close() + finally: + input_file.close() def __load_output(self): """Loads output information from monte carlo in a SampleInformation @@ -135,13 +136,15 @@ def __load_output(self): "An error occurred while reading " f"the monte carlo output file {output_filename}!" ) from e + + finally: + output_file.close() + if self.original_sample_size > sample_size_output: raise ValueError( "Monte carlo output file has fewer lines than the input file!" ) - output_file.close() - def __validate_distribution_dict(self, distribution_dict): """Checks that the variables passed in the distribution dictionary were in the input file. @@ -197,9 +200,10 @@ def sample(self, distribution_dict): "output files" ) from e - mrs_input_file.close() - mrs_output_file.close() - mrs_error_file.close() + finally: + mrs_input_file.close() + mrs_output_file.close() + mrs_error_file.close() def __setup_probabilities(self, distribution_dict): """Computes the probability ratio, probability ratio supremum and acceptance From 53b096d9cb96d85805515963b1893f0f22e797ca Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Sun, 23 Feb 2025 18:31:50 -0300 Subject: [PATCH 05/18] MNT: add MultivariateRejectionSampler class to inits and apply format --- docs/notebooks/test_mrs.ipynb | 11 ++-- rocketpy/__init__.py | 2 +- rocketpy/plots/monte_carlo_plots.py | 52 ++++++++++++++----- rocketpy/prints/monte_carlo_prints.py | 8 ++- rocketpy/simulation/__init__.py | 1 + .../multivariate_rejection_sampler.py | 2 +- 6 files changed, 53 insertions(+), 23 deletions(-) diff --git a/docs/notebooks/test_mrs.ipynb b/docs/notebooks/test_mrs.ipynb index 558189ac0..90e7d5acd 100644 --- a/docs/notebooks/test_mrs.ipynb +++ b/docs/notebooks/test_mrs.ipynb @@ -33,12 +33,13 @@ "metadata": {}, "outputs": [], "source": [ + "import numpy as np\n", + "from scipy.stats import norm\n", + "\n", + "from rocketpy import MonteCarlo\n", "from rocketpy.simulation.multivariate_rejection_sampler import (\n", " MultivariateRejectionSampler,\n", - ")\n", - "from rocketpy import MonteCarlo\n", - "from scipy.stats import norm\n", - "import numpy as np" + ")" ] }, { @@ -414,7 +415,7 @@ } ], "source": [ - "original_results.compare_ellipses(mrs_results, ylim = (-4000, 3000))" + "original_results.compare_ellipses(mrs_results, ylim=(-4000, 3000))" ] }, { diff --git a/rocketpy/__init__.py b/rocketpy/__init__.py index 539b8b2cb..4fd3a4e14 100644 --- a/rocketpy/__init__.py +++ b/rocketpy/__init__.py @@ -42,7 +42,7 @@ ) from .sensitivity import SensitivityModel from .sensors import Accelerometer, Barometer, GnssReceiver, Gyroscope -from .simulation import Flight, MonteCarlo +from .simulation import Flight, MonteCarlo, MultivariateRejectionSampler from .stochastic import ( StochasticEllipticalFins, StochasticEnvironment, diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 6b44f1cbd..03837e85c 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -233,15 +233,27 @@ def plot_comparison(self, other_monte_carlo): [other_monte_carlo.results[key], self.monte_carlo.results[key]], vert=False, tick_labels=["Other", "Original"], - patch_artist=True + patch_artist=True, ) - for patch, color in zip(bp['boxes'], fill_colors): + for patch, color in zip(bp["boxes"], fill_colors): patch.set_facecolor(color) ax1.set_title(f"Box Plot of {key}") # Plot histogram - ax2.hist(self.monte_carlo.results[key], alpha=0.5, color="blue", label="Original", density=True) - ax2.hist(other_monte_carlo.results[key], alpha=0.5, color="red", label="Other", density=True) + ax2.hist( + self.monte_carlo.results[key], + alpha=0.5, + color="blue", + label="Original", + density=True, + ) + ax2.hist( + other_monte_carlo.results[key], + alpha=0.5, + color="red", + label="Other", + density=True, + ) ax2.set_title(f"Histogram of {key}") ax2.set_ylabel("Density") @@ -327,13 +339,15 @@ def ellipses_comparison( if len(original_apogee_x) == 0 and len(original_impact_x) == 0: raise ValueError("No apogee or impact data found. Cannot plot ellipses.") - original_impact_ellipses, original_apogee_ellipses = generate_monte_carlo_ellipses( - original_apogee_x, - original_apogee_y, - original_impact_x, - original_impact_y, - apogee_rgb=(0, 1, 0), - impact_rgb=(0, 0, 1) + original_impact_ellipses, original_apogee_ellipses = ( + generate_monte_carlo_ellipses( + original_apogee_x, + original_apogee_y, + original_impact_x, + original_impact_y, + apogee_rgb=(0, 1, 0), + impact_rgb=(0, 0, 1), + ) ) other_impact_ellipses, other_apogee_ellipses = generate_monte_carlo_ellipses( @@ -342,7 +356,7 @@ def ellipses_comparison( other_impact_x, other_impact_y, apogee_rgb=(174 / 255, 159 / 255, 15 / 255), - impact_rgb=(102 / 255, 23 / 255, 204 / 255) + impact_rgb=(102 / 255, 23 / 255, 204 / 255), ) # Create plot figure @@ -357,7 +371,12 @@ def ellipses_comparison( plt.scatter(0, 0, s=30, marker="*", color="black", label="Launch Point") plt.scatter( - original_apogee_x, original_apogee_y, s=5, marker="^", color="green", label="Original Apogee" + original_apogee_x, + original_apogee_y, + s=5, + marker="^", + color="green", + label="Original Apogee", ) plt.scatter( original_impact_x, @@ -375,7 +394,12 @@ def ellipses_comparison( ax.add_artist(ell) plt.scatter( - other_apogee_x, other_apogee_y, s=5, marker="^", color="#ae9f0f", label="Other Apogee" + other_apogee_x, + other_apogee_y, + s=5, + marker="^", + color="#ae9f0f", + label="Other Apogee", ) plt.scatter( other_impact_x, diff --git a/rocketpy/prints/monte_carlo_prints.py b/rocketpy/prints/monte_carlo_prints.py index a06d8c5bc..0f99a401f 100644 --- a/rocketpy/prints/monte_carlo_prints.py +++ b/rocketpy/prints/monte_carlo_prints.py @@ -57,12 +57,16 @@ def print_comparison(self, other_monte_carlo): original_parameters_set = set(self.monte_carlo.processed_results.keys()) other_parameters_set = set(other_monte_carlo.processed_results.keys()) intersection_set = original_parameters_set.intersection(other_parameters_set) - symmetric_diff_set = original_parameters_set.symmetric_difference(other_parameters_set) + symmetric_diff_set = original_parameters_set.symmetric_difference( + other_parameters_set + ) print("Comparison of Monte Carlo Simulation by RocketPy") print("Original data Source: ", self.monte_carlo.filename) print("Comparison data Source: ", other_monte_carlo.filename) print("Original number of simulations: ", self.monte_carlo.num_of_loaded_sims) - print("Comparison number of simulations: ", other_monte_carlo.num_of_loaded_sims) + print( + "Comparison number of simulations: ", other_monte_carlo.num_of_loaded_sims + ) if len(symmetric_diff_set) > 0: print( f"The following parameters were not in both simulations: {symmetric_diff_set}\n" diff --git a/rocketpy/simulation/__init__.py b/rocketpy/simulation/__init__.py index b1aecdd99..6b98fdcf4 100644 --- a/rocketpy/simulation/__init__.py +++ b/rocketpy/simulation/__init__.py @@ -1,3 +1,4 @@ from .flight import Flight from .flight_data_importer import FlightDataImporter from .monte_carlo import MonteCarlo +from .multivariate_rejection_sampler import MultivariateRejectionSampler diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index ddb229be9..2d23e3b1f 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -119,7 +119,7 @@ def __load_output(self): output_file = open(output_filename, "r+", encoding="utf-8") except FileNotFoundError as e: raise FileNotFoundError( - f"Output file from monte carlo {output_filename} " "not found!" + f"Output file from monte carlo {output_filename} not found!" ) from e try: From 9787a17063d91dc7011236a6b3a473f610056a8e Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Mon, 24 Feb 2025 15:37:28 -0300 Subject: [PATCH 06/18] DOC: writting .rst documentation for MRS --- .../mrs.errors.txt | 0 .../mrs.inputs.txt | 116 +++++ .../mrs.outputs.txt | 116 +++++ docs/notebooks/test_mrs.ipynb | 450 ------------------ .../classes/MultivariateRejectionSampler.rst | 5 + docs/reference/index.rst | 1 + docs/user/index.rst | 3 +- docs/user/mrs.rst | 218 +++++++++ 8 files changed, 458 insertions(+), 451 deletions(-) create mode 100644 docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt create mode 100644 docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt create mode 100644 docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt delete mode 100644 docs/notebooks/test_mrs.ipynb create mode 100644 docs/reference/classes/MultivariateRejectionSampler.rst create mode 100644 docs/user/mrs.rst diff --git a/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt b/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt new file mode 100644 index 000000000..e69de29bb diff --git a/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt b/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt new file mode 100644 index 000000000..0d68c2376 --- /dev/null +++ b/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt @@ -0,0 +1,116 @@ +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 6, "radius": 0.06350803185536065, "mass": 15.321391102645253, "I_11_without_motor": 6.321, "I_22_without_motor": 6.318074651079169, "I_33_without_motor": 0.02231558279750141, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.796421153818757, "trigger": 800, "sampling_rate": 105, "lag": 1.2889273678634483, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9394597068963542, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4863408840421357, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5051.334409023799, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032456100097439426, "grain_number": 5, "grain_density": 1791.4919156464077, "grain_outer_radius": 0.03336766084887191, "grain_initial_inner_radius": 0.015859570445466348, "grain_initial_height": 0.11833708900926163, "grain_separation": 0.005520442830446927, "grains_center_of_mass_position": 0.39720688235605084, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00044613640497872, "throat_radius": 0.010531081211607219, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255876687441445}], "aerodynamic_surfaces": [{"length": 0.5575481869662148, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133894177473017]}, {"n": 4, "root_chord": 0.11988155918352632, "tip_chord": 0.05955433102562337, "span": 0.11002328692729561, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.049681091705158]}, {"top_radius": 0.06350056929758974, "bottom_radius": 0.0431795835697226, "length": 0.061288317308863575, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7011692212916728, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6163152348259862, "upper_button_position": 0.08485398646568665}], "rail_length": 5, "inclination": 84.47045493851068, "heading": 53.19885912092882} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 4, "radius": 0.0634923426395744, "mass": 15.186541205570112, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32969439703265, "I_33_without_motor": 0.031044527733126107, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.101304635322004, "trigger": 800, "sampling_rate": 105, "lag": 1.449152162843732, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0863326011878054, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5807386414953863, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6334.120250525818, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03348962524847486, "grain_number": 5, "grain_density": 1767.1073179570512, "grain_outer_radius": 0.032394751101825256, "grain_initial_inner_radius": 0.01504361534472906, "grain_initial_height": 0.12012668656538848, "grain_separation": 0.00515318449366391, "grains_center_of_mass_position": 0.39673404428016396, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0016859023790911862, "throat_radius": 0.011074908888687778, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254658376991242}], "aerodynamic_surfaces": [{"length": 0.5578223347296872, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1350307518657035]}, {"n": 4, "root_chord": 0.1203679293308533, "tip_chord": 0.059800875760536006, "span": 0.1091254204553351, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0488985452032389]}, {"top_radius": 0.06453827868465159, "bottom_radius": 0.0431198447535788, "length": 0.05964898322815028, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7012333719890909, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173871081166957, "upper_button_position": 0.08384626387239513}], "rail_length": 5, "inclination": 85.13902756092337, "heading": 52.08505981979775} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 16, "radius": 0.0635005371350456, "mass": 15.106582026573095, "I_11_without_motor": 6.321, "I_22_without_motor": 6.314365322306628, "I_33_without_motor": 0.047195635278228606, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.96009910422362, "trigger": 800, "sampling_rate": 105, "lag": 1.5014289998461325, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.928407162356345, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6001609880261682, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6241.821063933692, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033005608774528676, "grain_number": 5, "grain_density": 1833.9715498192554, "grain_outer_radius": 0.03303690853285959, "grain_initial_inner_radius": 0.015259991315133756, "grain_initial_height": 0.11921229192845037, "grain_separation": 0.0055318464522216, "grains_center_of_mass_position": 0.3950031401720469, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0009725665382717565, "throat_radius": 0.011294215263843456, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2545682392417146}], "aerodynamic_surfaces": [{"length": 0.5592118508676353, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1356073437435332]}, {"n": 4, "root_chord": 0.11984775443132953, "tip_chord": 0.05936097203918026, "span": 0.11039507555701751, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0508734335083847]}, {"top_radius": 0.06287906388966444, "bottom_radius": 0.043985985652853866, "length": 0.06067611091499706, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.701079186103225, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6185283287657592, "upper_button_position": 0.0825508573374657}], "rail_length": 5, "inclination": 85.23440818045665, "heading": 54.519967259401874} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 23, "radius": 0.06350088814734572, "mass": 15.687956793335713, "I_11_without_motor": 6.321, "I_22_without_motor": 6.336839789987341, "I_33_without_motor": 0.028988646489893646, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.982092676678759, "trigger": 800, "sampling_rate": 105, "lag": 1.3051455503803195, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0925632242929975, "trigger": "apogee", "sampling_rate": 105, "lag": 1.33808714514536, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4726.245950715227, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03359211884417262, "grain_number": 5, "grain_density": 1814.7129649641959, "grain_outer_radius": 0.03357420928819635, "grain_initial_inner_radius": 0.014461406772901576, "grain_initial_height": 0.12103608837837558, "grain_separation": 0.005180186940637563, "grains_center_of_mass_position": 0.3957081975153179, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.002383629196510536, "throat_radius": 0.010547659147086177, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2552427433847064}], "aerodynamic_surfaces": [{"length": 0.5595193024772361, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1330576937993402]}, {"n": 4, "root_chord": 0.1200999445781866, "tip_chord": 0.06118440239649141, "span": 0.11036846785415123, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.050574513578203]}, {"top_radius": 0.06368865651996705, "bottom_radius": 0.044099377434149246, "length": 0.058451866171339795, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997087894637934, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6195920415929042, "upper_button_position": 0.0801167478708893}], "rail_length": 5, "inclination": 84.97780983300318, "heading": 50.32009850038174} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 27, "radius": 0.06350183797455561, "mass": 15.87574952287981, "I_11_without_motor": 6.321, "I_22_without_motor": 6.303909335567725, "I_33_without_motor": 0.031204515788468067, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.20861081760533, "trigger": 800, "sampling_rate": 105, "lag": 1.4428882238217398, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8895257753015001, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7685807103946203, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6885.639331409522, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03250370190056724, "grain_number": 5, "grain_density": 1825.884563566716, "grain_outer_radius": 0.03323824319966411, "grain_initial_inner_radius": 0.014766901006896017, "grain_initial_height": 0.11836322594823653, "grain_separation": 0.005510123299339129, "grains_center_of_mass_position": 0.39653471390971057, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0012556198042742897, "throat_radius": 0.012334504482416634, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2545173835983094}], "aerodynamic_surfaces": [{"length": 0.5585796710933958, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1331704003460792]}, {"n": 4, "root_chord": 0.1201301284919981, "tip_chord": 0.06021996242563409, "span": 0.10888606828771016, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0471822676170683]}, {"top_radius": 0.06297340635893019, "bottom_radius": 0.04299308970247506, "length": 0.05803218708416568, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7012526216778054, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.617361647490302, "upper_button_position": 0.08389097418750346}], "rail_length": 5, "inclination": 84.17690533552943, "heading": 53.657314304656595} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 16, "radius": 0.06350252847592282, "mass": 14.554626267873774, "I_11_without_motor": 6.321, "I_22_without_motor": 6.320014393950434, "I_33_without_motor": 0.02978318505834989, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.809099315429796, "trigger": 800, "sampling_rate": 105, "lag": 1.435172682390572, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9661283642956846, "trigger": "apogee", "sampling_rate": 105, "lag": 1.0908194734007017, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7627.410184249112, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03181505461373091, "grain_number": 5, "grain_density": 1809.0171892348033, "grain_outer_radius": 0.03330315693468259, "grain_initial_inner_radius": 0.014336431082618886, "grain_initial_height": 0.12006289130189998, "grain_separation": 0.004307751767983378, "grains_center_of_mass_position": 0.39565554582103846, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00029326744719994076, "throat_radius": 0.011045581586300398, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2550074925862347}], "aerodynamic_surfaces": [{"length": 0.5587374419774356, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1346864242350938]}, {"n": 4, "root_chord": 0.11966494757566067, "tip_chord": 0.06043914775071417, "span": 0.110173410278682, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0482419734272284]}, {"top_radius": 0.06361223404913431, "bottom_radius": 0.04441213943878098, "length": 0.06031094064657681, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7004638353292927, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.616080438488119, "upper_button_position": 0.08438339684117369}], "rail_length": 5, "inclination": 85.31564942707135, "heading": 51.731722972868745} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 18, "radius": 0.06348749078905755, "mass": 15.274027636681094, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3056411973123305, "I_33_without_motor": 0.026210549348132318, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.889025425866114, "trigger": 800, "sampling_rate": 105, "lag": 1.488251498047699, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.1197674160601925, "trigger": "apogee", "sampling_rate": 105, "lag": 1.368366805211293, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6592.2157994782465, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03308605707134015, "grain_number": 5, "grain_density": 1796.3751731100065, "grain_outer_radius": 0.03308615810558528, "grain_initial_inner_radius": 0.015317995925855062, "grain_initial_height": 0.1192577099620557, "grain_separation": 0.005308100796681196, "grains_center_of_mass_position": 0.3965821036092778, "center_of_dry_mass_position": 0.317, "nozzle_position": 3.82008057787502e-05, "throat_radius": 0.010918433237017845, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.256142053636198}], "aerodynamic_surfaces": [{"length": 0.5573179150222657, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1354945971977657]}, {"n": 4, "root_chord": 0.12009501983146434, "tip_chord": 0.059321690994762456, "span": 0.10981054208765459, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0493722444849265]}, {"top_radius": 0.0634981444039416, "bottom_radius": 0.0424284557599094, "length": 0.06078217002823246, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997359937622002, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6167639468311972, "upper_button_position": 0.08297204693100302}], "rail_length": 5, "inclination": 83.25414857033617, "heading": 53.540889403739} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 9, "radius": 0.06349548448024785, "mass": 14.966201991043633, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3326064483970335, "I_33_without_motor": 0.03150658319946799, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.923681695232858, "trigger": 800, "sampling_rate": 105, "lag": 1.5500092224506672, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0425269447758416, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5510097362665025, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7273.673730718726, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03343837072141842, "grain_number": 5, "grain_density": 1802.9948737500492, "grain_outer_radius": 0.032391827913907975, "grain_initial_inner_radius": 0.015040686596184153, "grain_initial_height": 0.11842278684319403, "grain_separation": 0.004218582411143555, "grains_center_of_mass_position": 0.397666578233816, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00155681239484704, "throat_radius": 0.01101023301487878, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255162688850939}], "aerodynamic_surfaces": [{"length": 0.5586303555434702, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1355819589267528]}, {"n": 4, "root_chord": 0.12006416295694325, "tip_chord": 0.059812409475951275, "span": 0.11019422811314691, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0514202666055863]}, {"top_radius": 0.0622835603023874, "bottom_radius": 0.04417828791537684, "length": 0.05948731109850217, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6970434155886682, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6164912368242462, "upper_button_position": 0.080552178764422}], "rail_length": 5, "inclination": 83.66947889870069, "heading": 53.999814177607014} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 21, "radius": 0.06350599548545227, "mass": 14.972365965586375, "I_11_without_motor": 6.321, "I_22_without_motor": 6.308076402470525, "I_33_without_motor": 0.026971670359626596, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.951804391245139, "trigger": 800, "sampling_rate": 105, "lag": 1.529363112871357, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0182608330687164, "trigger": "apogee", "sampling_rate": 105, "lag": 1.1716302019327678, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6157.460989460494, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03306537899577222, "grain_number": 5, "grain_density": 1892.4765185643228, "grain_outer_radius": 0.03291729431647596, "grain_initial_inner_radius": 0.014705999588306696, "grain_initial_height": 0.11984707551286568, "grain_separation": 0.004948410892419892, "grains_center_of_mass_position": 0.39602765568237, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0005179033351693645, "throat_radius": 0.010687761348175333, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2554098554739306}], "aerodynamic_surfaces": [{"length": 0.5581666823037278, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1356861521267771]}, {"n": 4, "root_chord": 0.120336900983012, "tip_chord": 0.05983761810204665, "span": 0.11006917945884101, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0496412951180254]}, {"top_radius": 0.06483106026898965, "bottom_radius": 0.04532023794256472, "length": 0.06085021269786268, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7016850030652007, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6172697087884819, "upper_button_position": 0.08441529427671879}], "rail_length": 5, "inclination": 84.68308488633484, "heading": 51.77523923230421} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 21, "radius": 0.06348774454447496, "mass": 14.930117646216331, "I_11_without_motor": 6.321, "I_22_without_motor": 6.312056348648575, "I_33_without_motor": 0.029338448436193622, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.98485567249014, "trigger": 800, "sampling_rate": 105, "lag": 1.5954373224496392, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0082915348846462, "trigger": "apogee", "sampling_rate": 105, "lag": 1.47611633347176, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 8567.306574357362, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0327782378599868, "grain_number": 5, "grain_density": 1805.8062893436656, "grain_outer_radius": 0.032660819562014505, "grain_initial_inner_radius": 0.015203542682672516, "grain_initial_height": 0.11834508933300521, "grain_separation": 0.0036608470091045566, "grains_center_of_mass_position": 0.3958983640087799, "center_of_dry_mass_position": 0.317, "nozzle_position": 1.3285822027841874e-05, "throat_radius": 0.011243176236998718, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254117519523832}], "aerodynamic_surfaces": [{"length": 0.5567992399357332, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1343704811170066]}, {"n": 4, "root_chord": 0.11998896503739298, "tip_chord": 0.06031327043724632, "span": 0.1094885863904161, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0476229917891087]}, {"top_radius": 0.06401958894608005, "bottom_radius": 0.04327245837001616, "length": 0.06104097633057532, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997379913346332, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6177225623381292, "upper_button_position": 0.08201542899650405}], "rail_length": 5, "inclination": 85.30699486775356, "heading": 49.961788567748044} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 30, "radius": 0.06350385008258067, "mass": 15.233268563553258, "I_11_without_motor": 6.321, "I_22_without_motor": 6.329087167850529, "I_33_without_motor": 0.019504456718513197, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.939743618950054, "trigger": 800, "sampling_rate": 105, "lag": 1.5729841040708499, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8653356106930932, "trigger": "apogee", "sampling_rate": 105, "lag": 1.642216557896939, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5652.837999463443, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03378943189234374, "grain_number": 5, "grain_density": 1887.199502396904, "grain_outer_radius": 0.0326500721350551, "grain_initial_inner_radius": 0.01542876557663005, "grain_initial_height": 0.12059714963826691, "grain_separation": 0.005893156331975001, "grains_center_of_mass_position": 0.3981861148392029, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00022746211311398492, "throat_radius": 0.011621619417894464, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2560763636152479}], "aerodynamic_surfaces": [{"length": 0.5581001546412535, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1352389410492156]}, {"n": 4, "root_chord": 0.12024836395956051, "tip_chord": 0.06039111147883963, "span": 0.10936722291036971, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0489622166018164]}, {"top_radius": 0.06383371019026948, "bottom_radius": 0.04507765530380146, "length": 0.05923486424359505, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6989261396392559, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6200765851969161, "upper_button_position": 0.07884955444233976}], "rail_length": 5, "inclination": 83.29673725804211, "heading": 52.553141024002024} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 22, "radius": 0.06349565124600759, "mass": 15.80901182717842, "I_11_without_motor": 6.321, "I_22_without_motor": 6.324189476209414, "I_33_without_motor": 0.039947492124470727, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.958221119007575, "trigger": 800, "sampling_rate": 105, "lag": 1.4744047976407515, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9105919500153667, "trigger": "apogee", "sampling_rate": 105, "lag": 1.1715916196282805, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6940.150669688993, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03221267379186172, "grain_number": 5, "grain_density": 1771.9392395437242, "grain_outer_radius": 0.032362581319129495, "grain_initial_inner_radius": 0.01522597419310009, "grain_initial_height": 0.12093650772482176, "grain_separation": 0.007024323054740163, "grains_center_of_mass_position": 0.3976307814506138, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0010662703960836852, "throat_radius": 0.011254254446186175, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2558391857674298}], "aerodynamic_surfaces": [{"length": 0.5568948547525631, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1328486955355659]}, {"n": 4, "root_chord": 0.11970888327568459, "tip_chord": 0.06068066606961564, "span": 0.1095553598059544, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0486990002737873]}, {"top_radius": 0.06395363397677654, "bottom_radius": 0.044588547419253624, "length": 0.0606897880405041, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6988706406346304, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6183513975708271, "upper_button_position": 0.08051924306380331}], "rail_length": 5, "inclination": 85.68797172124307, "heading": 53.16551825136375} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 4, "radius": 0.06350899499179277, "mass": 15.547504896775179, "I_11_without_motor": 6.321, "I_22_without_motor": 6.334642042757825, "I_33_without_motor": 0.012290033228777135, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.965775818912215, "trigger": 800, "sampling_rate": 105, "lag": 1.5580775056673257, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0076034098063498, "trigger": "apogee", "sampling_rate": 105, "lag": 1.436168301289206, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7108.352414416814, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03408935068456883, "grain_number": 5, "grain_density": 1888.3646315038986, "grain_outer_radius": 0.03316321755418076, "grain_initial_inner_radius": 0.015345322019192812, "grain_initial_height": 0.12005373347344893, "grain_separation": 0.006309995911955411, "grains_center_of_mass_position": 0.3969962721356382, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0002593571580503328, "throat_radius": 0.011053543382358286, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2552580607650872}], "aerodynamic_surfaces": [{"length": 0.5588978515153908, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134669887424594]}, {"n": 4, "root_chord": 0.12063048971372142, "tip_chord": 0.06001144236474167, "span": 0.110121263663121, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0492306654166328]}, {"top_radius": 0.06375264410513082, "bottom_radius": 0.0450462087802562, "length": 0.059763517014825386, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6993198115252584, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6189976176735027, "upper_button_position": 0.08032219385175565}], "rail_length": 5, "inclination": 85.25638610051274, "heading": 52.62801172190558} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 28, "radius": 0.0635086339015458, "mass": 15.480732711974316, "I_11_without_motor": 6.321, "I_22_without_motor": 6.326942641019564, "I_33_without_motor": 0.04357144126749683, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.996944982220173, "trigger": 800, "sampling_rate": 105, "lag": 1.5573050954413707, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9540893919482105, "trigger": "apogee", "sampling_rate": 105, "lag": 1.213746158461936, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6762.474332967853, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03245268338710385, "grain_number": 5, "grain_density": 1810.768306695723, "grain_outer_radius": 0.0336992446005722, "grain_initial_inner_radius": 0.015133097842216219, "grain_initial_height": 0.12000029467356098, "grain_separation": 0.004548999685899851, "grains_center_of_mass_position": 0.3962068411646316, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0009074968900681854, "throat_radius": 0.011855513711284862, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.252781428787283}], "aerodynamic_surfaces": [{"length": 0.5588954108142717, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1336391009586577]}, {"n": 4, "root_chord": 0.11999657053978631, "tip_chord": 0.060034451842632744, "span": 0.11025901792606671, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.049919254784959]}, {"top_radius": 0.06479375834815082, "bottom_radius": 0.04418326742878161, "length": 0.0598707720851098, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6996697116885842, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6190084286350575, "upper_button_position": 0.08066128305352671}], "rail_length": 5, "inclination": 85.05121453684197, "heading": 54.38937240796542} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 27, "radius": 0.0635043477159264, "mass": 15.139007646667636, "I_11_without_motor": 6.321, "I_22_without_motor": 6.313732342465589, "I_33_without_motor": 0.03401796380358941, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.971929525597327, "trigger": 800, "sampling_rate": 105, "lag": 1.3189186920948879, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9755074105279257, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7499170526601382, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5522.339810570602, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03311023337029737, "grain_number": 5, "grain_density": 1898.1235562309237, "grain_outer_radius": 0.033377804105204134, "grain_initial_inner_radius": 0.014747469710170718, "grain_initial_height": 0.11851728927570118, "grain_separation": 0.004929695472279985, "grains_center_of_mass_position": 0.3944279741142745, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0020560467133627883, "throat_radius": 0.010647487735169303, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2541893610577874}], "aerodynamic_surfaces": [{"length": 0.5585689307810547, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133944556696124]}, {"n": 4, "root_chord": 0.12028386479547713, "tip_chord": 0.060567020786275454, "span": 0.11060886948473093, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0500126357605934]}, {"top_radius": 0.06301807675290487, "bottom_radius": 0.043437690975582956, "length": 0.06056615238024632, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7018789663470041, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6182845446728478, "upper_button_position": 0.08359442167415632}], "rail_length": 5, "inclination": 84.54965927059666, "heading": 54.68977304739376} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 19, "radius": 0.06349697824549427, "mass": 15.370288799482854, "I_11_without_motor": 6.321, "I_22_without_motor": 6.322725272036979, "I_33_without_motor": 0.04013883642345122, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.985841685991362, "trigger": 800, "sampling_rate": 105, "lag": 1.6047483709920678, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.2363284422568923, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2174381731651476, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7585.868329758809, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03274203701784928, "grain_number": 5, "grain_density": 1846.9500065168859, "grain_outer_radius": 0.032759520817618175, "grain_initial_inner_radius": 0.014724342430986978, "grain_initial_height": 0.11979571660644074, "grain_separation": 0.004488310192820125, "grains_center_of_mass_position": 0.39786905699768566, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.001935999568391242, "throat_radius": 0.010891327190413334, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254409281174013}], "aerodynamic_surfaces": [{"length": 0.5581338620871945, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1347477159672446]}, {"n": 4, "root_chord": 0.11985959432829377, "tip_chord": 0.06051170989675571, "span": 0.11025899487042218, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.049783054802366]}, {"top_radius": 0.06318094262884065, "bottom_radius": 0.04183814645871406, "length": 0.05912644320343163, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997077298704728, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6180323749818905, "upper_button_position": 0.08167535488858235}], "rail_length": 5, "inclination": 85.6066627752705, "heading": 52.89161157926526} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 27, "radius": 0.06349651506211391, "mass": 15.891823203043772, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3238260125805015, "I_33_without_motor": 0.035293084130928624, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.219655300685899, "trigger": 800, "sampling_rate": 105, "lag": 1.4474482767323453, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8004339775665128, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6624804285716261, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7979.525343319304, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033176768643920794, "grain_number": 5, "grain_density": 1899.8759391351418, "grain_outer_radius": 0.033089153681433045, "grain_initial_inner_radius": 0.015174750355542256, "grain_initial_height": 0.12047437435239357, "grain_separation": 0.004652308511776028, "grains_center_of_mass_position": 0.396048426735033, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0010149846598147812, "throat_radius": 0.011634037543367528, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2558247258381754}], "aerodynamic_surfaces": [{"length": 0.5583113920523873, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1333883942224727]}, {"n": 4, "root_chord": 0.11934442433222583, "tip_chord": 0.05951060585610028, "span": 0.11019261818537261, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0503214396087488]}, {"top_radius": 0.0630028918131456, "bottom_radius": 0.044300755825062606, "length": 0.06159695512765601, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7005190989305117, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6181094291365088, "upper_button_position": 0.08240966979400288}], "rail_length": 5, "inclination": 84.72044828192737, "heading": 53.96906321145176} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 18, "radius": 0.0634995375328335, "mass": 14.728367937532616, "I_11_without_motor": 6.321, "I_22_without_motor": 6.323884535648947, "I_33_without_motor": 0.03476117207556388, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.870703711038196, "trigger": 800, "sampling_rate": 105, "lag": 1.5776251552100067, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0001128347930888, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5995022249466047, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6934.719382352425, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03362435858336634, "grain_number": 5, "grain_density": 1778.2421511177895, "grain_outer_radius": 0.03309817433817483, "grain_initial_inner_radius": 0.015036577986059991, "grain_initial_height": 0.12034835463206361, "grain_separation": 0.004437275813535118, "grains_center_of_mass_position": 0.3973236960584773, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.000813718399551168, "throat_radius": 0.010845799939368905, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2568280809125016}], "aerodynamic_surfaces": [{"length": 0.5587371693608433, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133017893094876]}, {"n": 4, "root_chord": 0.11977837487750152, "tip_chord": 0.05926166484348912, "span": 0.10960434548434023, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0479480678183306]}, {"top_radius": 0.06326535201568326, "bottom_radius": 0.04400312055730409, "length": 0.06003504466296052, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997684815744579, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173507612335352, "upper_button_position": 0.08241772034092276}], "rail_length": 5, "inclination": 84.60164184517363, "heading": 54.26530214698211} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 3, "radius": 0.0634911464600429, "mass": 14.486440254831013, "I_11_without_motor": 6.321, "I_22_without_motor": 6.309901364586174, "I_33_without_motor": 0.03398994359036634, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.902362508377069, "trigger": 800, "sampling_rate": 105, "lag": 1.587203958670398, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.1003008274150388, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3128577817989673, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 8023.1051814785305, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032952391719729315, "grain_number": 5, "grain_density": 1868.3533909345456, "grain_outer_radius": 0.033555825658377225, "grain_initial_inner_radius": 0.015032932532847772, "grain_initial_height": 0.119961274522818, "grain_separation": 0.005646741525968341, "grains_center_of_mass_position": 0.39605226415712946, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0007565405445721585, "throat_radius": 0.011470072863148368, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255787232109951}], "aerodynamic_surfaces": [{"length": 0.5599156821783463, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1342425444589466]}, {"n": 4, "root_chord": 0.12029645924677836, "tip_chord": 0.06023974081776295, "span": 0.10957127506725406, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0506742265852562]}, {"top_radius": 0.062339073470403676, "bottom_radius": 0.04399047848735983, "length": 0.059587688129559446, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7002734900030118, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6183206080184945, "upper_button_position": 0.08195288198451722}], "rail_length": 5, "inclination": 85.62306981474396, "heading": 49.24217302156982} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 1, "radius": 0.06350096760807196, "mass": 15.638435850803534, "I_11_without_motor": 6.321, "I_22_without_motor": 6.320361559471775, "I_33_without_motor": 0.03323712566807844, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.085638405165113, "trigger": 800, "sampling_rate": 105, "lag": 1.6016220198439197, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0044325958821694, "trigger": "apogee", "sampling_rate": 105, "lag": 1.384787782299288, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7625.778081997914, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03262183380316639, "grain_number": 5, "grain_density": 1774.7084755302512, "grain_outer_radius": 0.03311379647061855, "grain_initial_inner_radius": 0.01523856734948392, "grain_initial_height": 0.11996990552537733, "grain_separation": 0.004341848603222936, "grains_center_of_mass_position": 0.39674886189897185, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0008441470235894177, "throat_radius": 0.011324550780740314, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2549056846208548}], "aerodynamic_surfaces": [{"length": 0.5586332641531137, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1329996400090154]}, {"n": 4, "root_chord": 0.12072203449331113, "tip_chord": 0.06099839068749964, "span": 0.11053328992356606, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0501774328973257]}, {"top_radius": 0.06363371424423879, "bottom_radius": 0.04366426886960126, "length": 0.061147693966520394, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7009829600788254, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6172382130414615, "upper_button_position": 0.0837447470373639}], "rail_length": 5, "inclination": 84.19052469712635, "heading": 50.03677113199436} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 17, "radius": 0.06349197680662393, "mass": 15.428411257414771, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32483064604844, "I_33_without_motor": 0.02723935117940278, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.155439419564885, "trigger": 800, "sampling_rate": 105, "lag": 1.3395248648567373, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9258740205169921, "trigger": "apogee", "sampling_rate": 105, "lag": 1.145219260228675, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6774.538140235507, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03234589541551225, "grain_number": 5, "grain_density": 1800.8846322064876, "grain_outer_radius": 0.03283234378818839, "grain_initial_inner_radius": 0.014820380559815506, "grain_initial_height": 0.11953657507627105, "grain_separation": 0.005914069343044977, "grains_center_of_mass_position": 0.3967095425406527, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0008366960006455244, "throat_radius": 0.011333928938224705, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254233414700003}], "aerodynamic_surfaces": [{"length": 0.5576124396090942, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1329124876166934]}, {"n": 4, "root_chord": 0.12018778583366128, "tip_chord": 0.05880483254677678, "span": 0.10986742385701066, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0488456853783297]}, {"top_radius": 0.06277404284735084, "bottom_radius": 0.043564867573667246, "length": 0.059618155707470026, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7010212376271764, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.616915825819793, "upper_button_position": 0.0841054118073834}], "rail_length": 5, "inclination": 85.72524446775732, "heading": 53.20971553322554} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 6, "radius": 0.06348857400194761, "mass": 14.611951499242362, "I_11_without_motor": 6.321, "I_22_without_motor": 6.327748122824438, "I_33_without_motor": 0.044872656150962614, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.979455972026859, "trigger": 800, "sampling_rate": 105, "lag": 1.4259687443485651, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0016762681530027, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2599870953114656, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5723.206261655799, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03241553176806094, "grain_number": 5, "grain_density": 1818.9573886954888, "grain_outer_radius": 0.03268732649737654, "grain_initial_inner_radius": 0.014628356892783188, "grain_initial_height": 0.11960726874545195, "grain_separation": 0.005384153215000254, "grains_center_of_mass_position": 0.39661697354289926, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0004737538387335993, "throat_radius": 0.011461519640227765, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2555089893235123}], "aerodynamic_surfaces": [{"length": 0.5570131217094269, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1333189711244893]}, {"n": 4, "root_chord": 0.1197016097259282, "tip_chord": 0.05924772317167854, "span": 0.10929674073287446, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0480820503417594]}, {"top_radius": 0.06314511953677157, "bottom_radius": 0.044957525988095264, "length": 0.060779192455191054, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6999878117942848, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173926643236608, "upper_button_position": 0.08259514747062402}], "rail_length": 5, "inclination": 85.81067628452577, "heading": 51.76674272786484} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 2, "radius": 0.06349747208414004, "mass": 16.12450150650205, "I_11_without_motor": 6.321, "I_22_without_motor": 6.318305741468311, "I_33_without_motor": 0.042994744781765744, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.018966993257663, "trigger": 800, "sampling_rate": 105, "lag": 1.4752410120145523, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0322100567242984, "trigger": "apogee", "sampling_rate": 105, "lag": 1.675019930852068, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6185.391700744513, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03306044843614433, "grain_number": 5, "grain_density": 1756.1606934870154, "grain_outer_radius": 0.0328368590658428, "grain_initial_inner_radius": 0.014947749952674096, "grain_initial_height": 0.12041452728610347, "grain_separation": 0.005752269536842135, "grains_center_of_mass_position": 0.39562678337841595, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0012908975147282852, "throat_radius": 0.010579189149364553, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548141108817714}], "aerodynamic_surfaces": [{"length": 0.557550329532748, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134437002436943]}, {"n": 4, "root_chord": 0.12001041814320897, "tip_chord": 0.06004816347996898, "span": 0.11028168672799134, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0506721427266907]}, {"top_radius": 0.06505881505156542, "bottom_radius": 0.04368838713692011, "length": 0.059246089428340885, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7000804856892673, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6175550504489563, "upper_button_position": 0.08252543524031097}], "rail_length": 5, "inclination": 87.15758192127657, "heading": 52.26119546253493} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 10, "radius": 0.06349552376377463, "mass": 15.350885147374614, "I_11_without_motor": 6.321, "I_22_without_motor": 6.320598487591626, "I_33_without_motor": 0.027179385251218935, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.023377756531493, "trigger": 800, "sampling_rate": 105, "lag": 1.5087962332491123, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.989500749130062, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2132040809107247, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5556.662759629915, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03287256576417531, "grain_number": 5, "grain_density": 1848.3895227297855, "grain_outer_radius": 0.03239593788185526, "grain_initial_inner_radius": 0.014746024060225535, "grain_initial_height": 0.12089118209590469, "grain_separation": 0.005117139105550911, "grains_center_of_mass_position": 0.3960083879734055, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0005231988164810428, "throat_radius": 0.011339794184151857, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.253820549043234}], "aerodynamic_surfaces": [{"length": 0.5579377234017414, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1342408227410292]}, {"n": 4, "root_chord": 0.12051475985943909, "tip_chord": 0.06091681182321002, "span": 0.11029784432365072, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0502407345389377]}, {"top_radius": 0.0663001633273378, "bottom_radius": 0.04436989802317084, "length": 0.059017924090161676, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6978344181881884, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6182786393436883, "upper_button_position": 0.07955577884450005}], "rail_length": 5, "inclination": 84.977737831712, "heading": 50.69292411737485} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 28, "radius": 0.06349796843796719, "mass": 15.491905617365733, "I_11_without_motor": 6.321, "I_22_without_motor": 6.318530013451749, "I_33_without_motor": 0.015281088244617286, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.068992583007631, "trigger": 800, "sampling_rate": 105, "lag": 1.5175927398734939, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.027203409764987, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6155101471429494, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6625.549104863241, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0329948949040469, "grain_number": 5, "grain_density": 1829.597728711299, "grain_outer_radius": 0.033284672224308864, "grain_initial_inner_radius": 0.015948902216040967, "grain_initial_height": 0.11883594776697178, "grain_separation": 0.005833559448851904, "grains_center_of_mass_position": 0.3979306534482448, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0002829617594964633, "throat_radius": 0.010985140272938367, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548144244413326}], "aerodynamic_surfaces": [{"length": 0.5571676937006194, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1343202243003896]}, {"n": 4, "root_chord": 0.1204072085193961, "tip_chord": 0.059907492479558164, "span": 0.10957089277071845, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0485292012470917]}, {"top_radius": 0.06345021024013636, "bottom_radius": 0.04507416542514857, "length": 0.06006196088748484, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6993967222533961, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6170001205301586, "upper_button_position": 0.08239660172323748}], "rail_length": 5, "inclination": 84.6766425128631, "heading": 54.34109899681687} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 15, "radius": 0.0634984098346836, "mass": 15.71839673894584, "I_11_without_motor": 6.321, "I_22_without_motor": 6.31976756592214, "I_33_without_motor": 0.032842114898029295, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.905706476854565, "trigger": 800, "sampling_rate": 105, "lag": 1.3616764480324317, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.040432074086954, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2254733943108183, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5194.14996115482, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033938474135009104, "grain_number": 5, "grain_density": 1725.4074142048564, "grain_outer_radius": 0.033142562783315455, "grain_initial_inner_radius": 0.014930287960728724, "grain_initial_height": 0.11970306899743223, "grain_separation": 0.00482149925675901, "grains_center_of_mass_position": 0.39814088875732373, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0010017713498807067, "throat_radius": 0.010435398004827488, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.256336924363288}], "aerodynamic_surfaces": [{"length": 0.5579693203961481, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1324781298725939]}, {"n": 4, "root_chord": 0.12000079489283769, "tip_chord": 0.06001557644450443, "span": 0.10857596284015132, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0476748328327194]}, {"top_radius": 0.0639354375404682, "bottom_radius": 0.043888253802334506, "length": 0.059877434458983206, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7007992651069247, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6163671845842055, "upper_button_position": 0.08443208052271922}], "rail_length": 5, "inclination": 83.6228346823337, "heading": 54.226610976778666} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 19, "radius": 0.06350744991481777, "mass": 14.405012223816323, "I_11_without_motor": 6.321, "I_22_without_motor": 6.33904387322666, "I_33_without_motor": 0.03907642168563871, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.04220167954604, "trigger": 800, "sampling_rate": 105, "lag": 1.385065031792861, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0141983266247385, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2421452168092624, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7534.161222384006, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03217593414103991, "grain_number": 5, "grain_density": 1765.8875058571182, "grain_outer_radius": 0.03305351920715771, "grain_initial_inner_radius": 0.014279974938862803, "grain_initial_height": 0.12164485394886902, "grain_separation": 0.0048662704197269995, "grains_center_of_mass_position": 0.39523790030746314, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0012617347579600676, "throat_radius": 0.01026971772511827, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2544778748627048}], "aerodynamic_surfaces": [{"length": 0.5571174658949877, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134024729870558]}, {"n": 4, "root_chord": 0.12009943831411411, "tip_chord": 0.05929962278679848, "span": 0.11008494595823437, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.051156776488256]}, {"top_radius": 0.06303461302295726, "bottom_radius": 0.04390532613115884, "length": 0.0604568423481011, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7002313903506101, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6164664126394285, "upper_button_position": 0.08376497771118163}], "rail_length": 5, "inclination": 85.96902861263881, "heading": 50.879864425972805} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 26, "radius": 0.06349452817007356, "mass": 15.041824059989539, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32654964707118, "I_33_without_motor": 0.02576756458062284, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.984470415994345, "trigger": 800, "sampling_rate": 105, "lag": 1.4333412448604037, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0424976306619997, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4390221191332053, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7740.346298202308, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03284342015615792, "grain_number": 5, "grain_density": 1785.436442510045, "grain_outer_radius": 0.03314852143501804, "grain_initial_inner_radius": 0.015393826504827186, "grain_initial_height": 0.12097497598830302, "grain_separation": 0.0029458341255568497, "grains_center_of_mass_position": 0.39730929858318426, "center_of_dry_mass_position": 0.317, "nozzle_position": 7.120474831156798e-05, "throat_radius": 0.011649789002983097, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2536650913196674}], "aerodynamic_surfaces": [{"length": 0.5589237622313102, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.135965790384511]}, {"n": 4, "root_chord": 0.1191775614739399, "tip_chord": 0.05978513441615296, "span": 0.11001345345569484, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0508045609573164]}, {"top_radius": 0.06371634737458537, "bottom_radius": 0.0440860135655003, "length": 0.061956448273616176, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7005999463551792, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6179054366752573, "upper_button_position": 0.08269450967992187}], "rail_length": 5, "inclination": 82.6520638353218, "heading": 55.48456084779803} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 0, "radius": 0.06350212359874853, "mass": 14.703787727470099, "I_11_without_motor": 6.321, "I_22_without_motor": 6.329468408696411, "I_33_without_motor": 0.029887243179465277, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.015770044517405, "trigger": 800, "sampling_rate": 105, "lag": 1.4538610328057946, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.043705362455051, "trigger": "apogee", "sampling_rate": 105, "lag": 1.306953523971075, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5470.520384202627, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0329890205403627, "grain_number": 5, "grain_density": 1922.4194471126045, "grain_outer_radius": 0.032981466844699305, "grain_initial_inner_radius": 0.014285910878932974, "grain_initial_height": 0.12191458411302673, "grain_separation": 0.003822570077215733, "grains_center_of_mass_position": 0.39598945633162497, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0022380488266456047, "throat_radius": 0.010023639050620198, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2553889492496562}], "aerodynamic_surfaces": [{"length": 0.5593544822892821, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1366275398877876]}, {"n": 4, "root_chord": 0.12006093090519347, "tip_chord": 0.06039452509576055, "span": 0.11065664264447529, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.049504086603735]}, {"top_radius": 0.06440857181801984, "bottom_radius": 0.044409531537504, "length": 0.059597104398322276, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6999338308832991, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.617289777285979, "upper_button_position": 0.08264405359732008}], "rail_length": 5, "inclination": 83.84850385369688, "heading": 49.828245638590715} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 1, "radius": 0.06349674560284929, "mass": 14.921816347237218, "I_11_without_motor": 6.321, "I_22_without_motor": 6.330364977651946, "I_33_without_motor": 0.032619758817294744, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.058257398709138, "trigger": 800, "sampling_rate": 105, "lag": 1.5652744069822428, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0084128327644075, "trigger": "apogee", "sampling_rate": 105, "lag": 1.461733451530952, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4681.446973533048, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03293366287913037, "grain_number": 5, "grain_density": 1832.1473819180446, "grain_outer_radius": 0.033394850177693634, "grain_initial_inner_radius": 0.014569446636452425, "grain_initial_height": 0.12012630522788963, "grain_separation": 0.007461080867009645, "grains_center_of_mass_position": 0.39784298410036856, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00012727371931139028, "throat_radius": 0.012577174911559772, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2537768919128724}], "aerodynamic_surfaces": [{"length": 0.5579890842749892, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1341779982779734]}, {"n": 4, "root_chord": 0.11946637495644881, "tip_chord": 0.060460413810812574, "span": 0.10980824436420111, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0489653601877569]}, {"top_radius": 0.0627489871147417, "bottom_radius": 0.04404477419356129, "length": 0.05802139383715877, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6992017032258433, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6179338816808166, "upper_button_position": 0.08126782154502665}], "rail_length": 5, "inclination": 85.06875061582517, "heading": 53.176458342516334} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 29, "radius": 0.06349516449101554, "mass": 14.833840746517417, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3142703122309145, "I_33_without_motor": 0.03461941854094872, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.053710122042567, "trigger": 800, "sampling_rate": 105, "lag": 1.5197605893524615, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.062545788595652, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3594285434007936, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6088.904205195488, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03245313023588548, "grain_number": 5, "grain_density": 1854.296259474287, "grain_outer_radius": 0.03286480455403395, "grain_initial_inner_radius": 0.014503780495382514, "grain_initial_height": 0.11947357100098997, "grain_separation": 0.003133930859190696, "grains_center_of_mass_position": 0.39648364263343683, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0001296773138576464, "throat_radius": 0.011046956113245993, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2541415291483216}], "aerodynamic_surfaces": [{"length": 0.5596273762939828, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1321710784318435]}, {"n": 4, "root_chord": 0.12013341414087628, "tip_chord": 0.05923749531249958, "span": 0.10966388837772555, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0500007070074222]}, {"top_radius": 0.0651768776139173, "bottom_radius": 0.042016219977453056, "length": 0.05805909141673695, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6995281554288816, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6171102171102731, "upper_button_position": 0.08241793831860844}], "rail_length": 5, "inclination": 83.71033709304348, "heading": 53.79686658514623} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 16, "radius": 0.06348609830297611, "mass": 15.775564448927595, "I_11_without_motor": 6.321, "I_22_without_motor": 6.311697128138629, "I_33_without_motor": 0.045649186904574694, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.094384024854044, "trigger": 800, "sampling_rate": 105, "lag": 1.489234116391569, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8903179875269849, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2553618971322373, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6826.105778724529, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033518227819183836, "grain_number": 5, "grain_density": 1764.8165276773004, "grain_outer_radius": 0.03234977843965594, "grain_initial_inner_radius": 0.015292612903080921, "grain_initial_height": 0.12106983248147343, "grain_separation": 0.005706491772334038, "grains_center_of_mass_position": 0.3968010685051293, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0012496435746191673, "throat_radius": 0.01067392938637024, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2555278148744777}], "aerodynamic_surfaces": [{"length": 0.5581739741447609, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1332158666233283]}, {"n": 4, "root_chord": 0.11957048513459026, "tip_chord": 0.06012621464950515, "span": 0.1104251435782624, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0513086459368413]}, {"top_radius": 0.06472259572820216, "bottom_radius": 0.043192920721482765, "length": 0.06017554020689808, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6995774476947385, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6180401618409889, "upper_button_position": 0.08153728585374964}], "rail_length": 5, "inclination": 84.60602142368998, "heading": 52.97926948901963} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 18, "radius": 0.06349911277736629, "mass": 15.502733930846519, "I_11_without_motor": 6.321, "I_22_without_motor": 6.326651378692527, "I_33_without_motor": 0.04719271131463472, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.030032993506115, "trigger": 800, "sampling_rate": 105, "lag": 1.3409979175873636, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8798019044434237, "trigger": "apogee", "sampling_rate": 105, "lag": 1.970590126901424, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6181.788048396556, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03255425294956757, "grain_number": 5, "grain_density": 1775.332205041046, "grain_outer_radius": 0.0331885797221139, "grain_initial_inner_radius": 0.015686918950381632, "grain_initial_height": 0.11996923072029957, "grain_separation": 0.0060016785603118974, "grains_center_of_mass_position": 0.397186664906841, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00010955905834264899, "throat_radius": 0.011862038142008058, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2545253016050688}], "aerodynamic_surfaces": [{"length": 0.5566816705137342, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.132347863080437]}, {"n": 4, "root_chord": 0.11961634492464189, "tip_chord": 0.06017996779860779, "span": 0.11017748689317333, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0503160764660022]}, {"top_radius": 0.06379244854711358, "bottom_radius": 0.04285932400432567, "length": 0.059823150807485334, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.701011879289094, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6182648629356197, "upper_button_position": 0.08274701635347437}], "rail_length": 5, "inclination": 84.7223994695584, "heading": 50.63343084700375} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 3, "radius": 0.06349578711094504, "mass": 14.733005311557188, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32186632400748, "I_33_without_motor": 0.030005413235617225, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.84072080079831, "trigger": 800, "sampling_rate": 105, "lag": 1.6016760044719902, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0599440405506435, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3246704961118614, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6327.116014098299, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03341605282322616, "grain_number": 5, "grain_density": 1946.843122881012, "grain_outer_radius": 0.032849748327516505, "grain_initial_inner_radius": 0.014452995102544403, "grain_initial_height": 0.1198178101325956, "grain_separation": 0.005897453340079971, "grains_center_of_mass_position": 0.3974497383545063, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0005660175898307726, "throat_radius": 0.0107788242114465, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2539751123411864}], "aerodynamic_surfaces": [{"length": 0.5595352722966735, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1339874584239653]}, {"n": 4, "root_chord": 0.12027984681343187, "tip_chord": 0.060010911990266966, "span": 0.10994620993010913, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0479461024543613]}, {"top_radius": 0.06434838044418614, "bottom_radius": 0.044868816644973525, "length": 0.0579134168068263, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.699720106120432, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173316485926563, "upper_button_position": 0.08238845752777568}], "rail_length": 5, "inclination": 84.27227233651884, "heading": 54.734579458852366} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 11, "radius": 0.06348978331678039, "mass": 14.530071275062346, "I_11_without_motor": 6.321, "I_22_without_motor": 6.313601515804047, "I_33_without_motor": 0.035811282864768305, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.06451765879675, "trigger": 800, "sampling_rate": 105, "lag": 1.5667731193590384, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0629388862215743, "trigger": "apogee", "sampling_rate": 105, "lag": 1.210409830920679, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6421.641366442464, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03302713139904139, "grain_number": 5, "grain_density": 1801.3659471351789, "grain_outer_radius": 0.032581448844778135, "grain_initial_inner_radius": 0.01566596274225949, "grain_initial_height": 0.12022367000122891, "grain_separation": 0.004163827667550902, "grains_center_of_mass_position": 0.3972738765128864, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00023026118927236877, "throat_radius": 0.011252346882402394, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2543600038658234}], "aerodynamic_surfaces": [{"length": 0.5593454471233844, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1337584372554539]}, {"n": 4, "root_chord": 0.11983005579448518, "tip_chord": 0.06038344945789773, "span": 0.10998277607273156, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.048457046745924]}, {"top_radius": 0.06205196560076307, "bottom_radius": 0.04322908211811743, "length": 0.05975893645128083, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7004254705935747, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.618256876505575, "upper_button_position": 0.0821685940879997}], "rail_length": 5, "inclination": 84.99725100723349, "heading": 55.37129030903806} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 20, "radius": 0.06349965671923972, "mass": 15.187653403269254, "I_11_without_motor": 6.321, "I_22_without_motor": 6.314893773590578, "I_33_without_motor": 0.031067759776396867, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.924283528979045, "trigger": 800, "sampling_rate": 105, "lag": 1.4716672756509848, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0179154571210376, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4215560721460743, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7331.311831434599, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033032316941278804, "grain_number": 5, "grain_density": 1805.6811676031355, "grain_outer_radius": 0.03268780803353489, "grain_initial_inner_radius": 0.01533792025006647, "grain_initial_height": 0.11889057340767889, "grain_separation": 0.004944929794747339, "grains_center_of_mass_position": 0.39730622834128204, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0004659840793624343, "throat_radius": 0.011285767541353475, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2570814649558104}], "aerodynamic_surfaces": [{"length": 0.556492208902252, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.135266253355802]}, {"n": 4, "root_chord": 0.11965598181056666, "tip_chord": 0.05985849455847514, "span": 0.11030262925104403, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0513234617976697]}, {"top_radius": 0.06306605778844096, "bottom_radius": 0.04381822534243298, "length": 0.060974249395334336, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6995913842047234, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6186179995290487, "upper_button_position": 0.08097338467567472}], "rail_length": 5, "inclination": 84.33274551001128, "heading": 48.2533802733674} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 9, "radius": 0.06350451524598685, "mass": 14.206096706406463, "I_11_without_motor": 6.321, "I_22_without_motor": 6.302903234647802, "I_33_without_motor": 0.027289553649598498, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.10326633095759, "trigger": 800, "sampling_rate": 105, "lag": 1.6724589857307486, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.176485433527294, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5587795846603474, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7178.31446779074, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032694635597417476, "grain_number": 5, "grain_density": 1791.4300327399603, "grain_outer_radius": 0.03260703977654995, "grain_initial_inner_radius": 0.015178454149511491, "grain_initial_height": 0.1197948700125519, "grain_separation": 0.004455244112382221, "grains_center_of_mass_position": 0.3974725503479587, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00015499443668369188, "throat_radius": 0.01146408370053178, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.257050613454498}], "aerodynamic_surfaces": [{"length": 0.5587607868505936, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1350135134423711]}, {"n": 4, "root_chord": 0.12059540677490324, "tip_chord": 0.05911810336122107, "span": 0.11029067795008576, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0498539997583487]}, {"top_radius": 0.06326578476354046, "bottom_radius": 0.04164927112867691, "length": 0.06079821849094003, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7010310806352795, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6182675032517331, "upper_button_position": 0.08276357738354645}], "rail_length": 5, "inclination": 85.5645567575092, "heading": 50.12029975816826} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 18, "radius": 0.06349908754612475, "mass": 15.091281944132664, "I_11_without_motor": 6.321, "I_22_without_motor": 6.304871783946793, "I_33_without_motor": 0.028929571194958655, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.181069516880273, "trigger": 800, "sampling_rate": 105, "lag": 1.4465220138957302, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0144764716954844, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4773827685037202, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4815.692857511716, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03276328796422462, "grain_number": 5, "grain_density": 1791.3739829419535, "grain_outer_radius": 0.03279999963439643, "grain_initial_inner_radius": 0.014835688785209347, "grain_initial_height": 0.1216240133991025, "grain_separation": 0.003073911865494121, "grains_center_of_mass_position": 0.39738065353557717, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.001383031679060434, "throat_radius": 0.011371548247390562, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254434870772941}], "aerodynamic_surfaces": [{"length": 0.5578227710459531, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1344666286817606]}, {"n": 4, "root_chord": 0.11992247200543255, "tip_chord": 0.05942046615597525, "span": 0.11112684328812697, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0518680748999483]}, {"top_radius": 0.061494913940682946, "bottom_radius": 0.0418688620143952, "length": 0.057582314581009195, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7006283567074604, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.615974860680944, "upper_button_position": 0.0846534960265164}], "rail_length": 5, "inclination": 83.32373734403978, "heading": 55.08948249534396} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 30, "radius": 0.0634993463075142, "mass": 14.801489078859, "I_11_without_motor": 6.321, "I_22_without_motor": 6.324861099285096, "I_33_without_motor": 0.031109938973260434, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.131106978975996, "trigger": 800, "sampling_rate": 105, "lag": 1.5799744945969683, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.033735142695526, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6543321946896454, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 8194.25490069113, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03358797333700211, "grain_number": 5, "grain_density": 1832.8641859651325, "grain_outer_radius": 0.03326344967206518, "grain_initial_inner_radius": 0.014098944811000932, "grain_initial_height": 0.12056686125015023, "grain_separation": 0.00570916237729603, "grains_center_of_mass_position": 0.3975068355913086, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00023748485345140427, "throat_radius": 0.011612784529061521, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254036338416369}], "aerodynamic_surfaces": [{"length": 0.5591181484273685, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134779288594393]}, {"n": 4, "root_chord": 0.11988516560589539, "tip_chord": 0.05984845512026722, "span": 0.10994789943873662, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0491091332295586]}, {"top_radius": 0.06457986434114686, "bottom_radius": 0.04520688148562775, "length": 0.05982051987933152, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6996412589648757, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6166618899414311, "upper_button_position": 0.0829793690234446}], "rail_length": 5, "inclination": 83.17748614864853, "heading": 50.80850509012273} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 18, "radius": 0.06349894169482198, "mass": 14.099064560280109, "I_11_without_motor": 6.321, "I_22_without_motor": 6.325013947970892, "I_33_without_motor": 0.03359814458900968, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.11334344556086, "trigger": 800, "sampling_rate": 105, "lag": 1.3675341328282251, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0733939042455976, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6287763043908137, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7268.554431573363, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033697889530363546, "grain_number": 5, "grain_density": 1926.1559879046883, "grain_outer_radius": 0.03264644740351762, "grain_initial_inner_radius": 0.014555931117282516, "grain_initial_height": 0.12068404386011491, "grain_separation": 0.00587470076016869, "grains_center_of_mass_position": 0.39532087387284237, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0012756829386657664, "throat_radius": 0.011195281240663895, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548296364212677}], "aerodynamic_surfaces": [{"length": 0.5584698107801568, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1348748623104554]}, {"n": 4, "root_chord": 0.12008562247079292, "tip_chord": 0.05938993226103333, "span": 0.10930797507563358, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0485908426349064]}, {"top_radius": 0.06372732646101763, "bottom_radius": 0.04333300868974996, "length": 0.061564305891335415, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6995502472027316, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6177815424909302, "upper_button_position": 0.08176870471180142}], "rail_length": 5, "inclination": 84.21686114545088, "heading": 51.596048360514224} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 21, "radius": 0.06350752038759941, "mass": 14.568592009759945, "I_11_without_motor": 6.321, "I_22_without_motor": 6.315703493536244, "I_33_without_motor": 0.04874128267366165, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.130522658569157, "trigger": 800, "sampling_rate": 105, "lag": 1.539809921052573, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0426413035746167, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5273967090900389, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6823.002889414789, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03303055807264287, "grain_number": 5, "grain_density": 1856.9222859046567, "grain_outer_radius": 0.033062772691915564, "grain_initial_inner_radius": 0.014875188201429109, "grain_initial_height": 0.1191905529449992, "grain_separation": 0.004920553384972976, "grains_center_of_mass_position": 0.3951012114148818, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0010643224349669294, "throat_radius": 0.011214346660564973, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2547733597296076}], "aerodynamic_surfaces": [{"length": 0.5587112069523473, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1322708251074562]}, {"n": 4, "root_chord": 0.12051615333197606, "tip_chord": 0.05965719359384979, "span": 0.1096619396945581, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0479092572793969]}, {"top_radius": 0.06330154215849293, "bottom_radius": 0.04303753924479578, "length": 0.059327294653763275, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6993630621332422, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6200970979521905, "upper_button_position": 0.0792659641810517}], "rail_length": 5, "inclination": 84.06076886892694, "heading": 54.77162126651408} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 16, "radius": 0.06352316457496157, "mass": 15.728235309957261, "I_11_without_motor": 6.321, "I_22_without_motor": 6.322592435295867, "I_33_without_motor": 0.042937380941228204, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.274660216759411, "trigger": 800, "sampling_rate": 105, "lag": 1.5317353953288444, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0302164531184763, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6075514119576728, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7080.060307716018, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03265967553888556, "grain_number": 5, "grain_density": 1819.941579898169, "grain_outer_radius": 0.03301592231597936, "grain_initial_inner_radius": 0.015656125802250925, "grain_initial_height": 0.11842622294982127, "grain_separation": 0.005657492725928914, "grains_center_of_mass_position": 0.39762298212080105, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0004209493104482007, "throat_radius": 0.011708112046648424, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2544959176060508}], "aerodynamic_surfaces": [{"length": 0.5562321768144465, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1351132308363574]}, {"n": 4, "root_chord": 0.11933898597818884, "tip_chord": 0.05962949872173691, "span": 0.11019436958753759, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0479789377327593]}, {"top_radius": 0.06330532157130539, "bottom_radius": 0.04347520056837399, "length": 0.06062141499978299, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6984570518175143, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6165578795743236, "upper_button_position": 0.08189917224319065}], "rail_length": 5, "inclination": 83.8587565579397, "heading": 51.47542529528003} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 29, "radius": 0.06349766810532545, "mass": 14.656848343367603, "I_11_without_motor": 6.321, "I_22_without_motor": 6.307533288706822, "I_33_without_motor": 0.0318613781097265, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.08296936874009, "trigger": 800, "sampling_rate": 105, "lag": 1.5510165049063207, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9102018275944145, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5079222294473764, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6885.096545351595, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03317257384851179, "grain_number": 5, "grain_density": 1840.3883692737118, "grain_outer_radius": 0.033348276571029255, "grain_initial_inner_radius": 0.015137371711569736, "grain_initial_height": 0.12032926296403364, "grain_separation": 0.006373605519429962, "grains_center_of_mass_position": 0.3975640018621129, "center_of_dry_mass_position": 0.317, "nozzle_position": 2.9822997766785866e-05, "throat_radius": 0.01111248000203877, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2523204155315593}], "aerodynamic_surfaces": [{"length": 0.5579542546555215, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1332210247093493]}, {"n": 4, "root_chord": 0.11974443237947338, "tip_chord": 0.059386130897948655, "span": 0.11038000090045949, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0499885287780564]}, {"top_radius": 0.06403444615056623, "bottom_radius": 0.04389711008510284, "length": 0.06032596822152251, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7004974238294233, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6191263006870993, "upper_button_position": 0.08137112314232398}], "rail_length": 5, "inclination": 83.62062658169378, "heading": 54.86835782617894} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 14, "radius": 0.0634924870241792, "mass": 14.709676646614824, "I_11_without_motor": 6.321, "I_22_without_motor": 6.313025008452103, "I_33_without_motor": 0.02922030499870789, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.817298873906841, "trigger": 800, "sampling_rate": 105, "lag": 1.4063749299306547, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9015042478644425, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6916849380661005, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6514.743542099575, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03247600375348105, "grain_number": 5, "grain_density": 1802.8487679718357, "grain_outer_radius": 0.03283690273976019, "grain_initial_inner_radius": 0.014254841714729672, "grain_initial_height": 0.12023205122080777, "grain_separation": 0.0064105459111511226, "grains_center_of_mass_position": 0.3967602433044211, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00013644286796200234, "throat_radius": 0.011668582226117183, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2539494671036846}], "aerodynamic_surfaces": [{"length": 0.5596403667045493, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1353701876975828]}, {"n": 4, "root_chord": 0.12014407469739156, "tip_chord": 0.06017500886414237, "span": 0.1103389212118897, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0489606170466572]}, {"top_radius": 0.06383549807917367, "bottom_radius": 0.04290815155775744, "length": 0.058220161897975437, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7011021489792616, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6190834841590558, "upper_button_position": 0.08201866482020581}], "rail_length": 5, "inclination": 83.7769529700423, "heading": 55.825128718842876} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 17, "radius": 0.06349375594679321, "mass": 15.199128285098368, "I_11_without_motor": 6.321, "I_22_without_motor": 6.322160088501507, "I_33_without_motor": 0.058963578092994406, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.045144262676045, "trigger": 800, "sampling_rate": 105, "lag": 1.6168084743320965, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.1678269734005617, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3540077683456562, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4563.572283518417, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03224422295261444, "grain_number": 5, "grain_density": 1821.5087968587952, "grain_outer_radius": 0.032396969255703054, "grain_initial_inner_radius": 0.014593338245721172, "grain_initial_height": 0.12015927711054189, "grain_separation": 0.005861398144002046, "grains_center_of_mass_position": 0.3977388838690814, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0008056669713052032, "throat_radius": 0.011976001511780647, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2560299433022888}], "aerodynamic_surfaces": [{"length": 0.558177699404519, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.132822153196735]}, {"n": 4, "root_chord": 0.12011092926040404, "tip_chord": 0.06042909487228104, "span": 0.10976673821218898, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0505549564489878]}, {"top_radius": 0.06479073513488832, "bottom_radius": 0.04350881624287202, "length": 0.06136391809263359, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997896733287025, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.616666029595402, "upper_button_position": 0.0831236437333005}], "rail_length": 5, "inclination": 85.22188930223953, "heading": 54.04282848968786} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 28, "radius": 0.06350235440727434, "mass": 15.070204779550483, "I_11_without_motor": 6.321, "I_22_without_motor": 6.342790416702579, "I_33_without_motor": 0.05023151335844672, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.950687209250601, "trigger": 800, "sampling_rate": 105, "lag": 1.6932911219652462, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8851945285655531, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7722113781686215, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6401.280224461789, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03365695385690572, "grain_number": 5, "grain_density": 1830.7009673285118, "grain_outer_radius": 0.03281947171301496, "grain_initial_inner_radius": 0.01528588507445965, "grain_initial_height": 0.1188540284866351, "grain_separation": 0.004376926437492424, "grains_center_of_mass_position": 0.398404054740682, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0006207325346728692, "throat_radius": 0.010632806187796618, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2558950008463732}], "aerodynamic_surfaces": [{"length": 0.5580098300026757, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134220754837157]}, {"n": 4, "root_chord": 0.12036332820175781, "tip_chord": 0.0597001950594256, "span": 0.10976695147617442, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.049443116624482]}, {"top_radius": 0.0650339166746558, "bottom_radius": 0.04472470808674029, "length": 0.05943466505615914, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6988256613164832, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6207561546904712, "upper_button_position": 0.07806950662601198}], "rail_length": 5, "inclination": 84.03603483764553, "heading": 55.887339061338764} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 26, "radius": 0.06351167017179078, "mass": 15.611985657395229, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32841482893715, "I_33_without_motor": 0.031011243422976696, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.948985022345356, "trigger": 800, "sampling_rate": 105, "lag": 1.4554028709851992, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0182590593942014, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2472473004292794, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6338.901413423589, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03246499500970873, "grain_number": 5, "grain_density": 1787.853898821363, "grain_outer_radius": 0.03286663630863919, "grain_initial_inner_radius": 0.015643692864322222, "grain_initial_height": 0.12082644736871681, "grain_separation": 0.005610711721622439, "grains_center_of_mass_position": 0.39614881164715504, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00010968724020596801, "throat_radius": 0.010886357471918257, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2539405124172907}], "aerodynamic_surfaces": [{"length": 0.5561785445012554, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.132630258756316]}, {"n": 4, "root_chord": 0.11930974875814616, "tip_chord": 0.060270682612888954, "span": 0.11027737478538215, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0485189363780572]}, {"top_radius": 0.06086559183894612, "bottom_radius": 0.0454375776142393, "length": 0.06030391500642561, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7009586103175619, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6181464263296432, "upper_button_position": 0.08281218398791867}], "rail_length": 5, "inclination": 84.15609134887411, "heading": 52.45330766215803} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 11, "radius": 0.06351202525163077, "mass": 15.392504202590164, "I_11_without_motor": 6.321, "I_22_without_motor": 6.323620497138478, "I_33_without_motor": 0.029186600176251954, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.125417795253925, "trigger": 800, "sampling_rate": 105, "lag": 1.727636501137058, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0094449809124664, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4192788769322402, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5282.801612432365, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0330815070178224, "grain_number": 5, "grain_density": 1755.1167766932929, "grain_outer_radius": 0.03277959596453596, "grain_initial_inner_radius": 0.014984155227919729, "grain_initial_height": 0.12049032672599923, "grain_separation": 0.004437783093532051, "grains_center_of_mass_position": 0.3966445370511041, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0002771738131394219, "throat_radius": 0.011132774552032137, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2561708441099395}], "aerodynamic_surfaces": [{"length": 0.5598532309485841, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1341045484548415]}, {"n": 4, "root_chord": 0.11862650717253713, "tip_chord": 0.0599523202030708, "span": 0.11010291683651284, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0483470778754516]}, {"top_radius": 0.06324533464958096, "bottom_radius": 0.04134060555718694, "length": 0.06058015057263284, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.698632311100594, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6212924683491421, "upper_button_position": 0.07733984275145189}], "rail_length": 5, "inclination": 86.19588906797561, "heading": 49.85601395629662} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 7, "radius": 0.06350006955536922, "mass": 15.799447870142059, "I_11_without_motor": 6.321, "I_22_without_motor": 6.332107671710035, "I_33_without_motor": 0.03153237328129834, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.001137879935596, "trigger": 800, "sampling_rate": 105, "lag": 1.3653233466638568, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8693621432003233, "trigger": "apogee", "sampling_rate": 105, "lag": 1.48557862101658, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7030.577307268565, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032796257083834886, "grain_number": 5, "grain_density": 1887.5726087443666, "grain_outer_radius": 0.03219561632695956, "grain_initial_inner_radius": 0.015077281922903172, "grain_initial_height": 0.1202439739511392, "grain_separation": 0.007695059111287829, "grains_center_of_mass_position": 0.3964477803779825, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0018830563802775702, "throat_radius": 0.01069571145826872, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2549438058658564}], "aerodynamic_surfaces": [{"length": 0.5586959945672927, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1347026583779645]}, {"n": 4, "root_chord": 0.12067841986788942, "tip_chord": 0.05980559387136491, "span": 0.1097717783830386, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0479600980127175]}, {"top_radius": 0.0629756691974217, "bottom_radius": 0.043808635977925774, "length": 0.05972379941617993, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6979147816839694, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6169507413489307, "upper_button_position": 0.08096404033503868}], "rail_length": 5, "inclination": 85.49590126163909, "heading": 52.95951498096336} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 15, "radius": 0.06349071169964288, "mass": 14.800191249080765, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32463403036484, "I_33_without_motor": 0.0322176693888181, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.924572501315387, "trigger": 800, "sampling_rate": 105, "lag": 1.3522038229512596, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9448792264908165, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5068837624054492, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7551.380253384962, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.031958148786281754, "grain_number": 5, "grain_density": 1770.6557869397002, "grain_outer_radius": 0.03299668473194588, "grain_initial_inner_radius": 0.01450476168660286, "grain_initial_height": 0.11938619567310826, "grain_separation": 0.006932306846733179, "grains_center_of_mass_position": 0.3959409043012191, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0007341638060561093, "throat_radius": 0.010634733696663935, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2560175990878202}], "aerodynamic_surfaces": [{"length": 0.5585889505952945, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1361210450033925]}, {"n": 4, "root_chord": 0.11939622090417909, "tip_chord": 0.05991464092188379, "span": 0.11061727097661712, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0522559589916516]}, {"top_radius": 0.06454087073167931, "bottom_radius": 0.0443065780298129, "length": 0.06121319273208881, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6999664441042162, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6180540116409904, "upper_button_position": 0.08191243246322577}], "rail_length": 5, "inclination": 83.87709490035185, "heading": 55.0599492522456} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 3, "radius": 0.06349780679999119, "mass": 15.009280751461688, "I_11_without_motor": 6.321, "I_22_without_motor": 6.29887945233111, "I_33_without_motor": 0.034479816961961667, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.90172819551314, "trigger": 800, "sampling_rate": 105, "lag": 1.5163655385794343, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.875816755176137, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2023748047438532, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7385.590506427114, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03221891989261677, "grain_number": 5, "grain_density": 1790.1967260100346, "grain_outer_radius": 0.03316729556849812, "grain_initial_inner_radius": 0.014863902626421193, "grain_initial_height": 0.12065846084196745, "grain_separation": 0.0036426744285935945, "grains_center_of_mass_position": 0.3965370904480209, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00013280584439873054, "throat_radius": 0.011210583646187327, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548409698708773}], "aerodynamic_surfaces": [{"length": 0.5584714172410293, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1333653549924239]}, {"n": 4, "root_chord": 0.11969334297624912, "tip_chord": 0.060121232394150424, "span": 0.10971653445562919, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0490302028140186]}, {"top_radius": 0.062407313736553297, "bottom_radius": 0.04065057212257242, "length": 0.05742457460519687, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6994335939676563, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6180270862200052, "upper_button_position": 0.08140650774765101}], "rail_length": 5, "inclination": 85.46542134999915, "heading": 55.536248042226646} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 5, "radius": 0.06349413243678145, "mass": 14.743964824602733, "I_11_without_motor": 6.321, "I_22_without_motor": 6.337257411297098, "I_33_without_motor": 0.0329993761123817, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.00520642707896, "trigger": 800, "sampling_rate": 105, "lag": 1.456810861337788, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8956931615186817, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3230597114159592, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7209.683200057362, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03279760108823367, "grain_number": 5, "grain_density": 1834.9366360707274, "grain_outer_radius": 0.032787904216677995, "grain_initial_inner_radius": 0.014970218367640686, "grain_initial_height": 0.12128795849055533, "grain_separation": 0.004719163578293065, "grains_center_of_mass_position": 0.39530647037378636, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0022908949144089534, "throat_radius": 0.010589347376890983, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2546074628084332}], "aerodynamic_surfaces": [{"length": 0.5572291958811432, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1353683373632557]}, {"n": 4, "root_chord": 0.12050940641366253, "tip_chord": 0.05962258502919415, "span": 0.11051119243479171, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0483006211672794]}, {"top_radius": 0.06387608941136222, "bottom_radius": 0.042135664250281764, "length": 0.06221056212548488, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6999072201956247, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6171381994017947, "upper_button_position": 0.08276902079382997}], "rail_length": 5, "inclination": 85.17946214102281, "heading": 51.998550698639285} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 1, "radius": 0.06349988246736835, "mass": 15.127951044531462, "I_11_without_motor": 6.321, "I_22_without_motor": 6.304120784320496, "I_33_without_motor": 0.047270325007072705, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.125776902514774, "trigger": 800, "sampling_rate": 105, "lag": 1.4104745690639993, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0402900695968205, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7050693742503058, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7382.714678228542, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03366868417579529, "grain_number": 5, "grain_density": 1822.1786217419121, "grain_outer_radius": 0.034093475845885395, "grain_initial_inner_radius": 0.014939083650324135, "grain_initial_height": 0.12125037765414684, "grain_separation": 0.004922597009769367, "grains_center_of_mass_position": 0.3986958463355442, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0009764665546426117, "throat_radius": 0.010583062536681957, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2569513063011652}], "aerodynamic_surfaces": [{"length": 0.5598181143296278, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1345825464475583]}, {"n": 4, "root_chord": 0.1199812213844204, "tip_chord": 0.06007242530874172, "span": 0.11046315666132789, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0495563519149418]}, {"top_radius": 0.06557365470659852, "bottom_radius": 0.043846776979273826, "length": 0.06026413656902243, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6992183915879916, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6171854737317541, "upper_button_position": 0.08203291785623745}], "rail_length": 5, "inclination": 86.05351223387608, "heading": 54.31655922653191} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 13, "radius": 0.06350430884204616, "mass": 15.110086357337545, "I_11_without_motor": 6.321, "I_22_without_motor": 6.313196794464696, "I_33_without_motor": 0.023551995393136224, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.021930028181636, "trigger": 800, "sampling_rate": 105, "lag": 1.352065013695944, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9537763680190132, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3902969567718713, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5378.405857272342, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032723072652738314, "grain_number": 5, "grain_density": 1830.5648866654535, "grain_outer_radius": 0.03291049993078663, "grain_initial_inner_radius": 0.014576842219137548, "grain_initial_height": 0.12037508413096347, "grain_separation": 0.003250255271304136, "grains_center_of_mass_position": 0.39659432746007384, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00026071784347483993, "throat_radius": 0.011194397861158844, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2547624185188067}], "aerodynamic_surfaces": [{"length": 0.5571692791716677, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1336810995436297]}, {"n": 4, "root_chord": 0.12020141034019076, "tip_chord": 0.05864438628824802, "span": 0.1103435967322336, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0486715741057797]}, {"top_radius": 0.06229932186875737, "bottom_radius": 0.04290881295541781, "length": 0.063358717393052, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7003511393453975, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6196147243858786, "upper_button_position": 0.08073641495951889}], "rail_length": 5, "inclination": 85.01280931564365, "heading": 54.70066345505092} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 14, "radius": 0.06349869030005506, "mass": 15.516371514227249, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3311270901818855, "I_33_without_motor": 0.039518484734917196, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.187056276082586, "trigger": 800, "sampling_rate": 105, "lag": 1.4862396222757985, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.960293736835046, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4964934334260673, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6438.003037636608, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03414470526835011, "grain_number": 5, "grain_density": 1800.8243668345003, "grain_outer_radius": 0.03374461059698083, "grain_initial_inner_radius": 0.013685565254489138, "grain_initial_height": 0.12022826792767276, "grain_separation": 0.0057261536814462825, "grains_center_of_mass_position": 0.3964320154434183, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0003684550695898837, "throat_radius": 0.012026535153821825, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2564012585885642}], "aerodynamic_surfaces": [{"length": 0.5576312641519685, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1321129037097613]}, {"n": 4, "root_chord": 0.11964163249817243, "tip_chord": 0.06053330978274308, "span": 0.10957726966567305, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0504223320165638]}, {"top_radius": 0.06377627586807537, "bottom_radius": 0.04344315579923672, "length": 0.06043671965659524, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997111517704975, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6176186103593101, "upper_button_position": 0.08209254141118738}], "rail_length": 5, "inclination": 84.85887548960986, "heading": 52.8059677474103} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 8, "radius": 0.06350780886056825, "mass": 15.713136063635455, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3444643700358165, "I_33_without_motor": 0.03428915836315116, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.103834277538313, "trigger": 800, "sampling_rate": 105, "lag": 1.3639714046090532, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8915577948691057, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5088803851157955, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7026.854294754978, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032921717246896305, "grain_number": 5, "grain_density": 1887.0827550331205, "grain_outer_radius": 0.03276949607729857, "grain_initial_inner_radius": 0.01501597811270181, "grain_initial_height": 0.11884550439621125, "grain_separation": 0.006216505249936778, "grains_center_of_mass_position": 0.3992649907504356, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00019146595975479876, "throat_radius": 0.011305035482275154, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548049677302013}], "aerodynamic_surfaces": [{"length": 0.5587865751733017, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1348964369359507]}, {"n": 4, "root_chord": 0.11935120769305262, "tip_chord": 0.06046467457639855, "span": 0.10942959470112658, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0511620933471475]}, {"top_radius": 0.06274060826929713, "bottom_radius": 0.041957770541348825, "length": 0.06034069520915706, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6974625963335641, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6178153625143794, "upper_button_position": 0.0796472338191847}], "rail_length": 5, "inclination": 83.20880479645666, "heading": 50.61474897693754} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 7, "radius": 0.06348996262058414, "mass": 14.374903371657116, "I_11_without_motor": 6.321, "I_22_without_motor": 6.316094399336938, "I_33_without_motor": 0.0424350372256497, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.060660624785088, "trigger": 800, "sampling_rate": 105, "lag": 1.3567309573777342, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0950657123179492, "trigger": "apogee", "sampling_rate": 105, "lag": 1.0724681653530452, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6331.80104234107, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03221203446405128, "grain_number": 5, "grain_density": 1790.2040907239311, "grain_outer_radius": 0.03306105381158216, "grain_initial_inner_radius": 0.014774081637033682, "grain_initial_height": 0.12011635841882029, "grain_separation": 0.004871724671113781, "grains_center_of_mass_position": 0.3968071243970028, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0011697908688223773, "throat_radius": 0.011307211840652049, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255799452226066}], "aerodynamic_surfaces": [{"length": 0.5581524755227274, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1340901674031068]}, {"n": 4, "root_chord": 0.11971592814833756, "tip_chord": 0.059482899746064105, "span": 0.11054868663961716, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0491225699779931]}, {"top_radius": 0.06314832010320223, "bottom_radius": 0.04309338518286907, "length": 0.05929522206206675, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6999439405557972, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6180478714284893, "upper_button_position": 0.08189606912730796}], "rail_length": 5, "inclination": 84.7017541615836, "heading": 52.05424611611283} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 23, "radius": 0.06350110609969463, "mass": 15.27945510023428, "I_11_without_motor": 6.321, "I_22_without_motor": 6.335105899381713, "I_33_without_motor": 0.04451985557154536, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.103771217226235, "trigger": 800, "sampling_rate": 105, "lag": 1.5137413752945212, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9719815443093841, "trigger": "apogee", "sampling_rate": 105, "lag": 1.1333745950007599, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7350.638053689589, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03291542616008069, "grain_number": 5, "grain_density": 1751.795497563181, "grain_outer_radius": 0.032580844789046944, "grain_initial_inner_radius": 0.015386196926125821, "grain_initial_height": 0.11925007255759713, "grain_separation": 0.0036535842265723465, "grains_center_of_mass_position": 0.39702849110222205, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0017443444494659314, "throat_radius": 0.010237030153352124, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2549235139961086}], "aerodynamic_surfaces": [{"length": 0.5580739365630819, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1332662344967228]}, {"n": 4, "root_chord": 0.12002936531818889, "tip_chord": 0.059286537455685656, "span": 0.11014486475303154, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0493736829106934]}, {"top_radius": 0.06431269005894381, "bottom_radius": 0.04397192766024827, "length": 0.061127347819634324, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7001038615254359, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6174162796002083, "upper_button_position": 0.08268758192522763}], "rail_length": 5, "inclination": 82.85778360047398, "heading": 51.16988676664341} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 23, "radius": 0.06351235563524632, "mass": 14.63322038652452, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3302254494163215, "I_33_without_motor": 0.025350749988723893, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.053096897204416, "trigger": 800, "sampling_rate": 105, "lag": 1.3635651794695702, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9701579230024913, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6372569132834822, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6832.288212514506, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03357760600646698, "grain_number": 5, "grain_density": 1899.105846343389, "grain_outer_radius": 0.03349899343792087, "grain_initial_inner_radius": 0.015038516649391938, "grain_initial_height": 0.1196638212053437, "grain_separation": 0.00560807561256116, "grains_center_of_mass_position": 0.39719181625568056, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0012562832448794689, "throat_radius": 0.012044905000954774, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255696338974987}], "aerodynamic_surfaces": [{"length": 0.5593896378193238, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1339020865839886]}, {"n": 4, "root_chord": 0.12030892210238418, "tip_chord": 0.06062600929386921, "span": 0.11017272883690943, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0483048017003125]}, {"top_radius": 0.06478527852177199, "bottom_radius": 0.042073537329639345, "length": 0.060411611459264415, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.700418092723315, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6153840766118764, "upper_button_position": 0.08503401611143857}], "rail_length": 5, "inclination": 84.59254794762977, "heading": 55.9687805076979} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 0, "radius": 0.06350590619094476, "mass": 15.080485170962332, "I_11_without_motor": 6.321, "I_22_without_motor": 6.327040010827636, "I_33_without_motor": 0.042590045765280984, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.1537874988919, "trigger": 800, "sampling_rate": 105, "lag": 1.4535783866105365, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.1199840450592056, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2928765553431871, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6560.483730429797, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033002539805288965, "grain_number": 5, "grain_density": 1753.135707019853, "grain_outer_radius": 0.03257329208233708, "grain_initial_inner_radius": 0.014644125862002266, "grain_initial_height": 0.12098127573465807, "grain_separation": 0.007023160684503705, "grains_center_of_mass_position": 0.3957751400327463, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0007006386699787393, "throat_radius": 0.01094411075588027, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2562606838365908}], "aerodynamic_surfaces": [{"length": 0.5581466476385946, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1341610555974102]}, {"n": 4, "root_chord": 0.11932672269248384, "tip_chord": 0.06030727424750291, "span": 0.1103326149631549, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.050338978641946]}, {"top_radius": 0.06425923763319025, "bottom_radius": 0.04278974362240359, "length": 0.060061214011226924, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7011599614929181, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.616562364935789, "upper_button_position": 0.08459759655712917}], "rail_length": 5, "inclination": 85.49450114169898, "heading": 54.39902008969704} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 3, "radius": 0.06349535545294449, "mass": 15.303293072393853, "I_11_without_motor": 6.321, "I_22_without_motor": 6.320331081926137, "I_33_without_motor": 0.03258812738472048, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.027716162274867, "trigger": 800, "sampling_rate": 105, "lag": 1.5230030817401685, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.13248367224743, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5705494417288957, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7837.4232661561955, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03206541531820579, "grain_number": 5, "grain_density": 1834.1727399069105, "grain_outer_radius": 0.033016426516149236, "grain_initial_inner_radius": 0.014720608706298632, "grain_initial_height": 0.1192598495122423, "grain_separation": 0.005158907991717304, "grains_center_of_mass_position": 0.39423900952152346, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0006761447815294225, "throat_radius": 0.011577124841068962, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2556291911841437}], "aerodynamic_surfaces": [{"length": 0.5569380047094106, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1340252793986345]}, {"n": 4, "root_chord": 0.12057834302562266, "tip_chord": 0.05948300577613497, "span": 0.10985576754615899, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0518576729558635]}, {"top_radius": 0.06445272034031992, "bottom_radius": 0.04234109310044354, "length": 0.05917382632419316, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7004017762281358, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.616986328570382, "upper_button_position": 0.08341544765775377}], "rail_length": 5, "inclination": 83.77920212144204, "heading": 53.03152903838162} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 19, "radius": 0.06350573537363302, "mass": 14.30805992536985, "I_11_without_motor": 6.321, "I_22_without_motor": 6.31528362122732, "I_33_without_motor": 0.03188559398428235, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.093521331465285, "trigger": 800, "sampling_rate": 105, "lag": 1.3564706409584264, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.009760896720427, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7787872915821343, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4242.052104083594, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033389290903656256, "grain_number": 5, "grain_density": 1746.8561271388007, "grain_outer_radius": 0.03304571390182966, "grain_initial_inner_radius": 0.014782952011176501, "grain_initial_height": 0.12135739369955491, "grain_separation": 0.004190858753516596, "grains_center_of_mass_position": 0.3949441894388302, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0003698788353958239, "throat_radius": 0.010375367704889374, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2547516322630021}], "aerodynamic_surfaces": [{"length": 0.5589418312759338, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1345455674290448]}, {"n": 4, "root_chord": 0.11955012772670659, "tip_chord": 0.059746869415886625, "span": 0.10985610336855757, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0480885307926457]}, {"top_radius": 0.06310190179238634, "bottom_radius": 0.04431718568223173, "length": 0.06132497816473511, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6992169721499453, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6171755890032975, "upper_button_position": 0.08204138314664777}], "rail_length": 5, "inclination": 84.69013994851046, "heading": 49.7799035498802} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 7, "radius": 0.06349808638580251, "mass": 15.26117984996623, "I_11_without_motor": 6.321, "I_22_without_motor": 6.313792929031072, "I_33_without_motor": 0.039028815462556654, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.019968502483774, "trigger": 800, "sampling_rate": 105, "lag": 1.293710811772124, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9805575865785177, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5983124444765036, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5820.692744412688, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03465972691618848, "grain_number": 5, "grain_density": 1869.9112320834886, "grain_outer_radius": 0.03285971795415413, "grain_initial_inner_radius": 0.01514107450990915, "grain_initial_height": 0.11885928499113928, "grain_separation": 0.006009036129893335, "grains_center_of_mass_position": 0.3958164370610288, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.001418728843530659, "throat_radius": 0.011731075210787385, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2559732262092702}], "aerodynamic_surfaces": [{"length": 0.5568826774337932, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1330704792408508]}, {"n": 4, "root_chord": 0.12031142839982933, "tip_chord": 0.0606743409717126, "span": 0.10870074033956711, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0508477777633585]}, {"top_radius": 0.0648848329000352, "bottom_radius": 0.044880244462127794, "length": 0.059120897804609475, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.700730906083566, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6161153401468761, "upper_button_position": 0.08461556593668995}], "rail_length": 5, "inclination": 84.40677839986306, "heading": 53.26302780747085} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 21, "radius": 0.06349929575481449, "mass": 15.465615089268946, "I_11_without_motor": 6.321, "I_22_without_motor": 6.332695064901782, "I_33_without_motor": 0.02944650746931481, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.145864653234616, "trigger": 800, "sampling_rate": 105, "lag": 1.5011199536099813, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.01143032578772, "trigger": "apogee", "sampling_rate": 105, "lag": 1.9278020202292208, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6414.157841409511, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03327788100491452, "grain_number": 5, "grain_density": 1844.8788954830204, "grain_outer_radius": 0.03301459564213143, "grain_initial_inner_radius": 0.014707825484932605, "grain_initial_height": 0.11883880719343697, "grain_separation": 0.006392721871365158, "grains_center_of_mass_position": 0.3956476448429322, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0010332525140067288, "throat_radius": 0.011484032909955786, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255615340545256}], "aerodynamic_surfaces": [{"length": 0.5583373706467214, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134658469530976]}, {"n": 4, "root_chord": 0.11944691692627743, "tip_chord": 0.06032775449099784, "span": 0.1095714360351648, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0473970351578303]}, {"top_radius": 0.06262037654067643, "bottom_radius": 0.042907937122465434, "length": 0.05949146626345526, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6987322801298296, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6175012977913668, "upper_button_position": 0.08123098233846282}], "rail_length": 5, "inclination": 86.90268603158258, "heading": 54.8443485850684} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 17, "radius": 0.06349646441148747, "mass": 16.186564204679556, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3285355865999335, "I_33_without_motor": 0.04373704731517958, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.048536374379845, "trigger": 800, "sampling_rate": 105, "lag": 1.5516683981538366, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9486697251128735, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6982717640872143, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 9445.646204880664, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03369883664825597, "grain_number": 5, "grain_density": 1811.0763143046966, "grain_outer_radius": 0.03305498320609093, "grain_initial_inner_radius": 0.015135428691737481, "grain_initial_height": 0.12007989129724471, "grain_separation": 0.006316667503302023, "grains_center_of_mass_position": 0.39808673559545676, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0009150862939795672, "throat_radius": 0.011078707680095713, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2545044859372902}], "aerodynamic_surfaces": [{"length": 0.557430375793955, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1351186435980873]}, {"n": 4, "root_chord": 0.12024472011328981, "tip_chord": 0.060165768151028885, "span": 0.10986083070797623, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.04817708214022]}, {"top_radius": 0.06295886487910317, "bottom_radius": 0.043326819305221406, "length": 0.05927481229384511, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6996806367425821, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6176905446611791, "upper_button_position": 0.08199009208140295}], "rail_length": 5, "inclination": 83.00188501232762, "heading": 53.64934999825792} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 17, "radius": 0.063489511048732, "mass": 15.403246955580508, "I_11_without_motor": 6.321, "I_22_without_motor": 6.325173329854296, "I_33_without_motor": 0.03821842888885621, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.00933365776983, "trigger": 800, "sampling_rate": 105, "lag": 1.6225523343468229, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0986084926586897, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4353139582859633, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7300.273578654727, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03376087952005415, "grain_number": 5, "grain_density": 1807.0328943697189, "grain_outer_radius": 0.03307141546035796, "grain_initial_inner_radius": 0.014598991393814006, "grain_initial_height": 0.11897725559644393, "grain_separation": 0.004816293114279538, "grains_center_of_mass_position": 0.39620109423477756, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0026381497150537786, "throat_radius": 0.010922838556938848, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2545358511905456}], "aerodynamic_surfaces": [{"length": 0.5591978529198565, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1330538423253214]}, {"n": 4, "root_chord": 0.1207332445668151, "tip_chord": 0.05917847890503504, "span": 0.10949151058046712, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0489433894492213]}, {"top_radius": 0.06146865769749782, "bottom_radius": 0.04413891123887712, "length": 0.05921232328798554, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6989306139678094, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6169141284281716, "upper_button_position": 0.0820164855396378}], "rail_length": 5, "inclination": 82.66250941837437, "heading": 51.8163456716249} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 1, "radius": 0.06350508115972937, "mass": 14.906764030320774, "I_11_without_motor": 6.321, "I_22_without_motor": 6.332614240778358, "I_33_without_motor": 0.032548280432326035, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.1314655019296, "trigger": 800, "sampling_rate": 105, "lag": 1.585236959922436, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.00670925931133, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7910842447208755, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6835.743103882098, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03303410945587017, "grain_number": 5, "grain_density": 1816.0087082791188, "grain_outer_radius": 0.03297010098654171, "grain_initial_inner_radius": 0.015317003102830207, "grain_initial_height": 0.12182376707803726, "grain_separation": 0.0027595682653325207, "grains_center_of_mass_position": 0.39586002002451076, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.001383263015482303, "throat_radius": 0.01061604442869967, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2550563220190505}], "aerodynamic_surfaces": [{"length": 0.5582747983454609, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1338111786693938]}, {"n": 4, "root_chord": 0.12035088651766729, "tip_chord": 0.06033904263684236, "span": 0.11086711947537538, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.05056962948637]}, {"top_radius": 0.06259444074688274, "bottom_radius": 0.044304101908211255, "length": 0.06019576431179175, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7014645175249009, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6179759213664193, "upper_button_position": 0.08348859615848159}], "rail_length": 5, "inclination": 83.54581353537868, "heading": 53.33504342574518} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 22, "radius": 0.06350279525433856, "mass": 15.079726308932507, "I_11_without_motor": 6.321, "I_22_without_motor": 6.321573596121193, "I_33_without_motor": 0.052029932619906016, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.064804018007504, "trigger": 800, "sampling_rate": 105, "lag": 1.4698430591084484, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9232606010826354, "trigger": "apogee", "sampling_rate": 105, "lag": 1.461215042765483, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7256.565275020275, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03340123307811307, "grain_number": 5, "grain_density": 1840.735276556465, "grain_outer_radius": 0.033143502255780416, "grain_initial_inner_radius": 0.015231953324966354, "grain_initial_height": 0.12114596568233399, "grain_separation": 0.0022352781316530702, "grains_center_of_mass_position": 0.397183479588522, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0011295604339312609, "throat_radius": 0.011248352425675857, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548223020777387}], "aerodynamic_surfaces": [{"length": 0.5579397744954074, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1333465577266038]}, {"n": 4, "root_chord": 0.12065492405149036, "tip_chord": 0.05978308596814549, "span": 0.11058923015763192, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0489675732803987]}, {"top_radius": 0.06345964106367127, "bottom_radius": 0.04319341747494364, "length": 0.06080431687843, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7002895383307389, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6178316145099039, "upper_button_position": 0.08245792382083506}], "rail_length": 5, "inclination": 84.00979106853103, "heading": 52.573723153993186} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 1, "radius": 0.06349928001026219, "mass": 15.06570967650027, "I_11_without_motor": 6.321, "I_22_without_motor": 6.322092540916452, "I_33_without_motor": 0.04767145939065197, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.960365660917095, "trigger": 800, "sampling_rate": 105, "lag": 1.453237317978458, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8565158896144405, "trigger": "apogee", "sampling_rate": 105, "lag": 1.516866089204166, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5720.589245204529, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03345305709290904, "grain_number": 5, "grain_density": 1805.2951782313703, "grain_outer_radius": 0.03280492984174041, "grain_initial_inner_radius": 0.01470483637132756, "grain_initial_height": 0.11924581792071379, "grain_separation": 0.004585293781336399, "grains_center_of_mass_position": 0.3971015082864182, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0006304677928403056, "throat_radius": 0.010616896410004469, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2543536853527917}], "aerodynamic_surfaces": [{"length": 0.559613843606631, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1341460039850042]}, {"n": 4, "root_chord": 0.12007717712184073, "tip_chord": 0.06014898484709693, "span": 0.11011775772637664, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.050326371994986]}, {"top_radius": 0.06513346101633884, "bottom_radius": 0.044078635819838806, "length": 0.060242702253202364, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.699959255661251, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6190222908977664, "upper_button_position": 0.08093696476348455}], "rail_length": 5, "inclination": 84.38391613878784, "heading": 52.38590767434992} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 3, "radius": 0.06349360455926858, "mass": 14.41240179186806, "I_11_without_motor": 6.321, "I_22_without_motor": 6.324893290095144, "I_33_without_motor": 0.04739462579687119, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.103904131050887, "trigger": 800, "sampling_rate": 105, "lag": 1.5464620064494783, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9918418977153363, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3994935164927669, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 8213.353251264492, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03296069774132139, "grain_number": 5, "grain_density": 1748.2042914731965, "grain_outer_radius": 0.03302778927387984, "grain_initial_inner_radius": 0.01452041803325679, "grain_initial_height": 0.11973576790235564, "grain_separation": 0.0044877209092750985, "grains_center_of_mass_position": 0.39849352236046437, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0007448821745868224, "throat_radius": 0.010567814449118354, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254346443947536}], "aerodynamic_surfaces": [{"length": 0.5585481856423747, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1335738768433299]}, {"n": 4, "root_chord": 0.12049144984639884, "tip_chord": 0.06009687764860615, "span": 0.11007761338967989, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0485952079037033]}, {"top_radius": 0.06406083801263061, "bottom_radius": 0.04375817740511762, "length": 0.05817060187939539, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6989525014670805, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6184542783640068, "upper_button_position": 0.08049822310307375}], "rail_length": 5, "inclination": 84.0187599565203, "heading": 52.21587371024279} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 8, "radius": 0.06351461916945023, "mass": 15.72120103134193, "I_11_without_motor": 6.321, "I_22_without_motor": 6.320270473698307, "I_33_without_motor": 0.047394256474891636, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.891406175298021, "trigger": 800, "sampling_rate": 105, "lag": 1.5187966523751615, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0632097751866945, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5986766570656645, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7976.658907594454, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03261755272228307, "grain_number": 5, "grain_density": 1788.4452838608797, "grain_outer_radius": 0.03194703582990407, "grain_initial_inner_radius": 0.015059965954195639, "grain_initial_height": 0.12063364793118307, "grain_separation": 0.0067145174250320865, "grains_center_of_mass_position": 0.3954802866652683, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0005801938743106314, "throat_radius": 0.011741871036135096, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.25448476882896}], "aerodynamic_surfaces": [{"length": 0.5571698904720201, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133336706467525]}, {"n": 4, "root_chord": 0.11990929321464576, "tip_chord": 0.06019154955791368, "span": 0.10907794255102529, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0495646454906975]}, {"top_radius": 0.0633928246694875, "bottom_radius": 0.044138659080206026, "length": 0.058566554215041804, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.69884725424692, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6183020275169964, "upper_button_position": 0.08054522672992359}], "rail_length": 5, "inclination": 83.53616800104072, "heading": 51.12808649566635} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 29, "radius": 0.06349875372499889, "mass": 15.52174848568608, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3144702798962555, "I_33_without_motor": 0.03155654105979724, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.150987379633719, "trigger": 800, "sampling_rate": 105, "lag": 1.5094082349627624, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.1474910908160763, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5253169971490854, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6985.1509150213515, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03406823309765977, "grain_number": 5, "grain_density": 1839.958319286012, "grain_outer_radius": 0.03305834160739747, "grain_initial_inner_radius": 0.015100562067457328, "grain_initial_height": 0.12084662100585823, "grain_separation": 0.005060721220757177, "grains_center_of_mass_position": 0.3977591987035246, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0004644006000592094, "throat_radius": 0.011377757096306876, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2559696807706626}], "aerodynamic_surfaces": [{"length": 0.558685327635886, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1348404752858852]}, {"n": 4, "root_chord": 0.12027042591129904, "tip_chord": 0.06016555756058694, "span": 0.11034169133769682, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0499666010623931]}, {"top_radius": 0.06389615055310356, "bottom_radius": 0.044013280181217224, "length": 0.059668445057651336, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6998735921147853, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6188400044420388, "upper_button_position": 0.08103358767274649}], "rail_length": 5, "inclination": 84.06179075879434, "heading": 51.89275923627153} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 15, "radius": 0.06350285139159496, "mass": 14.879636800722132, "I_11_without_motor": 6.321, "I_22_without_motor": 6.315619551337431, "I_33_without_motor": 0.03226393124986411, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.940166960888194, "trigger": 800, "sampling_rate": 105, "lag": 1.557278756713315, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9415985835572387, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7511041459337855, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6404.590304023814, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03338974133172039, "grain_number": 5, "grain_density": 1795.6513684627625, "grain_outer_radius": 0.0326900313594425, "grain_initial_inner_radius": 0.014820840979368548, "grain_initial_height": 0.11949501907655767, "grain_separation": 0.006741790016212349, "grains_center_of_mass_position": 0.3981427377147511, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0013433006593573185, "throat_radius": 0.010938108096252556, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.256919570094355}], "aerodynamic_surfaces": [{"length": 0.5573690266628984, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1348639567481815]}, {"n": 4, "root_chord": 0.12001622345599351, "tip_chord": 0.06077230409397119, "span": 0.11057405256458534, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0501091619135627]}, {"top_radius": 0.06407685568245465, "bottom_radius": 0.04292621530804189, "length": 0.06105343705276093, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6993449447206226, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6180904564334666, "upper_button_position": 0.08125448828715598}], "rail_length": 5, "inclination": 85.01744980068563, "heading": 52.44370578679336} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 17, "radius": 0.06350419070653365, "mass": 14.446850423296695, "I_11_without_motor": 6.321, "I_22_without_motor": 6.340403983267, "I_33_without_motor": 0.0013035065729761763, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.950468761358355, "trigger": 800, "sampling_rate": 105, "lag": 1.4255164516946592, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9961488765236984, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2033510758496146, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4953.890748247072, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032321282956486355, "grain_number": 5, "grain_density": 1925.8116427829807, "grain_outer_radius": 0.033329656905461226, "grain_initial_inner_radius": 0.014786019498855552, "grain_initial_height": 0.1189396871381035, "grain_separation": 0.003515376820615912, "grains_center_of_mass_position": 0.39760726411872865, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.002134807712007253, "throat_radius": 0.010454841459959256, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2552737871007522}], "aerodynamic_surfaces": [{"length": 0.5594800415657328, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.132628812342153]}, {"n": 4, "root_chord": 0.1206214582088253, "tip_chord": 0.059568289353501225, "span": 0.11039494159657012, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0500630206489185]}, {"top_radius": 0.06400765342799139, "bottom_radius": 0.044000083851521495, "length": 0.05988332401905376, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7000812201972062, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6190009381001828, "upper_button_position": 0.08108028209702345}], "rail_length": 5, "inclination": 84.422305378073, "heading": 52.475647171932145} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 1, "radius": 0.06350265595738074, "mass": 15.982168053307154, "I_11_without_motor": 6.321, "I_22_without_motor": 6.325056227712188, "I_33_without_motor": 0.02471340568145637, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.900811771524102, "trigger": 800, "sampling_rate": 105, "lag": 1.4715942030746079, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9749217135547606, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6502146624092577, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5770.517332006628, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033573040277917285, "grain_number": 5, "grain_density": 1833.9939023815473, "grain_outer_radius": 0.03289637708238185, "grain_initial_inner_radius": 0.014869179069359561, "grain_initial_height": 0.12009574200624915, "grain_separation": 0.0035856760780511032, "grains_center_of_mass_position": 0.3981955137521441, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0017524902169512625, "throat_radius": 0.011131997828966922, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2553387420934647}], "aerodynamic_surfaces": [{"length": 0.5568354661038059, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1341715843987137]}, {"n": 4, "root_chord": 0.12083598780842864, "tip_chord": 0.05960027098068451, "span": 0.11070755986788783, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0499393341021155]}, {"top_radius": 0.06268884905086451, "bottom_radius": 0.04412858769671177, "length": 0.06102353112627221, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997385079644506, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6183908945877536, "upper_button_position": 0.08134761337669694}], "rail_length": 5, "inclination": 85.27209407875938, "heading": 54.190666742860444} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 12, "radius": 0.06350299968737849, "mass": 15.129294772224442, "I_11_without_motor": 6.321, "I_22_without_motor": 6.325292179261114, "I_33_without_motor": 0.04030884205613722, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.896207814847713, "trigger": 800, "sampling_rate": 105, "lag": 1.5649182546152611, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8704696755097593, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4299433950094835, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5889.20702699435, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033477077464184754, "grain_number": 5, "grain_density": 1774.81181830841, "grain_outer_radius": 0.0328896606631102, "grain_initial_inner_radius": 0.014951437704814474, "grain_initial_height": 0.11809364556115116, "grain_separation": 0.0037159356402908833, "grains_center_of_mass_position": 0.39910621007343594, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0008600071351897885, "throat_radius": 0.01173267448889813, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2538392065792738}], "aerodynamic_surfaces": [{"length": 0.5590018174792856, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1352701022377598]}, {"n": 4, "root_chord": 0.12017862010002704, "tip_chord": 0.05989485134507201, "span": 0.10989769336716282, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0492381151006787]}, {"top_radius": 0.06478232771104268, "bottom_radius": 0.04322299879774567, "length": 0.05947832921729899, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7008143164103382, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6170750818837223, "upper_button_position": 0.08373923452661591}], "rail_length": 5, "inclination": 84.34437274993806, "heading": 53.93575339928429} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 8, "radius": 0.06349887901917879, "mass": 14.908900180107135, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3383172725705474, "I_33_without_motor": 0.025212036043287478, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.950150753973224, "trigger": 800, "sampling_rate": 105, "lag": 1.5403363381738076, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0344703111778326, "trigger": "apogee", "sampling_rate": 105, "lag": 1.841613070432098, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6306.432041999074, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03339587869190484, "grain_number": 5, "grain_density": 1805.5491626907615, "grain_outer_radius": 0.03279250298769639, "grain_initial_inner_radius": 0.014846522447359487, "grain_initial_height": 0.11852118665628893, "grain_separation": 0.004863210140639914, "grains_center_of_mass_position": 0.3975713150355508, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00043134535986236086, "throat_radius": 0.011588191496208784, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2547996887266022}], "aerodynamic_surfaces": [{"length": 0.5589046284272716, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.131665032204105]}, {"n": 4, "root_chord": 0.11976524532581982, "tip_chord": 0.060191214487939154, "span": 0.11063467862622987, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0512644707515444]}, {"top_radius": 0.06518729061669487, "bottom_radius": 0.04321760112969352, "length": 0.060661857819613994, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6984055609698314, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6177677348672254, "upper_button_position": 0.08063782610260606}], "rail_length": 5, "inclination": 83.29911765210288, "heading": 50.36919478460611} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 9, "radius": 0.06350028897313414, "mass": 15.874329757019883, "I_11_without_motor": 6.321, "I_22_without_motor": 6.325629498551334, "I_33_without_motor": 0.0330658281237145, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.113081852709353, "trigger": 800, "sampling_rate": 105, "lag": 1.5443059640260122, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0514581386283555, "trigger": "apogee", "sampling_rate": 105, "lag": 1.2893777431690934, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5856.250694728396, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03257323064928406, "grain_number": 5, "grain_density": 1821.2471097776988, "grain_outer_radius": 0.03307940544802427, "grain_initial_inner_radius": 0.014599262392719015, "grain_initial_height": 0.12185739034849959, "grain_separation": 0.005086332754855426, "grains_center_of_mass_position": 0.396257765860305, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0003085527648507209, "throat_radius": 0.011025573388122541, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548594817324203}], "aerodynamic_surfaces": [{"length": 0.5570003027061665, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1324518575478195]}, {"n": 4, "root_chord": 0.12043550822077433, "tip_chord": 0.06054714413296922, "span": 0.1093116317662277, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0510606132034135]}, {"top_radius": 0.06430330379963214, "bottom_radius": 0.042564059212328184, "length": 0.06140519639062275, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7019880394650353, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6188909496331936, "upper_button_position": 0.08309708983184172}], "rail_length": 5, "inclination": 84.22655015135797, "heading": 50.161628032700364} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 24, "radius": 0.06350601433065407, "mass": 15.27137233655113, "I_11_without_motor": 6.321, "I_22_without_motor": 6.300798198061935, "I_33_without_motor": 0.02137004367111585, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.998862201470702, "trigger": 800, "sampling_rate": 105, "lag": 1.5519932566494046, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0470064434345545, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5016451153311843, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7507.457954812889, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03296985470418464, "grain_number": 5, "grain_density": 1768.1816104939548, "grain_outer_radius": 0.03280639358265971, "grain_initial_inner_radius": 0.014606602717007382, "grain_initial_height": 0.12052048127614555, "grain_separation": 0.005583702001739207, "grains_center_of_mass_position": 0.3962570974679449, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0005508659076352886, "throat_radius": 0.010562014975168682, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2556945675888942}], "aerodynamic_surfaces": [{"length": 0.5571598712095784, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1341668960182867]}, {"n": 4, "root_chord": 0.12003815798814604, "tip_chord": 0.05980345832826959, "span": 0.1098800377955311, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.049899314543478]}, {"top_radius": 0.06316720845139089, "bottom_radius": 0.04340125221267471, "length": 0.06148964911894322, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6986922365641621, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6187687187018772, "upper_button_position": 0.07992351786228491}], "rail_length": 5, "inclination": 83.54080428492915, "heading": 53.44038241307092} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 7, "radius": 0.06349856448014375, "mass": 15.358370684317368, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3222345096299115, "I_33_without_motor": 0.02572546994214788, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.045187619282522, "trigger": 800, "sampling_rate": 105, "lag": 1.542490410308309, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.001272707258571, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3570579711793753, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6882.561778763908, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032608758666212184, "grain_number": 5, "grain_density": 1786.977399493363, "grain_outer_radius": 0.032941341907205095, "grain_initial_inner_radius": 0.015192380004538944, "grain_initial_height": 0.11881765503576278, "grain_separation": 0.005330974959019586, "grains_center_of_mass_position": 0.39725339808839444, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0010342129808944276, "throat_radius": 0.010083511038810002, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2543941278962114}], "aerodynamic_surfaces": [{"length": 0.5587810386460624, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133501354456158]}, {"n": 4, "root_chord": 0.11976191347978447, "tip_chord": 0.06031697763020787, "span": 0.10937836909154659, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0487621165011132]}, {"top_radius": 0.0644644492465009, "bottom_radius": 0.04325154743197436, "length": 0.06164649617383124, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.700311394963643, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.617312907001044, "upper_button_position": 0.08299848796259901}], "rail_length": 5, "inclination": 83.6138857416783, "heading": 53.15058153375897} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 9, "radius": 0.0634981813899827, "mass": 14.859267428427884, "I_11_without_motor": 6.321, "I_22_without_motor": 6.316954112738651, "I_33_without_motor": 0.02765475608430546, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.12348387601264, "trigger": 800, "sampling_rate": 105, "lag": 1.586989690186621, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0437775709689083, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5919514964529435, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6911.718333537482, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03323992749846229, "grain_number": 5, "grain_density": 1864.9016814407896, "grain_outer_radius": 0.03308728808508502, "grain_initial_inner_radius": 0.014683137425875183, "grain_initial_height": 0.1195874525594654, "grain_separation": 0.004857937649601254, "grains_center_of_mass_position": 0.3979359284543769, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00027485770574221406, "throat_radius": 0.01096828145733743, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254036876518058}], "aerodynamic_surfaces": [{"length": 0.5599183925022974, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1340088316484347]}, {"n": 4, "root_chord": 0.11942754487678753, "tip_chord": 0.06039599279937518, "span": 0.10984471967500362, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0509062230937016]}, {"top_radius": 0.06387595669150617, "bottom_radius": 0.04407715118801431, "length": 0.06071033247041186, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6999095056255527, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6167892445965332, "upper_button_position": 0.08312026102901948}], "rail_length": 5, "inclination": 85.93535290191042, "heading": 52.899414193888575} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 6, "radius": 0.0635109068171948, "mass": 15.633929781859923, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32413616153479, "I_33_without_motor": 0.03969900263775091, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.834362560642212, "trigger": 800, "sampling_rate": 105, "lag": 1.4258336009538153, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8912650468491736, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4521038685651637, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4974.817900447082, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033786578735444224, "grain_number": 5, "grain_density": 1746.8336950386788, "grain_outer_radius": 0.03279394214698376, "grain_initial_inner_radius": 0.015481373324010166, "grain_initial_height": 0.12022904373395915, "grain_separation": 0.003120285333965617, "grains_center_of_mass_position": 0.39711704679850884, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.001092892933712505, "throat_radius": 0.010893978680199414, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2557822082475814}], "aerodynamic_surfaces": [{"length": 0.5576492667259434, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1332263389142034]}, {"n": 4, "root_chord": 0.12072153231188552, "tip_chord": 0.05956047058002806, "span": 0.1095930062327995, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0503483533516376]}, {"top_radius": 0.06577505427999941, "bottom_radius": 0.043057787723638406, "length": 0.06057548259168792, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7014103970415169, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6183357107062871, "upper_button_position": 0.08307468633522974}], "rail_length": 5, "inclination": 84.18931587843701, "heading": 54.76429406471985} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 9, "radius": 0.06350739738241934, "mass": 14.970067335874123, "I_11_without_motor": 6.321, "I_22_without_motor": 6.308709317869596, "I_33_without_motor": 0.023538652012588535, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.996146328714246, "trigger": 800, "sampling_rate": 105, "lag": 1.4894377928376885, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0637967587480892, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4197552944025036, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7489.692061936832, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03254810364795023, "grain_number": 5, "grain_density": 1774.2887765854352, "grain_outer_radius": 0.032966655945223314, "grain_initial_inner_radius": 0.014842115968309474, "grain_initial_height": 0.11967731849857424, "grain_separation": 0.0023056409013189065, "grains_center_of_mass_position": 0.3981500175385283, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0006403021933827702, "throat_radius": 0.010817054503619824, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254063979969307}], "aerodynamic_surfaces": [{"length": 0.5587251191242447, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1344595537953381]}, {"n": 4, "root_chord": 0.12000658315386675, "tip_chord": 0.05988368920954532, "span": 0.10882738429387277, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0512731206666894]}, {"top_radius": 0.06401157697070317, "bottom_radius": 0.04402080285541102, "length": 0.06139041685117537, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6991978745687002, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6189370304572878, "upper_button_position": 0.08026084411141243}], "rail_length": 5, "inclination": 85.37536372514, "heading": 54.60708771420984} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 0, "radius": 0.06349902716433935, "mass": 15.031764351768178, "I_11_without_motor": 6.321, "I_22_without_motor": 6.321078321139381, "I_33_without_motor": 0.02484114491816245, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.112845655490997, "trigger": 800, "sampling_rate": 105, "lag": 1.4628219883138003, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8675669253380869, "trigger": "apogee", "sampling_rate": 105, "lag": 1.629724002234014, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6587.835206234734, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032715030291042065, "grain_number": 5, "grain_density": 1815.6587832894024, "grain_outer_radius": 0.03287905286539368, "grain_initial_inner_radius": 0.014992477710058136, "grain_initial_height": 0.12013537101805616, "grain_separation": 0.004504900421298859, "grains_center_of_mass_position": 0.39720090106779565, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00022033362393753122, "throat_radius": 0.011407593804265002, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2557425030428124}], "aerodynamic_surfaces": [{"length": 0.557966236998059, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1325285545264012]}, {"n": 4, "root_chord": 0.11941284851935915, "tip_chord": 0.05964851838161797, "span": 0.10976884631153055, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0493926197471277]}, {"top_radius": 0.06540213729157832, "bottom_radius": 0.044118083682024266, "length": 0.05942680550497701, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6984584080241735, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6187396730240534, "upper_button_position": 0.07971873500012006}], "rail_length": 5, "inclination": 83.64931191625233, "heading": 52.14542323283142} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 25, "radius": 0.06349853153743018, "mass": 15.800512063015404, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3230678320389195, "I_33_without_motor": 0.020632005492927256, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.064467551098277, "trigger": 800, "sampling_rate": 105, "lag": 1.42202349815714, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0211207849600876, "trigger": "apogee", "sampling_rate": 105, "lag": 1.294859378293711, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7327.188379174152, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03259678841686081, "grain_number": 5, "grain_density": 1770.7774641132228, "grain_outer_radius": 0.03364004279869712, "grain_initial_inner_radius": 0.0150071044594583, "grain_initial_height": 0.11978473437064659, "grain_separation": 0.004754878760393469, "grains_center_of_mass_position": 0.3948520417707456, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00041347157387067553, "throat_radius": 0.011090102521921098, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2564463067858118}], "aerodynamic_surfaces": [{"length": 0.5558310947742208, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1352685862009912]}, {"n": 4, "root_chord": 0.11945534314868292, "tip_chord": 0.05974861261669031, "span": 0.11069627174592134, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0484052632875618]}, {"top_radius": 0.06418729299507252, "bottom_radius": 0.04200329864929718, "length": 0.06029706779320863, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.699241641625261, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6182094016700278, "upper_button_position": 0.08103223995523323}], "rail_length": 5, "inclination": 84.50692064329158, "heading": 52.74761235497692} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 24, "radius": 0.06349779245926947, "mass": 15.83040838516131, "I_11_without_motor": 6.321, "I_22_without_motor": 6.307331480924691, "I_33_without_motor": 0.049734808569556144, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.986868907743112, "trigger": 800, "sampling_rate": 105, "lag": 1.306487374733884, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9999071401334688, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6624474606486757, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5100.176434958228, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03318709362846449, "grain_number": 5, "grain_density": 1884.3206172743958, "grain_outer_radius": 0.033229322295293955, "grain_initial_inner_radius": 0.01566407995973153, "grain_initial_height": 0.11939338823721432, "grain_separation": 0.00337919104444369, "grains_center_of_mass_position": 0.3964436415480343, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00041657452213572963, "throat_radius": 0.010038637515811466, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2549920011394837}], "aerodynamic_surfaces": [{"length": 0.5588806667686737, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1335087302986846]}, {"n": 4, "root_chord": 0.12096911434440984, "tip_chord": 0.060579532205768616, "span": 0.10942215935242752, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0489371105203595]}, {"top_radius": 0.06479727766674391, "bottom_radius": 0.042455281436162735, "length": 0.058961199571552006, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6992568250269238, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6170209376914776, "upper_button_position": 0.08223588733544618}], "rail_length": 5, "inclination": 85.31260312126922, "heading": 54.60310557901257} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 25, "radius": 0.0635034767740691, "mass": 14.473133168807818, "I_11_without_motor": 6.321, "I_22_without_motor": 6.314157512663184, "I_33_without_motor": 0.04889696873324676, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.166180032806391, "trigger": 800, "sampling_rate": 105, "lag": 1.444443190573961, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9222518517648833, "trigger": "apogee", "sampling_rate": 105, "lag": 1.578967793691044, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6747.593181220529, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03339213844272024, "grain_number": 5, "grain_density": 1766.5251094854266, "grain_outer_radius": 0.033049770480977514, "grain_initial_inner_radius": 0.015072758398978614, "grain_initial_height": 0.11954237196440844, "grain_separation": 0.006747663723533158, "grains_center_of_mass_position": 0.39728163201573646, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00040915838828450114, "throat_radius": 0.011106433784606226, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2549789089031034}], "aerodynamic_surfaces": [{"length": 0.5573615383899484, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1345157262485654]}, {"n": 4, "root_chord": 0.12000584296683708, "tip_chord": 0.06039242720272283, "span": 0.10944203375023989, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0478399658762683]}, {"top_radius": 0.06427304844014263, "bottom_radius": 0.04362518924575842, "length": 0.059429250291222945, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7016961426113497, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6167772016982755, "upper_button_position": 0.08491894091307417}], "rail_length": 5, "inclination": 84.14429779895038, "heading": 52.00650236133977} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 3, "radius": 0.06349743451992218, "mass": 15.036209974819245, "I_11_without_motor": 6.321, "I_22_without_motor": 6.328157884606955, "I_33_without_motor": 0.020809858026901485, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.933585095155895, "trigger": 800, "sampling_rate": 105, "lag": 1.597479007780775, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.031554050082618, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4940038776674385, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5461.218409447379, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033178989012976015, "grain_number": 5, "grain_density": 1846.1531627920788, "grain_outer_radius": 0.03343898860151159, "grain_initial_inner_radius": 0.016206673218069706, "grain_initial_height": 0.1191992730196467, "grain_separation": 0.0041334748134873155, "grains_center_of_mass_position": 0.39722733218563683, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0009667365815448472, "throat_radius": 0.01030357376889579, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2563677102876298}], "aerodynamic_surfaces": [{"length": 0.5589870716448792, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133722241800354]}, {"n": 4, "root_chord": 0.12083847429163766, "tip_chord": 0.060012508576741064, "span": 0.10904424651889484, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0497846202268302]}, {"top_radius": 0.06440493671436263, "bottom_radius": 0.043586877621665035, "length": 0.05953915724976317, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.698042811757638, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6172510529884843, "upper_button_position": 0.08079175876915379}], "rail_length": 5, "inclination": 83.96012019982963, "heading": 54.47657582359791} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 10, "radius": 0.06350175690119066, "mass": 14.549142208122827, "I_11_without_motor": 6.321, "I_22_without_motor": 6.326594091088183, "I_33_without_motor": 0.03710090262067121, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.918779719478051, "trigger": 800, "sampling_rate": 105, "lag": 1.5532740210965583, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8717575472916979, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6684736124636208, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7945.843186034017, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03289418847549375, "grain_number": 5, "grain_density": 1709.241093432216, "grain_outer_radius": 0.0325544293938807, "grain_initial_inner_radius": 0.015435461971633799, "grain_initial_height": 0.11901578165042781, "grain_separation": 0.0071511540336217354, "grains_center_of_mass_position": 0.3973355496372836, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0007628134779484506, "throat_radius": 0.010835780912748595, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2562548633384836}], "aerodynamic_surfaces": [{"length": 0.5592623692045254, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133809753309572]}, {"n": 4, "root_chord": 0.1200839555239807, "tip_chord": 0.05994580624437321, "span": 0.11034898118263718, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0494388771403702]}, {"top_radius": 0.06462883225148824, "bottom_radius": 0.04330043979825882, "length": 0.06041294199200335, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7000916725817011, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6175799723745381, "upper_button_position": 0.08251170020716303}], "rail_length": 5, "inclination": 84.63883968201144, "heading": 51.776176862661856} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 28, "radius": 0.06349705629815046, "mass": 14.123173705271643, "I_11_without_motor": 6.321, "I_22_without_motor": 6.321789717956909, "I_33_without_motor": 0.03757242012180704, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.933864321276971, "trigger": 800, "sampling_rate": 105, "lag": 1.3772029200894804, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0460831129194414, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7251040755779377, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 8380.428087484768, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03356381530138269, "grain_number": 5, "grain_density": 1778.8018692672638, "grain_outer_radius": 0.032601232663090625, "grain_initial_inner_radius": 0.015407918126331977, "grain_initial_height": 0.11946226618104315, "grain_separation": 0.003888874755026696, "grains_center_of_mass_position": 0.39648179816859264, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00010676080828896992, "throat_radius": 0.011914432665832444, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2557821487789416}], "aerodynamic_surfaces": [{"length": 0.5597763110459355, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1343778835318552]}, {"n": 4, "root_chord": 0.12052811157713465, "tip_chord": 0.0589963588844005, "span": 0.10906376174051868, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0490279322785745]}, {"top_radius": 0.06256583437416038, "bottom_radius": 0.04262291865880592, "length": 0.061321036336889706, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6999880172218871, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.617865706959014, "upper_button_position": 0.08212231026287309}], "rail_length": 5, "inclination": 84.99111462213077, "heading": 55.64381195735424} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 3, "radius": 0.06350712392139016, "mass": 14.757195794026398, "I_11_without_motor": 6.321, "I_22_without_motor": 6.314946562983625, "I_33_without_motor": 0.0413199832719251, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.926631088450291, "trigger": 800, "sampling_rate": 105, "lag": 1.614295195681567, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0614639608042675, "trigger": "apogee", "sampling_rate": 105, "lag": 0.9597354377586996, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6018.729975018477, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03292182548393906, "grain_number": 5, "grain_density": 1773.9816977872733, "grain_outer_radius": 0.03286325894637418, "grain_initial_inner_radius": 0.015208531177743352, "grain_initial_height": 0.11803009505850094, "grain_separation": 0.006183718692156587, "grains_center_of_mass_position": 0.3984108330378667, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0007785344345249372, "throat_radius": 0.010540839128373464, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2563649483166277}], "aerodynamic_surfaces": [{"length": 0.5592344342181025, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1342717809565317]}, {"n": 4, "root_chord": 0.12046562900988994, "tip_chord": 0.06015563965097916, "span": 0.11033953352236586, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0501540504579356]}, {"top_radius": 0.06265764135964348, "bottom_radius": 0.042796437579250356, "length": 0.05962491916009492, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6985486637619776, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173711707734717, "upper_button_position": 0.08117749298850585}], "rail_length": 5, "inclination": 84.27972185405488, "heading": 49.11395444365379} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 5, "radius": 0.06349439034172337, "mass": 14.511828482423246, "I_11_without_motor": 6.321, "I_22_without_motor": 6.322557061399875, "I_33_without_motor": 0.023858766674600802, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.999014528868885, "trigger": 800, "sampling_rate": 105, "lag": 1.5097901210455131, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9983767055783637, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7339958538677167, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5527.326388339707, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03319216579474029, "grain_number": 5, "grain_density": 1783.7190255339208, "grain_outer_radius": 0.032852794071041025, "grain_initial_inner_radius": 0.014970681871701585, "grain_initial_height": 0.11971804794880396, "grain_separation": 0.004879803995147723, "grains_center_of_mass_position": 0.3957458204141297, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0004388526374906204, "throat_radius": 0.010711310012743714, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255407265024171}], "aerodynamic_surfaces": [{"length": 0.5575487799632869, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1319916949927447]}, {"n": 4, "root_chord": 0.11976719404362368, "tip_chord": 0.0602899706761204, "span": 0.10951722560212694, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0491837633134198]}, {"top_radius": 0.06428310263768562, "bottom_radius": 0.042767384654531435, "length": 0.059757643693485386, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6981047632365266, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.619618773664377, "upper_button_position": 0.07848598957214958}], "rail_length": 5, "inclination": 85.45483499663216, "heading": 54.220028857512666} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 12, "radius": 0.06348897430717483, "mass": 15.058483311162382, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3211105500983225, "I_33_without_motor": 0.04368054003578594, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.806694743300474, "trigger": 800, "sampling_rate": 105, "lag": 1.3614997181239026, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0350322628023303, "trigger": "apogee", "sampling_rate": 105, "lag": 1.488708677510769, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 3390.0365457255234, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03329832702812169, "grain_number": 5, "grain_density": 1841.9056216115919, "grain_outer_radius": 0.03265677065908386, "grain_initial_inner_radius": 0.01496239709097564, "grain_initial_height": 0.11978120124839382, "grain_separation": 0.0046909039138377595, "grains_center_of_mass_position": 0.39652419549132584, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0006029574954276985, "throat_radius": 0.011139811102657401, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2534928158178336}], "aerodynamic_surfaces": [{"length": 0.5575443709218424, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1350695385716087]}, {"n": 4, "root_chord": 0.11985097167345075, "tip_chord": 0.05963472860749215, "span": 0.11027111820190999, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0489780726962399]}, {"top_radius": 0.0640996813261264, "bottom_radius": 0.04402776264876148, "length": 0.0614200691076832, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.699173144094483, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6166096855093683, "upper_button_position": 0.0825634585851146}], "rail_length": 5, "inclination": 83.67686652148507, "heading": 51.54488396734047} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 30, "radius": 0.06349246838909713, "mass": 14.826204145902281, "I_11_without_motor": 6.321, "I_22_without_motor": 6.322271890140243, "I_33_without_motor": 0.030662831007392553, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.945497373877698, "trigger": 800, "sampling_rate": 105, "lag": 1.4059600010241244, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.1268054769508686, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5478748618041258, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5176.828154802068, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033466378220068815, "grain_number": 5, "grain_density": 1781.2803700756092, "grain_outer_radius": 0.033622704626113296, "grain_initial_inner_radius": 0.014964989560786093, "grain_initial_height": 0.12112037554901918, "grain_separation": 0.004920474725492944, "grains_center_of_mass_position": 0.3969636433843197, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00023369905186361103, "throat_radius": 0.011788475871149442, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254266549869575}], "aerodynamic_surfaces": [{"length": 0.5576635013586334, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1339762614144924]}, {"n": 4, "root_chord": 0.11980545590277819, "tip_chord": 0.06003119121503844, "span": 0.11021512303867356, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.048162918289076]}, {"top_radius": 0.06215287024568877, "bottom_radius": 0.04353991021182836, "length": 0.059686603527171964, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6989219641076875, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6171773080284558, "upper_button_position": 0.08174465607923165}], "rail_length": 5, "inclination": 83.5604442635234, "heading": 53.39351157093405} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 7, "radius": 0.06349869140597078, "mass": 14.230120446345197, "I_11_without_motor": 6.321, "I_22_without_motor": 6.322198705483838, "I_33_without_motor": 0.0460586260595645, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.053143490032456, "trigger": 800, "sampling_rate": 105, "lag": 1.490070135913312, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8989419773806486, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5289319036937843, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6559.024357221486, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03319730326075547, "grain_number": 5, "grain_density": 1797.8957292224316, "grain_outer_radius": 0.03287147274515818, "grain_initial_inner_radius": 0.015151281478004326, "grain_initial_height": 0.12025202990673295, "grain_separation": 0.003959309636922095, "grains_center_of_mass_position": 0.39607013080810183, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0003962741879448741, "throat_radius": 0.010603587591186651, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.256055789328302}], "aerodynamic_surfaces": [{"length": 0.5582915458384061, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133268803385484]}, {"n": 4, "root_chord": 0.11994098837984403, "tip_chord": 0.059422708989922794, "span": 0.1097632816777115, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.050618027453366]}, {"top_radius": 0.06464450489184448, "bottom_radius": 0.0428688581243827, "length": 0.05989946211176852, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6994439031848404, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6175279982583463, "upper_button_position": 0.08191590492649414}], "rail_length": 5, "inclination": 85.5734203936308, "heading": 54.23748109698345} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 6, "radius": 0.06350859414346947, "mass": 15.08123397592947, "I_11_without_motor": 6.321, "I_22_without_motor": 6.327146902967929, "I_33_without_motor": 0.038358653698132746, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.185227155011349, "trigger": 800, "sampling_rate": 105, "lag": 1.6151479931612402, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9678223876898537, "trigger": "apogee", "sampling_rate": 105, "lag": 1.8070908043638352, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6577.049220883177, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03259700097307357, "grain_number": 5, "grain_density": 1889.2181195132098, "grain_outer_radius": 0.03281267011689317, "grain_initial_inner_radius": 0.015123000456895172, "grain_initial_height": 0.11847264426720913, "grain_separation": 0.005268131423275146, "grains_center_of_mass_position": 0.3973327145739362, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0016234323465176249, "throat_radius": 0.010835230795250126, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2548849957481993}], "aerodynamic_surfaces": [{"length": 0.5589633629929319, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1326835053032474]}, {"n": 4, "root_chord": 0.1199940157349497, "tip_chord": 0.06043123070468818, "span": 0.11000065592763485, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0496091812228723]}, {"top_radius": 0.06276768351463742, "bottom_radius": 0.044048138009539405, "length": 0.05925510722595696, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7026253750503199, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6175662233988229, "upper_button_position": 0.08505915165149691}], "rail_length": 5, "inclination": 85.62189855249338, "heading": 53.03933606508622} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 24, "radius": 0.06349285572117794, "mass": 14.0991917627014, "I_11_without_motor": 6.321, "I_22_without_motor": 6.302578184308834, "I_33_without_motor": 0.031192526030868573, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.112652889036847, "trigger": 800, "sampling_rate": 105, "lag": 1.4544041690223417, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.110808914694972, "trigger": "apogee", "sampling_rate": 105, "lag": 1.453024616529919, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6542.210093453685, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03215461280452752, "grain_number": 5, "grain_density": 1845.716865292814, "grain_outer_radius": 0.03337593093216716, "grain_initial_inner_radius": 0.014666509634611899, "grain_initial_height": 0.11982584607544652, "grain_separation": 0.004500199048877129, "grains_center_of_mass_position": 0.39725250572398374, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0005178740669312953, "throat_radius": 0.011887122187614736, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254494635467359}], "aerodynamic_surfaces": [{"length": 0.5582585865011, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1355608196819487]}, {"n": 4, "root_chord": 0.11967868525767447, "tip_chord": 0.06041915304652207, "span": 0.11067746328954345, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.050179759963341]}, {"top_radius": 0.062277315533638467, "bottom_radius": 0.04244566435902549, "length": 0.05812886068456072, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7011179624454615, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6164622486261881, "upper_button_position": 0.08465571381927339}], "rail_length": 5, "inclination": 85.28516776655833, "heading": 54.667427025718624} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 27, "radius": 0.06348830085282056, "mass": 14.882681968696248, "I_11_without_motor": 6.321, "I_22_without_motor": 6.296919223333103, "I_33_without_motor": 0.01735262091967832, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.038949419421275, "trigger": 800, "sampling_rate": 105, "lag": 1.663550509638369, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.10711558860621, "trigger": "apogee", "sampling_rate": 105, "lag": 1.851783766727872, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7018.328971240856, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032893145044193245, "grain_number": 5, "grain_density": 1820.949250316846, "grain_outer_radius": 0.03317081582341839, "grain_initial_inner_radius": 0.014767684909702001, "grain_initial_height": 0.12109336437516176, "grain_separation": 0.006751065574890648, "grains_center_of_mass_position": 0.39572180895868, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0011419891598097149, "throat_radius": 0.011470435308868307, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2538797326001356}], "aerodynamic_surfaces": [{"length": 0.5588231758083387, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134190447767395]}, {"n": 4, "root_chord": 0.11957936472301947, "tip_chord": 0.0596012810320038, "span": 0.10945902546471149, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0501113615661428]}, {"top_radius": 0.0634549757632317, "bottom_radius": 0.04257305378268893, "length": 0.0596555921107936, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7001154714685096, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6198215803456679, "upper_button_position": 0.08029389112284169}], "rail_length": 5, "inclination": 86.12913542246108, "heading": 54.35429031621445} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 8, "radius": 0.0635041630713396, "mass": 14.239149646523497, "I_11_without_motor": 6.321, "I_22_without_motor": 6.325401843417168, "I_33_without_motor": 0.0391906674942733, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.945290726653068, "trigger": 800, "sampling_rate": 105, "lag": 1.582706429176969, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.019018037048352, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5463022098488926, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7524.341754351671, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03302447704859476, "grain_number": 5, "grain_density": 1767.264966070118, "grain_outer_radius": 0.03273578260363594, "grain_initial_inner_radius": 0.014792063655201809, "grain_initial_height": 0.11944262930690712, "grain_separation": 0.005110137774917791, "grains_center_of_mass_position": 0.39578505089475297, "center_of_dry_mass_position": 0.317, "nozzle_position": -2.3175008766391544e-05, "throat_radius": 0.012330850972662987, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2537695068067107}], "aerodynamic_surfaces": [{"length": 0.5588215924463259, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1328834330713755]}, {"n": 4, "root_chord": 0.1199021935388457, "tip_chord": 0.06039293242532582, "span": 0.10966353700442702, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0492806676805786]}, {"top_radius": 0.06314336794599833, "bottom_radius": 0.04103506603327466, "length": 0.060918494828026845, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7001474161717912, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173932777304869, "upper_button_position": 0.0827541384413043}], "rail_length": 5, "inclination": 86.22967990849415, "heading": 50.53754878850209} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 30, "radius": 0.06350062494582949, "mass": 15.343970375031695, "I_11_without_motor": 6.321, "I_22_without_motor": 6.327279447330628, "I_33_without_motor": 0.026328274855093335, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.048288369115896, "trigger": 800, "sampling_rate": 105, "lag": 1.6228525387273725, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9669438069616259, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7479220198436785, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5973.9398228687205, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03315902554805301, "grain_number": 5, "grain_density": 1764.3383194857067, "grain_outer_radius": 0.032759471322047644, "grain_initial_inner_radius": 0.014404099387120476, "grain_initial_height": 0.11931497881514237, "grain_separation": 0.004442217531142403, "grains_center_of_mass_position": 0.3982944515942796, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00152255508622675, "throat_radius": 0.011407997384681222, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2539698024647843}], "aerodynamic_surfaces": [{"length": 0.5579938629651594, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.133090859957866]}, {"n": 4, "root_chord": 0.12051285093894681, "tip_chord": 0.06031276350597265, "span": 0.11018637183542702, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0502115726622683]}, {"top_radius": 0.06369659912199377, "bottom_radius": 0.04217611798127526, "length": 0.05970363858580814, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6971624767562781, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6195806465133274, "upper_button_position": 0.07758183024295062}], "rail_length": 5, "inclination": 86.27842755524009, "heading": 49.755545809360484} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 25, "radius": 0.06350744251137265, "mass": 15.09545405928696, "I_11_without_motor": 6.321, "I_22_without_motor": 6.30588824418657, "I_33_without_motor": 0.0331948403499901, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.96861324750267, "trigger": 800, "sampling_rate": 105, "lag": 1.573989669485147, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.005258938894275, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7205390488833778, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7045.211377396375, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0338996615367818, "grain_number": 5, "grain_density": 1764.0493333933991, "grain_outer_radius": 0.03271829974062877, "grain_initial_inner_radius": 0.015123293050648747, "grain_initial_height": 0.12116663363820428, "grain_separation": 0.004560852609572723, "grains_center_of_mass_position": 0.3973582622803934, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0007215085057244918, "throat_radius": 0.010784667189442848, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2556452149874053}], "aerodynamic_surfaces": [{"length": 0.5586659512479353, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1335278927889882]}, {"n": 4, "root_chord": 0.12071517883027967, "tip_chord": 0.0598883743408181, "span": 0.11061578599912787, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0504732528798342]}, {"top_radius": 0.061479208287981715, "bottom_radius": 0.04476953702172075, "length": 0.06073824962510204, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6992852406648619, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173146074716543, "upper_button_position": 0.08197063319320752}], "rail_length": 5, "inclination": 84.68319100123406, "heading": 54.189263990975526} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 17, "radius": 0.06349455718887169, "mass": 14.887415207410035, "I_11_without_motor": 6.321, "I_22_without_motor": 6.320465572362404, "I_33_without_motor": 0.030598423962824983, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.905167071652272, "trigger": 800, "sampling_rate": 105, "lag": 1.614389587965084, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9408958095850001, "trigger": "apogee", "sampling_rate": 105, "lag": 0.9863463094385564, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7802.112945200826, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03246697345486257, "grain_number": 5, "grain_density": 1870.2690491251096, "grain_outer_radius": 0.03294910037970672, "grain_initial_inner_radius": 0.015090361951501109, "grain_initial_height": 0.12118352267748121, "grain_separation": 0.00440899282780096, "grains_center_of_mass_position": 0.39605818443457236, "center_of_dry_mass_position": 0.317, "nozzle_position": -5.1847338411459676e-05, "throat_radius": 0.011430172565306212, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2554609815987887}], "aerodynamic_surfaces": [{"length": 0.5578690647847413, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.134076194493176]}, {"n": 4, "root_chord": 0.11952598259491723, "tip_chord": 0.06022399994528144, "span": 0.11062233320162532, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0504490373844608]}, {"top_radius": 0.06151230069881279, "bottom_radius": 0.042968606159515886, "length": 0.05838550568561321, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7024488641351397, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6173091818661893, "upper_button_position": 0.08513968226895041}], "rail_length": 5, "inclination": 86.45015632503704, "heading": 54.200319720269356} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 15, "radius": 0.06350488589791063, "mass": 14.430923854187728, "I_11_without_motor": 6.321, "I_22_without_motor": 6.31833401743427, "I_33_without_motor": 0.04073543950205016, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.00245743005434, "trigger": 800, "sampling_rate": 105, "lag": 1.42153396570128, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0678326366276096, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3685666231236249, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6190.163572455009, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0336974201355807, "grain_number": 5, "grain_density": 1737.1194229461462, "grain_outer_radius": 0.0336772460064573, "grain_initial_inner_radius": 0.015279909471779053, "grain_initial_height": 0.11939007713168291, "grain_separation": 0.0034895382643139825, "grains_center_of_mass_position": 0.3965372608832396, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.00048343945196766366, "throat_radius": 0.011484892642122496, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.255818472383435}], "aerodynamic_surfaces": [{"length": 0.559655232420582, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1342346704250672]}, {"n": 4, "root_chord": 0.12005812964672272, "tip_chord": 0.06012497141081534, "span": 0.10933218960725932, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0500228053433207]}, {"top_radius": 0.06307277956556913, "bottom_radius": 0.04460221393597581, "length": 0.06062859246228136, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.699985527922972, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6180555649715134, "upper_button_position": 0.0819299629514586}], "rail_length": 5, "inclination": 84.06735527187571, "heading": 51.627267512933734} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 21, "radius": 0.0634989618732998, "mass": 15.702657161423273, "I_11_without_motor": 6.321, "I_22_without_motor": 6.321853872089236, "I_33_without_motor": 0.04878757957731296, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.038654294373378, "trigger": 800, "sampling_rate": 105, "lag": 1.6521135153406716, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0853817897648086, "trigger": "apogee", "sampling_rate": 105, "lag": 1.446439603373895, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4701.825059972517, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03274441801914148, "grain_number": 5, "grain_density": 1881.0241258707003, "grain_outer_radius": 0.03278748778719712, "grain_initial_inner_radius": 0.015020305947445417, "grain_initial_height": 0.1206241846894501, "grain_separation": 0.00690279535991399, "grains_center_of_mass_position": 0.3970080431269157, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0012816968001657285, "throat_radius": 0.01157747292064822, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2543175432856517}], "aerodynamic_surfaces": [{"length": 0.5603041465473848, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1342603000011733]}, {"n": 4, "root_chord": 0.11978367368247034, "tip_chord": 0.061056613868349846, "span": 0.11009624704310296, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0477509663619837]}, {"top_radius": 0.06364377981582196, "bottom_radius": 0.043470905879548195, "length": 0.05941117959147104, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6995487854301886, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6193455246053537, "upper_button_position": 0.08020326082483487}], "rail_length": 5, "inclination": 84.28263463738632, "heading": 48.577058211496826} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 17, "radius": 0.06349859845820183, "mass": 15.536294576361628, "I_11_without_motor": 6.321, "I_22_without_motor": 6.339231283984124, "I_33_without_motor": 0.04589513462970105, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.007892456337862, "trigger": 800, "sampling_rate": 105, "lag": 1.4906798647356387, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9460983770926951, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7556917300574049, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 4679.861920183247, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.033040577513841395, "grain_number": 5, "grain_density": 1820.7981190446603, "grain_outer_radius": 0.0330556023630006, "grain_initial_inner_radius": 0.01453721731842722, "grain_initial_height": 0.12103284131427614, "grain_separation": 0.005176620900988839, "grains_center_of_mass_position": 0.39651051320917274, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.001035708872199685, "throat_radius": 0.01176007152483679, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2556297382157324}], "aerodynamic_surfaces": [{"length": 0.5594154225887948, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1332935332532756]}, {"n": 4, "root_chord": 0.11997215034129366, "tip_chord": 0.06035915286724394, "span": 0.10994396798128367, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.050812253903163]}, {"top_radius": 0.06263867674185546, "bottom_radius": 0.044815943242650744, "length": 0.059999092900904556, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6994799009720818, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6169006818224201, "upper_button_position": 0.08257921914966171}], "rail_length": 5, "inclination": 85.60311472426292, "heading": 50.2556874828904} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 24, "radius": 0.06350961652093641, "mass": 14.856898775437942, "I_11_without_motor": 6.321, "I_22_without_motor": 6.311328047398544, "I_33_without_motor": 0.044474806771103485, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.10899521269942, "trigger": 800, "sampling_rate": 105, "lag": 1.7176773093995306, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9740244605764622, "trigger": "apogee", "sampling_rate": 105, "lag": 1.4101895403322091, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5824.423080857596, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0329165804311135, "grain_number": 5, "grain_density": 1845.9886201595514, "grain_outer_radius": 0.03302902556555971, "grain_initial_inner_radius": 0.015576040053522847, "grain_initial_height": 0.11875703909590252, "grain_separation": 0.004053896559615764, "grains_center_of_mass_position": 0.3968781354080911, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0001481365017910036, "throat_radius": 0.010284320564042104, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2549957160646676}], "aerodynamic_surfaces": [{"length": 0.5596954913249531, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1343823013328866]}, {"n": 4, "root_chord": 0.11996165305879347, "tip_chord": 0.05904905572505063, "span": 0.10994195277364488, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0488102949844715]}, {"top_radius": 0.06285616353984486, "bottom_radius": 0.043290457846543604, "length": 0.059409674067830695, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7000914556866284, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6190780984698379, "upper_button_position": 0.0810133572167906}], "rail_length": 5, "inclination": 84.45430191304013, "heading": 53.24502927721654} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 19, "radius": 0.0635019236329062, "mass": 14.066185162053669, "I_11_without_motor": 6.321, "I_22_without_motor": 6.33023891562729, "I_33_without_motor": 0.03160067000255987, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.037375231463686, "trigger": 800, "sampling_rate": 105, "lag": 1.4654105108950752, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.0977041635896727, "trigger": "apogee", "sampling_rate": 105, "lag": 1.7576272456627253, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 5624.192436730688, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03251708588750148, "grain_number": 5, "grain_density": 1803.7522163713818, "grain_outer_radius": 0.03293303266411425, "grain_initial_inner_radius": 0.014902273644540855, "grain_initial_height": 0.12076586891362319, "grain_separation": 0.003659997951833788, "grains_center_of_mass_position": 0.39500881441197894, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0009530994108397453, "throat_radius": 0.011702072656281122, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2559121700163038}], "aerodynamic_surfaces": [{"length": 0.5575405435326249, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1336534885661131]}, {"n": 4, "root_chord": 0.11991950398135265, "tip_chord": 0.059950432311922486, "span": 0.11003586419562267, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0493939445897476]}, {"top_radius": 0.06180851293796316, "bottom_radius": 0.04432741685915527, "length": 0.05995575269620631, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7009476264141186, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6202947913017857, "upper_button_position": 0.0806528351123329}], "rail_length": 5, "inclination": 83.22674914284435, "heading": 52.95021700886993} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 22, "radius": 0.0634999279209893, "mass": 14.677466850170433, "I_11_without_motor": 6.321, "I_22_without_motor": 6.317240094313157, "I_33_without_motor": 0.028302190121379557, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.173383154679213, "trigger": 800, "sampling_rate": 105, "lag": 1.4070560375678367, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 1.1402584367530584, "trigger": "apogee", "sampling_rate": 105, "lag": 1.552687546048584, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7683.502058289, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03304670507665597, "grain_number": 5, "grain_density": 1738.4140881564338, "grain_outer_radius": 0.033017220758382315, "grain_initial_inner_radius": 0.014889639604763406, "grain_initial_height": 0.12040472145071134, "grain_separation": 0.004800166555709796, "grains_center_of_mass_position": 0.39529420477501054, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0007880229823142239, "throat_radius": 0.010690717026880089, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2533507712238883}], "aerodynamic_surfaces": [{"length": 0.5567767058256697, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1343240543575641]}, {"n": 4, "root_chord": 0.12047407976534229, "tip_chord": 0.06044261691821858, "span": 0.10897699951084462, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0499909383122348]}, {"top_radius": 0.06321244558310458, "bottom_radius": 0.042993573286898734, "length": 0.060690626113990294, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7000846075661536, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6193720023400624, "upper_button_position": 0.08071260522609125}], "rail_length": 5, "inclination": 86.2655551930799, "heading": 50.74057647173047} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 28, "radius": 0.06350324333844891, "mass": 14.416376730610171, "I_11_without_motor": 6.321, "I_22_without_motor": 6.31184314956329, "I_33_without_motor": 0.029277560506418797, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.169021112212215, "trigger": 800, "sampling_rate": 105, "lag": 1.3548254650030713, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9199799513884394, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3906165186174055, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6232.517433835797, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.032625285369376554, "grain_number": 5, "grain_density": 1851.914181639704, "grain_outer_radius": 0.03318698852189525, "grain_initial_inner_radius": 0.01568096604564223, "grain_initial_height": 0.1193343987949351, "grain_separation": 0.004615336351617327, "grains_center_of_mass_position": 0.3962425256515898, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0011052709121461357, "throat_radius": 0.011331315854668712, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2541039435133101}], "aerodynamic_surfaces": [{"length": 0.5583313806072471, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1346373766885023]}, {"n": 4, "root_chord": 0.12023781379374296, "tip_chord": 0.0600175571620146, "span": 0.11040102427643836, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0512571597959386]}, {"top_radius": 0.06149416957866327, "bottom_radius": 0.044634560306783984, "length": 0.05965379022287309, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6982160368214974, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6181734717646546, "upper_button_position": 0.08004256505684271}], "rail_length": 5, "inclination": 84.57525310803103, "heading": 52.98174404348843} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 19, "radius": 0.0634944444617853, "mass": 14.355525240406728, "I_11_without_motor": 6.321, "I_22_without_motor": 6.312629168787949, "I_33_without_motor": 0.02850104179259591, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.141247511278797, "trigger": 800, "sampling_rate": 105, "lag": 1.546145843698987, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9020516758614718, "trigger": "apogee", "sampling_rate": 105, "lag": 1.5452240565689404, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7129.174501402416, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03353239534540677, "grain_number": 5, "grain_density": 1900.060608340611, "grain_outer_radius": 0.03291508504511614, "grain_initial_inner_radius": 0.014352217371430113, "grain_initial_height": 0.11953919238939101, "grain_separation": 0.0045778818379726876, "grains_center_of_mass_position": 0.3961783989048371, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0013033964401244704, "throat_radius": 0.010891076621968561, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.254820835081322}], "aerodynamic_surfaces": [{"length": 0.5571351634791761, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1315414657736051]}, {"n": 4, "root_chord": 0.1200919892721906, "tip_chord": 0.05976820375727909, "span": 0.10947101236566135, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0510508470675448]}, {"top_radius": 0.06201059255974693, "bottom_radius": 0.043341140666026144, "length": 0.0599123412347966, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6989048217231505, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6186695958890003, "upper_button_position": 0.08023522583415021}], "rail_length": 5, "inclination": 83.51528103725204, "heading": 53.0014639854097} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 10, "radius": 0.06350106018608451, "mass": 13.924407077851685, "I_11_without_motor": 6.321, "I_22_without_motor": 6.326820881251539, "I_33_without_motor": 0.02986958528954678, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.048527966492273, "trigger": 800, "sampling_rate": 105, "lag": 1.5902006631592602, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.8892324749354281, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6251834376820244, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7508.10130715633, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0319240281027893, "grain_number": 5, "grain_density": 1850.5926783128011, "grain_outer_radius": 0.033664223984823535, "grain_initial_inner_radius": 0.015028732842170876, "grain_initial_height": 0.11957256826203207, "grain_separation": 0.005044535978620604, "grains_center_of_mass_position": 0.3955556218664703, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0006066331835518567, "throat_radius": 0.012125158843443479, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.253434751518294}], "aerodynamic_surfaces": [{"length": 0.5582705013968166, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1324382750401751]}, {"n": 4, "root_chord": 0.12083788079779771, "tip_chord": 0.059835733736456995, "span": 0.10986691204120996, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0501926818446154]}, {"top_radius": 0.06323998090682992, "bottom_radius": 0.04359758013450215, "length": 0.060640016015139124, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.7009313548369903, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.619162407445633, "upper_button_position": 0.08176894739135732}], "rail_length": 5, "inclination": 82.99098491530997, "heading": 53.08465759304224} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 11, "radius": 0.06349677289274533, "mass": 15.217709776706231, "I_11_without_motor": 6.321, "I_22_without_motor": 6.32175258715042, "I_33_without_motor": 0.033459201040714426, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 10.096602661490191, "trigger": 800, "sampling_rate": 105, "lag": 1.49396409511733, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9720085551685576, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3800358814129423, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7291.859944129631, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03286255098889512, "grain_number": 5, "grain_density": 1766.3677896946615, "grain_outer_radius": 0.032734627954657224, "grain_initial_inner_radius": 0.015352246485480142, "grain_initial_height": 0.12063907289605554, "grain_separation": 0.005563805824237478, "grains_center_of_mass_position": 0.3956640642090927, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0012330124869399171, "throat_radius": 0.010162279829192586, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2539163609254507}], "aerodynamic_surfaces": [{"length": 0.5589934632852431, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1334772004389817]}, {"n": 4, "root_chord": 0.12003103507713203, "tip_chord": 0.060007157881095584, "span": 0.10986526029259697, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0493237384065284]}, {"top_radius": 0.06277183025721901, "bottom_radius": 0.042988022665582465, "length": 0.057439786282093896, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6997446640244589, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6190247676395187, "upper_button_position": 0.08071989638494015}], "rail_length": 5, "inclination": 84.23171746111679, "heading": 49.527753617990584} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 22, "radius": 0.06349646712700412, "mass": 14.814700814397224, "I_11_without_motor": 6.321, "I_22_without_motor": 6.321544992542315, "I_33_without_motor": 0.04144368480385598, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.784322279807983, "trigger": 800, "sampling_rate": 105, "lag": 1.514681111835507, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9913712254685946, "trigger": "apogee", "sampling_rate": 105, "lag": 1.1417382025107303, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6961.5368868629685, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.0332900584493347, "grain_number": 5, "grain_density": 1788.2644189899684, "grain_outer_radius": 0.03308753719951774, "grain_initial_inner_radius": 0.014404582654050256, "grain_initial_height": 0.11886282772270461, "grain_separation": 0.006320449868136485, "grains_center_of_mass_position": 0.3981131019075248, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.00017776497846661547, "throat_radius": 0.010866721021756265, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2551342947682547}], "aerodynamic_surfaces": [{"length": 0.5584202748153241, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1332925035465926]}, {"n": 4, "root_chord": 0.11994623959052625, "tip_chord": 0.06053733305829076, "span": 0.11046021490057707, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0494544587721806]}, {"top_radius": 0.06257314656471137, "bottom_radius": 0.043319782433462004, "length": 0.059705173035873985, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6979990604581422, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6184120295740662, "upper_button_position": 0.07958703088407604}], "rail_length": 5, "inclination": 84.99589937631742, "heading": 51.887238286372636} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 4, "radius": 0.06350329530188674, "mass": 15.496453305544417, "I_11_without_motor": 6.321, "I_22_without_motor": 6.3186643284452035, "I_33_without_motor": 0.03950077227905335, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.88105682090641, "trigger": 800, "sampling_rate": 105, "lag": 1.3479343837879112, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9612370302510007, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3789775577365009, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 6782.298298373643, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03314152903223107, "grain_number": 5, "grain_density": 1894.1468996913864, "grain_outer_radius": 0.032694749462845674, "grain_initial_inner_radius": 0.014065073804489932, "grain_initial_height": 0.11959622509284373, "grain_separation": 0.003974991853732072, "grains_center_of_mass_position": 0.397716852247396, "center_of_dry_mass_position": 0.317, "nozzle_position": -0.0018820454638020388, "throat_radius": 0.01073279395891568, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2551170520864183}], "aerodynamic_surfaces": [{"length": 0.5597670641078055, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1348426935549736]}, {"n": 4, "root_chord": 0.12059750329274571, "tip_chord": 0.059581698346397705, "span": 0.1102813848132924, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0496196579028505]}, {"top_radius": 0.06489677704779642, "bottom_radius": 0.04318873444093642, "length": 0.05945155314026724, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6977594543350731, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6176268591659976, "upper_button_position": 0.08013259516907556}], "rail_length": 5, "inclination": 84.36696245438576, "heading": 51.29753106834522} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 10, "radius": 0.06350683275697407, "mass": 15.50203884001735, "I_11_without_motor": 6.321, "I_22_without_motor": 6.329234614352841, "I_33_without_motor": 0.03942543540618289, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.99705678394388, "trigger": 800, "sampling_rate": 105, "lag": 1.4864005383993102, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9261335073472055, "trigger": "apogee", "sampling_rate": 105, "lag": 1.3443714064567047, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 8005.5706291441375, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03173794023037279, "grain_number": 5, "grain_density": 1832.2847409983933, "grain_outer_radius": 0.032785297874888826, "grain_initial_inner_radius": 0.014704362412556253, "grain_initial_height": 0.12077876924005805, "grain_separation": 0.0037027528553549662, "grains_center_of_mass_position": 0.39681844080092726, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0008900775371926553, "throat_radius": 0.010678959998932978, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2561578769221484}], "aerodynamic_surfaces": [{"length": 0.557427788081872, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1344469733063216]}, {"n": 4, "root_chord": 0.11955388510819866, "tip_chord": 0.0605411069733704, "span": 0.10974109554384873, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0505154311823244]}, {"top_radius": 0.06344719682720237, "bottom_radius": 0.04316200610992135, "length": 0.058310525727021, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.6996285939418921, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6194024929103658, "upper_button_position": 0.08022610103152639}], "rail_length": 5, "inclination": 85.53895274253726, "heading": 53.0149968650151} +{"elevation": 113, "gravity": "Function from R1 to R1 : (height (m)) \u2192 (gravity (m/s\u00b2))", "latitude": 39.3897, "longitude": -8.288964, "wind_velocity_x_factor": 1.0, "wind_velocity_y_factor": 1.0, "datum": "SIRGAS2000", "timezone": "UTC", "ensemble_member": 26, "radius": 0.0635027211217431, "mass": 15.078500789243703, "I_11_without_motor": 6.321, "I_22_without_motor": 6.323893530066055, "I_33_without_motor": 0.03188238068989791, "I_12_without_motor": 0, "I_13_without_motor": 0, "I_23_without_motor": 0, "power_off_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power Off)", "power_on_drag": "Function from R1 to R1 : (Mach Number) \u2192 (Drag Coefficient with Power On)", "power_off_drag_factor": 1.0, "power_on_drag_factor": 1.0, "center_of_mass_without_motor": 0.0, "coordinate_system_orientation": "tail_to_nose", "parachutes": [{"cd_s": 9.791867275278832, "trigger": 800, "sampling_rate": 105, "lag": 1.5383774555509766, "noise": [0, 8.3, 0.5], "name": "Main"}, {"cd_s": 0.9846929514730729, "trigger": "apogee", "sampling_rate": 105, "lag": 1.6714485669192136, "noise": [0, 8.3, 0.5], "name": "Drogue"}], "motors": [{"thrust_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]], "total_impulse": 7684.489626218814, "burn_start_time": 0, "burn_out_time": 3.9, "dry_mass": 1.815, "dry_I_11": 0.125, "dry_I_22": 0.125, "dry_I_33": 0.002, "dry_I_12": 0, "dry_I_13": 0, "dry_I_23": 0, "nozzle_radius": 0.03363471170244506, "grain_number": 5, "grain_density": 1883.7104959971407, "grain_outer_radius": 0.032918135962112745, "grain_initial_inner_radius": 0.015256590744721637, "grain_initial_height": 0.11974726237237875, "grain_separation": 0.005701672701260577, "grains_center_of_mass_position": 0.39587480788878565, "center_of_dry_mass_position": 0.317, "nozzle_position": 0.0007353244314329845, "throat_radius": 0.010482322779698225, "interpolate": "linear", "coordinate_system_orientation": "nozzle_to_combustion_chamber", "position": -1.2540920606352421}], "aerodynamic_surfaces": [{"length": 0.5588416162332039, "kind": "vonKarman", "base_radius": 0.0635, "bluffness": 0, "rocket_radius": 0.0635, "name": "Nose Cone", "position": [0, 0, 1.1348355999109105]}, {"n": 4, "root_chord": 0.11904564842863577, "tip_chord": 0.061157344766110004, "span": 0.10994040231917326, "rocket_radius": 0.0635, "cant_angle": 0.5, "sweep_length": 0.06, "sweep_angle": null, "airfoil": ["../../../data/airfoils/NACA0012-radians.txt", "radians"], "name": "Fins", "position": [0, 0, -1.0501166747315005]}, {"top_radius": 0.06137425121555377, "bottom_radius": 0.04382040449893698, "length": 0.059674983070251444, "rocket_radius": 0.0635, "name": "Tail", "position": [0, 0, [0, 0, -1.194656]]}], "rail_buttons": [{"buttons_distance": 0.700243544566463, "angular_position": 45, "name": "Rail Buttons", "lower_button_position": -0.6167796839943969, "upper_button_position": 0.08346386057206612}], "rail_length": 5, "inclination": 84.42460213266236, "heading": 52.473469187557626} diff --git a/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt b/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt new file mode 100644 index 000000000..d299b6c68 --- /dev/null +++ b/docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt @@ -0,0 +1,116 @@ +{"apogee": 2312.1872472947116, "frontal_surface_wind": -3.0496076096117806, "apogee_y": 792.0643463024578, "lateral_surface_wind": -4.933428593177471, "t_final": 245.8640635159601, "out_of_rail_velocity": 22.602627269750965, "initial_stability_margin": 2.5965475536989793, "out_of_rail_time": 0.3978685698191799, "y_impact": -808.8458905124497, "apogee_x": 473.2474243585599, "impact_velocity": -5.29159675326023, "max_mach_number": 0.6712121311796375, "x_impact": 414.05676153229047, "out_of_rail_stability_margin": 2.676329129911605, "apogee_time": 21.623341277710804} +{"apogee": 3234.4452475578596, "frontal_surface_wind": -4.337392440631757, "apogee_y": 914.6161005985731, "lateral_surface_wind": -4.330218954821568, "t_final": 308.6136950810929, "out_of_rail_velocity": 25.80568850560873, "initial_stability_margin": 2.5212083871217477, "out_of_rail_time": 0.3566948768302634, "y_impact": -1630.901738601504, "apogee_x": 602.5236652027419, "impact_velocity": -5.1912272264568395, "max_mach_number": 0.861332104930048, "x_impact": 104.54718624691004, "out_of_rail_stability_margin": 2.5904766702124973, "apogee_time": 24.92645235696848} +{"apogee": 3194.2919822661884, "frontal_surface_wind": -2.9590922434593336, "apogee_y": 854.6215605295408, "lateral_surface_wind": -5.500986420895066, "t_final": 295.676524528265, "out_of_rail_velocity": 25.519210213159013, "initial_stability_margin": 2.6368645237557438, "out_of_rail_time": 0.3601293622658367, "y_impact": -1824.7409214359986, "apogee_x": 401.250373504897, "impact_velocity": -5.205589117769717, "max_mach_number": 0.8486046757015585, "x_impact": 298.52792415153493, "out_of_rail_stability_margin": 2.710429230797741, "apogee_time": 24.821588922607702} +{"apogee": 2005.5355578422684, "frontal_surface_wind": -4.355137085242682, "apogee_y": 768.6167980634466, "lateral_surface_wind": -5.742328463616666, "t_final": 232.74850709159384, "out_of_rail_velocity": 21.398277969831224, "initial_stability_margin": 2.6161759295091533, "out_of_rail_time": 0.4172765756487621, "y_impact": -980.0914807790709, "apogee_x": 324.1875339535975, "impact_velocity": -5.305869194997984, "max_mach_number": 0.6068006591743482, "x_impact": 332.7869115355111, "out_of_rail_stability_margin": 2.705155629496209, "apogee_time": 20.335146326527934} +{"apogee": 3414.1326037550193, "frontal_surface_wind": -4.145622464456691, "apogee_y": 1067.5341992124293, "lateral_surface_wind": -5.070996962871586, "t_final": 300.0408912215984, "out_of_rail_velocity": 26.318761101307224, "initial_stability_margin": 2.562607630136216, "out_of_rail_time": 0.35084514654733395, "y_impact": -1330.8722645723942, "apogee_x": 699.8948582654266, "impact_velocity": -5.267158445220961, "max_mach_number": 0.8997684911744048, "x_impact": 246.0016314455594, "out_of_rail_stability_margin": 2.633413869721548, "apogee_time": 25.544778409497113} +{"apogee": 4005.43639180465, "frontal_surface_wind": -3.223183682158992, "apogee_y": 825.9614723383999, "lateral_surface_wind": -5.350529455973221, "t_final": 345.2287009395753, "out_of_rail_velocity": 28.807427900808356, "initial_stability_margin": 2.5127223551102076, "out_of_rail_time": 0.3266913066347211, "y_impact": -2783.6999083332653, "apogee_x": 304.34509604603164, "impact_velocity": -5.159243827155025, "max_mach_number": 1.0465990745418756, "x_impact": 274.508021686453, "out_of_rail_stability_margin": 2.582497802323176, "apogee_time": 27.11963324697822} +{"apogee": 3369.7430206875033, "frontal_surface_wind": -4.126067141026567, "apogee_y": 950.1893037301417, "lateral_surface_wind": -5.367758720812397, "t_final": 316.8351000294194, "out_of_rail_velocity": 26.198310409725064, "initial_stability_margin": 2.5461594160894894, "out_of_rail_time": 0.35212814103223733, "y_impact": -2102.9174668126843, "apogee_x": 528.1202151342061, "impact_velocity": -5.244655424517382, "max_mach_number": 0.8912612876513054, "x_impact": 295.44698025503527, "out_of_rail_stability_margin": 2.6169443098116285, "apogee_time": 25.361625858486242} +{"apogee": 3779.43184471028, "frontal_surface_wind": -3.839784837857332, "apogee_y": 1017.1362281915923, "lateral_surface_wind": -4.910293207964168, "t_final": 336.1199113741417, "out_of_rail_velocity": 28.007046184035932, "initial_stability_margin": 2.7079631823608246, "out_of_rail_time": 0.3342151669899769, "y_impact": -2233.606939193176, "apogee_x": 691.6998659764772, "impact_velocity": -5.204211528816122, "max_mach_number": 0.993326214818677, "x_impact": 552.5339765803068, "out_of_rail_stability_margin": 2.7732698548275985, "apogee_time": 26.50431154681348} +{"apogee": 3185.0551035062344, "frontal_surface_wind": -3.250221342604423, "apogee_y": 719.5241227445958, "lateral_surface_wind": -4.907401228617864, "t_final": 302.51757266636207, "out_of_rail_velocity": 25.323908942075047, "initial_stability_margin": 2.5235206581218628, "out_of_rail_time": 0.36237409173413077, "y_impact": -1692.6591002104685, "apogee_x": 248.44542375123808, "impact_velocity": -5.183812017743841, "max_mach_number": 0.838106938357358, "x_impact": 163.65118864302815, "out_of_rail_stability_margin": 2.6002457121681752, "apogee_time": 24.831323336189406} +{"apogee": 4360.224222438373, "frontal_surface_wind": -3.403890176664362, "apogee_y": 980.186891813364, "lateral_surface_wind": -4.802088843385686, "t_final": 364.96342175857956, "out_of_rail_velocity": 30.60334103581782, "initial_stability_margin": 2.524717905329552, "out_of_rail_time": 0.31183422104004316, "y_impact": -2498.457065905911, "apogee_x": 543.560310489271, "impact_velocity": -5.168709004091191, "max_mach_number": 1.1461922887188867, "x_impact": 723.2265098794728, "out_of_rail_stability_margin": 2.5869153993174057, "apogee_time": 28.00589933642195} +{"apogee": 2762.1274253479473, "frontal_surface_wind": -4.070528982556502, "apogee_y": 812.7838243619475, "lateral_surface_wind": -5.913753916100903, "t_final": 267.8450828614702, "out_of_rail_velocity": 24.059379341598707, "initial_stability_margin": 2.58362636006892, "out_of_rail_time": 0.3786335192192805, "y_impact": -1435.0197541939556, "apogee_x": 296.92146384538205, "impact_velocity": -5.237641896590559, "max_mach_number": 0.7585832534208544, "x_impact": 259.5001445167858, "out_of_rail_stability_margin": 2.6609143629105283, "apogee_time": 23.357549269012186} +{"apogee": 3534.9029570139965, "frontal_surface_wind": -3.556772875965321, "apogee_y": 955.189860659162, "lateral_surface_wind": -5.435875170107231, "t_final": 306.92149145825124, "out_of_rail_velocity": 26.66380763503703, "initial_stability_margin": 2.6703444503640443, "out_of_rail_time": 0.34726074279325186, "y_impact": -2042.842691963689, "apogee_x": 484.46842361899496, "impact_velocity": -5.310370168169911, "max_mach_number": 0.9166027454514214, "x_impact": 332.16529159305156, "out_of_rail_stability_margin": 2.7362632833331526, "apogee_time": 25.947382516023982} +{"apogee": 3614.108677032202, "frontal_surface_wind": -4.296163859984769, "apogee_y": 978.1209429350522, "lateral_surface_wind": -4.371126338703365, "t_final": 320.0212794065488, "out_of_rail_velocity": 26.983391051354356, "initial_stability_margin": 2.625766417156153, "out_of_rail_time": 0.34451205219065767, "y_impact": -1828.4758943841007, "apogee_x": 660.3848176093826, "impact_velocity": -5.281596964122639, "max_mach_number": 0.9406237539646314, "x_impact": 194.09444824854987, "out_of_rail_stability_margin": 2.6969536938736858, "apogee_time": 26.131961746211903} +{"apogee": 3420.125327779051, "frontal_surface_wind": -3.7147720364157335, "apogee_y": 1003.1138426347507, "lateral_surface_wind": -6.815589778246364, "t_final": 307.1071052351639, "out_of_rail_velocity": 26.305927590690537, "initial_stability_margin": 2.550302927550933, "out_of_rail_time": 0.35153480359971184, "y_impact": -2272.945648804256, "apogee_x": 395.3936923057035, "impact_velocity": -5.2613997087095825, "max_mach_number": 0.8987755788931121, "x_impact": 614.8138782700777, "out_of_rail_stability_margin": 2.623412668922972, "apogee_time": 25.537608446255753} +{"apogee": 2599.417973288354, "frontal_surface_wind": -4.053575984754723, "apogee_y": 927.8333628905247, "lateral_surface_wind": -5.144872938283375, "t_final": 266.1509698445134, "out_of_rail_velocity": 23.681316131526582, "initial_stability_margin": 2.5817014651361134, "out_of_rail_time": 0.38329336171287726, "y_impact": -985.611612000622, "apogee_x": 617.6760010948253, "impact_velocity": -5.2171482517136365, "max_mach_number": 0.7413040886536101, "x_impact": 186.92295218668716, "out_of_rail_stability_margin": 2.6642380764852502, "apogee_time": 22.693999601208716} +{"apogee": 3881.63118624118, "frontal_surface_wind": -4.280852505152617, "apogee_y": 984.2476932897227, "lateral_surface_wind": -4.987685358209447, "t_final": 353.2799308179348, "out_of_rail_velocity": 28.17678208210907, "initial_stability_margin": 2.5703527206804613, "out_of_rail_time": 0.3326944375337907, "y_impact": -2923.3277905344717, "apogee_x": 615.1102090779864, "impact_velocity": -5.24007835674783, "max_mach_number": 1.0085432606568356, "x_impact": 726.2910223190462, "out_of_rail_stability_margin": 2.6380206959954426, "apogee_time": 26.87395393578114} +{"apogee": 4031.169401620982, "frontal_surface_wind": -4.11796971326075, "apogee_y": 916.9618884321287, "lateral_surface_wind": -5.093478306219435, "t_final": 322.1276956345975, "out_of_rail_velocity": 28.449872107328087, "initial_stability_margin": 2.6498441091561453, "out_of_rail_time": 0.3299172983320498, "y_impact": -1861.991473397278, "apogee_x": 455.0624288057102, "impact_velocity": -5.266702602345353, "max_mach_number": 1.0267153764695038, "x_impact": 8.207178256443001, "out_of_rail_stability_margin": 2.7178633531523158, "apogee_time": 27.388868130772234} +{"apogee": 3630.871096962262, "frontal_surface_wind": -4.057872513219252, "apogee_y": 984.0222585072161, "lateral_surface_wind": -5.419495770233277, "t_final": 326.99993219534747, "out_of_rail_velocity": 27.326388564356307, "initial_stability_margin": 2.5362561693858328, "out_of_rail_time": 0.3403621287534829, "y_impact": -2262.674213265278, "apogee_x": 583.9293868737337, "impact_velocity": -5.165031068855398, "max_mach_number": 0.9606086083268497, "x_impact": 410.82143574367603, "out_of_rail_stability_margin": 2.6061762933856505, "apogee_time": 26.05904046583953} +{"apogee": 4130.258160463937, "frontal_surface_wind": -3.6319081395042936, "apogee_y": 943.6973762557913, "lateral_surface_wind": -4.712169364357847, "t_final": 364.8898914002856, "out_of_rail_velocity": 29.599646211168185, "initial_stability_margin": 2.522227777666711, "out_of_rail_time": 0.3198041630806601, "y_impact": -2670.5595652655275, "apogee_x": 487.6698196275945, "impact_velocity": -5.12929795011279, "max_mach_number": 1.0936557042964867, "x_impact": 534.8324912082843, "out_of_rail_stability_margin": 2.5918742492779416, "apogee_time": 27.364979590201383} +{"apogee": 3862.398160305433, "frontal_surface_wind": -3.6709131233479657, "apogee_y": 1071.7009529907107, "lateral_surface_wind": -4.546792618170283, "t_final": 332.80479874085256, "out_of_rail_velocity": 28.09435892996872, "initial_stability_margin": 2.680099639336055, "out_of_rail_time": 0.33300595820560636, "y_impact": -1909.1191815511158, "apogee_x": 655.9070469784183, "impact_velocity": -5.260306250250454, "max_mach_number": 1.003147340511129, "x_impact": 547.1331574199163, "out_of_rail_stability_margin": 2.7459316600454846, "apogee_time": 26.831604063336425} +{"apogee": 3457.1464938724657, "frontal_surface_wind": -4.301422769308096, "apogee_y": 1011.7402292625326, "lateral_surface_wind": -5.877747623929149, "t_final": 308.69588054117315, "out_of_rail_velocity": 26.473440963674634, "initial_stability_margin": 2.633346181758324, "out_of_rail_time": 0.34926778911475, "y_impact": -1955.4186993661742, "apogee_x": 500.19723883474825, "impact_velocity": -5.214710521217645, "max_mach_number": 0.9069460544703524, "x_impact": 409.81006045710393, "out_of_rail_stability_margin": 2.7030118600968995, "apogee_time": 25.65241907461697} +{"apogee": 2930.9360659665736, "frontal_surface_wind": -3.1719539568495065, "apogee_y": 803.6198681094676, "lateral_surface_wind": -4.855670123907706, "t_final": 290.12653538933733, "out_of_rail_velocity": 24.681480762767105, "initial_stability_margin": 2.546934959494983, "out_of_rail_time": 0.36987020312468777, "y_impact": -1402.321604171246, "apogee_x": 395.71997795018314, "impact_velocity": -5.133172180527211, "max_mach_number": 0.7954499920899426, "x_impact": 283.90707917187666, "out_of_rail_stability_margin": 2.6232516584976655, "apogee_time": 23.90412984599284} +{"apogee": 2947.5707444915397, "frontal_surface_wind": -4.289086579688394, "apogee_y": 994.8489167255198, "lateral_surface_wind": -5.933503287736684, "t_final": 281.6616344102024, "out_of_rail_velocity": 24.76456187349953, "initial_stability_margin": 2.635437213467015, "out_of_rail_time": 0.36887908645968137, "y_impact": -1648.86595664764, "apogee_x": 500.7151812249715, "impact_velocity": -5.3488048773179715, "max_mach_number": 0.8000757854119254, "x_impact": 440.83709190823913, "out_of_rail_stability_margin": 2.706743887934832, "apogee_time": 24.039151681641275} +{"apogee": 2666.3189863892594, "frontal_surface_wind": -4.56034313319912, "apogee_y": 821.9337762167993, "lateral_surface_wind": -5.215932086583531, "t_final": 269.71680254461467, "out_of_rail_velocity": 23.78711937617732, "initial_stability_margin": 2.5284615872968246, "out_of_rail_time": 0.3814587634779732, "y_impact": -1570.3483732328764, "apogee_x": 375.6763233482961, "impact_velocity": -5.214713521705962, "max_mach_number": 0.7437899980180568, "x_impact": -5.862120521368879, "out_of_rail_stability_margin": 2.6056045455930934, "apogee_time": 23.0091769478826} +{"apogee": 3357.987939458601, "frontal_surface_wind": -3.720513055880615, "apogee_y": 977.0754888373787, "lateral_surface_wind": -6.812457552814147, "t_final": 309.0255506832201, "out_of_rail_velocity": 26.109362392419918, "initial_stability_margin": 2.642543229387226, "out_of_rail_time": 0.3533952628420922, "y_impact": -2304.943935000412, "apogee_x": 363.9330885624899, "impact_velocity": -5.244235197847795, "max_mach_number": 0.8838008479833885, "x_impact": 572.1468404143658, "out_of_rail_stability_margin": 2.712971895624635, "apogee_time": 25.350421057412625} +{"apogee": 2404.1219938397217, "frontal_surface_wind": -3.5260176055200043, "apogee_y": 656.9723123561896, "lateral_surface_wind": -5.8763961595870375, "t_final": 253.71517269361172, "out_of_rail_velocity": 22.70334996901872, "initial_stability_margin": 2.558467947604102, "out_of_rail_time": 0.3960997678903855, "y_impact": -1556.1483110023582, "apogee_x": 183.0533533673235, "impact_velocity": -5.307949555780116, "max_mach_number": 0.6778736616975899, "x_impact": 117.66019734596827, "out_of_rail_stability_margin": 2.6361421835556467, "apogee_time": 22.072098881093225} +{"apogee": 3952.052833800142, "frontal_surface_wind": -4.4533036944613125, "apogee_y": 925.6540968870343, "lateral_surface_wind": -4.834334453496733, "t_final": 349.615364652483, "out_of_rail_velocity": 28.805563889652156, "initial_stability_margin": 2.5426670623596808, "out_of_rail_time": 0.3267600535749173, "y_impact": -2881.711345413551, "apogee_x": 523.3087855551189, "impact_velocity": -5.076481648396569, "max_mach_number": 1.0439215834105346, "x_impact": 630.7092898564006, "out_of_rail_stability_margin": 2.611595986841253, "apogee_time": 26.92035967925358} +{"apogee": 3973.8620447387616, "frontal_surface_wind": -3.898178464469943, "apogee_y": 969.5709758373266, "lateral_surface_wind": -5.055666624184464, "t_final": 346.66173824304167, "out_of_rail_velocity": 28.77043508040725, "initial_stability_margin": 2.581404743183625, "out_of_rail_time": 0.32778231384515216, "y_impact": -2478.6308286168314, "apogee_x": 656.4387380592694, "impact_velocity": -5.197424876216387, "max_mach_number": 1.0408960951124477, "x_impact": 525.2838226262455, "out_of_rail_stability_margin": 2.6479590871120484, "apogee_time": 27.051306245931386} +{"apogee": 2733.3355689226432, "frontal_surface_wind": -3.3567696866431214, "apogee_y": 611.2617358028206, "lateral_surface_wind": -4.180518341717936, "t_final": 280.9740261931954, "out_of_rail_velocity": 23.783328535407755, "initial_stability_margin": 2.479056822395557, "out_of_rail_time": 0.38115068375692, "y_impact": -1893.3855378847995, "apogee_x": 227.00424837338818, "impact_velocity": -5.127304830718285, "max_mach_number": 0.7484626323831027, "x_impact": -193.36807509239586, "out_of_rail_stability_margin": 2.563608160252232, "apogee_time": 23.253192368514256} +{"apogee": 2154.7138533370976, "frontal_surface_wind": -3.4163730615519694, "apogee_y": 564.1016895887182, "lateral_surface_wind": -4.74102535071456, "t_final": 243.32700496945614, "out_of_rail_velocity": 21.760443760462987, "initial_stability_margin": 2.5546785875832905, "out_of_rail_time": 0.41112449420754144, "y_impact": -1128.451439653816, "apogee_x": 205.72323717181982, "impact_velocity": -5.158189768113623, "max_mach_number": 0.626576463457021, "x_impact": 45.24577905206546, "out_of_rail_stability_margin": 2.6430480773625886, "apogee_time": 21.014307652107505} +{"apogee": 3094.6886877693887, "frontal_surface_wind": -3.0751601430467863, "apogee_y": 896.7251234569044, "lateral_surface_wind": -4.267045813454278, "t_final": 301.869065695616, "out_of_rail_velocity": 25.32300007683221, "initial_stability_margin": 2.3900981583100207, "out_of_rail_time": 0.36239147917626113, "y_impact": -1441.7187363216885, "apogee_x": 655.7386401546678, "impact_velocity": -5.141225793861023, "max_mach_number": 0.8374904917809063, "x_impact": 541.409562847654, "out_of_rail_stability_margin": 2.4662877485285475, "apogee_time": 24.441530653640985} +{"apogee": 3495.021413543441, "frontal_surface_wind": -3.10592753732291, "apogee_y": 882.0723039729157, "lateral_surface_wind": -5.419436561218549, "t_final": 304.53067156286255, "out_of_rail_velocity": 26.456022159808725, "initial_stability_margin": 2.648389738023834, "out_of_rail_time": 0.34943027177572705, "y_impact": -2009.9380600058453, "apogee_x": 389.16997059150265, "impact_velocity": -5.272070505576486, "max_mach_number": 0.9026524443610076, "x_impact": 315.21098296484007, "out_of_rail_stability_margin": 2.7146784985665695, "apogee_time": 25.847661518014885} +{"apogee": 3074.4779335651006, "frontal_surface_wind": -4.393024467077156, "apogee_y": 914.0920057044569, "lateral_surface_wind": -5.151562847212306, "t_final": 284.32990880948097, "out_of_rail_velocity": 25.155318164093817, "initial_stability_margin": 2.6098559313042506, "out_of_rail_time": 0.3640768821992519, "y_impact": -1548.180765723026, "apogee_x": 446.11478991976225, "impact_velocity": -5.242390661805754, "max_mach_number": 0.8257764718757326, "x_impact": 214.3605415898124, "out_of_rail_stability_margin": 2.681807137985969, "apogee_time": 24.438789660765522} +{"apogee": 3294.3432942153395, "frontal_surface_wind": -3.1642138846267103, "apogee_y": 810.3416927678776, "lateral_surface_wind": -5.038159122588897, "t_final": 312.36217703190215, "out_of_rail_velocity": 25.80505936309025, "initial_stability_margin": 2.4800068914094195, "out_of_rail_time": 0.35734280340714486, "y_impact": -1874.4535978596978, "apogee_x": 414.2720815249571, "impact_velocity": -5.184104218067938, "max_mach_number": 0.8702927281736513, "x_impact": 279.2447186310422, "out_of_rail_stability_margin": 2.5575329073556685, "apogee_time": 25.113610127925575} +{"apogee": 3446.515911289857, "frontal_surface_wind": -3.767988938372002, "apogee_y": 777.542407443025, "lateral_surface_wind": -5.096852136472286, "t_final": 324.42908588886866, "out_of_rail_velocity": 26.462381861301154, "initial_stability_margin": 2.6239481702831315, "out_of_rail_time": 0.3495758472375969, "y_impact": -2202.348907429261, "apogee_x": 367.3784992086362, "impact_velocity": -5.0948180344201095, "max_mach_number": 0.9025534698944169, "x_impact": 90.88275672944428, "out_of_rail_stability_margin": 2.693497658724476, "apogee_time": 25.580452971667732} +{"apogee": 3734.147181142318, "frontal_surface_wind": -4.53620871982169, "apogee_y": 1187.3078421082737, "lateral_surface_wind": -5.1964030665307455, "t_final": 330.15934772464266, "out_of_rail_velocity": 27.90447108064831, "initial_stability_margin": 2.66137369013365, "out_of_rail_time": 0.3349003508213809, "y_impact": -2127.9786135394183, "apogee_x": 652.2305654009101, "impact_velocity": -5.2238023374355285, "max_mach_number": 0.9920622196703343, "x_impact": 364.3085898235332, "out_of_rail_stability_margin": 2.727485036683601, "apogee_time": 26.358155165056083} +{"apogee": 3831.2292558375816, "frontal_surface_wind": -4.163209532523157, "apogee_y": 943.3214623783674, "lateral_surface_wind": -4.639247070110235, "t_final": 357.6498110976195, "out_of_rail_velocity": 28.397282042356988, "initial_stability_margin": 2.4960073222845462, "out_of_rail_time": 0.330934212847961, "y_impact": -2610.5642954020486, "apogee_x": 539.7459952157958, "impact_velocity": -5.039588069408154, "max_mach_number": 1.0144465050556348, "x_impact": 371.1693189022848, "out_of_rail_stability_margin": 2.563497455533426, "apogee_time": 26.558803730506543} +{"apogee": 2212.6151597881767, "frontal_surface_wind": -3.979497776665914, "apogee_y": 665.8265146912603, "lateral_surface_wind": -5.477304189346046, "t_final": 247.61141085223713, "out_of_rail_velocity": 22.10965783835808, "initial_stability_margin": 2.687457307968085, "out_of_rail_time": 0.405442849385351, "y_impact": -1175.3744467566391, "apogee_x": 273.6156373974603, "impact_velocity": -5.141174945303881, "max_mach_number": 0.6456054561861525, "x_impact": -7.653695436250225, "out_of_rail_stability_margin": 2.7704570066931926, "apogee_time": 21.23356361942962} +{"apogee": 4196.004830934748, "frontal_surface_wind": -4.248685930735302, "apogee_y": 914.0127583764535, "lateral_surface_wind": -5.787085573931247, "t_final": 360.89163064474855, "out_of_rail_velocity": 29.6897405802687, "initial_stability_margin": 2.495257371640936, "out_of_rail_time": 0.3190315184022593, "y_impact": -2858.4744667769824, "apogee_x": 328.16302668664935, "impact_velocity": -5.121821434053113, "max_mach_number": 1.099351846776006, "x_impact": 503.4426317665029, "out_of_rail_stability_margin": 2.5636994287079076, "apogee_time": 27.611933271547542} +{"apogee": 3839.871056547459, "frontal_surface_wind": -4.305857938220858, "apogee_y": 950.6067686547282, "lateral_surface_wind": -5.22463885383259, "t_final": 352.5677629501762, "out_of_rail_velocity": 28.416479454860152, "initial_stability_margin": 2.3736378729544096, "out_of_rail_time": 0.33044711905922214, "y_impact": -2708.337141577087, "apogee_x": 506.8596742903591, "impact_velocity": -5.004701869365347, "max_mach_number": 1.0252802820181737, "x_impact": 348.0915562013146, "out_of_rail_stability_margin": 2.445969477146272, "apogee_time": 26.5457486242275} +{"apogee": 3600.831602872863, "frontal_surface_wind": -2.9892536817490645, "apogee_y": 945.9716746291302, "lateral_surface_wind": -5.070590500199269, "t_final": 331.91518398730074, "out_of_rail_velocity": 27.15968218051427, "initial_stability_margin": 2.477432823261019, "out_of_rail_time": 0.34265320811508826, "y_impact": -1890.2053072456886, "apogee_x": 593.9814350332412, "impact_velocity": -5.075718383908191, "max_mach_number": 0.9497395392183924, "x_impact": 616.4814521472077, "out_of_rail_stability_margin": 2.549931658372853, "apogee_time": 25.982173580517717} +{"apogee": 3608.4535517618706, "frontal_surface_wind": -3.247085548160896, "apogee_y": 993.6148011155773, "lateral_surface_wind": -5.336057903649261, "t_final": 321.9637830952574, "out_of_rail_velocity": 26.942031778460183, "initial_stability_margin": 2.640840048917396, "out_of_rail_time": 0.34448750591782407, "y_impact": -2158.470973514761, "apogee_x": 496.5070103992802, "impact_velocity": -5.218579997154987, "max_mach_number": 0.9352791720701759, "x_impact": 431.72597547631636, "out_of_rail_stability_margin": 2.708196972337256, "apogee_time": 26.14787972663668} +{"apogee": 3699.179498829001, "frontal_surface_wind": -2.994828835796924, "apogee_y": 676.906234435694, "lateral_surface_wind": -4.323805051546663, "t_final": 325.05903668140917, "out_of_rail_velocity": 27.17721904561257, "initial_stability_margin": 2.513890214542699, "out_of_rail_time": 0.34298131084691397, "y_impact": -2078.8838828081516, "apogee_x": 324.5488060387155, "impact_velocity": -5.106399683993388, "max_mach_number": 0.9512842255723164, "x_impact": 240.16335428442684, "out_of_rail_stability_margin": 2.5864810894664343, "apogee_time": 26.379193832739617} +{"apogee": 3372.703326111001, "frontal_surface_wind": -3.7212389657394835, "apogee_y": 1049.2144672952288, "lateral_surface_wind": -6.718121940554428, "t_final": 305.46498142032164, "out_of_rail_velocity": 26.399113835765277, "initial_stability_margin": 2.5155917209743994, "out_of_rail_time": 0.35031305749899605, "y_impact": -2031.267616591791, "apogee_x": 536.0396034272887, "impact_velocity": -5.19274742707198, "max_mach_number": 0.9032735488427164, "x_impact": 475.93633945474, "out_of_rail_stability_margin": 2.588456144762525, "apogee_time": 25.276409276117008} +{"apogee": 1996.5910910864711, "frontal_surface_wind": -4.215505302039444, "apogee_y": 721.9195261573232, "lateral_surface_wind": -5.939669184340507, "t_final": 236.94572564648632, "out_of_rail_velocity": 21.4142545768007, "initial_stability_margin": 2.5393158505989977, "out_of_rail_time": 0.41637390844558597, "y_impact": -1160.7813774573235, "apogee_x": 333.33372010178766, "impact_velocity": -5.208284899458889, "max_mach_number": 0.605805197465291, "x_impact": 210.37061940097385, "out_of_rail_stability_margin": 2.623666808898678, "apogee_time": 20.280493152381197} +{"apogee": 3290.172718242535, "frontal_surface_wind": -3.5353329770488546, "apogee_y": 936.3597057393529, "lateral_surface_wind": -6.910370181782125, "t_final": 297.63449573658335, "out_of_rail_velocity": 25.958929036159528, "initial_stability_margin": 2.5432853961410284, "out_of_rail_time": 0.35536623037301035, "y_impact": -2137.3288794219225, "apogee_x": 354.9942722046002, "impact_velocity": -5.210652158964284, "max_mach_number": 0.8728386266898874, "x_impact": 558.7450269569289, "out_of_rail_stability_margin": 2.614752200043072, "apogee_time": 25.09580223619011} +{"apogee": 3157.2312940893435, "frontal_surface_wind": -4.160071330874623, "apogee_y": 939.018849176115, "lateral_surface_wind": -4.842454633528848, "t_final": 295.7935864035987, "out_of_rail_velocity": 25.453459305952595, "initial_stability_margin": 2.825480269116136, "out_of_rail_time": 0.36072935644105525, "y_impact": -1638.5988955979024, "apogee_x": 549.941494761061, "impact_velocity": -5.294008355867942, "max_mach_number": 0.8416531076163297, "x_impact": 294.1364900996506, "out_of_rail_stability_margin": 2.8956885860061186, "apogee_time": 24.720456384010543} +{"apogee": 2493.9454433861424, "frontal_surface_wind": -4.240409732890779, "apogee_y": 746.1934216479096, "lateral_surface_wind": -4.711111083169344, "t_final": 260.3292570390996, "out_of_rail_velocity": 23.159704943043835, "initial_stability_margin": 2.5540253949824314, "out_of_rail_time": 0.39002200146552474, "y_impact": -1273.9911414524452, "apogee_x": 347.4088823033487, "impact_velocity": -5.21175770599466, "max_mach_number": 0.7025296599913385, "x_impact": 113.6381033024814, "out_of_rail_stability_margin": 2.631200713737236, "apogee_time": 22.373681047192225} +{"apogee": 3557.747882099693, "frontal_surface_wind": -4.623378717491691, "apogee_y": 965.262903169334, "lateral_surface_wind": -4.543683948542734, "t_final": 305.3114368363578, "out_of_rail_velocity": 26.76483739740462, "initial_stability_margin": 2.6627291588601705, "out_of_rail_time": 0.3462320179878831, "y_impact": -1881.614883628933, "apogee_x": 644.5182941711633, "impact_velocity": -5.299587220499189, "max_mach_number": 0.9251428711037164, "x_impact": 342.86376061280816, "out_of_rail_stability_margin": 2.730765898062247, "apogee_time": 26.004513267230156} +{"apogee": 3943.43528053845, "frontal_surface_wind": -3.4401784498805004, "apogee_y": 922.6435625785516, "lateral_surface_wind": -5.927056960399833, "t_final": 338.89339826231975, "out_of_rail_velocity": 28.58507664778766, "initial_stability_margin": 2.5689471432326156, "out_of_rail_time": 0.3287147486142479, "y_impact": -2711.0563850004437, "apogee_x": 437.68058381938033, "impact_velocity": -5.162181281027838, "max_mach_number": 1.0313741792407516, "x_impact": 585.8356462265267, "out_of_rail_stability_margin": 2.6363993957940877, "apogee_time": 26.967275831020494} +{"apogee": 3821.343422887789, "frontal_surface_wind": -3.093413767235326, "apogee_y": 965.3381451529741, "lateral_surface_wind": -5.0819374373234, "t_final": 324.6693523369747, "out_of_rail_velocity": 28.034675119837797, "initial_stability_margin": 2.5017804284142304, "out_of_rail_time": 0.3338369852778064, "y_impact": -2005.4232892531409, "apogee_x": 644.1199953670157, "impact_velocity": -5.211072130522262, "max_mach_number": 1.0001194701237042, "x_impact": 650.0727412309059, "out_of_rail_stability_margin": 2.570678756787538, "apogee_time": 26.63956571798566} +{"apogee": 3800.2563282190454, "frontal_surface_wind": -3.5897766426965965, "apogee_y": 913.0252185829698, "lateral_surface_wind": -5.634061051015556, "t_final": 327.97940431015735, "out_of_rail_velocity": 27.874485239441828, "initial_stability_margin": 2.489445428995911, "out_of_rail_time": 0.33534656596183354, "y_impact": -2487.4862418462326, "apogee_x": 394.54647826401816, "impact_velocity": -5.145282232800751, "max_mach_number": 0.9906807832694973, "x_impact": 532.2859666863826, "out_of_rail_stability_margin": 2.5592044304993564, "apogee_time": 26.585567151738804} +{"apogee": 3827.3766632072493, "frontal_surface_wind": -3.3213635910195753, "apogee_y": 870.0771663594517, "lateral_surface_wind": -4.808063037031196, "t_final": 338.64454382350846, "out_of_rail_velocity": 27.70777175011075, "initial_stability_margin": 2.4326044651443395, "out_of_rail_time": 0.33726945289980953, "y_impact": -2172.770177831218, "apogee_x": 494.1900412989954, "impact_velocity": -5.172525145945864, "max_mach_number": 0.9879283021822753, "x_impact": 358.79810910116066, "out_of_rail_stability_margin": 2.5061160258789243, "apogee_time": 26.74134159692111} +{"apogee": 2593.790189186025, "frontal_surface_wind": -3.343741131442183, "apogee_y": 744.5945332503826, "lateral_surface_wind": -5.795843019209302, "t_final": 265.483399793382, "out_of_rail_velocity": 23.458300227756403, "initial_stability_margin": 2.5957515254069974, "out_of_rail_time": 0.38602202076969216, "y_impact": -1470.475482518165, "apogee_x": 285.8571744000988, "impact_velocity": -5.188637434774776, "max_mach_number": 0.7240348088800113, "x_impact": 237.15278123039434, "out_of_rail_stability_margin": 2.6760114611016728, "apogee_time": 22.73937200762193} +{"apogee": 3210.27484397933, "frontal_surface_wind": -4.069916724279832, "apogee_y": 945.1246899174539, "lateral_surface_wind": -6.512799682603786, "t_final": 297.2325937657837, "out_of_rail_velocity": 25.466354244505833, "initial_stability_margin": 2.506334229800042, "out_of_rail_time": 0.3604992298911771, "y_impact": -2001.782436087753, "apogee_x": 327.68097551101613, "impact_velocity": -5.220580994885573, "max_mach_number": 0.850200521083141, "x_impact": 218.9073873806011, "out_of_rail_stability_margin": 2.583761775042269, "apogee_time": 24.901185032903207} +{"apogee": 3583.580764959765, "frontal_surface_wind": -4.2444876022185225, "apogee_y": 915.307034964373, "lateral_surface_wind": -4.329489674645672, "t_final": 309.92069961145666, "out_of_rail_velocity": 26.762207188462533, "initial_stability_margin": 2.5799423349291444, "out_of_rail_time": 0.3465913420786319, "y_impact": -1765.2073399075157, "apogee_x": 524.3171653595152, "impact_velocity": -5.25845194537824, "max_mach_number": 0.9259147341300998, "x_impact": 179.79250395126752, "out_of_rail_stability_margin": 2.6497176122710435, "apogee_time": 26.10056391600474} +{"apogee": 3345.8124779656255, "frontal_surface_wind": -4.6945885115472805, "apogee_y": 892.4253267686391, "lateral_surface_wind": -4.470070838012333, "t_final": 322.8485776373996, "out_of_rail_velocity": 26.271760315344608, "initial_stability_margin": 2.5290580955817465, "out_of_rail_time": 0.3520365183109293, "y_impact": -2175.1082012663487, "apogee_x": 561.7024311427972, "impact_velocity": -5.065719217167408, "max_mach_number": 0.8945851855121686, "x_impact": 168.79355127333753, "out_of_rail_stability_margin": 2.6028367340909067, "apogee_time": 25.19997305299555} +{"apogee": 3805.9364957671173, "frontal_surface_wind": -4.269493265509526, "apogee_y": 1023.2144838475733, "lateral_surface_wind": -5.806288183606378, "t_final": 330.8906636380743, "out_of_rail_velocity": 27.964275852805418, "initial_stability_margin": 2.630100065529309, "out_of_rail_time": 0.3346852452781659, "y_impact": -2357.788114751217, "apogee_x": 467.3439871737618, "impact_velocity": -5.211917181838343, "max_mach_number": 0.9888989491113712, "x_impact": 499.7012691696042, "out_of_rail_stability_margin": 2.6941926758095676, "apogee_time": 26.63410443796493} +{"apogee": 3556.4996446554, "frontal_surface_wind": -3.7687804898163426, "apogee_y": 1016.511674284893, "lateral_surface_wind": -6.143113936343518, "t_final": 322.98777593410654, "out_of_rail_velocity": 26.97227838896609, "initial_stability_margin": 2.370115878813151, "out_of_rail_time": 0.34419742456827207, "y_impact": -2167.67362426374, "apogee_x": 581.6189563024298, "impact_velocity": -5.1253218792467345, "max_mach_number": 0.9429265721062239, "x_impact": 611.5596995158832, "out_of_rail_stability_margin": 2.445436879200688, "apogee_time": 25.827190558051953} +{"apogee": 3409.7052847965238, "frontal_surface_wind": -3.0129465150622754, "apogee_y": 837.0610287535023, "lateral_surface_wind": -4.434725429153459, "t_final": 322.500392284277, "out_of_rail_velocity": 26.315442329021504, "initial_stability_margin": 2.55979495225858, "out_of_rail_time": 0.3507165790831769, "y_impact": -2356.0730798747386, "apogee_x": 546.6951264021687, "impact_velocity": -5.1500746382995075, "max_mach_number": 0.89653332095408, "x_impact": 193.67709727246333, "out_of_rail_stability_margin": 2.629551066910328, "apogee_time": 25.491472138108733} +{"apogee": 4006.3693308079146, "frontal_surface_wind": -3.312547556767319, "apogee_y": 933.1173830105945, "lateral_surface_wind": -4.941894933762254, "t_final": 353.5670376022463, "out_of_rail_velocity": 28.700606187750708, "initial_stability_margin": 2.5001261695325248, "out_of_rail_time": 0.32760129265720017, "y_impact": -2495.951057327003, "apogee_x": 537.6308654668574, "impact_velocity": -5.22328305667093, "max_mach_number": 1.0386767507553567, "x_impact": 557.0567493023455, "out_of_rail_stability_margin": 2.567721063228973, "apogee_time": 27.196007423021438} +{"apogee": 1908.736736747123, "frontal_surface_wind": -4.545286619686612, "apogee_y": 648.041264372225, "lateral_surface_wind": -4.747954606803458, "t_final": 233.20444443661853, "out_of_rail_velocity": 21.069122874093505, "initial_stability_margin": 2.5322544867984673, "out_of_rail_time": 0.4221769465494857, "y_impact": -1252.2645037766845, "apogee_x": 309.26364651232774, "impact_velocity": -5.048403777083266, "max_mach_number": 0.5888588004289596, "x_impact": 120.75652587040271, "out_of_rail_stability_margin": 2.6212938260090497, "apogee_time": 19.837904560950438} +{"apogee": 2816.24958934864, "frontal_surface_wind": -4.599244712497397, "apogee_y": 916.2692833283882, "lateral_surface_wind": -4.568111498657266, "t_final": 278.278618609887, "out_of_rail_velocity": 24.41563466189233, "initial_stability_margin": 2.5081578541534486, "out_of_rail_time": 0.37343054388673136, "y_impact": -1447.4669917487938, "apogee_x": 648.7729999242334, "impact_velocity": -5.213080340907972, "max_mach_number": 0.7834804674380761, "x_impact": 260.5052643284308, "out_of_rail_stability_margin": 2.584780677625157, "apogee_time": 23.498051343406708} +{"apogee": 3242.308094307731, "frontal_surface_wind": -2.982815016786125, "apogee_y": 863.3914358354883, "lateral_surface_wind": -5.074380767167222, "t_final": 302.29514909868965, "out_of_rail_velocity": 25.663946255498, "initial_stability_margin": 2.5672534951318813, "out_of_rail_time": 0.3596342294935801, "y_impact": -1519.0548562419845, "apogee_x": 482.30783068580786, "impact_velocity": -5.208875195729816, "max_mach_number": 0.8543562094844714, "x_impact": 445.93029305079, "out_of_rail_stability_margin": 2.640961271331624, "apogee_time": 25.021010311952452} +{"apogee": 4529.021812840644, "frontal_surface_wind": -4.256196224614887, "apogee_y": 1236.4314798378741, "lateral_surface_wind": -5.910579385178822, "t_final": 355.9646293836877, "out_of_rail_velocity": 31.070222039907623, "initial_stability_margin": 2.666848923411547, "out_of_rail_time": 0.3080662634932985, "y_impact": -2573.9967500584225, "apogee_x": 787.1842475847562, "impact_velocity": -5.3563838058921815, "max_mach_number": 1.18389127014406, "x_impact": 866.5744313224682, "out_of_rail_stability_margin": 2.7277785809964286, "apogee_time": 28.535454890170307} +{"apogee": 3773.150567392644, "frontal_surface_wind": -4.443077102463483, "apogee_y": 955.3878061988434, "lateral_surface_wind": -5.771414110293211, "t_final": 336.68452438138434, "out_of_rail_velocity": 27.543489201429487, "initial_stability_margin": 2.680687214325261, "out_of_rail_time": 0.33825271304236876, "y_impact": -2470.578911331097, "apogee_x": 374.60359027975676, "impact_velocity": -5.248797925480753, "max_mach_number": 0.9723884661568505, "x_impact": 286.3982441102645, "out_of_rail_stability_margin": 2.749149495312333, "apogee_time": 26.60539482165162} +{"apogee": 3618.5706604048005, "frontal_surface_wind": -3.403237631128055, "apogee_y": 820.966875607905, "lateral_surface_wind": -4.750463124569014, "t_final": 326.4453795276764, "out_of_rail_velocity": 26.960221130785975, "initial_stability_margin": 2.6757165400182563, "out_of_rail_time": 0.3443601864314907, "y_impact": -2023.748086853269, "apogee_x": 405.67120832510705, "impact_velocity": -5.137208275080617, "max_mach_number": 0.9364576036351423, "x_impact": 244.10187008708647, "out_of_rail_stability_margin": 2.7464749041780943, "apogee_time": 26.137489348201218} +{"apogee": 3745.260748346642, "frontal_surface_wind": -3.6127280751665003, "apogee_y": 1013.8329895293804, "lateral_surface_wind": -5.39884876719979, "t_final": 325.209557149793, "out_of_rail_velocity": 27.653306626993537, "initial_stability_margin": 2.574773987345006, "out_of_rail_time": 0.33786722247842566, "y_impact": -2253.9683249187588, "apogee_x": 550.4025849163155, "impact_velocity": -5.171734372979518, "max_mach_number": 0.9820830297324608, "x_impact": 416.14975914680235, "out_of_rail_stability_margin": 2.645016155328838, "apogee_time": 26.44115284909391} +{"apogee": 2849.5515702274315, "frontal_surface_wind": -3.481461094626852, "apogee_y": 783.6655441264116, "lateral_surface_wind": -4.693437430968447, "t_final": 273.35612920471476, "out_of_rail_velocity": 24.36833923457661, "initial_stability_margin": 2.537844166430635, "out_of_rail_time": 0.3745168355544106, "y_impact": -1306.5434142525917, "apogee_x": 412.6320657334109, "impact_velocity": -5.205709999609996, "max_mach_number": 0.7761287203559591, "x_impact": 254.65248378462616, "out_of_rail_stability_margin": 2.613852596861419, "apogee_time": 23.66431804732875} +{"apogee": 4244.90007629161, "frontal_surface_wind": -3.382561704671427, "apogee_y": 916.5593277937767, "lateral_surface_wind": -4.894238772912546, "t_final": 363.5868360091188, "out_of_rail_velocity": 30.279273648253533, "initial_stability_margin": 2.5189426447235714, "out_of_rail_time": 0.3144256370141395, "y_impact": -2682.3329904769994, "apogee_x": 524.9600556749829, "impact_velocity": -5.066338880123744, "max_mach_number": 1.1268900672122508, "x_impact": 616.4444503905102, "out_of_rail_stability_margin": 2.5836819598716136, "apogee_time": 27.633077704250987} +{"apogee": 4054.899573045121, "frontal_surface_wind": -4.205528007722659, "apogee_y": 934.7471575139593, "lateral_surface_wind": -4.367343589015011, "t_final": 345.7786741473781, "out_of_rail_velocity": 28.8913805961019, "initial_stability_margin": 2.6686154640261965, "out_of_rail_time": 0.3261227536185324, "y_impact": -2331.329030811318, "apogee_x": 558.0860040316805, "impact_velocity": -5.315839849605289, "max_mach_number": 1.043680082095999, "x_impact": 275.8821902721137, "out_of_rail_stability_margin": 2.730004828523415, "apogee_time": 27.391547966828874} +{"apogee": 3545.488860003587, "frontal_surface_wind": -3.2152425394191293, "apogee_y": 1013.0184784048213, "lateral_surface_wind": -4.1625118969452615, "t_final": 327.68240877321387, "out_of_rail_velocity": 26.789824967974152, "initial_stability_margin": 2.6109320827169396, "out_of_rail_time": 0.34612464101828755, "y_impact": -1752.450941248235, "apogee_x": 718.2690639132277, "impact_velocity": -5.221166581805151, "max_mach_number": 0.9283507156326842, "x_impact": 646.8378274960803, "out_of_rail_stability_margin": 2.6817331421483437, "apogee_time": 25.922788778470355} +{"apogee": 3328.3997192658558, "frontal_surface_wind": -3.7071402519060186, "apogee_y": 935.7211350563983, "lateral_surface_wind": -5.763847944866734, "t_final": 305.3000842632325, "out_of_rail_velocity": 26.10333910853045, "initial_stability_margin": 2.565870156019963, "out_of_rail_time": 0.3533745766393044, "y_impact": -2065.9623287516174, "apogee_x": 430.28615710659244, "impact_velocity": -5.1704474855654965, "max_mach_number": 0.8841759138373222, "x_impact": 478.93253049872214, "out_of_rail_stability_margin": 2.6371337187400257, "apogee_time": 25.207964878918958} +{"apogee": 2338.886616953487, "frontal_surface_wind": -4.376372858015383, "apogee_y": 830.8540796300078, "lateral_surface_wind": -5.82215729593019, "t_final": 256.9173087650527, "out_of_rail_velocity": 22.73809499249894, "initial_stability_margin": 2.473186197913793, "out_of_rail_time": 0.396792128340614, "y_impact": -1303.8614482395055, "apogee_x": 401.2549084152766, "impact_velocity": -5.116007601776199, "max_mach_number": 0.6851706855274269, "x_impact": 266.450538480061, "out_of_rail_stability_margin": 2.5613958814410887, "apogee_time": 21.660664394513397} +{"apogee": 2738.311059087404, "frontal_surface_wind": -3.3319200254523706, "apogee_y": 731.1515082219289, "lateral_surface_wind": -4.800753609154044, "t_final": 267.0155122346244, "out_of_rail_velocity": 23.84740598226049, "initial_stability_margin": 2.7367606706850522, "out_of_rail_time": 0.38102566934748006, "y_impact": -1300.769537696206, "apogee_x": 358.69127693554213, "impact_velocity": -5.361203759685262, "max_mach_number": 0.7440265428791331, "x_impact": 187.07285702648986, "out_of_rail_stability_margin": 2.8129295734526423, "apogee_time": 23.356089394780767} +{"apogee": 2983.3033214669804, "frontal_surface_wind": -3.926988148972946, "apogee_y": 755.5559779225467, "lateral_surface_wind": -5.105233730777631, "t_final": 280.10869730499365, "out_of_rail_velocity": 24.76407024167618, "initial_stability_margin": 2.5338596410495233, "out_of_rail_time": 0.36868125611797464, "y_impact": -1511.1170399930472, "apogee_x": 340.1913839136258, "impact_velocity": -5.231987052944898, "max_mach_number": 0.7993570817929538, "x_impact": 175.536690674999, "out_of_rail_stability_margin": 2.6067764105884934, "apogee_time": 24.1523024031831} +{"apogee": 3260.780127526729, "frontal_surface_wind": -4.2630035853139345, "apogee_y": 886.6311569304927, "lateral_surface_wind": -4.31125924526127, "t_final": 307.80439310193793, "out_of_rail_velocity": 25.852734697985106, "initial_stability_margin": 2.537416370203071, "out_of_rail_time": 0.35689437330241547, "y_impact": -1703.6118529878502, "apogee_x": 514.6753600226418, "impact_velocity": -5.175914597788924, "max_mach_number": 0.8680333376943979, "x_impact": 103.10302250261267, "out_of_rail_stability_margin": 2.609585679317097, "apogee_time": 25.00403093742554} +{"apogee": 2790.1934063490803, "frontal_surface_wind": -4.159862093748521, "apogee_y": 795.2914273728711, "lateral_surface_wind": -4.642248846217989, "t_final": 276.27210697392076, "out_of_rail_velocity": 24.029604637736274, "initial_stability_margin": 2.5212384829272376, "out_of_rail_time": 0.3786991777261954, "y_impact": -1498.9931784508321, "apogee_x": 387.2343770129541, "impact_velocity": -5.292900750090433, "max_mach_number": 0.7582048750946261, "x_impact": 114.55272861376322, "out_of_rail_stability_margin": 2.599137339170764, "apogee_time": 23.5184849805029} +{"apogee": 3885.592796414068, "frontal_surface_wind": -3.845001652770424, "apogee_y": 939.2832017868111, "lateral_surface_wind": -5.095951483570734, "t_final": 340.0112574786761, "out_of_rail_velocity": 28.14388784661246, "initial_stability_margin": 2.606327437224062, "out_of_rail_time": 0.332753098798267, "y_impact": -2302.648270657349, "apogee_x": 523.7956119484688, "impact_velocity": -5.221534646578817, "max_mach_number": 1.0052439721609034, "x_impact": 441.2699022399714, "out_of_rail_stability_margin": 2.672958551793843, "apogee_time": 26.88999928008215} +{"apogee": 3564.4563492383436, "frontal_surface_wind": -4.608201031876451, "apogee_y": 882.333426326476, "lateral_surface_wind": -4.55907642394957, "t_final": 319.13522219234375, "out_of_rail_velocity": 26.800944604337037, "initial_stability_margin": 2.530396066518384, "out_of_rail_time": 0.3459423347194663, "y_impact": -2178.022977282653, "apogee_x": 552.4549306108088, "impact_velocity": -5.2213280583500215, "max_mach_number": 0.9259688291193067, "x_impact": 217.42824095327947, "out_of_rail_stability_margin": 2.598818935515359, "apogee_time": 26.000702523260614} +{"apogee": 3651.907452355504, "frontal_surface_wind": -3.9333760409866176, "apogee_y": 825.5161669089649, "lateral_surface_wind": -4.8356467932853135, "t_final": 331.41982941219925, "out_of_rail_velocity": 27.073411408637302, "initial_stability_margin": 2.5233441449145144, "out_of_rail_time": 0.34324101610210905, "y_impact": -2333.1995162239323, "apogee_x": 409.36768189900846, "impact_velocity": -5.136155959174707, "max_mach_number": 0.9452208351126825, "x_impact": 216.47618860118308, "out_of_rail_stability_margin": 2.59573151009158, "apogee_time": 26.22172725117455} +{"apogee": 2249.1540235541006, "frontal_surface_wind": -2.9136950906011925, "apogee_y": 699.7716240226395, "lateral_surface_wind": -5.014898321560432, "t_final": 238.28498825340301, "out_of_rail_velocity": 22.28439099039905, "initial_stability_margin": 2.527813521310565, "out_of_rail_time": 0.40284589638826984, "y_impact": -822.4378059975744, "apogee_x": 388.02812201459426, "impact_velocity": -5.329323315219495, "max_mach_number": 0.6501037701009532, "x_impact": 328.21150966566074, "out_of_rail_stability_margin": 2.605714540032568, "apogee_time": 21.4131636137213} +{"apogee": 3874.494312527984, "frontal_surface_wind": -3.7875263209969856, "apogee_y": 983.2045382650492, "lateral_surface_wind": -4.950714226954847, "t_final": 343.51295818392396, "out_of_rail_velocity": 28.3682826061037, "initial_stability_margin": 2.5217592728536595, "out_of_rail_time": 0.3311000223996021, "y_impact": -2397.8618211293274, "apogee_x": 672.4998370752937, "impact_velocity": -5.185911028390577, "max_mach_number": 1.0156905074876306, "x_impact": 540.9545644537977, "out_of_rail_stability_margin": 2.5885529479851566, "apogee_time": 26.774895572955007} +{"apogee": 3449.8346567498425, "frontal_surface_wind": -3.185000897858484, "apogee_y": 768.9851534382531, "lateral_surface_wind": -4.312818755204869, "t_final": 306.5025672415605, "out_of_rail_velocity": 26.348099248173902, "initial_stability_margin": 2.4800468023736766, "out_of_rail_time": 0.3507803011063992, "y_impact": -2157.969479083126, "apogee_x": 414.3514399195889, "impact_velocity": -5.153043230767745, "max_mach_number": 0.8994012607697047, "x_impact": 100.5590495784027, "out_of_rail_stability_margin": 2.5516705606978234, "apogee_time": 25.64186822404151} +{"apogee": 3722.6351942298065, "frontal_surface_wind": -4.092948617010215, "apogee_y": 956.8106206470087, "lateral_surface_wind": -5.0049407159077335, "t_final": 325.6275187914103, "out_of_rail_velocity": 27.28145454123011, "initial_stability_margin": 2.542817456027403, "out_of_rail_time": 0.3409615873441347, "y_impact": -2307.3013342258832, "apogee_x": 537.9814397215778, "impact_velocity": -5.287084158486216, "max_mach_number": 0.9584898196749102, "x_impact": 266.00931567919895, "out_of_rail_stability_margin": 2.612371179032066, "apogee_time": 26.502991578273285} +{"apogee": 2277.8279251643685, "frontal_surface_wind": -3.7408031391008585, "apogee_y": 715.6511412077654, "lateral_surface_wind": -5.172924811671557, "t_final": 244.40275679292427, "out_of_rail_velocity": 22.313624411226854, "initial_stability_margin": 2.497313848975666, "out_of_rail_time": 0.40250665233846283, "y_impact": -1056.5558631456481, "apogee_x": 375.4045200929709, "impact_velocity": -5.309452079953268, "max_mach_number": 0.6572080734601271, "x_impact": 218.0805008347787, "out_of_rail_stability_margin": 2.5799948802508896, "apogee_time": 21.546609308507914} +{"apogee": 3600.0404447472083, "frontal_surface_wind": -4.157342377172009, "apogee_y": 904.1350081985215, "lateral_surface_wind": -4.951582000755581, "t_final": 323.45445748891524, "out_of_rail_velocity": 27.155582787310998, "initial_stability_margin": 2.46772737893552, "out_of_rail_time": 0.3428818366320518, "y_impact": -2254.04041056412, "apogee_x": 486.3724403284261, "impact_velocity": -5.05848825119632, "max_mach_number": 0.9479950961959466, "x_impact": 202.68881016533894, "out_of_rail_stability_margin": 2.5378433027900544, "apogee_time": 25.9809185823884} +{"apogee": 2672.2906159276477, "frontal_surface_wind": -3.186868623037853, "apogee_y": 733.5752883808632, "lateral_surface_wind": -5.023859595140672, "t_final": 273.36404117590416, "out_of_rail_velocity": 23.734232106655067, "initial_stability_margin": 2.4856054039259776, "out_of_rail_time": 0.38191685632737377, "y_impact": -1291.7145656203038, "apogee_x": 368.52270000641425, "impact_velocity": -5.206871844444488, "max_mach_number": 0.739023849160982, "x_impact": 198.63258330716704, "out_of_rail_stability_margin": 2.5642766100710603, "apogee_time": 23.02446097855121} +{"apogee": 4156.82953637903, "frontal_surface_wind": -4.460919868958712, "apogee_y": 895.7224109985343, "lateral_surface_wind": -5.301214101231658, "t_final": 344.781461420436, "out_of_rail_velocity": 29.820918850726752, "initial_stability_margin": 2.5687047947566612, "out_of_rail_time": 0.31783117138513334, "y_impact": -2596.734104346081, "apogee_x": 415.9606714808651, "impact_velocity": -5.118254799315706, "max_mach_number": 1.0961997111425543, "x_impact": 174.22409328456098, "out_of_rail_stability_margin": 2.6301192403558096, "apogee_time": 27.47284202463955} +{"apogee": 4319.35127470076, "frontal_surface_wind": -3.5646724453286067, "apogee_y": 1015.2416620470644, "lateral_surface_wind": -6.895281405815689, "t_final": 374.5769417088964, "out_of_rail_velocity": 30.97651613622723, "initial_stability_margin": 2.4986531067664646, "out_of_rail_time": 0.3087971816006266, "y_impact": -3475.373873639539, "apogee_x": 491.4073472558672, "impact_velocity": -5.066705020034197, "max_mach_number": 1.1662806722540133, "x_impact": 934.2288734296422, "out_of_rail_stability_margin": 2.561112229671911, "apogee_time": 27.70788875440057} +{"apogee": 3117.5202897745644, "frontal_surface_wind": -3.642444100445455, "apogee_y": 850.8700900521549, "lateral_surface_wind": -4.70402995603985, "t_final": 302.9742978864276, "out_of_rail_velocity": 25.357281302372975, "initial_stability_margin": 2.629012571162269, "out_of_rail_time": 0.3616875084002643, "y_impact": -1668.876468541172, "apogee_x": 391.71923703465757, "impact_velocity": -5.165393736379995, "max_mach_number": 0.8350626164065601, "x_impact": 230.63939548324268, "out_of_rail_stability_margin": 2.7008942162765184, "apogee_time": 24.52718977463929} +{"apogee": 2818.1427077940757, "frontal_surface_wind": -3.368689069470279, "apogee_y": 752.4144938905489, "lateral_surface_wind": -5.768975145054103, "t_final": 284.1108641657371, "out_of_rail_velocity": 24.32497667223676, "initial_stability_margin": 2.456180748088198, "out_of_rail_time": 0.3753106482745215, "y_impact": -1821.2060762132107, "apogee_x": 291.2408747970848, "impact_velocity": -5.110671266116348, "max_mach_number": 0.7724979499238693, "x_impact": 290.4231962419677, "out_of_rail_stability_margin": 2.5332731556494004, "apogee_time": 23.50275594544416} +{"apogee": 1251.9907669359416, "frontal_surface_wind": -4.136541817657884, "apogee_y": 445.30655137353284, "lateral_surface_wind": -4.9369696331668145, "t_final": 185.89763302821504, "out_of_rail_velocity": 18.101006099009016, "initial_stability_margin": 2.570978761450612, "out_of_rail_time": 0.48182103114886543, "y_impact": -658.5022895881125, "apogee_x": 174.8691837621877, "impact_velocity": -5.244817210161781, "max_mach_number": 0.4348781221904444, "x_impact": 115.38819962268032, "out_of_rail_stability_margin": 2.6717947244161797, "apogee_time": 16.476260903585775} +{"apogee": 2453.1236796243907, "frontal_surface_wind": -3.9833558520503556, "apogee_y": 844.5044984072373, "lateral_surface_wind": -5.972819077618828, "t_final": 266.616208062199, "out_of_rail_velocity": 23.11538671075964, "initial_stability_margin": 2.5826089431113775, "out_of_rail_time": 0.39062441190212455, "y_impact": -1354.240803306685, "apogee_x": 393.51252516685867, "impact_velocity": -5.1732369894814845, "max_mach_number": 0.7054011366720542, "x_impact": 339.37420824742424, "out_of_rail_stability_margin": 2.665668651729761, "apogee_time": 22.13894593435902} +{"apogee": 3465.113615276112, "frontal_surface_wind": -4.520891519754162, "apogee_y": 999.4998254525327, "lateral_surface_wind": -4.645668354092326, "t_final": 316.0842321891448, "out_of_rail_velocity": 26.92477168201846, "initial_stability_margin": 2.425641848905976, "out_of_rail_time": 0.34467337441054396, "y_impact": -1946.2742393169792, "apogee_x": 762.5291454788326, "impact_velocity": -5.044902598976564, "max_mach_number": 0.9353244847987882, "x_impact": 438.67924863082635, "out_of_rail_stability_margin": 2.4973753591124246, "apogee_time": 25.489056730493267} +{"apogee": 3418.3852785278145, "frontal_surface_wind": -3.0633314364292485, "apogee_y": 869.7285048852802, "lateral_surface_wind": -4.924918757417978, "t_final": 311.79498773410995, "out_of_rail_velocity": 26.236231529616024, "initial_stability_margin": 2.622958870587312, "out_of_rail_time": 0.3515489136017078, "y_impact": -1672.8917649311632, "apogee_x": 454.6727847292232, "impact_velocity": -5.153121429095131, "max_mach_number": 0.89294456072223, "x_impact": 373.8573526946888, "out_of_rail_stability_margin": 2.695032630464474, "apogee_time": 25.536466047246876} +{"apogee": 3546.798523821776, "frontal_surface_wind": -3.734993548942408, "apogee_y": 794.3262604328846, "lateral_surface_wind": -5.177121055381325, "t_final": 337.89571965442036, "out_of_rail_velocity": 26.807002480610297, "initial_stability_margin": 2.5001502239916493, "out_of_rail_time": 0.34582202020705954, "y_impact": -2342.140152942799, "apogee_x": 359.4710988903438, "impact_velocity": -5.010813810830097, "max_mach_number": 0.9318367189268297, "x_impact": 187.7517997751707, "out_of_rail_stability_margin": 2.575590478258739, "apogee_time": 25.82481815262343} +{"apogee": 3693.7242784195087, "frontal_surface_wind": -4.083630988422871, "apogee_y": 888.1815980445824, "lateral_surface_wind": -5.121050064747783, "t_final": 337.2585290941917, "out_of_rail_velocity": 27.318267186543146, "initial_stability_margin": 2.469962842560619, "out_of_rail_time": 0.34105547544286274, "y_impact": -2022.9018326535802, "apogee_x": 462.16760728392904, "impact_velocity": -5.1602477165949745, "max_mach_number": 0.9587759774374282, "x_impact": -96.26878015478988, "out_of_rail_stability_margin": 2.5417551354416537, "apogee_time": 26.331254236265718} +{"apogee": 3938.3204336927083, "frontal_surface_wind": -4.250317291002822, "apogee_y": 997.4164230311022, "lateral_surface_wind": -4.323766734463443, "t_final": 350.03209091046006, "out_of_rail_velocity": 29.063746545851043, "initial_stability_margin": 2.454826702411364, "out_of_rail_time": 0.32447840548776186, "y_impact": -2262.362311186252, "apogee_x": 660.6496877451102, "impact_velocity": -5.0724533397626095, "max_mach_number": 1.054868509606987, "x_impact": 351.76354036385544, "out_of_rail_stability_margin": 2.5212239962607037, "apogee_time": 26.805109145984556} +{"apogee": 2966.668633108827, "frontal_surface_wind": -4.354315277044086, "apogee_y": 901.5963711358562, "lateral_surface_wind": -5.708032064217207, "t_final": 284.54264224209714, "out_of_rail_velocity": 24.81664542701976, "initial_stability_margin": 2.592188437801929, "out_of_rail_time": 0.3687282800981479, "y_impact": -1588.4333942328888, "apogee_x": 349.3357736486525, "impact_velocity": -5.226161437329518, "max_mach_number": 0.8020761061599956, "x_impact": 322.13188909434473, "out_of_rail_stability_margin": 2.665322282188238, "apogee_time": 24.070130901088387} +{"apogee": 3678.001390735641, "frontal_surface_wind": -3.9657341861737563, "apogee_y": 939.3189017413574, "lateral_surface_wind": -5.1063306116867935, "t_final": 326.85130211032316, "out_of_rail_velocity": 27.35565186604991, "initial_stability_margin": 2.778371415161271, "out_of_rail_time": 0.34017274856429824, "y_impact": -2306.7654211188396, "apogee_x": 538.15504028874, "impact_velocity": -5.205042094074384, "max_mach_number": 0.958934481251867, "x_impact": 262.95768838126793, "out_of_rail_stability_margin": 2.8455046554739853, "apogee_time": 26.276917356755554} +{"apogee": 4018.1104631574044, "frontal_surface_wind": -4.199162787984338, "apogee_y": 966.7046245180038, "lateral_surface_wind": -5.9512340611787815, "t_final": 341.0165109239083, "out_of_rail_velocity": 28.905420627687977, "initial_stability_margin": 2.6345583679889932, "out_of_rail_time": 0.32560744161389577, "y_impact": -2564.8304804112827, "apogee_x": 441.1334996211137, "impact_velocity": -5.196688697238588, "max_mach_number": 1.051404787744187, "x_impact": 396.49610288233254, "out_of_rail_stability_margin": 2.7029024070124295, "apogee_time": 27.160349819281755} +{"apogee": 3253.261887487919, "frontal_surface_wind": -3.7888932716434236, "apogee_y": 917.2720769776556, "lateral_surface_wind": -5.710439541308664, "t_final": 314.3732410402694, "out_of_rail_velocity": 25.888137609326044, "initial_stability_margin": 2.543539816900533, "out_of_rail_time": 0.3563582964140308, "y_impact": -2219.5493908070202, "apogee_x": 402.2140381913957, "impact_velocity": -5.084582917969193, "max_mach_number": 0.8730150477790338, "x_impact": 426.0553233367289, "out_of_rail_stability_margin": 2.61765466012798, "apogee_time": 24.921763828866855} +{"apogee": 2038.232822006892, "frontal_surface_wind": -3.518942208238076, "apogee_y": 653.4773956688691, "lateral_surface_wind": -4.7184289047989205, "t_final": 234.04198139432364, "out_of_rail_velocity": 21.395978653746337, "initial_stability_margin": 2.5974872559023465, "out_of_rail_time": 0.4170688672216163, "y_impact": -792.1437009940422, "apogee_x": 256.48475189800723, "impact_velocity": -5.272409630249596, "max_mach_number": 0.6053200795814591, "x_impact": 145.7504936268748, "out_of_rail_stability_margin": 2.6834534434988973, "apogee_time": 20.53036215576582} +{"apogee": 2004.1759361243974, "frontal_surface_wind": -4.598614889643675, "apogee_y": 766.4146526122627, "lateral_surface_wind": -5.648264872301437, "t_final": 228.10673553621373, "out_of_rail_velocity": 21.420056310920607, "initial_stability_margin": 2.6750748079769506, "out_of_rail_time": 0.4164701298009173, "y_impact": -979.5513569742493, "apogee_x": 327.51192584228306, "impact_velocity": -5.269417346199548, "max_mach_number": 0.6084108521236261, "x_impact": 229.9281584756828, "out_of_rail_stability_margin": 2.761931425056001, "apogee_time": 20.324653422718992} +{"apogee": 2986.7143578265077, "frontal_surface_wind": -3.8623541989498578, "apogee_y": 714.5165001187027, "lateral_surface_wind": -5.082812142364545, "t_final": 290.0132182906828, "out_of_rail_velocity": 24.747527166310228, "initial_stability_margin": 2.5683261868585516, "out_of_rail_time": 0.3691044052253446, "y_impact": -1708.0792258414483, "apogee_x": 268.6673432795286, "impact_velocity": -5.129642037255641, "max_mach_number": 0.7999094808186158, "x_impact": 69.22777174581883, "out_of_rail_stability_margin": 2.643846215880008, "apogee_time": 24.15198991375388} +{"apogee": 2937.3249550929563, "frontal_surface_wind": -4.275748574242886, "apogee_y": 803.3298894722698, "lateral_surface_wind": -4.992061451267228, "t_final": 300.46724144983125, "out_of_rail_velocity": 24.815877905768566, "initial_stability_margin": 2.5791803970041554, "out_of_rail_time": 0.36821693347761986, "y_impact": -2170.858784517776, "apogee_x": 429.7589058546031, "impact_velocity": -5.024386919930757, "max_mach_number": 0.8063328653054785, "x_impact": 322.9612393860442, "out_of_rail_stability_margin": 2.6571786342719514, "apogee_time": 23.859062802041187} +{"apogee": 3996.9115249905276, "frontal_surface_wind": -3.7835828616212375, "apogee_y": 959.0151271232098, "lateral_surface_wind": -5.280518240233337, "t_final": 360.8638859636712, "out_of_rail_velocity": 29.023995426731023, "initial_stability_margin": 2.515485647984805, "out_of_rail_time": 0.3251211809426393, "y_impact": -2896.402672802543, "apogee_x": 467.9078637886909, "impact_velocity": -5.082453302124562, "max_mach_number": 1.0533945930329471, "x_impact": 316.90324183202944, "out_of_rail_stability_margin": 2.581325284010274, "apogee_time": 27.06275768916107} +{"apogee": 3264.8564967002135, "frontal_surface_wind": -3.8810778817659237, "apogee_y": 965.4159411991188, "lateral_surface_wind": -6.72227861543539, "t_final": 307.0030451743203, "out_of_rail_velocity": 25.99596396029284, "initial_stability_margin": 2.6679205317439965, "out_of_rail_time": 0.35489892728200173, "y_impact": -2233.5224936504483, "apogee_x": 342.6420557007235, "impact_velocity": -5.0536322930466415, "max_mach_number": 0.8776095475993376, "x_impact": 543.254833778517, "out_of_rail_stability_margin": 2.7420404711926567, "apogee_time": 24.927219754664154} +{"apogee": 3797.5685972755605, "frontal_surface_wind": -4.271281822636469, "apogee_y": 847.03730135533, "lateral_surface_wind": -4.995883805192391, "t_final": 332.6286050088647, "out_of_rail_velocity": 27.89720179659139, "initial_stability_margin": 2.510851371297206, "out_of_rail_time": 0.33523312132374716, "y_impact": -2655.046217522149, "apogee_x": 446.4895818474621, "impact_velocity": -5.043918650427335, "max_mach_number": 0.9951307131929221, "x_impact": 503.23943346387705, "out_of_rail_stability_margin": 2.583526365506102, "apogee_time": 26.54502604807747} +{"apogee": 3931.8125014034595, "frontal_surface_wind": -4.338701763270172, "apogee_y": 995.9132686955533, "lateral_surface_wind": -5.401698254601444, "t_final": 342.1561385206134, "out_of_rail_velocity": 29.035956116422845, "initial_stability_margin": 2.4389750050322876, "out_of_rail_time": 0.32484117963911396, "y_impact": -2406.75427808376, "apogee_x": 575.337097612752, "impact_velocity": -4.987091825094103, "max_mach_number": 1.0612884839917596, "x_impact": 311.2096058484707, "out_of_rail_stability_margin": 2.51075512259, "apogee_time": 26.748632732169362} +{"apogee": 3775.519117764259, "frontal_surface_wind": -4.2673310011136385, "apogee_y": 1012.1630087253565, "lateral_surface_wind": -4.686739641551506, "t_final": 329.76719462826645, "out_of_rail_velocity": 27.813068853184667, "initial_stability_margin": 2.6358526092723222, "out_of_rail_time": 0.3367177328106602, "y_impact": -2076.0543308050433, "apogee_x": 562.7430471902774, "impact_velocity": -5.1926133757981106, "max_mach_number": 0.984126098366045, "x_impact": 357.85582522464983, "out_of_rail_stability_margin": 2.701924050490265, "apogee_time": 26.554336876622784} +{"apogee": 3680.2721850439743, "frontal_surface_wind": -3.677153100121104, "apogee_y": 880.8014996972406, "lateral_surface_wind": -5.355176676306832, "t_final": 327.6849456765257, "out_of_rail_velocity": 27.310385026108975, "initial_stability_margin": 2.6119715923106637, "out_of_rail_time": 0.34100761441326133, "y_impact": -2450.0143097047876, "apogee_x": 365.0274800258772, "impact_velocity": -5.204034122601761, "max_mach_number": 0.9585733084753566, "x_impact": 185.89141022126375, "out_of_rail_stability_margin": 2.68215369298615, "apogee_time": 26.275019429687855} +{"apogee": 3431.650190011215, "frontal_surface_wind": -4.396499582018061, "apogee_y": 956.7441573583344, "lateral_surface_wind": -4.270194469349204, "t_final": 307.2456083272591, "out_of_rail_velocity": 26.318793569073883, "initial_stability_margin": 2.510923089103543, "out_of_rail_time": 0.35106022759252603, "y_impact": -1637.1021653899293, "apogee_x": 617.2623183698954, "impact_velocity": -5.296386806224455, "max_mach_number": 0.9002908675623732, "x_impact": 151.79827164553308, "out_of_rail_stability_margin": 2.584114299407272, "apogee_time": 25.58263955885719} +{"apogee": 4048.414976487407, "frontal_surface_wind": -4.345265988631907, "apogee_y": 980.7802377662935, "lateral_surface_wind": -5.396419230601599, "t_final": 336.8046289600785, "out_of_rail_velocity": 28.896917789586105, "initial_stability_margin": 2.5787340512638015, "out_of_rail_time": 0.3260160774314721, "y_impact": -2409.6210051643197, "apogee_x": 513.199760638137, "impact_velocity": -5.244512661768816, "max_mach_number": 1.0513832163562005, "x_impact": 267.6088382839362, "out_of_rail_stability_margin": 2.6450942821085452, "apogee_time": 27.337191733480473} +{"apogee": 3966.969352562571, "frontal_surface_wind": -4.158367086202538, "apogee_y": 924.5121992216217, "lateral_surface_wind": -4.843918200397008, "t_final": 339.20911020669985, "out_of_rail_velocity": 28.560796443914143, "initial_stability_margin": 2.6601006872937387, "out_of_rail_time": 0.3289462786117325, "y_impact": -2415.254283439537, "apogee_x": 516.122510910166, "impact_velocity": -5.2539984713720935, "max_mach_number": 1.0308784546640217, "x_impact": 375.91530427578294, "out_of_rail_stability_margin": 2.7279871054629226, "apogee_time": 27.070775305932848} diff --git a/docs/notebooks/test_mrs.ipynb b/docs/notebooks/test_mrs.ipynb deleted file mode 100644 index 90e7d5acd..000000000 --- a/docs/notebooks/test_mrs.ipynb +++ /dev/null @@ -1,450 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Quick test notebook for MRS" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "# We import these lines for debugging purposes, only works on Jupyter Notebook\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from scipy.stats import norm\n", - "\n", - "from rocketpy import MonteCarlo\n", - "from rocketpy.simulation.multivariate_rejection_sampler import (\n", - " MultivariateRejectionSampler,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "monte_carlo_filepath = (\n", - " \"monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example\"\n", - ")\n", - "mrs_filepath = \"monte_carlo_analysis/monte_carlo_analysis_outputs/mrs\"\n", - "old_mass_pdf = norm(15.426, 0.5).pdf\n", - "new_mass_pdf = norm(15, 0.5).pdf\n", - "distribution_dict = {\n", - " \"mass\": (old_mass_pdf, new_mass_pdf),\n", - "}\n", - "mrs = MultivariateRejectionSampler(\n", - " monte_carlo_filepath=monte_carlo_filepath,\n", - " mrs_filepath=mrs_filepath,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "mrs.sample(distribution_dict=distribution_dict)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt\n", - "A total of 113 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", - "\n", - "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/lprates/Desktop/Work/RocketPy/RocketPy/rocketpy/simulation/monte_carlo.py:133: UserWarning: This class is still under testing and some attributes may be changed in next versions\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "mrs_results = MonteCarlo(mrs_filepath, None, None, None)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "A total of 113 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.outputs.txt\n", - "\n", - "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.inputs.txt\n", - "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs.errors.txt\n" - ] - } - ], - "source": [ - "mrs_results.import_results()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MRS mass mean after resample: 15.027532656859725\n", - "MRS mass std after resample: 0.4560120026589398\n" - ] - } - ], - "source": [ - "mrs_mass_list = []\n", - "for single_input_dict in mrs_results.inputs_log:\n", - " mrs_mass_list.append(single_input_dict[\"mass\"])\n", - "\n", - "print(f\"MRS mass mean after resample: {np.mean(mrs_mass_list)}\")\n", - "print(f\"MRS mass std after resample: {np.std(mrs_mass_list)}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(111.0)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mrs.expected_sample_size" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The following input file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.inputs.txt\n", - "A total of 1000 simulations results were loaded from the following output file: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.outputs.txt\n", - "\n", - "The following error file was imported: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.errors.txt\n" - ] - } - ], - "source": [ - "original_results = MonteCarlo(monte_carlo_filepath, None, None, None)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Comparison of Monte Carlo Simulation by RocketPy\n", - "Original data Source: monte_carlo_analysis/monte_carlo_analysis_outputs/mrs\n", - "Comparison data Source: monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example\n", - "Original number of simulations: 113\n", - "Comparison number of simulations: 1000\n", - "Results: \n", - "\n", - " Parameter Source Mean Median Std. Dev. 95% PI Lower 95% PI Upper\n", - "--------------------------------------------------------------------------------------------------------------------------------------------\n", - " initial_stability_margin Original 2.556 2.568 0.086 2.392 2.710\n", - " initial_stability_margin Other 2.596 2.596 0.085 2.425 2.763\n", - " apogee Original 3203.634 3367.672 680.251 1855.810 4155.730\n", - " apogee Other 3221.616 3300.831 594.740 1981.254 4149.382\n", - " frontal_surface_wind Original -3.789 -3.845 0.483 -4.569 -2.954\n", - " frontal_surface_wind Other -3.839 -3.933 0.481 -4.608 -2.928\n", - " x_impact Original 324.695 322.132 191.745 -6.640 725.390\n", - " x_impact Other 312.319 306.587 195.323 -59.172 717.304\n", - " apogee_y Original 858.244 871.212 136.406 592.627 1071.250\n", - " apogee_y Other 876.923 885.545 123.791 628.347 1094.965\n", - " out_of_rail_velocity Original 25.700 26.078 2.586 20.821 29.656\n", - " out_of_rail_velocity Other 25.690 25.896 2.194 21.244 29.632\n", - " impact_velocity Original -5.291 -5.193 1.103 -5.339 -5.022\n", - " impact_velocity Other -5.259 -5.247 0.378 -5.404 -5.085\n", - " max_mach_number Original 0.861 0.883 0.152 0.575 1.095\n", - " max_mach_number Other 0.859 0.871 0.131 0.596 1.092\n", - " y_impact Original -1910.501 -1946.274 570.613 -2798.655 -895.268\n", - " y_impact Other -1839.493 -1840.286 486.133 -2737.980 -863.422\n", - " apogee_x Original 441.655 438.452 123.850 211.294 668.057\n", - " apogee_x Other 446.565 441.278 124.777 221.778 697.555\n", - " lateral_surface_wind Original -5.290 -5.190 0.630 -6.687 -4.276\n", - " lateral_surface_wind Other -5.259 -5.131 0.621 -6.700 -4.258\n", - " out_of_rail_stability_margin Original 2.630 2.637 0.085 2.471 2.778\n", - " out_of_rail_stability_margin Other 2.669 2.671 0.084 2.497 2.831\n", - " apogee_time Original 24.618 25.362 2.434 19.598 27.503\n", - " apogee_time Other 24.782 25.198 2.015 20.216 27.553\n", - " t_final Original 300.349 310.959 43.098 224.124 357.220\n", - " t_final Other 299.027 303.558 34.327 228.105 353.583\n", - " out_of_rail_time Original 0.362 0.354 0.034 0.319 0.427\n", - " out_of_rail_time Other 0.361 0.356 0.027 0.320 0.420\n" - ] - } - ], - "source": [ - "mrs_results.compare_info(original_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAMWCAYAAACHiaukAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgbFJREFUeJzs3XtYFnX+//HXfYMcPAAqysHFQCXFNCkPiGnqSotpB8o2NcvDmnSQNlNrtQNq2VKWZaZF1ibVWpmtuX3NSELNtlhS1MpCwxQ1E5UIUFREmN8f/ZjtFlBwgBv0+biu+0Jm3jP3ez6Mer+Yk80wDEMAAAAAcJ7szm4AAAAAQONGqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAFiWnZ0tm82mpKQkZ7fiIDk5WeHh4fLw8JDNZlN+fr6zWwKACxKhAgAakKSkJNlsNodX27ZtNXjwYH388cf13s+GDRscemnSpIk6dOigsWPHavfu3bXyHl9++aVmz55d6x/4f/nlF916663y9PTU4sWL9dZbb6lZs2a1+h4AgN+4OrsBAEBFjz/+uEJCQmQYhg4dOqSkpCQNGzZM//d//6frrruu3vv561//qt69e6ukpERbtmzRkiVL9NFHH+nbb79VYGCgpXV/+eWXmjNnjsaPHy8fH5/aaVjSpk2bdPToUT3xxBOKioqqtfUCACoiVABAA3TttdeqV69e5vcTJ06Un5+f3nnnHaeEigEDBuiWW26RJE2YMEGXXnqp/vrXv+qNN97QzJkz672f6jh8+LAk1WpQAQBUjtOfAKAR8PHxkaenp1xdHX8XVFRUpGnTpikoKEju7u7q3Lmznn32WRmGIUk6ceKEunTpoi5duujEiRPmcnl5eQoICFC/fv1UWlpa437++Mc/SpL27Nlz1rp169ZpwIABatasmXx8fHTjjTcqMzPTnD979mw9+OCDkqSQkBDzNKvs7OyzrnfFihXq2bOnPD095evrq9tvv10HDhww5w8aNEjjxo2TJPXu3Vs2m03jx4+vcn179+7Vvffeq86dO8vT01OtW7fWn//85wp9lJ+etnHjRt11111q3bq1vLy8NHbsWP36668V1vvSSy/psssuk7u7uwIDAzV58uRKT/NavHixOnToIE9PT/Xp00eff/65Bg0apEGDBjnUFRcXa9asWerUqZPc3d0VFBSkhx56SMXFxRXW+c9//tMco1atWmnUqFHav39/1YMKABZwpAIAGqCCggLl5ubKMAwdPnxYL774oo4dO6bbb7/drDEMQzfccIPWr1+viRMnKjw8XJ988okefPBBHThwQM8//7w8PT31xhtv6KqrrtIjjzyi5557TpI0efJkFRQUKCkpSS4uLjXu78cff5QktW7dusqaTz/9VNdee606dOig2bNn68SJE3rxxRd11VVXacuWLQoODtbNN9+sH374Qe+8846ef/55+fr6SpLatGlT5XqTkpI0YcIE9e7dWwkJCTp06JBeeOEFffHFF9q6dat8fHz0yCOPqHPnzlqyZIl5KlnHjh2rXOemTZv05ZdfatSoUfrDH/6g7Oxsvfzyyxo0aJC+//57NW3a1KE+Li5OPj4+mj17tnbu3KmXX35Ze/fuNa9BkX4LTHPmzFFUVJTuueces27Tpk364osv1KRJE0nSyy+/rLi4OA0YMEAPPPCAsrOzFRMTo5YtW+oPf/iD+Z5lZWW64YYb9J///EexsbEKCwvTt99+q+eff14//PCDVq1aZdY++eSTeuyxx3Trrbfqzjvv1JEjR/Tiiy/q6quvNscIAGqVAQBoMJYuXWpIqvByd3c3kpKSHGpXrVplSDLmzp3rMP2WW24xbDabsWvXLnPazJkzDbvdbmzcuNFYsWKFIclYsGDBOftZv369Icl4/fXXjSNHjhg///yz8dFHHxnBwcGGzWYzNm3aZBiGYezZs8eQZCxdutRcNjw83Gjbtq3xyy+/mNO+/vprw263G2PHjjWnPfPMM4YkY8+ePefs59SpU0bbtm2Nbt26GSdOnDCnr1692pBkxMfHm9PKx7K8x7M5fvx4hWlpaWmGJOPNN9+ssM6ePXsap06dMqfPmzfPkGT8+9//NgzDMA4fPmy4ubkZf/rTn4zS0lKzbtGiReZ4GoZhFBcXG61btzZ69+5tlJSUmHVJSUmGJGPgwIHmtLfeesuw2+3G559/7tBnYmKiIcn44osvDMMwjOzsbMPFxcV48sknHeq+/fZbw9XVtcJ0AKgNnP4EAA3Q4sWLlZKSopSUFP3zn//U4MGDdeedd2rlypVmzZo1a+Ti4qK//vWvDstOmzZNhmE43C1q9uzZuuyyyzRu3Djde++9GjhwYIXlzuYvf/mL2rRpo8DAQA0fPlxFRUV64403HK77+L2DBw9q27ZtGj9+vFq1amVOv/zyy3XNNddozZo11X7v39u8ebMOHz6se++9Vx4eHub04cOHq0uXLvroo4/Oa72enp7mn0tKSvTLL7+oU6dO8vHx0ZYtWyrUx8bGmkcaJOmee+6Rq6uruV2ffvqpTp06pSlTpshu/99/tZMmTZKXl5fZ5+bNm/XLL79o0qRJDqe2jRkzRi1btnR4zxUrVigsLExdunRRbm6u+So/FW39+vWSpJUrV6qsrEy33nqrQ52/v79CQ0PNOgCoTZz+BAANUJ8+fRw+sI8ePVpXXHGF4uLidN1118nNzU179+5VYGCgWrRo4bBsWFiYpN+uEyjn5uam119/Xb1795aHh4eWLl1qnqZTHfHx8RowYIBcXFzk6+ursLCwCtd3/F75e3fu3LnCvLCwMH3yyScqKiqq8S1ez7beLl266D//+U+N1lfuxIkTSkhI0NKlS3XgwAHzmhTpt1PRzhQaGurwffPmzRUQEGBeg1FVn25uburQoYM5v/xrp06dHOpcXV0VHBzsMC0rK0uZmZlVnhpWfmF6VlaWDMOo0GO534chAKgthAoAaATsdrsGDx6sF154QVlZWbrssstqvI5PPvlEknTy5EllZWUpJCSk2st27979gr4t63333aelS5dqypQpioyMlLe3t2w2m0aNGqWysjJntyfpt2squnfvbl4Xc6agoCCzzmaz6eOPP670epnmzZvXaZ8ALk6ECgBoJE6fPi1JOnbsmCTpkksu0aeffqqjR486HK3YsWOHOb/cN998o8cff1wTJkzQtm3bdOedd+rbb7+Vt7d3nfRa/t47d+6sMG/Hjh3y9fU1j1LU5IjJ79dbftpPuZ07dzpsc028//77GjdunObPn29OO3nyZJUP5MvKytLgwYPN748dO6aDBw9q2LBhFfrs0KGDWXfq1Cnt2bPHDGjldbt27XJY3+nTp5Wdna3LL7/cnNaxY0d9/fXXGjJkyFnHrGPHjjIMQyEhIbr00kurOwQAYAnXVABAI1BSUqK1a9fKzc3NPL1p2LBhKi0t1aJFixxqn3/+edlsNl177bXmsuPHj1dgYKBeeOEFJSUl6dChQ3rggQfqrN+AgACFh4frjTfecPhgvn37dq1du9b88C3JDBfVeaJ2r1691LZtWyUmJjrcRvXjjz9WZmamhg8ffl79uri4OJzyJEkvvvhilbfbXbJkiUpKSszvX375ZZ0+fdoc86ioKLm5uWnhwoUO6/3HP/6hgoICs89evXqpdevWevXVV83QKEnLli2rcIvaW2+9VQcOHNCrr75aoZ8TJ06oqKhIknTzzTfLxcVFc+bMqbBNhmHol19+Oed4AEBNcaQCABqgjz/+2DzicPjwYb399tvKysrSjBkz5OXlJUm6/vrrNXjwYD3yyCPKzs5Wjx49tHbtWv373//WlClTzFuozp07V9u2bVNqaqpatGihyy+/XPHx8Xr00Ud1yy23OHzAr03PPPOMrr32WkVGRmrixInmLWW9vb01e/Zss65nz56SpEceeUSjRo1SkyZNdP3111d6vUWTJk309NNPa8KECRo4cKBGjx5t3lI2ODj4vIPSddddp7feekve3t7q2rWr0tLS9Omnn1Z5y9xTp05pyJAhuvXWW7Vz50699NJL6t+/v2644QZJv90Sd+bMmZozZ46GDh2qG264wazr3bu3eWtgNzc3zZ49W/fdd5/++Mc/6tZbb1V2draSkpLUsWNHhyMSd9xxh9577z3dfffdWr9+va666iqVlpZqx44deu+99/TJJ5+oV69e6tixo+bOnauZM2eat6dt0aKF9uzZow8++ECxsbGaPn36eY0TAFTJeTeeAgCcqbJbynp4eBjh4eHGyy+/bJSVlTnUHz161HjggQeMwMBAo0mTJkZoaKjxzDPPmHUZGRmGq6urcd999zksd/r0aaN3795GYGCg8euvv1bZT/ktZVesWHHWviu7paxhGMann35qXHXVVYanp6fh5eVlXH/99cb3339fYfknnnjCaNeunWG326t1e9nly5cbV1xxheHu7m60atXKGDNmjPHTTz851NTklrK//vqrMWHCBMPX19do3ry5ER0dbezYscO45JJLjHHjxlVY52effWbExsYaLVu2NJo3b26MGTPG4da55RYtWmR06dLFaNKkieHn52fcc889lY73woULjUsuucRwd3c3+vTpY3zxxRdGz549jaFDhzrUnTp1ynj66aeNyy67zHB3dzdatmxp9OzZ05gzZ45RUFDgUPuvf/3L6N+/v9GsWTOjWbNmRpcuXYzJkycbO3fuPOd4AEBN2QzjjGOjAACgUuUP3tu0aVOVt9OtDWVlZWrTpo1uvvnmSk93AoCGhmsqAABwopMnT1a49uHNN99UXl6eBg0a5JymAKCGuKYCAAAn+u9//6sHHnhAf/7zn9W6dWtt2bJF//jHP9StWzf9+c9/dnZ7AFAthAoAAJwoODhYQUFBWrhwofLy8tSqVSuNHTtWTz31lNzc3JzdHgBUC9dUAAAAALCEayoAAAAAWEKoAAAAAGAJ11TUobKyMv38889q0aKFwwOMAAAAgMbAMAwdPXpUgYGBsturPh5BqKhDP//8s4KCgpzdBgAAAGDJ/v379Yc//KHK+YSKOtSiRQtJv/0QvLy8nNwNAAAAUDOFhYUKCgoyP9dWhVBRh8pPefLy8iJUAAAAoNE616n8XKgNAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsMTV2Q0AAFCX9u3bp9zcXGe3gUbM19dX7du3d3YbQIPW4ENFdna2QkJCtHXrVoWHh1drmaSkJE2ZMkX5+flO7QMA4Fz79u1T585hOnnyuLNbafT8m9t0V083vZJxSjnHDGe3U688PJpq585MggVwFvUWKvbv369Zs2YpOTlZubm5CggIUExMjOLj49W6desqlwsKCtLBgwfl6+tb7fcaOXKkhg0bVhttN0qlpaX6/PPPdfDgQQUEBGjAgAFycXFxdltOV9NxYRyBxi83N/f/B4p/SgpzdjuNWkDzHzR70F36cGeSco5d6ux26lGmTp68Xbm5uYQK4CzqJVTs3r1bkZGRuvTSS/XOO+8oJCRE3333nR588EF9/PHH+u9//6tWrVpVWO7UqVNyc3OTv79/jd7P09NTnp6etdV+o7Jy5UpNmzZN2dnZ5rTg4GDNnz9fN998s/Mac7Kajkt9j+Px48e1Y8cOdenSRU2bNq319QMIk3Sls5to5Movw+wiKdyJfQAXn8bwOaFeLtSePHmy3NzctHbtWg0cOFDt27fXtddeq08//VQHDhzQI488Ium3D21PPPGExo4dKy8vL8XGxio7O1s2m03btm0z1/fhhx8qNDRUHh4eGjx4sN544w3ZbDbzdKekpCT5+PiY9bNnz1Z4eLjeeustBQcHy9vbW6NGjdLRo0fNmuTkZPXv318+Pj5q3bq1rrvuOv3444/1MTy1ZuXKlbrlllvUvXt3paWl6ejRo0pLS1P37t11yy23aOXKlc5u0SlqOi7OGMcdO3aoZ8+e2rFjR62vGwAANG6N4XNCnYeKvLw8ffLJJ7r33nsrHD3w9/fXmDFjtHz5chnGb+dnPvvss+rRo4e2bt2qxx57rML69uzZo1tuuUUxMTH6+uuvddddd5mh5Gx+/PFHrVq1SqtXr9bq1av12Wef6amnnjLnFxUVaerUqdq8ebNSU1Nlt9t10003qayszOII1I/S0lJNmzZN1113nVatWqW+ffuqefPm6tu3r1atWqXrrrtO06dPV2lpqbNbrVc1HRfGEQAAoObq/PSnrKwsGYahsLDKz2UNCwvTr7/+qiNHjkiS/vjHP2ratGnm/N+ffiJJr7zyijp37qxnnnlGktS5c2dt375dTz755Fn7KCsrU1JSklq0aCFJuuOOO5SammouN2LECIf6119/XW3atNH333+vbt26VWtbi4uLVVxcbH5fWFhYreVqw+eff67s7Gy98847stsds6LdbtfMmTPVr18/ff755xo0aFC99eVsNR0XZ43jiRMnJEmZmZm1tk4Av/87dcKpfaAx499nOF/5/lf+eaEhqrcLtcuPRJxLr169zjp/586d6t27t8O0Pn36nHO9wcHBZqCQpICAAB0+fNj8PisrS/Hx8UpPT1dubq55hGLfvn3VDhUJCQmaM2dOtWpr28GDByWpyl7Lp5fXXSxqOi7OGsfy8Hz77bfX6noBlMuWdJWzm0CjlC2Jf5/RMGRnZ+uqqxrmv2V1Hio6deokm82mzMxM3XTTTRXmZ2ZmqmXLlmrTpo0kqVmzZnXSR5MmTRy+t9lsDqc2XX/99brkkkv06quvKjAwUGVlZerWrZtOnTpV7feYOXOmpk6dan5fWFiooKAg681XQ0BAgCRp+/bt6tu3b4X527dvd6i7WNR0XJw1jsHBwZKkf/7zn1Ue1QNQc5mZmf//w2Cws1tBoxUsiX+f4Vzl/5aVf15oiOo8VLRu3VrXXHONXnrpJT3wwAMO11Xk5ORo2bJlGjt2rGw2W7XW17lzZ61Zs8Zh2qZNmyz1+Msvv2jnzp169dVXNWDAAEnSf/7znxqvx93dXe7u7pZ6OV8DBgxQcHCw/v73v2vVqlUOp+6UlZUpISFBISEh5vZdLGo6Ls4ax/K/F2FhYbrySu5QA9S+i/OOgKgN/PuMhqMh3920Xu7+tGjRIhUXFys6OlobN27U/v37lZycrGuuuUbt2rU75/UQv3fXXXdpx44d+tvf/qYffvhB7733npKSkiSp2sHkTC1btlTr1q21ZMkS7dq1S+vWrXM44tAYuLi4aP78+Vq9erViYmIc7loUExOj1atX69lnn73onrNQ03FhHAEAAGquXkJFaGioNm/erA4dOujWW29Vx44dFRsbq8GDBystLa3SZ1RUJSQkRO+//75Wrlypyy+/XC+//LJ596fzPUpgt9v17rvvKiMjQ926ddMDDzxgXgjemNx88816//339e2336pfv37y8vJSv379tH37dr3//vsX7XMqajouzhjHLl26KCMjQ126dKn1dQMAgMatMXxOsBnVvYK6AXvyySeVmJio/fv3O7sVB4WFhfL29lZBQYG8vLzq7X15EnTleKI2cPHZsmWLevbsKZ6obd0V/j9oy1136cpXXtHWnIvridrS7crIyOD0J1yUqvt5tt7u/lSbXnrpJfXu3VutW7fWF198oWeeeUZxcXHObqvBcHFxuahuG1tdNR0XxhFo/Hx9feXh0VQnT3LnHqsOHrNp9gY3HTx2m6RG//vIGvHwaCpfX19ntwE0aI0yVGRlZWnu3LnKy8tT+/btNW3aNM2cOdPZbQEAGpj27dtr585M5ebmOruVC8YNzm7ACXx9fdW+fXtntwE0aBfE6U8NlbNOfwIAAABqQ3U/z9bLhdoAAAAALlyECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJa4OrsBAABqYt++fcrNzXV2G4ADX19ftW/f3tltAE5DqAAANBr79u1TWOfOOn7ypLNbwVn4N7fprp5ueiXjlHKOGc5up1409fBQ5s6dBAtctC7oUJGUlKQpU6YoPz/f2a0AAGpBbm6ujp88qX9KCnN2M6iSZ3Obwga5a+TOEp24CEJFpqTbT55Ubm4uoQIXrUYRKvbv369Zs2YpOTlZubm5CggIUExMjOLj49W6dWtJUnBwsKZMmaIpU6Y4t9kGoLS0VJ9//rkOHjyogIAADRgwQC4uLs5uCwBqTZikK53dBM6J4AdcPBr8hdq7d+9Wr169lJWVpXfeeUe7du1SYmKiUlNTFRkZqby8vHrvqaSkpN7fs7pWrlypTp06afDgwbrttts0ePBgderUSStXrnR2aw3C8ePHtWXLFh0/ftzZrQAAgFrA/+0NQ4MPFZMnT5abm5vWrl2rgQMHqn379rr22mv16aef6sCBA3rkkUc0aNAg7d27Vw888IBsNptsNpvDOj755BOFhYWpefPmGjp0qA4ePOgw/7XXXlNYWJg8PDzUpUsXvfTSS+a87Oxs2Ww2LV++XAMHDpSHh4eWLVtWL9teUytXrtQtt9yi7t27Ky0tTUePHlVaWpq6d++uW265hWAhaceOHerZs6d27Njh7FYAAEAt4P/2hqFBn/6Ul5enTz75RE8++aQ8PT0d5vn7+2vMmDFavny5srKyFB4ertjYWE2aNMmh7vjx43r22Wf11ltvyW636/bbb9f06dPNYLBs2TLFx8dr0aJFuuKKK7R161ZNmjRJzZo107hx48z1zJgxQ/Pnz9cVV1whDw+Put/4GiotLdW0adN03XXXadWqVbLbf8uLffv21apVqxQTE6Pp06frxhtv5FQoAAAA1KoGHSqysrJkGIbCwio/KzMsLEy//vqrSktL5eLiohYtWsjf39+hpqSkRImJierYsaMkKS4uTo8//rg5f9asWZo/f75uvvlmSVJISIi+//57vfLKKw6hYsqUKWZNVYqLi1VcXGx+X1hYWLMNtuDzzz9Xdna23nnnHTNQlLPb7Zo5c6b69eunzz//XIMGDaq3vhqaEydOSJIyMzOd3AmA81H+d/eEk/sAfq98f+T/Fucw/104wb8MztSgQ0U5wzj/O0c0bdrUDBSSFBAQoMOHD0uSioqK9OOPP2rixIkORzhOnz4tb29vh/X06tXrnO+VkJCgOXPmnHevVpSf0tWtW7dK55dPP/PUr4tNdna2JOn22293biMALMmWdJWzmwD+v+z//5X/W5wrOztbV13FvwzO0qBDRadOnWSz2ZSZmambbrqpwvzMzEy1bNlSbdq0qXIdTZo0cfjeZrOZIeXYsWOSpFdffVUREREOdWeeItSsWbNz9jtz5kxNnTrV/L6wsFBBQUHnXK42BAQESJK2b9+uvn37Vpi/fft2h7qLVXBwsCTpn//8Z5VHwAA0XJmZmbr99tsV7OxGgN8J/v9f+b/FOcx/F/7///FwjgYdKlq3bq1rrrlGL730kh544AGH6ypycnK0bNkyjR07VjabTW5ubiotLa3R+v38/BQYGKjdu3drzJgxlvt1d3eXu7u75fWcjwEDBig4OFh///vfHa6pkKSysjIlJCQoJCREAwYMcEp/DUX5PhQWFqYrr+SGlEBj5XnuEqDelO+P/N/iXGdef4v61eDv/rRo0SIVFxcrOjpaGzdu1P79+5WcnKxrrrlG7dq105NPPinpt99Ab9y4UQcOHFBubm611z9nzhwlJCRo4cKF+uGHH/Ttt99q6dKleu655+pqk+qEi4uL5s+fr9WrVysmJsbh7k8xMTFavXq1nn32WS7SBgAAQK1r8KEiNDRUmzdvVocOHXTrrbeqY8eOio2N1eDBg5WWlqZWrVpJkh5//HFlZ2erY8eOZz0d6kx33nmnXnvtNS1dulTdu3fXwIEDlZSUpJCQkLrapDpz88036/3339e3336rfv36ycvLS/369dP27dv1/vvvn/NC84tBly5dlJGRoS5duji7FQAAUAv4v71hsBlWroLGWRUWFsrb21sFBQXy8vKqt/flidoALlRbtmxRz5499U/xtOaGzNPfrrC7mivzlWM6kVPm7HbqXKak2yVlZGRw+hMuONX9PNugr6nA+XFxcbmobxsL4MLl6+urph4euv3kSWe3grPwP2borg3FeuWYoRxnN1NPmnp4yNfX19ltAE5DqAAANBrt27dX5s6dNbp2Ds5zg7MbqEe+vr5q3769s9sAnIZQAQBoVNq3b8+HNwBoYBr8hdoAAAAAGjZCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAscXV2AxcywzAkSYWFhU7uBAAAAKi58s+x5Z9rq0KoqENHjx6VJAUFBTm5EwAAAOD8HT16VN7e3lXOtxnnih04b2VlZfr555/VokUL2Ww2Z7dT5woLCxUUFKT9+/fLy8vL2e00Woxj7WAcawfjWDsYx9rBONYOxrF2XCzjaBiGjh49qsDAQNntVV85wZGKOmS32/WHP/zB2W3UOy8vrwv6L1d9YRxrB+NYOxjH2sE41g7GsXYwjrXjYhjHsx2hKMeF2gAAAAAsIVQAAAAAsIRQgVrj7u6uWbNmyd3d3dmtNGqMY+1gHGsH41g7GMfawTjWDsaxdjCOjrhQGwAAAIAlHKkAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqICDjRs36vrrr1dgYKBsNptWrVrlMN8wDMXHxysgIECenp6KiopSVlaWQ01eXp7GjBkjLy8v+fj4aOLEiTp27JhDzTfffKMBAwbIw8NDQUFBmjdvXl1vWr061ziOHz9eNpvN4TV06FCHGsZRSkhIUO/evdWiRQu1bdtWMTEx2rlzp0PNyZMnNXnyZLVu3VrNmzfXiBEjdOjQIYeaffv2afjw4WratKnatm2rBx98UKdPn3ao2bBhg6688kq5u7urU6dOSkpKquvNqzfVGcdBgwZV2Cfvvvtuh5qLfRxffvllXX755eaDriIjI/Xxxx+b89kXq+dc48i+WHNPPfWUbDabpkyZYk5jf6y5ysaR/bEGDOB31qxZYzzyyCPGypUrDUnGBx984DD/qaeeMry9vY1Vq1YZX3/9tXHDDTcYISEhxokTJ8yaoUOHGj169DD++9//Gp9//rnRqVMnY/To0eb8goICw8/PzxgzZoyxfft245133jE8PT2NV155pb42s86daxzHjRtnDB061Dh48KD5ysvLc6hhHA0jOjraWLp0qbF9+3Zj27ZtxrBhw4z27dsbx44dM2vuvvtuIygoyEhNTTU2b95s9O3b1+jXr585//Tp00a3bt2MqKgoY+vWrcaaNWsMX19fY+bMmWbN7t27jaZNmxpTp041vv/+e+PFF180XFxcjOTk5Hrd3rpSnXEcOHCgMWnSJId9sqCgwJzPOBrGhx9+aHz00UfGDz/8YOzcudN4+OGHjSZNmhjbt283DIN9sbrONY7sizXz1VdfGcHBwcbll19u3H///eZ09seaqWoc2R+rj1CBKp35YbisrMzw9/c3nnnmGXNafn6+4e7ubrzzzjuGYRjG999/b0gyNm3aZNZ8/PHHhs1mMw4cOGAYhmG89NJLRsuWLY3i4mKz5m9/+5vRuXPnOt4i56gqVNx4441VLsM4Vu7w4cOGJOOzzz4zDOO3/a9JkybGihUrzJrMzExDkpGWlmYYxm8Bz263Gzk5OWbNyy+/bHh5eZlj99BDDxmXXXaZw3uNHDnSiI6OrutNcoozx9EwfvuP8/f/kZ6Jcaxcy5Ytjddee4190aLycTQM9sWaOHr0qBEaGmqkpKQ4jBv7Y81UNY6Gwf5YE5z+hGrbs2ePcnJyFBUVZU7z9vZWRESE0tLSJElpaWny8fFRr169zJqoqCjZ7Xalp6ebNVdffbXc3NzMmujoaO3cuVO//vprPW2N823YsEFt27ZV586ddc899+iXX34x5zGOlSsoKJAktWrVSpKUkZGhkpISh32yS5cuat++vcM+2b17d/n5+Zk10dHRKiws1HfffWfW/H4d5TXl67jQnDmO5ZYtWyZfX19169ZNM2fO1PHjx815jKOj0tJSvfvuuyoqKlJkZCT74nk6cxzLsS9Wz+TJkzV8+PAK28r+WDNVjWM59sfqcXV2A2g8cnJyJMnhL0759+XzcnJy1LZtW4f5rq6uatWqlUNNSEhIhXWUz2vZsmWd9N+QDB06VDfffLNCQkL0448/6uGHH9a1116rtLQ0ubi4MI6VKCsr05QpU3TVVVepW7dukn7bTjc3N/n4+DjUnrlPVrbPls87W01hYaFOnDghT0/Putgkp6hsHCXptttu0yWXXKLAwEB98803+tvf/qadO3dq5cqVkhjHct9++60iIyN18uRJNW/eXB988IG6du2qbdu2sS/WQFXjKLEvVte7776rLVu2aNOmTRXm8W9j9Z1tHCX2x5ogVABOMGrUKPPP3bt31+WXX66OHTtqw4YNGjJkiBM7a7gmT56s7du36z//+Y+zW2nUqhrH2NhY88/du3dXQECAhgwZoh9//FEdO3as7zYbrM6dO2vbtm0qKCjQ+++/r3Hjxumzzz5zdluNTlXj2LVrV/bFati/f7/uv/9+paSkyMPDw9ntNFrVGUf2x+rj9CdUm7+/vyRVuHvEoUOHzHn+/v46fPiww/zTp08rLy/Poaaydfz+PS42HTp0kK+vr3bt2iWJcTxTXFycVq9erfXr1+sPf/iDOd3f31+nTp1Sfn6+Q/2Z++S5xqmqGi8vrwvmN0hS1eNYmYiICEly2CcZR8nNzU2dOnVSz549lZCQoB49euiFF15gX6yhqsaxMuyLFWVkZOjw4cO68sor5erqKldXV3322WdauHChXF1d5efnx/5YDecax9LS0grLsD9WjVCBagsJCZG/v79SU1PNaYWFhUpPTzfPhY2MjFR+fr4yMjLMmnXr1qmsrMz8ixgZGamNGzeqpKTErElJSVHnzp0vuFN2quunn37SL7/8ooCAAEmMYznDMBQXF6cPPvhA69atq3C6V8+ePdWkSROHfXLnzp3at2+fwz757bffOoS0lJQUeXl5madbREZGOqyjvOb353g3Zucax8ps27ZNkhz2yYt9HCtTVlam4uJi9kWLysexMuyLFQ0ZMkTffvuttm3bZr569eqlMWPGmH9mfzy3c42ji4tLhWXYH8/C2VeKo2E5evSosXXrVmPr1q2GJOO5554ztm7dauzdu9cwjN9uKevj42P8+9//Nr755hvjxhtvrPSWsldccYWRnp5u/Oc//zFCQ0MdboWan59v+Pn5GXfccYexfft249133zWaNm16Qd0K9WzjePToUWP69OlGWlqasWfPHuPTTz81rrzySiM0NNQ4efKkuQ7G0TDuuecew9vb29iwYYPD7fyOHz9u1tx9991G+/btjXXr1hmbN282IiMjjcjISHN++e3+/vSnPxnbtm0zkpOTjTZt2lR6u78HH3zQyMzMNBYvXnxB3e7vXOO4a9cu4/HHHzc2b95s7Nmzx/j3v/9tdOjQwbj66qvNdTCOhjFjxgzjs88+M/bs2WN88803xowZMwybzWasXbvWMAz2xeo62ziyL56/M+9SxP54fn4/juyPNUOogIP169cbkiq8xo0bZxjGb7eVfeyxxww/Pz/D3d3dGDJkiLFz506Hdfzyyy/G6NGjjebNmxteXl7GhAkTjKNHjzrUfP3110b//v0Nd3d3o127dsZTTz1VX5tYL842jsePHzf+9Kc/GW3atDGaNGliXHLJJcakSZMcbkdnGIyjYRiVjqEkY+nSpWbNiRMnjHvvvddo2bKl0bRpU+Omm24yDh486LCe7Oxs49prrzU8PT0NX19fY9q0aUZJSYlDzfr1643w8HDDzc3N6NChg8N7NHbnGsd9+/YZV199tdGqVSvD3d3d6NSpk/Hggw863IvdMBjHv/zlL8Yll1xiuLm5GW3atDGGDBliBgrDYF+srrONI/vi+TszVLA/np/fjyP7Y83YDMMw6u+4CAAAAIALDddUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQANWHBwsMaPH+/sNi54zzzzjDp06CAXFxeFh4c7ux0AaHQIFQBQT5KSkmSz2bR58+ZK5w8aNEjdunWz/D5r1qzR7NmzLa/nYrF27Vo99NBDuuqqq7R06VL9/e9/d3ZLANDouDq7AQBA1Xbu3Cm7vWa//1mzZo0WL15MsKimdevWyW636x//+Ifc3Nyc3Q4ANEocqQCABszd3V1NmjRxdhs1UlRU5OwWauTw4cPy9PQkUACABYQKAGjAzrymoqSkRHPmzFFoaKg8PDzUunVr9e/fXykpKZKk8ePHa/HixZIkm81mvsoVFRVp2rRpCgoKkru7uzp37qxnn31WhmE4vO+JEyf017/+Vb6+vmrRooVuuOEGHThwQDabzeEIyOzZs2Wz2fT999/rtttuU8uWLdW/f39J0jfffKPx48erQ4cO8vDwkL+/v/7yl7/ol19+cXiv8nX88MMPuv322+Xt7a02bdrosccek2EY2r9/v2688UZ5eXnJ399f8+fPr9bYnT59Wk888YQ6duwod3d3BQcH6+GHH1ZxcbFZY7PZtHTpUhUVFZljlZSUVOU6P//8c/35z39W+/bt5e7urqCgID3wwAM6ceKEQ9348ePVvHlz7d69W9HR0WrWrJkCAwP1+OOPVxjr2v6ZSNKBAwf0l7/8RX5+fnJ3d9dll12m119/vcL2FBcXa9asWerUqZO5PQ899JDDGAFAdXD6EwDUs4KCAuXm5laYXlJScs5lZ8+erYSEBN15553q06ePCgsLtXnzZm3ZskXXXHON7rrrLv38889KSUnRW2+95bCsYRi64YYbtH79ek2cOFHh4eH65JNP9OCDD+rAgQN6/vnnzdrx48frvffe0x133KG+ffvqs88+0/Dhw6vs689//rNCQ0P197//3fwwnJKSot27d2vChAny9/fXd999pyVLlui7777Tf//7X4ewI0kjR45UWFiYnnrqKX300UeaO3euWrVqpVdeeUV//OMf9fTTT2vZsmWaPn26evfurauvvvqsY3XnnXfqjTfe0C233KJp06YpPT1dCQkJyszM1AcffCBJeuutt7RkyRJ99dVXeu211yRJ/fr1q3KdK1as0PHjx3XPPfeodevW+uqrr/Tiiy/qp59+0ooVKxxqS0tLNXToUPXt21fz5s1TcnKyZs2apdOnT+vxxx+vs5/JoUOH1LdvX9lsNsXFxalNmzb6+OOPNXHiRBUWFmrKlCmSpLKyMt1www36z3/+o9jYWIWFhenbb7/V888/rx9++EGrVq066/gCgAMDAFAvli5dakg66+uyyy5zWOaSSy4xxo0bZ37fo0cPY/jw4Wd9n8mTJxuV/fO+atUqQ5Ixd+5ch+m33HKLYbPZjF27dhmGYRgZGRmGJGPKlCkOdePHjzckGbNmzTKnzZo1y5BkjB49usL7HT9+vMK0d955x5BkbNy4scI6YmNjzWmnT582/vCHPxg2m8146qmnzOm//vqr4enp6TAmldm2bZshybjzzjsdpk+fPt2QZKxbt86cNm7cOKNZs2ZnXd/ZtikhIcGw2WzG3r17HdYpybjvvvvMaWVlZcbw4cMNNzc348iRI4Zh1M3PZOLEiUZAQICRm5vrUDtq1CjD29vb3Ia33nrLsNvtxueff+5Ql5iYaEgyvvjii2qNCQAYhmFw+hMA1LPFixcrJSWlwuvyyy8/57I+Pj767rvvlJWVVeP3XbNmjVxcXPTXv/7VYfq0adNkGIY+/vhjSVJycrIk6d5773Wou++++6pc9913311hmqenp/nnkydPKjc3V3379pUkbdmypUL9nXfeaf7ZxcVFvXr1kmEYmjhxojndx8dHnTt31u7du6vsRfptWyVp6tSpDtOnTZsmSfroo4/OunxVfr9NRUVFys3NVb9+/WQYhrZu3VqhPi4uzvxz+ZGDU6dO6dNPPzX7rM2fiWEY+te//qXrr79ehmEoNzfXfEVHR6ugoMAc+xUrVigsLExdunRxqPvjH/8oSVq/fv15jRGAixOnPwFAPevTp4969epVYXrLli0rPS3q9x5//HHdeOONuvTSS9WtWzcNHTpUd9xxR7UCyd69exUYGKgWLVo4TA8LCzPnl3+12+0KCQlxqOvUqVOV6z6zVpLy8vI0Z84cvfvuuzp8+LDDvIKCggr17du3d/je29tbHh4e8vX1rTD9zOsyzlS+DWf27O/vLx8fH3Nba2rfvn2Kj4/Xhx9+qF9//dVh3pnbZLfb1aFDB4dpl156qSQpOzvb7LM2fyZHjhxRfn6+lixZoiVLllS6DeU/i6ysLGVmZqpNmzZnrQOA6iBUAEAjcvXVV+vHH3/Uv//9b61du1avvfaann/+eSUmJjr8pr++/f43+OVuvfVWffnll3rwwQcVHh6u5s2bq6ysTEOHDlVZWVmFehcXl2pNk1ThIuaqnHndhhWlpaW65pprlJeXp7/97W/q0qWLmjVrpgMHDmj8+PGVblN9K+/h9ttv17hx4yqtKQ+gZWVl6t69u5577rlK64KCguqmSQAXJEIFADQyrVq10oQJEzRhwgQdO3ZMV199tWbPnm2Giqo+SF9yySX69NNPdfToUYffjO/YscOcX/61rKxMe/bsUWhoqFm3a9euavf466+/KjU1VXPmzFF8fLw5/XxO2zof5duQlZVl/tZf+u0i5vz8fHNba+Lbb7/VDz/8oDfeeENjx441p5ffeetMZWVl2r17t3l0QpJ++OEHSb/d1au8z9r8mbRp00YtWrRQaWmpoqKizro9HTt21Ndff60hQ4bUavgCcHHimgoAaETOPO2nefPm6tSpk8MtQJs1ayZJys/Pd6gdNmyYSktLtWjRIofpzz//vGw2m6699lpJUnR0tCTppZdecqh78cUXq91n+RGGM48oLFiwoNrrsGLYsGGVvl/5b+XPdierqlS2TYZh6IUXXqhymd+PtWEYWrRokZo0aaIhQ4aYfdbmz8TFxUUjRozQv/71L23fvr1CP0eOHDH/fOutt+rAgQN69dVXK9SdOHGi0T1vBIBzcaQCABqRrl27atCgQerZs6datWqlzZs36/3333e4ILhnz56SpL/+9a+Kjo6Wi4uLRo0apeuvv16DBw/WI488ouzsbPXo0UNr167Vv//9b02ZMkUdO3Y0lx8xYoQWLFigX375xbx9aflv2avzW20vLy9dffXVmjdvnkpKStSuXTutXbtWe/bsqYNRqahHjx4aN26clixZovz8fA0cOFBfffWV3njjDcXExGjw4ME1XmeXLl3UsWNHTZ8+XQcOHJCXl5f+9a9/Vbi2opyHh4eSk5M1btw4RURE6OOPP9ZHH32khx9+2LyOoS5+Jk899ZTWr1+viIgITZo0SV27dlVeXp62bNmiTz/9VHl5eZKkO+64Q++9957uvvturV+/XldddZVKS0u1Y8cOvffee/rkk08qvfYHACrlpLtOAcBFp/yWsps2bap0/sCBA895S9m5c+caffr0MXx8fAxPT0+jS5cuxpNPPmmcOnXKrDl9+rRx3333GW3atDFsNpvD7WWPHj1qPPDAA0ZgYKDRpEkTIzQ01HjmmWeMsrIyh/ctKioyJk+ebLRq1cpo3ry5ERMTY+zcudOQ5HCL1/LbwZbfIvX3fvrpJ+Omm24yfHx8DG9vb+PPf/6z8fPPP1d5W9oz11HVrV4rG6fKlJSUGHPmzDFCQkKMJk2aGEFBQcbMmTONkydPVut9KvP9998bUVFRRvPmzQ1fX19j0qRJxtdff21IMpYuXVphnT/++KPxpz/9yWjatKnh5+dnzJo1yygtLXVYZ23/TAzDMA4dOmRMnjzZCAoKMpo0aWL4+/sbQ4YMMZYsWeJQd+rUKePpp582LrvsMsPd3d1o2bKl0bNnT2POnDlGQUFBtcYEAAzDMGyGUc2r3QAAF7Vt27bpiiuu0D//+U+NGTPG2e00aOPHj9f777+vY8eO1en78DMB0FBwTQUAoIITJ05UmLZgwQLZ7fZzPskadYOfCYCGjGsqAAAVzJs3TxkZGRo8eLBcXV318ccf6+OPP1ZsbCy3GnUSfiYAGjJCBQCggn79+iklJUVPPPGEjh07pvbt22v27Nl65JFHnN3aRYufCYCGjGsqAAAAAFjCNRUAAAAALCFUAAAAALCEayrqUFlZmX7++We1aNGiWg+LAgAAABoSwzB09OhRBQYGym6v+ngEoaIO/fzzz9yRAwAAAI3e/v379Yc//KHK+YSKOtSiRQtJv/0QvLy8nNwNAAAAUDOFhYUKCgoyP9dWhVBRh8pPefLy8iJUAAAAoNE616n8XKgNAAAAwBJCBQAAAABLCBUAAAAALOGaCgAAANSLsrIynTp1ytlt4HeaNGkiFxcXy+shVAAAAKDOnTp1Snv27FFZWZmzW8EZfHx85O/vb+m5aoQKAAAA1CnDMHTw4EG5uLgoKCjorA9RQ/0xDEPHjx/X4cOHJUkBAQHnvS5CBQAAAOrU6dOndfz4cQUGBqpp06bObge/4+npKUk6fPiw2rZte96nQhETAQAAUKdKS0slSW5ubk7uBJUpD3olJSXnvQ5CBQAAAOqFlXP2UXdq4+dCqAAAAABgCaECAAAAqAPZ2dmy2Wzatm1btZdJSkqSj4+P0/uoKS7UBgAAgFPMnt043m///v2aNWuWkpOTlZubq4CAAMXExCg+Pl6tW7eucrmgoCAdPHhQvr6+1X6vkSNHatiwYefXqBNxpAIAAACowu7du9WrVy9lZWXpnXfe0a5du5SYmKjU1FRFRkYqLy+v0uVOnTolFxcX+fv7y9W1+r/H9/T0VNu2bWur/XpDqAAAAACqMHnyZLm5uWnt2rUaOHCg2rdvr2uvvVaffvqpDhw4oEceeUSSFBwcrCeeeEJjx46Vl5eXYmNjKz3t6MMPP1RoaKg8PDw0ePBgvfHGG7LZbMrPz5dU8fSn2bNnKzw8XG+99ZaCg4Pl7e2tUaNG6ejRo2ZNcnKy+vfvLx8fH7Vu3VrXXXedfvzxx/oYHhOhAgAAAKhEXl6ePvnkE917773m8xzK+fv7a8yYMVq+fLkMw5AkPfvss+rRo4e2bt2qxx57rML69uzZo1tuuUUxMTH6+uuvddddd5mh5Gx+/PFHrVq1SqtXr9bq1av12Wef6amnnjLnFxUVaerUqdq8ebNSU1Nlt9t100031evTy7mmAgAAAKhEVlaWDMNQWFhYpfPDwsL066+/6siRI5KkP/7xj5o2bZo5Pzs726H+lVdeUefOnfXMM89Ikjp37qzt27frySefPGsfZWVlSkpKUosWLSRJd9xxh1JTU83lRowY4VD/+uuvq02bNvr+++/VrVu36m+wBRypAAAAAM6i/EjEufTq1eus83fu3KnevXs7TOvTp8851xscHGwGCkkKCAjQ4cOHze+zsrI0evRodejQQV5eXgoODpYk7du3r1p91wZCBQAAAFCJTp06yWazKTMzs9L5mZmZatmypdq0aSNJatasWZ300aRJE4fvbTabw6lN119/vfLy8vTqq68qPT1d6enpkn67WLy+ECoAAACASrRu3VrXXHONXnrpJZ04ccJhXk5OjpYtW6aRI0dW+4nUnTt31ubNmx2mbdq0yVKPv/zyi3bu3KlHH31UQ4YMMU/Jqm+ECgAAAKAKixYtUnFxsaKjo7Vx40bt379fycnJuuaaa9SuXbtzXg/xe3fddZd27Nihv/3tb/rhhx/03nvvKSkpSZKqHUzO1LJlS7Vu3VpLlizRrl27tG7dOk2dOvW81mUFoQIAAACoQmhoqDZv3qwOHTro1ltvVceOHRUbG6vBgwcrLS1NrVq1qva6QkJC9P7772vlypW6/PLL9fLLL5t3f3J3dz+v/ux2u959911lZGSoW7dueuCBB8wLweuTzajulSeoscLCQnl7e6ugoEBeXl7ObgcAAJypvh/p7AwNYBtPnjypPXv2KCQkRB4eHs5up0F58sknlZiYqP379zuth7P9fKr7eZZbygIAAAD15KWXXlLv3r3VunVrffHFF3rmmWcUFxfn7LYsI1QAAAAA9SQrK0tz585VXl6e2rdvr2nTpmnmzJnObssyQgUAAABQT55//nk9//zzzm6j1nGhNgAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAdSApKUk+Pj7ObqNe8JwKAAAAOMfs2Y3i/fbv369Zs2YpOTlZubm5CggIUExMjOLj49W6dWtJUnBwsKZMmaIpU6bUXr+NCEcqAAAAgCrs3r1bvXr1UlZWlt555x3t2rVLiYmJSk1NVWRkpPLy8uq9p5KSknp/z3MhVAAAAABVmDx5stzc3LR27VoNHDhQ7du317XXXqtPP/1UBw4c0COPPKJBgwZp7969euCBB2Sz2WSz2RzW8cknnygsLEzNmzfX0KFDdfDgQYf5r732msLCwuTh4aEuXbropZdeMudlZ2fLZrNp+fLlGjhwoDw8PLRs2bJ62faa4PQnAAAAoBJ5eXn65JNP9OSTT8rT09Nhnr+/v8aMGaPly5crKytL4eHhio2N1aRJkxzqjh8/rmeffVZvvfWW7Ha7br/9dk2fPt0MBsuWLVN8fLwWLVqkK664Qlu3btWkSZPUrFkzjRs3zlzPjBkzNH/+fF1xxRXy8PCo+42vIUIFAAAAUImsrCwZhqGwsLBK54eFhenXX39VaWmpXFxc1KJFC/n7+zvUlJSUKDExUR07dpQkxcXF6fHHHzfnz5o1S/Pnz9fNN98sSQoJCdH333+vV155xSFUTJkyxaxpiAgVAAAAwFkYhnHeyzZt2tQMFJIUEBCgw4cPS5KKior0448/auLEiQ5HOE6fPi1vb2+H9fTq1eu8e6gPDeKaisWLFys4OFgeHh6KiIjQV199ddb6FStWqEuXLvLw8FD37t21Zs0ah/mGYSg+Pl4BAQHy9PRUVFSUsrKyHGry8vI0ZswYeXl5ycfHRxMnTtSxY8fM+bNnzzbPifv9q1mzZrW34QAAAGiwOnXqJJvNpszMzErnZ2ZmqmXLlmrTpk2V62jSpInD9zabzQwp5Z89X331VW3bts18bd++Xf/9738dlmvon0GdHiqWL1+uqVOnatasWdqyZYt69Oih6OhoM8Gd6csvv9To0aM1ceJEbd26VTExMYqJidH27dvNmnnz5mnhwoVKTExUenq6mjVrpujoaJ08edKsGTNmjL777julpKRo9erV2rhxo2JjY83506dP18GDBx1eXbt21Z///Oe6GwwAAAA0GK1bt9Y111yjl156SSdOnHCYl5OTo2XLlmnkyJGy2Wxyc3NTaWlpjdbv5+enwMBA7d69W506dXJ4hYSE1Oam1Dmnh4rnnntOkyZN0oQJE9S1a1clJiaqadOmev311yutf+GFFzR06FA9+OCDCgsL0xNPPKErr7xSixYtkvTbUYoFCxbo0Ucf1Y033qjLL79cb775pn7++WetWrVK0m+pMjk5Wa+99poiIiLUv39/vfjii3r33Xf1888/S5KaN28uf39/83Xo0CF9//33mjhxYr2MCwAAAJxv0aJFKi4uVnR0tDZu3Kj9+/crOTlZ11xzjdq1a6cnn3xS0m/Pqdi4caMOHDig3Nzcaq9/zpw5SkhI0MKFC/XDDz/o22+/1dKlS/Xcc8/V1SbVCaeGilOnTikjI0NRUVHmNLvdrqioKKWlpVW6TFpamkO9JEVHR5v1e/bsUU5OjkONt7e3IiIizJq0tDT5+Pg4nJsWFRUlu92u9PT0St/3tdde06WXXqoBAwac38YCAACg0QkNDdXmzZvVoUMH3XrrrerYsaNiY2M1ePBgpaWlqVWrVpKkxx9/XNnZ2erYseNZT4c605133qnXXntNS5cuVffu3TVw4EAlJSU1uiMVTr1QOzc3V6WlpfLz83OY7ufnpx07dlS6TE5OTqX1OTk55vzyaWeradu2rcN8V1dXtWrVyqz5vZMnT2rZsmWaMWPGWbenuLhYxcXF5veFhYVnrQcAALio1fcTtc/TJZdcoqSkpLPW9O3bV19//bXDtPHjx2v8+PEO02JiYipc+H3bbbfptttuq3S9wcHBli4Ury9OP/2pMfjggw909OhRh9t6VSYhIUHe3t7mKygoqJ46BAAAAJzHqaHC19dXLi4uOnTokMP0Q4cOVbjHb7ny6xuqqi//eq6aMy8EP336tPLy8ip939dee03XXXddhaMfZ5o5c6YKCgrM1/79+89aDwAAAFwInBoq3Nzc1LNnT6WmpprTysrKlJqaqsjIyEqXiYyMdKiXpJSUFLM+JCRE/v7+DjWFhYVKT083ayIjI5Wfn6+MjAyzZt26dSorK1NERITDuvfs2aP169dX6wJtd3d3eXl5ObwAAACAC53TH343depUjRs3Tr169VKfPn20YMECFRUVacKECZKksWPHql27dkpISJAk3X///Ro4cKDmz5+v4cOH691339XmzZu1ZMkSSb/d+3fKlCmaO3euQkNDFRISoscee0yBgYGKiYmR9NvTD4cOHapJkyYpMTFRJSUliouL06hRoxQYGOjQ3+uvv66AgABde+219TcoAAAAQCPi9FAxcuRIHTlyRPHx8crJyVF4eLiSk5PNU4327dsnu/1/B1T69eunt99+W48++qgefvhhhYaGatWqVerWrZtZ89BDD6moqEixsbHKz89X//79lZycLA8PD7Nm2bJliouL05AhQ2S32zVixAgtXLjQobeysjIlJSVp/PjxcnFxqeORAAAAuLA1hguOL0a18XOxGfx060xhYaG8vb1VUFDAqVAAADREjeTuQ5Y0gG0sKSnRrl27FBgYKG9vb2e3gzP88ssvOnz4sC699NIKv0iv7udZpx+pAAAAwIXN1dVVTZs21ZEjR9SkSROHs1DgPIZh6Pjx4zp8+LB8fHwsnZlDqAAAAECdstlsCggI0J49e7R3715nt4Mz+Pj4VHnn1eoiVAAAAKDOubm5KTQ0VKdOnXJ2K/idJk2a1Mq1w4QKAADQ6NTWZQKDNtTOeurToEHO7uD82e12hxvn4MLBCW0AAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALDE6aFi8eLFCg4OloeHhyIiIvTVV1+dtX7FihXq0qWLPDw81L17d61Zs8ZhvmEYio+PV0BAgDw9PRUVFaWsrCyHmry8PI0ZM0ZeXl7y8fHRxIkTdezYsQrrefbZZ3XppZfK3d1d7dq105NPPlk7Gw0AAABcQJwaKpYvX66pU6dq1qxZ2rJli3r06KHo6GgdPny40vovv/xSo0eP1sSJE7V161bFxMQoJiZG27dvN2vmzZunhQsXKjExUenp6WrWrJmio6N18uRJs2bMmDH67rvvlJKSotWrV2vjxo2KjY11eK/7779fr732mp599lnt2LFDH374ofr06VM3AwEAAAA0YjbDMAxnvXlERIR69+6tRYsWSZLKysoUFBSk++67TzNmzKhQP3LkSBUVFWn16tXmtL59+yo8PFyJiYkyDEOBgYGaNm2apk+fLkkqKCiQn5+fkpKSNGrUKGVmZqpr167atGmTevXqJUlKTk7WsGHD9NNPPykwMFCZmZm6/PLLtX37dnXu3Pm8t6+wsFDe3t4qKCiQl5fXea8HAAA4mj27dtYzaEMtrageDRpUwwVqa7BwUaru51mnHak4deqUMjIyFBUV9b9m7HZFRUUpLS2t0mXS0tIc6iUpOjrarN+zZ49ycnIcary9vRUREWHWpKWlycfHxwwUkhQVFSW73a709HRJ0v/93/+pQ4cOWr16tUJCQhQcHKw777xTeXl5Z92m4uJiFRYWOrwAAACAC53TQkVubq5KS0vl5+fnMN3Pz085OTmVLpOTk3PW+vKv56pp27atw3xXV1e1atXKrNm9e7f27t2rFStW6M0331RSUpIyMjJ0yy23nHWbEhIS5O3tbb6CgoLOWg8AAABcCJx+oXZDVFZWpuLiYr355psaMGCABg0apH/84x9av369du7cWeVyM2fOVEFBgfnav39/PXYNAAAAOIfTQoWvr69cXFx06NAhh+mHDh2Sv79/pcv4+/uftb7867lqzrwQ/PTp08rLyzNrAgIC5OrqqksvvdSsCQsLkyTt27evym1yd3eXl5eXwwsAAAC40DktVLi5ualnz55KTU01p5WVlSk1NVWRkZGVLhMZGelQL0kpKSlmfUhIiPz9/R1qCgsLlZ6ebtZERkYqPz9fGRkZZs26detUVlamiIgISdJVV12l06dP68cffzRrfvjhB0nSJZdcYmWzAQAAgAuOqzPffOrUqRo3bpx69eqlPn36aMGCBSoqKtKECRMkSWPHjlW7du2UkJAg6bfbvA4cOFDz58/X8OHD9e6772rz5s1asmSJJMlms2nKlCmaO3euQkNDFRISoscee0yBgYGKiYmR9NsRh6FDh2rSpElKTExUSUmJ4uLiNGrUKAUGBkr67cLtK6+8Un/5y1+0YMEClZWVafLkybrmmmscjl4AAAAAcHKoGDlypI4cOaL4+Hjl5OQoPDxcycnJ5oXW+/btk93+v4Mp/fr109tvv61HH31UDz/8sEJDQ7Vq1Sp169bNrHnooYdUVFSk2NhY5efnq3///kpOTpaHh4dZs2zZMsXFxWnIkCGy2+0aMWKEFi5caM632+36v//7P9133326+uqr1axZM1177bWaP39+PYwKAAAA0Lg49TkVFzqeUwEAQN3gORU1wHMqYEGDf04FAAAAgAsDoQIAAACAJYQKAAAAAJYQKgAAAABY4tS7PwEAgPPH9bcAGgqOVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALHF1dgMAAKDhGbRhtrNbANCIcKQCAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABY0iBCxeLFixUcHCwPDw9FREToq6++Omv9ihUr1KVLF3l4eKh79+5as2aNw3zDMBQfH6+AgAB5enoqKipKWVlZDjV5eXkaM2aMvLy85OPjo4kTJ+rYsWPm/OzsbNlstgqv//73v7W34QAAAMAFwOmhYvny5Zo6dapmzZqlLVu2qEePHoqOjtbhw4crrf/yyy81evRoTZw4UVu3blVMTIxiYmK0fft2s2bevHlauHChEhMTlZ6ermbNmik6OlonT540a8aMGaPvvvtOKSkpWr16tTZu3KjY2NgK7/fpp5/q4MGD5qtnz561PwgAAABAI2YzDMNwZgMRERHq3bu3Fi1aJEkqKytTUFCQ7rvvPs2YMaNC/ciRI1VUVKTVq1eb0/r27avw8HAlJibKMAwFBgZq2rRpmj59uiSpoKBAfn5+SkpK0qhRo5SZmamuXbtq06ZN6tWrlyQpOTlZw4YN008//aTAwEBlZ2crJCREW7duVXh4+HltW2Fhoby9vVVQUCAvL6/zWgcAAFWZPbvu1j1oQx2uHJYMGlTDBepyR8EFr7qfZ516pOLUqVPKyMhQVFSUOc1utysqKkppaWmVLpOWluZQL0nR0dFm/Z49e5STk+NQ4+3trYiICLMmLS1NPj4+ZqCQpKioKNntdqWnpzus+4YbblDbtm3Vv39/ffjhh9Y2GAAAALgAuTrzzXNzc1VaWio/Pz+H6X5+ftqxY0ely+Tk5FRan5OTY84vn3a2mrZt2zrMd3V1VatWrcya5s2ba/78+brqqqtkt9v1r3/9SzExMVq1apVuuOGGSnsrLi5WcXGx+X1hYeFZtx8AAAC4EDg1VDRkvr6+mjp1qvl979699fPPP+uZZ56pMlQkJCRozpw59dUiAAAA0CA49fQnX19fubi46NChQw7TDx06JH9//0qX8ff3P2t9+ddz1Zx5Ifjp06eVl5dX5ftKv13/sWvXrirnz5w5UwUFBeZr//79VdYCAAAAFwqnhgo3Nzf17NlTqamp5rSysjKlpqYqMjKy0mUiIyMd6iUpJSXFrA8JCZG/v79DTWFhodLT082ayMhI5efnKyMjw6xZt26dysrKFBERUWW/27ZtU0BAQJXz3d3d5eXl5fACAAAALnROP/1p6tSpGjdunHr16qU+ffpowYIFKioq0oQJEyRJY8eOVbt27ZSQkCBJuv/++zVw4EDNnz9fw4cP17vvvqvNmzdryZIlkiSbzaYpU6Zo7ty5Cg0NVUhIiB577DEFBgYqJiZGkhQWFqahQ4dq0qRJSkxMVElJieLi4jRq1CgFBgZKkt544w25ubnpiiuukCStXLlSr7/+ul577bV6HiEAAACgYXN6qBg5cqSOHDmi+Ph45eTkKDw8XMnJyeaF1vv27ZPd/r8DKv369dPbb7+tRx99VA8//LBCQ0O1atUqdevWzax56KGHVFRUpNjYWOXn56t///5KTk6Wh4eHWbNs2TLFxcVpyJAhstvtGjFihBYuXOjQ2xNPPKG9e/fK1dVVXbp00fLly3XLLbfU8YgAAAAAjYvTn1NxIeM5FQCAusRzKi5OPKcC9alRPKcCAAAAQONHqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGCJ059TAQBAo9NAbtE5aIOzOwCA33CkAgAAAIAlhAoAAAAAlnD6EwCgUXPGmUicdgQAjjhSAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEvOK1Ts3r27tvsAAAAA0EidV6jo1KmTBg8erH/+8586efJkbfcEAAAAoBE5r1CxZcsWXX755Zo6dar8/f1111136auvvqrt3gAAAAA0AucVKsLDw/XCCy/o559/1uuvv66DBw+qf//+6tatm5577jkdOXKktvsEAAAA0EBZulDb1dVVN998s1asWKGnn35au3bt0vTp0xUUFKSxY8fq4MGDtdUnAAAAgAbKUqjYvHmz7r33XgUEBOi5557T9OnT9eOPPyolJUU///yzbrzxxtrqEwAAAEAD5Xo+Cz333HNaunSpdu7cqWHDhunNN9/UsGHDZLf/llFCQkKUlJSk4ODg2uwVAAAAQAN0XqHi5Zdf1l/+8heNHz9eAQEBlda0bdtW//jHPyw1BwAAAKDhO69QkZKSovbt25tHJsoZhqH9+/erffv2cnNz07hx42qlSQAAAAAN13ldU9GxY0fl5uZWmJ6Xl6eQkBDLTQEAAABoPM4rVBiGUen0Y8eOycPDo8brW7x4sYKDg+Xh4aGIiIhzPvNixYoV6tKlizw8PNS9e3etWbOmQn/x8fEKCAiQp6enoqKilJWV5VCTl5enMWPGyMvLSz4+Ppo4caKOHTtW6fvt2rVLLVq0kI+PT423DQAAALjQ1ej0p6lTp0qSbDab4uPj1bRpU3NeaWmp0tPTFR4eXqMGli9frqlTpyoxMVERERFasGCBoqOjtXPnTrVt27ZC/ZdffqnRo0crISFB1113nd5++23FxMRoy5Yt6tatmyRp3rx5Wrhwod544w2FhIToscceU3R0tL7//nsz9IwZM0YHDx5USkqKSkpKNGHCBMXGxurtt992eL+SkhKNHj1aAwYM0JdfflmjbQMAAAAuBjajqsMOlRg8eLAk6bPPPlNkZKTc3NzMeW5ubgoODtb06dMVGhpa7QYiIiLUu3dvLVq0SJJUVlamoKAg3XfffZoxY0aF+pEjR6qoqEirV682p/Xt21fh4eFKTEyUYRgKDAzUtGnTNH36dElSQUGB/Pz8lJSUpFGjRikzM1Ndu3bVpk2b1KtXL0lScnKyhg0bpp9++kmBgYHmuv/2t7/p559/1pAhQzRlyhTl5+dXe9sKCwvl7e2tgoICeXl5VXs5AED1zZ5d/+85aIMT3hT4/wYNquECzvhLggtGdT/P1uhIxfr16yVJEyZM0AsvvGD5g/KpU6eUkZGhmTNnmtPsdruioqKUlpZW6TJpaWnmEZNy0dHRWrVqlSRpz549ysnJUVRUlDnf29tbERERSktL06hRo5SWliYfHx8zUEhSVFSU7Ha70tPTddNNN0mS1q1bpxUrVmjbtm1auXLlObenuLhYxcXF5veFhYXnHgQAAACgkTuvayqWLl1aK795z83NVWlpqfz8/Bym+/n5KScnp9JlcnJyzlpf/vVcNWeeWuXq6qpWrVqZNb/88ovGjx+vpKSkam9rQkKCvL29zVdQUFC1lgMAAAAas2ofqbj55pvND9g333zzWWur81v9hm7SpEm67bbbdPXVV1d7mZkzZzocRSksLCRYAAAA4IJX7VDh7e0tm81m/rk2+Pr6ysXFRYcOHXKYfujQIfn7+1e6jL+//1nry78eOnTI4cF8hw4dMi8i9/f31+HDhx3Wcfr0aeXl5ZnLr1u3Th9++KGeffZZSb/dUaqsrEyurq5asmSJ/vKXv1Tozd3dXe7u7tXdfAAAAOCCUO1QsXTp0kr/bIWbm5t69uyp1NRUxcTESPrtQu3U1FTFxcVVukxkZKRSU1M1ZcoUc1pKSooiIyMlSSEhIfL391dqaqoZIgoLC5Wenq577rnHXEd+fr4yMjLUs2dPSb+FiLKyMkVEREj67dqN0tJS8z3+/e9/6+mnn9aXX36pdu3a1cr2AwAAABeC83qi9okTJ2QYhnlL2b179+qDDz5Q165d9ac//alG65o6darGjRunXr16qU+fPlqwYIGKioo0YcIESdLYsWPVrl07JSQkSJLuv/9+DRw4UPPnz9fw4cP17rvvavPmzVqyZImk3253O2XKFM2dO1ehoaHmLWUDAwPN4BIWFqahQ4dq0qRJSkxMVElJieLi4jRq1Cjzzk9hYWEOfW7evFl2u928bS0AAACA35xXqLjxxht188036+6771Z+fr769OkjNzc35ebm6rnnnjOPCFTHyJEjdeTIEcXHxysnJ0fh4eFKTk42L7Tet2+f7Pb/XU/er18/vf3223r00Uf18MMPKzQ0VKtWrXL4sP/QQw+pqKhIsbGxys/PV//+/ZWcnOzwYL5ly5YpLi5OQ4YMkd1u14gRI7Rw4cLzGQ4AAADgolaj51SU8/X11WeffabLLrtMr732ml588UVt3bpV//rXvxQfH6/MzMy66LXR4TkVAFD3eE4FLjY8pwL1qbqfZ8/rlrLHjx9XixYtJElr167VzTffLLvdrr59+2rv3r3n1zEAAACARum8QkWnTp20atUq7d+/X5988ol5HcXhw4f5jTwAAABwkTmvUBEfH6/p06crODhYERER5p2X1q5dqyuuuKJWGwQAAADQsJ3Xhdq33HKL+vfvr4MHD6pHjx7m9CFDhuimm26qteYAAAAANHznFSqk3x4gd+YD6vr06WO5IQAAAACNy3mFiqKiIj311FNKTU3V4cOHVVZW5jB/9+7dtdIcAAAAgIbvvELFnXfeqc8++0x33HGHAgICZLPZarsvAAAAAI3EeYWKjz/+WB999JGuuuqq2u4HAAAAQCNzXnd/atmypVq1alXbvQAAAABohM4rVDzxxBOKj4/X8ePHa7sfAAAAAI3MeZ3+NH/+fP3444/y8/NTcHCwmjRp4jB/y5YttdIcAAAAgIbvvEJFTExMLbcBAAAAoLE6r1Axa9as2u4DAAAAQCN1XtdUSFJ+fr5ee+01zZw5U3l5eZJ+O+3pwIEDtdYcAAAAgIbvvI5UfPPNN4qKipK3t7eys7M1adIktWrVSitXrtS+ffv05ptv1nafAAAAABqo8zpSMXXqVI0fP15ZWVny8PAwpw8bNkwbN26steYAAAAANHznFSo2bdqku+66q8L0du3aKScnx3JTAAAAABqP8woV7u7uKiwsrDD9hx9+UJs2bSw3BQAAAKDxOK9QccMNN+jxxx9XSUmJJMlms2nfvn3629/+phEjRtRqgwAAAAAatvMKFfPnz9exY8fUpk0bnThxQgMHDlSnTp3UokULPfnkk7XdIwAAAIAG7Lzu/uTt7a2UlBR98cUX+vrrr3Xs2DFdeeWVioqKqu3+AAAAADRwNQ4VZWVlSkpK0sqVK5WdnS2bzaaQkBD5+/vLMAzZbLa66BMAAABAA1Wj058Mw9ANN9ygO++8UwcOHFD37t112WWXae/evRo/frxuuummuuoTAAAAQANVoyMVSUlJ2rhxo1JTUzV48GCHeevWrVNMTIzefPNNjR07tlabBAAAANBw1ShUvPPOO3r44YcrBApJ+uMf/6gZM2Zo2bJlhAoAqGezZzu7AwDAxaxGpz998803Gjp0aJXzr732Wn399deWmwIAAADQeNQoVOTl5cnPz6/K+X5+fvr1118tNwUAAACg8ahRqCgtLZWra9VnTLm4uOj06dOWmwIAAADQeNTomgrDMDR+/Hi5u7tXOr+4uLhWmgIAAADQeNQoVIwbN+6cNVykDQAAAFxcahQqli5dWld9AAAAAGikanRNBQAAAACciVABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMCSBhEqFi9erODgYHl4eCgiIkJfffXVWetXrFihLl26yMPDQ927d9eaNWsc5huGofj4eAUEBMjT01NRUVHKyspyqMnLy9OYMWPk5eUlHx8fTZw4UceOHTPn79y5U4MHD5afn588PDzUoUMHPfrooyopKam9DQcAAAAuAE4PFcuXL9fUqVM1a9YsbdmyRT169FB0dLQOHz5caf2XX36p0aNHa+LEidq6datiYmIUExOj7du3mzXz5s3TwoULlZiYqPT0dDVr1kzR0dE6efKkWTNmzBh99913SklJ0erVq7Vx40bFxsaa85s0aaKxY8dq7dq12rlzpxYsWKBXX31Vs2bNqrvBAAAAABohm2EYhjMbiIiIUO/evbVo0SJJUllZmYKCgnTfffdpxowZFepHjhypoqIirV692pzWt29fhYeHKzExUYZhKDAwUNOmTdP06dMlSQUFBfLz81NSUpJGjRqlzMxMde3aVZs2bVKvXr0kScnJyRo2bJh++uknBQYGVtrr1KlTtWnTJn3++efV2rbCwkJ5e3uroKBAXl5eNRoXAKiJ2bOd3cH/DNow29ktABe0QYNquEBD+gcCjU51P8869UjFqVOnlJGRoaioKHOa3W5XVFSU0tLSKl0mLS3NoV6SoqOjzfo9e/YoJyfHocbb21sRERFmTVpamnx8fMxAIUlRUVGy2+1KT0+v9H137dql5ORkDRw48Pw2FgAAALhAOTVU5ObmqrS0VH5+fg7T/fz8lJOTU+kyOTk5Z60v/3qumrZt2zrMd3V1VatWrSq8b79+/eTh4aHQ0FANGDBAjz/+eJXbU1xcrMLCQocXAAAAcKFz+jUVDd3y5cu1ZcsWvf322/roo4/07LPPVlmbkJAgb29v8xUUFFSPnQIAAADO4dRQ4evrKxcXFx06dMhh+qFDh+Tv71/pMv7+/metL/96rpozLwQ/ffq08vLyKrxvUFCQunbtqtGjR+upp57S7NmzVVpaWmlvM2fOVEFBgfnav3//2TYfAAAAuCA4NVS4ubmpZ8+eSk1NNaeVlZUpNTVVkZGRlS4TGRnpUC9JKSkpZn1ISIj8/f0dagoLC5Wenm7WREZGKj8/XxkZGWbNunXrVFZWpoiIiCr7LSsrU0lJicrKyiqd7+7uLi8vL4cXAAAAcKFzdXYDU6dO1bhx49SrVy/16dNHCxYsUFFRkSZMmCBJGjt2rNq1a6eEhARJ0v3336+BAwdq/vz5Gj58uN59911t3rxZS5YskSTZbDZNmTJFc+fOVWhoqEJCQvTYY48pMDBQMTExkqSwsDANHTpUkyZNUmJiokpKShQXF6dRo0aZd35atmyZmjRpou7du8vd3V2bN2/WzJkzNXLkSDVp0qT+BwoAAABooJweKkaOHKkjR44oPj5eOTk5Cg8PV3Jysnmh9b59+2S3/++ASr9+/fT222/r0Ucf1cMPP6zQ0FCtWrVK3bp1M2seeughFRUVKTY2Vvn5+erfv7+Sk5Pl4eFh1ixbtkxxcXEaMmSI7Ha7RowYoYULF5rzXV1d9fTTT+uHH36QYRi65JJLFBcXpwceeKAeRgUAAABoPJz+nIoLGc+pAFBfGtJt6HlOBVC3eE4F6lOjeE4FAAAAgMaPUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACxx+hO1AeCiUYcPoBq0oc5WDQDAOXGkAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFji6uwGAAAAUIdmz3Z2B3XvYtjGBo4jFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLePgdAABAI7Jhg7M7cJ5Bg5zdAarCkQoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJoQIAAACAJQ0iVCxevFjBwcHy8PBQRESEvvrqq7PWr1ixQl26dJGHh4e6d++uNWvWOMw3DEPx8fEKCAiQp6enoqKilJWV5VCTl5enMWPGyMvLSz4+Ppo4caKOHTtmzt+wYYNuvPFGBQQEqFmzZgoPD9eyZctqb6MBAACAC4TTQ8Xy5cs1depUzZo1S1u2bFGPHj0UHR2tw4cPV1r/5ZdfavTo0Zo4caK2bt2qmJgYxcTEaPv27WbNvHnztHDhQiUmJio9PV3NmjVTdHS0Tp48adaMGTNG3333nVJSUrR69Wpt3LhRsbGxDu9z+eWX61//+pe++eYbTZgwQWPHjtXq1avrbjAAAACARshmGIbhzAYiIiLUu3dvLVq0SJJUVlamoKAg3XfffZoxY0aF+pEjR6qoqMjhw33fvn0VHh6uxMREGYahwMBATZs2TdOnT5ckFRQUyM/PT0lJSRo1apQyMzPVtWtXbdq0Sb169ZIkJScna9iwYfrpp58UGBhYaa/Dhw+Xn5+fXn/99WptW2Fhoby9vVVQUCAvL68ajQuAC9Ds2XW26g0b6mzVANBgDBpUxYw6/Pf1Ylfdz7NOPVJx6tQpZWRkKCoqypxmt9sVFRWltLS0SpdJS0tzqJek6Ohos37Pnj3KyclxqPH29lZERIRZk5aWJh8fHzNQSFJUVJTsdrvS09Or7LegoECtWrWqcn5xcbEKCwsdXgAAAMCFzqmhIjc3V6WlpfLz83OY7ufnp5ycnEqXycnJOWt9+ddz1bRt29Zhvqurq1q1alXl+7733nvatGmTJkyYUOX2JCQkyNvb23wFBQVVWQsAAABcKJx+TUVjsH79ek2YMEGvvvqqLrvssirrZs6cqYKCAvO1f//+euwSAAAAcA6nhgpfX1+5uLjo0KFDDtMPHTokf3//Spfx9/c/a33513PVnHkh+OnTp5WXl1fhfT/77DNdf/31ev755zV27Nizbo+7u7u8vLwcXgAAAMCFzqmhws3NTT179lRqaqo5raysTKmpqYqMjKx0mcjISId6SUpJSTHrQ0JC5O/v71BTWFio9PR0syYyMlL5+fnKyMgwa9atW6eysjJFRESY0zZs2KDhw4fr6aefdrgzFAAAAID/cXV2A1OnTtW4cePUq1cv9enTRwsWLFBRUZF57cLYsWPVrl07JSQkSJLuv/9+DRw4UPPnz9fw4cP17rvvavPmzVqyZIkkyWazacqUKZo7d65CQ0MVEhKixx57TIGBgYqJiZEkhYWFaejQoZo0aZISExNVUlKiuLg4jRo1yrzz0/r163Xdddfp/vvv14gRI8xrLdzc3M56sTYAAABwsXF6qBg5cqSOHDmi+Ph45eTkKDw8XMnJyeaF1vv27ZPd/r8DKv369dPbb7+tRx99VA8//LBCQ0O1atUqdevWzax56KGHVFRUpNjYWOXn56t///5KTk6Wh4eHWbNs2TLFxcVpyJAhstvtGjFihBYuXGjOf+ONN3T8+HElJCSYgUaSBg4cqA3cuxEAAAAwOf05FRcynlMBwAHPqQAAS3hORf1rFM+pAAAAAND4ESoAAAAAWEKoAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAlTn+iNgBI4sFFAAA0YhypAAAAAGAJoQIAAACAJYQKAAAAAJYQKgAAAABYQqgAAAAAYAmhAgAAAIAl3FIWwAVjwwZndwAAwMWJIxUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALHF6qFi8eLGCg4Pl4eGhiIgIffXVV2etX7Fihbp06SIPDw91795da9ascZhvGIbi4+MVEBAgT09PRUVFKSsry6EmLy9PY8aMkZeXl3x8fDRx4kQdO3bMnH/y5EmNHz9e3bt3l6urq2JiYmptewEAAIALjVNDxfLlyzV16lTNmjVLW7ZsUY8ePRQdHa3Dhw9XWv/ll19q9OjRmjhxorZu3aqYmBjFxMRo+/btZs28efO0cOFCJSYmKj09Xc2aNVN0dLROnjxp1owZM0bfffedUlJStHr1am3cuFGxsbHm/NLSUnl6euqvf/2roqKi6m4AAAAAgAuAzTAMw1lvHhERod69e2vRokWSpLKyMgUFBem+++7TjBkzKtSPHDlSRUVFWr16tTmtb9++Cg8PV2JiogzDUGBgoKZNm6bp06dLkgoKCuTn56ekpCSNGjVKmZmZ6tq1qzZt2qRevXpJkpKTkzVs2DD99NNPCgwMdHjP8ePHKz8/X6tWrarx9hUWFsrb21sFBQXy8vKq8fLARWX2bMur2LDB8ioAAA3YoEFVzKiF/0NQuep+nnXakYpTp04pIyPD4UiA3W5XVFSU0tLSKl0mLS2twpGD6Ohos37Pnj3KyclxqPH29lZERIRZk5aWJh8fHzNQSFJUVJTsdrvS09NrbfsAAACAi4Wrs944NzdXpaWl8vPzc5ju5+enHTt2VLpMTk5OpfU5OTnm/PJpZ6tp27atw3xXV1e1atXKrDlfxcXFKi4uNr8vLCy0tD4AAACgMXD6hdoXkoSEBHl7e5uvoKAgZ7cEAAAA1DmnhQpfX1+5uLjo0KFDDtMPHTokf3//Spfx9/c/a33513PVnHkh+OnTp5WXl1fl+1bXzJkzVVBQYL72799vaX0AAABAY+C0UOHm5qaePXsqNTXVnFZWVqbU1FRFRkZWukxkZKRDvSSlpKSY9SEhIfL393eoKSwsVHp6ulkTGRmp/Px8ZWRkmDXr1q1TWVmZIiIiLG2Tu7u7vLy8HF4AAADAhc5p11RI0tSpUzVu3Dj16tVLffr00YIFC1RUVKQJEyZIksaOHat27dopISFBknT//fdr4MCBmj9/voYPH653331Xmzdv1pIlSyRJNptNU6ZM0dy5cxUaGqqQkBA99thjCgwMNJ81ERYWpqFDh2rSpElKTExUSUmJ4uLiNGrUKIc7P33//fc6deqU8vLydPToUW3btk2SFB4eXm/jAwAAADQGTg0VI0eO1JEjRxQfH6+cnByFh4crOTnZvNB63759stv/dzClX79+evvtt/Xoo4/q4YcfVmhoqFatWqVu3bqZNQ899JCKiooUGxur/Px89e/fX8nJyfLw8DBrli1bpri4OA0ZMkR2u10jRozQwoULHXobNmyY9u7da35/xRVXSPrt4XoAAAAA/sepz6m40PGcCqAGeE4FAOAceE5F/Wvwz6kAAAAAcGEgVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLCBUAAAAALCFUAAAAALCEUAEAAADAEkIFAAAAAEsIFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBJCBQAAAABLXJ3dAIDaNXu2szs4P4M2OLsDAABwvjhSAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhAu1AQAA0Chs2FDF9Nn12YVzNPQbsXCkAgAAAIAlhAoAAAAAlhAqAAAAAFhCqAAAAABgCaECAAAAgCWECgAAAACWECoAAAAAWEKoAAAAAGAJD7+7kDX0p6SgTgza4OwOAADAxYYjFQAAAAAsIVQAAAAAsIRQAQAAAMASQgUAAAAASwgVAAAAACwhVAAAAACwhFABAAAAwBKeU4EL0oYNzu4AAADg4sGRCgAAAACWECoAAAAAWEKoAAAAAGBJgwgVixcvVnBwsDw8PBQREaGvvvrqrPUrVqxQly5d5OHhoe7du2vNmjUO8w3DUHx8vAICAuTp6amoqChlZWU51OTl5WnMmDHy8vKSj4+PJk6cqGPHjjnUfPPNNxowYIA8PDwUFBSkefPm1c4GAwAAABcQp4eK5cuXa+rUqZo1a5a2bNmiHj16KDo6WocPH660/ssvv9To0aM1ceJEbd26VTExMYqJidH27dvNmnnz5mnhwoVKTExUenq6mjVrpujoaJ08edKsGTNmjL777julpKRo9erV2rhxo2JjY835hYWF+tOf/qRLLrlEGRkZeuaZZzR79mwtWbKk7gYDAAAAaIRshmEYzmwgIiJCvXv31qJFiyRJZWVlCgoK0n333acZM2ZUqB85cqSKioq0evVqc1rfvn0VHh6uxMREGYahwMBATZs2TdOnT5ckFRQUyM/PT0lJSRo1apQyMzPVtWtXbdq0Sb169ZIkJScna9iwYfrpp58UGBiol19+WY888ohycnLk5uYmSZoxY4ZWrVqlHTt2VGvbCgsL5e3trYKCAnl5eVkap/Mye3b9v2cDwd2fAAC4eGwYNNvZLdQ5Z32sq+7nWafeUvbUqVPKyMjQzJkzzWl2u11RUVFKS0urdJm0tDRNnTrVYVp0dLRWrVolSdqzZ49ycnIUFRVlzvf29lZERITS0tI0atQopaWlycfHxwwUkhQVFSW73a709HTddNNNSktL09VXX20GivL3efrpp/Xrr7+qZcuWFXorLi5WcXGx+X1BQYGk334YzvD5p8XnLgIAAGjkioud81mrPjnp46T5OfZcxyGcGipyc3NVWloqPz8/h+l+fn5VHg3IycmptD4nJ8ecXz7tbDVt27Z1mO/q6qpWrVo51ISEhFRYR/m8ykJFQkKC5syZU2F6UFBQpdsCAACAWvDFU87uoM495eRNPHr0qLy9vaucz8PvatHMmTMdjqKUlZUpLy9PrVu3ls1mc2Jn9aOwsFBBQUHav3+/c073ukAwjrWDcawdjGPtYBxrB+NYOxjH2nGxjKNhGDp69KgCAwPPWufUUOHr6ysXFxcdOnTIYfqhQ4fk7+9f6TL+/v5nrS//eujQIQUEBDjUhIeHmzVnXgh++vRp5eXlOaynsvf5/Xucyd3dXe7u7g7TfHx8Kq29kHl5eV3Qf7nqC+NYOxjH2sE41g7GsXYwjrWDcawdF8M4nu0IRTmn3v3Jzc1NPXv2VGpqqjmtrKxMqampioyMrHSZyMhIh3pJSklJMetDQkLk7+/vUFNYWKj09HSzJjIyUvn5+crIyDBr1q1bp7KyMkVERJg1GzduVElJicP7dO7cudJTnwAAAICLldNvKTt16lS9+uqreuONN5SZmal77rlHRUVFmjBhgiRp7NixDhdy33///UpOTtb8+fO1Y8cOzZ49W5s3b1ZcXJwkyWazacqUKZo7d64+/PBDffvttxo7dqwCAwMVExMjSQoLC9PQoUM1adIkffXVV/riiy8UFxenUaNGmYd2brvtNrm5uWnixIn67rvvtHz5cr3wwgsVLhIHAAAALnZOv6Zi5MiROnLkiOLj45WTk6Pw8HAlJyebF0Xv27dPdvv/sk+/fv309ttv69FHH9XDDz+s0NBQrVq1St26dTNrHnroIRUVFSk2Nlb5+fnq37+/kpOT5eHhYdYsW7ZMcXFxGjJkiOx2u0aMGKGFCxea8729vbV27VpNnjxZPXv2lK+vr+Lj4x2eZQFH7u7umjVrVoVTwFAzjGPtYBxrB+NYOxjH2sE41g7GsXYwjo6c/pwKAAAAAI2b009/AgAAANC4ESoAAAAAWEKoAAAAAGAJoQIAAACAJYQKONi4caOuv/56BQYGymazadWqVQ7zDcNQfHy8AgIC5OnpqaioKGVlZTnU5OXlacyYMfLy8pKPj48mTpyoY8eOOdR88803GjBggDw8PBQUFKR58+bV9abVq3ON4/jx42Wz2RxeQ4cOdahhHKWEhAT17t1bLVq0UNu2bRUTE6OdO3c61Jw8eVKTJ09W69at1bx5c40YMaLCgyv37dun4cOHq2nTpmrbtq0efPBBnT592qFmw4YNuvLKK+Xu7q5OnTopKSmprjev3lRnHAcNGlRhn7z77rsdai72cXz55Zd1+eWXmw+6ioyM1Mcff2zOZ1+snnONI/tizT311FPmLfXLsT/WXGXjyP5YAwbwO2vWrDEeeeQRY+XKlYYk44MPPnCY/9RTTxne/6+9OwuJqg/DAP6aOqaIGy5ji6Yphmm2CDYVdjGiVlDUTZmEFBhtUFRmCd10UxAEFRVB0FUkFJXRRpZLBZOpOeqkTGi2ogmWOuWS6fNdyBw8OqNjQ5p+zw8GbP7vnDnn4VV76/jX1xd37txBdXU11q9fj4iICHR3dys16enpSEhIwMuXL/H8+XNERUUhIyNDWe/o6EBISAgyMzNhMplw/fp1eHp64vLlyxN1mX/dWDlmZWUhPT0dzc3NyuPbt2+qGuYIpKWl4erVqzCZTDAajVi7di3CwsLw48cPpWbXrl2YO3cunj59ioqKCixfvhwrVqxQ1n///o24uDikpKSgqqoKDx48QGBgII4dO6bUvHv3Dl5eXjh48CDq6upw/vx5uLq64tGjRxN6vX+LIzmuXr0a2dnZqp7s6OhQ1pkjcPfuXdy/fx9v376F2WxGXl4e3N3dYTKZALAXHTVWjuzF8Xn16hXmzZuHRYsWYf/+/crz7MfxsZcj+9FxHCrIruF/GR4YGIBWq8Xp06eV59rb2+Hh4YHr168DAOrq6iAiKC8vV2oePnwIFxcXfPnyBQBw8eJF+Pv7o7e3V6nJzc1FTEzMX76iyWFvqNiwYYPd1zBH21pbWyEiKC0tBTDYf+7u7rhx44ZSU19fDxGBwWAAMDjgzZgxAy0tLUrNpUuX4OPjo2R35MgRLFy4UPVemzdvRlpa2t++pEkxPEdg8Bvn0G+kwzFH2/z9/XHlyhX2opOsOQLsxfGwWCyIjo5GYWGhKjf24/jYyxFgP44Hb38ihzU1NUlLS4ukpKQoz/n6+kpSUpIYDAYRETEYDOLn5yeJiYlKTUpKisyYMUPKysqUmuTkZNFoNEpNWlqamM1m+f79+wRdzeQrKSmR4OBgiYmJkd27d0tbW5uyxhxt6+joEBGRgIAAERGprKyUvr4+VU8uWLBAwsLCVD0ZHx+v/EJNkcGcOjs75c2bN0rN0GNYa6zHmG6G52h17do1CQwMlLi4ODl27Jh0dXUpa8xRrb+/X/Lz8+Xnz5+i0+nYi39oeI5W7EXH7N27V9atWzfiWtmP42MvRyv2o2Mm/Tdq09TR0tIiIqL6xLH+2brW0tIiwcHBqnU3NzcJCAhQ1URERIw4hnXN39//r5z/vyQ9PV02bdokERER0tjYKHl5ebJmzRoxGAzi6urKHG0YGBiQAwcOyMqVKyUuLk5EBq9To9GIn5+fqnZ4T9rqWevaaDWdnZ3S3d0tnp6ef+OSJoWtHEVEtm7dKuHh4TJr1iypqamR3NxcMZvNcuvWLRFhjla1tbWi0+mkp6dHvL295fbt2xIbGytGo5G9OA72chRhLzoqPz9fXr9+LeXl5SPW+LXRcaPlKMJ+HA8OFUSTYMuWLcrH8fHxsmjRIpk/f76UlJSIXq+fxDP7d+3du1dMJpO8ePFisk9lSrOX486dO5WP4+PjJTQ0VPR6vTQ2Nsr8+fMn+jT/WTExMWI0GqWjo0Nu3rwpWVlZUlpaOtmnNeXYyzE2Npa96IBPnz7J/v37pbCwUGbOnDnZpzNlOZIj+9FxvP2JHKbVakVERuwe8fXrV2VNq9VKa2urav3379/y7ds3VY2tYwx9j/+byMhICQwMlIaGBhFhjsPt27dP7t27J8XFxTJnzhzlea1WK79+/ZL29nZV/fCeHCsnezU+Pj7T5l+QROznaEtSUpKIiKonmaOIRqORqKgoWbZsmZw8eVISEhLk7Nmz7MVxspejLezFkSorK6W1tVWWLl0qbm5u4ubmJqWlpXLu3Dlxc3OTkJAQ9qMDxsqxv79/xGvYj/ZxqCCHRUREiFarladPnyrPdXZ2SllZmXIvrE6nk/b2dqmsrFRqioqKZGBgQPlE1Ol08uzZM+nr61NqCgsLJSYmZtrdsuOoz58/S1tbm4SGhooIc7QCIPv27ZPbt29LUVHRiNu9li1bJu7u7qqeNJvN8vHjR1VP1tbWqoa0wsJC8fHxUW630Ol0qmNYa4be4z2VjZWjLUajUURE1ZP/9xxtGRgYkN7eXvaik6w52sJeHEmv10ttba0YjUblkZiYKJmZmcrH7MexjZWjq6vriNewH0cx2T8pTv8Wi8WCqqoqVFVVQURw5swZVFVV4cOHDwAGt5T18/NDQUEBampqsGHDBptbyi5ZsgRlZWV48eIFoqOjVVuhtre3IyQkBNu2bYPJZEJ+fj68vLym1Vaoo+VosVhw+PBhGAwGNDU14cmTJ1i6dCmio6PR09OjHIM5Art374avry9KSkpU2/l1dXUpNbt27UJYWBiKiopQUVEBnU4HnU6nrFu3+0tNTYXRaMSjR48QFBRkc7u/nJwc1NfX48KFC9Nqu7+xcmxoaMCJEydQUVGBpqYmFBQUIDIyEsnJycoxmCNw9OhRlJaWoqmpCTU1NTh69ChcXFzw+PFjAOxFR42WI3vxzw3fpYj9+GeG5sh+HB8OFaRSXFwMERnxyMrKAjC4rezx48cREhICDw8P6PV6mM1m1THa2tqQkZEBb29v+Pj4YPv27bBYLKqa6upqrFq1Ch4eHpg9ezZOnTo1UZc4IUbLsaurC6mpqQgKCoK7uzvCw8ORnZ2t2o4OYI4AbGYoIrh69apS093djT179sDf3x9eXl7YuHEjmpubVcd5//491qxZA09PTwQGBuLQoUPo6+tT1RQXF2Px4sXQaDSIjIxUvcdUN1aOHz9+RHJyMgICAuDh4YGoqCjk5OSo9mIHmOOOHTsQHh4OjUaDoKAg6PV6ZaAA2IuOGi1H9uKfGz5UsB//zNAc2Y/j4wIAE/f/IkRERERENN3wZyqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgpHCqIiIiIiMgp/wEBcp1hegFG/gAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAMWCAYAAABsvhCnAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhdFJREFUeJzs3XlcVXX+x/H3BdkUAZFVRcFlXHKhUEnTwKLcskibzDSX3GZSS6mmqEaxjSaXbLG0RXFSyywzsyIVU5ukTNQxU3FfUgHJBEVFhfP7wx93ugIKHOCCvp6Px30o3/O93/M5X5Z73/dsFsMwDAEAAACACQ72LgAAAABA9UewAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsACASnbgwAFZLBYlJCTYuxQbiYmJCg0NlaurqywWi06ePGnvksrdlClT1LhxYzk6Oio0NLTS1hsXFyeLxWLTFhwcrKFDh1ZaDUWJjIxUZGRkhY1fFbYRQOUhWACothISEmSxWGwefn5+6tatm7755ptKr2fNmjU2tTg5Oalx48YaPHiw9u3bVy7rWL9+veLi4sr9Tf/vv/+u+++/X25ubpo5c6Y+/PBD1apVq1zXcSVvv/12hQetFStW6B//+IduueUWzZ07Vy+//HKFrg+Fbd++XXFxcTpw4IC9SwFQAWrYuwAAMOv5559XSEiIDMNQenq6EhIS1KtXL3355Ze66667Kr2eRx99VB06dNCFCxe0adMmvfvuu/rqq6/0yy+/qF69eqbGXr9+vSZPnqyhQ4fKy8urfAqW9PPPP+vUqVN64YUXFBUVVW7jltTbb78tHx+fCv10e/Xq1XJwcNAHH3wgZ2fnCltPUZ577jk9/fTTlbrOqiA1NVUODv/7DHP79u2aPHmyIiMjFRwcbL/CAFQIggWAaq9nz55q37699evhw4fL399fH330kV2CRdeuXXXfffdJkoYNG6a//OUvevTRRzVv3jzFxsZWej0lkZGRIUnlGlaqmoyMDLm5uZVLqMjJySnVHp0aNWqoRo3r7yXXxcXF3iUAqEQcCgXgmuPl5SU3N7dCb+RycnL0+OOPKygoSC4uLmrevLmmTp0qwzAkSWfPnlWLFi3UokULnT171vq8EydOKDAwUJ07d1ZeXl6p67ntttskSfv3779iv9WrV6tr166qVauWvLy8dM8992jHjh3W5XFxcXryySclSSEhIdZDrq52WMnixYsVFhYmNzc3+fj4aNCgQTpy5Ih1eWRkpIYMGSJJ6tChgywWy1X3HGzevFk9e/aUh4eH3N3ddfvtt+vHH3+06VPUeQXS/w5hK6g7ODhYv/76q9auXWvdptIc93/x4kW98MILatKkiVxcXBQcHKxnnnlGubm51j4Wi0Vz585VTk6OdR0lPfRq6NChcnd31969e9WrVy/Vrl1bAwcOlCR9//33+utf/6qGDRvKxcVFQUFBmjBhgs3Pz5XmojRat26tbt26FWrPz89X/fr1rWG2oG3GjBm64YYb5OrqKn9/f40ePVp//PHHVdeTkZFhDeeurq5q166d5s2bV+R6X3/9dbVp00aurq7y9fVVjx49tHHjRmufP59jkZCQoL/+9a+SpG7dulm/D2vWrNGQIUPk4+OjCxcuFFrPnXfeqebNm1+1bgD2d/19fALgmpOVlaXMzEwZhqGMjAy9+eabOn36tAYNGmTtYxiG7r77bn333XcaPny4QkND9e233+rJJ5/UkSNH9Nprr8nNzU3z5s3TLbfcomeffVbTp0+XJI0ZM0ZZWVlKSEiQo6Njqevbu3evJKlu3brF9lm1apV69uypxo0bKy4uTmfPntWbb76pW265RZs2bVJwcLD69u2rXbt26aOPPtJrr70mHx8fSZKvr2+x4yYkJGjYsGHq0KGD4uPjlZ6ertdff10//PCDNm/eLC8vLz377LNq3ry53n33XethZU2aNCl2zF9//VVdu3aVh4eH/vGPf8jJyUmzZ89WZGSk1q5dq/Dw8FLNz4wZMzRu3Di5u7vr2WeflST5+/uX+PkjRozQvHnzdN999+nxxx/XTz/9pPj4eO3YsUOff/65JOnDDz/Uu+++qw0bNuj999+XJHXu3LnE67h48aK6d++uLl26aOrUqapZs6akS6HtzJkz+vvf/666detqw4YNevPNN/Xbb79p8eLFJR6/JPr376+4uDilpaUpICDA2v6f//xHR48e1QMPPGBtGz16tPV7/+ijj2r//v166623tHnzZv3www9ycnIqch1nz55VZGSk9uzZo7FjxyokJESLFy/W0KFDdfLkST322GPWvsOHD1dCQoJ69uypESNG6OLFi/r+++/1448/2uxBLHDrrbfq0Ucf1RtvvKFnnnlGLVu2lCS1bNlSDz30kP7973/r22+/tdnLmJaWptWrV2vSpEmm5w9AJTAAoJqaO3euIanQw8XFxUhISLDpu3TpUkOS8eKLL9q033fffYbFYjH27NljbYuNjTUcHByMdevWGYsXLzYkGTNmzLhqPd99950hyZgzZ45x/Phx4+jRo8ZXX31lBAcHGxaLxfj5558NwzCM/fv3G5KMuXPnWp8bGhpq+Pn5Gb///ru17b///a/h4OBgDB482No2ZcoUQ5Kxf//+q9Zz/vx5w8/Pz2jdurVx9uxZa/vy5csNScbEiROtbQVzWVDjlURHRxvOzs7G3r17rW1Hjx41ateubdx6663WtkmTJhlFvcwUrOvP23DDDTcYERERV1335bZs2WJIMkaMGGHT/sQTTxiSjNWrV1vbhgwZYtSqVavU6xgyZIghyXj66acLLTtz5kyhtvj4eMNisRgHDx60thU1F40aNTKGDBlS4jpSU1MNScabb75p0/7II48Y7u7u1lq+//57Q5KxYMECm36JiYmF2iMiImzmfcaMGYYkY/78+da28+fPG506dTLc3d2N7OxswzAMY/Xq1YYk49FHHy1UZ35+frHbWPD79N1339k8Jy8vz2jQoIHRv39/m/bp06cbFovF2Ldv3xVmBkBVwaFQAKq9mTNnauXKlVq5cqXmz5+vbt26acSIEVqyZIm1z9dffy1HR0c9+uijNs99/PHHZRiGzVWk4uLidMMNN2jIkCF65JFHFBERUeh5V/Lwww/L19dX9erVU+/evZWTk6N58+YV+SmuJB07dkxbtmzR0KFD5e3tbW1v27at7rjjDn399dclXvefbdy4URkZGXrkkUfk6upqbe/du7datGihr776qtRj5uXlacWKFYqOjlbjxo2t7YGBgXrwwQf1n//8R9nZ2WWqtywK5iYmJsam/fHHH5ekMm1jcf7+978XanNzc7P+PycnR5mZmercubMMw9DmzZvLbd2S9Je//EWhoaFatGiRtS0vL0+ffvqp+vTpY61l8eLF8vT01B133KHMzEzrIywsTO7u7vruu++KXcfXX3+tgIAADRgwwNrm5OSkRx99VKdPn9batWslSZ999pksFkuRexLKcsiXg4ODBg4cqGXLlunUqVPW9gULFqhz584KCQkp9ZgAKh/BAkC117FjR0VFRSkqKkoDBw7UV199pVatWmns2LE6f/68JOngwYOqV6+eateubfPcgsMxDh48aG1zdnbWnDlztH//fp06dUpz584t1ZuliRMnauXKlVq9erW2bt2qo0eP6qGHHiq2f8G6izqOvGXLlsrMzFROTk6J11+ScVu0aGGzzSV1/PhxnTlzptha8/Pzdfjw4VKPW1YHDx6Ug4ODmjZtatMeEBAgLy+vMm1jUWrUqKEGDRoUaj906JA1ELq7u8vX11cRERGSLh2iV9769++vH374wXqOzJo1a5SRkaH+/ftb++zevVtZWVny8/OTr6+vzeP06dPWE/WLcvDgQTVr1szmSk5S4d+TvXv3ql69ejZB2KzBgwfr7Nmz1sPXUlNTlZKScsXfHQBVC+dYALjmODg4qFu3bnr99de1e/du3XDDDaUe49tvv5UknTt3Trt37y7VJ6Zt2rSxyyVbq5riwlhZToAv67rKi4uLS6E323l5ebrjjjt04sQJPfXUU2rRooVq1aqlI0eOaOjQocrPzy/3Ovr376/Y2FgtXrxY48eP1yeffCJPT0/16NHD2ic/P19+fn5asGBBkWNc6Zwce2rVqpXCwsI0f/58DR48WPPnz5ezs7Puv/9+e5cGoIQIFgCuSRcvXpQknT59WpLUqFEjrVq1SqdOnbLZa7Fz507r8gJbt27V888/r2HDhmnLli0aMWKEfvnlF3l6elZIrQXrTk1NLbRs586d8vHxsV7atDRvoP88bsGVqQqkpqbabHNJ+fr6qmbNmsXW6uDgoKCgIElSnTp1JEknT560uYxtUXsRyhoMGjVqpPz8fO3evdv6qbokpaen6+TJk2XaxpL65ZdftGvXLs2bN0+DBw+2tq9cubLC1hkSEqKOHTtq0aJFGjt2rJYsWaLo6Giby7o2adJEq1at0i233GJzqFZJNGrUSFu3blV+fr5NkLr896RJkyb69ttvdeLEiVLttbja93nw4MGKiYnRsWPHtHDhQvXu3dv6cwSg6uNQKADXnAsXLmjFihVydna2vtns1auX8vLy9NZbb9n0fe2112SxWNSzZ0/rc4cOHap69erp9ddfV0JCgtLT0zVhwoQKqzcwMFChoaGaN2+ezR21t23bphUrVqhXr17WtoKAUZI7b7dv315+fn6aNWuWzaVXv/nmG+3YsUO9e/cuda2Ojo6688479cUXX9hc5jY9PV0LFy5Uly5d5OHhIUnWK0utW7fO2q/gfJPL1apVq0x3Ey+YmxkzZti0F1zRqyzbWFIFVwgz/v9yxQX/f/311ytsndKlvRY//vij5syZo8zMTJvDoCTp/vvvV15enl544YVCz7148eIV57lXr15KS0uzOY/j4sWLevPNN+Xu7m49zKtfv34yDEOTJ08uNMaf5+NyV/v5HTBggCwWix577DHt27fP5spuAKo+9lgAqPa++eYb6yeqGRkZWrhwoXbv3q2nn37a+ia3T58+6tatm5599lkdOHBA7dq104oVK/TFF19o/Pjx1jfBL774orZs2aKkpCTVrl1bbdu21cSJE/Xcc8/pvvvus3mTX56mTJminj17qlOnTho+fLj1crOenp6Ki4uz9gsLC5MkPfvss3rggQfk5OSkPn36FHmzNicnJ/3rX//SsGHDFBERoQEDBlgvNxscHFzmsPTiiy9q5cqV6tKlix555BHVqFFDs2fPVm5url599VVrvzvvvFMNGzbU8OHD9eSTT8rR0VFz5syRr6+vDh06ZDNmWFiY3nnnHb344otq2rSp/Pz8Cu1lKUq7du00ZMgQvfvuuzp58qQiIiK0YcMGzZs3T9HR0UXe96G8tGjRQk2aNNETTzyhI0eOyMPDQ5999lmJ7hVhxv33368nnnhCTzzxhLy9vQsddhcREaHRo0crPj5eW7Zs0Z133iknJyft3r1bixcv1uuvv25zz4s/GzVqlGbPnq2hQ4cqJSVFwcHB+vTTT/XDDz9oxowZ1r193bp100MPPaQ33nhDu3fvVo8ePZSfn6/vv/9e3bp109ixY4scPzQ0VI6OjvrXv/6lrKwsubi46LbbbpOfn58kWe+FsXjxYnl5eVVoMARQAex5SSoAMKOoy826uroaoaGhxjvvvGNz2UvDMIxTp04ZEyZMMOrVq2c4OTkZzZo1M6ZMmWLtl5KSYtSoUcMYN26czfMuXrxodOjQwahXr57xxx9/FFtPweVmFy9efMW6i7rcrGEYxqpVq4xbbrnFcHNzMzw8PIw+ffoY27dvL/T8F154wahfv77h4OBQokvPLlq0yLjxxhsNFxcXw9vb2xg4cKDx22+/2fQpzeVmDcMwNm3aZHTv3t1wd3c3atasaXTr1s1Yv359oX4pKSlGeHi44ezsbDRs2NCYPn16kZebTUtLM3r37m3Url3bkFSqS89euHDBmDx5shESEmI4OTkZQUFBRmxsrHHu3DmbfmYuN1vc87Zv325ERUUZ7u7uho+PjzFy5Ejjv//9b6Hvb3lcbvbPbrnlliIvs/tn7777rhEWFma4ubkZtWvXNtq0aWP84x//MI4ePWrtc/nlZg3DMNLT041hw4YZPj4+hrOzs9GmTZtCP6uGcen3YsqUKUaLFi0MZ2dnw9fX1+jZs6eRkpJyxW187733jMaNGxuOjo5FXnr2k08+MSQZo0aNKvF8AKgaLIZxhX2WAAAAleiLL75QdHS01q1bp65du9q7HAClQLAAAABVxl133aUdO3Zoz549FX61LwDli3MsAABVUlpa2hWXu7m5mbpSV1ZWls6ePXvFPgEBAWUevzQqelurg48//lhbt27VV199pddff51QAVRD7LEAAFRJV3tjOWTIECUkJJR5/KFDhxZ5hao/q6yXyIre1urAYrHI3d1d/fv316xZs1SjBp99AtUNv7UAgCrpaveDqFevnqnx//GPf1SZy5lW9LZWB3zOCVR/7LEAAAAAYBo3yAMAAABgGodClVF+fr6OHj2q2rVrc4IZAAAArkmGYejUqVOqV6+eHByuvE+CYFFGR48eVVBQkL3LAAAAACrc4cOH1aBBgyv2IViUUe3atSVdmmQPDw87VwMAAACUv+zsbAUFBVnf+14JwaKMCg5/8vDwIFgAAADgmlaSQ/85eRsAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgWg17FwAAgD0cOnRImZmZ9i4DlcDHx0cNGza0dxnANc+uweLAgQMKCQnR5s2bFRoaWqLnJCQkaPz48Tp58qRd6wAAVF+HDh1S8+Ytde7cGXuXUqUEuFs0OsxZs1POK+20Ye9yyo2ra02lpu4gXAAVrFyCxeHDhzVp0iQlJiYqMzNTgYGBio6O1sSJE1W3bt1inxcUFKRjx47Jx8enxOvq37+/evXqVR5lV1t5eXn6/vvvdezYMQUGBqpr165ydHS0d1nXrPKa78r8vuXl5WnNmjVas2aNJCkyMlKRkZGF1sfPEq5XmZmZ/x8q5ktqae9yqoxA912KixytZakJSjv9F3uXU0526Ny5QcrMzCRYABXNMGnv3r2Gn5+f0aVLF2PNmjXGwYMHja+//tq44YYbjGbNmhm///57kc/Lzc01u+pys3//fkOSsXnz5hI/Jysry5BkZGVlVVxhRfjss8+M4OBgQ5L1ERwcbHz22WeVWsf1orzmuzK/b5999pnh5+dnsy5Jhq+vr836yrOmnJwcIyUlxcjJySnPTQEqTEpKyv//3KcYksHj/x83Bmw2jEkexo0Bm+1eS/k9Ln2vU1JS7P1jB5SJvV9jS/Oe1/TJ22PGjJGzs7NWrFihiIgINWzYUD179tSqVat05MgRPfvss5Kk4OBgvfDCCxo8eLA8PDw0atQoHThwQBaLRVu2bLGOt2zZMjVr1kyurq7q1q2b5s2bJ4vFYj30KSEhQV5eXtb+cXFxCg0N1Ycffqjg4GB5enrqgQce0KlTp6x9EhMT1aVLF3l5ealu3bq66667tHfvXrObXumWLFmi++67T23atFFycrJOnTql5ORktWnTRvfdd5+WLFli7xKvKeU135X5fStYV0ZGhrp06aKkpCQlJSWpS5cuOn78uPr166clS5aUe007d+5UWFiYdu7cWW7bAgAAqtlrrJkE8/vvvxsWi8V4+eWXi1w+cuRIo06dOkZ+fr7RqFEjw8PDw5g6daqxZ88eY8+ePYX2FOzbt89wcnIynnjiCWPnzp3GRx99ZNSvX9+QZPzxxx+GYRjG3LlzDU9PT+s6Jk2aZLi7uxt9+/Y1fvnlF2PdunVGQECA8cwzz1j7fPrpp8Znn31m7N6929i8ebPRp08fo02bNkZeXp5hGNVjj8XFixeN4OBgo0+fPta6C+Tl5Rl9+vQxQkJCjIsXL1ZKPde68prvyvy+FazLzc3NuOuuu2zWl5eXZ9x1111GzZo1jeDgYKNRo0blWlPBp798Iojqgj0W7LEAqgt7v8aW5j2vqXMsdu/eLcMw1LJl0centmzZUn/88YeOHz8uSbrtttv0+OOPW5cfOHDApv/s2bPVvHlzTZkyRZLUvHlzbdu2TS+99NIV68jPz1dCQoJq164tSXrooYeUlJRkfV6/fv1s+s+ZM0e+vr7avn27WrduXaJtzc3NVW5urvXr7OzsEj2vvHz//fc6cOCAPvroIzk42O5ocnBwUGxsrDp37qzvv/9ekZGRlVrbtai85rsyv28F65KkZ5991mZ9Dg4OeuaZZ7R8+XJrn48//rjcajp79qwkaceOHaa2Aags//tZPWvXOlAZ+PuE6q3gZ7fgtbYqK5eTtw3DKFG/9u3bX3F5amqqOnToYNPWsWPHq44bHBxsDRWSFBgYqIyMDOvXu3fv1sSJE/XTTz8pMzNT+fn5ki5dFaSkwSI+Pl6TJ08uUd+KcOzYMUkqtt6C9oJ+MKe85rsyv29/HqOo9V3eVp41FYSVQYMGlfg5QNVwQNIt9i4CFeqAJP4+ofo7cOCAbrmlav+9MhUsmjZtKovFoh07dujee+8ttHzHjh2qU6eOfH19JUm1atUys7piOTk52XxtsVis4UGS+vTpo0aNGum9995TvXr1lJ+fr9atW+v8+fMlXkdsbKxiYmKsX2dnZysoKMh88SUUGBgoSdq2bZtuvvnmQsu3bdtm0w/mlNd8V+b37c9jFLW+gnVdqU9ZawoODpYkzZ8/v9g9mEBVsmPHjv9/oxls71JQ4YIl8fcJ1VfB36uC19qqzFSwqFu3ru644w69/fbbmjBhgtzc3KzL0tLStGDBAg0ePFgWi6VE4zVv3lxff/21TdvPP/9spkT9/vvvSk1N1XvvvaeuXbtKkv7zn/+UehwXFxe5uLiYqsWMrl27Kjg4WC+//LKWLl1qcwhLfn6+4uPjFRISYt1GmFNe812Z37eCdaWnp+ull17SF198YV1ffn6+Xn75ZdWsWVN+fn4yDKNcayr43W/ZsqVuuukm09sCVB63q3dBNcffJ1wb/vw+u6oyfVWot956S7m5uerevbvWrVunw4cPKzExUXfccYfq169/1fMj/mz06NHauXOnnnrqKe3atUuffPKJEhISJKnE4eRyderUUd26dfXuu+9qz549Wr16tc2eh+rC0dFR06ZN0/LlyxUdHW1zJZ/o6GgtX75cU6dO5R4E5aS85rsyv28F6zp37pyWL1+uW2+9VatWrdKqVasUERGh5cuX68yZM5o2bZqmT5/OzxIAAChf5XG2+IEDB4whQ4YY/v7+hpOTkxEUFGSMGzfOyMzMtPZp1KiR8dprr9k8r6irMX3xxRdG06ZNDRcXFyMyMtJ45513DEnG2bNnDcMo+qpQ7dq1sxn3tddeMxo1amT9euXKlUbLli0NFxcXo23btsaaNWsMScbnn39ebB1XU5XuYxESEsJ9LCpIec13ZX7firuPhZ+f31XvY1HWmux9jW2gtLgqFFeFAqoLe7/GluY9r8UwSnjmtZ289NJLmjVrlg4fPmzvUmxkZ2fL09NTWVlZ8vDwqNR1c7fkysWdt4Frz6ZNmxQWFibuvG3rxoBd2jR6tG6aPVub066dO29Lg5SSksKhUEAZlOY9b5ULFm+//bY6dOigunXr6ocfftC4ceM0duxYvfjii/YuzYY9gwUAwJxDhw6pefOWOnfujL1LqVIC3C0aHeas2SnnlXa6Sr09MMXVtaZSU3eoYcOG9i4FqHZK8563XC43W552796tF198USdOnFDDhg31+OOPKzY21t5lAQCuIQ0bNlRq6g5lZmbau5Qq6W57F1DOfHx8CBVAJahyeyyqC/ZYAAAA4FpXmve8pq8KBQAAAAAECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKbVsHcBAABUlEOHDikzM9PeZaAa8vHxUcOGDe1dBlCtECwAANekQ4cOqWXz5jpz7py9S7lmBLhbNDrMWbNTzivttGHvcipUTVdX7UhNJVwApVBtg0VCQoLGjx+vkydP2rsUAEAVlJmZqTPnzmm+pJb2LuYa4eZuUctIF/VPvaCz13Cw2CFp0LlzyszMJFgApWD3YHH48GFNmjRJiYmJyszMVGBgoKKjozVx4kTVrVtXkhQcHKzx48dr/Pjx9i22isjLy9P333+vY8eOKTAwUF27dpWjo6O9y7pmMd9A9dZS0k32LuIaQ1ADUBS7nry9b98+tW/fXrt379ZHH32kPXv2aNasWUpKSlKnTp104sSJSq/pwoULlb7O0liyZImaNm2qbt266cEHH1S3bt3UtGlTLVmyxN6lXZOY75I5c+aMNm3apDNnzti7FAAAKg2vf7bsGizGjBkjZ2dnrVixQhEREWrYsKF69uypVatW6ciRI3r22WcVGRmpgwcPasKECbJYLLJYLDZjfPvtt2rZsqXc3d3Vo0cPHTt2zGb5+++/r5YtW8rV1VUtWrTQ22+/bV124MABWSwWLVq0SBEREXJ1ddWCBQsqZdvLYsmSJbrvvvvUpk0bJScn69SpU0pOTlabNm1033338Wa3nDHfJbdz506FhYVp586d9i4FAIBKw+vfZQw7+f333w2LxWK8/PLLRS4fOXKkUadOHSMzM9No0KCB8fzzzxvHjh0zjh07ZhiGYcydO9dwcnIyoqKijJ9//tlISUkxWrZsaTz44IPWMebPn28EBgYan332mbFv3z7js88+M7y9vY2EhATDMAxj//79hiQjODjY2ufo0aMlqj8rK8uQZGRlZZmciZK5ePGiERwcbPTp08fIy8uzWZaXl2f06dPHCAkJMS5evFgp9VzrmO/SSUlJMSQZKSkp9i4FsLL+XEqGwaN8HgEOhjHJ49K/9q6lAh8pksHfNJTE9fD6V5r3vHY7x2L37t0yDEMtWxZ9pGbLli31xx9/KC8vT46Ojqpdu7YCAgJs+ly4cEGzZs1SkyZNJEljx47V888/b10+adIkTZs2TX379pUkhYSEaPv27Zo9e7aGDBli7Td+/Hhrn+Lk5uYqNzfX+nV2dnbpNtik77//XgcOHNBHH30kBwfbHU0ODg6KjY1V586d9f333ysyMrJSa7sWMd+lc/bsWUnSjh077FwJ8D8FP49n7VwHqp+Cnxn+puFqrH9nzvKXRqoCJ28bhlHm59asWdMaKiQpMDBQGRkZkqScnBzt3btXw4cP18iRI619Ll68KE9PT5tx2rdvf9V1xcfHa/LkyWWu1ayCQ7xat25d5PKC9ssPBUPZMN+lc+DAAUnSoEGD7FsIUIQDkm6xdxGoVg78/7/8TUNJHThwQLfcwl8auwWLpk2bymKxaMeOHbr33nsLLd+xY4fq1KkjX1/fYsdwcnKy+dpisViDyunTpyVJ7733nsLDw236XX5Fn1q1al213tjYWMXExFi/zs7OVlBQ0FWfV14CAwMlSdu2bdPNN99caPm2bdts+sEc5rt0goODJUnz588vdi8kUNl27NihQYMGKdjehaDaCf7/f/mbhqux/p35/9fB653dgkXdunV1xx136O2339aECRPk5uZmXZaWlqYFCxZo8ODBslgscnZ2Vl5eXqnG9/f3V7169bRv3z4NHDjQdL0uLi5ycXExPU5Zde3aVcHBwXr55Ze1dOlSm8Nz8vPzFR8fr5CQEHXt2tVuNV5LmO/SKfj9bdmypW66iQt7ompxu3oXwEbBzwx/01BSf34fez2z61Wh3nrrLeXm5qp79+5at26dDh8+rMTERN1xxx2qX7++XnrpJUmXPg1dt26djhw5oszMzBKPP3nyZMXHx+uNN97Qrl279Msvv2ju3LmaPn16RW1ShXF0dNS0adO0fPlyRUdH21ylKDo6WsuXL9fUqVO5v0I5Yb4BAABKx67BolmzZtq4caMaN26s+++/X02aNNGoUaPUrVs3JScny9vbW5L0/PPP68CBA2rSpMkVD4263IgRI/T+++9r7ty5atOmjSIiIpSQkKCQkJCK2qQK1bdvX3366af65Zdf1LlzZ3l4eKhz587atm2bPv3006uegI7SYb5LrkWLFkpJSVGLFi3sXQoAAJWG1z9bFsPM2dPXsezsbHl6eiorK0seHh6Vum7uBF25mG+getq0aZPCwsI0X9wpury4BTio5Wh37Zh9WmfT8u1dToXZIWmQpJSUFA6FwnWvNO957X5VKJSeo6MjlzitRMw3UD35+PiopqurBp07Z+9SrhkBpw2NXpOr2acNpdm7mApW09VVPj4+9i4DqFYIFgCAa1LDhg21IzW1VOfmoWTutncBlcDHx0cNGza0dxlAtUKwAABcsxo2bMibQwCoJHY9eRsAAADAtYFgAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTati7gOrKMAxJUnZ2tp0rAQAAACpGwXvdgve+V0KwKKNTp05JkoKCguxcCQAAAFCxTp06JU9Pzyv2sRgliR8oJD8/X0ePHlXt2rVlsVjsXU4h2dnZCgoK0uHDh+Xh4WHvcqod5s885tA85tA85tAc5s885tA85tA8M3NoGIZOnTqlevXqycHhymdRsMeijBwcHNSgQQN7l3FVHh4e/BKawPyZxxyaxxyaxxyaw/yZxxyaxxyaV9Y5vNqeigKcvA0AAADANIIFAAAAANMIFtcoFxcXTZo0SS4uLvYupVpi/sxjDs1jDs1jDs1h/sxjDs1jDs2rrDnk5G0AAAAAprHHAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsGiGlu3bp369OmjevXqyWKxaOnSpYX67NixQ3fffbc8PT1Vq1YtdejQQYcOHar8Yquoq83h6dOnNXbsWDVo0EBubm5q1aqVZs2aZZ9iq6D4+Hh16NBBtWvXlp+fn6Kjo5WammrT59y5cxozZozq1q0rd3d39evXT+np6XaquOq52hyeOHFC48aNU/PmzeXm5qaGDRvq0UcfVVZWlh2rrlpK8nNYwDAM9ezZs9i/mderks5hcnKybrvtNtWqVUseHh669dZbdfbsWTtUXLWUZP7S0tL00EMPKSAgQLVq1dJNN92kzz77zE4VVz3vvPOO2rZta72BW6dOnfTNN99Yl/NacnVXmsPKei0hWFRjOTk5ateunWbOnFnk8r1796pLly5q0aKF1qxZo61bt+qf//ynXF1dK7nSqutqcxgTE6PExETNnz9fO3bs0Pjx4zV27FgtW7askiutmtauXasxY8boxx9/1MqVK3XhwgXdeeedysnJsfaZMGGCvvzySy1evFhr167V0aNH1bdvXztWXbVcbQ6PHj2qo0ePaurUqdq2bZsSEhKUmJio4cOH27nyqqMkP4cFZsyYIYvFYocqq7aSzGFycrJ69OihO++8Uxs2bNDPP/+ssWPHysGBtxIlmb/BgwcrNTVVy5Yt0y+//KK+ffvq/vvv1+bNm+1YedXRoEEDvfLKK0pJSdHGjRt122236Z577tGvv/4qideSkrjSHFbaa4mBa4Ik4/PPP7dp69+/vzFo0CD7FFQNFTWHN9xwg/H888/btN10003Gs88+W4mVVR8ZGRmGJGPt2rWGYRjGyZMnDScnJ2Px4sXWPjt27DAkGcnJyfYqs0q7fA6L8sknnxjOzs7GhQsXKrGy6qO4Ody8ebNRv35949ixY0X+vuN/iprD8PBw47nnnrNjVdVHUfNXq1Yt49///rdNP29vb+O9996r7PKqjTp16hjvv/8+ryUmFMxhUSritYSPGa5R+fn5+uqrr/SXv/xF3bt3l5+fn8LDw9n1X0qdO3fWsmXLdOTIERmGoe+++067du3SnXfeae/SqqSCXare3t6SpJSUFF24cEFRUVHWPi1atFDDhg2VnJxslxqrusvnsLg+Hh4eqlGjRmWVVa0UNYdnzpzRgw8+qJkzZyogIMBepVUbl89hRkaGfvrpJ/n5+alz587y9/dXRESE/vOf/9izzCqrqJ/Bzp07a9GiRTpx4oTy8/P18ccf69y5c4qMjLRTlVVXXl6ePv74Y+Xk5KhTp068lpTB5XNYlIp4LSFYXKMyMjJ0+vRpvfLKK+rRo4dWrFihe++9V3379tXatWvtXV618eabb6pVq1Zq0KCBnJ2d1aNHD82cOVO33nqrvUurcvLz8zV+/Hjdcsstat26taRLxxQ7OzvLy8vLpq+/v7/S0tLsUGXVVtQcXi4zM1MvvPCCRo0aVcnVVQ/FzeGECRPUuXNn3XPPPXasrnooag737dsnSYqLi9PIkSOVmJiom266Sbfffrt2795tz3KrnOJ+Bj/55BNduHBBdevWlYuLi0aPHq3PP/9cTZs2tWO1Vcsvv/wid3d3ubi46G9/+5s+//xztWrViteSUihuDi9XUa8lfNx1jcrPz5ck3XPPPZowYYIkKTQ0VOvXr9esWbMUERFhz/KqjTfffFM//vijli1bpkaNGmndunUaM2aM6tWrZ/PJCaQxY8Zo27ZtfIJpwtXmMDs7W71791arVq0UFxdXucVVE0XN4bJly7R69WqOZS+houaw4DVl9OjRGjZsmCTpxhtvVFJSkubMmaP4+Hi71FoVFfd7/M9//lMnT57UqlWr5OPjo6VLl+r+++/X999/rzZt2tip2qqlefPm2rJli7KysvTpp59qyJAhfBhaSsXN4Z/DRUW+lhAsrlE+Pj6qUaNGoZTasmVL3viV0NmzZ/XMM8/o888/V+/evSVJbdu21ZYtWzR16lSCxZ+MHTtWy5cv17p169SgQQNre0BAgM6fP6+TJ0/afNKUnp7O4SiXKW4OC5w6dUo9evRQ7dq19fnnn8vJyckOVVZtxc3h6tWrtXfv3kKfdvbr109du3bVmjVrKrfQKqy4OQwMDJSkIl9TuNLg/xQ3f3v37tVbb72lbdu26YYbbpAktWvXTt9//71mzpzJ1Qb/n7Ozs3UPTlhYmH7++We9/vrr6t+/P68lJVTcHM6ePVtSxb+WcCjUNcrZ2VkdOnQodLm7Xbt2qVGjRnaqqnq5cOGCLly4UOiKJ46OjtZP7653hmFo7Nix+vzzz7V69WqFhITYLA8LC5OTk5OSkpKsbampqTp06FCxx3xeb642h9KlT5fuvPNOOTs7a9myZVzZ7TJXm8Onn35aW7du1ZYtW6wPSXrttdc0d+5cO1Rc9VxtDoODg1WvXj1eU4pxtfk7c+aMJPF6Ukr5+fnKzc3ltcSEgjmUKue1hD0W1djp06e1Z88e69f79+/Xli1b5O3trYYNG+rJJ59U//79deutt6pbt25KTEzUl19+yadzf3K1OYyIiNCTTz4pNzc3NWrUSGvXrtW///1vTZ8+3Y5VVx1jxozRwoUL9cUXX6h27drWY109PT3l5uYmT09PDR8+XDExMfL29paHh4fGjRunTp066eabb7Zz9VXD1eaw4IXgzJkzmj9/vrKzs5WdnS1J8vX1laOjoz3LrxKuNocBAQFFfqrZsGHDIoPc9ehqc2ixWPTkk09q0qRJateunUJDQzVv3jzt3LlTn376qZ2rt7+rzV+LFi3UtGlTjR49WlOnTlXdunW1dOlSrVy5UsuXL7dz9VVDbGysevbsqYYNG+rUqVNauHCh1qxZo2+//ZbXkhK60hxW2mtJuV1fCpXuu+++MyQVegwZMsTa54MPPjCaNm1quLq6Gu3atTOWLl1qv4KroKvN4bFjx4yhQ4ca9erVM1xdXY3mzZsb06ZNM/Lz8+1beBVR1NxJMubOnWvtc/bsWeORRx4x6tSpY9SsWdO49957jWPHjtmv6CrmanNY3M+oJGP//v12rb2qKMnPYVHP4XKz/1PSOYyPjzcaNGhg1KxZ0+jUqZPx/fff26fgKqYk87dr1y6jb9++hp+fn1GzZk2jbdu2hS4/ez17+OGHjUaNGhnOzs6Gr6+vcfvttxsrVqywLue15OquNIeV9VpiMQzDKJ+IAgAAAOB6xTkWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYALgmBAcHa+jQofYu45o3ZcoUNW7cWI6OjgoNDbV3OeXu9OnTGjFihAICAmSxWDR+/PhKW3dkZKQiIyOtXx84cEAWi0UJCQmVVkNRLBaL4uLiKmTsqrKNAMoHwQJAlZOQkCCLxaKNGzcWuTwyMlKtW7c2vZ6vv/66wt4wXYtWrFihf/zjH7rllls0d+5cvfzyy5W27jNnziguLk5r1qyp0PW8/PLLSkhI0N///nd9+OGHeuihhyp0fSiM30ug+qph7wIAoDykpqbKwaF0n5V8/fXXmjlzJm9iSmj16tVycHDQBx98IGdn50pd95kzZzR58mRJsvlUv7ytXr1aN998syZNmlRh6yjOihUrKn2d9taoUSOdPXtWTk5O1jZ+L4Hqiz0WAK4JLi4uNm9OqoOcnBx7l1AqGRkZcnNzq/RQUZkyMjLk5eVlehzDMHT27NlSPcfZ2fmantuiWCwWubq6ytHR0d6lACgHBAsA14TLz7G4cOGCJk+erGbNmsnV1VV169ZVly5dtHLlSknS0KFDNXPmTEmX3twUPArk5OTo8ccfV1BQkFxcXNS8eXNNnTpVhmHYrPfs2bN69NFH5ePjo9q1a+vuu+/WkSNHCh2XHhcXJ4vFou3bt+vBBx9UnTp11KVLF0nS1q1bNXToUDVu3Fiurq4KCAjQww8/rN9//91mXQVj7Nq1S4MGDZKnp6d8fX31z3/+U4Zh6PDhw7rnnnvk4eGhgIAATZs2rURzd/HiRb3wwgtq0qSJXFxcFBwcrGeeeUa5ubnWPhaLRXPnzlVOTo51rq52XPzixYsVFhYmNzc3+fj4aNCgQTpy5IhNn8vPKygwdOhQBQcHS7p0HL6vr68kafLkydb1l+YT7YyMDA0fPlz+/v5ydXVVu3btNG/ePOvyNWvWyGKxaP/+/frqq6+s6zhw4ECJxg8ODtZdd92lb7/9Vu3bt5ebm5tmz54tSZo7d65uu+02+fn5ycXFRa1atdI777xTaIzi5qKk0tPTVaNGDeuenT9LTU2VxWLRW2+9ZW07efKkxo8fb/0Zb9q0qf71r38pPz//quvavHmzevbsKQ8PD7m7u+v222/Xjz/+WKjfyZMnNWHCBAUHB8vFxUUNGjTQ4MGDlZmZKanwORbF/V4ahqHg4GDdc889hdZx7tw5eXp6avTo0SWaJwAVh0OhAFRZWVlZ1jcgf3bhwoWrPjcuLk7x8fEaMWKEOnbsqOzsbG3cuFGbNm3SHXfcodGjR+vo0aNauXKlPvzwQ5vnGoahu+++W999952GDx+u0NBQffvtt3ryySd15MgRvfbaa9a+Q4cO1SeffKKHHnpIN998s9auXavevXsXW9df//pXNWvWTC+//LI1pKxcuVL79u3TsGHDFBAQoF9//VXvvvuufv31V/344482gUeS+vfvr5YtW+qVV17RV199pRdffFHe3t6aPXu2brvtNv3rX//SggUL9MQTT6hDhw669dZbrzhXI0aM0Lx583Tffffp8ccf108//aT4+Hjt2LFDn3/+uSTpww8/1LvvvqsNGzbo/ffflyR17ty52DETEhI0bNgwdejQQfHx8UpPT9frr7+uH374QZs3by7VXgFfX1+98847+vvf/657771Xffv2lSS1bdu2RM8/e/asIiMjtWfPHo0dO1YhISFavHixhg4dqpMnT+qxxx5Ty5Yt9eGHH2rChAlq0KCBHn/8ceu6Syo1NVUDBgzQ6NGjNXLkSDVv3lyS9M477+iGG27Q3XffrRo1aujLL7/UI488ovz8fI0ZM6bE41+Nv7+/IiIi9MknnxQ6lGvRokVydHTUX//6V0mXDi2LiIjQkSNHNHr0aDVs2FDr169XbGysjh07phkzZhS7nl9//VVdu3aVh4eH/vGPf8jJyUmzZ89WZGSk1q5dq/DwcEmXToTv2rWrduzYoYcfflg33XSTMjMztWzZMv3222/y8fEpNHZxv5cWi0WDBg3Sq6++qhMnTsjb29u67Msvv1R2drYGDRpkZvoAlAcDAKqYuXPnGpKu+LjhhhtsntOoUSNjyJAh1q/btWtn9O7d+4rrGTNmjFHUn8GlS5cakowXX3zRpv2+++4zLBaLsWfPHsMwDCMlJcWQZIwfP96m39ChQw1JxqRJk6xtkyZNMiQZAwYMKLS+M2fOFGr76KOPDEnGunXrCo0xatQoa9vFixeNBg0aGBaLxXjllVes7X/88Yfh5uZmMydF2bJliyHJGDFihE37E088YUgyVq9ebW0bMmSIUatWrSuOZxiGcf78ecPPz89o3bq1cfbsWWv78uXLDUnGxIkTrW0RERFGREREoTGGDBliNGrUyPr18ePHC81pSc2YMcOQZMyfP9+mxk6dOhnu7u5Gdna2tb1Ro0ZX/bkpSqNGjQxJRmJiYqFlRX1/u3fvbjRu3Nim7fK52L9/vyHJmDt3bonrmD17tiHJ+OWXX2zaW7VqZdx2223Wr1944QWjVq1axq5du2z6Pf3004ajo6Nx6NAha9vl8x4dHW04Ozsbe/futbYdPXrUqF27tnHrrbda2yZOnGhIMpYsWVKozvz8/GK3sbjfy9TUVEOS8c4779i033333UZwcLB1TAD2w6FQAKqsmTNnauXKlYUeJfmk2svLS7/++qt2795d6vV+/fXXcnR01KOPPmrT/vjjj8swDH3zzTeSpMTEREnSI488YtNv3LhxxY79t7/9rVCbm5ub9f/nzp1TZmambr75ZknSpk2bCvUfMWKE9f+Ojo5q3769DMPQ8OHDre1eXl5q3ry59u3bV2wt0qVtlaSYmBib9oJP7L/66qsrPr8oGzduVEZGhh555BG5urpa23v37q0WLVqUaUwzvv76awUEBGjAgAHWNicnJz366KM6ffq01q5dWy7rCQkJUffu3Qu1//n7W7AXLiIiQvv27VNWVla5rLtA3759VaNGDS1atMjatm3bNm3fvl39+/e3ti1evFhdu3ZVnTp1lJmZaX1ERUUpLy9P69atK3L8vLw8rVixQtHR0WrcuLG1PTAwUA8++KD+85//KDs7W5L02WefqV27drr33nsLjXP5XriS+Mtf/qLw8HAtWLDA2nbixAl98803GjhwYJnGBFC+CBYAqqyOHTsqKiqq0KNOnTpXfe7zzz+vkydP6i9/+YvatGmjJ598Ulu3bi3Reg8ePKh69eqpdu3aNu0tW7a0Li/418HBQSEhITb9mjZtWuzYl/eVLr05euyxx+Tv7y83Nzf5+vpa+xX1xrNhw4Y2X3t6esrV1bXQoSWenp76448/iq3lz9twec0BAQHy8vKybmtpFDyn4FCgP2vRokWZxjTj4MGDatasWaGrhl3+/TSrqO+tJP3www+KiopSrVq15OXlJV9fXz3zzDOSiv7+muHj46Pbb79dn3zyibVt0aJFqlGjhvUQMknavXu3EhMT5evra/OIioqSdOmclKIcP35cZ86cKfJ727JlS+Xn5+vw4cOSpL1795bLZaH/bPDgwfrhhx+s37PFixfrwoULXBYYqCIIFgCuSbfeeqv27t2rOXPmqHXr1nr//fd10003Wc8PsJc/f3pd4P7779d7772nv/3tb1qyZIlWrFhh3RtS1Im0RV1Bp7ir6hiXnWxeHHt92lvcevPy8iq5EvOK+t7u3btXt99+uzIzMzV9+nR99dVXWrlypSZMmCCp6O+vWQ888IB27dqlLVu2SJI++eQT3X777TbBMz8/X3fccUeRewRXrlypfv36lXtd5eGBBx6Qk5OTda/F/Pnz1b59+yKDDoDKx8nbAK5Z3t7eGjZsmIYNG6bTp0/r1ltvVVxcnPVQouLe1DZq1EirVq3SqVOnbPZa7Ny507q84N/8/Hzt379fzZo1s/bbs2dPiWv8448/lJSUpMmTJ2vixInW9rIcwlUWBduwe/du6yf40qUrDJ08edK6raUdU7p0MvNtt91msyw1NdVmzDp16hR5uNblexHMBJ9GjRpp69atys/Pt9lrcfn3syJ8+eWXys3N1bJly2z2NH333XcVts7o6GiNHj3aejjUrl27FBsba9OnSZMmOn36tHUPRUn5+vqqZs2aSk1NLbRs586dcnBwUFBQkHUd27ZtK3X9V/pee3t7q3fv3lqwYIEGDhyoH3744YonmgOoXOyxAHBNuvxSre7u7mratKnNJVRr1aol6dIlMf+sV69eysvLs7k0pyS99tprslgs6tmzpyRZj6d/++23bfq9+eabJa6zYE/D5XsWKuvNUq9evYpc3/Tp0yXpile4Kk779u3l5+enWbNm2cz3N998ox07dtiM2aRJE+3cuVPHjx+3tv33v//VDz/8YDNmzZo1JRX+XpVEr169lJaWZnPewcWLF/Xmm2/K3d1dERERpR6zpIr6/mZlZWnu3LkVtk4vLy91795dn3zyiT7++GM5OzsrOjraps/999+v5ORkffvtt4Wef/LkSV28eLHIsR0dHXXnnXfqiy++sLkUb3p6uhYuXKguXbrIw8NDktSvXz/997//tV5Z7M+utCetuN/LAg899JC2b9+uJ598Uo6OjnrggQeKHQtA5WKPBYBrUqtWrRQZGamwsDB5e3tr48aN+vTTTzV27Fhrn7CwMEnSo48+qu7du1vfpPTp00fdunXTs88+qwMHDqhdu3ZasWKFvvjiC40fP15NmjSxPr9fv36aMWOGfv/9d+vlZnft2iWpZJ+ye3h46NZbb9Wrr76qCxcuqH79+lqxYoX2799fAbNSWLt27TRkyBC9++67OnnypCIiIrRhwwbNmzdP0dHR6tatW6nHdHJy0r/+9S8NGzZMERERGjBggPVys8HBwdbDgCTp4Ycf1vTp09W9e3cNHz5cGRkZmjVrlm644QbrScDSpcOMWrVqpUWLFukvf/mLvL291bp16xIdwz9q1CjNnj1bQ4cOVUpKioKDg/Xpp59aP+2+/Fya8nTnnXfK2dlZffr00ejRo3X69Gm999578vPz07Fjxypsvf3799egQYP09ttvq3v37oUu7/vkk09q2bJluuuuuzR06FCFhYUpJydHv/zyiz799FMdOHCgyMvBStKLL76olStXqkuXLnrkkUdUo0YNzZ49W7m5uXr11Vdt1vHpp5/qr3/9qx5++GGFhYXpxIkTWrZsmWbNmqV27doVOX5xv5cFevfurbp162rx4sXq2bOn/Pz8TM4WgHJjz0tSAUBRCi43+/PPPxe5PCIi4qqXm33xxReNjh07Gl5eXoabm5vRokUL46WXXjLOnz9v7XPx4kVj3Lhxhq+vr2GxWGwucXnq1CljwoQJRr169QwnJyejWbNmxpQpUwpd0jInJ8cYM2aM4e3tbbi7uxvR0dHWy2L++fKvBZeKPX78eKHt+e2334x7773X8PLyMjw9PY2//vWvxtGjR4u9ZO3lYxR3Gdii5qkoFy5cMCZPnmyEhIQYTk5ORlBQkBEbG2ucO3euROspzqJFi4wbb7zRcHFxMby9vY2BAwcav/32W6F+8+fPNxo3bmw4OzsboaGhxrffflvocrOGYRjr1683wsLCDGdn51JfejY9Pd0YNmyY4ePjYzg7Oxtt2rQp8jKuZi43W9zzli1bZrRt29ZwdXU1goODjX/961/GnDlzDEnG/v37rf3K43KzBbKzsw03N7dCl9n9s1OnThmxsbFG06ZNDWdnZ8PHx8fo3LmzMXXqVJvfk6LmetOmTUb37t0Nd3d3o2bNmka3bt2M9evXF1rH77//bowdO9aoX7++4ezsbDRo0MAYMmSIkZmZWew2Xun3ssAjjzxiSDIWLlxY6rkBUHEshlHCM/sAACWyZcsW3XjjjZo/f74GDhxo73KAa86ECRP0wQcfKC0tzXqYHAD74xwLADDh7NmzhdpmzJghBweHq97xGkDpnTt3TvPnz1e/fv0IFUAVwzkWAGDCq6++qpSUFHXr1k01atTQN998o2+++UajRo2yXh0HFeP8+fM6ceLEFft4enoWeRnYkjp+/PgVL33r7Owsb2/vMo9fUpWxrVVdRkaGVq1apU8//VS///67HnvsMXuXBOAyBAsAMKFz585auXKlXnjhBZ0+fVoNGzZUXFycnn32WXuXds1bv379VU8unzt3roYOHVrmdXTo0OGKN9CLiIjQmjVryjx+SVXGtlZ127dv18CBA+Xn56c33nhDoaGh9i4JwGU4xwIAUC398ccfSklJuWKfG264QYGBgWVexw8//FDk4W4F6tSpY72KUUWqjG0FALMIFgAAAABM4+RtAAAAAKZxjkUZ5efn6+jRo6pdu3aJboIFAAAAVDeGYejUqVOqV6+eHByuvE+CYFFGR48e5YovAAAAuC4cPnxYDRo0uGIfgkUZ1a5dW9KlSfbw8LBzNQAAAED5y87OVlBQkPW975UQLMqo4PAnDw8PggUAAACuaSU59J+TtwEAAACYRrAAAAAAYBrBAgAAAIBpnGMBAACASpGfn6/z58/buwz8iZOTkxwdHctlLIIFAAAAKtz58+e1f/9+5efn27sUXMbLy0sBAQGm781GsAAAAECFMgxDx44dk6Ojo4KCgq56ozVUDsMwdObMGWVkZEiSAgMDTY1HsAAAAECFunjxos6cOaN69eqpZs2a9i4Hf+Lm5iZJysjIkJ+fn6nDooiLAAAAqFB5eXmSJGdnZztXgqIUhL0LFy6YGodgAQAAgEph9hh+VIzy+r4QLAAAAACYRrAAAAAAKsCBAwdksVi0ZcuWEj8nISFBXl5edq+jLDh5GwAAAHYRF1c91nf48GFNmjRJiYmJyszMVGBgoKKjozVx4kTVrVu32OcFBQXp2LFj8vHxKfG6+vfvr169epWtUDtjjwUAAABQjH379ql9+/bavXu3PvroI+3Zs0ezZs1SUlKSOnXqpBMnThT5vPPnz8vR0VEBAQGqUaPkn+W7ubnJz8+vvMqvVAQLAAAAoBhjxoyRs7OzVqxYoYiICDVs2FA9e/bUqlWrdOTIET377LOSpODgYL3wwgsaPHiwPDw8NGrUqCIPQVq2bJmaNWsmV1dXdevWTfPmzZPFYtHJkyclFT4UKi4uTqGhofrwww8VHBwsT09PPfDAAzp16pS1T2Jiorp06SIvLy/VrVtXd911l/bu3VsZ02ODYAEAAAAU4cSJE/r222/1yCOPWO/3UCAgIEADBw7UokWLZBiGJGnq1Klq166dNm/erH/+85+Fxtu/f7/uu+8+RUdH67///a9Gjx5tDSZXsnfvXi1dulTLly/X8uXLtXbtWr3yyivW5Tk5OYqJidHGjRuVlJQkBwcH3XvvvZV+l3POsQAAAACKsHv3bhmGoZYtWxa5vGXLlvrjjz90/PhxSdJtt92mxx9/3Lr8wIEDNv1nz56t5s2ba8qUKZKk5s2ba9u2bXrppZeuWEd+fr4SEhJUu3ZtSdJDDz2kpKQk6/P69etn03/OnDny9fXV9u3b1bp165JvsEnssQAAAACuoGCPxNW0b9/+istTU1PVoUMHm7aOHTteddzg4GBrqJCkwMBAZWRkWL/evXu3BgwYoMaNG8vDw0PBwcGSpEOHDpWo7vJCsAAAAACK0LRpU1ksFu3YsaPI5Tt27FCdOnXk6+srSapVq1aF1OHk5GTztcVisTnMqU+fPjpx4oTee+89/fTTT/rpp58kXTqBvDIRLAAAAIAi1K1bV3fccYfefvttnT171mZZWlqaFixYoP79+5f4ztXNmzfXxo0bbdp+/vlnUzX+/vvvSk1N1XPPPafbb7/deniWPRAsAAAAgGK89dZbys3NVffu3bVu3TodPnxYiYmJuuOOO1S/fv2rnh/xZ6NHj9bOnTv11FNPadeuXfrkk0+UkJAgSSUOJ5erU6eO6tatq3fffVd79uzR6tWrFRMTU6axzCJYAAAAAMVo1qyZNm7cqMaNG+v+++9XkyZNNGrUKHXr1k3Jycny9vYu8VghISH69NNPtWTJErVt21bvvPOO9apQLi4uZarPwcFBH3/8sVJSUtS6dWtNmDDBenJ4ZbMYJT0bBTays7Pl6emprKwseXh42LscAMB1oLLvUlzVXO/bX52dO3dO+/fvV0hIiFxdXe1dTpXy0ksvadasWTp8+LDdarjS96c073m53CwAAABQSd5++2116NBBdevW1Q8//KApU6Zo7Nix9i6rXBAsAAAAgEqye/duvfjiizpx4oQaNmyoxx9/XLGxsfYuq1wQLAAAAIBK8tprr+m1116zdxkVgpO3AQAAAJhGsAAAAABgmt2DxcyZMxUcHCxXV1eFh4drw4YNxfb99ddf1a9fPwUHB8tisWjGjBmF+hQsu/wxZswYa5/IyMhCy//2t79VxOYBAAAA1wW7BotFixYpJiZGkyZN0qZNm9SuXTt1795dGRkZRfY/c+aMGjdurFdeeUUBAQFF9vn555917Ngx62PlypWSpL/+9a82/UaOHGnT79VXXy3fjQMAAACuI3YNFtOnT9fIkSM1bNgwtWrVSrNmzVLNmjU1Z86cIvt36NBBU6ZM0QMPPFDsTUR8fX0VEBBgfSxfvlxNmjRRRESETb+aNWva9ONeFAAAAEDZ2S1YnD9/XikpKYqKivpfMQ4OioqKUnJycrmtY/78+Xr44YcL3SZ9wYIF8vHxUevWrRUbG6szZ86UyzoBAACA65HdLjebmZmpvLw8+fv727T7+/tr586d5bKOpUuX6uTJkxo6dKhN+4MPPqhGjRqpXr162rp1q5566imlpqZqyZIlxY6Vm5ur3Nxc69fZ2dnlUiMAAACuTQkJCRo/frxOnjxp71IqxTV9H4sPPvhAPXv2VL169WzaR40aZf1/mzZtFBgYqNtvv1179+5VkyZNihwrPj5ekydPrtB6AQC4FkWuiSufgcppmEoTF2fvCqq+yp6jMq7v8OHDmjRpkhITE5WZmanAwEBFR0dr4sSJqlu3rqRLFxAaP368xo8fX371VjN2OxTKx8dHjo6OSk9Pt2lPT08v9sTs0jh48KBWrVqlESNGXLVveHi4JGnPnj3F9omNjVVWVpb1cfjwYdM1AgAAoGrbt2+f2rdvr927d+ujjz7Snj17NGvWLCUlJalTp046ceJEpdd04cKFSl9nSdgtWDg7OyssLExJSUnWtvz8fOs3yay5c+fKz89PvXv3vmrfLVu2SJICAwOL7ePi4iIPDw+bBwAAAK5tY8aMkbOzs1asWKGIiAg1bNhQPXv21KpVq3TkyBE9++yzioyM1MGDBzVhwgTrrQz+7Ntvv1XLli3l7u6uHj166NixYzbL33//fbVs2VKurq5q0aKF3n77beuyAwcOyGKxaNGiRYqIiJCrq6sWLFhQKdteWnY9FComJkZDhgxR+/bt1bFjR82YMUM5OTkaNmyYJGnw4MGqX7++4uPjJV06GXv79u3W/x85ckRbtmyRu7u7mjZtah03Pz9fc+fO1ZAhQ1Sjhu0m7t27VwsXLlSvXr1Ut25dbd26VRMmTNCtt96qtm3bVtKWAwAAoKo7ceKEvv32W7300ktyc3OzWRYQEKCBAwdq0aJF2r17t0JDQzVq1CiNHDnSpt+ZM2c0depUffjhh3JwcNCgQYP0xBNPWMPBggULNHHiRL311lu68cYbtXnzZo0cOVK1atXSkCFDrOM8/fTTmjZtmm688Ua5urpW/MaXgV2DRf/+/XX8+HFNnDhRaWlpCg0NVWJiovWE7kOHDsnB4X87VY4ePaobb7zR+vXUqVM1depURUREaM2aNdb2VatW6dChQ3r44YcLrdPZ2VmrVq2yhpigoCD169dPzz33XMVtKAAAAKqd3bt3yzAMtWzZssjlLVu21B9//KG8vDw5Ojqqdu3ahQ7pv3DhgmbNmmU9j3fs2LF6/vnnrcsnTZqkadOmqW/fvpKkkJAQbd++XbNnz7YJFuPHj7f2qarsfvL22LFjNXbs2CKX/TksSJdOijEM46pj3nnnncX2CwoK0tq1a0tdJwAAAK5PJXn/WZyaNWvaXBwoMDDQejPonJwc7d27V8OHD7fZ03Hx4kV5enrajNO+ffsy11BZ7B4sAAAAgKqoadOmslgs2rFjh+69995Cy3fs2KE6derI19e32DGcnJxsvrZYLNagcvr0aUnSe++9Z72YUAFHR0ebr2vVqlWmbahMdr3zNgAAAFBV1a1bV3fccYfefvttnT171mZZWlqaFixYoP79+8tiscjZ2Vl5eXmlGt/f31/16tXTvn371LRpU5tHSEhIeW5KpSBYAAAAAMV46623lJubq+7du2vdunU6fPiwEhMTdccdd6h+/fp66aWXJF06ZH/dunU6cuSIMjMzSzz+5MmTFR8frzfeeEO7du3SL7/8orlz52r69OkVtUkVhmABAAAAFKNZs2bauHGjGjdurPvvv19NmjTRqFGj1K1bNyUnJ8vb21uS9Pzzz+vAgQNq0qTJFQ+NutyIESP0/vvva+7cuWrTpo0iIiKUkJBQLfdYWAwzZ6Ncx7Kzs+Xp6amsrCzuaQEAqBTV9UbO5XXn7cjIchmm8lTXb1gFOHfunPbv36+QkJAqe6nU69mVvj+lec/LHgsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAFQKrhlUNZXX94VgAQAAgApVcBfp8+fP27kSFOXMmTOSCt8lvLRqlEcxAAAAQHFq1KihmjVr6vjx43JycpKDA59tVwWGYejMmTPKyMiQl5eXNQCWFcECAAAAFcpisSgwMFD79+/XwYMH7V0OLuPl5aWAgADT4xAsAAAAUOGcnZ3VrFkzDoeqYpycnEzvqShAsAAAAEClcHBw4M7b1zAOcAMAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmGb3YDFz5kwFBwfL1dVV4eHh2rBhQ7F9f/31V/Xr10/BwcGyWCyaMWNGoT5xcXGyWCw2jxYtWtj0OXfunMaMGaO6devK3d1d/fr1U3p6enlvGgAAAHDdsGuwWLRokWJiYjRp0iRt2rRJ7dq1U/fu3ZWRkVFk/zNnzqhx48Z65ZVXFBAQUOy4N9xwg44dO2Z9/Oc//7FZPmHCBH355ZdavHix1q5dq6NHj6pv377lum0AAADA9cSuwWL69OkaOXKkhg0bplatWmnWrFmqWbOm5syZU2T/Dh06aMqUKXrggQfk4uJS7Lg1atRQQECA9eHj42NdlpWVpQ8++EDTp0/XbbfdprCwMM2dO1fr16/Xjz/+WO7bCAAAAFwP7BYszp8/r5SUFEVFRf2vGAcHRUVFKTk52dTYu3fvVr169dS4cWMNHDhQhw4dsi5LSUnRhQsXbNbbokULNWzY0PR6AQAAgOuV3YJFZmam8vLy5O/vb9Pu7++vtLS0Mo8bHh6uhIQEJSYm6p133tH+/fvVtWtXnTp1SpKUlpYmZ2dneXl5lWq9ubm5ys7OtnkAAAAAuKSGvQsobz179rT+v23btgoPD1ejRo30ySefaPjw4WUeNz4+XpMnTy6PEgEAAIBrjt32WPj4+MjR0bHQ1ZjS09OveGJ2aXl5eekvf/mL9uzZI0kKCAjQ+fPndfLkyVKtNzY2VllZWdbH4cOHy61GAAAAoLqzW7BwdnZWWFiYkpKSrG35+flKSkpSp06dym09p0+f1t69exUYGChJCgsLk5OTk816U1NTdejQoSuu18XFRR4eHjYPAAAAAJfY9VComJgYDRkyRO3bt1fHjh01Y8YM5eTkaNiwYZKkwYMHq379+oqPj5d06YTv7du3W/9/5MgRbdmyRe7u7mratKkk6YknnlCfPn3UqFEjHT16VJMmTZKjo6MGDBggSfL09NTw4cMVExMjb29veXh4aNy4cerUqZNuvvlmO8wCAAAAUP3ZNVj0799fx48f18SJE5WWlqbQ0FAlJiZaT+g+dOiQHBz+t1Pl6NGjuvHGG61fT506VVOnTlVERITWrFkjSfrtt980YMAA/f777/L19VWXLl30448/ytfX1/q81157TQ4ODurXr59yc3PVvXt3vf3225Wz0QAAAMA1yGIYhmHvIqqj7OxseXp6Kisri8OiAACVIi7O3hWUTeSauPIZJ7Jchqk81fUbBvxJad7z2vUGeQAAAACuDQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGBaDXsXAABAScXF2bsCAEBx2GMBAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI0b5AEAUIki18TZuwQAqBDssQAAAABgGsECAAAAgGkcCgUAAKqFNWvsXUHplPdRb3HlPB5Q3thjAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATLN7sJg5c6aCg4Pl6uqq8PBwbdiwodi+v/76q/r166fg4GBZLBbNmDGjUJ/4+Hh16NBBtWvXlp+fn6Kjo5WammrTJzIyUhaLxebxt7/9rbw3DQAAALhu2DVYLFq0SDExMZo0aZI2bdqkdu3aqXv37srIyCiy/5kzZ9S4cWO98sorCggIKLLP2rVrNWbMGP34449auXKlLly4oDvvvFM5OTk2/UaOHKljx45ZH6+++mq5bx8AAABwvahhz5VPnz5dI0eO1LBhwyRJs2bN0ldffaU5c+bo6aefLtS/Q4cO6tChgyQVuVySEhMTbb5OSEiQn5+fUlJSdOutt1rba9asWWw4AQAAAFA6dttjcf78eaWkpCgqKup/xTg4KCoqSsnJyeW2nqysLEmSt7e3TfuCBQvk4+Oj1q1bKzY2VmfOnLniOLm5ucrOzrZ5AAAAALjEbnssMjMzlZeXJ39/f5t2f39/7dy5s1zWkZ+fr/Hjx+uWW25R69atre0PPvigGjVqpHr16mnr1q166qmnlJqaqiVLlhQ7Vnx8vCZPnlwudQEAAADXGrseClXRxowZo23btuk///mPTfuoUaOs/2/Tpo0CAwN1++23a+/evWrSpEmRY8XGxiomJsb6dXZ2toKCgiqmcAAAAKCasVuw8PHxkaOjo9LT023a09PTy+Xch7Fjx2r58uVat26dGjRocMW+4eHhkqQ9e/YUGyxcXFzk4uJiui4AAADgWmS3cyycnZ0VFhampKQka1t+fr6SkpLUqVOnMo9rGIbGjh2rzz//XKtXr1ZISMhVn7NlyxZJUmBgYJnXCwAAAFzP7HooVExMjIYMGaL27durY8eOmjFjhnJycqxXiRo8eLDq16+v+Ph4SZdO+N6+fbv1/0eOHNGWLVvk7u6upk2bSrp0+NPChQv1xRdfqHbt2kpLS5MkeXp6ys3NTXv37tXChQvVq1cv1a1bV1u3btWECRN06623qm3btnaYBQAAAKD6s2uw6N+/v44fP66JEycqLS1NoaGhSkxMtJ7QfejQITk4/G+nytGjR3XjjTdav546daqmTp2qiIgIrVmzRpL0zjvvSLp0E7w/mzt3roYOHSpnZ2etWrXKGmKCgoLUr18/PffccxW7sQAAAMA1zO4nb48dO1Zjx44tcllBWCgQHBwswzCuON7VlgcFBWnt2rWlqhEAAADAldn1ztsAAAAArg0ECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAptWwdwEAgOtYXFypukeuqZAqAADlgD0WAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTyhQs9u3bV951AAAAAKjGyhQsmjZtqm7dumn+/Pk6d+5cedcEAAAAoJopU7DYtGmT2rZtq5iYGAUEBGj06NHasGFDedcGAAAAoJooU7AIDQ3V66+/rqNHj2rOnDk6duyYunTpotatW2v69Ok6fvx4edcJAAAAoAozdfJ2jRo11LdvXy1evFj/+te/tGfPHj3xxBMKCgrS4MGDdezYsauOMXPmTAUHB8vV1VXh4eFX3PPx66+/ql+/fgoODpbFYtGMGTPKNOa5c+c0ZswY1a1bV+7u7urXr5/S09NLte0AAAAA/sdUsNi4caMeeeQRBQYGavr06XriiSe0d+9erVy5UkePHtU999xzxecvWrRIMTExmjRpkjZt2qR27dqpe/fuysjIKLL/mTNn1LhxY73yyisKCAgo85gTJkzQl19+qcWLF2vt2rU6evSo+vbtW/aJAAAAAK5zFsMwjNI+afr06Zo7d65SU1PVq1cvjRgxQr169ZKDw/9yym+//abg4GBdvHix2HHCw8PVoUMHvfXWW5Kk/Px8BQUFady4cXr66aevWENwcLDGjx+v8ePHl2rMrKws+fr6auHChbrvvvskSTt37lTLli2VnJysm2++uURzkJ2dLU9PT2VlZcnDw6NEzwEAXCYurlTd16ypkCqACrEmMq5cxyvlrwtQLkrznrdMeyzeeecdPfjggzp48KCWLl2qu+66yyZUSJKfn58++OCDYsc4f/68UlJSFBUV9b9iHBwUFRWl5OTkspRVojFTUlJ04cIFmz4tWrRQw4YNr7je3NxcZWdn2zwAAAAAXFKmYLFy5Uo99dRTCgwMtGk3DEOHDh2SJDk7O2vIkCHFjpGZmam8vDz5+/vbtPv7+ystLa0sZZVozLS0NDk7O8vLy6tU642Pj5enp6f1ERQUVKYaAQAAgGtRmYJFkyZNlJmZWaj9xIkTCgkJMV1UVRQbG6usrCzr4/Dhw/YuCQAAAKgyapTlScWdlnH69Gm5urqWaAwfHx85OjoWuhpTenp6sSdml8eYAQEBOn/+vE6ePGmz1+Jq63VxcZGLi0uZ6gIAANefyDVx5TtgOQ9XITgR5LpWqmARExMjSbJYLJo4caJq1qxpXZaXl6effvpJoaGhJRrL2dlZYWFhSkpKUnR0tKRLJ1onJSVp7NixpSmrVGOGhYXJyclJSUlJ6tevnyQpNTVVhw4dUqdOncq0XgAAAOB6V6pgsXnzZkmX9lj88ssvcnZ2ti5zdnZWu3bt9MQTT5R4vJiYGA0ZMkTt27dXx44dNWPGDOXk5GjYsGGSpMGDB6t+/fqKj4+XdOnk7O3bt1v/f+TIEW3ZskXu7u5q2rRpicb09PTU8OHDFRMTI29vb3l4eGjcuHHq1KlTia8IBQAAAMBWqYLFd999J0kaNmyYXn/9ddOXWe3fv7+OHz+uiRMnKi0tTaGhoUpMTLSefH3o0CGbq00dPXpUN954o/XrqVOnaurUqYqIiNCa/78G4dXGlKTXXntNDg4O6tevn3Jzc9W9e3e9/fbbprYFAAAAuJ6V6T4W4D4WAFAuuI8FUGKRkfauoAQ4x+KaU5r3vCXeY9G3b18lJCTIw8PjqnepXrJkSUmHBQAAAHANKHGw8PT0lMVisf4fAAAAAAqUOFjMnTu3yP8DAAAAQJlukHf27FmdOXPG+vXBgwc1Y8YMrVixotwKAwAAAFB9lClY3HPPPfr3v/8tSTp58qQ6duyoadOm6Z577tE777xTrgUCAAAAqPrKFCw2bdqkrl27SpI+/fRTBQQE6ODBg/r3v/+tN954o1wLBAAAAFD1lSlYnDlzRrVr15YkrVixQn379pWDg4NuvvlmHTx4sFwLBAAAAFD1lSlYNG3aVEuXLtXhw4f17bff6s4775QkZWRkcE8HAAAA4DpUpmAxceJEPfHEEwoODlZ4eLg6deok6dLeiz/fGRsAAADA9aHEl5v9s/vuu09dunTRsWPH1K5dO2v77bffrnvvvbfcigMAAABQPZQpWEhSQECAAgICbNo6duxouiAAAAAA1U+ZgkVOTo5eeeUVJSUlKSMjQ/n5+TbL9+3bVy7FAQAAAKgeyhQsRowYobVr1+qhhx5SYGCgLBZLedcFAAAAoBopU7D45ptv9NVXX+mWW24p73oAAAAAVENluipUnTp15O3tXd61AAAAAKimyhQsXnjhBU2cOFFnzpwp73oAAAAAVENlOhRq2rRp2rt3r/z9/RUcHCwnJyeb5Zs2bSqX4gAAAABUD2UKFtHR0eVcBgAAAIDqrEzBYtKkSeVdBwAAAIBqrEznWEjSyZMn9f777ys2NlYnTpyQdOkQqCNHjpRbcQAAAACqhzLtsdi6dauioqLk6empAwcOaOTIkfL29taSJUt06NAh/fvf/y7vOgEAAABUYWXaYxETE6OhQ4dq9+7dcnV1tbb36tVL69atK7fiAAAAAFQPZQoWP//8s0aPHl2ovX79+kpLSzNdFAAAAIDqpUzBwsXFRdnZ2YXad+3aJV9fX9NFAQAAAKheyhQs7r77bj3//PO6cOGCJMlisejQoUN66qmn1K9fv3ItEAAAAEDVV6ZgMW3aNJ0+fVq+vr46e/asIiIi1LRpU9WuXVsvvfRSedcIAAAAoIor01WhPD09tXLlSv3www/673//q9OnT+umm25SVFRUedcHAAAAoBoodbDIz89XQkKClixZogMHDshisSgkJEQBAQEyDEMWi6Ui6gQAAABQhZXqUCjDMHT33XdrxIgROnLkiNq0aaMbbrhBBw8e1NChQ3XvvfdWVJ0AAAAAqrBS7bFISEjQunXrlJSUpG7dutksW716taKjo/Xvf/9bgwcPLtciAQAAAFRtpdpj8dFHH+mZZ54pFCok6bbbbtPTTz+tBQsWlFtxAAAAAKqHUgWLrVu3qkePHsUu79mzp/773/+aLgoAAABA9VKqYHHixAn5+/sXu9zf319//PGH6aIAAAAAVC+lChZ5eXmqUaP40zIcHR118eJF00UBAAAAqF5KdfK2YRgaOnSoXFxcilyem5tbLkUBAAAAqF5KFSyGDBly1T5cEQoAAAC4/pQqWMydO7ei6gAAAABQjZXqHAsAAAAAKArBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGlVIljMnDlTwcHBcnV1VXh4uDZs2HDF/osXL1aLFi3k6uqqNm3a6Ouvv7ZZbrFYinxMmTLF2ic4OLjQ8ldeeaVCtg8AAAC41tk9WCxatEgxMTGaNGmSNm3apHbt2ql79+7KyMgosv/69es1YMAADR8+XJs3b1Z0dLSio6O1bds2a59jx47ZPObMmSOLxaJ+/frZjPX888/b9Bs3blyFbisAAABwrbJ7sJg+fbpGjhypYcOGqVWrVpo1a5Zq1qypOXPmFNn/9ddfV48ePfTkk0+qZcuWeuGFF3TTTTfprbfesvYJCAiweXzxxRfq1q2bGjdubDNW7dq1bfrVqlWrQrcVAAAAuFbZNVicP39eKSkpioqKsrY5ODgoKipKycnJRT4nOTnZpr8kde/evdj+6enp+uqrrzR8+PBCy1555RXVrVtXN954o6ZMmaKLFy8WW2tubq6ys7NtHgAAAAAuqWHPlWdmZiovL0/+/v427f7+/tq5c2eRz0lLSyuyf1paWpH9582bp9q1a6tv37427Y8++qhuuukmeXt7a/369YqNjdWxY8c0ffr0IseJj4/X5MmTS7ppAAAAwHXFrsGiMsyZM0cDBw6Uq6urTXtMTIz1/23btpWzs7NGjx6t+Ph4ubi4FBonNjbW5jnZ2dkKCgqquMIBoBhxcfauoPxErrF3BQCA8mLXYOHj4yNHR0elp6fbtKenpysgIKDI5wQEBJS4//fff6/U1FQtWrToqrWEh4fr4sWLOnDggJo3b15ouYuLS5GBAwAAAICdz7FwdnZWWFiYkpKSrG35+flKSkpSp06dinxOp06dbPpL0sqVK4vs/8EHHygsLEzt2rW7ai1btmyRg4OD/Pz8SrkVAAAAAOx+KFRMTIyGDBmi9u3bq2PHjpoxY4ZycnI0bNgwSdLgwYNVv359xcfHS5Iee+wxRUREaNq0aerdu7c+/vhjbdy4Ue+++67NuNnZ2Vq8eLGmTZtWaJ3Jycn66aef1K1bN9WuXVvJycmaMGGCBg0apDp16lT8RgMAAADXGLsHi/79++v48eOaOHGi0tLSFBoaqsTEROsJ2ocOHZKDw/92rHTu3FkLFy7Uc889p2eeeUbNmjXT0qVL1bp1a5txP/74YxmGoQEDBhRap4uLiz7++GPFxcUpNzdXISEhmjBhgs05FAAAAABKzmIYhmHvIqqj7OxseXp6KisrSx4eHvYuB8B15No6eTvO3iUA1UZkpL0rKIFr6Q8UJJXuPa/db5AHAAAAoPojWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMK2GvQsAAPy/uLgSdYtcU6FVAABQJuyxAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhWJYLFzJkzFRwcLFdXV4WHh2vDhg1X7L948WK1aNFCrq6uatOmjb7++mub5UOHDpXFYrF59OjRw6bPiRMnNHDgQHl4eMjLy0vDhw/X6dOny33bAAAAgOuB3YPFokWLFBMTo0mTJmnTpk1q166dunfvroyMjCL7r1+/XgMGDNDw4cO1efNmRUdHKzo6Wtu2bbPp16NHDx07dsz6+Oijj2yWDxw4UL/++qtWrlyp5cuXa926dRo1alSFbScAAABwLbMYhmHYs4Dw8HB16NBBb731liQpPz9fQUFBGjdunJ5++ulC/fv376+cnBwtX77c2nbzzTcrNDRUs2bNknRpj8XJkye1dOnSIte5Y8cOtWrVSj///LPat28vSUpMTFSvXr3022+/qV69eletOzs7W56ensrKypKHh0dpNxsACouLK1G3NWsqtAoAVVRkpL0rKIES/h1D9VGa97x23WNx/vx5paSkKCoqytrm4OCgqKgoJScnF/mc5ORkm/6S1L1790L916xZIz8/PzVv3lx///vf9fvvv9uM4eXlZQ0VkhQVFSUHBwf99NNPRa43NzdX2dnZNg8AAAAAl9Sw58ozMzOVl5cnf39/m3Z/f3/t3LmzyOekpaUV2T8tLc36dY8ePdS3b1+FhIRo7969euaZZ9SzZ08lJyfL0dFRaWlp8vPzsxmjRo0a8vb2thnnz+Lj4zV58uSybCYAAIBp1WFv5Zq4ihmXHSHVg12DRUV54IEHrP9v06aN2rZtqyZNmmjNmjW6/fbbyzRmbGysYmJirF9nZ2crKCjIdK0AAADAtcCuh0L5+PjI0dFR6enpNu3p6ekKCAgo8jkBAQGl6i9JjRs3lo+Pj/bs2WMd4/KTwy9evKgTJ04UO46Li4s8PDxsHgAAAAAusWuwcHZ2VlhYmJKSkqxt+fn5SkpKUqdOnYp8TqdOnWz6S9LKlSuL7S9Jv/32m37//XcFBgZaxzh58qRSUlKsfVavXq38/HyFh4eb2SQAAADgumT3y83GxMTovffe07x587Rjxw79/e9/V05OjoYNGyZJGjx4sGJjY639H3vsMSUmJmratGnauXOn4uLitHHjRo0dO1aSdPr0aT355JP68ccfdeDAASUlJemee+5R06ZN1b17d0lSy5Yt1aNHD40cOVIbNmzQDz/8oLFjx+qBBx4o0RWhAAAAANiy+zkW/fv31/HjxzVx4kSlpaUpNDRUiYmJ1hO0Dx06JAeH/+Wfzp07a+HChXruuef0zDPPqFmzZlq6dKlat24tSXJ0dNTWrVs1b948nTx5UvXq1dOdd96pF154QS4uLtZxFixYoLFjx+r222+Xg4OD+vXrpzfeeKNyNx4AAAC4Rtj9PhbVFfexAFDuuI8FgGpuTWRchYzLVaHsp9rcxwIAAADAtYFgAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCthr0LAIBC4uLsXQEAACgl9lgAAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADANIIFAAAAANMIFgAAAABMI1gAAAAAMK2GvQsAgNJas8beFQAAgMuxxwIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhWJYLFzJkzFRwcLFdXV4WHh2vDhg1X7L948WK1aNFCrq6uatOmjb7++mvrsgsXLuipp55SmzZtVKtWLdWrV0+DBw/W0aNHbcYIDg6WxWKxebzyyisVsn0AAADAtc7uwWLRokWKiYnRpEmTtGnTJrVr107du3dXRkZGkf3Xr1+vAQMGaPjw4dq8ebOio6MVHR2tbdu2SZLOnDmjTZs26Z///Kc2bdqkJUuWKDU1VXfffXehsZ5//nkdO3bM+hg3blyFbisAAABwrbIYhmHYs4Dw8HB16NBBb731liQpPz9fQUFBGjdunJ5++ulC/fv376+cnBwtX77c2nbzzTcrNDRUs2bNKnIdP//8szp27KiDBw+qYcOGki7tsRg/frzGjx9fprqzs7Pl6emprKwseXh4lGkMAMWIi7viYu68DQBV05rIuAoZ9yovC6hApXnPa9c9FufPn1dKSoqioqKsbQ4ODoqKilJycnKRz0lOTrbpL0ndu3cvtr8kZWVlyWKxyMvLy6b9lVdeUd26dXXjjTdqypQpunjxYrFj5ObmKjs72+YBAAAA4JIa9lx5Zmam8vLy5O/vb9Pu7++vnTt3FvmctLS0IvunpaUV2f/cuXN66qmnNGDAAJuU9eijj+qmm26St7e31q9fr9jYWB07dkzTp08vcpz4+HhNnjy5NJsHAAAAXDfsGiwq2oULF3T//ffLMAy98847NstiYmKs/2/btq2cnZ01evRoxcfHy8XFpdBYsbGxNs/Jzs5WUFBQxRUPAAAAVCN2DRY+Pj5ydHRUenq6TXt6eroCAgKKfE5AQECJ+heEioMHD2r16tVXPSYsPDxcFy9e1IEDB9S8efNCy11cXIoMHAAAAADsfI6Fs7OzwsLClJSUZG3Lz89XUlKSOnXqVORzOnXqZNNfklauXGnTvyBU7N69W6tWrVLdunWvWsuWLVvk4OAgPz+/Mm4NAAAAcP2y+6FQMTExGjJkiNq3b6+OHTtqxowZysnJ0bBhwyRJgwcPVv369RUfHy9JeuyxxxQREaFp06apd+/e+vjjj7Vx40a9++67ki6Fivvuu0+bNm3S8uXLlZeXZz3/wtvbW87OzkpOTtZPP/2kbt26qXbt2kpOTtaECRM0aNAg1alTxz4TAQAAAFRjdg8W/fv31/HjxzVx4kSlpaUpNDRUiYmJ1hO0Dx06JAeH/+1Y6dy5sxYuXKjnnntOzzzzjJo1a6alS5eqdevWkqQjR45o2bJlkqTQ0FCbdX333XeKjIyUi4uLPv74Y8XFxSk3N1chISGaMGGCzTkUAAAAKJ3INXEVM3AFDVsuuBauld3vY1FdcR8LoAJxHwsAwJ9ERtq7giu4xoNFtbmPBQAAAIBrA8ECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmESwAAAAAmEawAAAAAGAawQIAAACAaQQLAAAAAKYRLAAAAACYRrAAAAAAYBrBAgAAAIBpNexdAAAAAHAla9bYu4LirYmr+HXEVcI6ygN7LAAAAACYRrAAAAAAYBrBAgAAAIBpBAsAAAAAphEsAAAAAJhGsAAAAABgGsECAAAAgGkECwAAAACmcYM8oBqqLjfKKavINfauAAAAlBbBojq71t9doli88QYAAFUNh0IBAAAAMI1gAQAAAMA0ggUAAAAA0wgWAAAAAEwjWAAAAAAwjWABAAAAwDSCBQAAAADTCBYAAAAATCNYAAAAADCNYAEAAADAtCoRLGbOnKng4GC5uroqPDxcGzZsuGL/xYsXq0WLFnJ1dVWbNm309ddf2yw3DEMTJ05UYGCg3NzcFBUVpd27d9v0OXHihAYOHCgPDw95eXlp+PDhOn36dLlvGwAAAHA9qGHvAhYtWqSYmBjNmjVL4eHhmjFjhrp3767U1FT5+fkV6r9+/XoNGDBA8fHxuuuuu7Rw4UJFR0dr06ZNat26tSTp1Vdf1RtvvKF58+YpJCRE//znP9W9e3dt375drq6ukqSBAwfq2LFjWrlypS5cuKBhw4Zp1KhRWrhwYaVuP8pmzRp7VwAAAIA/sxiGYdizgPDwcHXo0EFvvfWWJCk/P19BQUEaN26cnn766UL9+/fvr5ycHC1fvtzadvPNNys0NFSzZs2SYRiqV6+eHn/8cT3xxBOSpKysLPn7+yshIUEPPPCAduzYoVatWunnn39W+/btJUmJiYnq1auXfvvtN9WrV++qdWdnZ8vT01NZWVny8PAoj6kovbg4+6y3CiBYAACAqmBNZFyFr8Oeb/lK857Xrnsszp8/r5SUFMXGxlrbHBwcFBUVpeTk5CKfk5ycrJiYGJu27t27a+nSpZKk/fv3Ky0tTVFRUdblnp6eCg8PV3Jysh544AElJyfLy8vLGiokKSoqSg4ODvrpp5907733Flpvbm6ucnNzrV9nZWVJujTZ9vL9qtyrdwIAAECFyc2t+PeCdny7aX2vW5J9EXYNFpmZmcrLy5O/v79Nu7+/v3bu3Fnkc9LS0orsn5aWZl1e0HalPpcfZlWjRg15e3tb+1wuPj5ekydPLtQeFBRU3OYBAADgWvfDKxW+ilcqfhVXderUKXl6el6xj93PsaguYmNjbfaU5Ofn68SJE6pbt64sFosdKytadna2goKCdPjwYfsdqlWNMX/mMYfmMYfmMYfmMH/mMYfmMYfmmZlDwzB06tSpEp0qYNdg4ePjI0dHR6Wnp9u0p6enKyAgoMjnBAQEXLF/wb/p6ekKDAy06RMaGmrtk5GRYTPGxYsXdeLEiWLX6+LiIhcXF5s2Ly+vK29gFeDh4cEvoQnMn3nMoXnMoXnMoTnMn3nMoXnMoXllncOr7akoYNfLzTo7OyssLExJSUnWtvz8fCUlJalTp05FPqdTp042/SVp5cqV1v4hISEKCAiw6ZOdna2ffvrJ2qdTp046efKkUlJSrH1Wr16t/Px8hYeHl9v2AQAAANcLux8KFRMToyFDhqh9+/bq2LGjZsyYoZycHA0bNkySNHjwYNWvX1/x8fGSpMcee0wRERGaNm2aevfurY8//lgbN27Uu+++q/9r725jmrrbMIBfVSkCAhMUWdeULUFB3AAxROkcTFmwxmwoJLIs29xmlMVWAyYsm/Mt0wQ/sDeVyLJNN+OI8yWtVWPViRSW4eaMRDEIE01IBMYWg8iLW2P/+7CHKtDa+pzZcwrXL+GD7TG5uFK8vU8PpwCgUqlQVFSErVu3YurUqa7bzWo0GixevBgAMH36dBgMBqxYsQIVFRVwOBwwmUx49dVXfXqbh4iIiIiIBpN9sSgoKMAff/yBjRs3oqOjA6mpqbDZbK5fvm5tbcWYMfffWNHr9aisrMT69euxbt06TJ06FRaLxfUZFgDw3nvvobe3FytXrkRXVxfmzp0Lm83m+gwLAPjuu+9gMpmQnZ2NMWPGID8/H9u3b/ffN/6YBQcHY9OmTcMu3yLfsD/p2KF07FA6digN+5OOHUrHDqXzV4eyf44FEREREREFPll/x4KIiIiIiEYGLhZERERERCQZFwsiIiIiIpKMiwUREREREUnGxSKA1dTU4OWXX4ZGo4FKpYLFYhl2TGNjI1555RVERkYiLCwM6enpaG1t9X9YhfLWYU9PD0wmE7RaLUJCQpCUlISKigp5wipQaWkp0tPTER4ejpiYGCxevBhNTU2Djrl79y6MRiOio6MxYcIE5OfnD/uQy9HMW4e3bt3C6tWrkZCQgJCQEOh0OqxZswa3b9+WMbWy+PI6HCCEwMKFCz3+mzla+dphXV0d5s+fj7CwMERERCAzMxP9/f0yJFYWX/rr6OjAG2+8gdjYWISFhSEtLQ2HDx+WKbHy7Nq1C8nJya4PcMvIyMCJEydcz3OWePewDv01S7hYBLDe3l6kpKSgvLzc7fMtLS2YO3cuEhMTUV1djUuXLmHDhg2Dbrs72nnrcO3atbDZbNi3bx8aGxtRVFQEk8kEq9Xq56TKZLfbYTQace7cOZw+fRoOhwM5OTno7e11HVNcXIyjR4/i4MGDsNvtaGtrQ15enoyplcVbh21tbWhra0NZWRkaGhrwzTffwGazYfny5TInVw5fXocDPvvsM6hUKhlSKpsvHdbV1cFgMCAnJwe//PILzp8/D5PJNOiW8KOVL/29+eabaGpqgtVqxeXLl5GXl4elS5fi4sWLMiZXDq1Wi23btuHChQv49ddfMX/+fOTm5uLKlSsAOEt88bAO/TZLBI0IAITZbB70WEFBgXj99dflCRSA3HU4Y8YM8dFHHw16LC0tTXz44Yd+TBY4Ojs7BQBht9uFEEJ0dXWJoKAgcfDgQdcxjY2NAoCoq6uTK6aiDe3QnQMHDgi1Wi0cDocfkwUOTx1evHhRPPXUU6K9vd3tzzvd567D2bNni/Xr18uYKnC46y8sLEzs3bt30HFRUVHiyy+/9He8gDFx4kTx1VdfcZZIMNChO49jlvA0wwjldDpx/PhxTJs2DQsWLEBMTAxmz57Nt/4fkV6vh9Vqxc2bNyGEwNmzZ9Hc3IycnBy5oynSwFuqUVFRAIALFy7A4XDgpZdech2TmJgInU6Huro6WTIq3dAOPR0TERGBceNk/4xTRXLXYV9fH1577TWUl5cjNjZWrmgBY2iHnZ2d+PnnnxETEwO9Xo8pU6YgKysLP/74o5wxFcvda1Cv1+P777/HrVu34HQ6sX//fty9excvvviiTCmV6969e9i/fz96e3uRkZHBWfJ/GNqhO49jlnCxGKE6OzvR09ODbdu2wWAw4NSpU1iyZAny8vJgt9vljhcwduzYgaSkJGi1WqjVahgMBpSXlyMzM1PuaIrjdDpRVFSE559/Hs8++yyAf68pVqvVeOKJJwYdO2XKFHR0dMiQUtncdTjUn3/+iS1btmDlypV+ThcYPHVYXFwMvV6P3NxcGdMFBncdXr9+HQCwefNmrFixAjabDWlpacjOzsZvv/0mZ1zF8fQaPHDgABwOB6KjoxEcHIzCwkKYzWbEx8fLmFZZLl++jAkTJiA4OBjvvvsuzGYzkpKSOEsegacOh3pcs4Snu0Yop9MJAMjNzUVxcTEAIDU1FT/99BMqKiqQlZUlZ7yAsWPHDpw7dw5WqxVxcXGoqamB0WiERqMZdOaEAKPRiIaGBp7BlMBbh93d3Vi0aBGSkpKwefNm/4YLEO46tFqtqKqq4rXsPnLX4cBMKSwsxNtvvw0AmDlzJs6cOYPdu3ejtLRUlqxK5OnneMOGDejq6sIPP/yASZMmwWKxYOnSpaitrcVzzz0nU1plSUhIQH19PW7fvo1Dhw5h2bJlPBn6iDx1+OBy8ThnCReLEWrSpEkYN27csC11+vTp/I+fj/r7+7Fu3TqYzWYsWrQIAJCcnIz6+nqUlZVxsXiAyWTCsWPHUFNTA61W63o8NjYWf//9N7q6ugadafr99995OcoQnjoccOfOHRgMBoSHh8NsNiMoKEiGlMrmqcOqqiq0tLQMO9uZn5+PF154AdXV1f4NqmCeOnzyyScBwO1M4Z0G7/PUX0tLC3bu3ImGhgbMmDEDAJCSkoLa2lqUl5fzboP/o1arXe/gzJo1C+fPn8fnn3+OgoICzhIfeerwiy++APD4ZwkvhRqh1Go10tPTh93urrm5GXFxcTKlCiwOhwMOh2PYHU/Gjh3rOns32gkhYDKZYDabUVVVhWeeeWbQ87NmzUJQUBDOnDnjeqypqQmtra0er/kcbbx1CPx7diknJwdqtRpWq5V3dhvCW4fvv/8+Ll26hPr6etcXAHz66afYs2ePDImVx1uHTz/9NDQaDWeKB9766+vrAwDOk0fkdDrx119/cZZIMNAh4J9ZwncsAlhPTw+uXbvm+vONGzdQX1+PqKgo6HQ6lJSUoKCgAJmZmZg3bx5sNhuOHj3Ks3MP8NZhVlYWSkpKEBISgri4ONjtduzduxeffPKJjKmVw2g0orKyEkeOHEF4eLjrWtfIyEiEhIQgMjISy5cvx9q1axEVFYWIiAisXr0aGRkZmDNnjszplcFbhwODoK+vD/v27UN3dze6u7sBAJMnT8bYsWPljK8I3jqMjY11e1ZTp9O5XeRGI28dqlQqlJSUYNOmTUhJSUFqaiq+/fZbXL16FYcOHZI5vfy89ZeYmIj4+HgUFhairKwM0dHRsFgsOH36NI4dOyZzemX44IMPsHDhQuh0Oty5cweVlZWorq7GyZMnOUt89LAO/TZL/rP7S5HfnT17VgAY9rVs2TLXMV9//bWIj48X48ePFykpKcJiscgXWIG8ddje3i7eeustodFoxPjx40VCQoL4+OOPhdPplDe4QrjrDoDYs2eP65j+/n6xatUqMXHiRBEaGiqWLFki2tvb5QutMN469PQaBSBu3Lgha3al8OV16O7v8Haz9/naYWlpqdBqtSI0NFRkZGSI2tpaeQIrjC/9NTc3i7y8PBETEyNCQ0NFcnLysNvPjmbvvPOOiIuLE2q1WkyePFlkZ2eLU6dOuZ7nLPHuYR36a5aohBDiv1lRiIiIiIhotOLvWBARERERkWRcLIiIiIiISDIuFkREREREJBkXCyIiIiIikoyLBRERERERScbFgoiIiIiIJONiQUREREREknGxICIiIiIiybhYEBERERGRZFwsiIiIiIhIMi4WREREREQkGRcLIiIiIiKS7B/UECHaDtbK8QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAMWCAYAAABsvhCnAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbyVJREFUeJzt3Xd8VFX+//H3JJACpEAIJEggISAEkSJNBAwgyAIiZVFQwMBSVECX5irqkoAiuojiigKiJoqIrMiqq0hVYNdGV6S3QKRFBBJqIMn5/eE382NIYZKbzKS8no/HPHTO3Ln3c+fMDPede88ZmzHGCAAAAAAs8HB3AQAAAABKPoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBYBSLTExUTabTQkJCe4uxcHy5cvVtGlT+fj4yGaz6ezZs+4uqdDNmDFDderUkaenp5o2beqy7cbFxclmszm0hYeHa8iQIS6rwVlDhgxRpUqVnFrWZrMpLi7Ofj8hIUE2m02JiYn2tg4dOqhDhw6FW2QpU1zfC0BpQLAA4JSsg5hrb9WqVVPHjh311VdfubyetWvXOtRSvnx51alTRw899JAOHjxYKNv47rvvFBcXV+gH/b///rvuv/9++fr66o033tCCBQtUsWLFQt1GXt58880iD1orV67U3/72N7Vt21bx8fF64YUXinR77nDs2DHFxcVp27Zt7i4lVyWhRgClRzl3FwCgZJk6daoiIiJkjNHJkyeVkJCg7t276z//+Y/uuecel9fz+OOPq2XLlrp69aq2bNmit956S19++aW2b9+uGjVqWFr3d999pylTpmjIkCEKDAwsnIIlbdy4UefOndNzzz2nzp07F9p6nfXmm2+qatWqRfpX26+//loeHh5655135OXlVWTbycmzzz6rp556qsi3c+zYMU2ZMkXh4eEuOSNz6dIllSuX9z/bK1eudLjv6hpLgj179sjDg7+rAkWBYAEgX7p166YWLVrY7w8bNkzVq1fXokWL3BIs2rdvr379+kmShg4dqptvvlmPP/643nvvPU2aNMnl9TgjOTlZkgo1rBQ3ycnJ8vX1LZRQceHChXyd0SlXrtwND8BLIh8fnxsu4+oQ527p6enKzMzM1357e3sXYUVA2UZkB2BJYGCgfH19sx3IXbhwQRMmTFBYWJi8vb1Vv359vfzyyzLGSPrjr68NGjRQgwYNdOnSJfvzTp8+rdDQUN1xxx3KyMjIdz2dOnWSJB06dCjP5b7++mu1b99eFStWVGBgoHr16qVdu3bZH4+Li9MTTzwhSYqIiLBfcnXt9ew5+fjjj9W8eXP5+vqqatWqGjRokI4ePWp/vEOHDoqJiZEktWzZUjab7YZnDrZu3apu3brJ399flSpV0l133aUffvjBYZmcxhVI2a/DDw8P144dO7Ru3Tr7PuXnmvz09HQ999xzioyMlLe3t8LDw/X0008rLS3NvozNZlN8fLwuXLhg34azl15ljTk4cOCAunfvLj8/Pw0cOFCS9N///lf33XefatWqJW9vb4WFhWncuHEO75+8Xov8WrVqldq1a6fAwEBVqlRJ9evX19NPPy3pj0vxWrZsKemPQHv9fjpba5aDBw+qa9euqlixomrUqKGpU6faPytZrh9jkZNrx1jkVWNsbKzKly+v3377Lds6Ro4cqcDAQF2+fNmp1ynr9d67d68GDRqkgIAABQcH6+9//7uMMUpKSlKvXr3k7++vkJAQzZw50+H5V65c0eTJk9W8eXMFBASoYsWKat++vb755huH5bLGS7388suaNWuW/T24c+dO+/62aNFCPj4+ioyM1Lx585wab5P1Gfn22281fvx4BQcHq2LFiurTp0+Orw+A3JW+P+kAKFIpKSk6deqUjDFKTk7W66+/rvPnz2vQoEH2ZYwxuvfee/XNN99o2LBhatq0qVasWKEnnnhCR48e1auvvipfX1+99957atu2rZ555hm98sorkqTRo0crJSVFCQkJ8vT0zHd9Bw4ckCQFBQXluszq1avVrVs31alTR3Fxcbp06ZJef/11tW3bVlu2bFF4eLj69u2rvXv3atGiRXr11VdVtWpVSVJwcHCu601ISNDQoUPVsmVLTZ8+XSdPntRrr72mb7/9Vlu3blVgYKCeeeYZ1a9fX2+99Zb9srLIyMhc17ljxw61b99e/v7++tvf/qby5ctr3rx56tChg9atW6fWrVvn6/WZNWuWHnvsMVWqVEnPPPOMJKl69epOP3/48OF677331K9fP02YMEE//vijpk+frl27dunf//63JGnBggV66623tGHDBr399tuSpDvuuMPpbaSnp6tr165q166dXn75ZVWoUEHSH6Ht4sWLevTRRxUUFKQNGzbo9ddf16+//qqPP/7Y6fU7Y8eOHbrnnnvUuHFjTZ06Vd7e3tq/f7++/fZbSVJUVJSmTp2qyZMna+TIkWrfvr3Dfuan1oyMDP3pT3/S7bffrn/84x9avny5YmNjlZ6erqlTpxZ4H/KqsV27dpo6daoWL16sMWPG2J9z5coVLVmyRH/+85+dOkNyrf79+ysqKkovvviivvzySz3//POqUqWK5s2bp06dOumll17SwoULNXHiRLVs2VJ33nmnJCk1NVVvv/22HnjgAY0YMULnzp3TO++8o65du2rDhg3ZLuGKj4/X5cuXNXLkSHl7e6tKlSraunWr/vSnPyk0NFRTpkxRRkaGpk6dmufn9XqPPfaYKleurNjYWCUmJmrWrFkaM2aMFi9enK/XASjTDAA4IT4+3kjKdvP29jYJCQkOy3766adGknn++ecd2vv162dsNpvZv3+/vW3SpEnGw8PDrF+/3nz88cdGkpk1a9YN6/nmm2+MJPPuu++a3377zRw7dsx8+eWXJjw83NhsNrNx40ZjjDGHDh0ykkx8fLz9uU2bNjXVqlUzv//+u73tp59+Mh4eHuahhx6yt82YMcNIMocOHbphPVeuXDHVqlUzjRo1MpcuXbK3f/HFF0aSmTx5sr0t67XMqjEvvXv3Nl5eXubAgQP2tmPHjhk/Pz9z55132ttiY2NNTl/pWdu6dh9uueUWEx0dfcNtX2/btm1Gkhk+fLhD+8SJE40k8/XXX9vbYmJiTMWKFfO9jZiYGCPJPPXUU9keu3jxYra26dOnG5vNZg4fPmxvy+m1qF27tomJiXG6jldffdVIMr/99luuy2zcuDHbeyu/tWbt72OPPWZvy8zMND169DBeXl4O25dkYmNj7fdz6tvo6GiHvs2rxjZt2pjWrVs7tC1dutRIMt98802u+329rNd75MiR9rb09HRTs2ZNY7PZzIsvvmhvP3PmjPH19XXoi/T0dJOWluawzjNnzpjq1aubv/zlL/a2rM+yv7+/SU5Odli+Z8+epkKFCubo0aP2tn379ply5crd8L2Q9Tp27tzZZGZm2tvHjRtnPD09zdmzZ51+LYCyjkuhAOTLG2+8oVWrVmnVqlX64IMP1LFjRw0fPlxLly61L7Ns2TJ5enrq8ccfd3juhAkTZIxxmEUqLi5Ot9xyi2JiYjRq1ChFR0dne15e/vKXvyg4OFg1atRQjx49dOHCBb333nsO40Cudfz4cW3btk1DhgxRlSpV7O2NGzdWly5dtGzZMqe3fa1NmzYpOTlZo0aNcvhLb48ePdSgQQN9+eWX+V5nRkaGVq5cqd69e6tOnTr29tDQUD344IP63//+p9TU1ALVWxBZr8348eMd2idMmCBJBdrH3Dz66KPZ2nx9fe3/f+HCBZ06dUp33HGHjDHaunVroW1b+v/jXz777DNlZmbm+/n5rfXaswY2m01jxozRlStXtHr16vwX76SHHnpIP/74o/0snyQtXLhQYWFhio6Ozvf6hg8fbv9/T09PtWjRQsYYDRs2zN4eGBio+vXrO8zc5unpaR8jkZmZqdOnTys9PV0tWrTQli1bsm3nz3/+s8OZiIyMDK1evVq9e/d2mLChbt266tatm9P1jxw50uGyqfbt2ysjI0OHDx92eh1AWUewAJAvrVq1UufOndW5c2cNHDhQX375pRo2bGg/EJKkw4cPq0aNGvLz83N4blRUlP3xLF5eXnr33Xd16NAhnTt3TvHx8fm6Pn7y5MlatWqVvv76a/388886duyYBg8enOvyWduuX79+tseioqJ06tQpXbhwwentO7PeBg0aFOjg5LffftPFixdzrTUzM1NJSUn5Xm9BHT58WB4eHqpbt65De0hIiAIDAwvtAKxcuXKqWbNmtvYjR47YA2GlSpUUHBxsPwBOSUkplG1n6d+/v9q2bavhw4erevXqGjBggP71r385HTLyU6uHh4dDcJSkm2++WZJuOKbHiv79+8vb21sLFy601/XFF19o4MCBBRqjUqtWLYf7AQEB8vHxsV9GeG37mTNnHNree+89NW7cWD4+PgoKClJwcLC+/PLLHPs1IiLC4X5ycrIuXbqU7X0pKcc2Z+uvXLmyJGWrFUDuCBYALPHw8FDHjh11/Phx7du3r0DrWLFihSTp8uXL+V7Hrbfeqs6dO6tjx4669dZbS+VsQM7I7UCwIAPgC7qtwuLt7Z1tOtCMjAx16dJFX375pZ588kl9+umnWrVqlX2wdEHOKuTF19dX69ev1+rVqzV48GD9/PPP6t+/v7p06XLD19TVtRZU5cqVdc8999iDxZIlS5SWluYwXio/choTlds4KXPNwPQPPvhAQ4YMUWRkpN555x0tX75cq1atUqdOnXJ8ra49G1SYnKkVQN4IFgAsS09PlySdP39eklS7dm0dO3ZM586dc1hu9+7d9sez/Pzzz5o6daqGDh2qZs2aafjw4YX+1+drZW17z5492R7bvXu3qlatap/aND8H0Hmtd8+ePQ777Kzg4GBVqFAh11o9PDwUFhYm6f//dfX6H/PL6SxCQYNB7dq1lZmZmS38nTx5UmfPni3QPjpr+/bt2rt3r2bOnKknn3xSvXr1UufOnS3/VklePDw8dNddd+mVV17Rzp07NW3aNH399df22Ypyex3zW2tmZma2H3Xcu3evpD9mMLLiRn390EMPae/evdq4caMWLlyoZs2a6ZZbbrG0zfxasmSJ6tSpo6VLl2rw4MHq2rWrOnfu7PSsVNWqVZOPj4/279+f7bGc2gAUHYIFAEuuXr2qlStXysvLy36pU/fu3ZWRkaHZs2c7LPvqq6/KZrPZr3u+evWqhgwZoho1aui1115TQkKCTp48qXHjxhVZvaGhoWratKnee+89h4PwX375RStXrlT37t3tbVkBw5lf3m7RooWqVaumuXPnOky9+tVXX2nXrl3q0aNHvmv19PTU3Xffrc8++8zhkpiTJ0/qww8/VLt27eTv7y9J9pml1q9fb18ua7zJ9SpWrFigXxPPem1mzZrl0J41o1dB9tFZWX9Nvvavx8YYvfbaa0WyvdOnT2dry5qdKKt/c3t/FKTWaz8rxhjNnj1b5cuX11133VWg+rPc6D3crVs3Va1aVS+99JLWrVtX4LMVVuT0ev3444/6/vvvnX5+586d9emnn+rYsWP29v379zuM5wJQ9MrmNQMACuyrr76yn3lITk7Whx9+qH379umpp56yH+T27NlTHTt21DPPPKPExEQ1adJEK1eu1GeffaaxY8faD4Kff/55bdu2TWvWrJGfn58aN26syZMn69lnn1W/fv0cDvIL04wZM9StWze1adNGw4YNs083GxAQ4PA7Ac2bN5ckPfPMMxowYIDKly+vnj175vhjbeXLl9dLL72koUOHKjo6Wg888IB9utnw8PACh6Xnn3/e/nsKo0aNUrly5TRv3jylpaXpH//4h325u+++W7Vq1dKwYcP0xBNPyNPTU++++66Cg4N15MgRh3U2b95cc+bM0fPPP6+6deuqWrVq9t//yEuTJk0UExOjt956S2fPnlV0dLQ2bNig9957T71791bHjh0LtI/OaNCggSIjIzVx4kQdPXpU/v7++uSTT4rs+vepU6dq/fr16tGjh2rXrq3k5GS9+eabqlmzptq1ayfpjzAXGBiouXPnys/PTxUrVlTr1q3zXauPj4+WL1+umJgYtW7dWl999ZW+/PJLPf300/maLjUnudWYNU6hfPnyGjBggGbPni1PT0898MADlrZXEPfcc4+WLl2qPn36qEePHjp06JDmzp2rhg0b2s+C3khcXJxWrlyptm3b6tFHH7X/YaNRo0batm1b0e4AgP/PPZNRAShpcppu1sfHxzRt2tTMmTPHYZpGY4w5d+6cGTdunKlRo4YpX768qVevnpkxY4Z9uc2bN5ty5co5TLNpzB9TT7Zs2dLUqFHDnDlzJtd6sqab/fjjj/OsO6fpZo0xZvXq1aZt27bG19fX+Pv7m549e5qdO3dme/5zzz1nbrrpJuPh4eHU1LOLFy82zZo1M97e3qZKlSpm4MCB5tdff3VYJj/TzRpjzJYtW0zXrl1NpUqVTIUKFUzHjh3Nd999l225zZs3m9atWxsvLy9Tq1Yt88orr+Q4JemJEydMjx49jJ+fn5GUr6lnr169aqZMmWIiIiJM+fLlTVhYmJk0aZK5fPmyw3JWppvN7Xk7d+40nTt3NpUqVTJVq1Y1I0aMMD/99FO2/i2M6WbXrFljevXqZWrUqGG8vLxMjRo1zAMPPGD27t3rsNxnn31mGjZsaJ/WNKsOZ2vN2t8DBw6Yu+++21SoUMFUr17dxMbGmoyMDIdtqQDTzeZVY5YNGzYYSebuu+92+vW5Vtbrff3UvLn1ZXR0tLnlllvs9zMzM80LL7xgateubby9vU2zZs3MF198YWJiYkzt2rXty2V9lmfMmJFjHWvWrDHNmjUzXl5eJjIy0rz99ttmwoQJxsfHx2G53Kabvf7zmPUdk5+pd4GyzmYMo5IAACirfvrpJzVt2lTvv/9+njOqlUS9e/fWjh07CjyxBID8YYwFAABl2Pz581WpUiX17dvX3aVYcunSJYf7+/bt07Jly9ShQwf3FASUQYyxAADoxIkTeT7u6+urgICAAq8/JSUl24Hf9UJCQgq8/vwo6n0tKf7zn/9o586deuuttzRmzJhsY4fOnz9/wzEOwcHBuU7T6mp16tTRkCFDVKdOHR0+fFhz5syRl5eX/va3v7m7NKDM4FIoAMANpyWNiYmx/w5DQQwZMiTHGaqu5ap/jop6X0uK8PBwnTx5Ul27dtWCBQuy/aBlXFycpkyZkuc6Dh06ZHlK3MIydOhQffPNNzpx4oS8vb3Vpk0bvfDCC7rtttvcXRpQZhAsAABavXp1no/XqFFDDRs2LPD6d+7c6TAVaE46d+5c4PXnR1Hva2lx8ODBbL+vcb127drJx8fHRRUBKO4IFgAAAAAsY/A2AAAAAMsYvO2EzMxMHTt2TH5+fje8NhcAAAAoLYwxOnfunGrUqCEPj7zPSRAsnHDs2DGFhYW5uwwAAADALZKSklSzZs08lyFYOCFrpoykpCT5+/u7uRoAAADANVJTUxUWFpZt5ricECyckHX5k7+/P8ECAAAAZY4zwwEYvA0AAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwrJy7CwCAsuLIkSM6deqUu8tACVK1alXVqlXL3WUAgFNcGiwSExMVERGhrVu3qmnTpk49JyEhQWPHjtXZs2fdWgcAWHHkyBHVrx+ly5cvuruUYiukkk0PN/fSvM1XdOK8cXc5xYKPTwXt2bOLcAGgRChQsEhKSlJsbKyWL1+uU6dOKTQ0VL1799bkyZMVFBSU6/PCwsJ0/PhxVa1a1elt9e/fX927dy9ImaVCRkaG/vvf/+r48eMKDQ1V+/bt5enp6e6yAOTTqVOn/i9UfCApyt3lFEuhlfYqrsPD+nxPgk6cv9nd5RQDu3T58iCdOnWKYAFYkN9jqeJ07FWcanFGvoPFwYMH1aZNG918881atGiRIiIitGPHDj3xxBP66quv9MMPP6hKlSrZnnflyhV5eXkpJCQkX9vz9fWVr69vfsssFZYuXaoJEyYoMTHR3hYeHq6ZM2eqb9++7ivsOhcvXtTu3bvVoEEDVahQwd3lAMVclKTb3F1EMZU17K+BpKZurANASXX9MUl+j6WK07FXcarFWfkevD169Gh5eXlp5cqVio6OVq1atdStWzetXr1aR48e1TPPPCPpjx1/7rnn9NBDD8nf318jR45UYmKibDabtm3bZl/f559/rnr16snHx0cdO3bUe++9J5vNZr/0KSEhQYGBgfbl4+Li1LRpUy1YsEDh4eEKCAjQgAEDdO7cOfsyy5cvV7t27RQYGKigoCDdc889OnDgQMFeITdZunSp+vXrp1tvvVXff/+9zp07p++//1633nqr+vXrp6VLl7q7RLvdu3erefPm2r17t7tLAQAAZdi1xyT5PZYqTsdexamWfDH58PvvvxubzWZeeOGFHB8fMWKEqVy5ssnMzDS1a9c2/v7+5uWXXzb79+83+/fvN4cOHTKSzNatW40xxhw8eNCUL1/eTJw40ezevdssWrTI3HTTTUaSOXPmjDHGmPj4eBMQEGDfRmxsrKlUqZLp27ev2b59u1m/fr0JCQkxTz/9tH2ZJUuWmE8++cTs27fPbN261fTs2dPceuutJiMjwxhjstVxIykpKUaSSUlJyc/LVWDp6ekmPDzc9OzZ015zloyMDNOzZ08TERFh0tPTXVLPjWzevNlIMps3b3Z3KUCxlfU5kTYbyXDL4dYsZKsxsf6mWchWt9dSPG58twL5lfVdu2HDhnwdSxWnY6/iVIsx+TsOztelUPv27ZMxRlFROV8fHBUVpTNnzui3336TJHXq1EkTJkywP37tqRxJmjdvnurXr68ZM2ZIkurXr69ffvlF06ZNy7OOzMxMJSQkyM/PT5I0ePBgrVmzxv68P//5zw7Lv/vuuwoODtbOnTvVqFGjG+5nWlqa0tLS7PdTU1Nv+JzC9N///leJiYlatGiRPDwcTyp5eHho0qRJuuOOO/Tf//5XHTp0cGltObl06ZIkadeuXW6uBCi+/v/n45Jb60BJwncrkF9Zn5cffvghX8dSxenYqzjVkl8FGrxtjHFquRYtWuT5+J49e9SyZUuHtlatWt1wveHh4fZQIUmhoaFKTk6239+3b58mT56sH3/8UadOnVJmZqakP2ZlcSZYTJ8+XVOmTLnhckXl+PHjkpRrrVntWcu5W1ZgHDRokHsLAUqERElt3V0ESoRESXy3AgWRdXm2s8dSxenYqzjVkl/5ChZ169aVzWbTrl271KdPn2yP79q1S5UrV1ZwcLAkqWLFioVT5XXKly/vcN9ms9nDgyT17NlTtWvX1vz581WjRg1lZmaqUaNGunLlilPrnzRpksaPH2+/n5qaqrCwsMIp3gmhoaGSpF9++UW33357tsd/+eUXh+XcLTw8XJL0wQcf5Ho2Cyjrdu3a9X8HiOHuLgUlRrgkvluB/Mj6rm3QoIEk54+litOxV3GqJb/yFSyCgoLUpUsXvfnmmxo3bpzDbE0nTpzQwoUL9dBDD8lmszm1vvr162vZsmUObRs3bsxPSdn8/vvv2rNnj+bPn6/27dtLkv73v//lax3e3t7y9va2VIcV7du3V3h4uF544QV9+umnDqfBMjMzNX36dEVERNj3z92y3gdRUVG67TZmuwHyVjZnuUNB8N0KFNTtt9+er2Op4nTsVZxqya98zwo1e/ZspaWlqWvXrlq/fr2SkpK0fPlydenSRTfddNMNx0dc6+GHH9bu3bv15JNPau/evfrXv/6lhIQESXI6nFyvcuXKCgoK0ltvvaX9+/fr66+/djj7UBJ4enpq5syZ+uKLL9S7d2+H2QB69+6tL774Qi+//HKxnscYAADAXfJ7LFWcjr2KUy35le9gUa9ePW3atEl16tTR/fffr8jISI0cOVIdO3bU999/n+NvWOQmIiJCS5Ys0dKlS9W4cWPNmTPHPl1tQc8YeHh46KOPPtLmzZvVqFEjjRs3zj44vCTp27evlixZou3bt+uOO+6Qv7+/7rjjDv3yyy9asmRJsZq/uEGDBtq8ebP9tCMAAIA7XHtMkt9jqeJ07FWcaskPm3F2JLaLTJs2TXPnzlVSUpK7S7FLTU1VQECAUlJS5O/v79Jtl7RfXASQsy1btqh58+bil7dz1yxkr7Y8/LBumzdPW0/wy9vSLkmDtHnzZi6FAizgl7etyc9xcIFmhSpMb775plq2bKmgoCB9++23mjFjhsaMGePusooNT0/PYjeVGID8q1q1qnx8KujyZWb4yc3x8zbFrfXS8fMPSipWf/NyGx+fCqpataq7ywBKtPweSxWnY6/iVIsz3B4s9u3bp+eff16nT59WrVq1NGHCBE2aNMndZQFAoapVq5b27NmlU6dOubuUYu9edxdQjFStWlW1atVydxkA4JRidylUceTOS6EAAAAAd8nPcXC+B28DAAAAwPUIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwr5+4CAODIkSM6deqUu8tAGVO1alXVqlXL3WUAQKlBsADgVkeOHFFU/fq6ePmyu0sp1UIq2fRwcy/N23xFJ84bd5dTLFTw8dGuPXsIFwBQSEpMsEhISNDYsWN19uxZd5cCoBCdOnVKFy9f1geSotxdTCnmW8mmqA7e6r/nqi4RLLRL0qDLl3Xq1CmCBQAUEpcHi6SkJMXGxmr58uU6deqUQkND1bt3b02ePFlBQUGSpPDwcI0dO1Zjx451dXkA3CRK0m3uLqIMILwBAIqKSwdvHzx4UC1atNC+ffu0aNEi7d+/X3PnztWaNWvUpk0bnT592pXlSJKuXr3q8m2WRhcvXtSWLVt08eJFd5cCAECJwL+dKG1cGixGjx4tLy8vrVy5UtHR0apVq5a6deum1atX6+jRo3rmmWfUoUMHHT58WOPGjZPNZpPNZnNYx4oVKxQVFaVKlSrpT3/6k44fP+7w+Ntvv62oqCj5+PioQYMGevPNN+2PJSYmymazafHixYqOjpaPj48WLlzokn0v7Xbv3q3mzZtr9+7d7i4FAIASgX87Udq47FKo06dPa8WKFZo2bZp8fX0dHgsJCdHAgQO1ePFi7du3T02bNtXIkSM1YsQIh+UuXryol19+WQsWLJCHh4cGDRqkiRMn2sPBwoULNXnyZM2ePVvNmjXT1q1bNWLECFWsWFExMTH29Tz11FOaOXOmmjVrJh8fn6LfeQAAAKCUc1mw2Ldvn4wxiorK+QrfqKgonTlzRhkZGfL09JSfn59CQkIclrl69armzp2ryMhISdKYMWM0depU++OxsbGaOXOm+vbtK0mKiIjQzp07NW/ePIdgMXbsWPsyOUlLS1NaWpr9fmpqav53uIy5dOmSJGnXrl1urgQlTdZ75pKb60DZkvV+4zsL7mT//rvENyBKB5cP3jam4LORVKhQwR4qJCk0NFTJycmSpAsXLujAgQMaNmyYw5mO9PR0BQQEOKynRYsWeW5n+vTpmjJlSoHrLIsSExMlSYMGDXJvISixEiW1dXcRKDMS/++/fGehOEhMTFTbtnwDouRzWbCoW7eubDabdu3apT59+mR7fNeuXapcubKCg4NzXUf58uUd7ttsNntQOX/+vCRp/vz5at26tcNynp6eDvcrVqyYZ62TJk3S+PHj7fdTU1MVFhaW53PKuvDwcEnSBx98kOtZKSAnu3bt0qBBgxTu7kJQpoT/33/5zoI72b///u/fUKCkc1mwCAoKUpcuXfTmm29q3LhxDuMsTpw4oYULF+qhhx6SzWaTl5eXMjIy8rX+6tWrq0aNGjp48KAGDhxoqVZvb295e3tbWkdZk9WfUVFRuu02Jg1F/vneeBGg0GS93/jOQnFw/dhToKRy6axQs2fPVlpamrp27ar169crKSlJy5cvV5cuXXTTTTdp2rRpkv746/f69et19OhRnTp1yun1T5kyRdOnT9c///lP7d27V9u3b1d8fLxeeeWVotolAAAAAHJxsKhXr542bdqkOnXq6P7771dkZKRGjhypjh076vvvv1eVKlUkSVOnTlViYqIiIyPzvDTqesOHD9fbb7+t+Ph43XrrrYqOjlZCQoIiIiKKapfwfxo0aKDNmzerQYMG7i4FAIASgX87UdrYjJXR1GVEamqqAgIClJKSIn9/f3eXA5QqW7ZsUfPmzfWB+FXoouQb4qGohytp17zzunQi093luN0uSYMkbd68mUuhACAP+TkOdvmsUABwrapVq6qCj48GXb7s7lJKtZDzRg+vTdO880Yn3F1MMVHBx0dVq1Z1dxkAUGoQLAC4Va1atbRrz558jadCwd3r7gKKkapVq6pWrVruLgMASg2CBQC3q1WrFgd4AACUcC4dvA0AAACgdCJYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMCycu4uoCQwxkiSUlNT3VwJAAAA4DpZx79Zx8N5IVg44dy5c5KksLAwN1cCAAAAuN65c+cUEBCQ5zI240z8KOMyMzN17Ngx+fn5yWazFWgdqampCgsLU1JSkvz9/Qu5QhQX9HPZQD+XDfRz2UA/l370sTXGGJ07d041atSQh0feoyg4Y+EEDw8P1axZs1DW5e/vz5u6DKCfywb6uWygn8sG+rn0o48L7kZnKrIweBsAAACAZQQLAAAAAJYRLFzE29tbsbGx8vb2dncpKEL0c9lAP5cN9HPZQD+XfvSx6zB4GwAAAIBlnLEAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsCgE06dPV8uWLeXn56dq1aqpd+/e2rNnj9PP/+ijj2Sz2dS7d++iKxKWFaSfExISZLPZHG4+Pj4uqhgFUdDP89mzZzV69GiFhobK29tbN998s5YtW+aCilEQBennDh06ZPs822w29ejRw0VVI78K+nmeNWuW6tevL19fX4WFhWncuHG6fPmyCypGfhWkj69evaqpU6cqMjJSPj4+atKkiZYvX+6iiks3gkUhWLdunUaPHq0ffvhBq1at0tWrV3X33XfrwoULN3xuYmKiJk6cqPbt27ugUlhR0H729/fX8ePH7bfDhw+7qGIUREH6+cqVK+rSpYsSExO1ZMkS7dmzR/Pnz9dNN93kwsqRHwXp56VLlzp8ln/55Rd5enrqvvvuc2HlyI+C9POHH36op556SrGxsdq1a5feeecdLV68WE8//bQLK4ezCtLHzz77rObNm6fXX39dO3fu1COPPKI+ffpo69atLqy8lDIodMnJyUaSWbduXZ7LpaenmzvuuMO8/fbbJiYmxvTq1cs1BaJQONPP8fHxJiAgwHVFodA5089z5swxderUMVeuXHFhZShMzn5vX+vVV181fn5+5vz580VYGQqTM/08evRo06lTJ4e28ePHm7Zt2xZ1eSgEzvRxaGiomT17tkNb3759zcCBA4u6vFKPMxZFICUlRZJUpUqVPJebOnWqqlWrpmHDhrmiLBQyZ/v5/Pnzql27tsLCwtSrVy/t2LHDFeWhkDjTz59//rnatGmj0aNHq3r16mrUqJFeeOEFZWRkuKpMWOTs5/la77zzjgYMGKCKFSsWVVkoZM708x133KHNmzdrw4YNkqSDBw9q2bJl6t69u0tqhDXO9HFaWlq2y5J9fX31v//9r0hrKwv4gbxClpmZqXvvvVdnz57N8w36v//9TwMGDNC2bdtUtWpVDRkyRGfPntWnn37qumJRYM728/fff699+/apcePGSklJ0csvv6z169drx44dqlmzpgsrRkE4288NGjRQYmKiBg4cqFGjRmn//v0aNWqUHn/8ccXGxrqwYhSEs/18rQ0bNqh169b68ccf1apVqyKuEIUhP/38z3/+UxMnTpQxRunp6XrkkUc0Z84cF1WKgnK2jx988EH99NNP+vTTTxUZGak1a9aoV69eysjIUFpamgsrLoXcfMak1HnkkUdM7dq1TVJSUq7LpKammvDwcLNs2TJ7G5dClSzO9HNOrly5YiIjI82zzz5bRJWhMDnbz/Xq1TNhYWEmPT3d3jZz5kwTEhJS1CWiEBTk8zxy5Ehz6623FmFVKGzO9vM333xjqlevbubPn29+/vlns3TpUhMWFmamTp3qokpRUM72cXJysunVq5fx8PAwnp6e5uabbzajRo0yPj4+Lqq09CJYFKLRo0ebmjVrmoMHD+a53NatW40k4+npab/ZbDZjs9mMp6en2b9/v4sqRkE428+56devnxkwYEAhV4XClp9+vvPOO81dd93l0LZs2TIjyaSlpRVViSgEBfk8nz9/3vj7+5tZs2YVYWUoTPnp53bt2pmJEyc6tC1YsMD4+vqajIyMoioRFhXks3zp0iXz66+/mszMTPO3v/3NNGzYsAgrLBsYY1EIjDEaM2aM/v3vf+vrr79WREREnss3aNBA27dv17Zt2+y3e++9Vx07dtS2bdsUFhbmosqRH/nt55xkZGRo+/btCg0NLYIKURgK0s9t27bV/v37lZmZaW/bu3evQkND5eXlVZTlooCsfJ4//vhjpaWladCgQUVYIQpDQfr54sWL8vBwPDzy9PS0rw/Fi5XPso+Pj2666Salp6frk08+Ua9evYqw0jLCjaGm1Hj00UdNQECAWbt2rTl+/Lj9dvHiRfsygwcPNk899VSu6+BSqOKvIP08ZcoUs2LFCnPgwAGzefNmM2DAAOPj42N27Njhjl2AEwrSz0eOHDF+fn5mzJgxZs+ePeaLL74w1apVM88//7w7dgFOsPK93a5dO9O/f39XlosCKkg/x8bGGj8/P7No0SJz8OBBs3LlShMZGWnuv/9+d+wCbqAgffzDDz+YTz75xBw4cMCsX7/edOrUyURERJgzZ864YQ9KF4JFIZCU4y0+Pt6+THR0tImJicl1HQSL4q8g/Tx27FhTq1Yt4+XlZapXr266d+9utmzZ4vri4bSCfp6/++4707p1a+Pt7W3q1Kljpk2b5jDmAsVLQft59+7dRpJZuXKlawtGgRSkn69evWri4uJMZGSk8fHxMWFhYWbUqFEcdBZTBenjtWvXmqioKOPt7W2CgoLM4MGDzdGjR11ffCnErFAAAAAALGOMBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAKJDw8XEOGDHF3GaXejBkzVKdOHXl6eqpp06buLqfQnT9/XsOHD1dISIhsNpvGjh3rsm136NBBHTp0sN9PTEyUzWZTQkKCy2pwVnh4uO65554bLrd27VrZbDatXbvW3jZkyBCFh4c7LGez2RQXF1e4RZYixfm9ABRnBAsASkhIkM1m06ZNm3J8vEOHDmrUqJHl7SxbtoyDmXxYuXKl/va3v6lt27aKj4/XCy+84LJtX7x4UXFxcQ4HqEXhhRdeUEJCgh599FEtWLBAgwcPLtLtucN3332nuLg4nT171t2l5Kok1Aig+Cvn7gIAlEx79uyRh0f+/jaxbNkyvfHGG4QLJ3399dfy8PDQO++8Iy8vL5du++LFi5oyZYokOfxVv7B9/fXXuv322xUbG1tk28jNypUrXbKd7777TlOmTNGQIUMUGBhYpNu68847denSpRu+Xy5duqRy5f7/IYAraywJateurUuXLql8+fLuLgUoUThjAaBAvL29S9w/uhcuXHB3CfmSnJwsX19fl4cKV0pOTi6UA1ljjC5dupSv53h5eZW619bDw0M+Pj43DP0+Pj4OwaK0y+9n32azycfHR56enkVUEVA6ESwAFMj1YyyuXr2qKVOmqF69evLx8VFQUJDatWunVatWSfrjOu833nhD0h//aGfdsly4cEETJkxQWFiYvL29Vb9+fb388ssyxjhs99KlS3r88cdVtWpV+fn56d5779XRo0ezXTMeFxcnm82mnTt36sEHH1TlypXVrl07SdLPP/+sIUOGqE6dOvLx8VFISIj+8pe/6Pfff3fYVtY69u7dq0GDBikgIEDBwcH6+9//LmOMkpKS1KtXL/n7+yskJEQzZ8506rVLT0/Xc889p8jISHl7eys8PFxPP/200tLS7MvYbDbFx8frwoUL9tfqRtd7f/zxx2revLl8fX1VtWpVDRo0SEePHnVY5vpxBVmuvQ4/MTFRwcHBkqQpU6bYt5+fM03JyckaNmyYqlevLh8fHzVp0kTvvfee/fGssQCHDh3Sl19+ad9GYmKiU+vPGnOwYsUKtWjRQr6+vpo3b54kKT4+Xp06dVK1atXk7e2thg0bas6cOdnWkdtrkV+vv/66brnlFlWoUEGVK1dWixYt9OGHH0r64z30xBNPSJIiIiKy7aeztWZZuXKlmjZtKh8fHzVs2FBLly51eDynMRY5ubY/86oxOjpaTZo0yXEd9evXV9euXW/08thlXVL5888/Kzo6WhUqVFDdunW1ZMkSSdK6devUunVr+fr6qn79+lq9erXD8w8fPqxRo0apfv368vX1VVBQkO67775s75msSzvXrVunUaNGqVq1aqpZs6b98TfeeEN16tSRr6+vWrVqpf/+979OjbcZMmSIKlWqpKNHj6p3796qVKmSgoODNXHiRGVkZDj9OgClWdn5cwWAG0pJSdGpU6eytV+9evWGz42Li9P06dM1fPhwtWrVSqmpqdq0aZO2bNmiLl266OGHH9axY8e0atUqLViwwOG5xhjde++9+uabbzRs2DA1bdpUK1as0BNPPKGjR4/q1VdftS87ZMgQ/etf/9LgwYN1++23a926derRo0eudd13332qV6+eXnjhBXtIWbVqlQ4ePKihQ4cqJCREO3bs0FtvvaUdO3bohx9+cAg8ktS/f39FRUXpxRdf1Jdffqnnn39eVapU0bx589SpUye99NJLWrhwoSZOnKiWLVvqzjvvzPO1Gj58uN577z3169dPEyZM0I8//qjp06dr165d+ve//y1JWrBggd566y1t2LBBb7/9tiTpjjvuyHWdCQkJGjp0qFq2bKnp06fr5MmTeu211/Ttt99q69at+TorEBwcrDlz5ujRRx9Vnz591LdvX0lS48aNnXr+pUuX1KFDB+3fv19jxoxRRESEPv74Yw0ZMkRnz57VX//6V0VFRWnBggUaN26catasqQkTJti37aw9e/bogQce0MMPP6wRI0aofv36kqQ5c+bolltu0b333qty5crpP//5j0aNGqXMzEyNHj3a6fU7Y/78+Xr88cfVr18//fWvf9Xly5f1888/68cff9SDDz6ovn37au/evVq0aJFeffVVVa1a1WE/81Prvn371L9/fz3yyCOKiYlRfHy87rvvPi1fvlxdunQp8D7kVePgwYM1YsQI/fLLLw7jrDZu3Ki9e/fq2Wefzde2zpw5o3vuuUcDBgzQfffdpzlz5mjAgAFauHChxo4dq0ceeUQPPvigZsyYoX79+ikpKUl+fn72bX733XcaMGCAatasqcTERM2ZM0cdOnTQzp07VaFCBYdtjRo1SsHBwZo8ebL9jMWcOXM0ZswYtW/fXuPGjVNiYqJ69+6typUrO4SP3GRkZKhr165q3bq1Xn75Za1evVozZ85UZGSkHn300Xy9FkCpZACUefHx8UZSnrdbbrnF4Tm1a9c2MTEx9vtNmjQxPXr0yHM7o0ePNjl97Xz66adGknn++ecd2vv162dsNpvZv3+/McaYzZs3G0lm7NixDssNGTLESDKxsbH2ttjYWCPJPPDAA9m2d/HixWxtixYtMpLM+vXrs61j5MiR9rb09HRTs2ZNY7PZzIsvvmhvP3PmjPH19XV4TXKybds2I8kMHz7coX3ixIlGkvn666/tbTExMaZixYp5rs8YY65cuWKqVatmGjVqZC5dumRv/+KLL4wkM3nyZHtbdHS0iY6OzraOmJgYU7t2bfv93377Ldtr6qxZs2YZSeaDDz5wqLFNmzamUqVKJjU11d5eu3btG75vclK7dm0jySxfvjzbYzn1b9euXU2dOnUc2q5/LQ4dOmQkmfj4eKfr6NWrV7bPxvVmzJhhJJlDhw4VuNas/f3kk0/sbSkpKSY0NNQ0a9bM3vbNN98YSeabb76xt13ft8aYbH2bW41nz541Pj4+5sknn3Rof/zxx03FihXN+fPnc9nr7KKjo40k8+GHH9rbdu/ebSQZDw8P88MPP9jbV6xYka0vcnqtvv/+eyPJvP/++/a2rO+zdu3amfT0dHt7WlqaCQoKMi1btjRXr161tyckJBhJN3wvxMTEGElm6tSpDjU0a9bMNG/e3OnXASjNuBQKgN0bb7yhVatWZbs585fqwMBA7dixQ/v27cv3dpctWyZPT089/vjjDu0TJkyQMUZfffWVJGn58uWS/vhL5LUee+yxXNf9yCOPZGvz9fW1///ly5d16tQp3X777ZKkLVu2ZFt++PDh9v/39PRUixYtZIzRsGHD7O2BgYGqX7++Dh48mGst0h/7Kknjx493aM/6i/2XX36Z5/NzsmnTJiUnJ2vUqFHy8fGxt/fo0UMNGjQo0DqtWLZsmUJCQvTAAw/Y28qXL6/HH39c58+f17p16wplOxERETleinNt/2adhYuOjtbBgweVkpJSKNvOEhgYqF9//VUbN24s0PPzU2uNGjXUp08f+31/f3899NBD2rp1q06cOFGwHbiBgIAA9erVS4sWLbKf8cvIyNDixYvVu3dvVaxYMV/rq1SpkgYMGGC/X79+fQUGBioqKkqtW7e2t2f9/7Wfp2tfq6tXr+r3339X3bp1FRgYmOPndsSIEQ5jJDZt2qTff/9dI0aMcBhfMnDgQFWuXNnpfbj+O6V9+/Y3/NwDZQXBAoBdq1at1Llz52w3Z/7RnTp1qs6ePaubb75Zt956q5544gn9/PPPTm338OHDqlGjhv2ShyxRUVH2x7P+6+HhoYiICIfl6tatm+u6r19Wkk6fPq2//vWvql69unx9fRUcHGxfLqcDz1q1ajncDwgIkI+Pj/2SkWvbz5w5k2st1+7D9TWHhIQoMDDQvq/5kfWcrEuBrtWgQYMCrdOKw4cPq169etkGEF/fn1bl1LeS9O2336pz586qWLGiAgMDFRwcrKefflpSzv1rxZNPPqlKlSqpVatWqlevnkaPHq1vv/3W6efnp9a6detmu0zv5ptvliSnx6YUxEMPPaQjR47ov//9ryRp9erVOnnyZIGmBq5Zs2a2fQgICFBYWFi2NkkOn6dLly5p8uTJ9nFYVatWVXBwsM6ePZtjv17//sh6313/2StXrly23/nIjY+PT7bL9SpXrnzDzz1QVhAsABSKO++8UwcOHNC7776rRo0a6e2339Ztt91mHx/gLtf+lTPL/fffr/nz5+uRRx7R0qVLtXLlSvvZkMzMzGzL5zQzTG6zxZjrBpvn5vqDK1fJbbslcfBpTn174MAB3XXXXTp16pReeeUVffnll1q1apXGjRsnKef+tSIqKkp79uzRRx99pHbt2umTTz5Ru3btnJo+19W1FlTXrl1VvXp1ffDBB5KkDz74QCEhIercuXO+15Xb58aZz9Njjz2madOm6f7779e//vUvrVy5UqtWrVJQUFCOr1VO7w+rmCUKyBvBAkChqVKlioYOHapFixYpKSlJjRs3dphJKLeD2tq1a+vYsWM6d+6cQ/vu3bvtj2f9NzMzU4cOHXJYbv/+/U7XeObMGa1Zs0ZPPfWUpkyZoj59+qhLly6qU6eO0+uwImsfrr9k7OTJkzp79qx9X/O7TumPwczX27Nnj8M6K1eunOOPoF1/FsFK8Kldu7b27duX7WDv+v4sCv/5z3+Ulpamzz//XA8//LC6d++uzp07F8lBZpaKFSuqf//+io+P15EjR9SjRw9NmzZNly9flpT7a5nfWvfv358tuO7du1eSnP6Le27y6m9PT089+OCDWrJkic6cOaNPP/1UDzzwgMsPspcsWaKYmBjNnDlT/fr1U5cuXdSuXTunf9Qv6313/fdFenp6kZ7xAcoSggWAQnH9VK2VKlVS3bp1HaZQzboe+/oDge7duysjI0OzZ892aH/11Vdls9nUrVs3SbJfT//mm286LPf66687XWfWwdD1B2izZs1yeh1WdO/ePcftvfLKK5KU5wxXuWnRooWqVaumuXPnOrzeX331lXbt2uWwzsjISO3evVu//fabve2nn37KdvlO1gw7Bfkl5u7du+vEiRNavHixvS09PV2vv/66KlWqpOjo6Hyv01k59W9KSori4+OLZHvXv++9vLzUsGFDGWPss6nl9r7Pb63Hjh2zzxomSampqXr//ffVtGlThYSEWNqP3GrMMnjwYJ05c0YPP/ywzp8/r0GDBlnaXkF4enpm+9y+/vrrTp9ta9GihYKCgjR//nylp6fb2xcuXMilTEAhYbpZAIWiYcOG6tChg5o3b64qVapo06ZNWrJkicaMGWNfpnnz5pKkxx9/XF27dpWnp6cGDBignj17qmPHjnrmmWeUmJioJk2aaOXKlfrss880duxYRUZG2p//5z//WbNmzdLvv/9un24266+2zvyV3d/fX3feeaf+8Y9/6OrVq7rpppu0cuXKbGdBikqTJk0UExOjt956S2fPnlV0dLQ2bNig9957T71791bHjh3zvc7y5cvrpZde0tChQxUdHa0HHnjAPt1seHi4/dIaSfrLX/6iV155RV27dtWwYcOUnJysuXPn6pZbblFqaqp9OV9fXzVs2FCLFy/WzTffrCpVqqhRo0YOU47mZuTIkZo3b56GDBmizZs3Kzw8XEuWLNG3336rWbNmZRtLU5juvvtueXl5qWfPnvaD4Pnz56tatWo6fvx4kWwvJCREbdu2VfXq1bVr1y7Nnj1bPXr0sO9n1vv+mWee0YABA1S+fHn17Nkz37XefPPNGjZsmDZu3Kjq1avr3Xff1cmTJwslNOVWY1bgaNasmRo1aqSPP/5YUVFRuu222yxvM7/uueceLViwQAEBAWrYsKG+//57rV69WkFBQU4938vLS3FxcXrsscfUqVMn3X///UpMTFRCQoIiIyPddnkiUKq4aTYqAMVI1vSMGzduzPHx6OjoG043+/zzz5tWrVqZwMBA4+vraxo0aGCmTZtmrly5Yl8mPT3dPPbYYyY4ONjYbDaHqWfPnTtnxo0bZ2rUqGHKly9v6tWrZ2bMmGEyMzMdtnvhwgUzevRoU6VKFVOpUiXTu3dvs2fPHiPJYfrXrKlif/vtt2z78+uvv5o+ffqYwMBAExAQYO677z5z7NixXKesvX4duU0Dm9PrlJOrV6+aKVOmmIiICFO+fHkTFhZmJk2aZC5fvuzUdnKzePFi06xZM+Pt7W2qVKliBg4caH799ddsy33wwQemTp06xsvLyzRt2tSsWLEixylJv/vuO9O8eXPj5eWV76lnT548aYYOHWqqVq1qvLy8zK233prjNK5WppvN7Xmff/65ady4sfHx8THh4eHmpZdeMu+++2626VQLY7rZefPmmTvvvNMEBQUZb29vExkZaZ544gmTkpLisNxzzz1nbrrpJuPh4eFQh7O1Zu3vihUrTOPGjY23t7dp0KCB+fjjjx22U9DpZvOqMcs//vEPI8m88MILTr8+18rt85FbX0oyo0ePtt8/c+aM/T1VqVIl07VrV7N79+5s30U3+j775z//aWrXrm28vb1Nq1atzLfffmuaN29u/vSnP9mXyW262Zw+j1nfEwCMsRnj5EhDACimtm3bpmbNmumDDz7QwIED3V0OUCq99tpr9h+Vu36mtJIsMzNTwcHB6tu3r+bPn+/ucoASjTEWAEqUS5cuZWubNWuWPDw8bviL1wAKxhijd955R9HR0SU6VFy+fDnbOI33339fp0+fVocOHdxTFFCKMMYCQInyj3/8Q5s3b1bHjh1Vrlw5ffXVV/rqq680cuTIbHPho3BduXJFp0+fznOZgIAASzMw/fbbb3kOxvXy8lKVKlUKvH5nuWJfS4ILFy7o888/1zfffKPt27frs88+y7bM6dOndeXKlVzX4enpme23H9zlhx9+0Lhx43TfffcpKChIW7Zs0TvvvKNGjRrpvvvuc3d5QMnn3iuxACB/Vq5cadq2bWsqV65sypcvbyIjI01cXJy5evWqu0sr9bKu38/rlp/xCTmpXbt2nuu/dkxEUXLFvpYEWWMNAgMDzdNPP53jMtHR0Xm+TteP73CnQ4cOmZ49e5rq1aub8uXLm+rVq5uhQ4eakydPurs0oFRgjAUAwClnzpzR5s2b81zmlltuUWhoaIG38e233+Z4uVuWypUr22cwKkqu2NfSYvPmzXlO1+rr66u2bdu6sCIA7kKwAAAAAGAZg7cBAAAAWMbgbSdkZmbq2LFj8vPz4wd0AAAAUGYYY3Tu3DnVqFFDHh55n5MgWDjh2LFjzDYDAACAMispKUk1a9bMcxmChRP8/Pwk/fGC+vv7u7kaAAAAwDVSU1MVFhZmPx7OC8HCCVmXP/n7+xMsAAAAUOY4MxyAwdsAAAAALCNYAAAAALCMYAEAAADAMsZYAAAAwCUyMzN15coVd5eBa5QvX16enp6Fsi6CBQAAAIrclStXdOjQIWVmZrq7FFwnMDBQISEhln+vjWABAACAImWM0fHjx+Xp6amwsLAb/tAaXMMYo4sXLyo5OVmSFBoaaml9ZSJYxMXFacqUKQ5t9evX1+7du91UEQAAQNmRnp6uixcvqkaNGqpQoYK7y8E1fH19JUnJycmqVq2apcuiykSwkKRbbrlFq1evtt8vV67M7DoAAIBbZWRkSJK8vLzcXAlykhX2rl69SrBwRrly5RQSEuLuMgAAAMosq9fwo2gUVr+UmQvc9u3bpxo1aqhOnToaOHCgjhw54u6SAAAAgFKjTASL1q1bKyEhQcuXL9ecOXN06NAhtW/fXufOnctx+bS0NKWmpjrcAAAAgPxITEyUzWbTtm3bnH5OQkKCAgMD3V5HQZSJS6G6detm///GjRurdevWql27tv71r39p2LBh2ZafPn16tsHeAAAAKFxxcSVje0lJSYqNjdXy5ct16tQphYaGqnfv3po8ebKCgoJyfV5YWJiOHz+uqlWrOr2t/v37q3v37gUr1M3KxBmL6wUGBurmm2/W/v37c3x80qRJSklJsd+SkpJcXCEAAACKg4MHD6pFixbat2+fFi1apP3792vu3Llas2aN2rRpo9OnT+f4vCtXrsjT01MhISH5mjTI19dX1apVK6zyXapMBovz58/rwIEDuc7V6+3tLX9/f4cbAAAAyp7Ro0fLy8tLK1euVHR0tGrVqqVu3bpp9erVOnr0qJ555hlJUnh4uJ577jk99NBD8vf318iRI3O8BOnzzz9XvXr15OPjo44dO+q9996TzWbT2bNnJWW/FCouLk5NmzbVggULFB4eroCAAA0YMMDhkv7ly5erXbt2CgwMVFBQkO655x4dOHDAFS+PgzIRLCZOnKh169YpMTFR3333nfr06SNPT0898MAD7i4NAAAAxdTp06e1YsUKjRo1yv57D1lCQkI0cOBALV68WMYYSdLLL7+sJk2aaOvWrfr73/+ebX2HDh1Sv3791Lt3b/300096+OGH7cEkLwcOHNCnn36qL774Ql988YXWrVunF1980f74hQsXNH78eG3atElr1qyRh4eH+vTp4/JfOS8TYyx+/fVXPfDAA/r9998VHBysdu3a6YcfflBwcLC7SwMAAEAxtW/fPhljFBUVlePjUVFROnPmjH777TdJUqdOnTRhwgT744mJiQ7Lz5s3T/Xr19eMGTMk/fGDzb/88oumTZuWZx2ZmZlKSEiQn5+fJGnw4MFas2aN/Xl//vOfHZZ/9913FRwcrJ07d6pRo0bO77BFZSJYfPTRR+4uAQAAACVU1hmJG2nRokWej+/Zs0ctW7Z0aGvVqtUN1xseHm4PFZIUGhqq5ORk+/19+/Zp8uTJ+vHHH3Xq1Cn7mYojR464NFiUiUuhAAAAgPyqW7eubDabdu3alePju3btUuXKle1XwVSsWLFI6ihfvrzDfZvN5nCZU8+ePXX69GnNnz9fP/74o3788UdJfwwgdyWCBQAAAJCDoKAgdenSRW+++aYuXbrk8NiJEye0cOFC9e/f3+lfrq5fv742bdrk0LZx40ZLNf7+++/as2ePnn32Wd111132y7PcgWABAAAA5GL27NlKS0tT165dtX79eiUlJWn58uXq0qWLbrrpphuOj7jWww8/rN27d+vJJ5/U3r179a9//UsJCQmS5HQ4uV7lypUVFBSkt956S/v379fXX3+t8ePHF2hdVhEsAAAAgFzUq1dPmzZtUp06dXT//fcrMjJSI0eOVMeOHfX999+rSpUqTq8rIiJCS5Ys0dKlS9W4cWPNmTPHPiuUt7d3gerz8PDQRx99pM2bN6tRo0YaN26cfXC4q9mMs6NRyrDU1FQFBAQoJSWF37QAUPK4+qdtC1NJrh2A3eXLl3Xo0CFFRETIx8fH3eUUK9OmTdPcuXPd+oPMefVPfo6Dy8SsUAAAAEBx8Oabb6ply5YKCgrSt99+qxkzZmjMmDHuLqtQECwAAAAAF9m3b5+ef/55nT59WrVq1dKECRM0adIkd5dVKAgWAAAAgIu8+uqrevXVV91dRpFg8DYAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAAEUgISFBgYGB7i7DZfgdCwAAALhHXFyJ2F5SUpJiY2O1fPlynTp1SqGhoerdu7cmT56soKAgSVJ4eLjGjh2rsWPHFl69JQxnLAAAAIBcHDx4UC1atNC+ffu0aNEi7d+/X3PnztWaNWvUpk0bnT592uU1Xb161eXbdAbBAgAAAMjF6NGj5eXlpZUrVyo6Olq1atVSt27dtHr1ah09elTPPPOMOnTooMOHD2vcuHGy2Wyy2WwO61ixYoWioqJUqVIl/elPf9Lx48cdHn/77bcVFRUlHx8fNWjQQG+++ab9scTERNlsNi1evFjR0dHy8fHRwoULXbLv+cWlUAAAAEAOTp8+rRUrVmjatGny9fV1eCwkJEQDBw7U4sWLtW/fPjVt2lQjR47UiBEjHJa7ePGiXn75ZS1YsEAeHh4aNGiQJk6caA8HCxcu1OTJkzV79mw1a9ZMW7du1YgRI1SxYkXFxMTY1/PUU09p5syZatasmXx8fIp+5wuAYAEAAADkYN++fTLGKCoqKsfHo6KidObMGWVkZMjT01N+fn4KCQlxWObq1auaO3euIiMjJUljxozR1KlT7Y/HxsZq5syZ6tu3ryQpIiJCO3fu1Lx58xyCxdixY+3LFFcECwAAACAPxpgCP7dChQr2UCFJoaGhSk5OliRduHBBBw4c0LBhwxzOdKSnpysgIMBhPS1atChwDa5CsAAAAAByULduXdlsNu3atUt9+vTJ9viuXbtUuXJlBQcH57qO8uXLO9y32Wz2oHL+/HlJ0vz589W6dWuH5Tw9PR3uV6xYsUD74EoM3gYAAAByEBQUpC5duujNN9/UpUuXHB47ceKEFi5cqP79+8tms8nLy0sZGRn5Wn/16tVVo0YNHTx4UHXr1nW4RUREFOauuATBAgAAAMjF7NmzlZaWpq5du2r9+vVKSkrS8uXL1aVLF910002aNm2apD9+x2L9+vU6evSoTp065fT6p0yZounTp+uf//yn9u7dq+3btys+Pl6vvPJKUe1SkSFYAAAAALmoV6+eNm3apDp16uj+++9XZGSkRo4cqY4dO+r7779XlSpVJElTp05VYmKiIiMj87w06nrDhw/X22+/rfj4eN16662Kjo5WQkJCiTxjYTNWRqOUEampqQoICFBKSor8/f3dXQ4A5I+rf9m2MJXk2gHYXb58WYcOHVJERESxnSq1LMurf/JzHMwZCwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAuARzBhVPhdUvBAsAAAAUqaxfkb5y5YqbK0FOLl68KCn7r4TnV7nCKAYAAADITbly5VShQgX99ttvKl++vDw8+Nt2cWCM0cWLF5WcnKzAwEB7ACwoggUAAACKlM1mU2hoqA4dOqTDhw+7uxxcJzAwUCEhIZbXQ7AAAABAkfPy8lK9evW4HKqYKV++vOUzFVkIFgAAAHAJDw8Pfnm7FOMCNwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBm/YwEAJUBcXMGf22FtYVXhemvj/vivlf0HALgGZywAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGBZOXcXAADAjcTFubsC9yrr+w+gZOCMBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCszAWLF198UTabTWPHjnV3KQAAAECpUaaCxcaNGzVv3jw1btzY3aUAAAAApUqZCRbnz5/XwIEDNX/+fFWuXNnd5QAAAAClSpkJFqNHj1aPHj3UuXPnGy6blpam1NRUhxsAAACA3JVzdwGu8NFHH2nLli3auHGjU8tPnz5dU6ZMKeKqAAAAgNKj1J+xSEpK0l//+lctXLhQPj4+Tj1n0qRJSklJsd+SkpKKuEoAAACgZCv1Zyw2b96s5ORk3Xbbbfa2jIwMrV+/XrNnz1ZaWpo8PT0dnuPt7S1vb29XlwoAAACUWKU+WNx1113avn27Q9vQoUPVoEEDPfnkk9lCBQAAAID8K/XBws/PT40aNXJoq1ixooKCgrK1AwCKlw5r49xdQoGs7RDn7hIAwOVK/RgLAAAAAEWv1J+xyMnatWvdXQIAAABQqnDGAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWlXN3AQBQYsTFuW3THda6bdMAADiFMxYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAy/iBPAAlght/m86OH6kDACB3nLEAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYFk5dxcAoAyKi8v3UzqsLfQqAABAIeKMBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMCyMhEs5syZo8aNG8vf31/+/v5q06aNvvrqK3eXBQAAAJQa5dxdgCvUrFlTL774ourVqydjjN577z316tVLW7du1S233OLu8gAApUyHtXGFu8JCXl3u23HVhgCURmUiWPTs2dPh/rRp0zRnzhz98MMPBAsAAACgEJSJYHGtjIwMffzxx7pw4YLatGmT4zJpaWlKS0uz309NTXVVeQAAAECJVCbGWEjS9u3bValSJXl7e+uRRx7Rv//9bzVs2DDHZadPn66AgAD7LSwszMXVAgAAACVLmQkW9evX17Zt2/Tjjz/q0UcfVUxMjHbu3JnjspMmTVJKSor9lpSU5OJqAQAAgJKlzFwK5eXlpbp160qSmjdvro0bN+q1117TvHnzsi3r7e0tb29vV5cIAAAAlFhl5ozF9TIzMx3GUQAAAAAouDJxxmLSpEnq1q2batWqpXPnzunDDz/U2rVrtWLFCneXBgAAAJQKZSJYJCcn66GHHtLx48cVEBCgxo0ba8WKFerSpYu7SwMAAABKhTIRLN555x13lwAAAACUamV2jAUAAACAwkOwAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGXFOlgcPHjQ3SUAAAAAcEKxDhZ169ZVx44d9cEHH+jy5cvuLgcAAABALsq5u4C8bNmyRfHx8Ro/frzGjBmj/v37a9iwYWrVqpW7SwPcLy7O3RUAAADYFeszFk2bNtVrr72mY8eO6d1339Xx48fVrl07NWrUSK+88op+++03d5cIAAAAQMU8WGQpV66c+vbtq48//lgvvfSS9u/fr4kTJyosLEwPPfSQjh8/7u4SAQAAgDKtRASLTZs2adSoUQoNDdUrr7yiiRMn6sCBA1q1apWOHTumXr16ubtEAAAAoEwr1mMsXnnlFcXHx2vPnj3q3r273n//fXXv3l0eHn/koYiICCUkJCg8PNy9hQIAAABlXLEOFnPmzNFf/vIXDRkyRKGhoTkuU61aNb3zzjsurgwAAADAtYp1sFi1apVq1aplP0ORxRijpKQk1apVS15eXoqJiXFThQAAFL21a120nTjXbCe/mAQPKBmK9RiLyMhInTp1Klv76dOnFRER4YaKAAAAAOSkWAcLY0yO7efPn5ePj4+LqwEAAACQm2J5KdT48eMlSTabTZMnT1aFChXsj2VkZOjHH39U06ZN3VQdAAAAgOsVy2CxdetWSX+csdi+fbu8vLzsj3l5ealJkyaaOHGiu8oDAAAAcJ1iGSy++eYbSdLQoUP12muvyd/f380VAQAAAMhLsQwWWeLj491dAgAAAAAnFLtg0bdvXyUkJMjf3199+/bNc9mlS5e6qCoAAAAAeSl2wSIgIEA2m83+/wAAAACKv2IXLK69/IlLoQAAAICSoVj/jsWlS5d08eJF+/3Dhw9r1qxZWrlypRurAgAAAHC9Yh0sevXqpffff1+SdPbsWbVq1UozZ85Ur169NGfOHDdXBwAAACBLsQ4WW7ZsUfv27SVJS5YsUUhIiA4fPqz3339f//znP91cHQAAAIAsxTpYXLx4UX5+fpKklStXqm/fvvLw8NDtt9+uw4cPu7k6AAAAAFmKdbCoW7euPv30UyUlJWnFihW6++67JUnJycn8aB4AAABQjBTrYDF58mRNnDhR4eHhat26tdq0aSPpj7MXzZo1c3N1AAAAALIUu+lmr9WvXz+1a9dOx48fV5MmTeztd911l/r06ePGygAAAABcq1gHC0kKCQlRSEiIQ1urVq3cVA0AAACAnBTrYHHhwgW9+OKLWrNmjZKTk5WZmenw+MGDB91UGQAAAIBrFetgMXz4cK1bt06DBw9WaGiobDabu0sCAAAAkINiHSy++uorffnll2rbtq27SwEAAACQh2I9K1TlypVVpUoVd5cBAAAA4AaKdbB47rnnNHnyZF28eNHdpQAAAADIQ7G+FGrmzJk6cOCAqlevrvDwcJUvX97h8S1btripMgAAAADXKtbBonfv3u4uAQAAAIATinWwiI2NdXcJAAAAAJxQrMdYSNLZs2f19ttva9KkSTp9+rSkPy6BOnr0qJsrAwAAAJClWJ+x+Pnnn9W5c2cFBAQoMTFRI0aMUJUqVbR06VIdOXJE77//vrtLBAAAAKBifsZi/PjxGjJkiPbt2ycfHx97e/fu3bV+/Xo3VgYAAADgWsU6WGzcuFEPP/xwtvabbrpJJ06ccENFAAAAAHJSrIOFt7e3UlNTs7Xv3btXwcHBbqgIAAAAQE6KdbC49957NXXqVF29elWSZLPZdOTIET355JP685//7ObqAAAAAGQp1sFi5syZOn/+vIKDg3Xp0iVFR0erbt268vPz07Rp09xdHgAAAID/U6xnhQoICNCqVav07bff6qefftL58+d12223qXPnzu4uDQAAAMA1im2wyMzMVEJCgpYuXarExETZbDZFREQoJCRExhjZbDZ3lwgAAADg/xTLS6GMMbr33ns1fPhwHT16VLfeeqtuueUWHT58WEOGDFGfPn3cXSIAAACAaxTLMxYJCQlav3691qxZo44dOzo89vXXX6t37956//339dBDD7mpQgAAAADXKpZnLBYtWqSnn346W6iQpE6dOumpp57SwoUL3VAZAAAAgJwUy2Dx888/609/+lOuj3fr1k0//fSTCysCAAAAkJdiGSxOnz6t6tWr5/p49erVdebMGRdWBAAAACAvxTJYZGRkqFy53Id/eHp6Kj093YUVAQAAAMhLsRy8bYzRkCFD5O3tnePjaWlpLq4IAAAAQF6KZbCIiYm54TLMCAUAAAAUH8UyWMTHx7u7BAAAAAD5UCzHWAAAAAAoWQgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsKxPBYvr06WrZsqX8/PxUrVo19e7dW3v27HF3WQAAAECpUSaCxbp16zR69Gj98MMPWrVqla5evaq7775bFy5ccHdpAAAAQKlQzt0FuMLy5csd7ickJKhatWravHmz7rzzTjdVBQAAAJQeZeKMxfVSUlIkSVWqVHFzJQAAAEDpUCbOWFwrMzNTY8eOVdu2bdWoUaMcl0lLS1NaWpr9fmpqqqvKAwAAAEqkMnfGYvTo0frll1/00Ucf5brM9OnTFRAQYL+FhYW5sEIAAACg5ClTwWLMmDH64osv9M0336hmzZq5Ljdp0iSlpKTYb0lJSS6sEgAAACh5ysSlUMYYPfbYY/r3v/+ttWvXKiIiIs/lvb295e3t7aLqAAAAgJKvTASL0aNH68MPP9Rnn30mPz8/nThxQpIUEBAgX19fN1cHAAAAlHxl4lKoOXPmKCUlRR06dFBoaKj9tnjxYneXBgAAAJQKZeKMhTHG3SUAAAAApVqZOGMBAAAAoGgRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlpVzdwEoReLi3F0BAAAA3IQzFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsKycuwsA4Jy1a91dAQAAQO44YwEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCsnLsLAAAAyEtcnLsrcD9eA5QEnLEAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhWJoLF+vXr1bNnT9WoUUM2m02ffvqpu0sCAAAASpUyESwuXLigJk2a6I033nB3KQAAAECpVM7dBbhCt27d1K1bN3eXAQAAAJRaZeKMBQAAAICiVSbOWORXWlqa0tLS7PdTU1PdWA0AAABQ/HHGIgfTp09XQECA/RYWFubukgAAAIBijWCRg0mTJiklJcV+S0pKcndJAAAAQLHGpVA58Pb2lre3t7vLAAAAAEqMMhEszp8/r/3799vvHzp0SNu2bVOVKlVUq1YtN1YGAAAAlA5lIlhs2rRJHTt2tN8fP368JCkmJkYJCQluqgoAAAAoPcpEsOjQoYOMMe4uAwAAACi1ykSwAAAAN9ZhbZy7SyiQtR3i3F0CADErFAAAAIBCQLAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGBZOXcXAAAAYEWHtXHuLqHA1naIc3cJQKHhjAUAAAAAywgWAAAAACzjUiiUCGvXursCAAAA5IUzFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAy8q5uwAAAADkLS7O3RW4V1nf/5KCMxYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCvn7gLgnLg4d1dwYx3WursCAABQGpWE46CiVFL2nzMWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLylSweOONNxQeHi4fHx+1bt1aGzZscHdJAAAAQKlQZoLF4sWLNX78eMXGxmrLli1q0qSJunbtquTkZHeXBgAAAJR4ZSZYvPLKKxoxYoSGDh2qhg0bau7cuapQoYLeffddd5cGAAAAlHhl4ncsrly5os2bN2vSpEn2Ng8PD3Xu3Fnff/99tuXT0tKUlpZmv5+SkiJJSk1NLfpic3FNOcXWhfQSUCQAAMVIWpr7ji1QcrjxENR+/GuMueGyZSJYnDp1ShkZGapevbpDe/Xq1bV79+5sy0+fPl1TpkzJ1h4WFlZkNQIAgDLo2xfdXQFKgBeLwdvk3LlzCggIyHOZMhEs8mvSpEkaP368/X5mZqZOnz6toKAg2Wy2Aq0zNTVVYWFhSkpKkr+/f2GVimKGfi4b6OeygX4uG+jn0o8+tsYYo3PnzqlGjRo3XLZMBIuqVavK09NTJ0+edGg/efKkQkJCsi3v7e0tb29vh7bAwMBCqcXf3583dRlAP5cN9HPZQD+XDfRz6UcfF9yNzlRkKRODt728vNS8eXOtWbPG3paZmak1a9aoTZs2bqwMAAAAKB3KxBkLSRo/frxiYmLUokULtWrVSrNmzdKFCxc0dOhQd5cGAAAAlHhlJlj0799fv/32myZPnqwTJ06oadOmWr58ebYB3UXF29tbsbGx2S6xQulCP5cN9HPZQD+XDfRz6Ucfu47NODN3FAAAAADkoUyMsQAAAABQtAgWAAAAACwjWAAAAACwjGABAAAAwDKCRSGYPn26WrZsKT8/P1WrVk29e/fWnj17nH7+Rx99JJvNpt69exddkbCsIP2ckJAgm83mcPPx8XFRxSiIgn6ez549q9GjRys0NFTe3t66+eabtWzZMhdUjIIoSD936NAh2+fZZrOpR48eLqoa+VXQz/OsWbNUv359+fr6KiwsTOPGjdPly5ddUDHyqyB9fPXqVU2dOlWRkZHy8fFRkyZNtHz5chdVXLoRLArBunXrNHr0aP3www9atWqVrl69qrvvvlsXLly44XMTExM1ceJEtW/f3gWVwoqC9rO/v7+OHz9uvx0+fNhFFaMgCtLPV65cUZcuXZSYmKglS5Zoz549mj9/vm666SYXVo78KEg/L1261OGz/Msvv8jT01P33XefCytHfhSknz/88EM99dRTio2N1a5du/TOO+9o8eLFevrpp11YOZxVkD5+9tlnNW/ePL3++uvauXOnHnnkEfXp00dbt251YeWllEGhS05ONpLMunXr8lwuPT3d3HHHHebtt982MTExplevXq4pEIXCmX6Oj483AQEBrisKhc6Zfp4zZ46pU6eOuXLligsrQ2Fy9nv7Wq+++qrx8/Mz58+fL8LKUJic6efRo0ebTp06ObSNHz/etG3btqjLQyFwpo9DQ0PN7NmzHdr69u1rBg4cWNTllXqcsSgCKSkpkqQqVarkudzUqVNVrVo1DRs2zBVloZA528/nz59X7dq1FRYWpl69emnHjh2uKA+FxJl+/vzzz9WmTRuNHj1a1atXV6NGjfTCCy8oIyPDVWXCImc/z9d65513NGDAAFWsWLGoykIhc6af77jjDm3evFkbNmyQJB08eFDLli1T9+7dXVIjrHGmj9PS0rJdluzr66v//e9/RVpbWcAP5BWyzMxM3XvvvTp79myeb9D//e9/GjBggLZt26aqVatqyJAhOnv2rD799FPXFYsCc7afv//+e+3bt0+NGzdWSkqKXn75Za1fv147duxQzZo1XVgxCsLZfm7QoIESExM1cOBAjRo1Svv379eoUaP0+OOPKzY21oUVoyCc7edrbdiwQa1bt9aPP/6oVq1aFXGFKAz56ed//vOfmjhxoowxSk9P1yOPPKI5c+a4qFIUlLN9/OCDD+qnn37Sp59+qsjISK1Zs0a9evVSRkaG0tLSXFhxKeTmMyalziOPPGJq165tkpKScl0mNTXVhIeHm2XLltnbuBSqZHGmn3Ny5coVExkZaZ599tkiqgyFydl+rlevngkLCzPp6en2tpkzZ5qQkJCiLhGFoCCf55EjR5pbb721CKtCYXO2n7/55htTvXp1M3/+fPPzzz+bpUuXmrCwMDN16lQXVYqCcraPk5OTTa9evYyHh4fx9PQ0N998sxk1apTx8fFxUaWlF8GiEI0ePdrUrFnTHDx4MM/ltm7daiQZT09P+81msxmbzWY8PT3N/v37XVQxCsLZfs5Nv379zIABAwq5KhS2/PTznXfeae666y6HtmXLlhlJJi0trahKRCEoyOf5/Pnzxt/f38yaNasIK0Nhyk8/t2vXzkycONGhbcGCBcbX19dkZGQUVYmwqCCf5UuXLplff/3VZGZmmr/97W+mYcOGRVhh2cAYi0JgjNGYMWP073//W19//bUiIiLyXL5Bgwbavn27tm3bZr/de++96tixo7Zt26awsDAXVY78yG8/5yQjI0Pbt29XaGhoEVSIwlCQfm7btq3279+vzMxMe9vevXsVGhoqLy+voiwXBWTl8/zxxx8rLS1NgwYNKsIKURgK0s8XL16Uh4fj4ZGnp6d9fSherHyWfXx8dNNNNyk9PV2ffPKJevXqVYSVlhFuDDWlxqOPPmoCAgLM2rVrzfHjx+23ixcv2pcZPHiweeqpp3JdB5dCFX8F6ecpU6aYFStWmAMHDpjNmzebAQMGGB8fH7Njxw537AKcUJB+PnLkiPHz8zNjxowxe/bsMV988YWpVq2aef75592xC3CCle/tdu3amf79+7uyXBRQQfo5NjbW+Pn5mUWLFpmDBw+alStXmsjISHP//fe7YxdwAwXp4x9++MF88skn5sCBA2b9+vWmU6dOJiIiwpw5c8YNe1C6ECwKgaQcb/Hx8fZloqOjTUxMTK7rIFgUfwXp57Fjx5patWoZLy8vU716ddO9e3ezZcsW1xcPpxX08/zdd9+Z1q1bG29vb1OnTh0zbdo0hzEXKF4K2s+7d+82kszKlStdWzAKpCD9fPXqVRMXF2ciIyONj4+PCQsLM6NGjeKgs5gqSB+vXbvWREVFGW9vbxMUFGQGDx5sjh496vriSyFmhQIAAABgGWMsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlv0/vi1pBnZ9ZHYAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "original_results.compare_plots(mrs_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABEsAAAMzCAYAAABeDpxZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgABAABJREFUeJzs3Wd4VNXah/F70nshgdBDpAqIKL1EioCAUgSploBw7AVFEfVQVBQbIIjYQBBUPHRFQKkBDCBVeu+EThJCejKz3w95Z8yQSUggMUD+v3PNZbL2Wns9e89ODvNkFZNhGAYiIiIiIiIiIgKAU1EHICIiIiIiIiJyM1GyREREREREREQkCyVLRERERERERESyULJERERERERERCQLJUtERERERERERLJQskREREREREREJAslS0REREREREREslCyREREREREREQkCyVLRERERERERESyULJERERERERERCQLJUtERERERERERLJQskREREREREREJAslS0REREREREREslCyREREREREREQkCyVLRERERERERESyULJERERERERERCQLJUtERERuU/369cNkMtGvX7+iDkWkQN2qz3ZucV/vMRERKRxKloiI3OaSkpJYsmQJo0aNolu3boSGhmIymTCZTIwcObKow8vVpUuXmDp1Ko899hg1a9bE29sbd3d3ypcvT9euXZk/f35Rh3jb2rp1K++88w6dO3emRo0aBAUF4erqSlBQEM2aNeP9998nJiamyOIbOXKk7Tk2mUz8/PPP12zz4IMP2rU5duxY4QeaR9OmTWPkyJFERkYWdSgAmM1mZs2axRNPPEG1atUICAjAzc2NUqVK0bx5c95880127dpV1GEWiaufvWu9RETk1uRS1AGIiEjh2rhxIx07dizqMK5L6dKlycjIsH3v4eGBq6sr0dHRREdH88svv9ChQwfmzJmDl5dXEUZ6+/nuu+/44osvbN97eHjg6elJTEwM69atY926dXz22Wf8+uuvNGnSpAgjzTR16lR69+6d4/HTp0/zxx9//IsR5c+0adNYvXo1AC1btizSWDZs2EBERAQHDhywlbm6uuLr68ulS5eIiooiKiqKDz/8kG7dujFz5kzc3NyKMOKiExIS8q/0U6ZMGapXr06ZMmX+lf5EREQjS0REioXAwEDuv/9+Xn/9dWbOnEnp0qWLOqQ8ycjIoGHDhkyaNInDhw+TnJxMQkICR48eZcCAAQAsWbKEp59+uogjvf00bNiQTz75hPXr1xMbG0tycjLx8fFcuXKF77//npIlS3Lx4kW6du3K5cuXiyzO4OBgvL29Wb58OadOncqx3vTp0zGbzVSqVOnfC+4WtHDhQlq2bMmBAwcICgpi9OjRHDhwgLS0NC5dukRaWhqbNm1i6NCh+Pn5MW/ePJKSkoo67CJz9uzZa74KwujRo9m3bx+jR48ukPOJiMi1KVkiInKbCw8PJyYmhuXLl/Pxxx/Tu3dv3N3dizqsPFm5ciV//fUXzz77LHfccYetvFKlSkyePNmWJPnhhx84efJkUYV5W3riiSd47bXXaNy4MQEBAbZyHx8fnnjiCX744QcAzp8/z2+//VZEUYK3tzePPPIIFouFadOm5Vhv6tSpAFrzIRcHDx7kscceIzU1lZo1a/L3338zdOhQqlataqvj7OxM/fr1GT16NEePHqVLly5FGLGIiEjhUbJEROQ25+zsXCDn+e233+jRoweVKlXCy8sr1zn6kydPLpA+W7Vqletx6+gSgM2bN//r8cfGxjJlyhR69uzJXXfdRYkSJfDw8CA0NJS+ffuyYcOGHNu2bNnStm6MYRh8++23NGrUCD8/P3x9fWnSpIktIZGbH3/8kWbNmuHr64u/vz+NGjXim2++wTCMPF3D9WrcuLHt69xGdEDhPzv9+/cHyDFZ8ueff3LgwAHuuOMO7rvvvmueLzIykh49elCuXDnc3d0JDg7m/vvvZ+rUqZjNZodtrvf9nDZtGiaTyTYF55133sl2TxytrXLs2DEGDRpErVq18PHxwcvLixo1avDyyy9z4sSJa16jI//973+Jj4/Hw8OD+fPnU758+VzrlyhRggULFuDv729XXlA/F+np6YwZM4b69esTEBCAyWTK15ou1/M+3qxyW+A16z1LS0vjww8/pE6dOnh7exMYGEjbtm1ZsmRJruf/3//+R4cOHQgJCcHV1ZWAgACqVq1K586d+eKLL0hJSXHY7kaew+vtU0TkX2OIiEixExoaagDGiBEjrlk3KSnJ6Ny5swEYgGEymYyAgADDxcXFVnb1a9OmTYV/EYZh7Nixw9bn7Nmz//X4R4wYYWvj7OxsBAYGGu7u7nZ9jR8/3mHbFi1aGIDx3//+1+jSpYsBGC4uLoafn59dLMOHD3fY3mKxGP3797frKzAw0HBycjIAo3fv3kZERIQBGBEREXm6nvz47bffbop7HxoaalgsFqNy5coGYKxevTpb3SeffNIAjHfffddYtWqVra+jR49mq/vKK69ki9fZ2dlW1rp1ayM+Pj5bu+t9P3/++WcjJCTEcHV1NQDD29vbCAkJsXudOHHCrs0PP/xg95y5u7sbnp6etu99fX2NP/74I0/30ers2bO2Z2fAgAH5anu1gvi5eOONN4ymTZva7mNgYKBhMpmMVatWGYZhXPPZvt73Mb/Xl1+5xX29x6z37M033zTCw8Nt9ywgIMDu2cvp933W3yOA4ePjY3h5edmVOfpZuZHn8Hr7FBH5NylZIiJSDOUnWdK1a1fbh55hw4YZ586dMwzDMJKTk41x48bZ/mHbqFEjY+rUqcbUqVONlJSUQr6CTBMmTLD1v2/fvn89/q+//toYMWKEsXnzZiM1NdUwjMwkxpEjR4yXX37ZMJlMhrOzs7F169Zsba0fcAIDAw1/f39j2rRpRlJSkmEYhnHy5EmjU6dOBmA4OTkZBw4cyNZ+/PjxtthfeOEF48KFC4ZhGEZcXJwxcuRI2wfEgkyWpKSkGEePHjU+//xzIzAw0ACMKlWq5Hi/CvPeZ02WGIZhvPfeew6vNSEhwfDx8TGcnJyMEydO5Jos+fzzz23HnnrqKePMmTO2c4wbN86W5OnVq1e2eG70/bS2v9bP5NKlSw0nJyfDxcXFGDJkiHH06FHDYrEYFovF2Ldvn9GjRw8DMPz8/Izjx4/n6V4ahmHMnDnTdu2//fZbnts5UhA/Fz4+PoaPj48xdepU2328ePGicenSJcMwck8e3Mj7mBc3a7LE39/fcHd3N7766isjOTnZMAzDOHHihPHII4/Y4v3ll1/s2q5du9b2XH700Ue2+2sYmff7jz/+MCIiIozo6Gi7djfyHF5vnyIi/zYlS0REiqG8JkumT59u+0f25MmTHdbp1auXARhBQUGFEGnOYmNjjTJlyhiAER4e7rBOUcf//PPP5/iXeusHHMBYuXJltuMpKSlG2bJlDcAYNWqU3bHk5GSjRIkSBmA8/vjjDvseOnSo7fw3mizJ+tfjrK9mzZrl+IG8sO/91cmSEydOGE5OToa3t7dx5coVW73vvvvOAIy2bdsahmHkmCxJSkqy3dM+ffo47DNrcm7z5s12x27k/czaPrefSbPZbFStWtUAjK+//jrHetbRPC+//HKOda723//+1xZ/YX9IzevPxa+//prjOXJKHtzo+5gXWZMlV48Cuvr10ksv5SnuGzmW9Z5NmTIl23Gz2Wzcd999BmDUqlXL7thHH31kAEa7du3yfP03+hxeT58iIkVBa5aIiIhDhmHw3nvvAdC1a1e79UGy6tSpEwCXLl3izJkz/0psFouFxx9/nDNnzuDh4cHEiROz1bkZ4n/wwQeBzDUzctKsWTOHa7O4u7vzwAMPALBjxw67Y0uXLiUmJgaA4cOHOzzv0KFD8fDwuK64r1a6dGlCQkLw9va2lbVq1YrPPvuMihUrZqtfFPe+QoUKtGnThsTERGbNmmUrty7s+uSTT+baftmyZbZ7OnLkSId1nnvuOdvWrT/99JPDOtfzfubVmjVrOHjwIMHBwQwcODDHek888QRAvrZKvnTpku3rEiVKXFd8eZWXn4tatWrZno/8KKj3Ma/OnTuX6+vf3CmqQoUKtvV7snJycuK///0vALt372bnzp22Y9bFmy9cuJDndVxu9Dm8nj5FRIqCkiUiIuLQ+vXrOXjwIACvvfZajvWCgoJsX6enpxd6XAAvv/yybQeWL774gjp16mSr82/Ff+TIEV577TXq1atHQEAAzs7OtoU5O3bsCOS+AGqjRo1yPFa2bFkA24c/K+tithUqVKBKlSoO2/r7+1OvXr18XUtOjh07xtmzZ0lISODcuXN8+umn/P333zRs2NBhsqaonh3rB8XvvvsOgEOHDrF27VoCAwPp2rVrrm2z3tNq1ao5rOPs7Ezr1q3t6l/tet7PvIqKigLg8uXLlC1bltKlSzt8/ec//wHg+PHj19VPQbjRn4tmzZpdV78F9T7mlZE5SjvHV247NBU060KvjoSHh+Pi4gLYX/P999+Ph4cH27ZtIzw8nClTpnD06NFc+7nR5/B6+hQRKQouRR2AiIjcnFasWAFkjipo0qRJjvXOnz8PZP71snTp0oUe12uvvWYbSTJu3LgcRwz8G/HPnz+fPn36kJqaaivz8/PDw8MDk8lEWloasbGxJCYm5ngOX1/fHI9ZP9xcnUiwxlyuXLlc47vWbibXo1SpUgwePJjw8HCaNGnCe++9R8OGDXnooYdsdYrq2Xn44YcJDAwkKiqKgwcP2j6o9unT55qjbPJ7T631r3Y972denT592tb+3Llz16yfnJyc53NnTVzFxMTYEjvXoyB+LkqVKnVdfRfU+3gryu2aPTw8CAoK4ty5c3bXXLlyZSZPnswzzzzD+vXrWb9+PQAlS5akVatW9O3bl86dO9slYW70ObyePkVEioJGloiIiEPWodoNGzbEySnn/7uwbnlap04d3NzcCjWmIUOGMGbMGAA+/fRTBg0alGPdwo7/0qVL9OvXj9TUVFq3bk1kZCRJSUlcvnyZc+fOcfbsWWbPnp3n891qGjZsSPPmzQH45ptv7I4V1bPj7u5Onz59AJg8eTLTp08HcDg14VZknbLQqFGja45osL7yqlatWravt23bdt0xFtTPRUFteS7X9uijj3L8+HG++uorevXqRYUKFbhw4QKzZs2ia9eutGjRgvj4eFv9gngO89uniEhRULJEREQcio6OBiA4ODjHOmazmV9//RXANrS+sLz++ut88sknAHz88ccMHjw41/qFHf/ixYuJj48nMDCQhQsX0qJFCzw9Pe3qnD17Nl/nzCvrX92t15iTax2/Uda/ZB86dMhhv0Xx7FgTI5999hmnTp2idu3a1K9f/5rtrPc0t6khWY9f78iHG2EdfVMY02tatWplS2zNnz//us9TlD8XcGu8j4Ult5/31NRU27o0jq65RIkSPP300/z888+cOHGCQ4cOMXToUEwmE2vXrrVb/6WgnsP89CkiUhSULBEREYesUwayLvx4ta+//pqLFy/i7Oxsm59eGF577TU+/fRTIDNR8vrrr1+zTWHHf/LkSQCqV6+Ol5eXwzrLly/P1znzyvrh/+TJkxw+fNhhnfj4eLZs2VIo/VsdOXIEyD71pCifnfr163PXXXeRlpYGXHth16ztIPND9IEDBxzWMZvNrFq1CoAGDRoUQLT/sCYqchsNYl3H4+zZsze81sbVQkJC6N69O5C56GlO98CRrDEX5c8FFP37WJRWr16d4/Ozdu1aMjIyAPKUPKxcuTKjR4+mb9++QObCuVaF9Rzm1qeISFFQskRERByqUaMGAKtWrSIuLi7b8X379jFkyBAAXnrpJSpVqlQocbz22mt2U2/ykiiBwo/f398fgAMHDpCSkpLt+N9//33DO23kpG3btgQGBgLYdp252scff5yvNSuyMpvN15zCsWLFCjZu3AhkLiyZVVE/Ox999BGDBw9m8ODBPPbYY3lq07ZtW9u6HTn9Rfvrr7+2rddgne5TUPz8/AAc3i+rVq1a2Rb0feWVV2wJoZzkdyHZUaNG4ePjQ3JyMt26dbvmyKTY2Fi6d+9ut+NLUf5cQNG/j0XpxIkTfP/999nKLRYLH3zwAQA1a9bkrrvush3Luq6MI9ZRQVmn093oc3g9fYqIFAX9FhIRKQZiY2O5ePGi7WWxWABISkqyK09ISLC1efTRR4HMEQo9evTgxIkTAKSkpDBjxgzCw8NJTEykWbNmvP/++w77PXbsmG0HjOsZUp11jZKxY8dec+pNVgURf27atWuHk5MTMTExPProo7YPlmlpacyaNYt27drlutjnjfD09GTYsGEAfP/99wwaNMg2iiM+Pp733nuPDz74wLZFZ36dPHmSe+65h6+//pojR45kGznw4Ycf0qVLFwzDoESJErzyyit27Qv73l9Lhw4d+PTTT/n0008pWbJkntp4enrantGZM2fyzDPP2BavTEpKYsKECbY1cnr16lVgOw1Z1a5dG8icxpJTksLFxYWvvvoKFxcX/vzzT+677z5WrFhht2DskSNH+Oqrr2jQoAGTJk3KVwzVqlVjxowZuLm5sXv3burWrctHH31kN83KbDazbds2hg8fzh133MG8efPszlGUPxdQ9O9jUfL39+fZZ5/l22+/tSWqTp48SZ8+fWwjaUaNGmXX5oUXXqBnz57MnTvXbuHXhIQEvvrqK9u6P9btnuHGn8Pr6VNEpEgYIiJy2wsNDTWAa74iIiLs2r3wwgt2xwMCAgwXFxfb9w8//LBx+fLlHPs9evSore6IESPyFfPx48dtbZ2cnIyQkJBcX5988km2c9xo/Nfyxhtv2J3f39/fcHV1NQAjLCzM+PHHH23HrtaiRYtr3pcRI0YYgNGiRYtsx8xms/H444/b3aPAwEDD2dnZAIzevXsbERERDt/Xa8n6vgGGm5ubERwcbHh7e9uVh4WFGVu3bnV4jsK+99Z7Exoamq92q1atssVw9OjRbMdfeeUV23GTyWQEBgbaxd2qVSsjPj4+W7sbfT8PHDhgeHh42D3voaGhRmhoqHHy5Em7uvPnzzd8fX1tMbm6uhpBQUGGu7u73T0fNWpUvu6N1Z9//mlUqVIl2zNQokQJw8nJye7+9OnTx0hLS7NrX9g/F4ZhXPPZvt73MS+s7yNwzd9LISEhRlRUVJ7ivt5j1nv25ptvGs2bN7c9E4GBgXbvw3//+98cz2t9+fj4GAEBAXZlzZs3NxISErK1vd7n8Eb6FBH5N2nrYBERydHnn39OkyZN+Oabb9i+fTtJSUmULl2apk2bMmDAANq1a5dr+6x/IW/cuHG++raOfrF+fa0tKrOOiimo+K/lww8/pFatWkycOJGdO3eSnp5OlSpVePjhhxkyZMgN7SpyLU5OTkyfPp22bdsyadIkdu7cSUZGBvfeey8DBgzgqaeeuu5dYMqWLcvs2bOJjIzkr7/+4vTp07b1RSpWrMjdd99Nly5d6Nu3b7bFO60K+94XlrFjx9KpUye++OILoqKiuHTpEr6+vtStW5fHH3+cJ554olB2aqlatSqrVq1i9OjR/PXXX1y6dMm2xoT1v1Zdu3bl0KFDTJo0iSVLlnDw4EHi4uLw9vamRo0aNGjQgAcffPC6F85t1qwZ+/btY/bs2fz222/89ddfnD9/nitXrlCiRAlq1KhBixYtePzxx6levXq29kX5c2H1b72Pedk691rTVAqKm5sbK1asYMyYMfz0008cOXIEf39/6tevz6uvvurweRg2bBj16tVj1apV7N27l7Nnz5KQkECpUqW4++676dOnT4736nqfwxvpU0Tk32QyjHzsKyciIpIPo0aNYtiwYTRv3py1a9cWdTgiIredli1bsnr1akaMGKEdZERECpDWLBERkUKzcuVKANvigiIiIiIitwIlS0REpFCkpqayfv162rdvT3h4eFGHIyIiIiKSZ1qzRERECoW7u/t1b10rIiIiIlKUivXIkrFjx9KtWzeqVq2Kv78/7u7uhIaG8sQTT7Bz584c202bNo2GDRvi4+NDiRIl6NixI+vWrcu1r6ioKDp27EiJEiXw8fGhYcOGtq3RcnLq1Cn69+9P2bJl8fDwoFq1aowYMcK2HZyIiIiIiIiIFLxivcBrcHAwiYmJ1KlTh3LlygGwe/duDhw4gKurK/PmzeOhhx6yazNo0CDGjx+Pp6cn7dq1IyUlhRUrVmAYBnPmzKFr167Z+pk7dy69evXCYrFw3333ERwczIoVK4iLi2Pw4MF8+umn2docOnSIJk2acPHiRWrXrk3NmjXZvHkzR44coVmzZqxYsQJ3d/dCuS8iIiIiIiIixVmxTpZERUVRr149PDw87MonTZrE888/T0hICKdOncLFJXO20vLly2nbti1BQUGsX7+eqlWrArB+/XpatmyJl5cXR48eJSAgwHaumJgYwsLCiI+PZ+7cuXTr1g3I3GquefPmHDp0iFWrVtGyZUu7GJo3b05UVBQvvfQS48ePBzK3DuzZsyfz58/XiuciIiIiIiIihaRYT8Np1qxZtkQJwHPPPUflypU5d+4ce/bssZWPHTsWgP/+97+2RAlAkyZNeOaZZ4iLi2PKlCl255o8eTLx8fF06dLFligBCAkJ4eOPPwZgzJgxdm02btxIVFQUpUqVstUBcHFx4csvv8TV1ZUJEyaQkZFxA1cvIiIiIiIiIo4U62RJblxdXQFwc3MDIDk52bYF5iOPPJKtvrVs4cKFduWLFi3Ksc2DDz6Ih4cHy5cvt1uHxNqmU6dO2abahISEEB4eTmxsLH/++ed1XZuIiIiIiIiI5EzJEgdmzJjB/v37qVq1qm0Eyf79+0lNTaVkyZKUL18+W5t7770XgB07dtiVb9++3e54Vm5ubtSuXZuUlBQOHDiQpza59SUiIiIiIiIiN05bBwOffPIJu3fvJjExkb1797J7927Kli3LzJkzcXZ2BuDEiRMADhMlAN7e3gQEBBAbG8uVK1fw9fUlPj6ey5cv59qufPnybN68mePHj1OnTp089WUtP378+HVesYiIiIiIiIjkRMkS4I8//mDFihW270NDQ5k+fTr16tWzlSUkJADg5eWV43m8vb2Ji4uzJUusbXJr5+3tDcCVK1fy3JejNrmpVauWw/L9+/fj6elJxYoV83QeERERERERkRtx4sQJvL29OXv2bFGHkitNwyFzlxvDMIiNjWXNmjVUrVqVFi1a8P777xd1aIXKMAzS09OLOgwREZFbjmEY7Nmzh2K8qaCIiMh1SU9PJzExsajDuCaNLMkiICCA8PBwFi9eTJMmTRg2bBjt2rWjQYMG+Pj4AJCUlJRje+sb7uvrC2BrY23n5+d3zTZZ2+XUl6M2udm9e7fDcuuIk5yOi4iIiGPp6em4ubmxfft226LwIiIicm05zXy42WhkiQOurq706tULwzBsu9tYp6qcOnXKYZvExETi4uIIDAy0JTH8/Pzw9/fPtZ21PDQ01FZ2rb4ctRERERERERGRgqFkSQ6Cg4MBuHDhAgDVq1fH3d2dCxcuEB0dna3+1q1bAWyLtFrdfffddsezSk9PZ9euXXh4eFCtWrU8tcmtLxERERERERG5cUqW5GD16tUAVK5cGQBPT09at24NwOzZs7PVnzNnDgCdOnWyK3/wwQftjmf122+/kZKSQps2bfDw8MjWZuHChaSmptq1OXfuHGvXriUwMJBmzZpd17WJiIiIiIiISM6KbbIkKiqK33//HYvFYleenp7O559/zowZM/D09KRXr162Y6+++ioAo0aN4uDBg7by9evX8/XXXxMQEMCAAQPszjdw4ED8/Pz45ZdfmDdvnq38/PnzDBkyBIDBgwfbtWnYsCHNmjXj/PnzvPHGG7byjIwMnnvuOdLT03nppZc0R1pERERERESkEJiMYrqM+7Rp0+jfvz/BwcHUq1ePoKAgLl68yM6dOzlz5gweHh58//339OzZ067doEGDGD9+PF5eXrRt25a0tDSWLVuGYRjMmTOHrl27Zutr7ty59OzZE8MwaNmyJUFBQSxfvpy4uDheffVVxowZk63NwYMHadKkCZcuXeKuu+6iZs2abNq0iSNHjtC0aVNWrlyJu7v7Dd0DLfAqIiJyfawLvKalpemPFyIiIvlwq3wOLbbJkqNHjzJ58mRWr17NkSNHuHjxIm5ublSqVInWrVvz0ksvUaVKFYdtp02bxsSJE9m7dy9ubm40btyYYcOG0bRp0xz7i4qKYtSoUWzYsIG0tDRq1qzJCy+8QERERI5tTp48yfDhw/n999+JiYmhYsWK9OnTh7feestu2s71ulUeUhERkZuNkiUiIiLX51b5HFpskyVy6zykIiIiNxslS0RERK7PrfI51KWoAxAREREREccMw0B/2xSRm5XJZMJkMhV1GIVCyRIRERERkZuEYRhcuXKF+Ph4kpKSMJvNRR2SiEiu3Nzc8PX1JSgoCGdn56IOp8AoWSIiIiIichOwWCycPXuWy5cvF3UoIiJ5lpaWxqVLl0hMTKRixYq3TcJEyRIRERERkZvA5cuXbYmSEiVK4Ovri7u7+207xF1Ebn0Wi4XExETOnTtHSkoKly5dolSpUkUdVoFQskRERERE5CYQGxsLQKlSpQgKCiriaERErs3JyQl/f38ATp8+zZUrV26bZIlTUQcgIiIiIlLcGYZBamoqAH5+fkUcjYhI/nh7ewOZU3Jul0WplSwRERERESliWT9c3C7z/UWk+HBy+ie1oGSJiIiIiIiIiMhtSMkSEREREREREZEslCwREREREREREclCyRIREREREblpmUymYrl9sslkolKlSgVyrmPHjtnuo/Xl7OxMcHAw7dq1Y+7cuTfcR79+/TCZTERGRt54wCI3ASVLREREREREigFvb28iIiKIiIigd+/eVKxYkWXLlvHII48wdOjQog7PpmXLlphMJo4dO1bUoUgxpmSJiIiIiIhIMRAcHMy0adOYNm0aP/74I1u3bmXq1KkAfPzxx+zcufO6zz169Gj27t1Lw4YNCypckSKlZImIiIiISDFmGAb79++/bbb7lPzp168frVq1wjAMfvnll+s+T5kyZahRowZeXl4FGJ1I0VGyRERERESkGBs/fjw1atRg/PjxRR3KDYuLi+Pzzz/ngQceIDQ0FHd3d4KCgmjfvj3Lli1z2KZSpUo5rokSGRmJyWSiX79+duVZ1+dYs2YNrVu3xtfXFz8/Px588EH27NmTY4y///47nTt3JiQkBHd3dypUqMBDDz2U47ohZrOZjz76iGrVqtnqv/HGG6SmpubtpuTBPffcA8DJkydtZRkZGXz++efUq1cPHx8ffHx8aNiwIV9++SVmsznbOXJasyTr/Z08eTJ16tTB09OT0qVL8/TTTxMXF2era11bZfXq1QCEhYXZrbMi8m9SskREREREpBibPHkyAFOmTCniSG7chg0beOmllzhw4ADVq1fn4Ycfpnr16ixdupQHHniA7777rkD7W7hwIa1btyYpKYmOHTtSpkwZFi9ezH333cfZs2ez1R88eDAdOnRg0aJFVK1ale7du1O5cmWioqJ47733HPbRt29fRo0aRfXq1WnXrh1Xrlzh448/ZsCAAQV2HVeuXAHA3d0dyEzQdOnShZdeeolDhw7Rtm1b2rRpw759+3juuefo0aMHFoslX30MGTKE559/njJlytChQwcMw+Cbb76hc+fOtlFNPj4+REREEBISAkD37t1ta6xEREQU2PWK5IVLUQcgIiIiIiJFY9++fezevRuAXbt2sX//fqpXr17EUV2/6tWrs379eho3bmxXvm3bNlq3bs0rr7xCz5498fHxKZD+PvvsM+bOnUvXrl2BzCRDr169mDt3LpMmTeLdd9+11f3hhx8YO3YsZcuWZdGiRdStW9d2LDk5mT///DPb+Y8fP46XlxcHDx6kdOnSABw9epR7772XH3/8kXfeeYfKlSvf0DWkpKTYRt3UqVPHdl2LFy+mVq1arFixwpa8OHPmDK1atWL+/PlMmjSJF154Ic/9zJgxgx07dtier4sXL9KkSRPWrl3LqlWraN26tW1NlZYtW3Lu3Dk+/fTTAtsRSCS/NLJERERERKSYOH/+PL/++qvtNWbMGLvjY8aMsTt+/vz5Ior0+oSFhWVLlEDmNJPnn3+e+Ph4Vq1aVWD99enTx5YoAXB2dubNN98EYM2aNXZ1P/jgAwDGjh1rlygB8PT0pG3btg77mDBhgi1RApnX+NhjjwGwdu3a6449PT2dnTt38sgjj3Ds2DGCgoLo0aOHrU9rrNZECWSuS/LJJ58A5Hva1nvvvWeXiAsODuaZZ54Bst8rkZuBRpaIiIiIiBQTLVq0YN++fTke//bbb/n2229t39eoUYO9e/f+G6EVGLPZzIoVK1i3bh1nzpyxre1x8OBBu/8WhHbt2mUrq1atGpA5CsPq9OnT7N27l4CAAHr27Jnn87u6utKqVas89ZEXx48fd7j2R0hICHPnzsXf358TJ05w4sQJSpYs6fD6HnroIQICAjh06BBnz561S+TkJq/3SuRmoWSJiIiIiEgx0b17d95///181b+VnDp1ioceeojt27fnWMe6PkdBKF++fLYyX19fALsFWK0Lp95xxx35Wqi0dOnSODs756mPvPD29uaRRx4BMkfBBAQEcO+99/Lwww/bdrE5ffo0AKGhoQ7PYTKZCA0NJS4ujujo6DwnS/J6r0RuFkqWiIiIiIgUE6NGjaJOnTo89dRTXL58Ocd6/v7+fPvtt7ZpGbeKgQMHsn37drp3786QIUOoXr06vr6+ODk58c033/D000/na4vkay1i6uRUuKsaFPT5rWuC3Kjr2ZmmsO+VSEFTskREREREpBjp2bMnDRs25N577yU2Njbb8cDAQLZu3XrLLayZmJjIsmXLCAkJ4X//+1+2ERlHjhxx2M7NzQ2AhISEbAu/Zt1K90ZUqFDBFoNhGDf1Nrhly5YFMqfs5MR6rFy5cv9KTCJFQek9EREREZFixsXFxWGiBCA2NhZXV9d/OaIbd/nyZSwWC2XKlMmWKElPT2f+/PkO25UpUwaAAwcOZDtm3SXmRpUtW5Y777yTuLg4Zs+eXSDnLCwVK1akYsWKXLhwgRUrVmQ7vmjRImJjY6lSpUqep+DklzWBlZGRUSjnF8kLJUtERERERIqZnBIHeT1+MypVqhT+/v7s2rWLqKgoW7nZbOaNN95wmAyBzEVvAUaPHo3ZbLaVz5w5k5kzZxZYfEOHDgXg1VdfZceOHXbHsm7fezN48cUXgcxYL1y4YCs/e/Ysr7/+OgAvv/xyofVvHd2yf//+QutD5FqULBERERERKWayJkM6d+7Mvn376Ny5s61s3rx5RRFWrho3bpzja/Lkybi4uDBkyBAyMjJo0aIF7dq1o3fv3lSpUoWvvvqK559/3uF5n3/+eUqWLMmcOXOoWbMmPXr0oG7dujz++OMFmhB44oknePHFF4mOjubee+8lPDycvn370qpVK8qUKWNLQtwMXnnlFTp06MCOHTuoWrUq3bp14+GHH6ZatWrs3buXrl278txzzxVa/9ZnsW/fvvTo0YOBAwcycODAQutPxBGtWSIiIiIiUsz4+fnh4eHBmDFjePbZZzGZTCxYsIBJkybx2muv4e/vX9QhZvPXX3/leKx9+/YAvPXWW5QvX57PPvuMqKgoPD09ad68Oe+++y5bt2512DYkJIQ1a9bw+uuvs3r1aqKjo6lXrx7Lli3DZDIxbty4AruGCRMm0KZNGyZNmsSmTZvYuHEjpUqVonnz5jz55JMF1s+NcnZ25tdff2XSpElMmzaNP/74A4CaNWvSv39/nn766UJdsLVbt26MGzeOb7/9loULF9p2y5k8eXKh9SlyNZORn+Wg5bZSq1YtAHbv3l3EkYiIiNxa0tPTcXNzIy0t7ZZc20FuPhaLxTbloHr16oW+c0haWhpmsxlPT89sx5KTk3F2dratGyEici35+R12q3wO1cgSEREREZFiJrdEiKMEiohIcaM1S0REREREREREslCyREREREREREQkCyVLRERERERERESyULJERERERERERCQLJUtERERERERERLJQskREREREREREJAslS0REREREREREslCyREREREREREQkCyVLRERERERERESyULJERERERERERCQLJUtERERERERERLJQskREREREREREJAslS0REREREREREslCyREREREREbnoxMTGMHDmS+vXrExgYiKenJ2FhYURERLB+/fobOrfJZKJSpUoFEmelSpUwmUwFcq78OnbsGCaTiZYtW173OWrWrInJZKJy5coFF5jILUjJEhERERERuamtWLGCKlWq8M4773Ds2DHCw8Pp0qULfn5+TJ8+naZNmzJo0CAsFktRh3pL27JlC3v37gXgyJEjrFu3rogjEik6LkUdgIiIiIiISE42bdpEx44dSU9P591332Xo0KG4urrajv/555/06dOH8ePH4+zszJgxY/Ldx969e+3OeSNWrFhBenp6gZzr3zZjxgwAypQpw5kzZ5gxYwZNmzYt4qhEioZGloiIiIiIyE3JMAwiIiJIS0tjxIgRDBs2LFtSo3nz5ixduhQPDw/GjRvHhg0b8t1PjRo1CmzaSeXKlalRo0aBnOvfZDabmTlzJgDTp0/HZDIxa9Ys0tLSijgykaKhZImIiIiIiNyUlixZwt69eylbtixvvfVWjvXuvPNOnn/+eQzDYOzYsXbHWrZsiclk4tixY/z00080btwYX19fAgICbHVyWrPEMAy++eYb7r77bjw9PSldujQDBgzg/Pnz9OvXD5PJRGRkpF0bR2uWZF1LJDk5maFDhxIaGoq7uztVqlTho48+wjCMbP2vXbuWF154gTp16tjWaalRowZDhw4lLi7umvcvP5YuXcr58+dp1KgRbdq0ITw8nJiYGBYtWuSw/siRIzGZTEybNo2//vqLBx54gICAAPz8/Gjbtm2uSavFixfTtm1bAgMD8fDwoHr16rleU2JiIkOHDqVSpUp4eHhQpUoV3nvvPdLT03NdI2bv3r3069ePChUq4O7uTkhICL1792b37t05xvbXX3/Ro0cPypQpg5ubG+XLl2fgwIGcOHEi55sntyUlS0RERERE5KZk/aDeo0ePa06TefTRR4HMD/2O1i4ZPXo0jz/+OG5ubjz00EPUrl37mv2/+uqrPP300+zbt48WLVrQokULFi9eTKNGjYiNjc339aSlpdGuXTu+/fZb6tevT6tWrYiOjmbo0KEMGzYsW/3XX3+dKVOm4Onpyf3338/9999PfHw8H330Ec2bNychISHfMeTEOgXnscces/vvDz/8kGu7devWcd9993Hq1Ck6dOhA9erVWb58OS1atGDp0qXZ6o8ePZoHH3yQyMhI6tWrR9euXUlKSuKjjz6iUaNGnDt3zq5+amoqbdq04aOPPuLKlSs89NBD3HnnnXz44Yf07Nkzx7gWLFjAPffcw/fff09wcDCdO3cmLCyMWbNm0bBhQ9asWZOtzaRJk2jatCnz5s0jNDSUrl27EhQUxJQpU6hfv75tPRcpJgwptmrWrGnUrFmzqMMQERG55aSlpRmAkZaWVtShyG3CbDYbe/bsMfbs2WOYzeaiDuem0axZMwMwZsyYcc266enphpubmwEYhw4dspW3aNHCAAwPDw8jMjLSYVvACA0NtStbu3atARglSpQwdu7caStPTEw0HnjgAQMwAGPVqlV27UJDQ42rP2YdPXrUVr9FixbG5cuXbcc2bdpkODs7G15eXsaVK1fs2i1evNiIi4uzK0tJSTGeeuopAzDeeecdh/20aNHC4XXmJD4+3vD09DRcXFyMCxcuGIZhGLGxsYa7u7vh7u5uxMTEZGszYsQI2zW9/fbbhsVisR2bNGmSARhlypQxkpKSbOUbN240nJycDB8fH2PDhg1219SjRw8DMLp3727Xz3vvvWcARsOGDY3Y2Fi7a61QoYIthqvvg7e3t+Hj42MsW7bM7tiSJUsMV1dXo0KFCkZqaqqtfP369Yazs7NRrlw5Y/PmzXZtJk+ebABGo0aNrnUri638/A67VT6HamSJiIiIiEgxtvb4Whp+25C1x9cWdSjZXLp0CYCSJUtes66LiwuBgYEAXLx4MdvxAQMG0KJFizz3/dVXXwHwyiuv2I1C8fLyYsKECTg55f+jlJOTE19//TV+fn62svr169OhQweSkpLYvHmzXf0OHTrg7+9vV+bu7s5nn32Gi4sLv/zyS75jcGTu3LkkJyfzwAMPEBwcDEBAQAAPPvggqampzJo1K8e2oaGhtik5Vs8++yyNGjXizJkzzJ0711Y+ceJELBYLL774Io0aNbK7pokTJ+Lp6cn8+fM5efKk7Zj1fRgzZozd1KlKlSoxfPhwhzF99tlnJCYmMnr0aNq0aWN3rH379jz77LOcPHnSborRhx9+iNls5quvvqJevXp2bQYMGEDnzp3566+/2LZtW473Qm4vSpaIiIiIiBRTFsPCs4ueZdPpTTy3+Dksxu279W7nzp3zVT8qKgrInAJ0tWrVqlG3bt18xxAaGkr16tUdng/gzJkz2Y5FR0fz1VdfMWjQIJ588kn69evHs88+i5ubGwcPHsx3DI5Yp9o8/vjjduXW761TdBzp3r07Li7ZN1nt06cPkLnuipX1a+uUqaxKlSpFu3btsFgstnt//PhxoqOjKV26NM2bN8/WplevXg5jsk7/6datm8Pj4eHhAGzcuBEAi8XCihUr8PLy4oEHHshTG7n9aetgEREREZFiau6euey+kLnY5a7zu5i3dx6P1HykiKP6R1BQEAAXLly4Zt2MjAzbOiLW0RFZVaxYMV99WxMXFSpUcHi8YsWKbN26NV/nLF++vMNyX19fIHN9jqzGjh3L0KFDC3Ur4ujoaFatWoWfn1+2hFLHjh0pUaIE69at4+jRo4SFhWVrHxoa6vC81gVzT58+bSuzfu1oMd2s5dHR0cC13wPrQr1XLwx77NgxAMqVK+ewnZV1BNLFixdt67+4ubnlqY3c/pQsEREREREphiyGhXdWv2NX9s7qd+h2ZzecTDfHAPS7776bqKgoNm/ebFtwNCe7du0iLS0Nf39/hx/qPTw8CivMPMvP1J0NGzYwePBg/P39GT9+PC1btqR06dK4u7sDULZsWYcjUfLrxx9/tC2I27Zt22zHLRYLhmHwww8/OFyEtiDltKtNflmvJyIiItd61qlA1vo+Pj5079491za1atUqgAjlVqBkiYiIiIhIMZR1VInVzTa6pGPHjkyaNIk5c+bwySef5Lojzk8//QRAu3btrms9kauVKVOGY8eOcfLkSYdTZ7Kuq1EY5s+fD8D777+f7UN/cnIyZ8+eLZB+rFNw4uPjbdNfcqrnKFly/Phxh/Wt5WXLlrWVlS1blqNHj3L8+HFq1qyZrc3VI0LKlCkD5Hyvr1y54nC74fLly3P48GHGjBljG52Um+DgYDw8PHBycmLq1KkFlrSRW9vNkTIWEREREZF/1ecbP89XeVHo0KEDNWrUIDo6mg8//DDHevv372fixImYTCZeffXVAum7WbNmAHYLlFodOnSo0Bf6tE4pcjR1Z/bs2RiGccN9bN++nZ07dxISEkJGRgaGYTh8hYWFceDAAf76669s55g3bx5mszlb+c8//wxgt9aIdd2PmTNnZqt/4cIF/vjjD0wmk+3eh4aGUq5cOc6ePcu6deuytZk9e7bD67KOkLEmnK7FxcWFli1bEh8fz4oVK/LURm5/SpaIiIiIiBRD7au0JywgjEoBlWyvsIAwHqjseIHLouDk5MT06dNxc3NjxIgRfPDBB2RkZNjVWbduHW3btiU5OZlBgwbRuHHjAun76aefBjLXDdmzZ4+tPDk5mZdeesk2daOwWBd9nTJlit2aJXv27OGNN94okD6sC7f27NkTZ2fnHOv17t0b+GcUSlbHjh3jnXfsp3N98803rF+/npCQELtpLc8//zxOTk5MmDDBbueftLQ0XnzxRZKTk+nWrZvdGiXPPPMMAIMHD+by5cu28uPHj/Puu+86jHfw4MF4enry2muvMW/evGzHU1NTmTNnDqdOnbKVvf322zg5OdG/f38iIyOztUlISOC7774jOTnZYZ9yGyq6XYulqN0q+1uLiIjcbNLS0gzASEtLK+pQ5DZhNpuNPXv2GHv27DHMZnNRh3PTWbZsmREYGGgARnBwsNG5c2ejV69ext13320ABmC8+OKLDu9dixYtDMA4evRojucHjNDQ0GzlgwYNMgDD3d3daN++vdGzZ0+jTJkyRmhoqNGpUycDMKKiouzahIaGGld/zDp69KgBGC1atHDY/4gRIwzAmDp1qq3s4sWLRunSpQ3ACAsLM3r27Gm0adPGcHV1NXr06HFd/WSVkZFhlClTxgCMdevW5Vp3x44dtntv/b1njfk///mP4erqatSqVcvo06eP0aBBAwMwXF1djSVLlmQ71/vvv28AhouLi9GmTRujd+/eRoUKFQzAqFq1qnH27Fm7+ikpKUbjxo0NwAgKCjIeeeQRo1OnToa3t7fRuXNno2LFioarq2u2fhYsWGB4eXkZgFGlShWjU6dORu/evY3w8HDD29vbAIxt27bZtfnyyy8NZ2dnAzBq165tdOvWzejVq5fRqFEjw93d3QCM2NjYa97b4ig/v8Nulc+hGlkiIiIiIiI3tTZt2nDw4EGGDx9OhQoViIyMZMGCBcTGxvL444+zbt06JkyYUCBrlWQ1duxYvvrqK6pVq8aqVauIjIykXbt2bNiwwTbCIC9rYlyPoKAgNm3aRN++fUlLS+PXX38lOjqa9957z+E0lvxasWIFZ86coVKlSjRp0iTXunfddRe1atXi4sWL/P7773bHmjZtyurVqyldujS//fYbe/fu5f777ycyMpL27dtnO9dbb73Fb7/9RosWLdi0aRPz5s3D3d2dIUOG8NdffxESEmJX393dnWXLljFkyBC8vb359ddf2b17N4MHD+Z///sf586dc/gedOnShR07dvDcc89hMplYtmwZixYt4vz583Tq1IlZs2ZlWzflmWeeYfPmzURERHDlyhV+++03/vjjDxISEnj00Uf57bff8Pf3z+stllucyTAKYLKb3JKsKznv3r37GjVFREQkq/T0dNzc3EhLS8t1wUmRvLJYLOzfvx+A6tWrF/iHfilYCQkJhIWFkZKSQlxcXK5TWG5XI0eO5J133mHq1Kn069evSGLYsGEDTZo0oX379ixZsqRIYpBM+fkddqt8DtVvYREREREREQf27t1LUlKSXVl8fDxPPfUUFy9epHfv3sUyUfJv27ZtW7Y1Yo4cOWJbV+Za20qLXA9tHSwiIiIiIuLA+PHj+eGHH6hXrx5lypTh4sWLbNu2jZiYGO644w4++OCDog6xWOjTpw+XL1/mrrvuIigoiBMnTrBlyxZSU1Pp3Lkzffv2LeoQ5TakZImIiIiIiIgD3bp14+zZs2zZsoWNGzcCEBYWxsCBAxkyZEihrVci9l588UVmzZrFjh07iImJwcPDg7p16/LYY4/xzDPPYDKZijpEuQ1pzZJi7FaZKyYiInKz0ZolUtC0ZomI3Mq0ZomIiIiIiIiIyG1OyRIRERERERERkSyULBERERERERERyULJEhERERERERGRLJQsERERERERERHJQskSEREREREREZEslCwREREREREREclCyRIRERERERERkSyULBERERERERERyULJEhERERERuenFxMQwcuRI6tevT2BgIJ6enoSFhREREcH69etv6Nwmk4lKlSoVSJyVKlXCZDIVyLny69ixY5hMJlq2bJnnNv369cNkMjFt2rRCi6ugWWOOjIy0Ky/Ke38tJpPJ7uXk5ERAQADh4eFMnjwZwzBu6PwjR4685d7Hm52SJSIiIiIiclNbsWIFVapU4Z133uHYsWOEh4fTpUsX/Pz8mD59Ok2bNmXQoEFYLJaiDlUkVxEREURERPDoo49Ss2ZNoqKi+M9//kPfvn2LOjSbnJJRxY1LUQcgIiIiIiKSk02bNtGxY0fS09N59913GTp0KK6urrbjf/75J3369GH8+PE4OzszZsyYfPexd+9eu3PeiBUrVpCenl4g55L8uRXu/dUjP5YtW0bHjh35+eefefTRR3nooYeu67wvvPACvXv3pkyZMgUQpYBGloiIiIiIyE3KMAwiIiJIS0tjxIgRDBs2LFtSo3nz5ixduhQPDw/GjRvHhg0b8t1PjRo1qFy5coHEXLlyZWrUqFEg55L8uRXvfdu2bXn88ccBWLBgwXWfJzg4mBo1auDv719AkYmSJSIiIiIiclNasmQJe/fupWzZsrz11ls51rvzzjt5/vnnMQyDsWPH2h1r2bIlJpOJY8eO8dNPP9G4cWN8fX0JCAiw1clpzRLDMPjmm2+4++678fT0pHTp0gwYMIDz58/na92MrGuJJCcnM3ToUEJDQ3F3d6dKlSp89NFHDtesWLt2LS+88AJ16tSxrdNSo0YNhg4dSlxc3DXvX2FYtGgRTz75JHfeeSd+fn54e3tz991388EHH5Campqt/rRp0zCZTIwcOZITJ07Qt29fSpYsiaenJ/Xr12fhwoU59vXdd99Rt25d273v168fZ8+ezbF+Qd57gNWrV9O6dWt8fX0JDAykY8eObN682e6aCsI999wDwMmTJ+3KZ8yYQfPmzfHz88PLy4s6deowevRoUlJSsp0jpzVLsj7/CxYsoHHjxnh7e1OiRAn69OnDqVOn7OqbTCa+//57AFq1amW3zsqxY8cK5HpvFZqGIyIiIiIiN6VFixYB0KNHj2tOk3n00UcZM2YMS5cuxWKx4ORk/3fh0aNHM3nyZJo1a8ZDDz2U7YOpI6+++iqfffYZbm5utGrVCn9/fxYvXszKlSupU6dOvq8nLS2Ndu3asWfPHlq2bEliYiKrV69m6NChXLlyhVGjRtnVf/3119m+fTt16tTh/vvvJyUlha1bt/LRRx/x22+/sWHDBnx8fPIdx40YMGAAycnJ1K5dmzp16nD58mU2btzI22+/zYoVK1i6dCnOzs7Z2h07dowGDRrg6+vL/fffz4kTJ1i/fj1du3ZlyZIltGvXzq7+0KFD+eijj3B1dbXd+yVLlrBq1SruvvvufMed33s/b948evbsidlspnHjxlSqVImdO3fSvHlz+vfvn+/+c3PlyhUA3N3dbWVPP/0033zzDR4eHrRu3RovLy8iIyN56623WLhwIcuXL8fLyyvPfUyaNImxY8cSHh5Ox44d+euvv/j555/ZsmUL27dvx9PTE8hcU+XPP//k8OHDPPDAA5QuXdp2jn/7WStyhhRbNWvWNGrWrFnUYYiIiNxy0tLSDMBIS0sr6lDkNmE2m409e/YYe/bsMcxmc1GHc9No1qyZARgzZsy4Zt309HTDzc3NAIxDhw7Zylu0aGEAhoeHhxEZGemwLWCEhobala1du9YAjBIlShg7d+60lScmJhoPPPCAARiAsWrVKrt2oaGhxtUfs44ePWqr36JFC+Py5cu2Y5s2bTKcnZ0NLy8v48qVK3btFi9ebMTFxdmVpaSkGE899ZQBGO+8847Dflq0aOHwOh2JiIgwAGPq1Kl5qr9gwQIjKSnJriw+Pt546KGHDMD4/vvv7Y5NnTrVdu2DBw+2e77HjRtnAEZ4eLhdm/Xr1xsmk8nw9/c3tm7daiu/cuWK0bp160K/95cvXzZKlChhAMaPP/5od75hw4bZzjdixIhr37D/Z21zNYvFYjRp0sQAjLffftswDMOYM2eOARhly5Y1Dhw4YKsbFxdnNG/e3HYvsxoxYoTD99H6/Ht5eRnr1q2zlScmJhpNmzY1AGPKlCl2bazPxNX3Nzf5+R12q3wO1TQcEREREZFi6P334Y47ICzsn9cdd2SW3ywuXboEQMmSJa9Z18XFhcDAQAAuXryY7fiAAQNo0aJFnvv+6quvAHjllVeoXbu2rdzLy4sJEyZkG7mSF05OTnz99df4+fnZyurXr0+HDh1ISkpi8+bNdvU7dOiQbQ0Kd3d3PvvsM1xcXPjll1/yHcON6tKli20UgpWvry/jxo0DyDGmsLAwPvjgA7v79sILLxAYGMiGDRtIS0uzlX/55ZcYhsHLL79sm6ICmSMbPv/88+vaHjg/937WrFnExMRw//33Z9ulZvjw4YSGhua7/6uZzWYOHjzIk08+yfr163F3d7eNWJkwYQIAI0aMoGrVqrY2/v7+fPHFF5hMJr7++muH03Fy8sorr9CkSRPb915eXrz66qsArFmz5oav53akaTgiIiIiIsXQH3/A0aPZy5cuhbff/vfjKWydO3fOV/2oqCggcwrQ1apVq0bdunXZunVrvs4ZGhpK9erVHZ4P4MyZM9mORUdHs3DhQvbt20d8fLxte2Q3NzcOHjyYr/4LysGDB1m8eDGHDh0iMTERi8ViW/cjp5hatmyJm5ubXZmLiwthYWFs3bqVS5cu2XZyWbt2LQC9e/fOdp6aNWty99138/fff+cr5vzc+9zeexcXF7p3755tbZy8cpTo8fX15fvvv6dy5cqkp6fbFil+9NFHs9WtU6cOderUYfv27fz99980btw4T/1ePc0Jcn/uRMkSEREREZFi6cUX4f8/k2Yrv1kEBQUBcOHChWvWzcjIIDY2FsjcGeRqFStWzFff1g+QFSpUcHi8YsWK+U6WlC9f3mG5r68vQLYFUseOHcvQoUNvmu1wDcPgtddeY9y4cTkuimpdf+Nq+bn206dPA+Q4gqNSpUr5Tpbkp/+8vPfXKyIiAsgc6eLn58ddd91Ft27dbKOiLl26RFpaGsHBwXh7ezs8R6VKldi+fTvR0dF57tfR9ef03EkmJUtERERERIqh7t2hVi3Yvfufstq1oVu3oovpanfffTdRUVFs3ryZxx57LNe6u3btIi0tDX9/f8LCwrId9/DwKKww8yw/U3c2bNjA4MGD8ff3Z/z48bRs2ZLSpUvbFgEtW7bsvz4i4H//+x9jx46lQoUKjBs3jiZNmlCyZElcXV1JS0vD3d09xyTK9UxbKkhF3b/V1bvVXI/rnYYk+aM7JiIiIiJSDDk5wYgR9mUjRmSW3yw6duwIwJw5c645uuKnn34CMqcbFMQHQ+uUkJx2zcnLbjo3Yv78+QC8//77RERE2La7BUhOTs51C93CjunLL7+ke/fulC1b1rZL0ZEjRwqsH+u9P378uMPjOZUXdP9F8d4HBQXh5ubGxYsXSUxMdFjHuoVvuXLlCi0OKcbJkqSkJBYsWMCAAQOoXr06Hh4etj3C3333XRISEnJsO23aNBo2bIiPjw8lSpSgY8eOrFu3Ltf+oqKi6NixIyVKlMDHx4eGDRsyffr0XNucOnWK/v37U7ZsWTw8PKhWrRojRozI10I+IiIiIiI5sY4ugZtvVAlkLnBao0YNoqOj+fDDD3Ost3//fiZOnIjJZLItWnmjmjVrBsDcuXOzHTt06BDbtm0rkH5yYp1S5Gj6xOzZs3McwVGYcotp1qxZBdZPeHh4jufct29fvqfg5Fdu773ZbGbevHmF1rerq6ttHZKff/452/Fdu3axfft2fHx8qFu3bqHEYF1bJiMjo1DOf6sotsmSn376iYcffpjvvvsOZ2dnOnfuTHh4OEePHmXEiBE0aNCA8+fPZ2s3aNAg+vfvz65du2jTpg0NGzZk2bJl3HfffSxYsMBhX3PnzqVFixb8/vvv1KlTh/bt23Pw4EEiIiJ47bXXHLY5dOgQ99xzD9OmTSMoKIguXbpgNpt59913adOmjeaViYiIiMgNc3KCL7+EBg1g0qSba1QJZE4dmD59Om5ubowYMYIPPvgg2we4devW0bZtW5KTkxk0aFCeF7y8lqeffhrIXDdkz549tvLk5GReeukl20KrhcW6+OaUKVPsRtXs2bOHN954o1D7vlZM33zzjV2yZu3atXzyyScF1s8zzzwDwGeffcb27dtt5YmJibz44ouFnijq0aMHJUqUYNmyZdkSFqNGjeKoo5WRC9CL/79w0MiRI+1G7Fy5coUXXngBwzB4+umnC21qWdmyZYHMJGRxdpP9Ovz3uLq68tRTT7Fnzx727NnDrFmz+P3339m/fz/33HMP+/btY9CgQXZtli9fzvjx4wkKCmL79u0sWLCA33//nTVr1uDs7Ez//v2Ji4uzaxMTE8OTTz6J2Wxmzpw5REZGMmfOHPbt20eVKlUYM2YMkZGR2eLr168fFy9e5KWXXmLnzp3873//Y//+/Tz88MNERUUxevTowrs5IiIiIlJshIfDxo2Z/70ZNWjQgEWLFhEQEMDbb79NmTJl6NKlC71796Zu3bo0a9aMkydP8uKLL/Lpp58WWL/h4eEMGjSIS5cuce+999KhQwd69epF5cqV2bNnD506dQLItsNLQenfvz+lS5dm4cKFVK9enV69etG2bVvq1q1LeHh4gWxfm9V7771H48aNHb4efvhhAF566SW8vb2ZNGkStWvXpk+fPtx33320aNHCluAoCE2bNuW1114jLi6OBg0a0L59e9u9P3DggO3eFxZ/f3++/fZbnJ2d6dOnD02bNqVv377cddddfPDBBzz11FNA4b33jzzyCE899RSnTp2idu3aPPTQQ/Ts2ZPKlSuzevVqGjduzLvvvlsofQN06tQJk8nEa6+9RteuXRk4cCADBw60beVdXBTbZElERARff/01d955p115mTJl+OKLLwCYN2+e3X7f1u2h/vvf/9rtd92kSROeeeYZ4uLimDJlit35Jk+eTHx8PF26dKFblnGNISEhfPzxxwCMGTPGrs3GjRuJioqiVKlStjqQuU3Vl19+iaurKxMmTCj2w6JEREREpHho06YNBw8eZPjw4VSoUIHIyEgWLFhAbGwsjz/+OOvWrWPChAkFvojl2LFj+eqrr6hWrRqrVq0iMjKSdu3asWHDBpKTk4F/duwpaEFBQWzatIm+ffuSlpbGr7/+SnR0NO+99x4zZ84s8P6OHDnCX3/95fBlnXJUrVo1Nm/eTKdOnbh48SK//vorCQkJfP311wU6sgTgk08+4dtvv+XOO+8kMjKSyMhI2rZty/r16ylRokSB9uVIt27dWL58OS1btmTHjh0sWrSIsmXLsnbtWttuOIX13gN8/fXXTJ8+nXvuuYfVq1ezcOFCSpUqxfvvv8/KlSvx8vIqtL7r1avHDz/8QM2aNVm6dClTpkxhypQpOe50dLsyGUUx2e0ml5SUZNum6fTp05QpU4bk5GQCAwNJTU3l5MmT2ebprV271pZVzTpSpEWLFqxZs4YZM2ZkW8Hbulo3ZM7/sw6jGjFiBO+++y4DBgxg8uTJ2eK7//77WblyJatWraJly5bXfZ21/n+C6u6sS6CLiIjINaWnp+Pm5kZaWpptcUORG2GxWGxD3qtXr66dK25yCQkJhIWFkZKSQlxcHM7OzkUdkvyL2rdvzx9//MGGDRto1KhRUYdzU8jP77Bb5XOofgs7YJ0X5urqasta7t+/n9TUVEqWLOlwQaN7770XgB07dtiVW+fYWY9n5ebmRu3atUlJSeHAgQN5apNbXyIiIiIiUnD27t1LUlKSXVl8fDxPPfUUFy9epHfv3kqU3Kaio6M5d+6cXZnFYmHcuHH88ccfVKtWjYYNGxZRdPJvcCnqAG5G48ePBzIzhtbtuU6cOAE4XvkZwNvbm4CAAGJjY7ly5Qq+vr7Ex8dz+fLlXNuVL1+ezZs3c/z4cerUqZOnvqzled0yy5q5u9rhw4epXLlyns4hIiIiIlLcjB8/nh9++IF69epRpkwZLl68yLZt24iJieGOO+7ggw8+KOoQpZCsXbuWxx57jHvuuYfQ0FBSU1PZtWsXx44dw8vLi8mTJ2MymYo6TClESpZcZfHixUyZMgVXV1fee+89W7l1K+Hc5oZ5e3sTFxdnS5Zk3X44p3bW6T5Z539dqy9HbUREREREpGB169aNs2fPsmXLFjZu3AhAWFgYAwcOZMiQIYW6ZoUUrXr16vHEE0+wdu1a9u/fT0pKCqVLl+bxxx9n6NCh1KxZs6hDlEKmZEkW+/bt47HHHsMwDD755BPuvvvuog6pQOQ0FyynESciIiIiIgLt2rWjXbt2RR2GFIGqVavy3XffFXUYUoS0Zsn/i46Opn379sTGxvLqq6/y8ssv2x338fEByDZnMavExEQAfH197drk1u7qNnnpy1EbERERERERESkYSpYAMTExtGvXjuPHj9O/f3+H+7Nbt4c6deqUw3MkJiYSFxdHYGCgLYnh5+dn2+0mp3bW8qz7pF+rL0dtRERERERERKRgFPtkSUJCAh06dGDPnj1069aNb7/91uFCPdWrV8fd3Z0LFy4QHR2d7fjWrVsBbIu0Wlmn8liPZ5Wens6uXbvw8PCgWrVqeWqTW18iIiIiIiIicuOKdbIkNTWVLl26sHHjRh544AFmzpyZ49Zfnp6etG7dGoDZs2dnOz5nzhwAOnXqZFf+4IMP2h3P6rfffiMlJYU2bdrg4eGRrc3ChQtJTU21a3Pu3DnWrl1LYGAgzZo1y+ulioiIiIiIiEgeFdtkidlspk+fPqxcuZLw8HDmzZuHm5tbrm1effVVAEaNGsXBgwdt5evXr+frr78mICCAAQMG2LUZOHAgfn5+/PLLL8ybN89Wfv78eYYMGQLA4MGD7do0bNiQZs2acf78ed544w1beUZGBs899xzp6em89NJLuLq6Xt/Fi4iIiIiIiEiOiu1uOBMnTmT+/PkABAcH89xzzzms9+mnnxIcHAxAmzZtePnllxk/fjx169albdu2pKWlsWzZMgzDYOrUqQQEBNi1L1GiBN999x09e/bkkUceoWXLlgQFBbF8+XLi4uJ49dVXadmyZbZ+p06dSpMmTRg/fjwrV66kZs2abNq0iSNHjtC0aVPefPPNAr0fIiIiIiIiIpKp2CZLYmNjbV9bkyaOjBw50pYsAfjss8+oW7cuEydOZNmyZbi5udGmTRuGDRtG06ZNHZ6je/furFmzhlGjRrFhwwbS0tKoWbMmL7zwAhEREQ7bVK1alW3btjF8+HB+//135s+fT8WKFRk2bBhvvfUW7u7u13nlIiIiIiIiIpIbk2EYRlEHIUWjVq1aAOzevbuIIxEREbm1pKen4+bmRlpamqbFSoGwWCzs378fyNxYwMmp2M6WF5FbUH5+h90qn0P1W1hEREREREREJAslS0REREREREREslCyREREREREbnoxMTGMHDmS+vXrExgYiKenJ2FhYURERLB+/frrPm+/fv0wmUxERkYWXLCF7OOPP8ZkMmEymVizZk1RhyNyW1KyREREREREbmorVqygSpUqvPPOOxw7dozw8HC6dOmCn58f06dPp2nTpgwaNAiLxZKtbcuWLTGZTBw7duzfD7yQzJgxw/b1Dz/8UISRiNy+lCwREREREZGb1qZNm+jYsSNxcXG8++67nDlzhl9//ZWff/6Z7du3s3btWsqXL8/48eN5/fXXizrcQvf333+za9cuQkJCcHJyYvbs2aSmphZ1WCK3HSVLRERERETkpmQYBhEREaSlpTFixAiGDRuWbQeq5s2bs3TpUjw8PBg3bhwbNmwoomj/HdZRJQMHDqRly5bExcWxcOHCIo5K5PajZImIiIiIiNyUlixZwt69eylbtixvvfVWjvXuvPNOnn/+eQzDYOzYsQAcO3YMk8nE6tWrAQgLC7Ot82EymRyeZ82aNbRu3RpfX1/8/Px48MEH2bNnT479/v777zz44IOULFkSd3d37rjjDl599VUuXbqUrW7WtVH++OMPWrVqRUBAACaTibi4uDzdD7PZzMyZMwF47LHHeOyxxwD7aTlZWe9By5YtiY+P5+WXX6ZChQp4eHhw5513Mm7cOIdTlwBOnjzJ008/TWhoKO7u7pQqVYpu3bqxadOmHOObN28ejRs3xsvLi+DgYHr06MGhQ4cYOXIkJpOJadOmZWuTlJTE6NGjueeee/Dx8cHHx4fGjRvz/fff59hPTEwMb775JjVr1sTT0xN/f39at27Nb7/9lmMbkfxSskRERERERG5KixYtAqBHjx7ZRpRc7dFHHwVg6dKlWCwWfHx8iIiIICQkBIDu3bsTERFhe11t4cKFtG7dmqSkJDp27EiZMmVYvHgx9913H2fPns1Wf+jQoXTo0IHly5dTvXp1OnfujIuLC+PGjaNRo0acO3fOYZw//fQTHTp0IDExkQ4dOtCgQYMckzdXW7FiBWfOnKFevXrUqFGD7t274+npyZIlSxwmaKxSU1Np3bo106dPp2HDhrRt25bjx4/z6quv8uSTT2arv3PnTu69916++eYbPD096datG1WrVmX+/Pk0bdqU2bNnZ2szfvx4unfvzqZNm2jUqBFt27Zly5YtNGzYkKNHjzqM6/z58zRp0oS33nqLs2fP0qJFC+677z727dtHv379ePHFF7O1OXDgAHXr1uXDDz8kOTmZBx54gPr16/PXX3/RqVMnPv300zzdS5FrMqTYqlmzplGzZs2iDkNEROSWk5aWZgBGWlpaUYcitwmz2Wzs2bPH2LNnj2E2m4s6nJtGs2bNDMCYMWPGNeump6cbbm5uBmAcOnTIVt6iRQsDMI4ePeqwXUREhAEYTk5Oxvz5823lGRkZRvfu3Q3AGDZsmF2bWbNmGYBRu3Zt4+DBg7Zyi8ViDB8+3ACMXr16OewHMH7++ec8XH12jz32mAEY48aNs5X17NnTAIwvvvgiW/2jR4/a+qxTp45x4cIF27FDhw4ZZcuWNQC767ZYLMZdd91lAMaQIUMMi8ViOzZnzhzDycnJ8PHxMU6fPm0rP3z4sOHm5ma4ubkZK1eutJWnp6cb/fv3t8UwdepUu/g6duxoAMbLL79spKSk2MrPnj1r1K9f3wCMJUuW2MozMjJssX388cd2PysHDx40wsLCDGdnZ2Pnzp15u6FSYPLzO+xW+RyqkSUiIiIiIsXYxXPriPytNRfPrSvqULKxjpYoWbLkNeu6uLgQGBgIwMWLF/PdV58+fejatavte2dnZ958802AbNvzvv/++wDMnDmTKlWq2MpNJhMjR46kbt26zJkzx2EcDz74IL169cp3fImJicyfPx9nZ2f69OljK7/WVByrTz/9lODgYNv3lStXZtiwYQBMnDjRVh4ZGcnOnTupWLEio0aNshv10r17d7p27UpCQgLfffedrfy7774jLS2Nxx9/nFatWtnKXVxcGDt2LD4+Ptni+fvvv1m8eDENGjRg7NixuLu7246FhITwzTffAPDll1/ayhcuXMjOnTvp3r07r7/+Ok5O/3ycrVKlCmPGjMFsNvPtt9/mei9E8kLJEhERERGRYsowLPy9fjCxF7eyff1rGIbj9SuKg3bt2mUrq1atGgBnzpyxlZ0/f57t27dTtWpVateuna2NyWSiWbNmmM1mtmzZku14586dryu++fPnk5iYSNu2bW1TiwDat29PcHAwGzZs4NChQw7blihRgrZt22YrtyZd1q1bZ1u7ZO3atQD07NnT4dSnxx9/3K4eQFRUFJA5XepqAQEBDu/t0qVLAejatatd0sPKuobJxo0bs7Xp1q2bo8skPDwcwK6NyPVSskREREREpJg6ffxXrsTtBSA+bg+nj99cu6oEBQUBcOHChWvWzcjIIDY2FsBuBEVelS9fPluZr68vgN3WvMeOHQPg4MGDdgvGZn198cUXgOMRLhUrVsx3bPDPyBHrSBIrV1dX20iVH374wWHb0NBQh+X+/v4EBASQnJxsu3enT58GoFKlSg7bWMujo6NtZdZkUoUKFRy2cXTN1vv49ttv53gfExIS7O6htc2jjz7qsL51BNL1jCwSuZpLUQcgIiIiIiL/PsOwsPfvj+zK9v39EWVDO2Ey3Rx/U7377ruJiopi8+bN2ZIEV9u1axdpaWn4+/sTFhaW774cjW5wxDoCo3Tp0jzwwAO51nWUpPDw8Mh3bGfOnGHFihUAjBs3zm5qCvyTTPrhhx8YOXJkvs+fH3ldjPZarPexefPmVK5cOV9t2rdvbze65mrXkywTuZqSJSIiIiIixVDWUSVW1tEl5Sp1KaKo7HXs2JFJkyYxZ84cPvnkk1x3xPnpp5+AzOk0eU18XA/rCJTg4GCHW+EWhp9++gmz2QzgcGqP1eHDh1m3bh1Nmza1Kz9x4oTD+vHx8cTFxeHp6UlAQAAAZcuWBeD48eMO21hHd5QrV85WVqZMGfbv38/JkyepWbNmtjYnT57MVma9j127dmXw4ME5XpOjNgMHDqR79+55aiNyvW6OlLGIiIiIiPyrDu/9Ol/lRaFDhw7UqFGD6OhoPvzwwxzr7d+/n4kTJ2IymXj11Vftjrm5uQGZ03QKQvny5alRowZ79uzhwIEDBXLOa7FOr/ntt98wDMPhyzqixNFCr5cuXbKNTMnq559/BqBJkyY4OzsD/6z7MXv2bFuCxlEs1noAzZo1A2Du3LnZ6l++fNm21khW1jVU5s+fn8NVZ3c9bUSul5IlIiIiIiLFUEi5Nnj5hOLlUzHLK5SQcvcXdWg2Tk5OTJ8+HTc3N0aMGMEHH3yQLemxbt062rZtS3JyMoMGDaJx48Z2x60jJfbv319gcQ0bNgyLxUL37t35+++/sx2/dOlSge3IsmvXLv7++29KlCjhcKFUK+tirbNmzSItLS3b8ddee822uxDA0aNHeffddwF4/vnnbeUtW7bkrrvu4tixYwwfPhzDMGzH5s+fz7x58/Dx8eHJJ5+0lffv3x83NzemT59ut3OQ2Wxm8ODBXLlyJVs8jRo1om3btkRFRfH8888THx+frc727dv5/fffbd93796dmjVr8uOPP/Lee+/ZrSUDYBgGUVFRtgVnRW6EpuGIiIiIiBRD1esMpnqdvE1/KEoNGjRg0aJF9OzZk7fffptx48bRtGlTPD092bdvH9u3bwfgxRdf5NNPP83WvnPnznz//ff07duXdu3a4e/vD8DkyZOvO6a+ffuye/duPvjgA+rVq0fdunWpXLkyhmFw+PBhduzYgY+PD//5z3+uuw8r60iRRx55JNdpSNWqVePee+9l69atLF682G4b5MaNG5OWlkaVKlVo3bo16enprFixgqSkJB577DG73WVMJhM//vgjrVq14oMPPmD+/PnUrVuXEydOEBUVhYuLC1OmTKFMmTK2NpUrV+bjjz9m0KBBtGrVihYtWhASEsLGjRuJiYnhscce44cffrCN8rH64YcfaN++PZMmTeKnn36ibt26lC1blsuXL7Njxw5OnjzJyy+/TPv27YHMrYgXLFjAAw88wPDhw5k4cSJ16tShVKlSXLx4kb///pvz588zbtw422gXkeulkSUiIiIiInJTa9OmDQcPHmT48OFUqFCByMhIFixYQGxsLI8//jjr1q1jwoQJDtcq6datG+PGjaN8+fIsXLiQKVOmMGXKlBuO6f3332f16tV0796ds2fPsmDBAlatWoXZbObZZ5/l119/veE+LBaLbS0W68iR3FjrXD0Vx93dnZUrV9K3b182bNjAH3/8QYUKFfj0008drrty1113sXXrVv7zn/+QkJDAnDlz2L9/P127diUqKoqePXtma/Pyyy8zZ84c6tevb+ujbt26/PXXX7ZFba27G1mVKlXK9t7VrFmTbdu2MWfOHHbs2MEdd9zBJ598wmuvvWbXpmrVqmzbto1Ro0ZRvnx5NmzYwLx58zhw4AD33HMPX3zxxTUXAxbJC5ORdVyVFCu1atUCYPfu3UUciYiIyK0lPT0dNzc30tLScv1Lr0heWSwW2zSR6tWrF+oCpVJ8HDt2jLCwMFq0aEFkZGSRxGA2m6lTpw579+7l9OnTlC5dukjikMKVn99ht8rnUP0WFhERERERkRty+PBh4uLi7MpSU1MZMmQIe/bs4f7771eiRG4pWrNEREREREREbsjs2bMZMWIE9erVo0KFCsTHx7N9+3bOnDlDcHAwEydOLOoQRfJFyRIRERERERG5Iffffz/bt29nw4YN7Nixg4yMDMqVK8ezzz7Lm2++SYUKFYo6RJF8UbJERERERETkNlSpUiX+rSUqGzRowMyZM/+VvkT+DVqzREREREREREQkCyVLRERERERERESyULJERERERERERCQLJUtERERERERERLJQskREREREREREJAslS0REREREREREslCyREREREREREQkCyVLRERERERERESyULJERERERERERCQLJUtEREREROSmFxMTw8iRI6lfvz6BgYF4enoSFhZGREQE69evv+7z9uvXD5PJRGRkZMEFW8AiIyMxmUy0bNmyqEPJM2vM/fr1sysfOXIkJpOJadOmFUlcubE+C1lfnp6e1KhRg1deeYWzZ8/e0PmPHTt2y72PxZmSJSIiIiIiclNbsWIFVapU4Z133uHYsWOEh4fTpUsX/Pz8mD59Ok2bNmXQoEFYLJZsbVu2bInJZOLYsWP/fuByS2rWrBkRERFERETQqlUrzp8/z2effcY999xz0zxHOSWjpOC4FHUAIiIiIiIiOdm0aRMdO3YkPT2dd999l6FDh+Lq6mo7/ueff9KnTx/Gjx+Ps7MzY8aMKcJo5VpeeOEFevfuTZkyZYo6lBwNHDjQLglx4cIFOnbsyObNm3nttdeYM2fOdZ23XLly7N27Fy8vrwKKVAqTRpaIiIiIiMhNyTAMIiIiSEtLY8SIEQwbNswuUQLQvHlzli5dioeHB+PGjWPDhg1FFK3kRXBwMDVq1MDf37+oQ8mzkiVL2pJwixYtIj09/brO4+rqSo0aNahYsWJBhieFRMkSERERERG5KS1ZsoS9e/dStmxZ3nrrrRzr3XnnnTz//PMYhsHYsWOBf9aHWL16NQBhYWF2a1E4smbNGlq3bo2vry9+fn48+OCD7NmzJ8d+f//9dx588EFKliyJu7s7d9xxB6+++iqXLl3KVjfr2ih//PEHrVq1IiAgAJPJRFxcXD7uyrUdOnSIkSNH0qRJE0qXLo2bmxvly5fniSee4MCBAw7bmEwmKlWqhNls5qOPPqJatWq4u7tToUIF3njjDVJTUx222717N127diUwMBBfX1/Cw8P5/fffc4wtpzVLsk6XWrBgAY0bN8bb25sSJUrQp08fTp065fB8Fy9e5Nlnn6Vs2bJ4enpSu3ZtvvjiCwzDsF1TQbjnnnsASElJ4eLFi7byPXv28Oijj1KmTBnc3NwoV64cTzzxBPv37892jpzWLJk2bRomk4mRI0dy4sQJ+vbtS8mSJfH09KR+/fosXLjQrn6/fv1o1aoVAN9//73dcz1y5MgCuV5RskRERERERG5SixYtAqBHjx7ZRpRc7dFHHwVg6dKlWCwWfHx8iIiIICQkBIDu3bvb1qGIiIjI1n7hwoW0bt2apKQkOnbsSJkyZVi8eDH33Xefw4U9hw4dSocOHVi+fDnVq1enc+fOuLi4MG7cOBo1asS5c+ccxvnTTz/RoUMHEhMT6dChAw0aNMgxeXO9Jk+ezLvvvktiYiINGjSgc+fO+Pn5MWPGDBo0aMCOHTtybNu3b19GjRpF9erVadeuHVeuXOHjjz9mwIAB2epu3ryZxo0b88svv1C+fHkeeughkpOT6dixI7Nnz76u2CdNmsQjjzyCp6cnHTt2xMfHh59//pnWrVuTnJxsV/fixYs0bdqUr776CpPJROfOnSlbtiyvvPIKr7zyynX1n5MrV67YvnZ3dwcy19KpX78+P/30E2XKlKF79+6UKlWKGTNmUL9+fdauXZuvPo4dO0aDBg3YuHEj999/P/fccw9btmyha9euLF261FavefPmPPDAAwBUrlzZ7rmuW7fujV+sZDKk2KpZs6ZRs2bNog5DRETklpOWlmYARlpaWlGHIrcJs9ls7Nmzx9izZ49hNpuLOpybRrNmzQzAmDFjxjXrpqenG25ubgZgHDp0yFbeokULAzCOHj3qsF1ERIQBGE5OTsb8+fNt5RkZGUb37t0NwBg2bJhdm1mzZhmAUbt2bePgwYO2covFYgwfPtwAjF69ejnsBzB+/vnnPFz9P1atWmUARosWLfJUf/369caRI0eylX/33XcGYLRq1SrbMWtsd955p3HmzBlb+ZEjR4yAgIBs99VisRg1a9Y0AGP48OF25/riiy9s54uIiLA7NmLECAMwpk6daldufZ+8vLyMdevW2coTExONpk2bGoAxZcoUuzYDBgwwAKNz585GcnKyrXzLli2Gv7+/ARihoaE53qerWd+jq2MzDMP46quvDMAoV66cYRiGkZCQYISEhBiAMXHiRLu6Y8eONQCjfPnydnEdPXrU4fs4depU2/0aPHiw3e+AcePGGYARHh5u18b6TFx9f4tKfn6H3SqfQzWyRERERESkGFr82RnebriTtxr883q74U4Wf3amqEOzsU5nKVmy5DXruri4EBgYCGA3TSKv+vTpQ9euXW3fOzs78+abbwKZ03Oyev/99wGYOXMmVapUsZVbp0HUrVuXOXPmOIzjwQcfpFevXvmOLz8aN25MWFhYtvL+/fvTrFkzIiMjuXz5ssO2EyZMoHTp0rbvw8LCeOyxxwDsRkpERkayZ88e7rjjDoYPH253jueee45GjRpdV+yvvPIKTZo0sX3v5eXFq6++Cti/DwkJCfz44484Ozszfvx4PDw8bMfuvfdeXnjhhevq/2oXLlxg6tSpDBkyBIBnn30WgFmzZnHu3DmaNGnC888/n+0a6tWrx6lTp5g7d26e+woLC+ODDz7Ayemfj+kvvPACgYGBbNiwgbS0tAK4IskrJUtERERERIqh3ZHxXDyRxqWT/7wunkhjT2R8UYdWJNq1a5etrFq1agCcOfNPAun8+fNs376dqlWrUrt27WxtTCYTzZo1w2w2s2XLlmzHO3fuXIBR5ywhIYGZM2fyxhtv8J///Id+/frRr18/zpw5g2EYHD58OFsbV1dX21oYWTm6D9bEySOPPIKzs3O2Nn369LmuuPP6PmzZsoWUlBQaNGjgcF2SG0lI9e/f37YGSKlSpXjyySeJj48nIiKCoUOHAv9cv3X619UcJZiupWXLlri5udmVubi4EBYWRnp6usO1cKTwaOtgEREREZFiqPWTpTi0ISFbeasBpYogGseCgoKAzL/uX0tGRgaxsbFA5o4r+VW+fPlsZb6+vgB2i5seO3YMgIMHD15zrRFHI0v+jZ1QVq5cSe/evXO9b1nX4LAqXbq0w8SHo/tw+vRpAEJDQx2e/3oXVs3r+2BNnFSoUMHheW7kPjdr1sw2YsjDw4PQ0FA6dOhgtx6I9fpzuk5reXR0dJ77dXTt4Pj6pfApWSIiIiIiUgzd81AAZat7cHp/iq2sbA0P7nkwoOiCusrdd99NVFQUmzdvtv2lPie7du0iLS0Nf39/h1NQriXr1IfcWCwWIDOxYF1kMyeOEglZp4sUhoSEBHr27ElMTAzDhw+nd+/ehIaG4unpiclkom/fvsycORPDMLK1zes9KEw3QwwDBw6kX79+N3SO61m092a4dvmHkiUiIiIiIsWQk5OJhwaX5ZunjtjKHhpcFiengt2Z5UZ07NiRSZMmMWfOHD755JNcd8T56aefgMxpHIX5odP61//g4OBs29/eDNauXculS5d45JFHeOedd7IdP3LkiINW+VemTBkAjh8/7vB4TuUFxdr/yZMnHR7PqbyglC1bFsj5Oq0jkMqVK1eocUjhUepKRERERKSYso4ugZtvVAlAhw4dqFGjBtHR0Xz44Yc51tu/fz8TJ07EZDLZFgO1sq4BkZGRUSAxlS9fnho1arBnzx4OHDhQIOcsSNapSI6mdBw6dIitW7cWSD/h4eEAzJ071zbaJquff/65QPrJSb169fDw8GDz5s2cOHEi2/FZs2YVav/W6585c6bD4z/88INdvYJW0M+1ZKdkiYiIiIhIMeXkZKLvRxWpVNeLvh9WvKlGlUDmtITp06fj5ubGiBEj+OCDD7J9OFy3bh1t27YlOTmZQYMG0bhxY7vj1hEA+/fvL7C4hg0bhsVioXv37vz999/Zjl+6dIlvv/22wPrLD+tiqPPmzbNbsyQuLo4BAwaQnp5eIP20bNmSGjVqcPjwYUaNGmV37Ouvv2b9+vUF0k9OfHx8ePTRR8nIyODll1+2W89j+/btfP7554Xaf8+ePQkJCeHPP//km2++sTs2YcIENm/eTLly5ejevXuh9F8Yz7XY0zQcEREREZFirGpjX978/c6iDiNHDRo0YNGiRfTs2ZO3336bcePG0bRpUzw9Pdm3bx/bt28H4MUXX+TTTz/N1r5z5858//339O3bl3bt2uHv7w/A5MmTrzumvn37snv3bj744APq1atH3bp1qVy5sm2XmR07duDj48N//vOf6+7Dka1bt2ZLBmU1adIk6tevT9u2bVm2bBnVqlWjZcuWQOZWv8HBwXTp0oVffvnlhmNxcnJi2rRp3H///YwYMYI5c+ZQu3ZtDh06xObNm3nuueeYNGnSDfeTmw8//JDVq1ezYMECKleuTPPmzYmLi2PlypU8/fTTTJw4MdvuMgXF29ubH3/8kU6dOvH000/zzTffUK1aNfbt28e2bdvw8fFh5syZhbZGTaVKlahTpw6bN2+mYcOG1KpVC2dnZzp37vyv7bh0u9PIEhERERERuam1adOGgwcPMnz4cCpUqEBkZCQLFiwgNjaWxx9/nHXr1jFhwgSHa5V069aNcePGUb58eRYuXMiUKVOYMmXKDcf0/vvvs3r1arp3787Zs2dZsGABq1atwmw28+yzz/Lrr7/ecB9Xu3LlCn/99VeOr/j4zG2ff/nlF95++21KlizJkiVL2LJlC71792bDhg0EBAQUWDyNGjVi/fr1dOrUiRMnTvDrr7/i4uLCwoUL6dGjR4H1k5Pg4GDWrVvH008/jdlsZsGCBZw4cYJPPvmEIUOGAP/sqFQY7r//fjZt2kSfPn04deoUc+bM4ezZszz22GNs3ry50KbgWM2dO5euXbty5MgRpk+fzpQpUwpsmpWAyXC0DLIUC7Vq1QJg9+7dRRyJiIjIrSU9PR03NzfS0tJyXXBSJK8sFottOH316tW1K4bIDfr555/p06cPzzzzDF9++WVRh3Pby8/vsFvlc6h+C4uIiIiIiMgtacuWLdnK/v77b15//XWAa245LZITrVkiIiIiIiIit6RmzZpRunRp7rzzTvz8/Dh69ChbtmzBYrHwwgsv0KxZs6IOUW5RSpaIiIiIiIjILenNN99k8eLFbN68mbi4OHx8fLjvvvsYOHAgjz76aFGHJ7cwJUtERERERETkljRixAhGjBhR1GHIbUhrloiIiIiIiIiIZKFkiYiIiIiIiIhIFkqWiIiIiIiIiIhkoWSJiIiIiEgRM5lMtq/NZnMRRiIikn8Wi8X2ddbfZ7cyJUtERERERIqYyWTC3d0dgPj4+CKORkQkfxITEwFwc3O7bZIl2g1HREREROQmEBgYyNmzZzl//jwZGRn4+vri7u5+23zwEJHbj8ViITExkXPnzgHg6+tbxBEVHCVLRERERERuAv7+/qSkpBAXF0dMTAwxMTFFHZKISJ55eHgQFBRU1GEUGCVLRERERERuAk5OTpQuXRpvb2+uXLlCYmKi1i8RkZuem5sbvr6+BAUF4ezsXNThFBglS0RERETktpOamkp6ejoZGRlkZGRgNpttX0NmYsL6cnd3x8PDAw8PD5ycinZJP5PJhJ+fH35+fgAYhoFhGEUak4hITkwm0207VVDJEhERERG5paw9vpbBSwczpt0YwkPDSU9PJzEx0fZKSkoiPT0Vw5KBgRnDYsEwzBhGBoZhHanhlPmPfJxxcnbF5OSGs7Mb3t7eBAQEEBgYaFtwtSjdzh9ERERuZkqWiIiIiMgtI8OcwVNzn2LfmX0MPDuQWV1mkZ6WhtmcgjkjBYs5BbM5GQwLLi5OmC0WDIsZJydnnJxNmADDAIvFjMViwWKAxWwmPcOMCWcSvQOIjfHllKsPB5MOM2bXGMY9NI7w0PCivnQREfkXKVkiIiIiIje1jIwMLl++TFxcHHO3zeXQgX14meB8wgF+3/ED9UPq4uJswtnFCRdnJ9zdnABT5vQbp3QySMeCBeP//2cxGeCU+bUJJ1xwxhUnTBlmEuLPkZZ2igyzhQ+2fsru2BP8J/4/7Bm6BydTwU3RuXp0jIiI3FyULBERERGRm4Y1ifBRq4+o5VeLuLg44uPjMWckkpaWwOwtEwlxM+HkBiY3WHj6fzQufxe4GKSQTrqRTlpGGmmkk046Ts4mXN1cMxcdNGWuVWIyOYEJTCYwLGZSM1Iwm82kp6VjuIAH7uw5vYvL5pOEuJg4fHw/Xy3/imfbPFsgU2IshoVnFz3L7gu7eW7xc2x/ZnuBJmJEROTGKVkiIiIiIjeF9Ix0/vO//7D/5H6eOjKQ7zt9iyUjkdTUeAxLBtsubeGi5ync/f5JWJwxR7M0dil1ytyFq5srru5ueLh74Ofuh4ubKy753JkhPT2d5KRk/tj2B64lTDh5GJSMMTH299HcH3o/1atVv+HrnLtnLrsv7AZg1/ldzNs7j0dqPnLD5xURkYKjFLaIiIiIFKnLly9z+PBhxs4bw7Ej+wnIgMT4o0QemEdqyiWcnTNw8jazLPZ3nFyzj+zYFreNilUqUqZiGYJDgvAL8MPD0yPfiRIAV1dX9l7ay9mEMwA4e5lwC4KklGi++n0SMTEx2dqsPb6Wht82ZO3xtdc8v8Ww8M7qd+zK3ln9DhbDku9YRUSk8ChZIiIiIiL/OrPZzPnz5/l+6fc0/6Qxy/6ew5xtkyjpYcIv0IRHaVhy+RfiPWM543aGS+4x1Ch3J8HeJQn2KUnJ/3+V8ilFnQp3AXDw4Eq2//oiBw+uvKHYlu5eZve9s6cJF2+IPPUrf/75J2az2XbMOqVm0+lNPLf4uWsmPbKOKrGyji4REZGbh6bhiIiIiMi/JjU1lfPnz3Pp0iWSk+P4bNVwYhNO8vWOT4nzvIRblik2p5NOs8+8n+Y1muHi4kKfsN70obfD85qNDFL3ziXEycLFvXMxV7kPZ9P1/VO3ToW7iE2IwcCwlRmeBhWSy3D68imOHTtG5cqVgfxPqfl84+c5lmsqjojIzUPJEhEREREpdFeuXOH8+fPExsaQlhpH/OUzbDi5llink7iVhninGJzIPsXmz2N/0rJ2i2uef8/2uZR0yhzVEexkYc/2udxVt5ft+L6z+/lp/Y/0bfIoNUrnvu5Il7pd6FK3S7byAzuPcubEOY4cPUJoaChOzk4Op9R0u7Nbjgu2tq/SnlPxp+wSMSZMPFD5gWteo4iI/HuULBERERGRQmGxWIiJieH8+fMkJFwm8cp5YmOjwTDj5uvM8pQlOPv8kyBxwgkL/0xj8ffw567ytbOd9+rEh9nIwHRijd0Ec9OJNZjv7o6zyQULFqaunUp03Cmm/TmNDx55H6frmI0eVCqQs6dPcCnpEpcvX2bl2ZU5TqnJaZTIW+Fv8Vb4W/nuW0RE/l1as0RERERECpTZbOb06dPs3LmTQ4d2c/zoNg4fXMeluKO4BJqxlEllfeo6ziSdsWuXNVEC4OvpR6e6nbLVmbp2KkcuHmHan9OwkDmKJNjJgmFkjtYwDMM2ugRg05FNRMedAuBU7Ek2Hd10Xdfl7OKEu6cbyZZkkpOTc51SIyIitzYlS0RERESkQFgsFs6dO8f0pdPpOKk1y7f9zNFDm0kyX8StvIm0kGQsQWYCygewLWbbNc/nKLHhKPGRcXIdACaTye6/GafWYcHCvC3z7c4xf8uCbImZvHBycsLVzYUUSwopKSm0r9KesIAwSvuUxs3ZjdI+pQkLCNOUGhGR24CSJSIiIiJyQwzD4OLFi+zatYsDB3cxYdVwLiUcYM6ZGThXtJBeMhmvEE8qVK1ASPkQvH28qVPhLgI8A3FxcsHfMwBXJ1eH5162e7nt62yJDwt8vvRzThhuXMqwEGuGOIvJ9srwC+WXrb/YkitW1zu6xGy2ACacnJ0wmUy8Ff4Wh146RJBnEGnmNIK9gjn00iFNsxERuQ1ozRIRERERuW6xsbGcPn2amJiznD97mL9OryHWLRrXADjPGY5YDhNeJRwnk5PdWiOd6nYicm8kGZYM3J3daHtvW9bsW2238CkWqB5YnZgLMaSlpLHt6N9EHz4FBmStNjv2DDiDq5srLzzwAnWr1cXZyRkLFr6a+h+HcS/bvZxGYY3yda1pqelYDCc8XD1wdnYG8r8bjoiI3BqULBERERGRfIuPjyc6Oppz56I5f+4we85vYfmVPwjwiOOVit4sjE/laLqZJft+p1RQKWZumEl8yhUuJlxg2p/T6HJPZy4kXADgfMJ5SvuXZnS30SQnppCanELSlSSSk5LJSEvm6N69mNNS2LRvGSVMJkwmMAFOJjAMMANms0FGUjrfL/oWp7inCS4dzKmMU6RmpNpi9vPww93FHRMmhwvHXktaShpp6QZenl64ublhMSz53g1HRERuDSbDuhKWFDu1atUCYPfu3deoKSIiIlmlp6fj5uZGWloarq6Op4/crhITE4mOjmbJtkVM2zKBTuXup3LFSnx17AsupJxncLAXpV2dOZNuZuzFJAwykxTxKfGOT5iW+XJOd6b3Pb0I8QzgxIWjbDu1ibtL16RkYDAmdxPObib2nd/HvjN7MUwWTE5kZkwMMMz//8oAIw3uLlsfd7cSLD6yArNPhu3Pg+UDK1z3TjgWi4WDu05w+pwZL28fZpyeQZc7uzAickS2urN7zNboEhGRHNwqn0OV8hYRERGRa0pLS+Pw4cNs2bKZrVtWMW3TR8Q4HWeZeRHHvY5yPuU8d3m4UNo1c3pKGVdn7vLIzFJkS5SkAwnAJXC+DF4p4Gex8OeuBVxJi2ZnzHqS3S+xL2Mnvnd4UiLMjxKhAZQLLQOuBiYXU+awElPmf02uJpw8TDj7mHApYeJg0i42HVuBR0YGXCZz6AmO1yrZd3Y/w+cPZ9/Z/ble/9+HdzJ+xSSOXz7JxEMT2XpuKx9FfeSwrnbDERG59WkajoiIiIjkyDAMzp07x9GjRzkdfYC4yyfZk7GTy/7nqerpQiefBFYcmEuYqzO9/T3s2j7o687uFAtmLGABUoFkcDKDhwncTSZcXcHkDk5ukOGWzKozy0l2SsbkZOJyymUupcRQucQdnLl0hrXb1+Yp5jSnVJwDDHxiTWSkG6QmAb6Zx37d+qttrRLrNsTRcaeY9uc0WtVoyaxNs+jVsBftarWznc+Che9XzOBwzGmOW2YT6xELQFJ6EqW8S+Hl6mWra8Kk3XBERG4DSpaIiIiIiEOJiYkcOnSI48cOcenSITI8knENNbFhbxROLia6+7tT2tWZ9iYzHp7uuDmZMAzDtnVvkIsTtdyc2BFjgRRwBbxMJtxdobyfE61KurM2MZXojH9mhSenJdvFsGHneiqVrcSabWtIy0jLe/BOJpz9MhMmqSkGeANOEJcUhwULTjhl24b4pw0/YTbMzNwwk9Y178fFlDlKZsOBvzh97gxJFjCbYu26KeVdiu3PbNcaJSIit5li/Vt9y5YtfPjhh3Tr1o3y5ctjMpls/+eem2nTptGwYUN8fHwoUaIEHTt2ZN26dbm2iYqKomPHjpQoUQIfHx8aNmzI9OnTc21z6tQp+vfvT9myZfHw8KBatWqMGDGClJSUfF2niIiISH6YzWaOHj3KmtWRzFvzHaPWv8xRj31cKRPD13u/4mzCmWxTbgJdMr+++t9SD/m6454CgSYTJVxNePqCaxC0C/GgjJszrX09svWfVXxSPBt2rifmSgzlXJ3oE+BBOdd//glbpUIV/Lz88HDLfh6TqwkXZ3A1kbk2CnA55TKbjm7Kvg0xYDYy5+ukW9L5318/A5mjSmavmUey2cDsCrjb92HdAUdERG4vxTpZ8t577/Hmm28yf/58oqOj89Rm0KBB9O/fn127dtGmTRsaNmzIsmXLuO+++1iwYIHDNnPnzqVFixb8/vvv1KlTh/bt23Pw4EEiIiJ47bXXHLY5dOgQ99xzD9OmTSMoKIguXbpgNpt59913adOmDampqQ7biYiIiOTX2uNrafhtQ9YeX8ulS5dYs2YN66KWc+T0BhZemMlFn9NExq1gwb4FnE84jwlo5+OWp3P7u5gI8DDhEQAuQeDsZaKquwvBLpn/DA12caKqm3Ou59hxaAcArX0yR7K09vknY3Hs9FFa1muJi3MOA6Zd/v8fvFm2NJi/ZQF/HdloG1XiyPLdy8kwzGw8vJFTp09zxULm6BQHtEaJiMjtp1gnS5o0acKwYcP49ddfOXPmDO7u7rnWX758OePHjycoKIjt27ezYMECfv/9d9asWYOzszP9+/cnLi7Ork1MTAxPPvkkZrOZOXPmEBkZyZw5c9i3bx9VqlRhzJgxREZGZuurX79+XLx4kZdeeomdO3fyv//9j/379/Pwww8TFRXF6NGjC/BOiIiISHFlMSw8u+hZNp3YRP8p/Vm6dDEHjq7jgnGAzc7ruex5CZOziejL0UTHZf5xyTqqJC+bKjo7mWhd1g0ndxOZ29dAY2/7RMvV3ztS1c3ZLsHSLzBzhEmG2czSDX+QkJxgV982CsUz+z93T8We5Of/HzmSE+vokt82/E5qBqQ7AZ72dVydXAkLCNMaJSIit6FinSx54403ePfdd+nUqROlS5e+Zv2xY8cC8N///peqVavayps0acIzzzxDXFwcU6ZMsWszefJk4uPj6dKlC926dbOVh4SE8PHHHwMwZswYuzYbN24kKiqKUqVK2eoAuLi48OWXX+Lq6sqECRPIyMjI/0WLiIiIZDFn9xx2H9kNF+D8hcOM2vwyJzz2U61RGOvOO15QtblX5nbJeZm+DFDH09WWvGjklTmqxJpoMQwjT6NLrk6oBLr8M8IkJT37iFvrKJS2we6ZKZqr8jpxCbGU9ClJSZ+SOfYZuSeS8q4VwdUf/xL+1lyPTbolnY/bfsxb4W/lGruIiNx6inWyJD+Sk5NZuXIlAI888ki249ayhQsX2pUvWrQoxzYPPvggHh4eLF++3G4dEmubTp06ZRvtEhISQnh4OLGxsfz55583cEUiIiJS3F1JuMIbP72BWwKEOJvw9zKR5B/HiktL+e3AIjIsjv8wsy/VzKUMCzFpFpIyDMxG5ivdYsGSJQli/a+rk4mHfDOTFw29MpMe1kSL9b91PV1t5796bRLrqJKrR7IEuzjRyDP79Juso1BKujtT3c8lc3XZLMyYubPMnfh4+ODq5JrtHAClnctT078+o5t/QtWyVR3W0RQcEZHbk3bDyaP9+/eTmppKyZIlKV++fLbj9957LwA7duywK9++fbvd8azc3NyoXbs2mzdv5sCBA9SpU+eabazlK1euZMeOHbRs2fK6r0lERESKn7XH1zJ46WBeqf4Km3ZsJC72GCXdTLj4Z64nAnAh4QLLdy1zfAILrDyXxsrkNLxM4OVkwtkDnL3A5GKih78H5d2csyVDvJwzkxcuJhMWw8DJZMJsGCRYMhMgx9LNti5a+7gT7OJEO193UiyG7a97jkayNPR2469k+6TO1aNQ2oS4sSM24+rBJaw5uCbb+cJcnenk584vMSl4p/vjZAmgZrmadC7ZmUvbL2FkOYu2CRYRuX0pWZJHJ06cAHCYKAHw9vYmICCA2NhYrly5gq+vL/Hx8Vy+fDnXduXLl2fz5s0cP37cliy5Vl/W8uPHj1//BYmIiEixYzEsPP3L0+w9uJeBWyO4wysQX28TLgFgcrZPRFh3hrGTAiSCuwE+ziZc3MDZJzNJYnUs3YzvVefydTLhlCXRYf3a2WRibUIqB9P+6SvrqJAAZydwhkSLhctmS7bzQGby5akSniy6kkp0usVuFIrJlLmVcRkPZ+7ycGFHSu5TmE1g2w65u78Hw3b9Tb9aQ6lZsyZNA5oyrOWwXNuLiMjtQ8mSPEpIyFw0zMvLK8c63t7exMXF2ZIl1ja5tfP2zlxW/cqVK3nuy1Gb3NSqVcth+eHDh6lcuXKeziEiIiK3trXH1/LYj49x4sQJfEzg75JBouclgoMDsVjMXEnN5d8VGUAiOKeBj5MJD1dw9gWTW/aRHpuS0tmUlG77vqqbMw/557w9cHMvNw7GJ2dODneCxoHZF3v1dnJiS2Ia9XJYCNbb2YnWPu7MiE22Tee5emRLMy/XayZLsm6HXNbTmaalArm71t0EBATk2k5ERG4/SpaIiIiI3OaSU5J5fPLjRJ8/QbCzCQ93cAkEk6tBQvIVArwDwVGyxACSgSTwArydTTh7gbM3kMfFXZtcY6ebAFcnaro4cyjBTJiP/aiQrOp4Ol5XxMq6SKxtZIsBhgUsgOEE+1MdjJTJwgR08PMi60qwHcumUzG0Qq7tRETk9qRkSR75+PgAkJSUlGOdxMREAHx9fe3aWNv5+flds01e+nLUJje7d+92WJ7TiBMRERG5fZw+fZqxv4zl3IXjlHIx4eoLzn7/jLgwYyY2MSZ7w3QgAVzM4OdkwtXBlJvclHN14j4vN9yvXZWGwa6cS7dQL9DxLjvWRWLN/7/Aq3MOiZrG3m6sTEilipszOy+mU8PflV/jUjlqyj1RApmjSko6G/bTd1zNLFg/jEeaf5iHqxARkduJdsPJo4oVKwJw6tQph8cTExOJi4sjMDDQlsTw8/PD398/13bW8tDQ0Dz35aiNiIiISFYWi4W///6bP1b+wZz9U/g/9v48vM67vvP/n/d9n33ROTraZXm342xOnH0jCaRJygBpEmhpod9pA2EGOmVKG+YHAwO0DTDttKVtGpZSCslMyzYwkDSlC4GEACH7vtnxbms/ks6+L/fvj6MjHUlHi23Zku3X47p0ybrPvXyOkuuy9PL78363uQzcHeAIGXPCiCrV6S9sIA1GHIIViDgM3C3gCBtLC0qqQA6u87rpdlmYQKpUJVeZ3V51ms8ysYIGQ9UKqXKVcnXmuUZDj5N81SZRqZKt1tY8ewTxmyen7rypy81an8XbO9yzJ/7OYBkWfpefq+eZ0jO05x8Wf88iInLKUViyRNu2bcPtdhONRhkYGJjz+rPPPgsw1aS17vzzz5/xeqNSqcTLL7+Mx+PhjDPOWNI1Cz1LRERETm8/O/gzLv3Kpfxw5w/50Y9+xBMvPsojw/+PipXA1Qmme5GwowzEwZmHiGXg8xk4I2B6Fr6uPur3fMvBu0IervQ5aHfXfsz0OUyey5YozJpF0zgG2G0a3NTiZrRi80/JPC/GSyRKVRLl6oxgBGr9SX6WLjJRrl0/O9xoqU/dMWtf9zhrzV1nc1kufu2SX+N/v+9/8+Xf/jI5ax3jBRgrwHjFYLxqMl41cUWaTycUEZFTm8KSJfJ6vVx33XUAfOc735nz+ne/+10AbrrpphnH3/rWt854vdE///M/k8/nuf766/F4PHOueeCBBygUCjOuGRkZ4Wc/+xmtra1cddVVx/CORERE5FRStav8zg9+h6cOPcX77nkfLw89zUT1dV4pPoOzbe60mznyQBz8FWh1GLhC4GgxwJx7XT0cWeOs/Sh5nb9WzXFN2EW3x+Litpl9Si4KOAlb5oyAZHZ1S4tlcqnPCYbBS4ky9x7I8bWxHF+byJGtzjiVy/0uDpQqU9tyKnat2qRiN69euSHgmqouCXlC/Nolv8bX3vs1bt5xMwD7dx3EYbwZh+8vufHNL/C+22O8770TvO+9E7z/Vx5Y+PsmIiKnJIUlR+COO+4A4DOf+Qy7d++eOv7YY4/x5S9/mXA4zO233z7jmve97320tLRw//33873vfW/q+OjoKB/5yEcA+PCHPzzjmksvvZSrrrqK0dFRPvrRj04dL5fL/Jf/8l8olUr83u/9Hk7nwo3ORERE5PTxnZe/wysDr8AYxJOHeT39OBe84WwK7sycYAJgo9Pi99p8bHRYkAQrBa2GQcBj4GydvwpljdPk1pCHbqfFdX43W8sW7c6Z1RyNPUVs28Y/We3RbB2NwpbJWtOkOtmYFZMZo4Dr92t3mHgbnmMZBnvyZazJXiP18+qfG6tLelp7p0ISgOH+UQ7tHKLLeSaXXHiZtjmLiAhwmjd4/cEPfsCnP/3pqa+LxSIAl19++dSxT37yk1OVHtdffz0f+tCHuOuuu9ixYwc33HADxWKRBx98ENu2ueeee+aMlotEInzta1/jne98J7/6q7/KG9/4Rtra2vjRj35EPB7njjvu4I1vfOOctd1zzz1cccUV3HXXXTz00EOcffbZPPXUU+zbt48rr7ySj33sY8v/DREREZGTUjqT5mMPfAzGIWxAwG3wiv0CZ4xvIFPMzDnfAN4RqlWD/HqLm7wfXomXOK/Nyc9yBQZK8/cXeXPQjXMypGh3mlzbvvC0m6lGsrY9FWYsFJps9znZWS2DA9a4TG4Mumfcp/559nSc7fOMDG4cHfxa0WB737lT18SicXY/v58Oxxmcfeb5an4vIiJTTuuwJBqN8sQTT8w53ngsGo3OeO2v//qv2bFjB5///Od58MEHcblcXH/99Xzyk5/kyiuvbPqcd7zjHfz0pz/lM5/5DI8//jjFYpGzzz6bD37wg/z2b/9202u2bt3Kc889x6c+9Sn+7d/+je9///usW7eOT37yk3z84x/H7V5Kb3kRERE51Y2MjPA3P/wbDhzcT7tl4PWCIwKDqX6+8fg3ml6z3eOg22kB0O6ufe72mjgMgxstD3nb5qeZIgOlmftftrqsqZ4gdUHn4oXKFdsmV7UJWHObyzaybZtWp0lfwCLtsLk15JkKZuoyldqa/JY5Y3KNyzTIlqu4TQPDqAVCNpC3IVe1eb1Q4ZaLbpmqKomPxXnl6ddpZS0b157FRRddtOj7EBGR04dh2/Ns7pRTXv1fT+YbLSwiIiLNlUolXC4XxWJxxbbFVioV9u/fzwu7XuAjP/kw2ewhXAGwQo3TYxxU7PKM6wzgwxEf3ZMhyXzGylX+IZZreCDc3ualpSEcWaxKpNH+QpkNLmtJ5/fnKrS4jDnBTH1d+apNn2vu+ovVWmhSsm2chsFQqcr/znsxMbn2rGungpKx4TF2P3+AYKmHdb3beeMb36h/iBIROUFOlt9DT+vKEhEREZGTUalUYufOnTy35zkOp/Zwae9GXs9mcbZMhwvFcpFEPjHzQhuu9nbQ7c4vGnS0O0y2uix2FytQhK2mNSMogelQprHCY757djvMRc+pVG3SFZs0VfqsuSFUvV/Ja/kSicrksyu1ChKHMV3lUq9G6XGa3L7xCrbv+PXJt28z0j/KgZcHCJXWsH7tebzhDW9QUCIiInMoLBERERE5ieRyOV577TWe3vs0Y8XDdHQ6eM9Vv0kw5Adg5/AuvvHY1ylXyzPDkiqQhPNCGWBuhUezEONyv4vd8RxWES7um7+CZnZ/kNnhiW3beBdp8lqxbZ6cKHG4UuEdnZ6m59SvDZomXxvLUo5DpmiTMeDD23wEm11z6KdUzn8H2AZDB4cZfn2McHkNGzfu4LLLLpsxkVBERKRO03BEREREThLJZJLnnn+OR3c9ykTxIL09HqptRf78of/FzuFdVKlyz8/uYd/YPhLZBB2BDkKeEFbVwpv1ErF8jJacxMtVyrN2YjcLT9odJme5LIKmQW7W+bZtU7ZtqpMf9WON95r9ufHa2QoVm8dTJd7c7p4xTadReXJE8IFCeSooSQPbu2s9WJpNwmk3q7z83HcZ2DdI9PUYLeUezth6CZdddhler3exb7mIiJymFJaIiIiInATGx8d5/sXneWzfL8gxyJp1LWw4s49vPP2P7Bvbx70/v5cn9j3JQLwfgEQ+wWUbL4eSQWWiQhCTd17zFp63q9wTy/F4tkS6UqUyGXbMDjDqAceOsBNnEFrdc7fgmIBpGJhNQpFqQ5BSXaRFnm3b+Bwm13Q6m/YpgVpQ8ni2xNfGsjw2VCI7GZQQhmtCnhnPn/25fPhRkvuytFS6OeOMS7ngggsUlIiIyIK0DUdERERklRsaGmLnnp08fegpTFeS9es6WLOhi6cPPjUVjvTHDvOtx78547ofPPvP2AmbIGDYWfanXydTro0Sfipb4ky3g4BhMFausrNQZrvHUWsAYtcawRrAcLXCep9FuGH6TJ25QM+TZNXmB8kC65wmVwfcC/Y1mW8csG3bJKu1oOWlfJmnMkXKCcgWbFKA2WrSHmpn3OUmXEngpoqr4dZFG/K2QSLfxUZPB1vOvIRzzz0Xn8+39G++iIiclhSWiIiIiKxStm1z8OBB9vTv4ZlDT+Px5enpjbBmYxeY8L1nvj/j/PHM+PQXZaaCEp/bwBGGV/bXJg+c73FwTcCFYzKkaHeYxDNVvhbNQRq8NvgcBlYQsAzeEqw1QF3q5BvbtglbJmudJtvcjhnXzncP27ZxmjPDFMMw2JMv8dNsCar2jKDECBu8/bJ3cMsFNze9XyKWYGJoAqsftvjb2LzlIs466ywFJSIisiTahiMiIiKyClWrVfbs2cPrA6/z5MEnCYTKdPe2sGZjF6Zp8tS+6aqSOcpAnBlBCYaBTa1KozEoqbvc52oalAB4jvAnxnrYsc3tYLBcJVWpTm35Weya2WHKeT4ndtmmHIPMZFBCGGyHTU+4e+5br1QY6R8hNpCgfMgg4Opi6xmXcNZZZ+H3+4/sjYiIyGlLYYmIiIjIKlMPSvaM7uHpQ09jV5/GGPgr8pVXMc3aj28/fOXB5hfPE5TUXeNzzglKbNum3Wlyjt/C5zSwWpgKStY5Tbzm0n5krPc9qdo22UqVoXKVV/Jl/ilZ4Llcad7GrfPdx7ZtnIbBpopFomSTNoEwU7XRD77yoxnX5XN5hvYPUh6rUDpg09a6kS1bL2bbtm0KSkRE5IhoG46IiIjIKmLbNvv37+dA9ADP9z9PW8SAgw/T6bYZ2/k9KluvxTIcnLd2O7H0xFS1SNW2iSdjVOKV6aAkxIygBOB839wRwPVqjjd2uflJsgCWwYVeJ8/mSmz3zj8yeL77mIZBEZtX8mUmF8cZjqX/2Dm7yuT8sItfpKuYLWCYBh6nB7/Lz/a+c6euiY/HSUQTeNJeMqNF1q0/j47O9WzZsgW3273kZ4uIiIDCEhEREZFV5eDBg+wf3s8zh58h0mqSGH+Qra5aINJuVnn1hf/H9h2/zrbuM3lm/zO8+4rfZG1LH4NDQ9z78L2McQCfazIoMQ0MDJwOJ8VysWlVSZ1t27hMg0uDLgDClslVPif+Jo1dm6nYNiUbPKYxdf1ap8mhbIVKBpLOKl0ea8F71J+TrVYpVcC2wcagGt7E//6Nj2Iwdw3lcoWxoSiVTAVvLEAha7NpyyW0d6xh06ZNWNbCzxQREWlGYYmIiIjIKnH48GH2De7j6cNPEw4bBIMG5sCzMzZOG4d+Sum8t3PPz+5hIN7PPT+7h/98yX9i3+hecpkYfsfk1pvJ0OKXLvklDMPgwScf5Nx5qkQaw5Bww+he/+SfZwclzcITyzDIV6vQEGhc4HGyd6RCtmoTWSQoaXzOeMHmF+k13HTZ/0ekq42z2sJNz89msowNjeEt+WDUieXwsWHDmXR1r2HdunVLbkgrIiIym8ISERERkVVgaGiI/YP7eerwUwSDVcItLhLpn9JlVmeM3W03q3z5/36IgVQSgIF4Pz9//efk0mnsfBJnhKmgBOBHT/0Ix+QWmESlSqdpzQk7FgoV6k1ZrSWcP7sKJegw6fCZ7C5VmJ2V1CtRwKZQ7/tqg12F1xNlDuUTdPR1EmwJznmOjU0sGiM1niJSaSM3XqSlpZ2W8AbWrdtAV1fXvO9HRERkKRSWiIiIiKyw0dFRDgwc4JmBZwgEINTioG9TN7F/fRyMuT08LnCWeLx+cQGefOVxur1eHC1gOJptVan1DilOhhLNwo5m1SK2bU+FJI2BzULhyuzXrmh3QbY4I0ip3/dfk3l2FysAVLI2lTQkqzYFA2gZ5dXxV7ms5bIZ9yuVSkQHo5CDzlIXmWSR1ra1BIJ9bNq0iXA4PO/aRERElkrTcERERERW0MTEBPsP7+eF6As43FX8vip9G7pwOCzKofXEq8bUR6wC4+Uquwq1gIEykAIKacIRP6Zn4W0nqWp13teaBSDNqk+MhvCkmdnHPSbsmNz+M/seO7xOqNqUEzbFNExUbApOoBVwzpx2Y2MTn0gwsG8QX85HpNBGKQdt7RsIt25g27ZtCkpERGTZqLJEREREZIVks1n2HdjHa8nXyFcyhHwleta24/bWmqxecs0dU+dWqfKx73ycgXj/9A3S4Ac8LhjMHG76jDVOk2v8Ln6aKdLhaN43pGrbmA3BSHUy8DANg6ptU5rcMuM1DazJypDxShW3YeCbPFbXWH1i2zZ+y+RQqUSiMjeMOZArU5qAbNkmi0G4O4Llra3RwJiadlMoFBgbGsPIG/TSQzVvUKmYhFrX0BLqYsuWLbhcriV8x0VERJZGYYmIiIjICqhUKuzbt49D+UNMJCeIhKG1NUBLOND0/Kf2PTUzKMmDVQK/08DRUgtTmrku4KbdYfLmoJuWWVthGkf9NspV7anmrqZh8ESmiAFcHaiN4DUMAw8GT0VLvKnbPeeesytIgqbJ1yZyU/c/v2cHz+5+jlIWUlWbogm02Pzmm36TyzZOb7up2lViYzESY0laCROstlAq2ZgOD/5gD+0d3axfv14Tb0REZNkpLBERERFZAYcOHWIoO8S+kX1EIg68niodPZF5z//hKw9Of1EF0hA0DUwfYDXffnOZ10G7oxZ6tMyabDPfhJt6NUij8zxOmLXrJuAwOa/V0fSeZdsmW61tnQE4UKpML71g89Jrr5Ir2CSrYHsBH2DWtt3Uw5JsJsv48DjOkpM19OI2veRLFZyuIB5fF+vWraejo2Pe75eIiMixUFgiIiIicoKNj48zPDHMK0Ov0BJy4jLy9K5fMxU27BzexTce+zrvvuI3ObN7GwDnrd3OvtG9lKolyIIbcDvB8s3/nEv9M7emVBoats7WrCdJPTwJTwYus5u7+p0micrcipaX8mXcGy4jnkpwYPQAJk5anD7KaZtyAVyBVjKOBJEWE9M1+dzJbTflcoWJ0XHyyTwRIoSsEKblJJMu4vZ2EQh2sGnTJny+Bd64iIjIMVJYIiIiInICFYtFDh0+xCtjr2C5qrgo0Lu+G8dkP5EqVe752T0MxPu59+f38j9/9bOYmNy842YA/vmZfyafzxOwTCx/8yarANf4nDgagg17gaCkHoJUbBvbBoc5dyvN7D8DeEyDHyUKUxNtGnUf3s0t59zKL2+5EbtskoxnMBxeLE+QcHsrobYQpjFdwWJjk4qn6N/XT6AaYA1raAmEyGaL5LM23sA6Ojq6WbdunbbdiIjIcaewREREROQEOnz4MP3ZfmLpcdpaoWtNBK/fM/V6Y2+S/thhntr/1NTWlJt33MxmYwtP7f05A+OvYreUSWdTTZ9z3uQEmrqljPu1DIOd6RI9HgvLAL9VC00aG77OtsPrnBOWOAyLLe1bCAdbSYynKVVMTE8EbzBAe0/7nGasuWyOidEJyEMP3YQ8ITweP9FoDMsZItDSybp162hvb5/3PYiIiCwnhSUiIiIiJ0gqlWIsPsbrI6/T2uokGDQJt7VMbbt51+Xv4nvPfH/GNd9/5j5aPC188/Fv8q7L300mlWbnoeeputI4ss0rLLa6LJym0bSZ62LavRZfi+W4PeKd0QB2Z75Ej3Pu8xr7kQBYhskbNl/Njo6LGBtKYLiDuIIBIh0RguHgjHML+QKxaIxipkgrrbSYLbS3tZPJFBiNxvH4egmFOti4cSNut3tJ6xcREVkOCktERERETgDbtjl8+DB7E3uxLBuHUaRrTd+MbTd/+/DfMp4Zn3Fdf+wwX3r4S0xkJrj3p/dyJmdSLKRxBeafgLNjsqqkWR+Sxq+brbHdYXKNzznVELau3WHNmGjTVNXGWw2yxXs2mTxY/g6CrS20dkZwNGydKZfLTIxOkE3mCBOiiy4irRFcLg9DQ1FsPPgDG+hd00dPT8+Sgx4REZHlorBERERE5ASIxWKMpcc4GD1IZ4dFe2cYp8vBE/uemNp2MzsoqZvITAAwMNJPujCOx8m8E3CgVu0RnHzdaYDPnJ6E01gh4jeNGX1N6qHE+b6ZW3jqIcpWlzVny43f5cdpOilnbMpZm01rzsXytuNrCdDa0YrbM10RUq5UiI/FScVStBCkjz4iLa2Ew62Mjk4wMjqK29OJP9DGxo0bCQSaj1EWERE53hSWiIiIiJwAo6Oj7B3fSyBg4XEZRDpDVKnO2XZjGQ5a/a0Y1Kb1xjIxKna59mIJKuUchnfhSounsiWeypYA+I+tXnwNRSLtDot/TxW4xu/iYLHCetfMrTUOmDM6uB6i3Bh0k03mGShNVrTYNmEzwlu23gSWC9MZxBPw09rZitfnnbq+aldJTiSJjyfwV32spY+QP0R7eweZTI59+w5jOoIEWjbR1dVNb28vpjlzDSIiIieSwhIRERGR4yybzTKeGGdwYoDuLouOng4Mw+DJfU9OVZXUVewy77r8N7hs42U8se8J7v7x3dMv2mAa0DBEhjVOk2v8Ll7Nlznb4+CnmeJUmLHVZdHuMGf0Lml3mLw56KbFMnEYxpytNb8W8uBv0grFtm1cpsF1ATdfnyhgFZ04Sm7aW/owPK24fH4ina34A/6G5dqk42liYzFcZfdU89aOjg4Mw+Jw/zD5QhWPt49QqI3169fj9XrnPlxEROQEU1giIiIicpyNjY1xMHYQjxd8fifBUC1Q+OErDzY9/8FXfsRlGy9r+ro9a1rwdQE37Q6Tdkct/Lgu4OYfYrUAZL7eJfV+JM221tS38FjURgPnqzaGAX5z+ppf6bqAjt5rMZxeXB4f4Y4wgVAAg9r9q3aVTCJDfCKBVTTpoIOgo4XOzg4CgSBDw1HGx+K43G20hNro6+ujvb1dvUlERGTVUFgiIiIicpzF43GGYkP4W2wiHaGp4+et3U4sPYHNdAJiYLC979yp14fjQyTyidqLZm1rjj2ZbdQrR4Cp3iONAUhj75K6gGlgNYQSl/td7C5OV5fUt/C8N+LFYRiUsSlXbPwN1SyBwi684XcQam/FH/RNhSSVaoVULEUylsRRdtBGhKAVpL29ndbWVpLJNDt37qVqu/EFN9DW1sHatWtxOmf2SBEREVlpCktEREREjqNischwdJhcKU673zdVVQJw846buXnHzfNee/OOm3nx8EskhifDEicUCuAvAAGby/2uptfVA5DG3iVQC1feFvLM2ZYzu7pkq8siNFl9ErZMsJhxTYcLoolHWbPx14HadJv4eIJUPIXP9tJJFwFHgEiklXA4TLlcZf/+flLpHG5PJy2BNtatW0coFEJERGQ1UlgiIiIichxls1lG46M4rTLtna1HtNVk5/AuoslRwt5WnJaDlJUin85TKMM2e2Y/krqFJtfMty1nh9fJ7mIFu2xTLcA14bkhzOxryv2/oHDmLSQmEmSTOQIE6GMNAXeAtrY2WlpaqFSqjIyOMxadwHKGCLRsoru7h56eHjVwFRGRVU1hiYiIiMhxlM/nSWfTWFaJYNi/+AWTqlS552f3MJGdoK91LZ95x2d4/73/GQKQStnsmKwqmR2+zA5A6izDbLotx7Zhf7pMedymUoHNAYsW59wgI1WpUrIBA0zDIuPpYfjAMCFCRGgj5G8hEong9weoVquMjIwzOjqOafnw+NYRCteqSdTAVURETgYKS0RERESOo1gsRrWawxN04nQt/Uevp/Y9NTUppz92mG8/8S0K5QJ4oFKBV5Nlgk6DkNPAbAhMqrZNqmpzoDQdlIS9YT50w4f4wr9/kScGRqmWgBJUK1CyoWzbFKj9+T3dzbf2ZKo292R9XNxzEW/sfSO9hAgSJNQSIhJpw+Opbe8ZG5tgZGQMGzduXx+BQJg1a9YQDoeP5tsnIiKyIhSWiIiIiBxHuVwOo1rE420eQjRTpcr3nvn+jGMPvfbQ9Bd++FG+yOhwld9a553RT8Q0DH4ynOf1dGWyG6xFe3cPjzz2GP2HRylWbcpAEajYgAU4AVftw2k13ybkNi0+ftHHCBAgYARobW0lEongcNS29sRiCYaGo1QqJm5vNz5fK729vUQiEU25ERGRk47CEhEREZHjyDRNnPbi5zVqrCqpK5QLhDwhnA4XsUyMiqfMGyLNe5BsDzl5bKKMbYNNGRJRDmTSjFft2k9/TqY+W5aDiL+1dj0G+51uzEpixoxiG0i5tnKBZz2hUIhQKIRpWgAkkykGh0YplsDtbifQ0kpPTw8dHR0KSURE5KSlsERERETkOLJtGycmpuUim87iC/gWveaHrzzY9HhPay83nH09d//4bgB2FiqELJPGSMIGdpYqlFsAo/YxYoxy+dYryI5mmcjEqNjlqfMDbj+fe9fnqJZt0sk06USaaqGCHz8BAvgdflpaWgiFQrjdnqnr0uksQ8Oj5HIl3J52QuFWurq66OrqUvNWERE56SksERERETmOqtUqwRY/HkeA2FgMj9+DaSwcJpy3djux9AQ209UdBgbnrjl3xvachzJFHsoUm99k1q6f/lg/77z01/nCQ5+fcTyRT/DgUw9yRnAbfnxEaMWHj2AwSCgUJhDww2QcY9s2iUSK6NgEuWwBl6edYKiVzs5Ouru7cTj0o6WIiJwa9DeaiIiIyHFkmiahcBiXUaWQLxAdiNLZ14nB/FtUbt5xMzfvuHnO8Sf2PTFne85S9ccO8/1nv9f0tcf3Pc71519PwBsgFArT0hKc2mYDUC6XGR+PMz4eo1w1cblaCYRCtLe309PTg8u19H4sIiIiJwOFJSIiIiLHkWmaOCwnPT1tWKMmQ+khhg8N097TjtPpPKJ7/ftL/z7j641Oi5ta3DyQLLC/YfrNfHL5HBFPBMOu7c8xMLAMk6v63sAZm8/A6ZwZeuTzBcbGJojFEpiWH6e7m4CnhY6ODjo6Oo54/SIiIicLhSUiIiIix5HH48E03WAbrO1bizFgEstO0L93gGA4QCAUwOP1LH4jwDYat+XAO0Juup0Wbw+5+cuxLM36yPodAdyWC8MweWPXtbxjwzvw+/0EAgECgQCWNffHwWQyRTQ6QTqdw+kO4fVvwB9ooauri9bWVvUkERGRU57CEhEREZHjKBQKMTHuJ5FIsWnTOjZv2sTwsI9gJkgqniIaj4ID3D43Lo8bt8eFaZlYlgPLUQslqtUq5WqZ/dH9U/fd7nHQ7axtlelxWmz3OHgxX57z/LW+tfzPKz6Lz+cnEPDj8XigyRagSqVCLJYgOhajVLJxuVsJhHppbY3Q2dlJMBg8Pt8gERGRVUhhiYiIiMhxFAqFcDgDpJJRMpkcfr+XtWvX0Z7LEo/HSSaT5Mt5CskChWSBLBkqVChTgYZakX/d+6+Uq7UwxABuDMzcMnNDwMVL+TI24DScRLxtWKbJdWe8iXXr1jddW7VaJZlME4slSKXSmJYPl7sdX6DWj6SjowO3232cvjMiIiKrl8ISERERkePI6/XS0dFFuZTmcP8gZ2zdiGmaeL0+vF4fXV1d5HI5crk8+XyeYrFApVKhUqlMTcMxMHhu5Lmpe9arSmzbxjAMbNueqi7ZVbR430Xv4z073tt0PdVqlXQ6QzyeIh5PYlhunM4WfMFO/P4gHR0dtLW1aauNiIic1hSWiIiIiBxnfX19xONx0skse/cdYtPGtVhWbQuNaVr4/QH8/sCsq2wqlQqGYWAYBuftO5+nBp6kSpU3+GqNVQ3DmPH5ar+bq7ffNicoqVQqJJNpEokUyWQaTCdOZxBfYAMer59IJEIkEsHr9R7fb4SIiMhJQmGJiIiIyHHmcDjYunUrr79uk00Psuv1/fSt6aKlZaE+IMaM5qtfeMsXALjpm29jZ2GckGXO6DxiA6H2i3j7jvdSLpfJZnNksjmymRyZTBbD8uJ0BPAF2nF7fITDYSKRCIHA7JBGREREFJaIiIiInAB+v58zzzyT3bstspkJDhwcwuMZI9IaIhQKLjiG9+nd32X/a3/HxrP+M28/6+3c99p97MzVtujYVRu7BDeufzM3r7+VV1/bQ6lYwrTcWA4PltWCL9iNzxcgHA4TDofx+/0n6m2LiIiclBSWiIiIiJwgXq+Xc845h6GhIUZGgpSKSYZHUgwMjOD2uPB6PLjdLtxuF6ZpYpgGUOXgK1+iw1HhwCtf4sbL/pEbOt5CpVwhXyiQzxUwTCeW5SFX8OBwhXF73Xi9Xvx+P36/n2AwODkFR0RERJZCYYmIiIjICWRZFn19fXR1dTExMUEsFiOdTlGp5MkVimRyBaqVHGBjU+Wlg/9Ir6MCQLujwiMv3MsFG2/HMJyYZoBAixenyz0VjNQ/6j1RRERE5MgpLBERERFZAU6nk66uLrq6uiiVSmSzWXK53OREnCLVapVypYS58yfQML3XzP2Ytev/HLfLg9PpxO/343K55n2OiIiIHDmFJSIiIiIrzOl0EgqFCIVCM45/92cfpdtdmTEiuNtZ5okDX+RX3/CnK7RaERGRU5+50gsQERERkeaG9vwjMHdE8NCef1ixNYmIiJwOVFkiIiIiskq52i5kfOzRucfbL1yB1YiIiJw+FJaIiIiIrFLv/5UHVnoJIiIipyVtwxERERFZRR564W/5wte6eOiFv13ppYiIiJy2FJaIiIiIrBKVapnXn/kEvWaB15/5JJVqeaWXJCIiclpSWCIiIiKySnz/0f9Bl1kLSLrMEt//xSdWeEUiIiKnJ4UlIiIiIqtApVpmbPdXZxwbe/2rqi4RERFZAQpLRERERFaBelWJbdsA2Lat6hIREZEVorBEREREZBUY2vOPABiGMePz0J5/WLE1iYiInK40OlhERERkFXC1Xcj42KNzj7dfuAKrEREROb0pLBERERFZBd7/Kw+s9BJERERkkrbhiIiIiIiIiIg0UFgiIiIiIiIiItJAYYmIiIiIiIiISAOFJSIiIiIiIiIiDRSWiIiIiIiIiIg0UFgiIiIiIiIiItJAYYmIiIiIiIiISAOFJSIiIiIiIiIiDRSWiIiIiIiIiIg0UFgiIiIiIiIiItJAYYmIiIiIiIiISAOFJSIiIiIiIiIiDRSWiIiIiIiIiIg0UFgiIiIiIiIiItLAsdILEBEREZHmPnLLEENPjGE0HLOBnsva+bP7elZqWSIiIqc8hSUiIiIiq9TQC0l8drHpcVBYIiIicrxoG46IiIjIKnXZuzoBsG1mfL783Z0rtCIREZHTg8ISERERkVXqA3eGyVgejMl9OIYBGcvD+/84vKLrEhEROdUpLBERERFZpRwOg8t/u3fGsStu68XhMOa5QkRERJaDwhIRERGRVaxeXQKqKhERETlRFJaIiIiIrGIOh8Gtf7iOjMvHrX+4TlUlIiIiJ4Cm4YiIiIiscu/4z0He8Z/PWulliIiInDZUWSIiIiIiIiIi0kBhiYiIiIiIiIhIA4Ulq1wul+NTn/oUZ5xxBh6Ph97eXt773vcyMDCw0ksTERE5bdm2PeOziIiInFoUlqxi+Xye6667jk9/+tOk02luvvlm1q5dyz333MMFF1zAvn37VnqJIiIip6W77757xmcRERE5tSgsWcU+85nP8Pjjj3PFFVfw+uuv8+1vf5snnniCz33uc0SjUd773veu9BJFREROS1/72tcAuOeee1Z4JSIiInI8KCxZpYrFIp///OcB+MIXvkAgEJh67Y477uC8887jkUce4ZlnnlmpJYqIiJyWdu7cyauvvgrAK6+8wq5du1Z4RSIiIrLcNDp4lXr00UdJJBJs3ryZCy64YM7rv/qrv8qLL77IAw88wEUXXbQCKxQRETk9jI6O8vjjj099/cADD8x4/XOf+xxve9vbpr6+/PLL6ezsPGHrExERkeWnsGSVeuGFFwC48MILm75eP/7iiy+esDWJiIicjq699lp27tw57+tf+cpX+MpXvjL19Zlnnslrr712IpYmIiIix4nCklXq0KFDAPT19TV9vX784MGDi97rnHPOaXp87969bNq0iVKpdJSrFBEROfXdcsst/Omf/ukRna+/W0VERJqzbRvDMFZ6GYtSWLJKpdNpAHw+X9PX/X4/AKlU6pie89prr+FyuY7pHiIiIjLtT//0T48oXBERETndnH322Su9hEUpLDkNvPLKK02Pn3POOdi2PbXlR0REROZ34MABLr30UuLx+JzXwuEwTz75JBs2bDjh6xIRETmZnH/++Su9hCVZ9rDk4MGDPP/880SjUeLxOOFwmI6ODnbs2MH69euX+3GnrPr0m2w22/T1TCYDQDAYPKbnGIaB0+k8pnuIiIicDrxeb9OgBCAej+Pz+fR3qoiIyCJOhi04sExhyQsvvMDf/d3f8YMf/IDDhw/Pe97atWt529vexvve9z527NixHI8+Za1btw6A/v7+pq/XjyuAEhEROTG+//3vL/r6Bz/4wRO0GhERETmejiks+clPfsLHPvYxnnzySWzbxul0cuGFF3LmmWcSiURoaWkhkUgQi8V47bXXeOmll/jiF7/Il770JS677DL+5E/+hGuvvXa53ssppV6a9OyzzzZ9vX78vPPOO2FrEhEROZ01hiVve9vb+Od//uepzwDf+973FJaIiIicIo46LHnb297Gv/7rvxIKhXjve9/Lu9/9bq688krcbve81xQKBR599FG+/vWv8/3vf5/rrruOt7zlLTzwwANHu4xT1lVXXUUoFGLv3r08//zzcypxvvvd7wJw0003rcDqRERETj8tLS14PB4+97nP8b73vQ+3283/+3//j6985Sv8t//23wiFQiu9RBEREVkmhm3b9tFc2Nvby0c+8hE+8IEP4PF4jvj6fD7Pl770Jf78z/+cwcHBo1nCKe8Tn/gEn/3sZ7nyyiv54Q9/ODUB5y//8i/58Ic/zLXXXstPfvKTo75/faTwfA1gRUREZFqxWKRSqeD1eimVSrhcLorFIk6nk1wuh2VZmjAnIiKyiJPl99CjDkvy+fxRhSTH6z6nonw+zxvf+EaeeOIJenp6uPrqqzl48CBPPPEEHR0dPP7442zatOmo73+y/E8qIiKy2swOS0RERGRpTpbfQ82jvXC5Ag4FJfPzeDw8/PDDfPKTn8Tn83Hfffdx8OBBbrvtNp599tljCkpEREREREREpLmjriyRk9/JkuiJiIisNqosEREROTony++hyzI6uFE2m+Xpp59maGiIQqEw73m/9Vu/tdyPFhERERERERE5ZssWlti2zac+9Sn++q//mmw2u+B5hmEoLBERERERERGRVWnZwpI777yTz372s7hcLm655RY2bdpEIBBYrtuLiIiIiIiIiJwQyxaWfPWrX6WlpYXHHnuMs846a7luKyIiIiIiIiJyQh31NJzZxsbGuPbaaxWUiIiIiIiIiMhJbdnCkq1bt1KtVpfrdiIiIiIiIiIiK2LZwpLf+Z3f4eGHH+bAgQPLdUsRERERERERkRNu2cKSD3zgA9x+++1cffXV3HvvvQwMDCzXrUVERERWJdu2sW17pZchIiIiy2zZGrwCvP/97+fHP/4xt99++4LnGYZBuVxezkeLiIiILLt8Pk8qlSKbzVIoFCgWixSLRUqlEgDPPfccDocDh8OB0+nE6XTicrnw+/34fD68Xi+GYazwuxAREZEjtWxhyWOPPcaNN95IJpPBMAwikYhGB4uIiMhJJ5VKMT4+TjKZJJ8rUsxVKOVtysUqlZJNpQLlUu0ffYZ353E4HZgWmJaB5TCwXAZOt4HTbeJ0W/j9fsLhMOFwGLfbvcLvTkRERJZi2cKSj3zkI2QyGf7wD/+QP/iDP6ClpWW5bi0iIiJyXFUqFaLRKGNjY2RSObLJCoV0hUoJfD4/fm8Ad9iN0+nC6XRRqVQAOHPruTgcDsrlEqVyiXK5RKFQIJfMksxlsY0ibl+BqD+O22/hD/gIh8O0trbi9XpX+F2LiIjIfJYtLHnuuee4/PLL+cM//MPluqWIiIjIcVWtVolGowwNDZGOF8gmKpTzBuFQK509YXxeP6Y5t8Vbido2HMuyprbheJgbfhSKBVLpBMlUgsRoBqenyFgghScwSCDoo7u7m9bWVm3VERERWWWWLSwJBoNs2LBhuW4nIiIiclwlEgkOHTpEKp4jFS1h4aYj0k14XaRpQHI03C437kgn7ZFOyuXyVHASHUuR9JVIxjIEQl66u7tpa2tTaCIiIrJKLFtY8pa3vIWHH36YSqWCZVnLdVsRERGRZVWtVunv72d4aJTESJFKwaKro4/W8PENKxwOB63hNlrDbVQqFcZjY4wNjJIaT5KMZwmGhujq6qK9vX3ZwhoRERE5Osv2N/Gf/umfYpomt99+O4lEYrluKyIiIrJscrkcr732Gof3DxE9WCDoaWfblrOJtLaf0KoOy7LobO/izK3n0BroJjlkM7Qvxe6dB3j55ZcZHh6e6osiIiIiJ96yVZZ89KMfZfv27fzDP/wD999/PxdffDFr1qxp+i8jhmHw1a9+dbkeLSIiIrKoVCrFnj17iA0XKKYN1q/ZRDCwsg3pTdOko62LttYOYvFxoqMjpMfTpGJ5RkZGWLt2LZFIZEXXKCIicjoybNu2l+NGR1IuahiG/rVkFTjnnHMAeOWVV1Z4JSIiIsdXLBZj7959xAYLWLaX9X2bcDiO/t+MSqUSWy9pZfdTMZxO57Kt07Zt4okJomMjVK0S4S4nbR2trFu3DpfLtWzPERERWSkny++hy1ZZ8vDDDy/XrURERESWTSwWY/fre4kNFvE6g6xds2HV9gQxDIPWcBvhUITo2Aijh4bJZ8ZJpVKsXbuW9vb2lV6iiIjIaWHZwpJrr712uW4lIiIisizS6fRkRUmRgKeVNT1rT4qJM4Zh0NnRTUtLmP7Bg4wmsxSy+5mYmGD9+vW43e6VXqKIiMgpbdnCEhEREZHVJJ/Ps2fPHuJDtYqSkyUoaeRxe9i84QzGY1FG+ofIpydIp9OsWbOGzs7Ok+79iIiInCyOuga1VCotywKW6z4iIiIidaVSid27dzMxlMeouFm7ZsNJGywYhkF7pJMtm87ELngY3Z9j3+6D7Nq1i3w+v9LLExEROSUddViyefNmvvzlL1Mul4/q+lKpxBe/+EU2b958tEsQERERmcO2bfbs2cPESJZy1mTD2s2rtkfJkXC73Gxav5Wutj5iAxWGDsR57bXXSCQSK700ERGRU85R/+SwZcsWfud3foe+vj5+//d/n8cff5xqtbrgNdVqlccee4z/+l//K319fXzwgx9k69atR7sEERERkTmGh4eJjaXITthsWLflmKberEaR1nbO2HwWdsFN9FCOXTt3Mzw8vNLLEhEROaUc9U8PDz30ED/4wQ/4+Mc/zt/8zd9w99134/V6ueCCC9i2bRutra0Eg0FSqRQTExPs2rWL559/nlwuh23b7Nixg3vvvZf/8B/+w3K+HxERETmNFQoFBgcHSYyU6O1eh9t1ajZCdTqdbFq/lcHhfsYPj1MtHyabzbJhw+qd9CMiInIyOaZ/annrW9/KW9/6Vh599FH+/u//nn/5l3/h0Ucf5dFHH216fmdnJ+985zv5T//pP3HFFVccy6NFRERE5jh06BCpsRJeV4BwKLLSyzmuDMNgTc9avDEvg/39lEtR8vk8W7ZsweVyrfTyRERETmrLUpd61VVXcdVVVwGwa9cuXnzxRUZHR0kkEoRCITo7Ozn//PM544wzluNxIiIiInNMTEwwEY2TiVfYumntSi/nhIm0tuN2ezh4eD/lQpJS6TU2bdpEMBhc6aWJiIictJZ9E++2bdvYtm3bct9WREREZF6VSoX+/n4S0RKdbd3HffuNbdc+5/J58vkCpmlgmCamYWBaVu2zaWIYJidiCI/fF2DLpm0cOryP6KEspeLrrN+wjo6OjuP/cBERkVPQqdXxTERERE5LAwMDJMdzGGUnHe1dy3rvYqlELpulUCiQLxQoFgrkcrWRvbtfP4hhOjAA0wTDBNMAw6h9DWCaBh6PB6/Xi8fjweP14nI6l3WNAC6ni00bzmBg6BBjh+JUygfIZrOsW7fupB2bLCIislIUloiIiMhJLZPJMDI8SnKszPo1m5clGCiXyySTSRKJJNlsnkIBCgUolaBYrP0ZYCRq4XF5qFZtqnYVbJtqtVr7M2AAlmXjcuVwu3O43eB2g9Nl1QIUjxev14PP78dchnWbpsnaNRuIjo8wcmiISnmEcrnMpk2bFJiIiIgcAYUlIiIiclIbGhoiNV6mxR8m4D/6Ph3VapVkMkkymSSdzpLNQiYD2Sy43V5cLjcej4dg0D21tWbtmi04HM2rROx6cFKtkC/kKBbyxOM5CoU8lqOCx53B7c7gdoPXaxAMBgmFQvh8/mPeutPR1oXb5eHQwH5sexzbttm0aZMm5YiIiCyRwhIRERE5aeXzeWITcXLJCn2beo7qHuVyebIxfZJcDtIZyGbA5fISCIRoawtiWdasa0qL3tcwDCzLwrIsnE4XBEIA2ECxkKdYzJMv5Egks0CJgD9JIJDE63UQCrUQCoVwu4++90pLMMT6vk0c6t8P9jjVapUtW7YoMBEREVkChSUiIiJy0opGo2STFQK+4BE3dbVtiMUmGB2NEo/bJJNgGC4CgRC9a1pwzlMxcqwMwO324HZ7CAbDABQKedLpOENDKRyOMoHABH7/BD6/m1BLLThxOI78x7ZgoIUN6zZz4NBebDuGbe9my5Ytc8IfERERmUlhiYiIiJyUKpUK4+PjZONl1vYc2dSXbDbL8PAwiUSR8XEwTQ+dnd243Z7jtNqF1cKTbiJt3eSyadLpBBMTKbzeAn5/FH8gSms4THt7O07nkf345vcF2Lh+CwcO7QU7jm3vZuvWrQpMREREFqCwRERERE5K4+PjZBJFHIaLYKBlSdfUt9xMTCSZmIBczqI10klwcovMSjMAny+AzxegWq2SySZJpRLEYjlSyTjxeJzW1jBtbUcWmvi8fjau28K+g3uwqwls+3W2bt16VNUqIiIipwP9DSkiIiInpdHRUTLxMu2R3iWdn06nGRgYJB6vEotBIBCmr69z1fbwME2TYCBMMBAmn88Ri0dJJLOkUnFisTiRSCttbW1LDjy8Xh+bN2ytBSYkpwIT53EYYywiInKyW/awJJvN8vTTTzM0NEShPlevid/6rd9a7keLiIjIaSKZTJJJ5ijnDVrXtS16fiKRYGBgiOERwPbQ09ONy7UyW26Ohsfjpad7Hbl8lngsSjyRI5WKTYUmkUhkSaGJx+Nl04at7D+4h6idwrZf54wzzlBgIiIiMsuyhiWf+tSn+Ku/+iuy2ey859i2jWEYCktERETkqNWqSipEWtsWrQwZHx9naCjK8DC43CHa23s4xsm8K8br8eHtWT8jNEmmJpiYiNHW1kZbexvmInOHPW7PZGCymzE7jW3v4swzz9SWHBERkQbL9rfin/3Zn/GZz3wGy7J461vfyhlnnEEwGFyu24uIiIgAUCgUauOCUxX6NrXPe55tw+joCCMjMYZHIOBvo7X1yBrBrlZToUkuQzweJR7Pk82OkUol6e7pwef1Lni92+Vm4/paYDJuZNht7Wbbtm2rdkuSiIjIibZsYclXvvIVvF4vP/vZz7jwwguX67YiIiIiM8TjcfLpCn5vYN5xwbYNg4MDRKMpRkYgHO6ipaX1BK90ed1/PzzyU8BuOGj4ufYaPzfckGZsbJh0ukg2e5D29jCdnQv3Y3G73GxYt4V9B3Yz7kiyz7mPzZs3YyxSmSIiInI6WLaw5PDhw1x33XUKSkREROS4SiQSFLJVWoPNJ+DYNhzuP8xYNMPoKLS19RJY4rSc1eyllyA6Ovf4yy/DzTcH8Hg2MTExysBAnFwuTiqVpru7m2AwMO89PW4PG9ZtYv/BPZjWBE6nk/Xr1x/HdyEiInJyWLZay+7ubvx+/3LdTkRERGSOSqVCKpWikKnOO+53dHSEsbEMo6MGnV3rTomgBODGG5sfv+GG2mfTNGlv76ajcx2xuJOBgTIHDvQzMDBAuVye974+r5++3vXEBksM9Y8yODh4HFYvIiJyclm2sOQ3fuM3+MlPfkImk1muW4qIiIjMkEwmKWQruByupltwkskk0WiM6Ch0dKzB6/GtwCqPj0sugdnFNJYF3/pWbYtOndfjo2/NJlyuNgYHYWAgxb79+0kkEvPeO9QSpqdzDbGhIocPDTA2Nnac3oWIiMjJYdnCkj/6oz/irLPO4ld+5VfYs2fPct1WREREZEp9C04wOLeqpFAoMDg4xOgoBINt+Hzzbz85GRkGBGa9pUoFotHaVpyZ5xq0tnbQ3b2BVMpD/+EKBw8O0d/fT7VabXr/tkgHbaEuYgNF9u87sGC4IiIicqo76p4l11133Zxj1WqVn/zkJ5x11lmsX7+evr6+po3FDMPgxz/+8dE+WkRERE5TiUSCQrpCZ8/MEotqtcrAwABjYzaG4Sd8iky9me3tt8IXvjD3eH0rzmwul4ee3g0k4uMMDkbJF9IUCvvp6+vD7Z5bmdPV2UOxVCQ2FGevYy/btm3TNmsRETktHXVY8pOf/GTe1yqVCvv27WPfvn1NX1eXdRERETlS2WyWfK5ItWzin1U1Mjg4yNh4kWzOQW9PL6fqTxqXXQbf/jY07pLp66tt0ZmPAYTDbfh8fkZG+ykWSpRKB+jt7aGlZW4/l77edRw4VGJiMMseaw9nnnlm02BFRETkVHbUYcn+/fuXcx0iIiIiC0okEhQyVQL+wIx/eBkfH2d8PM3EOHR392FZ1gqu8vgyDHjXu+Duu6eP3Xpr7fhiXC4PvT0biUYHGRzMUCoN0tmZo7Oza8b1hmGwfu0m9h14nYmhHLut3Wzbtg2n07n8b0hERGSVOuqwRGPlRERE5ESqhSUV2huqIYqlEiOjUUZGIdLWjdvtWcEVnhiXXAJr1sDAwOJVJbNZlkVX91ri8TEGB8colWPkcjn6+vpwOKZ/LDRNk/VrN7Pv4OuMD2fY69jLGWec0XR7tYiIyKlo2f7Gu/POO/mnf/qnRc974IEHuPPOO5frsSIiInIaKJfLpFJpijl7xsjg0ZEREnFwOQMEA+EVW9+JZBjwnvfAxk1w221LqyqZcT3QGm6no6OP6KjJ0FCeffv3k81mZ5zndDrZsG4L2Qmb8ZEkhw4dWrb3ICIistot6zSc++67b9Hz/umf/ok//uM/Xq7HioiIyGkgk8lQKlRxOVxT20GyuRzxeJp4HFpP0Yau89m2De7849rno+X1Bujp3Ugm42ZosMKBA4eYmJiYcY7b5WbtmvXEh0uMDEWJRqPHuHIREZGTwwmvpaxUKirhFBERkSOSzWYpF2y8Xt/UsZHhEWIxCAbDuFxqQHo0nA4nvb0bMIwW+gfg8OFRBoeGsO3pc4KBFro6eogNFjl48BDpdHrlFiwiInKCnPDU4pVXXqG1tfVEP1ZEREROYrlcjlK+isfjBSCZTJJM5slkDMLh9hVe3cnNMAw6OnoJh7oZHobh4QT9/f1UGxKTjrYu/J4Q8eEi+/bto1QqreCKRUREjr+jbvAK8N73vnfG1z//+c/nHKsrl8vs2rWLp59+mltuueVYHisiIiKnmVwuR7lo4wl7qdo2o6OjTExAKNSOZR3TjzMyKRgM43A4GB0ZwK6mqVYPsXbt2qmK4L7e9ezdv4vYSI69rr1s27ZtxlQiERGRU8kx/XRx7733Tv3ZMAz27NnDnj17FrzmvPPO48///M+P5bEiIiJyGqlWq9NhidtLbGKCZLJMqeygKxRZ6eUdlfvuGiO7P0Fj1GADvo0hbvnQylXKeL0BurrWMTp6mEo1R6V6kHVr1+JwODBNk3VrN7Fn3y7G3UkO+w6zbt26FVuriIjI8XRMYcnDDz8MgG3bXHfddbz5zW/mox/9aNNzXS4Xvb29GjksIiIiRySXy1Ep2lhm7Rf2aHSMiQloDXeetJUN6cMZ/MzdypLuzwDNw5L774dHfkotVakz4Npr4Oabl29tHo+X7u71jIwcplIuUK0cYN369biczqmGr4cG9+NwjRAIBIhETs7ASkREZCHHFJZce+21U3/+7d/+ba6++uoZx0RERESOVTabpVSs4nF7SCQSpNM24CYQaFnppR21tZe3MvHzHLZdG/1b/7z2svn7ur30EkRH5x5/+eW5YcmxBisul5vunvUMDx+iWi1RtQ+wbu1aPB4PLcEQHa1dxIZGOeA6gM/nw+PxLOl9i4iInCyWrcHr888/z7/8y78s1+1EREREgMnmrgUbr8dHPB4nlYKWlpO7WfzVtwbJGi7qhTGGAVnDzdW3Bue95sYbmx+/4Ya5x+rBSjTa8DFaC1aWyulw0tuznnzew/BwhYMHD5HNZgHo7OjGZfmIjxTZu3cv1Wp16TcWERE5CSxbWPL666/jcrmW63YiIiIiwGRz10KVqg2ZTJF83sDvP3mrSgBMy6DvqpnbbfquasO05t9WdMklsGbNzGN9fbXjsx1JsLIQy3LQ3b2OctnH0FCVAwcPkUqlMQyDtb0bKKYNYtE0Bw8ePLIbi4iIrHLLFpZs3bqV8fHx5bqdiIiICDC5DadgU8gXSKUhEAhNTWg5mdWrS2DxqhKoVZ+8/e0zj916KzRr23IkwcpiTNOku2sthhFgeAgOHeonmUzidDpZ17eB5GiZ0eExxsbGjvzmIiIiq9Sy/aRx++2388gjj7Bz587luqWIiIic5gqFAqVihUqpSi6bJ52qjbg9FZiWwVm/0k3G8nDWr3QtWFVS1xiCLBR+HEmwshSGYdDR2YfTGWZ4GA4fHiSZSuH3Behs7yE+VOTQoUPk8/mje4CIiMgqs2xhyX/9r/+V2267jWuvvZa/+qu/Ys+ePRSLxeW6vYiIiJyG8vk85WKVYqlMLmdgmm7c7lOnmeiFb/Lx/31uAxe+ybek8w0D3vMe2LgJbrtt4fBjqcHKUhlAe3s3LleYkRHoPzxAKpWmo60Ll8NPIlrkwIED2La96L1ERERWO8Nepr/RLMsCamOEFxvjZxgG5XJ5OR4rx+Ccc84B4JVXXlnhlYiIiDQXjUbZ+dI+Du6aoFLsxOfrXhWVJeVyiZv+Yytn9sQwcE6/cAyjfI/HaOBdu+Dr34DffDds23Z095jNBsaig5TLSbp7YP26tThdTnbv3Ul4jcXGzWvp6elZnoeJiMgp52T5PfSYRgc3Wrt27aIhiYiIiMiRKBaLZNN5SsUqxbxBR8fqauwaHZ1b3dFslO9SLGU08JEGKtu2wZ1/fORrWYgBtHf0Eh21GR5OYdDP+vVrWdPTx+DwIQY8g4RCIXy+pVXLiIiIrEbLFpYcOHBguW4lIiIiAtTCklgsTqHgxe9vOSkaux7pxJm6G2+sVYIsdL+lBConggF0dK5hdKSfkZE0hnGY9evXE/CGSIyk2O/dz1lnnXVS/PcSERFpZtnCEhEREZHlViwWSSdzFItBulZZVQnUeoIMDk5/fSy9Qeo9RgYG5r/ffIHK4CDccUfDgclqE1j+rT0Nt6Gzq4+R4cOMjGQwrcP0rVnDwf4M8bEMAwMDrF279tgeIiIiskKOa9wfi8WIxWLH8xEiIiJyCkun0+SyZaoVJx7P6tvWccstM79eysSZSqVMsZgnl0uTyaTI53OUyiXAXnCCzf33w7e+BZNt4qZYFiSTEI02fIzWqk3qlSjNXlsOBtDV1Uel4mF0pMLAwCBdHb0kRksMDY6QTCaX50EiIiIn2LJXlvzLv/wLd911F48++ii5XA4Ar9fLG97wBn7v936Pt7zlLcv9SBERETlFxeNx8jkIB1pWZW+0iy+ergaxLPjmN2uBBjBVwXHTTVXS6QSZbIpSsUClXKZatbGrNrYNpmnw058bPPecgW2bmKaLatWPaQYYGPROPeull2phx2wtIYhNzD1e376z2NaeY2UYBp2daxkaOkh0rIhpxmjxhUmOJjngPcA555wzNQhARETkZLGslSV/8Ad/wE033cSDDz5INpulpaWFUChENpvlhz/8ITfddBN3zKgRFREREWmuUqmQSqXIZ8HvC630cpqqj/L1eKBSgbGxxgqOHM8+N8ShQ68zMjhIfDhBYiRLarRAfqJKKWVRzTgoJGwO7ypRShQoJnO4SeJkBLu6n/vv2803vjFEJpPi+uubDzB897umRwTX1bfvNI4Pnv3acrIsi56edaTTDsbGShQLVcp5k8RYjkOHDi3vw0RERE6AZass+fa3v81dd91FZ2cnn/jEJ/iP//E/EgrVfrBJJpP8wz/8A5/5zGe46667uPzyy3nnO9+5XI8WERGRU1CxWCSdylAqmQQCwZVezry2bYP/9J/g7rvrR0rAIAYZLjy3Qmq0isN0EfC34gr6cDpcGLMan173RvjWNytYlLHJ4zAzQIaKXeL1V/IMXTxBT4+b7u4Iw8Ot1DbAQEcnXHYZmGbj82du33n72+d/7WjMP5HHwVveup6hwQOYZpFQ2EUymmXUN0Y4HKa1tfXoHyoiInKCLVtlyRe/+EU8Hg8//elP+eAHPzgVlAC0tLTwu7/7uzzyyCO43W6++MUvLtdjRURE5BSVSCTIZ20Mw4XT5Vnp5SxouoIjAezDZSRZ217mnK1BOiPr6O7aSCAQweXyzAlKAM45G1rCFobhxjRCWEYvJltw0MflF4YoxG0e+tcsmdQQsAcYB6oU8vBP/zSzgmR25chCrx2NhfqgOB1OurvXMj5ukM1UMWyL+HCJgwcPUiqVju3BIiIiJ9CyVZa88MILXHfddZxxxhnznnPGGWdw3XXX8fOf/3y5HisiIiKnqHg8TjYDXq+f1detpOb/95FajYdtV8nlhjBI4DHLOHBz4/W9tEWcS7uRAf/hl+H//t+GQ4ZBV5efyy7xAx2M9CcgN47XzFKsFqgwTjIZ4aWX2rn55tp2oK9/A37z3TMrR+pbhWa/Nn+FyMKTchYbcexyeWhv72V0dIDubgfFYobEWIEDBw6wdevWpX0/REREVtiyhSXFYhG/37/oeX6/n2KxuFyPFRERkVNULBYjlwO/f+VHBs8OFuzJz9FRONMXZYN7HJw2ZtgA3GBYTLySgfPCS37G2DgYJtjV6WOZdO25115r8IY3hPnWN0M4SeIwxymTo1gd4aKLkxQKvWzb5uHOP25+723bmPNavUJktpdfXjgsWcqIY78/SLHUTjQ6Rlu7k/GBDG6vSWvrGO3t7Yt/M0RERFbYsoUlmzdv5pFHHiGTycwbmmSzWR555BE2b968XI8VERGRU1ClUiGZTJLLQHvnyvcrmR0s2FPVGDZdzhh+C5iqf7GBMqnBHH/1V+E5lRsXXgjXXjv3GXv3zgxKADIZ2Lundv45Z0Nnl0F0NASEMOwEnR1R1ndnGOjfTygcIRLpXPLUoMUqROZjGEvrg9IabqdULJCIg8eXY3wohzcwQDgcxuFY9oGMIiIiy2rZepa8853vZHR0lFtuuYXdu3fPeX3v3r28/e1vJxqN8uu//uvL9VgRERE5BaXTaTKZCobhxOVc+X4lN97Y/HgoNMD+fK0Xhz2r6mTCaiE2AbFYw8dELfxo5vLLmx+/rH7cgOuumz5uGiFuvH4DbjNAZrzIRDRK/8A+cvns1Dn33w93fBjuuKP28f73w2//du3zN79ZG3fcaKk9TZbaB6Wjo5dy2UO5FGJ0KEY8mqW/v3/xB4iIiKywZYv1/9t/+2/cf//9/PjHP+bss8/mwgsvZMOGDQAcPHiQZ555hkqlwsUXX8yHP/zh5XqsiIiInIJyuRz5vI3b5VlypcTRWkrvjmZbTwB+6ZeSPHg/pCsuAlaldqkBecPJhdf52Puduc+7bJ5Q5Jyza9NtGitYOrtqx5ud09kF2891gNGDLx9kIj5MOZ+lVDhYqzJp65p3q002W/uYbamTcubrgzL3PIPOzj6Ghg7g9bWx99VBvEEnbW1tBIMrXzEkIiIyn2WrLPF6vfzkJz/hd3/3d3G5XDz11FN85zvf4Tvf+Q5PPvkkLpeL3/3d3+Whhx7C6/Uu12NFRETkFJTNZikUbBwOF6axbD+uNLXQdJe6+taTaSkANnaX6ezoYX8+MuOeneeH2b7doKNz5rNmhx+VSplypUy1Usa2q7zpTTPPf9ObYEZ3WwN+5Vegtw9uumn6NY8nQHfnRtxWkMx4kdj4GMPDh/il6ytL/j4c6aSceh+UbdsWPs/hcNDZ2Ucm7aVa9rB/5zCHDh3Ctu2FLxQREVlBy7phNBAIcPfdd/O//tf/4plnnmFwcBCA3t5eLrroInw+33I+TkRERE5R9coSp9O1tFKHY7DU3h3T1SVVOrtGGB+EFn+EW29p4V//1SaXceKlRN5wcu2bfFPbZr79rel7XHZphrGJHJVymUqlSrWhR4lpQmsrtLZ1Eht30NZeZt3aHIWCC5fTOTVyeP16+MD7567XNC1aw9143H7GY0NUy0n61pTo6e1jaNA97/sPtkB7+8IVIsfK7fbQ1tbL+HiF0YG99LcPE4lE6OnpOT4PFBEROUbHpbuWz+fj6quvPh63FhERkVNctVoln8+Tz9t4nG7M4xyWLGW6C0xvPfnf/yfKG68u8Nr/hpaWNiIR+MAHDHY93ca+n02w6eoIhllb86aNedraHYyPOWhtLREKJRgbhXIFqg1FH/UaCwM4f3ucF15q4cILk4xGizgd4HCAw2Hh8Xjw+bw4nK6pax95BJ59tuEmBKni5IwzBrjkyizXXL2fb397DdB828tv/xZcdtkxfAOXKBBooVTqJDqeZs8rg/hDbiKRCG73/EGOiIjISlErchEREVlV8vk8xSIYholpWMe9smSp010ANmzI8773TpAcrUxfPGnbxR62XdwLtk0qlSKTTlMs2lx0oYunnm7hgh0ZwI/L5cTncGBaFqY53WHVtm1su0okYrN5S4VS2UOpaJLLlqhWKzgcFVyeDB53BrfLgdfrxevzsmePg9jE9BrXu+P0utLwmosXdlawsfnlcD8HCn6ivnVMjE+fG2mDSy+d/3uzWD+XpfR7adTa2kGpVGB4NMHuVw7T1tbGWWedNf8CREREVshRhyV33nnnMT34U5/61DFdLyIiIqemfD5PoQAOhwvKYHB8wxKYWV0yX+8OGxgfH6aQLvPSCwEA7vprMOvLM+C888qce+4YuVyVTAaqVZPOTifveDs4nK0LrsEwDAyjFp6YlgOn0w2Tbd6q1QrlUol8PstEOo/TWWbn6zZ7dkO5VKWxDV2bM4fXKjfeGSzodmX4pd8Y4r77ehgcAKcLPvCBhbOo+RrEvvxyLQxZ7PVmOjrWkMmmGTm8k1deeo2uri4ikUjzk0VERFbIUYclf/RHf4RhGEfUnKuxm73CEhEREWmmXlnicrmwy2Cax7fBKyxtuksumyaXyfL8P5kYk5UlZ5b7MQ0nAIPFAK/v8rKmt0q5bBIIhHC5vCxH1mOaFi63hcvtoVqtUizk6D/sIpV01CpJgumpcy2j1gjFtmvvo/657cwyHZEJbr3F5l/+pZff/M3Fm7Mu1s9lqf1eGhmGwZrejaR2jTG4P8oLL7zANddcgzV7jrGIiMgKOuqw5E/+5E+O6PyBgQG++tWvksvljvsIQBERETl51cMSy3JSqtosS9qwBPXpLvNJJCcoZitUY268ZhEAr1WZ6qkSceZwb6hiWQGCLcHj9vOOaZrs/lmJrYUYW4LgMstYTR5Vf3x9lPHV10eIxYZoa43xwQ9W6ejsW/RZi/VzWWq/l9lcLjcbNpzDa7t+wb7XB+jp2c2ZZ5656HpEREROlKMOSz760Y8u6byRkRH+5//8n/z93/89+XyelpYWfv/3f/9oH7tsMpkM3/ve93jyySd58sknef755ykWi/zhH/4hf/RHf7Tgtf39/Xzyk5/k3//935mYmGDdunW8613v4mMf+xgej6fpNblcjj/5kz/hW9/6FocOHSISifDmN7+ZT3/606xZs2beZ91777188Ytf5NVXX8XlcnH55ZfziU98giuvvPJY3r6IiMiqVSgUKBTA6XRRpLQq/pGlWCyQy2Qo56t0nhsm+cL03pN65UYUP798jg+n8/i3hKvEcviMMjQpxqivp1Hn+WH8fj+WZTI2MQAksG3o7Fyz4Pd3sX4uR9LvZbaWYCvdnVsY2v8qzwWfp7e3l5aWlsUvFBEROQGOW11rNBrlwx/+MJs2beLzn/88TqeT//E//gcHDhxYNIw4EXbv3s1v/dZv8fnPf54nn3ySYrG4pOv27NnDBRdcwL333ktbWxs333wzlUqFO++8k+uvv55CoTDnmnw+z3XXXcenP/1p0uk0N998M2vXruWee+7hggsuYN++fU2f9fu///u85z3v4eWXX+b666/n0ksv5cEHH+Saa67hvvvuO5a3LyIismrl83lKJbAsB9i1Rq8rLZmMUcpV8LgDXPRLQfLGdCBiGJCuODnz8sAJCUoAAptqoUJ9N3TjrmjDgKztIDeZpORwsuONPgA8ngDtkTXk4xWSsQQjI/2LbqmuV49A86qRxV5fyNq+rVhmhKGDZR5//PEj2t4tIiJyPC37Tx/j4+N85CMfYdOmTfzVX/0VlmXx3//7f2f//v18+tOfJhwOL/cjj0owGOT222/nb//2b3nmmWeW3LD2tttuY2xsjN/7vd/jpZde4tvf/ja7du3i1ltv5dFHH226Pekzn/kMjz/+OFdccQWvv/463/72t3niiSf43Oc+RzQa5b3vfe+ca370ox9x11130dbWxgsvvMB9993Hv/3bv/HTn/4Uy7J4z3veQzweP9Zvg4iIyKpSKpUol6uUy+BwOLFte8UrSyqVCul0nGKuQjDQimEahM70zThnyA6zecuJC3U2XeQjh3NGhUcj/+YQvm1eMjgJbXcwPh6lNPkPQ088EeBb31zDV75Q4U8/m+BDv3+IO+6wuf/+5s+q93PZuAluu23usxZ7fSGmabJty0XEhi0O7Btl586dS79YRETkOFq2v9VjsRgf//jH2bhxI3/xF38BwEc+8hH279/PZz/72VXX5Xzz5s38/d//Pe9///u58MILcTqdi17z5JNP8uijj9LZ2cmf/dmfTR13OBx86Utfwul08jd/8zeUy9Md6IvFIp///OcB+MIXvkAgEJh67Y477uC8887jkUce4ZlnnpnxrL/8y78E4BOf+ARbt26dOn7FFVfwgQ98gHg8zle/+tWje/MiIiKrVLlcplKZrCqZZK5wZUk6naCUL+MwXLjdPgqFPL1nZ6dfrzjZ8Uu+4z3heAbTNPBvCc84lq9aU+v56csBnnytneLmToLdNhOxMiOjYyQTCXbvgWTcTzbZRyFpk5xIEY0OcN99cMcdcMeHmROc1Pu5zNcQdrHXF+LzBVi37mwG98Hzz79AKpU68puIiIgss2OuFU0kEvzFX/wFd999N8lkEp/Px4c//GE++tGP0t7evhxrXDV+8IMfAHDTTTfhdrtnvNbV1cXVV1/NQw89xM9//nPe+MY3AvDoo4+SSCTYvHkzF1xwwZx7/uqv/iovvvgiDzzwABdddBFQ62/y0EMPTb3e7Jq/+Zu/4YEHHuDDH/7wcr5FERGRFVUulymXa2GJbVdr20tWuLIkm01SztsEAmHKlTKxiRiZTG1NWcNJx0VtrOltvsZnnoGdO6nNHa4z4MwzYfKv/UU98AAMDs493tvjo6/ixG+VSFec7MpG2OqNsTsXoVQxKBVheNDJJRd3kE4nicVylEsZzj7T5tCBMIbhw7L78JqHyVYTlMsOotFuYOHRv8fq/vvhkZ8y43tis5ktZ0wQaB3gySef5E1vetMJmYIkIiIyn6P+WyiZTPJHf/RHbNiwgc9+9rOUSiX+4A/+gH379vHnf/7np1xQAvDCCy8AcOGFFzZ9vX78xRdfPKZrdu3aRaFQoKOjg76+uZ3qm10jIiJyKphZWWJMjr6trth6KpUK+XyOcqGKxx0gNj5BKmVj27WK1PPf2cvas5o3dwfoPwypJKRSDR/J2vGlGh0Fuzr3Y2DAYGe2jWTZxa5sG4mKl6fTvSQq0+vZvr02drilpZVgMEI6bRJpy9LaVquCNQwvJj34zDIGE8AYsPDo32P10ksQHYVodPpjLGoQHTmTxKjFnt3D7Nmz5/gtQEREZAmOOixZv349n/70pykWi3zoQx9i3759fO5zn6Ozs3M517eqHDp0CKBpgNF4/ODBg8f1Gr/fTzgcJhaLqVRVREROKfXKEofDgWmaGIZBtbpyYUk2l6ZcrOJwuEmnM2QyZfJ5k5Zg65KuP3d78+Pb5znezJlnzf9aouKZE5DUtbbV+ojUuVwewq0d2FUXZ25LTh03jSAmnXjNEgaj9PTGj6hJ65G68cbmx9/yH1ro7trE0EGbl156jVgsdvwWISIisoij3oaTSCQwDINCocAXvvAFvvCFLyz52vp1J5t0Og2Az+dr+rrf7weYEWAcj2vq18XjcVKpFMFgcMF1n3POOU2P7927l82bNy94rYiIyInUWFlimiUwYOYelhMrn8tQLlSxTA/pdJZUCoItrZjW0v69adMmaI1AbGL62OwQo5nG7TtHOyDmkovm7mAyTYtQqJ3Nm1K8/EqJVMJJIFAmnW7Fsit4zHGufsMw+bwDrzfQ/MbHqD49Z2Bg+lh9ik6xtJlEMsqe3XG6u1/jkksuxuVyHZd1iIiILOSYepbYto1t2yvyLz633norr7322hFd83/+z//h0ksvPU4rEhERkWPVbBvOSlWW2EA2m+bxR6u8/moLdtULGJimhU1pSfcwDLj4Ynjwh9PHGkOM+XqaYNe27My23h2n15Wec3ywGOBgITz19YKBjAGBYJCr31DgsceKXHJJkqeeDhMbb6e9rcTG3hQjI/309GzA7Z5/i9HRMgx4+9vh7runj916a+242+Wlt2czh0de5rXXhujsPDij0b2IiMiJctRhyUqWxALs37+fXbt2HdE12Wx28ZMWUJ9kM999MpkMwIxKj+NxzXzXzeeVV15peny+ihMREZGVUg9LXK7pbTgr1bOkkM9RLpU5dABSycCMEcZHUu3RWF0yO8So9zSZrXWeXT5tzhxeqzzneMSZ42AhTHs7GCZceeXifXHXrXOzZk2ZZLLKRRfEeeHFFm64sRWXWSYXzzNiHqandwNOx+ITA49UY3VJvaqkrr21h3h8lMH+w+zde5hIJEJbW9uyr0FERGQhxzwNZ6U8//zzJ/yZ69at47nnnqO/v7/p6/Xj69evn3FN42vLcU0mkyEej9Pa2rqksERERORkMXMbjgkGVFcoLMnlM5TyFbadYTM2svhEnoUm31xzDfziFzNDjGeeqTU3bSbSVru2cfuO1wf9xRbCjii2zWTz29rn/kILAA4n3HLL0t+jZTkIhzuwrDjXXTdGwA9ed5iHfzrO86/kKRsDWNb6WlBkwLXXLM+UHMOA97wHvv4N+M13zwx2HA4nne19FEczvPpqlM7Og7S0tOB0Ln9oIyIiMh/NZDsC559/PgDPPvts09frx88777xjumbbtm243W6i0SgDjRt6F7hGRETkVNDY4NUwzMktKSvTs6SQz5FKpOlbYxMMzazmCDcpdFho8k1PD7zjHbXPjeeX5xaJAJDJ1LbvNLr6DWBGfKQrzqlwwTAgXXESLdX6nAX8R/4+DcOgpaUVp8NHPA7xeIqB/m7ySUjG0oyNDdWm1ozWRgovl23b4M4/rn2eLRzqJOBpI5822b07OtX8XkRE5ERRWHIE3vrWtwLwwAMPzGlQOzIyws9+9jNaW1u56qqrpo5fddVVhEIh9u7d27Qa5rvf/S4AN91009Qxr9fLddddB8B3vvOdJV0jIiJyKphdWWIYBtWVCksKOdLJDKWSm4svrMx47eIL555/pJNv5jsf4LztEI/XttRA7fNjj0EiYbA/H55xbu3rWnoyuUt3yjPPwNe/Dl//x4aPr9eOzxYIhvF4gsTi4HZXMejFa1YwiAO1yTTh8NzrjgfTNGmP9OB3dLB37wSDg2OajiMiIieUwpIjcOmll3LVVVcxOjrKRz/60anj5XKZ//Jf/gulUonf+73fm1Em6nK5+OAHPwjA7/7u7071GgH4y7/8S1588UWuvfZaLrroohnPuuOOOwD4zGc+w+7du6eOP/bYY3z5y18mHA5z++23H5f3KSIislIawxLDqDV4tVegT1qlUiGVSlLI21imlzO2uWmN1F5rbYONG+deU+9N0mihRqubNjXvTdIaqV3TfxjqO5Dsaq1SJZeDaKlWXQIzq0pgbjAzX7XLzteahyivvRbE5wuRTFiYhh+TDrxmCRgBcpzIvKIl2IbXHcRthXj11TEOHTpEeb5SHBERkWV20vYsWQ633norQ0NDAAwODgLw93//9/zbv/0bAD09PXz/+9+fcc0999zDFVdcwV133cVDDz3E2WefzVNPPcW+ffu48sor+djHPjbnOZ/4xCf40Y9+xC9+8Qu2bt3K1VdfzcGDB3niiSfo6Ojga1/72pxrrr/+ej70oQ9x1113sWPHDm644QaKxSIPPvggtm1zzz33ED5R/7wjIiJyglSrVarV2ojb+jacE9Wz5P774ZGfAjZUq3kqJTeuSjfnnBXhsvbmfUcaLTb5pun5l8w8H+CSi2uvnbsdJn9MmX0lu7JtbPVOsDsXoV5V4vfPDWb882zLKZUgn597vP8wXHSRn/O2F3j4YTCNCJadx2NmyFcH+KXrN3Aif3xsj6yhOJojFhtiYCBDS8thNjZLqkRERJbZaR2WPPfccxw8eHDGsYGBgak+IY1NV+u2bt3Kc889x6c+9Sn+7d/+je9///usW7eOT37yk3z84x/H7XbPucbj8fDwww/zJ3/yJ3zjG9/gvvvuIxKJcNttt/HpT3+avr6+puv767/+a3bs2MHnP/95HnzwQVwuF9dffz2f/OQnufLKK5fhOyAiIrJ6maaJwYmbhvPSS7W+HDUFHBh4TS979rjZs5epxq0P/XhmD9dGC02+adTYDNYwpytIvN7paxrvNVui4uHpdO+MY5kM/N3fgdMJbnetsWw6M/faqfHDs/qlDhYDbNseBuCMbW6ee84mHjcw6cbJAVo7cqxfN4jNOhZvd7s8fN4gPncLBhV27YoSibhpbW3VPxiJiMhxd1qHJQcOHDiq69auXcs999xzRNd4vV7uvPNO7rzzziO67rbbbuO22247omtEREROBYZh1oKE8onpWXLjjbBrV/2rPKZhY+DG4WDO9pP52qgYxuIVKDD/yGCvjxnNW2dXqvj9c/uSzFhXFYqF2sezzzTfLtTmzOE1525naXPl2LgpPPXsSy41ePCHtf8Opr2GHWe/SiZtEI9FaW3tmH8Ry6w9soZDgylMt5P9+zP4fIcIBoNYlnXC1iAiIqef0zosERERkdWrPq72RFWWXHIJrFkDtQLTApZhE2511QKLB5d+n/rkm4XMt8Xm4otmVp3YDZUnhgHlytxr5lOpwPDw3OqUKC2EmTt+2OxumRHuNFa2hFpNNqz3M3JoAtMy8Xj9eD2+uQ89DlwuDy2BNnIVg5GRCTo7/Rw+fJgNGzackOeLiMjpSWGJiIiIrAr2rHIN0zyxPUsMA97+drj7boACFjYXX+xl02ZofWZm4BBuA2aFHY0hx/RNa9thZvVxb7rFpr5t56X7m1ed2DYUZvUZmdpSM8tgMcDBQphMFtyziki2XeEj85QTr1Gaet/pipML3jgz/GiskrnkkirlYgDDyjE2OIHL7WJN76baf6MFNPaBafyeXHsN3HzzgpfOEAl3c6B/HG+4hf370wQCEIlEaGlpWfpNREREjoDCEhEREVmVauODDSqV4zcBZfYv87YNplmmWrUJBips2exouh3m4gvhmR/MvNd8W2tqTVNnHluoGez8jV3nanPm8Fpzvz8RZ46DhTB2dWYjV68XnnjcoKUSZpsrOnU84Q9jOebuGZquknFTLLSSSFZJxfqJuqN4PH462nsWXN/MPjDTXn75yMISh8NJKNhOtjhBxSgwPAw+30HOOeecRQMbERGRo6GwRERERFalelhSPI5hSfNf5ss4HRXO3wGmWQsQ5jRubdILZL6QY/Y437r5msE2rTqJQFsxTocxs4rEpFZ1M3tLTX9hbsVFMAROB0yMQwofaywnAatEuuIkweJbalxuL4FAK4lEkfHhAZzufvy+ID5fYN5rZvaBmXbDDYs+bo7WUBfJ/nH8AS8TE0XCYRgeHqa3t3fRa0VERI6UongRERFZdQzDwOFwggXl4xiW3Hhjs6NlLrwgzpo13ob11LakdHTCNVc3b9xaDzkaLTQRZ7571qtOGl1yMUQctSqSxg+3VaViGzOuTVecREszw4/WNnj3uxorXGrjh5NlF7uybZx33tLm23i9flpaOigXw4wOxOnv37dg5U+9D0yjvr7a8SPlcDhpCbZRSFcxTZORERgeHqFYLB75zURERBahyhIRERFZlSzLgWkZVKsVbNuuNXxdgiPpkzGzqWtNpC1N35oKTqdrxrmDg7UtLQ/9eHoazje/CWedVQshDAM2euKcGZyu/jDK8NI3wWgPsP3GMNC8t8lDD83sbdKs6mTveAvVvXMbs/YXgqz3TO//2Z8P195w4/ucXF/jfevjhw2z1pfkscemv1fN+qzU+XxBWit9PP4E3P/PNjgGcTjWNf0+z+wDU3PrrfNPCVpMvbqEFpNi0WBsrEp/fz+bNs2TSImIiBwlVZaIiIjIquRwODBNE8M0KFdKS76uvrUmGm34GK31yZit/st8o4sujOF2uDCNmaNp6z1JUqnaB9S+7j9c+/MzzwDJmdUfHqP2UY7l5r1PKjXzPvV1za462XSxj6ztnFNFsjcfJl1xAs2rSjye6eqWZlUrdhXS6fnX0kww0Eo8tpFSBuKxNNFofN7vc2N1ydFWldTVqkvaySfLmKbJ2BhEozFS9f8gIiIiy0SVJSIiIrJqWZYDw4JKpYzT4Vr8Ahbuk9G06gQIttRCgq6uEj09KSg6Mc2ZPyYt1pOk/zCUCy2EHc2qP1qI/p84XVaaDcCG4PT19ck1s3ubzB5BbJoGga1hqnumG7PWqkhMdmXb2OqdYHcuwuyqEp+feUcC+/2Qycz/nuZlwAU7fPzwwXY85hi56jDgA1xz+pEYBrznPfD1b8Bvvvvoq0rqWkOdJPvHKBVL+Pw+RkfzBIOHOeuss5ZcfSQiIrIYhSUiIiKyqjROEHY4nJMTcRavLKkHIXYVLAsqlenX6hUNn/1s8+ks69ZDezu86Y1j5AsV3JYb05xZWdKs8Wq4oSfJudvhwR/6SFdqjVNhuvpjIOPjwsAwXrP55JpkIDynt0nzUcQ+zsGJzyzNqCJJVDwUNveSeGHue7u4ySSe+kjgK66An/2s+QjjxWzeYtL2TISxiQwuo0DRHqKvb33TypFt2+DOP178nktRry7JJsbxeG3SaQcTEznGxsbo6OhYnoeIiMhpT2GJiIiIrCqNxQH1viVLGR8835hamO6TMV/Vyc2/AtvPy3P4UIG9+wwMjDlhSbNxv4UsfOPr9RPA6zXYnw+z3T9d/VHpCkPK4PACVSeXXDm34qL5KGKDnc42tngm2J2driLx++GKy2rXLCX4aKxaaZsVAMUn4O/+DpzOqbeFq7Gop6GnycWXGPzw33twGfsp2RmuvXYIw1h4nPByqFeX5HM5wq0RRkbiBAIDtLa24nDox1sRETl2+ttEREREVgXDMDBNE9OsUq1WsCwLh8OJYRlLmogzXxASaZvuk9GsoWu96iSZLFAqgcOyoAyGMbe1W726ZGK89nUuV2v6WtfaCtHYdHVJ1nZy4Zt87JuA6ETzqpNy0Nc00Jhv20+85OHp0vS4XNOCX7qh9nl2mFNv7ArzVaowZ0uSbdeOFQvTxwqFmef0H66FJZs2QaTNyfh4Gx0tI/gDO0mlgwQD848TXg6N1SWlQBHb9jI+nmNwcJB169Yd12eLiMjpQQ1eRUREZNWwLAvTZKqS5Ei24TQbU+t0wQc+MHMs7+yGrvWqk2KpRKlUq2apnTu3/0V9C0sw1HwNF18CrZHJsbwVF2072rAcxmRTVWOyx8i0YTPMNdcYTft4NBtFPFswBDfdBL09c6+ZXVVSr1SJFOOcS3/tw+7nXKOfK4L9rHfHF37YpPXuOBuz/bz0jX5e/mY/Z1X6uSqUY5vfRWKswr69ry2pEuhYRcJdlHM2mXQav7+FaBSGh6PkcrnFLxYREVmEKktERERk1bAsC8sqUZlsODLV4LW4+C/fzcbUfuD9cNaZM89rrC5pnM5SLpWoVMA0HVTtKrMbpdb19MBv/Do8//mZx71eePwxKFeggIfn871UfgbOx8HlBMOEaGm6uiSHkzf/hg9znn+6arbtp1FrG7zz12Zu32nsR7LeFeelb6an3sVGu95Y1sZrVebcL+LMcbAQbv6wBm3OHB5j1n8PA6olL6WsxehIgsOhQ6zfsGme7+DysCzHVHVJNpDC621lbCzGoUOH2LZt23F8soiInA4UloiIiMiq4XA4sCyoViuTXzsxTJY8Oni+IARmTsJJTvYCGRisVZ74/VAud3DGGSnOPz9DlSrGAgW4zSpBPB6Ixaa/nnwLFAuNW1oMXs+3cYZ3AsPv4uVvDcwIFGzAaA+w/cYwsPDkmny9X0pDDxGohTkbNkDl1RweR0OoMfmgdKX241+z3ilLYXS3wNjc3ivBzWEiEZvHnozy/fvKOJyV2pamyWdfew3cfPOSHrFkkXAXycNjZNJp1vS1MzqaYHw8TSwWo7W1dXkfJiIipxVtwxEREZFVY/Y2nCNp8ArTY2o3boLbbpsZatQbwEaj0z047Cpks7VjsZiDQ4e9tcauNvMVlswQbtjyUttqs7h4ycNhfy/VbAmPUcbd8OExyhTGpreR1CtFOjph7axWHLkcpFK1rTX9h2e+1n8YDk+GH/XpQvXP+/Nh0hXnjK1JOZyU/bXJOk1atUwJBODCN/nIMff6TRf5CId7SE74yKZKxCZiRKO17210FF5+eWnfnyNhWQ5CLR3kE2Xi8THa2roZHYX+/n6q1eryP1BERE4bCktERERk1ahtw2FqG069weuR9MCoj6mdvRPjxhsXv3b79jSmaYLdvMHrbFdfXQsyrrkaNm2e22Nkvlv4/ZAt1aouZocZuZLF1/+R2sfXYXCwNrkmEZ9/HbHY9PnPPFNrDlvf8tMYaqQrTsYq/jm9U/xbwlzzRoOOTrjqyuY9WSwLrvslsBwG/i1zrzdNA9OwOP+8btxmGYgC0xVBN9ww//qPRWuoc6p3idvto1BwMTFRZHR0ntFIIiIiS6BtOCIiIrJqzN2G45hs8FrGtu2mTVebadxy0yjY0mwcb01HZ5EtW/LY1epkYcniz+rphjOCcaIPpxkDzrLBDtZeGywGaNkW5qUXZ17T2gbpDLSYtQCoMcwAcJllUqnp8+uTZ+abjgO1iTz1qTz9h+HCC2uNZvenZo4x3p8PY1cNotWGiT1VJ+ddVOudUh8nfM658H//b237T7CltsXoyitrW3wANl3k46U9TrzUeq9sv8g39Yyzzgzx7HNJSrECJXsYWDtnS9RyqvUuaSOXihGPR+noWEM0up9QaJiOjg6s+lYgERGRI6DKEhEREVk1mk7DsUxMy6BULi75Po1bbho/gsH5r7n6DXEcljVV4bHUYKYSy01tp/GYZbxW7SPizHFg/9zqknwW4jE4XGg+Uqd/1vF4vFYtEo8vvEWmbvv26eaw9eoSqFWVREv1UGNyYk/ZxYCjDdOc+V4bt/9cd10tRKkHJQCmaRDZ0UbWcBHZMfN6w4BLL+nCbVQwSAEpfvmXs037vCyXUEsHxUyFZCKOy+XBtr3EYhVGRkaO30NFROSUpsoSERERWTXq23AKhelpLU6nG9ORp1Qq4HK6l3SfG2+EXbvmHn/7rfD97083gK3aMDgAPb1Vtm7Nks97ps599hnY9Tozq1Mmm6nu2DF9KLCpheqeuQ1P+wstpJr0pa1Pts3jI11xELCmtxilK46GQGP6/Gefqa3VXqQNh2HAgw8CD04veFe2ja3eCXbnIjQ2YklUPDyd7sXrrW3faWwSC7VwpF5p0szaszysPau36Wtbt7h46uk2yrEY7uAAfX1uSqU+nE7nwm/gKLmcbvzeEMV0hlhslI6OXkZH9xIKjdDZ2YnDoR95RUTkyKiyRERERFaNelhS34YD4HK5MR0GpXJhgStnqk/FadTXB5deOrMB7Hsn//zr78xiA1bDL9X9/bUtO6lUw0cSdr4G3/xm7ZxvfgOe2DW3N0jVhi2eCa4I9rPeHZ9nlQb78zMntqSCrTTrLFupLB6UQC2oafyA6VAkUfE0vSaXa94k9lgYBrzp2gidEYOLL4wxOppgbCw6e1fUsmoNdVJIl0kkxvF6/Zimj1isyvDw8HF8qoiInKoUs4uIiMiqUetRwoyGrrXKEoNSaenbcAwD3v52uPvu6WO33lo7Xm8AW3fnH8P4eIGBATANayr0OPtcm2a/ZzscMDFR+3MqVduus985szeIaYDXqgU+EWeOg4Xw1GuNI4Dr22QCVoms7eSqt/jYdc/02OHZ5zfjdtem+6x3x+l1pee8PlgMzHj+fLZvX/SUOZ55BnbupGn1zUUXmdxyczuJdInx8TitkQA+X4JQqPn2o2aa9p6ZZwyxx+PH7fRRyBSZmBilo2MNw8O7CYdH6ezsxOVyHfkbFBGR05YqS0RERGTVmD0NB8Dt9hxxZQnMrC5ZrMFotVqlWgXTMjEME8OAjRuqc6bbtLZBpG3u9dGSj3y1+XSb/skRvvXrr7yy8UqDvcU2khUX+8ptfPvbBrP7kXb3LDxV55d/ufZ6mzM31S+l8SPizDW/eNb72rhp0dPm6D/cvPqmXqXi9YRwWh7cDj9Dg3FisRil8tInGzXtPbPAGOJwqJNCqkwsFsXnC+BwBIjFbFWXiIjIEVNYIiIiIqtGfRrO7MoSy2FQKh1ZWGIYM7fcLNRgtFKpUKnUKkumkwmbiy+eeV4+C/v2Nn0au0vtVGxjzqjexh4kucxkpUTDGmNlD0+nehnNeEiloLGAprWtVlUy3xaccgUefrj258OTocxCYU2d1zvz61wGvvH1meOHl+LceapR6lUqhmEQDHTgqLrI5XJMTJQYGxtb2s2Zf9zzfGOI/b4Qpu2kkCkSj4/R2bmGsTEYHR2jUDiy/39EROT0pm04IiIismq4XC6czlpYUq1WMU1zsmeJeUTbcOpmb7mZjw088WSIV1/xU60aeACXWa1tp/FON2XNLVCkUfZ4cW5up7qnYTvOmjCtowaxyW079fG+U8+1wa7QVDAE11wNrzStosgDBQr5CoU8gEW0as1oGNssrIFaAPNr74DvfJcZ62pc27OTYUljw9dmNm2C1sj0fer3b6xScbsCOB0+MGxGRycIBJwE/CmCC40mmlSvDhoYmD62UJWQYRiEQ53EUoNMTIyyefM5uN0tTEwkGRoaYsOGDYs+U0REBBSWiIiIyCpiWRYOh4XTWaFYLODxeHE6XVgOEwybcrmEw3F8JqocPOglkTAAg7Jp4MTGNGrbbhwuSCUWvv7iS2DjRh8v7XHipUQOJ+dd66NrBB56ePHrG7W2wTt/rRZ4PPTj+tEKkATSGJQwqU5Vsdg22Bjsz5ts90+X0OzPh5ndMDafqzWoLVdqRTTNqlYqlbmByXz9Sbo6Z4Yll1w0t4onGOhgPJbFcpmMjuZwucbxer2LTqlZqPfMfFoCbUzEhsmnc6RScTo713DoUJLR0XG6u7vxeJo3uhUREWmkbTgiIiKyqrjdbhwOKJdrlSSGYeBwuDAdHHHfkiOxY0dy8k/T23AAshmgOnfrSiO/v1ZlYZoGkR1tZA0XkR1tmKbB2EtxttPPFS39XBGc/ph/Ss7MwKGWJ+SAQSzGcZs5vGYFt+nBZQRwGQHcpgePaZGulMhUautOVyBaKlALWablsrXeIrlsLSgxZ/VIqatUZk7Ima8/STrDVG+X+XqfOB2eWv8SPGQyaVIplrwd50h6zwCYpkko2E4+XWZiYgSPx4fPFyYWg8HBwSU9U0RERJUlIiIisqq4XC5crizFYqHhmBvLYVIs5vF6AsfluVu2ZOnoqBKN1ssWaiUX9S0qra3zb8O58ip49tl65YUH6IVngGfhTCNH0CjPmQg8e0pOnWHCY4/VPgCKpSQwjtssY2FhEMHAh9GkvMK2KxzMp1jnybI/X8ZiggppoA3wN127Zc6cvgPTk3WMDLz0jdqxjYDLPXeyznnbweuDX/yi1rx2vqqPoL+dsfEkbp+LaDSFxwOBQJpAYOH/nvXeM1//BvzmuxeuKqkLhzqIHR4hnUqRzaZpb+/l4ME44XCM7u4sPp9v8ZuIiMhpTZUlIiIisqq43W6cTmb0KKn1LTEolY+8b8mS2LUtN294QxEwsTGohyV1F18yXUERbpiIE2ypVZXMV3kxZiy98app1ao9pu+RppAfx2cVsfBj0otp+HHO2onkctn4fDaGYZGphnkt20u20o7btHCbBQxGgFFmV5kAlEpzp+3UJ+t4zDJuo/bhMcq0uWamRV4vPPZ4batQPlf7PF+DWNN04PNFsIsmhlEmnrCJxWLYtj335FnqvWe2bVv0VAAsy0HQH6GQrkxWl3gJBCJMTMBAYwMUERGReSgsERERkVWl3uS1cfqN0zkZlhzhRJwjtW1bhUibMRloTP8S39pWC0SuuQY6OuHqN9SOt3fCddfVqh3mmwwzmPeRrjgXnJID4PbAL13XeKQARHGbJTo73FhG21Q1ybYzDXyTBRmGCWefa7Bp88ySC9PwYdKDgxY8ZhkHSWAAyM5Z40UXzQxM5pusY3TNDHg8noVHB8/m87VCBSzDSSadI52uEE8cQTOXI9Aa6qSYrpCIxygU8nR09BKLGUxMJMlkMsflmSIicupQWCIiIiKrSrPKErfbM1lZcnzDEtOEG653EAiC3VCFUe8h0tMD73gH9HTXjr/91toxgHh8boUGQCFvTDZandas8erVb4BNm6erV2Acp1Em4HWz/ZxO6n1JPR7o7KxVWQRboLsLdr4Ku3fPuSWGYWAaYSx6cE1WmcAItUaxNa1ttbCksWpjrDI34Mnh5MI3+Wb0bonFmn4bp0YHz2YaFj5fhEq+imFUiSds4vE4pXK5+QXHwOXy4PMEKWYqxGKjuFxugsFadcnIyMiyP09ERE4tCktERERkVan1LJkZlkxXlhynbThMV0+sW+fgllsNwuHaL/DzNS2drf9w88kyANFSLXyA5lUlhgmbt9RCiYsurAApDHI4DaiWO3j8cYtKFTCgUoUDB6E1XGt2msvVeqoU8sycVNN4f8OFSQ8WfjxmCRgHahUdsXH4uy/DztcavhfVuQGPf0sYy2HgXaTdR73nSrOtOAA+bxgqBiYm5VKJdApiE+ML3/QotYa7KKTLxONjlMtlIpEuYjEYH49RKBzf4E1ERE5uavAqIiIiq4rL5cLhgGq1TKVSwbKsqfHBNlUqlTKWtfCPMPffD4/8lDljbq+9Bm6+ee75hmFgGGDbNqbpwDThkkvKvPTiwk1Ln30WXn+99pxSaaEVGezKtrHVO8HuXITZJSA9PfCNb9TuU67YGEYMl1HFNFoply0aCy9KxVrAsXFD7eu+tbWqlsUYhoFFG9gWHjNBoTqOjQ2EadY2pB7wBKzaGOTtF9VSkosuggd/OP9z6j1Xnn2mIYAx4Mwza9fWq0uyuXGcAZNUysbnyxEM5vAuNHLoKHg9AZyWh0KmRCIxTltbFz5fiFgswcjICOvWrVvW54mIyKlDYYmIiIisKrVwxIHDUaZUKmJZXkzTxOl0YTryFEt5vNbCE1Reegmio3OPv/xy87DENE1MEyrVKg7LwjAN2tsrvOMdC6+1v7/Wo2MpEhUPT6d75xw3TBgebpxIU8CghGUYeNwBmhVAZDLwi0ehZw1sWF/bPlSdp6plNssIY9jgNhMUqhOTeVJ4xjn1aTimYVO1wbSrvPSNAQaLAQ4Vw5PB0sLPqVRqoUld/+FaWALg87aSzU6w+0dVXLESBzCBAQzDwAZ8G0Pc8qH2pb2hRYSC7cTSA8TjY7S1ddHW1s3gYIJodIyenh6cs7vlioiIoLBEREREVqFak9cypVIBj6dWbeB2e7GcaQrF3KLjg2+8EXbtmnv8hhuan2+aZq16xK5imm4wDSrVxftonHMujAwvetqC7Ors3TNJHEYVaGHLVoP9ByCbnnlNqVT72L8PhgYgEITkUvukGmASBtvAY8bJVyewqQJTzVKmpuHUuY1akhNx1qbh9LpmLQgYLM4dK9yosY+JaZj4fBGseAKfUWX25KF0fwZYnrAkEGhlbGKQXDZLJpPC7w/icPiJxzNEo1F6e+cGWCIiIupZIiIiIqtO8yavXiyHSbGYX/T6Sy6BNWtmHuvrqx1vxjRNLAsqlSqm5QDToPr/Z+/Po+S4z8Pe+/urqu6urt6nZ8eABAYgQZAASGLhKoKkKNKyYy2kbEe2E4dy8sZ+Y1v2kX3fnPve+PracU5O8l77RJFjWzc3ieMrUpKlWFJkx7JoUpEsriIoUqBEggQIgthn632v5f2jpqb3mcFCGUM+n3PqNKa66lfVPTpi9zPP4vaP2e01u7WzIevaBjWADVgxF7CBOobyiIQTHDsKqw4A8vx+Jf7i67kBSKf9f2oqhUYGU7NR5PH7mEAsNnwazqlGciWQ0rsFgZRgjU6D+r5Y0QzGtDvwOptvzazjxayPrukk4hmaZYdcbh6AkZEJlpZgbm4Od70pOUIIId5VJFgihBBCiCtO0OS12WxHCkzTQo8oGo3+0be9lIKHHure9+CDw3uPaJrG00+n+I//McUn/53OZx+Fv/wfLo98xh3aqDS4zv7963lFPs+FUIi+JqmZLOzZUwHqaLgowoBOvb5WLxRfscDQ5q7gB2kSCbh5r98QNqCpJBojywGTAonEEvfca0PaouoNHne8WiAFIB73+7x0CqYJddKUxuy+NBXP7bpOVYW568HE2i/6AqSSozQrDqVSDttukUikcd0IhYLDwsLCZb2WEEKIdwYpwxFCCCHEFcc0TSIRqFTa3+z9MhyNSrOO53moYZGPZUF2yenT/VklvQ1gXTdJPq9wnGBNDVdTNLA5dTK80muj12c/6yd0KG34JJxeV1/t31OnWgUKeUU0Wsauu8SsGAqw1xEoWQ9dhwO3LP+7509lmkqA5xLR8kxNncYwqnzoQxO8+WIa9+j8ynHBuOPOxq/QHUjRdXjvfX7D2swhyC2tPk0oFhtB25SHM+2bSu4OL49tvnwfUyPhKGEjSqPSIp9fZHR0kmx2gsXFtzh//jxjY2Nr/u9JCCHEu4sES4QQQghxxbEsi0gEGo12sCQcjqAbOkrzaLUahMPmqmsoBR/7GDzyKPzsz3RnNvQ3gO1NttWXu2g45PPwyCOQTEKxCHjtbIpScXi2yiCZLJQr3dkd4JfSvPJKHFjC1Dxs2yST6T9ukOwoLK6RHBEOt/+9dRa+/3L385pKAS3q5Rbz8wvous5VN47yytEQUVo94479scK7Y/2BlPvug6AFyMGD8NRTq08TCrJLjp4uElMaZcLcuL9FPp8nm+3vWXKhU446pZKjLAHuI1wAALwlSURBVBZPkc/PMzo6SSqVZX7+DMVik1wux8jIBdRTCSGEeMeTYIkQQgghrjh+ZonC8/yJOKFQGKUUphlFD9VoNGtrBksAduyA3/nt/v3DGsDG4zblsoH/EUnh0aJWi0LND2gELVRWmwQTZJnoOmy/Bo682n7uwD7/e/65s4PObAIOGopW02R+ftAx/Sr9vVb7bN3a/vf4OHxf0Ve2o7wsi+dbzM21qNsOSulkwllmw0scrY8QMRV2y59y05ldEgRSejNIpqZYc5oQQCyWIXJNntJRRWZ/lEq1QbFYJpVKYxjdH1UvdMpRp3gsw/ziaerVOuVykXg8ycjIOAsLZzh37pwES4QQQnSRYIkQQgghrjiapi0HTGo0GjVCIT81wjQt9HCeRrNGgotrAvqVr8A3v8lyQ9f2/ljM4Y4783z9r0eBMI6nCKl2Hcx1O+HwS2uvH/Ql2bYdTp9qB0+UBk8/7a8TCrcDL20NNBzADwzhwVS4xGio1tW71QMWWlHONv2+HvU6y/1dBt9PxPQDJAGl/LKkUye7j/OvOY7mnUGjjustsdQYZanhp4pMjcKmGXj+OwCKI9Us10SXeL02QiSiaNTh0Uc6F4TrrmNoCRPAoUPw6qs6tpOi4eVpPd1CPb2ZG28s8uBDecZGu7NLLnTKUSdN00gmRqiVc+Tz88TjSdLpMY4dO0ehUKNYLJJMJtdeSAghxLuCNHgVQgghxBUpGo1imlCvd/ct0UKKZnMd9SlDHD4M8/PdgRIAy3LYuqXM2BhAGG85swT88pnbb+2ffBMZktxi2/6X+lKp3cvEc/2fv/PcoEAJgIOmAEIre1J6E1NziHRspuaQ1LsXWC3TxXHg6afgqSfh+Jv+PmPIn8uU0lGMEtFcFEWgnbaye7cf+Ajeg4Jj8nx5Gi1tkhmBasV/fStbsT8g0+vUSf+4ajlNs+JSKlYoFlscPRalVCzT6ulue6FTjnqlEn6j12IhR6vVxDAMUqlRlpbg3LlLnAEthBDiHUWCJUIIIYS4IrWDJe3pN6ZpYYS1rl4mF+qBBwbvf+978+g6/PiPO6TTIVwP/NIYv3xG0/sn30xv6lsG8IMX62342tZC4aE6En/PL/cJ6Z08M9fqHqez2sQcu+Vnn9Tr8OZxP2CSzw0/XlNRFCnCmgMsAC3SaZets4On/xzY5wdSBgn2Hzrk93155DMd2yPtEcNKhVAkCSsbWOTmm+tUKpDLdd/ohU456hUOm5iRGM2aQz7vN3rJZicoFBS5XIlqde1JS0IIId4dJFgihBBCiCvSoCavkUgUzVA4no3j2Be17qDshLExuPHGJroO09Mt/tkvhUmlNaDZ1YtjdrY7u+Tyfre2lzNLjJWGrDnbpOoY3aN1HYOcvXa/lkE8F44f6274OohGCp3wchnSPNdcW6S1nA7T+R4E703v+9L5HLQzSHozTyqV9nkaGULKJZMpsWd3iHIZSqVq1/ho6P79XUhWSSCVyNIs+8ESz/MIhcLE4xnyeZibG9AQRQghxLuS9CwRQgghxBUpGo0SiUCzWcd1XTRNQ9M0wmETzWhQb1SJWRfeYyLITvjUp9r7Gg34//2fU9i2h6Y0lHKZmlSUdZu73tMeU6yUP+Xl20/CsVOwaxc8MaB640JGCbfZgIdCx/VAN8CxFWeacbZH8ytHnWnGgUsbczu/xvQcpRSaN0ZIncahyvdeMqlWbe68U0fT9IGTbvbvh8e+3l7jwL72c7t2w9kBTW137/Z7sDz2dVDKRPMs9t/YoNUqE4nEKJcr5PN5xscnOu5t+JQjWHtiTtDotVFpUC4XSCTSZDJjnDmzxNJSjs2bN6Pr+nrfSiGEEO9QklkihBBCiCtSKBQiHPazLDqzS/wmr9ol9S3pzE4Ih/2RwLklnelWntvUcW7lBFedU+z2Iiz8z1Mc/np+5dypKXjoQf/fs1v7MyoAjIv6ru0sfzDTsVssZ5m0s0vg0rJKOq0nkOP3L/GzPRqNImfOQrlUAtqTbqam2scPyjgZ9FxgUFbKyEiGTRMO1WqeWCxBtQqlUq2vd0kw5WjHjv77DibmzM93bHP+xBz/dSmSiSyNikMu548csqw4mhalVHJZXFxc+80RQgjxjieZJUIIIYS4YvmlOEUajRrRqN/gwjSjGCGNxiUESzqzE26+Gf78v/n7J0IVYnrnF3MFOFRyNSC9PL2lHWz43Gf7G8Vq+vAeIpoOrrNW5okfMgmF/ekzbx5XnGik2BwpcrKR5FKzSgzDb0C7HppKoHtlDGVTr+X48lcm0JSLUst/b+uYeBNk3Tz1FGSz8OijdGV39F6zM/OknakSx9DDOM0WzWaFcDhKtVqjUCgw2jMZZ5j1TMxJJrLkT89RLhVoNhuEwxHS6VFyuZMsLCww3jk+SAghxLuSZJYIIYQQ4oo1rMmrHlaXFCyBdnbChz/UzjI5VvfHEbcbqvr/SMz65T6dvTfAf6zV2tNldB323jz4eokU3HG7P1a4P1ASlOB4KOWnpWzd6m+aBmUnzCvVUcrOGs1G1vO6r4NNZondsTn2dGy7Y3NMhUt9x2tkCSmXerVOtdKkXNaGTrwJMk4K+f4eJbWOX5fS/ODII4/4zV87M1WsaAa75lKu5IjHU5QrUCqX192jZj0Tc8KhCNFInGa13eg1lcpSqWgUizXK5TJCCCHe3SSzRAghhBBXLMuyME1YWOht8qrRajVWeplcCqVg82Y4fRpONxMU7DApo7n8nKKKYs8+f/rMsN4bN90MJ074PTwmJ+HYG5Bbaj+fycJP/aR/rajV3dvD5wdKQGMqXGI0VEN7E5behF1RP0FjoRXlbDNxSa8V4NhR2KL5I4l7JfUmvS9PqTDKSxLWSjTcRcCk8+9tgybhDHufAp4LQTzihUPw6iudz6aYuXqB3fsbOE4TQ49QrTQoFktkMpk1X9+gnjSDJuYkE1kWCm9RLC4xPr4JXddJJjPk84ssLCwQj8fXvJYQQoh3LgmWCCGEEOKKFTR57exZEgqFCYVDKL1Bs1XHjFirrLA+SysTahWv1ka5NXFm5Tl9RqEtNxAJ+mssdbS1yGT9MpTOkbqrNTsN1ugMpoAfLgFI6T2BjOXzNoXLTIfLuCjONWMXHTip1+G8YZGINvE8/76Cx7mWBcrPkOlM5NBIAxV01cDx8oDfZCQahcqxPN97ttxVHOQB2+NxjpbTK/tiMX/6TS/HaWfqBC94YS6N08xRqeaIJ8YoFuYoFoukUql1BceC7JLTp4dPzIlZKeYWFPVanUqlRCyWIJMZ49SpRRYXl5iZmcEw5KOyEEK8W8l/AYQQQghxxTJNk3BYoZRDo1EnEjGX91sYkSr1enlgsGStiSi9fuQBeG25z0VndknJ9ZjZ0WwvofxAyNf/2v/5qkiezXaDlz/bXssD1GiczEia3FJ/s9Ngje7sErVy9oJrkaAdyOg8TwEaXl8GiGlCvbGyxJqCprGWbq+s3dk8NhKGakewRCmF8rKE1ByOVwTiQJhIxMPJ1bBUf4lMEr/PS+COO+H557uDRMMCKHv2pHGbizTqVdIpHTCoVm1KpRKpVGrN17fWxBwATdOIx9I0KwWKxSVisQTRaAzDsCiVqiwuLjIxMdF/ohBCiHcFCZYIIYQQ4oqllCIWi2FZZWq18kqwxLLiGJElavUK6QHfnYOJKIEd0QW2RAqUH4fPfsPf5wHW1hQf/tXRrkwEULxYmWRP7DyJm+p4ysF1bTTN/9g0OwvpEeAcjIZrmKq/U2slV+PgwXTXeN2gOSzeciZHV5NX/9t8JOIxszNC7XWDqDa8R8dcqztAVK+v+Vb2UJxtxdmm51f2dI4krlb7z9BUFM+zCKkaLW8BmOb6XVWsehL36HxflorfjNaXyfrvG3QHiQYFUJQGzz1rYLsx6l6d6/fkueuuFOXyIsVikWQqta4Wt0FPmtUkEyOcmVuiWMwxMbEZTdOWG72+xcLCggRLhBDiXUwavAohhBDiihaPx4lGoVptN92MRuMYYY16Y0BaAv5ElE7BlBtLa2Hib1FalE/55wd9LgKLtsX4+7eyeVfYn25jt6MRSsFdd/n/Dm3yAwLthrD+Y2I22Tdet7M5bLnc2+RVAxS2DS++qDjdGN4v40LGB69WRbLUuvCRxBojGAoUdaDEi9+N8MyrUapuaCV7QykoOyHmlwM6iRQcvMvf3zteeHa2u3wJ/PelVIJKOU2j4vDGGwVMM4bt6FSrzmVtvho142gYNGtNyuUCAMnkCNWqRrFYp1Tqb3grhBDi3UEyS4QQQghxRYvH41gW5HKdwZIYRkTHcZu07CYho3tKTHemiD/lZjRU68t+OFrL8IlPtM9LJDxKJUU2a3P99Qb5vEldr2LbDSLhdgBjatJ/3H2XxQ++WCGq/FnBQaDglSMWzx6ha7Tu6k1P/UiD7Sh03L4ymU6dGSCrMU247np49QftzJOgeWxwtsLD9fx7HramuRxDqddBKR3NSxHWCjTcAtWK3zfljXCaXdb8yjnH62lAoTS4bgecOQNPPAF4YDv+COV6DV54AfbuHdzDRVNxdM9g1/Ut6vUi8ViCcjlPsVAgcRmbrybiI1QrixQKiySTGXRdJ5UaIZ9fYGFhgUTi0pvqCiGE2HgkWCKEEEKIK1o8Hsc0wbYb2HYLwwihaRqRSBQjXKdeLxOK++kKnb1KVnp44PchKXth4iqYcgMFO8KxQvcX4c2bPRLJJrccyKG0SUKhCEpXtOxGXxkNwOc/r9iaThMtdQcKSq124OGFQ/DSS9BqtQM1q/MAxYlGis2RIgYOpu6noQzMAFEM7FOy/RoYycDtd8BTT0KjMaB57LJB+wCMkP/odPWbTaJTQNHAowQkmGtalCMh4nqrK6vEc/2MmkQlzy5vOdilA8tVRIuvxlH70hw86I8Srtf97JtAJpNm8+QS1WqekZGrKJXy1Got6vU6prm+7Jq1JOMjFM7OUS4XsG0bwzDIZMY4eXKBpaUcmzdvlkavQgjxLiRlOEIIIYS4oum6TixmYVkDSnEiOrV6uxQn6FUyP9/9pTscVszcOdq17iu1LL3ZFIWCRq2q8/jjo/z+78GnP23y0mGFbTe6ymiC6oxSERZaFjX8qEJnoCDgONBs+IGD1QMl7Sav/lphXqmOcryRoero1BydE41U3z3rQz7NHX0djr/pB2i2X+PvOx8EMXrKhnp7oATCIT+A0Wp13KVSKFKENRfIE4nYgOJINUvRDnOk2v2+5nIQd2tEdbtvS2n+lKOgZOm227qvf8v+FJ7t0mjUcJwmUStOtcplLY8Jh01ChkmzalMq+WORTNPCMCyKRY/FxcU1VhBCCPFOJMESIYQQQlzxglKcarX9Jdmy4ugR1dW3pLdXSeADH4C7P5KgqvxynaqKoEa7s0rCYSgWIZczKJUM8nkoFExOndawnSY37Boc6di9RzFyU5aqCnNS9Qdg1k9bDpN0X6fshPl+dZyXq+M0tO5yI1R31keneh3ePO4HTMbHIRJpT8Hp7C+yWr+SQY1e/csm0VEommzbvkAiYVNwTJ4vT1Nwuteq19vNXnuDNKntya5je3uabNtuEIkkcOoOlWqemJWgUoVypYIz7IVfhEQsQ6vqUii0AyOZzBi5HMzPz69yphBCiHcqCZYIIYQQ4oo3qMmrZflNXpvNOo7rf3EOepV0mpnxxwVrumLnByep6CY7PzjBQx/pDmq8972Drmyw+0YdpeCqqxorX+QD6eWxwJt3mtz00Wl23Ta8NESt+alLDQyWdDzdZ/Pm1Vf0XD9g8vRT4Lr+In7Pk7b19kDpuhWlUCQJ6y7Hjjap1Vc/f75lUXa6m8BWvRCz+7ozWpSCgwdhbLzdFNaKpnAaDrVqAcMIoWth6jUua6PXRHyEVt2lUi7TbPr1W8nkCPW6TqnUuKzXEkIIsTFIsEQIIYQQV7wgWNJs1lYyCgwjRDgSQQtBvT54qg3Agw+y8iV9770W/+D3trD3XqsrsDIzAx/9aH+gZXwCrtthonSNF16oU691P9+o+k1KA52ZEbFY97G7dq31Kv2JOB79o4gB8LrLYVAwN8eacQ7P7S6lCbJL4MIm6/TdrZZE9xTNRgu71Z+C0h0cUpz10l3Px69Jo2n9N987RSgciqFpIZymTbVaJBZLUKlc3lIcwwgRjcRp1ZyV7BJN00gk0hSLsLS0tMYKQggh3mmkW5UQQgghrnihUAjLMjHNOrVamXg8BQR9Syo0GlVill/S0TkJZ2bG/3kQpeBjH4NHHoWf/RnQdT/Q8qlPtY+59x4IhSJohuLU6Qa1nmBJreY3MN23r71m0Kz06nCekF4O+rWinYDbk3CmEedEIz3gjozlZq0tILr2m+JBo776IRFz0DHt5rF+eUyQ7sHQpJZemgY7r1ccPpwirOVpuHnAL2u6OpJnOlzuW68Rj1OthrBUi6oXYk9HVkln89yO21yZJGSZKSp1v9FrNnsVhcIitbpNrV4nerkavSZGWCiepFBYYmxsGoBUKsu5c4vkcn6jV6UutsRKCCHERiPBEiGEEEJsCH7fkjqVSmklWOKX4sxR6yjP6Q2CrPb9dscO+J3fbv/cGWhRmsfXvqbwPBPNg5AzODKxe/fgL/tutUbU6Bn9q2AkVBsYLLFiGpNjinNv9Y8Lvljbt/uNXhuN7v1B89gu6wyUACSScORVUCSWJ+M0VybjZEN+M9dejVKN11pZZkNLHK2P8Ox/VIRCfi8VvHbT3E5BICpqpihXFmg2a7iujWXFqVbKlIrFyxYsiVlpzs+fpF6rUatViEZjWFYc1w1RLrcoFAqk0+nLci0hhBBXPinDEUIIIcSGEDR5rdW6J+LoEY16o4rXMWomCILs2HFh1wgCLeGwh+cqCgUoFqPkSzr1egNd744oBD1LeifllErDm5qeanQ3NQWImDbvudPjqqsgFLo8wRLd8Bu7JlOXZbm25eCTbfdPxoHhr/tkI8lSw28Cm7dNPNefElQqwrDJvPk8PPIZ+OyjBn/1VzH+7FGHJ54oYlkJqlWoVKuXrdGrpmnEYylalXajV6UUyeQIhYKU4gghxLuNBEuEEEIIsSEEfUvq9Squ362USMQkFA6B5tJo1tZYYX127IB/8A8qHXvCgIGDx46d3dkl+/f6AZZdu/vXGdbUtHe0MMDO6yqgFJqmoRutvucvhhn1r9lsXpblVmzd2t1Y1s8u8SfjQOmCXndg/wH6mucahl/mFASfquUE9YrLsTfyhMIRDMNv9Ho5e5ck4iM0qjbFYm4l+JZKjVAsQj5fuKwTeIQQQlzZJFgihBBCiA0hEolgmiHCYY9aLWjoqohGYxgRrWuE8KW65RadsbHOKEOURErjppuqXV/qt271Hzsbu7YpjtfTXXvi16SJxbrrgiKmy8xMEzwFmmLTtN2VJdMpHB64e6CtW/zHtSbmXIyxMTBC/r+DyTghzQVKgOK02z2WOX5NmszI4HqoTNZ///bv796/84bunxUJDBS7djZpNmpYlt/o9XJOqrGiCTTXoFltUqkUATBNC00zKZVc8vn8ZbuWEEKIK5v0LBFCCCHEhpFIJLCsJarVErGY/4Xc71uy5E/ESY5dlutEoxHufe8Cf/b58WAPlVqeL32pBh5YMaBJV/bE/v3w2Ne71wmyLOJ6ixohdu+zOJ6HY0c7DvIUT3wjw/RUk6uuLpHJwtkzNo16qO++hsRQ+il4/XW/X4m3/POF9CRZTW7JDxKFQ2C3gsvF0ckDDaDB1HUutWMhorRf95t5/9xepQI8+oj/2pTmT+/JZOH2W/3ypuAcpTTS6ThXbapQrRVIJsYpFhf5+mMxDn/P626+qmB8DObm6Wsae/dBf5T0IEop4vEMtdoShcLSSm+cVCpLsXiapaUlstnsJb1/QgghNgYJlgghhBBiw0gmk8TjS8zPF1YmlphmDCOsUS1dvgwDTdO4+SabP/9vHratAItKXUM16+gKJiaBXPc5s7MQjdIzMUdxpJrlGmuJ5vgImqao9CTANBoKGgYLCy5btuhommLrVptXX+kPlrTWW6GzyqScqXCJ0VCta+KwByy0opxtJcCD6UiJrDH4mOxmP0gVi0N1eWKwUjrKszBUHU8rMjIKLS1C9agie+MI3/2u4o3jg+/Htrubu4ZCcPAu0PT+ANT+vUncVpF6rUg6NUk4bPH6a1EWFvqzVsplqPVPNObll4cHSwASsTTFuXlKpTyu66JpGslkhuPHT1MoFLFtG2NYkxUhhBDvGPL/9EIIIYTYMJLJJJYFjUYV225hGCEsy2/y6rhNmq0G4VDkslwrGo1w6615nnwyA5h4aLi00Lwmu3YpnjzhH9c5Cafe6F+n4Jg8X5pGr0LkkD8959zZ/uMqFZ2//XaIMHXCmk0odAHBkXXQDXBsSOlNTK2/90bKaBLfAufOQdptYqrBx4yNwbnvl5is1JiKtZ/z8DjfhLN6Bdu2SG6CrbuzhCMRXvgyuOts93HvvTA15f87KG/KLfnZJtdcY7GwpGM3WtTrZSwrzq5dRU6d6p+Ic/dB+NrX+te///7Vr2+aMTTPwK7bVKv+5KVwOEI4bFEuV8nlcoyNXZ4MJiGEEFcu6VkihBBCiA0jFAqRSMSIxaBcLgB+Fkg0GidkalRrxct2rWg0yt13FxjJ2vh1LCYuilSmutKrBLon4Xju8PUcxz+2eizP7clT3J7o3qa1Eo16iHoDanWbsOmXpVyMSEe8aCpcYndsjhsic+yJzWFq/rSd3mk155sWr7/uv46zdWvgMXbSQinQKn7AJdKxmZpLxtCZ3eKgKZdWE+p1P81mUAPcQTLL04UCSsHBgzA2vpxtoilMM4nTcqlW85imxZYt9Z7+MjAzAx/9qD8Gunf/gQNr30c8nqZZcygW2+lDyaTf6DWXy61yphBCiHcKCZYIIYQQYkNJpVLE4+1gCUA8nsQwNaq1yzcZxW8oC/v2BY02LGxPo1Sq83//3/6e//gf/UyM9crloHa+RlSzierd20ioBoRxPQW0aNZhbPTC79uKw/Zr/H9PhUtMh8tdgQ2/EWt3v5WqY5CzTb/WxoOcbVJ1jL5jZq7zMzi0scHBlEXXJJtycb0GjSY0mi1c1xnSALffgX3t+wqcOQP1OjzxuD9G+CtfSvLVL7k8+WQZz3OJxSxuuz3fdc6DD4Kuw0MP0be/d/1BYlaKZtWhVMqvNNtNJjOUSlAolGhdzpQfIYQQVyQpwxFCCCHEhuIHS85w/nwRz/Mbe8ZifrCknC+v7Ov1la/AN7/Fuht+6rqOaYbZubPKd19wWViwUJrCtmsrf23yXH+N9arX4WQoSdqY9xuaKlYeTzWSgIGLBtRptfyxv5EINDrLe9Zo1pqILTeQVX7JjbaO+wspl92xeb9vSTMBKM4042yP5leOOW/HqZ70Fzt7xuQ6XesKvLgeTBktzr6ocdJ1mNxksPsGm3qjgRW1BjbA7RSLdWeVBILMnTYTxwtz+qRDrVbENONs3nyO8YkWc+dDzMz4AZZP/Lr/+9F1P6tH1/396xE14yhPp1VvUamUiMeThEJhTDNGuVwhl8sxPj6+9kJCCCE2LMksEUIIIcSGYlkWlhUiHHapVPxMEtO0CIVDoLk0GgO6egKHD8P8HMzPd2xzfsPPYaJRCysK996bZ3qTyZ6bNDyaeN7qDThWy14IJuR0Zm2UnRDzLQuI4KHh4eF5LWY2t7NEAobO0ACNFff7ptTrgAfnW9aq9xkIaS6m5pDU2+UsQXYJ+FklC02T3CLkFqFeV9he98dITYGpuSQ1A7vhsLTYpNmE5nIjl9WyS3Qd7rt/8Ps2qIRHkaRScPkPf1jkD//Q5Pnn07z//Qts2eLy8MP+73R+DhYW/EAJ+I/f//663g4/AGelaNYcSqV22U0ikZFSHCGEeJeQYIkQQgghNpzeUpwguyRk6kNLcR54YPBaqzX8tKwopgmjo0V+4Z/q3HJbmFhS4VEbfhJ+toiut3uOZLKQyQTPKo7X013H+z8HkYIIDoporM7YGIyP0xUcsW0GZpaYJuzYAZs3t/f5AQ+979iWo1bus/Nxriu4ojjRSFF2QpxopADFzGYIh/1nTzc7urvS2fskhqE8ZmbKNJsOzZaNY9sr/UesGIR7evCGw3C2J+vj0CF45BF4+qn+3i2KBE7DpVSskMs5nDkdZ3yswcd/dYkdOy7ud90rHkvTqvWX4pTLUCyWpRRHCCHe4aQMRwghhBAbjh8sWeDMmQLgRwfi8SSL5jzVcpGRzGTfOQcO+A0/T59u71ur4ac/BUXHMBwazTqmGWP3jVWe+VZl+EnL7rsPohY89RTccYc/ZjcoQwmyS+J6qyOrJGDiehWq1Sbf+Aak07BlC7w5ZPQu+ON2AV75fm8cRXGmmegqpwE40UwwHa5i6X6z166+JR3KTphXqn7jFCsOY2Nw8qT/XM6OUnfKmLrTtUbeiWNoZcZGbFy3Raup02g2eOUlg1df9UcaOz2JObWaX26zb197X3/5TcerUmGUF0HHwaHErbfGqNWgWqngjY5e1O+6t0zL8xI0HI2972ny8V8rE4slVkpxqtUKhUKB0dGLaCojhBBiQ5DMEiGEEEJsOIlEAstSuG6DRqMO4PctiejUm1WcAXNqlbq4hp/RqJ9d0qhXMSNxtm7XSCbbpT5af+IGmRG//8bUFHzkI/5jZxlKJqtQV2Up2mGOVLN019VEcDyF59XB86fTbN3aPeGm+4VBy/ZLb+p1PxjRqTe7pO7o5GyLM81413H+z8PfjNmt/nvVzlxRnGomBq+hxTn0nMfTzyhePRKl0WiuBD96AyWB3T3lNsMm6ARZJooEhnIZyZbYsyeEh06j4VGv1y/qd91bprWwoMgvpXj1ZbenmXCKchkKhcLwxYQQQmx4EiwRQgghxIaj6zrJZKJrhHAoFMaMRtFDitqQUpwg4wDWP0bWsixM0x+DG4lYaIZGJuuXYCgNjAF5ugf2938x7x2De9NdJsfC0xQcs+fsoG+Jjec5TE/75/b2LlmxPMFmOMWJRpqqo1NzdI430oDq60nSmVUSjBve07GpN+Y48mSJo6+3M1mGreHZMeymR6PeYm5O0WrZXH/D8D4vvSODwQ8uRaP9xwbXVsQxlMu+vRXAxYxEaTSgVvUDWRf6ux5UuqNIcdftfilOIAiWFIvFlfIcIYQQ7zwSLBFCCCHEhjRohPBafUuUgo99zP9i/vDD6xsjG41GCYfB82wcxyESiVIo+x+hPBeaje7jlQZPP+2PuX3kM37fjUOH/Oc6M006gyf7u77I60AIFwWqyfZt/t7x8VWyS9ZQdsJ8vzrOy9Vxyk44uNO+niSBlN7sGjcc0RxMzSGumtTrfibLamsopaGIouOwaVOBVhOmp+pDG7wOGhmslN+HpVez4QeolIqQSYe5erNDrVbCNKPU61BdDpZc6O+6M7gS2DyT5IbroFGvU6/7fWpM08LzQlSrLqXS5RtVLYQQ4soiPUuEEEIIsSGlUilisZOcPVvGcRx0XSceT2KYZ6kuDWl2gd8E9Xd+e/3XUUphmiamWafeqBKJxLn2ujwvDhhDqzQ/gNL7Hbq3H0cgCJ54Hhw7Brml4BkT16sxNV1HadHl+4CdN8BLL8KkUWI0VOsqmvGgY/Tv8vrh1Y/r7EnS6XzLImE0+8YbrzSA7UioGLSGf10X0PHearLwlsuCapC2W+RIdx07KKsksH8/PPZY//6bboYTJ+CmmxN4rRz1eol0eppWCxoNm5ZtEzKMC/pdB6U7n/pUe99DD2lY0TitWo1yOY9p+r+LWCxJubxIoVAgmUyu7wJCCCE2FMksEUIIIcSGFIlEiMUimKZHpeIHRywrgRHRsZ0WzVZjjRXWb6UUp1YlEomxddtyZklHGUYmC++7b/D5vf04einlBwbaInhKsXlzdwOSkYwfKEgZgzM/Okf/wvAMkd7jegXlNZ3jjQc1gB3Gv66HqSmiOkR1m6hmk9baU4QSyXZJ0rCsj9lt/nGdlAavvgL1Gjz1ZJyvftnlyacqKKUIhc2uUpwLNah0J2alVqbirNx7Ii19S4QQ4h1OMkuEEEIIseH8fz58lrPPLoAHHiHwTqLUKWLXj/LALyeomE2qtSLh0NhluZ5lWUQiS+RyDXQ9hBEOGqbWAb+s5cA+P0Mic6gzQ8QPouTyfjlOV28RBddd1844yefbmSkQwXY1nnmuRVj3CIWUPzIYvwQl7lkk9FUyP5YNyxCZty0Mg5U1OwXZKHpPI5Saa9DbAFbXIWJCtWc40LDrnmr4kY9ECt57r59ZM8ihQ/Dqq/771Tuh13OhXA5+MnE8nRcPORx5tYJS436ZUEvDNCEWTDdWcPdB+NCHBl8vEJTuPPIo/OzP+D/HrBTzS6eoVSu0Wk1CoTCWleD0aUWl0qBer2MOqhcSQgixoUmwRAghhBAbztmXilheR3bE8nf44tEisViKnJmjWiuRTl6eYIlhGESjESKRBrV6lXDYD0okMxXKheRKKUmQIRKMCAY/iHL48OAxuJ3lOadOBoES8AMwBq5nY9sNnI4msLYNdUwmdGPN0b9BhkjvcUstk3QajDAszHXfU5CN0iukBk8Yisf6gyWDrhuMSM5k4ad+sp1N0hkYCVSrg6fmaDr0DzqKo9wSxWIZaE/4qVb9LfDyy2sHS6C/TMswQphhi1a9SblcIJMZQ9d1otE4lUqJQqEgwRIhhHgHkjIcIYQQQmw4t/70OOBnLHQ+brt/fLlviUatVr6s00pisRiWBfVamUjE/1K+d2+lr5Ske0SwH0QZNga3szyn/5gojqdwqfU+Aah1jv4dftzMZth9Q/8p55ezU3rf26jmrEzG2R2bYypcwnagMLA9TP91j9cTgOLAPnjhBT/T5pHPwAuH/EBSqdTeho0X3nszfU1i4/E4unKB1Zut3n//qk+vyrJStGruwKk4UoojhBDvTBIsEUIIIcSG84u/k6aim109NUoqwgf+aZpIJEo4Egbdpd6orL7QBYjFLCIRaLWaGIY/liadafDgQw5nzsB/+c/w6U/D//V/QT7nn1Mu+oGBzgBKoLexaf8xURxPYzpc6xvjuzs2h6m1ho7+7dSI9I/3teIwNuaX/WzZ0n38oH4lACHN7e974vmlOIN0jhUuOx7zLUimbbZs9bNoggDJsMDISglNx/u1b39vbxe4844YmZSGooVfFgW63h0k03X47GfhE78OX/nK4OutJm6lsOsu1WoJ1/XTf4JgSankNxgWQgjxziJlOEIIIYTYcAxDcds/mubwf35jZd/I7SGU5qGUhmUlKJk1qtUSUTO+ykqr+8pX4JvfYrlExMB2ZnBs2L3bz/ZQuqLZrHLqZILGgH6yrZbfjPTVV6HV01M1m+lubNpfwmPhopM23IFlMUm9xYlGis2RIicbSfqzSnyzs4ri+RRuuX3c7FZ48wScPb380hQdZTB+Vsj2aL5rnWH9UeKx5XKXviQetXx/Sxyr2UCVajnOoUM2u3YbnD078Hb9MzWYnIJjR9v7gvHCQVApt+QHULZtU1RqFvPfrNGiDJjs3l3kxRdTK+c6Diws+P9ebzlOp3DYRNdCtOo21WqJeDxFJGKi6xGq1QbFYpFMJnNhiwohhLiiSWaJEEIIITakILsEoKxFOPj3yytTceLxFKGoRqV2aSUShw/D/BzMz/tbbsmgWDR447gfmNBCGo1meWiZDfgNWUtFqHcPtqE8IOmlM7skmXbZammYmn+t3rKYuZa1Mra37ISJ+MkuWDF/A1YySLbtCnNC848L9uUW/Xtq1OkLdHRmhVQdfehknBmzxERljj3WXF+JDvhjhX9QGaHqukAd21Z897sGzzwN0ejw98xz4fhxP2gC/uPTT/v9TZSCgwe7J+lcsy3GSNoDKoxPwC235EgmB3Sv5eLLcaxoErvuUS63646kFEcIId653rXBkldffZV/82/+Dffeey+jo6OEQiEmJyd56KGH+Nu//dtVzz116hQf+9jHmJ6exjRNrr32Wn7rt36Leu+noA61Wo3//X//37n22msxTZPp6Wl+/ud/ntOnT696rT/5kz/hlltuIR6PMzIywo/92I/x1FNPXdRrFkIIId5JDEPx4G9dRSVsce+vpkhnoFj061/i8RRGRKPZqtOyVx+Tu5oHHhi8/4Yb/C/HWkij0SizdavXV2YDfuCjt2wksGdAgKUzEHDn7Q6jIQgvB0s6gxWOR1fZTcSEnTewXCa0PEFG+dksf/stf2s1u/cVB/YaWbkTTjRSlJ0QJxrpoX1P4trao4mVCqPQUDhADdfxy2/qa0x2dp12w1vP9c85ddL/eWoKPvKR9jSdSCTGgX0uY2M1fvzvuZhmmA9+cJ5QqHvNYBzwxbCiCVp1ZyUgB+1gSXH1N1MIIcQGpLzL2flsA5mZmeH06dPE43Fuu+02RkZG+MEPfsDLL7+MUorf//3f59d+7df6zjt69Ci33347CwsL7Nq1i+uvv57nn3+eN954gzvvvJPHH3+cSPCnnWX1ep17772XZ555hqmpKe666y7efPNNnnvuOcbGxnjmmWeYnZ3tu9av/dqv8clPfpJoNMoDDzxAvV7n8ccfx/M8vvjFL/LhD3/4kt6DG264AYDvf//7l7SOEEII8XetUqlw+PCrHDumce21N6JpGm++eYSFk0ukopOkU+MXta7nwf/6v0Ln3zbicQelmhzPjbEl/SxRZYOzGc+1sHvG3G7fDve9D/7sz/rHCXdOhBl8bY/vfWuO6JkanuehOg4+27A41WyXmWgahMPLAYi35ZOdxw3WApZuU3UMvl8dBRQZo8b2aL6vROfNVpr5RnTlXhxvkYlwjcmQAXQ3OTnTjHOike7aF4tBZUDmzQMPwOy2wXc4v/QGetRjdOJqGo0mShVZWMjyJ3+SWDnmV34Fbrnl4t4Bx3U4fuIwyekI1+7YQygUxvM8jhx5kW3bXPbs2YllWWsvJIQQ73Ib5Xvouzaz5LrrruNP//RPmZ+f57HHHuPzn/88hw8f5o//+I/xPI/f+I3f4Ac/+EHfeQ8//DALCwt8/OMf5/Dhw3z+85/nyJEjPPjggzz55JP863/9r/vO+d3f/V2eeeYZbr/9dl577TU+//nP8+yzz/J7v/d7zM/P8/M///N95/zN3/wNn/zkJ8lms7z00kt8+ctf5mtf+xrf+ta30HWdj33sY+Tz+bfjrRFCCCE2nFgsRjwewTTbE0sSiTRGVKNcvfgSCaXgoYe698XjimLRL1EpleIUyhr1erkvUAL+F/6gF0mnoP/GoUPtqTAr2yNBuYli294YVY+uQInrwalmoms9110u83nb/gTWmWmSIuiPMqgZbNUxyDlmdz8WwowYiqjuEdXtrm0kVCOT7b7aHXf2N8QNSnGC96dXJBTDsV3qjTKRiEmzCddeW2DTJv/5S8kqAdA1nUg4it1oZ5copYjFElQqUCqtPo1HCCHExvKuDZb8zd/8Df/wH/5DTLO7c/wv/MIv8MADD+A4Dl/4whe6nnvuued48sknGR8f59/+23+7st8wDP7oj/6IUCjEv//3/x7bbtfINptN/uAP/gCA//Af/gPxeDuN9ROf+AR79uzhm9/8Jod6/qv/+7//+wD8i3/xL7jmmmtW9t9+++384i/+Ivl8nv/0n/7TJb4LQgghxDvHyMgIqRQUi34KRyKRJmTq1BsVHPfip5UcOEDXF+6HPtKZDpLA9jSGja0NRgMPGicM3VNhVraiP0730CGwYhbuZPfHNb8E5tI+wmlau6/JegX9UVpGuGPv4NHEdkutlND4R5mca/q/g97eK6caScKh7vdndrY/wBSU4pSK7XKcTpFIDK/l0ahXePoZk//yJzP82387Sbns940pl+G///cLe829BvUtiUbj1GpQLpcvas1/9a/817t1a3ubnfX3CyGE+Lvzrg2WrObGG28E4MyZM137//Iv/xKAD3zgA32lNhMTE9x1113kcjm+/e1vr+x/8sknKRQKbNu2jZtvvrnvWj/xEz8BwFe/+tWVfbVajSeeeKLr+bXOEUIIId7tRkZGSCSgUili2zbhcISoZaGHFdVLzC752Mf8AMfDD8NttyomJ4M/jMRw0YmnbFLp7t5lSoOnnvIzIV54ob8p6eGv59laPcXtie7t6kgex/EDApqmsfWmONXlyELd0ymELn66T2DTjP+F/GKkUt0/dzeDHTzCWKkQOdsfIdyZhVJ2Qsy3LG7c0//+zM72jw8O7B7Q7yUUsvAcD9tucvSoQ6lokM8bFApg25DP+9ONPvGJ5e0ixghblt+3pFotEVSyB5klFxss+eu/9pvZvvlmezt+HL7+9TVOFEII8baS0cEDvPGGP4ZwcnKya/9LL70EwN69eweet3fvXp544gm+973vcc8996z7HIDvfe97K/uOHDlCo9FgbGyMmZmZdZ0jhBBCvNuZpkkyaRGPVymVcmQyY3z1qyke/6sSUVUgbCynLii4++D6x8d2jg/+9Kf9fbVa0HdDA+Ls2tMiopf59jfbgQLP9bMZoD0+GA+eeNzfd41XI23YvS08GAnVONFIk8v5ZTkwQsQuM2vY6JsizJqKlw/33+dUuMRoqNY1QNgDFlpRzvaU7Zx8CwYkZ6xrrVozgWH4AQifWtcIYzA5UW9yQ6z9go/X04DiG/8TzIh/6pkzfuNWpeC+++Evv+qP/l252nI5ztNP+8cnk8vNaj2Nlhul7jVpOBUg3XcHrZY/1ShwoWOEzUgMXI1mo0m9XiUajWGaFratUa/b1Ov1vqzltfzKr8Cg2QK/8isXtIwQQojLTIIlPY4dO8Zf/MVfAPDBD36w67m33noLYGAAo3P/iRMn3tZzYrEY6XSaXC5HqVQikUgMPC4QNNDpdezYMbZtG9IlTQghhNiAstksyWSVpaVFMpkxXnopzdmFM6T0IjrtJqlf+Qp885sdJ64SQAnGB3fyvHZAYCRrcfW2Al6tRCw2OrAxqWFALte972QoSdqY72uOeqqRBPweJMGgvRJJnOQ5smWXwskBY3eAlO5PpumV1Juc7dyhWLO3yWprZTfDwgKc61g0KNExQsCQiidFhCW7TtkxiOveSlYJ+BN6WssDdF59Bfbt8/89PQXvvQ8e68iyCMpxAvV6+1zXi9HwGjS8MpqWxu0oBRrk9Bk/w2S9wTOlFNFoHLtepVIpEo3GlvfFqFZLlEqlCw6WfOQjcMMN0NnncNeu/l45QgghfrikDKeDbds8/PDDNBoN/v7f//vsC/5LvSxIrxzW6Ty2nCva2eDr7Thn2HlCCCHEu10mkyEeh0ajQrPZ4Gd+JoZHBNvz8Gj3mQgyDFa2OT/LYJBh44MBpqYb3PWeOnpIw3Gb3HNvE70nUySTHTw+eL5lUXZCA8tSAldH8svlOSV2EmG8qHGNfp6pcP9//88vn9fbE2SuZWF0/nlsHU1gh62Vw2JsDOq1wecNanIbUETQlceRKhTtMEeqWQZloRg9f8rr7PcyyHU7O68RQ1cuUCUWW/uFlor+776rPGeNEh0rmsCuu119SywrTrV6caU4mga/9Vvd+37rt/z9Qggh/u5s2MySBx98kFdeeeWCzvnTP/1TblllXtzHP/5xvv3tbzM7O8sf/uEfXuotXjGGjWQalnEihBBCbFShUIh0OkkiUaRYXOK9753iqqvSnD9ZI6QKQIqRLCwt9p97//2D1wwavHaOD56ZgcUT8M/+3+eZn9dptTT0sEY8VuK992W7MiEO7PP7nWQOdY8PBsXxeprdsXZdyPF6mkxWgetnomRDNaK6vXK8v7n92SK0e4dYy8cHk2mmd5i8+RbYF/D3lWFrjc36U25mNvs9QC5MBA0oejbPlzcx7GNovR6UHy1TMLPJD6LU636AIxCNwvFjfmmO31A2go5GNGrzvvfV+dKXouu6s97yHBheomNFkywsnaZWK+M4DrquY1kJ5ubOXnTfks7sEskqEUKIK8OGDZYcP36cI0eOXNA51Wp16HP/6l/9K/7oj/6IiYkJ/vqv/5qRkf4/YQSTbIatU1nOu+0si3k7zhl2nhBCCCH8Upx0usiZMwtks5P843+c4bd/6zweBTzP46c/qvjyl/uDH8PGygbjgz/1qfa+D30IXvr3EIvHKVdqNPIKPayo10vMzmbJjPiBkWDyTTA++LGepp1Bdklcb1FxQ5C2OHgnVKv+sScbvaU6finR+eag7FN/Ms32aL69vhvnhgmF0hjY52S4AWt5/loAY2NgxaF6AbEBvwQqTNKqUyjVgf5GtZoOtQFZK69VwLL8oEYn0+wub1JKgRdF9+o8/ngVpUW5NrLAlkh/g983GymO1EYvOHgWDkUw9BB2w6FWKxOPp4hGYzQailqtSbPZJBwODz55CE2DP/oj+PVfh9/7PckqEUKIK8GG/b/iF198Ec/zLmgLmq72+uM//mP+xb/4F6RSKb72ta+xffv2gcddddVVAJw6dWrg88H+q6+++m09p1KpkM/nyWQyEiwRQggheqTTaRIJHaWaVCpF3v/+OFObwjiew/SmMrfe2v+X+wcfZKUcZpDe8cFBWU0insCKAmigg203cNxm32QXGFZOojhSzVK0w5wxsnzkJxRTU+1j51sWla5SHUXVdVmy241BDIOVapbeyTRLjsnTT8HR1xlU8bKq3rWmrzN58wQ89SQ8/RQ0Gxe2HgCeSbWsA/WOEqP2dqvlTwPq5Th+n5J6x8Ahwxhc3qSIYpkexWINz4WJUIWY3urbxkP+H55+5qfbv9vAasEz6B8hrGkapmlRq118ifRdd8Fzz/mPQggh/u5t2GDJ5fK5z32OX/qlX8KyLP7yL/+Sm266aeixwUjhF154YeDzwf49e/Zc0jk7duwgEokwPz/P6c4/e61yjhBCCCF8mqbx6KNb+NVf3cVP/ZTFgw8qKpU0rqaz+ao8SvUHP1b7Ygz944OD4EUoFMKKmcRjBq4LelijVi8yNQVbtsATT/glJY98Bh59xP+yb4S61y44Js+Xp9m53+y63sGDsD1RINTTaNVAMWP6X8itOMTidPQh8SfTlJ0QJxop7JZqN4pdR6+Snle9stYpO8WrryjePN5uPLtaf5LhK0bQFEBjpcSodxsJdaeWDBsffNPNMLutPwCVTFrsvsEF/HWO1TNAf/+VY/UMMzNwyy0XHjyzov4I4UqlXRMUjV583xIhhBBXnnd1sOR//I//wc/93M9hGAZf+tKXuPPOO1c9/u/9vb8HwFe/+lUaje4/p5w/f56//du/JZPJdK1z5513kkqlOHbsGC+++GLfml/84hcB+MAHPrCyLxqN8t73vheAL3zhC+s6RwghhBBtTz2V5Ny5CHNzIc6cgXw+Tc3WOXvOL8cYFvxYzY4d8Du/7T92SiYSxGLgehpaWFGv+9c4ddLvr1EqtbdaFUZH/XKTTkG5TqepKUhRI6y6R7qENUVCd4nG6lx7rcfmzd3nBZNpqt6FlYKAPzJ4d2yOPcvbrJnHUC4WDer1oC9Iv96mtsDATBZFGA0PaC2PGe4PYgTTgAJ33NkfEMlk/Yk5QXlTp9tvM9m8SZFJ20CT080EBTvc1Ui3QoTIdGLld3+hwbNoNIHT8qjXarSWR/FcSpNXIYQQV553bbDkySef5Cd+4ifwPI/Pf/7zPLBaq/tlt9xyC3feeSdzc3P883/+z1f227bNP/tn/4xWq8XHP/5xQqH2n4zC4TC//Mu/DMAv/dIvrfQaAfj93/99vve973H33Xf3Td75xCc+AcDv/u7v8vrrr6/sf/rpp/n0pz9NOp3mH//jf3xxL14IIYR4h/vVXw0+4gTpFElcQtx6m02t7n+ZHRb8WI///lX/8X/5X+A3fzPGH/zBDF/4wnae/66H69k0WzV27R587p7dsHdv974D+wYHbE43BwcUzjRddlx3lli0ztjY4B4Xg8bmmqa/DROMDI50bKbmkNSbK8dEIj0nqe7gj2FAIjHgOAD05RiKx3wr3DcNqOFqbDeX2qU5yVNUnj3FVjPftUrn+9VZ3qQ0eOYZxdf+KkKz7gBVQPFqbbTr/M3vyfI7/1Kt/O4vNHimazpm2MJutLNLotE49TpUq3Vs2159ASGEEFc85XneBSdlvhNkMhny+Txbt27l4MGDA495z3vewz/5J/+ka9/rr7/O7bffzuLiIrt37+b666/nO9/5Dm+88QZ33HEHTzzxBJGeTwf1ep177rmHZ599lqmpKe666y5OnDjBs88+y9jYGM888wyzsz1/TgJ+7dd+jU9+8pNYlsX9999Ps9nksccew/M8vvjFL/LhD3/4kt6DYBrOsGk5QgghxEblunDDDTavvtruZX/VVcf5//7GeSwtw1h25pLW/51/2eLpH2TI6jmUav+RZHziTT7w/hIREiTik/zZn3VPwMlk4ad+0v938Fywr/ML+qFD8OqrUKt57DXPENfbNS9lR2dhtM7miRLnzmxladGi1fL7egwzFS4xGqr583SUH3TxgIVWlLPNdv+zjFFjezTf0VDWfzxaS5OzowR/D+pttNpFgRmBZBLm5vqfdrzT1FwPj02MhZyuaUAVxyCm9wcaKlqE15haeb+2b/PfnyAWZjv+OOPgU63jzdPw8jS9UWCKqNXibuskltekqiL89P+5BU2/wCYuPRaXzlJxFpi8eoJNm7YC8MYbP2BiosaePdtIp9OXtL4QQrxTbZTvoe/azJL88ry748eP81//638duH3729/uO++aa67hu9/9Lg8//DDz8/N86UtfQtM0fvM3f5PHH3+8L1ACYJom3/jGN/jN3/xNLMviy1/+MidOnODhhx/mhRdeGBgoAfh3/+7f8V/+y39h586dPPbYYzz99NO8733v41vf+tYlB0qEEEKIdzJNg9/+7e7akI99LEPE0ihX8pe8/v3vG7z/xj3geC3qjRLg9ZWIBBkRQU+S3iawgaCEx27544U7vVkfwYyZvPiSxZnTDvX66oES6M4YCavBGSPQburame1RdQxytp+OEgqvESgB8PyeJsXisOyS0EopznzLour5EZiyE+KN5dfam0mTmE12vV+9JU61avtY8Ju86soj6FsSj3tsuT9FRTfZ+cGJSw6UAJhmbGUiTsCy4tRqUoojhBDvBO/azBKxcSJ6QgghxMVwXdi5s8Vrr4W46qoGf/ZnIY4d+x65UxWmx7cTNftH165Xq9Xigz/XnVkyNeXwD//hW5w6dQaTOMnYNJFwYtUMkmGOHescM+xxS8LPLik7IWpbpzl/vsDi+QUimoGuptZcb62MkUHHBoJjrDiMUiLl1brakQzKUAFA+SOG53uySxxviaZXwfZGUGqE3bN1rKUl3miOMFeJrLzWQI0Qu//+NJrfGZbDX8/jLZT7+qecacY5p9I06uB5Ng7HKLth4Fp+/McXufdej/HxiTXfq/VyXIfjJw6T2hTh2h03Yhgh8vlFyuU32bkzwbXXXnvZriWEEO8kG+V76Ls2s0QIIYQQ72yaBn/4hx7XX1/h537uTTzPJpFIE47pFEtLay+wikEBj4cegnhCYYQiuMqh3iiumUEyTPeY4fZ44dfqWW6/TbF7dxwHA48GntdcbSlgcMZIzW1njHQaC1W6Mju2mXn2xc8y4yxiOYN7mkyHyytNYffE5tgdm2MqVKLV7O+RojBQy5klngfzVZObPjrN7febjI0rtE3pruNj29MrgRIAJ1fDVP1TdLLhGne9J3h9BooQGi7ZbJktW6q0Wpe3j4iu6YTDJnbTpVr1M0lMM7rct6R6Wa8lhBDih0+CJUIIIYR4x7rvvjBf+tJpbr21TD6/QCqVJWzplCt5LkdybecElVtv1UnE4xw9uokvfjnMn3+pzGf+H4cnHvfLUs6cWf+6vVNeCo7JC7Vpdt1qoumwfbtBMh2j5em45NezImea3Zk02nh8YPQmpttdQRWlQFMQ01ucb1lAf5mMphjYFHZmM+y8ARJJSGeCK4SWxwf72SPBaOAzZ/z36funLcpOuzSnoKyu+4vPDm56q00m2ba9c9Swha48br2tguvxtjRdNSMxnIa3EiyJRKLYtqLZdGg21w5iCSGEuHJJsEQIIYQQ72hjY2Ok05DPL2BZcUzLRAt5VKqFS177H/2j7gkqqVSKU6cylCsxShVFsVTy+2oU/T4bF+IHP+j+2fPgyafgiUfzHP7sKW5w6xyI69wUt9kdO89UuLTqekF2CUDdMxjZYrJlS/9x883oyvU6H+eb0YEZKg1XG3h8DouxMcikYXQMltvFoTCWe5b4wYvy8qDAdh+SdibNkWqWU6faAZ1Dh+DZI1bfFJ2yE+LmeyyUgvvu90cZK0yyaZetW5q4Driuh7NWc5cLFO3pW6KUIhw2aTQku0QIITY6Y+1DhBBCCCE2rnQ6TSJhYBgtyuUCyeQIZatKsbxEPJa+pLWvvdYfPxwIhULcc3eFP/3TJC23gqEVAP8au3e3p9zQmdSi4LrrYN++7rV7J8l4LlwdyTNFHl3557HSPcQlqTc5u+rdKpojKVShSGhzkhNvKc6dXV6i435ONRNMhKtoHcEI1/P3BxkqnT1NTjaSTIfLWMtTbDqbwr55ArZugdxi5zWCMhw/YFLIGzzyme7GsQXH5PnyNADNPDzyiP8enTrpB1OOh9JdU3TOkmav4d/w9BT8+AfgySej7LzBw3UbaLqF7Tg4jo2udzf+vRSmGcde8Gg0ariui6ZpmKZFvV6jVqvJRBwhhNjAJLNECCGEEO9oSilGR0dJpyGXmyeZHCFk6VRrRRzn8pdmvOeuKGNjJjY6HnU8r0Em62eg9E5xWS3rZGSkf182VGPYIJfzzfDqN6Zg5tow47eM0sg1SJyb41p9jj1WR5+RcAnQON/sLn3xf/Y/NnZmqARBkd4SnzPNOK2WIrcIx9+ESqXjNpQCdBQeSrOp1fz3oV4ffNu1mv8evfQSnDvn75tvdZfq7Lit+36npuAjHwkzOqpwXRdwsG0ue9+SkBFG14zl7BL/RUYiURoNqNVql/VaQgghfrgkWCKEEEKId7zR0VGSSahWi2iaRtSyMCKKUiV32a8VNSP8yI+0gARNT8OlsDIyeNfuwecEWSePPAKPfMbfejNLwM/igO4xuQB1x2PRXr3sQ9fh6af84IVWaXb1GOkdJXyqmcBdvkY7q4SVbJYTjRRlJ8SJRgpQAwMo4AdJzp4eNG7Yzy7ZuXP9ZTGu0/m6u0t1tm3rjyAppTCMMJ7t4rkurvP29S2xm+5KKU4kIk1ehRDinUCCJUIIIYR4x4tEImQySdJpWFqaI5XKErJ0yuXLHywBOHh3lNFRi5ank0gV2LLFn3PbPeXGNyzrpHc0LvgZFVUv1NeX9fW6WsliGcax/eyN42/AuebgRq1zrSBDQ+OtRhLHU7zVSBJ8ZDSWK1jKTphXqqOUnSCbpT+AAn6QRBtY9aKhlMeJNz3UOj6NZrKw8/rufUGpTmqzOXTKkGGYuI6H57nY9tsTLPH7lnROxLFoNKBebyxntQghhNiIJFgihBBCiHeFyclJRkagUFggFksSjurUm1WareEBhosVNSP81E95jGRh5/UlGq0Shw7Bo49CrSfhIJtZPeukU2ZEEd+e7tpXc3TmWzFay1ksa/JgodHfqLUzIwRgvhXjhfIk862V8TKsFmvoD6D4tm4FK957tAIPKhVvYFCo14F9cPttgwMvP3L/8PNCRgTP9nA9G+ftyiwx49gNd6UMxzAMdD1EsymlOEIIsZFJsEQIIYQQ7wqJRIJ02iIWcymX88QTKUJR7W3LLtm3L8HDDzdIjVYpleZXMkd6e3O8cdwvu3nmafqyLNpjcH0H9sPsfosafr8Ox1P8oDoKZLA9A4/aqtklbf2jhP2fh6Ro9Aiv0R4loGlQrUJvPErX241pu+5qwCfTIPPmuy/6pUSdDANefGn49Q0jguu4eO7bFyyJhKN4jsJu2dTrfnBESnGEEGLjk2CJEEIIId41JiYmGB31S3Hi8TThmE6pvPS2XCscDjMxOUk8pSiVF9l5/eAOpq4zvPTmjjvbZTtB0EDTFCM3ZSk6YV4sT1BwovgDDuO0PA2lD88uMTrmIA7rMwJg+LEYTBOsnoCNFYerYiV2x/zGsMHWbhDbtmkGckv9PUscR1su6eluvmL0zGlMpODgXX7my6mT0Gp2P2/bq49kNowInguu69Bq2W9LWYxSCtO0sOvtEcJBKY5klgghxMYlo4OFEEII8a6RyWRIJk8TiTRxXYdwNER1sUq9UcWMWGsvcIFGs6OMjMR4K1ciO7pAZmSG3BqxmVjMb4yayfo9TiwLnnoK7riDlbKZzTtNmqFpCo91npnG9spMb6px6q0amooCEA67NJsaVsxjyxbFD74fHO/3GbkqUiRyVRLrlKJa9oMh114Lx45CPAYLC93312pAyGtiav3NWcdCVUZDtZX8FLUEGQ+i4Shngyaxy9e+agu8fqxn7Y5giFJw3Q5/sg34ZUpnB8xGPncOPv1pCIUgEukew6wpHV0zwHN57rkon/vcRHdARsHdB+FDH+pf90JEI3EqzTrVaplMZoxIJEqhIJklQgixkUlmiRBCCCHeNZRSTExMkM1CPr9APJ4i9DZml4RCISYmpomlFLnCWfbtW73sRGmw+SoYG29nVPhjcNtBg8DsNkh0xh8wSKXj7NilYcWX8DyPRAr27KkTTzhcdVWFsTGHSKR9RtkJo20bJbMpzI4dkEjCjh0wkoEDB/yxvb1ZIa0W5LzBDWJdT8PsmLATVv5jyuhOCVFK8eZxj94ynE6eBy8cWp4O9Ajk8/3NcYPjPBeajcFjmEMhExw4eUqRyxnMz9Pe5uDll4fewrqZZqxrfLBklgghxMYnwRIhhBBCvKuMjo6SThvoegNN04lYOqVyDq93Hu9lMjk5TTIVxqXO6NjCyhd+w+gvu/FcKOQHB0ege7zwo4/0BzJuOTBCxIpw3fUOyXSBvTfD5qtMbr+9wthoi1q1xM6dzkqQJhSCo6/DU0/CK9/3Mzte+b4/XhhgZvPg17TQGtwg9nTTr9npDaIUdbPrfM9TyxU4q5fFOEGJ0nIQZP/+VQ8H/DHMnQw9Ah5ce83iwOPvX6VB7HqZZgy3Bc1GHdtuEQ5HcByNZtOl0bj8DYSFEEK8/aQMRwghhBDvKpqmMTY2xuLiWRYXK4SjYSp6mWqtSMxKXfbrGYbBxOQ0xdybLC2d4q6D4zz9FFx9NTz/nf7je7/sdwqaxA6SycLsNo1WcwRn+jyZZIFUMoamhYjH40CZt06GOHsGDN2j5Sladn/ABeD4MX8LTIVLXeU1AKqn38iZZny5D0oFS/cbqSoFdc+gqLo7wqp1NpLttHu337MlM8LQUqagr0snw4jgNTzyeRdN83Dd9rWVBv/pP8HnPtd1cxdcmqNrOqFQBLvpjxBOJjOEQmFarTqNRoNIZzqPEEKIDUGCJUIIIYR41xkfH+fcufPMz9cIhSzCUYNSOfe2BEsANk1fxdkzb1HJV4jHFvnIR7J4Hhw71v3Fv/fL/qFD8OqrrPRBHRTYgO5GqOFIjNePWrx5rEyYRQxtEtBAJXEdv3/JhUrpg3uUOJ5CV95Kg1grrtDH4rCQXznGzZpMRxq8Vgp1nBkELNaXzRO8Ly+84E8TUlp/Vg74I4ZVTxzG0MN4jse5c3pXoAT8NapVf+v08ssX3sfEjMRoNYs0GjUgQzgcodms02w21zxXCCHElUeCJUIIIYR41zEMg9HRLIuL8ywsNAnHdUpnCziug67pay9wgf7qr8L8zd9ci3IWCLlVIqEsKJgY7w6W1Kt+eU2gWvVLUVaTycJP/WQ7SHDoEHz/+6O4Th1Ta6BTRlP+mOBEQusbXbweC45Fwmjief51gsezzRhpo8HJRhKUIpWAkS0mi/MGprKpewY5W2fpfMSPj6zERoJIx+AMk0gEOqtXgiDIqZNQG9IzdVBWCYCuh/HwuOaaMgsLNuv5+HsxpTmRsEm9nqde92/QzyxBynCEEGKDkp4lQgghhHhXmpiYIJ0GsNF0DcNUlEqD+1pcqsOHIZ8fI1eKUK1VKRZblIpQrtDVw6RWa48RLpXWDpRAfzbFqZPgOgaQpunqeCzhLadhXH+D38T1QlgxmLnepOb29yg524zzSnWUshMGz79/TVMYm1PUCOFOhCiVw9TrelcSiYeHh2LYR1FNbze/7QyC7BpSotSZWdNLKYWmGWzeZJPNlruem5mB6U307TtwYI03ZYBIxMJpucuZJRAKRWi1kMwSIYTYoCRYIoQQQoh3pUgkQjabIZMB8AjHdArFhbVOuygPPAAQAWI0PQ0XP51kz244eNCffnPTzYPPjcWGr6s0ePppv+nroUO9x6dxidDywCUH+EGb1AVWGs3OwkhWoU3Eu/aHlMue2Dw3x8+xL36W/fGzbG2dY+GZOey38iw2Irx6IkWpMCiTw48CGaHBH0Vr1XaZTb0Gjz7qv77Z2f6JOJks/MxPD26IGzD0CAq45dbu3++DD8JHHqJv36Cgy1rC4ajf5LXZwLZtySwRQogNToIlQgghhHjXmpycXA6WuGhhsL0mtXp5rdMu2IEDsGkTQJaWpwMFkqkmW2fbo4H37RscCJhcJQjgud3TYsDPVmkbpeUZeJTxvAbVih98WG92iRWDsTH/3yNXm9Q9P/DheBDSXCKag6E8NOUHGAzNI6I5mJpDUm/i2MOiDi6eB46zdslTrdp+fUr1T8QZ1Kekl6GH8FzYuqXI1LQfhQkySNq/m4vPKgG/yathhHCbHo1GbblniWSWCCHERiU9S4QQQgjxrmVZFplMgkymxNxck0jMoFBcIGrG1z75AigFDz0En/pUDI8oLcps236SVnOacCS6csz+/fDY19vnHdgH3zu8vmsEU3R274ZzZ4O9JpCg6eaJaPNo3jTbt2ucO9+eqjNo0o0HLDlRxq9LrAQiVsprThVpRCKkm+WV3iWdgn1zLWuVu3XwUHiujmGAbfulN+4qZUfB65vtmIjTWaLT2wwXAAXXXQfX7QyBC57X4qc/WudLX7b42Z9p3/vHPgaPPErXvosRDkex7Sr1epVUKottQ6vVwnVdNE3+RimEEBuJBEuEEEII8a42NTXF0lKJ8+ddNBPK83kcx0bX2x+TvvIV+Oa3WPki7i0//vevwkMPru86QQbD6dMjJDNlNs3MUSrFGAmbqOVv6IMCAR6dwY/BgnKcXB727vUzQqorGSYZHGrYXp2QtkixNEa51D53zKgRGTDpZlKVab1aY4F28KQSTVBvjeK1PMJafWVEcNe9LPczydnmKnfcwkMHDG7eC2++OXyUMnQHRZTyS5eeegruuKMd3Bg2VvnUSbhhVxhcD8dpsX27w+/8dvcxO3bQt6/3d+5ffPWxwmbYotys0GjUMAwD0LBtl2aziWmu9n4IIYS40kiwRAghhBDvaolEgs9//mo++9kErdbrWFqJqLaIYUysfDE+fBjm59rnBMGS739//cESpZYzGB5Jcd99EWh4OI0CtWoMK5ZYOaY3EDA7C9vjecZUf3nQmWacE430SjnOC8t9S+68Ax57LDhKB8ZoeufQvCpnzpbYcW2CheX2HQMm8AKgKYiodhAl7jY5nVt5NZwx4myP5geee6YZZ9ikG89zVxq8ZkYM9u71S5A6RynHYlDpKCfqLbUJSpc67doNZwcElXbvBn25DMe2W8Nuq0/v7zyw2ljhcNjEqbkrE3H8UpyaBEuEEGIDknxAIYQQQrzrPfdchvPnIywtTXJuQWd+cYH5Of+LMQQNWvu9774Lu86OHfA7vwM33phlZDwFqkCtVsJutftaBIGAqSm/tOTRRyFJjahu920joVrX+o7jZ1LMboNI13dzE8jQcA2KxSVeeqlJJOI/c7qZGHivXk8WTW9ZTc42qTr+391qrk51uf9Ib1ZJIgmJ4BIKwF5O1tA5sF/rmrBz8KCfFdPoafPx2GPwn/9zu4ntIMOav26dXR4f7Hq4roO7nhFDDP+drzZWOBKxcJoezWYdz/OkyasQQmxgEiwRQgghxLver/1a0Gg0g00Yx2vhesWVL8adTUA79TYbXa9kMkMiHSdsKvRQlVK50F3usSwoLTnZ8Duy9gYwTjX6O7Xu3u0HHn6k78t+Co8Y5YZGpTpHKOwHDXK2ScPt/kjodvQiGV5WozjRSFFxQqSuSxPenKbihDjRSBGkb1hxvywoO+qXChkGeDTwUCjNIJfvXnFqClJJsFvd+z0Pmo12E9tBVmv+qikNTTPwHGi11tdwddDvfK0GsCEjjELDbjk0GnUZHyyEEBuYlOEIIYQQ4l3vIx+BnTtdXnlFB7I0vQYzUwscOOAHI9oNWrvPG9YMdK1+F5qmkUikGZmss3S2iMKiWithWd1ZHkFpyXzLouyEiOutleuWnRDzPdkenb09pjfB/gO9fUBGcWjR8moUivPoagJQnGwku0pqGjGLaLW68vOZZhzTVNTr3a+z7IRJ7hllcsb/2ds1yrG/IJgMTLUC3/xm+32wXZgKVxkLGYANr57i8BH/aTUaZ/cD6aHlNNBu8jpMb8+XXN7PSGm1wPay1FybP30kStSEH/ux4eU0MPh3vp6xwpFIFKfZoF6vEgqFaTYls0QIITYiySwRQgghxLuepsFv/3bwsWiUhqdz8J4ijtNOcegdMbuaoN/F/HzH1lHWA5BKZTFjEcIRnUi0Tq1awrG7G6a2S0sUx+vprudCyuH25GluT5xa2bZG8l1f5vvHEevAOC0vhEMTx/ObkORsk7rrZ9fUXZ2jhcRKiU3VMbAtkxtv7H+diZQflAko1VP+49GXMZM2bKK6Iqq7RDWbiLIxlU3tfI1HPgPPPO1nofTKjLQDQcMEpTxj43DwLj8TpdnwRyzjGv5EHNehWu3+XQxzMWOFI+EobgsZHyyEEBucBEuEEEIIIfCzS66/3gWiTE6G2Lm7SbG0uPJ80KB16yz83M+tvtZ6+l0YhkE8kSI5EsP1KkRjUCrluoILL7wA9eW2JEF2CYDjKSKaH2zo7GESqnf3MAmCB9Fo594wME7DNXAp4XpFgmBM2QlxvJ6mXtdWSmzm9RR79yo2zfj9R8DvK5LOwN6b/XG9f/VX8Ff/w996bqGL5zU523SW/03X48lGklLJb1TrDeg6e2D/4KyOQ4fgkUfgkc/42xOPQ70OZ874mTkd7/jy+X5AarXeI4HO3/nDD69vrHAkHMVp+U1eDSO0Mj5YCCHExiJlOEIIIYQQ+Nklf/zHGr/8yw1+4ifq1O0chZJFJj2xMto3GDFr90/M7dIeE9ze15mZEJTpeO4otl3A9EIYKsnWrS437y1jReOAnxlRWwk+KI5Us1wTXWLBjjJrFvCWe4sEj4nZ/h4mZ874vUICV0fyTIfL+FkmoFQZqLLQivFKdXTluLIT5pgzig585zuwZYvff+Sll+DGG2F0+dDvv9w5pnh1HjXmWrDJUcR1b/n67ZKi9r11m3PjbJ1ND1xztZHBe/dCJgO5HICBwgPsdWeJwOCxwqsJh6PYOZdGo4am6bguOOtsKiuEEOLKIcESIYQQQohld90Fzz0HL72k841vNKi3ylRrRWJW6oLWWavfxeHDMFJaYEukAGgoFUGxAMcNvn00xrwO1+3sH4dbcEyeL0+zf59H7ViVqGr3MKkRYvc+v4fJoUN+xgceVKv+lJxANuRP1lm+0+VHj6RR5WzPZJzOVhuvvgKvv+Ynvnznufb+C4kDeFRwPMXxeozdsXZQxC8xUj331nHPeg2l0gPXXG1ksFJ+35bHvg4KffnV2uvqPXKxIuGo30i22cJ1XRzHD5Z4nrcSdBNCCHHlk2CJEEIIIUSHSCTC5OQ4V101xxtHchSKCxccLIHu7JKZGT/D4xO/DnhQb8DNoQoxPSjPCL5E26S8Om+UOjIjlhuWBjJZ2HdAcUylcY/Or+yPbU+jaf46w7ItwC93SRvzfVkpc60GjpdH7whKTIVLjIZqdH7F94CFVrQrsKLrawdNXK+GSwuXMPOtDGWnQVxvdTWqHXZvye3tjJnOQFBAad2lO52Nbmdn/eySxSUdTXmMj9vrziq5GEopQqEIru1i2008z38djuNgGPLRWwghNgrpWSKEEEII0WNqaootW0ZQoTpL+fO07Atv0Nnb7+Lll9tNX0tFOFbPAJ29O/x/BOOAt19bXXUc7uw+ixp+D5MaIWb3tSfj7FplakzQ+6RzNHDZ0ThZ13EprDR9BUjpTUzNIdKxmZpDUu9+P4LAxFS4xO7YHHs6tt2xOabCJTxK2J4GxAGdI9UsRTsMV2UJgkWD7i14bUFvkkOH/Pcv6G8yqMdJ8B4Fa9x1l0MiAamkzYc/ZL9tWSWBcMjEaXk0mw2U0layS4QQQmwcEt4WQgghhOgRCoXYvHmGTTNnOPGan10yOjJ9wet09rt44AE4cqT93OlmgoIdJmX4gQelFCXHZa4JI9kW42N5mk2N2VmzaxxuEJjQNIUbjeBWW2i4fP9zfoOUYAxvZiTdlZHS5jdz3R1rZ6WctLN4ONTdRUytCJ6HrkY437JIGM0BWSjtwEwiBbt3wfnzkGr5wZVeSb2GRw3bCwF+lk7BMflea5rwic7MkP57CzJmVsuWAYjFoFLpfo/aWSg6rmfguvCFLzgsLXWPDV5r1POFCoUi1OwyrVYDXddxHFeCJUIIscFIZokQQgghxACTk5Ns3TqKbjY5d/4ErjtgRMsF6BxD61McqY92HXOk6uGyxHvubJJKQamU59Ahl0YDNN2fNPPoI+0MC9VooSmIKIeIao/htXO1voyUTp2TdcpOiLM1C8NIAqPU3RAOJRzvHEstg6pjdGVpVB2DnN2eD9ysw1//NTSbcH45iNI76eZcq0nD1YAkLGfDGIY/1rdc7s4M6by3zoyZ1bJlMlm47/72yODgfoMAS6kE1XKEakUnl/M4fLh7nvF6Rj1fiHAogmv7mSW67gdp7LW6AgshhLiiSLBECCGEEGIAwzC45pprmJ4JUaouUCguXNJ6QdPXTrf8WIKiEwag6IR5q6mTHqmyazfELINI2OXECYdqBVwHatXl0pOiHwiIL0+/6Q1OVGNJnnnaz9gYcjcrZTBHqn4ZTHYUIAGM0XDDtLwmDmc53ehORHazcRLJdh1Lo+E3kW3UIWebA4IrMNdycYkAfumRrsNNN69+b2UvTCWb5bOfVTzyGVZ9PQf2wfSUP/55aqq9vzPAolTQ4NXjvvu6AxeZzOB10+lh97i6UCiCY7s0mw00TZcyHCGE2IAkWCKEEEIIMcTExASzs5NYGZu3Tr+20lfkYnVml8zMwIcfVOx+aJKKbjLxnkk2b05z34/olCqLZDIZEgnYvr00cK3du9t9S3p7fMy3rIG9PDoFk3UKTjtLJDMCfk+RGVpenLqrMW8XqS5/z6+6Bjv2mezdC1Z80KqKM83uJ95q2DTdEDBG8NFzy1a/JKk3+BH8rKVNbv7paearZld/kkGvp7Psplc+33sNHUPzOH26O3CxlGOg3JD9awkZEVwbbLuJpknPEiGE2IikZ4kQQgghxBCaprFr1y5OnDjDay8uUCgukk6Nrn3iEEHT10cehZ/9Gf/nvfda7L13CwDv+0iYkyfzlBdq2E6DVDrFDdcXePn7LUqF0Mo6mSzk8vD0ZxVJO82OcLvHRzmRZvdOxblzF3ZvN+6BqAVPfANKBQOYwqNA3c3xes1mW1RDm/RA2YyOhnj/j8Bjj3X3EVFakF2iY+kOFcfjTFPHD5T4QZlE0u8tMqz/iBVrl9IMGwsMEI5AKgV33DF8DPCpk+0Ay9WRPFNhHQ+of+skn/22hgdYW1P8yAOjvHak//wHHlj7fRvEMELgKRzbxfNcXFeCJUIIsdFIsEQIIYQQYhXZbJatW2eYP3OCN9/6ATftPrjq8Ws1C+1s+trLMAxSqRFa9TnyhXkmx7eQTDbZd3OJ//k/R1aOO7DP77NRKkIJi016qGsMb/JYntuT5e57AM4045xopPuumxnxszOUgp/5afizPwvGFaeAKK34EjP31nBadfLFM+h6mHAoyrU7Ijz/nIGfMeKy5eomx96o8Ea9zjVRAwPF7QkNyC1vcKYR53S1/x7AD2w06vDE4x1vnTY4oySR8MtuVtMZbMmGalh6EFVxljdYeL3Ct06Mkkh2B3BmZrikEcOhUBjX9hu7Oo70LBFCiI1GgiVCCCGEEGu46aabOH78LV7/7iJL+TmS8SFNLmg3C+318svrm6ySSmUplfKUq3XK1QKpVIrrb5jnuy+2KORDK2UnHkEgwO/xcU10iddrIzRtRa1cI230fzkfCdUGBksO7O8etbt/Pzz29eDZMLfdMkkm26BWzVNvVMFxaLSKJNJgxjwqFYjFYcs2xZunFXM1g5mIRtrwAHd5W/0eAo7jl9wErBhUK/3H7dvb/XN78k3HTgXRKNRqcLKRJG3M43keSqmVyT6v1zLMF/zgS6dCEX79Ny5tIo5jV3EcW8pwhBBiA5KeJUIIIYQQa0gkElxzzSyj03DixKu9CRtdhpVu3H//+q6l6zqZzBiRhE6xuICHx2h2hHvuKTCSbbI1ssDhz56i+uwpbk+e4vbEKa63FphvWRQccyUwAP2NX08t7++kNHjqqfaEHYDZ2aB/SbsnSCgUIZmaYDS7mWR6nFgqyfFTUUqtCHXClJoRHv92jKY7AsxwsjG67ntYzZ13+JOAeu/56ae777lz8s3KVoRIxL+wP2XHH9EMfqCkYEc40/SjJJWegEypeGkTcfy+JR6O40gZjhBCbECSWSKEEEIIsQ67d+/mjTeO89q5RZZywxuCBE1cT59u77vQko5EMkOhuESrWqVUypFKjbJrV5yJiQVe/DMw1XLWSEevjs6MjfmWRdULYamWf5hipUSnl+f643vBDzjs2+cff/CgH0QZzcKjj9KRsWGASnDddQkWF/2yGWg/gh/cmG8ZlB2/PGitexgmk4XZbX5/lue/033PQfZJcM/D+pvcdFOLF15UFPMhTqOxoyPL5ZWaPwkIYNhk6PUGuXqFQmGqNQ/bbuK6xiWPnhZCCPHDJZklQgghhBDrEI/Hueaa7YxNw8mTrw09btCI4AcfHN6EdOAaQHZkgnBcp1RZwnZaRCIm6XSS+FY/zWK1jI1MVhHfnu5a8yxpuqIrA+zuGLU7tTyKN58fnLFx6mT3aN5O+/bB2LhC29R9D8fr3fdgmqwqvwR/8Rf+erHYkGPyfnZJZzZMIJOFTTN1brulwMSkzS0PKKrLUZ/OrJJhLqVvSZBZ0mo1L+h3L4QQ4sogwRIhhBBCiHXauXMnY9NhHHf1mbK9I4Iv5gu3ZcWxYjGMqKJYXAD8gM2eg2FqGF09RnozNg7sg9n9/lhh8McJ77h19YyOYSN4hwVEcjl45hm/J0jvOnv3+oGWPXe376HshLDjFplM+7i77lr9PfA8mJvzX+N99/sTbW5PnOrabjJOUXg1v9JrpdOBfeDYDWY2N/nYx5pcdZXO6K0OFc3guDEBKIxV8qwLRfj1X4dP/LrfuPdChMPmSrAk6JMihBBi45AyHCGEEEKIdUokEmy/dhtzpw4D0Gw2/DGxPQaNCA6sNS2n08jIBLVqlcpCkXgsQzhsMpLNkLjWwX6tvHJcckeazBuK3FI76KGUYuSmLIsvLZG9cYSZ7YpDLwRTbvod2Dc4+2V2tt0ktVO97m+ZTPdznetomn8PCy8ucUYf4eDd/hNPPeWP/J2cBOMbsNqgmJ3X+4/TU3AmUiOq9R+cogakV7JLgvfh6i0uuaUWoRBEImHqDcXWPXDrj2Y4f97ikUfh5pvhz/9bey3DaN+PP23It94GvSvr6CE8F1zXlUk4QgixAUmwRAghhBDiAszOznL0tTcBmF84w9VXXTvwuGEjgi9kWk4kYpJIpvjmE0sceXmOsHYVAJ6X5VqnQVxvUcNg181RYjPtIEQQrNi802TzzumV9bqn3PilLZXK8KwS8NfyVulou/8APP88XYGaldf69TzeQhkDuJoFFr7hx4iuHY0zNZUG4Kabu/uRdF1bg9tuaf+c2p7Ee2N+ZZJN8Jjanly516DXyh13+FklhgEhQ0fXjZUpOB7eyu/H8+DZZ/weM0EW0Je+1H8vF9q7RClFyAjTbFVotZoXdrIQQoi/cxIsEUIIIYS4AOl0mi2zMwCUSucplyeJx9c/4eWBB+DIkf79w76MZzLjHDtRJJevYVBEU0lAcUTPcq21RPJ6nUolx9Rklo98ZPVr92Ze3PUef6pMZ4BlENP0s0gGefopcFy/qevkePc6Tq6GpfqzKio5PxPk0CE48qofFPEG9D/dtbt7Es62AxbfOxrC0tpNY6teiD372iVGQa8VgHKpQTgCETOy8vxTT8NL3wetoxi91fIzZB5+GK69Fp577sIb9A7KGGo6EXbujfDRf9Ba/WQhhBBXHAmWCCGEEEJcAKUUMzN+sETpi+Ryc1hWnK9+VVtXec2FTssxDIP77hvlv/7n8+jaHJ4XQymdgmOy+YExxsfmyecdSuU8iUR6jXvvzrzoDCys5sABeOyxwc+V29VA5PPdz8Vnk7hH+zNBErN+cOnUyfZUm7571eD2W7v3aZoifk0a99h8+xrXpNG0wZGeZrNBMgnmcidZz/M4fhwWF/uPv+46PxsI/Aa9n/pU+7n1NOgdlDHkeBGOHtFptaqrnyyEEOKKIw1ehRBCCCEu0OjoKABWEhwvx+LS+ZUvy/PzHducX17Tab3Tcr7yFb+x6Cc+AV/5ShZPM2nh4eI3ex2fgJtuDDGSHSGZAtuuUi4V1rz3IEAyNbX+1zu7bfg0mk67e5rBzu7zG7x2NqOtEWJ2ORNkWPNY8IM5nVklK2vu98cig59VMrtvcONax7HxPAcjBOFQGPCDJX4T2P7Ix+kz7UauF9Og94EH+vcpQtx2W0N6lgghxAYkwRIhhBBCiAukLddwXL1tEtQC9VqBu+8ZXKcyqLxmPV/GO4Mvi4sK152k7hp45PG8OvfeCyg/a2JkJEUqBc1WhWplSKrGJVDKD150ivSM/R3U90TTFLGeEcax7e1MkEHjfpUGH/xQf+Al8N3vKt6wsxSdMG/YWT77qOKRR/zxwZ0ajRrhCIQjYdTy7+uLX3SXp9r0fwQuFdvBraBB79ZZvzRnPYNsOn+ngelpneuva+E4ztoLCCGEuKJIGY4QQgghxEXKTsZZOlfBa5W5+qpTbNq0fV3lNatNywn09zaJAUkabo5NY+e4fufVBBkSlhXD8zygSD5XAgWWlbjo1xU0Zu28LQ+YjcV5o5ImkYTbbu0uzRk6TWefxQ9e0whrLq4HjdeXOPx6Dg9Qo3H27093NZ29/30wPd2/TuDUSZirmMwx3bd/3772zdZrFRJJiEXbmSfnzvv9VVYTBLeGNegdJsgY6izf+cAHQuB5uK5klgghxEYjmSVCCCGEEBdpYmKCzdvHsd0cpmlz//35rudX63URfBkP+mT0GpSpMDo6wfimMHfd06BS675WLBYnnUqQTkO9VqJavfgMEydXw1Q2kY7NVDajoRpj4/De9/qlOUFWyGrTdDRN4SzX02gKIspZWa+xUOOZZ/xsEvAfn36mP0uk07DSnc5MlGarDsolElZEo9GV/TdcHzSUGfwReL0lN8P0ZwyFcF2wbRu1nvQUIYQQVwwJlgghhBBCXKSJiQkSmTDpbAIzWmbbtnNMb/JTFy71i/eg3iY//dMG/9v/Ns6260IUigs4TnfGQjyRIJ1OkEr7AZNKuXhR144vN2ANRgYHj8ntyZV+J0Gz2LFxOHjX6qUqQSlO73qLKkmp2J6E47l+Ocypk8PXGlS60xusqdcqmFGIWtGuG3vPe1x0XTGoZwmsr5HranrLdwzDANeTMhwhhNiApAxHCCGEEOIiGYbBxMQE1UKLU6/nGR2N8+N/7yyP/c2moeU1F6Jzcs5K8EWlKZfzNOslcvnzjGa700/iCb/85rvf9XjlBxbgoAWdUpU/9WWlXGWI2X0Wh4+GiKr2iN6mp+Eul9AEPODa0ThTU+kLXq9GiG37LY7/Tf/xuRw88sjge1UK9u+nq3SnswTIdW2azQbxBMSsWM+5Hvv2w9PPtn8xsRhUKpce3Ap0lu+4roFje4AETIQQYqORYIkQQgghxCWYmJjg/PnzJDIWrWqVa6+FG26YY2Rk/JLXHtbbJJudpFatUVksU6+XMc1413nxRILz52wqlf6Pel29PYYIGrO6R9sjeh2lEaW/90YlVwPSq6733e8qzrTS7Ai113urlWa6qMiMQG6p+/h63d+G3WuQXZKs5JmOlKk8C4ef9Z/z8HAyYaY/pGGEQl3neZ7H++6D555XOA6EQvDxj8PnPt9+f7/8yQWqxwt9/VqsrSk+/Kujq77OXpqmoZQakscihBDiSibBEiGEEEKIS9DOLjnF0pkmo6Nw6tQSsViSSO/ImIswqNFoOGySzmRxWnMs5c8xOb61nT2y7I47DT7/uf71hk2Z6bWSDUKLGiGs2RTeGwt4nh9UCB6rsSSPPIIfUQAaTWi1/EBExJ/YS7UKjmOxKREirrcoOyFOVyzOHfKPG2bYvQYlQKcerxHVBgRwig6xAQ1uXc8hHNL4qZ/S+W//DT76Ubj++u73t3yyQoxW37nlUxXgwoIl/r1KsEQIITYiCZYIIYQQQlyiiYkJ5ubmKC/ZaJ5iJOsxP3+GTTOzQ78of+Ur8M1vsRJkAEDB3QfhQx9a+5qZzBiVagm7XiVfmGMkM9X1/A3X+/1E5ufa+5Jpm6u3wHo+AmqaYuSmLIsvLZG9cYRNOyIcfqPQV0oz37IoDWiN0mz4W+eLO1LNck10iddrI4Cf3TGsOmW1prHg902p7EjiHp3vC+CktoeIWlbfOa7joJTOAw8Y/NiPDV53820Zlr5d61tz862Z4TeziuEdUoQQQlzJJFgihBBCCHGJDMNgfHycSv4UlUWbdDpMpdwkn18gkx6cjXD4cHcgI/Dyy+sLliilGBudptV4k8pSkWgtTjTakU2h/Kk1ndklN+4pUsg3SSZHMELhNa+xeafJ5p3tEb29pTmx7Wl2jyjOnVv7fmMxKFRMni9Pr/xcqQw/PuhDcugQvPoq4LWzVsDPSAmHLK5XfraK/55ADYN73jcgq8T1ozJKV+i63vd84K4HE3z2yTAWzZU1qyrChx68yFHMSkOD5dHOQgghNgqZhiOEEEIIcRlMTEwQz0TwVAsrFmV0FIqFBZrN+sDjH3hg8Dr337/+a5pmlMzIKGbSYCl/rm86TpBdAjA27rFnT4tYzKVQWKBWWyVSMcTsPosaft1MjRCz+yxmZ/3Ax2oyWbjjju59d9zZP9UmqCTqzCo5ddKfkFMq+ZkqnutvzQaUy4rj9XTXGqnrTKLR/vIn13VAA4VadYyvpitm7uwOcM3cmUXTLzI/xJMyHCGE2Igks0QIIYQQ4jIIskvKuZPUciVGRpLUaiXm5s6wadPWvi/onZNuAhczkSWdGaNaLWM3yuTy5xjNzrSfVPDBD8JffQ1+9P2K8bEx/vq7dQ5/L4zjglqelDPu5pnQy13TezxAjcbZ/UB6ZV9vaY6m+SfccQc89tjwezywzw9+ZA75zVwzWb9JK3RPtQkSPuo1eOrP8yQaZbZ6sKUjqeNMM86JRvue5lsWVS+EpVrUMLjjfamB9+A4NkoD3Vj74+9KdonXvLSsEkBb7lniuu5FryGEEOKHTzJLhBBCCCEuk/HxceKZCLbXIGpFyGQMwuEmi4vn+45VCh56qHvfgw9e+LhhBYyNTWMmQtTtCuVKvuv5q6+GX/wF/1FpGqdPW5RKBmN2mT3aWXZxihkjj6nZRFR7M5WNnav1XW/zTpObPjrN5p3t7I3Zbf3ZJcHPQZZI0JR1bBwO3uX/PDsLnbGLVhNcB2pVCNdqmMrG1GyiensbCXXfU2YEwtcYVFWIqVtihCODO8Y6Tgvd0DCMVTrKLtN0xc4PTlLRTXZ+cOKis0o8AKWhPCnDEUKIjUYyS4QQQgghLpOV7JL8SRaX5tm06Wqazbc4fSZPuWwRjye7ju/MLrmYrJJAOBxhZGQct3WOfG4OM2JhGIN7ktx2G5x4E7KhGlG9f5IMDJ90A4CC667rHumrFNz3PvjLv/AbtmaycNdd8PRTftZJEACamoKPfKT7vJtuhue/M+AmJpKw0N+89VSj+z2sVjwOvZJFM+DIdwwKLtx9d/9ytmODYl3BEoC991rsvXfLuo4dxnUcdE3Hk2CJEEJsOBIsEUIIIYS4jFYm4yxWaNkNxsdHaTYXOH/+LBEzSqjjy7pS8LGPwSOPws/+zIVnlXRKpUao1srYzSJLubOMj141cMGgj8nJXJK00R+MCO5rtUk3p076j0Hj1UAwKfngXf2BkWH27YNjx/zynEAm6wcrXv5CqGv6TtkJYcctMkAu5x/baGg0Gu1k6WNHBwdLHKeFpisM/cI//n75kwtUjxe6eo94gLU1xYd/dfg4Ydd1CEcMlKdwho39EUIIcUWSYIkQQgghxGWk6/pKdsnc/Dm2bb2OarVCvV5jfu40U9Nbur5079gBv/Pbl+faY6PTNOo1KosNiqVFkskBX+RXpuRYlJ3uSTKdVpt0s3u3P81nUCBlasrf1iOYdFPrqfYpFeFzn1dsSaWJltrTd85paQ7e7d/oE4+7lEr9FeW33jb4WrbdQjPBCK0vs6RT+WSFGK2+/bnjFT7x66NDxz87joOhKzRNl2CJEEJsMNKzRAghhBDiMpuYmCCejuDQoFBcYnp6E9lRHU2rk1saMC/4MjEMg+zoJGbKoFhepF4vDzzOzy7pnyTT8PwOq1UMRrZVufoqm2i0+1ylwdNPD5+As3v3+u83mHRj98Qh7Ja/f6HVPX3n/R+1mJqCVLLE+99/jkym+8TxCf+1DdJs1dFCGuFQ/6SctWy+LQP42Tedj+eNDPNzMD/fsc3545/BzyzRdQ1N06UMRwghNhgJlgghhBBCXGa6rjM1NUViLMS5ubPousb01BRjY1CpLFGrDQ5iXA6JeIpUegQzZbCYO9s3ThhYmZITGm8HI+oqxFUHR6mpMNmbQphmi0JhjlCk+3zP9cf4liv9o387R/6ux641Aiu79/jTd6oqzMhNWTSlKJXyNJolMiNw18HuYMm99/qvrZfj2Hiei2ZohMOR9d/gsrseTFBV4a4ypaqKcPdHBk/JCcY/t1pNQoZC13SZhiOEEBuMBEuEEEIIId4GY2NjJNJR9IjDwuIc8XicsbEMo6MwP38W2x7cXPVyyGYnsBIWRhQWl063UyE6XH01/OIvKmbvzlLTwmw9mGXnLVF+9BPT7LsnSzoTJp2B3bsG1NoAe3bD/v3d+w7su7C+K7Oz/QGXQBB4CabvbNoRplhcxLGrpFIwMpJi/z6LsXH/+NWySlqtOpqhCBnhvhHO66Hpipk7u0uaZu7Mctttik2buo/tbNRr203CYf+6nudJdokQQmwg0rNECCGEEOJtoGkaMzMz/OEfHOXxr54nYmRRagLbzuI6Hvv3l/nZf5AelAhxyZRSPPeFGLXjDRQuirdA+SU2kek49/x0euXYHftNduyf7jrf0A1Gs6PUY3VuuqnISy/alMvtj42dGSSZEb85ayYLuTzrmp7Tvk8/4PLY1/uf6wy8NOpVypUioZBLOgMjIyOYpl9O88EPwl99DX70/QzMKgFothpohiISufASnMBdDyb47JNhLK9JVUX40IOJlfHPn/pU+7jO8c/NVpNEXMP2/PfOdV10Xb/oexBCCPHDI8ESIYQQQoi3SSaT4TuHEpw8lyeqnUVXVxF8/Hrt9TCF/ALp9PBpKpeicqpGTIEfQfAAP5Oldr4GpNe1hmmamKbJAw80+fM/b+/fcW2OcllhmlEOHozw1PKI4OeeHdz09dTJwcESaGeX5JZA08F12sEYx7YplfO4bpNEAqJRnUw6TTjSLqW5+mr4xV9Y/XW0Wg2e+Y7ipZcjaJ151R3NWNei6YqdH5zkB38xx/U/Po6m+xGR3vHPZ87AJ34d8MC2p9F1D5s67/uwx6c+JZklQgixUUiwRAghhBDibfSrvzrDz/1cmQhLaN4YSvkdU3/0R5coFMpETIuoaV32626+LcPSt2sdo4E9lFJM7E5e8Fo33RTmb7/tNy8dydrsuqFGswmlYpVIWONH3x8jEomya7fB2bP956/W9FUpOHgQnnoKdlwLR16DTMbmM/+PwgMUaTTdz9TZt09xzz2Kb34TXniBvgyWvXsHjw1uteq8cVyxuNifWfLyy+sLloA/znjvvVv67r9z/PMXvuC/Tz7/o7btaTz7DNK3RAghNhDpWSKEEEII8Tb62Z+Nc801I9RdA5fTAGzbBj/ygM7YGMzPnX5b+pf0NyVV1PDYc3f4whdbbgg7PQMPPmgwMZlldMxidFSRSLq4bol8fo50+jypdPdrWU/T14kJlw98oMGWLXnuufscS0sOlYpOtWJQqRiUigaFvMYbx/wXc/Son4mSy3VsS3DsaP/arutg2y1uuV0D+pu7Bs1YL0Uw/nnHDnjggUFHaPzUT3oSLBFCiA1EgiVCCCGEEG8jTYP/4//YRMMzsCnjekX+6T+FqelJMiMREkmHublTl73556CmpNZ1DotLp/Eu4kt7UO5y9dUQiURIp9NMTk4yMZ5hdDRCdhSSSYcbb+quw9l5XYFiYYFiYZFiMUe5lKdcylMq5cnnF1haPMfS4jkqlUWUqpJOu+zdWxt4D7fe5j/edtvge7x1wP5Go4oWUtx0Y4RNm7qTqjubsV4uQVlOp80zGnffLZklQgixkUiwRAghhBDibfbRj0a49toJ6o7Bps2nuedeD00pNs9sZnRUxzDqzM+fvuzXDbJLAKoqxI0/EsbTWyzmzgyckHPBlMKMRhnJZpmcmGBycoRb9ocYyfrZJZlsi+t2VIhGm0QiDUKhGppRRdOrGEYVK9okmXQZHYXRUY2xcYvxiRHuvCO9MuUm0Dnt5obrWfX5TrV6BSOiYVkxHnqo+7nOZqyXS9D0tdNP/KTyO8fINBwhhNgwJFgihBBCCPE20zT49KenuPaGCD///2pSKCwCEAoZzMzMMDYOtl0ml1+4vNddbkpa0U12fnCKqanNRNMhmk6Vpfz5y3wtnUjEJJlK8OCDBtMz8KEPKCanRpiYSDMxkWJiIsnkeIKJ8TgT4wkmJtJMTmaZnJxgYmKSdDpNJGKiNHjve7vXv/de2tNu1BrPd6jXy8vBknhX1sfbkVUSOHAAJiZaAGzd6nDrbQrPkzIcIYTYSKTBqxBCCCHED8E99+g88cQ0R197k/Nnz5FKZtB1HSsaZdP0FI59lrNnFwgZYeLxC2/COkxvU9Lx8RnOOSep5AoYRYNk8vJP42lPqDEAg//52TyNM+W+43rHGHcKskfm5wZnjaz1PECzWcdVDnoohBmNoehuxnq5s0oCSsEHPnCOxx8f4zd+Q8PQNDzPkWCJEEJsIJJZIoQQQgjxQzI2NkYybWGYLguLKyNTSKVSTEyMMD4OS0tnaTTqb9s9WFacsfEprHSIYmWRciX/tl0rUDtfI4Ldt/ljjIfoaCr7gQ/QnzWy1vMsZ5WE/RKc4OnOZqxvF9u22bKlwr/8l29yyy1hlKbhedKzRAghNhLJLBFCCCGE+CFRSjEzM0Ol9DoLb82RyWQJh/yeImNj4zQaTVqtMnNzp5ie3oKuvz0f1RKJNLbdAm+e/NJ5DN3ANONvy7UAJnYnKb443zHG2H9ca4xxO0OFrnHBI80847qfqbIFePWL8Cr9mSq1ehkjpohab99r+8pX4JvfomuMsetqHDiQ5brrKigFmtJAynCEEGJDkcwSIYQQQogfonQ6TXokiZnUOD93dmW/UrBp0zTZ0QjxuM3585d/Qk6nTGaMZCaDmTZYWDpDo1F92651870WdRXqGGMMdRXi5nutda/ROS44pWpENZuoZmNqgzNVbLtJy25ghHWib2Mg6PBhvxRofr69LS5qHD0aIxZ7+64rhBDi7SWZJUIIIYQQP2QzMzMU8iXmT+QYqWaJLWc+aJrGzMwMtv0mZ8/UmZ8/w/j4pjVWu3BBNoTnTuG4NppbJKJOsX/vNO+77/J/wVeaYvzGNMUX51f2jd+YRmnrbxpy221w4k3/3ycbSdLG6pkq5UoOI6phxRIYxtv3kfeBB+DIkf7999+/RCw2AoDruYBC0+TvlEIIsVHI/2MLIYQQQvyQxWIxJibHSGYNzpw92ZVBEg6FVibktFol8pd5Qg60syEWFiC3NMNiPsX5nM4rR05Tr/c3Yr0cguwSuPCsEugeFzzfsig7wzNVXNehXCkStnSSycxlew2DdE7YCUxMNLjjjgrRqH8/nueB8suwhBBCbAySWSKEEEII8Xdg06ZN5PN5zpUqzC/OMT46sfKcFY0yPTWJY5/jzJkFjMs8Iac7G0IBMzjAzbcWWFg6TTYzTTSauGzXAz+7ZOvBLG/87RL///buPL7q6s7/+Ovua5Kbm+1mDwmLVoShVgQRtULF5WcR3EbbKminP3+t0v5op1qt4jrWTrFVa+1Mx4o6Mx0f0tGKWq2O/bmgonUBNxADBAhJyJ7c5N6b3Jvz+yMmJiYBErLzfj4eeSDnez/f77nxPL7cvHO+5xQvDA5qVklXN087DR79r86/7IwGONbX/0yV1tZGbE6Dy+3G4/H1Ok1/a4xggVNOhqVLh/C+LLB8Odx77+dtZ5xRjd/v+3y3HWOwWNHMEhGRCUR3bBEREZExYLfbycvLIyXDQXVNJW3tbb2OBwIBsrKChEJQV7ePSGT4Znz0NxsiNzePufMDeFLt1Nbvo7W1adiu12XGV9yc+X9zmPEV95Dqe84uITDwTJVwSwMOr42UlGCfc/S3xkj1fvjggyF1Cej9/QyF2jnhhDA+3+f96ejowIJmloiITCQKS0RERETGSFpaGsGMFDwBK/sq9vQ5npmZSUZGMhmZsH9/OdHoAbbaHYSu2RA9LV8OmVm5pASDeFLt1DVU0DIK2woPSo/tgr++tHOmSsTqZMrJad2zSqLRMHHacbod+Hx9Z+Ocfnr/p/7a1w6jWxZYuRKmFMPZZ1fg9XY+atXFYLBYLApLREQmkCM2LNmyZQtXXXUV8+bNIycnB5fLRUpKCvPnz+fee++lvb19wNq9e/eycuVKcnJycLvdTJ8+nTVr1hCNRgesiUQi3HjjjUyfPh23201OTg6XX3455eXlB+znunXrmDt3Ln6/n2AwyFlnncVrr7025PctIiIi40tBQQFJaQ5aY800NjX0OZ6dnUNGup+MDMP+/Xtoa4sNy3V7zobIy+v8uwXISM8mEEzDm+qgvqmKxsbhXzNlsF56CX75S/jlXfDff4RIC/z3f0NlS++ZKqajg/rGKlw+G0lJgX4fe+lvVk3X+z8cM2bAT37SyrRprbhcdlwuV/cxY0znFsJ6DEdEZMI4Yu/YL7/8Mvfddx+VlZV86UtfYvny5Rx//PG89957rFq1iq997Wu0tbX1qfv000+ZM2cO69atIy0tjaVLl5JIJLjllltYvHgxsVjfDzDRaJTTTjuNW2+9lXA4zNKlS8nPz+fBBx9kzpw57Nixo98+/uAHP2DlypV88MEHLF68mLlz5/L8889z8skn88QTTwz3t0RERETGQOcvUbJJznCwr3IviUSi13GLBXLzcklP95Aa7KCqag/t8YF/qXOoes6GWLECek56SE8PkZqejjfoIBytpaZ2Lx0diQHPNdJ6bhvc/VUHpZ/2fl1zuA6sCTx+N4FAer/n6m9WzbJlvd//UEUjLXg84PP3Xielo0MLvIqITDRHbFhy1llnUVpayq5du3jhhRf4wx/+wAsvvMCuXbuYOXMmL730Ev/6r//ap27FihXU1NSwatUq3n//fR599FG2bdvGsmXL2LhxI3fccUefmttuu4033niD+fPn88knn/Doo4+yadMm1q5dS3V1NZdffnmfmhdeeIG7776btLQ0Nm/ezBNPPMGzzz7Lyy+/jM1mY+XKlTQ0NIzEt0ZERERGWSgUIiXNi93TQVV1RZ/jVouF/Px80tNdJCfHqawsIx6PH/Z1Z8yAW27u/POLgsFMMkO5+NJcxImwv3o38XjfXySNhnnz+m8/oUd7vD1GU7gWV7KdYDDrgLM4+ptVMxxaW8OdYYm3904/xhgsVj2GIyIykRyxYUlxcTHFxcV92rOysrjmmmsAePHFF3sde/PNN9m4cSOZmZn8/Oc/72632+3cf//9OBwO7rnnnl4fXtra2vj1r38NwH333Yff7+8+tnr1ambNmsVLL73E22+/3etad911FwA//elPmTZtWnf7/PnzufLKK2loaOCBBx4Y6tsXERGRccRqtVJQUEByhoO6hhoikdb+X5OfT0aGgyR/nIrKMhKJww9MDiTJn0JOThH+NA9Wd4LK/WUjtrXwgfRa2PUzmVmd7V3qGqtw+mz4/En4fAfeyedAs2qGKhaL0mFieL0WkpJ6X9+YDkCP4YiITCS6Y/fD4ehcWd3pdPZqf/rppwE455xzej2HCp0hy8KFC6mvr+fVV1/tbt+4cSONjY2UlJQwZ86cPtc6//zzAdiwYUN3WyQS6Q5quo4frEZEREQmtuTkZNIzgvjT7JRX7MYY0+c1drudgoJCMjMd+H3tVFTs7vPYznBzudzk5BSRnObHnWKlpq6cpuZa6Kd/I+azbYN7+upXO9sBwuE62hIRXH47aemhQzpl16yarVth9Q9h9eoeXz/s3GJ4MJqa6/H7ITkluU8o0rVmiWaWiIhMHApLvqC+vp61a9cCcPbZZ/c6tnnzZgC+/OUv91vb1b5ly5bDqtm2bRuxWIyMjAzy8vIOqUZEREQmvvz8fFLSXcRNlLr6/hdWdTi6AhM7Xm8blZUjH5jYbHZCoUIC6UG8aQ7CkVqqqstobx94cfvh1nN2Sc9ZJa2tjTQ0V+MNOEhNzcRhdwzqvMOxlXBHRwct4SaS/J1bPnf5/e/hnK8b/u9qWLoUpk2zUlwMt98+qC6KiMgYOOLDku3bt7NixQouvfRSlixZQkFBAW+99RZXXnkl3/jGN3q9dvfu3QD9Bhg928vKyka0xufzEQgEqK+vp7m5+aDvUURERCYGh8NBbm4uKVlOqqorBtydz+GwU1DYGZi43TGqqvaMeGBisVjISM8mM5SDP92NxRWnqrqsc7ec0Zhl0mPb4HPO6fx7NBqmrqEST8BOIDWNlJTgoE87HFsJt7Q04fEYfD4nXo+nu/3112FfeQc11VBRaaGszMLOnfCXvwy6myIiMsrsY92BsVZVVcVDDz3Uq23VqlXceuutfaZQhsOdz+h6v7BoVxefr3Pl854BxkjUdNU1NDTQ3Nzc57nYLzrmmGP6bS8tLaWkpOSAtSIiIjK60tPTqa2tpbWpgYqqvRTkTen3dU6Hg8LCAgxl7K+KUlFRRihUgN0+sh/vkvwBvB4/tbWVNDc10dJUR2R/M8FACKfLc/ATHIbCQrjyf3f+d1tblJq6fbgDdpIDAYJpWUM6Z9dir+Xln7cNdtHX5uYGAgEIpKb2ar/oInjnHYPpel7osz+vvnpIXRURkVE0YcOSZcuW8fHHHw+q5uGHH2bu3Lm92k466SSMMSQSCXbv3s3jjz/OzTffzJ///Gf+8pe/UFRUNIy9FhERETkwi8VCQUEBzU1hqssaaWxqICU50O9rnU4nRYWFWC272V/dRkXlLkJZBTgczn5fP1xsNjuZmXn4fM3UOiuJhmPsr92N15NMsj+I3eE6+EkOQ7ilnobGalzJVvwpSWRk5jLU1UC6thK+997P2wazlXBbW5REIorXCynJyb2OnbYIphTH2bYDwAZYmDmz79bFIiIy/kzYsGTnzp1s27ZtUDWtrX1Xlu9is9mYMmUKq1evpqioiPPOO4+rr7661yKqXTvZDHSelpYWgF4zPUaiZqC6gXz44Yf9tg8040RERETGltfrJTsnRFt0H+UVe/B5/QPOGHE6nRQWFmG17qba2kZFRRlZWfm4XO4R76fPl4Tb7aWuropmVyNtrWEqq5twu/wkJ6XhdA5vHzoSceoaKonGW/CmOvAlJ5F5GEFJl56zSwY7q6SpqQG/H1JSkrHZbL2OWS2w4rJ2rr0RoHMtlTVrQJviiIiMfxM2LHnvvfdG7NzLli3D7/fz7LPP0tbW1r0rTkFBAe+++y579+7tt66rvbCwsLutoKCg17HhqGlpaaGhoYHU1NRDCktERERk4snJyaGpqYlYuInyit0U5hf3Ov7738MTf+paLsQOFJNIxJk3r565x5eRmZmHx+Mb8X7abDYyMnJISQnS0FBDuLmZ9kiE/bVluJ0+/P5U3E7vYe3Pazo6aI000dhUg9Vl8Ke5CAYzh7RGSX+6thL+j/+Eb1xy6F3t6OggHG4kN6/3wq49LVgYJ6/AwtZdds0qERGZQJRr98NisRAMBonH49TX13e3z549G4B33nmn37qu9lmzZh1WzYwZM3C5XFRXV1Pe8wHaA9SIiIjI5GK1WikqKiI500FLtIn6htpexzsXD4WKfZ9/7a+y8+mnSWRmGvbv30NLy+gtBO90usnMzCMvv5hgVhB/upMOe5Sahr3srfiU2rp9tLY20pGIH/I529qi1DdUUl5ZSmPrfpzJFpLSfOTmThm2oKRL11bCM2Ycek1TUx0ej8Hvcw641lwi0c7/+T8Wjj3WwW9+o1klIiIThW7X/dixYwd79uwhOTmZ9PT07vaurYQ3bNhALBbrVVNVVcUrr7xCamoqCxYs6G5fsGABKSkplJaW9jsbZv369QCcc8453W0ej4fTTjsNgMcee+yQakRERGTy8Xq95OXlEgg5qKgqp629rfvYRRf1X3Ppt9xkZSURCkFtbTnNzQ2j09nPOJ0uMjJyyCuYSloonZRML940Gx32VhpaqthXVUrV/l3U1JbT0FhFU3MtLS0NtLY2EW6pp7GxhpraciqrdrC/towYzXjTbCRn+sgIhcjNnYLTObJrohyKRCJOY2MtwSCkZ2QM/Lp4gmNnWXjqKTsLF45iB0VE5LAcsWHJvffeS2VlZZ/2bdu2cckll2CM4dJLL+317OncuXNZsGAB+/fv55prruluj8fjfPe736W9vZ1Vq1bhcDi6jzmdTq666ioAvve973WvNQJw1113sWXLFk455RSOO+64Xv1YvXo1ALfddhvbt2/vbn/99df5l3/5FwKBAFdcccVhfhdERERkvMvKyiKYkYInxcKe8l2Yz7bpPW0RFH9hU7uSks72nJxcQqEA2dnQ0FBJQ0PNqPfbYXeQnh4iv2AauXlTyMjJIpCVhC/dic2fwLgitNFMa3sdzdFqGlsqCUdriJh6jDOCI9ngz3SRlhUkJ7eQ/LwSAoE0LIfxOM9wqq+vwe83JCe7ST7AY9HxRByr3TLiuxSJiMjwspiuf3GPMEVFRezZs4fZs2czdepUjDGUlZXx9ttv09HRwcknn8zTTz/dvdhql+3btzN//nxqa2s59thj+dKXvsRbb73Fjh07OPHEE3nxxRdxuXr/tiMajXLqqaeyadMmsrOzWbhwIWVlZWzatImMjAzeeOMNiot7P4cM8IMf/IC7774br9fL1772Ndra2nj++ecxxrB+/XrOPffcw/oedC3wOtACsCIiItK/9vZ2nE4nbW1tvX5JMlJisRgffvgh1bsipAWyyfhsm9wXXoBrr/38dXfeCYsWff736uoaKitrqKwEjyeVYFrWYS+Gerja4+20xaIkEnESiTjxRJxEPI4xCWw2O1arHYfDidPpwul091k0dTxoa4tRUbGTvDwoKSnC4xl4Idtdu0ux+SPMmFlMxgFmoIiIHCkmys+hR2xY8h//8R8888wz/O1vf6OyspJIJEIwGOTv/u7vuPjii/nWt76FdYCHSvfs2cONN97Is88+S11dHQUFBVx88cVcd911uN39/2MZiUS44447+M///E/27NlDMBjkjDPO4NZbbyUvL2/Afq5bt45f//rXfPzxxzidTubNm8cNN9zAiSeeeNjfg4kySEVERMab0Q5LAGpqaij9ZCc1e9qYWjQDt9tDh4G//3vYUdo5q+QP/9W5A0tPdfX17CuvYv9+wOIlMyN3XAYQE0ll5R7c7hYKCpLIzc094Gs/3bEVT0aCY46dQUpKyij1UERk/JooP4cesWGJTJxBKiIiMt6MRVgC8Omnn1K+q5b2JhtTi4/CYrHw7rvwy1/B//0BzJnTf11TczP7yvdRU2NobbWTmZk3KlsLT0aRSJia2r3k50HJ1BKcB/n//9G29wkW2Jg1eyYej2eUeikiMn5NlJ9Dj9g1S0REREQmmsLCQgIZbjpsbVTtrwA6A5KHHxo4KAFITkqiuHgKOTlOUlPjVFbuGvWFXycDA9TW7ic1AGlpwYMGJR0dHSQScWx2C06nc1T6KCIiw0NhiYiIiMgE4XA4KCwsJCXLQU39flpaw4dc63Q6KSoqIicnqXPh18ZKqmsq0CTjQ9fYUIvN1kZKwNZrx8SBtMfbsdot2Gw2PfokIjLBKCwRERERmUACgQBZoQxSMu3s3VdGIpE45Fqr1Upubi75+Znk5YLpaGTfvl20x9tHsMeTQyTaSlNTNekZkJmRMeDadj21t7dhs6FZJSIiE5DCEhEREZEJJj8/n5R0L1ZXgn2VewddHwwGKSoqIDvHhs8Xo2LfTiKRQ5+lcqRJJOJU7y8nPR3S01MIBAKHVBeLRbE7rX12ShQRkfFPYYmIiIjIBGOz2SgqKiIl00Fzaz31DbWDPofX66V4yhSys91kZHZQXb2X+vpq9FBObwbYv38vSUkJUoMuQqHQIddGohHsLqsWdhURmYAUloiIiIhMQElJSeTl5xIIOdhXuZdoNDLoc9jtdgoLi8jNSSUnB6KxWsr37iAWi45AjyemutoqsERJS7OSl5eH1WI5eNFnorEIdpcFr9c7gj0UEZGRoLBEREREZIIKhUKkZ6XiT7exe+/OQa1f0sVigaysLAqLcsnLs5ESaKOyche1tVVH/OKv4XATrZF6MjMgNzfnoLvf9GSMIRqL4tDMEhGRCUlhiYiIiMgEZbFYmDJlCqmZXqyuOOUVu4d8ruSkJEqKi8nLSyEvDxKJevaWlxKJtAxjjyeOWCxKbW0FmRmQlZWO3+8fXH1bDIvV4HDatGaJiMgEpLBEREREZAKz2+0UFxeTEnLSEm2kpm7/kM9ls9nIyc5mypR8cnPtpAXj1NTsobqmYkizViaqSCRMZWUZ6emGYJrvkLYJ/qJYLILdacHj8WAZxKM7IiIyPigsEREREZngfD4fBQX5pGY7qdy/j9bDnA3i8/koLikhPz9Ibi5YaKS8fAfhcNMw9Xj8ag43Ul29l8wsQ2aWj7y8PIaSdUQiET2CIyIygdnHugMiIiIicvgyMzMJh8O0x6op27OTqVNm4BjEGhtfZLVYyMzMJCkpGY+3goaGGDU1+wiHG0lNzcDlcg9j78eHhoZampurCYUgIyOZ7OycIQUl0Lm4q8OvxV1FRCYqzSwRERERmSQKCwtJzfTjSjLsLt85LAu0ejxuphRNoSA/nbw88HhaqKraRVXV3km1a05tbRXN4WpC2ZCdHSQnZ+hBCXy2bbBTM0tERCYqhSUiIiIik4TNZmPq1KkEslzEibCvcu+wnNdigfT0dKZOLaGwMEB+Abjd4e7QpK1t4oYmiUSC/fvLicXqycmGvNxMMjMzD+uc8XicRCKO3WVRWCIiMkHpMRwRERGRScTlclFcXEx723Zq99TiqfcQTB38AqX9cTocZGeHSEtPo6amhob6Rhobw1RWhnG7/QQC6TidE+PxHAOEmxuoq9uPz9dBdg7k5eaQnJx82OeOxiLYneB2u7HZbIffWRERGXUKS0REREQmmZSUFPILcumI72Xf3r243R68Ht+wnd/pcJCTnU16WmdoUl/fRFNTmIqKMB6Pn6TkIB73+F2ro3Nb4EogSigEKSluQqEQHs/wBD2trS3YXVatVyIiMoEpLBERERGZhLKzs2ltbSXeVsOu3TsomTIdl9M1rNdwOp3k5OSQnp7eKzSpqQkDdvy+FPz+FBwO57Bed6gSiQT19dW0tDQQDEIgYCU9I4PUQOphrU/yRU3hRtyp1mGZpSIiImNDYYmIiIjIJFVUVEQsFiMRb2bX7k8pKZqB3T78H/+6QpO0tDTq6uppbm6itTVOOFxLRUUtdrsbvz8Fny8Jm230P37GYlHC4UbC4UZ8vg7y8iCYlkJmRsawfz/i8TjRaIRkr0thiYjIBKawRERERGSSstlsTJs2jURiK9XxFnbtKaW4cBpW68is8e9yucjODpEVyiIcDtPU2Ehzc5jW1ijhcJS6uircbh8+fxIupweH08UwTujopb29jXBLE+FwI9CO3wfZ2ZCU7CIUCuEdoYVXwy1NODwWfD4vTuf4mFEjIiKDp7BEREREZBTdfjs88AD03NXXYoErroDrrx/+6zkcDqZNm0ZHxzaqd7eye+9OCvOLsQzncydfYLVYSE5KIjkpiUQiQVNTM42NDbS0RGlpbSHS2kJDPSQSFlxuDy6nG5fLg8vlGfJMj0QiQVt7jFg0QmtrM/F4FJ8PMtLB67WQlJREcnIyPp9/WB+5+aLmcBMun42UlJSRu4iIiIw4hSUiIiIio+i552Dnzr7tf/nLyIQl0LkrS0lJCfH4J9TsCVNesYe8nIKRudgX2Gw2UlMDpKYGaGtro7GxiUiklUgkQnu7IRZrJRZrpakZ2mrAYrHhcLqwWa1YrDasFgsWixWL1YrVYsVqtWKMIZGIE4+3d38lEnGcTnA4IRAArxf8fj8pKcn4k5KwjmRC8hljDM3hZoJ5CktERCY6hSUiIiIio+jqq+GVV/pvH0l+v5+SkmIS8U+p21vH/monmRmhkb3oFzidTjIyOrcxNgba2mJEo1EikQiRSJRYLEpbW4L29lYSHYCBjo7O13Z0wDN/SeONN5IwpnM2joXOP08+uYFzl9XicjpwuVz4fH6Sk5NGfdve1kgLWBO4vG58vuHbfUhEREafwhIRERGRUXTeeXDMMfDhh5+3zZwJy5eP/LUDgQBTigsxZhfVeypxOBykBtJG/sL9sFg61zhxuVzdszA6jCEWjdHWFqOjw2BMB4lEB8Z00NHRwa5dKdTVOvqcq7Q0jaOOSh+V2SMHEg434/LZSE5OHtHHnEREZOSNzOpeIiIiItIvqxXWrOndtmZNZ/toyMjIIC8/h2COk31Ve2hqbhydCx8Cq8WCx+MmJSWF1NQAwWCQjIx0MjMzCYVCXPqt/hdMveQS65gHJQDN4UZcPqsewRERmQQUloiIiIiMsq7ZJTB6s0p6ys3NJZSbQSDbwZ7yXZ2Pj0wApy2C4pLebSUl8NXTxqY/PbW3txNti+LyKiwREZkMFJaIiIiIjDKrFe6/H44/Hn7zm9GbVdJTYWEhGaFUkjNt7Nq9g1hbbPQ7MUhWC3znH3q3fec7ne1jraGpDpfPit/vH/KOPiIiMn4oLBEREREZAwsXwptvdv45FiwWC8XFxaSFkvEGLezYtZ1oLDo2nRmEnrNLxsusEmMMtXXVeFNspKenj3V3RERkGCgsERERETlC2Ww2pk6dSkZOEt4gnYFJNDLW3TogqwV+ci186Ri49trxMaukqbkRY4njS3YRDAbHujsiIjIMNEdQRERE5AjmcDiYPn06Fst2LDSxo+xTphSU4PF4x7prA5ozBx5+aKx78bna+mp8ATvp6elYx+KZKhERGXa6m4uIiIgc4ex2O9OnTycjN4WkDAs7d386YRZ9HWvRaITWaAvuZBsZGRlj3R0RERkmCktEREREBJvNxrRp08jICZCUaWVn2ae0tIbHulvjXm19Dd5kG8FgKk5n/1sbi4jIxKOwRERERESAzwOTzJxUUkI2du0uJdzSPNbdGrcSiQQNjXV4AzYyMzPHujsiIjKMFJaIiIiISDer1crUqVPJzAmSErKza08pTc2NY92tcamuoQan10JSso+kpKSx7o6IiAwjhSUiIiIi0ktXYBLKSyM1x8Hu8p00NjWMdbfGle7tgjWrRERkUtJuOCIiIiLSh8Viobi4GIvFApYa9u7bRTyeS1pQi5gCVNdUYXEk8Kf4tV2wiMgkpLBERERERPplsViYMmUKVqsVq6WaqopyItEIudn5nSHKESrWFmN/bSXpBU7y8/O1XbCIyCSksEREREREBmSxWCgqKsLtdmNz7KW+op4dZVEKcqfgcDjGuntjYl/FHvypdoLpAVJTUwdV++NzK6jYVEPPqMkA2Sek8/Mnsoe1nyIiMnSKwUVERETkoEKhENNnTCOjwAPOGKW7thGJtI51t0ZdQ2Md0fYw/jQ7BQUFg66v2NyE17Th6fHlNW1UbG4agd6KiMhQKSwRERERkUOSkpLC0UcfTVZBEt4g7CjbTkNj3Vh3a9QkEgkqqvaRnOkgJycHl8s16HOccHHnYrDG0OvPeZdokVgRkfFEYYmIiIiIHDK3281RRx1FdkEaqbl2yqt2U1FVjun6qX8Sq9y/D4eng5Sgj1AoNKRzXHlLgBabm64lXywWaLG5+d83B4avoyIictgUloiIiIjIoNhsNkpKSiiYkkt6gYvGlhp27S4lkUiMdddGTEtrmPrGWpIyHBQUFAx5gVu73cK8y3J6tc1fkYPdfuQumCsiMh4pLBERERGRQbNYLOTm5jJtegkZhW4Stla27/iY5vDkW3sj1hajbM9OUrLsZGalk5SUdFjn65pdAppVIiIyXiksEREREZEhS01N5aijjiKzwI8vHXbv28Ge8rJJM8skHo+za/eneIMW0rKSh7So6xfZ7RaWrSmgxell2ZoCzSoRERmHLOZIeMBU+nXMMccA8OGHH45xT0RERCaW9vZ2nE4nbW1tR+z2uV/U0dFBeXk5FfuqaK5pp73VSk4oj5TkwFh3bcg6OjrYUbYdi6uNjDwfRx11lP5/i4gcponyc6h9rDsgIiIiIhOf1WolPz+f1NRUysrKaKhpobxqF41NKeSE8rHbJ9bHTmMMe8p3YWwx0rI9TJs2TUGJiMgRRI/hiIiIiMiw8fv9HH300RRNzSWj0E27JcwnpR9PqC2GOzo62L13J5F4M4FsJ1OnTsXtdo91t0REZBRNrIhfRERERMY9q9VKbm4uqamp7Nq1i4a6MPsqd9PQWE8oMwe32zPWXRxQPB5n155SjC1Ger6bkpJi/H7/WHdLRERGmcISERERERkRXq+Xo48+msrKSsrd+wjXtvLprm0k+ZLJTA/h8XjHuou9RCKt7C7fid3TQVqOh6lTpyooERE5QiksEREREZERY7FYyM7OJjU1lX379lFbU0drYyuluz/B5/aTmRHC5x3bQMIYQ3XtfvbXVJCcbieQ6WPatGl69EZE5AimsERERERERpzb7aa4uJicnBwqKyupqamlpSHKrr2f4nZ6yUwPkeRPHvV+tUZa2Fe5l7iJkl7gJCMrjYKCggm3IK2IiAwv/SsgIiIiIqPG7XZTVFREdnb2Z6FJDS0Nbeyp2IHT7iE1JUhyUmDEd56JxqJU7d9Hc2sTSWl2UlPdFBYWkpaWNqLXFRGRiUFhiYiIiIiMOpfLRWFhIdnZ2VRVVVFdXU1rYzt14Qoq9pfjcXtJTkohOSmAy+kalmt2dHTQ1NxAXUMtrZEWfAEbmUUuMrMyyMnJ0dbAIiLSTWGJiIiIiIwZp9NJfn4+2dnZ1NTU0NDQQHNzmFhLG43hKqqqK3A5XHi9fjxuD16PD5fLjcViOei5jTHEYlHCrc2Ew820tLZgcxm8yTYys10Eg6nk5OTg8Yzf3XlERGRsKCwRERERkTFnt9sJhUKEQiHa2tpoaGj4LDhpJtaaoD3aSGtzPZU1HXTEO19vtztw2B1YrbbPzmIAaI+3E29vp629DasdnG4rTq+VtAw7Xp+b9PR00tLScDqdY/eGRURkXFNYIiIiIiLjitPpJDMzk8zMTOLxOM3NzbS0tNDa2kprayvtbXES7YZEIk5HvJ1EB3RNNLEATh947FZsDhd2hw2/309ycjJJSUl4PJ5DmpUiIiJHNoUlIiIiIjJu2e12UlNTSU1N7W5ra2ujvb29+yuRSACd2xRbLBZsNhtOpxOXy6XZIyIiMiQKS0RERERkQnE6nQpBRERkRFnHugMiIiIiIiIiIuOJwhIRERERERERkR4UloiIiIiIiIiI9KCwRERERERERESkB4UlIiIiIiIiIiI9KCwREREREREREelBYYmIiIiIiIiISA8KS0REREREREREelBYIiIiIiIiIiLSg8ISEREREREREZEeFJaIiIiIiIiIiPSgsEREREREREREpAeFJSIiIiIiIiIiPSgsERERERERERHpQWGJiIiIiIiIiEgPCktERERERERERHpQWCIiIiIiIiIi0oPCEhERERERERGRHhSWiIiIiIiIiIj0oLBERERERERERKQHhSUiIiIiIiIiIj0oLBERERERERER6UFhiYiIiIiIiIhIDwpLRERERERERER6UFgiIiIiIiIiItKDwhIRERERERERkR4UloiIiIiIiIiI9KCwpIdbb70Vi8WCxWLh3//93wd83d69e1m5ciU5OTm43W6mT5/OmjVriEajA9ZEIhFuvPFGpk+fjtvtJicnh8svv5zy8vID9mndunXMnTsXv99PMBjkrLPO4rXXXhvyexQRERERERGRA1NY8plt27Zx++23Y7FYDvi6Tz/9lDlz5rBu3TrS0tJYunQpiUSCW265hcWLFxOLxfrURKNRTjvtNG699VbC4TBLly4lPz+fBx98kDlz5rBjx45+r/WDH/yAlStX8sEHH7B48WLmzp3L888/z8knn8wTTzwxHG9bRERERERERL5AYQlgjOE73/kOgUCAr3/96wd87YoVK6ipqWHVqlW8//77PProo2zbto1ly5axceNG7rjjjj41t912G2+88Qbz58/nk08+4dFHH2XTpk2sXbuW6upqLr/88j41L7zwAnfffTdpaWls3ryZJ554gmeffZaXX34Zm83GypUraWhoGK5vgYiIiIiIiIh8RmEJ8G//9m+8/PLLrF27lkAgMODr3nzzTTZu3EhmZiY///nPu9vtdjv3338/DoeDe+65h3g83n2sra2NX//61wDcd999+P3+7mOrV69m1qxZvPTSS7z99tu9rnXXXXcB8NOf/pRp06Z1t8+fP58rr7yShoYGHnjggcN63yIiIiIiIiLS1xEfllRWVvLjH/+YRYsW8Y1vfOOAr3366acBOOecc3C5XL2OZWVlsXDhQurr63n11Ve72zdu3EhjYyMlJSXMmTOnzznPP/98ADZs2NDdFolEePHFF3sdP1iNiIiIiIiIiAyPIz4sWbVqFZFIhPvvv/+gr928eTMAX/7yl/s93tW+ZcuWw6rZtm0bsViMjIwM8vLyDqlGRERERERERIaHfaw7MJaeeuopHnvsMW6++eZej7oMZPfu3QD9Bhg928vKyka0xufzEQgEqK+vp7m5maSkpAP2+5hjjum3fevWrTgcjgGPi4iISP+MMQDMnj37oIvDi4iIyOdKS0txOBxj3Y2DOmJnloTDYb773e8yffp0rrnmmkOuAfB6vf0e9/l8ADQ3N49ozUB1g9XR0UF7e/uQ60UOVWlpKaWlpWPdDTkCaKzJaNmxYwcul0tBiYw43ddktGisyWhpb28nEomMdTcOasLOLFm2bBkff/zxoGoefvhh5s6dC8B1113Hnj17+J//+Z8+649MNh9++GG/7V0zSgY6LjJcNNZktGisyWjRWJPRorEmo0VjTUbLRHmyYcKGJTt37mTbtm2DqmltbQU6d7W57777+Na3vsVpp512yPVdO9l0neeLWlpaAHo9FjMSNQPViYiIiIiIiMjhm7BhyXvvvTfk2meeeYaOjg7ef/99Tj311F7Htm7dCsDtt9/Ov/3bv3HGGWdw7bXXAlBQUMC7777L3r17+z1vV3thYWF3W0FBQa9jw1HT0tJCQ0MDqampCktEREREREREhtmEDUuGw4ECl61bt7J161aKioq622bPns2f/vQn3nnnnX5rutpnzZrVq6bnsUOpmTFjBi6Xi+rqasrLy8nNzT1ojYiIiIiIiIgMjyNygdebbroJY0y/X5dddhkAjzzyCMYY1q1b11139tlnA7BhwwZisVivc1ZVVfHKK6+QmprKggULutsXLFhASkoKpaWl/YYz69evB+Ccc87pbvN4PN2PBz322GOHVCMiIiIiIiIiw+OIDEuGau7cuSxYsID9+/f32kEnHo/z3e9+l/b2dlatWtVrGySn08lVV10FwPe+973utUYA7rrrLrZs2cIpp5zCcccd1+taq1evBuC2225j+/bt3e2vv/46//Iv/0IgEOCKK64YkfcpIiIiIiIiciSzGGPMWHdiPFmxYgUPPfQQjzzyCN/85jf7HN++fTvz58+ntraWY489li996Uu89dZb7NixgxNPPJEXX3yxz+460WiUU089lU2bNpGdnc3ChQspKytj06ZNZGRk8MYbb1BcXNznWj/4wQ+4++678Xq9fO1rX6OtrY3nn38eYwzr16/n3HPPHalvg4iIiIiIiMgRSzNLBmnatGm8++67rFixgurqah5//HGsVis33HDDgNsQu91u/vrXv3LDDTfg9Xp54oknKCsrY8WKFbzzzjv9BiUAv/rVr3jwwQc5+uijef7553n99ddZvHgxL7/8soISERERERERkRGimSUiIiIiIiIiIj1oZomIiIiIiIiISA8KS0REREREREREelBYIiIiIiIiIiLSg8ISEREREREREZEeFJaIiIiIiIiIiPSgsGQC27JlC1dddRXz5s0jJycHl8tFSkoK8+fP595776W9vX3A2r1797Jy5UpycnJwu91Mnz6dNWvWEI1GB6yJRCLceOONTJ8+HbfbTU5ODpdffjnl5eUH7Oe6deuYO3cufr+fYDDIWWedxWuvvTbk9y2jb+vWrdx555189atfJT09HYfDQSgUYvny5bzyyisHrNVYk8FoaWnhkUce4eqrr+aEE07A5XJhsVi46aabDlqrsSajYahjRia3t99+m5/97GcsX76cvLw8LBYLFovloHVDuZds3LiRs846i2AwiN/vZ+7cuTz88MMHrBnK/VHGn9bWVp544gmuuOIKZsyYgdvtxufzMXv2bG655RbC4fCAtRprMhR33XUXy5cvZ9q0aaSkpOByuSgsLOTSSy/l/fffH7Bu0ow3IxPWvffeawBTWFhoFi1aZP7+7//eLFq0yLjdbgOYU045xcRisT5127dvN+np6QYwM2fONBdeeKEpLi42gFmwYIGJRqN9aiKRiJk3b54BTHZ2trnwwgvN3LlzDWAyMjJMaWlpv338/ve/bwDj8XjM0qVLzZIlS4zdbjc2m808/vjjw/0tkRGSm5trAOP3+83ixYvNhRdeaGbOnGkAY7FYzC9/+ct+6zTWZLDeffddA/T5WrNmzQHrNNZkNAx1zMjkt3Tp0n7vXQcylHvJ+vXrjc1mMxaLxZxyyinmvPPOM4FAwADmhz/8Yb81Q7k/yvj0u9/9rntsHX300eaCCy4wS5YsMUlJSQYwRx11lKmqqupTp7EmQ5WWlmbcbreZO3euWbZsmVm2bJmZPn26AYzD4TAbNmzoUzOZxpvCkgmstLS03w9mlZWV3T/I3nvvvX2OL1iwwABm1apV3W3t7e1m2bJlA/5Qcv311xvAzJ8/3zQ3N3e3r127tjuY+aLnn3/eACYtLc188skn3e2vvfaacTqdJhAImPr6+sG9aRkTixYtMg8//LCJRCK92n/7298awNhsNvPhhx/2qdNYk8H69NNPzRVXXGF++9vfmrffftvccssthxSWaKzJaBjKmJEjw89+9jNzww03mCeffNJUVFQYl8t1wLBkKPeS2tpak5ycbADzxz/+sbu9srLSTJ061QDmr3/9a59rDeX+KOPTunXrzHe+8x3z0Ucf9Wrft2+fmTNnjgHMxRdf3OuYxpocjldffbXP539jjLnvvvsMYLKyskx7e3t3+2QbbwpLJqlHHnnEAGbZsmW92jdt2mQAk5mZ2Sdtq6ysNA6Hw6SmpvYa9LFYzKSkpBjAvPPOO32uNWvWLAOYv/3tb73azzzzTAP0O+tg1apVBjC/+MUvDuNdynhw+umnG8DcdNNNvdo11mQ43HHHHQf9B09jTUbDUMeMHJkOFpYM5V5y5513GsAsXbq0T81///d/G8D8r//1v3q1D+X+KBPTa6+9ZgDjcrl6zSzXWJORUlJSYgCzefPm7rbJNt60Zskk5XA4AHA6nb3an376aQDOOeccXC5Xr2NZWVksXLiQ+vp6Xn311e72jRs30tjYSElJCXPmzOlzrfPPPx+ADRs2dLdFIhFefPHFXscPViMT0+zZswHYt29fr3aNNRktGmsyGoYyZkT6M9R7Sde9rr+as88+G7fbzQsvvNDrWf2h3B9lYur6PBaLxaitrQU01mRkffHnzck43hSWTEL19fWsXbsW6BxgPW3evBmAL3/5y/3WdrVv2bLlsGq2bdtGLBYjIyODvLy8Q6qRiWnHjh0AhEKhXu0aazJaNNZkNAxlzIj0Z6j3kgONQafTycyZM4lGo3zyySeHVHOga8nE0/V5zOFwEAwGAY01GTmPPPII27ZtY9q0aUybNg2YnONNYckksH37dlasWMGll17KkiVLKCgo4K233uLKK6/kG9/4Rq/X7t69G6DfAdyzvaysbERrfD4fgUCA+vp6mpubD/oeZXwqLS3lqaeeAuDrX/96r2MaazJaNNZkNAxlzIj0Zyj3kqamJhobGw9YN1z3OpmY7r77bgDOOOOM7t+0a6zJcPnnf/5nVqxYwQUXXMDMmTO59NJLyc7O5g9/+AM2mw2YnOPNfljVMi5UVVXx0EMP9WpbtWoVt956K1Zr7zysa0sxr9fb77l8Ph9Arw/6I1HTVdfQ0EBzczNJSUkDvk7Gp3g8zooVK4jFYlx00UUcd9xxvY5rrMlo0ViT0TCUMSPSn6HcS3puCTvS9zqZeJ555hkeeOABHA4Ht956a3e7xpoMl+eee47/+Z//6f57YWEhDz/8cK/P/5NxvCksGUPLli3j448/HlTNww8/zNy5c3u1nXTSSRhjSCQS7N69m8cff5ybb76ZP//5z/zlL3+hqKhoGHstE9FwjbWeVq1axauvvkpxcTG/+c1vDreLMkmMxFgTERGR/m3dupVvfvObGGP453/+5+61S0SG0wsvvABAQ0MD77//PrfccgunnHIKt912G9dff/0Y927kKCwZQzt37mTbtm2DqmltbR3wmM1mY8qUKaxevZqioiLOO+88rr766l6L6Pj9/gOep6WlBaDXb0RHomagOhkZwz3Wbr/9du6//36ysrJ47rnnup+N7Ulj7cg03GPtUGisyWgYypgR6c9Q7iVdNV11ycnJB605lGtp3E5s5eXlnHHGGdTX17N69Wq+//3v9zqusSbDLRAIsHDhQp555hnmz5/PDTfcwOmnn87xxx8/Kceb1iwZQ++99x6mc/vmQ/469dRTD+ncy5Ytw+/38+yzz9LW1tbdXlBQAMDevXv7retqLywsHNGalpYWGhoaSE1N1U1zFAznWPvtb3/LT3/6U1JSUnj22WeZOnVqv6/TWDsyjeR9bSAaazIahjJmRPozlHtJcnIyKSkpB6wbrnudTAx1dXWcfvrplJWVsXLlSn7xi1/0eY3GmowUh8PBRRddhDGm+xfzk3G8KSyZpCwWC8FgkHg8Tn19fXd719S8d955p9+6rvZZs2YdVs2MGTNwuVxUV1dTXl5+SDUy/v3Xf/0X3/ve9/B6vTz99NP83d/93YCv1ViT0aKxJqNhKGNGpD9DvZccaAy2t7fzwQcf4Ha7mT59+iHVHOhaMr6Fw2HOPPNMPvroI5YvX87vfvc7LBZLn9dprMlISk9PB6C6uhqYnONNYckktWPHDvbs2UNycnL3QIbPtxLesGEDsVisV01VVRWvvPIKqampLFiwoLt9wYIFpKSkUFpaynvvvdfnWuvXrwc697nu4vF4OO200wB47LHHDqlGxrdnnnmGSy+9FLvdzuOPP95rjPRHY01Gi8aajIahjBmR/gz1XtJ1r+s63tNTTz1FNBpl8eLFuN3uPjWDuT/K+BaLxVi6dClvvvkmS5Ys6bUbyRdprMlIeumllwAoKSkBJul4MzJh3XPPPaaioqJP+9atW80JJ5xgAHPVVVf1Ob5gwQIDmO9///vdbe3t7Wb58uUGMGvWrOlTc/311xvAnHjiiSYcDne3r1271gDmlFNO6VPz/PPPG8CkpaWZTz75pLv9tddeMy6XywQCAVNfXz+o9yxj49VXXzUej8fY7Xbz+OOPH3KdxpocrjvuuGPAsdKTxpqMhqGMGTkyuVwuc6CP2UO5l9TW1prk5GQDmD/+8Y/d7VVVVWbq1KkGMH/961/7XGso90cZn+LxuFm2bJkBzMKFC01LS8tBazTWZKheffVV8+c//9kkEole7W1tbeaee+4xVqvVeDwes3v37u5jk228KSyZwAoLC43VajVz5swxF1xwgTn//PPN8ccfb6xWqwHMySefbJqbm/vUffLJJyYtLc0A5thjjzUXXXSRKS4u7v4AGI1G+9REIpHuACY7O9tceOGF3X/PyMgwpaWl/fbx+9//vgGM1+s1S5cuNWeeeaax2+3GZrMN6oduGVuBQMAAZsqUKeayyy7r9+t3v/tdnzqNNRmKc88915xwwgnmhBNOMPn5+QYwubm53W3nnntunxqNNRkNQx0zMvk99dRT3feoE044wVgsFgP0anvqqad61QzlXrJ+/XpjtVqNxWIxX/3qV83555/f/W/06tWr+60Zyv1Rxqdf/epXBjCAWbZs2YCfyaqrq3vVaazJUDz44IMGMOnp6WbJkiXmkksuMaeffrrJzs42gHG73ebRRx/tUzeZxpvCkgns3//9380ll1xipk+fbpKTk43D4TBZWVlmyZIlZt26dX1SwJ52795tVqxYYUKhkHE6nWbq1KnmhhtuMJFIZMCa1tZWc8MNN5iSkhLjdDpNKBQyK1asMHv27DlgPx988EFz3HHHGa/XawKBgDnjjDPMxo0bh/y+ZfR1/cN8oK/LLrus31qNNRmswsLCA461wsLCfus01mQ0DHXMyOTW9UPFgb4efPDBfusGey959dVXzRlnnGECgYDxer3mK1/5ilm3bt0Ba4Zyf5TxZ82aNYf0mWznzp19ajXWZLB27NhhrrvuOrNgwQKTnZ1tHA6H8fl85phjjjFXX3212b59+4C1k2W8WYwxZqBHdEREREREREREjjRa4FVEREREREREpAeFJSIiIiIiIiIiPSgsERERERERERHpQWGJiIiIiIiIiEgPCktERERERERERHpQWCIiIiIiIiIi0oPCEhERERERERGRHhSWiIiIiIiIiIj0oLBERERERERERKQHhSUiIiIiIiIiIj0oLBERERERERER6UFhiYiIiIwrFovloF8rVqwY624OSkNDA2lpaVxwwQUjep13330Xi8XCz3/+8xG9joiIyGRnMcaYse6EiIiISBeLxQLAZZddNuBrTjrpJL797W+PSn/WrVvHypUrWbNmDTfddNOQzvGP//iPrF27li1btjBz5szh7eAXLF26lJdffpnS0lKCweCIXktERGSyso91B0RERET6s27durHuwrCoqKjg3nvv5ZxzzhnxoATgJz/5CU8++SR33nknd95554hfT0REZDLSYzgiIiIiI+j3v/89sViMSy+9dFSuN2/ePKZOncrvf/972traRuWaIiIik43CEhEREZnwXnnlFa666ipmzZpFamoqHo+Ho446imuvvZaGhoZ+a1577TXOPfdcCgsLcblchEIh5s6dy7XXXks4HAbg1FNPZeXKlQDcfPPNvdZNOZSZL8YYHnjgAZKSkjj77LP7HL/pppu6z/X2229z5plnEggECAaDXHjhhezduxeAlpYWfvzjH1NUVITb7WbmzJmsX79+wOtefPHF1NTU8Pjjjx+0jyIiItKXwhIRERGZ8P7xH/+RBx54AI/Hw6JFi1i0aBFNTU3ceeednHTSSd3hR5cNGzawcOFCnnzySbKzs1m+fDlz5syhrq6OO++8k5qaGgDOOOMMFixYAMDs2bO57LLLur+mTp160H599NFH7Ny5k3nz5uF2uwd83aZNm1iwYAHV1dUsWbKEtLQ0HnvsMRYtWkRjYyNf/epXeeihhzj++OOZP38+H330ERdeeCHPPfdcv+c79dRTAXj66acP5dsnIiIiX6A1S0RERGTCW7NmDSeeeCIpKSndbbFYjFWrVvGv//qv3HXXXdx4443dx37xi1/Q0dHB+vXrOe+883qd66233iItLQ2Aa6+9llAoxMaNGzn33HMHvcDrK6+8AsDxxx9/wNf99re/5f777+fKK68EoL29nbPOOosXXniBE088kVAoxI4dO/D5fAA88MADfPvb3+af/umfWLJkSZ/zfeUrX8FqtfLSSy8Nqr8iIiLSSTNLREREZFw60NbBTzzxRK/Xnnnmmb2CEgCXy8WvfvUr7HY7f/rTn3odq66uBmDx4sV9rnv88ceTlJQ0LO9hy5YtAMyYMeOArzvppJO6gxIAh8PB1VdfDcDWrVu5//77u4MSgBUrVpCens7rr79Oe3t7n/MlJyeTnZ3N7t27qa+vH463IiIickTRzBIREREZlw60dXBBQUGftvLycjZs2MDWrVtpamqio6MDAKfTyfbt23u99rjjjuPjjz/mW9/6FjfccAPHHXccVuvw/w5p//79AKSmph7wdaeffnqftuLiYgCKioqYPn16r2M2m43CwkLefvttampqyM7O7lMfDAYpLy+nurr6oNcXERGR3hSWiIiIyLg0mK2D77rrLq699tp+Z1n055/+6Z94//332bBhAxs2bCA1NZWTTjqJr3/963zzm9884Poig9HY2Ahw0Jkqubm5fdr8fv+Ax3oej8Vi/R5PTk4GGHCBWxERERmYHsMRERGRCe2NN97ghz/8IV6vl3Xr1rFr1y6i0SjGGIwx/c66yM/P529/+xvPPfccV199Nfn5+WzYsIF/+Id/YNasWdTW1g5L37oeDWpubj7g6w40q2WoM166gppAIDCkehERkSOZwhIRERGZ0Lq2x7399tu57LLLurcCBohEIlRWVvZbZ7fbOf3007nnnnvYvHkzu3bt4rTTTmP79u3ceeedw9K3zMxMAOrq6oblfIPRtVZJRkbGqF9bRERkolNYIiIiIhNaVyiQl5fX59hjjz2GMeaQzlNYWMg111wDwAcffNDd7nQ6AYjH44Pu2+zZswHYtm3boGsPR1NTE/v27aOgoEDrlYiIiAyBwhIRERGZ0LoWP33ggQd6rVny0UcfdYcfX/TLX/6y3xknzzzzDND5mE6XnJwcYGiBx8KFC4HO7YhH01tvvYUxhlNOOWVUrysiIjJZaIFXERERGZdWrFgx4LGCggJuueUWAFauXMnatWvZsGEDM2bM4Pjjj6euro6XXnqJc889lzfffJOysrJe9TfffDM/+tGPmD17NtOmTcMYw+bNm/nkk08IBoP86Ec/6n7tvHnzyMzMZP369Zx66qkUFxdjtVq5/PLLOfHEEw/4Ho4++mimTJnCpk2biEajw7Zw7MH8v//3/wA4++yzR+V6IiIik43CEhERERmXHnrooQGPzZ49uzssSUtL46233uKaa67hpZde4sknn2TKlCnceuut/OhHP6KkpKRP/b333suzzz7L22+/zZ///GegczbJ6tWrWb16da8daNxuN08//TTXXXcdb775Ji+//DLGGE466aSDhiUWi4Vvf/vbXH/99WzYsIELLrhgKN+KQfvDH/5Aeno6y5YtG5XriYiITDYWc6gP8oqIiIjIoFVWVjJlyhQWL17Mhg0bRvx6r7/+OieeeCI//vGPh22hWhERkSON1iwRERERGUGhUIirr76ap59+mvfff3/Er/ezn/2MQCAw4HotIiIicnAKS0RERERG2HXXXUdqaio333zziF7n3Xff5cknn+QnP/kJwWBwRK8lIiIymekxHBERERERERGRHjSzRERERERERESkB4UlIiIiIiIiIiI9KCwREREREREREelBYYmIiIiIiIiISA8KS0REREREREREelBYIiIiIiIiIiLSg8ISEREREREREZEeFJaIiIiIiIiIiPSgsEREREREREREpAeFJSIiIiIiIiIiPSgsERERERERERHpQWGJiIiIiIiIiEgPCktERERERERERHpQWCIiIiIiIiIi0oPCEhERERERERGRHv4/+wMqnovq8QAAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "original_results.compare_ellipses(mrs_results, ylim=(-4000, 3000))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "dev-py3-12", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/reference/classes/MultivariateRejectionSampler.rst b/docs/reference/classes/MultivariateRejectionSampler.rst new file mode 100644 index 000000000..8f70b8a2d --- /dev/null +++ b/docs/reference/classes/MultivariateRejectionSampler.rst @@ -0,0 +1,5 @@ +MultivariateRejectionSampler Class +---------------------------------- + +.. autoclass:: rocketpy.MultivariateRejectionSampler + :members: diff --git a/docs/reference/index.rst b/docs/reference/index.rst index c0868c0c5..de3b36ac8 100644 --- a/docs/reference/index.rst +++ b/docs/reference/index.rst @@ -20,6 +20,7 @@ This reference manual details functions, modules, methods and attributes include classes/EnvironmentAnalysis Monte Carlo Analysis Sensitivity Analysis + Multivariate Rejection Sampler .. toctree:: :maxdepth: 2 diff --git a/docs/user/index.rst b/docs/user/index.rst index e734abe5d..f23eae25a 100644 --- a/docs/user/index.rst +++ b/docs/user/index.rst @@ -35,7 +35,8 @@ RocketPy's User Guide ../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 - sensitivity.rst + Sensitivity Analysis + Multivariate Rejection Sampler .. toctree:: :maxdepth: 2 diff --git a/docs/user/mrs.rst b/docs/user/mrs.rst new file mode 100644 index 000000000..8c6b384ef --- /dev/null +++ b/docs/user/mrs.rst @@ -0,0 +1,218 @@ +.. _MRS: + +Multivariate Rejection Sampling +=============================== + +Multivariate Rejection Sampling allows you to quickly subsample the results of a +previous monte carlo simulation to obtain the results when one or more variables +have a different probability distribution without having to re-run the simulation. + +We will show you how to use the :class:`rocketpy.MultivariateRejectionSampler` +class to possibly save time. It is highly recommended that you read about the monte +carlo simulations. + +Motivation +---------- + +As discussed in :ref:`sensitivity-practical`, there are several sources of +uncertainty that can affect the flight of a rocket, notably the weather and +the measurements errors in design parameters. Still, it is desirable that the flight +accomplishes its goal, for instance reaching a certain apogee, as well as staying under +some safety restrictions, for instance that the landing point is outside of a given +area. + +Monte Carlo simulation is a technique that allows us to quantify the uncertainty and +give objective answers to those type of questions in terms of probabilities and +statistics. It relies on running several simulations under different conditions +specified by probability distributions provided by the user. Hence, depending on the +inputs and number of samples, it might take a while to run those monte carlo +simulations. + +Now, imagine that you ran and saved the monte carlo simulations. Later, you need new a +monte carlo simulation but with new probability distributions that are somewhat close +to the original simulation. The first straightforward option is to just re-run the +monte carlo with the new arguments, but this might be time consuming. The second option +is to use a sub-sampler that leverages the existing simulation to produce a new sample +that conforms to the new probability distributions. The second option avoids completely +the necessity of re-running the simulations and is, therefore, much faster. + +The Multivariate Rejection Sampler, or just MRS, is an algorithm that sub-samples the +original results based on weights proportional to the ratio of the new and old +probability distributions that have changed. The final result has a smaller sample size, +but their distribution matches the one newly specified, and without having to re-run the +the simulation. + +The time efficiency of the MRS is specially interesting in two scenarios: quick testing +and tight schedules. Imagine you have an initial design and ran a huge robust monte +carlo simulation but you are also interested in minor variations of the original +design. Instead of having to run an expensive monte carlo for each of theses variations, +you can just re-sample the original accordingly. For tight schedules, it is not +unheard of cases where last minute changes have to be made to simulations. The MRS might +then allow you to quickly have monte carlo results for the new configuration when a +full simulation might just take more time than available. + +Importing and using the MRS +--------------------------- + +We now show how to actually use the :class:`rocketpy.MultivariateRejectionSampler` +class. We begin by importing it along with other utilities + +.. jupyter-execute:: + + from rocketpy import MultivariateRejectionSampler, MonteCarlo + import numpy as np + from scipy.stats import norm + +The reference monte carlo simulation used is the one from the +"monte_carlo_class_usage.ipynb" notebook with a 1000 samples. An +MultivariateRejectionSampler object is initialized by giving two file paths, one +for the prefix of the original monte carlo simulation, and one for the output of the +sub-samples. The code below defines these strings and initializes the MRS object + + +.. jupyter-execute:: + + monte_carlo_filepath = ( + "notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example" + ) + mrs_filepath = "notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/mrs" + mrs = MultivariateRejectionSampler( + monte_carlo_filepath=monte_carlo_filepath, + mrs_filepath=mrs_filepath, + ) + +Running a monte carlo simulation requires you to specifies the distribution of +all parameters that have uncertainty. The MRS, however, only needs the previous and new +distributions of the parameters whose distribution changed. All other random parameters +in the original monte carlo simulation retain their original distribution. + +In the original simulation, the mass of the rocket had a normal distribution with mean +:math:`15.426` and standard deviation of :math:`0.5`. Assume that the mean of this +distribution changed to :math:`15` and the standard deviation remained the same. To +run the mrs, we create a dictionary whose keys are the name of the parameter and the +values is a 2-tuple: the first entry contains the pdf of the old distribution, and the +second entry contains the pdf of the new distribution. The code below shows how to +create these distributions and the dictionary + +.. jupyter-execute:: + + old_mass_pdf = norm(15.426, 0.5).pdf + new_mass_pdf = norm(15, 0.5).pdf + distribution_dict = { + "mass": (old_mass_pdf, new_mass_pdf), + } + +Finally, we execute the `sample` method, as shown below + +.. jupyter-execute:: + + np.random.seed(seed=42) + mrs.sample(distribution_dict=distribution_dict) + +.. note:: + We set the numpy's seed just for reproduction. When actually using the MRS, + skip setting the seed! + +And that is it! The MRS has saved a file that has the same structure as the results of +a monte carlo simulation but now the mass has been sampled from the newly stated +distribution. To see that it is actually the case, let us import the results of the MRS +and check the mean and standard deviation of the mass. First, we import in the same +way we import the results from a monte carlo simulation + + +.. jupyter-execute:: + + mrs_results = MonteCarlo(mrs_filepath, None, None, None) + mrs_results.import_results() + +Notice that the sample size is now smaller than 1000 samples. Albeit the sample size is +now random, we can check the expected number of samples by printing the +`expected_sample_size` attribute + +.. jupyter-execute:: + + print(mrs.expected_sample_size) + +Now we check the mean and standard deviation of the mass. + +.. jupyter-execute:: + + mrs_mass_list = [] + for single_input_dict in mrs_results.inputs_log: + mrs_mass_list.append(single_input_dict["mass"]) + + print(f"MRS mass mean after resample: {np.mean(mrs_mass_list)}") + print(f"MRS mass std after resample: {np.std(mrs_mass_list)}") + +They are very close to the specified values. + +Comparing Monte Carlo Results +----------------------------- + +Alright, now that we have the results for this new configuration, how does it compare +to the original one? Our rocket has, on average, decreased its mass in about 400 grams +while maintaining all other aspects. How do you think, for example, that the distribution +of the apogee has changed? Let us find out. + +First, we import the original results + +.. jupyter-execute:: + + original_results = MonteCarlo(monte_carlo_filepath, None, None, None) + +Prints +^^^^^^ + +We use the `compare_info` method from the `MonteCarlo` class, passing along +the MRS monte carlo object as argument, to print a summary of the comparison + +.. jupyter-execute:: + + original_results.compare_info(mrs_results) + +This summary resemble closely the printed information from one monte carlo simulation +alone, with the difference now that it has a new column, "Source", that alternates the +results between the original and the other simulation. To answer the question proposed +earlier, compare the mean and median of the apogee between both cases. Is it what you +expected? + + +Histogram and boxplots +^^^^^^^^^^^^^^^^^^^^^^ + +Besides printed comparison, we can also provide a comparison for the distributions in +the form of histograms and boxplots, using the `compare_plots` method + + +.. jupyter-execute:: + + original_results.compare_plots(mrs_results) + +Note that the histograms displays three colors. Two are from the sources, as depicted +in the legend, the third comes from the overlap of the two. + +Ellipses +^^^^^^^^ + +Finally, we can compare the ellipses for the apogees and landing points using the +`compare_ellipses` method + +.. jupyter-execute:: + + original_results.compare_ellipses(mrs_results, ylim=(-4000, 3000)) + +Note we can pass along parameters used in the usual `ellipses` method of the +`MonteCarlo` class, in this case the `ylim` argument to expand the y-axis limits. + +Time Comparison +--------------- + +Is the MRS really much faster than just re-running a Monte Carlo simulation? +Let us take a look at some numbers. + +Important Remarks +----------------- + +Talk about the sample size reduction. If the user needs a really robust +monte carlo simulation with a lot of samples and there is a substantial reduction, +then he might have to re-run the simulation. From 8a5f75ec8b211e73902790db51c4106e8aec20c4 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Mon, 24 Feb 2025 16:00:23 -0300 Subject: [PATCH 07/18] MNT: adding pylint flags to skip checks --- rocketpy/simulation/multivariate_rejection_sampler.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index 2d23e3b1f..dd9264405 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -69,6 +69,7 @@ def __init__( self.__setup_input() self.__load_output() + # pylint: disable=consider-using-with def __setup_input(self): """Loads input information from monte carlo in a SampleInformation object @@ -108,6 +109,7 @@ def __setup_input(self): finally: input_file.close() + # pylint: disable=consider-using-with def __load_output(self): """Loads output information from monte carlo in a SampleInformation object. @@ -158,6 +160,7 @@ def __validate_distribution_dict(self, distribution_dict): "not found in input file!" ) + # pylint: disable=consider-using-with def sample(self, distribution_dict): """Performs rejection sampling and saves data From 232aede333303efa6c3c33d6bd4af8e27ba6957c Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Mon, 24 Feb 2025 20:18:10 -0300 Subject: [PATCH 08/18] DOC: completing missing sections in mrs.rst --- docs/user/mrs.rst | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/docs/user/mrs.rst b/docs/user/mrs.rst index 8c6b384ef..0989f96e2 100644 --- a/docs/user/mrs.rst +++ b/docs/user/mrs.rst @@ -18,8 +18,7 @@ As discussed in :ref:`sensitivity-practical`, there are several sources of uncertainty that can affect the flight of a rocket, notably the weather and the measurements errors in design parameters. Still, it is desirable that the flight accomplishes its goal, for instance reaching a certain apogee, as well as staying under -some safety restrictions, for instance that the landing point is outside of a given -area. +some safety restrictions, such as the landing point is outside of a given area. Monte Carlo simulation is a technique that allows us to quantify the uncertainty and give objective answers to those type of questions in terms of probabilities and @@ -31,15 +30,15 @@ simulations. Now, imagine that you ran and saved the monte carlo simulations. Later, you need new a monte carlo simulation but with new probability distributions that are somewhat close to the original simulation. The first straightforward option is to just re-run the -monte carlo with the new arguments, but this might be time consuming. The second option +monte carlo with the new arguments, but this might be time consuming. A second option is to use a sub-sampler that leverages the existing simulation to produce a new sample -that conforms to the new probability distributions. The second option avoids completely +that conforms to the new probability distributions. The latter avoids completely the necessity of re-running the simulations and is, therefore, much faster. The Multivariate Rejection Sampler, or just MRS, is an algorithm that sub-samples the original results based on weights proportional to the ratio of the new and old probability distributions that have changed. The final result has a smaller sample size, -but their distribution matches the one newly specified, and without having to re-run the +but their distribution matches the one newly specified without having to re-run the the simulation. The time efficiency of the MRS is specially interesting in two scenarios: quick testing @@ -208,11 +207,24 @@ Time Comparison --------------- Is the MRS really much faster than just re-running a Monte Carlo simulation? -Let us take a look at some numbers. - -Important Remarks +Let us take a look at some numbers. All tests ran in a Dell G15 5530, with 16 +13th Gen Intel® Core™ i5-13450HX CPUs, 16Gb RAM, running ubuntu 22.04. Each function +ran 10 times, and no parallelization was used. + +To run the original monte carlo simulation with 1000 samples it took, +on average, about 644 seconds, that is, 10 minutes and 44 seconds. For the MRS described +here, it took, on average, 0.15 seconds, with an expected sample size of 117. To re-run +the monte carlo simulations with 117 samples it took, on average, 76.3 seconds. Hence, +the MRS was, on average, (76.3 / 0.15) ~ 500 times faster than re-running the monte +carlo simulations with the same sample size provided by the MRS. + +A word of caution ----------------- -Talk about the sample size reduction. If the user needs a really robust -monte carlo simulation with a lot of samples and there is a substantial reduction, -then he might have to re-run the simulation. +Albeit the MRS provides results way faster than running the simulation again, it +might reduce the sample size drastically. If several variables undergo +changes in their distribution and the more discrepant these are from the original +ones, the more pronounced will be this sample size reduction. If you need the monte +carlo simulations to have the same sample size as before or if the expected sample size +from the MRS is too low for you current application, then it might be better suited to +re-run the simulations. \ No newline at end of file From b7e6be123ef528d92b330712c9e4c383d841e560 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Wed, 26 Feb 2025 17:51:43 -0300 Subject: [PATCH 09/18] DOC: add changelog and apply sugestions in MRS class --- CHANGELOG.md | 1 + .../multivariate_rejection_sampler.py | 34 ++++++++++++------- 2 files changed, 22 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 15cb0f7dd..91ce0841a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -33,6 +33,7 @@ Attention: The newest changes should be on top --> ### Added - DOC: ASTRA Flight Example [#770](https://github.com/RocketPy-Team/RocketPy/pull/770)) +- ENH: Implement Multivariate Rejection Sampling (MRS) [#738] (https://github.com/RocketPy-Team/RocketPy/pull/738) ### Changed diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index dd9264405..dcf9f94a6 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -10,25 +10,29 @@ import json from dataclasses import dataclass +from pathlib import Path from random import random from rocketpy._encoders import RocketPyEncoder @dataclass +# pylint: disable=unsupported-binary-operation class SampleInformation: """Sample information used in the MRS""" - inputs_json: dict = None - outputs_json: dict = None - probability_ratio: float = None - acceptance_probability: float = None + inputs_json: dict | None = None + outputs_json: dict | None = None + probability_ratio: float | None = None + acceptance_probability: float | None = None class MultivariateRejectionSampler: """Class that performs Multivariate Rejection Sampling (MRS) from MonteCarlo - results. The class currently assumes that all input variables are independent - when performing the + results. + + The class currently assumes that all input variables are sampled independently + when performing the Monte Carlo Simulation. Attributes ---------- @@ -55,8 +59,8 @@ def __init__( ------- None """ - self.monte_carlo_filepath = monte_carlo_filepath - self.mrs_filepath = mrs_filepath + self.monte_carlo_filepath = Path(monte_carlo_filepath) + self.mrs_filepath = Path(mrs_filepath) self.distribution_dict = None self.original_sample_size = 0 self.sup_ratio = 1 @@ -74,7 +78,7 @@ def __setup_input(self): """Loads input information from monte carlo in a SampleInformation object """ - input_filename = f"{self.monte_carlo_filepath}.inputs.txt" + input_filename = self.monte_carlo_filepath.with_suffix(".inputs.txt") try: input_file = open(input_filename, "r+", encoding="utf-8") @@ -114,7 +118,7 @@ def __load_output(self): """Loads output information from monte carlo in a SampleInformation object. """ - output_filename = f"{self.monte_carlo_filepath}.outputs.txt" + output_filename = self.monte_carlo_filepath.with_suffix(".outputs.txt") sample_size_output = 0 # sanity check try: @@ -180,11 +184,15 @@ def sample(self, distribution_dict): self.__validate_distribution_dict(distribution_dict) - mrs_input_file = open(f"{self.mrs_filepath}.inputs.txt", "w+", encoding="utf-8") + mrs_input_file = open( + self.mrs_filepath.with_suffix(".inputs.txt"), "w+", encoding="utf-8" + ) mrs_output_file = open( - f"{self.mrs_filepath}.outputs.txt", "w+", encoding="utf-8" + self.mrs_filepath.with_suffix(".outputs.txt"), "w+", encoding="utf-8" + ) + mrs_error_file = open( + self.mrs_filepath.with_suffix(".errors.txt"), "w+", encoding="utf-8" ) - mrs_error_file = open(f"{self.mrs_filepath}.errors.txt", "w+", encoding="utf-8") self.__setup_probabilities(distribution_dict) From 53e69b4fba20d2cd92bc36ee4709157a057516b7 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Wed, 26 Feb 2025 17:58:55 -0300 Subject: [PATCH 10/18] DOC: apply suggestions to the MRS.rst --- docs/user/mrs.rst | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/user/mrs.rst b/docs/user/mrs.rst index 0989f96e2..e37050523 100644 --- a/docs/user/mrs.rst +++ b/docs/user/mrs.rst @@ -8,8 +8,8 @@ previous monte carlo simulation to obtain the results when one or more variables have a different probability distribution without having to re-run the simulation. We will show you how to use the :class:`rocketpy.MultivariateRejectionSampler` -class to possibly save time. It is highly recommended that you read about the monte -carlo simulations. +class to possibly save time. It is highly recommended that you read about the Monte +Carlo simulations. Motivation ---------- @@ -18,21 +18,21 @@ As discussed in :ref:`sensitivity-practical`, there are several sources of uncertainty that can affect the flight of a rocket, notably the weather and the measurements errors in design parameters. Still, it is desirable that the flight accomplishes its goal, for instance reaching a certain apogee, as well as staying under -some safety restrictions, such as the landing point is outside of a given area. +some safety restrictions, such as ensuring that the landing point is outside +of a given area. Monte Carlo simulation is a technique that allows us to quantify the uncertainty and -give objective answers to those type of questions in terms of probabilities and +give objective answers to those types of questions in terms of probabilities and statistics. It relies on running several simulations under different conditions specified by probability distributions provided by the user. Hence, depending on the -inputs and number of samples, it might take a while to run those monte carlo -simulations. +inputs and number of samples, running these Monte Carlo simulations might take a while. -Now, imagine that you ran and saved the monte carlo simulations. Later, you need new a -monte carlo simulation but with new probability distributions that are somewhat close +Now, imagine that you ran and saved the Monte Carlo simulations. Later, you need new a +Monte Carlo simulation with new probability distributions that are somewhat close to the original simulation. The first straightforward option is to just re-run the monte carlo with the new arguments, but this might be time consuming. A second option is to use a sub-sampler that leverages the existing simulation to produce a new sample -that conforms to the new probability distributions. The latter avoids completely +that conforms to the new probability distributions. The latter completely avoids the necessity of re-running the simulations and is, therefore, much faster. The Multivariate Rejection Sampler, or just MRS, is an algorithm that sub-samples the From 7637c66203ec5afe652c02091be7c680e18651ff Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Thu, 27 Feb 2025 13:52:04 -0300 Subject: [PATCH 11/18] MNT: use Union instead of | for type hinting since we have to support python3.9 --- docs/user/mrs.rst | 22 +++++++++---------- .../multivariate_rejection_sampler.py | 10 +++++---- 2 files changed, 17 insertions(+), 15 deletions(-) diff --git a/docs/user/mrs.rst b/docs/user/mrs.rst index e37050523..59f25dd3c 100644 --- a/docs/user/mrs.rst +++ b/docs/user/mrs.rst @@ -4,11 +4,11 @@ Multivariate Rejection Sampling =============================== Multivariate Rejection Sampling allows you to quickly subsample the results of a -previous monte carlo simulation to obtain the results when one or more variables +previous Monte Carlo simulation to obtain the results when one or more variables have a different probability distribution without having to re-run the simulation. We will show you how to use the :class:`rocketpy.MultivariateRejectionSampler` -class to possibly save time. It is highly recommended that you read about the Monte +class to possibly save time. It is highly recommended that you read about Monte Carlo simulations. Motivation @@ -28,7 +28,7 @@ specified by probability distributions provided by the user. Hence, depending on inputs and number of samples, running these Monte Carlo simulations might take a while. Now, imagine that you ran and saved the Monte Carlo simulations. Later, you need new a -Monte Carlo simulation with new probability distributions that are somewhat close +Monte Carlo simulation with different probability distributions that are somewhat close to the original simulation. The first straightforward option is to just re-run the monte carlo with the new arguments, but this might be time consuming. A second option is to use a sub-sampler that leverages the existing simulation to produce a new sample @@ -38,13 +38,13 @@ the necessity of re-running the simulations and is, therefore, much faster. The Multivariate Rejection Sampler, or just MRS, is an algorithm that sub-samples the original results based on weights proportional to the ratio of the new and old probability distributions that have changed. The final result has a smaller sample size, -but their distribution matches the one newly specified without having to re-run the +but their distribution matches the one newly specified without having to re-run the simulation. -The time efficiency of the MRS is specially interesting in two scenarios: quick testing +The time efficiency of the MRS is especially interesting in two scenarios: quick testing and tight schedules. Imagine you have an initial design and ran a huge robust monte carlo simulation but you are also interested in minor variations of the original -design. Instead of having to run an expensive monte carlo for each of theses variations, +design. Instead of having to run an expensive monte carlo for each of these variations, you can just re-sample the original accordingly. For tight schedules, it is not unheard of cases where last minute changes have to be made to simulations. The MRS might then allow you to quickly have monte carlo results for the new configuration when a @@ -63,7 +63,7 @@ class. We begin by importing it along with other utilities from scipy.stats import norm The reference monte carlo simulation used is the one from the -"monte_carlo_class_usage.ipynb" notebook with a 1000 samples. An +"monte_carlo_class_usage.ipynb" notebook with a 1000 samples. A MultivariateRejectionSampler object is initialized by giving two file paths, one for the prefix of the original monte carlo simulation, and one for the output of the sub-samples. The code below defines these strings and initializes the MRS object @@ -80,7 +80,7 @@ sub-samples. The code below defines these strings and initializes the MRS object mrs_filepath=mrs_filepath, ) -Running a monte carlo simulation requires you to specifies the distribution of +Running a monte carlo simulation requires you to specify the distribution of all parameters that have uncertainty. The MRS, however, only needs the previous and new distributions of the parameters whose distribution changed. All other random parameters in the original monte carlo simulation retain their original distribution. @@ -89,7 +89,7 @@ In the original simulation, the mass of the rocket had a normal distribution wit :math:`15.426` and standard deviation of :math:`0.5`. Assume that the mean of this distribution changed to :math:`15` and the standard deviation remained the same. To run the mrs, we create a dictionary whose keys are the name of the parameter and the -values is a 2-tuple: the first entry contains the pdf of the old distribution, and the +value is a 2-tuple: the first entry contains the pdf of the old distribution, and the second entry contains the pdf of the new distribution. The code below shows how to create these distributions and the dictionary @@ -208,7 +208,7 @@ Time Comparison Is the MRS really much faster than just re-running a Monte Carlo simulation? Let us take a look at some numbers. All tests ran in a Dell G15 5530, with 16 -13th Gen Intel® Core™ i5-13450HX CPUs, 16Gb RAM, running ubuntu 22.04. Each function +13th Gen Intel® Core™ i5-13450HX CPUs, 16GB RAM, running Ubuntu 22.04. Each function ran 10 times, and no parallelization was used. To run the original monte carlo simulation with 1000 samples it took, @@ -226,5 +226,5 @@ might reduce the sample size drastically. If several variables undergo changes in their distribution and the more discrepant these are from the original ones, the more pronounced will be this sample size reduction. If you need the monte carlo simulations to have the same sample size as before or if the expected sample size -from the MRS is too low for you current application, then it might be better suited to +from the MRS is too low for you current application, then it might be better to re-run the simulations. \ No newline at end of file diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index dcf9f94a6..cb0b802ed 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -12,19 +12,21 @@ from dataclasses import dataclass from pathlib import Path from random import random +from typing import Union from rocketpy._encoders import RocketPyEncoder @dataclass +# TODO: replace Union by "|" once python 3.9 is no longer supported # pylint: disable=unsupported-binary-operation class SampleInformation: """Sample information used in the MRS""" - inputs_json: dict | None = None - outputs_json: dict | None = None - probability_ratio: float | None = None - acceptance_probability: float | None = None + inputs_json: Union[dict, None] = None + outputs_json: Union[dict, None] = None + probability_ratio: Union[float, None] = None + acceptance_probability: Union[float, None] = None class MultivariateRejectionSampler: From f565acb75ec051dac2084676ac4fd64765b80790 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Thu, 27 Feb 2025 15:54:21 -0300 Subject: [PATCH 12/18] TST: adding unit and integration tests to MRS --- .vscode/settings.json | 3 + .../test_multivariate_rejection_sampler.py | 33 +++++ .../test_multivariate_rejection_sampler.py | 125 ++++++++++++++++++ 3 files changed, 161 insertions(+) create mode 100644 tests/integration/test_multivariate_rejection_sampler.py create mode 100644 tests/unit/test_multivariate_rejection_sampler.py diff --git a/.vscode/settings.json b/.vscode/settings.json index 5c973672e..d957d9888 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -50,6 +50,8 @@ "bijective", "bmatrix", "boldsymbol", + "boxplot", + "boxplots", "brentq", "Bressan", "bysource", @@ -275,6 +277,7 @@ "savgol", "SBMT", "scilimits", + "scipy", "searchsorted", "seblm", "seealso", diff --git a/tests/integration/test_multivariate_rejection_sampler.py b/tests/integration/test_multivariate_rejection_sampler.py new file mode 100644 index 000000000..eac05e520 --- /dev/null +++ b/tests/integration/test_multivariate_rejection_sampler.py @@ -0,0 +1,33 @@ +# pylint: disable=unused-argument +import os + +import pytest +from scipy.stats import norm + +from rocketpy import MultivariateRejectionSampler + + +@pytest.mark.parametrize( + "monte_carlo_filepath, distribution_dict", + [ + ( + "tests/fixtures/monte_carlo/example", + {"mass": (norm(15.5, 1).pdf, norm(15.2, 1).pdf)}, + ), + ], +) +def test_mrs_sample_integration(monte_carlo_filepath, distribution_dict): + """Tests the set_inputs_log method of the MonteCarlo class. + + Parameters + ---------- + monte_carlo_calisto : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + mrs_filepath = "mrs" + mrs = MultivariateRejectionSampler(monte_carlo_filepath, mrs_filepath) + mrs.sample(distribution_dict) + + os.remove("mrs.inputs.txt") + os.remove("mrs.outputs.txt") + os.remove("mrs.errors.txt") diff --git a/tests/unit/test_multivariate_rejection_sampler.py b/tests/unit/test_multivariate_rejection_sampler.py new file mode 100644 index 000000000..d1e3881a4 --- /dev/null +++ b/tests/unit/test_multivariate_rejection_sampler.py @@ -0,0 +1,125 @@ +import json +import os + +import pytest +from scipy.stats import norm + +from rocketpy import MultivariateRejectionSampler +from rocketpy._encoders import RocketPyEncoder + + +def test_mrs_initialization(): + """Tests if the MultivariateRejectionSampler initialization opens input and output + files correctly, and if it raises errors correctly when the files are problematic. + """ + mrs_prefix = "mrs" + + # Tests if the input and output files opens correctly when the input is valid + valid_mc_filepath_prefix = "valid_mc" + valid_inputs = [ + {"a": 1, "b": 2}, + {"a": 3, "b": 4}, + ] + valid_outputs = [ + {"d": 10, "b": 20}, + {"d": 30, "b": 40}, + ] + with open(valid_mc_filepath_prefix + ".inputs.txt", "w+") as file: + for json_input in valid_inputs: + file.write(json.dumps(json_input, cls=RocketPyEncoder) + "\n") + with open(valid_mc_filepath_prefix + ".outputs.txt", "w+") as file: + for json_output in valid_outputs: + file.write(json.dumps(json_output, cls=RocketPyEncoder) + "\n") + MultivariateRejectionSampler(valid_mc_filepath_prefix, mrs_prefix) + + # tests if it raises an error when the file does not exist + with pytest.raises(FileNotFoundError): + MultivariateRejectionSampler("non_existent_mc_prefix", mrs_prefix) + + # tests if it raises an error when the input file contains different + # variables in different lines + invalid_mc_filepath_prefix = "invalid_mc" + invalid_inputs = [ + {"a": 1, "b": 2}, + {"c": 3, "b": 4}, + ] + with open(invalid_mc_filepath_prefix + ".inputs.txt", "w+") as file: + for json_input in invalid_inputs: + file.write(json.dumps(json_input, cls=RocketPyEncoder) + "\n") + with pytest.raises(ValueError): + MultivariateRejectionSampler(invalid_mc_filepath_prefix, mrs_prefix) + + # tests if it raises an error when the input and output file contains + # different number of samples + invalid_mc_filepath_prefix = "invalid_mc" + invalid_inputs = [ + {"a": 1, "b": 2}, + {"a": 3, "b": 4}, + ] + invalid_outputs = [{"c": 10, "d": 40}] + with open(invalid_mc_filepath_prefix + ".inputs.txt", "w+") as file: + for json_input in invalid_inputs: + file.write(json.dumps(json_input, cls=RocketPyEncoder) + "\n") + with open(invalid_mc_filepath_prefix + ".outputs.txt", "w+") as file: + for json_output in invalid_outputs: + file.write(json.dumps(json_output, cls=RocketPyEncoder) + "\n") + with pytest.raises(ValueError): + MultivariateRejectionSampler(invalid_mc_filepath_prefix, mrs_prefix) + + os.remove(valid_mc_filepath_prefix + ".inputs.txt") + os.remove(valid_mc_filepath_prefix + ".outputs.txt") + os.remove(invalid_mc_filepath_prefix + ".inputs.txt") + os.remove(invalid_mc_filepath_prefix + ".outputs.txt") + + +def test_mrs_sample(): + """Tests if the MultivariateRejectionSampler samples correctly and raises errors + when a non-existing variable is used in the distribution dict. + """ + mrs_prefix = "mrs" + + # Tests if the input and output files opens correctly when the input is valid + mc_filepath_prefix = "valid_mc" + mc_inputs = [ + {"a": 0}, + {"a": 0.1}, + {"a": -0.1}, + {"a": 0.2}, + {"a": -0.2}, + {"a": 1}, + {"a": 1.1}, + {"a": -1.1}, + {"a": 1.2}, + {"a": -1.2}, + ] + mc_outputs = [ + {"b": 10}, + {"b": 10}, + {"b": 10}, + {"b": 10}, + {"b": 10}, + {"b": 10}, + {"b": 10}, + {"b": 10}, + {"b": 10}, + {"b": 10}, + ] + with open(mc_filepath_prefix + ".inputs.txt", "w+") as file: + for json_input in mc_inputs: + file.write(json.dumps(json_input, cls=RocketPyEncoder) + "\n") + with open(mc_filepath_prefix + ".outputs.txt", "w+") as file: + for json_output in mc_outputs: + file.write(json.dumps(json_output, cls=RocketPyEncoder) + "\n") + mrs = MultivariateRejectionSampler(mc_filepath_prefix, mrs_prefix) + + invalid_distribution_dict = {"invalid_name": (norm(0, 1).pdf, norm(0, 1).pdf)} + with pytest.raises(ValueError): + mrs.sample(invalid_distribution_dict) + valid_distribution_dict = {"a": (norm(0, 1).pdf, norm(0, 1).pdf)} + mrs.sample(valid_distribution_dict) + + os.remove(mc_filepath_prefix + ".inputs.txt") + os.remove(mc_filepath_prefix + ".outputs.txt") + os.remove(mrs_prefix + ".inputs.txt") + os.remove(mrs_prefix + ".outputs.txt") + os.remove(mrs_prefix + ".errors.txt") From af3e393d55c6072c24b970713f4ac493a2eface2 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Thu, 27 Feb 2025 16:00:27 -0300 Subject: [PATCH 13/18] MNT: use pylint flag to fix linter --- tests/integration/test_multivariate_rejection_sampler.py | 1 - tests/unit/test_multivariate_rejection_sampler.py | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/integration/test_multivariate_rejection_sampler.py b/tests/integration/test_multivariate_rejection_sampler.py index eac05e520..39b3648ee 100644 --- a/tests/integration/test_multivariate_rejection_sampler.py +++ b/tests/integration/test_multivariate_rejection_sampler.py @@ -1,4 +1,3 @@ -# pylint: disable=unused-argument import os import pytest diff --git a/tests/unit/test_multivariate_rejection_sampler.py b/tests/unit/test_multivariate_rejection_sampler.py index d1e3881a4..cc030009b 100644 --- a/tests/unit/test_multivariate_rejection_sampler.py +++ b/tests/unit/test_multivariate_rejection_sampler.py @@ -8,6 +8,7 @@ from rocketpy._encoders import RocketPyEncoder +# pylint: disable=too-many-statements def test_mrs_initialization(): """Tests if the MultivariateRejectionSampler initialization opens input and output files correctly, and if it raises errors correctly when the files are problematic. From cd74e22da493ea90b05758a2d0b9778c56a5bb47 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Thu, 27 Feb 2025 16:17:25 -0300 Subject: [PATCH 14/18] TST: adding tests to MonteCarlo comparison features --- tests/integration/test_monte_carlo.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tests/integration/test_monte_carlo.py b/tests/integration/test_monte_carlo.py index 51d8bfae9..0dcbf2c7b 100644 --- a/tests/integration/test_monte_carlo.py +++ b/tests/integration/test_monte_carlo.py @@ -84,12 +84,21 @@ def test_monte_carlo_set_outputs_log(monte_carlo_calisto): def test_monte_carlo_prints(monte_carlo_calisto): """Tests the prints methods of the MonteCarlo class.""" monte_carlo_calisto.info() + monte_carlo_calisto.compare_info(monte_carlo_calisto) @patch("matplotlib.pyplot.show") # pylint: disable=unused-argument def test_monte_carlo_plots(mock_show, monte_carlo_calisto_pre_loaded): """Tests the plots methods of the MonteCarlo class.""" assert monte_carlo_calisto_pre_loaded.all_info() is None + assert ( + monte_carlo_calisto_pre_loaded.compare_plots(monte_carlo_calisto_pre_loaded) + is None + ) + assert ( + monte_carlo_calisto_pre_loaded.compare_ellipses(monte_carlo_calisto_pre_loaded) + is None + ) def test_monte_carlo_export_ellipses_to_kml(monte_carlo_calisto_pre_loaded): From e2a3ac63fa13c152423778135a9a29885cdf3fc8 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Sun, 30 Mar 2025 00:04:10 +0100 Subject: [PATCH 15/18] MNT: applying suggestions in .rst, better handling nested variables in MRS and applying linters --- docs/user/mrs.rst | 60 +++++++++++++++++-- docs/user/sensitivity.rst | 4 +- rocketpy/plots/monte_carlo_plots.py | 18 +++--- rocketpy/simulation/monte_carlo.py | 2 +- .../multivariate_rejection_sampler.py | 34 ++++++++--- .../stochastic/stochastic_aero_surfaces.py | 2 +- rocketpy/tools.py | 56 +++++++++++------ .../test_multivariate_rejection_sampler.py | 13 ++++ .../test_multivariate_rejection_sampler.py | 21 ++----- 9 files changed, 147 insertions(+), 63 deletions(-) diff --git a/docs/user/mrs.rst b/docs/user/mrs.rst index 59f25dd3c..ec598960e 100644 --- a/docs/user/mrs.rst +++ b/docs/user/mrs.rst @@ -103,15 +103,16 @@ create these distributions and the dictionary Finally, we execute the `sample` method, as shown below +.. jupyter-execute:: + :hide-code: + :hide-output: + + np.random.seed(seed=42) + .. jupyter-execute:: - np.random.seed(seed=42) mrs.sample(distribution_dict=distribution_dict) -.. note:: - We set the numpy's seed just for reproduction. When actually using the MRS, - skip setting the seed! - And that is it! The MRS has saved a file that has the same structure as the results of a monte carlo simulation but now the mass has been sampled from the newly stated distribution. To see that it is actually the case, let us import the results of the MRS @@ -218,6 +219,43 @@ the monte carlo simulations with 117 samples it took, on average, 76.3 seconds. the MRS was, on average, (76.3 / 0.15) ~ 500 times faster than re-running the monte carlo simulations with the same sample size provided by the MRS. + +Sampling from nested parameters +------------------------------- + +To sample from parameters that are nested in inner levels, use a key name +formed by the name of the key of the outer level concatenated with a "_" and +the key of the inner level. For instance, to change the distribution +from the "total_impulse" parameter, which is nested within the "motors" +parameter dictionary, we have to use the key name "motors_total_impulse". + + +.. jupyter-execute:: + + old_total_impulse_pdf = norm(6500, 1000).pdf + new_total_impulse_pdf = norm(5500, 1000).pdf + distribution_dict = { + "motors_total_impulse": (old_total_impulse_pdf, new_total_impulse_pdf), + } + mrs.sample(distribution_dict=distribution_dict) + +Finally, if there are multiple named nested structures, we need to use a key +name formed by outer level concatenated with "_", the structure name, "_" and the +inner parameter name. For instance, if we want to change the distribution of +the 'root_chord' of the 'Fins', we have to pass as key +'aerodynamic_surfaces_Fins_root_chord' + +.. jupyter-execute:: + + old_root_chord_pdf = norm(0.12, 0.001).pdf + new_root_chord_pdf = norm(0.119, 0.002).pdf + distribution_dict = { + "aerodynamic_surfaces_Fins_root_chord": ( + old_root_chord_pdf, new_root_chord_pdf + ), + } + mrs.sample(distribution_dict=distribution_dict) + A word of caution ----------------- @@ -227,4 +265,14 @@ changes in their distribution and the more discrepant these are from the origina ones, the more pronounced will be this sample size reduction. If you need the monte carlo simulations to have the same sample size as before or if the expected sample size from the MRS is too low for you current application, then it might be better to -re-run the simulations. \ No newline at end of file +re-run the simulations. + +References +---------- + +[1] CEOTTO, Giovani H., SCHMITT, Rodrigo N., ALVES, Guilherme F., et al. RocketPy: six +degree-of-freedom rocket trajectory simulator. Journal of Aerospace Engineering, 2021, +vol. 34, no 6, p. 04021093. + +[2] CASELLA, George, ROBERT, Christian P., et WELLS, Martin T. Generalized accept-reject +sampling schemes. Lecture notes-monograph series, 2004, p. 342-347. \ No newline at end of file diff --git a/docs/user/sensitivity.rst b/docs/user/sensitivity.rst index 7cac7d980..624fe559e 100644 --- a/docs/user/sensitivity.rst +++ b/docs/user/sensitivity.rst @@ -85,8 +85,8 @@ value of that parameter, i.e. the measured value by the instrument, and the "motors_grain_initial_inner_radius": {"mean": 15 / 1000, "std": 0.375 / 1000}, "motors_grain_outer_radius": {"mean": 33 / 1000, "std": 0.375 / 1000}, # Parachutes - "parachutes_cd_s": {"mean": 10, "std": 0.1}, - "parachutes_lag": {"mean": 1.5, "std": 0.1}, + "parachutes_Main_cd_s": {"mean": 10, "std": 0.1}, + "parachutes_Main_lag": {"mean": 1.5, "std": 0.1}, # Flight "heading": {"mean": 53, "std": 2}, "inclination": {"mean": 84.7, "std": 1}, diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 03837e85c..2d73afa27 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -280,8 +280,6 @@ def ellipses_comparison( MonteCarlo object which the current one will be compared to. image : str, optional Path to the background image, usually a map of the launch site. - actual_landing_point : tuple, optional - Actual landing point of the rocket in (x, y) meters. perimeter_size : int, optional Size of the perimeter to be plotted. Default is 3000. xlim : tuple, optional @@ -345,8 +343,8 @@ def ellipses_comparison( original_apogee_y, original_impact_x, original_impact_y, - apogee_rgb=(0, 1, 0), - impact_rgb=(0, 0, 1), + apogee_rgb=(0.0117647, 0.1490196, 0.9882352), + impact_rgb=(0.9882352, 0.0117647, 0.6392156), ) ) @@ -355,8 +353,8 @@ def ellipses_comparison( other_apogee_y, other_impact_x, other_impact_y, - apogee_rgb=(174 / 255, 159 / 255, 15 / 255), - impact_rgb=(102 / 255, 23 / 255, 204 / 255), + apogee_rgb=(0.9882352, 0.8509803, 0.0117647), + impact_rgb=(0.0117647, 0.9882352, 0.3607843), ) # Create plot figure @@ -375,7 +373,7 @@ def ellipses_comparison( original_apogee_y, s=5, marker="^", - color="green", + color="#0326FC", label="Original Apogee", ) plt.scatter( @@ -383,7 +381,7 @@ def ellipses_comparison( original_impact_y, s=5, marker="v", - color="blue", + color="#FC03A3", label="Original Landing Point", ) @@ -398,7 +396,7 @@ def ellipses_comparison( other_apogee_y, s=5, marker="^", - color="#ae9f0f", + color="#FCD903", label="Other Apogee", ) plt.scatter( @@ -406,7 +404,7 @@ def ellipses_comparison( other_impact_y, s=5, marker="v", - color="#6617cc", + color="#03FC5C", label="Other Landing Point", ) diff --git a/rocketpy/simulation/monte_carlo.py b/rocketpy/simulation/monte_carlo.py index 45b936d78..f5f79bd17 100644 --- a/rocketpy/simulation/monte_carlo.py +++ b/rocketpy/simulation/monte_carlo.py @@ -1103,7 +1103,7 @@ def all_info(self): self.info() self.plots.ellipses() self.plots.all() - + def compare_info(self, other_monte_carlo): """ Prints the comparison of the information of the Monte Carlo simulation diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index cb0b802ed..278b28f7a 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -15,15 +15,35 @@ from typing import Union from rocketpy._encoders import RocketPyEncoder +from rocketpy.tools import flatten_dict @dataclass # TODO: replace Union by "|" once python 3.9 is no longer supported # pylint: disable=unsupported-binary-operation class SampleInformation: - """Sample information used in the MRS""" + """Sample information used in the MRS + + Attributes + ---------- + inputs_json : dict or None + Dictionary containing the original information of the inputs file. + flatted_inputs_json : dict or None + Dictionary containing the information of the inputs file in a + flat format to allow re-sampling based on nested data. + outputs_json : dict or None + Dictionary containing the original information of the outputs file. + probability_ratio : float or None + Probability ratio of the new proposed distribution and the previous + distribution evaluated at the unit sample data. + acceptance_probability : float or None + The final acceptance probability that the given sample will be + re-sampled. It is given by the ratio of the probability ratio + and the supremum of all probability ratios. + """ inputs_json: Union[dict, None] = None + flatted_inputs_json: Union[dict, None] = None outputs_json: Union[dict, None] = None probability_ratio: Union[float, None] = None acceptance_probability: Union[float, None] = None @@ -93,18 +113,14 @@ def __setup_input(self): for line in input_file.readlines(): sample_info = SampleInformation() line_json = json.loads(line) + flatted_line_json = flatten_dict(line_json) sample_info.inputs_json = line_json + sample_info.flatted_inputs_json = flatted_line_json self.all_sample_list.append(sample_info) # sets and validates input variables names if not self.input_variables_names: - self.input_variables_names = set(line_json.keys()) - else: - if self.input_variables_names != set(line_json.keys()): - raise ValueError( - "Input file from Monte Carlo contains different " - "variables for different lines" - ) + self.input_variables_names = set(flatted_line_json.keys()) self.original_sample_size += 1 except Exception as e: raise ValueError( @@ -264,7 +280,7 @@ def __compute_probability_ratio(self, sample, distribution_dict): probability_ratio = 1 try: for variable in distribution_dict.keys(): - value = sample.inputs_json[variable] + value = sample.flatted_inputs_json[variable] old_pdf = distribution_dict[variable][0] new_pdf = distribution_dict[variable][1] probability_ratio *= new_pdf(value) / old_pdf(value) diff --git a/rocketpy/stochastic/stochastic_aero_surfaces.py b/rocketpy/stochastic/stochastic_aero_surfaces.py index 5dda716bb..5e3750f48 100644 --- a/rocketpy/stochastic/stochastic_aero_surfaces.py +++ b/rocketpy/stochastic/stochastic_aero_surfaces.py @@ -4,12 +4,12 @@ """ from rocketpy.rocket.aero_surface import ( + AirBrakes, EllipticalFins, NoseCone, RailButtons, Tail, TrapezoidalFins, - AirBrakes, ) from .stochastic_model import StochasticModel diff --git a/rocketpy/tools.py b/rocketpy/tools.py index 91428d50b..692d5e224 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -569,26 +569,48 @@ def __generate_ellipse_points(ellipse, resolution: int): return np.array(points) -def flatten_dict(x): - # Auxiliary function that flattens dictionary - # this is used mainly in the load_monte_carlo_data function - new_dict = {} - for key, value in x.items(): +def flatten_dict(original_dict): + """Flatten a dictionary for easy handling of nested variables + + This function is mainly used for handling data in sensitivity analysis + and in the MRS. + + Parameters + ---------- + original_dict : dict + A dictionary possibly containing nested variables. This means that + a key might contain another dictionary inside of it. + + Returns + ------- + flatted_dict : dict + The flatted dictionary which, ideally, should not contain nested + variables. All nested information should be available directly in + the first level (access by key). Variables that were available + inside the first level retain their original key name. Variables + that were nested are created by appending the name of the outer + key used to access it concatenated with a '_' and the key name + of the variable. + """ + flatted_dict = {} + for key, value in original_dict.items(): # the nested dictionary is inside a list - if isinstance(x[key], list): - # sometimes the object inside the list is another list - # we must skip these cases - if isinstance(value[0], dict): - inner_dict = flatten_dict(value[0]) - inner_dict = { - key + "_" + inner_key: inner_value - for inner_key, inner_value in inner_dict.items() - } - new_dict.update(inner_dict) + if isinstance(original_dict[key], list): + for inner_item in value: + if isinstance(inner_item, dict): + inner_dict = flatten_dict(inner_item) + sep_str = "_" + if "name" in inner_dict: + sep_str = "_" + inner_dict["name"] + "_" + inner_dict = { + key + sep_str + inner_key: inner_value + for inner_key, inner_value in inner_dict.items() + } + flatted_dict.update(inner_dict) else: - new_dict.update({key: value}) + flatted_dict.update({key: value}) - return new_dict + return flatted_dict def load_monte_carlo_data( diff --git a/tests/integration/test_multivariate_rejection_sampler.py b/tests/integration/test_multivariate_rejection_sampler.py index 39b3648ee..ddbe3eb2e 100644 --- a/tests/integration/test_multivariate_rejection_sampler.py +++ b/tests/integration/test_multivariate_rejection_sampler.py @@ -13,6 +13,19 @@ "tests/fixtures/monte_carlo/example", {"mass": (norm(15.5, 1).pdf, norm(15.2, 1).pdf)}, ), + ( + "tests/fixtures/monte_carlo/example", + {"motors_total_impulse": (norm(6000, 1000).pdf, norm(6500, 1000).pdf)}, + ), + ( + "tests/fixtures/monte_carlo/example", + { + "parachutes_calisto_drogue_chute_lag": ( + norm(1.5, 0.25).pdf, + norm(1.2, 0.25).pdf, + ) + }, + ), ], ) def test_mrs_sample_integration(monte_carlo_filepath, distribution_dict): diff --git a/tests/unit/test_multivariate_rejection_sampler.py b/tests/unit/test_multivariate_rejection_sampler.py index cc030009b..af58b8fef 100644 --- a/tests/unit/test_multivariate_rejection_sampler.py +++ b/tests/unit/test_multivariate_rejection_sampler.py @@ -18,12 +18,12 @@ def test_mrs_initialization(): # Tests if the input and output files opens correctly when the input is valid valid_mc_filepath_prefix = "valid_mc" valid_inputs = [ - {"a": 1, "b": 2}, - {"a": 3, "b": 4}, + {"a": 1, "b": 2, "c": [{"d": 1}]}, + {"a": 3, "b": 4, "c": [{"d": 1}]}, ] valid_outputs = [ - {"d": 10, "b": 20}, - {"d": 30, "b": 40}, + {"e": 10, "f": 20}, + {"e": 30, "f": 40}, ] with open(valid_mc_filepath_prefix + ".inputs.txt", "w+") as file: for json_input in valid_inputs: @@ -37,19 +37,6 @@ def test_mrs_initialization(): with pytest.raises(FileNotFoundError): MultivariateRejectionSampler("non_existent_mc_prefix", mrs_prefix) - # tests if it raises an error when the input file contains different - # variables in different lines - invalid_mc_filepath_prefix = "invalid_mc" - invalid_inputs = [ - {"a": 1, "b": 2}, - {"c": 3, "b": 4}, - ] - with open(invalid_mc_filepath_prefix + ".inputs.txt", "w+") as file: - for json_input in invalid_inputs: - file.write(json.dumps(json_input, cls=RocketPyEncoder) + "\n") - with pytest.raises(ValueError): - MultivariateRejectionSampler(invalid_mc_filepath_prefix, mrs_prefix) - # tests if it raises an error when the input and output file contains # different number of samples invalid_mc_filepath_prefix = "invalid_mc" From c767a324fe5c96888c5f6487c68d8a1d724d6f67 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Sun, 30 Mar 2025 11:20:00 +0200 Subject: [PATCH 16/18] MNT: removing TODO comments from monte_carlo_plots --- rocketpy/plots/monte_carlo_plots.py | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 2d73afa27..c0a6e6bd3 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -209,11 +209,6 @@ def plot_comparison(self, other_monte_carlo): ------- None """ - # TODO: understand why this validation is failing - # if not isinstance(other_monte_carlo, MonteCarlo): - # raise TypeError( - # "Argument 'other_monte_carlo' must be an MonteCarlo object!" - # ) original_parameters_set = set(self.monte_carlo.processed_results.keys()) other_parameters_set = set(other_monte_carlo.processed_results.keys()) intersection_set = original_parameters_set.intersection(other_parameters_set) @@ -294,12 +289,6 @@ def ellipses_comparison( ------- None """ - # TODO: understand why this validation is failing - # if not isinstance(other_monte_carlo, MonteCarlo): - # raise TypeError( - # "Argument 'other_monte_carlo' must be an MonteCarlo object!" - # ) - imageio = import_optional_dependency("imageio") # Import background map From d335d263457d5d18715d14e69234cfac70bf9ab1 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Fri, 4 Apr 2025 22:40:11 +0200 Subject: [PATCH 17/18] MNT: remove useless TODO --- rocketpy/simulation/multivariate_rejection_sampler.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/rocketpy/simulation/multivariate_rejection_sampler.py b/rocketpy/simulation/multivariate_rejection_sampler.py index 278b28f7a..605e79714 100644 --- a/rocketpy/simulation/multivariate_rejection_sampler.py +++ b/rocketpy/simulation/multivariate_rejection_sampler.py @@ -19,8 +19,6 @@ @dataclass -# TODO: replace Union by "|" once python 3.9 is no longer supported -# pylint: disable=unsupported-binary-operation class SampleInformation: """Sample information used in the MRS From 0a86a588b4e371d1fef2b229f66f61951cd140f1 Mon Sep 17 00:00:00 2001 From: Lucas de Oliveira Prates Date: Sat, 12 Apr 2025 10:40:30 +0200 Subject: [PATCH 18/18] MNT: inserting pragmas for no cover and resolving changelog conflict --- CHANGELOG.md | 2 ++ rocketpy/plots/monte_carlo_plots.py | 6 ++++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e18389355..07969e855 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -33,6 +33,8 @@ Attention: The newest changes should be on top --> ### Added - ENH: Implement Multivariate Rejection Sampling (MRS) [#738] (https://github.com/RocketPy-Team/RocketPy/pull/738) +- ENH: Create a rocketpy file to store flight simulations [#800](https://github.com/RocketPy-Team/RocketPy/pull/800) +- ENH: Support for the RSE file format has been added to the library [#798](https://github.com/RocketPy-Team/RocketPy/pull/798) ### Changed diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index c0a6e6bd3..cfb865c5f 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -295,7 +295,7 @@ def ellipses_comparison( if image is not None: try: img = imageio.imread(image) - except FileNotFoundError as e: + except FileNotFoundError as e: # pragma no cover raise FileNotFoundError( "The image file was not found. Please check the path." ) from e @@ -323,7 +323,9 @@ def ellipses_comparison( other_impact_x = np.array([]) other_impact_y = np.array([]) - if len(original_apogee_x) == 0 and len(original_impact_x) == 0: + if ( + len(original_apogee_x) == 0 and len(original_impact_x) == 0 + ): # pragma no cover raise ValueError("No apogee or impact data found. Cannot plot ellipses.") original_impact_ellipses, original_apogee_ellipses = (