From 380e981d4dc8bb1cf0b9d359e706168e7b08118d Mon Sep 17 00:00:00 2001
From: Dominik Jain <dominik.jain@outlook.com>
Date: Tue, 6 Aug 2024 21:20:04 +0200
Subject: [PATCH 1/6] Add example application: dengue fever time series
 prediction

---
 examples/dengue-fever-time-series/.gitignore  |  10 +
 .../dengue-fever-time-series/dengai/data.py   | 165 +++++
 .../dengai/features.py                        |  60 ++
 .../dengai/models/glm.py                      |  38 ++
 .../dengai/models/mean_week_model.py          |  19 +
 .../dengai/models/model_factory.py            | 134 ++++
 .../dengai/models/rnn_mlp.py                  |  95 +++
 .../dengai/prediction_problem.py              |  44 ++
 .../dengai/vectorisers.py                     |  80 +++
 .../dengue-fever-time-series/environment.yml  |  19 +
 .../nb_data_analysis.ipynb                    | 604 ++++++++++++++++++
 .../dengue-fever-time-series/run_hyperopt.py  |  81 +++
 .../run_model_evaluation.py                   |  81 +++
 examples/dengue-fever-time-series/run_rfe.py  |  40 ++
 14 files changed, 1470 insertions(+)
 create mode 100644 examples/dengue-fever-time-series/.gitignore
 create mode 100644 examples/dengue-fever-time-series/dengai/data.py
 create mode 100644 examples/dengue-fever-time-series/dengai/features.py
 create mode 100644 examples/dengue-fever-time-series/dengai/models/glm.py
 create mode 100644 examples/dengue-fever-time-series/dengai/models/mean_week_model.py
 create mode 100644 examples/dengue-fever-time-series/dengai/models/model_factory.py
 create mode 100644 examples/dengue-fever-time-series/dengai/models/rnn_mlp.py
 create mode 100644 examples/dengue-fever-time-series/dengai/prediction_problem.py
 create mode 100644 examples/dengue-fever-time-series/dengai/vectorisers.py
 create mode 100644 examples/dengue-fever-time-series/environment.yml
 create mode 100644 examples/dengue-fever-time-series/nb_data_analysis.ipynb
 create mode 100644 examples/dengue-fever-time-series/run_hyperopt.py
 create mode 100644 examples/dengue-fever-time-series/run_model_evaluation.py
 create mode 100644 examples/dengue-fever-time-series/run_rfe.py

diff --git a/examples/dengue-fever-time-series/.gitignore b/examples/dengue-fever-time-series/.gitignore
new file mode 100644
index 000000000..38e071701
--- /dev/null
+++ b/examples/dengue-fever-time-series/.gitignore
@@ -0,0 +1,10 @@
+*.pyc
+__pycache__
+*.bak
+*.orig
+/data
+/temp
+/.idea
+/results
+/temp*.py
+/mlruns
diff --git a/examples/dengue-fever-time-series/dengai/data.py b/examples/dengue-fever-time-series/dengai/data.py
new file mode 100644
index 000000000..6eebe6377
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/data.py
@@ -0,0 +1,165 @@
+import logging
+from typing import Sequence, List, Hashable
+
+import pandas as pd
+
+from sensai import InputOutputData, RuleBasedDataFrameTransformer
+from sensai.vectoriser import ItemIdentifierProvider, T
+
+log = logging.getLogger(__name__)
+
+COL_CITY = "city"
+COL_YEAR = "year"
+COL_WEEK_OF_YEAR = "weekofyear"
+COL_WEEK_START_DATE = "week_start_date"
+
+COL_FEATURE_STATION_MAX_TEMP = "station_max_temp_c"
+COL_FEATURE_STATION_MIN_TEMP = "station_min_temp_c"
+COL_FEATURE_STATION_AVG_TEMP = "station_avg_temp_c"
+COL_FEATURE_STATION_PRECIP_MM = "station_precip_mm"
+COL_FEATURE_STATION_DIURNAL_TEMP_RANGE = "station_diur_temp_rng_c"
+COL_FEATURE_PERSIANN_PRECIPITATION_MM = "precipitation_amt_mm"
+COL_FEATURE_REANALYSIS_SAT_PRECIP_MM = "reanalysis_sat_precip_amt_mm"
+COL_FEATURE_REANALYSIS_DEW_POINT_K = "reanalysis_dew_point_temp_k"
+COL_FEATURE_REANALYSIS_AIR_TEMP_K = "reanalysis_air_temp_k"
+COL_FEATURE_REANALYSIS_REL_HUMIDITY_PERCENT = "reanalysis_relative_humidity_percent"
+COL_FEATURE_REANALYSIS_SPEC_HUMIDITY = "reanalysis_specific_humidity_g_per_kg"
+COL_FEATURE_REANALYSIS_PRECIP = "reanalysis_precip_amt_kg_per_m2"
+COL_FEATURE_REANALYSIS_MAX_AIR_TEMP_K = "reanalysis_max_air_temp_k"
+COL_FEATURE_REANALYSIS_MIN_AIR_TEMP_K = "reanalysis_min_air_temp_k"
+COL_FEATURE_REANALYSIS_AVG_TEMP_K = "reanalysis_avg_temp_k"
+COL_FEATURE_REANALYSIS_DIURNAL_TEMP_RANGE_K = "reanalysis_tdtr_k"
+COL_FEATURE_VEG_INDEX_SE = "ndvi_se"
+COL_FEATURE_VEG_INDEX_SW = "ndvi_sw"
+COL_FEATURE_VEG_INDEX_NE = "ndvi_ne"
+COL_FEATURE_VEG_INDEX_NW = "ndvi_nw"
+
+# all numeric features
+COLS_FEATURES = [COL_FEATURE_STATION_MAX_TEMP, COL_FEATURE_STATION_MIN_TEMP, COL_FEATURE_STATION_AVG_TEMP, COL_FEATURE_STATION_PRECIP_MM,
+    COL_FEATURE_STATION_DIURNAL_TEMP_RANGE, COL_FEATURE_PERSIANN_PRECIPITATION_MM, COL_FEATURE_REANALYSIS_SAT_PRECIP_MM,
+    COL_FEATURE_REANALYSIS_DEW_POINT_K, COL_FEATURE_REANALYSIS_AIR_TEMP_K, COL_FEATURE_REANALYSIS_REL_HUMIDITY_PERCENT,
+    COL_FEATURE_REANALYSIS_SPEC_HUMIDITY, COL_FEATURE_REANALYSIS_PRECIP, COL_FEATURE_REANALYSIS_MAX_AIR_TEMP_K,
+    COL_FEATURE_REANALYSIS_MIN_AIR_TEMP_K, COL_FEATURE_REANALYSIS_AVG_TEMP_K, COL_FEATURE_REANALYSIS_DIURNAL_TEMP_RANGE_K,
+    COL_FEATURE_VEG_INDEX_SE, COL_FEATURE_VEG_INDEX_SW, COL_FEATURE_VEG_INDEX_NE, COL_FEATURE_VEG_INDEX_NW]
+# features where the assumption of a normal distribution would be problematic
+COLS_FEATURES_NONSTD = [COL_FEATURE_STATION_PRECIP_MM, COL_FEATURE_PERSIANN_PRECIPITATION_MM, COL_FEATURE_REANALYSIS_SAT_PRECIP_MM]
+# features where the assumption of a normal distribution would be OK
+COLS_FEATURES_STD = [c for c in COLS_FEATURES if c not in COLS_FEATURES_NONSTD]
+
+CITY_IQUITOS = "iq"
+CITY_SAN_JUAN = "sj"
+
+COL_GEN_WEEK_DP = "week_data_point"
+
+COL_TARGET = "total_cases"
+
+
+class Dataset:
+    def __init__(self):
+        df = self._read_combined_df()
+        self.df_sj = df[df[COL_CITY] == CITY_SAN_JUAN].reset_index()
+        self.df_iq = df[df[COL_CITY] == CITY_IQUITOS].reset_index()
+        self.df = df
+
+    @staticmethod
+    def _read_combined_df():
+        # join training data
+        train_features = pd.read_csv("data/dengue_features_train.csv")
+        train_labels = pd.read_csv("data/dengue_labels_train.csv")
+        train_df = pd.merge(train_features, train_labels, on=[COL_CITY, COL_YEAR, COL_WEEK_OF_YEAR])
+        assert len(train_df) == len(train_labels)
+
+        # concatenate with test data
+        test_features = pd.read_csv("data/dengue_features_test.csv")
+        df = pd.concat([train_df, test_features]).reset_index(drop=True)
+
+        # obtain time stamps for week start date
+        df[COL_WEEK_START_DATE] = pd.to_datetime(df[COL_WEEK_START_DATE])
+
+        return df
+
+    def get_city_data_frame(self, city: str) -> pd.DataFrame:
+        if city == CITY_IQUITOS:
+            return self.df_iq
+        elif city == CITY_SAN_JUAN:
+            return self.df_sj
+        raise ValueError(city)
+
+    def create_io_data(self, city: str, min_window_size: int, train=True):
+        df = self.get_city_data_frame(city).copy(deep=True)
+
+        if city == CITY_IQUITOS:
+            df = df[df[COL_YEAR] >= 2002]  # remove seemingly broken data at the beginning of the Iquitos time series
+
+        df.reset_index(drop=True, inplace=True)
+
+        df_imputed = DFTImputation().apply(df)
+
+        week_data_points = [WeekDataPoint(t_raw, t_imputed, df) for t_raw, t_imputed in zip(df.itertuples(), df_imputed.itertuples())]
+        df[COL_GEN_WEEK_DP] = week_data_points
+
+        if train:
+            df = df.iloc[min_window_size:]
+
+        if train:
+            df = df[~df[COL_TARGET].isna()]
+        else:
+            df = df[df[COL_TARGET].isna()]
+
+        return InputOutputData.from_data_frame(df, COL_TARGET)
+
+
+class WeekDataPoint:
+    def __init__(self, t_raw, t_imputed, df):
+        self.t_raw = t_raw
+        self.t_imputed = t_imputed
+        self.df = df
+
+    def window(self, size: int) -> Sequence["WeekDataPointInWindow"]:
+        window = self.df[COL_GEN_WEEK_DP].iloc[self.t_raw.Index-(size-1):self.t_raw.Index+1].values
+        assert window[-1] == self
+        return [WeekDataPointInWindow(wdp, window, i) for i, wdp in enumerate(window)]
+
+    def get_value(self, col: str, imputed: bool = False):
+        if imputed:
+            return getattr(self.t_imputed, col)
+        else:
+            return getattr(self.t_raw, col)
+
+    def get_index(self) -> int:
+        """
+        :return: the index of the respective data point in the dataset (row index in DataFrame)
+        """
+        return self.t_raw.Index
+
+
+class WeekDataPointInWindow:
+    def __init__(self, week_data_point: WeekDataPoint, window: List[WeekDataPoint], idx: int):
+        """
+        :param week_data_point: the data point
+        :param window: the full window
+        :param idx: the 0-based index of the week data point within its window
+        """
+        self.week_data_point = week_data_point
+        self.window = window
+        self.idx = idx
+
+    def is_current(self):
+        return self.idx == len(self.window) - 1
+
+    class IdentifierProvider(ItemIdentifierProvider["WeekDataPointInWindow"]):
+        def get_identifier(self, item: "WeekDataPointInWindow") -> Hashable:
+            return id(item.week_data_point)
+
+
+class DFTImputation(RuleBasedDataFrameTransformer):
+    def _apply(self, df: pd.DataFrame) -> pd.DataFrame:
+        log.info("Applying imputation")
+        df = df.copy()
+        for col in COLS_FEATURES:
+            series = df[col]
+            num_na = series.isna().sum()
+            if num_na > 0:
+                #log.debug(f"Imputing {num_na} values for column {col}")
+                df[col] = series.fillna(method="ffill").fillna(method="bfill")
+        return df
diff --git a/examples/dengue-fever-time-series/dengai/features.py b/examples/dengue-fever-time-series/dengai/features.py
new file mode 100644
index 000000000..4b5a8e157
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/features.py
@@ -0,0 +1,60 @@
+from typing import Dict, Any, List, Optional
+
+from .data import COL_GEN_WEEK_DP, WeekDataPoint, COLS_FEATURES, WeekDataPointInWindow
+from sensai.data_transformation import DFTNormalisation
+from sensai.featuregen import FeatureGeneratorMapColumn, FeatureGeneratorMapColumnDict
+
+COL_FGEN_HISTORY_WINDOW = "history_window"
+COL_FGEN_TARGET_WINDOW = "target_window"
+
+
+class FeatureGeneratorHistoryWeekWindow(FeatureGeneratorMapColumn):
+    def __init__(self, window_size: int, exclude_current: bool = False):
+        super().__init__(COL_GEN_WEEK_DP, COL_FGEN_HISTORY_WINDOW,
+            normalisation_rule_template=DFTNormalisation.RuleTemplate(unsupported=True))
+        self.exclude_current = exclude_current
+        self.window_size = window_size
+
+    def _create_value(self, week_data_point: WeekDataPoint):
+        w = week_data_point.window(self.window_size)
+        if self.exclude_current:
+            w = w[:-1]
+        return w
+
+
+class FeatureGeneratorTargetWeekWindow(FeatureGeneratorMapColumn):
+    def __init__(self):
+        super().__init__(COL_GEN_WEEK_DP, COL_FGEN_TARGET_WINDOW,
+            normalisation_rule_template=DFTNormalisation.RuleTemplate(unsupported=True))
+
+    def _create_value(self, week_data_point: WeekDataPoint):
+        return week_data_point.window(1)
+
+
+class FeatureGeneratorWindowColumnsFlat(FeatureGeneratorMapColumnDict):
+    def __init__(self, window_size: int, columns: Optional[List[str]] = None):
+        super().__init__(COL_GEN_WEEK_DP)
+        self.window_size = window_size
+        if columns is None:
+            columns = COLS_FEATURES
+        self.columns = columns
+
+    def _create_features_dict(self, week_data_point: WeekDataPoint) -> Dict[str, Any]:
+        window = week_data_point.window(self.window_size)
+        result = {}
+        for i, wdpiw in enumerate(window):
+            wdpiw: WeekDataPointInWindow
+            for col in self.columns:
+                result[f"{col}_{i}"] = wdpiw.week_data_point.get_value(col)
+        return result
+
+
+class FeatureGeneratorTakeImputedColumns(FeatureGeneratorMapColumnDict):
+    def __init__(self, columns: Optional[List[str]] = None):
+        super().__init__(COL_GEN_WEEK_DP)
+        if columns is None:
+            columns = COLS_FEATURES
+        self.columns = columns
+
+    def _create_features_dict(self, week_data_point: WeekDataPoint) -> Dict[str, Any]:
+        return {col: week_data_point.get_value(col, imputed=True) for col in self.columns}
diff --git a/examples/dengue-fever-time-series/dengai/models/glm.py b/examples/dengue-fever-time-series/dengai/models/glm.py
new file mode 100644
index 000000000..5487fec5a
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/models/glm.py
@@ -0,0 +1,38 @@
+from typing import Union
+
+import pandas as pd
+import statsmodels.api as sm
+import statsmodels.formula.api as smf
+
+from ..data import COL_TARGET, COL_FEATURE_REANALYSIS_SPEC_HUMIDITY, COL_FEATURE_REANALYSIS_DEW_POINT_K, \
+    COL_FEATURE_STATION_MIN_TEMP, COL_FEATURE_STATION_AVG_TEMP
+from ..features import FeatureGeneratorTakeImputedColumns
+from sensai import VectorRegressionModel
+
+
+class GeneralisedLinearModel(VectorRegressionModel):
+    """
+    The generalised linear model (GLM) from the DrivenData benchmark notebook.
+    See: https://drivendata.co/blog/dengue-benchmark/
+    """
+    def __init__(self, alpha=1e-8):
+        super().__init__()
+        self.alpha = alpha
+        self.model_formula = f"{COL_TARGET} ~ 1 + " \
+            f"{COL_FEATURE_REANALYSIS_SPEC_HUMIDITY} + " \
+            f"{COL_FEATURE_REANALYSIS_DEW_POINT_K} + " \
+            f"{COL_FEATURE_STATION_MIN_TEMP} + " \
+            f"{COL_FEATURE_STATION_AVG_TEMP}"
+        self.with_feature_generator(FeatureGeneratorTakeImputedColumns()) \
+            .with_name("GLM-DD-Benchmark")
+
+    def _fit(self, x: pd.DataFrame, y: pd.DataFrame):
+        data = pd.concat([x, y], axis=1)
+        model = smf.glm(formula=self.model_formula,
+            data=data,
+            family=sm.families.NegativeBinomial(alpha=self.alpha))
+        self.model = model.fit()
+
+    def _predict(self, x: pd.DataFrame) -> Union[pd.DataFrame, list]:
+        result = self.model.predict(x)
+        return result.to_list()
diff --git a/examples/dengue-fever-time-series/dengai/models/mean_week_model.py b/examples/dengue-fever-time-series/dengai/models/mean_week_model.py
new file mode 100644
index 000000000..04cbe51c5
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/models/mean_week_model.py
@@ -0,0 +1,19 @@
+from typing import Union, Optional
+
+import pandas as pd
+
+from ..data import COL_WEEK_OF_YEAR, COL_TARGET
+from sensai import VectorRegressionModel
+
+
+class MeanPastYearWeekModel(VectorRegressionModel):
+    def __init__(self):
+        super().__init__()
+        self._mean_week_values: Optional[pd.Series] = None
+
+    def _fit(self, x: pd.DataFrame, y: pd.DataFrame):
+        df = pd.concat([x, y], axis=1)
+        self._mean_week_values = df[[COL_WEEK_OF_YEAR, COL_TARGET]].groupby(COL_WEEK_OF_YEAR).mean()
+
+    def _predict(self, x: pd.DataFrame) -> Union[pd.DataFrame, list]:
+        return x[COL_WEEK_OF_YEAR].apply(lambda w: self._mean_week_values.loc[w])
diff --git a/examples/dengue-fever-time-series/dengai/models/model_factory.py b/examples/dengue-fever-time-series/dengai/models/model_factory.py
new file mode 100644
index 000000000..2bd8a759d
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/models/model_factory.py
@@ -0,0 +1,134 @@
+from typing import Optional
+
+from ..data import *
+from ..features import FeatureGeneratorWindowColumnsFlat, FeatureGeneratorHistoryWeekWindow, FeatureGeneratorTargetWeekWindow, \
+    COL_FGEN_HISTORY_WINDOW, COL_FGEN_TARGET_WINDOW
+from .glm import GeneralisedLinearModel
+from .mean_week_model import MeanPastYearWeekModel
+from .rnn_mlp import RnnMlp
+from ..vectorisers import create_history_sequence_vectoriser, AutoregressiveResultHandler, create_target_sequence_vectoriser
+from sensai.data_transformation import SkLearnTransformerFactoryFactory, DFTSkLearnTransformer
+from sensai.featuregen import FeatureGeneratorTakeColumns, MultiFeatureGenerator
+from sensai.sklearn.sklearn_regression import SkLearnDummyVectorRegressionModel
+from sensai.torch import Optimiser, NNOptimiserParams, NNLossEvaluatorRegression
+from sensai.torch.torch_models.seq.seq_models import EncoderDecoderVectorRegressionModel
+from sensai.torch.torch_models.seq.seq_modules import LSTNetworkEncoderFactory, SingleTargetDecoderFactory, LinearPredictorFactory
+from sensai.xgboost import XGBGradientBoostedVectorRegressionModel
+
+
+class ModelFactory:
+    COLS_FEATURES_SEL = [COL_FEATURE_STATION_MAX_TEMP, COL_FEATURE_STATION_MIN_TEMP, COL_FEATURE_STATION_AVG_TEMP,
+        COL_FEATURE_REANALYSIS_PRECIP, COL_FEATURE_REANALYSIS_DEW_POINT_K, COL_FEATURE_REANALYSIS_SPEC_HUMIDITY]
+
+    @classmethod
+    def create_baseline(cls):
+        return SkLearnDummyVectorRegressionModel().with_name("Baseline")
+
+    @classmethod
+    def create_rnn_mlp(cls, week_window_size: int, feature_columns: Optional[List[str]] = None, auto_regressive=False, batch_size=8,
+            optimiser_lr=1e-5, loss_fn: NNLossEvaluatorRegression.LossFunction = NNLossEvaluatorRegression.LossFunction.SMOOTHL1LOSS,
+            early_stopping_epochs=100):
+        if feature_columns is None:
+            feature_columns = COLS_FEATURES
+        return RnnMlp(
+                NNOptimiserParams(optimiser=Optimiser.ADAMW,
+                    early_stopping_epochs=early_stopping_epochs,
+                    optimiser_lr=optimiser_lr,
+                    batch_size=batch_size,
+                    train_fraction=0.9,
+                    use_shrinkage=True,
+                    loss_evaluator=NNLossEvaluatorRegression(loss_fn)),
+                rnn_hidden_dim=32,
+                mlp_hidden_dims=(32, 16),
+                mlp_dropout=0.2,
+                week_window_size=week_window_size,
+                feature_columns=feature_columns,
+                auto_regressive=auto_regressive) \
+            .with_name("RnnMlp")
+
+    @classmethod
+    def create_rnn_mlp_autoreg(cls, week_window_size: int, feature_columns: Optional[List[str]] = None):
+        return cls.create_rnn_mlp(week_window_size, feature_columns=feature_columns, batch_size=64,
+                auto_regressive=True) \
+            .with_name("RnnMlpAutoReg")
+
+    @classmethod
+    def create_lstnet_encoder_decoder(cls, week_window_size: int):
+        autoregressive_result_handler = AutoregressiveResultHandler()
+        target_transformer_factory = SkLearnTransformerFactoryFactory.MaxAbsScaler()
+        history_sequence_vectoriser = create_history_sequence_vectoriser(COLS_FEATURES, True, target_transformer_factory,
+            autoregressive_result_handler)
+        target_sequence_vectoriser = create_target_sequence_vectoriser(history_sequence_vectoriser)
+        encoder_factory = LSTNetworkEncoderFactory(week_window_size-1, 100, 4, 32, 0, 0)
+        decoder_factory = SingleTargetDecoderFactory(LinearPredictorFactory())
+        # decoder_factory = SingleTargetDecoderFactory(MLPPredictorFactory(output_activation_fn=ActivationFunction.RELU))
+        nn_optimiser_params = NNOptimiserParams(batch_size=64, shuffle=True)
+        latent_dim = encoder_factory.get_latent_dim()
+        return EncoderDecoderVectorRegressionModel(False,
+                    COL_FGEN_HISTORY_WINDOW, history_sequence_vectoriser, False,
+                    COL_FGEN_TARGET_WINDOW, target_sequence_vectoriser,
+                    latent_dim,
+                    encoder_factory,
+                    decoder_factory,
+                    nn_optimiser_params=nn_optimiser_params) \
+            .with_feature_generator(MultiFeatureGenerator(
+                FeatureGeneratorHistoryWeekWindow(week_window_size, exclude_current=True),
+                FeatureGeneratorTargetWeekWindow())) \
+            .with_autoregressive_result_handler(autoregressive_result_handler) \
+            .with_target_transformer(DFTSkLearnTransformer(target_transformer_factory())) \
+            .with_name("LSTNetEncoderDecoder")
+
+    @classmethod
+    def create_mlp(cls, week_window_size: int, feature_columns: Optional[List[str]] = None):
+        if feature_columns is None:
+            feature_columns = COLS_FEATURES
+        return RnnMlp(
+                NNOptimiserParams(optimiser=Optimiser.ADAMW, early_stopping_epochs=30, optimiser_lr=1e-5, batch_size=8, train_fraction=0.9,
+                    use_shrinkage=True,
+                    loss_evaluator=NNLossEvaluatorRegression(NNLossEvaluatorRegression.LossFunction.SMOOTHL1LOSS)),
+                use_rnn=False,
+                rnn_hidden_dim=32,
+                mlp_hidden_dims=(32, 16),
+                mlp_dropout=0.2,
+                week_window_size=week_window_size,
+                feature_columns=feature_columns) \
+            .with_name("Mlp")
+
+    @classmethod
+    def create_xgb(cls, feature_columns: Optional[List[str]] = None, min_child_weight=5, **kwargs):
+        if feature_columns is None:
+            feature_columns = COLS_FEATURES
+        return XGBGradientBoostedVectorRegressionModel(min_child_weight=min_child_weight, objective="reg:absoluteerror", **kwargs) \
+            .with_feature_generator(FeatureGeneratorTakeColumns(feature_columns)) \
+            .with_name("XGBoost")
+
+    @classmethod
+    def create_xgb_fsel(cls):
+        feature_columns = ['station_min_temp_c', 'station_avg_temp_c', 'station_precip_mm', 'precipitation_amt_mm', 'reanalysis_sat_precip_amt_mm', 'reanalysis_dew_point_temp_k', 'reanalysis_air_temp_k', 'reanalysis_relative_humidity_percent', 'reanalysis_specific_humidity_g_per_kg', 'reanalysis_precip_amt_kg_per_m2', 'reanalysis_max_air_temp_k', 'reanalysis_min_air_temp_k', 'reanalysis_tdtr_k', 'ndvi_se', 'ndvi_sw', 'ndvi_ne', 'ndvi_nw']
+        params = {'colsample_bytree': 0.2867610159931737, 'gamma': 8.62166097248104, 'max_depth': 4, 'min_child_weight': 12.0,
+            'reg_lambda': 0.7172266188561198}
+        return XGBGradientBoostedVectorRegressionModel(objective="reg:absoluteerror", **params) \
+            .with_feature_generator(FeatureGeneratorTakeColumns(feature_columns)) \
+            .with_name("XGBoost-fsel")
+
+    @classmethod
+    def create_xgb_window(cls, window_size: int, min_child_weight=5, feature_columns: Optional[List[str]] = None, **kwargs):
+        if feature_columns is None:
+            feature_columns = COLS_FEATURES
+        return XGBGradientBoostedVectorRegressionModel(min_child_weight=min_child_weight, objective="reg:absoluteerror", **kwargs) \
+            .with_feature_generator(FeatureGeneratorWindowColumnsFlat(window_size, feature_columns)) \
+            .with_name("XGBoostWin")
+
+    @classmethod
+    def create_xgb_window_opt(cls, window_size=12):
+        params = {'colsample_bytree': 0.2867610159931737, 'gamma': 8.62166097248104, 'max_depth': 4, 'min_child_weight': 12.0,
+            'reg_lambda': 0.7172266188561198}
+        return cls.create_xgb_window(window_size=window_size, **params)
+
+    @classmethod
+    def create_mean_past_year_week(cls):
+        return MeanPastYearWeekModel().with_name("MeanPastYearWeek")
+
+    @classmethod
+    def create_glm_benchmark(cls):
+        return GeneralisedLinearModel()
diff --git a/examples/dengue-fever-time-series/dengai/models/rnn_mlp.py b/examples/dengue-fever-time-series/dengai/models/rnn_mlp.py
new file mode 100644
index 000000000..00f701333
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/models/rnn_mlp.py
@@ -0,0 +1,95 @@
+from typing import Union, List, Optional, Sequence
+
+import numpy as np
+import pandas as pd
+import torch
+
+from ..data import COLS_FEATURES
+from ..features import COL_FGEN_HISTORY_WINDOW, FeatureGeneratorHistoryWeekWindow
+from ..vectorisers import AutoregressiveResultHandler, \
+    create_history_sequence_vectoriser
+from sensai.data_transformation import SkLearnTransformerFactoryFactory, DFTSkLearnTransformer
+from sensai.torch import TorchVectorRegressionModel, TorchModel, NNOptimiserParams, Tensoriser
+from sensai.torch.torch_models.mlp.mlp_modules import MultiLayerPerceptron
+
+
+class RnnMlp(TorchVectorRegressionModel):
+    def __init__(self, nn_optimiser_params: NNOptimiserParams,
+            rnn_hidden_dim: int,
+            mlp_hidden_dims: Sequence[int], mlp_dropout: float,
+            week_window_size: int,
+            use_rnn=True,
+            feature_columns: Optional[List[str]] = None,
+            auto_regressive=False):
+        super().__init__(self._create_torch_model, nn_optimiser_params=nn_optimiser_params)
+        self.window_size = week_window_size
+        self.use_rnn = use_rnn
+        self.rnn_hidden_dim = rnn_hidden_dim
+        self.mlp_dropout = mlp_dropout
+        self.mlp_hidden_dims = mlp_hidden_dims
+        self.use_positional_encoding = False
+        if feature_columns is None:
+            feature_columns = COLS_FEATURES
+        target_transformer_factory = SkLearnTransformerFactoryFactory.MaxAbsScaler()
+        autoregressive_result_handler: Optional[AutoregressiveResultHandler] = None
+        if auto_regressive:
+            autoregressive_result_handler = AutoregressiveResultHandler()
+            self.with_autoregressive_result_handler(autoregressive_result_handler)
+        self.history_vectoriser = create_history_sequence_vectoriser(feature_columns, auto_regressive,
+            target_transformer_factory, autoregressive_result_handler)
+        self.time_series_dim: Optional[int] = None
+        self.with_feature_generator(FeatureGeneratorHistoryWeekWindow(week_window_size))
+        self.with_input_tensoriser(self.InputTensoriser(self))
+        self.with_target_transformer(DFTSkLearnTransformer(target_transformer_factory()))
+
+    def _create_torch_model(self):
+        return self.TorchModel(self)
+
+    class InputTensoriser(Tensoriser):
+        def __init__(self, model: "RnnMlp"):
+            self.model = model
+
+        def fit(self, df: pd.DataFrame, model=None):
+            windows = df[COL_FGEN_HISTORY_WINDOW]
+            self.model.history_vectoriser.fit(windows)
+            dim = model.history_vectoriser.get_vector_dim(windows.iloc[0])
+            if self.model.use_positional_encoding:
+                dim += 1
+            self.model.time_series_dim = dim
+
+        def _tensorise(self, df: pd.DataFrame) -> Union[torch.Tensor, List[torch.Tensor]]:
+            vector_seq_list, _ = self.model.history_vectoriser.apply_multi(df[COL_FGEN_HISTORY_WINDOW])
+            x = torch.tensor(np.stack(vector_seq_list), dtype=torch.float)
+
+            if self.model.use_positional_encoding:
+                pos = torch.tensor(np.linspace(0, 1, self.model.window_size), dtype=torch.float) \
+                    .view(self.model.window_size, 1)
+                pos = pos.repeat(x.shape[0], 1).view(x.shape[0], self.model.window_size, 1)
+                x = torch.cat([x, pos], dim=-1)
+
+            return x
+
+    class TorchModel(TorchModel):
+        def __init__(self, parent: "RnnMlp"):
+            super().__init__(cuda=False)
+            self.parent = parent
+
+        def create_torch_module(self) -> torch.nn.Module:
+            return self.RnnMlpModule(self.parent)
+
+        class RnnMlpModule(torch.nn.Module):
+            def __init__(self, parent: "RnnMlp"):
+                super().__init__()
+                self.use_rnn = parent.use_rnn
+                self.lstm = torch.nn.LSTM(input_size=parent.time_series_dim, hidden_size=parent.rnn_hidden_dim, batch_first=True)
+                mlp_input_dim = parent.rnn_hidden_dim if self.use_rnn else parent.time_series_dim * parent.window_size
+                self.mlp = MultiLayerPerceptron(mlp_input_dim, 1, hidden_dims=parent.mlp_hidden_dims,
+                    hid_activation_fn=torch.relu, output_activation_fn=None, p_dropout=parent.mlp_dropout)
+
+            def forward(self, x):
+                if self.use_rnn:
+                    _, (l, _) = self.lstm(x)
+                    l = l.squeeze(0)
+                else:
+                    l = x.view(x.shape[0], x.shape[1] * x.shape[2])
+                return self.mlp(l)
diff --git a/examples/dengue-fever-time-series/dengai/prediction_problem.py b/examples/dengue-fever-time-series/dengai/prediction_problem.py
new file mode 100644
index 000000000..473a350fc
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/prediction_problem.py
@@ -0,0 +1,44 @@
+from typing import List
+
+from .data import Dataset, CITY_SAN_JUAN, CITY_IQUITOS
+from sensai.evaluation import MultiDataModelEvaluation, VectorModelCrossValidatorParams, \
+    RegressionEvaluatorParams
+from sensai.evaluation.crossval import CrossValidationSplitterNested
+from sensai.evaluation.eval_stats import RegressionMetricMAE
+from sensai.evaluation.metric_computation import MetricComputationMultiData
+from sensai.util.string import ToStringMixin, TagBuilder
+
+
+class DengaiPrediction(ToStringMixin):
+    def __init__(self, week_window_size: int = 12, city_only=None, test_fraction=0.2, cv_folds=3, cv_test_fraction=0.2):
+        self.test_fraction = test_fraction
+        self.cv_test_fraction = cv_test_fraction
+        self.cv_folds = cv_folds
+        self.city_only = city_only
+        self.week_window_size = week_window_size
+        self.dataset = Dataset()
+        self.evaluator_params = RegressionEvaluatorParams(fractional_split_test_fraction=test_fraction,
+            fractional_split_shuffle=False)
+        self.cross_validator_params = VectorModelCrossValidatorParams(folds=cv_folds,
+            splitter=CrossValidationSplitterNested(cv_test_fraction))
+        self.io_data_dict = {city: self.dataset.create_io_data(city, min_window_size=self.week_window_size)
+            for city in [CITY_SAN_JUAN, CITY_IQUITOS]
+            if city_only is None or city_only == city}
+
+    def experiment_tag(self, use_cross_validation: bool):
+        return TagBuilder().with_alternative(self.city_only is None, "combined", self.city_only) \
+            .with_conditional(use_cross_validation, f"cv{self.cv_folds}-{self.cv_test_fraction}") \
+            .with_conditional(not use_cross_validation and self.test_fraction != 0.2, f"split{self.test_fraction}") \
+            .build()
+
+    def _tostring_excludes(self) -> List[str]:
+        return ["io_data_dict"]
+
+    def create_multi_data_evaluator(self):
+        return MultiDataModelEvaluation(self.io_data_dict, key_name="city", evaluator_params=self.evaluator_params,
+            cross_validator_params=self.cross_validator_params)
+
+    def create_metric_computation(self, use_cross_validation: bool):
+        ev = self.create_multi_data_evaluator()
+        return MetricComputationMultiData(ev, use_cross_validation=use_cross_validation, metric=RegressionMetricMAE(),
+            use_combined_eval_stats=True)
diff --git a/examples/dengue-fever-time-series/dengai/vectorisers.py b/examples/dengue-fever-time-series/dengai/vectorisers.py
new file mode 100644
index 000000000..c67d5b114
--- /dev/null
+++ b/examples/dengue-fever-time-series/dengai/vectorisers.py
@@ -0,0 +1,80 @@
+from typing import Optional, List, Callable
+
+import numpy as np
+import pandas as pd
+
+from .data import WeekDataPointInWindow, COL_TARGET, COLS_FEATURES_STD, COLS_FEATURES_NONSTD
+from sensai.data_transformation import SkLearnTransformerFactoryFactory
+from sensai.torch import TorchAutoregressiveResultHandler
+from sensai.vectoriser import Vectoriser, SequenceVectoriser
+
+
+class InputFeatureVectoriser(Vectoriser[WeekDataPointInWindow]):
+    def __init__(self, col: str, transformer):
+        self.col = col
+        super().__init__(self._get_value, transformer=transformer)
+
+    def _get_value(self, w: WeekDataPointInWindow) -> float:
+        return w.week_data_point.get_value(self.col, imputed=True)
+
+
+class AutoregressiveResultHandler(TorchAutoregressiveResultHandler):
+    def __init__(self):
+        self.results = {}
+        self.min_index = None
+
+    def clear_results(self):
+        self.__init__()
+
+    def save_results(self, input_df: pd.DataFrame, results: np.ndarray) -> None:
+        for t, result_arr in zip(input_df.itertuples(), results):
+            if self.min_index is None:
+                self.min_index = t.Index
+            self.results[t.Index] = result_arr[0]
+
+    def get_result(self, w: WeekDataPointInWindow) -> Optional[float]:
+        index = w.week_data_point.get_index()
+        result = self.results.get(index)
+        if self.min_index is not None and index >= self.min_index and result is None:
+            raise AssertionError("Expected result was not previously stored")
+        return result
+
+
+class AutoregressiveFeatureVectoriser(Vectoriser[WeekDataPointInWindow]):
+    def __init__(self, transformer, current_value=-3,
+            result_handler: Optional[AutoregressiveResultHandler] = None):
+        super().__init__(self._get_value, transformer=transformer)
+        self.current_value = current_value
+        self.result_handler = result_handler
+
+    def _get_value(self, w: WeekDataPointInWindow) -> float:
+        if w.is_current():
+            return self.current_value
+        else:
+            if self.result_handler is not None:
+                value = self.result_handler.get_result(w)
+                if value is not None:
+                    return value
+            return w.week_data_point.get_value(COL_TARGET)
+
+
+def create_history_sequence_vectoriser(feature_columns: List[str], auto_regressive: bool, target_transformer_factory: Callable,
+        autoregressive_result_handler: Optional[AutoregressiveResultHandler] = None):
+    vectorisers = []
+    if auto_regressive:
+        vectorisers.append(AutoregressiveFeatureVectoriser(target_transformer_factory(),
+            result_handler=autoregressive_result_handler))
+    std_transformer_factory = SkLearnTransformerFactoryFactory.StandardScaler()
+    vectorisers.extend([InputFeatureVectoriser(col, std_transformer_factory()) for col in feature_columns
+        if col in COLS_FEATURES_STD])
+    nonstd_transformer_factory = SkLearnTransformerFactoryFactory.MaxAbsScaler()
+    vectorisers.extend([InputFeatureVectoriser(col, nonstd_transformer_factory()) for col in feature_columns
+        if col in COLS_FEATURES_NONSTD])
+    return SequenceVectoriser(vectorisers, fitting_mode=SequenceVectoriser.FittingMode.UNIQUE,
+        unique_id_provider=WeekDataPointInWindow.IdentifierProvider())
+
+
+def create_target_sequence_vectoriser(history_sequence_vectoriser: SequenceVectoriser):
+    return SequenceVectoriser([v for v in history_sequence_vectoriser.vectorisers if not isinstance(v, AutoregressiveFeatureVectoriser)],
+        unique_id_provider=WeekDataPointInWindow.IdentifierProvider(),
+        refit_vectorisers=False)
diff --git a/examples/dengue-fever-time-series/environment.yml b/examples/dengue-fever-time-series/environment.yml
new file mode 100644
index 000000000..2439cf821
--- /dev/null
+++ b/examples/dengue-fever-time-series/environment.yml
@@ -0,0 +1,19 @@
+name: dengai
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+dependencies:
+  - python=3.10
+  - pip
+  - pytorch
+  - scikit-learn
+  - scipy
+  - pandas
+  - matplotlib
+  - seaborn
+  - xgboost
+  - mlflow
+  - hyperopt
+  - pip:
+      - jupyter
diff --git a/examples/dengue-fever-time-series/nb_data_analysis.ipynb b/examples/dengue-fever-time-series/nb_data_analysis.ipynb
new file mode 100644
index 000000000..19fc1b0cd
--- /dev/null
+++ b/examples/dengue-fever-time-series/nb_data_analysis.ipynb
@@ -0,0 +1,604 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:27:56.582501400Z",
+     "start_time": "2023-08-01T11:27:56.083023200Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from dengai.data import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [],
+   "source": [
+    "dataset = Dataset()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:27:56.691136500Z",
+     "start_time": "2023-08-01T11:27:56.584500600Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [],
+   "source": [
+    "df = dataset.df\n",
+    "df_iq, df_sj = dataset.df_iq, dataset.df_sj"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:27:56.790625400Z",
+     "start_time": "2023-08-01T11:27:56.689070700Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "city                                       0\nyear                                       0\nweekofyear                                 0\nweek_start_date                            0\nndvi_ne                                  237\nndvi_nw                                   63\nndvi_se                                   23\nndvi_sw                                   23\nprecipitation_amt_mm                      15\nreanalysis_air_temp_k                     12\nreanalysis_avg_temp_k                     12\nreanalysis_dew_point_temp_k               12\nreanalysis_max_air_temp_k                 12\nreanalysis_min_air_temp_k                 12\nreanalysis_precip_amt_kg_per_m2           12\nreanalysis_relative_humidity_percent      12\nreanalysis_sat_precip_amt_mm              15\nreanalysis_specific_humidity_g_per_kg     12\nreanalysis_tdtr_k                         12\nstation_avg_temp_c                        55\nstation_diur_temp_rng_c                   55\nstation_max_temp_c                        23\nstation_min_temp_c                        23\nstation_precip_mm                         27\ntotal_cases                              416\ndtype: int64"
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.isna().sum()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:27:56.891455800Z",
+     "start_time": "2023-08-01T11:27:56.779623100Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Axes: xlabel='week_start_date'>"
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df_iq.plot(x=COL_WEEK_START_DATE, y=COL_TARGET)\n",
+    "df_sj.plot(x=COL_WEEK_START_DATE, y=COL_TARGET)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:27:57.909620400Z",
+     "start_time": "2023-08-01T11:27:56.886456800Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "NOTE: It looks like the Iquitos data prior to 2002 is flawed."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n",
+      "C:\\Users\\DominikJain\\miniconda3\\envs\\dengai\\lib\\site-packages\\seaborn\\axisgrid.py:118: UserWarning: The figure layout has changed to tight\n",
+      "  self._figure.tight_layout(*args, **kwargs)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAHpCAYAAABN+X+UAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAArO0lEQVR4nO3de3CU9b3H8c9uLiQGaRLJQTtSLSYBkdCExJAIh5uNtIUA5SJ1MArUaqmnTj1yE/BA4SBoj1Zjp1VAjAgVJyjaUG71jK0tEEgKkowzscmZIzd7QMJFlpDb7u/8QUlZyGVXNru/Ne/XTGfM8/z2eb7f/U357PPss8/jMMYYAQAAKzlDXQAAAGgbQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGJdLqiNMXK73eLn4wCAcNDlgtrj8eijjz6Sx+MJyLYqKioCsq1QCPf6pfDvIdzrl+jBBuFev0QP7elyQR1Ixhg1NTWF7dF5uNcvhX8P4V6/RA82CPf6JXpoD0ENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALBYZ6gLCXXLf29VsJHezu80xHiPFREUEsSoAwFcFQX2NoqOj9MCr++RwtD1m3czs4BUEAPhK4dQ3AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMVCGtRut1sFBQWaP39+y7KDBw9qypQpysjI0KhRo1RcXOz1ms2bNysvL0/p6emaOHGiDhw4EOyyAQAImpAG9a9+9SuVl5e3/H327Fk9/PDDmjBhgsrKyrR8+XKtWLFCFRUVkqS9e/dq2bJlWrlypcrKyjRu3DjNmjVLFy5cCFULAAB0qshQ7XjPnj3auXOn7rnnnpZlO3fuVHx8vKZNmyZJys3NVX5+vjZs2KCBAwequLhYY8aMUWZmpiRp+vTpeuutt7R161ZNmjTJr/273e5r7uHiNhySMTJytDnOBGh/gXapJhtr81W49xDu9Uv0YINwr1/qej1ERET4vN2QBHVtba0WLlyoX//61yoqKmpZXl1drdTUVK+xycnJ2rRpkySppqbmqkBOTk5WVVWV3zVUVlb6X3gr+qcNlOv8+XbHeDwefVRZEZD9dYZAvRehFO49hHv9Ej3YINzrl7pOD5cOOH0R9KD2eDyaM2eOZsyYoX79+nmtO3/+vGJjY72WxcTEqK6uzqf1/khLS/PrE01r3G633JK6x8VJjraPqJ1Op9LT069pX53B7XarsrIyIO9FqIR7D+Fev0QPNgj3+iV6aE/Qg/qVV15RdHS0CgoKrloXGxurc+fOeS2rr69XXFxcy/r6+vqr1ickJPhdR0REREDeSLfbIzkc7eW0HPLvNEewBeq9CKVw7yHc65fowQbhXr9ED60JelC/9957OnHihLKysiSpJXjff/99zZ07V7t27fIaX1NTo5SUFElSSkqKqqurr1o/bNiwIFQOAEDwBf2q7+3bt2v//v0qLy9XeXm5xo4dq7Fjx6q8vFx5eXk6efKkioqK1NTUpNLSUpWUlLR8Lz158mSVlJSotLRUTU1NKioqUm1trfLy8oLdBgAAQRGyq75bk5CQoLVr12r58uUqLCxUYmKiFi1apJycHEkXrwJfvHixlixZouPHjys5OVmrV69WfHx8aAsHAKCThDyoV65c6fV3WlqaNm7c2Ob48ePHa/z48Z1dFgAAVuAWogAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALBaSoN6zZ4+mTJmiQYMGaciQIVq2bJnq6+slSQcPHtSUKVOUkZGhUaNGqbi42Ou1mzdvVl5entLT0zVx4kQdOHAgFC0AABAUQQ/qU6dO6ZFHHtF9992n8vJybd68Wfv27dOqVat09uxZPfzww5owYYLKysq0fPlyrVixQhUVFZKkvXv3atmyZVq5cqXKyso0btw4zZo1SxcuXAh2GwAABEXQgzoxMVG7d+/WxIkT5XA4dObMGTU0NCgxMVE7d+5UfHy8pk2bpsjISOXm5io/P18bNmyQJBUXF2vMmDHKzMxUVFSUpk+froSEBG3dujXYbQAAEBSRodhp9+7dJUnDhw/X8ePHlZWVpYkTJ+qFF15Qamqq19jk5GRt2rRJklRTU6NJkyZdtb6qqsrvGtxu95es/sptOCRjZORoc5wJ0P4C7VJNNtbmq3DvIdzrl+jBBuFev9T1eoiIiPB5uyEJ6kt27typs2fPavbs2XrsscfUq1cvxcbGeo2JiYlRXV2dJOn8+fPtrvdHZWXlly/8Mv3TBsp1/ny7Yzwejz6qrAjI/jpDoN6LUAr3HsK9fokebBDu9Utdp4fMzEyftxfSoI6JiVFMTIzmzJmjKVOmqKCgQOfOnfMaU19fr7i4OElSbGxsy0Vnl69PSEjwe99paWl+faJpjdvtlltS97g4ydH2EbXT6VR6evo17aszuN1uVVZWBuS9CJVw7yHc65fowQbhXr9ED+0JelDv379fCxYs0O9+9ztFR0dLkhobGxUVFaXk5GTt2rXLa3xNTY1SUlIkSSkpKaqurr5q/bBhw/yuIyIiIiBvpNvtkRyO9nJaDvl3miPYAvVehFK49xDu9Uv0YINwr1+ih9YE/WKyvn37qr6+Xs8995waGxt17NgxPfPMM5o8ebJGjx6tkydPqqioSE1NTSotLVVJSUnL99KTJ09WSUmJSktL1dTUpKKiItXW1iovLy/YbQAAEBRBP6KOi4vTmjVr9PTTT2vIkCG6/vrrlZ+fr0cffVTR0dFau3atli9frsLCQiUmJmrRokXKycmRJOXm5mrx4sVasmSJjh8/ruTkZK1evVrx8fHBbgMAgKAIyXfUycnJWrt2bavr0tLStHHjxjZfO378eI0fP76zSgMAwCrcQhQAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWC1hQu1yuQG0KAAD8g99BnZ2d3eryESNGXGstAADgCpG+DDp06JD+4z/+Q8YYuVwuPfDAA17rXS6XevTo0SkFAgDQlfkU1LfccovuuecenT59Wvv377/qqDo6OlqjRo3qlAIBAOjKfApqSZo2bZok6eabb9aECRM6qx4AAHAZn4P6kgkTJqiiokL/+7//K2PMVesAAEDg+B3Uzz//vFavXq2kpCRFRv7z5Q6Hg6AGACDA/A7q9957Ty+//LKGDx/eGfUAAIDL+P3zrLq6Og0bNqwzagEAAFfwO6hHjBihkpKSzqgFAABcwe9T3w0NDZo/f75efvll9ezZ02vdunXrAlYYAAD4EkGdmpqq1NTUzqgFAABcwe+g/rd/+7fOqAMAALTC76B+8skn21y3YsWKayoGAAB4u+anZ50+fVrbtm3TddddF4h6AADAZfw+om7tqHn37t367W9/G5CCAADAPwXkedR33XWXSktLA7EpAABwGb+PqK/U3NysLVu2KDExMRD1AACAy/gd1P369ZPD4fBaFhERoYULFwasKAAAcJHfQX3lTU2cTqduueUWJSUlBawoAABwkd/fUWdnZysrK0sxMTE6efKkJOmGG24IeGEAAOBLHFF//vnn+vGPf6yqqirFx8fr9OnTuvXWW7V27VrdeOONnVEjAABdlt9H1M8884xuvfVW7du3T7t27dLevXt1++23c7MTAAA6gd9H1KWlpdq+fbvi4uIkSddff72WLFmiu+++O+DFAQDQ1fl9RO3xeK666tvhcCgqKipgRQEAgIv8DurBgwdryZIlqqurkySdP39eS5YsUXZ2dsCLAwCgq/P71PecOXM0Y8YMZWdnKz4+XmfOnNFtt92mVatWdUZ9AAB0aX4FtTFGzc3N+v3vf6/y8nLV1tbq2LFj+uEPf6iIiIjOqhEAgC7L51PfdXV1uu+++/Tss88qMjJSOTk5ysnJ0a9+9SsVFBS0nAoHAACB43NQ/+Y3v1FUVJR+/vOftyy74YYb9MEHH6i5uVmvvPJKpxQIAEBX5nNQ79ixQ//5n/951V3IbrjhBv385z/X9u3bA14cAABdnc9BXVtbq1tuuaXVdbfffrs+//zzgBUFAAAu8jmou3fvrtOnT7e67syZM4qNjQ1YUQAA4CKfgzo3N1cbNmxodd1vf/tbpaenB6omAADwDz7/POuRRx7RxIkTdfr0aX3ve99TUlKSTpw4oW3btuntt9/W+vXrO7NOAAC6JJ+D+pvf/KZeffVVLV68WBs2bJDD4ZAxRqmpqVq9erUGDBjQmXUCANAl+XXDk0GDBqmkpERHjhzRqVOnlJSUpK9//eudVRsAAF2e37cQlaTevXurd+/ega4FAABcwe+HcgAAgOAhqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgsZAEdVVVlWbMmKHs7GwNGTJEc+fO1alTpyRJBw8e1JQpU5SRkaFRo0apuLjY67WbN29WXl6e0tPTNXHiRB04cCAULQAAEBRBD+r6+no99NBDysjI0F/+8hdt2bJFZ86c0YIFC3T27Fk9/PDDmjBhgsrKyrR8+XKtWLFCFRUVkqS9e/dq2bJlWrlypcrKyjRu3DjNmjVLFy5cCHYbAAAExZd6HvW1+Oyzz9SvXz89+uijioiIUHR0tKZOnaq5c+dq586dio+P17Rp0yRJubm5ys/P14YNGzRw4EAVFxdrzJgxyszMlCRNnz5db731lrZu3apJkyb5VYfb7b7mXi5uwyEZIyNHm+NMgPYXaJdqsrE2X4V7D+Fev0QPNgj3+qWu10NERITP2w16UPfp00dr1qzxWrZjxw7dcccdqq6uVmpqqte65ORkbdq0SZJUU1NzVSAnJyerqqrK7zoqKyv9fk1r+qcNlOv8+XbHeDwefVRZEZD9dYZAvRehFO49hHv9Ej3YINzrl7pOD5cOOH0R9KC+nDFGL7zwgj744AOtX79e69atU2xsrNeYmJgY1dXVSZLOnz/f7np/pKWl+fWJpjVut1tuSd3j4iRH20fUTqdT6enp17SvzuB2u1VZWRmQ9yJUwr2HcK9fogcbhHv9Ej20J2RB7XK59OSTT+rjjz/W+vXr1bdvX8XGxurcuXNe4+rr6xUXFydJio2NVX19/VXrExIS/N5/REREQN5It9sjORzt5bQc8u80R7AF6r0IpXDvIdzrl+jBBuFev0QPrQnJVd+HDx/WpEmT5HK5tGnTJvXt21eSlJqaqurqaq+xNTU1SklJkSSlpKS0ux4AgK+aoAf12bNn9eCDD2rQoEF69dVXlZiY2LIuLy9PJ0+eVFFRkZqamlRaWqqSkpKW76UnT56skpISlZaWqqmpSUVFRaqtrVVeXl6w2wAAICiCfur7nXfe0WeffaZt27Zp+/btXusOHDigtWvXavny5SosLFRiYqIWLVqknJwcSRevAl+8eLGWLFmi48ePKzk5WatXr1Z8fHyw2wAAICiCHtQzZszQjBkz2lyflpamjRs3trl+/PjxGj9+fGeUBgCAdbiFKAAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLRYa6gK7A7ZEam93tjvEYKSYqIkgVAQDCBUEdBE6n9MDafe2OWTczOyD7qm9yy+lofwwfCgAgfBDUXzFOR/A+FAAAOh/fUQMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAx7kxmCe4HDgBoDUFtiWDeDxwAED449Q0AgMUIagAALMap7zDiy/fYxo/tGEn90waq2UjuK7bL9+EAYAeCOoz48j326z58j31pO8ZILpdL3bt3l+OKZ1jzfTgA2IFT3wAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsFhnqAmAnt0dqbHa3O8ZjpJioiCBVBABdE0GNVjmd0gNr97U7Zt3M7CBVAwBdF6e+AQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBh3JsOXxm1GAaDzEdT40rjNKAB0Pk59AwBgMYIaAACLEdQAAFgspEF96tQp5eXlae/evS3LDh48qClTpigjI0OjRo1ScXGx12s2b96svLw8paena+LEiTpw4ECwywYAIGhCFtR//etfNXXqVB0+fLhl2dmzZ/Xwww9rwoQJKisr0/Lly7VixQpVVFRIkvbu3atly5Zp5cqVKisr07hx4zRr1ixduHAhVG0AANCpQhLUmzdv1uzZs/X44497Ld+5c6fi4+M1bdo0RUZGKjc3V/n5+dqwYYMkqbi4WGPGjFFmZqaioqI0ffp0JSQkaOvWraFoAwCATheSn2cNHTpU+fn5ioyM9Arr6upqpaameo1NTk7Wpk2bJEk1NTWaNGnSVeurqqr8rsHtbv/3v75vwyEZIyNHu2ON6Xh7QR9zaWAb9QdiX0aBea/bcmnbnbmPzhTu9Uv0YINwr1/qej1ERPh+f4mQBHVSUlKry8+fP6/Y2FivZTExMaqrq/NpvT8qKyv9fk1r+qcNlOv8+Q7HuVwua8e0VX8g9uXxePRRZUWH27lWgZrPUAn3+iV6sEG41y91nR4yMzN93p5VNzyJjY3VuXPnvJbV19crLi6uZX19ff1V6xMSEvzeV1paml+faFrjdrvlltQ9Lk5ytH9E3b179w63F/Qxxsh1/nyb9QdiX06nU+np6R1u58tyu92qrKwMyHyGQrjXL9GDDcK9foke2mNVUKempmrXrl1ey2pqapSSkiJJSklJUXV19VXrhw0b5ve+IiIiAvJGut0eyeHoKKc7XB+KMS2nu9uoPxD7csi/UzxfVqDmM1TCvX6JHmwQ7vVL9NAaq35HnZeXp5MnT6qoqEhNTU0qLS1VSUlJy/fSkydPVklJiUpLS9XU1KSioiLV1tYqLy8vxJUDANA5rDqiTkhI0Nq1a7V8+XIVFhYqMTFRixYtUk5OjiQpNzdXixcv1pIlS3T8+HElJydr9erVio+PD23hAAB0kpAH9SeffOL1d1pamjZu3Njm+PHjx2v8+PGdXRYAAFaw6tQ3AADwRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLhfxe3/hqc3ukxmZ3u2M8RoqJCu/H2gFAZyGo0amcTumBtfvaHbNuZnaQqgGA8MOpbwAALEZQAwBgMYIaAACLEdQAAFiMi8kQFuqb3HI6rl5uJPVPG6hmIzU1ubl6HMBXDkGNsOB0tH71uDGSy+VS9+7d9cYPuXocwFcPQY2Q8+W31iZItQCAbQhqhJwvv7V+nd9aA+iiuJgMAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFgsMtQFAIHi9kiNze52x3iMFBMVEaSKAODaEdT4ynA6pQfW7mt3zLqZ2UGqBgACg1PfAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAW417fwBXqm9xyOtofw8M9AAQLQQ1cweng4R4A7MGpbwAALEZQAwBgMYIaAACLEdQAAFiMi8mAL8HtkRqb3e2O4cpwAIFAUKNL8SVgjQ/bcTq5MhxAcBDU6FJ8CdjXgxiwTW6pf9pANRvJ3cYHCI7Mga6NoAZCyOGUJr34R3Xv3l2ONm6ywpE50LVxMRkAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxrvoGOokvv9kGgI4Q1EAnse032wDCE6e+AQCwGEfUwFdAfZNbzjZumHIJdzgDwlNYBnVtba2eeuop7du3TxERERo3bpzmzZunyMiwbAe4Zk5Hx6fZX5uezYNEgDAUlsn2s5/9TL169dKf//xnnTx5UrNmzVJRUZEeeuihUJcGBBwPEgG6trAL6kOHDmnfvn368MMPFRsbq969e+snP/mJfvGLX/gU1MZc/CetsbFRERHXduTgdrvllkPRDqM2b9T8j3FRHZyWDM0Yo24RarV+e2u+0j97sKMe/8e0NQeXGOPWD1/7a7vbeeWBzIDU09jkVrO74yvVPZ6LwX9J3/53qKHZLV32geLKMb5sJ5Rj+va/QxcamxUdEZwr9ZvcF+/13h7jkXw5weH+x5wF4t+1UAllD77MhdTxfPjTQ0REhJxOpxztZMclDnMpucLE+++/r4ULF2rv3r0tyz755BONGzdOZWVl6tGjR7uvb2xsVGVlZWeXCQBAu9LT0336UBJ2R9Tnz59XbGys17JLf9fV1XUY1JGRkUpLS/P5kwwAAJ3B2dFpoH8Iu6C+7rrrdOHCBa9ll/6Oi4vr8PVOp1PR0dGdUhsAAIEWdr+jTklJ0ZkzZ3Ty5MmWZf/zP/+jG2+8Uddff30IKwMAIPDCLqhvvfVWZWZm6umnn5bL5dKRI0f061//WpMnTw51aQAABFzYXUwmSSdPntTSpUu1d+9eOZ1OTZgwQbNnzw7bqx0BAGhLWAY1AABdRdid+gYAoCshqAEAsBhBDQCAxQhqAAAsRlB/CbW1tfrJT36irKwsDR48WMuXL1dzc3Ooy2rX1q1b1b9/f2VkZLT8b86cOZKkgwcPasqUKcrIyNCoUaNUXFwc4mq9nTp1Snl5eV63je2o5s2bNysvL0/p6emaOHGiDhw4EOyyW7RW/+LFizVgwACv+Xjrrbda1ttSf1VVlWbMmKHs7GwNGTJEc+fO1alTpySFzxy010M4zMOePXs0ZcoUDRo0SEOGDNGyZctUX18vKXzmoL0ewmEOLnG73SooKND8+fNblgVlDgz8dv/995snnnjC1NXVmcOHD5sxY8aY1atXh7qsdq1cudLMnz//quVnzpwx2dnZZv369aapqcns3r3bZGRkmIMHD4agyquVl5ebb3/72yY1NdWUlpYaYzquubS01GRkZJjy8nLT2NhoXnvtNTN48GBTV1dnRf3GGPP973/fvPPOO62+xpb6L1y4YIYMGWJefPFF09DQYE6dOmV+9KMfmUceeSRs5qC9Hoyxfx5qa2tNWlqaefvtt43b7TbHjx83Y8eONS+++GLYzEF7PRhj/xxc7oUXXjD9+vUz8+bNM8YE798ijqj9dOnpXXPmzPF6eteGDRtCXVq7KisrNWDAgKuW79y5U/Hx8Zo2bZoiIyOVm5ur/Px8K/rZvHmzZs+erccff9xreUc1FxcXa8yYMcrMzFRUVJSmT5+uhIQEbd261Yr6Gxsb9be//a3V+ZDsqf+zzz5Tv3799Oijjyo6OloJCQmaOnWqysrKwmYO2ushHOYhMTFRu3fv1sSJE+VwOHTmzBk1NDQoMTExbOagvR7CYQ4u2bNnj3bu3Kl77rmnZVmw5oCg9lN1dbXi4+PVq1evlmW33XabPvvsM33xxRchrKxtHo9HH3/8sf74xz9q5MiRGjZsmJ566imdPXtW1dXVSk1N9RqfnJysqqqqEFX7T0OHDtUf/vAHfe973/Na3lHNNTU1VvTUVv1VVVVqbm5WYWGh7rrrLo0ePVqrVq2Sx+ORZE/9ffr00Zo1a7xuJLRjxw7dcccdYTMH7fUQLvPQvXt3SdLw4cOVn5+vpKQkTZw4MWzmQGq7h3CZg9raWi1cuFDPPfec10OhgjUHBLWfOnp6l41OnTql/v37a/To0dq6das2btyoTz/9VHPmzGm1n5iYGCt6SUpKUmTk1c+N6ahmW3pqq/5z584pOztbBQUF+tOf/qRf/OIXeuONN7R27VpJ9tR/OWOMfvnLX+qDDz7QwoULw2YOLndlD+E2Dzt37tSHH34op9Opxx57LCzn4MoewmEOPB6P5syZoxkzZqhfv35e64I1BwS1n6716V2h0LNnT23YsEGTJ09WbGysvv71r2vOnDn68MMPZYxpuajjkvr6emt7kS5+MGqv5o7Wh9qQIUO0bt06ZWdnKyoqSgMHDtSDDz7YcjrMtvpdLpcee+wxlZSUaP369erbt2/YzUFrPYTbPMTExKhXr16aM2eO/vznP4fdHEhX9zBgwADr5+CVV15RdHS0CgoKrloXrDkgqP0Ujk/vqqqq0n/913/JXHa32MbGRjmdTg0cOFDV1dVe42tqapSSkhLsMn2Wmprabs0pKSlW9/T+++9r48aNXssaGxsVExMjya76Dx8+rEmTJsnlcmnTpk3q27evpPCag7Z6CId52L9/v77zne+osbHRq8aoqCglJyeHxRy018OuXbusn4P33ntP+/btU1ZWlrKysrRlyxZt2bJFWVlZwfv/QUAviesi7rvvPvP444+bc+fOtVz1XVhYGOqy2vT3v//dpKenm1WrVpmmpiZz7Ngxc++995oFCxaYU6dOmaysLPPaa6+ZxsZGs2fPHpORkWH27NkT6rK9XH7VdEc1X7rycs+ePS1XWt55553m9OnTVtS/c+dOM3DgQLN7927j8XjM/v37zeDBg827775rVf1nzpwxI0aMMPPnzzdut9trXbjMQXs9hMM8uFwuM3z4cPP000+bhoYGc/ToUTN58mSzePHisJmD9noIhzm40rx581qu+g7WHBDUX8Lnn39ufvrTn5rs7GyTk5NjVq5caZqbm0NdVrv27t1rpk6dajIyMkxOTo5ZtmyZqa+vN8YYU1FR0bLu7rvvNm+//XaIq73alT9v6qjmd99914wePdqkp6ebyZMnm48++ijYJXu5sv4333zT3HPPPeZb3/qWufvuu8369eu9xttQ/9q1a01qaqr51re+ZdLT073+Z0x4zEFHPYTDPFRXV5sZM2aYrKwsM3LkSPP888+bhoYGY0x4zIEx7fcQDnNwucuD2pjgzAFPzwIAwGJ8Rw0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoga+IEydO+HWz/08//bTzigmSc+fO6dSpU6EuA+hUBDVgkfLycmVkZPg09uWXX9ZDDz0kSTp58qRGjx7tc2ht2LBBTz31VMvfY8aM0e9+9zv/Cw6xvLy8q+6lDHzVXP0MPgAhk5WVpQMHDvg09sc//nHLf9fX1/t1NH1loP/+97/3+bU2OX36dKhLADodR9SAD44ePaq+ffvqjTfe0JAhQ5SZmak5c+bI5XLppZde0syZMzVp0iRlZ2errKxMLpdLS5cu1fDhw5Wbm6vHH3/c64lrH3/8sQoKCpSRkaGhQ4fqxRdflDFGe/fubXm6U3v7lKSXXnpJBQUFcrvdGjt2rCRp7Nix2rp1qxobG/XMM8/ou9/9rjIyMpSbm6tly5bJGKPNmzfrlVdeUXl5ubKysiRJo0aN0jvvvCPpYug/++yzGj58uO68804VFBSooqKipfZLNY0ePVoZGRn6wQ9+oE8++cSn97G9uiSpoKBAhYWFuu+++5Senq5x48apoqJCTzzxhAYNGqRRo0bpj3/8oyRp9OjRkqQf/ehHWr16dYf7nj9/vpYuXapHHnlEGRkZysvL0549e7Rs2TLdeeedGjJkiIqLi73e+3fffVcjR45Uenq6nnzySZWXl2vcuHHKyMjQgw8+yGl3BMe13Jwc6CqOHDliUlNTzf33329qa2vNiRMnzJQpU8zs2bNNYWGh6devn9m9e7dxuVymqanJ/PSnPzUzZ840J0+eNC6XyyxatMhMnTrVeDwec/r0aZOdnW1eeukl09DQYA4dOmSGDRtm3nzzTVNaWmpSU1M73KcxxhQWFpr777/fa+yRI0eMMcasWrXKjBkzxhw/ftwYY8z+/ftN//79ze7du696rTHGjBw5suVhAvPmzTP5+fnm008/NQ0NDaaoqMhkZGSYY8eOGWMuPmBk6tSp5sSJE+aLL74w06dPNzNnzvTpfeyorvvvv9/cddddprq62jQ0NJhp06aZO+64w/zhD38wjY2NZuXKlWbUqFEt27vyYSftmTdvnhk4cKApKyszbrfb/Pu//7u5/fbbzbp160xTU5N5/fXXzYABA0xDQ0PL+/mzn/3M1NXVmU8++cTcfvvtZty4ceb//u//TG1trcnLyzMvvfSST/sGrgVH1IAfnnzySSUmJiopKUmPPfaYtm/frsbGRvXu3Vu5ubmKi4vT2bNntWPHDi1cuFA33HCD4uLitGDBAlVWVurjjz/WBx98oG7duunRRx9VdHS0vvGNb+i1117TiBEj/Npne+69914VFRUpKSlJJ06caHlY/fHjx9t9XUNDg7Zs2aInnnhCt9xyi6Kjo/Xggw+qT58+2rJlS8u4goICJSUl6frrr9d3v/tdny9M86Wu0aNHKzk5WdHR0crKylKfPn307W9/W1FRURo2bJiOHTvm075ak5OTo6ysLDmdTuXk5Oi6665TQUGBIiMjNXLkSDU2Nnqd+Zg5c6ZiY2OVmpqqpKQkff/731evXr2UmJio9PT0a6oF8BXfUQN+uOWWW1r++6abblJjY6POnj2rf/mXf2lZfukf73vvvdfrtRERETp69Kg+//xz3XTTTXI4HC3r+vTpI0k6dOiQT/s8c+ZMu3VeuHBBS5cuVVlZmW688Ub1799fxhh5PJ52X3f27Fk1NTXp5ptv9lp+88036+jRoy1/9+zZs+W/IyMjW05dd8SXuuLj41v+OyIiQl/72tda/nY6nT7vqzVXbrtHjx4tf1+aj/ZquXz8tdYC+IqgBvxw/PjxllA9evSoYmNjlZCQ4BW6vXr1kiRt27ZNSUlJLctramrUu3dv7dixQ3//+99ljGl53fvvvy+Xy6WbbrrJ5322Z9GiRfra176mv/zlL+rWrZs8Ho/uvPPODvvr2bOnunXrpiNHjui2225rWX748GGNGjWqw9d3xJe6Ln8vA83fbXdmLYCvOPUN+OG5556Ty+XS8ePHVVhYqPHjxysy0vvzbq9evTRixAgtX75cp0+fVlNTk37zm99o8uTJ+uKLLzRixAg1Nzfr5ZdfVmNjow4fPqynn35aDQ0NPu8zKirKa0y3bt0kqeVCM5fLpW7dusnpdMrlcunZZ5+Vy+VSU1NTy3iXy3XVEaHT6dSkSZP0/PPP69ChQ2psbNTrr7+umpoajRkz5prfv47q8ld0dLTOnTt3zXUBNiOoAT984xvf0NixY1uu/F2wYEGr45599ln16NFDEyZMUE5Ojv70pz9pzZo1SkpKUo8ePfTqq69qz549Gjp0qAoKCvSDH/xAU6dO/dL77Nmzp/Ly8jR16lS9+eabWrRokaqqqpSdna3vfOc7crlc+td//Vf97W9/kySNHDlSZ86cUWZmpr744guvbc2dO1dDhw7V9OnTNXjwYG3btk2vvvqqvvnNb17ju6cO6/LX1KlT9cQTT+iXv/zlNdcG2Mph+JIF6NDRo0d1991367//+7+v+v72q7RPAPbhiBoAAItxMRmAgNixY4fmz5/f5vrMzEytWbOmU/b92muvqbCwsM31+fn5Wrp0aafsG+hsnPoGAMBinPoGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWOz/AYyTYgCww41PAAAAAElFTkSuQmCC"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 500x500 with 1 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import seaborn as sns\n",
+    "for c in COLS_FEATURES:\n",
+    "    sns.displot(data=df, x=c)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:28:04.660705Z",
+     "start_time": "2023-08-01T11:27:57.896605Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGPCAYAAABcTNrhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9eZzkZJn/N0lV9T3TPT099z3dc58cDiCKoCMejCCIuLIqIIIoKOiCq+K1yqLr/tYVQWVBFlFW5HBUkEtgQG6GY2Z6rp7u6Z7umb7vu64kvz9SSd43eZNKUqmqPvL9fGC6kjfv++TNezzvc3KyLMsIECBAgAABAgSYBuDzTUCAAAECBAgQIECuEDA+AQIECBAgQIBpg4DxCRAgQIAAAQJMGwSMT4AAAQIECBBg2iBgfAIECBAgQIAA0wYB4xMgQIAAAQIEmDYIGJ8AAQIECBAgwLRBKN8EOEUymUQ0GkUoFALPB/xagAABAgQIMBkgSRKSySQKCwsRCuWf7cg/BQ4RjUZRV1eXbzICBAgQIECAAB6wevVqlJaW5psM74xPX18fLrnkEvzoRz/Ctm3bAABPPfUUfvnLX+L48eMoLy/HhRdeiC996UuahGbnzp345S9/ie7ubqxYsQLf+c53sHXrVmeEprjE1atXIxKJAABEUcTBgwexbt06CILg9VWmHIJ+MSPoEzaCfjEj6BM2gn4xI+gTM1h9Eo/HUVdXNyGkPYBHxuett97Cv/7rv6KlpUW7tn//ftx000347//+b5x11lloamrCF77wBRQXF+OKK67A66+/jh/+8Ie46667sGnTJtx///245pprsGvXLhQVFaVtU2WeIpEIxfio14JBpyPoFzOCPmEj6Bczgj5hI+gXM4I+McOuTyaKmYprKnbu3Il/+Zd/wQ033EBdb21txac+9SmcffbZ4HkeK1euxPbt27F7924AwEMPPYSPfvSjOPnkkxEOh3HZZZehoqICjz/+uD9vEiBAgAABAgQIkAauJT5nnnkmduzYgVAoRDE/5557Ls4991ztdzQaxfPPP48dO3YAABoaGnDRRRdRdVVXV+Pw4cPMduLxOOLxuPY7kUgAULhJlaM0/htAQdAvZgR9wkbQL2YEfcJG0C9mBH1iBqtPJlr/uGZ8qqqq0pYZGRnBV7/6VRQWFuKyyy4DAIyOjppUWoWFhRgbG2PWceedd+L222/XfldUVOCOO+7AwYMHTWVra2tdvMH0QdAvZgR9wkbQL2YEfcJG0C9mBH1ixkTuE98tjRobG/GVr3wFlZWVuO+++zQL7qKiIkSjUapsNBpFRUUFs56rr74al19+ufY7kUigsbER69ato2x8amtrsXHjxkC/SiDoFzOCPmEj6BczrPpEFEVN8jwdIYoi6uvrUVNTk/FYEUURyWTSJ8ryB0mS0NzcjKVLl04Y+5Vcg+M4FBYW2u7L8XicKbRIB5YT1eHDh3Hrrbdi3759KCoqwo4dO3DjjTe6Mpz2lfF54YUX8LWvfQ2f/OQn8fWvf50ipKamBvX19VT5hoYGvPe972XWRRoxA9DUXoIgmCYd61qAoF9YCPqEjaBfzFD7RJZldHR0YGBgIN8k5RWyLCMUCuHEiRPgOM5zPaIoQpIkHynLL0KhENra2vJNRl4hyzKKiopQXV2trSPkmuJlbWE5UfX19eGyyy7D5ZdfjrvvvhudnZ34/Oc/jzlz5uDzn/+847p9Y3z27NmDL3/5y/j+97+PT3ziE6b7n/jEJ/DlL38ZH/7wh3HyySfj/vvvR29vL7Zv3+6qncDGJz2CfjEj6BM2gn4xw9gnHR0dGBoaQlVVFYqLizPa9CczZFlGNBpFYWGh5z5IJBKQJAmCIEwZCYkkSVPmXbxAlmWMjY2ho6MD9fX1WL58OQC2jc/o6Chlu2sUcKjYuXMnbrvtNtx4442ULfGf//xnLFu2DFdffTUAYNGiRbjnnntcj0dOlmXZ1RMEVq9ejfvuuw/btm3DF7/4RTz//PMmO56TTz4Zd999NwDgL3/5C371q1+hs7MT1dXVuPnmm7F582ZHbcXj8QmtMwwQIMDUBM/zmDt3LmbOnJlvUgIEmLAYHBxEZ2enrTTv85//PMbHx7Xf1157La677jpTue7ublRUVCAUClF8xvXXX48ZM2YAAJ599lkUFRXhoosuwtVXX+2K+cxI4kNGUv71r3+dtvz555+P888/P5MmAxsfBwj6xYygT9gI+sUMsk8SiQSam5tRXl7uKN7YVIYsyxgfH0dRUZEniY8kSYjH44hEIlNKQjLdJT4qZFlGT08PFi9ejObmZqaNz65duxAOh7VnWNIewNqJanBwEM888wy+//3v4zvf+Q6OHj2KL37xi4hEIvlRdeUKgY2PcwT9YkbQJ2wE/WKGIAiQJAkcx4Hn+Wmr4jKC4zhPfaE+4/X5iQhSYTJV3skrVOZP/Zdl41NSUmLJ7DhBJBLBxo0bNXOaNWvW4J//+Z/xxBNPuGJ8AjY1QIAAAQIECDDhsXLlSspGCFAkbm4tdgLGJ0BeISZi+SYhZxiOJlxP0AAB/Mbw8DD6+voclz927Fj2iJmg6Orq0mLMSZLkOIxBLDZ91rN84KKLLsKRI0dw1113QRRF1NXV4fe//71rE5qA8QmQN3Tu+zsOPPg9DLZMfaP1+s5hbPz+07jqd2/lm5QA0xzbt283hRaxwnPPPUepEK699lpH9pzZwGc+8xn84he/AAB897vfxXe/+92stNPT04Nzzz1XYw4bGxsxMjKS9rnx8XE0NDQ4bqeurg79/f2e6ZyOWLlyJX7/+9/j+eefx2mnnYYrr7wSn/rUp/CZz3zGVT2TzsYnwNRBZ+2zAIDW3X/BzCUb80xNdvHbV48BAP5+sDO/hATwBbIsQxZzF8yQE8K+2ZC42WwHBgYoKeXtt9+O4uJiX+gAlH6UHApBlbIyREnG977/AwCA6PRhAjxnb48TjUapjAJOQz2IohhIdLMA0okKADZv3oz7778/ozoDxidAgBzAw/ocYIJClmU0/v3XGO1uzlmbJVVLsWL7F10xP7/4xS/w8MMPY3x8HIsXL8aXvvQl/Md//AcA4Atf+AKuu+46XHnllbjrrrvw6KOPor29HRzH4b3vfS9uueUW7N27F9/73veQSCSwdetWPPHEE/ja176G0047DV/5ylcgSRLuvvtuPPjgg+jv78fy5cvx1a9+Fe95z3sAAOeccw4uueQSPPHEE1p046997Ws488wzASj9eLR7FGNxdgTnZ//2F/zpD/disL8fp73nbPQNjaJ7OIYDbYO4/Sf/BgC49hvfxYO/vQsH9r6NH/zXr7Rnv/TpC3DxZ6/E2R86D9/72jWomjsfB/a8BRky7vzdQ9iwdA6zL0VRxHnnnQcAOO+883D99dfjlFNOwYMPPog///nP6Orqwrx583DppZfi5JNPRnl5Ob7+9a/jpJNOwgsvvICmpibMnz8fP/zhD/HAAw9g165dKC0txZVXXolt27ahubkZt9xyCy666CL87ne/A8dxuOCCC3DjjTfaGv3G43G0t7fj0ksvxUknnYQ33ngD8+bNwze+8Q1885vfxPbt2/HYY48hHo9j8+bN+OlPf4rKykqIoog77rgDDz74IKLRKE466SSEQiGsXbsW1113HQYGBtDd3Y1EIoFIJIK5c+eirKwMgBJz5+2338avf/1rHDx4EJFIBB/+8IfxrW99KyMD5YmAQNUVIEAOEBwEA+QSr732Gv74xz/ioYcewuuvv46LL74Y3/72t/HYY48BAO666y584QtfwBNPPIH77rsPv/jFL/Dmm2/igQcewEsvvYRHH30U27Ztww9+8AMsWLAA77zzDubOnUu1cccdd+D+++/Hz3/+c7z++uu44oor8KUvfQn79u3TyjzyyCP4+c9/jldeeQWrV6/GLbfcQtVhxcbVvvMmfvOL/8QXv/Yt/Pavz6Bm3QYcrXOf8kCr7+038KPb7sL/u+t+FBeXWJYTBEHro8ceewyXXXYZ9u7di//5n//BzTffjP/93//FVVddhZ/+9KdIJpMYGhpCPB7HI488gh/+8If47W9/i6qqKlxxxRU47bTT8OCDD+IjH/kI7rvvPsyfPx/9/f3o7OxEU1MT7rrrLtx99914/vnn8ctf/tKSJlmWcezYMYRCIYTDYTQ3N+PXv/41fvrTn0KSJLS3t2N0dBS7du3Cgw8+iEOHDuE3v/kNAOCPf/wjfvvb3+LnP/85Xn75ZWzevBnPPqtI2oeHh9HW1oYFCxZg7dq1mDNnDo4fP66llmpubsb3v/99rFixArt27cLPf/5zvPXWW5q6cTIjkPgECJATBJzPVAHHcVix/YsTWtVVUFCAwcFBPPjggzj77LNx8cUX45JLLjHV8d73vhcnnXQS5s2bh76+PvT396O8vBydnelVso888giuuuoqrF+/HgDwkY98BE899RQefvhhbNq0CYASsX/p0qUAFAnKX/7yF/2dOA4rqkqY0tD7b38GHzz3g/jUeR8AAGz64hV4+enHUFVWgPULZqKiWIkFs37BTFSVFaAkImD9Aj3AZFjgsLCiCOsXzERJRMA573sf3ru5BkB6VZcRf/vb33DhhReiuroaIyMjOP/88/GPf/wDf/rTn3D99dcjmUzigx/8IFasWIFjx47hlFNOwdDQEC688EIAwPve9z789re/1dy8OY7D9773PXR1dWHOnDm48sorceedd+L6669ntj82NoZ4PI7q6mpwHIcPfehDWLduHWRZRm9vLwDghhtuQDgcxoIFC7BlyxYcP35co/3cc8/F8uXLwXEcvvSlL2HXrl0AgN7eXsyaNQslJQojOGPGDJSVlaGvrw8LFizAoUOH0N7ejuuuuw5lZWXYtm0bfvWrX02JdCMB4xMgQA4QSHymFjiOAxeauOL+rVu34he/+AV+97vf4e6770ZhYSE+85nP4JprrqHKybKMn/3sZ9i1axdmzZqFtWvXIpFw5n2oBqsjsWjRIhw+fFj7PXv2bO3vcDhsqpfjOAgMHqS7qwvr16+HwOs3lyxZDJ7jIPB6HCCB58Cn4gKRZTmOo8rOnTuHuu8GXV1d2L9/Px555BEASpwaURRx2mmnacH41GjCgCI1mjlzJpLJJNrb23H8+HHIsoyhoSGtbEVFBbq6ugAA8+fP1/5mIZFIIBQKaYzTnDlzTKqm3t5e9Pb2orCwEDzPa8xJb28vzj77bPT396OtrQ2RSATz5s3T6h0dHTV5+KmMUCgUwsyZM9Hf34+uri6UlZVhwYIFVADCyYqA8QkQIAcIGJ8AuURbWxsqKyvxm9/8BvF4HK+++iquvfZaTTqj4j//8z/R1taG5557DqWlpQCAHTt2OGpj4cKFmmRBxfHjxzFnzpyM6Z83b56p7o6ODtTU1JjK8jxPuZtLkmRKKJuJYXhlZSV27NiBT3/60xgcHER1dTXa2tpQWFhIJc82oqWlBTNmzMCSJUsAQFMVjoyMUGkbTpw4gQULFli2Hw6HkUwmNWaG4ziMjo5ifHxcM8Jevnw5CgoKNFpUg2xVkrdy5UqIooi+vj40NzejpqYG4XAY5eXlVJTkeDyuMU6VlZUYGhrCkiVLwPM8Wltb8fTTT6O7uxuXXXaZ1+6cEAhsfAIEyAGkgPMJkEPU1tbiyiuvxOHDhxGJRFBZWQkAqKioQCQSwfDwMABlEy4oKIAgCIjFYrjnnntw5MgRjZEoKCjA+Pg4kkmzAfLFF1+M//mf/8GBAwcgiiKeeOIJPPfcc/j4xz+eMf0XXXQRnnnmGezatQvJZBI7d+7E3r17mWVXrlyJuro61NfXI5lM4u6776a8stxCZSBUF/YPfehD+OMf/4jjx48jFovhxRdfxIUXXog///nP6OzsRCikyA9UiYzKoKhRv1W0t7cDUAyof/KTnyAej6O5uRm/+c1vmIm9VRQVFaGgoAAdHR2QZRmiKKK9vZ1ihniehyzLGB4epgL8nXvuuXjooYfwzjvvQJIkPP744zhy5Ag4jkNFRQV6e3u1vhobG8PRo0c1pnHmzJlYtGgRfvKTnyCRSGBgYAB33nmnqxhQExWBxCdAgBwgYHsC5BLnnnsujh07hmuuuQb9/f2orKzEt771LWzevBmXXHIJvv71r+Oyyy7D9ddfj29+85s444wzUFxcjJNPPhnnn38+jhw5AgA49dRTUVlZiVNPPRV/+MMfqDYuv/xySJKEG264Ad3d3Vi6dCn+67/+C+9617sypv/kk0/Gf/zHf+DHP/4xbrjhBpx22ml497vfzSz7gQ98AK+88gouu+wySJKECy64ACeffLLntmfPno3t27fjkksuwb/+67/ivPPOw8jICL75zW+iu7sbJSUl+MhHPoLTTz8dpaWlmtqpoKAAxcXF6OnpQTKZxMKFC9He3o6WlhYAiuRGLTtz5kx84QtfAM/z+PSnP40rr7zSkh6e57F06VK0t7cjkUigq6sLJSUlmDt3rhZcsr6+HhzHoaCgAAUFBYjFYpAkCZ/85CfR2tqKa665BolEAqeccoqW73LmzJmQJAmtra1IJBIQBAGVlZWorKxU7K9WrMB3v/td/OpXv8L73vc+hEIhfOxjH8NXvvIVz307UZBRdvZcQs3OvnHjRipJ6Z49e7Bly5YgzxCBydIv++7/VwBAqLAU6y66Oatt5btPvv7gXjzy9gkAwLEffzTn7Vsh3/0yEUH2SSKRQFNTE5YvX47CwsJ8k5ZXyLKMsbExFBcXe05SGovFUFBQMGWSesqyrCUpddInr7/+Oj772c+aYtNkC4cPH0ZZWRkWLlyoXbvwwgvxqU99Cp/85Cd9bWtsbAwNDQ1YtGgRmpqaqDWFtX/nE1Nj9AUIMMEhBzKfAAEC5BivvfYavvjFL6K7uxuyLOPxxx9HQ0MDTj/99HyTllcEqq4AAXKAySFXDRAg+6itrbU1jl2wYAH+9re/ZaXtffv24XOf+1xe2rZCQ0MD4vE4fvzjHzPtmNRs9j/4wQ/wsY99zFXd//zP/4zW1lZ8/OMfx+joKFasWIFf/epXWLx4MS688EI0NTVZPnvXXXfhlFNOcf0+kwEB4xMgQA4wSTTKAQJkHRs3bsQ777yTl7Y3bdqUt7YBYNu2bSY1V3V1NQDgvvvu8729UCiEb3/72/j2t79tuvenP/3J9/YmCwJVV4AAOUDA9gQIECDAxEDA+AQIkAMEAp/JjUBiFyCAPdQ54lcy3WwiYHwCBMgBgm1zckKNUptJXJgACtQNcSqkPAhgxujoKGRZnhTej4GNT4AAOUAQwHByQhAElJeXaykFvLpyTwXIsoxYLObYdZuFRCKBWCxGpWCY7FDd2acrZFnG6OgoOjs7UVRUNCHc1dMhYHwCBMgFAr5n0kLNbWSXT2k6QJZlJBIJhMPuEqYaIYrilJL6yLI8bZlhFbIso6ioCNXV1ZNCLRwwPgEC5ABBHJ/JC47jMH/+fMyZM4fKCTXdIIoiDh8+jOrq6oyDXYqiyEyDMdkgiqIW4HI6BwAlJT1qnrCJjIDxCRAgB5gEh6AAaSAIwrTe3NQNrbCwcFr3Awm1T2bOnBn0ySTC9FVMBgiQQwSMT4AAAQJMDASMT4AAOUBg3BwgQIAAEwMB4xMg/5gGTMHUf8MAAQIEmBwIGJ8AAXKAacDbBQgQIMCkQMD4BAiQEwScT4AAAQJMBASMT4AAOUA+JD5jPcdR99efYujEwdw3HiBAgAATFAHjEyBADpAP4+Zjz/8vYsO9OPaC/1mfAwQIEGCyImB8AgTIAfKh6BLj0Ty0GiBAgAATGwHjEyBADpAf4+bArihAgAABjAgYnwABcoB8sCCTIWdOgADpIE+hvF4BJgYCxidAgBwgYEICBHCPoROHcODB72GwpTbfpASYQggYnwABcoAgcnOAAO5x7IXfQhITaH7x/nyTEmAKIWB8AuQfHJdvCrKOgO8JECBAgImBgPEJECAHCBifAAECBJgYCBifAAFyADnwsAoQIECACYGA8QkQIAeQAr4nQIAAASYEAsYnQIBcYJozPkMnDuL4K3+ElIznm5QAAQJMc4TyTUCAANMB013VpabNCJdUYN7mD+aZmgABAkxneJb49PX1Yfv27Xj99de1a3v37sXFF1+MrVu34pxzzsFDDz1EPbNz505s374dW7ZswYUXXoh33nnHO+UBAkwiBMbNCpLjQ/kmIUCAANMcnhift956C5dccglaWlq0a4ODg7jqqqtwwQUXYPfu3bjllltw6623Yt++fQCA119/HT/84Q/x4x//GLt378bHPvYxXHPNNRgfH/fnTQIEmMAI+B4VUz90QYDMEB8dwEjH0XyTEWAKwzXjs3PnTvzLv/wLbrjhBur6008/jfLyclx66aUIhUI4/fTTsWPHDtx/vxJ46qGHHsJHP/pRnHzyyQiHw7jssstQUVGBxx9/3J83CRBgAiMIYBgggDMc/vOP0fjsXRjtOpZvUgJMUbi28TnzzDOxY8cOhEIhivmpr6/HqlWrqLLV1dV4+OGHAQANDQ246KKLTPcPHz7MbCcejyMe1w0hE4kEAEAURYiiqP1N/htAwWTpF1lWcvDIkpR1WvPdJ2TKilzRoPavXZu56heVFkmWJ/y4zPdYmajI9VgZ7mx0NIbziWCsmMHqk4nWP64Zn6qqKub10dFRFBUVUdcKCwsxNjbm6L4Rd955J26//Xbtd0VFBe644w4cPHjQVLa2NsjjwsJE75fezi4AAB8ZRnTPnpy0ma8+GR3Vx/meHL2r2r8AkEzTZrb7RaVlUDiG7og9LRMFE33+5Au5GivDDQ0YczGG84lgrJgxkfvEN6+uoqIiDA8PU9ei0ShKSkq0+9Fo1HS/oqKCWd/VV1+Nyy+/XPudSCTQ2NiIdevWIRKJAFC4yNraWmzcuBGCIPj1KpMek6Vf9h+aAwAIFZRizZYtWW0r331S9MqrAAYBAFuy/K4q1P4FgA0WbeaqX1RaZi1fgQU5en+vyPdYmajI9ViZW12NztEG7brVGM4ngrFiBqtP4vE4U2iRL/jG+KxatQovv/wyda2hoQE1NTUAgJqaGtTX15vuv/e972XWF4lENAYHgKb2EgTBNMBY1wJM/H7hOMXEjOP5nNGZtz4hbHpz1b7av07azHa/qLTwE3xMkpjo8ydfyNVYEQTB1RjOJ4KxYgbZJxOtb3wLYLh9+3b09PTg3nvvRSKRwGuvvYZHH31Us+v5xCc+gUcffRSvvfYaEokE7r33XvT29mL79u1+kRAgwIRFYNysgJsGCWkDBAgwseGbxKeiogL33HMPbrnlFtx2222YNWsWbr75Zpx22mkAgNNPPx3f+9738P3vfx+dnZ2orq7GXXfdhfLycr9ICJBDyJKI/qZ3UDp3JSKlbHVlAB0B36MiYHwmEgaO7UXBzDkoqpifb1JsETDMAfxERoxPXV0d9Xvjxo144IEHLMuff/75OP/88zNpMsAEQc/hl9D+zhPgOB4bP/3vmVU2DbiCfL7ihNo0JhIt0xwjHQ1oefkPAIBNl/44z9SwwFn8HSBAZghydQXwhJEOxeiQdDcNYI28snZcMM0nAtre/CtOvPZIvsnQMN7Xlm8SnCNgmKclWBkiVHR1deGMM87An/70J9f1BitiAE+Qp4GUxk/ks78mksRnItGSS0hiEj11r6Dv6G7ERwfyTU4Kk2cOT9dxM53ByhChQpIk/Mu//Av6+/s91T3pkpQGAQzTIxf9IkmSJu3x2o4e1G7qBzCM8EBRiMspDU6CBuY8gGEOglVmimz0iSSKWh8kE3EIE6APRDHpag7nfqyIEz7wZb7XlYkIuwCGo6OjVGBio/e2ip07d+K2227DjTfeaMoSAQB33HEH5s2bh/nzvdmmTTrGJwhg6BzZ7JehlhYkBpTgYl4Di2kBDMNFiE3xAIbfe3cJACWmVa4DGHJCGIkJEsBwKNKIDs6elokCP/tEFpPoS/VBrLYWQnE5pPgYRg8/g4L56xGpWulbW04x3qwHCHQzh7M5VmRZ1vqJDGCojuHkcDfGGl9G8fLTEZoxN2t0uEWwB5nB6pOzzz6bys957bXX4rrrrjOVs8oQAQCvvfYa/va3v+GRRx7Bjh07PNE26RifIIBheuSiX5p638RogcK5ew0spgYqEwpKsHaKBzA8//aXcLR7FACw/wfn5qRNtX/5cCHWTZAAhrNXrsS8CRiIjkQ2+kRKxnHwiNIHNRvWo2BGFQaa9+LE0XGUhoawLA990hXqQ9eYkgzUyRzOxViRJQkHDiv9NK+6Gh0jSuw3PlSAdVu24OBD30dhJAa+81Wse+/3s0KDG+R7XZmIsAtguGvXLoTDYa0sS9oDWGeI6O3txbe+9S3cdtttWnBkL5h0jE8QwNA5stkvPM9Rgca8QAtqx039AIZRERhPyhoNuYDWv3z6d85dULrQpJmrvvaJxBPfQxnvAq9c47j8BHjjed7THM7mWJEgU+NWD3ypjBtZTIDjeMhiYkKNo2APMoMVwLCkpMSS2UkHWZZx00034TOf+Qw2bNiQEW2BcXOAADlAfo2bJ9I0n6ZGqqT3ozYWOMPvHGMiOiiQ/UQYNAfGzQHa29vxxhtv4I477sApp5yCU045BW1tbfjBD36Aq6++2lVdk07iEyDAZESu9xiK0ZpIm8ZEoiWHmJhekDpNsixPCObCup9o2viQN6lBgMmLBQsWmOyGzjnnHFx77bW48MILXdU1kY6CASYRJuZCPnGR894iTs4TYUNTMZFoySlkkslIfRutL/Izl6g5PEHiccmShXeUYdwI4YIcUBNgqiKQ+AQIkAPkmlGkNpA8q7rod5+mjA/J3KT6I+9MIMmMSRI4fgLYqFgwYMa+4kMB4zNdYMwQQeK5557zVGcg8QngDRPkhDhZkOszPcn4TKQNNlB1maOd50t6StIxUSKwW0uhDIxPIPEJkAECxidAgBwg19nZZYk0Es23xGdibKp5BXNDnzjGzZYqplyDZMYktqEzEKi6AmSGgPEJECAHyL1x8wRiNoiXz7v0KW+wYzLyL/GZKBJcktmhpZY8JQ0KjJsDZIKA8QngCYFxszvkvLuY7tP5wYRiwvIEekM3GjfnByRjQUlX8ghK/SYl9RscB1nUfwc2PgEyQcD4BAgwBUFtavlmPGxsNaYPzDY+qvQrbzY+FOMz8VRdEsHocBwHMRHVfvOhMAIE8IqA8QngDZNY4iPGx9Hf+DakZDx9YZ+Qe6+uiSTxIVRd/PRccmxdx/PF+BCMRd6Z4xQoyRhBH8BBSsRyT1CAKYnpuQoFmNY49sJ9OP7qg2h9Y6ev9Y71HEfzi/cjPtJnuifl2saHOsHnmUmdIJtqXmFwHVcwcVRdE+UbkQxYb/1r+g2Og5SMEeUm78ErQP4RMD4BPGLyLjyjXU0AgP6md3ytt+GpOzDYUovmf/zedE/OcX/RrsoTR+IzfTEBAxgSNjQTUdVluhWMowA+IWB8AuQfeTLyzFYOq/H+NtO1nHt1Uaf5fEt86NQI0xEsVdfEsvGZKBIfi76QZUNIgOk5jgL4g4DxYUBKJlD/+G1of/tv+SYlQDaRQ4Yrnykr8i2dkyeQh1newFR15RfSBLTxsZb4yKDH8dQdR92HXkTdX3+KxNhgvkmZsggYHwYGmvdivL8N3YdezDcpJiTGBpEYH843GVPi5J7LrOX5lPjk/Vt5ZMJad/8FLS8/ADE+7j9NOQbtpq1+m/wGMJyIXl1WdEwUZjEXaH/7b4gN96LtrcfyTcqURZCraxJBSsZxaOetAICN//Tv09ZDxjfkUuJjUPdkO5DfRPXqcgoxEUPvkVcBALwQxqLTLvKbrNzCNklpfkB6TYmxsTxSosN6rMimOTTVkRjtZ16XZRlSIgohUpRjiqYOgp2TgYkaXZaU9OT9hDYFFh6/v7NdNFmJWrR9bZYJeQKpuuDB0FqMjWp/J8YG/KYoD7DLhJ5/ic+xF347ISTJVqouWZYnVFDOXCAxNsS83vLi73HgoR9gvK81xxRNHQSMDwt5zm1kBVI1Q0U1zSFkWcZ4X1tOY+BkDT5/Z7v8Qbm2TphIqi7Zg1FqkpBA5Jt+P0C+g2pbk3/jZnoNGW6zzoKdK1iqtGTZ0E+Tf0ykQ2KczfgMHj8AAOg5/HIuyZlSCFRdDOTS9sMr3Ep8ZFnGaFcTCsvnIVRQ7LndoeP70fzi/Z6fZyJPC7/f35kPFwIWp2Z675eR9RguE+l07MFwllK95Jt+P0C8Q9ubf0VJ1VLmvVzCuIZwvJAXOgAlBlaosNTGyFqeGuPAVwT94RUB48MAaTuTC3sMp5Atwrk7wWDzPrS8/AeEi8qw9sJve6bB79g3eYXP39VW4pPzyM0TJ4AhfYp3qOqaAgbNNOj3PvH6nzB/60fyRIsCKZmgfueL8Rnva0XDU3cAAApnzmGWUebP9LLxSYfpZPDtNya+aCMfICUBE8XNE6BtJVwyPkMnFPFopnp8Xpg6vLLvEh8icaLxNE1JfHxtlQ0q9H/eNwn3G1aSsPHJN+PmB5jvnccAhrIkIRkdocnJE+PT3/iW9nd0sItdyKjqyvuYzh7I72A/X7z3gRgfn9bu8gHjwwAp4WFx1bIso/fIqxjtOpZDqgybWZ5sfDhhCiUH9Nu4mZD4iPEodY+yTsjSmi3Gx9F14HnERwcmVABDLx5m4hSz8bHLz5WP90tGh01qpXyp+Ee7mx2UmqaqLpt3zmTcHHjoBzi089aJYdCeBwSMDwuUEbHZlmakvR6tu/+Co3//dS6pomhxq+ryy6bEznNpssHvhZ5kmMm8QoDBnT1LJ/z+pnfQsedJ9Bx6cWJ5dXlon1J1TSSpq0ewNql8qtDjowOma/nyFI0OdKQtY1R15X9MZxGs0AfMcpnPiygjyvx0QMD4MMClYXxiQxbi2CyDHQQtt+ADiY8lKObGICnMhcRHFhWbDSkZ8+RCni148cYR4xMjroxvYH6D/AUwTLAYn3wxmE7aNZTJ95jOLuxCHxC3pnQfZBcB45MGLAYjb0ZlGdj4GCHGx9Hy0h8w1HrY1XN8aOowPr6L9m02+NysUbp7tNnGKI+LpJc4PoSqcGos8BPLxifOCI6X6ZriFU6+rzKmJ7/kzwkcB2qcEvMiPwgYHybIkzuL8cmPtIUOMZ/ZItW57xkMNO/FsefvdfUcy8Zn0m5MWVQ1GBdpKRd9xOkSBNMmkcdv5MXGZ6rl9zLPkfy+U3y413Qt70FR7WBUdU2BMeEEspjESEcDxETMfG8KqIDzhYDxYYA2ImYtBvmKu+Hdnd0Irxb9TK+uSboI+S3xoVSRRtE8Vc7XZjVwhATBPG7z+Y08tD2hbJR8gI2NTz4ODtHBTtO1Cc34wBjAcGrC+I6DLfvQ+Ozd6Nz7NKtwjqiaeggYHyb0AXXksf8ye+jkSeSakY2PUbrhq7Rjck7ArOY6My5KlDt7tvortZFKkpnxmigSH4fvPvXyMtnY+KglTNGJs0SJLCM2yRgfJWWFQ6PfSQzjN1BDDrAOqlO1D3KBgPFhQDZMsJ66lw33J7+Nj2cSGAvz5N2YfFZ12dn45II5tJP45PUbeWBippqqy2jsbohJI8syGp/5Hxx9+ldZn0/J8SGIiZhJ4jmRGR+TqmuqwrS3qIcZxrfxYZxM3rU7MwSMDwuGwWByt8wT45OJjY/RddaNK60sy3ruJNZEmayTx3cbH2uvLikH5gmU6mSCJMIEvNr4TDXXZXvjZikRxWhXE8Z6WpC0yNHkF1TpQbh4Jk3hRGZ8jKquybrmpIHpG3A2jM+UmBf5QcD4MEEPqPhwD303X6ouFzY+UiKKZHTUtoxTtL35Vxx8+N8w3HYE7Mk2OSeg/zY+dl5dssUdH6G+D8O4Oa+qLi8HhQnkju8HTO9gUOXlck1RN1HOYK83kRkfo6prsq456WDKn5aa01nzLp4Cc8sLAsaHAeMiFRsyMD55kPgkxofR/OLvdRrSLFL9L9+Fwzt/ZJNF3bm0o/fIqwCAjj1PsiNZT1Y30xx6dVH3srTY2Bo359Wd3f2GNeVO94Z3kMSEIUJ8kvg7uwyIOjatVF3J2BhiQ91ZpcELpoNNi2ndyILEZyocJDJFwPiwwFikaHF97k+jbW/+lfptZ+ND0hrT3FYz3+SVxXkqSXxyZ+MDR3fcIxkdwWhXE8iM74qRLL2AxkfM7suZQpYkS1dbQ0n9Ly82PpN0fNEwSADFBMgAhqQEN1OPzbSUqBIfXsDs1WeYrh965Ieoe/T/mQ58eccUkwKykBOJD9l3EyQBd64RMD5MmCdVMqrnNLFigrKJhCHgmJ2Nj6MTo4cBL4nJqWXc7HtuImsbn2z10KGdt+Lo3+/ESHu9IY4PPQbqn/iF7213H/oHGp+9G03P3m1bzssCPdW8uozvQGdGl6mDTLYdF1SmmON5zD/pPJTOq1aup8aMSutoV1NW6XCLSStZdoHc2PhMMWmqBwSMDwOshZZ0J6Tdyr1PRlmW0bTrf3HshfscLO40o2J3KpREfVG1kmp4kXbIYnJKGTfn0saHLudjm6kFcaSjnjBulnLCkKtZtcd6j9uWo4MROqQrS15dPXWvoO6vP0V8pD99YT/BkCKThw9yzmY7AbG2iXI8OJ5HSdUy+rpaLgdjyA1TO9WCWrJgThyrMj7mMTEVDgT5gq8r/4EDB3DppZfilFNOwZlnnokf/ehHiMcVG5O9e/fi4osvxtatW3HOOefgoYce8rNpf8EYUFRSP5/E8MnxIQy31WHoxEEbW5wUDIyKnVSH8v7ycXIo9bIkPpPnJCZnU8xrk6uLLudvswo4kKqTCWWo6mEMeon94wRtb/4VseFedOx5wrc6ncAUV0kStX6RZVriQ0uDskGMKvERqH/NdmHZnddjPS3oOfSi6XqooJhZnqZvam76JmmfjarL6/cJGCYfGR9JknD11Vfj3HPPxRtvvIGHH34YL730Eu666y4MDg7iqquuwgUXXIDdu3fjlltuwa233op9+/b51bzPSCPxSRvZ2Rnc6PJNhoh2Nj4iw1DSh01eEhPsSTOZJhKxWPieq8th9uhsxPTheN4Qxyf7zKhTqaHsyTYju2Mq54whS0WsnuJl2WDcnG2JD23cbMX4ZHsMNTz1S7S/87jp+rytH2GWV4P5TWVYS3yyZOMzTeHbyj84OIju7m5IkqQtbjzPo6ioCE8//TTKy8tx6aWXIhQK4fTTT8eOHTtw//33+9W8r2AtzmRsDW8LOashFyoAwybTW/+a5cmQWkQtGSQPqi7ilGq447qufIFaLHKYnZ0u52uzCjieiuMzYSU+HuL4ZOWE6jvTmw4sxkf/RuRctjsQjfUcR/0Tv8jI/kY3bk7D+EwwSW7X/ue0v6eq1MJs42Mj8fHDxmeagpF4yRsqKipw2WWX4Sc/+Qn+4z/+A6Io4v3vfz8uu+wy/PjHP8aqVauo8tXV1Xj44Yct64vH45qaDAASCWVhEEURoihqf5P/+gVRTJomfSI6qreXTGj3xWQCXMhb+4l4TKsnmUgAQsSyLMtTp/fom5hV/S5T2WRc8bKRJBnJZByiKKYY0hTNjN92UMvJogRRTJjoSCaT4D18A7UeSZZ8/4ZGqPUniW8ny/6OHbpPk1Td5DotSqJv7Wp9KEmQJGWMSKLIHMPJZBIcxyE23IvOPU9i9rqzUFA+P0Wve3okYkzaPU+OGUly9q0lgn4pC/1l9+2zsa6IScb3SMSV7yWJSCbItSBm2Xb9k4qReuNz92Ddxd/3SIvyPaRUH8hQ+kVMJpTfxNpG0uF3v1gxVhJBgxUk0b8xkQn87hMxNSZUqGtKfGwQHbXPoWrdWfq88NgH5Fj0cy3S6mf0yUT4ViR8Y3wkSUJhYSG+853v4BOf+ASam5tx7bXX4rbbbsPo6CiKioqo8oWFhRgbG7Os784778Ttt9+u/a6oqMAdd9yBgwcPmsrW1tb69RoAgGhbHUY7u6hr/VIdusJvYuTgk4j36Ket+N494AtKPbWTHOrEYKqd+L694CNm3bYYHcZo3bNI9JsNSEcOH0LhiJlZSg4pkaa7u7sRPbAfkfZhjBw7hliqreSePRhpbqZ+26GX6IuhyFGMG/omtm8vhKKZxsdsIcsy+lL18OEixNLQ4Bf21+5Df6rdfrEE/T62O3jiOJJDSt1jhw4h0sO226qt3Y8ZBf5IHNRvM1zUBKFkEMOdXQjHwuBCBYj30N8psecdcByPgd33QxztQ/1bz6HyfdelaHI/hwZaWyGO9gGwH0PRVn0+DXCN6C6wLqvV3dYKMSVl5QvGMO7Td1L7awAt6C2xr9PPdSXarvQBx4c0iezQy09ivLMLfLgQQ4cOYCRF2+jBAyjoZ5/KVfo5jkPcY59E2w5jtLML/WIJBvbsQbT9qPI72YTe0ne0eTlcX4/WuHle+9UvvYZ1REWscwQDFvdUhKMChnK0ZgCKxCU50IrQzPnghLDpvl99kug/jiHi3Ufq67W50/n0faiMz9T6TRiKY9RDH8jJuPaNxw4dRqQ7XTgKb/B7X/YTvjE+f//73/HUU0/hySefBADU1NTgy1/+Mm655Rbs2LEDw8PDVPloNIqSkhLL+q6++mpcfvnl2u9EIoHGxkasW7cOkYiy2YuiiNraWmzcuBGCIPj1KugrjaFt8AB1rWTuXMyqjOC4MArMnaNdX7VhAyIl5Z7aGe0+hqZWpa7VGzYgXDzDVKblpf9DQSRGtaliXvVKzF6zxXR9qL0Bu98GqqqqsGxVDWYsWocT0QYMyEoslw1btph+22H/Ib3tyuXL0Rtvpe7XbNiAgrJK2zqMkGUZBw4r9QoFJVibhoZMoY6V9evWor5BaXfGomVY4mO7RztfxniRsmEtXr0KM5ds1G8+9KT25/oNG1BZYi3dcwP128yprkbBzDk43vMWiqsWQQgXYligbSLWbdoEXghh/+GHgFLlubUbN3qeQw3t/0B0QFlC7MZQb/EY2ocOAQDKly3DIgd9Xtf8FBJjhQCAUNEMrPHpO6n9Vb58hSUd2VhX+krjaBvYj7KF6zDa1QgpEQXirZgxdw6EcBHmVq9EW99eAMCC6hWYVcOmTaU/XDQTqz32SW/xONoHD2DGouVYsmUL+mdKaB3Yj9J5C7F08yZtXs5ZuRxzNuht+N0v5LpCYv3pZ2Fs5RI0PXeX5bPFsxdhRZbXDBIde55ET+erKBPWYOlZn9Ou+90nw21FaO7Q+2XhqtVoHdiv/V6/eTMOpPotUjILqzz0gRgfx6F6pY4la9dgxsK1mRFtrJ/RJ/F4nCm0yBd8Y3za29sp1RQAhEIhhMNhrFq1Ci+/TCf6bGhoQE1NjWV9kUhEY3AAaHULgmAaYKxrmYDnOLMxcTIGSAnTdYHnPLfNyZJWnyDwzHrkRNTSCJeTJeYzPFQbKw48p/eP3pb5ty2dRPs8zzP6gE27HWRJf3eec/+8V5DfluO8fzsWOKJu3qZP7O65bzP1DUNhCEIIHMeD5wAOMnOs8oIAnhc0kzKVDi9ziBwLds/yHO+oX6j3It7Nz/Gh0xtKW6ef64raV0qdYciEFyfHcdRawEG2bFctEykp90ybOgeUMSMgFIqA43hwkJWxo/U7e3740S+ybB6fKkKhEIpnLbB1PvB77qbDwNHd4DgeI+1HstYnAKj+B5R5Tf3mfVi/yLXfx7XI3IxArS8TCb5Z+J155pno7u7Gr3/9a4iiiOPHj+NXv/oVduzYge3bt6Onpwf33nsvEokEXnvtNTz66KO46KKL/GreV7AM56RElPLs0spmEseH8r5i18OHrCUDVi7wkpTFKLCT3rg5R7pmWUJ8pB9d+3fpCV7VW9mw1XVg3Oy/Qah7ry7nL5/dvEyqYW/OoPUBZ8qRBThzZyevs6TDjkkhAhgq/+rGzVQ+wHQhNjJAunmY7vuM9bRg6MQhP0myhfmbZQdWKStY970an09Vw3A38G32V1dX484778Rzzz2Hbdu24bOf/SzOOecc3HDDDaioqMA999yDJ598Etu2bcPNN9+Mm2++GaeddppfzWcdYjxqEfTM+yCivK8sBrEXxofpzm6CV48mvyI3Zz75ZFl2nYg1q0HQDJ5IR5/+JTr2PoUTr//J33ZY4AxxfBjjSfPmyXWYeg9xr+gF3v+FWoyP53QD0NriOI3RoO47cGc/9sJvtb/5cKF3WoiUFeS/skQbFXcfehGDLfuJ5yRFRWdZr4ToYJejw4UspolV5MDrjuyPbIP1zbIBq5QVzPtex2/A+Pin6gKAM844A2eccQbz3saNG/HAAw/42Vz2wBgYYiKK+KiZ8ZElCQPN+zDeexzztn7E1aZCnexyzvh4w0SK49PxzuPoPvQilp31WcxYtM7ZQ1nNAUW6bUtIjCt2bSOdRwGcQpTKggSDM8bxYQU887ldp3F8PI3B7IbVH2jeBz5ciEXbLvS9biZS78BxvGkTlR3m6oprefeQPvyFLS2pZxlxfIzfqvnF32PTpT8GALS+/ggGdj+N+NpVKJpZZar2+CsPYKB5H0qqlmLlB6+xJSGdJNppjC1FZZZ9Rp7PmcSHnbJCu+/L+jW10sF4QZCyggl2zI34sDlpnyxLaHnp/9B96EUMnXBnvEVLfMxtDrfXo+/obsvnLRkfMnKztsAYFgcXiwW5ULPiAnkRufox4bpTUV/b3zYHQbNsN4uSBKvYM6ZmshLHh6NUXayNUSbULbkEHfDT2Vhxmv7DFR2GD9HX8IYv9TpsXfmH48ybqCxTEhCr2Ft0WosMVOyWEp+kLUMVG+qCLEmIDbI9rgaPKw4ho93N6WlIx/g4VUVmYeOWknFEBzoM9OSI8bEIYKjdJ9d2j2NgujI7JALGhwFyYFSf+2Vt8KkneLqwPvjIIIdOYCfxkWUZTc/9hvmcehqSLMTF9AKZucSHXKiZYvg8TyQ3YmhfRMWWldMSHx2Gxcu35vSaFIkPb6aDesDfgHRWJ+3xvjYqs7cnW4QsZOLOdvJP27Y1iQ9b1SWJ6VVdtHooExW7IXJzan7LkoiRzkbL5yxTW3iiIc23cCzx8XdMS8kEDv/5xzjyt/9GdKBTJydPEh8Tc+O3xHqaMkEB48NCajBUrDgZxbMXm/TpKz5wlV7Uw2lWL29t3Gx1qgL0SehI4mOxSLkSD6cWoZmL11ucfDxMHh8nXGyoG21v/tWRvY8/omLL2ol2iL+zZfxNMj48T3xTGbPXvhcVy7fSxdUxlkXVQDI6ivonbkPdo/9JNkxS4ageaj5kOFZ6Dr+M3vrX8xvNWnsHFuNjMG62kvgk/Zb4pLy3UutJbLgXx1/5I1WWXCf8ZHzS5SNzvD75zPh0H3xBc0aIERL+fNn4MHO8aff8sPEJGJ8AGvTTGQAIBsYnXDxTi1uTyUZKT3762bGeFsvn+LSMj/3pkTVhmv/xezQ+e7eFDY/yjvO2fFijM1xUZltfLiHLEnrqXkHr7j87KJyjMPx2Eh+fuks2taHm9ZFQvnQTFp9xiU15P0C/V2JskBq36rjwpl70Z3FORkfQ9tajaH1jJ6RkdgK1OQNp3EwfHmRjri4xgb6GN3D4zz9BbKhbuUZEBafq80KJ0caHEZBPBbnhq39LDnKJxUf6IcbHrWnwKR+Zn/nEpGQCPXVE2BWiv2mpd/YYaClhGKMmxsdFmiNLBDY+AePDgD64lIWdDxdQ95VJoHrQ2Et8pGQC3QdfQJQhwbHT2dstDOrCaeUZ4SxJKUeVGTy+HyMdDYiP9JnrU0XjPK9NlNlrzkSkdFaqQO69uliurNH+9vStZilzvbE+u7p9kwCRCVcNSUrtymfDGFRMxHBo5620p42WfdyDDZhPtlgisZFkPeu5BSQxia4DzwOwUXUZcnWdeP1PiI/2o+Wl/0tdo2n3uuEnxofRc/glhZYUHXYOFKTKSVt3HGz8h//yExx46AeW9/36Fn4y87GhLopZIyVvJLMqGpkTH2Fkzo1j3488kdRzAeMTQId+OgPMCwPHC5qYOF2m9q4Du9D+zhM48th/mVshGRQbkaYR6VRdUjqvLlmiGKF0E0GP+yHomy0VNya3yQxlSWK7sjrY0Ck7j6za+NgwPqlbydgY2t9+nMkUO2pOoiU+lHEzs93seXVRHkdae6m8WJ7sqnxanKnEsflRdfUc+gexoTIYH5PER/97PMXMGw85Xudc8z9+p/2tBSq0YXw4ivFJ0Z0LGx/nFflTD4D46ABdNaVy1MeRSSrjI0xMld2+4PXdJ5Gqq6+vD9u3b8frr7+uXXvqqadw/vnn46STTsI555yD22+/HZLLg0DA+DBAGiICgGCQ+HC8QJyE7AfReK85x5YK6hRnJ9I0wI2qi2UvYDpFpFvICPsEum84w33nyGQTTlgYkTuRZEg+GYiyQUp8CIbY6JmR+rf19T+h+9A/UP+3//bWmlHik+Z7+L3xU/3N6nuVDpcqGiUhrz+LM5XwMV3smCyBUls7MG5mva9pHnucPyQtmsTHVtVlZnx8sfHxydDcT1VXwsj4WKyj2VSZGuMkmTUBfkisJ4eq66233sIll1yClhZ9zO7fvx833XQTrr/+erz55pu466678Kc//Qn33nuvq7pzY6ruI3KRnV3NDC1JslI3H6IXUJnTMho3v/QH7Z4xmzEAyOD1+4Z7ZCZeMUln8xaTcctTncwpdSbjUea7iwmFIZIkWaOJyqSdTGqZvAE9S7RKI51VXNZ0+pIsa5mTlazBSh3GTOQs9Bx+CfGRPsw/eQc4jqOyQLvNzh4d7mX2jSTLaTNuk+/qNFO4U5DZ2ans4qKEohBHlFP6eKSrCbIspfrQS5ZlPeu5KEkQUu2T2czJflLHGCuruqfs7OT7SuagieOD3eiqfQbRwQ5XfW60Z/Ganb1z71OIEWOFzICugjl/fF5XyH6SZTqrvXJNhkjQJooiQkUzkBgbUOhOJpGMR+lv6WDOsUCvY3IqO7t6oGExXMRYSh32koZ1TpZltL35FyZjaUUj61sYn3Ei1Uom4uB9+k7R4R6qzWQiro8FYq4lomMIZ2kPSsTGDd85Qf8m1i9Z8tZukszO7nEc2cEuO/vo6CiV2sqYmkrFzp07cdttt+HGG2/EDTfcoF1vbW3Fpz71KZx99tkAgJUrV2L79u3YvXs3rrjiCsc0TjrGJxfZ2ceaGjDe2YXBUBO6wnswcqJdy2QOAInaWgy1tiE53AWAyFxe2IA2cTZV1/CJE4h3s7OgDzc2aPfGDx5AuF2XZIwfq8eYRYbi0DiP5FAXOI5H7J13TJKOkSbFJbW7uxtDwlF0R/ZgtKkJ0VR9ib17MNbUqP2O792jZSyP7d8Pobhcq0uWJS2Tb7x2P8aajyHW1YWR+gZE29ogjvUrtLeZ03mQ6H3+fwEAbWMRhGbMg5SMaW26zc4e6zysZbKm+mVETJutuL5OfzYcC2HQxwzPZEbx4foj2vfjC0rw+4/P1cp1NdWhC0B/exuklArELru5FaTYiNaHo3V1EApnYLCzC8JQFGOp+sgM2NH9tQjN6EJ/R6d2ak2m5o6XOTR04gQSKTVd7MABU0btvr/+Gok+2ki/XyxBX9ke23plSdTGHKCoWxIu+0eKj6H/lQepa+P7a6nM14B9v/u1rgy3tCDeq7Q7GGqCFB/T5r2K0JiE5LBiyByORSAno0iO9CA8cz727t2L5HA3Bgnaw7GIp7FLjoeRxiYt+3pfTx/TZpDjeW1ujh4/AQBobKhHe6JcK5MYOIGhPY8y27Pq31j7QeYcJp+xyt5O1VO7F0JRedpyTjB8aB/1XYaPHMaJaCkAYPB4s/Z9xmr3IDKLDmbr11gZaqxHYqALHKcwoyNHjmjZ2QHzGPaybohjA9pcHa2rQ8FgdhQ/rD45++yzMT6u21Fde+21uO6660zlzjzzTOzYsQOhUIhifM4991yce+652u9oNIrnn38eO3bscEXbpGN8cpGdvZPvQne0GbOWr8SCLVvQlmxBH1SjXw4btp6Eo92vYdxg1jB7+VLMM2TLPT56GIO8Ev/HmMG6eXAfhnllo1y2Zg1K5+tJWzv5LnSPNzHpK65airFuhWNfv3mTSXTeMnoY9R2HUFVVhYrFi7B4yxa0Jo6hX1QG+9pNm9Apd6AvqQTpWr1hPeqOKtl6azZsQMEMnXmTxCQOprI1r928Ba2xRgxxg5i/ahX6+H7EBsMK7fOqrboTgJ6JefnqVSiZu4LKEOw2O3v3gX509pkzOxeWz0d1mozbK5YvRWe/8qzfGZ7rWp5GYlTxAJy7ciU6R48CAKRwKT69U48J8uT178GiimIcapwHMaa44NtlN7dCfHQARxqVd1m0ahUiZbPR2PoCwiUVWuZuMgP2inVrUTx7CQ41zIOYUBafTLKzN/a8gbFC5SRXvWEDGlrob1JUWYXxMC26L1uwBEvTvKuUTOBgHVEXx7vun8T4sDamVSxZVY2WDvoaq16/15Xmwb0YDiku0rOWr0RyfBBDPB0TrGDGHMSKlQNMyZzFSEaHERvisfycK1AydwXGelrQeEKnvbhqoaexS46H+atWoXKVUsfhxsVIxkaYz6zftBEcL+BEvAl17QewbOkSzCfaHjoRQUs7O9P6isWz0bZ7J+Zt/hC1vvUWj6N9gP3MBsbYtULN+vUomGGOIu0FR7tewTg/B6GCUiRjI5izfBnmbFRoqW97Xvs+S1av0jKa+z1Wjna8hPGCBISCEoixUcyrXomO4Trt/tI1q6js7V7WjdhQD+qblToW1tSgYqX7Ouxgl519165dCId11SpL2gMAVVXpv+nIyAi++tWvorCwEJdddpkrGicd45Ob7OxkJmUBoUihbgiYyuqsZsKmnzNnyyWz6xrvFZXPxUi7Mqh5Q5Z3VoZ4FRVLN2K8pzn1HA/e+O4pMSbPc1qmZ4HMpJ1qS8/CDIpGkg5OFrV7oXBYK0tlA3eQ4VfPIp7Kik217y5DsBgdZvYNz6cfBzyIrPC8vxmejZnfyb/Hk7oaQaWT5zhIDrKbW4HM1MzzPEKhUCrLtl4f2U/q+OR4Olu62n5G2dl583gtLJuNaF+r6Zm0Y4UYc8o7uP9OcogxP1kZ623q9S3jtiGLvUT81gmmxyWXojUUKVC+GXEfUOasF9rozN8RPXt2pBBifIz9kJSEEI5ACCkbljF7PLmWGHH8H/chGRtF8wv3aqkv1DqsnmGNXStYZZD3AjkRBcfxiJRWQIyP0fOIyCbPXOd9GiuyGAfH8QgXlECKj4PnOIQKSjTj+JYXfkt/Qy/rhkDP/1xmZy8pKbFkdtygsbERX/nKV1BZWYn77rsPpaWlrp4PjJuZsPbq0qQrjEnJMrSzC3w1b+uH9XhANkZsJOZufD9mVb+LLMggn+XJYvDiIr26bIwVKeM3Tndnd2PcTEUYVg0kM3FRtooP4tK4OZvu7NQ3sIjjk2n75JgZ7z2huSlbGjcz3NkzMVSl6zGPQ6Gg2JIGO5jmgsnYOT1Y5f0yqM0IHMemjXBUIHN3abFzfHJnp0khGCmDgXO4eKbuRJHyNLIybrb7NlZz1a8o2n56lIpxRToZKlQ2Uat4aNn0DlRpECJFqbYkrDrva762kY10MLnECy+8gIsvvhjvec978Jvf/AYzZ850XUfA+DBg59WlxnNgnUZYk9Au1DnHcRAKSpjPWi1sMxato3NnMcuRjE/6FBN0zBRrBozjeMrDK23cGL0S4od3TzC9OqW+mUs2UtedeHXlyp2d8riyyo2V4aJNttFT9zL6m95R7zhuz69FnJkN3vPmlp1Q/PlMWaHCaoxS9jWynmRWYzZM9jdy2kjl6e6THlsml3ZZBh9S1j2VKdPj+Ejav2qUY+tGLN7XgTt75arTES6aYV/IJ8ZHMTCnGR+rsCBZDWCYsr1TDw2yLCFcVIbiysX+NeIw3thExJ49e/DlL38Z3/zmN/GNb3wDoZA3pVXA+LBAbu5gS3yYSfRYjA/JpDAGmcZA2QSqMtVHMF3MDYcp8dGvDbcfMZBtE2eFrJ/j9HrIpJhpTp8U8+Q0+aB9jQCAkEmi4NadPYugJD6GW1AD+2Uq8WEvwOnj+BCSmoyYAaK/nTJVDt6ZOZ5c9xVL4pMfd3Ya7DFqdGc3Mj7GgH9jvSdw8JEf6lI+A3oOv4SDj/xQS+TLJsWa8ZFlicjhRUuf1N9Nz92Ngw//G2KDnXALJxKrhaeejzUf/yaKKhZkVI8jesSk1ueaxMcijUi2GB9JTGrtqBIfLeiohebA2xoyeQMY/vrXv0YymcQtt9yCrVu3av9deeWVruqZdDY+uYFR1UVIfFQJjgdVlywmwYXChvupQIgOAxhyvJCyH0mJzB2runQcf+WPKF+6mVnGRIcm/eL1NpE6uTJjGTHIkRgSHx+SLJLfJUVU+mfTxEvJDGyJj3Gz0z5PpouO1WmXqHfByeeh7a3HqPKUK7VvEh+GhIV5qnfyzqwyLlVdjLmYL4kPrS7m2NIoQ3wWWVN10cwHL4QpBq7trccwe82ZpvrUb97+9t9QtfY9TLrItYkl8VEPZXrkdlrVpSY07Tv6JrN+OzhVUXEch+oPfRn9Te/gxGsPe64nHVSVHMdx2oHKSsqTNcaHCF6oqbrU9dbqwGgwW3CCyabqqqvTjbt//etf+1JnIPFhgNzsAQuJj1NVF7G4sE+cbNWP5eTS2rWWtrDCmhs3pmR0hFneUuKjTi6tbPpIwaz6/ZD4qPXZhtpPITbUjfG+Nu03dXLzyHiMdDYiMT5sum5t42MoZ3nHHaxPu3q9s9ecqYnJdRVFZou4kn29O62dmNcNgj2mp4bEhyOlplZgqLpUiY+TMe+cFlLiYwxiKJsOZbrazRhM0QPz4eJ7crxA5QbMuG3qcRHDbUe0oKh8uNDEbKrlWH/7Ce2bc7yJybS2FfWwhkxiVZdfCCQ+LKiDQZX4UDY+dqouliqLCFyXiCEWG6PcxfXUF4bJZKfqSj0nixJkSUR8dABj3ccwY/EGxSCR2oAlS9r0ImTbbAZMO/1RfePQuJmqn8UsuZx8FoyP0X5ClmXUPfr/AABrLrxZuZahjc9wez2anvsNAFBeKub6yFO+sZhPqi6rAJfGeg2pRehF3J0URIyPo/6J2wAAZYR7MqsvnUQNZ4NRxq1x8wSS+FA0SKKjg4KJ2VAlPuECIKbb7rjJu2Zs187GR5Yk7ZBlsjcyGjfbqZss39Xl2Lfw8MpU1TVwbA+Ov/oQSuYsB6BIWrSUQKnxIhOMKAAMtx5GYrQf87Z8KKO2zSDNCAwmEFbvLxtdJ1y0Q9Y/zRBIfAwY6WjQMvSyjJv1LL3m4cY+9eoTs+m536Du0f/EYMt+ogRb9WOn6kr9oT134rWH0fLyA2hO5a9iJ7KzkTsQbfXUvcKUimiLJCkNS/XPcNthJq1EA8x2vUKlyZg81rQ4EJM6Maac6DJNWTHSXm9Hmf4XaTBuWTxbqi76ujZmZMmkHnV7eqUlhVaqPZu6vdr4uP5WTlVvuYWTjZpk0PS8fGyJj0nda9+45S2mjY+2+UoULebv6n4cu2VYLI3CM5T4qMbZqp2SEC7U1nj1Oxjfd7j9CLoPvYj+xrcyapuEwlzpXpfqeqsaXFtKfDJW9QWMTwAAjc/eTfxSJT6F+hUbiQ/b0Fi/FhvuAQCNsSLrM7uzK7/nbnw/lp+th+LWYsOknhPjUYx0NABQpBGyJBokPmzpAtsAGuhvfAsd7zyu/R5s3qcSqpZWCdE8TfqOvmmbbZmZaTsTcatjiY+Z4crdqV9m/kn+dLpoi/FxdO3fhfhIP12PxeZhOtmTKkmDa7hrF2+SuaRUpE4lLM4lPplkkWf1Td7c2Y1zLa2ElMwKTruzG93O3ai+jLn9yD4is4+rNBvXJk8SH0u43XCz4xmpvpPKAAkRUtUlUv8awVJ3u4UYj+LY8/fi0CM/1PYHcLw2z/oa3kBsqNuG8fPAdAaqroDxAYDhtjp07nvGUkWgWdgrF1P/OPPqSjsxLVzC1ckWLp6JEKHfNtoYjXY1Us8pizvjJG7jrWWc2L1HXk1dl9Cx9ykAuvEfadxMbsR29hPesnNbQzNuFkKGBcGoUzIzXFQcHx8THJJtmOo2qbrc1TtwbA869j6F7kP/MNST3rhZaV9XWZgWcZcSH6sYQEzVUoY2Puk8ItPUYr7i0Man/e3HMHLwSd82BaN9SLoo5ySDZmQ2TBIfo9TTrt6kMRYQ4W1pCrthtvHhebbEx4vUxbXEx8I2kKRltLsZHXuecsXgGiUpibEhk3rR6rDE24QqcYrBln0Yaj2MZGxMS2itOq/oNA1a91em9lXTlPEJbHwANO36XwBAuJiOGaGrunSJj7pxMo2bPRhlGj0n9Of0xZ+cnEaJU3SQzmcjiwmDka2FVIBozyiy1W1Q7Bg5DknC1sBuArIXRu+TT6uP48HxIX1DM0p8mHYeWTRwtbLxMb2eu/dVT+om2i373Cjx0dWUxk1Lcqn+sWJG2KquDG18rKRLTmpgSXxspJIkeuteRqyrC9GBDpTOXuSqXTYtpOpYwuw174YQKUJx1VIceey/zOVVj66UJ6VSR8rOxrDZCq4YH6PEhwwzQTMASpBTg6rLwBAQFTmmQa/f5TNpbHw69z2DztpnACgxcKw82czVGqLpz1potvGxMjuwyWrvFOSY1Bg2QuIDKIdfx/Z8jjC5vLqygUDiQ2BAVetoUBYd8rShbj5Mex6nEh+jeyvjWa1+jqfi1ei0pJ4znEakZIIp6bCSKAHA0Alz4ldVLcK8TtCt12fD+NgYT1tfswHpYm8TGZvlrZYzd3ZSvWdSwbms1Uql5VTVRZzczRIft5uWReyeLNj4+C7xcWvjkwWJD2QJHC9gVvWpiJTOYpbXDleGUBiAWeIz1nsCvfWvO6LDHP3ZmvHxT9Vl0Ycu+9bOxic62KUxPQAQV1VGTuo1vPfczR9k2PhYSXwyZ3yoNUM7VHPUISdUNMOauQxUXZ4QSHwIqLYyGhiTTeXQSSNPFWxmyH6jNxoQEpUp93kBocJSLD79k+CEECHxYYeylywkPk5TYqgQ4+NsUS4Zx8dpfWmCLLqFLg2jGR/T4siw8ZGo07e/k97SU823ZuxsmKgbhsf0MeaHmkJ7lmTuHNvUOGB8tNQapMTHrVTQmZeZk+cyhVXwO8vNnCHd0VRdjM229Y2dqKzZpv1OjA2y6zWsFSVzlum0mCQ+EiGNtvfq8jbA/bPxEWN0hGq7w5CpVqJspKQcBWWVSKZc29PZ+NhF5XcKtr0dR9kPCeECm0NOhur6acr4BBIfG7AWJlVcnIwyDNs82Pjop3G2REZdfCpWnITypZvMzxk3MpONT3qJDxOyVX4khhoC9hMwW8bN4HjD4mMthdJcuUl1h9+T3sLGxyTxcV+x8o8tY2fdAqlOzZzxYRvF+xnHR2OuXWxgjMbNlxiMT/3jt9GSXoY0NlPIFoyP1WbOit2iRU9Os9nGhnpwaOettvWGCkqw6ryvUVnNWX1tGcfHB+Nm/2x8JFNdXhkfLR2RIY6PUUWolXeQRDUtSOm8FrSSR9JkOO2P5MzYpo+nskmFgPGxhR3jY5b4MOOWpLP7MUh8ZFlGT90rGO1uTt22mMTqZsaQ+FDqC0sbn3SbkmwrqeE4Dis/eI2j+mwDJFpds6OMcvsk+sdGCqX+7damxTtsvLpca/aspGzWqi5TtGDAJ1UX2Y69WzyL0XDC5Oo2XOT7+iHxMdv4jPe3oeWl//PcjiNaqEB4zvubZnzYxs1G9De9bUOH0naosBSFM+dQ95jSXYfu7N6kDv5IfI6/+iAan72LLumC8SHfW5OmG2x8rBgfP6JG0w4RusRHjNM50KzX18zGa6DqmqawXYhYEp/U4slKzscenOmMm/UIzN0H/4GuA7uojMZWk1g9bRiZLVlMaLmg1HoBlkTJngGwsvHRr3EoqVqKUGEpktERe8bHQ7/YQ5c60aouaykUW2ydIxsfUylvNk3myzZjV5a18UuqU012Hm6Nhi08QpiGzA4S5Fo0AkA37vWSnd2pxMf8GOHi7ceJHjZ5ngzrC5kSBqA3ZbUOK7sSWRLB8QKV9oBVBrCS7lhfM9n4+BAWwLWUyIX0zbvER/mbNzB4lkbxfjANxDjV2uE4zD/pPDQ+exfmbvxAqimLNcCLtC3w6gokPnYMgF0ckZmL1zPqsg9gqGKspwVHn/6Voosn4uOMdjVRTA9gLeLVxNBGiU8yYRjMZtWSFa10AQvGx6B2sbRRohszP8+q0yF0iQ9Pb052qiD1OxjUbrIkmvo8TevWd4j+YkkEbWt1sgCZAjQ6Myol1alSKiCa3q7LhdPCk8u5qsuNV5fz6OCmGliG+Y6kfdmQ+DhLd2CMpcOW+LAZH3XTNL4jK/wAa01hMj6cM1WXF6h1VtachhkL16Yt74YJdaUiJepVJT2aqkuV+Fh4gvot8SE9hkvmLMP6T/4AczacnSroTK3tsNHMnp8CmPaMj73Bo5nxUU8DC7ddhAWnfIy659jTC2rMiScpiY8QKTQXtJrwqsTHFJsjadiQ1L9dMj6QLVyUdTWTQgY7ACPrGeqab8bNxMJlowrSJD4yHVOo4cnbceChH7hmVCwI0/4c6TxqW8z0/rb94f60Z6VONTF5mcQy8sT4KIHf7JhNkrG1inPlhjYVTtzZWSrCTEHZ+JB564wSH8HI+JiNm61cqCVLb1OC8SFs44wwMguzV7/bZEeoBU1NxiDGaQbaCpbzPHW9sHwulr3vc2nrcZPjL1NVl8pcqo4iVqoufyQ+pFeX6s7OmWhz69mZplGi+YDxmZawFdsSC9PKD16DolkLsfz9XwAAhAqKUVlzGlWcOUFsTgVSMkFMUpmKEK2RkEbVZTzhWUl8rIynrSBLUhqJjxpBmp1d3qot5kncvdFL6g9CIsAsxlJ10XSO97cDUIJYZg9md3Y3dhKWNj7pVF1q64Rxs3HDysy4OQ3jw/iuYnwch/50Cw489APrFggbH6eJcJ207Uji48Mp3q5dYz+R39RoZ8N0Z7difNRYT8bvQI4Zg+TGqq0ZC9dg/kkfMdn4REpnQSiaAVlMoOfwi0w6nIPtJGENF0yoR+mQ7jFLM5xWsb/8yQxvVhezY8T5Z+MTqLoCxsc24jC5KJVULUXNh69DSdVSsgBVPjE2iM59z1DX7BZsJeoqIfFhBCOzEvGqDIfJxkdKGtQRHlVdkMGaVKZN2ODyyqzJYNw80nGU4bXgDLGhbsRH+1NN84ZvYBe5WaL+Nf7t9ARrDwvJjOm3OZCgfTgAktFz+AxT1SVpuX/0qrNn3MxCbLjXScUA1LHvTdXFKu/WnT2TlBlafZLkuE4jQ8J0Z7dQdambs/Ed2aouFuOjt1Uyd6USONUQXJXjBRTM3wAApvQpbkFJ9ZwgSzY+JJOkMp5kH8tiwsbGhz13krExJX2Qi5hVABnAkPWu7LokMYnhtiMQbWy7zFVNT2aHRGDcbLtg20821iLWWfsM5m76ANmA5fNCuIDalOjUGKk20np1mSU+NKNh7fljB1mW2WoQwyZMJsC0rky/N953Am1vPYaCskpGnemhZltPNU5/AztVl0wk6GQstkaGwBp2EiZn7yHL5u/miHFI487OCyEqo7T+HGHcbHzPTCQpMmPR9gGkKtOrqouppnUStZvqDx8YH4IOIVyAhe+60FCCg/puJsaH6c6exsbH9B0YjE8aVRdnlOZSgQ5Vj6fMIqCzPfes4crGx0VZlqpLXVdkWYYkJjVpGi+E6ZQ3FnOn/m//jcT4EBad9gnMWnlKGgpIVZcewNBUykKl1bX/OQy21KJkznKs3H51mrYYrWdBwjkZMO0lPraLoR8nPjuJT0iX+ECWqNQYGglpvboY7uyMeDLejFhp2vsadhOJ9Iw2PnZeXXrbyagSbEzNlu6OJJoeSiKQwkjHUS0StVkiYW1XY2IIMqSNusfYQN2E/bcMV28Xv4Sl6pJls6orA0NVS28lh0hn/wF4V3UxbXwcSXx8jnFC1Lf2wptRWD6Xvk+sMY6Mm92quiBjvK8NZLybdKouleHREnhGR3RJnSGqsWdQUj2guHIxACBSUsEs7sbGx813Y6q6OI4wcE5oa6zJBtNiXiZSARCHju9PTykxh/X0Q4z1wqKtwZZaAMBoV5NtO8noKOr++p/o3Pd3UP0zTaU/057xsVsM/RB1221oPCXxkZkJB9N7ddm7s2uD3PUAp12IC8oqKTsY7VRokWuMqimtd49D2ox9yXEGGwYZjc/ehWMv3GdysVeyYtPP+6/qcg6zijI9Y5ouWjZlm0C+K5HvySTZysSry6G3knVdaTxVDN/WVdWuY0OJzHZiw73o2r/LnSqBVS/Sb95GhoQPRZCMjqBr/3Oaasnaq0tlfAwSYDGJ+iduQ9f+Z9Ooush4WDz1b0/dy6j760+ZCTy9wijxWfrez6Bq3VlY8YEvWDzhfC128+1ZAQwB0sBZl/gYJfKdtc8iPjqQIR3mMqxxsmjbRQ7qskZfw+uIDfegs/ZZA10B4zMtYX9y8cb4WGbpNoAXwpQagiXxSefVZTwJSEk6gKHXDOTGOD4rz/0yvehqEh+XNj6EF5trmowSDoOqi5R+ifFxemOVzcba5Ld3ruqyIs5O4mMu6krVZWHjYzSmp7yCGBIfMN3ZM/Cuy5DxSeepwlHJGjO38bGD3pe0fVz93/4bHXufQvtbj7prX62DfEeWiomS+JgZn/7Gt9Cx92ld/efaq0tBZy3J+DhUdRnojQ13E6oufyU+4eIZmL/1w5b5y1xJ310w8yyJj/K3LvFRtQJG5xMxPo6mZ//HOV0MMOcfY5yUzluJ1Tu+7rkdSprIsgGdZggYH7uTi0eJD70h2bspk2oIljt7OlWXCtUwWpaSbImPJ3dg5ZlQQTFCBcXU5DG5szu08dFVF3Q8HUckGdpQbED0fqD6neNNXkdmg2L92ztXdVnRavcOxpQVsmnc2asiGRIQmJk12ivIwrjZ6EaegVcXddXDRmidcdoPry5376XHwTEcJFKbXjpVQjo6OOJdaBCMj8Griw9FTAyGZQBDC+NmJi0siQ9l60Lb+KgQwoUApwYxzMzGx2pMW8GN3Y5XiQ9JCy3xSam6GAfTxGhmRt6s+WelaVBMI7yBlFaljaQ/DTDtGZ9sqLrIpHlpY60QaghX7uyGRUmdFEZ3djXqrRd3YNkgaaDF7LRXV8c7T6Bj79PsuhzkJ3JEEyNGCSXxIdQRinGiwcbHxrMtU1WXXf/GB9txxuBjWD/6GiDLkGXGuHPgzm6EKUovIQGzjuOjvGeooDh1KfNgdJ7rsXrnLHl12YEl8fHF0Nkmdo4RLImP0cU9rarLYj3jhbAtLXaqLhWyLJvSObgBSxKeDa8uN9/eKsmxesg78epDWhoQZpw1AGPHXvdMB3tus9/VnZ0TDZJ2kco6EDA+0xLZUHWR6SzSxVoh1RBM4+Y0qi4VPCHxMU04g9rKEVQPKIUI5R+BoepK0REf7UfX/ucsUnmYVV3m5hzQZ5L4CCC/ESnxUeIQSZa/jW1KSW82HE4xM9mDJdHDKJAViYvxxOyEcTAy4kaJjxWjQNphqe+pngD9iI+j1K3QX7H8JJQv2+KsrjQZpzNZ6N1LfFKMg8/2D3aeVADQP57AOy39SIoSg8mJmA2e03l1WYwjPlzg2MZHj2djLCcDmaStYIWS8EHiM2PROoSLZpjrdlKvxcFSZTA1Zw6YVV0qos27PZsUMJl/iz7JKGkvgaQhm/10RODO7qOqS4gUQYyP0xx1Gm8dUg3hyrjZQtVlcmeHuhB4N25WN1xSzK67vNKTUYyNadIEun31OR8lPhxH9Q/F+Mh01mblWeuFw/PCpTdoc0//UwIPGS6Nm61sfAwSH44XlDEr042SY8yU7NInd1Yt83cqd5ujZ9JIfADdeD2T1BpOoNmHeVDB2pIh2TNxv3u1GYKcxHhcxIeX0eNTCBeY1V8ebXwEN4yPMR2N9jJyRu7saj4xtS5mG1ZwEf/I1be3ipPG6GdWuBH9Aeexd6gSDFqtY7d5Z3zIdiiNRKDqmp6wV3W5656iigUAQNlRqAOrdF415m/9MFa8n/BakGWQJ3TWouZU1aVOVJlhxAuPqi7jhss2bqbpY50mHKm67IyDJRHRwS6zF5PBnZ2KsSGJBl22ZLt5Zh7Pwplxs8QJihrRMO669j+neM4wAzs6s/FRgs6ZVV1k7iEt2WWK8fErjocWZ4YXnEtqrKRHDBsfL16JbsCW+BDwyLDb2dWkKgYAdAxFmaouu6CGJNTDltVBTslLZ61eotuhHReISjKS+BjjajHbsIDdWmyUlLmS+FjZ0zD62S6mmucDHYvxseqTTJLmEn2ihhQxXp9OmPaMj9OUFU7Aa1IX4iSeGlizV78bVevOQum8lZi5eIN6kzqNMyeWU1UXkVGYKfHxEAfFKI5mGzfTdIgsMSrDq8sNOmufxZHH/gsde56ibxjc2UkJSFftszQDynBnp0l0aqNC5j5y7x0hIpSS+NAn5sHj+xXX6RTdHXufRtf+XdRmYVxczRIfUtWlP0flHjIyPm4lXWlUXco3ocfE0vd+hmb4jc9YXKdVmW7d0929l6Z6pAI0kurC7Nj4kK4HLLWWXRoLEn0NbyA21G3Zp1IiaivxYRnGG8uRa5QniQ/TqNZhv7qQ+Aw270Xzi/d7CEFgHVNJIcGChoxUUC5sfDJgfOhYarpEdrpKfAJVl8fs7Ozy5pg2mrqIYBBChSV6OcLwlOP1iKEAMG/zucyTB9mW9luVFrHUWoxghOmQjI4gVFhGtcUybjZJfKIsiY8TVZc1ff1HdwMABpr3UtdJCQdAL6yDx/drgQwVGszGzQYire9lDKVdiVNUUSx3dq2kLGHg2F507X8OAFA8e4nl4sSS+IAl8UmNDSkZhykCsCw53nvsoEqSjCEGAMUbhm2Ua2G0rUbKDUU8S1rcS3xSqiKbNASyLLteE9Ia8WqqSfNcUtRTNkEqCUhiAq27/2IpwRYTMceqLm3s2Ki6MrXxsZJiWsFu0zcyKdHBLkQHu1BStRSz15zpnD6GVxeJGYvWY6B5H2JD3YbH2N/EbcoKFh3U5Qxs3sj5QEnlpynjM+0lPvYZm10yPqyEnawTHxGbhMzObixXuYpOgspqS4Uu8ZFME05L1+ACx164T2ccbIybjYujZ1WXDYqrljGvcwzpAtWuwZjSPpGqU8aHlAgwvjOA+Vs/YqBD+VciFkg7hpuUGIqJqOXp2OiCTzGCxPdWVaj+qLrsJT7GEAPKRQuDdivjZjVuSiji3Z3drcRH7QcL4+ZkdATNL9znqk6FDmtmgy5oVmPxoYjBzVxgMl5l81cBAGIMdTBJRzI6nKqHMWfIb2ZhfyNDBlTGx8NBQQkpIaVVuzGRRuITKiw1Xc8k1hBL4hMunolV530Nc9a/j77hQuKTjI4YHEBYNj4e1aq2QWT1e87DrUxd+Mr4DAwM4KabbsK2bdtw6qmn4ktf+hK6upQw3Hv37sXFF1+MrVu34pxzzsFDDz3kZ9OeYctFux2AhmzGyp96HA+9WmIxNwRoswtoxmxL/Wlj4yOLDE8vB+g6sIuiiTZuZhtAslRdThbJdN5CTLjQrcuSxM49prXvYSG3oNlqTMmE2sY23gr5zqQEz5Bw0lSHRcA/TdWVjJuMm2XJX68u5ZsYxiYjtYhSF7vP1cOIMt4ys/GZuXgD5S1pOae0+q3Vl0Oth1zSoL9jujEhQ07rzm7tgaR8y8T4kO18GWjep1ZkuseSnLJsfDIxsBXjUdT99adoeen/PHh12TA+QgiL3/0p0/VMQjWwJD5CpIh52HLaJ1IyjoOP/AgHH/43bWyxJT7etmX7aNpkKAF/QlhMZvjK+Fx33XUYGxvD3//+d+zatQuCIOA73/kOBgcHcdVVV+GCCy7A7t27ccstt+DWW2/Fvn37/GzeEypWnoq5Gz+QvqAD6OHcWSJdhsSHWEh0exTOXI4Fw6ahLZAMVdehnf+Osd7jDt7AAg5UXWr7bHd2YqK5YCZ7Dr+M/Q/cjNHOo2yyLDZUFhSG0FmQRcewsPEx2UYwHrMKAEeqOhWydGkdufiz7BcsjZtTDCupGsuWVxfH8WbDeyrZKPUQsy5d1RUmnvMm8eF4HuFi3dU5UlJu9YTyf79F/w7j+ChnIHvjZku1t0sVSHrpE9vGhzRu9oKhEwcRH+1X8ku59eqyAccLKJw5B1Vr30NdZ9obOq6TZdysRrTmjDfYlRjGUmJsUL+lrYnOvbrSwU57QZlfkDn2ZBlDJw6i7tH/h7HeE57anYzwzcZn//792Lt3L1555RWUlipixx/+8Ifo7u7G008/jfLyclx66aUAgNNPPx07duzA/fffj02bNjHri8fjiMd1kVwioXxUURQhiqL2N/mvF/CRYsxefzY69pmD74liMm3dtDpF+S0m4wRtSciyBEmWtWuSpKhdRDGBwlmLIcsShjsaMNbfqUT1TdUpSTJksNsXDW7rMsen6kxC0tqRwfOZb2xyinYJelBA9X2k1DtzQgRyMo7E+LCpz8RkkngntspJTCZNyTxb3/yL8oyFe7QoKf3qRFqjLAqFSp8IMG26Tr61Uk43HhfFJOTUIkW9o2wYFwapiihKSCZi7H6QJHDEtxWTCUipNsmxn4iOmY3YwWn9ISb191HHhmKnknqGF7TxgrDzOUS+Jwk1jIIky6ZvIkqSYspieC6ZSDDbVftGVj3gDO/jiE5t3tFjTiicAdlgo6G+lyiKSn+nvpckmt/V7VqTTPWL7OBZGYagm5xAzTkZHDX+rJ5LBytayHEtiqKy/pDfUUyC43jI4D0xzGIyTqwDomldTEu3RZtqvxjXlvjYkKO6yfXWOGco+tV1VabXaI4PUe2Qa13ngefBhyKYVb0NoihR89rqe9r1id13TiZi4CxiDYkisaYQf0uiiKbn7wUANO36X6z5+Lcs63cK1r6cyR6dDfjG+Ozbtw/V1dV48MEH8Yc//AHj4+N4z3veg2984xuor6/HqlWrqPLV1dV4+OGHLeu78847cfvtt2u/KyoqcMcdd+DgwYOmsrW1tRnT39vZZbo2eugQCnrt9cTkc4NCM6KdXRiur0drogIAMNB6AuL4EKKHDiPUOgAAGGtqwnhnF4YiR1GM+RiKhZAYaMPoK3/HaGcX5NSJN2kjERtpPIoY0fZQQQvGO7sQGpORHFYW9u5u8wJvBB8qSBu8TxhJYnTPHiSHOjCYajNeWwu+oBRjzc0Y7+wCXzAKKTaKvngB+mfugTg2gOF9f0bh4pMhjvYimnpupKEBo4y+Tuzda7JxYH0TEsm9ezHS0oJYl305ABjAMRQsWI/ubiXfkFEszPE8Env2QEpEMfT2Q4jMqUHxcrONlfrtACCxZw+4lOREio+hP3V9tL4BIwTtA1F6sTpSX4/40BGtHhKDwjFw4ULt3mjdYSQG2xDr7MJwcSPakkouI3FsAAOG5wfkFiQGOiDFxxHdX4tQabvST8NdGOzsAsf3aifN4eIWjHV2YYBrQumaldQcGm95CxwfQuGizSb6ksPd2hggoX7/kYajkOJj1LtFDyoqIuNz0f21CM0w1zXScER535IWxNrbIY4PoPP+f0NJzVkoXEgflMTxAST6WlAwfx11Sh8/Xq+8H1qQHOmCONoHACjALGreaG0eqUPhcAiJwXYMpebN4cOHTTQn9+wxPWuHRF8Lhjq7EBqVMcp4VmX2E4kkGpuOYYxoL37wMKT4mEaDUBRDdM8e07wY4FqY72SFkYajOBEtM13v1cZcHQqGBMQ66HE8VleHSOUydPf0QRbjpufTYaigXhsXwuA4xOgwogcPIjSjz9HzVuvBcEkT2pJ7MNZ0jBp3fbHD6C3Z47jewVAjukJK+bFjzab5qX778eZG6juFZsyl5o9anzCcgFj7KgBg1ntDkGLD2pyNv/M2+HAhhpuPId5Nt9MvlqLfYpzZrYmxPe9AKC5n3oueOKKtu1woou0xA2jSxg7H9yDqcnzbwY99OVvwjfEZHBxEXV0dNmzYgJ07dyIajeKmm27CN77xDcyePRtFRXTwp8LCQoyNmdUiKq6++mpcfvnl2u9EIoHGxkasW7cOkYiy2YiiiNraWmzcuBGCkFlUy/2H5piuLVq9CuVLzYu/1XOzVqxEn9iFqhXLMXfTFgBAXcvTSIwWYsX69SiuXAwA6EA7euKtqFy+HPO3bEHL8AEMnUhiwcrl6Byph5hQ1F4btmyxbLdl5CCG0K/9nrNqNbpix1Ewcy7GCxWmp6qqCjxvrwpafOalOP7S/bZlCsvno3rLFoz3t+No6wsAgNWbNiNcVKa9S6iwDMnoMErmLMLyLVtw7Pl7UTCzCBg6iIoVp6Jf7AQAzF+1Cu3DdaY21m3epKtfUmB9ExIbtmxBT+EIOt4ZtC0HAGWLFqJLlFBVVYVQQREjNxeHDVu2oOOdxxGZEQGizdiw5YumetqlVvTGWwEAazdt0kLBJ8aHUXd0DgAOC9esQeuAPum54RhwTHetr6mpxsKeTvSl6iExa8UK8KEIeqLNAIAFNdUY74mgX+rB3JpqVK3bAkDxXGlopvunfNlKjHRISEaHsXLdOhTNWqCXPbFLp4cXMHfVKnSMHcWMxYvRB2hzKDE2hLpDfwQArN/0zyZ1x3hfK46eMH8XoaAEYmwU81etQjI6gu5Yi3Zv5XolfMNRggYAWLFuLYpnLzHVdXz0EAblXsxfsxZ9/CBiw6lxMXQIGz76Wars/j98EwUAFqxZi1krt2jXuyOD6Bw5gvLlyxHtiyA6qCx1Ves2oRvmjXZBTQ1mVW/BaNdMHD1Rhe7ubqxevRrNrfS72s1JFobbitDcOQdFsxZhJeNZlfERQgJqVq1Gx1ijdm/t1pORHB9C/fFnAQCFFQtQvWWLaV5ULF+BfrnXkoaiioWIDnVp6tUFq9dgVo2ZlubBszDa1YjV7/84hEgRBo4BJ/p1T8pFq2pwrDeBefMXQEpYr91WqFy2BL2pcREumonEeBFWrN+A4spFjp63Wg/mrVqN2Wu2oJPrRHdMV+kXzpyFagffS6134UnvRkVqDHWH+9E5fowqp3777sgAOlPfSZJkDCQEag9S61PeUVEzr9u0EYnxYdQfU+6t3rAe4aIyNA/VYpinY3fNWLQMSyzotlsTV65djaKK+cx7PYXD6Eitu5wQ1sbCzCVLMEjsI27HNwusfTkejzOFFvmCb4yPyox8+9vfRkFBAUpLS3H99dfjk5/8JC688EJEo/RGE41GUVJSYlufWicATe0lCIKJyWFdcwuWXpXnuLT1ks8JQggcx1PPcakyoVBYuyYIYapcKFKg1CNL4AUBUpLX3ssKPEe3HQoXKvYVsqwxOzzPpdUXh0LhtGV4XunfcKRQKxsKhZR+D0WUd+EVo1ZZjIOTRYo+jvhb7SMjBEEAb3jfdHQJgoA5a8/EWGcDhtvrbctyUAIy8jwHQQhrJx7qPTkOUnycoNXc/4IgEPd5rYyUus5xnKlPOYMKj+N4cJDYY45XxoUWQiAVxI/jeAhCSB9DvNmIWAiFwPNCqqxOG/ndAMVoWEjRqJorqHMoSdDFc5zpm5DvT71TKv1KKByBnAgZxmY45Qpu8ETkefYYl8RUXYXgDe2R5cVETLsnjg0AYgJd+59F+bItWh+q40otV1A6y7LfBUFQ+j81f1jv6nadUecBT3w7K6hzSUUoFAbC+rVQpIhNU5o5zAsCwoWlmo2JEIowaVl+9mUAEavHWC+fsnERQmHISfd2KPSaJZvWxXSwekeeS41fA71SYtxR3as+8lWMdjWhsvpUzY7HWFfRrIWm9RuAYkrACdQepN0jvhUHmZqzKs3kXFchhKzHiu13hmz5HE84HXCyHkbFuEdkuo+SIPvEz3r9gG/GzdXV1ZAkSbPFARQdJwCsXbsW9fX0xtTQ0ICamhq/ms8OXBo6au7sJq8cgDZapg02yTgrTo11jR49nObOTl53UpeDMpo7O8kn015dqlHoeF8r9v/xu5TBnxN3dq9GpRwvYPaa96QtR6ZrsDLuZGYvt62TFezO3sUeUL66XRwU6+Sq7JhFOsgUD2avLu23EGJ6IAIG7x6G90d67zvObGxrFbzPKtgeGcfHZnySRu+hohnoOrAL3YdeRP0TvwDtVKDXIRQUY/nZVzCIkel/jX97RHq3bRsvTo6j1HcCI6WN8ly6ZZyj0shYp8HhaBqMY0w1SLZIlJoO5PfWxn8GKWxU6O7ZdF0sRwsWimYtxOw1Zxr6ha5r+dmXE7cMBxnL9YRwUjDYi6l9YTmPPcAqqOR4fzva33mcTVcQxycznHHGGVi8eDG+9a1vYXR0FH19ffjZz36GD3zgAzjvvPPQ09ODe++9F4lEAq+99hoeffRRXHTRRX41nzEqa7YBUJIs6nA5KDQmwD6AodHzRnMtFhPOFwKTV1fKnZ1YXJy4WTrxCNHd2a09HYwgVUmOvLoymIBO3oFkIKxdmiWIcRcifFbMF8YJjuXVZbVIcYoVMEUTcZN9nbhPJr3VLhtSoXB8yBw/Sr9LNOHcIFFPWWGO48Mx+sRIIwlJi+Njv8GSwTJlSURidICo2uwJp/4unc86cOnu7PGkjDfaonjhSHobuXRwmppBhvFgkeo30p3dIk9XOkab43k6z5RDryHj91ffhWd4PLmtTxsvPnh1aR6Ohm+tRLH3uK4QdRWUVVJxgkw0WzE+xvdlMD6sOeA1UKHVYarhiV94qm8qwzfGJxwO43e/+x0EQcC5556Lc889F/PmzcO///u/o6KiAvfccw+efPJJbNu2DTfffDNuvvlmnHaadYC+XGP+yTuw4v1XYuG2C7VrboOg6Qn40gQwNKQV4DWJT8LxQmDKW0WkrNDpcVKXc6kQFd3VKD0xTmALiY9VPI7YcE8G7pQO3oFwZ7c8oUlS2lOiVfZuaqN1wLw6l/iYwxOY6SDAcP82pT0QQnroBRMDlSbeh2V+LV3CYhrDVhIfKy8dMoCh7RimT9Th4pnELWLeUd9DVR0aNkkirsrbLf1oHRLxnb/st2nbGcj4RnZvwHJnR0pFpkL9e8mZn0ZlzTZt3ShbsNqeCI5mfJzGnTF9/3QHhzQgpdRSFiQ+rLXFn5g1RgkPK06VGbLhfdku5Uqf0gEYvfXJcNthJMaGzHTYhvGYnhIfX1NWzJ07Fz/72c+Y9zZu3IgHHnjAz+Z8BS+EUDqv2nDVpapLlfiwUlZQgQlp9RCZS8npQmBUdWnME3Gd4wTI8B691EgvHy5E2YLVkMUkQkVl6k32M5YqE/b7NTypePCt/fi3qLgrzgh0wGhIIjTVop2qK5143BBjh3U9rcQHsn2wMcPJkCm9YCxm5IZujCvEEe65dqouc0Z7d2DG8eF4yB7i+HBkAEMG6BO1qI9JQNsATEyO9jcH6ssQAQxHY5nPGYKwVLMWDByZJoEh8SGlCeq4LV+6CeVLN2Helg8hGR2BECmmnqtYcTL6G9+i6iHLZMr4eI3lwxpPfkh8Zq08JVWZuS5ZEgGL+Ed2YI8Z9bdR4sOu36jaY6u6lD6trNmGztpn2e05RE/dK+hreAMbPvUjF08FjE8AA9yKSR2nrDBEo9WiLoveJT4q80SeMhwtcI4mmWrPw9G6bqoNY195U5nER3pdMz5OojdLYhIy7CU+zlRdbImP/jfDxsWUO80unD5nYJzJSNxkn1qd4tiRjvlQWFMJ2Ku60kV4tZ8THM+DN8QS4XgenMQ6jacJYCiEbccnHehRpMZBfKRPbZymRUu1whlexRzAMHNZhP6Olsy2nY2PctHyvhApghApMkkpQwVGpxEOAmnj41XVlebgkLY+1pjPQOJTNn8VFp12kSbpY0p8xCRgYRtlD+K7MNSl9O/0NmzGg46u6jKPj0yYQbdpOgIbnwBmuAzSpUduJge8+cSnb4wpiQ+h6nK6EBjdFjlWDh2GmmBW9bvo55y0Zxcu3mDczIK7yM1eFkIHz0iilrLCTtWVbiFIaxjIyh9m5nu0TYBNi9HGR7cf0tu2CHWvSXwMRstkuhFe0Gg0BcPLUOIDjkdh+TzjRWbRtCkrDOENzBWQtCap76EyPsr4plVd+nWSFtW42Z9I1nq9Dm18LNJB0JJihwmLDfVwPI9I6SzL+1YwMrDaQc1rZGGGXVsmmzzHC7R6kynx8Si948xjxrIdq1x0xFgyqboMEh/qm/ig/nOMgPEJYIRrbpihPmAvfEbjZt2ry2nuqfknfRQlc5Zrv1mGoKwFzpwqIX179pmRrRZRve8kIr2C1wR8tnAk8UkQpyt3XkZ0IbbXD6mOslJ1HS4+RXtMy5nFMFilF0gLZswqTxgjSamxHdLGx6TqYhlgQjEkVqIo288JXgihcOZchmrXhaqLMG62Gy+mjYTcaEhPH4aa2USPzJL4+OHVZW/jQ8KKsdHvW7g4s1KE0FdQUFaZth4jKpZvpeOYMRw13ICVpiWzjOOGuhhjxWuiUtvcYKZ76dcfMTZKBYq1l/jkjvHxkqNwKiBgfGzgNLCWCpaND0tNoS3Eqs2FGv1XTMDJJAIUMfeCk8/Tq+QZHiGMxdbkrp2pxMfBIipSwQL9n9ROFgpZEgkm1EIn72gRsFB1Ed+ZtZh3RRbjREENUTxFi9H+gDOkLSD+ZiWSpB8lpRtmVZf2NxFLycTIMBif3iOv4dCffoSu2mdMbZpo4AXwoTAlYTAyH3r95neQJSLsQBobH4q5tjhRc7wxkS2h6mLVZWG87hlpbHysVF2sMW0919JLJKjv4TQxKC9gyZn/pGV/z1TVxWZCMlgPHDAgno2bmRJ68z2LZk1ofvF+NO36X4IupS/YEp8cbssZJp6drAgYHwZWf+xGLD/7CmZUWTuwbHxYEh+jAaqmpnLjzq48qf9lMuBjMz5eVF12ZUrnrURx5WJDGAA6YZ6b2Die4GChIDPUW54yHTA+1qouQh3FUHWN8aXET5mQ+DCYMKONGIt5TpMZ3sjQzKreRpQJ6Soxox2HgXmQkgm07v4zZFlGf+PbzDbp9lNBE0sqTDQZwWLeSNWEYoTtQuLDtE8yMgUWqi5JQvvbf0MnI2dfJkhn46OVM3l1MRgfKyNdw7tQrutQmK4wkcogaZH7zhIGKaJ3Gx9GCAcX6926i76Dmg9fZ3mfNc6skgG7QzqbHvfMm9GdnTyM5VLio7QdMD4BoMRtKFuwKn1BA4zqA3rzYZw6jRKfZMLVoKczNxtUJhyYi0qoaAZmr363BV2WLVneCRfPRPWHvozy5Vup66Q+38j4+D2xHRk3E3E0rCQ+dtmNNcgsaR5NC1vVRUprYE2LQZ1EubOns/EBp21wlO0DgNlr3o2Fp56vlCKjZ6dRdZEZpQvL56W1CVDHJBkwD5xR6qI1wLhEx6GyVXWRtBolPuSBgzMfOozMaWyoG92HXkR0UM+F5IuqK62NT4oBhQ1jk4LZdipVg+FdypdtobPQc4oUUl0jvEqytW/v1caHMb/c2PiECktQWLHApgRD1ZWMY6j1MMS4MUWNPWzXFB/WL2N29vwxHzL78DXFMf3eOJswqrpINQVvFp2y3NlZNh/W7RGusCYbH7bExxSdNUNVl16EbktipIRQICv9JPuZrdeBqktMIt0iY00zUU+aOD5KAwyRO8m0QB8j5u8m0+omWbfxSefODo7D4nd/ComxQRTONOf0UVUNPGXjY6/qSkbJPEIy0ql/tHQHhGeR2cBYwcCxvShffhKtwqMM4c22QUrqC/rgoD7Htk9iq0OMGxvJ4PkKplcncZv422pcrvzgNRjvPYEZi9ax2zC8Cy+EsOQ9/6yFiFDn5pqPfxNibNSghnQAVTqYqVcXy9DYJRNha3vDYC57Dr+MweP7UVK1FCs/eI2blshGDTRYGzc7tQvVjJtViWCemA+jUT01v6YwAomPj9BtfGiLfeVmend2KRl3ZexHnupMkgOOZ3p1AYZosB6YGmYZQ1t2ImbfJ5ZrGx/vjA/LoJm+zpL4yJQthyzrqi7jdzNGm7WKgWTlCi6EC5hMDwDak8zC+8uoPiLVIk4CeqrvY5T4sDDcfgSDzXuZ7at5z0zflhEVXbmcBFMaZYjjY2XczFT/+GLiY58mRS8oWx5ISqqWYvaad1vOG9N1o4Qt9XeooBgFM6qcE2+sP1OvrgwlPulh7p/B40oQytHuZpdVEWPG1L82tkUuGR/WYSynLuZGxsejMfhkQ8D4+AijjY9l+ght4tDu7LIL42ZAUZGtu+hmrPvEdxkLK2dKjqm2nc6WgPVM+jLOJD6yLNuLyj0wRVYbQs2Hv6LZNMlSMq07u5Fm9gLE9uoi1VEm5lUGxfgo9KgGvAbGh2CKUgUtFlO2ms0ORbMWghdCKK5aZmLSWfUaGR8gvVeXlcTHiqEf7WqiWzcwCmZbHFYePLPER2/bKDViGzcnY6PIBpzm6pJB23tlcjgwStgyP2jQ65V34+bsenWx1g7Sm40V1di6KsaY0e45iyZuB5PEx2Gf+i+NoRkfR4e/KYCA8fETBrsJVephVC8ZPWooGx+XC0GosBShgmKzSyvHMSU+JlWXA3iRCllOIIeiVHenHnZ9BTPnYP7WD+t1Snaxcxg0M2igjZstInQzF0aDqouMokw1QDM6ibEhvR1KJcS28bFD2YJVWP/JH2DWylP08WJ4x8wlPqqNTwl50TImj/FbkN5YAIMZZcTIAlJqPBbjY/LIYau6WBKf3Nj4yNr/fbPzMKbpyFSqohnCp/rXqzs708PKv4083boSHWh3UxtZMX2Htdam4EbV1d/4FqKDnak6yeSwdnXYv6MrUwnAFKLCc9yjLKGvrw/bt2/H66+/rl3bu3cvLr74YmzduhXnnHMOHnroIdf1BoyPj1A3//hIH/qOvqkZ1JGRclMFlX814+aUxEeWMGPRegD0ScVZ46wFnjVJPNj4eJAK2S4Adguxunm5iC9hnW2ap1RJGiNqlVjVxKyliZ9j8TfLuFkmp5pMbvBGVZdEMVTD7Ucw3FaXqjedcXN6aN/eKoChycZnhL6XTuKTYuToSMEchEgRlr3vMszf+mGUzl1JEsRsX6XTaHtDMT4WqT0MFFmoLWyMphl/eUYaGx+NuXLg1eUURgP7TNVJep+pzL2PhrgZS7bIC4zwHUQMMVcxfWyNm83tJMaGcOK1RzDWfcxR9bIk4vir+oZNf3vrcZf2YMxxaH3jzxg8fsARHSByGAIOHTxyhLfeeguXXHIJWlpatGuDg4O46qqrcMEFF2D37t245ZZbcOutt2Lfvn2u6p50xs2iKEIURe1v8t98gIrOmfodG+nD8Vcf1AvxAkWjlNrc1HeR+TBmLt0Cjucxa/WZCJdWorhqmev3UhZ+GZIkA+BS3Dy9sYmSREkcJMNGy6wX6ftYksxtsSCKSap9I5LJBERRhJSM29a34F0XEt+f/Q6iJEHpB0npEzGh0AmOWT4ZH6euJxMJUxoeiVCpiGKSGoOyLEGSZUjGfpdlREIcikKqXY2oxJ2RJchEDi21Tklkq23osZ80lZFSY8oJVBol41xKJrR6k8k44oTESRKTEC1USnq9Sl2RGXOIflLqLplXg5J5NRjra9fVwaDHVjKhfHcZHERRRNzA+CQTcXBhUaNHayMZh5hk9wk5D0RJTn0r6/EqcECYBwoF8zh1OyfV/pRlmflsAS8hLAMCD0jQx4KbbwnAMIZEZZ5rdbHbdgp1bqt12M1fT3XD7Tqnr12sdZUEOafF1NrijC69LuO3I+8pay1Q99efAnISo73HHfVNMhGj9w5qjFp/e9PaAgAcjwWnXoC2N/4EMRFFz5FX0HPkFWz4p1tT9NvMV0mi1hJyTfMK1r6s/j06Oop4XD9gRiIRRCJmafDOnTtx22234cYbb8QNN9ygXX/66adRXl6OSy+9FABw+umnY8eOHbj//vuxadMmxzROOsbn4MGDpmu1tbV5oERBb6fu/jp2uA7DxG8VfEEJYnv2aL9jHfUY6exCX7wAA+r1IiW4XbfKufbWu6alr7tb9xaKFKGtvR2JAZqe2IEDSAy0YjRFZ/TAQQwyaCYxIDejt2SPbRkpNoL+NPUAwMiRIxjv6IBkEdtn/OBBhNuHISWilvWFyuYgORxGS6rvxPEBDDDKJvcqhrN93T2QJQkFcyrQ3d2NkcJmjDPKD9Udoq4n9u6hUj0AwPCxJsS7U323fz9CM7qVtoa7MNjZBb5gDKP791P0hAB888wNKFo6V7kw1obOjg7IsoQBtCJGlB2QmyDFR03fDQBGj9SjYEg5GcbaD2PE8A5DkUZ0YA+ry8x9o9E7iopl+hyKdzdoY3jk8CHEuxs0WkLjPHpDBzFk850TtfvBpdRaycXvByeEsIcY+wAw0tysvfNQwTGK5uRQp9aP0T17qPkFALG9eyAUKa76o41HEU3dF0aSCA+J2m+trYajiPcdR6Iv9c0OHkSorAcDHR0QKY81HesqgHUVJfinDbPRuf81ut8M75IOKo1DhU1ol83PfnJtMaTUPrB3Xy36UvRzQhgJF22R/ZTcswfiWL82Bge4Y+gpdEc3iZHmZsS6ujBy9CgKF21Bc3MLc/54QWLvXtd2K+q79oul6Cvbo12PddVrc4LjOJMEcPTwIRT0OdvUY11HtLrCsRCGiG+R6D9OzYHC+XPQ2dGmtNszAFlMbyczVFhP9WH00GFtHR4UmtAd3sN8rq+z21Q/xwuIdY2a1kB1rBrnEInQOA8pOqitx9HafQiVuNQ2WIC1L5999tkYH9fX/muvvRbXXWeOzXTmmWdix44dCIVCFONTX1+PVavoUDPV1dV4+OGHXdE26RifdevWaRyiKIqora3Fxo0bIQj5iYOw/5DuQbNs3Xoc63rdVCZSWolVW7ZovweaZJzo34uSuYuxnLieKQ4cmQ85JdXoHRzFwkWLMV5Ai3drNmzAWM8MtA4qotCVGzbg6Am2F5CKmUuWYXEaOhPjw6hrtK8HABasqkFXrMXgJq1j6ZrVKJu/CsnoCA43sOsrmDkXNQQ98ZE+HDlmLrshVeZg/QIk4zEMSglUVVVhzsqV6Im3wShSnr10MXrGj2m/C7tfw8oPfpkSL7cM78cQr9C+Yv06FFcuBgCM9Z5A44k5CBeXY8WmLahrekJ75kT/OG55aQDH3lb0+b/4py2YM2c2AKBixUr0o08rO2PRYiSjwxgrMIvlF61ejfLlyjv1lSXQNkAvLLNXrsQ8h+NpvL8dR0/sAl9QijigzaHBZh7He5TM3vOrV2IwMoaxAkX8XTRrAeauXYtjHa9Y1rtu60lp44K0xo6iX+4FAFRVV2PuJp3mse5mNLbO0eYMOb8AoGb9Os0zqTVxDP1JpU8jpZUombsU/WInVX7+qlUYbpUxElbUzivXb0DRrAWoa1mAxGg/k77nDnehqXsUezp68IvNdPsbXM7X1ngT+pOdmFNTgzkbzM9++e5hRKQoiiIC/v36rdh/WGmPD0WwzkVbZD9t2LIFsaFu1Dcr1ypWrMTCDNaZE+NHMMANYM7y5WhLAMtXrkRv/ITn+khs2Lo1fSED1HedsWgplhDvNdgi4HivEmSTDxVQKSIAYFFNjTZ/0mGwmcfx3ncAAMVVi7GCaGeko1SbA5IkI1q1EmXJLvA8h0jJLMRH+1hVUpi9fCl6orqn2Yr169HY+gIAoGLZMsvvdahhPsSEIS6aEEbNxk2mNVAdq8Y5RKKociHiw4VacuaV69aZ8kC6BWtfjsfjOHjwIHbt2oVwWD9MsqQ9AFBVxfY+HB0dRVERHaCzsLAQY2PpkkvTmHSMjyAIJiaHdS1XIPXnQijM1KeHIoUUfWo5nuN8pVsQQhAlETwvKQalvGCiRxBCCIUj2vVQKJTWBoDn09MpW7y7qS6Op1ImmN6B5yEIAiTO2jaBkyW6Py3qU8sIoYiiOosnwUc4CKEIeF4wi4BliaonNtCBsc4GzFi0Vm+bsJ9QaVX/5lJ9Lhj6VAYQFYHxZMqQVdbfLRQpMNhjIBV7kvE+oZDWHs8IlCgIIcfjKZT6XlyqD9Q5xKfeA0jRAVn/zXHUfWa94UjaEzxZZygcoWjmUt+dT72LKQEnZL0PAIJWmdknnCyDJ+pR+5A1N1RIMpCQgJgomsrwphQY9uBT7yOEIsxvI4oiEjIQkkC9L8+7W9OodUgQqDmR6fqo9hXPc6n60q8ZTuGFLr2PeMt1QAgXmEJqOFnHtLpC1v1HzoHVH/sa9u/fD55Xxp4sxp2F/4Dxm4Us34t6B0GAlGTMe8b6KwgCZEmypYdPhXvQ1zT/9iSy39R/S0pKLJkdJygqKsLwMH1ojkajKCkpsXiCjcC42UdYGtmaYuzQxoL+tU/n+mEOeI4z0OOTV4XjzUC2nYiqqo7lATJj0TpwvIBFp33Csm12jiMiJQisGSqWJ5qZObJKWaHTwqpftjBMNo6N8d7jGOs9zqRP/VZKXiqGyN7FhqymNRATUYvAf4qHB513zoFXl5Mo2pSRKTtOjzqW520+l44zQr233v8Sw+YJAKRkjKKJZOLSgfchnko6d3YerCjvPsBHry5jwFVz9vd8RR22jq/D8iJ04pXIrts4RvVvFSkpB4gx6TRCdP/R3XRrVHBSt44hnOV4TperzBg+w10f5R6rVq1CfT1tBtLQ0ICamhqLJ9gIGB8fYbUAGKPzWiaIzJwAshHmRuglcrMTOl0tfrZtpqQijAlYtfY92HDJv1FZ6ZXq7Bd51dNI1Y0raQzMNDiLYUF6cumbVmJcjxHCiuNDLp6ky6gxjk9inK0CVApzkJIJHP7zj9H25l8d0GqNUFGZopKSJUim6MwqnZJ5UfSFGWB7ZpH31PE0Z8PZ2HDJv+nRhikmzcCwMWhTNiKGR6WjUznLq8/dxmB0z7dqgxGVyVU7pqfTHAZc1qb8wwgAGi4qw4ZL/s03CVAmIGlgMj5uvh3LC5dZjqfms9M2SG8ztR5nZDHWN94Yq0pH2iStBq+uiZ6tffv27ejp6cG9996LRCKB1157DY8++iguuugiV/Xkf7ROJVipZkx5tOiFxLfmDdGh2YuRMaaQg0XRCePjcHFVQqJ7k/iA49kMVhrXXe0ZzZ2dnQOKxfiYAugxJD49h19C8z9+p5dnurOzY/C4zZMz3nfCMsmkqzxvnJ6xWxrXPaeMzAS9EPrDqFsFISTvUeo/XtC+ISktMuXqYnnCJaJMiaBtX6mxKGGuz+1hRY/BZK22BYBYQsJojJCE+RZ00Lpt51Wp3oisXF3u44JlDWklPs69lewZR5m65zkDPNUe2afWYyxUyFLpWAcITUebmIgZ4vjkz0PaCSoqKnDPPffgySefxLZt23DzzTfj5ptvxmmnneaqnkln4zORYSnONmxuxuzsvrVviAPCnAxeIjc72fDcLK6OJD7mCegkZD/H8zB6x9KRsYtS7+9R4sOI3RMb6iapYY4DiYrjo6o/3G0aHMeZmWi6hOO6ACBSOgvjAx0Qo7q0ilZ70UEBqYSpGYCWIrGzwxv7RZ1Damyh1jd2YqSjga6HpepKGFUP6eP46CXTxHFyAJVuIVyYtuw/3fUaflThqnpLULkBM2SiTHF8XMcByw3SSXzcHTStVV2mdduPoH8O+3HJmZ/G8VcehCxLGO9rJZ71JvGREjG6X3KZLsMh6urqqN8bN27EAw88kFGdgcTHR1htYmYGR5X4+M340KouZjRajrNNiOc2c7Ner8OhlInEx3KzSqPqSn0XzdjRhY2PuU1zmgrjRmDKW2b4zJpUxZROIR38OV2qiJQqbqvS+IB+0cDo2KmlvILMB2RmfCxyWxEpNtrfeQKDxw9Q6gJZlph9Y0yCqqu67NQXqX+Y7+tuzs7ZcA7mbf4gZi7ZYK7JMDD2ndAlb/6lmTD+nUFdDBufCZXQ0k8bH1uJoDHauR8SH9IG0HqMFcyoQvWHvowZC0mHC7bqXqHNnimTkgaJzwRXdfmFgPHxEZZRNQ0D2ZjTy0cCiL85hEtYx0drG5/yZVtQWD7P9IQjyZQb42ab6KOsPGdu2mYaNxPSAiC1cHu08aFUQRbGnqyNhsrVJadSZ3C8uxQlHGeb/NXt6btghuJST8ZUolVdBiNqnxh1e4kPm/HRmFdT/jAd8dEB6nfJnOWpjObeVF08S9Xl0vizYEYV5mw4x8LmxFVV7mCUgvpQl56WhVZ1TRSQ35SVusHNestkllMwqZvSMBdzN74fVWvfm65Fx7QB5kOuV+NmYzTr1tcfcZXTbLIiUHX5CQtJgnnCZUniQ9pFgMPsNWciXFiCoooFOPH6I2oh04mt+kPXor/xLczdtB0d7zzOegEHbbuTXFhCtlZ1WW3sdgkFAYaq0YWNj7lNs6rLdAJm1C1zPObHmrB2bDfE/kv151zaX/gZUr582RaM9bUjOl6g02mS+NCGj36oZyljUIeMD6nqsrKL0kT/KRRVzGd8Z+eqLjb8m7NSBjmZ0iHdnPBWl8oRGpwoPGLJu//JO1Gstkn38AhDtehR1WUcQ0WVizF34/sRKZudqtae8eHDhcwDJdUa2aeO5pjBU9Fq73EpjYqPDmCwZR9mrznT1XOTDQHjkyEWn3EJjr/yRyx59z9Zq3CMAzkH7uzgeBTNWojSqiWIj/RZlwOH4spFmoorG3ZHtLqElvgYI6zqYeLNi5Q1c2XvgWF0GTdm7FZpsJWmEPQTv1L1G2yrjAbRqX9nJ1pRII1B6mvSnnNrkGy3yLpVOwiRIiw49Xx0kRGCDYaOdOqNLHh1GSQoVkk9SYmP0c6ppGopRrubzQ2p85El/XDkzm7eNPx09xWzK/LR/8o4A3p2VF3lyzZnRJURlMSHYVPlXdXFGW5xmLtpO4BUqpo0zAXH8Wls88xtpCXPocTHVX6yFHz3Np6ACBifDFGxfCvKl24CxwumhIo6DKouzV7BZ68uajLof4aLZ2p/80IIkmvjRO8Twcj4KIsnuSiHaIZDlfgwJ6wFrWnewSiaNqq6VBpMLqaA+ZRIMQYMQ1wWLTIgg4esbsRkslRXEh8ujcQnc7UD+a3io/0mptUPSDY2PuocslR1iUmTxMcy8ztTrZVe1SVrJVnv69+mYC/wyfBb+ml7o6m6WIbn7tspqVqK+Sfv8IMyGsRcChFJclX4peoyIa3nVDRt1nSaOXUr8bE2bh5s3uugLiMtE8RLL4sIGB8fYMx4bYRpw8iSxMfoZqpfFrBy+9WQknEIkSJKpWPaABircSYbHi+EzCokkukQQhojkGot1SZjkbJUdenvPWPhGvQdfZNaaOZu+iAKZy1G7/OKuo8zRN9VaWCd3MzMqb3Eh72hphKjpkzqZDEBCAA4+yjIJnAcJAdSqcygv99oV5Phlj9eXWrwRKVKvc9HOhvRtf85ACzGR1V1JU2nZ+uFmqHWciNhY7yrn6dhe1VXZvDT6FirS5ahJLtnqLo4ThsaC07eAY7n0XvkNUQH6RQiALDsfZezVVF+0QkriY8btY+93SBdr71URYyNmWK52bXnCEZm3oLG7kMvuqsX04PxCYybfYTlgDFs4llzZ2ctSCmUzFmOsgWrlVtuT2wZ0GnuE9qry3h61xgNN6ou4nrFipOx7KzPYfXHbtSuhYtnoGLlKVo5N5FnpWQMLS/9H/qblLw9rDg+rP6sWvtelFQtVcqpdamMj6THE3K1Efts3MyCnRTSr/G6+IxLiPb0zaiHXKSNqSJSG8fQiYPoPfIqdc8UGV27zvDwc8X4MPrCV8bHpm1fvaX88epijXcWnbPXvBuVq07HrJpt7NqytrHqtJDMtQavAQzT9V86iU98LL2qy6FXl16cjHPFPkB59TabCMEos42p/4Y5hGX+qQKDF4BaLstxfJyUcyb+9U5n+bKtjPbJSWtgfDSvLhZd6Y2bOV7AjEVrES6eYS5IieqJRdImxspYTwsGmveh++ALKoEksUR9GjEAgPknfQRLz/qcXpTjIKkqziQZSNE/VZcfm6XdeFBsfjIfs4Uz52DRtgtN7ZEqKyuJz3A7Ha6eVZa4kfrXvIk5eY+asT2ma356Yop2nE+m8HPzsovjY7fOWElos8X4cPZz2s3YdaPqSsdglC/bkl7VRbbh2ouWLfER4+Oma4tPvzh91YHEJ4AbWBkRLjDos3WJj982Ps6MDilmw0SDv4txyZzlWHXe11C+dJNSu9HGx+ih48Gri15803uMwRABOlJaYfMIbXPEimRM1kVKsLTvrP2XGh8SkTPMJbNir+ryQUpgNyZ9ZNRJY2UVpDrAxPjYxJ6yWqgpFY1+0SWlxiBMftr4ENJDE6Pip1dXZuAMBzXHzLpVOZ9oM74jlfQzY68uF7BRdS089XyULVidXtXlklGl1nqLxLnJmDljebi43FXdUxUB4+MjOCGMiCF2zpJ3/xND+sBYkH1pn9gcLMT/gEHi40Acmskpn+N5FM6cAz5UoFZGMYgmVZcXry6HpzPSVZqkQcsDxaw6xbyoi1saVRfFVJpSV6iqrqROh0sbHyeeZ5nAXtXF9uryJBonAhKqsJP42KX2SG/jQ6cYUC45G9Om4JM+bp6kwEf2g2ml4M2uiV2VelBL/TRsutaPmdt168noFSxVl7vYYM4jX9vZ+BTPXqLU4UDioxpkz1i01rasmSa2wb6YYnxChaVp66PqDhifAG7AcRxWnfc1LDnz0/o1Zm6p7Bg3U9IGG8YHHIeiigWIlM7SovfaIhMGzbQpmr26mG0xN5j0C6Z9YDpC1cU5Y3zMGzRD1UUukiyJj6zQrqq6kNSTpbpxNeY4zuSeamfX5QXqxs4UzVuMg0WnXwyO4zH/pI86boct8SEYH8O4sRvPVtIgdsoW5+7sAGOG+nhYIVVdknEpnkBeXbZxfOzmJCuKeo7sRzJ1Z3cTB8mOoVLpSKfqAsdj1Xlfx/JzPo+ZSx24+TPnvYHxibMYHwf2QxmHP5j4CLy6fAYfCkMI6wHhWIyPLkXwW9VFSnysuXaO41D94etM0pdsQFtAWLFUYN602t95HBUrTvIcwDBUxLDtUaHlyKJVXewI19DKAroLNjOOD/EOdpIJ2ri5ILV4udmgzBIfjuchi3rur4yRer9QYYkpErJs4dVVMmc5Nnzqh65OiukYH6NkxYuqi9W3ah+VL92MaH+bhTTTINWj+tU/xmfX4S69Vp8ZgqwYR2uMvrm/hXCBSbViJfHJHvRvk3F2djcSs9QYFsIFppAY6l5gN36VJjgIhSUom1/jjDpyPU2NHXItAHRVF8n4yLKMoor5GO9vt647kPgE8AJaFGyXTTx7xs22Eh8oE4fF9KTbCDwQZa7fxqsLAE689giTKbRbzFd+8BosP/sKhIvKLMuQcUjIk2e4qMyaYdGYVFGtRK+PEceH7nfVxiflzq7F8SFUXTaM56JtF5mumYybfd4w1T4yGeRr91mqLvcZunW7Ef07k31nZPDsTsyWNj5aahiS5pTX3br3YsOnfqQZWTuFX55tsaSImx7Zp/2WYLBpyphxce6Onb4q2iaRZcy/7H2Xo6BsNpYRBv1MiU8WN1Xy2zDb8ejV5VTVJUTMsYNUBiz9N3Drzu5A4mOh6lp+zpVYtO0izF59hkXVAeMTwAPSMT7Zcme3Mw51DJ/j+GinEYuFhMWgjfU0W5zOrBeHkqqlKFuwyp4YglExfiMroz/tW2kqJobEh8oKTWzQhsVOs+Ow8C4zYsaidQiRDAgjjo/veZNStIUsGB+vKkjTE4b8aanKtb+MDJ7didlaysagy+AByKaddC023PJpzho9umTTxjgBVV2aTZvZ/qV49mKs/ti/UPYpOZf4kIwPI0aWdwl7mr5MrQ2CIWhiZc02y+Ca5ibcfS9Kvc6QqgOEqoucy7KMUGEJZlWfilChxSExcGcP4AWOJT7ZdGdPI1rNFfRFklg8LWxiVMiSyN5gM13MiXQInMFOIWQpKdJPu7Iss+P4ULZVDM861cZHVXVp9+1tfBQ66fpYqi4/oW4OpkSMhvs0ER4YH4ZxszFBKgkvxs3sOD7ubGnMfI/15hkd6DTlC7OC0ZPdZOPjK/ySHrlzZ8+1xIduiDN9q2xFbuZSjEVRxXztWuHMuVj4ro+7aM+tVxcp8TEfLgHdnZ0Z0wgAT5hk0HUHEp8AHuBU4uO/qsuhcbMtGDRlxKAZTyMyNUGZWZQldv6bTEX2soVxM8fzlrF8yAVGYcjSGTeT70O7s0sG24i0SUo53sAYmo2b2SJv72Cpusj38xoUzQiWjQ+5MZkkPg69FA131IqJS0YXaFafmZlb4gKzJVmWceRvP0P9E7+AGI9a0qpCFA0SH20pVl2nJpA7u0FlSHsuWrfDUjv7y6gb26a99wTjxu5TklIjSmrOQvWHv4rS+brE2fV7uv5eDPoMa4kaMZ9mcPQ+MvWPWl/A+ATwgrQSH3VD9Nu4WXBm3OwembmzM67qf1lIfNwEMHQMmXRnp0+tVqciSu1hTNrJMG62zttFpKzQ3ILtU1aYbGdYqgMXbreOoDI+VH+QjIA72ysr6IwPmQSVUHUZbXxs4qBYMkWO6Eoj8XHozi4ldGZHTDhgfAwVa8EtsxjT0DuMqi5na0tx1TLM3fh+aixlc1M12qUtPetzqFp3Fhac8jEALtdbNxG++RAKy+cZ1FpuVVcuyzuQ+KiHB1JaStr7aCFGTLRMfbZgYuhDphgoxoclos+3O7tLZGaLRMeYMGVnZyyEikopG6ouIoChUeJjlTuIDCUvJmnjZobEhynBSj0iGRaUtCkrON6k4pm35UPoP/om+o7u1uvwEermQJ4Gye/fue/vLEJdt5NO4mN8by8SH/27MOL46Bds6XTqzk5GyXWycZhsfFJMsSTLEDjrbNue4JtrvJnRt5OiqFnMk7ExLc1INhmfgrJKLDz1Am1zL527AqVzV6C/8a0Uqc6llV5s56i576LP11/8PcdliQaIptjGzerhgQ9FsOyszyI+0o+iWQu1+9NZ1RUwPlkAbZdhnS/If3d2515dVvA9f5hGk4WNj8UC4beqS5YkilExnphK51Wjp+4VxoNKbjFZltDw5O2Ij/ZT95TH2YwuqdKUCRsfFUKkOI3Ex2zjUzx7CQrKZmuMj1GqlCk05sOCrmR0hEWo63ZYjA+5iRqzd3tyZ3dAFzPHEfm3mfNh1kO6cjuxJVEZnwRfgLAUQ1d4EQDF9sfvbSdTJsrojEEHQE3/rsaUMtlE5arTGASo0jSPEh+H/UfHoXLe59bSZmsw7awMbSbHh5TLQhgzFq0z1WFleB0wPgE8IX/u7FlSdWUUwNBePWNp4+KT95BWHeU2bbDx4TiULVyLxWdcgqJZC3Hksf+inuOEEORknGZ6lLt6fSmwjHBTts2Q5VSbxZVYdNrHULZgNRKmOglwnKF/UtIz6sSdSToGBizSEnAc5ytTrDKeydgoxvtaUTRrobaJVq19DwrK6MCanoybnYjsGX1GmXEZ5qhVH1B5kZwwPql6Xpr5McxOtKEtsgIAmbHdR4lPxrBWdTmTopBMhI9qFIfjXaPXY9Rtp0xMOlXXmvNvwmhXE4pnL8WRv/0MsiR6Z0oZjJlxvKuxeqxCQUxnG5+A8ckC8uXOTkkbvHp1+RzHR5uMpHEzwx3W1KLP0jAYGB/adkbJdVOxfCvzOauFIG3KCq1g6h/1u3McZq08BQCQMAQJJMFxnIFJVJ4nmQBy4/EzSanZNouD1TjIxMYHADr2PIXl51xhK22yC/lvOdYdzDMW7bLlDwCyBDE+juOvPAhZSmLRaZ9AuHgmxfg4GbtSSuIT5UtwoqCGuE7T7g98VnWR6l8nzEQOJT7s5lnxnNI9416SSocTMY9hJVK+EiV+3Se+i55DL6J8mYMozUz6ePPfFmPGyj7O0sYnYHwCeEJaTxuGt4kP8NvGp2x+DYbb61G56nTvlRhj2RhUXVaLit82PhSDYDAqttu4ZUkCL4TAPNemUXVRRQnjZkgkE2Z/ArZNuwCX4nsnsGA+jFFhDQS5boY0sowN96TaZkubAK8SH4/GzTLzT+W3LGOkowFDrYcAAEMnDiI23Iuewy8RZdJ/k6TBxkfgOYiS7PthyA/YHdScSHxyqepitq96pbnySMxM1ZUOQrgAczd9wAU9BlB9qho3s9cSq0ODtY3P1DduzsobiqKIz3zmM/jXf/1X7drevXtx8cUXY+vWrTjnnHPw0EMPZaPpCYG0Eh9tYGVT1ZU547P0rM9h1UevR/nyk7zTxAxgSBsWs+C/jQ9RH8PGx/I5G4mPK1UXiFgt1MaY5p0YDBrVD27qcgAtGrWbbOEevgsfimDJu/+JbttS2mTPyFtH3XYQL4tBu2TD+ECWNDdhQHEZJpketUw6GI2bBV6hI0v5wzODXT+6ZLzzIk1gRAlP/4xzd3YVZH4wcoxkA0zjayuJjwNVF1lmOkh8ssL43H777XjzzTe134ODg7jqqqtwwQUXYPfu3bjllltw6623Yt++fTa1TF4I4QIsOOVjWHDyDi3jLg39BOWv3UTmxs3kUs8Lipuma1dLJmOjS7mMwQNZ6Gt4g1Gx9+GqqR9Saq10Buj6c6JlX7JTVljHlFFTVpDB+awYvxXvv5JBG8sexV/mWVc3GeLduMzC7QTFsxcDUIwwZVkmNiZzffbu7N5tfNiqLus4PqNdTVQsJWNuJsChqstQb1hlfCSzOilj+GbcbH4vtzY+fm6qTvtID5aZnSSlKkgGPBkdddyWF9AHN8aBiKTLYu5Q+QqLZzCvT1X4rup69dVX8fTTT+ODH/ygdu3pp59GeXk5Lr30UgDA6aefjh07duD+++/Hpk2bmPXE43HE4zrXnEgornmiKEIURe1v8t+JhIrqbQDYtImSpC0iYjLpm2hRhhKtVJJkcELIU79IJG0un6/acA669j+H+ad8DG1v/EmpQ5LBiyKkVAwcUVTeV21DsnJdt6ANHr91UjuB8RBFEZKsL+SiJIEXLQLpiUnIjCiwACCKSWZdZL8VVy2D1N2A/tAclIoDSv0SMYYl9vuHSmdDFEUl+CGjbq3/xKT+t6FtJzDOoehgF2RZAh8pBjhO29hkmb3xqc/KnPvvwkVKlDGRjCMRHYWYVN5FkmXTe0gy+xso99i0qf1hN6bJuaiB4Ekkw/fp2Pd3VK17n3YtGRszPZ9MJtJ+h3iCDkSpSnxUelh9YAeSBtMYIcabF2g0EWNF789k2rolWe9jWc58vXY73tU1RnJAqwpRlIg1yrod4/xRn0lEh7O6L5HrhpwaK1ZrqZRa81gomVuN2GAnSuavQnToZb3uTMYLY1+eaHu0r4xPb28vvv3tb+OXv/wl7r33Xu16fX09Vq2i8yhVV1fj4YcftqzrzjvvxO233679rqiowB133IGDBw+aytbW1mZOfA4hJaLo71QyMyf2vOMbh50YaMVQqt6ZSwRP/TLcfAzxHqWO5J49Lp+uhLzqQjR1DGIgRUe8thZ8pBhjjU0Y7+zCUKQJ4ASMp+4PFTVqf6dDYu9eWyNXO4hjAwCAru4e7NmzByPNzYhpNO4HT7iU9hL0DKAR4lgvksPdpjqHG+rRGp8JWUyiL/XM2OE6RHr1TU2edQqOzV8LqWMEYipy8+BAP/ak+lYc7dP6ioTab8PHj2vfI3rgAEKlnRSNHC9ozMlofT0Khr1N6draWojRYQw0HQHH8Ui09qO/qxeyqEZ/LYKUGGc+m9i7z7MxfX/fEKREFNHdryB6vBGxzi4MlzSiLTmLKicn41ofGxE9XIdBxr2xI0cQ6Zcw3NKMeC97TMd7j2E49SwfKYYUH0OMOHD1Fa3AeOeb1DMD2KeNnQGuTvtbo+fAfoRm9Ni+d2O/Idls6ht29/QiVsBDGEli1MX8I8es+o7qteH6BpyIWifvTYdYez1GOrsQSRajrGILamtrtbr5UAFiaehU5z4ADMjH0ed6XaGhtj2AY+gpSl9XYuAEhjq7IAwnMOKwbTE6rM3LwXATOnn759S1lvwOiQzf0w7J4S5tzA/ILegt2YOBtnaIY2Yv0fiBQ9T6RkIu3wKUy+g99ob2jRL7an2ROE7kfdk3xkeSJNx44424/PLLsWbNGure6Ogoioroji8sLMTY2BiscPXVV+Pyyy/XficSCTQ2NmLdunWIRBQjMlEUUVtbi40bN0IQJo94TkzEcKhhDgBg3ebNtoabbjDWW4nG9pcgSTISQshTvzQP1WJYUMS0G7Zs8URHbLgX9S1KoLs1m7cgVFCMDrSjJ34ClcuXgQ8VoDvWAgCYU12NrvFjjupdt3mLrcrDDmN97Xj1DWDe/PlYt2ULWuNN6Jd6UjRuplSS+w/N0f6euXQJ4iOlGO81LwRzV65E1fotkCUJB44ozyxZu9YUM+NQvAV456CWpHRGaSm2pPp2vL8dR1vmwIg1mzYjVFiCluEDGEp9j+oNG1FYPpemkeM1FdHCVatQsWKLq34h51D3sf0QZlehrGoxVp58Kg41PwUxprQdKihFMsaI4QNg3ZYtnsdwfVsNYoOdWFa9DAN8HwbkXsyrWYXZa+n3kGUZLWN1GG41H3xWbtiEo60vmK4vWbMWMxavx7GBPRgJKWuNcUwPtxWhuet1AECkZBbio30Id7QDKXP2pctXgkML9czMpUswiD4AwIxFCzAk91L3l69dg5KqZbbvzZ8YBJ55VftdWBDBUDyGWbNmobI0goKZc1HjYv6RY1Z9R/XavJoazF7jvC4j+meIaB2oRfHchRgCsHHjRhxK1c2HIliXhs5OrhPdseMAgPJlK7HI47qiQn2v8mXLHNU12l2OpvaXESmbjVUO206MDaKuSWmncsUKzLd4zrgHsb5DNjDe346jJ3YBAMqXLceiLVtQ37oLsSHz+rjupJPTGl538t3ojjYDADZsZXi3ugBrX47H40yhRb7gG+Nz5513IhKJ4DOf+YzpXlFREYaHh6lr0WgUJSUWGaABRCIRjcEBoKm9BEEwbeasaxMZglCMyup3AeAQjrAt670gFC4Ax/HgeQngBU/9whMeT177NBSOaHWEQqEUHeEUbQKEUJhoI+Q4RLoQCoH3SJN6gOEFhR7yPUOhMPWuVCRmjn4fFQVllZi5eD0EQYBM9VnI3G+qV0kqNB0HSSvDc2xbFEHtt1CI+h7qcxrtBSVIppgTZtsOkZQ5fOCuIzh5bBy/uPF9qbYjkFJu2rzNdwqFQp6llnPWvgf9Te+gpHIRBpveBsfxEAzfQ8WKsy9Dz+GX0fbWo3T7kQLbPrQb0+T4U9+Rsr7hBXPdUlK/JiZM93mOS/sdJIPdSCil6pIBfZ64+JYkDcYxkun6qPYRn5pEgkD0iSynrZscO1bf1g2078XzjuoKpdYbDs7XNImk2cG8UvuYF8KaBDabe1KIWEO1Nc1ijoYihWklOH6s+0aQ426i7c++MT5/+ctf0NXVhVNOUeKTRKNKvppnnnkGN910E15++WWqfENDA2pqakz1TBcsOu0Tvtfph3FzpKTcVzpYSR7TBTAsrlyMsd7j5np98OpiepnZ2FjJEturq+YjX9VOUWnrSvWBlrKCSs1gYXioGixa5OpafMYlGGypRXHlYnTsfcp03y3aBsYxLpThpbIPo3jR+hRtzpJRZoJZ1e/CrOp3KT9sjJs1MpxkXNfvpCfA8O2KZi2ELJMZ1s11k3m5pKTZuNmJ95DRuDkkqCkrVLImUABDuxQ7Dt7V6VzLGjTjZhd2Jh4iNwPKQSSRipicVTC8zqzGjJOxNBHDKGQTvo3CJ598Em+//TbefPNNvPnmmzjvvPNw3nnn4c0338T27dvR09ODe++9F4lEAq+99hoeffRRXHTRRX41H8AAr4zP3E3bUbH8JCw/5/Oenh+NJfHzF06gLxFBuHimnvXcRQDDSGmFRe0ZbAZkZnZTXTZxfGSJ2ZdW/WtMlAiY3dllWU+fUVg+V0mkaEjRoLuosvuqYvlWLDvrs5axONyC3IhV55eiWYuItu2WCn82ad1LzqYtVnBDK68uXpdKWFZHbXA8Vm7/IkYjVdqlxw+YbYdITy6vXl1Gd3ZV4mNkiJyiYIZCM/vg4pdXFyOOjyN6sxXHx51Xlxt3do7BWDhByZzljstmArY7+9SPv+MXchLAsKKiAvfccw9uueUW3HbbbZg1axZuvvlmnHYaI69KAO8gFyGPC4wQKcLiMz7pmYTnDnfh9ucb8cG1H8Wd55+SNgAfa7Ja5q7J4BSsLrgao2BzCg0Xz0RibBCAckpkSWWMzyw+4xLER/pQXLnIVFb9LDKxUMuSqBkEz9/6YQCgVTjMU5z9+2ciJSA3YjWdwoJTz4dQUIxZK09By0v/Z2pL2/R8k07oSWStQC74JVVLMXPpZusEs442Rjq+FB8KYzxSAUCROD6+vxPv2ZDAzCJ9DFASHxbj4yGOT0gwMj7u+nT52Veg+9A/MHvNma6ec4YMA676nE/OdfNaXjg3MYe80bnwXRdAKChGxYqTPT3vFHSiZ7MU2zWmmcQna4zPj3/8Y+r3xo0b8cADD2SruQBQTn0FM6rAhQqQzFMshvG4Ik4ejsmGWDn6qTFd1GSrUOqZoLBiAYqXn475J53DuEvTsHL71Wh85n8QHx2wTVlBgpnuAsr7qlF6Ze3kibSnT61f0pzivMQbYYFc90RR+REqKMbCU89n1i1EiqjEnH7AOniiDnLBr1z9bpQv3cSUutBlnQUw1CL8yvT9wfE4xfiQ7XlVdZkDGKZUXR5TVkRKK4hvRaNgptl43hXsVF1uq8qDqkv/rh6TlLqAECmy/A7+gjXvM2EqpxfjE8jGphA4nseqj96AFdu/mDcaVGlB3JTewHkAQ8uswZlIfDgORUtPQcncFea6DPVGSmdh3hZFCiNLkve8ZwAuv3c3fviY4s1AZmdPb29gb+PDfsRfiQ9VtWHDipTNJpr1SdVlETzRQAjRbrqTbnq6WPZmIhW5mcPf9nWgY0h35Zf8UHUZbXx4/WDgF6rP/RIWbbsQpfOqM6on09yCRnWiX3CsVspQ1TURwZL4ZMsObyoiyNU1xcDxPLg8ii1VUX0sabWx07m6WCdANzlvvMNeh0+eEjOh5/k6Pf6PmqtLEfikYXwYGZfZi7E/ix2ZOyrJ3LjpdsJFM7D8nM9bGmd7guxA4sPKg2dV3slGwLLlIAMYpr7Zq0f78PGtC5Vroh6Dh/UdHam6RCtVV3qSnaJ49hIUz17iQ01qv3hNqEGrEzOFkuX8GMqXbXHWuofIzflQybkCw8aHtT7UfPgrjqqbbsbNAeMTwFeoIffjScMiY5Griy3x8XEztUJa6Yl+SlQzKvvRppahPQ3jo3t1pU/vYXzGCxKEhM7p/lA231+vTD3bvTNVVzqJj5Os3KwEmhI4radV9WRh2MWG7YTxsZD4qAeHCSVxyFTiw0ivkAnILOdOoNr1SWICkph0FnNqIvU/A04PAGrcr7SYZoxPoOoK4CvUE2vMyPikIBtUXfmT+NiDPCUWlFV6qoO1UYzxZZD5kLUBt06B4V+rYv4s0CTjw5L4kPnFsgaLzPA0GEbpVlmpHdmTmNUwpGeVapBeVuD8jOgoV5fJq4t2Z59IEgd9k/XBxicPnkdCpEhrVw3ImQ4TivFkgSWlzkAinH49mloIGJ8AvkK0kPhY6/k5LSGnilwwPukWNlLVRdqzuIHRgBUAXp3xEcRPujL9OzLi+KTfyDOR+Jjd2an7Y4bYJFnYGNwaN8OpjY/D7OyaLQvpfZdaIosizp0FnKi6kmm9uiYQOAf9aF+B/lc+jJs5DqFCJcyE8+ShxBiYgN+EPUcY88DhPJ299j0om78qK/HlJiICxieAr1AXbpOqizJupg12S+dVY/bqM7RLJFOQvZNX9lVdxs0NABJ8IVAwg1Ha0DxT1WVdLvXDHYEkXWkkPqRdS7bg3rg5c2kYiyEnP5vKBLna+7wEMDQaNxtof72xF+/76S68cMScMy7b4DJlfPLszg4AocJSAEAyyk67YsIEl/hQ64KNitjp+imEC7D8nCswa+UpvtA30REwPgF8hW7czF78+47upuKgsDxGyESk/gY8cw499ocIXgihbMFq13WwJD6A9f7BXKTS2EP5BcrGx8EGlxWG1LVxczqm0J2qS7fxIUji3BsdO5EQWLqzWzz6uf99A8d6x/C5e95wTohvUCVhmXt15Ws+q4FFk1NF1cVcCyY6zRMHAeMTwFeoC7edcfNA8z7iekpdQSyIlMQnWwtlWlWXzvgAwLL3Xea6iaRowfi4qINpxEiXIG57X/jiBK0sSZUfqUzSwb1xs1OJj1NVlyGWDghPPBfSDiepEYx9nMpYAYlXxr6R0Y4mvHpU+QCGxMedrY4/UslMEFIZH6cSnwnORLADw05smicSAsYngK/QbHxEiTLgpDYp2Xx9zvr3oXDmXMw/6aM5YXzS2/ikTv9i0lF5Fthu4e42UVcbfQYgGVWWpGrFB65C+dJNJGX+E+HEuNlniQ+VkDY17si3V5OJunIzd6LqsjBuTpx0BRaf/knMWf8+Fw1mF7pUVn+vcHF6dS1RAfFnfrYcVdXl1Lh5wjMRVD+qnoDBdu4UQU8F8BXkpk4HMSQWPyr5pTIEQ4WlWHXeDaha+x46NkzWJrM7iY8XWKm6XMHrydolSFUXi+5I6SxUrMiu/l83brZ+D87NJurEDZuoT3V7JsvLhKdXUcV8+/bUZ5youogyD3/xdPApG59kqAwVK07Km0qIDbPEZ+lZn0Nx5WKTY0L6qvJr4yPGx9OUnBxgq8UnOLM2gRAwPgF8BblnmqM3KyAZG3bKCtK4OT9DVI31wWJ8nEpeEj4wPmlTUmTBuNmSYfOpLSvIDiQ+biJZO5P4EIxPatyJDK8umTDK5zgOMxevt67URcqKj2ych1OWzco4SWlWwVB1FVXMR/WHvuwoKvREsPEpX7YZZQtWuwh6OPmYiMlIc74QBDAM4CvITTOWkAA1fyRnIfFJk7LCVX4dN3Bp42O466gJY3ReFdZ7GwezPYpzZiOzAIZEygoLxsdrxmrHkJ2I7N1LfNIU0v4SNIkPQRKh6lLHxJwN56By1RkYPH6AWaMTKaHax3yKRvVfln1VvqEdVLy6orvxxMsSIqWzsPzsy/PSdu4QMD5OETA+AXyFtapLBxk5lemCSdzPRNVkh/Q2PtYSH6fSDksbHxfmza7c2TOAI4lPlhdWlcl1atzsmBG0Y54piQ+L8SElPsqYkMSkbf42R7m6Un0spCQ9qsTHqu95zt90Fm5QNGshqtadhcLKxWjsZieEdYzADsV3WIVACGCNYBQG8BWk7UIsoTMNlLSAyu9knqwcx6F07goUlFWiaNbCrNDpxsZHXVgWnfYJ8EIIy876nKMWrE7v7rQZbqQsGXh1pTFu9rMtS7g0bk4v8fGm6iJfX+JIiY8e28leZePcnV1lfPg0jI9aLh/geB7zt34YMxau9fb8BDBung4I+tY5AolPAF9hbeNDbDBpJD4AsPz9XwBkGcde+K3fJAIAimcvtr1PbWyyBHACZq08BRXLtzq2U7ByZ3dzck+fq8svGx/77OyZ1u8Ezoyb7dOd0GXdqbq0nE4E46IHMJQpKSDHC+A4jmnI7CY7u8A5k/go7yJrZfLJCLlH/t3ZpwWmUN8eOHAA//7v/466ujoUFhbiQx/6EG666SZEIv5E9Q9YxAAZ4X/+cRS/ev6o9pt00zVHb1aQTuIDKAs9x/NZswkonb8KS878NFad9zV2+wRzQ6q73BhnWm1ilgas6XLtZHFhoyM3p7fxyQ4tqsjeXcoKm8JKrQ69ulQbH0k2G5STNj6SmATHcZZpR5yoZyWDxEdwoOpSMRrPQd40PzHZJT4T0eCcxERMbJsBJEnC1VdfjXPPPRdvvPEGHn74Ybz00ku46667fGtj0kl8RFGEKIra3+S/ARTkql/G4yJ+9nQdAOCirfNRWVoADhKKQsoEjMWTGg2SLGk2HDI47W9JkmzplCRZK5vJ+7D6pGzRest6ZVm3OUnEYwhx7r1REsmk1hckOIt3lok+0vpNkqi+guE54323faSWlyVRo1Ui5hhVNsO20tOShCwr8Z+s6haJ8UDSoNsHCRrjod4n+8hYL3lP5gSIoogwD6jJ2AtDPMI8wEFGqKRcoU9UxjUXKoDMcI8WxWTavpElZZ4UCApNBQJS/c/u1wKeA5f6PsPjMZS4yRbvE7yuK9QYla2/7USDPs7Y8wHI7x5knAcSsWYZ6cslWH2i/j06Oop4PK5dj0QiJinO4OAguru7U+Mm5QTA8ygq8i+RKidPxAxsDMTjcdTW1uabjAAeET2xF6MN/wAAFK88E2NHXwIAzNh8AcIV1mqn4drHEO9tAgBUvu+67BNKoO+F2yHLMipOvwJ8KvJrVtv7xx2amkR911jHIYwcfgYAMOs915iMamOdhzFy6O8AgBmbP45wxaKs0ZcYbMfQOw8DAArmrUXpmg/4VreUiKL/ZeVEV/6uf4ZQXMEsJ44PYuD1+5Ryp10GobAMAND7/C8AKEbpaib5ijOuBB8pwuDbDyE51AHAPIak2Aj6X/1fAMDMkz+FUFkVxo6+jPHjb6fa+JzCBUsi4n3NGDv6Egrmrkbp2g9icPf/ITnaa6KxcNFmlFS/N6P+mEqIdRzGyGFljJat/wgiVSvzTJEzqGOqaPFWFK88M8/UmKHSV7hgA0pWnY2Rw88g1nGIKpPrNTMdPv/5z2N8XD8sXHvttbjuOjONt956K+677z5wHAdRFPH+978ft99+O3ifktxOOonPunXrNA5RFEXU1tZi48aNEISJFPArv8hVvwyOxfHun+wCAPzly2dg5Zwy3Pr4Idz/egsA4I5Lt+KsVXMAAL3F42gfPgwAmL96DdpHjgAAlq9bj5K5KyzbaB6qxXBIiba6YcsWz7R66ZMDdfMhS0ms2rDeU8qGN5r6cMW9u03Xv3jWClx7Tg2jvXnapq2+a3+ThNZ+JcXHus2bwYfC1DMDTTJO9O0FACxbtxalc91tKmq/PHJMwM532gAAP/vkZmxfP89UdqxnFhrbFOa1YvlyLMzgexjR+sZOROYqY6Vm4yYUlFUyyyXGBlF37EkAwOpNm7UIwvsPKc/yoQikpHKiXLtlC4RIEY52vYLxXoWhNI6hxPgw6hpT7W45CQVllbjkD09iwbAy5v7R04OYUIL3ra7CD04pRPvIEcxcshiLt2xBY/frGOsxj6VZy5ZhQZq++fmzR3DXP5pw6bYl+OZH1uJnzxzBb15swmdPX4qbPrSGKjs0nsAZP35O+33/lduweXG5bf3ZgNd1ZaBJxol+ZYwuWbsWMxatyxaJvkIdU7NXrMA8i++Zzz1IpU+di62xRvTLNCP+/9s778AoyvSPf7emVwIkQOgQeu9FRUBOmogROdRTyok/PUQ9FQucioee4sGJiKKoHKKioh5iAUFQem+BEGogIQHSyybb9/39sTuzU7dlN5vdvJ9/kp2d8u4zM+8889S6zJm+IiUTk8mE7Oxs7Ny5ExqNcw6Titmx2WyIjIzEokWLkJmZiatXr+Jvf/sbVqxYgSeffNIvYww5xUelUokuMKlllMDLxQol9BZHiwqbAiqVCiYbnMusYI+vUqlZ/75aG8n+r1KrXY5RpVI51/XDb/FGJiq1BlazDUqFb8e2EgUrCy5mh6yEKJVK2Aj/t6rVGp6slMJrX63myMe1LF2htxB2rBZIj497DpVKpV+vLaVC4bw+XFwTNs4YuNeOc1xqEIXFMV77uVYqlLLXEOHITxMRBZVKBb2VgGmNpbcCRmKXjUqthUKhhAIEKpUKmshoyZgVT64Xk9VxbSgYOdrvJaNVvK3RauZdRyabf+4FX/F2XlFy7mG1Rhsyc7XzmnL/e4PxDGLHp7Dfr1w5c8cVLLgyYf7GxMS4DVDetm0btm7dii1b7C84nTp1wuOPP44lS5b4TfEJwUgzSkOBG4ipNzOxPJx0dm5wMzdtWKJlhTzBTON1UcvHA8wy2T2yWVPSo3D+5y74uQ54VsfH/8dl4PV+8jC4WTJQVkJGLQbeBYVCidTe40Tf2Sxm9n+2V5fE+fn9XDEuldTat3H0b1NqIkXrAZ7W8bGv40lwc60gmFkuaaChwj9P4RGA2xDhtfoJYa5fv86LAwLsL0NcS1FdoYoPxWe4D8takyOgjTMnG+WyupScdPYGnInA1vKx+pZFI1e5Wdig0vUg3LSs4K0a2MrNgcwq00QncA7j+7TEz7qzjze6SSv0mP5PNOsxSrS+OirOcUxnlpaNI2fC+f/Jrx0xho4AUm5WV9epLyGt7532rz1qWWH/qxQoPlIZdXozX/EONcWHl9XlpxgNihimHEOoM2LECBQXF+ODDz6A1WpFfn4+3n//fUyaNMlvxwg5Vxel4cB9QNYa7coBr3IzZ4LmF4pzn87O2bBug6wDdW1UKpcWLt+PSbqYo0u8UIxcwT1XFiux160RHDuQ6ezqKKfFpy4PR010AmKatoFCqYJK67TIyO1TqVKj+72vQKFUOrKCCU8x5So+NoXgeuAoOOqIGKelypPu7I5rQC2y+Ii3FSqiZpmK6CFBKKazhwgqGQtkqNGxY0esXr0a//nPf7BmzRrExcVh8uTJePzxx/12DKr4UHyG25Lh/z4/hp+eGCHv6uK6bJRcV1fgrBh1xan4+GbxkWtZ4dVzi/ug8EoJ8g7uw/S5b09h49Fr+GruEPdNUv2EhqP4uDqOuyalCoUCbW550Ktjq7SRsNoIJr27BzER8jERpepUxDRTI6l9fwB8l5a95pRStFwO5tpgenQ5FR/xukLFR64VTEMl4D3eGjtMyneYWHwAYNiwYRg2bFjA9k8VH4rPCC0aL286gzZNnGnfciZ5nsWnAVdTqKvFx+sChlJjcPPQ8F+vLv6YDl0pQ2mNCSmxnMk0gA8wxuXkDpU2Ck272lPF1RHR4hV8tCgUVuiRfb0KANCZs5xr8TErI9Fh7Fznd4LrgrEqeePqEvfqcm/xkXMhN1y4lkJq8QkU4WLxqQ+o4kPxGWFLhjOFVThytZz9bJIJbuZZfNz2NQqixUdVt+Bm+ZYVvgU3u12zDsqI1Jjyy2r5ik8AUUfGIr5lVxCbBSophYZDWr/xst/5KgOjhXuOubJQiNaLUNsV4oj4poKDe+HqkqvcLHFpCF8wQs7VFeqVm0OEcLL4BBqq+FB8RjghC4Mw+Q8TJ8JaNA2VQFl8PMuaYgbhzYPcd8VHKh4pr6wWfVs7CwkGMjtHoVCg7W2eNX91vSPfHqw6o/Q5JgL5V+ktaBpnvy6adrsVVrMBCen2CuDeubrkWla4t/iEWnCzIuSDmxuuVdqO41qiio/HhOJVSGkgSE3SXOSCm7kWH7eFw4MYE6Cso8VHLp3dm15d7t+Q/SMfqQy0a+XidgzOwzbMWA1fLQo1Rmccl6tfVqnnpr9r0KL/RMQ0a2ffzgtXl03QpNRVOnuoKz58iTbM6yYUadp1JJQqDZp2t2crypVXoIihFh+KzwjjQoTIBjdz6/i4UXwaQnCzzdd0drkYH6+Cm734/XWQlVRtofyyWr/tP9CoNBGwmo2Ia9HZ/coS6Izccyyd1QXwFR8xjnU9ivERWHwUnis+Iefq4hCaFp+GSVq/CUjtcycrU2rx8Rx6FVJ8xp3Lhv9m6lyXX2ulAcf41DWdXUYx9KaAoTfp7HVREqXOZVkNv4hYQ87O6TzxaaQPnYaULr71VNIZpJXbR2/ltwCpMsgrPuz14sH5FSk+Liw+QjdkqFl8eMoOjfHxK1zZUouP59CrkOIz7t48uWm3vNRfzuTXkF1dda/jI+Pq8ibGJ8CKX0WtCaduGmGROJdil1zDUna4aKITkNS+n0Cp9pwaQXVkpQKYNbwNxvVI4y2vcmHxiU3tgJhm7dh0d1cwCo4nBQxFWV0hZ/Ghwc31AbX4eA51dVF8xp3FhxvczI174D6cIhOau9xHUrt+KL981O16gaC+CxhKWVEiE8XNQuW38V4xmfbhQVwqrpH8Tm78vh6rIaPjxfjYHVxatRIqgWumXGAF46KOjOWlu7uCDW4WxPhIXRsiV5dE/7eQoYFZCsMJX5X+xghVfCg+4/rBKDDJ8xQfJbpl/gM2iwnqyBiJLZ3EpnZAxqS/QxOdWJeh+kRde3XJtaxwExrFQx0Zgy5Tnue1R/AnckoPIKHYhvFDq8bIt/gwP1UtaPJYWGnwy/GYl4IorSM+g7H4SFwcQsuhyerb9Rg0aDp7vaGOiIHFKH9PU+zQq5DiM8wkPahdMprHi82s3OBmnktLoYQ6IhramESPjhMR3zQoKfB17dVllg1u9u6NXRuTKF2sT4ifFROh4hPIlhXBRhjjw/w8RiFhEAV8+wijaEVp7Mq12oXFR7gs5GJ8Qj6dPXToMuX5YA8hJKBXIcVnmDdRtVKBSI3YzGqUs/iEyEMzplk7KFUaRDVp5dP2cun+3vTqck/gAo7FFr3QOG++IKzjw/xStYo/ReaX+0fxYZr6Rmvt9w3TukLKiiq0ArnLpmx40MrN9UWo1EgLNtTVFcZcKa1Bq+QYttKsv2EmZLVKiQi1eELjvpl6UtStoZHUvh8S2/bx+S1VzhXoVQFDr/CvYiKyTDXgrK66InZ18VtJMOSV+kfxYYp9MoqPWuWw+IRlHR8n1NVFaQjQqzBMOXnTiNHLdmPGRwcDdgxmQlYrFdBKKD5GmXT2UKIupnm5GB9vChi6JYAKiFBxCzdlhws3q0tBnNV7hK6uKoPFZUq7pzAWnyhPLD4h36uLQwheQ0o1zZYKN6jiE6Zsu2yvunuU0zvL35g5ri5h9gsAmLhZXSFo8akr8lld/jtGIONuxJap0HtoeYpQmWD0HaHFBwBqZdpbeIOedXUxMT72+0fKGiiK8Qm5dHZODa8Qsvi0HHQ3Ypt3QErXkcEeCsXPUFdXmOJpI8waowX/+iUHE3qlYUj7Jh5tc/RqOb49dg1p8faCWWqVQvKRyA9uDrXJuu7I1fEJlKsr8DE+vKP59VjBRljHSM7iA9S9cjIhBLUOC1MMY/Fx6AOSBQwdlkOFwl7o3BxiFh9uYkMoBTc36TQYTToNDvYwKAGAKj5hiqfP1hW/XcBnB67iswNXceVfEzza5p739/E+S1l7APl09saCbMsKr7qzuyNwCoirGJ9wg6/kEWc6u8S17a6MgzuMFht7fzKuLtbi46KOT5RGhVqTNfQsPoKMTgol2NCrMEzxdG7OLal7zQeNUgGJF2N+5Wa/PuwbPharDdUybRD8q/hw8bfFR2AFCeN0dmGmFGvxUYl/p1SVa29g3FyA09WlcmHxYZQhJhBa2Eqk4cN1dYXXdUMJTfyq+OTk5GDmzJkYNGgQhg8fjueeew5lZWUAgJMnT+Lee+9F3759cfvtt+Obb77x56EpAjx1p/hjHlIpFZITmtHceC0+d76zGz+eui75ndy5CcZDQSPxYGdoTDE+XGVGAfmsLqDuFh8mkNpeGZqp3Cwf48MsY0pG5JbU4OvD+XUaQ9CgFh9KA8BvV6HBYMCcOXPQt29f7NmzBz/++CMqKirw4osvorKyEo888gimTJmCw4cPY8mSJXjjjTdw6tQpfx2eIiBgGdMSCGudMMj16gp3CCG4UKST/d6voqijFUYrc+4ACbdLGL+ti4o1Ov5KxfjINZ/1FL2ghg/gujs7c7woTq2sVzefqdMY6hN+n77wvYYooYPfYnwKCwvRpUsXPP7441CpVNBqtbjvvvvw3HPP4ddff0ViYiLuv/9+AMDQoUMxadIkfP755+jVq5fk/kwmE0wmp0nXbLankFqtVlgdJduFfyl2rFYrry2Cp/LxVY52o4H0m6rRZIZapYTVamYDnINxvurzWuG6MiTHQmyS47DZbF7LyGa1stvYbNL7dYWrB5HFSnj7s/KOZQ2r+04YsKxQOGKcJLRUo9lSp9+uc6TDR2lU7H4UcJx3GxHt2+L4zLU+dWgaW+/y9/UeslotQb33A0lDfAZxE0kaylzbkOQD+FHxad++PdasWcNbtnXrVnTv3h0XLlxA586ded917NgRGzdulN3f6tWrsXLlSvZzUlIS3nvvPWRnZ4vWzcrKquPoww9uHMmJEydk16uoqPBoPVeUl5Wgtka6tsmR4ycQqVai5vJlGG4WAQAsPh7HH9THtVJhcH2TV1fXSMq6/MYN2Mz2XlCeyshcno8qh1yNWVlQRSV4NVabiz5kBqOJN06b2YByx7GqtJdwA56NMRSoNRh5nxUAiouLcerUSXZZpFoBg4Xg7LnzUJT53jvtdJH9WEqbmZVvXqX9/jGYzKJro+B6NQBAS5xjTFAZfb5f64q395Cp5DKqG8C9H0ga0jOo1CFrIPznWl8JSFYXIQT/+c9/sHPnTqxfvx7r1q1DVFQUb53IyEjU1spXQZ07dy5mzpzJfjabzbh8+TK6desGrdY+6VitVmRlZaFnz55QqWhnWgar1Qrbjt/Zz3369JFdNzH7OFBw0+16PL7ZwvuY2rwZisyVQIm4ZlCXbj2QGK1FbcskXN5+HdrYJujs6XH8SH1eK/aA8WLZ7yOjoiVlffZyGqyOBoM9PJSR7kYsrtywZ9l17tkL2tgkr8aq+GEbAKfy84+JXdEmORqz1x2FQqXmjdNqMuDsxWYAgJT27ZEahPMYKBS/7ABgtzArQKBUAE2bNkWvPn3wZUIZaowWvLn1PC4U6dCuQwf08bD0gxTlOUUAypEUF8PKN65YB/y6B0qlSnRtbL1xDsjJxYCOLaCNqsThK+WIjU/w/H71E1L3ECHErfuqKl+DvOLDADy/rkOFhvgMOn22Gft/MOQtJROTySRptAgWfld8dDodXnjhBZw5cwbr169HRkYGoqKiUF1dzVvPYDAgJka+M7dWq2UVHACs20ulUokuMKlljR1uqIAr2XAr8PgqQ61aJTv5WYgCKpUKcant0WXyc9BEJ0AZxHMV6Gvl8S+O4SeZoGYGAmlZKxVK2BzBn56OUaVSs0XhVGq1179NGFPywJC2yHM04rQRwt+f2nkspTK87jlxQ1ZAqbRfu0M7NgUA/Hv7RQCAzXFN+4rB4YeOjnCeL41azY5DuG9maGq1Evf0a4XDV8phtorXqy+Ye+iNX87if8cLsHneCDSLi5RdX6lUOq/RMLpmuDSkZxC3SGQwx8SVSUORDYNfQ+zz8vJwzz33QKfTYePGjcjIyAAAdO7cGRcuXOCte/HiRXTq1Mmfh6dw4Lq6XGV4+SvWUG433Fo+EfEpYd9Ez53SAzSsAobCsdircDsCbYUp3mEcmMoPWCaS1zOTASdXmNJTiqvtLqvkaOeLHRO/I1nHx7FMpVAgQmOfshtC24rVf1zGzSoj1uzOdbNm4yplQWn4+E3xqaysxEMPPYR+/frh448/RnJyMvvd2LFjUVJSgrVr18JsNuPAgQPYvHkz7rnnHn8dniKA+zzbeDQf+WV8t6LVRrDpRAEKK/Re71vYkNRotskqUEZLwwpqCyRSDSYl12tANY2EqdlKpYJ9CFtsBNfKa7HpRIFDQeKe5IbzG/yBmZt5BGn3DaMQ1rU7en6Z/Z5LT3a6/5UcmQvh9cRzvDk3BMWHodYkXa+KIa5FBjRRcYhv2bWeRkShuMZvrq7vvvsOhYWF+OWXX7BlCz8G5Pjx4/jkk0+wZMkSrFixAsnJyVi4cCGGDBnir8NTBHCTVBZ8mwWtWonz/7yTXbbhcB5e+v60T/uOiVDDaHFm3BksVvRulYgDl8tE6zakCTrQGNwoefGRalQZLAFsUurd9jYbgdRQVBzrw6i3f4fZSlBtsGDGgBbejy9E8CRFXeOi1o43MK7E1snR7DLW4uOiSalKqWSbATekDu3uxqJUa9FlygthXQ6BElr4TfGZOXMmLxhZSM+ePbFhwwZ/HY7iBqHJXDg57b9U6vO+hbVNDGYrFk7oij/OFyPnBj+WqyFN0IHGYJb+rYsmdkNFrQndW8Tj0fXHAubq8vbBIuVWAfgPYWas+y+VYsbAlnUbXwOFECK2fEmIUq1iLD51u6avldsVn1YcxUfJqeMjDBhmLIlqlYK1tjakFwpP7vFQ6tFFCX/o1RimmNy8wWrV4lPviavm71+fZGMUGIxmG6K1ajw7LkO0fkOaoAON3ixt8enQNAZ/vyMDyTERAALYnd1L5BQwpYT1QSmozh1OLUik5CAlVaZQZ10KGBJCWLdzepLY4gOIrw9GKVMqFByLT3BcyJfLzZjw7l5sz77JLgu53mGURg9VfMIUNzX0RHE6AD/OQYoaowXfHrsmWm5wPPClqtw2LouPtNCZBpRMkWQ5V1ddg4e93V6u9YJUmwb7svB0VUjJQUqUztgn369po8WGGsfN2Sw+gl3O7QkmVMS4MT7MfRssZWN9VjVyblRjzroj7LLGdI9TwgOq+IQpRncWH4lWBe6CNuVM/ExsC7eTdWQDyj6pL+QqNjMKodJFWwIAiEp2upLKakw4cqXMA8tKHSw+MudbSoFVKRV8bSCMLD6iqs1uXIB16dXF7V/HbUGh4si2opbfhNTKxvg4LT5GGbdqoIlUS/Tks9hwprASBT4kSlAowYAqPmEIIcStq0sjofi46zotF8PSKtFusuc+MJlJvTG9DcplsDFp0IziI+dSbDUkEykZw9F5wlO4Y/kfyPxgP/ZcLHFzVO6+vLX4SJ8bScUnjANTPXVdafzg6mJeEpQKvmVNzbH4vLqZX+iNq/gE2+LTNFpcj+VikQ4TVuzB8H/tCMKIKBTvoYpPGGK02NzGkUjF+LibTIUP9lX390Nm/1ZYcGcXAPzJm1V8GliPlkCiN7lWJJi/cudGHRmLFgMmITKxOUp09rf+XeflK0CL8Da4WWYgkoqPShG2dXzEFhwZi48fgpsZS02khl/0M0KtwuB29hIg+eX80hOMgmpXfFS8/dQ3Ui9U1ysNQRgJheI7VPEJQ3RG13U1AOlnpLs3WaHbamj7Jnj73t5IjrEXYuM+MCO1wZ2gg4G7GB/W1eWFmyguMnAFH+VjfMTTglTcT7jgacyOyh+uLsfLg1SM3Qvj7XVuzt+sxiPrjmBnjr3nEq+OT5AtPu5uZ09rWVECT7i+qPgDqviEIZ4oPlIuKHdvssIHO9fCAzjrnABApJqx+DQexUcuq4uREyMedw8HbqxQbITnFSe8nehks7okdiNeFD4POEbhd6fc+aOOD+MuZiw3XJo4XiAMZht+zb6JmWsP846n5Li6rDbi1jUdCNy50BtTTB8ldKGKTxhSY3TvXpIKZHan+AgnNWGcEC/Gh1p8WJgHKhMn46pyc15pLUp0znIBGgnLgK8QQnC1tIYNmJazXCgUCpG7y90Dzx9U1ppRXmNyv6KfYa57KSsMF7+4uhwWHyb4n0uTWOmO7xYJiw8QnJcKd9eB3D1AoTQkqOIThtTIWHy4b4hSb2busrqESozwDVk6xocqPmxWl4vqvADw9eF83LJ0Jx757Ci7zF1wOC/rS+H6dv507xXcuvR3vPbjWcc45PctUnwC/CZvtRH0Xvwr+r62rd4fnoxiwSgVcnYffwQ3M/edlMUnWqtGtFa8nJfVxXnZCEbigLs5Qs7qSQkG1NUlB1V8whA5VxdXCfHF1SUMbhY+HHkxPpqG11Mo0MhlvTEPTDarS+bZ8fav5wAAZ69Xscv8+XB7/We7wvPJXntTSVenW6jUCs+9vwsYcpUdYYHMQMO6uiQyHbmwvbrqUMeH+Z0REhYfQNrq44zxUUKtUrLjCMa9ZXbj5qMWn+Cj0tp7wEWnpAd5JA0XqviEIXKKj9ninLSklJxFm87g8BVxvy0G4YNdGFOilnJ1hUmT0k0nCvDO9gsuH/hyb7sqgavLmxgRo8WK93ZexLdHxYUjhbiL8RG62FwF9Qba4rPvYgkWb85mrw9uwHfAWnrIwMjBef26zuqSq3/kCYyyEilh8QGAJjERomVOi4/9M2P1CYbFx11hVGrxCT4dxz2GlIzhaD3i/mAPpcHit15dlIaDXIyP0WoFYM8Skpo0T+ZX4N4P9uPKvyZIb+9GieG+MUc2wGaKdWH+hhMAgJGdU9CvdZLkOu5ifNjgZi+sJacLqrD9rL09wD39W3m8nRRCfcKVgiGO8fHveZyx5iAAIDFagydGd+K5j7zJevMHZtbi41lws1+yumQsPikSFh9uk1JmW73ZGhSLj/sYn/C430OZiPimaDFgUrCH0aChFp8wRNbiw5m0fHmQuZtouUXunBaf8JoIK2vNMJitkpYfdxYfpQfBzULKOVV8JZVI3r7807ICkHB1BeiBdrqg0jEWvhtWrgp2IGBi3zRuGmn6s46PXCB1fJS4fAFzvTDnhLH4BMOa6i7Gh7q6KKEAVXzCELngZu6D05fJ292kxn1uhFPlZm5Q+I0qA7r9Ywue/OqEaD25t13GEqZyE9wsBVfBkjuvLH5KZwc8sPj4ySpTZTAD4AcMH8+rQI9XtmLJT9lym/kVNobGodhYFNLZVWzLirpUbmZjfKRdXfESdZuY4zHB8RFBbAdDs7oo4QBVfMKQGpP9AZmaEInWyc4O0FwlxJdJ0902Co7FQRtGri4D5zd8eSgPNgJsOlEoWq9SL52KrRZZfLw4NkeZ8qQ+kze4eoALW1QEyrpQpbeIxvL6z2dhtRF8tDs3IMcUYha4ki5E9UZNZBpaDs7krcd2Z6+Tq8u1xSdBwuLDLWAIAHER9nWq9Gafx+ErwuLkozKaIiXWGZdEY3wooQBVfMIQnSPGZ8bAdOx6bhRS4yMBOK08V0pqcChXPoh5yU/ZOH+zWrTcnbuDayRgqv+GQ3Az1+3iqtYL02ZCiNPV5VzGLWL4/fFr2HmuSDKklqvsuFN8vClg+P7vl3BN0BqBi0rlLrjZPxafSsfDm5spxbU2fbTrMi4Wia9FANhy+jq2nL7u9TF/OnUdv565gR9PFeKNn8/iYpEOgLOnmlkZidy0CUhq35+3nb+6swPS6eyAtOLDbVkBODO//vnTWeTcqML7v19CUXX9tI0Qurr+dntHHFk4Brd2bgqAxvhQQgMa3ByGMC6RmAj75Mp2dHZMulPf3+dy+4925yLnRjU+mz2Yt9zgRomJ1jovJ2Zyru/U5EDANd8rXMTRlOqkf6tG4OoC7AG8SihwpaQGT311EgDQNE6c0cN1b7l1dXkR4/PmlhyX3wvbVgTKcse4urhuNw1H6Vry81ks+fmsKOBeZ7Tg0fXHAABnXh2HGA8rXJfXmPD4F8d4y5higm4rN/ujSSnj6vIwxocQgkqHVYzZhrGwXCzS4U//2Q0A2JZ9A989NtzncXmK0NXVq1UiAKcMqcWHEgpQxScMYSZXJs6GeZAwD68yD6rjSlkv3Fl8orQqrJ05EARAp2axAIAT+RWoqDUhMVo6biIUkItbsNkIG3cByFt8mFW46zIBq9fK9ewyqbirai8sPv5EGOMjdHP6q45PtcH+m7i/XapJqpBak4Xzv9VjxYdRtLgwVgqP6/jUqXKzs0mpFEKLz+WSGpTojNCqlOiaFg/A2dqCy7G8Cp/H5CkWqw2M3rP4ru7okhrPKoPMXGOkig8lBKCKTxjCTORMZpXWYVb/80cHPN6H1IPNE7fVbRnN2P+7pMYh50Y1/jhfjLv6tPT42A0Nrvn+EKfOUY3JwjYRNVlsrNtGCOOCUnJcUf0Wb8Mrk7vzFEKdQazYcC0t0mUKuJWb/VepVRjjE+hYLa4V5WaVeyshdzzeBNS6csW4t/h4H5wuxFWTUkCs+Oy7WAIA6NcmkVWWUiQsg/XBG1vOsf9n9m/Fs/AyY6vPbDwKxVdojE8YomfN6XxXlzdIBXB667/v66h3k1tS4/XxGxJy5nuuIsJNO5eDq0zUmKx4duMp3nbugmZ1xsAEs2qUgFalwPN3dmGXubP4+BNCiNdxM1xlp9aLh60rGbqz+DDuP3fVi13BNimVqeMTH8V/F71Sao/DYqw9gLTFpz5Yu+8q+78wRolRfNy5wykUT6ioqMBzzz2HwYMHY+DAgXjsscdQVFTkt/1TxScMYV1dWkfBMzcTuhRS1h1vA5XjIu2TuPvYlIaNnEWB63oqkYnv4SJVJqZUxj0mfTzX8ve2OztDRhMtTr08Fo/e2oFdJhyrzmjhx2vVwdUltCbWmqwexc1YrDZsPlmIm1UGnhLOdXu5w5UMNW4sPmy6uz9cXTLBzcJ0dsYKyHWN+fIi4y3bs2/icrFO9nuhYsyMb1v2TeTcqJLahELxmHnz5qG2thbbtm3Dzp07oVKpsGjRIr/tP+RcXVarFVarlf2f+5dih9hsiFIrEKlSwGq1IkarQJTay4eizSaSq9Vq4+3HndwTIlSIUitgMFmCfo7qcq0YTGZJ+VXrTez+SqoNsjJm1mHOC0PHZjGorJHfTjQOo1ninFhBiI13HDnkjhOlAZQgvO31BvFvXrb1LKY7jmWTuD48xSy4jqpqjbBYrS7lYLVasX7/Vby5JQep8RF4K7M3u75eQi5y1BpMsseJVDvvE61KLE+t0i5DBfH9t1sdvzNKI32+YrRK3viMFvt5iHLcywDQNFYj+Rv8dY8dvVqOeV/YG+WefnUcu9zVvR+rsY87v7QGd6/cw9sunKHPIDFSMmH+r6mpgcnkfNnTarXQavkWzNOnT+PkyZPYt28fYmPtsaKvvfYaiouL/TZGBfF3t8EAYTKZkJWVFexhUCgNCnN5PqpO/g8A0OS2eQE/Xunv7wIAItK6ITZjdMCPR6FQwofZs2dDr3cmdPztb3/DvHn8eeuLL77Axo0bMXHiRHz55ZfQ6/UYOXIkFixYgMTERL+MI+QsPt26dWM1RKvViqysLPTs2RMqlbTpuDEy8s0dKK8149tHhyAjLQHzNxzHb2el/aNbnhyJ384WYenWc7zlEWolji4ay1t234f7cabAacZ291b37bF8vLwpG7d0bopV9/fz8df4B6vViq92HMGmy1YsmtgdPVomiNY5eLkUy7efxz8mdkd6chT+9vlx3N61GWIjVXh5k7iK8DvT+2B01+bYfaEY/7f+mOh7Bq6cery81effcO+AVshoHoufs25g5Z/7IT5aA92NWFy5YS9P0KNPH5fbyx27b6oWax+5hXcPMeu2SIjEP+/uiVlrD0OlVGBarQW9WyWgS9t2aOnmeHJU1Zox7M0d7OcNjwxBcbUR8748LrvN6VfH4eFPDuHI1XIA9rRvbgG/bU/fgrQEe1fqa+W1eHbjKfxlSBvc2TONt5/PHFYjKaYPTMeGw/kAgAEttPh4Dl8mh6+UYeanh9EuJRqb54308lfbuef9fTh3oxofPNgfIzqmyK434J/bYDDb0Cc9ESfyK/DsuAw8NKwtb53Zaw/jIKcel7+sLF8cvIrXf7bLKOuVO1gX6vB/7UCl3ozv/28oOqXG87b59mg+Xv7BeY+0To7CV3OHIi5Sg//uu4IdOUVYdX8/j7PvQgX6DBIjJROTyYTs7Gzs3LkTGo3TnSu09gBAZWUlzp07hx49euD777+HwWDAc889hwULFmD16tV+GWPIXYUqlUp0gUkta8yU663QWwiiIzRQqVSIi4qA3iJt2GueEI2oCI3oe73FCqVSyYsbKau1sOtN6JXmVuYxEfbjlustDeL8LPrd/tB8ZP0xHHxxjOj7GR8fBgDM/O9RPHpre+y5XIY9l8vwyqRukvLTmWxQqVR4eO1RdtmIjinY48jEYeD+drnz4AmVBite2nQWAPDp/qt4+o4MqFQqKBRK0XGEEEJkj61SKkT30NT+6fj8YB4W390LKXHM9UNwvdKI65VF6D9E4fM5tcDCG0uN2QYLUbiUjUqlgsnmlJ++mh8b9ebWC3j3z30d/5/HoSsVOHSlAlf68Bu7VhutsseJ0DrvA5NVPK9EO+6Tcr3V599erDNDbyFIiI5wuQ9GHsw9p9GoResL71t/3WMqlZrdr9HqrAdW5ZCdVnIsWt5YzhXV4rvj1zFrRDss/smuRH17vBAzh7fzyxgbGvQZJIYrE+ZvTEyMpLLDhfn+pZdeQkREBGJjY/Hkk09i2rRpqKmpQUxMTJ3HRoObwwxCCJtZwQQcDmmfLLnukYVjEKlRyb6FbT51HdUGM3RGC349cwOXi+3ZWWtnDsS70/u6HQszYTa04GZ36dIlOiP2XyplP8vVz5FaPqxjExxZOAYzBreu0xhbJESKlnHlqDdbcf5mNYqq9KL1pHCVldUiVnz+F9/VA4deHI3hHVPQJFacPu1JLSghF4t0KKjQi+rg6AwWt1ldp65VsK1YpOCWEuAGMOuMFhzLK0e1wYzTBZUuayExwfhyRDvKQ3iTRSY3zng3x2IakTLjlUpQkOrr5SmnCypli4sSTokErlyZ8yYVXB0r8XtKa4w4mV/Bfq5LGQBK46Fjx46w2Wwwm53Xns0xP/grMifkLD4U1xgtNjbhhlF8hnZoIrkukxYbJ6P4PPHlcUzq3QIalQLfHStgl7dtEsMrxidHrGO/9Vl4z1/8luN0DV4qlk7HL68Rp0anxEQgJTbCbU0Yd/RslYDCSn4bgmpOnZ9SnQl3LN+FFHMBPvHAi+hK8UmLE7+pqpQKNHO0OkmM0kCp4PcYe+n7LHx7q83jDKPyGhPGLPsDAPD7M7fxvqsxWVxWxAaAySv3uvxey6n2HBvh/D3TP9yP0xz3bLsU+bfFGK1zu5RosUyiHHVrfK1VY7Ha2HtBqjUFF6YwIKPsSck5Ido3xefcjWpMfHcPmsRoRe5sgP/7qgxmtEAUbDbCtquQVHwk5pD3dl7CezsvsZ/Dzc1FCQzDhg1Deno6XnzxRbzxxhswGo1Yvnw5xowZwwY71xVq8QkzuKnXTBn5ZnGR+MfEbmw/HQbGjeVqQsq5XoWdOfz4IE8nsNgwSWeX6lsGAEfzykWVgJlWHXIsmtgNs0fwzf29WjnjjdqlxODuvi2x/L4+6N2KH4fEffs+ea2C/d+TtyBXpQhaxLk+n0qlAskxfKuPAvaq3J5SUOG0TAkLPeqM1jpVQwacigIAxHAK63GVHsB1TanYSA3WzhyIKX1a4L7u4gk22vEiYbLafEpp5yquwtYUQjSODComnV2q4CH3d3pTyeCP8/b7ubTGxOsZx8C1aFXW2s+VifN7tRLWJ+5Y5PCkIjeFotFo8Nlnn0GlUmHcuHEYN24cUlNT8frrr/vtGFTxCTOY+iYqBf9hMGtEO/x31iDc3qWZaJuYCHnf9KViHcpr+Q8qdy4Bdr+OybBEZ8Lmk+Ju5p6w+o9LeHXzGZ9NnB/vycWyX89Jbn+6oBKPfnbUZb0SADhTKF2XZNf5Ygx/YwdvGWNlk5viZ49oh0UTu7Gfh3VowjtPO5+5Dcvv64NorRqvTenB27aQozxwiyf+cb4YpwsqXf4GV+1G0mLdxyYkSVgX9l0qkVjTSWGFHo99fhSbThRg7mfOOKi73uNbb3QGS53dINyq2NFa32ItYiNUuC2jGf59by/ESBQYjOLsd9LKvdiWfdOr/TMKX4xWxTvnUmgEneClrCzcZcJK267gNhq9KdHclKf4ME1keYqP+FiezAm0nQXFU5o3b47ly5djz549OHz4MN58803Ex8e739BDqOITZjBVhqUmJ4DfIZwhLkL+7VPqeeSqQzkXrvnbVcaOHCaLDW/8koNP917BJTfKiRRGixWv/ZiNFTsuYv9lfjd6Qgge+uQQtpy5gVlrD3u9b4ZqgTWrc/M4AMC4HqkAgObxrtsLRKiVeGCIPR5oXPfmvO+iBP2cqjgWgxtVjgcWAc5er8buCyWSfagYuBYXLknRGkTLVBHmkpEaJ1q272KpxJpOFv3vNH7OuoH5G07IHh+wWwTrUg0Z4PfgclcBWw53lkzudX/2ehX+s/28V/tnxujO2gOIrSpS3dw1Mve4O7gKdH6Z+LzoObFUzDXHbREipbR5YgWmDUwpDQXqdA0z2O7PMpOiVHVfVxYfT/chhdxkeLPKgOQYrdu3Xu7DslRnQpMYE5K8KNfPDcD99Qz/7bzKYEGp43umLYCv/HNKDwxulwyFQsF2WB/WIQU/PzES6clRLreN1KhwV++WaNskhteWgPnOHSalU7H6/liBKOWZYd9FaeuMu1gThn/d0wt3922JjcvWssuO55ej1mTh9Wziwm3A6gqd0YImDotCjFaFGh9iaLhKobetVRik4lS4CK97ud5sQqoNZlhtBPscAfOeyFxo4ZGy+HDvH4uN4ExhJbqlxfPGWVxtRFykmr2WCCE813V+WS0GteMnP3AtPheK7G5extWlVkAyvs+TOcTX80Kh+Btq8Qkz3Fl8UiQydAIVdCg1WZ8uqMTg13/D/60/KrEFn/wyp0Jy34cH0Pe1bV4FSnPbQfyUdV3wnTijxdUbdP82SbzP3LicGYNao1PzOHRsxo8L6dYinm1iKkfz+EgolQr0bZ0kUnQ8UXyq1Ck4F90fJ2Jvwcs/nMHZ69JuuQMCixeD0KokR2yEGqO7ci1S9mDXo466OpL79tDlpDNa2JYVw1zUtnEFt6aPN01LubhTfISUe5DZZrMRDFryG/os3oZ//WJP6/bE4iN8KZCysgoVqAkr9uCTvVfYz9fKazFwyXZM/9DZnHj9gau8oPm8MrHSX8uR3+o/LqOwQg+zI1VdLmifa5FqmSit7FOLD6WhQBWfMIOZ9LUyZfn/fkdnDGqXjGXTerPLIjUqPCxjKQCA5Bgt70HvDfcNSGf/t1ht+HhPLgBgu0xBRS5Sk7K7eBwuxRzlpkwQp1RaY0KiIG6F616I1Cgxpmsz/G1UR0zslYaRnfgP5Lm3dMBtGU3x2pQeHmW4CXnrnl4Y1C4Z80d3kl0n0gMXFABcjuqJ6xHtAUA27uSijNwivYyHub1LM6QlRKJDU3t21KUi+fPhaaxNRa2JdU8lRmnwwJDWmDagFe4XlAS4b0C67D79ofh4+wJQY7K6zfCqNlpED3zh75JCqIRLvUSM75mGWwQJC1tOOxX8n07Z/+cGoR8RKKrFEi8Awt/0+7limBwtB2RajPGQs2j5el4oFH9DFZ8w4ujVMvxj0xkAgJzlOSU2Al/PHYqp/fiF3V6Z3F12v0PbN/HI+iDFkrudAbpVBgvPPfDsNyexeHO2bD2R/HKx4uNN/IarBqClOiOSo51us0q9mRcg++rk7ljz0EA8My4DK2f0EwWPJkRpsHbmIDw4pI3H4+EybWA6vp471KXrzhuZPzsuAwA/4LioyoAXvsvCi99nydbdifSy4WVGahym9G2Jto608HwZd9ah3DLWteOOEp2JzZJSqxT455SeeCuzN5bc3ZNdR6VU4M3MXshe/CfM4hTB+9uojgDs548Qu7vntxzPuzinceolSdWicT921zWhqgTusC/mDMZdfVq63a/Q4iMX3Lxu1iDessNXyrHphL30BNdlxSgdjBV1aHt7iQspyyfT9JVRbl/8PgtXHe5gd41cAX6H+ZTYCPx9bGcAwPazN/H21nN1avJKofgDqviEEfe8vx8XHW/gcjE+vnB7l2aY1LsFAHkzthxqlZKtj1KpN/MeBN8cvYZP9uZi8Y/idhAAcP6GOI1c+CBxhdSkzjzoSnQm2DiZXgXlerbwIwD0bc13bQn1LVs9tLhzFwPF5Y5udjdU1jVndteXh/Lx5aE8fHEwD4D0m7ivCm2KQ2HLl7DKAcC01fs93leJzsgGN6ulWtiDr6BxFZTWydFQKuwK8c0qI176/rTHxwWAPumJ7P+epGQLKXXj7hLGAUkVg5RC6NryNKEAAN5wtJvgHptRfPMcwcx9WycCkH45YBSm8Zx2H2v3XQEAeDKMO3s4t4uNULHXWH6ZHit3XsTZ69LlISiU+oIGN4cpSVF1L58eH6nGf6b3waiMZrARoGmsFv0ECoEnJERpUGOyokpvlgwIlUrFNlttOJQrjksRbm+zEVgJYZUEq42gVGdEdIRa8qHUJz0B1ysNuFSs41lBblYb2DTf92b0Y7OzGKwCRUf4OdgwQdU1JntNHI1Kiaul/Jo1rZOjkSWQtafuNCFMvSIpd6QrmsVFoEhg4SsVWHykkFPQhnVsgh4tE3DqWiV+zb6BU5z6Rp4QpVXh2/8bBrVS4VOdmesVep7yxMVqI6K6Qe7qPDEIqzJ7UiiyXUoMcktqUKIzwmYjyOaUYSjVmZAUrWUtVIxiL2WxYhSfoR2aYO/FEhzLq2AVXFcWn93PjcL5m9UY3jEFL/9gtzybrUTkTvU09otCCRTU4hMmCP3ySZF1P7Xtmsbi9i7NoVDYHwp/6pHGVvP1BiaYs1JvlnS5SAV72lsUiGMChBafzA/2YfS//4DRYgUhBFPe24tBr/+Gvot/ZWMcuLRPsQcgf7r3Ci8TaOanzpT20V3FtY6EdYCCVYqtTZNoyeXcIGpGRkKlRCrDzFeLTxOHm/BauR6EECz5KRtdF23BxSIdql2k1Y/rnipapjdb2eJ+clYu7jgrap3XUKukaLYy+fJt5yXLL7iCEHvgem8Z5cUd//f5MSz5SWyxZK5FYRmHpGgPFR/BPSGVzi5kssMqa7ERrNt/BYeuOF8cSmqMrOs4LlKN9g43lqTFx5FAEK1V476B9hg9JiBaTjEFgPTkaIzu2px3rspqTCJ3aoqHyh+FEiio4hMmXBPEw9TV4tMyMQpv3dOrTvtgYFwsWQWVklYYqb5FcjViuMpKrcmCY3kVyCurxfkbOpy/qWMtGmYrEdWOUcCzSVfKrcB1bfVsmYBhHXzLPqoL6clReOHOLuznER1TkJYQiRV/7guVUsG2HmGsYtwYqRitChN6tsATt3fktW2I9CRaVYJkhxx1RntZgI9250JvtuKd3y5I1oZhsNgIL3CXsTgxdYnkrC5cy9RfhrZFy8Qo/MNRCLKvQ2kRFtp0xaKJ3dAqKQpPjens8TYA8Pa9vdEiIZKnKH20O1e0XpXeIrKuAZ5XLxYrPvJT9ZwR7dCxWSxmjWjH3kvCMZXqTChy9KhLjY9kszurjRZe0HGpzsgqOa2SotDEUbGbqePjrYFQb7byLDxqpaJOPcYoFH9AXV1hgjAQuC4Wny6pcdjy5C11HRILM4kv3XrO4232OoJ0e6cn8hodMg91i9WGZb86C8jpjBYs+loc38HtMaVVKTzKNJKqU8SNx9w8b4QnP8Gv/GVoGyy+qwcvXf3xUR15fdjiozSoNtoDyA1mK9uM9diisUh2xORM6JWGp+/IQNvnfwLgu6tLo1Swbqstp2+wy49dLcfKnRdkt7PZCCI1KpitdgU2JTYC18r1uOF42Mq5UrhWhI7NYrH3+dvZz62SpK1grpg9op2odYgnZPZvhcz+rfDezou867KgQo8dOUWYPjAdGpUSJTWug57dIYzHkmoTwbBwYjcsdPyfEhuBKoOFVfq7pcUj+3oV1u7LxZB2Tdh14iPV0KgUMFsJXvnhDLqkxmFA22S8ucUeH9QlNQ4psRFIiePHJPnSg46rXDeJ1fqUBUmh+BNq8QkTLgrSin1RfJgg5OE+1lKRI9mNeV8Yt6M3WXHsagUAYGpffgYM48bZcDgfa/Y432o3Hr3GyoDb46pnS+f/GpX9LdYXurXwX7l0X+jRwv47uJaAfm0SeeskcFyKTPHAGK1Kst0Eg68uHsAeMwQAXx3OZ5cVVOjxc9YNuU3QOz0Rf3K4u1olRbGWh+uV9vGqBQ94ps6QMG2bS3qytOIzWtCeZYyjDpG7zuieIDzm1FV7seh/p/H6z2cBuM4o9ASu4qNRKTxWFrgxRMkxWrYMw+mCKvZ+SYmLgEKhYBMVNhzOxyubszHx3T3YfcH+wjHCMQc0EWQdepLVBTiD7Qe0SeJZfJrEeBbcTaEEEmrxCRP2C1KHk31wdf0y/xZsO3sTMwa5rzPiDX1aJ+KrI/aHo1qpEKWkCxWfo1fLYbLakJYQiQeGtIHFRvDRrsu4UWVg1z1wmf97D+Y6Pz9/Z1f8+SN70bZhHVNw0pHppFUpMKR9Eyyb1hsf7c6VLfYnxcSeaajUm1m3Sn2x5cmROJRbhnv628sPtEyMwvL7eqNZXKQo7oNJI64yWFgLYHpytKQF68d5I3A8vwITe6bi5Envek4xpCdH48jVctal0691Iga0tVcB3nyyENcdVpz5ozshJkKFCLUK9w1Mx+Q+LZCRGoc7e6bh9Z/P4kR+BUocioLQFfTL/JH4LafIZe0buboxi6f0QIvfL+GzA1cBAAsndMXQDk0wRiKGy1taCxQfxrr26d4reHlSd8mMwu1P3+rx/rnKmStrjxBugdKOTWNF2YmAU5n597TemPHRQRgt4vTyxxxlAoTB2J4mly3N7I1BR/MxqXcLnhve0+BuCiWQ1KviU1paikWLFuHQoUNQqVSYPHkyFixYALW6Yepfr/2YjUO5ZVg/ezCO5pVh/oYTaBYXge/+bzgSHG/Ru84X44XvsrA0s5fbqrNWG8Ej644AAD76ywB8sjcXS7eeQ/82SdCqlVArlfjwwf5emYJPF1TioU8OiWJnfLH4tG4S7ZP53x3DOfEw70zvi8e/OMb7vkpvRmGFHpnv70NRtZGNpxnaoQlUSgVmj2iHlFgt5m84gV9O38DxPHG1YMbC8cTtHXl9pQa2TcL7jv+ZFP+p/Vohu7DKK8VHqVT4XLOnLnRJjUeXVL616e6+rSTX5Vp8mABgOWtIj5YJ6NEyAVar70Xl0gXWszem9mJlP6BNEh5xNCa9d0ArnjsqNkKNOSPbO/bBH5+wcF/blBivrslIjZJtjRAXqcbcW9uzik9yrNZv17fwt3N58fsstoQAw6B2yaLK3q7gKnMRXgSgcxWLVslRbL0eLkycW/82yVg5ox/+6piTGJZm9mJdo9FaNaK1KjbTy9P+YAnRGvYcczPHpCrHUyj1Tb26up588klER0dj9+7d2LhxI/bv34+1a9fW5xA8ptZkwcd7cpFVUInvjl/DFwfzUW2w4FJxDXaecxZIe+jTQyio0GPWf903uswurMJvOUX4LafI4Xe/AqPFhn2XSvH7uWJsP3sT5256V+Pi22PXWKWnU7NYtGkSjZ4t4xGtaTh+9HTHBNwqKQq3ZjTF4ru6Q6NS4O177dWjqwwW/HiqEIWVBlhsBDZif/PnFnrr3SqR/f/bY9d4Qc5cWiVHIylag4Ftk9CxWSyGdUjBC3d2gValwN8GOt1ec0a2R1yEGrdlNEVitAYjO6UgLkKNaQOklYpQgHlYVunNbPqxULHwHwSdOCn/KbFadG7ufLBza+3I9fICxJlmcnV83PH02M6I1Cjxzdxh6NgsFl3T4hGrVSMtIQrtm8agS2ocG/ztD1xVMxcqPVqVEgv+1EVyXTkSOO7JFomeZ1K2SXYGrqcnRSMhWoMJnHo8AL+WkFD+SdEajBK4CLnWLV9ifNo2iWHLLUgpYhRKfVNvpparV6/i0KFD2LVrF6KiopCeno7HHnsMS5cuxZw5c+prGCL0Jit+zrou6gHFLcz2y+kbOMupibHhcB7rcmGSfQxmG/7rKPIlB7dc/H+2X5Bs4vjBH5e8qpWz/azdTfGvqT1x74B02AgBsdmQdeqkx/sINAqFAl/8dTD7/1+GtsV9A9NhswHPfHMSVhvBt0ft1WafGtMZ0welI0qr4mV/tE2JwTvT+2D+hhPYcbZItoJzepLdtfPNo8NACIFCocDcWzvgwSGtcfb0KXa91IRIHFk0hudGMFltXrkVGhqMvPZfKmWvT3dNUuvCEM5DrKugOSZXjq4CyoWKmbtKyHI8MboT5t3eEQqFAlvmjwTgbKb565O3QKFQeNxc1xMUCgW+f2w4bISg3+JtqJbpITexVxr+Pa23R+noXLjX/p8kSgDIwQ12ZxSmlTP6onatBTvPFQPgW1248n92XAZmj2gnKnEwtEMT5DiKifoSCx8TocaeBaOgN1mR6GE6P4USSOpN8blw4QISExPRvLmz0WGHDh1QWFiIqqoqxMfzzfkmkwkmk9N9YzbbJ3Kr1cqa54V/feGrw1fxyuazLtcRFtI7cLlMsukjU7TLExiFRcimE4XYdKLQ4/0AgEIB3N6lKUBsUAKwErupvy5yCTRqBUCUhDWjM5au0V1SkBJjn/SF47+lo931xW2yKCQ9KVLyd6sVRLRPtQKw2Wyyn0ONZIfc9nA6sacnRbm8Dry9h4jj2lLHJCM52jl9DGqbxNtHIqdtgVpBZPffMpHv+ohUK+t83TLqDbMfhX3g8HS33shECWD6oHQ2fXxo+2Ts58wN6UlRUCu8vxfjOT1nxnRt5vH2nZs5LT7N4yLY7dpy6j+lxGjY5ZGcnn5dmsdCoxSPdVj7ZHzqaH4aqVb4dH7UCiAuQtWg5yRf8MczKNyQkklDk4+CCCuzBYhNmzZh+fLl+P3339lleXl5GDt2LP744w+kpvLfat59912sXLmS/ZyUlIT33nvP7+MqrrViY7YOtWaxGLQqwGKzp0MrFMCwVpG4VG7GDZ3zJCoU9rcgs81p/XEFExxosdn/v61tFA4WGKB3HF8iztAtvZprMbZ9oFwagWV3nh6HCuxv+e2S1Lg7I8blm/mO3Focv2FXiLUqe8CywUJgsQGdmmgwuXOM7LbhTrnBiq/O6FBjsl9LKdFK3N8zzif3hBzmyuswl1xCVNshUKjUOFdqwpFCI6Z1jxVl/Gw+X4M4rRK3tXVtddpyqRbFNVZYbAT3dotFrDa0rG5mG8HGbB0GtIiAUqHAj+droFUpEKtV4t5uMV73Q2P4/YoeVkIwup139/bxG0ZcqTBjCudeulljwcbsGiRHKTG9eyzvHjtYYEBuhRn3dYuVLuVACL7I0qHCYMXdXWLRKr5hxmRSGj49e/aEVht8q1+9KT7btm3DwoULcfDgQXbZuXPnMHnyZBw5cgRxcfwWAVIWn8uXL6Nbt26s4KxWK7KystCzZ0+oVLQMOgOVixgqE2moXMRQmUhD5SKGykSMlExMJhOys7MbjOJTb6p7p06dUFFRgZKSEqSk2LN8Ll26hNTUVJHSAwBarZYnIEYJUqlUogtMahmFykUKKhNpqFzEUJlIQ+UihspEDFcmDU029WZTbtu2Lfr374/XX38dOp0O+fn5WLVqFTIzM+trCBQKhUKhUBo59epMX7FiBSwWC0aPHo1p06Zh5MiReOyxx+pzCBQKhUKhUBox9RqllpKSghUrVtTnISkUCoVCoVBYQit9gkKhUCgUCqUOUMWHQqFQKBRKo4EqPhQKhUKhUBoNVPGhUCgUCoXSaKCKD4VCoVAolEYDVXwoFAqFQqE0GqjiQ6FQKBQKpdEQMt3mmK7Z3P5dTMdXk8nU4EpiBxMqFzFUJtJQuYihMpGGykUMlYkYKZkwz23mOR5s6q1JaV3R6XQ4d+5csIdBoVAoFArFBzIyMhAbGxvsYYSO4mOxWGAwGKBWq6FUUg8dhUKhUCihgM1mg8ViQWRkJNTq4DuaQkbxoVAoFAqFQqkr1HRCoVAoFAql0UAVHwqFQqFQKI0GqvhQKBQKhUJpNFDFh0KhUCgUSqOBKj4UCoVCoVAaDVTxoVAoFAqF0migig+FQqFQKJRGA1V8KBQKhUKhNBqo4kOhUCgUCqXREPza0TJkZ2dDpVKhZcuWiI2Nhc1mo60qAJw6dQoGgwGpqalo3bo1CCFQKBTBHlZQycrKQm1tLQYPHgyr1UqbBTo4duwYampq0LRpU3Tp0oXeQwDOnDkDpVKJ5s2bIzk5mcrEAZ1vxdC5VppwmG8bXMuKsrIyPP3007h48SJatmwJpVKJ1157DR07dgz20IJKSUkJFixYgAsXLqBjx444fvw4Vq1ahaFDhwZ7aEGluroaDz/8MIxGI3788UcAaPQTVHl5OZ599lmcOXMGnTp1wpUrV/C///0PycnJwR5a0CguLsaCBQuQm5uLtm3boqamBqtXr0ZSUlKwhxZU6Hwrhs618oTLfNvgVPoPPvgAzZs3x549e/DWW2+hVatWmD9/Pi5cuBDsoQUNQgj+9a9/oUWLFti1axc+/PBDjB8/Hm+99VawhxZ0oqKiUFtbi6KiInz00UcA7A3xGjPr1q1DfHw89u/fj3Xr1uHLL79s1EqP2WzGa6+9hpYtW2Lnzp24//77YbFYUF5eHuyhBR063/Khc61rwmW+bTCKDyEEOp0OOTk56NevHwCgTZs2WLp0KQgh2LhxIyoqKoI7yCCRm5uL3NxcjB8/HgCgVqsxduxYWCwWVFdXB3l0wYExVF69ehUqlQpz5szBhg0bcPPmTahUqpC8Gf1BTU0NDh8+jBEjRgAAvvnmGyxbtgyrVq3CiRMngju4IFFQUIDq6mqMGzcOAJCTkwOz2YzLly+joKAgyKMLDjabDbW1tXS+5UAIwdWrV+lc64JwmW+DqvicPn0av/32Gy5evAiFQgGTyYTy8nLExcUBACwWCwDgsccew9atW3Ht2rVgDrfe4MoFsGvZCoUCLVq0YC+w3bt3IzU1lZVVuMPI5NKlS7zlVqsV3bp1w5AhQ5CamorVq1cDAPR6fTCGWe8IrxWj0YgbN24gLS0N//73v7Fu3TpkZGTg2LFjePzxx3Ho0KEgjzjwCGUSERGBK1eu4P3338ctt9yC7777Dn379sWqVavw4IMPorCwMMgjrh+uXr3Knn+lUknnW/BlolAoEBkZ2ejnWoAvF6vVyi632WxhMd8GRfExGAyYP38+Zs6cia+++gr33nsvvvrqKyQnJ2PAgAH45JNPAIANmpo4cSLi4uLw66+/AnC+7YcbcnJJTU3Fu+++izZt2kCpVEKv1+P48eOYMGFCsIcccIQyyczMxMaNG1k3xenTp1FVVYVevXph1qxZ2LZtGzIzM/HJJ5/AZDIFefSBw9U91Lt3b7z55pvQ6/XYvHkzHnnkEaxZswbt27fHxo0bAYTnPSQnk7S0NLzzzjvo0KEDWrVqhR07dmDx4sX47rvvoNFosH79egDhKRMuK1euxIoVK2A2mwEAiYmJ6N69O/773/8CaHzzLSCWSWpqKt58881GOddy4cqFa9E5c+ZMWMy3Qcnq2rlzJwwGAw4cOACVSoUvv/wSX3/9NcxmMx599FGMHTsWmzZtwl133QWz2QyNRoMRI0bg3LlzABBygVSeIiWXb775BjqdDrNnz2bXy87Ohl6vx6hRo9hleXl5aN26dTCGHVDkrpXy8nL89a9/hdFoxLBhwwAAu3btQlVVFQghmDdvXpBHHljk5KLX6/Hggw9izpw5iIuLg8lkgsViQXR0NG677TZ8/fXXAMLzHpKTSW1tLWbOnInKyko2aLeqqgrx8fEYPXo0zpw5AyA8ZcKQm5uLvXv3IioqCl988QUeeughAMC8efMwbtw4/PDDD5g8eXKjmm+lZEIIQYcOHdh1GtNcyyAnF8DuSh8+fDiA0J5vg2Lx2b9/PxQKBfuG8ec//xmDBg3Cjh07UFxcjPnz52Pp0qXIycmBRqMBYD8ZY8aMCcZw6w05uezbt4/novj0008xfPhwJCQkYNOmTejduze+//77kPOzeoKUTAYMGID9+/fj1KlTMBqN+PjjjzFu3Djk5ubipZdeAiEEmzZtCvLIA4vctbJ3716Ul5dj+vTpyM3NRVFREaKjowEAFy5cwF133RXMYQcUKZkMHjwYe/bsQVZWFgoLC7FmzRoAQHx8PAAgPz8fEydODNqYAw3jpti2bRsGDx6M8ePHY+vWrax7r2XLlpgzZw7efvvtRjPfysnk+vXrUCgUIISw6zSmudaVXJh7qqysDJ9++mnIz7cBt/jk5ORg//79aNu2LW699VYolUokJSXBYrGgoqICiYmJAIC7774bS5cuxc6dOzFv3jwcPnwYzz77LHr37o2LFy+ipqYG/fv3D/Rw6w1P5TJlyhS8/fbb2L9/P/r06QPAnm6ZkZGBmTNnIi8vD0uXLsUdd9wRvB/jGwfh2AAADpBJREFUJ7yVyY4dO2A2m5Geno6HH34YY8aMYdcNpzcyb+SybNkyZGVlYe7cudi7dy/+8pe/YNiwYcjNzUVJSQkefvjhoP4Wf+GNTJYuXYrff/8dkydPxrvvvoupU6dizJgx2LdvHwwGAwYOHBjcH+NHhHJhHlj79+/H/PnzQQjBmTNn8Nlnn2HBggUAgCeffBJnz54N2/nWU5msW7cOCxYsgEKhgEKhgF6vR2lpaVjOtYD3ciGEwGKxIDU1FbNnz8bo0aNDd74lAcJqtZIlS5aQvn37kgULFpBBgwaRF154gVy8eJHs3LmTTJo0iezbt4+3zb///W8ye/ZsQgghRUVFZM+ePeTdd98l69evD9Qw6x1f5TJ37lxCCCFnz54lGRkZZNCgQeS9994Lxk/wO77I5K233iJPP/00KSgo4C232Wz1OfSA4otc3n77bTJnzhxCCCH5+flky5YtZOXKleSLL74Ixk/wO77KhLl/jh8/TpYtW0aeeuop8vHHHwfjJwQEKbksXLiQHDx4kBBCSHV1NSGEEJPJRFavXk0yMzPJ0aNH2e1LS0vDbr6tq0zOnz8fdnMtIb7J5fDhw4QQQgoLC3n7CtX5NmCKz9WrV8mDDz5Irl69SgixTzjPP/88mTlzJiGEkAceeIAsXLiQJ8gdO3aQAQMGsIIPR3yRy86dO1m5VFRUkDVr1hCdTheU8QcCf1wrFoul/gceYOg9JMZfMrFarfU78AAjJZcXXniBPPDAA+zDyWw2E0IIycnJIfPmzSPPPPMMu324yYOQusuktLSUfPzxx2E11xJSd7kQEvrzrV9jfHJycpCfnw+r1YoLFy7gwoULaN26NaxWK/r06YPJkyejuLgY33zzDV544QWcOHECP/zwA2prawHYI8YnTJiA2NhYfw4r6NRVLqdPn8b48eMRGxuLhIQEzJ49GzExMUH+VXXD39dKKJZNl4LeQ2ICIZNwaMfgTi6TJk1CTU0NPvjgAwDOIOWMjAzceuutyM7OxnfffQcgPOQB+Ecm3377LQAgOTkZs2bNCvm5FvDvtQKE/nzrlxif/Px8vPjiiygqKkJCQgKioqIwZ84ctGrVCseOHWMLZPXq1Qvjx4/Hl19+iQ0bNuChhx7CZ599hj/++AMKhQLXrl0LqwqZVC5iqEykoXIRQ2UijTdyueOOO7Bt2zZMmzYNTZo0YXsrDRkyBHl5eWjXrl2Qf41/8KdM2rdvH+Rf4z/otSJNnXt1lZWV4bHHHkO/fv3w3HPPYf/+/Vi1ahUAeyXQ6OhovPjii+z6R44cwYoVK/DMM8+gV69eKCgowNmzZ1FRUYHMzMy6/ZoGBJWLGCoTaahcxFCZSOOLXN577z08/vjjGDBgQLCGHVCoTKShcpGnzhafw4cPw2Kx4MknnwQADB06FL/88gtiY2MRFxeHgwcPYvv27WxqZHp6Ols3A7CnU7Zs2bKuw2hwULmIoTKRhspFDJWJNL7I5dSpU9BqtUEcdWChMpGGykWeOjt24+LiUFtbC61Wy5Y8P3XqFJKTkzFlyhS0aNECa9asYVsNZGVloWfPnkhLS6vroRs0VC5iqEykoXIRQ2UiDZWLGCoTaahcXFDX6GiDwUDOnDnDfs7LyyO33347uXjxIiGEkIsXL5K5c+eSMWPGkOnTp5MhQ4aQzZs31/WwDR4qFzFUJtJQuYihMpGGykUMlYk0VC7y+D2d/aOPPiIPPPAAb5nNZiN5eXnk119/9ffhQgYqFzFUJtJQuYihMpGGykUMlYk0VC5O/Kb4WCwWUl1dTcaOHUv+97//EUII+frrr0lGRgb54Ycf/HWYkIPKRQyViTRULmKoTKShchFDZSINlYsYv7WsUKlUKCgoQHJyMjQaDaZPn46Kigp88MEHuO222/x1mJCDykUMlYk0VC5iqEykoXIRQ2UiDZWLGL/26jp79ixOnDiBa9eu4aGHHsJf//pXf+4+ZKFyEUNlIg2VixgqE2moXMRQmUhD5cKnznV8uOzevRunTp3CX//610aREucpVC5iqEykoXIRQ2UiDZWLGCoTaahc+PhV8SGEsKWuKU6oXMRQmUhD5SKGykQaKhcxVCbSULnw8aviQ6FQKBQKhdKQCY/OdBQKhUKhUCgeQBUfCoVCoVAojQaq+FAoFAqFQmk0UMWHQqFQKBRKo4EqPhQKhUKhUBoNVPGhUCgUCoXSaKCKD4VCCQpGoxE3btyo0z6uXr3qp9G458qVK/V2LAqFEjio4kOhUFzy/PPP4/nnn/f7fmfMmIF9+/b5vP2bb76J999/3+ftvfldn3/+ORYtWuTzsSgUSsOBKj4UCiUolJeXB3V7bygrK6u3Y1EolMBCFR8KJYSZOnUq1q5dy35+8MEHce+997Kf169fj/vvvx95eXl49NFHMXjwYIwaNQrLly+HyWRi19u3bx8yMzMxYMAATJgwAT/88IPk8QoKCjB69Gi8/vrr8KTo+xdffIExY8ZgwIABmDRpEr755hsAwKxZs1BYWIiXX34ZixcvBgBs3LgRU6dOxeDBg9G3b1/MnTuXVTjeffddzJo1C/fccw8GDRqElStXYvPmzdi8eTMmT57skax+++03TJgwAX369MHcuXN5ipPJZMKbb76JO++8E3379sXQoUPx2muvgRCC77//HqtXr8aRI0cwYMAAAIBOp8PixYtx6623YujQoXjqqadQUlLi0TgoFEqQIRQKJWRZtWoVmTVrFiGEEJ1OR/r06UO6d+9OKisrCSGEzJw5k6xatYqMGjWKvP3228RgMJDCwkKSmZlJ3n77bUIIIWfPniW9evUiW7duJRaLhRw9epQMHjyY7Nq1ixBCyIIFC8iCBQtIXl4eGTVqFHnnnXc8GlteXh7p0aMHuXTpEiGEkF27dpGePXuSmzdvEkIIGTVqFPn2228JIYScPHmS9O7dm5w8eZIQQsj169fJHXfcQZYvX04IIWTFihWkS5cuZN++fUSn0xGz2cyOyxMuXbpEunfvTjZt2kTMZjPZtm0b6dq1K7v9hx9+SCZMmMCO7dixY6Rbt25k37597PEfeOABdn/z5s0js2bNIiUlJUSn05GFCxeS++67j9hsNo/GQ6FQgge1+FAoIcyYMWNw6NAh6PV6HDhwAL169UKHDh1w4MAB6HQ6HDp0CGlpaTCZTHj66acRERGBtLQ0zJ8/H59//jkAYMOGDRg9ejTuuOMOqFQq9OvXD9OmTWO/B+yWngcffBC33HILnnjiCY/GplKpQAjBhg0bcPToUQwdOhQnTpxAs2bNROt27twZP/74I3r16oXKykoUFRUhOTkZN2/eZNdJT0/H0KFDERMTA7Va7ZWcfv75Z/To0QOTJ0+GWq3GmDFjMGrUKPb7adOmYe3atWjatCmKiopgMBgQExPDOz5DaWkptm7dipdeeglNmjRBTEwMXnzxRWRlZeHMmTNejYtCodQ/3s0eFAqlQdGpUye0aNECBw8exO7duzF8+HCUlJRg3759sFgsyMjIQHFxMcrKyjBw4EB2O0IIzGYzSktLUVBQgAMHDrBuHACwWq1o3bo1+/nIkSMYPnw4fvvtNzz11FNISEhwO7YWLVrgs88+w5o1a/Doo4/CarVi6tSpePbZZxEREcFbV6lUYt26ddi8eTOio6ORkZEBnU7Hc6dJKUyecvPmTbRo0YK3rHXr1qy7S6/XY/HixTh8+DBSU1PRrVs3EEJgs9lE+yooKABgV5a4qFQqXLt2DT169PB5nBQKJfBQxYdCCXFGjx6NXbt2Yf/+/Vi2bBlKS0uxZMkS6HQ63HHHHUhNTUXr1q2xZcsWdhudTofS0lIkJycjNTUVd999NxtrAwBFRUU8pWP8+PF466238Oc//xmvvvoqli1b5nZcpaWlsFqteO+992Cz2XDs2DE88cQTaNeuHe6//37eumvXrsXevXuxefNmpKSkAAAeffRR3joKhcIn+QBAamoqfv/9d96yGzdusArYwoULkZCQgD179iAiIgI2m42nKHJp3rw5AOCXX35B06ZN2eUXL15Eenq6z2OkUCj1A3V1USghztixY/Hzzz+jqqoK3bp1w6BBg1BYWIjt27dj7NixGDVqFGpqarBmzRqYTCZUVVVhwYIFeOqpp6BQKJCZmYkff/wRe/bsgc1mw5UrV/DAAw/gk08+YY+h0WigUqnwxhtvYPv27fj555/djquwsBCzZs3C/v37oVQqWYUhKSkJAKDValFdXQ3Aroip1WpoNBpYLBZs2rQJu3fvhtlslt0/d3t3TJ48GefPn8fXX38Ni8WCPXv2YNu2bez3Op0OERERUCqV0Ol0eOutt6DT6djjR0REsBao5s2b47bbbsOSJUtQXl4Os9mM999/H5mZmaiqqvJoPBQKJXhQxYdCCXH69OkDtVqNYcOGQaFQIDIyEgMGDEDLli3Rvn17xMbGYu3atTh48CBuueUWjBkzBkqlkq2B07t3byxbtgzLli3DwIED8cADD+D222/H3//+d9GxOnTogHnz5uHVV1+VjH/h0rNnT/zjH//AK6+8gr59++L+++/HjBkzcOeddwIAMjMzsXz5cjzzzDOYNWsW0tLSMGrUKIwcORI//PADZsyYgfPnz8vuf/z48Th27Bhuu+02tzJKT0/HBx98gM8//xz9+/fHqlWrMHbsWPb7hQsXIicnB4MGDcKf/vQn6HQ6jBw5kj3+qFGjUFFRgf79+6OqqgpvvfUW4uPjMWXKFAwZMgR//PEH1qxZw7MAUSiUhomCEA9yUikUCoVCoVDCAGrxoVAoFAqF0migwc0UCsUnpk6ditzcXNnvP/roI16mWKAoLS3FmDFjXK5z/PjxgI+DQqGEBtTVRaFQKBQKpdFAXV0UCoVCoVAaDVTxoVAoFAqF0migig+FQqFQKJRGA1V8KBQKhUKhNBqo4kOhUCgUCqXRQBUfCoVCoVAojQaq+FAoFAqFQmk0UMWHQqFQKBRKo+H/ARQCreJ9dqo3AAAAAElFTkSuQmCC"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAGPCAYAAABS5aSOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeXxU5b3/P+ecmUkmCZAEwo5sSdgR1CIUa6ve1PYqYkGr1utVWtTrVfq7WqvV2ostRexuqVot1otWWy0oVdTiVmpdAEEJhISEhEBCyL4nk9nO8vtj5pw568yZmTNb8rxfL15kzvI83/OcZ/me7/N9vg8lCIIAAoFAIBAIhBEOnWoBCAQCgUAgENIBohQRCAQCgUAggChFBAKBQCAQCACIUkQgEAgEAoEAgChFBAKBQCAQCACIUkQgEAgEAoEAgChFBAKBQCAQCAAAW6oFMAvLsvB4PLDZbKBpossRCAQCgZAJ8DwPlmWRnZ0Nmy291Y70lk6Gx+NBTU1NqsUgEAgEAoEQA3PmzEFeXl6qxQhLzEpRd3c3rrvuOvz0pz/FhRdeCAB4++238eSTT+LMmTPIz8/HmjVr8N///d+SZWfXrl148skn0dHRgVmzZuFHP/oRli5dak7QoHY5Z84cOBwOAADHcaiqqsL8+fPBMEysjzLsIOWihZSJPqRctJAy0YeUixZSJlr0ysTn86GmpibtrURAjErRZ599hh/84AdobGyUjh07dgz33XcfHnvsMXz5y1/GqVOncOuttyInJwff/va3ceDAAWzatAnbtm3D4sWL8eKLL+KOO+7A3r174XQ6I+YpKlYOh0OhFInHSIUMQcpFCykTfUi5aCFlog8pFy2kTLSEK5NMcH2JWsJdu3bh3nvvxd133604fvbsWVx//fW45JJLQNM0Zs+ejbKyMhw8eBAAsGPHDlxxxRU4//zzYbfbccstt6CgoABvvfWWNU9CIBAIBAKBEAdRW4ouuugirFq1CjabTaEYXX755bj88sul3x6PB//85z+xatUqAEBdXR3Wrl2rSKu4uBjV1dW6+fh8Pvh8Pum33+8HENBCRU1U/T8hACkXLaRM9CHlooWUiT6kXLSQMtGiVyaZVD5RK0VFRUURrxkcHMT/+3//D9nZ2bjlllsAAC6XSzNNlp2djaGhId00nn76aTz++OPS74KCAjzxxBOoqqrSXFtRURHFE4wcSLloIWWiDykXLaRM9CHlooWUiZZMLRPLvZ7q6+vx3e9+F2PHjsXzzz8veZo7nU54PB7FtR6PBwUFBbrp3H777Vi3bp302+/3o76+HvPnz1f4FFVUVGDRokVkPlcGKRctpEz0ibZcOI6TrLbDFY7jUFtbi5KSElJXZFhZLhzHgWVZiyRLHTzPo6GhAdOnT88If5lEQFEUsrOzw47LPp9P16CRjliqFH3wwQe455578M1vfhPf+973FJ7mJSUlqK2tVVxfV1eHiy++WDctuUM1AGkqjWEYTYPUO0Yg5aIHKRN9IpWLIAhobW1Fb29v8oRKEYIgwGazoampCRRFpVqctMGqcuE4DjzPWyhZarHZbGhubk61GClFEAQ4nU4UFxdL/Yi8T8mkPtcypai8vBx33nknHn74YVxzzTWa89dccw3uvPNOfP3rX8f555+PF198EV1dXSgrK7NKBAKBkCBEhWj8+PHIyckZ1sqCIAhwu91wOp3D+jmjxYpy8fl84Hl+WAXh5Xl+2DxLLAiCAJfLhba2NtTV1WH27NmpFikuLFOKnnrqKbAsi82bN2Pz5s3S8fPPPx/PPPMMVqxYgY0bN+Lhhx9GW1sbiouLsW3bNuTn51slAoFASAAcx0kK0dixY1MtTsIRBAE8zyM7O5soRTLiLRdBECAIAux2e0bEqzGDWCY0TY/oupKbmwsAaGlpUSyQykTiqpnyCNNPPfVUxOtXr16N1atXx5MlgUBIMqIPUU5OToolIWQygiAAyIxYNYToyc3NBUVRGt/hTIPUTgKBYIqR/CVMIBDCI/YPovKbqRCliEAgEAgEAgFEKSKkEM7vzfivimgY8PhH1PMSCOmK1+tFa2urqWt5njcdhsLr9cYjFiENIEoRISV4ettQ+deNaPjXn1ItSlKobRvAooffwW1/+izVohBSwO9+9zvcdNNNcaXx1FNPYf369RZJlByuuOIKvP7666kWQ8O3vvUtfPLJJ6au3bRpk6l353a7UVdXZ1qGmpoa9PT0mL4+2fT09OAHP/gBVq5ciS984Qu4+eabcfz48VSLlXCGxxIAQsbRdSLQIfU3ZUZAr3h5bt9pAMC7VW2pFcRCBEGAwCUvkCPF2Ee0X9N//dd/pVqEqHnzzTfDnhcEAXySjac0haiUEbMxlTiOG1aW4B/+8IfgOA5vvPEGcnNz8fvf/x7r16/Hu+++O6wXXRCliEBIAsnu+BONIAiof/cpuDoakpZnbtF0zCr7L9OKUVNTEy677DKsW7cOr7zyCq688kpccMEFeOqpp9Dc3Izp06fjnnvuwUUXXQQAaGtrw5YtW3D06FF0dXVh3LhxuOOOO6S4a3PmzMFDDz2EF154Ae3t7ZgzZw5+/OMfY86cOQCAnTt34s9//jPOnj0Ln8+HZcuWYcuWLSgsLFTI9fWvfx2rV69WKDmrVq3CzTffjK997Wv40Y9+hE8++QQ2mw1z587Fgw8+iNmzZ+N3v/sdPv30U/zpT3/C4OCg4XWRuOmmm7BgwQJ8+umnqK+vx6xZs/Dggw/iggsu0C2zjRs34s0335TK7ZxzzsH3vvc9qdyGhobwy1/+En//+9/h9/uxdOlSPPzww5gyZQouvfRS3HXXXVizZg3+8z//E3PnzsVnn32GU6dOYebMmbjlznswc+6iiDILgoDXXvoT/vX+HnS1t4GiKCy98Iv4r+89iKysbDz+s58g2+lER2sLKo98jvzCsbj9ngfw6Uf/xIfv7YHNbscN374Dl/37VXjkB99Fc3MzNm7ciGPHjuF///d/DfM9ffo0eJ6Hz+dDc3MzKIrCrbfeiqKiItx7770oKCjASy+9hJ07d4JlWVx44YVobGzEDTfcgGuvvRatra1wuVzw+/1gGAaFhYUYP368VN+uuuoqPPTQQ3jqqafg8Xhw6aWXYuPGjdJOEPJynzhxIm688UYsXboUY8aMwX333YepU6di37594DgOW7duRVZWFpxOJ6ZMmYKsrCxwHIfm5mYMDg7iH//4B95//32cf/75eO2110DTNL797W/D6/Xi5Zdfhsvlwte+9jVs2bJFCjWwZs0atLS0wGaz4YorrsCTTz6J06dPY/78+RHfWaZCps8IhCQwjD4gMw6Xy4WPP/4Y5513HjZu3Ij//d//xaeffooNGzZgw4YNUqT9hx56CHa7HW+88QY+/PBD3Hjjjdi0aRNcLpeU1ptvvokXXngB//rXv+B0OvHzn/8cAHD06FH89Kc/xcMPP4wDBw7g73//O06fPo3nn39eI8+aNWvw2muvSb+PHTuGpqYmfP3rX8ezzz6LwcFBfPDBB9i7dy+Kiorwy1/+UpOG2euMePnll3Hffffh008/RVlZGe644w6F9UQss7vvvhsffPABNm7ciB/96EfYu3evptx+8pOfoKKiAq+++io++eQTjBs3Dvfcc49uvq+88oqU71e/+lX85P67MdDXF1HefR+8jzdffQnff/hRPPf6+9j8u2dQ/uk+fPT+O9I1e/fsxtU3/Cee3/0PFM+dj5/e911MnnoO/vjqHqz51i3449ZfwO/3Y/Ovn8SkSZPw4x//OKxCBAAzZswATdNwOBxgGAbr1q1DaWkp/vCHP6C4uBjbt2/Ha6+9hueeew579uxBbm4uqqur4XA40NbWBp/Ph9mzZ2P+/PmYNGkS2tvbNX5H77zzDnbv3o09e/agoaEBP/7xjwFAUe4vvPAC1q1bh1/84hegKApDQ0Pw+/345JNPsGnTJrz88ss477zzJAW9vb0dANDZ2QmO4zBnzhxMnDgRlZWVcDqd2L9/P26//Xb85je/wcmTJ/HOO+/g97//Pf72t7/h448/BkVRuPvuu7Fs2TLMnz8fM2bMwJ49e+B0OjFz5syI7yuTIZYiQkoYTmZmcwyv56UoCrPK/isjps+uvvpqOBwOvP7667jhhhvwhS98AQBwySWX4NJLL8VLL72EH/3oR/jpT3+K3Nxc2O12NDU1ITc3Fx6PB319fVJwuptuuknaFPvrX/86nn76aQBAaWkp3njjDUydOhV9fX1ob29HYWEh2tq006VXX301HnvsMWl/qL/97W/42te+htzcXGRnZ6O6uhp/+9vfsHLlSjzyyCO6cX3MXmfE2rVrsXz5cgCBabm//OUv2Lt3L5YtW6YoM4fDgRdeeEEqt6GhIUW53X///XjzzTfx+9//HpMmTQIAPPDAA2ho0Lcgrl69GhdeeCFompbybak+hOXfWBNW3hmrL8eqS1di4sSJ6O7uhsfOYtzYQti8/VgweQwKcuxYsXw5rrn8ywCAr11yMY4e3Id777wVAFCw+uv4vyd+jfF2H6YWjYu6Hg0MDGDdunUYN24cfvWrX0n3/+Mf/8Dq1atRXFwMl8uFG264AR999BEASBYhmqbh9/ul98OyLLKysqS0H3jgAcma+N3vfhd33HEHNm/eLJX7ggULcOrUKaxZswb79u3Djh07cP/998Nms+FLX/oSLrzwQskq5Pf7YbPZpH3laJqGx+NBb28vOI5DTk4O7r77blAUhTlz5oDnedx2223IycnB8uXLMXbsWJw4cQIrV64ERVHo6+sDwzA4cOAAnnnmGTz88MOajd2HG0QpIhCSwHDUASmKAmVzRL4wxYiD09mzZ/Hpp5/iL3/5i3SO4zhJOThz5gx+/vOf4/Tp05g2bRpmzZoFQOlTMm7cOOlvm82mCEj4/PPPY/fu3cjJycGcOXMwODioq/wXFRXhS1/6El577TXMnTsXb7zxBn73u98BAG699VY4HA7s3LkTP/nJTzBt2jR873vfw1e/+lVFGmavM2LGjBnS3xRFYeLEiejo6NCUmbrcBEEARVFSufX19cHn82Hy5MnS9aNHj8aiRfpTYtOnT9fk29XZCYYOr6RQALb+9jHs3bsXhYWFmDdvXnBFmACGpkBRFAoKCqR0bDYGo0ePDv1m6GA6QkyKdV1dHS688EIcOXIEZ86cwTnnnAMgMAVWVFQkKSEMw0hlwbIsWlpa4Ha74XA4JGVCXSfkZTJp0iT4fD709vZK5f7nP/8ZgiCApmmp3B0OB2iaxvjx49HX14fu7m4AAWVZXV8pikJPTw9aW1uRm5uL/v5+jBkzRrpOtCqJiM8yc+ZMtLW14bHHHsMrr7yCe+65B1dccUXUZZdpEKWIQEgCw1EpyhTEQXDixIm4+uqrcdttt0nnmpubkZ2dDb/fj9tvvx333HMPbrjhBrjdbtTX15teObV9+3Z8/PHH2L17t6Q4hXOMXrt2LX784x9j5cqVGDVqlGS9qqmpwaWXXopbbrkFAwMD+POf/4y7774b+/fvV9wf7rpRo0ZFlFduweJ5Hs3NzZKlB1AG6hTL7dZbb8XQ0BBycnLQ0tKC7Oxs5Ofnw+FwoKWlRVIiu7q6sG3bNvzP//yPJl/5AKyXrxG//OUv0dzcjH/84x+Sv82qVasU1yTSCX/RokX41a9+hfvvvx/3338/XnzxRdA0jYkTJ6Kzs1Pa8FQQBLS0tAAAGhsbMXr0aMyYMQMURYFlWV0H77a2Nqnsmpqa4HQ6UVBQIJX7jTfeiFOnTmH+/PlobW1Fdna25Kfk8/nQ1dWFWbNmSdan5uZmKaq0x+PBqFGjMG7cOEyePBkMw+DMmTPIy8uTtlopLi7G1KlTAQB2ux35+fngeR69vb346U9/itraWjz33HMYPXo0WlpaJIVwuEJ8igipYYRpCfwIe9505Jvf/Caef/55HD16FABQUVGBNWvW4I033oDf74fH45H29WppaZF8dMzEqBkcHITNZoPdbgfLsnjttdfw4YcfGt77la98RXKOXbMmNHW0Y8cO3Hfffejq6kJeXh7y8vKQk5MDh0NpkTN7nRE7duzAsWPH4PP58MQTT0AQBFxyySVhy62iokJTbjRN4+qrr8bvfvc7tLW1wev14rHHHkN5eTmys7M1ae3atQuVlZWm8pUzODiIrKwsMAwDr9eLZ599FidOnDAdP0iNw+HAwMCAqWspioLNZsOYMWOwfv161NfXY9u2bfB6vfi3f/s37N69G6dPnwbHcdixY4ek+PE8LylqotUI0FqKfvWrX2FwcBBtbW3YunUrVq9eDbvdLpV7XV0dsrKy8MEHH0j+aC0tLdJechRFgaZpCIKAgYEB9Pb2Snn09PSgqakJLMtKsoj7tI0ZMwYAJAVK9FMaGhoCANx9991oamrCzp07sWjRIlAUlbTd7vft24drr70W5513HlauXIlNmzZJcm7cuBELFy7E0qVLpX8vv/yydO+uXbtQVlaGJUuWYM2aNTh8+HBUeRNLEYGQBIhKlHq+9rWvYWhoCA8++CCam5uRn5+PW265BTfddBMoisIjjzyC3/72t/jpT3+KwsJCfPOb30RdXR1OnDgR0bn029/+Nk6cOIFLLrkEWVlZmD9/Pr71rW9pLDwidrsdV111FZ5//nn8/ve/l47fc889+MlPfoIrrrgCXq8Xs2bNwpNPPqnwQYnmOiOWLVuGn/zkJ6irq8P8+fPx7LPPYtSoUejTcXpWl9uYMWOkcgOAH/zgB/jNb36Da6+9Fh6PB8uWLcNvf/tb3XzPP/98/OQnP8HJkycV+Ubif/7nf/DAAw/gi1/8InJycnD++edj9erVOHHihKnnVXPNNdfgN7/5DSoqKiI6qGdnZ8Pn86GtrQ3nnnsu7rjjDvziF7/A9OnTceONN4Lnedxwww1gGAYrV67E2LFjwXEcpkyZgpaWFnR1dYFhGIwZMwbZ2dnwer2KZz7nnHNw5ZVXwu12Y9WqVfj+978PIFTuP/zhD9Hc3Iy8vDz8+7//O5YvXy75vmVnZyMvLw+1tbWgKApZWVkYO3Ysuru7wfM8JkyYgJaWFtTW1qKlpQU8z2P69OmgaVqSobW1FT6fDwzDgGEY5OXl4fjx4zh48CDsdju+8pWvSLJSFIVnnnkGF1xwQUzlbobu7m7cfvvtePjhh3H11Vejs7MT3/nOd/CHP/wB3/3ud1FRUYFNmzbhG9/4hubeAwcOYNOmTdi2bRsWL16MF198EXfccQf27t1r3hdKyBC8Xq9w6NAhwev1SsdYlhUOHToksCybQsnSj0wolzP7dgpHXrhfOPLC/UnJL9Vlcs/L5cL0+98Qpt//RkryN8JMubjdbqGqqkpwu91JlCx18DwvDA4OCjzPJzSf5557TvjOd76T0Dz0+I//+A9h69atUd8Xb7nceOONwq9+9SuB47iY7k9HDh8+LLS2tkplwvO8sGzZMuGjjz6KeO+ZM2eE0tJS4cyZM4kWMym4XC7hyJEjQldXl6ZP0Ru/wzEwMCAIQqA8a2pqhLKyMuFPf/qT4PV6hQULFggnTpzQve973/ue8NBDDymOfe1rXxN27txp+jkyzlLEcRw4jpP+lv9PCJAJ5cLzPAQh4OiXDDlTXSYMxcNpo1Iqgx5mykUMSif+G+6Iz5ioZ+3o6EBLSwuee+45PPjgg0kv01jfpVXlMpzq0RtvvIGTJ0/it7/9LZxOpxSC4dxzz434jPLyHA7lIT6D6MAt71PEv10uF3w+n3RcXOGoRvQb+/KXv4y2tjZccMEFWLNmDaqrq8GyLLZu3YrPPvsMo0aNwtq1a7F+/XrQNI26ujqsXbtWkVZxcTGqq6tNP0fGKUVVVdoIyOJcN0FJOpfL4Kl6eNsCc+9seXnS8k1VmVw3C7hu1gQAQHkSn9cskcrFZrPB7Xabju47HHC73QlJ95133sEvfvELaSpE9OGwgl/84hf429/+Znj+29/+trSXV6z5xlougQ8hQfINEamsrFQ4v6uZNGkSdu7cGVOekXj//ffDxipaunQpHn/8ccPzt956K372s5+hrKwMfr8fc+fOxeOPPw6KorB8+fKwe6Ft3boVQMCnJ946kMoyFPF6A3tZiuEY9PqUSy65RFF/7rrrLmzYsMEwzXfeeQd9fX2499578d3vfhfr1q3DsmXLcNNNN+HXv/41jh8/jjvvvBM0TWP9+vVwuVyaabLs7OyoypcSMkRF9fl8qKiowPz58yXNkuM4KdZHshzAMoFMKJezB15BT/0hAMDCG7YkPL9Ul8kPXjmCN44GNqA89uPLk56/EWbKxePxoKGhATNnztR1nh1uCIIAt9sNp9M5orcVURNvuYiRocXl5MMFnueH1fPEytDQEE6ePInJkyejoaFB0af4fD5UVVVh1qxZsNvt0j1GliI1R48exbXXXotPP/1UchAXeeaZZ/DWW2/h1VdfxVVXXYVvfvOb+I//+A/p/IYNGzBp0iQ8+OCDpp4j4yxFojNYpGOE9C6XwAqIQEeSTBlTVSY+noKbFSQZ0o1w5cIwTCAmUfDfSGGkPa9ZYi0X8Z7hVK5ym8JweaZYka9uA5R9ivh/bm5uRCXo888/x4MPPojXX39dutbn88Fut+Pjjz9Gf38/rr/+eul6n88nfayVlJRIkdZF6urqcPHFF5t+DqLeEghJIDPsseHJEKMygUBIAWL/EK9yOGfOHHg8HvzqV7+Cz+fD2bNn8bOf/QzXXHMN7HY7tmzZgn379kEQBBw+fBjPP/88rrvuOgCBVYW7d+/G/v374ff7sX37dnR1daGsrMx0/hlnKSIMD0baAJvJTyuau4eGhoZ9iH9C4hAHSzLdNDxxuVwQBCHuKfbc3Fw888wzeOSRR6TgpqtWrcKdd94Jh8OBBx54AA8//DDa2towbtw4bNiwAatXrwYArFixAhs3bpTOFxcXY9u2bcjPzzedP1GKCIQkkMnBGxmGQX5+vhSULicnZ1hPFQiCAK/XKwW5IwSwolz8fj+8Xi9sNtuwUYxGupInCAJcLhfa2trgdDpNBxANR3FxMZ599lndc9dff71i+kzN6tWrJSUpFohSRCAkg8zViQAEtnoAtPskDUcEQYDf74fdHtsGtMMVq8qF47hhtYpREGLbT204IQgCnE4niouLM34WgChFhNSQ4Q0nWoQM14ooisKkSZMwfvz4mLdWyBQ4jkN1dTWKi4vT0ik+VVhZLhzHSRuPZjIcx+HUqVOYOXPmiK4rcgtROsVhiwWiFBEISWC46IDpvKLRKsROPTs7e9g/azSQctEilsmYMWNImQwTRu5EKIGQRIaLUkQgEAjDGaIUEQhJIJMdrQkEAmGkQJQiQooYWUrCyHpaAoFAyEyIUkQgJAFiKCIQCIT0hyhFBEJSIFoRgUAgpDtEKSIQkgCxFBEIBEL6Q5QiAiEJEEdrAoFASH+IUkRICZke9TRaRtbTEggEQmZClCJCahhpStHIelwCgUDISIhSRCAkAaITEQgEQvpDlCICIQmMtOlCAoFAyESIUkQgJAHiaE0gEAjpD1GKCCliZCkJRCciEAiE9IcoRQRCEiBKEYFAIKQ/RCkiEJKAMMIsYwQCgZCJEKWIQEgCPNGJCAQCIe0hShEhJYy41Vgj7HEJBAIhEyFKEYGQBMj0GYFAIKQ/MStF3d3dKCsrw4EDB6RjR44cwbXXXoulS5fi0ksvxY4dOxT37Nq1C2VlZViyZAnWrFmDw4cPxy45gZBBjDTDGIFAIGQiMSlFn332Ga677jo0NjZKx/r6+nDbbbfh6quvxsGDB7F582Zs2bIFR48eBQAcOHAAmzZtwqOPPoqDBw/iqquuwh133AG3223NkxAyixGmJYyspyUQCITMJGqlaNeuXbj33ntx9913K46/8847yM/Px4033gibzYYVK1Zg1apVePHFFwEAO3bswBVXXIHzzz8fdrsdt9xyCwoKCvDWW29Z8yQEQhpDgjcSCARC+mOL9oaLLroIq1atgs1mUyhGtbW1KC0tVVxbXFyMnTt3AgDq6uqwdu1azfnq6mrdfHw+H3w+n/Tb7/cDADiOA8dx0t/y/wkBMqFceJ6HIPAAkiNnqstE7lieTu8l1eWSjpAy0YeUixZSJlr0yiSTyidqpaioqEj3uMvlgtPpVBzLzs7G0NCQqfNqnn76aTz++OPS74KCAjzxxBOoqqrSXFtRURHVM4wU0rlcBhob4OtoBwCw5eVJyzdVZeJyhep5eRKf1yzpXFdSBSkTfUi5aCFloiVTyyRqpcgIp9OJgYEBxTGPx4Pc3FzpvMfj0ZwvKCjQTe/222/HunXrpN9+vx/19fWYP38+HA4HgID2WVFRgUWLFoFhGKseJePJhHJpHDiGfjpQXxYuWZLw/FJdJs5P9gHoAwAsScLzmiXV5ZKOkDLRh5SLFlImWvTKxOfz6Ro00hHLlKLS0lJ8/PHHimN1dXUoKSkBAJSUlKC2tlZz/uKLL9ZNz+FwSMoPAGkqjWEYTeXTO0ZI73KhaRoUFXBpS6aMKSsTSilDupHOdSVVkDLRh5SLFlImWuRlkkllY1mcorKyMnR2dmL79u3w+/3Yv38/du/eLfkRXXPNNdi9ezf2798Pv9+P7du3o6urC2VlZVaJQCCkLcTRmkAgENIfyyxFBQUFePbZZ7F582Zs3boVhYWFeOihh7B8+XIAwIoVK7Bx40Y8/PDDaGtrQ3FxMbZt24b8/HyrREhrREdbiqIiXEkYjhCdiEAgENKfuJSimpoaxe9FixbhpZdeMrx+9erVWL16dTxZZiSCIODU+88AAGZetp4oRhh523yMsMclEAiEjIRs85EEOO8QBttOYrDtJDivK9XiEFIA0YkIBALBHPv27cO1116L8847DytXrsSmTZukhVqJ3jmDKEVJh1iJRiIjzTJGIBAIsdDd3Y3bb78dN9xwAw4dOoRdu3bh008/xR/+8Iek7JxBlCJCahhhSsIIe1wCgUCIicLCQnzyySdYs2YNKIpCb28vvF4vCgsLk7JzhmWO1skiEyNacxyniN5MJVjeTCiXkRbR2sEIcNqolMqgR6rLJR0hZaIPKRctpEy0hIto7XK5FDtVqEPviOTl5QEAvvzlL6OtrQ0XXHAB1qxZg8cee8zSnTP0yDilKBMjWvM+N3raAtGbfUePgHbkJCXfdC6XgcZG+LpGTkTrh1fmAQg0dBLROjMgZaIPKRctpEy06JXJJZdcopjKuuuuu7BhwwbDNN555x309fXh3nvvxXe/+11MmDDB0p0z9Mg4pSgTI1qzHheqT44HAMxdvBi27LyE5pcJ5dLQdxQDtoDT+UiIaH3V4x+hviPwvMd+fHnS8zci1eWSjpAy0YeUixZSJlrCRbTeu3cv7Ha7dK2elUhOdnY2srOz8f3vfx/XXnstbrrpJkt3ztAj45SiTIxoLTCMInpzsmRN53KhaWpERbT2sALcrCDJkG6kc11JFaRM9CHlooWUiRa9iNa5ubkRFaHPP/8cDz74IF5//XXpWp/PB7vdjuLiYkt3ztCDOFoTCEmAOFoTCARCZObMmQOPx4Nf/epX8Pl8OHv2LH72s5/hmmuuweWXX57wnTMyzlJEGB6MtCXqI+tpCQQCITZyc3PxzDPP4JFHHsHKlSsxatQorFq1CnfeeSccDkfCd84gSlEyIBGsRzwjTQkkEAiEWCkuLsazzz6rey7RO2eQ6TMCIQkQlYhAIBDSH6IUJQNiJRjx8KQOEAgEQtpDlKIkQ6ZRgoywchhhj0sYAQiCgKb9r6Dj+IepFoVAsAziU0QgJAGiFBGGG672U+g+eRAAUDTvSymWhkCwBmIpSgpkRCQQCMML3u9NtQgEguUQpSjZEJPBiIRMmxIIBEL6Q5SiJEAGRAJPqgBhuEFCjRCGIUQpSjpkdAwwsspBGGHPSyAQCJkIUYoIhCRAjIUEQuLwD/WD9ZrfCZ1AMIIoRclANiKSqbSRCXnrhOEGlSbTZ5zPjeO7HkHVzp+kWhTCMIAoRcmGKEUARp5yOMIel0BIGt7+zlSLQBhGEKWIQEgCArEWEoYd6WEpInZYgpUQpSgpCAZ/E0YKvEIpSqEgBAKBQDCEKEUEQhIgajGBQCCkP0QpSgJk6kSHEVYO8scldYAw3CB1mjBcIEoRgZAEyKBBGHakyeqz9PFtIgwHiFKUDJRmgtTJQUgZiiqQOjEIhMRA+jXCMIEoRQRCElD4FJHxg0BICMQiS4gXohQlBeJmq2VklYPCr2yEPTthJEDqNGF4QJQiAiEJEEsRYbghj2idNhaadJGDkLEQpSjJpE3nQUgq5LUThjUpreCkcRGsgyhFSYAoQlpGWpnwI+x5CQQCIRMhSlGyIYPjiIRMnxGGH/Kl8OlSqdNFDkKmQpSiZEBGQYJiST6pD4ThxUiz/BKGL0QpSjqk8wAw4hRFoggRhjVp0p6JckaIF6IUJRnSaLWMhDLhSfxOwrCGVGrC8IAoRUmBdBgjHWWcIgJhGJA223zIIF8chDghShEhRYzczmskWMYIIwtSpwnDBaIUJRvSeWgZYWUysp6WMFyRB29MnzacLnIQMhWiFCUB8hVFIDWAMLwhNZwwPCBKUdIhnQdgvaKYSYpnBolKIBiSSW2OQDCLpUpRZWUlbrzxRlxwwQW46KKL8NOf/hQ+nw8AcOTIEVx77bVYunQpLr30UuzYscPKrNMb0nlEIL7y6a47iOOvbMJQV5NF8iQYUh0Iw4x0UZDSRQ5CfFRXV2PdunVYtmwZVq5cifvuuw/d3d0AgI0bN2LhwoVYunSp9O/ll1+W7t21axfKysqwZMkSrFmzBocPH44qb8uUIp7ncfvtt+Pyyy/Hp59+ip07d+Kjjz7Ctm3b0NfXh9tuuw1XX301Dh48iM2bN2PLli04evSoVdlnDKTRWk/TgVfAeodw5uOXUi2KKUjMIsKwQCBxJgjW4/F4sH79eixduhQfffQR3njjDfT29uLBBx8EAFRUVGDTpk04fPiw9O+6664DABw4cACbNm3Co48+ioMHD+Kqq67CHXfcAbfbbTp/y5Sivr4+dHR0gOd5aeCnaRpOpxPvvPMO8vPzceONN8Jms2HFihVYtWoVXnzxRauyJxAyBjJ+EIYfaVKpSePKeJqbmzF37lzceeedcDgcKCgowHXXXYeDBw/C5/PhxIkTWLhwoe69O3bswBVXXIHzzz8fdrsdt9xyCwoKCvDWW2+Zzt9m1YMUFBTglltuwc9+9jP8/Oc/B8dxuOyyy3DLLbfg0UcfRWlpqeL64uJi7Ny50zA9n88nTb0BgN/vl46LcBwnHWMYxqpHsRyfzyvJ6vd5Fc+QCDKhXFjWL8np9XpBM7FXRTEdjmMNyzbVZZLNhFbq+P0+JLgKmCbV5ZKOkDLRR10u8n7N5/NBsFlTqbvrDmCwpRZTv3i9qX7B5/PJ5PCCSaKrLKkrWvTKROyXXS6Xoo92OBxwOByK+2fNmoVnnnlGceztt9/GggULUF1dDZZlsXXrVnz22WcYNWoU1q5di/Xr14OmadTV1WHt2rWKe4uLi1FdXW1afsuUIp7nkZ2djR/96Ee45ppr0NDQgLvuugtbt26Fy+WC0+lUXJ+dnY2hoSHD9J5++mk8/vjj0u+CggI88cQTqKmp0VxbVVVl1WMkBHawE30dHQAAX3U1bKN7k5JvOpdLX3Mz2P5AmXDHKgCKAdvfAsZZANrhjHC3kq5g2TKDfrgrKsJem6oyeeEbE6S/z5yswZmUSGFMOteVVEHKRB+xXPw9Z9AfbHv+ykow2aMsSb/rn38EALS5aGRPWRTxera/Vepf2WPHQNuzLZEjGkhd0aJXJpdccoliKuuuu+7Chg0bDNMQBAGPPfYY9u7dixdeeAGdnZ1YtmwZbrrpJvz617/G8ePHceedd4Kmaaxfvz4mXUONZUrRu+++i7fffht79uwBAJSUlODOO+/E5s2bsWrVKgwMDCiu93g8yM3NNUzv9ttvx7p166Tffr8f9fX1mDNnjqRZchyHqqoqzJ8/P621dE9PC042FAEAZs6Zg5xx5yQ0v0wol/rWj+DO4gEA8xYugqu1Fo1V/wJjz8Lctf8bVVqVlYGyzRo1FsWL9DvRVJfJuT95T/p77/cuRmGuI8zVySPV5ZKOkDLRR10ug61ONDQH2l7J/Hlw5BZYko/YnidMn4px8yIrRUOdY3DqTOCeOQsWwJaVY4kcZiB1RYtemfh8PtTU1GDv3r2w2+3StWorkZzBwUE88MADqKysxAsvvIA5c+Zgzpw5WLlypXTN4sWLcfPNN+Ott97C+vXr4XQ64fF4FOl4PB4UFJivm5YpRS0tLZqpC5vNBrvdjtLSUnz88ceKc3V1dSgpKTFMT21WE9OWHxfNdA6HI60rJCeTT89caHl+GVAuNsYWKhO7HZ3tJwO/eTbq8hHTYRib4b2pLhM3G/J1sNntCa8DZkl1uaQjpEz0UZeL3W5XtGGr6rSYpt1kmqyqf7UlsW2py8Q32AOKpmHPGZM0GdKNcO0nNzfX1DttbGzErbfeismTJ2Pnzp0oLCwEALz33nvo7OzE9ddfL13r8/mQnR2wDpaUlKC2tlaRVl1dHS6++GLT8ls2+XrRRReho6MDTz31FDiOw5kzZ/D73/8eq1atQllZGTo7O7F9+3b4/X7s378fu3fv1sz9DVvk+14RR8ARh/qdkypAGG6MlH5NkC0kUsOzflS/9jMc37UFAs8nWbLhQ19fH26++Wacd955+OMf/ygpRECgnm3ZsgX79u2DIAg4fPgwnn/+eWn12TXXXIPdu3dj//798Pv92L59O7q6ulBWVmY6f8ssRcXFxXj66afx2GOP4ZlnnsGoUaNw1VVXSR7kzz77LDZv3oytW7eisLAQDz30EJYvX25V9oSMY2R0ogBRggjDlHSs2AmUiWf9qP7bo8gumIRZl63XnGc9IRcRgedA0SQ2ciy8+uqraG5uxt///nfJHUfk8OHDeOCBB/Dwww+jra0N48aNw4YNG7B69WoAwIoVK7Bx40bpfHFxMbZt24b8/HzT+VumFAHAF7/4RXzxi1/UPbdo0SK89FJmxJGxHhLPIzzDu0zUT0fiFBGGHSOgXxtsrQPrdWGwtS7Vogxr1q1bp/AnVnP99dcrps/UrF69WlKSYoGoskln+HceBCW8esAgVYAwLBAM/rYodZOKlvI60rgI8UGUIkJKGCk+CID2I3rkPDlhpDCS2rMxVORLCGkPUYqSgEAcrcMy3MuETJdZQ3fdp+iqPZBqMQhB0qbdpk3/SixWwwFLfYoIBIIWjaWI9JdRw7M+NB14FQCQP30xmCgDfBISTNooIwRCfBBLUbIhI+KIh1iOoofnWN2/CSkkHX15Etq/mk87baxohKghSlEyIA1EywjaYZtYiuKHooi/RjqTSiWAKCAEKyFKUdIhDXikobYMkRoQJ2QQTBPS8cMmlXLIFHeBBG/MVIhSlBTSpcNIV4Z3+aTNeEEgDEeS1sCItXIkQJSiJENMvSMPTfBGUgfihJRfOkDiA6lJl1VwhHggShGBkGDI3mfWQgac9CNR78TvHkDb0XfhH+oLl3vC5VDnQxi+EKUoCQgjyKnYPCPnq2p4P11yIG0oDUnCO2n415/QVvE+6t9/JnqZko7cp4jU0UyFKEUEQoIhq89iZ6jzDJoPvQ7O5061KIQUMNTZCADw9ncYXpM+H1VkOnE4QII3JgMy9z6yIa88ZurefgIA4HP1plYQQgTSpZKnixyETIVYiggpYSRNh2iX5A/v500E3r422S9SfulBmkyBp0n/QbZzGh4QpSgpkMYykiHTZ9ZC2hDBiGTVDVIHhy9EKUo2pDEFGEHloFmSnxIpMpuRZFnMFJTvJHnBClmPC4OtJ2X5p6A+6NVBUkeHBUQpSgLkqyISw7t8tEvyh/fzJh5SfiOZmt2/RP3729B/5liqRVFBfEeHA0QpSjqksQQYOeUwcp40gRB/jfQj0e/EIE1xJWJ/03HT91gPqYPDFaIUEQgJRuNTlBoxhg9EKUo/yIawxNF6mECUomRAGouGkdSBaFafDe/HTQiCzGdFIJttpglpMl2UgpAnEfss0sgzFqIUEQiJRtM/kg4zaogTa9ox3D9moobEoxsWEKUo2ZCOJMAIKgfthrApEWMYQQow3WC9Q+io+leEPcqih6LM7EyfAquzbj6kXg4HSETrpEAaixbll7+5zi8zIUqQFYyc6dZMpGnfX8FzLLpPHsScVd9LtThJQFsHR5JLwHCGWIoIhASjjWhNiAsy4KQHsvfAcyyA8HuUxUbkjyUSw4pgJUQpSgICmWvWMJJi95CI1vFD2hAhndDtr4hyNiwg02eENGB4dyDaiNbp8bze/k6c2vt/8NomA1iSanHCI5+a4Mnqs/QgCfWYoiJnk5YKSDrKRDADsRQlmeFsEYmKEVQO6frOmw68Au9ABwar3021KCYglqJUMdB8Ah3HP0xJPY7e15A4WhPig1iKkkGaDoqpZeSUSbpOn/GsL9UixES6KpnDlVN7nwUAOMZMUBw3+x4EngfPesE4nJbLFswhapmszFMvb1JHMxdiKUo2pLEAGNkdSNo8btoIEiWZKneGE+ty+/r3t6Fyx4/h7e+M4e4MXZVK6mjGQpSipEAayEhGu81HutSHdJEjMsTROg3RGfgpmtEcc7WfAgD0nj6cIDGS7+Ac0dGakLEQpSjpkIYDYESt1CDbfFjLSLMsZhI0Y7FHRrrGL4tYB0kdzVSIUpRkSIc+8kjXV55Rq7jk+52Rvc/SFopOgZtq2lgRR65LgNVUV1dj3bp1WLZsGVauXIn77rsP3d3dAIAjR47g2muvxdKlS3HppZdix44dint37dqFsrIyLFmyBGvWrMHhw9FZKIlSlATSoYH4BntinNNPFMoyGdYRrU1ex7N+dNcdhN89kFB5MpGR7IOWvuhMn1lsKUrffoFsCJsoPB4P1q9fj6VLl+Kjjz7CG2+8gd7eXjz44IPo6+vDbbfdhquvvhoHDx7E5s2bsWXLFhw9ehQAcODAAWzatAmPPvooDh48iKuuugp33HEH3G636fyJUpQM0mCqqPq1n6Fm9y/B+cxXjkQyknxEtIEq9a9r+fwNNB14BfXvPpUEqYCMLXcy4KQtlk+fmXK0To7CHCltoqxbQ3NzM+bOnYs777wTDocDBQUFuO6663Dw4EG88847yM/Px4033gibzYYVK1Zg1apVePHFFwEAO3bswBVXXIHzzz8fdrsdt9xyCwoKCvDWW2+Zzj/jluRzHAeO46S/5f+nKxzPQQia/DmeS7i86nIRBEHK393fBWfBpITmbwaB50NlwnHgVL+jSit4Hy/whvemsq7wPAenjVL81pOjt/EYBIGHp78jKXLyHAeeD3Tk6dqGpHcrb0Mcm1B5U1VXfIPdaPjndoydexEKi5clNe9wSO+A4wDQsvJhpXPStRStKTdFOzdRpsp3Lmj6hdD5QHvnWDbqPGKB50J1kGVZUKqxSF4eia6j6Yxe+xH/drlc8PlCoUAcDgccDofi/lmzZuGZZ55RHHv77bexYMEC1NbWorS0VHGuuLgYO3fuBADU1dVh7dq1mvPV1dWm5c84paiqqkpzrKKiIgWSmMfXeQoDbe0AAFdNDbL6kmOgE8tFEAR0B/P3HKuAbVRbUvIPR09LC3h/wGrlraiAp7EenqCMbHl5VGl1Be9j+n0YinBvqurKC98IxXhhO06hXGeLqJ6WZvBBS160ZRALvc3N4IZ6AKRvGxLfLUXbIPCB/bWGjh+HozPxMZaSXSYDFW/A13UKjXWVGPsVR+QbkoT4Dlx1dciaOE8qF09zLVzBcyK2IcClqrvi/f3ZJ9HCF5nOb6DuJDytreBZL4BQmxDP9+I0Op3l8LbVYFDs3yorYRudGDcBX0ed1I/7jh4FnZUrnauoqIC/9yz65XKMsnofuMxCr/1ccskliqmsu+66Cxs2bDBMQxAEPPbYY9i7dy9eeOEFPP/883A6lfGusrOzMTQ0BCCgdIU7b4aMU4rmz58vaZYcx6GiogKLFi0Cw2iXgqYL/U0ONHZ8CgCYUlqKgllLEpqfulwEnkdl9XgAwKz585EzdmpC8zfD8fqJ4LwuAEDJwoXoZLrRwwc6kYVLlkSV1rHjgWdzjBqHUoN7U1lX6jsGcNXjn0i//3LrciyaOkZzXXX9JLDeQQDRl0EsnGh6H54+Gzo6OtK2DYnvVq4UTZs7B2OmLUxYnsmsK6c6B/H+8XZ868Jz0Nb9GVy2QJtIxvs3i/gOJhUX48wgpHLpzvWgua9ScW3OuBmYpZJdvL9o9mxMWKw8Fy6/CcWz0cm2gPMFBjSxTMTz+TNmYOqSJeg5xeNs9xEAwKwF85EzdlpMzxmJvkYGZzo/AwDMWbQI9pzRirri6RqDUy0fBeRIk342Fei1H5/Ph6qqKuzduxd2u126Vm0lkjM4OIgHHngAlZWVeOGFFzBnzhw4nU4MDCh9Lj0eD3JzAwqq0+mEx+PRnC8oKDAtf8YpRQzDaDoqvWPpgsDzcLWcAEUFrEM0TSdNVrFcBApS/gxNpUVZ0RQFXpSJYUDTdEjGKOWTypaKXLYpqSsUAzcr8zcwqAM0w8RcBrFAUxRompLyS4d6oUYsD4qiAOk9J6cOJ6NM/u03gUG0fdCP/8hJ7vs3i7zvAkLlIm+zIozdoZFd/kxmniuUXyAPXlUm6r6UoWXlRifunTGq9inPR9OHJbGfT1fkZST+n5ubG1YREmlsbMStt96KyZMnY+fOnSgsLAQAlJaW4uOPP1ZcW1dXh5KSEgBASUkJamtrNecvvvhi03ITR+sE03ViH7pPHky1GBICnx7z3AlxSkzTlSqaDWENnj3ZjpoZ5RiaBosVEslnDT2pFsES4nW01tbJ9Nn7bCQtDkklfX19uPnmm3Heeefhj3/8o6QQAUBZWRk6Ozuxfft2+P1+7N+/H7t375b8iK655hrs3r0b+/fvh9/vx/bt29HV1YWysjLT+WecpSjT6G9SmpdT0aErljOnY2yaYTjIydFGtCbEx/ArwYxSUMOQkjhFKagPkSNaD4/3mQpeffVVNDc34+9//zv27NmjOHf48GE8++yz2Lx5M7Zu3YrCwkI89NBDWL58OQBgxYoV2LhxIx5++GG0tbWhuLgY27ZtQ35+vun8iVI0ElDEeEkTpWiYDAJmSNuI1mkjSHQMFwVCTiY+UULegzrNKK2/Ca0bEa2VmfgW049169Zh3bp1hucXLVqEl156yfD86tWrsXr16pjzJ9NnCUbbSFPccNJFKUp1OSSR9B3D01YwHYb39NnweSQrH0QwFbwxHZXkdJSJYA5LlaLe3l7cd999uPDCC/GFL3wB//3f/4329sASxUihuQmJJM2nz0x2fpmKtn9UWY54DgPNJ8D7vUmTCcjkjjtT5TaGFwRk3I7w6Vh/Ehq8Ud53avNJxca0BOuxVCnasGEDhoaG8O6772Lv3r1gGAY/+tGPIobmHtZoohmn2Kco2LB9g93w9LUb3ZJwMndAjp5I02ftx/6BU3ufBc/5kyhVZpH2fnFxMlyaQ/ztOgZH67QsvNTKJPA8Oqo+wFBnY0rlyEQs8yk6duwYjhw5gk8++QR5eXkAgE2bNqGjo0MRmhuAIjT34sWLddPz+XyKyJd+f2DAyLSI1rwsUnPgd/IjWisjvrJgWRbH//YoAGDe2o1gHNkJlUcPZYRiayJaC3x6RrTmOF7zWy5H54n9Gl+vpES05jMnorWc4RjRWhAERV+RTu9DHkEaYMJGtOZ12mA00aYFVb/AC9oy0US0TlK0c/nzsiwLJmxE68T38+HoOfU5mj9/EwCw8IYtSc07XETrTMAypejo0aMoLi7GX//6V/zlL3+B2+3Gl770Jdx///0RQ3Pr8fTTT+Pxxx+XfhcUFOCJJ57IuIjW/U1n4JdZZAZrTiB7MCspeYvlwvs96BGj0gajAYsRrr2H9oHJMR/Yyiq6W9ukYHzeigp4zp6KP6L1gF8TTVdNKurKyR6lBehEbS1svaFYHT0tLeB9yoiryYho3dPcLOWbrm2oq01rzRw8cQLZg4mP+JzMMhlyu9F4phH+7tjaQCIxjGjdVKeJaN3D5qInjojWAs9KfdNATj08La3ggwFNjSJae5prJDncVVWwN/fF+KTh8baekCJne49VgHHmS+cqKirg626QIl67qyoTJocZhk59CneM/alVpGufEgnLlKK+vj7U1NRg4cKF2LVrFzweD+677z7cf//9GDduXNSht2+//XaFB7rf70d9fX3GRbSu79iPoeyQljyppBhjS5ckNE91uXA+N47XBaLATi0pxuhzFqEqGOG6ZOEiZI0el1B59KisKZJiJhUvXIguex96uEAjXnDuuVH5GIkRbrNGFaEkDSNa0019wHv7pN8lJcVYMiMUe6P61CSwHmWU1mRENK4+NQm+of6MiGgtZ3JJMQpLliQsz6TWlR2BJcdZ2dk4Z9o5GLQHovFmQkTrzuwBtA7UKK4dNfkcTI8jojXPsaiqCUW07hY64XcHlAujiNbdeT4psvbMefOQO2FWzM8ajp56Dmd7ApGzSxYsRNbocYq6MtTmREPbfgDAjHnzkDdhdkLkMEMb3YEOTwOA5NelcBGtMwHLlCJRUfnhD3+IrKws5OXl4X/+53/wzW9+E2vWrNENvS2G5jZKTx75UpxKy7SI1uqor8mUVYpoLZOBpmkw8sirNltKyo4CpAjFehGto1GKpKjHJqLIpqKuiJGARShV5G3dyMBJkJHKoIjWcpIVFT7ZZRJPVPdEIQiCLGK8sq7QskjSIrROxPxoIlpTAq+MaK0T5V0d0VpebnQC35ny/SjroDaidWrbE2Ozp7wu6UW0zgQsc7QuLi4Gz/OS7w8gzkED8+bN0w29LYbmHkmkxMFY5Wid6lhFgZ2vw6zUSEvHydhJs6AMITK0nIejk35g8VmGrT7Twfp3E2WZpLJupFHwRr2PCYI5LCu5L37xi5g2bRoefPBBuFwudHd34ze/+Q3+7d/+DVdeeWXY0NzDmUR24IIg4PQ/n8OZT16O4iZeEasoJUvhIyplw2vQU9eB9BnT00YQicHWk2j86M9gPYPGFyVYqR/wsPjlvl68XdmW0HzkpN+bCBKuskaM6hx35uYUxWQ1KMXHpXV59jcdR+NHfwbn80S+2CQUTZSiWLGs5Ox2O/70pz+BYRhcfvnluPzyyzFx4kQ88sgjKCgowLPPPos9e/bgwgsvxEMPPaQIzT2isLAxefs70H/2OHpOHY6wTFm+nJlTNejkK0XJXFKtsUqlgLQd8NKQ+ve3obfhKJoPvW54TaLf5xP/PIl9TR78958PJzQfOXz6aMoqki1XLPmli4UmNqXp9AfPobfhKNoq3rNOFGIpihlLt/mYMGECfvOb3+ieixSamxA9ZoP9KWO8cCmPaq2dvtPGcrJKVTu991mwHhdmlt1hUYrRo937zFyHybN+9DYcwegpc2HLzkuAXOk6EAO+wTAbpCZY7vZ+677YTZO+ryIMid/qIhGWbL97AJ7eVuRNLI4y/SiCM8ZQR/1D1q1WG87BcBMN2fss6VjXafCsT/bLnJlb4PnUB7/TUcoS0YgFQcBAS8CXzdvfYXn6UUgS9qcRLZ+/ga7aA8geMx6lV96TALEyciRGhmoQYQm4FKXfQGal4mwmrVjyi/ae6l1bIAg8pl98E8ZMW2BZPvGWlaXvX2YpCjjLp1/dSleIjS3RJHDgkStFZhtkIDZQas3NaqVMI7tVZSZPJ4WdgtZSZI6+xmMAkMDI45mpXKSzhStW0vaZwsilJ3MiHa2tUqpES/VgS22EKyOnoToo/xFDmtaVndzRWgx9QjAHUYqSjJUVX2EpCpuusaUoNduOJMtSlR4DjWb1WXqIlb4DcSTSZlNj68jINxFl/TFlrVCnmaaO1pEvTfHqM7mj9TBsL4mEKEUZjNnpM7VPkUIpSUmIgOSsPkt1xySSJmIMGxL9XlPxutK3jkQpWJSWpajyMzO4J7QgI/kUReFzlHBCyiTPsSmUI/MgPkUJJ3ExeJRKUTgRwjlap2L6TGXOTVQHkvKOKYBmSb7pMk+w/GlSPlGTqXKHIbD6LP38PowUmaHOM2g98nbC85dbl4wXYKSmPviH+jHU05KSvCMiLzcyfRYVRCnKYGLyKRL4lFlQfIM9sDlH6Tp6K6xZlsmXHoNnuk6fpUv5RE+mym1M+tQJc5z+5/8ZnInvQcK2/XgtTXGilE3A8V2PQBB4+CYsB7BEcz6lqD+ECaYhSlHSsdBSxMk2Gg1rWja2FCVLQRrqbETd208ie8wEnPOlG8NfbJFM6Tp9plWSUiNnupRPtGSq3BmJQVmbtlLHjdxSlOpVs/plwfY0hT2fCuRlRZSi6CA+RRmM2Y5J41PEJ9+nqPd0OQDA09emo8Bp1ARrMk2TTko9XWbeqpce8qcdw7Bc0vddRyeX5c8hd7Q2SDsxVubwRLIKpfx9EktRzBClKMEksnHEMn0WUEjSa0l+AnNKUj4RSBMxNKS6446RlFsMEgCfpq9CoXCYqcjx1inV/UqfojRytI50PuVtS/beiKN1VBClKMmkZEl+GEtRuizJVztUxoJ6yW/Kv9aCxGwHSxP5U0O8viWZhWB2n680wbhtJfDdGOWZkhW0cusUH/w/feqlso8ffh8RiYQoRckmYavPwqWb3kvyE9aZpEknpREjPcRCGgkSJQlekp/aMTa9iFIRcXU0xBk93lw/lgoMp8wiLc9PCWT6LFaIUpRoEjl9Jtv7LJxiofQp4iM4ZSeeiI00EavPUjjqaHyK0mRJfjp92Woxtpqkt9yxkb5PFL1kNbt/Fbo7jnel3szZeNo9Se4AkZ4lBb5NRijKjUyfRQVRipKOlY0l+kE/YClKhU+RPG5GcpSyVHdMIonaxWR4M8KmzzLhkWKJ6Bzlg4Xf8id9Ckkhp/R3+shHHK1jhyhFCSdxDcW8c7WqgaRgSb5SHF59IDGKms68fypIo65ymJBgC1pqYlqnIM/IxOo7JMjDhcSeuSIfo4+p5K0+i6IsUm4pIkvyY4UoRUnG0kZrOjK1UjnQ/8pJIhEUlIQEb0zl9Jk6orVpXTY9B8pUMxzLJV1Xn8VqqeF8nqjvMSGMweEUO4EF/06rekksRTFDlKIMRt4Ivf0d8A32RLxOu81H8tH94ktAh6LMJ5U+ReF/p/qrMuMYhqtpBEEwt2FqKonCIsP5PaauC5cHIGisQBHTS2BbMrJm61sWiaUoUyFKUbJJUKOtf/8ZVL/2M1OdRqqVBe1UltJMnghH65R+xWncJKKf9iSESKsvcotIW0tRjG1Ivggkvuzl/YIZR+uoEo9dFr3jaeRoTSxFsUOUokxGr+FFPCYovyLScPrMsmxS3TEF0a4+I8RFgt9rKqpNn9sPrz/9Bq9Yff1ES1G0hekb7FLlrVI0IqaXHJ+iVFqszEGUolghSlGC0TaeRM+xhz+m6VhS4WgdYUNYy8ooTVaupLx/HHYMzwJ94p91qRZBS4x9BS8qRVHgG+zGyXefNieL4nB6+BSlU71UukyQJfnRQJSiRJO0OW7jY6oLVNNXSWrI8ojVqi+XxHVq6eJoHf43QYvZuFuJIFmuPernONMdvSKRrsTiaO1qP608oI5TpNmiKLlEWokX94ddghbhEEtRdBClKMlYu/rM3PSZprGm25L8wEHZn9bIlPJVdmLWJo6YvZOAYTN9lhnKcWztMmZHa032yjasm15KfHnC+zqleupes7gmQ+nu7kZZWRkOHDggHdu4cSMWLlyIpUuXSv9efvll6fyuXbtQVlaGJUuWYM2aNTh8+HBUedosk56QAkxOn6lXcCRtQ1YDkjUfny5ximJckj+SCb8Sa3gUIB/BGpYOq9FitX7EMn2mk7tKlhHSb1nBMLAUffbZZ/jBD36AxsZGxfGKigps2rQJ3/jGNzT3HDhwAJs2bcK2bduwePFivPjii7jjjjuwd+9eOJ1OU/kSS1GysbDh6E6f6So8aotJin2KdII3JmKgS/keb2LWKcs5cwk7fZZqpd4iuHB1UvGlz4PzuZMgUQSisRSJ02dxKDKCeqrf0NE6Wf2ZvkUq9Hd6WKYD2SvrT6axa9cu3Hvvvbj77rsVx30+H06cOIGFCxfq3rdjxw5cccUVOP/882G323HLLbegoKAAb731lum8M85SxHEcOI6T/pb/n47wqg1YeZ6zTF512gDAcSxEXVdePuJ1vMCDZf3Sb45jk1J+clk51qeQm+M58Dwfs0zSs/G84j6OZUNp8imsKzwPp0321S8o5eQFXuc9csoyS4DcgsCDD64FT5c2JO04HnyXetYBK9uQHjYa0vtKZD4sy8Fpo8AIfswYqsBYoRuCMC6YLwtKYAAAJ99+Au7uJpSu+j4ceYUJk0cPZRsK1cVIVhvW75X66lD7DP/eOJ2+UtDpF9TtXX6MM1E35M8TzftV5MOxsvYjxCSHWh51/xUPPMcmvY8X0RuXxb9dLhd8vtBG5g6HAw6HQ5PGRRddhFWrVsFmsykUo+rqarAsi61bt+Kzzz7DqFGjsHbtWqxfvx40TaOurg5r165VpFVcXIzq6mrT8mecUlRVVaU5VlFRkQJJzNF79iy4oR7pd3/WSbQI5dak3dSkSBsAfOXloB0BM6FYLv6+FvS3tQMAbC4enXwNXMHf7qoq2FsHLZEnHEOnTsMdzHPwxAkpfwBwV1bC23wK3vbAMW/FUTDOfFPpCoKA7mBazIAfrvJy6Rw70I4+8Tmra2AvmJqSujIOwAvfmBA64G9FeXmr9LOnpRW8X2kJYMvL0d3WJn3lsbLnsoou2TtIlzYkymQbEjBQXq6QUaSHP42u3PKEyfCfpcB/lgbeV3kCyl3OC9+YAF9HHQYqAyvP2oLP6y8/DIoOdM9dxz8HAAz8Yxec55yfUHnUcEM96A3KNHDyJJznnI+Kigrd9yKnlzqJDkc5eL8HPcFr+7Pr0cKXG97jbT2BQVm6/Y6T8LY3g/e6AADuymOw5bVJ7b0Xp9HpLMfQqZNS3+KqrkZWT3grjSh7H3MKHXZjedTI8xmqqsJA8G/HuFGoqKiApynUrw3W1CB7wG4qXVGezoHDONvrQ/aUxaBoxrRcerjq6+GRyv0kWviiuNKLBb0+5ZJLLoHbHerr7rrrLmzYsEFzXVGRvrwDAwNYtmwZbrrpJvz617/G8ePHceedd4Kmaaxfvx4ul0szTZadnY2hoSHTcmecUjR//nxJs+Q4DhUVFVi0aBEYJr5KlChqz+6Ftz/UOMbNmomJS5ZYk3bTP+BVNby5ixeBsjsV5eLqyMep5vEAgKwxEzC2pBjNfZUAgBnz5iFvUokl8oSjhT+LLt9ZAMDE2bPQOlAjnZs5fz667QPoo3oBACULFyFr1FhT6QqCgMrq4LONHo8SWdkOdTWhvilwblppCU51uFNSV96tbMXdfz0i/f7ltYvxtYWTpN/H6yeCC3b8IguXLEFlzQTJH2ChRXVGzrHj48HzAjo6OtKmDR07HnhfzoIpmL1kifRbzuip5+CcBJSHyD1/Lcc7lW0BeX58ecLyGfSyWP7I+5jsacGCgcD7/86XZgIA5i8+F7Qt0LbFMphYUoJx85YkTB49vP0dqG0I5F80cyZaOGDRokU4rvNe5OTPmIGpS5aA9Q6hui54/+xZmLB4ieE9Pad4nO0JtZNxs2ahl+4H6xkAAMycNw/ZBZNx/MR4RR5tdDs6PA0AgKmlpcifaZwHECrPgpkzMSWKeiTP55y5c9DYfgA8L6BPELBo0SL0Ol1oGQhYJCaXlqCw2Fzaijo+eAITc4oxbu6XTMulRzPbiG428OFVNGsmJpxrThYr0BuXfT4fqqqqsHfvXtjtoTFLz0oUjpUrV2LlypXS78WLF+Pmm2/GW2+9hfXr18PpdMLjUfqzeTweFBQUmM4j45QihmE0nbfesXSBoihQVMh1i6atk1WddiB9GnQwfbFcGJqWrqMpSnEfTdNJKTuGYaQ81XIzDANaJiMThUwCzxs+C6NKU8wr2XWFp2i42dDXKw+lnDRFg1e9R4ZhQIECqJDcVkNRNGial9JPhzYk1ZHgu1TXbwCgaSqhsvp5SO8roWVC8XCzAnwsD39w1kiqr0yoHUv1m7El/R3J2yVNUwAHw/eiuI8KXCco7g9fxxiaUfWVtLKvoihF3mJ7pylZHibqcSz9TCB/dT8abD+s2Icxpp9VTx4Rb09L3O+ZpqDob1PRtuV9ivh/bm5u1IqQnPfeew+dnZ24/vrrpWM+nw/Z2dkAgJKSEtTW1iruqaurw8UXX2w6D+JonWwsdcAztyRfeVpQOT+mIvCZ0h9BHbnWwoxkf6VPnCKdK5IhBnyD3WC95s3IyebMJy9HvghJWO6s8JdNfJwxGum3pFtCtYKzv/xVNB/aHfk2ybnX4v4upeVisAxf0HnWeOS0YNVhuoQjsRpBELBlyxbs27cPgiDg8OHDeP7553HdddcBAK655hrs3r0b+/fvh9/vx/bt29HV1YWysjLTeWScpYgQiQhxijQB0VKw+szSiNYmg/yldPWZamlxFHdahX+oH9Wv/RwAsPjGRy1L1yo4vxc9p0zGE0niu+QFgIlzjPIP9eP0B89hbOkKFM6+QJE2ANCCjhOszjOmeon+YOtJ+HvPorvWH9FSFMsHm34y6r4qdcvijVZ0Wb0hrCXvOdUfvgmirKwMDzzwAB5++GG0tbVh3Lhx2LBhA1avXg0AWLFiBTZu3CidLy4uxrZt25Cfn286D6IUJZ0ULMnXhFRO7VL1pMUbSRelSF38KZDF3d2U9DyjIoo6kcx4NbwggEF8g1TL52/C3X0WTft3KpQiLqgVUaYH1VQoRbEFART7oXiiPHefPKSMd2T5hrCxoxfuI9Ufm3LSSZZ4qampUfy+/vrrFdNnalavXi0pSbFAlKJEk8gKGSlmh+4xdfDGVFiKVJ2rKv5INI04/HYQkb7mkkNmd0lpSKIjWsveWLgAi2bhWZ/u8b3VgdVBlNnpsxRYimIfUAUxgZjTUsdmEgwiWidk30Q9FB9ZoXfm7zmDgbPV6TVNlSYfhJkI8SlKMlZq7XpfzJECdWkCoiUNZZyepJAmHUOsEa2trSvp3TFGt49f8p4lUcXmZTnc98pRAACt0x5aD5sPNpdQYlQ4TFmso5aFT5sBXv18Df96TnVBSE7/UD/6Go9FEUTRCuU3SYriMIQoRcOOyD5F8Xy9WYG5qNtmEwt3bXooRQQT6EY5N7g0we+Skg1KVliK9BCnzgL5adtD98lDYD3KMA2p9imKpg0Jes7HcWdvkFbS+jOl03m483JOvPFrNHz4ArpPHkyQXDqSyH2eMjCidSohSlHC0TiUWJi0ya9r1QqSVG9/oe1Q1DJY72idTqvPUilLuhKVZSHJjtaJTldv9VkAdeap9SmK5WPF0qmthK1SNZu9/vSZwdXSX+LmuANnTUZVtkT5JZaiWCFKUUYTwwoPzf5BKWgwEXaVtuxrL8rpM571ob/pOHiOtSZ/MWvNxpaWJm+KlFsZIhDdppWZ5VOkB8fJLEWGK4UoZVvIIJ8i6cPHwnZt/DGVfItwpBW0+otgkrfVhsJSRKzkUUGUogSjrZCJNSebMeumerdpK8254Rt8dJ1lw4cv4vQHz6Hl8zfjF0wuRQKNheZlSPeOMdICAdnRJD5LNE2l7eh7puuOfDNYuaVI212EziVbsRUEAR1VH4R+R9N3JeIdqRyte04dhqe3NcwN1ucv+xHhvN5pc5XJmvdMXAdihShFmUyEqbLQIVVjFlL7FaHuHAS19coimaKdPhtoDiz97DqxD+2V/7Qs0KF2+oygJipFOclL8s0g8DzaKt5Dx/EP4RvsiXi93KdI7mjNq9qqslySqxT1n6lEX2Nse+Lp+hRZbikCTrz5WBr5Rcov0Oubk1dvlVYr4lMUDUQpSjLWNmCTX9cqs66iQafEbGFhIw0nfxyKVmv5HjTt2xGjUEoSNQUTK0ZLm1OJ7kpKAxkTLbs8ec50XrI2xkeeflU6Wsun6+RyqHxokmwp8g50Kg9E5VMUf5wibZrqqX/diyIkEc90XiRFI0LeSZw+M+r70q3dpyNEKcpgTAdvVN6ElDjhyTr0yNN+0chk3fSZmoGWE1HfE0GKoCgp7phMDC4+Vy96Tx9J3sqVaBTlBJefXDExbSmKcuCRK1sUQoOlIj+BT+5AaiGJqePqvkvKLIokYpcrkqN1JAUwmUvy9frT3tPlqNr5Ewy21ced/nCGKEXJJsGrzyJbj4TUO+FFsfw6rmziXH1mmQ9H2k2fGQwuMmpe+zkaP/4LuusOJEeiqOLaJFopkis4Jm+K0vrJG02fKYy4yraadGd51cNHNQ2TCEdrE0pFIvozgedQt+cJdJ3YZ1oW8/6eCUJe7kFZGz9+CZzPjdP/3J48OTIQohQlmgQ6Wut+jUTwKRIEQWkWT4lPUeQpvrjS0kkztue0ZhDSKGTqn0l+B2amz8QOfKClNux1VhHNdETip8/k01nRW4rMwKqmz2hKJx2BRzqo0LEQeg4rfQWN6q1VlmV9BltPYqjrjDIVvfoaIdSJaaufJRvCDs+9z5JBQpQijuNw00034Qc/+IF07MiRI7j22muxdOlSXHrppdixwxp/jZGMvnIR/oub87kx2FqXQKlMkLQvpjg7ZIu+zFM9W6ZBEJL4DkySRtNnnEwU03GKooz9pXC0BidZgRRDmZAGVt1YicHnJmKSJqZ9hzpOhy2nWMowogIUJFIoj1T5FKmfOd3Dc6SahChFjz/+OA4dOiT97uvrw2233Yarr74aBw8exObNm7FlyxYcPXo0EdmnGWoTdGKnz+JxHkwW2s5BNZ1jkY9AukyfaW2FqR7c0tDROkLcF9WZhMoitw7xJrWiaMtTngclCGAonfwEQdlWUv3OorHg6m4IG2/++pYz9TL9gbPHw6RhTT+gV1+Ve9xp8/H2d5hamZj4JflEKQqH5RvC7tu3D++88w6++tWvSsfeeecd5Ofn48YbbwQArFixAqtWrcKLL76IxYsX66bj8/ng84Uqmd/vBxCwQnEcJ/0t/z8d4XllBGme5y2Tl+c5zVcMx7E65cMazmdzLGuJPJzPA0AA43BGlJVjlfJwHKcoJ/kzRMyXC6WrLlv5c/McB8AeNl1tqABr6hbHqd+RUk5BVUcC13CaMooHXpYey7JAMLK5OAir0zcq00TBsX5VO+E0ZSBdG0X9MJW3zw1QNBh7VjDv0CDCyvqbsGnI5FfLp6zbgeM+f8iqQIMPDoQCOFU7gE67EAQhKV/76v6F58U6IYCmw1v2xPcnb+tchLLkdPozxXnp+ZXXqPvYnoYK5E6aoy9XmP7COF+9ftavaD88L4DzezXvilf1vSfe+i3mrf2RIi1N2ha0OWW/qGxLgiBI6fOsDzzrhy07N6781HnL/1f/ne5YqhR1dXXhhz/8IZ588kls375dOl5bW4vS0lLFtcXFxdi5c6dhWk8//TQef/xx6XdBQQGeeOIJVFVVaa6tqIgtlkYy6G1pAecZCP2m69HhKLck7e62No3VxV1ZCXthID+xXLzttRhsa9dNY/BEDbIH4qsGgsCj+4MnAACFF/83KJrRXDNUfwruoAzdviz4e0LyDB0/Dk9To3TMU1UF2+huU3nzviH0BNNlBvxwlZdL57xt1dJzD9bVIXvywrB1pUtVRrQ9G15ZerFy5owy3lHjmTMot3dJv3taW8GzXsU1bHm5Qh42Tjl8HScxEEzPV344kG/wN0VRmnIR8+7hctFjQRlEwt9zBv2y57W5ePQfKZdklKN+z/EgcCy6P/w9AKDwy3eBoij0DYTaa2VVFbrzIrcP3uuSZPVUVMA2KhRUcKCxEb6uwDnxPdb3+KXzNHhpOqajswverIAB31tRAVA0esU6fOIE6IZmDFbtQd7cf4OjqDjWxzaFu6EOQ7LyZwYCMnd0dES8l+n3wVVeDtbVhb5gGpH6Pm/rCcN+Cgg8v73LJ5WHSB9TD4/sWC/q0Zmtn4/A+dEdvLaPPmWqL/Z1nZbajpSn7aQiz46ODvRTtfC2B44NOE/irC8fPR8/A4HzKe5V9ynqfqePOY0Oe2S5wtF/phH+vlAb7h4V6k/k/Vr3h09B4PwoWHkraHt2XHmqSedxORyWKUU8z+P73/8+1q1bh7lz5yrOuVwuOJ1KC0J2djaGhoyD491+++1Yt26d9Nvv96O+vh7z58+Hw+EAENA+KyoqsGjRIjCMdiBOB2pOT4TfHXr2ghkzMWXJEkvSrqwZr1GKps+bi5zxsxXl0tdA40zX57ppTC4tReHs+OThfB4crx4PAJgztxj2nDGaa1rRik5vwFkxd/wUuBwhJWD63LnopLqkY7PmzUNO0XRTebOeQVSfDOSdNaoIJbKy7TnF42z3EQDAhNmzcNaNsHXl2PHxit9MVi7mWfCuqryNwOchZX7q1GlYsmSa9Pt43URwfrfinoVLlijkWRinHP1n7GjsDExpz128GBAEVNeNB88L6OzsxKJFi+BhBdAUBaeDkfIeNWU6pltUX8Mx0JKDhtbQ82bnT8LMxYtxvHa85lr1e44HT1876k4E8lhw7mJQNIPcQwcABAayuXPnYea4yF/R/qF+1NQH0pm9YD6chVOkcw19RzFgC2zuKr5HuqkPeC+wmokSeNgYBl6OQ2FhIcbmBfq34gXzAYpGXUMg3UnFs9Hy2evIGVcAdH6GhWXXxF8AYWi3daN9KLR8255biKb6HhQVFYGmw1uqHHljUbpkCTy9rahrDMgfqe/rOcXjbM8Rw/MTi2dj1JT5qD2trBMFM2egh2uTfo855xxMM8iH83txPPi+C2aa64sHmp1oaFeuwiycORPdbCt4XkBHRweKioowZuoUDFB9AIDxs2dhzPTpqK3J16Qnb8uCIKBS1e8UzpqFyXHW75Pt++DODowNoyZPw3RZfyLv144dLwAAzJg2DnkTrVGy9cZln8+na9BIRyxTip5++mk4HA7cdNNNmnNOpxMDsq8vAPB4PMjNNe5sHA6HpPwAkKbSGIbRDGp6x9IFiqZBUSHXLZqmQNO0JeZvChRAKd3CGJqWykIsF1olg9H1MWOzSenTFKWbHsMw0jUUBGWZMAxoigqlEcX75GXPRqmehZGdo4PlHa6uqMuIpi2qV7Q6XaWc6joiyik/Fq8ctCw9hqaB4DsQp0FYgcLin7wLB0OjetPXQuVmRf0wI5/s/cvz1au3lEEdiylfWV2kKQo0wyi9QShzz8/RlGEbkLc/8TgPCvNcnwacrMGHVp8BirKH6reVdSIS6vKnaFEOyrA/ka4N3i+XmabDvzeG1n/fIjRFK9p06D5tH2uYD89EXbf16iGlaj80TQE8K0ubAcPo97vyPANToeH7h1iQtyexvYi/eZ8b3p6zcBZOkY7ZHNmW1yd5X5uu47MelilFr732Gtrb23HBBRcACCg9APDee+/hvvvuw8cff6y4vq6uDiUlJVZlnzF0nzwEb38HZpX9lwWKkdkAYdauxtBJRPaniVgiahnVMsQqkyauSvhgapGwLk6RSq6UbMJrHKsKAJp7A5YqH8fDn4qI51FEtLbS0VppaQ36V6liBZlMSHZP5DbA+b2Y4Ql8OfvpLND24OozxWvStguKZlIX0DGqUBnWxykyG6IhbAyhmFZd6vQDevWV88t/mXtenWus6HcUdVAnj7q3n8SCazdKv2nGcvfijMWy1Wd79uzB559/jkOHDuHQoUO48sorceWVV+LQoUMoKytDZ2cntm/fDr/fj/3792P37t1Yu3atVdmnLzoV0tXRAN7v1bk42qTNxewwHcsnZjlCDdDl8eGXb9fg2Nk+U9fLjhr8HTFzc+dSGqdI9Tvli4iUq/0EQVCtuEqBTFFkauWKJvmWHKKyIS+L5/c1RC+TGaVI9ryMwIaW5Ks+MNTxZvT89ZJGkiJHGybJm4vblIwgifqrz0JKkSAIcHefTbgchpj4IFSuliMr0kSSEryxoKAAzz77LPbs2YMLL7wQDz30EB566CEsX748GdmnJfE2XOv2hbLWUvTRiXY8vrcOW99XB/2TNbqorAJRCWL4O6b0ExSnKDU6kWqpt0ooedwc8/t9WYd+LBgDOSxVimSrAIPpysvmT/sbcKrTZSIhWV0zoeDJV+PIp894tSKv2rw5lV/00Vg4E7UhbKzWl9Apa+qO+HxZo8fDNnoiAKWS0XPyIM588rKZlCyRJ1y6RvVRLi/ZNDZEwlrYo48+qvi9aNEivPTSS4nKLvOItxJGM2AkvJMIpeEJ+n4NeIwDmenHKYpVJrPPFsv0WfzfDIIgKKIXBw+G/50AlB2joKl/8mXoHJeK6b1oLEXWdeCKgHviEmbV4zd0uQydrf1D/RhorlE4VpuaPpPN0VGCIPm8KccvdZwiHhSdPKVI0w6jMSHqKJiR22D4821H30V7xfuGeYV+hps+s6huB/OgKDpovePBy6bP/O4BgxvV4ujJY8H0mbq966CwFBGlSIJMJKaIeDfa5BXz17J0ExBJNhLyhi3FYeGMny/iPldRdFyt5Xt05QhmZDodXSywFK3bfhD/rIm8hDnxKK1maWcpisYXzkpLkawdiTJwKq3olv87iFfuWIHzpxdq7q/b8zv43QMYNVkWF8dURGvl84pKkXpLHvVvKpWWohQprlGnG/YaiyxF4vujKFCMHYBfNR2VaiJbyRWWolTMmacpZO+zhGMwzRWHs6TAc6j860aDk8n3KZJ3QnzQR8PLmg+SGDwq/eXpbcHZT3eZ+trqOXU4TD7xme6tcHjUU4hSMX2mKQtVebAyJZZNQQepVyeS4WitN4Wgl+0jb1Xr3i/W0YHmGk064eBU7YOSps9kBwVeOcALmeRTpONoHcMmqiYzU2Vtsv6azU+3HxCCp+igUoTY/ET1ZLDE0TqyjxuZPtOHWIpSRDxKUfhQ8cn3KVJ8zQanI3ys+RUg6s6w+bM3AmkM9mDmpd+ORhDD37F1uIlxPkyJo7VmhaBSCD8nV2yTJZSMCHXC7LlokTvHhqbPtOkX5Dg0xwwxoxQJ+pYiXm0pUk2DRONT5Oltg7e/A2POWWj6nnBEZymK4R1Z9l4TN6Uu3SmzFIGxA3ysikWCOgOVL5oeZPpMH2IpShEJMy9HmprSnLLYUhScPvOGUYr0FEI9OTy9rZpjke5RXaEro2ni/GKzzhneClSO1qp64pc5/qbEUhRNvbVSKdKbPtNJf0q++Wi/ZiwV6s1DQ0qRPCFB0U8IghCVT9GJN3+Dhg9fgKv9lOl7whKLpSjWVaVREN2SfKumz4LthaJAMVEozCawZkm+sr33NR7TXEOmz/QhSlGCMRwYExRrxDfYjd7T5eC98hUzyfMp4g0tRdGtzlHfY5Bx2OvV/hjREm/npPZNkWSJK9XYUFsc1Eq5X+ZcrXb2TQap8lcxO302Ni/LdJpm5GNVPndifE/1knzN9FkMPkXunpao7xHzU/6M3lIUXRu0SGEx6VNkPgaVnkuCmAclTZ/FQsI+kFQWsYYPX9BcQqbP9CFKUYpIlFLUVvEemva9DFfdByYFscJSJB9Qg47WKqVIUHf26vtjksNYCVLLFVuHG59SpFl1llJUg4FGKUqtpUjfkpdcR2sxXb3pM71jxolGvpY34Wgtt+i19Lpx718/R21HaGuk1vI98Ll6zcsVJ1ENnDEMsjErCLGu5jSdn851gtanKCYStfpMbmE0GGvI9Jk+RClKFQmuhIIv1HmG72ysGGDkPkWBQUYzfWbC8S/qXBP85UnR8TUPQ0uR5nBkOeP9otQMtqr0/DLHX7VfSzKIznyfGJ8iveCNIkbvUg9Tjta8CUdrmUXvjYoWtPV78MzHjdLZ9sp/4vTe/zMtV9xEUReklXMRIivHmn74ZMyufDXOzzvQhYZ//QlDnWd066aUBxW9pcgqv6bB1jo0H3pd6RcXykT6kzNwACfTZ/oQR+sUkehQ/ZFWXlEUDdPB0CLlJWtQ4hdwOEfraLciMU4o/BdivKvP4rYUGcT7ianEBSE+Hyd1R6waOHwyWVNh4dKzHibDJ0u5jDqQrl40iajKxFScImX71wveKPCh6TOWE0AB4KFcfebpa0MkrNquJuoplgjT2zo3RJe+0X0m60e4enTm45cw1HUGfWcqMePL/6lzsyxOUZQ+RQLPSdOgujKYfF/17z8DILDB64RFl6lzkf7ifG7oQabP9CGWokSTEJ8iM40+/NeI5JtgyQCj41PE8YqAgMrpm1CHYiRftPnqnzZv8YinczLCaBrKzKBuvYVGWRbhLEXRWEUsI0URrfUcrfXKPipLkSlHa9X0GcTpM0VKOpaNFE7JRl3uJvf/kpK3yFIUtm8196HkG+yWXabjU6SJU2SVfNHjG+jUySNUb8woRWT6LARRilJER9UHmhUoZjFl6oygEISW9lprKYJsLyl5AEfduBkypSPR23xEVqC0ZZooR2tTRP2VHSE59SavGp8iWSeaCktRiqbPFMEbjZbkCwLYcCEm1GlGOX32jaWTpbagWZIvS4uCACqpSlF8dVD9ThM1FatN1zgfs1NXCof2MI7WVLxKkV6ZRFlO+uOICb82Tr7vH1GKRIhSlHD0K+dASy06KvfGlqIprT58o7A2CJzK5B/EKKq12DEpttGIocOMaP2JYrd3/a+3+JQif1zKRZipwLjT01mSn2JLkbZOG1tFrOzA9eIUqWc9zx/8B8ZUvxhFUEATlqJgfZtdlIuJY5zS9JlyzNYqr8lViuJFUD5QonyKErAkn1YoOnqKi2z1mS366bOwaUOAf6gfjR/9Ga6OyBsS64Y4MWONUoR7SE+lqLu7G2VlZThw4IB07MiRI7j22muxdOlSXHrppdixY4finl27dqGsrAxLlizBmjVrcPjw4ajyJEpRChlsq4/tRlOh7uV/60yf0WHmtKMVR2dJPgB4/eGVEtGROfZVJ5G+RKOYPtPrSOO1FBn5FJl43PAr6aJHu32ESimSb/ORBtNniV8cIGar/VoWVM8/3ncGjKvNlP+OPJ1wiHufiVVMtEoKYZRXSifoZiKJV/k0u6u97I648tNLh/UOoa/xmK5Dcrg6Jv9oDDd9RtE0EOV+dEKEGQJBENC0fyd6G47i5Du/j5yeSgESBMHUliN6+/6lE5999hmuu+46NDaGFhf09fXhtttuw9VXX42DBw9i8+bN2LJlC44ePQoAOHDgADZt2oRHH30UBw8exFVXXYU77rgDbrf+FKIeRClKMOG32IitIppTIpLoU6RwDtWfPtNFseFqAixFUazy0Puyinf6zNCnyMyz6lpO4kA9fanxKUqz6bMkOVrL8w1NnynlkPKUK/+sL8xHTeTpG9FSJNYxWmf1mcDzsmmagN2SismJOLZ6HK/1QN/6F+76WN+rvqWIZ32oee1naPjwBXTWfILe04eV14ZTikxOn4GiTVuKRJcFeV+j+8yCAN9gl6k01ekBgMD5zfktyqfPkrTK1Cy7du3Cvffei7vvvltx/J133kF+fj5uvPFG2Gw2rFixAqtWrcKLL74IANixYweuuOIKnH/++bDb7bjllltQUFCAt956y3TeGbf6jOM4aeWG+v90hOdYw86F49iYZOdYf9gOi+cDHbi8fDTXB1efxSqDQh7ZM1ICC6ct0Al7vD5wnMNQBtFiwXMceNkAID2H7F3r5ssqy5bnldfLy57nOIAxriusTplyEfKPhJ8NlYUcSvZuAnJrn531K+VhWRYMFfuUp/wdcSwr1SHRGZ6TySp/VzzPJ6V9cZxf+y5Z47bDsqwlq6oU5RJsCw5GkMqCEnjYaQAQFPWh/r1tGOrUn9rgWL/h++VYFhRNQ+A42GnARgUGWIZCIB+ZFY/jQu/JwVDIYgQ4oFY2KN33I1eo1O3CLOq+S6wrPC+Apk1Yw1hW8Q4jtSee1+mnTDDY0aCUM/gePX2dYGVOxqzfB1YmT9hyCfaPgefQ9g1i2QSijNvNlQnFQBB8YP0+2MS+WaeO8zwHXlEP9GWUyye/xu8ZMufXxvpkafgsa+d647L4t8vlgs8XsmI5HA44HFql8qKLLsKqVatgs9kUilFtbS1KS0sV1xYXF2Pnzp0AgLq6Oqxdu1Zzvrpaf+9CPTJOKaqqqtIcq6ioSIEk5uhubVUGiJNhGxIwUF4edZr+vhb0t7WHvYbJLZTKxX2mFkOq621uCmx/O/qzT6KFL4paBqU8zZI8C6dOwgvfmAAA6G2qQ3lT4BrXqZPwqGSgHU7wPjdcNdXwNDWBdXWpzg/AE6Z8eN8QemRp0nYnvLLrh+pPwh083+84jZzZUw3rCu8dVKQFALYhxPR+5IhloaQP5bJ0u1vbIHBKc7fvSLlCHt+RctA281GV1bgbQnXAXVUJwe/BgCz95QUufDEoq9DXiLbguW5/NnrjLAMzuE4q6wfT78HAsWPoNajn/vLDSp+0GOk70wh2IJDHUGUlHG1D2PrVQum8wLPo/lcuAAGVlZWwjQpc21V50DDNgdoTaPKODv1ubISvqz0kN81gfk4/ppUG0m1ra0fJaKBkdC4An1T2rupq8P4hDLW149+Lc5A9OR/cEI+2trNS2hTNKOqSQu5gOoO1dch2md+mRET9TkQ6OrSbHOvhO1IO1tUp1bNIdUmvnzKHql/JcsFdXg52oAN9svSGGs6C6XBLdaqHy0X3KH15+s+2wN8bfA81NRhUycX0ucF5BtDDj0LenLmmyoR25ID3DcFTcRS2UYE+V6/f6bPVw9/dDM7dCwBgDcqsK3ifzU2jX3YNN9Rr2G7kdHtt0jMOnjiBM0M5Ee+JBr2+9pJLLlFMZd11113YsGGD5rqiIv0xyeVywel0Ko5lZ2djaGjI1HkzZJxSNH/+fEmz5DgOFRUVWLRoERgmhbtHh6GqdoLh/G52wWQUL1kSdZquttE41Tze8DzPC+h2sVK5dGb1o3XwhOKanKIZGOoQUDBlAqbEIIPI/318CsJgP5ZNCMjzYY8NT+wK+F68dNtyLJwyBgDQzDaim1X6ZNiyR4H1DGDqnDnoYJvh7VO+Q1tWHuaGkc3vHkDNyVA5MFm5mCe7vhUt6PSeAQAUTD8HHYBhXfENduNEvbJMnQVTMDuOsqk824/r/rBPc/z/XVaC73xxGvxDvcgaXRSsI8oAa3MXLUR1XUieeYsXg3E41UmZpt3WjfahkwCAmfPmgfMOobHjIHheQEdHB/a2Z+H/Pg28nye+tQQTgu8zb+I5mBFHGZil2d+Abja0150jtxDTFy5AbYN+PV9w7rmWLBaoa/0Qnp7A3+fMKcXoaQvwxUf/gX534EOGFlhc1unCrKJcrF+wAM7CyQCAY8eN29/4WbMwfuES6XdD31EM2ALb7sw/91zQjA1//Fs7jp1wYc7EUbioZBz2nexCVXM/zp2WjwtmFAAAppSWgPUMoG2wFts/OY2Gxh7kcv3YcME4ZNkCCiFtc2C+zvvhWT+qagIyTi4tQWGx9ppItHBn0OVvDqUZrCtFRUWg6chWujmLFsHT14qGtv0AItelDkcf2gZro5ZTjdhvDHU0oL4p9J6mlpYge8xE1DUGjo2aMh3TDeQ53VuOwZZAvz25ZDaae44oztudY+B3O5E35Rz0ULSpMnHkFsLn6sas+XORM3YaAMA/1IcaVb9TOHMmBp0sfAOBcW6hgYxiHXQWTFL0U+7uszhp0G7kOMdOgjsrMIU2sXg2xs3Vzyda9MZln8+Hqqoq7N27F3Z7yIldz0oUVmanEwMDA4pjHo8Hubm50nmPx6M5X1BQYDqPjFOKGIbRDGp6x9IFCpThFy0lCGAYBpzfC29fG5xjp5maEqBpOuxXsmjGFcuFphnN9Ta7AxRFo7f+EMZMnYcx0xZE8VQB3D4OP32rBmP9LVi8UIDTwYDjObjZgJndx0N6LzSlLQeasYGiaDA0A5rSPhNF02HfK68qB5qiFNfL0xS3UTCqK3ryUar0ooUDpLKQ4+eBU+8+CU9fO2Zdth40TUNQl4362SKURSTk6dE0DYEOPK9YVzysIMnKC1Bcm8i2xfm98A12B3xmZM8rlr1RPadpGrQFclGCoHnWIT8vlQUj8PDzgYCO8roTtv2p66Gs7Jmg3D5egJ8HBKl/oODntWUv1ks/B/gYAVk8D46XXcPY9d8Pz8rSia1/1NZBPvi/cZ+mvJ8Co6h34dtTpH7NLBQV7HcETqd/UPYJRvLY7FnSdZSsLOV5UBQNhrEBFGWqTGibPdDmIEj5cjrPTFOUou8yklEe501xjY68uvcLvKmyiBV5exH/z83NjVoRklNaWoqPP/5Ycayurg4lJSUAgJKSEtTW1mrOX3zxxabzII7WCSfyKpqTbz+JurefRO8pc0sHTc27R3Aylu+23XbkHVP5qgk5EgtSnBteNo+sjGqtI4MieGMsjn6R7pGvuIpwpU6ZxutoahQFmRMEePoCZuve0+UGzpZax+O4UC2NVucp36CUTaKPXt3ft6L2rd9isEXZkUWMtp6ALSFCviahtCnxmGWrqIKO25zoaB3MR4pTpBAOAs+DFwRwvBCQRRAUCxjkgx/nc0v1yorVRHGHPlC9w4jOvJa9U7GMVW4LmjoVJj/Zx6neNhlSOhSlWjASJsmgZTNinKKo40Ep2ysflJeOsHmwMk5R+vrlyikrK0NnZye2b98Ov9+P/fv3Y/fu3ZIf0TXXXIPdu3dj//798Pv92L59O7q6ulBWVmY6j4yzFGUa4ToCsdMRl/r2nj6MglnnmUnUTM5hZZCvrvD0taH6tZ9jxpdvRna+ng+MPuIqJQpCaMWSrHF5ZbFvdGWIc28xdZrhf0e/+izegcVomw9FpG+DDtX6YGrqpd7K55Vv86HerDSReAcCfmQ+V4/yRMQ6btFqGcXeXMrVZ+cN7MUorkd2zOTKrzDlJ9ZJThb8D4AsTpHqPQm89MEx1VsHAPCxU6Qr5FOIx199BDznR+kVd8OWnWdK1rDPEffqM8FkXyXdEVd+oWRCq8/CyRO+b5Y5yvs9ehcACG7zQVEws8JPVynSy1sQogoHolGKgs9N27PBc4PG96Xx6jMjCgoK8Oyzz2Lz5s3YunUrCgsL8dBDD2H58uUAgBUrVmDjxo14+OGH0dbWhuLiYmzbtg35+fmm8yBKUaIJ1/A0nY65hhB18MawEa0D+Aa70XTgFRRf/t+mZAAAvziQCiEFSd5Aw+1/BkBSCPS2nTBFNF+eEa/VsxTF11FolrYHOzuFTmTQ+UW7nDkSmi929ZJ8+UqRtIhuG35AtWxLCEU4CVEpCuQ9wRdaXRbV1mfh2qe4JD+o6IgqsWQpkl/K88ibWAyWU1py5fVK/mEhblky2FqHMdMXa/KMmritkxZbO01nKypFWktRpH4xdKmsPfi0SpF0PvjeKJqO+Hz6SpH+kvxo0CpFAUsRY88G6wmjFPHpHadIpKamRvF70aJFeOmllwyvX716NVavXh1zfmT6LOEkYArAkukznfnjKBtGyFLEwy8OpHyoI/LKlSI9S5FcIYipLHSUDoPzkWID6VuK4uvE/TLlIosfwiV9O1EyVA5Onq6R6T2qYIYm0EyfqYI3yrf5SOMQFxIWdeLKmDEhpYiGMv3GriFUNffC29+BtqPvxSGbuKw9kK/o60YZWIryJsxCzjyl6V+pFBn4gVgQrdgSS1EUW+1YZ60IlrHaUqRR9sP1zbL2oGMpkoI3SvOfJnyszMYpihJ13yVO9zGO8CsOyTYf+hClKMGoK70jNz90LsZ5XDMVOFJj0+1Mo3RyFAdSCqGpIsobWhngjeBTFG1+aiLteSSoFIGwaemUabyDgjyi9Sx3BbI5F4rd5UqfFbPTZ3FHtFa9izA+RfJBVxB4+If648o7FrQDqt55KzIKPbentxU1r/8CE911oKB999/Z/ilOvPkY2irCK0Vmps94aVANHNcN3hi81qeahlVaIA0sjVFscRNG2NjuCwkR3XuyyvonC96oTN68PPLy0189LKYjKrUmHJuDfW7kPS8t8imyh1eKlNNnRCkSIUqRxfQ1VqC3IRByXN0A86cvRs646dLv2J3bLPAp0glNH+3KD4WlKDioMt5eyTk10vSZlF+EAdCQaKbEIipF1luK5I7WtOz5FBuOGkyf8ZrYVtZZigSdYJF+v2y6gOWk/AZb61D9ty3orPkkvvyjJdKUqsUDKAB0HP8Q3oFOLBz4ELSgVx/MttnIcqstDdI2HwpFPhhYT5WcYtNYPXkoSteBPHriVMSj3hDWqinRgPKjaUOqSO5mfYr0tuWQzgenL6NRiiI5WguCEHEVsmLaVyWfNH0WIYRHpkyfJRviU2QhAs+h4cNAuPG8CbM1lVL99av5AjHpXGfK1BnBSqJnKYo27ot89dnblW249gI7IHDI5l1wM6MUliLdDkgcCIwGmig70XgcrdVxggL3x7v6TP9++e4nFKXvi6BeOWP1hrDqTlC+99mPXqvAf/DNWL10MgAKgiCg+dDrGFu6wpIo0gDQVXsAPfWfmZRX/3x33acAgMLiZVHn7xvshj0nX3rHgiBg52dNsDPBZdDQ2fZFx3qkK5mmPmvrISdt8xE4KrcUOQsmw93THLIqqYqC01GKtHvlxW8pindKpbV8DwZaZPHRkunMK/AG02fR+xTpbrgavJcSo8ybWDRiqU+RQrlTvidp+iySpUjHn45AlCJLUTgZD3ZLgd6UF8mUIs4fU2WM2tFaB32lKDpLEStZigJ8VNuJ0U47crl+uJlRSkuRrk9RIL+mA69ElW8oSf2vLHfXGWSNHm/6qxAILGfWSSwmuaQ0DbxzTVmK1Apz3NNnyrJQl4dftU9dc58Hbh8Pp0O2MSbHgrLZYQVnP90V9nyklUucz42mA68CAMZMPxeM3Xy0777GCjR8+CLGTFsoKQ+DXhadg6Ey17MU0SYtGeGUc/X0magMUQhZiqR2KClFyjqint6UX6ufZ2p8ihQKUSDFCPlZpzQJPKc7fWZWHoWljTee7qLitRTp5x4xLaV8+tNnkXyKjNIb6ZDpMwuRV06/u99g0FZWPtbrkv42/RVuytHa8IeYmc6xKJUi0Y8o+Jydg17UtA4gmw88U8TpsziX5GsGTUFAf1MV6t5+ErVv/RZmvwoBgxUmiVqSL5Ml0Jlqr9P6MVg3fQZBaymS11Vx+rPfo7RWmdl52zIivC/5yqJo5eqo+hcAoO/MMemjRB1TSnf6DIK5lXnhVl2J02dSnCKdDWEV8bsATqUU8byAKV+4OphV0FKkGriVUzTm67G3vwNN+3cGQiVYbNlJVpwiIPD8keIUmd2sO5wPUHRKkYWO1uH2vpQtybcivZEGUYosRF7BWXe/fiNXVT7fgPndkPXyCXNV2Ov1FLDop89ES1Hgf3GJvjj1II9TpK+YxVv9tGn2Bf25fK4e5fvwDGiu9fZ3ovnQ6/AP9elaijjvEHpPl2uX9prEyFLEyYPv0bTu+1HnafX0mdpCKXe0FmuGWikK98VsPeH9zCL5fIRDHqNLVHz9KgWe1ps+EwR4dSKUa2ULZ5EQp88C/0uWIplPkTjAhkIEKFPjeEGamhfLQT5wUxSltJJGYY0++c5T6D55CA0fPG/6o2DS0n/Hgm/+2HQexiTYUsTz+n2ywf3S32GVohimz+Tp6X048zwihWcJZ42UL8k3C5k+C0GUIiuRdSKBFTtaS4a68nkHOmW/rLQURWr8OkpR1I7WIZ8iOeJXdmRH6/j8U3RXnxks8x9srYW/p0lx9cl3n0JnzSdo+NefdJUiQeDR+PFLaD70ekzy+Q06Gl6hXFC67yrR02fqd8bLrFqi78yAR+3AmTxLUaTYVXIn2miVNYXyLypFnFop0r47CoJK0TcizFQWL/owBS1FwXYoLdeGbPpMXFqu41MkKXaiT5TCB0btSG++7oiWa09fW1R1ztQHVaTFDhZainyuXvSdqQQA2dSqqt6H6Ucj+RSJiM9t7fRZZDRpyMrO7JJ85e1EKRIhSpGFyBUe/1CvgYNecixFQqSpI11LUbRL8pWWIhFxQFE4WuspCPFaiiJawJTnOU+f4rcY2Gyoq0k3FolIz6nPYxLPyFIkqCxFutNnmtVncaJyvFW/D07HmjHgVk+fWSxTOCINoFzs02e0wlIUyEe97J3WGSQCSpGJcBhhBixJ0VEtyaeYgK+WfPosFP1amRzPC5qYN5rl1UKEthcBSrWCLTyRV0uJ14U/bZ1SJHfip20BpSigLJq1FJn1KYpPKdIvYxMyaqa/ZdN9Jpfkh0tvJEOUIkuRT9e49Bug6pjCUpRMnyIdop0+43gDpSjaJfkxo/dFHipD9WBAMcYbEeo6WseJ8TYfKkuR3jUW+xSpHW81K1Z0ps/cfpUDp0WKmrlBOryjtdKnKDq59MJRqOuqaO0875z80H3g4TNhKQoXP0vraC1aiuzB8/JQFfpL8jle5p8StKipp3sUg7qJ/sI32KOocxTNWKqkJBv/UOgDKGdcYEd6IcySfHdPC2rf2oqB5kD05GgtRbGvPtNi6qNXE8dMHldJf/rMWTDJfHojGKIUWYimIzKxyajuvjpR5BPmKlme5nyKYg3eqO48aQQGfZ9iSsKks3cUhFvmr5en+DWuRzilKNZpPqMl+bwqYrS+T5HOvk3xoHG0Dvz2+Hl0uDiFA7HoaK0Z2i1SiswoV5GeV55GtMqanvKvnj5zUBy+vXI6ZhXlyqUyZSkK58QuOVqrluSLq/p4QQgNnmGW5Cv8onhOYc0QeE7ZzxiUZX/TcbQdfQ/e/g5Uv/YzVL/2c+kcRTNRTqlEbiOxximK5eNJ7FeL5n0JjryxweSNHeAb/vUnuHuacWrv/wVPyZUM4/olymbmg5LSiWit73canc+oOk2j6bPJQed83dSIpUiCLMm3EGVHxOs6XI6aVApX+ynpSOTophHyMb5I/2+J+B2tI1mKIvlfxG0p0ll9Jldg1J0wFWbXaN9gd3yy6KBe0SQi8CwQLGqjd6ldOWOxo3Uw39fKm9Ez5MepfBfAjAYQqhlq8a3yKTKVjo7fk+K0rN1EK5dePVArRQx4OGy0oj7RggCPz4SlKMxXvPhMohIa8ikKWYpke34A0He0VuxdKPBay4aJ4I2nP3gOADDUGdjjTb5PFkXbTNc50wp7jD5Ftuxc+N3ahRLhYD2u4L150spSTZwi2d+cbBVw4FqTlqLge6BMKIUhS5G8z9d7ZjOWIqVM7p4W5E2YBUEQpPagjpNHh/koJNNnIYilyEoUHZF2fykAKJp/MaatuBZTvrA6cF0MSlEsXxIa9HyKorSIGA364sodX5jgjeYUoti+LKWzqo6Doo07Bbm53So4w+mzyMulEzt9FrIU9Qxpv4JFR2v1O4tFgdfDnBJj3lIUbRtSb4YMaJUiG6Wc3hJlGvSamT4zthSJf7NsQGYbE1SK5JYiyacoGC5AvSRfEBRTgALPqfax4pSKWYT+Qm/T0MBgH4WyY0VQTwM5GUdO1ElxviEAQX8iaWWf+SX5kf1+goj9mIXTZ4GLI6w+Uyne9e/9AQMttYq2pfYposPEGCPTZyGIUmQhylUmnO6AR9EMCmadD8eoccHrVEtpTeUT3fSZXueml1e0UzSiz8yCyXnIzQpZmUR/jLAbwlrQier7bsgsRarBkrIZ+xQlAr+ho7VypZAe1k+fqR2tI0ddVmdplaXIzDRcpNVncVmKTPgU2YJTwPJqSkHAgMfEVJ2JOEVefyB9e3AwpYN1UxBkCx7EqTZV8hyvnT7rPV2u+A3F9HmE/kLnA4WimQQMlLHVYVt2buSLVLDeoFJkz1L6aBnUqbARwcMQv6O1Vh5z23xo5euq+VhysqYoSmsZCiMjmT4LQZQiK4mwwkeO+LUa09d3lI7W+oOLTqOLsmGIPjM2CrDRsmkGndVnmtwpKn7FKIJPkXrVSDifIgCYtPTr8cmjwijQn9r/Qw+NH4OFS/IRIQZQaPpM5bdglU+RBcpVrD5F3v5OdNXu1xxXrz6zI5Cm3FJEQdDEbtIj/EbFSqVIshQFFwHIfYpCU23K1Dg+YE0SB2JXRwO6TuwL5cCzgeCLoQNh5TXa8sfq1Wex+hSNLV1hUg5ZSsF2xdizJSUzmk2WzSqEklJkxqfI5N5nRnJ11R5A3Z7HA5Y9nWt8rl7JyZq2ZWlWE4d9R0QpkiBKkYWoHa3DmdGl1SOx+BSZdLQ+3eUyGVclmnRDiJYiGw0wMqWI0Y1TpG7EVuyhpRq0VV9YGsVCx0Igkjt+JgpmXWCBTCEMfYpM7E6dyIjWAs/D3dOiOC1/G1O9tepbgjIlWSkyEbUXiE5Zq9n9S11FVONoLYhKUegYBQH9bhPt1cT0mbiKzR5Uihh70KcI0C7JVxUDzwemq8RBz9Pbqjjv7e9QxNaK1K71rBw0Y96nyDQx+BSVfP27sOeMiTlLxpEts5CoPwb0/S6NXB/0kJQhE5YidRgFY/TL6eynuzDU1YS2o+/p12FXr+RkTduzIG/VgY/QcJYii991BkOUIgvRrPgI07BCKxEiL8/WycnwzNQL1wAA2gZZXParf+Fb2w4YdEaxOfjJER2tGUqpFFF6cYrUPkXxbvGhk6aYu3Re7VMUxlJEM/YwMsWmwBn5FIGXBx40sBQlcEPYjqp/YrC1TvcqB+/GOZ7AsmS1pciqJflmlaJwg7ne9Fk8ZaRWikRLkVzJnuathZeNvCw/rEUi+Ldf8ikKTp8x4vSZgEhL8tngNUZTN4Nt9WqJwsoYr6XIsgFVJ52AH0zsH1C0LTR9po5TZCh3FFYTafVZFNNnytkB/emzcPCsV/fdcH5PyMnaHvKlEvMmliJzEKXIStSxYBI0fWaUbtG8izF62kIAwOm+QKfeU/0vdNZ8bCqNaC1FYsRmhhK/RALHQxGtwwweFG3ah8qQCNNn6kE8nIk7oKTGb71qr/wnmvbvhCAIhpYiyOUybSmKD/m79bl69a4AADCC3IqllanvTKVhBHCzmLc4GQ8Oiukz1o+Oqn/h+Cub4Olrj0kmdaBNhxDcP0p2LN8fSNtvpOwGCb/xaNBS5BctRYEcGJs4fRb6YJCW5GtkRdBSJFoponPKDRwLtU3djwGKtt5SFNPCifim2RlHaPqs/+xxZQgUzZRy8K8oIk6Hps+s8ykyVe5G/Ubw+SjGruhfKZoJbymyIMr2cIEoRRaiWZIfzlKkN31mgaN1aA+lgMVmztBnutdJez5xPD6s7UBzr9v0l+FnDT14cFcFuoO7itvogDrBBSM8hPY+M3a0jlshCiQa/mwUCifN2CyxXrWW70H3yUMY6jgdJk6RCUuRxdt8RCorSkpfplTq+BQ1/OtP6DtTibaK92OWxEjhU39tm7YUcX60HH4LrHcILZ/tjk0mlVJkF7SWIunaSO8iwvSZIAiSpchOi6vPQsEYpcFLNX0misIHfYrE6yIr0HqWIlm90xssBfXy9fiJZAExOh9P6I7A6rPA/ZzPjcaPX5LnqC9HDEqRmekz86vPVAtGDJyx9RDDvahXWEayFJHpsxAkTpGVqEPrh1mFoj99ZjYfgwpMURAbk4CQb0+4ND473YNjZ/tx7Gw/5i0ypxSt/f0nit/SDt8UA0ZgDfY+s96nKGInG0XZBpRUKxS1ADzrA8f6UOBvRa9tvPqk9KfRwK+Nm2Slo7XhRRjLtsh/KpBbePSWcZvFaBCnbQ7VdivmLEVWOICr30Jg+syh8CmSro2kE+nEz5L/7WVD0ziio7XCUqRaks8Fl+TbaAp+TgAniD5FwemYoB+JoTy6liL5qlftgK5Z1h82gwQOqBQV1R5eagKrz6JzAo/GYh733memFs3wABWycqsjmMsRI3KrV1gGlueT6TMzEEuRhSgbk7nVZ9Fo6KITnZFFR76iSxAABsZKgZhGr1vmsBrjElxbcOaMpQI+O6JPkTyiteY5ZQpczOiUXVhH6zBQjM3YUheDVcvv98N58u9Y3r8HszwVkA/wFC8v8/BfjaGgftY5WutBAZjpqcSiwdBUq2gREZeLyxWReL7ejZRVWtq4U7wunKUo9r3P9FBbimwITp/paEXqa7XChZ8+c/s4qY1I02d2mU+Rakm+WEPEaz1+DpRMKQq3bx8A9DYcwVDnGZWI8nqnb0myfJl2RAubfnuOJU6RSMACrD9tbtSmonnu6KbPzDlaq+XSVbINZBSnj9UBSh25+WFlJNNnISxViqqrq7Fu3TosW7YMK1euxH333Yfu7sAX75EjR3Dttddi6dKluPTSS7Fjxw4rs46b3tPlGOpqinyhAZ6+dnh6ZV/Zmp2qlejFSgnHYGsdKv+6ES2fvxlGq6cU02dy/xANwYam3FQ+tk6QoQJfrnywOon5ev3hpvmsqHqRHBLND5Y0Y7NIpgD/9adDaKk7AgCY7T6miPptZvUZABTMOj+08iZB02cMHTo/d+iQ4pyoFDly8wO/ZRaJeKYajZRVRq0UhV19FvveZ7rpqcrXrrP6zOhaNWplTj195vKxoCCAoUPt1ZaVGzyvuDOQXzA5MexF75Afr3x2VlKYuWBMnnCcfPcplYyhQVDPrzEQZ81snbPqOn2fIrWybJYZX7lFSkM/O6OQGVEoCGKfEY2lSNH+TfgU6W0XFeEDVj19FuhHjD/ukrrZc5pj2Sjg8Xiwfv16LF26FB999BHeeOMN9Pb24sEHH0RfXx9uu+02XH311Th48CA2b96MLVu24OjRo1ZlHxeujgY0fvwS6vY8HtP9As/hxBu/RvNnb4SOGex9JqK31UA4M2/L4b8DADqOf2hsNdBMn+krRYY7YMc48Iorz7igpYjWsRRp0k5I8EZAORcfyt/uHBM2LYoOYymKWh4Bjd2hbQMo8NJ+YgAA+SAUpo4ELDSBNM/s+2t8shl0okzwmdVbtQChIUoMNCpGCQ7cEIdSZDDdJe5mHhIgjFKk8MuKZQWnKj3V49uDjtb6PkXh09K0LcX0GQ+3jwMtCNJyfACwZeUE0w4FrZSiX4tKkez6TW9VSxY8ccokrEyqgV4dAVt7vfajrmD2soj5xIPuHo107AsyRk2eI6Whh3egC90nD4mZh+SIxdHaoD3Ij5uOU6S70bX6fATLL61VisJ9yFi9sCOTscynqLm5GXPnzsWdd94JhmHgcDhw3XXX4b777sM777yD/Px83HjjjQCAFStWYNWqVXjxxRexePFi3fR8Ph98vtCL8vsDnSDHceCCEYHV/8fKUFdTaP4+hrQ4n0fTgfAcC5b1K47zPKdMn6KUX2w8b5i/vJPiOFZXqeF5HhzPg+cFxfSZJl4SaHAq2cR0Y3l+OthI+eC8t7j3GccL8Pr8sDE0eJU5XoA4ABgPfBzrDyuPXjmo8wGA6RffjKzCqagoP4Szh17H+PlfgT1ntFIeigJvYN0TBOP3orgueD/LCQoliAKvVDp4X+hd6rwHKT0Anv4OAIB3oBOs3x+zhUavXALCUQAEOHjtFEygHvGw5eRDEHj4PS4pDUGIvd1xfv0lxVAtA1e3HzmujtOh9NhQPQjXhgJyGzi/q1ef8Z6gQ7OO/BGswDzHKt6VvOw5lsWg3w8KPGx06OOEyc4LygdQtiwIAg8+2NeJQUDlgSRnFeUBjB168dCMkJcL65fVQZ33wbE+UIwtdJyipZAWPC+ApkPXi/1GJDk8/R3wuvpgCz6rGr32x3E8aBNpG6Unymt0/5l9f8WYGUvByz5iw7VJNaK+IsCgblF0qG5C7EtC/Rqn0y4DZRmSmfX7ANqmqOPy96crF0Ur3gmdlQeOM64rHOuLexyVyy//X/13umOZUjRr1iw888wzimNvv/02FixYgNraWpSWlirOFRcXY+fOnYbpPf3003j88ZDlpqCgAE888QSqqqo011ZUVMQlu6epGq62wFwsW14e9f2834OeNuVSYNoxgP6qKgzIjvf4neiRpd/d3gWBCyl+vUIDunL18+872wR2IDBA9tIn4W3TLj3ud9ajmS1Ed0cHBAiSpahNdS1FM+iz1cPT1g6PJzQlcqaxAX0xPP/gQB8ovx9ssDrRCDWAQ4fLkW2j0d/YCH9PSA7G6QEzwMHXEX4Jde8rjyNn9kW653yd9YryBYA++yl4VMf8bYOgOurQf3gnen1unKz8HKPPvRpdsusGchrQwpcrjolQjB0+E+Ui8Cy629rhZQVQmBa6XxAkHxIA8LoGpXfS7c+Gv1u/DPodDXDL5PEd2g86Rv8KdflLMgc7SYegVYpYjkdbWzsGx/TA1dYOumcAfHApfp/tNNrt5THJ4jpZp3lHjnGz0H2mCf7e0HHX8eMY1HkfauweBv6gL0WP34neMO9K7/0CgF/VaVMAOjo6FMdsdMBq09XVDbjDRDBua0fT43cge9pS5Mxcjt7ms+Dc/QAAd1UVavxFsAs+UOClejDYeBb/KPgmRjlofON0I1xt7egV6tHpLEdrRyeAUKgLABjN+NDU3Apfp/kQBPK+je1vQ18wb5uLBzvYqbiWtvcDtA28N+BQT1EU+u2nAZ1y6c+uN2w7arr/8ihySi8BN9gJx/hShRVo8NQpTb/mqzgKOivPVNpqxOf1tteGrUdseTm629oki4y3ogK9JvPz1tSAceajsfGMVKcpxiH16xRjl/zfPFXV6GtrB53lgjsom7/nDPpVedm9NgicX+rvfUeOgHY4pTLoFRrgGLJr+j45fcwZdGaH3omnbQCNg0fQbXAPRTPwxtD3hyPecTlVJGT1mSAIeOyxx7B371688MILeP755+F0Knfszc7OxtCQ8Vz47bffjnXr1km//X4/6uvrMX/+fDgcAbMxx3GoqKjAokWLwDDR7fAupzOrH60DARP0wiVLor6f9bhQXadcYcQ4cjBlTika20PH8yadgxmy9I/XT1HszjzmnBmYZpD/ydaP4O4JdCD506ejl+/UXDO+uBhF85ei4ngRhIZGafXZhAlK2SjGjoIZM9Dtb0Z2VxswEHgPU6dMwSwzz79jj+JnYf5oDHY4wLOipSjUec+dvxD5OQ6c6v4MLkdIAXPkjUV2wWT00/3h8/KdNXwn/WfsaOw4qDg2duZMdPmV0ZoXLD0fPM/jn/90o6ioCHanDfOWLMGx46FymVg6B+PmKY+J0LYszDdRLr7BHpyoGY/eIT+oVlUIApmliM8djwkTAmWeO34KXHZ9R9miklJ0+EJ+brNLZsJZMCmiHGoEnkPl8ZeBCdpno+pOAxCk6aKVxWMxJtuOt461gqJpTJgwHjPOW47TfZXB/bBGAQDGzp6NSTG0FQBo8tShlwt1zmPnrMSk867EqfefgSsr9JEwpaQYZ3uOREzPWTgJ7uxAnVO3MTV67xcAqPpGQKbM0xQwfvwEUJSA1Vke+DgeB051o9vlx5iCfEzId+qmo8DTgIVL/gs1je/A7wqsoJoxby4Ge0fDwbuRnWOX2uY5CxfD+6/P4bTbUVJShJaBGow5ZzqmLVmC92u70AtgUkEeGJsXLX0e5I0uwMyZJehlQqsA7c4x8LuNNzaWt6OhjgbUnw3k7Rg1Dr4BpQWStmWBtmeBdYvtk0LB9OmoPnMYRUVFkgO6IADjZ8/ChMX6bUcLBzS+Jz3z6CnzpDNN7hPohXLV5ZzF58LuHGUybSXi8/Y1MjjTdTjsdYH0A2109vx5ONloLr/iBYtQXX8G02fMQC8fUGKyRhXBG1RoaHu2FDuoePG5qGv6B5isXMwLyjbYkovTrcq8csZNAc/54Qn293MWLVSUwehp52DMtFKc6dQPtwIAY2cXY9KSJRia8r/wD/VhzPTFEHgelTWq56JoyUK24NxzLQmVojcu+3w+XYNGOmK5UjQ4OIgHHngAlZWVeOGFFzBnzhw4nU4MDAworvN4PMjNNd7oz+FwSMoPAGkqjWEYjQKkdywaKISiyMaSDk9TmjlliqJAU8rjNE0r0mdsDunLW++8Ij06tNeROt3Q/QwYmw00TSl8itTX0jQDWpJZHgo+tue30RQoCuAoraWIFSgwDANaJj8QcARkGMaUc7ORTOo0A89AafKx2WyS+ZamKThyxmjyZuxZhvKEey8int5W1L75GN473o66dheo3HOUacj8AgackzFxcSnaKt5DYMGgfhnY7A7lOdYT0/tpq9xrmIc4a+TgAwrrgsljpP29xOjKzjHjA/cL8nZij7nNUQIHiqIxtmQ5coqmY9TkObp1JFzZKNIDFO03nFxG6fkoBwC37DqAcWRBYH2YXBCwzh083QMAEAT99qcHwzCK9krTNFxVe5DL9cPOZEvHHcEpJY4XJKd/sT2KCxhomsKciaPQ0ueBnwdsjmyFHDnjpqG/aQBGyMtF3udR8ijasvPgOVX/RUn/UxSN/fVdONE2gPXFLCabbMtyfL0tYM5ZGMpTp1+z2cz3E2rE52Vs9rD3B9IP+WMyOv254b3BVYM0E8rDkVcA32Bg77nRk0rQd6YSFEVL7ZkSeEk2WufZaJqGwMnqNE1h8Oxx6fdQ20mMnlyquY+xZ0krlMX+bNTEWdJ5Qae/ZBxOKRArDUHjoB0P8rYYz/icbCxdfdbY2Ii1a9dicHAQO3fuxJw5AUe30tJS1NbWKq6tq6tDSUmJldnHTLzLEfUdFZU7VeuhrYDmHJ3DLclXrD6TfIrUgRNDXwfy74KhzkZ0VmujX5uQCADAIeh0KAjSZLsUqyhZwRtVZaO3ys/uHKU5Fm9n0F33KQCgrj1g+VM7Lsunz3iOl3b+Dlf31EuJ/W7jAS8cehHNRcS6YReCeyZRId8V8ZUFnDRVnVoc70908nUWTkbBzKWSk7FGNpPt0oyjdaSQBm4oLT8UoNllXFQKIgZvDJO3wPkxWH8AAJBtD5Wp3RZcXi9TUPoaK8D5vdInBoXQogYvy2sc043KUcpbHklZsfpM6/gu8Jwy+nPgQRQ/Dzf2wuXlsOeYcu+1mAmzcEKvzZolkoKjWQIfTZwiUbGULVO0O0dLf09c+u+YtPTfUbrqe7IQCt5QVHijwIyyfszn6kXDhy9Ivzm/B2c/3aW5Tx66QK8/0+tz5Ss+rdrGJ9OxTCnq6+vDzTffjPPOOw9//OMfUVhYKJ0rKytDZ2cntm/fDr/fj/3792P37t1Yu3atVdnHBR9piWQkDFZyRdqVWT1gmw+WZrwkX/xfbimqaR3AgHx3b4oCx3GobR/AgFe5Qq3ZRETgLJuy2rB+LhDRmgoNIrQU1VrsfM0Fb8wZOzVi/iK6kV5VZSiu8pOvrtBz9DSzy3VYWXhOIQ+tCgc43heKEyMIfGj1VtiwDUqZ5FOt0SCuUtJDtBTZgz5FAQuneE5A7orv4PWjLaAdKqUhjvISfSw0Cqu60zbr7BpBefL0tuH4q5sVO8mrcVPKAIEURWnKTZQu0uozETGUgbzd86wf/Z5AmxudHXp+UeFig5u9inQe/5e0JJ+mKKVSpFqqbpMNxnrIt2aRK5J6kd/FyNvKY/rpev0xBKCF0aoqFcGymHnZrTHlAUQOH6FW/mKJUyTvz+Qb2DL2LBTNvxhZo8Yq2kzfmUq0HX0X+h92yrJnTX4MMbI2ajbkC0WH4jhZEQR1OGCZrezVV19Fc3Mz/v73v2PPHqXPyeHDh/Hss89i8+bN2Lp1KwoLC/HQQw9h+fLlVmUfF+ovKL3l8mbvl44JfMTOWpuPWUtRuCX5gf/lcYr21nSAoSncdvGs4GkaH9V14MOq2PaJys2ywStTMnwch/GjssF6bRAoCpQgwCF4QfMueHz6DS3QUWkVo6gGW92vLGWHJn7ty/f70u8w4lyOz/OK/bNonWjiWTY6GM2Yk77aOJ9x4D2rLEWMPQt6byEw8AX+FqfPgNAXJS8AX/tjLfycgC3TvFiQL5MthukMT28bznzyEtw9AZ+vwGafxqjbz4RFl+luL6JQhHW+hs9+ugusZxBnD75mmJdP0MqiVooYyYJmUitS7M4egOf80vTk6OxQnmIMIo4XFF/0vsEecGxAiaeokAw+ltfIF8mawnqHpA8CZZ8Xm1IjpctFZ1mJSukIPm/2mPGYtuJanNkXQ3y7CHWV9ag+NmJQiuR1UPHRpZrKl6O/ByEAqIMzmqtv8sjfZscwiqZBM3ZwPEeW5QexTClat26dwjFazaJFi/DSSy8Znk8lGrNy1EqRUcyf6KbPwnW2CtNnuIjWwf95QVDEKZIP2BRNo7bV2CEzEowqop2f43DBjALs53PhbXEiWxjCdM9xzHIfQ9f+LuCaDTrPpq+ERBO9Vj/Wkr6lSK5gGC9NN8oncqck8JxiA1hxOgoIOC97/DyK8hzYU9kGngtZiliPsaKjVt7MfjGq0cT/EWWW/S2XVxrKBUHa/LS+h1UoRbFMnw00V0sKERD5a1atFBlZQiIN6pEHYQFeqKbKKEhL0KVjouIS5/TZQNBSNMopsxRRIaXI5wq1TXvOGIB1SfnLLUXqYJeMwxl0htf/GJNbinjF3nFmlSL95460Qa4cirFBEAffSJGbAZVCE9uHS6SpekX8LUQ5fSYpRaEylCtF8rw1Flsda1zgsP7xSAS28gj+bXYMo2jQNjs4v4cEcAxCtvmA8Vx7LPdLx0xZilRfpyYbgnGjDU2fcTKfIr3rbDqhes00xO/99Qg6BpR7LbF+DjaGxje/MB0eOuArM8t9DADgbqsTE1dKYGDSjmQ9UAmsPcSrLUWBziFr1FhkTZgrXhSQQaeznP6lGzFhcZnCBG7my1GtFDlkSkZ+jh3LZhYi2xHsQAU+ZCkKs28VRTOYddmtkiw+V09EOfQwiggsf99j2K5QvjJLkXStgWIVDerBV/2u1e9D/S6NLCER21mEQZEXQlvUSPdAO4hJ5WJyzJTylZUzx/ox4A4MPqOCliKKZhTt0SdTfgWeg4/JlWQSlSIfy2n6D4HnwdiN9wmTRySPyY9SENDn4bHjs7M43emClw5M1/TmFZtOQu2npU4/HNHE6JKvaotoKVJFBI8qJpJoPZTVbcVebargjRplxeiZVVHQzSB/95qxxQBKHn8qjabP3nrrLcyfPx9Lly6V/n3/+98HkPjdMciGsFDNqccQJMww+J6m41ErBsrpEfMBwwyuk02fcUKYDWEpCnadfoIXBMk8r4fLy+KVz7VbofiD5nOapuCllZaekIVK+eyB3av18ormazDy9JncGmEbNR4Y6Jb8f+SdjTgdNOacRRgDoK/hKPwIfLHzHIua13+BaV+8HjnjpkGPQNDGUN7TPCekv2nJgieT0eS2AHkTZ2P6xTehbs/j8A10BpQvjwv2nPD+I3KMfIqMfGP0tragbFkAZFN9MXzJqn1X1JYiRuW3pLEUZesrRfIvXH0FKHydEgRBqxRR2nKjqdD1ZpBHOBfx+bzwBS0rxV/5D+QwQO74mfDIolUXlK5E78mA4z7PeuHOnomK3C/iwvEMGF99IB2O11paeBaMwwnWwPeMZ+NTigQIONbhQ5eLw9+PteLDguvBgMNF9rGm06BtDkCSL7JPkfJ9musbii+/E9my0BURHa3VljKT/bB853m5pUhebzQry2wO6eMg0FcZ+RTJAsuatOQxMkd7s24I4vRZIJ/0UYoqKiqwevVqbNmyRXFc3B3ju9/9Lq677jocPHgQd955J+bMmWMYCDpaiKUISifc2L6gzCpFSkx/NWgS1r9OPn3G8UKYbT5o2KhQGqecCwBEdiD1G/gOiIHvGJqBO6gUiVsScAaJqgfAeBg1SbaKUW2RkpexPMx+hI5PbV3xDnSh7u0nUP23n2Gos1F7QzCStW5a0lYaoqWBj9hRe/wcqloHIQgCskYFBh2/ewB1ex7H8V2PwN19Nuz9StH066HRxqa6egVjfl8yYzlUSpGq/k8670rkFs2QXa+U25FXoJtupC/cSBYGjtcqRYDO6jOZA7opVNt1AIDXG+hrvHQOxs9agoJZ58GRV6D4GHHbxmDSeVcEZPN7wfECmrJLgTHnhKbP/NroxDzHKqwUeRNmK59TbikyPWWmfB75GguWssND58LL8qhs7sOgN7o05eXCs370N+nFsZGFDDFpKcoZN03Rt0a6T10vxXoXqY0qpuRldVUxXa1qTIpzhvVI6VNk1udLbkk1ssiNX3ip4jdFM6ENn9No+qyiogILFy7UHJfvjmGz2RS7Y1hFxlmKErHNByvbpoP1+0BHkR7P+tHTUKE7SLCq8PnqLQgEKPcgC7fNBm9imw+xbHheAE0BTppVWIRCWzQIsDuc0rke5yyUeivBcTxstHF5Dnn9cNq0I2ZRbiAEPUNRgD0Xdl/QqVjgpGdWbwNA2Ry6O3Hrh/o38JEIbu8gD+OvLhvanh2qMxQFnhfAsYFtGMK9Gyq4hYIa72AX6v/xLOat/ZFKFj9YntO1wNEIyEdBgJ0GssAZbiki8spnZ/BJZQUeKSzGF2ePCzyHbwhDQWWos/YgJl8w0fB+hWwGWwJwPK+Qty73PAhCYIrOTgN99iLpfdtsyvLgY9gSRr01gQBakQadlYsZl92K2jd+De9ABzgu9I6mLL8WlN0ZURnjeUEjl9E2D+MXlaG94l3kzbgAzNGzirJgAvNnivvsdMDCKgjht6eR8g2WES+rkx6PG3Ya4BgGlMCDCyrSFHiprB95sxI/PC+QN+t1gw6es9GBzZftNEBTgrQdiEje5HnoO1MpHVPXMdY7FOoz2fDbROg/D4c8R8jKnG1jAIpCU9cgrnnyY5R1NOA7X5oZNg15vvJtj85++jfwOso7x/MQpC0xzG1pon7/XJhtPgCA9Sn7aXF7mYD/U0ghoWgbpq74Js58/GfxiJSXvG4zztGyZxQgQN7nQ9FXybeoEeE5Drysv1SPI0ZQjpxQvjrlAABFCy8DKBptR98JXCcEFCNB4MH6PJZsxxFumw+Xy6XYvksdjxAI1NvKyko4nU4888wz4DgOX/7yl3HvvffGtDtGtGScUpSIbT76G+ql7QW8R4+Cyck3fe9g1R5422t1zw2cOIEhWVj1bl+WYguCwcYmRVh7u9dhuM1GX1MT2IH24HV2xXYIUnp1dWjy5KGnoxNXlOTCMTYXvq5QgExxSwHG6cPypddgYXYnsiYtwI3OfPR9love7kCU7HBbnbzwjQnafI8fRVtbO3Ly2vGjy6ZisPp46CTvQnl5OfqazoDtD8nc72gB7xvShPXvFRrgbVceM5LH01IDV1s7etgc+LpC2zz4ZNtm9NFF6A7eT1E0Ojo60MudQnfuYUXIe1/bIOieUD4Dza2GW5BQtE0TEr//9CnA3Y8rS3UCknr60eYJRAa+sjQXoxbkoubEibBh+i+bkY1vLJ4A+0ATysub0NfrksL+A4EtQNpt5Yb3y+lrOKUoezlyeUctnoO2o68DAK5aOA75y24CFfyKdJ9uQNtp+furQ4ugrQvhGKw7oXjf3uPHwThbNNf1trSAc3WjzxbYDsQ+ZhLYPhoN5ZG3kujhG6T3Lcna1KS7xYn3HICavQp+uxM/vozF4HHlu2tsOqvYjmRBIbCgMBeAB21txqsGRWjHIFyf7kPP2VA4hmymAVeW5oLJGYMjR5TRuuVtq7b+NAbb2tHtteOmJYtxU+kE+DpPYeBUL64szcXNXynEyQ4vhmwTYcsrgqOoGJUn6jHQ3CbVW7vXoegnBo5XwukOPKO7Qdk3RSJn5nL0NjZgQVEWFhQFrB03f0WplHf9M1ezpZCILW8c2MFO0LY+aRqv33ESrSgP3LvvTd37/EeOSBYZX8fJsG1GRN1fsAMd0pYmegxWH5e2eQKAoepqDLS1K6JRA0De3DLUNfdKW4AwzjHwBseepjOhbXTYqhr4J18MiqJxRLXpeW9zCzh3L4DA++ngxmieiRlkIfiGpLwHaqpNvSv3qSZpyxD3iTrYO/T9Fd2N9VJ6dq8DFM3A190O1/FKZPVEbwE2Qm9cvuSSS+B2hxz+77rrLmzYsEFxTXd3N+bPn4/LL78cW7duRU9PD+6//358//vfR1FRUdS7Y0RLxilFidjm42TrR3BnBb4IiufPQ3a++c7+mMH2CQBQNHM6OtynpN+5E6ZhpizU/llvPXpkYe1zx09VnFfI2PYx3MFLc8ZNxlCW1tQ5qbQUY0uX4FDVOLz40Ql027tR6A/5F4hfcVmjivDWwFhsq18B1AN5bCdW9Lhw3bJpyMuyGW6rUdc+gKuf+ET6/dF9lyA/1yGF5x8YMwkPvNWIc/tdGJNjR9+QHxeVjMNlS5bgZPsncHeFzMXj58yHb6ATvVA6D+fPmIleqldxzEie7jwfmnuPYdSUGRiwBRpF3sRpGLSHGt24OfMxcckScByHQ201KCoqwqhJUzFt0UJU1wbe29xv/FATu6jJU4deWn+1F21zaLb9ONV1CFUDPXivqk1z/eolUzBulANdgz787fBZNPb14f++vRyNYcL0//HDUzjU1o0bL1+A//rKbNR3HMBQZ8hKN272bEw0uc1GXeuH8Di1nd2gl8XLn4YG7A+6BDw/fzx4AdhyEKhoC72bb8/IwVdl9XzszBlRb/PR5D6BXiHk0D3n3PN0faPqWv4FT68NBdOno4dtQ864adL2M5G2exg99Ryco5LrdM/nGHRoB4iSRYuRNXocWvvduOHlQ1jSH2orE/MY3HRxMbrZUGDCD2o6UNc+iC/MLMTiqWM06alhsnJh7zoIh6zcvGPGYuc/XWBzcvC725RyHm3qw7e27Ue2nca/jbfhy/ZRmDFxPH5TxeOfNR348arzseACYMPuZrS/1o4jG78KLF2qSOOs7xR6glvn5I6fptg2Zdz0qVKdaaM70DF0MuIzFMxehnHzLoYjrxBN+3fir4cPo6k/0Fe+26Os62UdLnz7opnBaXzl1FDexFIMtp5QrI4bN2uWJI/Re12wZKk0/dXf5EBj56GIMqv7C3dPC042GdebibNnorU/9LE9tbQETZ2fwZaVB9Yb2kZl6pw5yJs8B9Wn3gIAOMdOw4xFi1BRUYEpkybCHaxjgfyVMoicaHofvgFH8P4JGDd3rma7jqzR48G6B8D5A/3Y+Jkz0D6o/+Etp/i8ZahrC8TimrlwkWIqWk5n9gBaXYEFMHkTp4O2ZaHf7sbk2TNRWKIvdzSE2+Zj7969sNtDU3tqKxEAjBs3TjEd5nQ68f3vfx/f/OY3sWbNGng8yg+SSLtjREvGKUWJ2OZD4PyyLTSiC0kebt5ZHkof0NvmQxl+noK5LS3U6UrpBbfO8PMU/HzA18IvGwvt2XlgvUOYeO5X4a4U4GYDHRfNBa4Xty8wksHLQboHAByOYAj+YDnYGRtcnC2YZyBNltdudQAADmceWFePboh7TSj6CGUi3wZAvTWEI2e0dD8lbm8CQRHK35EzWuOga89yGr5bmtbWNwoCWB6K8g5dH8iLpgNl4mX5sFsPsBwPPw8McTScWYHtNBjVlh+MzWG+nqq2a5BLLZe3j8sKlCclwMfzinfN0Vmauhwo/ygc41Vy2BxZus8gbnNBB98lLWvf8vunfGG1JvaQXhuiaf1tImz2QNnyAo0hngYnhPzqOCFQxor7qEB5cYK5OE0UAG9fm+Jan58NtDXYNHKOG5UNNyvAzXJ4v64fg/2tKJkxHR422FYZG6Z84SrU//1dwMdDAAUbo5TDnp0b2h7CZlPKybOh7SVMbqFiz8pBTv744ONT8POCVGfk9QMI1H1eAOw2m9ZJ3hGsP7KI3fL+0EiWwDMEt9+IsF2HdI96fNDpU+Soy4IOypMzdgo4nxtDXU1S/nbZ1io2e3aoPGWyhWuXNCWThfPryhbYmSAkk1F/ryYrN18mg7Z+iTBMqF7QjE16N67WWhTNXRkxH7PobfORm5urqwjJqa6uxhtvvIHvfe970rv3+XygaRqLFy/Gc889p7je6t0xRryjNetxSfvUALE5kBqRsOCNwXTzJszCrMvWy1MEEIobona0PueiGzHvGw8gf8a5qtgi5uKveFll2dilDjmYH8NIDqtiZy06WqtX7NA6S4cDzoFRDLLSuzKO4aTc+kBcKcJJy70De0xp8xw9dYFxvjodlMBz4AzWaqsdrQWB0zh/ilME/W4/3P7A+xUoGnZbqPNSXB9F8MSQU62Afrcf4vsa96XbpP3qgomKf0gyi6jj+HRWf4Tjr26Gb7AbkRjqasLxVzej78wxxXG1M2jfkB89Lp/0bHrtp/TKezDx3K9i4XWbUFh8oea8bpszUNzEMvdzPDjYNGEq1O9ILBO5g3ru+JmGK330ZPEHF3UwNu336Ni80GDBUmIkdq8U6sFGU3DIPJ19Ogsf5KEk8mcsRfaYkNVbvqDEbGwixfJyQUCkkEQsrz+Am10iHo5wCvikpV8H43Bi6oXaXRIi+qGpHIzF6ymawZRl35ALoOiz5SElJl9wFbJGjcO0FdeGzUteFzmfx3AlozK2VfSrzzRbtChkUIYJyBpdBADoP1sN/1C/qbwSSX5+Pl588UU888wzYFkWzc3N+MUvfoFvfOMbuPzyyxO+O8aIV4oGmmuUFTDOfdDkROp4NEvyTQZAEdMdv/AyZOdrnW3FJb/qOEUCbZc6TbmCI0Db2evhVZlBxEFELD+GocBTgWeyywLd6T2XLStHsWwWgOFyd29/p25ZSu9N1tGo81IEgxTLW+BlHZ9+E8ibOBuzy/5L95xe5yyEWX0mi5Qgk1G2LYBzNCDwqG7px4sHGqW9pHjQ0t5xZsP26yGuzvo87xK8eKAR/7+9Mw+sojr7/3dm7p6bfd9ZAmFfBMIqimwKiIq4bxW0+Nqi1df+UGv7tvjaVrH61gW1oqXYuu9YqqKibFH2ncgWEkiAkD03uevM+f0xd+bOdpeEhAiczz+QuffOnHlm5sxznnXDoeAiwBava0ciwWlO0ajic8DjQvWW6G1hKte/aViNW3n/8wLB0MVfYvjjqyEZIEJZQKHB2BIzkDHoMnFlbmCpMnoBhn2ZSgU0BQKe4eTijEbjA5S9z0Lbek9dEL6NisFY/H6psbX+ejosJjiCtaykxYUQ8MkLC45lYFFYhnwB/f4tcaEMPc5iR99ZDyBv9BwAoeyz2rL1qC1bbzxmDdrFS7QpKiAQw2dKW2gSCD2/MRetjbAQcKQVYMDc3yGlaJT+wyhKkW7Ol77PsKpsMWVvSUCt6FkT0lE8+yEk9xoR8VhKlCUS1MfXZp/F9k5iGAbOrCKY7fGIywgf8K5uuswifcCl0cd0FsnKysIrr7yCr7/+GiUlJbj22msxePBg/O53v0NycjJef/11fP755xg9ejQee+yxTu+Occ65zzob7STamUqRvv5F5DpFsVqKpBUfw5lUD6Y0dl8YS1GADX3Xp1KKxIdEUExSRi+SUB8zgCECWMhvL/F4LCevcDlFSr7A+3XnzpptSOs3AUk9hsHf1oT6g98jc8g0nNz5he64P658Ggm5/dHj0jvUHwT3KU1WhBD429SVuqXGq8EvBofLh65zhIk2LqMHOLMNvG7VpZZNW91xuOurVMUblUhp1KFmveoXhzUxA353MzaVi1aXWpd4fQWGCylFmpdoewqtSfVHntnYAKdzInB8LcYXpUEAp2pUq0Rbq8hDjK0hfnf0lWW4StxKGXj8oXvL5SOwILZFAsNyqufM+PkNYymSlCKewMfYdNYxnVIU/Febkh/eUmSgFAUzb1gDSxEgWova6t1yH0Eh4AMftAiZWBYmjgXHiiU3tJZbADBL/dYQumekF7tUvLF662eGxzZCrcyQqOUIAopq7UpYk0V+RrXE2l5COScl9RgGd90xeFuCCn4Yiy9gbKVKKhwCc1wyTu/7TvcsKa3IaoVXk17fAeuXcoy83xtGYVPXUGvPs97zsvkgAh+xorXyuWNYFgzLwmRzIuBxder770woKSkJ2wGjq7tjXPCWouReI9B35gMhM3Onus8iW4ra0+ZD9T2poSbDqvYhHU8yq2uLNwpM6AFX1hwiwQd17cFanGhyh5WBR7IUEYKLmz7GgZVLcHLH52g6tlc8HsfKk7mJDbnPjIqCcRY7GIaB2R4PR2oe8sbMjViQsLlqv8FWSV6MXPdIW/VZaSliGEWfIoWJPBKS++BgTQu2HK0Xj6mZfMu/fhUAEAjzEpfrR0mjFngoJ1iL4kWmRAALb4DHi2sOYdNRtbLXnkJrkpUtQDiV2h0AE1YP11pNvMR4klUqPLzPbfiC007q8TnFaCi4HItX7pMVbaXrVvovMXKPatBdv3a0cJFeDgFBgIdz4mjSGDSYMxQ/08a7GVtUw72AjMt0iPIxhancnhonKiF+xgrCsADDyqnqkpFIshZFsxRJyqL0YnedOtzul57SUkTOxH3GcnprZ/BCx96+RmGlYRiDv42xJ2cjvf9E3b6k66aVidKKrKxXpp3P21V9PwxhLeAdKN4IiHKI2uJDFScnxWKGd1lfaFzwShHDMLAlZcqrqk61FEWLKdJN6MYzTs2eNXKwH6CwFLGcah/SA+YLPkOsxn3mV8SP+AzcZzXNXny8vTrsSlJ6gXEIII5vhq+1ETV7v5U/5zg2FFOkaHAp+uzV56acvDuKpEQyLBu2L5ZK0VJZikKrwUhwVtHS9NW+Gmw+2oBTzXrzsuSWCFu8UX14sQaKYrUWtjcZw2JPVTOWfPEjln+vLhgZa6E1IoTazfjBQfkiEUj4c9e6zzzhlCKPKzgeH/a+9wfsfff3UceU3n8i7vh3K17fUI5Xvjsi7kchO0FxnQCEVWoAvVuRCAKqt36GE9tWhb4TNaZIPHZN4hBUWPvrPpeQY4qijCESgYCkFBn/Ji0YVyQwHLY7L0HB+JvgD14nLnjPWIOFgowsRcoYIMkVonyx737rNzGPFVC3jgAhiNb7NZz7TCwSqGlLItXUidVlo72O7ah2nX3RDPXig2Hk6xauorWysKE4TvUzF27OiYS2aG3b6aP6L2mq7Z9pw14tWvcZELrX29P37XzlgleKJEI3RecpRZIFJdoxJaRJovn4Phz9boXcvVnrUpKUH61LRRq7NzhzMRolS1m1VxmkSTQTSt2BUsMOztIkzISxJJktDggQz0lZ0ZoIAX2gdZhVVruymUjIUmQOM0GpSu5L1ziGmCIJk1Wd6un1iz3OjKx64dxnykrj4gDULgbWbEVSj2G63wlg0dAmvkR5mFTVwWM1qSsnVIHhZKsgAAQiPP5a91mbEK5/mihHb3Ot/PfJHV9EjKdTXvs9VaIFTGll4wUGAT5670BAf/38bU2oLVuP0/vXKio4h7unxO1SexYzy0JQKsk6pUj8V2spirWlAgAE3OIzbRRoDQAJ9pBsTlkKkVgwSHZZSQsNyVKkdGcrSe8/EfbkbCTkDQAgxmF1FLad7jM+jPvMyFIkXd9Yg77VCxhNfE8M1a6Vx2cUQdPhKlprjyEtRnNHXQVnZi+k9ZsQ07iV5I6+VnU96g/rSwzoijl2dqVpA7l1xfvvXIUqRUHOzk2hnUyNzclHv1uB5uP7cHLH5xH3prVySCseXxiLhTLjzB9BKRL3pX8QpbgPJozPxZacDcKwEBgOZoX7TAioY4qKpv/C8PftJxRora0zZIjCRBxLTBEgdrxWvghafTz+7+tD+NU7O+RtkuIVTimS5mv5SEJANdlyZivyx16P0syb4eZC5yGAlZUvgWHV1yxGpUjVDR3ql3ekuHqtpchL2LDXTYyRCu27Zu8a1P24Iey+lfd9s0c8D6WlqKLBi9fWl2PVTtE6GklR1j5DSmUx9CyHUVaDY5aUTRPHQIB+FS0Rrs1HexqVSn3JwrnPEmwGAe1B2Ujuu0iWIkC0ivSZcb98X5psTgP3UXiUsTJcp7nPTGEXcTG7h1RB12r3WTRLkTgG5f3PyH9rlTJ50am5rpJSlNp3LHpN+blh8Hg0bIkZ6DvrwSiNcbVKUfiYK6mVSzgXvBEqOciWIuo+k6BKUZCQT/XsmQ+jNYQNeCL72vXZa+pAa6eVQ6Ld2GXmNQi0VmK0epN+Ey5jyRyXAgDgGZM8gcuB1kF6Tb47bJZZJJQvRkKIKpsp3EvTnpyj2YniwY8xpsiRXqiy0Ow70QwCBp/sqJa3SQqZ1288ocgBvMF/zbxbYymygWFZ+DmHygonMJwcxyXApFKKIq0eicDDdfIwhIBfFX9GGFYdUxThDadLyQ/wcKTlI2fELMPjaV0bnsZTYcepfDk2uwO6sXy66wQEAmw4GL2Kr+4ZMFCKjJ7p/nN+I78I/HJ2lyijcPs2yj4LfjPqOOVeZpLVJ4ylKNGuf1nygtpSFG8VvyOWV4gNVcJBFJQuOFVKPqBTiiYVpyPNGVIOwlpLWVbf71BqOxSje0inbOmUpMgoEyZYk1lWTLRKR7gFU2d2kdeXY1EeP3alKLfkauSOuhq9p90b+7FVliJO9S9ViqhSJNMdN0X0mKLID7p+5SXFFIn7GZCdgJtHF8JpDdVjAYCjta1yphMAlUsFAEoP1+LwSX39GSklnw3jPpOyrHjGJK+qeSIEX1T69PkwZ2W4VemuOrH1M+z/8Ak0VuwKfW5w3Qon3qbeszTJEUF+WUeLKUrpPQrm9CL5b45hdJY16Tq6wypF4r9xWeJ+bEKb6lJ/d6gBa36sAYHaCkfAyk02BYZVKbWRJuhTu7/Gka9fReWGt3SuVkkB3l7ZgOMN4Uvja91n8rEN5CWEzaIBeJ/+GMpA0Kbgi92veBGEitYJ2HmsETUtxjEnn+85gR9PuVTblMq8ZIHQ3huH67xYc6QVn+2qxp9W7cehGnEfZo5RWdO0z6fc0LcDliLJZSIrOGHS+I2UIsm1KD1fUj2j//33fpSdbMZL3x5GTUvktiPtKumgVNg1DUy1rsNfXlaELY9NwSV9xVo3AV6fiCDukoMzs5dqW3vdZyq3jzY9Poa6XXHphQCAhNz+SB9wSchSpFWKZEuR+vpHSnNvL0bB0BanuKjUu8/Cx1yZbE6k9h0TMUlFR8SYIqoUXfAp+RLdohRFKd4YbbLVuc/kmCJxP+agD0TurB18sc15aaP6dxrdeMexJmxfvQ8v91cXMPQEJPeZWkacxY6el80HYxHPh4cJ9mC9lTYvjyNfL5Mf+GgkFgxC/eHNMNsTwqZ71wZdM6FO8QxSikahsWKn/J3Ci2/Rd1VXWIoajoil9aOtoBmWRVz/qQBWB4+kR5pU3b7IlqKkXqMAfAUrcUMI7qnJ7cefV5ejxsIjPd6qssIRMGgNKkU8w8XsPpNq0DQf34fMwZMBhNwgteZcuLgkfFCVjF3v78IVYfbBabQiuTSAwQtPCHjDPjdGq1xlirTkPlNa47hgzIyJBLDxcBM+PnYIH1yl3ofLG8A9/9yGCU3VeGBskqKQaAhpkaB8yXj8PD7fcwJfVIdaK9iC7igTy6hiirQvRUkmRGcNiazos5xJvv8li1g4S1GCXRuMTNAUtKZZg4UbJcvMoRoXLv+/dQCA1ftO4sN7w1cjjmSZ0H1Xcd7q3+ndZ0PykgCEZBg2A5M1IT6nGKf3r5O3eVvq4Dp5KGb3mV7xaZ+lKG/s9cgadoU8L0jJK3pLUUB1vP7XPApP0yk4s4rQWWjLBHBmGwovvhUH//Oc7lnSji+553A0lG833E9Mx1bd4xqlqBOzr89VqKUoiHRzNB7d0YXH0FQljla8McrqR1+7Ru2KkKpKswwDL+uQX2z1rZpJwGDfza5W3TbJUqSNKcofex0cqXmwWzgsv3MUbhzbGwUpYir8qRYvvH5ernwcLZDamd0XRdN/gb6zHtB9FrZkQbBomRRYKm4zkJ3sNxfQUl0GAEiLIdbCx2sKBGqKXUqTVpuRpYgJzdcWRzwAwCq45QyrFo8fgWCpBD8vqK1wDIOWoFJEwKqC4yOZ1JWTHu8TLQiSG0RgOKxLvAq7nBdHOGPAbUlT/e2NYCni/QZKkZSpZTBO5Sq5xSOen1Lhk0oncCSoMDF6F2dbMMXSKrg11dlDCAaWIl9A0NVmklyUJo5VLRB0liLZ+qk5XpR7mjVZYA42mZaUPytr/PLRWoqO1Lai1uWFhWPRP1u0BqTG6a1M2yobI4+hPUqRypKgqKvD87Lr8OI+aXh3wVhZGbWbg0UnwxUwZTmYNRmn7voqHPl6GVwno/f1AqCvGaSxHEX9PWdSLZQkmWjvUW1MkdmRgPjsPu1LAolhLKpjBrzy+URTijIGXSb/vz1B/qHfGKTkU0uRDFWKgkg3hevUYbTWHO3UfduTc2BLzERuydWq7fqJSmMpYpiIMU66lWzQGuBXBI4CQHnmdKxLnI2bXv0ePR7Wd6MmYOVK1PLYBP3LTMp20brPOEWG1qXFGeiXm4p4mxmpTgsIASpVbpooLkGGgSMtXx9/AIR10UiTlSM1T7dN/b2QpUhyn9k1VbWN8Aqhx6S6ySMrha3BF7NUdVhb8RsQrWbSOUsZcjahDVP/shY/nmxGgCdywUuXJyArAhKSIsuDU738I7ocVK0ExKaSKnkaTe7BTX2uWIjMwVNwKnG44TiM3BSCkVIkfWZkKTJw5Shfpg1By4gpWFJCMDBoS+OxCJ6w7VWM3GcBgeiyMiVMbPhAa1tiJtjBc8X96XSiaG5uM1iTGfnjbpAVKgsxdololaKNh8SsvosKk2ALKh5p8e0P8G2P+0zZKkTJyl0n5P/3y4pHSc+Q9VcaW0AQjJ89lgurmLlORm9MC+jjm9THab/CIskk1piizkSXiacsmKuZ50JZlCLWhHRkDZ2OvNHXdkxRM3CfqeItL3CoUhREqWAoe6F1BomFQ9B31gM6F1IsbT4Orvq/sPuVbuiCCTcjPrsPModMBQBIBgupgKInvhB+Vt9rTLEjrE6+ST0Ww+wz40Brbdq6VPAtM0H8t6lNsa8zWG2FVQQ0q53gxrDfI0QImchjMD97BPW+2GBRzFYvL9cBChdkrVQ2rcGXDUt4eH1efFN2Gp4AL5dKCBekKu3HH+iApSgYXGrUa06CY0TrzMNX9IM9JReZQ6boSiaELEWxuc8Y2VIUOdAaEF8ISreLFOwcyVKkrIAdzlIkB/AqXjI+Pvykb+LUiwP1/URgSi/G+sTZaLVqU9yjW4oA0e0hKX/mMEpRgl0tm6N14oJCshIBxpaiaLTHfZbUczjSiseh8OJbVNvXHwrNi/mjr1F9JilFfNhAay7ssxary0Z5D4v3f/vcZ7oxhbEUyTFFXakUGV6PoKVIo3UbKSoZgyYZtzSJ5dgR3GedWbz4XIXGFAVRauOqflmdQPg2B/o2H6pVracVnqbwGTjSDZ1UOARJhUPk7X5Ntoo5hsqrAqMx5xo0FPTKMUUapUgTlyOlh0r1VPzRKr7FCOEDgEEarFwHSBkLYRSPpZgMpIknFreCV+M+YyEAhMDlDSA9aIBRuc4YyEY/XhG4a7KY0colwia0ygG9bh8vVwGPhMBw6tpSEWKKlOduaCnSkGLncO2YIgy9pHfoHDXic3kDON3ihSmM+4zTKV3h3Wda2ny8ylIkubAki44kqwAv4D97TqKkZ0qoujrC318h95niu4HwiqdZaylS3E+EEJg4Bi2mFPgZM1QlHGNwn0lIim+4Z1Kbku8KuhclpQOAqilsrLTHfcZyZuxzjEYvexyUNiPpud8TNxbpxWNVv5HGV17biuIWD7S2pkiWolhfxMrf835Pu91n4fYXNqaoHaUWOnpsFZ3onouIQT856V73uRqMfnFBQS1FQaTKvADgbqju1NT8cAHDRiZU5cq6ow+ltHI2sQwYhoXZ3H6/M+/Xv8ykF5G2eKPWCiHFDlhM4sOnrJt0Jn75ugOlYT7RK0VGq/eOdu92a5UiwmOE6xsc+/KvcnaVW/GSVmYwKVO8WYbBhsRZ+C5pDgiAlDgz3D5eVVRT3ofGOiJAHWjN+72qe1ZzVqHf+aWYovBKEcPoG5Q2tOqVrqc+LzOcuCvXvxl2LEZKkdYi5vIGVNu02X2SpWhFaQUWvrUdV7+4Qc702xo/GUjpZVhDych9FklB51hGdb2UmqEtMUOOnwloLIfR7mllTZrj2dPRZEoDV3SZ4Xe1gdauoItW2Qg2vYvdZ3uqW3DXii247C/fGX6uvTeBUExRfasfy9aVGxzfoM1HkFjbG6nGEPCpFYsOWHXkitbaGB7JIt2l7jO9DDszZinWY8vZZ8F/T+3+KmrR4fMdqhQF4b2hwOJTu1bjxPZVEb7dPsLFrRj1bVKmWsecqqrBJ9Vd4RiwJrNqQtXy31P7Gk6yRmmgUiaU1n2mfZilFh5mjkWtOUfTo6njD/6p3V/B23xa/4FsKVJUrDVSKDXbGIYxnJy0eDTWBY4EkOE7Bk/jKbgbxDgLN6+wQikeq1Y25PbgGAY8Y4aXdcgvX7efD8YdqfEzaheJmJKvHse+D/4XbbWVut8aWooiuM8YRn8vVjW65f+P7ZUKAKiobwvrUji9L8wLVGPRssQl6xQTlzcQsZgoH7RifrnvJADgRJNHdp/VWPKBwTcYpiS31pSDEKILtA6H02rSxBRxKLr8l0jpPQq5JdfIL36fRimK9vJUuiKrzYXYmDgL8cnpYcfw1NyQ1VeyFEkFGwHxevx6enHEY0YagxFKF/iBGmMFN8EqXoe5F+XpPouzaguD6qt+h1vkhbMmDpj7u7DjFfxe1YKmIwpFOJeidL90pfvMWBGMfg4FE24+42NHqlMEQE6KuVChSlEQ7UpXSms+U7KHz0BaP+NMH6PYCuUEYeTCioWA0lLEmiKa268enosFE3vpthtNVFJgcbg6RRJSoKaFY3HUNqDT3GeAsXnXyH1mNMHsPe3Hh9uqcDpY04VhTaoJYuOhWlz1wnrsqWpCi8eP618uxbJ1R8JWDvbxBLzPjcr6VqzaF4q3UKZ1V9j6I614HHpeNl/VZLWVS8Q2vgiftvQztL74GbWiygctRXurmvDx9io5hql6y6f6gRlmn4W3FLEI/wLITbLjvsl9AABbKxpw/zs7UH5a/9KUlC8JyQWhvY8szhSdC6vVG1C7zzTykCxvyvfIL9/cLv//7hVbcELRk67F48eH246j9LtVaKrYpYpZ8UW4F+M0ShGAYLPia2GyOeUyE15NDFNUS5HCfdYcVHKM6hFJXD8yX05xl+pUKRc2DMPgF5OKMK53asTjqsaoeDaM7gVlcLWyXIDy5S0FtE/qp1fonFblXMbg7U2V8AXd7TuPNeKXb++UF1VawilFJmv4MAbe74nYwT4Wwi0UfC3is9yV7rOOxO6k979YFSbRYSLFFAGRq21fAFClKEgsUfeEEDQc2apqzhoJzmJH+oCJ4ft8aVbnvM+No98uD/3tj7FRogafItCa4UxIiQtvbk+PtyLOarBiCvjkVXZt2QZ4m0/LEzQDAUUZ4ev7mIMxRWYTCx9rVStFZ2giNi5kZqAUGRznf9Y2ocblw3/2iBYHrVJ687IfsPN4E3729814Z/MxbDpaj//99364fbzuRQ2Irhje24p/7zopWzPyk+2qF6vAsMgZORvx2X10v98fNxrl9kGG5+ln1ddMiilae7AWJ5o82HW8CQAM70VVGnVQWYkUaG1i9ffiLaMLAABPzR0iNynlBYKyUy58vveUbh/aF21D+XZUrn8Lfk0PvbR+43WKidZ9plVMjNw1TZpqzn9ZfUj+f+nhOpxq9mL1vlNoKN8Ws/sszmpSu8802aCOoFJUYekrfj+9R/CTdihFwXFHUooAyK66kKVIL4No+1CitKqk9B6FuPRCVeKHWdEmQrmGalPU3pKUIpOBsqCcQ3ysDU3uAMpOirGUGw/XYfvxZry75VjM442G4PeqlaIOzCtmRwIS8/XPn681uPA6S5aipMKh6D31nujn0EnjUS2ADJJUolkVz3dooHWQwom3o3zN62E/FwJ+1Jatw8mdXwIABt/8p+ipuFFcM0afK91DHbEUEUJUKfksZ8aYghS8tUnvZtny2BTYzJyhUsQRP1buOoEh/F7U7VmNqgY3jpy+HADwx6sHIL3yKACxRpEWsz0eWUOn4eSxBviqAp1qKfIbBq2L52vkK9d/k0WrN1haIMyKqNblRenhkOXH5Q1gc/w0OPlGDGj9Qd7uCwhy015JKcpNtmPa8Gx8X3YMe6ubdRafWIlz6JVOSY6EYRAQBNS3+mA1sep0XkBjKRKVIp4Nn7HktLC6e3HxVYNw/+Q+yEiwqepaSa5Blzegsg4YtWpQFtNM6T0SzUkD0eLsAUarFHkC6uwzjVLEMybsOt4oWyqNaPLwQNCwoIxh8/IE1Q2tSOR4NLsDEQOt4216S5ESSSmqZrPR76orQ9aVGFLy5XEGlaIEW+SpV7IMSQsRq4EL3KhPWjiU8Tec1QH3wJvhaCiDb+dHADRp+AorRpPbL88PUmaZ2awfu9Nmwk7nRGT4j+GAfRguafwIHj+PmmZxDiNgw2amdQQh4FU9vx11daUUjULTsT2Gn3Wl+0wp44IJYuZvNLdVR2oSGe9Hn5Kv2naBW4qoUhQkPqcvkgqHqFpHKKne8inqD2+W//Y2nzbsPt3jkttx9LsVAKLfxNEyQjpiKfIGBDkmw8SyYE1mjA1jZpdSe+MNlCIL8eC+t7bj7oTvEec+jR9PuoDgbnISrAgwDJyZvZHca4ThvjMGXYYUZz34Nd+o4jjONJjQKJNPjgGIln0GMV5FGkGkNOWvy0JZf4dPt6LOnI16U6ZKKfL4ebnBpxQsbTdzcFhMaCmYgiMNB9HExe7iUJKVmQEoKkOwhJfl6GPscPt4vLNZXHmPvoNXnYvaUiQGggfaqRRxLIOMYEmFJLsZLCP1/BL3/UZpBX4+sVeotYvGfabFw9gxY/kRAEfw7UOXqj5r9QUUV0XvPuPBYfYL4RvMAoBZ4fKxKLrZLv2uHG01R2EWxGcpyRF+wo+zcLJC5jDr71N7sGK728errCyxus8CvCArObFaiiRF0MgFnhjhXLQo4+2ON/ow54316M8ew5PBovXKhsoehfLZ7PEjB3YIApEtRWZtt2CI7rNqay9UW0VX/Nqka7Cr7jSGVIhhCAJYY4t0BxH4gNqi0cF5xZpgHNsFdK37zDiRJ1oNt04aT1T32YWtFlD3mYJIGRpKhQgAmip3676TO+oqVVXl6DdX5IegI4W0PH5eoRSJ55QRb8PvZg2Q+xPJRw9OJEaTlU0QX6Y1jS5U1Kn7V0mL3GiThtNmAs+YNHVkzlApMmiSKytFnDquwQilJSBW3/mBU+IxiWZSOtnsRUtzozguSSmycAAhcKcNxo+OEbrJ+rezBmD+hJ6qbUPyQqv0+tzJKOxVjIf/6+cYqtjexiXIsU2EYVT9wPxerUUxdEzJkhVgwt+LRkqREpZlZBesMgha2W8rmlJU5wndA1rXl8vLawKto7vPtJhMZvl+Vrb8qGzwqGLgGtvClzJw2sxYPq8EPQsK0D8rHtbETNXnDinQmhcQUFm7Yss+k6p3A/osMy3mYOam7D4zUIriLEpFOOLuVM/G9qDrtdEdkN04yvgajy8kI6nGmI8X5LM0c/rroRwLIMbMedhQTJDAsLrWMWfKmQZaA5ArjRvuv5MsM8a032rWWUpaNPfZhW4pokqRAn2D1fBun5o93+jTkDUvzWgPFWd1IC69B6zxaRG/p/pNhNgQQEybJ2DAMuLLTFpNzZvQE/+YV4LL+umtW9rMEUC0FDFEQJ3LraoJA4RW0dHOL85iAg8T2ny83HSzvew41oANh2ohTSL+Nn15AyNLkfSWeG19OZ758kd58lcqNidb/Ljnja04YhA4rGRvtXFJhWP1bXj6MzHgV1KKpNpQ4abo+RN64rezQorzuN6pqpf4O7+/Bw8/8r+Id8bj8atD8Q5e1oFvHDPxbdK1ACEqJeL3H23FPzYeDZ26YvKULFl+EkkpYoAo1zI5aJVQWnEqvU5kDZ0mbjfIpnF5A/hy70kcrGnBktWhNO2rXlRbfVyegMq1oss+i8GgzbKsPJkrLRmiZTA2963TyuHS4gw8+PCfkTFhvm5RIwVaA8CVL2zA6n3B2KoYLUWSMhhn4Qx7tSkJpf8HK2AbKEXKbVzUsgChc5EMtwLDyDFDymrRSkuR3LCXF+RK7kZjjzd0ByqvAxe2wGl7SO4pVlpPKhx6xin54s8i/K4rY4oM3i3asWjn+k5T0owa6TLtXyyer1ClSIF2EpSqARvdwETgdenhWvNmtNogDMOg19QF6DV1QUzjK7z4lqhBcG4/DwKxSjGg6XINffdzAIi3ivvc7RwPr7S6I0HFyMBaZWL0MTxGOK0mgGEgMFzMLxAlvEBQergeu443oSG4YjWqh2PoPmNYeAM8Hv9sH5775hBKj4j+el62mBD844cqfL73JOYt36zdZVRaTGLZAeKTLDHBqsVBi8r0QVkAgMyEyDFFVhOLW8eIQc3TB6otE3ZNcG01nwg3Fw8GonVF4t/bK/A/n+6Vm6salXI42WqsGNjMbDBLMfK1LM4S+7YpFZYjdR7d/aVk3YHTOHy6FV/tq8FJV/h4oFZvQI6D0x4DiM1S1Ozxy5O5MnSFgNX16guHZDFlWNbw2VVaa/afaMb/fXUAgNr1ZIT0zErXJ5qVCICujIbVpJeBkRsrHMrzqXVJVkZGHpMyUN6jqMslZcspXeBGSpGRtVl5HQWGlWtLnQm5JXPQ45LbkTfmWnUJjjNwyxdNvxdZQ6frtndpTFEM9ySnzb7rgkBro5T8Cz3QmipFCrQvhurNn8Df1hzKRtAQLeYnFs2eYZiYH+jEgsFRHwyxfgsjm6oj9wsSkSxFx6198E3y9fCy4gRpFdrAwmAiC7ojolqKpABNRj15nWr2xBR87VKk8Hp8PDx+3rAQZjhLkTJA+MtgxpRkdfAGBLT4xInpqMY9GIlvk+ZiQ+IsuLgkAICVeDCxbxp+f/Uw3FiSHwzGJRjXOw2r7rsYXz14ScT92cwcrhqai4/uHYe/3jhc95kx6gnVFGyH8dGWSjRXlYH36s9nU4VxVXXpRR/tWv752iF47Y6RKtdWZYMXPhL+flS6i/gI7juXNyC7o+IsnM5NadTmQ0uzJxRjosxkYyHoio2Gwxkl5kX77EhWlKyh0xGf3SdsDRk3z6KxzYeNweD9WLLGtJYhI0uRUjkJCAR7q5t0FrvTLV54/LzCCkGwraIh+D8WzcE+c6zZhpwRVyKxYDAaHCH37sEa8b7xBS1FLAMwBisrI2uzciQCWJ3FOWfElbrfRIM1mZGQNwCsyaJ5eXdcKXKkFSBj0CTd9u6OKdJmdHZWcUdVULVBTBF1n1FktKvDxoqdqFj3TwTCVKT2tdQabpdqSRg9aGEOHPUrPSfNC3418gvCHYwpClmK1AG2aU79yl67ypOsRVbBLff5AiAXijFUQgyQJnJlxeayky0Y/cev8V//3Brxt0AofRkAPt5Rjb9vOAp3q3gt0vuHaj+FsxTVuUJK0b93n1CNRWyvoT7vSCvvEYWiZcjNOdFsSkNeqmg5YYiAAdkJyE9PRrJDLesBOQmIj5IhlJlgA8syGF6QrFOCwitFakY3f47BrvVY8d472PrZK7LLTMn3FcYuQunFGm1V7LSaMLl/pupF5ycMyk6Hz5A0KeQZKQvPpahTNK4oTW8pisF91uz2y5M5r1C4TYoGu9EsTtGUIi0NQaXbZItDz8vmG9aQIYTg9uXbMGzxavz5P2UAYrMUaa0xRjFFWuVq5nPr8fqGo/LfxxvaMOqJr3Dj376Xt+2tapYtRURpKTLbkNZvPAovvgVtigy9V747gupGt5y1xzJQBcWHxheSbW6S+DJnFXeLwHA6S5HJHq/6u2C8uv9iNFTzdVdUg+5CS1HOSFEhzBioeEcwkZWijlT+NiRaSj4NtKZIGL3k22or5QJ4Wqq3fma4PX/8Teh/zSOqoOuIx9U8DD0vm6/6OzF/IOJz+ga/G4ulCLKlSFuf5r+n9UVJzxQ8c/1QeZvNzOFn43rIf4csRW5w4GG3cMhIsIJDACwJhPpuxTBp3DAyXy6+JxCCN38QSwN8tT98TzcJacJW0tjm051XOEvRaVfIklcvud+CipDbz8NmVSsxSpeFzcxiSv8M/HJSEWYNycbFfdRxX1MH5aEg1YGJfdPAMIzOIheNp64dgpKeKbh/sr5+kXIMRhi5g/K8h9DTsw9H6/QKEcMwOFhrHAjtihezhdIUSmYkHp05ENmJNmQn2iAwHI41hXeLEWsoUFwZdKulsc0nW3eS7GZMH5SN/tnxGJgjVqnmg/fZDSPz5bR4Lc1ufyjLS2EpMpGQYhzJWgUYu4Ai0erj4fZFdgn5eAFtvPo6SjWgIqFV0I0sRTMGZ2OiJnni8z2hTvb/Dna133GsUd52ojk0lxEw8viV96/2nL798bTYSJeIlqJoCkhIWVP3s/NolKJw4QqxorQUdUWLjK50nzmzijDohsXIGhZy22ndsNqYItLBDgdaVO4zRr8oopYiiky4FO32PqwMw6jrfkT9gSbATms2jSHVHAC2VtTjd5/sBWFCliJO00A1zWnFuwvGYo6mVP/vZw+U/+9lxOPbSBs4EkBuog0mloFZ8GJC06dyraZY3INPXDNIVkR8AUGOUQCAX7+3E4tX7sPpFmM3pNL9IiG977goShHDMCpLkYTUfNXj4+GwhmTT5PaDVUysf5g9EMvuGIWHphfjhZsv0gWyxtmsmDk4GwNzxOusjK2JZUV3/ah8vLtgLJIjdDwPZykyUopG90oBQwRUNYSUnzZvAN8dOI01hxpkpVDLydwrkDx2HpxZRVHHDAAzh+Ti6uG5yEywgoDFCZf6RSctBE40uXGgITRONxc+7qbW5ZPdZyaOwT2X9sWlxRnyC19gTOBYBk/OHYJ9iy/HvPEh984vJ4njbnL7wbAcal1elTs0ORBSvpXNeSWyE0P3kTNK7SDjsUd2ofsCgipQ/M27RuOqYblR96u1FIULtF4xr0S1bfPRBnyyowqAuvCipJC0BK2vUusWtz/kPpNoCwZa904Xa2U9+tFuVNS1Bd1nTFSlKMEejM0iBA4Lh5KeySBg8NX+U9hUXi+3ANFmjyUWDI5YeV2L2rLfBUpRV1a0ht6KzzAM+lxxX9jjG9UC6whG7jPVuKhSRJEI95LXFlHs7FWJ9uHQK0Whhz8us3dwm36s175UGszyYiDNqZECYcMhWYri+GawhEdBahyKMpzI8lcgyxx64cSiFJk4FiazeH7egKBSdN7behyvbyjH4s/2Gf5WGRMkuT68Af3KVlKKtNkodQYvrHiHeG5tfh684vavanDDEwi9RIYXJKt+p607RzSuVtbcsSKNkYiWoaSkZ2ocTPCrFMx9J5qxr7oZO6pERckolsVmMYG16gtFhiV478fbzOAZDlXN6olaWu1+vL1alanGGzS9lah1eUMFR1lWN1Hz4GBTKAVK5aUgxQGWEa1DLj+LtQc0vfGC183LOgzHMCw/Sf6/Nq08Fupa1Yp39vArRMth8H7w+gWVhSrVwH1thNZdZuQ+C8efVoluOmXpg/pWH5J7jUCtz4wqSy8ML0gCBz/cPlEZVS6eJGVqxuBQz8blG48CwZiiaFwxSPwdAwFmjoGJZUEYFsfq3dha0RBarCgWDwOvXwyT1YFek++CI61ArPAchc6oUxQJ40KxXYuysrgtKUuVmaxsFn5GGLjPlOVfaKA1RSacL1XrPuts86JWydKtIBTjyh5+BbKGXY6+Mx8Iuz8CBjaTcaB1LEhKUR45gRmDs1Cc5cSA7AQ8OMSHOcNDq9xYzcuW4Bi8fl5lKZLYU9Wk2+bnBZwINiUNMGYctA8T9xHMgpGUPUII/H5xsmBYDoQQtHkDaPXxuhcWABSki5adxjY/mhQfn2rxyPWUXrz5IvTNVMc78Brrj6BRiqKVSuhMGkz6sgoOCwcQsZqztBKXYrKkl3JBit6FFc5FFw7pmifYTQgwFp37zBKXhB6X3IHvEy4HR/TXOsOg+XCdxlKkvf95xhzWajauKBWDcsVruvdUq6p+k5It8ZcZBmzbLRw++K9x+OQX4ztUR+dEo9otmT7gEgy68X8Rl9ELhBA0uv2q46Y6w1sGlWirVUfqXyjRM01UbmtdXggCwT5FKYk6lw9pI+bgM8ccBFgrhhckw0QCslVIucCRlKKxvVNxUUESALH8BCBmtYZ77tf9v0l47Y6RuGFUvrhPEAhEHVsGhP5WNguWXsT2lFwUTb8XcRk9op5vZ2WfhcORmt/p+4yGckEsBPzoO+tB+e9OsxQZuM+U/QG7MpbqXODCPnsN4VLote6zrn5YtMqZ8m/WZEHGwEthTVDHuGjjACSlqCOWIin+I80moDA1DoCYIdfD6oJDEXcRa90MS9BN5Q0Icmq9EqPA013HG+V2DYRh5Re7L5jBIil7H2+vwvNflYkWJIbFh9uq8I/SCly65Bs5pkJJRlJ8cP9NcCmGcuffQ2n5k/vrlQ6tS0xrYlZZijorINKAwlQHdseNQ7l9IE5ZCuXtypemNygjSQGV3Jf5KXrXRKzB3DIKS5GfsaKqyQ+AoPRwLZatO4KqJh+YtCI0mLMgGMTwTB+Ypdvm9vOyBdHMsarYigBjhsBwqnFKcWUAkJfskCu2r9pbK4t+X9zo0P6DwfGH7GIgtFR1GRAv1YjCZAxVWIzaw3/9axue+Lfa0smwHMAw+HBbFVbvO6WyUGmD8cOhfSaMUvK1zB6aA0C0mq0oPYpNR0NtI2pbvTjW0AbCsIi3mdArPQ4s4XUZYYDodgUAh8UkKzjVTR4wgMrFrCU/xYHJ/TPla8WAwOPn5dpdElIRzPjsPrDEJXe4yalWeT5TpBpIRdPvRZ8r7oM9JadT9x8LSuUu4G1VWU2NSm108CCh/0r7VyhFXaFgnktQpUhBNPdZfHYf5I2eE3MAdXtQKT5mm+rGjEX5ON4QcmuJliI2uK+Ouc/ibSZMKtYrB0piVYqsNnEFe9rlNYxtMeoDtfFQnepvqQCfN2hRYM02BHgBJ5u9aGzz4sBJFw6edsuWggAvoEqzimcAJMSFrCWBMC4dI1eFoFB0BucmYnC+un2HOnara5Si/BQ7HrmiH3ysHWWOUcjtWQynlcPUAZlgGEYet+RilALVecaMOAuHmYNzcN9lRbJFAQBsMbxslciWIpsJfsaCuoAVbp+AHcea4OcJ3t9WhWP1otz3OMagjYvHDudE+fcBgaiCiCVL1clgADDHMiqlyBe0WiotWreP7YHcJDt+FyyCOTyo0DQrLH8uLhTTV2cS3TmnLD2wJvk67Iy7GL+dNQB5yXY8MKVvu87/6euGIifRplKiXl1XrvueYE+X70Wl+yxWa5ReKQo/Vd81oSeKMpyYN6Gn/Cxpx1Tn8qGmWRxPVoINaU4rTlh6okmwIb7nSMX3vKhuEq9FXrIdqcG6W75AqChspPY4SlxcIvw8gUnhBv7RORoWE4vMwZPBmiwovur/hS1lEA17Si6cWUVI7nlRh36vJW/s9Rh0w2I40gq6RSGSkOJRE3L7qbZbFK61M8GoTlGkQsUXGhd27p0O/cuMYRjZfebM7ouUohLUH94S8+9jheHMQHAlwDAMOGucXKgwWhFIADjWoKxNo3CfdcCtU5CVgVuzFVYIZ4phs8KYK6wm9wAqt+KHI/VAUmw/2XC4FskAMhKsOO5i5LYjkhVEAIdN5eKYWMLD5Q3gdx/vhBQuLAUjh3p2iT2xrDZF5V7WOJbGaKWkLKu0cuEENBxRlxRQvshjuV7t5faxhVh81SDsPxFyidx05Sz0JQPQVluJxoqdsJhYeAMCvAEBvCDIjW8fmz0Ugy4Xm/nOHJKNB6cVo8fD/wbQAfdZcGXJsSycTicEnsPBnrcBGx8HAPx4qhUvrDkIAGgxpeC7pGtVvxcEApuZgz94r6c5rTje4MbJ4IvYzIr3voQ/qLgqLUVFGU5sePgy+e+8ZL1bUHlt68zZuu3zJ/TUtVuJhbkj8jB3RB5eXHMIOxVZXVWNbnxTVoMbR+XDzLHwZw5WnEP7LRra+C9tMUclj80agMeC/09zWtHsCcgLggHZCdh3ohnLN5ZjTM9U+TsJNhMYsxVrkq5D5okC9NtQjpE9UvDk52I8Ur+seKQ5rUhTuDsP2Icjzn4Scek9YjqHVi4JmxOm4pqxY4GPxKzT1vRhGDCnRE7HPxOrBMOy6DX5rg7/Xrc/hgHTydanjtDnivvgaTqFuAzx/uw1+W40H9+LtH6xZYhGxaB5NImxlteFALUURYEQItd9kRSMsGbbM/DFal1mJsWLIZaVmbKNBgFg46SU/NgtRXHBdOdRfUPuweIr/ztsG5JYszOs6aG0c6O0aG0vLLePx7aKRvH4mfEgYOU4Gl/QCvLxvmbsDPZwauMS8P7W4zhYIypOGQlWOeNncG7IYmDmgIxERePLCGniWgYE08MllHFllrhkmGxOFEy4GWZ7PAovuT3m/cbKoGCWm9KCMKJ3BtL6jUdq3zEAoLIUSa4zC8fIweVGtN9tFJpQ05PEMb27K1TctKGlFat2n4x4vMuDLrS8ZLtcN+tEk/gSN3GsKq5C6rOlTT1Xkh+MleIUhUY9rAM9UsXt9WaxUviU/uK/0TrUx0K+Jj5rztIN+O3He/DHVfsBAE2CA5sSpmFL/JSIQebhUCpFZo4BG6OFSRmzlBJnkUtJ7KlqxrL1ovUoLd4KhmHEekIMg7c3H8PvV+7DrOfXY91BsfbahCLxd6mK7MhaSy5OpIyNaTE0bYAo6x5FgxCXGlJKU+OsMDsSLngXTSRMtjg4M3vJMnJm9UbOyNmdFgAtFgzWpOJTpUiGWooUKONGTDanbKlxnTwEIBTHQni9C8iWmNlh3zigD9422ZxAk1iFOZZJqPRwyN3UbEqBzSymIrfHUvSf+ydi9f5TuLmkAP7TPwPhA7AmpIdtYxCrpWhoz3QsSbgcVqENvClOl8qlVYq2VjTAxws4nTEeA3NOwDvgOuzbKWArGNjy8nH3rBL87d/HUZo4A4WeMpQ5RuJkeR3AMNjlnIAnZvTBP1aHigFKypOFYzC4MA11/TOw81hjWEuREbMGZ6PJ7ZddNUol1p4qljdIKhyCxILBnTrhf/6ri7GpvB7XjhCPkZtkx7M3DEVGvE2OM5GaWkpKkS9A0BJ0ncXbzYbB9p8tnIDtxxoxa3AWdu48FfN4lIpwRkoiUAfsqnYhF0BWghXF/dLQltsLK3dW40TQ+nP/5D6Is3KwmjjcMCofs4floDgrHlcMzsYfV+3HjmONqA1mJHGsusL7vZN6Y2LmgIi1fSQFQllolGfMmH3t7fh4xwl4DovX+bGZ/TG2dyqmGMSMtRdt0PqpoGvq7xuO4n+uHIg6lxd1ZrULJlp1cyVKxS2SlUiLsjhrUbpTl0UJhBSdv1w/FDe/+oOcvKDk3mCpA21geKxJcEvmDkXJ1mO4cmiOyrUfa6A5pYthGIAoLL+W2BeI5ztnVSmqq6vDb3/7W2zatAkcx2H27NlYtGgRTKafiG6mUIr6X/MoXnn85zjR5MGsIdk42ezBwpc2w5RWhxWzQxPNsfo2fHfgNK6+/yH0jWJ65QWCn68QXW+v3j4Sr28ox5IvfsSIwmQUH6uGzd8gr6KVikikCqN7qppwx+ubVJlWR2yDkFBgQ0pRT13V2EgUpDpkl4Jd4c+2p+ahoXwbAMCakC73fItVKRrfOw2PmMXzevHG4fjFm9tUnze7/ahudGPuSxtR0+KV43cKhl6KwdcOwlDOhJS8Ktz/thcfHQFubxJfgo2mDDQ6xRfc8WB9nmuvuBxDxvQEVq8GAIzqkYyXgsexcgxACPpmxqO2xQtPW+wTAcsyuG1MyKWorEOlrPHT2SvgflkJ6JeltlJdM1xdY0oai9XMosmUCm+Ah4fYwDMmxNttSMgfBC2DchMxKDcRPN/eflSh88tKSQIQSlu+pDgDfYdnImdkf4wsTMbP3xBdjNeNzFO5uJxWE+66WAx2zte4vrRFC1OdtpjdXCx4mDhGro6dO3gibivy45Un1wAAUpyWDrnMjMhPDm99e/Sj3XKRUomSnikoyojcI02J0lJkbUcwvFLpyEuxy/WIlKQFvzOiMAUv3HwR7l6hDgdYMncIUoKKk8NigsPCyRlpsfZbS3SY5WusrOVkVFGfcvZhGBYEvOzdSOs3Hu7644ZzRXfQnbrCWXWf/epXv4LD4cC6devw/vvvo7S0FMuXLz+bQ4gZd0DAjqoW1LR4ceBUC/adaEa934LDp1uxqSUFaf0mwJ6cg3/vPoEWTwDz/hG9qei+6mZ8XVaDr8tqgn7+o/AGBGw8XIcDpz04Wtsm1+ZRx6iEnxQ/2HZcVoj6ZDhRmOrAoLxkJBdPRM7I2Z3yknakhVbpyqDGWMvO5wcn57xkOy4pTsfiqwbCzDF4+jqxqnazJ4DPdlWjusmDgCCm8XIsg6uG5coK4dC8JHl/H2w7bpjaDwB5KQ4kO8wY1SMZRRlOjOudhkeu6AcLx+CXoxLB+0XlaWh+Ehw2Oy4tTkeSw4yL+6Qh3mrC9SPzDPerxZ6Si8KJt6HHJXcgpagk+g+6EGm1ZzVxaDalon7of6G86A58m3QtfKN+oQvY7IxjAUDP7NAL12HhkBJnhhAQ70VlLSFHhPo/2ow4k7ZTeIzF/B6c2hdWluDqYblIjjOjf3YCnBYTshPt6JUeh35Z8YhvZ8XqSKTEWTAkz7hAq1YhsnAsFl3evmuQ6AgpRTlJsVt7C1NC1s/8ZAcSHWbMVNQbAtS1krTyT3aYMamf2pKmtIppM8lioUdqHNKDsUlGShrl7CM9V8qQkMKJt8kZeN1Nd+oKZ81EU1FRgU2bNmHt2rWw2+3Iz8/HvffeiyVLluCuuzovWK69uH08Vu0+AZc3AOZ0LUzBmjmffnkAm+KnIYGvh8fSA1X8SbQEm4C+s+U4mgcNAizZIGQdvKwDHr+Af2w8GvFYWypCsRf/99VB2boBAGWOEShp/hJrWwtRufEo2GMt4IJj2WmvgVBrvO+v9ouujz/PGYzrRuZDIAREELB7184OSkSPPTkbZnsCCBGQ1m88Tu78AgDgb9PXFzKCYRi8efdo+f+3j+2BG0blQxCAh97bCV4g+GCrWIX3gSl9cWNJPuwWTlWrpUdaHP564zDc//YOfLO/RtXKQUl+sgMMw+C9e8aBEAKGYbDgkt64bUwB9u/ZBUe66NKId9ix5bdTVK4JHy+0y1WRmD8w+pfOEun9J8JU8TkO2YeitNKNJrcfPtaOvAy9++RMUGaplBTlADgKALBkFgPwIqWPGN+klGO41hyA3lIkWRXyx16H0/u+i7lp6H2T++BUxmyc2rUaN47pjcXXjZfjcL781cR2NV6OBYZh8NG94yEQgosWr0aL11hJnzUkG3+5fmhMKfVKlPf+5QZlDMIhlScAQsrUCzcPR9vyANb8KFp4ldYapfx/Pb0Y8yf01JVpGNs7FWUnRYtgO+PyAYjtU9YvmgS3j0dSjCUJKF1LwYSb4He3wOxIiP7ls0x36wpnTSk6ePAgkpKSkJmZKW/r3bs3qqur0dzcjIQE9cXx+Xzw+UIuIalAn3KbZPr3+XzguHbWWwny3uZj+NN/fgQAMITHkJY4NJoyUNF8FLBnw41snKoDYOkNaU21s7IBOytFBceeNhc+xgY7y+DPq4wrMyuxB7PCNhyskf8PAG2mXGyw3gR/nRVYtQ/ZnloMCjac3Xm6CjXW8EF2DjODS/ukgA9WPO0MuWgpnPJfAAgCApAxfBZq932LhB4jVNejPTAAWEKQ4jDB7eNRWeeC3cTgsr4pSLaxAIhu3xN6JsFpYdHQKr44lfKTyE00G46JCVZsNcVnoPCyu2GOSwYj8PArKrkygOrvc4nUQVPANfYG881hbD0qxpfZTQzyk6wRr1F775WAQOTfJDvt8jXIH3cTikoyYbLFwefzIdHKyJ8xQgC+MD3CchJMqusYZ2Lg8/kQlzcYcXmD5bHFQmLRWBDOCmd2Hwh8ANpDxnpl2yuTW0bn4R8bKwAAJT2SseloaPHTI8UGRuDDnn844kyh+3tycVrMMuidapN/l+kMPQtFaXZ8f1jcnmrn5O1mJnScfhkOsEQ/1nE9k/D2D8H6VBamQ/MKA8Bhiv1anit0xVx7NjAn5cKc1DXXw0gm0nFaW1tVx7RYLLBY1Ipye3WFzoYhndZ6NzKffPIJnn32WXz77bfytsrKSkydOhXfffcdsrLUq6Hnn38eL7zwgvx3cnIyXnzxxbMx1J8ERAjAc3wniN8De8/RXZLmTaF0BO+pMjCcBZa0XtG/TKFQKEHmz58PtzvkIfnlL3+JhQsXqr7TXl2hszlrb1qHw6ESBgD577g4fRbQggULcOedd8p/+/1+HDlyBMXFxbJmyfM89u3bhwEDBpxTWnrMDO2Yf/e8l0sHoDIxpkNyGTw4+nfOYei9YgyVix4qEz1GMvH5fPjxxx+xZs0amM2KciYWvTu1vbpCZ3PWlKI+ffqgsbERtbW1SEsTa2AcPnwYWVlZiI/XZ0hpzWqSyU25XTLTWSwWekMqoHLRQ2ViDJWLHioTY6hc9FCZ6Ikkk7i4OENFSEl7dYXO5qxln/Xo0QMjRozAH//4R7hcLhw7dgxLly7F3Llzz9YQKBQKhUKh/ITpbl3hrKbkP/fccwgEApg8eTKuv/56XHzxxbj33nvP5hAoFAqFQqH8hOlOXeGsRu+mpaXhueeeO5uHpFAoFAqFcg7RnboC7X1GoVAoFAqFAqoUUSgUCoVCoQCgShGFQqFQKBQKAKoUUSgUCoVCoQCgShGFQqFQKBQKAKoUUSgUCoVCoQCgShGFQqFQKBQKgLNcp+hMEAQBgLqr77naobiroXLRQ2ViDJWLHioTY6hc9FCZ6DGSifTelt7jP2UYQgjp7kHEgsvlwo8//tjdw6BQKBQKhdIBiouL4XQ6u3sYETlnlKJAIACPxwOTyQSWpV4/CoVCoVDOBQRBQCAQgM1mg8n003ZQnTNKEYVCoVAoFEpXQk0uFAqFQqFQKKBKEYVCoVAoFAoAqhRRKBQKhUKhAKBKEYVCoVAoFAoAqhRRKBQKhUKhAKBKEYVCoVAoFAoAqhRRKBQKhUKhAKBKEYVCoVAoFAoAqhRRKBQKhUKhAPgJN4Tdt28fOI5Dbm4unE4nBEGg7T0A7Nq1Cx6PB1lZWSgoKAAhBAzDdPewupXdu3ejra0No0ePBs/ztDFjkG3btqG1tRXp6eno168ffYYA7N27FyzLIjMzEykpKVQmQeh8q4fOtcac7/PtT67NR319PR588EEcOnQIubm5YFkWjz/+OIqKirp7aN1KbW0tFi1ahIMHD6KoqAjbt2/H0qVLMXbs2O4eWrfS0tKCn/3sZ/B6vfjss88A4IKfvBoaGvDrX/8ae/fuRZ8+fXD06FF8/PHHSElJ6e6hdRunT5/GokWLUF5ejh49eqC1tRWvvPIKkpOTu3to3Qqdb/XQuTY8F8J8+5NbCrz88svIzMzE+vXr8dRTTyEvLw/3338/Dh482N1D6zYIIfjzn/+MnJwcrF27Fn/7298wY8YMPPXUU909tG7Hbrejra0NNTU1ePXVVwGIzQcvZFasWIGEhASUlpZixYoVeOutty5ohcjv9+Pxxx9Hbm4u1qxZg1tuuQWBQAANDQ3dPbRuh863auhcG5kLYb79yShFhBC4XC6UlZXhoosuAgAUFhZiyZIlIITg/fffR2NjY/cOspsoLy9HeXk5ZsyYAQAwmUyYOnUqAoEAWlpaunl03YNk4KyoqADHcbjrrrvw9ttv49SpU+A47rx7UGOltbUVmzdvxoQJEwAA7733Hp555hksXboUO3bs6N7BdRNVVVVoaWnB9OnTAQBlZWXw+/04cuQIqqqqunl03YMgCGhra6PzrQJCCCoqKuhcG4ELYb7tVqVoz549+Prrr3Ho0CEwDAOfz4eGhgbEx8cDAAKBAADg3nvvxRdffIHjx49353DPGkq5AKJ2zjAMcnJy5Jtv3bp1yMrKkmV1viPJ5PDhw6rtPM9jwIABGDNmDLKysvDKK68AANxud3cM86yjvVe8Xi9OnjyJ7Oxs/OUvf8GKFStQXFyMbdu24Re/+AU2bdrUzSPuerQysVqtOHr0KF566SVMnDgRH374IYYPH46lS5fitttuQ3V1dTeP+OxQUVEhX3+WZel8C7VMGIaBzWa74OdaQC0Xnufl7YIgnPfzbbcoRR6PB/fffz/uvPNOvPPOO7juuuvwzjvvICUlBSNHjsTrr78OAHIA16xZsxAfH48vv/wSQMhKcL4RTi5ZWVl4/vnnUVhYCJZl4Xa7sX37dsycObO7h9zlaGUyd+5cvP/++7LrY8+ePWhubsaQIUMwb948rF69GnPnzsXrr78On8/XzaPvOiI9Q0OHDsWTTz4Jt9uNlStX4uc//zmWLVuGXr164f333wdwfj5D4WSSnZ2Nv/71r+jduzfy8vLwzTffYPHixfjwww9hNpvxz3/+E8D5KRMlL7zwAp577jn4/X4AQFJSEgYOHIh//OMfAC68+RbQyyQrKwtPPvnkBTnXKlHKRWkJ2rt373k/33ZL9tmaNWvg8Xjw/fffg+M4vPXWW3j33Xfh9/txzz33YOrUqfjkk09w1VVXwe/3w2w2Y8KECfjxxx8B4LwK6lJiJJf33nsPLpcL8+fPl7+3b98+uN1uTJo0Sd5WWVmJgoKC7hh2lxLuXmloaMDdd98Nr9eLcePGAQDWrl2L5uZmEEKwcOHCbh551xJOLm63G7fddhvuuusuxMfHw+fzIRAIwOFw4NJLL8W7774L4Px8hsLJpK2tDXfeeSeamprkAOLm5mYkJCRg8uTJ2Lt3L4DzUyYS5eXl2LBhA+x2O958803ccccdAICFCxdi+vTp+PTTTzF79uwLar41kgkhBL1795a/cyHNtRLh5AKI7vnx48cDOH/n226xFJWWloJhGHllctNNN6GkpATffPMNTp8+jfvvvx9LlixBWVkZzGYzAPFCTZkypTuGe9YIJ5eNGzeq3B5///vfMX78eCQmJuKTTz7B0KFD8dFHH51Xfl0JI5mMHDkSpaWl2LVrF7xeL1577TVMnz4d5eXl+M1vfgNCCD755JNuHnnXEu5e2bBhAxoaGnDjjTeivLwcNTU1cDgcAICDBw/iqquu6s5hdylGMhk9ejTWr1+P3bt3o7q6GsuWLQMAJCQkAACOHTuGWbNmdduYuxrJ9bF69WqMHj0aM2bMwBdffCG7DHNzc3HXXXfh6aefvmDm23AyOXHiBBiGASFE/s6FNNdGkov0TNXX1+Pvf//7eT3fdrmlqKysDKWlpejRowcuueQSsCyL5ORkBAIBNDY2IikpCQBwzTXXYMmSJVizZg0WLlyIzZs349e//jWGDh2KQ4cOobW1FSNGjOjq4Z41YpXL1VdfjaeffhqlpaUYNmwYADFltLi4GHfeeScqKyuxZMkSTJs2rftOppNor0y++eYb+P1+5Ofn42c/+xmmTJkif/d8Wsm1Ry7PPPMMdu/ejQULFmDDhg24/fbbMW7cOJSXl6O2thY/+9nPuvVcOov2yGTJkiX49ttvMXv2bDz//POYM2cOpkyZgo0bN8Lj8WDUqFHdezKdiFYu0sustLQU999/Pwgh2Lt3L9544w0sWrQIAPCrX/0K+/fvP2/n21hlsmLFCixatAgMw4BhGLjdbtTV1Z2Xcy3QfrkQQhAIBJCVlYX58+dj8uTJ5+V8C9JF8DxPnnjiCTJ8+HCyaNEiUlJSQh555BFy6NAhsmbNGnLllVeSjRs3qn7zl7/8hcyfP58QQkhNTQ1Zv349ef7558k///nPrhrmWaejclmwYAEhhJD9+/eT4uJiUlJSQl588cXuOIVOpyMyeeqpp8iDDz5IqqqqVNsFQTibQ+9SOiKXp59+mtx1112EEEKOHTtGPv/8c/LCCy+QN998sztOodPpqEyk52f79u3kmWeeIQ888AB57bXXuuMUugQjuTz22GPkhx9+IIQQ0tLSQgghxOfzkVdeeYXMnTuXbN26Vf59XV3deTffnqlMDhw4cN7NtYR0TC6bN28mhBBSXV2t2tf5NN9KdJlSVFFRQW677TZSUVFBCBEno4cffpjceeedhBBCbr31VvLYY4+phPzNN9+QkSNHyhflfKQjclmzZo0sl8bGRrJs2TLicrm6ZfxdQWfcK4FA4OwPvIuhz5CezpIJz/Nnd+BdjJFcHnnkEXLrrbfKLy6/308IIaSsrIwsXLiQPPTQQ/Lvzzd5EHLmMqmrqyOvvfbaeTXXEnLmciHk/JxvJTo1pqisrAzHjh0Dz/M4ePAgDh48iIKCAvA8j2HDhmH27Nk4ffo03nvvPTzyyCPYsWMHPv30U7S1tQEQI9tnzpwJp9PZmcPqds5ULnv27MGMGTPgdDqRmJiI+fPnIy4urpvP6szo7HvlfCk1T58hPV0hk/OhhUU0uVx55ZVobW3Fyy+/DCAUMF1cXIxLLrkE+/btw4cffgjg/JAH0Dky+eCDDwAAKSkpmDdv3jk/1wKde68A5898a0SnxBQdO3YMjz76KGpqapCYmAi73Y677roLeXl52LZtm1wcbMiQIZgxYwbeeustvP3227jjjjvwxhtv4LvvvgPDMDh+/Ph5VTmUykUPlYkxVC56qEyMaY9cpk2bhtWrV+P6669Hamqq3KtqzJgxqKysRM+ePbv5bDqHzpRJr169uvlsOg96r7SfM+59Vl9fj3vvvRcXXXQR/t//+38oLS3F0qVLAYgVUh0OBx599FH5+1u2bMFzzz2Hhx56CEOGDEFVVRX279+PxsZGzJ0798zO5icElYseKhNjqFz0UJkY0xG5vPjii/jFL36BkSNHdtewuxQqE2OoXDrGGVuKNm/ejEAggF/96lcAgLFjx+I///kPnE4n4uPj8cMPP+Crr76S0zvz8/PluiCAmBKam5t7psP4yUHloofKxBgqFz1UJsZ0RC67du2CxWLpxlF3LVQmxlC5dIwzdiTHx8ejra0NFotFLhO/a9cupKSk4Oqrr0ZOTg6WLVsmt2fYvXs3Bg8ejOzs7DM99E8aKhc9VCbGULnooTIxhspFD5WJMVQuHeRMI7U9Hg/Zu3ev/HdlZSW57LLLyKFDhwghhBw6dIgsWLCATJkyhdx4441kzJgxZOXKlWd62J88VC56qEyMoXLRQ2ViDJWLHioTY6hcOkanp+S/+uqr5NZbb1VtEwSBVFZWki+//LKzD3fOQOWih8rEGCoXPVQmxlC56KEyMYbKJTY6TSkKBAKkpaWFTJ06lXz88ceEEELeffddUlxcTD799NPOOsw5B5WLHioTY6hc9FCZGEPloofKxBgql/bRaW0+OI5DVVUVUlJSYDabceONN6KxsREvv/wyLr300s46zDkHlYseKhNjqFz0UJkYQ+Wih8rEGCqX9tGpvc/279+PHTt24Pjx47jjjjtw9913d+buz1moXPRQmRhD5aKHysQYKhc9VCbGULnEzhnXKVKybt067Nq1C3ffffcFn9anhMpFD5WJMVQueqhMjKFy0UNlYgyVS+x0qlJECJHLg1NCULnooTIxhspFD5WJMVQueqhMjKFyiZ1OVYooFAqFQqFQzlXOjy6AFAqFQqFQKGcIVYooFAqFQqFQQJUiCoVCoVAoFABUKaJQKBQKhUIBQJUiCoVCoVAoFABUKaJQKBQKhUIBQJUiCoXSTXi9Xpw8efKM9lFRUdFJo4nO0aNHz9qxKBRK90CVIgqFEpGHH34YDz/8cKfv9+abb8bGjRs7/Psnn3wSL730Uod/357z+te//oXf/va3HT4WhUI5N6BKEYVC6RYaGhq69fftob6+/qwdi0KhdB9UKaJQzmHmzJmD5cuXy3/fdtttuO666+S///nPf+KWW25BZWUl7rnnHowePRqTJk3Cs88+C5/PJ39v48aNmDt3LkaOHImZM2fi008/NTxeVVUVJk+ejD/+8Y+IpRj+m2++iSlTpmDkyJG48sor8d577wEA5s2bh+rqavzP//wPFi9eDAB4//33MWfOHIwePRrDhw/HggULZGXk+eefx7x583DttdeipKQEL7zwAlauXImVK1di9uzZMcnq66+/xsyZMzFs2DAsWLBApVT5fD48+eSTuOKKKzB8+HCMHTsWjz/+OAgh+Oijj/DKK69gy5YtGDlyJADA5XJh8eLFuOSSSzB27Fg88MADqK2tjWkcFArlJwyhUCjnLEuXLiXz5s0jhBDicrnIsGHDyMCBA0lTUxMhhJA777yTLF26lEyaNIk8/fTTxOPxkOrqajJ37lzy9NNPE0II2b9/PxkyZAj54osvSCAQIFu3biWjR48ma9euJYQQsmjRIrJo0SJSWVlJJk2aRP7617/GNLbKykoyaNAgcvjwYUIIIWvXriWDBw8mp06dIoQQMmnSJPLBBx8QQgjZuXMnGTp0KNm5cychhJATJ06QadOmkWeffZYQQshzzz1H+vXrRzZu3EhcLhfx+/3yuGLh8OHDZODAgeSTTz4hfr+frF69mvTv31/+/d/+9jcyc+ZMeWzbtm0jAwYMIBs3bpSPf+utt8r7W7hwIZk3bx6pra0lLpeLPPbYY+SGG24ggiDENB4KhfLThFqKKJRzmClTpmDTpk1wu934/vvvMWTIEPTu3Rvff/89XC4XNm3ahOzsbPh8Pjz44IOwWq3Izs7G/fffj3/9618AgLfffhuTJ0/GtGnTwHEcLrroIlx//fXy54BoIbrtttswceJE3HfffTGNjeM4EELw9ttvY+vWrRg7dix27NiBjIwM3Xf79u2Lzz77DEOGDEFTUxNqamqQkpKCU6dOyd/Jz8/H2LFjERcXB5PJ1C45rVq1CoMGDcLs2bNhMpkwZcoUTJo0Sf78+uuvx/Lly5Geno6amhp4PB7ExcWpji9RV1eHL774Ar/5zW+QmpqKuLg4PProo9i9ezf27t3brnFRKJSfFu2bWSgUyk+KPn36ICcnBz/88APWrVuH8ePHo7a2Fhs3bkQgEEBxcTFOnz6N+vp6jBo1Sv4dIQR+vx91dXWoqqrC999/L7uGAIDneRQUFMh/b9myBePHj8fXX3+NBx54AImJiVHHlpOTgzfeeAPLli3DPffcA57nMWfOHPz617+G1WpVfZdlWaxYsQIrV66Ew+FAcXExXC6XykVnpEzFyqlTp5CTk6PaVlBQILvQ3G43Fi9ejM2bNyMrKwsDBgwAIQSCIOj2VVVVBUBUpJRwHIfjx49j0KBBHR4nhULpXqhSRKGc40yePBlr165FaWkpnnnmGdTV1eGJJ56Ay+XCtGnTkJWVhYKCAnz++efyb1wuF+rq6pCSkoKsrCxcc801cmwPANTU1KgUkhkzZuCpp57CTTfdhD/84Q945plnoo6rrq4OPM/jxRdfhCAI2LZtG+677z707NkTt9xyi+q7y5cvx4YNG7By5UqkpaUBAO655x7VdxiG6ZB8ACArKwvffvutatvJkydl5eyxxx5DYmIi1q9fD6vVCkEQVEqkkszMTADAf/7zH6Snp8vbDx06hPz8/A6PkUKhdD/UfUahnONMnToVq1atQnNzMwYMGICSkhJUV1fjq6++wtSpUzFp0iS0trZi2bJl8Pl8aG5uxqJFi/DAAw+AYRjMnTsXn332GdavXw9BEHD06FHceuuteP311+VjmM1mcByHP/3pT/jqq6+watWqqOOqrq7GvHnzUFpaCpZlZWUiOTkZAGCxWNDS0gJAVNJMJhPMZjMCgQA++eQTrFu3Dn6/P+z+lb+PxuzZs3HgwAG8++67CAQCWL9+PVavXi1/7nK5YLVawbIsXC4XnnrqKbhcLvn4VqtVtlxlZmbi0ksvxRNPPIGGhgb4/X689NJLT6Wf5wAAAdJJREFUmDt3Lpqbm2MaD4VC+WlClSIK5Rxn2LBhMJlMGDduHBiGgc1mw8iRI5Gbm4tevXrB6XRi+fLl+OGHHzBx4kRMmTIFLMvKNX6GDh2KZ555Bs888wxGjRqFW2+9FZdddhn++7//W3es3r17Y+HChfjDH/5gGG+jZPDgwfjd736H3//+9xg+fDhuueUW3HzzzbjiiisAAHPnzsWzzz6Lhx56CPPmzUN2djYmTZqEiy++GJ9++iluvvlmHDhwIOz+Z8yYgW3btuHSSy+NKqP8/Hy8/PLL+Ne//oURI0Zg6dKlmDp1qvz5Y489hrKyMpSUlODyyy+Hy+XCxRdfLB9/0qRJaGxsxIgRI9Dc3IynnnoKCQkJuPrqqzFmzBh89913WLZsmcpyRKFQzj0YQmLIq6VQKBQKhUI5z6GWIgqFQqFQKBTQQGsKhdJB5syZg/Ly8rCfv/rqq6qMtq6irq4OU6ZMifid7du3d/k4KBTKuQ91n1EoFAqFQqGAus8oFAqFQqFQAFCliEKhUCgUCgUAVYooFAqFQqFQAFCliEKhUCgUCgUAVYooFAqFQqFQAFCliEKhUCgUCgUAVYooFAqFQqFQAFCliEKhUCgUCgUA8P8B1gOvipJvtJ8AAAAASUVORK5CYII="
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 2 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for c in COLS_FEATURES:\n",
+    "    ax = df_iq.plot(x=COL_WEEK_START_DATE, y=COL_TARGET)\n",
+    "    df_iq.plot(x=COL_WEEK_START_DATE, y=c, ax=ax.twinx(), c=\"#aa550088\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:32:42.008129300Z",
+     "start_time": "2023-08-01T11:32:30.335660700Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "   station_max_temp_c  station_min_temp_c  station_avg_temp_c  \\\n0            0.075279            0.211702            0.113070   \n1            0.044967            0.211177            0.104548   \n2            0.008211            0.214703            0.116686   \n3           -0.033225            0.226510            0.068458   \n4           -0.040664            0.203024            0.077881   \n5           -0.075318            0.227928            0.068676   \n6           -0.067048            0.217538            0.072845   \n7           -0.075707            0.190215            0.057694   \n8           -0.084085            0.188249            0.042049   \n\n   station_precip_mm  station_diur_temp_rng_c  precipitation_amt_mm  \\\n0           0.042976                -0.058230              0.090171   \n1           0.093426                -0.083947              0.125996   \n2           0.050036                -0.084740              0.138774   \n3           0.096129                -0.141336              0.154550   \n4           0.062992                -0.126618              0.112311   \n5           0.099698                -0.160208              0.125317   \n6           0.131390                -0.137087              0.148583   \n7           0.045916                -0.122819              0.088308   \n8           0.013774                -0.162148              0.119178   \n\n   reanalysis_sat_precip_amt_mm  reanalysis_dew_point_temp_k  \\\n0                      0.090171                     0.230401   \n1                      0.125996                     0.273006   \n2                      0.138774                     0.278538   \n3                      0.154550                     0.316042   \n4                      0.112311                     0.282566   \n5                      0.125317                     0.287285   \n6                      0.148583                     0.271994   \n7                      0.088308                     0.234052   \n8                      0.119178                     0.226745   \n\n   reanalysis_air_temp_k  reanalysis_relative_humidity_percent  \\\n0               0.097098                              0.130083   \n1               0.085112                              0.172959   \n2               0.071123                              0.188278   \n3               0.052015                              0.232489   \n4               0.049312                              0.207347   \n5               0.012743                              0.233717   \n6               0.029769                              0.206826   \n7               0.029828                              0.174960   \n8               0.005398                              0.185177   \n\n   reanalysis_specific_humidity_g_per_kg  reanalysis_precip_amt_kg_per_m2  \\\n0                               0.236476                         0.101171   \n1                               0.281101                         0.110917   \n2                               0.287082                         0.107484   \n3                               0.323679                         0.150713   \n4                               0.289669                         0.123296   \n5                               0.294210                         0.154732   \n6                               0.277832                         0.100821   \n7                               0.241168                         0.076922   \n8                               0.231639                         0.066094   \n\n   reanalysis_max_air_temp_k  reanalysis_min_air_temp_k  \\\n0                  -0.056474                   0.214514   \n1                  -0.068858                   0.220019   \n2                  -0.084575                   0.233470   \n3                  -0.129535                   0.239341   \n4                  -0.108065                   0.213643   \n5                  -0.141709                   0.192671   \n6                  -0.139575                   0.193179   \n7                  -0.153664                   0.184693   \n8                  -0.155861                   0.182844   \n\n   reanalysis_avg_temp_k  reanalysis_tdtr_k   ndvi_se   ndvi_sw   ndvi_ne  \\\n0               0.079872          -0.134425 -0.041067  0.032999  0.020215   \n1               0.075159          -0.151779 -0.051156 -0.021661 -0.008529   \n2               0.065361          -0.168602 -0.055266 -0.045039 -0.037245   \n3               0.043853          -0.207594 -0.027706  0.000721  0.016771   \n4               0.056184          -0.173838 -0.048618 -0.043703 -0.028570   \n5               0.014499          -0.213775 -0.041393 -0.041231 -0.024761   \n6               0.024886          -0.187961 -0.058371 -0.061431 -0.039912   \n7               0.023667          -0.165388 -0.074527 -0.084462 -0.060560   \n8               0.001047          -0.185797 -0.127096 -0.150034 -0.118949   \n\n    ndvi_nw  \n0 -0.009586  \n1 -0.038200  \n2 -0.044821  \n3 -0.009288  \n4 -0.067982  \n5 -0.016291  \n6 -0.015861  \n7 -0.037703  \n8 -0.095510  ",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>station_max_temp_c</th>\n      <th>station_min_temp_c</th>\n      <th>station_avg_temp_c</th>\n      <th>station_precip_mm</th>\n      <th>station_diur_temp_rng_c</th>\n      <th>precipitation_amt_mm</th>\n      <th>reanalysis_sat_precip_amt_mm</th>\n      <th>reanalysis_dew_point_temp_k</th>\n      <th>reanalysis_air_temp_k</th>\n      <th>reanalysis_relative_humidity_percent</th>\n      <th>reanalysis_specific_humidity_g_per_kg</th>\n      <th>reanalysis_precip_amt_kg_per_m2</th>\n      <th>reanalysis_max_air_temp_k</th>\n      <th>reanalysis_min_air_temp_k</th>\n      <th>reanalysis_avg_temp_k</th>\n      <th>reanalysis_tdtr_k</th>\n      <th>ndvi_se</th>\n      <th>ndvi_sw</th>\n      <th>ndvi_ne</th>\n      <th>ndvi_nw</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.075279</td>\n      <td>0.211702</td>\n      <td>0.113070</td>\n      <td>0.042976</td>\n      <td>-0.058230</td>\n      <td>0.090171</td>\n      <td>0.090171</td>\n      <td>0.230401</td>\n      <td>0.097098</td>\n      <td>0.130083</td>\n      <td>0.236476</td>\n      <td>0.101171</td>\n      <td>-0.056474</td>\n      <td>0.214514</td>\n      <td>0.079872</td>\n      <td>-0.134425</td>\n      <td>-0.041067</td>\n      <td>0.032999</td>\n      <td>0.020215</td>\n      <td>-0.009586</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.044967</td>\n      <td>0.211177</td>\n      <td>0.104548</td>\n      <td>0.093426</td>\n      <td>-0.083947</td>\n      <td>0.125996</td>\n      <td>0.125996</td>\n      <td>0.273006</td>\n      <td>0.085112</td>\n      <td>0.172959</td>\n      <td>0.281101</td>\n      <td>0.110917</td>\n      <td>-0.068858</td>\n      <td>0.220019</td>\n      <td>0.075159</td>\n      <td>-0.151779</td>\n      <td>-0.051156</td>\n      <td>-0.021661</td>\n      <td>-0.008529</td>\n      <td>-0.038200</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.008211</td>\n      <td>0.214703</td>\n      <td>0.116686</td>\n      <td>0.050036</td>\n      <td>-0.084740</td>\n      <td>0.138774</td>\n      <td>0.138774</td>\n      <td>0.278538</td>\n      <td>0.071123</td>\n      <td>0.188278</td>\n      <td>0.287082</td>\n      <td>0.107484</td>\n      <td>-0.084575</td>\n      <td>0.233470</td>\n      <td>0.065361</td>\n      <td>-0.168602</td>\n      <td>-0.055266</td>\n      <td>-0.045039</td>\n      <td>-0.037245</td>\n      <td>-0.044821</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-0.033225</td>\n      <td>0.226510</td>\n      <td>0.068458</td>\n      <td>0.096129</td>\n      <td>-0.141336</td>\n      <td>0.154550</td>\n      <td>0.154550</td>\n      <td>0.316042</td>\n      <td>0.052015</td>\n      <td>0.232489</td>\n      <td>0.323679</td>\n      <td>0.150713</td>\n      <td>-0.129535</td>\n      <td>0.239341</td>\n      <td>0.043853</td>\n      <td>-0.207594</td>\n      <td>-0.027706</td>\n      <td>0.000721</td>\n      <td>0.016771</td>\n      <td>-0.009288</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-0.040664</td>\n      <td>0.203024</td>\n      <td>0.077881</td>\n      <td>0.062992</td>\n      <td>-0.126618</td>\n      <td>0.112311</td>\n      <td>0.112311</td>\n      <td>0.282566</td>\n      <td>0.049312</td>\n      <td>0.207347</td>\n      <td>0.289669</td>\n      <td>0.123296</td>\n      <td>-0.108065</td>\n      <td>0.213643</td>\n      <td>0.056184</td>\n      <td>-0.173838</td>\n      <td>-0.048618</td>\n      <td>-0.043703</td>\n      <td>-0.028570</td>\n      <td>-0.067982</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-0.075318</td>\n      <td>0.227928</td>\n      <td>0.068676</td>\n      <td>0.099698</td>\n      <td>-0.160208</td>\n      <td>0.125317</td>\n      <td>0.125317</td>\n      <td>0.287285</td>\n      <td>0.012743</td>\n      <td>0.233717</td>\n      <td>0.294210</td>\n      <td>0.154732</td>\n      <td>-0.141709</td>\n      <td>0.192671</td>\n      <td>0.014499</td>\n      <td>-0.213775</td>\n      <td>-0.041393</td>\n      <td>-0.041231</td>\n      <td>-0.024761</td>\n      <td>-0.016291</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>-0.067048</td>\n      <td>0.217538</td>\n      <td>0.072845</td>\n      <td>0.131390</td>\n      <td>-0.137087</td>\n      <td>0.148583</td>\n      <td>0.148583</td>\n      <td>0.271994</td>\n      <td>0.029769</td>\n      <td>0.206826</td>\n      <td>0.277832</td>\n      <td>0.100821</td>\n      <td>-0.139575</td>\n      <td>0.193179</td>\n      <td>0.024886</td>\n      <td>-0.187961</td>\n      <td>-0.058371</td>\n      <td>-0.061431</td>\n      <td>-0.039912</td>\n      <td>-0.015861</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-0.075707</td>\n      <td>0.190215</td>\n      <td>0.057694</td>\n      <td>0.045916</td>\n      <td>-0.122819</td>\n      <td>0.088308</td>\n      <td>0.088308</td>\n      <td>0.234052</td>\n      <td>0.029828</td>\n      <td>0.174960</td>\n      <td>0.241168</td>\n      <td>0.076922</td>\n      <td>-0.153664</td>\n      <td>0.184693</td>\n      <td>0.023667</td>\n      <td>-0.165388</td>\n      <td>-0.074527</td>\n      <td>-0.084462</td>\n      <td>-0.060560</td>\n      <td>-0.037703</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-0.084085</td>\n      <td>0.188249</td>\n      <td>0.042049</td>\n      <td>0.013774</td>\n      <td>-0.162148</td>\n      <td>0.119178</td>\n      <td>0.119178</td>\n      <td>0.226745</td>\n      <td>0.005398</td>\n      <td>0.185177</td>\n      <td>0.231639</td>\n      <td>0.066094</td>\n      <td>-0.155861</td>\n      <td>0.182844</td>\n      <td>0.001047</td>\n      <td>-0.185797</td>\n      <td>-0.127096</td>\n      <td>-0.150034</td>\n      <td>-0.118949</td>\n      <td>-0.095510</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def lagged_correlations(df, max_lag):\n",
+    "    return pd.DataFrame.from_dict(\n",
+    "        {x: [df[COL_TARGET].corr(df[x].shift(-t)) for t in range(max_lag+1)] for x in COLS_FEATURES})\n",
+    "    \n",
+    "lagged_correlations(df_iq, 8)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:45:16.794373900Z",
+     "start_time": "2023-08-01T11:45:16.582992600Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "   station_max_temp_c  station_min_temp_c  station_avg_temp_c  \\\n0            0.189901            0.177012            0.196617   \n1            0.162878            0.142917            0.161135   \n2            0.133076            0.104494            0.120340   \n3            0.095389            0.061008            0.075798   \n4            0.061942            0.018889            0.033268   \n5            0.035191           -0.015761           -0.003189   \n6            0.000917           -0.057626           -0.047735   \n7           -0.033656           -0.096191           -0.089366   \n8           -0.068179           -0.140209           -0.132138   \n\n   station_precip_mm  station_diur_temp_rng_c  precipitation_amt_mm  \\\n0           0.051759                 0.034630              0.060211   \n1           0.046117                 0.041811              0.045910   \n2           0.059218                 0.054005              0.037490   \n3           0.070727                 0.052235              0.044117   \n4           0.082058                 0.059824              0.049555   \n5           0.066061                 0.071265              0.029974   \n6           0.067955                 0.074676              0.021254   \n7           0.053376                 0.072971              0.003778   \n8           0.042250                 0.078140             -0.007533   \n\n   reanalysis_sat_precip_amt_mm  reanalysis_dew_point_temp_k  \\\n0                      0.060211                     0.203774   \n1                      0.045910                     0.173224   \n2                      0.037490                     0.137591   \n3                      0.044117                     0.104958   \n4                      0.049555                     0.074424   \n5                      0.029974                     0.040923   \n6                      0.021254                     0.001887   \n7                      0.003778                    -0.040226   \n8                     -0.007533                    -0.085822   \n\n   reanalysis_air_temp_k  reanalysis_relative_humidity_percent  \\\n0               0.181917                              0.144045   \n1               0.150842                              0.129085   \n2               0.110540                              0.118634   \n3               0.070264                              0.114727   \n4               0.031346                              0.113228   \n5              -0.001615                              0.094865   \n6              -0.046819                              0.085099   \n7              -0.088452                              0.062503   \n8              -0.133895                              0.039161   \n\n   reanalysis_specific_humidity_g_per_kg  reanalysis_precip_amt_kg_per_m2  \\\n0                               0.207947                         0.107457   \n1                               0.177260                         0.101659   \n2                               0.141874                         0.099007   \n3                               0.109216                         0.098935   \n4                               0.078455                         0.099295   \n5                               0.044457                         0.076004   \n6                               0.004866                         0.069192   \n7                              -0.038023                         0.059995   \n8                              -0.084173                         0.050671   \n\n   reanalysis_max_air_temp_k  reanalysis_min_air_temp_k  \\\n0                   0.194532                   0.187943   \n1                   0.162360                   0.160299   \n2                   0.119837                   0.124852   \n3                   0.078449                   0.086789   \n4                   0.040211                   0.047449   \n5                   0.009837                   0.013008   \n6                  -0.036309                  -0.027656   \n7                  -0.081864                  -0.069696   \n8                  -0.128965                  -0.114930   \n\n   reanalysis_avg_temp_k  reanalysis_tdtr_k   ndvi_se   ndvi_sw   ndvi_ne  \\\n0               0.175267          -0.067600  0.001113 -0.000333  0.037639   \n1               0.144233          -0.076799 -0.004761 -0.002942  0.041123   \n2               0.103817          -0.086207 -0.016334 -0.018851  0.044404   \n3               0.064067          -0.097819 -0.020883 -0.022959  0.038974   \n4               0.025607          -0.099464 -0.016952 -0.028363  0.042456   \n5              -0.005976          -0.102407  0.002094 -0.015591  0.036047   \n6              -0.050754          -0.109374  0.018032  0.002590  0.041193   \n7              -0.091382          -0.117422  0.023458  0.010751  0.037332   \n8              -0.135738          -0.121490  0.013130  0.009482  0.019928   \n\n    ndvi_nw  \n0  0.075307  \n1  0.066731  \n2  0.057947  \n3  0.035358  \n4  0.045405  \n5  0.037189  \n6  0.036400  \n7  0.038844  \n8  0.028750  ",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>station_max_temp_c</th>\n      <th>station_min_temp_c</th>\n      <th>station_avg_temp_c</th>\n      <th>station_precip_mm</th>\n      <th>station_diur_temp_rng_c</th>\n      <th>precipitation_amt_mm</th>\n      <th>reanalysis_sat_precip_amt_mm</th>\n      <th>reanalysis_dew_point_temp_k</th>\n      <th>reanalysis_air_temp_k</th>\n      <th>reanalysis_relative_humidity_percent</th>\n      <th>reanalysis_specific_humidity_g_per_kg</th>\n      <th>reanalysis_precip_amt_kg_per_m2</th>\n      <th>reanalysis_max_air_temp_k</th>\n      <th>reanalysis_min_air_temp_k</th>\n      <th>reanalysis_avg_temp_k</th>\n      <th>reanalysis_tdtr_k</th>\n      <th>ndvi_se</th>\n      <th>ndvi_sw</th>\n      <th>ndvi_ne</th>\n      <th>ndvi_nw</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.189901</td>\n      <td>0.177012</td>\n      <td>0.196617</td>\n      <td>0.051759</td>\n      <td>0.034630</td>\n      <td>0.060211</td>\n      <td>0.060211</td>\n      <td>0.203774</td>\n      <td>0.181917</td>\n      <td>0.144045</td>\n      <td>0.207947</td>\n      <td>0.107457</td>\n      <td>0.194532</td>\n      <td>0.187943</td>\n      <td>0.175267</td>\n      <td>-0.067600</td>\n      <td>0.001113</td>\n      <td>-0.000333</td>\n      <td>0.037639</td>\n      <td>0.075307</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.162878</td>\n      <td>0.142917</td>\n      <td>0.161135</td>\n      <td>0.046117</td>\n      <td>0.041811</td>\n      <td>0.045910</td>\n      <td>0.045910</td>\n      <td>0.173224</td>\n      <td>0.150842</td>\n      <td>0.129085</td>\n      <td>0.177260</td>\n      <td>0.101659</td>\n      <td>0.162360</td>\n      <td>0.160299</td>\n      <td>0.144233</td>\n      <td>-0.076799</td>\n      <td>-0.004761</td>\n      <td>-0.002942</td>\n      <td>0.041123</td>\n      <td>0.066731</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.133076</td>\n      <td>0.104494</td>\n      <td>0.120340</td>\n      <td>0.059218</td>\n      <td>0.054005</td>\n      <td>0.037490</td>\n      <td>0.037490</td>\n      <td>0.137591</td>\n      <td>0.110540</td>\n      <td>0.118634</td>\n      <td>0.141874</td>\n      <td>0.099007</td>\n      <td>0.119837</td>\n      <td>0.124852</td>\n      <td>0.103817</td>\n      <td>-0.086207</td>\n      <td>-0.016334</td>\n      <td>-0.018851</td>\n      <td>0.044404</td>\n      <td>0.057947</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.095389</td>\n      <td>0.061008</td>\n      <td>0.075798</td>\n      <td>0.070727</td>\n      <td>0.052235</td>\n      <td>0.044117</td>\n      <td>0.044117</td>\n      <td>0.104958</td>\n      <td>0.070264</td>\n      <td>0.114727</td>\n      <td>0.109216</td>\n      <td>0.098935</td>\n      <td>0.078449</td>\n      <td>0.086789</td>\n      <td>0.064067</td>\n      <td>-0.097819</td>\n      <td>-0.020883</td>\n      <td>-0.022959</td>\n      <td>0.038974</td>\n      <td>0.035358</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.061942</td>\n      <td>0.018889</td>\n      <td>0.033268</td>\n      <td>0.082058</td>\n      <td>0.059824</td>\n      <td>0.049555</td>\n      <td>0.049555</td>\n      <td>0.074424</td>\n      <td>0.031346</td>\n      <td>0.113228</td>\n      <td>0.078455</td>\n      <td>0.099295</td>\n      <td>0.040211</td>\n      <td>0.047449</td>\n      <td>0.025607</td>\n      <td>-0.099464</td>\n      <td>-0.016952</td>\n      <td>-0.028363</td>\n      <td>0.042456</td>\n      <td>0.045405</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.035191</td>\n      <td>-0.015761</td>\n      <td>-0.003189</td>\n      <td>0.066061</td>\n      <td>0.071265</td>\n      <td>0.029974</td>\n      <td>0.029974</td>\n      <td>0.040923</td>\n      <td>-0.001615</td>\n      <td>0.094865</td>\n      <td>0.044457</td>\n      <td>0.076004</td>\n      <td>0.009837</td>\n      <td>0.013008</td>\n      <td>-0.005976</td>\n      <td>-0.102407</td>\n      <td>0.002094</td>\n      <td>-0.015591</td>\n      <td>0.036047</td>\n      <td>0.037189</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.000917</td>\n      <td>-0.057626</td>\n      <td>-0.047735</td>\n      <td>0.067955</td>\n      <td>0.074676</td>\n      <td>0.021254</td>\n      <td>0.021254</td>\n      <td>0.001887</td>\n      <td>-0.046819</td>\n      <td>0.085099</td>\n      <td>0.004866</td>\n      <td>0.069192</td>\n      <td>-0.036309</td>\n      <td>-0.027656</td>\n      <td>-0.050754</td>\n      <td>-0.109374</td>\n      <td>0.018032</td>\n      <td>0.002590</td>\n      <td>0.041193</td>\n      <td>0.036400</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-0.033656</td>\n      <td>-0.096191</td>\n      <td>-0.089366</td>\n      <td>0.053376</td>\n      <td>0.072971</td>\n      <td>0.003778</td>\n      <td>0.003778</td>\n      <td>-0.040226</td>\n      <td>-0.088452</td>\n      <td>0.062503</td>\n      <td>-0.038023</td>\n      <td>0.059995</td>\n      <td>-0.081864</td>\n      <td>-0.069696</td>\n      <td>-0.091382</td>\n      <td>-0.117422</td>\n      <td>0.023458</td>\n      <td>0.010751</td>\n      <td>0.037332</td>\n      <td>0.038844</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-0.068179</td>\n      <td>-0.140209</td>\n      <td>-0.132138</td>\n      <td>0.042250</td>\n      <td>0.078140</td>\n      <td>-0.007533</td>\n      <td>-0.007533</td>\n      <td>-0.085822</td>\n      <td>-0.133895</td>\n      <td>0.039161</td>\n      <td>-0.084173</td>\n      <td>0.050671</td>\n      <td>-0.128965</td>\n      <td>-0.114930</td>\n      <td>-0.135738</td>\n      <td>-0.121490</td>\n      <td>0.013130</td>\n      <td>0.009482</td>\n      <td>0.019928</td>\n      <td>0.028750</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lagged_correlations(df_sj, 8)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-08-01T11:45:46.393882800Z",
+     "start_time": "2023-08-01T11:45:44.916063800Z"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/examples/dengue-fever-time-series/run_hyperopt.py b/examples/dengue-fever-time-series/run_hyperopt.py
new file mode 100644
index 000000000..6ec6cabdd
--- /dev/null
+++ b/examples/dengue-fever-time-series/run_hyperopt.py
@@ -0,0 +1,81 @@
+import os
+import warnings
+from typing import Literal
+
+import hyperopt
+from hyperopt import hp
+
+from dengai.models.model_factory import ModelFactory
+from dengai.prediction_problem import DengaiPrediction
+from sensai.util import logging
+from sensai.util.io import ResultWriter
+from sensai.util.logging import datetime_tag
+from sensai.util.pickle import load_pickle
+
+log = logging.getLogger(__name__)
+
+
+def run_hyperopt(model_type: Literal["xgb"] = "xgb_window", use_cross_validation=False):
+    experiment_name = f"{datetime_tag()}-{model_type}"
+    result_writer = ResultWriter(os.path.join("results", "hyperopt", experiment_name))
+    logging.add_file_logger(result_writer.path("log.txt"))
+
+    pred = DengaiPrediction()
+    week_window_size = pred.week_window_size
+
+    if model_type == "xgb_window":
+        initial_space = [
+            {
+                'max_depth': 6,
+                'gamma': 0,
+                'reg_lambda': 0,
+                'colsample_bytree': 1,
+                'min_child_weight': 1,
+            }
+        ]
+        space = {
+            'max_depth': hp.quniform("max_depth", 3, 18, 1),
+            'gamma': hp.uniform('gamma', 0, 9),
+            'reg_lambda': hp.uniform('reg_lambda', 0, 1),
+            'colsample_bytree': hp.uniform('colsample_bytree', 0.25, 1),
+            'min_child_weight': hp.quniform('min_child_weight', 1, 12, 2),
+        }
+
+        def create_model(params):
+            return ModelFactory.create_xgb_window(window_size=week_window_size,
+                verbosity=0,
+                max_depth=int(params['max_depth']),
+                gamma=params['gamma'],
+                reg_lambda=params['reg_lambda'],
+                min_child_weight=int(params['min_child_weight']),
+                colsample_bytree=params['colsample_bytree']).with_name(model_type)
+
+        hours = 1.5
+        warnings.filterwarnings("ignore")
+    else:
+        raise ValueError(model_type)
+
+    metric_computation = pred.create_metric_computation(use_cross_validation=use_cross_validation)
+
+    def objective(params):
+        log.info(f"Evaluating {params}")
+        result = metric_computation.compute_metric_value(lambda: create_model(params))
+        loss = result.metric_value
+        log.info(f"Loss[{metric_computation.metric.name}]={loss}")
+        return {'loss': loss, 'status': hyperopt.STATUS_OK}
+
+    trials_file = result_writer.path("trials.pickle")
+    logging.getLogger("sensai").setLevel(logging.WARN)
+    log.info(f"Starting hyperparameter optimisation for {model_type}")
+    hyperopt.fmin(objective, space, algo=hyperopt.tpe.suggest, timeout=hours*3600, show_progressbar=False,
+        trials_save_file=trials_file, points_to_evaluate=initial_space)
+    logging.getLogger("sensai").setLevel(logging.INFO)
+    trials: hyperopt.Trials = load_pickle(trials_file)
+    log.info(f"Best trial: {trials.best_trial}")
+
+
+if __name__ == '__main__':
+    logging.configure()
+    log.info("Starting")
+    run_hyperopt()
+    log.info("Done")
diff --git a/examples/dengue-fever-time-series/run_model_evaluation.py b/examples/dengue-fever-time-series/run_model_evaluation.py
new file mode 100644
index 000000000..91f2271fd
--- /dev/null
+++ b/examples/dengue-fever-time-series/run_model_evaluation.py
@@ -0,0 +1,81 @@
+from typing import Optional
+
+from matplotlib import pyplot as plt
+
+from dengai.data import CITY_SAN_JUAN, CITY_IQUITOS, COL_WEEK_START_DATE, COL_TARGET
+from dengai.models.model_factory import ModelFactory
+from dengai.prediction_problem import DengaiPrediction
+from sensai.evaluation.eval_util import RegressionMultiDataModelComparisonData
+from sensai.tracking.mlflow_tracking import MLFlowExperiment
+from sensai.util import logging, mark_used
+from sensai.util.io import ResultWriter
+from sensai.util.logging import datetime_tag
+
+mark_used(CITY_IQUITOS, CITY_SAN_JUAN, plt)
+
+
+def eval_models(city_only: Optional[str] = None, use_cross_validation=False):
+    pred = DengaiPrediction(city_only=city_only)
+
+    experiment_name = f"dengAI-{pred.experiment_tag(use_cross_validation)}"
+    run_id = datetime_tag()
+    result_writer = ResultWriter(f"results/eval-{experiment_name}/{run_id}")
+    logging.add_file_logger(result_writer.path("process.log"))
+
+    week_window_size = pred.week_window_size
+    mark_used(week_window_size)
+
+    # define models to evaluate
+    model_factories = []
+    #model_factories.append(lambda: ModelFactory.create_baseline())
+    #model_factories.append(lambda: ModelFactory.create_glm_benchmark())
+    #model_factories.append(lambda: ModelFactory.create_rnn_mlp(week_window_size, batch_size=64))
+    #model_factories.append(lambda: ModelFactory.create_rnn_mlp_autoreg(week_window_size))
+    #model_factories.append(lambda: ModelFactory.create_rnn_mlp(week_window_size, feature_columns=ModelFactory.COLS_FEATURES_SEL))
+    model_factories.append(lambda: ModelFactory.create_lstnet_encoder_decoder(week_window_size))
+    #model_factories.append(lambda: ModelFactory.create_mlp(week_window_size))
+    #model_factories.append(lambda: ModelFactory.create_xgb())
+    #model_factories.append(lambda: ModelFactory.create_xgb_fsel())
+    #model_factories.append(lambda: ModelFactory.create_xgb_window(week_window_size, min_child_weight=1))
+    #model_factories.append(lambda: ModelFactory.create_xgb_window(week_window_size, min_child_weight=1, feature_columns=ModelFactory.COLS_FEATURES_SEL))
+    #model_factories.append(lambda: ModelFactory.create_xgb_window_opt(week_window_size))
+    #model_factories.append(lambda: ModelFactory.create_mean_past_year_week())
+
+    # evaluate models
+    ev = pred.create_multi_data_evaluator()
+    results = ev.compare_models(model_factories, use_cross_validation=use_cross_validation, add_combined_eval_stats=True,
+        create_metric_distribution_plots=False, create_combined_eval_stats_plots=False,
+        result_writer=result_writer, write_per_dataset_results=True)
+    results: RegressionMultiDataModelComparisonData
+
+    # write metrics to mlflow
+    tracking_exp = MLFlowExperiment(experiment_name, tracking_uri="", context_prefix=run_id + "_")
+    for model_name in results.get_model_names():
+
+        # track metrics
+        eval_stats = results.get_eval_stats_collection(model_name).get_combined_eval_stats()
+        with tracking_exp.begin_context(model_name, results.get_model_description(model_name)) as tracking_context:
+            tracking_context.track_metrics(eval_stats.metrics_dict())
+
+            # visualise prediction time series
+            for dataset_name, result in results.iter_model_results(model_name):
+                fig, ax = plt.subplots()
+                full_io_data = pred.io_data_dict[dataset_name]
+                plt.plot(full_io_data.inputs[COL_WEEK_START_DATE], full_io_data.outputs[COL_TARGET])
+                for eval_data in result.iter_evaluation_data():
+                    io_data = eval_data.io_data
+                    predictions = eval_data.get_eval_stats().y_predicted
+                    plt.plot(io_data.inputs[COL_WEEK_START_DATE], predictions)
+                    fig_name = f"{model_name}_{dataset_name}_time-series"
+                    result_writer.write_figure(fig_name, fig)
+                    tracking_context.track_figure(fig_name, fig)
+
+
+if __name__ == "__main__":
+    logging.configure()
+
+    use_cross_validation = False
+
+    eval_models(city_only=CITY_IQUITOS, use_cross_validation=use_cross_validation)
+    #eval_models(city_only=CITY_SAN_JUAN, use_cross_validation=use_cross_validation)
+    #eval_models(use_cross_validation=use_cross_validation)
diff --git a/examples/dengue-fever-time-series/run_rfe.py b/examples/dengue-fever-time-series/run_rfe.py
new file mode 100644
index 000000000..76be0b888
--- /dev/null
+++ b/examples/dengue-fever-time-series/run_rfe.py
@@ -0,0 +1,40 @@
+import os
+
+from dengai.models.model_factory import ModelFactory
+from dengai.prediction_problem import DengaiPrediction
+from sensai.feature_selection.rfe import RecursiveFeatureElimination
+from sensai.util import logging
+from sensai.util.io import ResultWriter
+from sensai.util.logging import datetime_tag
+
+log = logging.getLogger(__name__)
+
+
+def run_rfe(model_type="xgb"):
+    experiment_name = f"{datetime_tag()}-{model_type}"
+    result_writer = ResultWriter(os.path.join("results", "rfe", experiment_name))
+    logging.add_file_logger(result_writer.path("log.txt"))
+
+    if model_type == "xgb":
+        params = {'colsample_bytree': 0.2867610159931737, 'gamma': 8.62166097248104, 'max_depth': 4,
+            'min_child_weight': 12.0, 'reg_lambda': 0.7172266188561198}
+        model_factory = lambda: ModelFactory.create_xgb(**params)
+    else:
+        raise ValueError(model_type)
+
+    metric_computation = DengaiPrediction().create_metric_computation(use_cross_validation=False)
+    rfe = RecursiveFeatureElimination(metric_computation)
+    result = rfe.run(model_factory, minimise=True)
+    result_writer.write_pickle("result", result)
+
+    for i, step in enumerate(result.get_sorted_steps(), start=1):
+        log.info(f"Top features #{i}: [loss={step.metric_value}] {step.features}")
+
+    return vars()
+
+
+if __name__ == '__main__':
+    logging.configure()
+    log.info("Starting")
+    globals().update(run_rfe())
+    log.info("Done")

From 7c465391b6b64146962db6bae32b5c0dfa877a55 Mon Sep 17 00:00:00 2001
From: Dominik Jain <dominik.jain@outlook.com>
Date: Thu, 10 Oct 2024 00:33:05 +0200
Subject: [PATCH 2/6] Add the dengai dataset

---
 .gitignore                                    |    1 -
 examples/dengue-fever-time-series/.gitignore  |    1 -
 .../data/dengue_features_test.csv             |  417 +++++
 .../data/dengue_features_train.csv            | 1457 +++++++++++++++++
 .../data/dengue_labels_train.csv              | 1457 +++++++++++++++++
 5 files changed, 3331 insertions(+), 2 deletions(-)
 create mode 100644 examples/dengue-fever-time-series/data/dengue_features_test.csv
 create mode 100644 examples/dengue-fever-time-series/data/dengue_features_train.csv
 create mode 100644 examples/dengue-fever-time-series/data/dengue_labels_train.csv

diff --git a/.gitignore b/.gitignore
index ab76546db..b548cc62c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,7 +18,6 @@ dist
 /build
 /git-split.sh
 /.pytest_cache
-data
 .coverage
 /*.env
 /docs-build
diff --git a/examples/dengue-fever-time-series/.gitignore b/examples/dengue-fever-time-series/.gitignore
index 38e071701..c452e72c5 100644
--- a/examples/dengue-fever-time-series/.gitignore
+++ b/examples/dengue-fever-time-series/.gitignore
@@ -2,7 +2,6 @@
 __pycache__
 *.bak
 *.orig
-/data
 /temp
 /.idea
 /results
diff --git a/examples/dengue-fever-time-series/data/dengue_features_test.csv b/examples/dengue-fever-time-series/data/dengue_features_test.csv
new file mode 100644
index 000000000..d481b59cc
--- /dev/null
+++ b/examples/dengue-fever-time-series/data/dengue_features_test.csv
@@ -0,0 +1,417 @@
+city,year,weekofyear,week_start_date,ndvi_ne,ndvi_nw,ndvi_se,ndvi_sw,precipitation_amt_mm,reanalysis_air_temp_k,reanalysis_avg_temp_k,reanalysis_dew_point_temp_k,reanalysis_max_air_temp_k,reanalysis_min_air_temp_k,reanalysis_precip_amt_kg_per_m2,reanalysis_relative_humidity_percent,reanalysis_sat_precip_amt_mm,reanalysis_specific_humidity_g_per_kg,reanalysis_tdtr_k,station_avg_temp_c,station_diur_temp_rng_c,station_max_temp_c,station_min_temp_c,station_precip_mm
+sj,2008,18,2008-04-29,-0.0189,-0.0189,0.1027286,0.0912,78.6,298.492857143,298.55,294.527142857,301.1,296.4,25.37,78.7814285714,78.6,15.9185714286,3.12857142857,26.5285714286,7.05714285714,33.3,21.7,75.2
+sj,2008,19,2008-05-06,-0.018,-0.0124,0.08204286,0.07231429,12.56,298.475714286,298.557142857,294.395714286,300.8,296.7,21.83,78.23,12.56,15.7914285714,2.57142857143,26.0714285714,5.55714285714,30.0,22.2,34.3
+sj,2008,20,2008-05-13,-0.0015,,0.1510833,0.09152857,3.66,299.455714286,299.357142857,295.308571429,302.2,296.4,4.12,78.27,3.66,16.6742857143,4.42857142857,27.9285714286,7.78571428571,32.8,22.8,3.0
+sj,2008,21,2008-05-20,,-0.01986667,0.1243286,0.1256857,0.0,299.69,299.728571429,294.402857143,303.0,296.9,2.2,73.0157142857,0.0,15.7757142857,4.34285714286,28.0571428571,6.27142857143,33.3,24.4,0.3
+sj,2008,22,2008-05-27,0.0568,0.03983333,0.06226667,0.07591429,0.76,299.78,299.671428571,294.76,302.3,297.3,4.36,74.0842857143,0.76,16.1371428571,3.54285714286,27.6142857143,7.08571428571,33.3,23.3,84.1
+sj,2008,23,2008-06-03,-0.044,-0.03046667,0.132,0.08352857,71.17,299.768571429,299.728571429,295.314285714,301.9,297.6,22.55,76.5571428571,71.17,16.6671428571,2.85714285714,28.0,5.17142857143,32.8,25.0,27.7
+sj,2008,24,2008-06-10,-0.0443,-0.024925,0.1322714,0.1591571,48.99,300.062857143,300.007142857,295.65,302.4,297.5,13.1,76.8442857143,48.99,17.01,3.15714285714,27.4,6.04285714286,31.1,23.3,91.7
+sj,2008,25,2008-06-17,,0.08215,0.1443714,0.1167286,30.81,300.484285714,300.578571429,295.997142857,303.5,297.5,7.2,76.87,30.81,17.42,3.9,28.7571428571,6.98571428571,34.4,24.4,0.3
+sj,2008,26,2008-06-24,0.0108,0.0499,0.1005714,0.1173286,8.02,300.601428571,300.621428571,296.268571429,302.5,298.5,17.1,77.3957142857,8.02,17.6785714286,2.78571428571,28.6571428571,6.24285714286,32.8,23.9,28.7
+sj,2008,27,2008-07-01,0.07266667,0.10666,0.1554286,0.1649,17.52,300.497142857,300.528571429,296.411428571,302.3,298.7,11.9,78.5342857143,17.52,17.8085714286,2.22857142857,28.4571428571,4.62857142857,31.1,25.0,2.9
+sj,2008,28,2008-07-08,-0.04645,0.006825,0.2602857,0.2147286,16.37,300.214285714,300.342857143,295.824285714,301.7,299.0,19.86,77.0214285714,16.37,17.2014285714,2.02857142857,27.7142857143,5.91428571429,31.1,23.9,22.1
+sj,2008,29,2008-07-15,,,0.1958429,0.1761571,4.34,300.448571429,300.607142857,296.177142857,302.3,298.7,5.49,77.6157142857,4.34,17.5714285714,2.61428571429,28.7857142857,5.01428571429,31.7,26.1,0.0
+sj,2008,30,2008-07-22,0.2083,0.4295,0.2776833,0.24565,3.39,300.598571429,300.721428571,296.512857143,302.3,298.9,13.62,78.56,3.39,17.94,2.58571428571,28.6857142857,6.31428571429,32.8,24.4,7.1
+sj,2008,31,2008-07-29,0.0002,0.0039,0.1090667,0.08648333,13.73,300.73,300.885714286,296.202857143,302.7,299.2,8.7,76.5214285714,13.73,17.6085714286,2.8,28.9857142857,6.17142857143,32.8,25.0,5.1
+sj,2008,32,2008-08-05,0.1122,0.0322,0.1941857,0.2057714,50.94,300.741428571,300.842857143,297.047142857,302.5,299.1,43.5,80.3714285714,50.94,18.5471428571,2.42857142857,28.3571428571,5.85714285714,32.2,23.9,37.6
+sj,2008,33,2008-08-12,,,0.0589,0.06564286,4.28,301.15,301.285714286,296.912857143,303.3,299.0,7.82,77.9685714286,4.28,18.4185714286,2.74285714286,29.2142857143,6.34285714286,33.9,25.0,1.8
+sj,2008,34,2008-08-19,0.28915,0.2410333,0.2406,0.2085571,31.97,300.735714286,300.814285714,296.828571429,302.6,298.6,65.9,79.5471428571,31.97,18.3557142857,2.54285714286,28.9714285714,5.32857142857,32.2,24.4,54.9
+sj,2008,35,2008-08-26,0.1132,,0.2260833,0.1982429,19.67,301.022857143,301.135714286,297.218571429,303.2,298.9,31.6,79.8642857143,19.67,18.7771428571,2.7,28.8571428571,5.47142857143,32.2,24.4,16.2
+sj,2008,36,2008-09-02,,0.0173,0.1904167,0.1199833,60.56,301.225714286,301.314285714,297.4,303.5,298.9,50.0,80.0242857143,60.56,19.0914285714,3.37142857143,29.3571428571,6.41428571429,35.0,25.0,6.9
+sj,2008,37,2008-09-09,0.3619,0.649,0.1464,0.1313857,126.68,300.804285714,300.935714286,297.275714286,303.6,298.8,58.4,81.3242857143,126.68,18.9014285714,2.98571428571,28.3857142857,6.42857142857,34.4,23.3,45.1
+sj,2008,38,2008-09-16,0.091375,0.16405,0.2516667,0.19645,48.44,300.757142857,300.871428571,297.081428571,303.3,298.9,28.1,80.4485714286,48.44,18.5957142857,3.11428571429,28.2285714286,6.27142857143,32.8,24.4,20.4
+sj,2008,39,2008-09-23,0.0795,0.103675,0.2826857,0.2613,153.79,300.378571429,300.45,296.535714286,303.3,298.1,136.91,79.8614285714,153.79,18.0342857143,2.81428571429,27.4,5.85714285714,32.2,22.8,146.3
+sj,2008,40,2008-09-30,-0.13735,0.13095,0.2718857,0.2700286,54.96,300.564285714,300.771428571,296.882857143,303.4,297.4,37.5,80.42,54.96,18.4285714286,3.05714285714,28.3571428571,7.05714285714,34.4,22.2,37.1
+sj,2008,41,2008-10-07,0.1306,0.0897,0.1860857,0.1964429,6.16,300.715714286,300.742857143,296.164285714,303.0,298.7,21.1,76.3614285714,6.16,17.6171428571,2.91428571429,28.1714285714,5.94285714286,31.7,24.4,8.5
+sj,2008,42,2008-10-14,0.1834,0.11755,0.1524571,0.1425,60.42,300.234285714,300.278571429,296.2,303.4,298.0,40.4,78.6585714286,60.42,17.6585714286,3.12857142857,27.2142857143,6.2,32.8,22.8,73.0
+sj,2008,43,2008-10-21,0.03325,0.07486667,0.3363143,0.2526571,91.7,299.734285714,299.878571429,295.888571429,302.6,297.8,22.7,79.4928571429,91.7,17.3371428571,2.52857142857,27.0142857143,5.32857142857,31.7,23.3,16.5
+sj,2008,44,2008-10-28,0.0834,0.0757,0.07362857,0.1237286,0.0,300.352857143,300.557142857,295.407142857,302.2,298.4,9.9,74.5057142857,0.0,16.8114285714,2.57142857143,27.6428571429,5.74285714286,31.1,23.9,6.4
+sj,2008,45,2008-11-04,-0.0944,-0.00495,0.1438,0.1303143,12.23,300.077142857,300.142857143,296.432857143,302.6,298.2,58.03,80.6185714286,12.23,17.8914285714,2.6,27.6142857143,5.75714285714,31.1,24.4,36.6
+sj,2008,46,2008-11-11,0.1011,0.074,0.2376,0.1755286,12.64,300.137142857,300.292857143,295.854285714,303.3,297.9,19.6,77.6342857143,12.64,17.3057142857,3.3,27.3857142857,5.92857142857,30.6,23.9,6.4
+sj,2008,47,2008-11-18,,0.044,0.2210429,0.1835286,22.49,299.712857143,299.757142857,295.664285714,301.9,298.0,49.42,78.64,22.49,17.1085714286,2.51428571429,26.8142857143,5.71428571429,30.6,23.3,56.9
+sj,2008,48,2008-11-25,0.03925,0.0731,0.1884,0.2118714,9.3,299.355714286,299.442857143,294.764285714,301.6,297.8,31.83,75.9971428571,9.3,16.1671428571,2.14285714286,26.4857142857,5.45714285714,30.0,22.8,32.8
+sj,2008,49,2008-12-02,-0.0874,0.1729,0.1455833,0.1098333,3.64,298.582857143,298.714285714,292.44,300.5,296.7,0.72,68.9442857143,3.64,13.9857142857,2.57142857143,25.2285714286,6.48571428571,28.9,21.7,4.1
+sj,2008,50,2008-12-09,0.0362,0.06956667,0.2926429,0.2735,0.0,298.552857143,298.571428571,293.29,300.0,296.7,9.52,72.79,0.0,14.7257142857,1.91428571429,25.5571428571,5.65714285714,28.9,22.2,11.2
+sj,2008,51,2008-12-16,0.0306,0.0238,0.2890286,0.2582286,7.75,298.575714286,298.6,294.054285714,300.2,297.2,25.75,76.2185714286,7.75,15.45,2.08571428571,26.2714285714,6.11428571429,30.6,21.7,37.9
+sj,2008,52,2008-12-23,-0.00395,-0.0159,0.1993143,0.16795,0.0,297.788571429,297.914285714,292.737142857,299.9,294.9,17.5,73.7785714286,0.0,14.2857142857,2.6,25.0714285714,6.02857142857,28.9,20.6,11.7
+sj,2009,1,2009-01-01,0.5004,0.161425,0.1607857,0.18865,,,,,,,,,,,,,,,,
+sj,2009,2,2009-01-08,-0.0814,0.0081,0.35324,0.2524,0.0,297.751428571,297.95,292.747142857,300.3,294.3,3.45,73.9542857143,0.0,14.2857142857,2.87142857143,25.0714285714,6.2,28.9,20.6,3.6
+sj,2009,3,2009-01-15,0.0764,0.0102,0.1719333,0.1197714,0.0,298.291428571,298.535714286,294.052857143,299.8,297.2,6.5,77.5228571429,0.0,15.4214285714,1.98571428571,25.9285714286,6.02857142857,29.4,22.2,8.5
+sj,2009,4,2009-01-22,0.03183333,0.01133333,0.1108286,0.1701429,9.09,297.921428571,298.107142857,294.185714286,300.2,296.4,29.9,80.02,9.09,15.5385714286,2.5,25.9,6.11428571429,31.1,21.7,18.6
+sj,2009,5,2009-01-29,0.0626,-0.00625,0.2114667,0.1452333,0.0,298.042857143,298.242857143,294.595714286,299.8,296.6,21.1,81.3328571429,0.0,15.9528571429,2.28571428571,26.1857142857,6.51428571429,31.1,21.7,22.6
+sj,2009,6,2009-02-05,0.0162,0.000625,0.1229,0.1317,0.0,297.89,298.078571429,293.738571429,300.4,295.6,12.0,77.83,0.0,15.1085714286,2.78571428571,25.5714285714,5.78571428571,30.0,21.7,11.7
+sj,2009,7,2009-02-12,0.0558,0.07665,0.2572,0.2180143,0.0,297.542857143,297.735714286,293.19,300.0,295.7,32.43,76.9514285714,0.0,14.6071428571,2.32857142857,25.3571428571,6.4,30.6,21.7,62.8
+sj,2009,8,2009-02-19,0.0374,0.07305,0.1799714,0.1514429,11.01,297.355714286,297.492857143,292.295714286,300.1,295.9,31.2,73.5842857143,11.01,13.8214285714,2.35714285714,25.0285714286,5.71428571429,30.0,21.7,14.6
+sj,2009,9,2009-02-26,0.4708,0.2018,0.3043,0.2088167,5.82,297.605714286,297.75,292.488571429,299.6,295.0,5.0,73.2571428571,5.82,13.9785714286,2.35714285714,25.2,6.25714285714,30.0,20.6,5.8
+sj,2009,10,2009-03-05,0.0714,-0.05,0.2076714,0.1410571,63.28,297.9,298.135714286,293.015714286,299.9,296.3,4.08,74.3057142857,63.28,14.4614285714,2.7,25.7285714286,6.88571428571,30.0,21.7,1.0
+sj,2009,11,2009-03-12,,-0.0287,0.07662857,0.08174286,31.47,296.804285714,296.842857143,292.012857143,299.6,295.2,33.5,74.9171428571,31.47,13.6685714286,1.8,25.5,4.84285714286,31.1,21.7,21.6
+sj,2009,12,2009-03-19,0.0025,0.00592,0.2417714,0.1799143,0.0,296.651428571,296.792857143,291.351428571,298.4,295.2,10.06,72.2585714286,0.0,13.0128571429,2.18571428571,25.0,5.37142857143,28.3,21.1,25.5
+sj,2009,13,2009-03-26,-0.1295667,-0.06473333,0.1990714,0.1755429,9.09,297.07,297.2,292.311428571,300.0,295.1,24.84,74.93,9.09,13.8585714286,3.65714285714,25.2714285714,6.88571428571,30.0,21.1,21.9
+sj,2009,14,2009-04-02,0.1003,0.1035,0.1227,0.1065143,3.79,296.692857143,296.792857143,291.425714286,298.9,294.1,9.4,72.4642857143,3.79,13.1171428571,2.41428571429,25.0571428571,5.54285714286,28.9,21.1,3.8
+sj,2009,15,2009-04-09,-0.04683333,0.03844,0.1654429,0.1341857,0.0,297.508571429,297.7,292.701428571,299.7,296.0,3.74,74.7285714286,0.0,14.1885714286,2.91428571429,25.7285714286,6.41428571429,30.0,21.7,13.0
+sj,2009,16,2009-04-16,,-0.0276,0.1130286,0.1084429,0.0,298.248571429,298.3,293.241428571,300.2,296.1,0.5,73.9214285714,0.0,14.6628571429,3.28571428571,26.5714285714,7.0,30.6,22.8,0.9
+sj,2009,17,2009-04-23,-0.0266,0.0271,0.1302286,0.1296143,14.71,298.532857143,298.742857143,293.582857143,301.0,296.1,4.5,74.1928571429,14.71,14.98,3.2,26.8,7.54285714286,32.8,22.2,35.0
+sj,2009,18,2009-04-30,0.0558,0.0407,0.1873143,0.1395286,18.69,298.602857143,298.75,294.055714286,300.8,296.9,10.9,76.1242857143,18.69,15.4214285714,2.35714285714,26.7285714286,6.21428571429,31.7,22.2,23.6
+sj,2009,19,2009-05-07,0.0584,0.0277,0.048,0.04892857,8.25,298.071428571,298.142857143,293.538571429,300.0,295.6,15.6,76.06,8.25,14.9414285714,2.65714285714,26.2571428571,5.41428571429,30.0,22.2,13.7
+sj,2009,20,2009-05-14,0.03605,0.05396667,0.1071429,0.1168571,34.87,298.218571429,298.257142857,294.987142857,300.1,297.1,29.93,82.3328571429,34.87,16.3342857143,1.74285714286,26.5857142857,4.7,30.6,23.3,23.4
+sj,2009,21,2009-05-21,0.0736,0.04505,0.1062143,0.1195857,28.6,297.971428571,298.0,294.715714286,299.5,296.6,65.47,82.2571428571,28.6,16.0957142857,1.8,26.2571428571,4.72857142857,29.4,22.8,44.2
+sj,2009,22,2009-05-28,,0.044,0.2181571,0.1863,92.89,299.265714286,299.321428571,296.405714286,301.2,297.4,18.3,84.4142857143,92.89,17.8557142857,2.5,27.6142857143,5.71428571429,31.1,23.9,46.7
+sj,2009,23,2009-06-04,-0.0021,0.0656,0.1694714,0.1681,19.06,299.744285714,299.75,295.607142857,301.9,297.3,5.22,78.3085714286,19.06,17.0071428571,2.81428571429,27.7571428571,5.8,33.3,23.3,44.7
+sj,2009,24,2009-06-11,,0.0713,0.08968571,0.0782,34.18,299.56,299.528571429,295.655714286,301.5,297.9,23.83,79.2714285714,34.18,17.0385714286,2.62857142857,27.8142857143,6.45714285714,32.2,23.9,78.7
+sj,2009,25,2009-06-18,0.03945,0.035,0.1112143,0.1364286,55.21,299.951428571,299.957142857,296.131428571,301.7,298.4,8.61,79.7214285714,55.21,17.5414285714,2.45714285714,28.0571428571,6.28571428571,32.8,24.4,80.1
+sj,2009,26,2009-06-25,0.02156667,0.01685,0.18475,0.2024143,38.8,300.241428571,300.228571429,295.688571429,302.4,298.2,9.6,76.37,38.8,17.11,2.91428571429,28.6571428571,6.98571428571,33.3,24.4,40.0
+sj,2009,27,2009-07-02,-0.0798,0.00745,0.2403333,0.2286,19.38,300.621428571,300.592857143,296.245714286,302.7,297.7,4.0,77.3214285714,19.38,17.6771428571,3.75714285714,29.7857142857,6.65714285714,33.9,26.1,0.0
+sj,2009,28,2009-07-09,0.02915,0.1117333,0.1795286,0.1759714,40.29,300.87,300.928571429,296.43,302.8,298.8,11.49,76.9185714286,40.29,17.8557142857,2.82857142857,29.1285714286,6.57142857143,33.9,23.9,50.0
+sj,2009,29,2009-07-16,0.0501,0.069,0.2032333,0.2080429,5.22,300.717142857,300.821428571,296.752857143,302.6,298.7,15.43,79.1828571429,5.22,18.2128571429,2.87142857143,29.3571428571,5.34285714286,32.8,26.1,12.7
+sj,2009,30,2009-07-23,0.0067,0.05496667,0.1936286,0.1653857,8.15,300.758571429,300.842857143,296.877142857,302.6,298.8,27.4,79.5842857143,8.15,18.33,2.82857142857,29.3285714286,5.95714285714,32.8,24.4,28.2
+sj,2009,31,2009-07-30,0.0838,0.1409333,0.1300714,0.1130571,26.35,300.865714286,300.871428571,296.812857143,302.6,299.0,26.64,78.73,26.35,18.2785714286,2.65714285714,29.3714285714,6.18571428571,32.8,23.9,61.5
+sj,2009,32,2009-08-06,-0.002,-0.035525,0.2497143,0.1535429,6.73,300.83,300.907142857,296.532857143,302.4,299.4,20.01,77.5728571429,6.73,17.9742857143,2.35714285714,29.3142857143,5.55714285714,32.8,25.6,9.4
+sj,2009,33,2009-08-13,0.0323,0.04776667,0.1554143,0.1342714,16.15,300.924285714,300.971428571,296.681428571,302.5,298.9,21.5,77.8357142857,16.15,18.1314285714,2.34285714286,28.8142857143,6.32857142857,33.3,25.0,36.1
+sj,2009,34,2009-08-20,,0.02,0.1940333,0.2151857,90.59,300.72,300.785714286,296.764285714,302.3,299.1,49.1,79.1828571429,90.59,18.2528571429,2.45714285714,28.9142857143,5.78571428571,32.8,25.6,86.7
+sj,2009,35,2009-08-27,,-0.0002333333,0.2517,0.2129143,15.02,300.877142857,300.942857143,297.01,303.7,298.4,32.72,79.7,15.02,18.5714285714,2.88571428571,29.4714285714,5.22857142857,33.9,26.7,11.3
+sj,2009,36,2009-09-03,-0.01276667,0.0009,0.1799,0.1595143,9.63,301.101428571,301.214285714,296.554285714,303.7,299.1,8.1,76.5442857143,9.63,18.0442857143,2.82857142857,29.5285714286,7.07142857143,35.0,24.4,76.3
+sj,2009,37,2009-09-10,0.0595,0.08106,0.1314286,0.09584286,30.56,300.621428571,300.707142857,296.908571429,302.9,298.3,49.2,80.3257142857,30.56,18.4114285714,2.5,28.6428571429,5.02857142857,31.7,23.3,21.4
+sj,2009,38,2009-09-17,0.0879,0.07886667,0.08078571,0.07994286,9.52,300.842857143,300.85,296.588571429,303.2,298.5,10.0,77.8542857143,9.52,18.0757142857,3.35714285714,29.2,6.34285714286,34.4,25.0,104.7
+sj,2009,39,2009-09-24,-0.06316667,0.058325,0.1537143,0.1367429,53.19,300.772857143,300.807142857,296.405714286,302.7,298.8,23.52,77.2185714286,53.19,17.8657142857,2.98571428571,28.6428571429,6.54285714286,34.4,23.9,35.8
+sj,2009,40,2009-10-01,,0.006025,0.1571,0.1427429,43.31,301.144285714,301.221428571,297.052857143,303.7,299.1,15.4,78.5514285714,43.31,18.5814285714,3.01428571429,29.3571428571,5.78571428571,33.3,25.6,1.6
+sj,2009,41,2009-10-08,0.3461,0.04855,0.1787667,0.2105,60.94,301.345714286,301.378571429,297.091428571,303.6,299.4,28.47,77.7671428571,60.94,18.6114285714,2.58571428571,29.7285714286,6.1,33.3,26.1,7.4
+sj,2009,42,2009-10-15,0.19475,0.135325,0.2547429,0.2541143,20.01,301.045714286,301.2,297.228571429,303.5,299.2,40.1,79.9157142857,20.01,18.7785714286,2.88571428571,29.5428571429,5.38571428571,33.3,25.6,29.5
+sj,2009,43,2009-10-22,-0.07906667,-0.12845,0.2722429,0.2278143,5.52,300.831428571,300.985714286,296.9,303.1,299.0,18.7,79.3128571429,5.52,18.4242857143,2.54285714286,28.9857142857,6.34285714286,33.3,24.4,18.6
+sj,2009,44,2009-10-29,,-6.666667e-05,0.2418571,0.2270429,10.07,300.757142857,300.8,295.995714286,302.6,298.6,15.38,75.4471428571,10.07,17.4685714286,2.88571428571,29.1,6.5,33.9,25.0,2.1
+sj,2009,45,2009-11-05,,-0.1572,0.1306714,0.1443857,12.01,300.407142857,300.414285714,295.571428571,302.3,298.6,9.11,75.0357142857,12.01,17.0271428571,2.82857142857,28.2714285714,5.71428571429,32.2,25.0,36.0
+sj,2009,46,2009-11-12,,-0.206,0.2320833,0.1026857,51.55,300.204285714,300.135714286,295.954285714,301.9,298.2,37.29,77.6657142857,51.55,17.4028571429,2.38571428571,27.4,5.42857142857,30.6,22.8,121.1
+sj,2009,47,2009-11-19,0.0291,-0.03568,0.1349833,0.1323,94.13,300.104285714,300.314285714,296.135714286,303.3,297.6,19.1,79.0542857143,94.13,17.65,3.17142857143,27.7285714286,6.9,32.8,23.9,97.3
+sj,2009,48,2009-11-26,-0.0033,,0.2258857,0.1390429,41.17,299.988571429,300.135714286,296.444285714,301.9,297.7,12.5,81.1328571429,41.17,17.9428571429,2.92857142857,27.3,6.21428571429,32.8,23.3,68.7
+sj,2009,49,2009-12-03,0.17255,0.1421,0.2154571,0.2151571,3.27,300.038571429,300.15,295.387142857,302.0,298.0,1.42,75.7842857143,3.27,16.7928571429,2.64285714286,26.8571428571,6.2,30.6,23.3,20.1
+sj,2009,50,2009-12-10,-0.0192,-0.04448,0.1941167,0.1522,0.0,300.025714286,300.221428571,295.412857143,301.8,298.5,11.5,75.99,0.0,16.81,2.15714285714,27.1285714286,5.91428571429,30.6,23.3,12.0
+sj,2009,51,2009-12-17,0.3517,0.17815,0.2365571,0.2147286,1.88,299.718571429,299.814285714,295.38,301.4,298.3,17.9,77.1914285714,1.88,16.7357142857,2.08571428571,26.6857142857,5.78571428571,30.6,22.2,28.4
+sj,2009,52,2009-12-24,-0.07163333,-0.0481,0.172225,0.1085875,0.0,299.448571429,299.557142857,294.702857143,301.5,297.4,3.0,75.3514285714,0.0,16.1214285714,2.65714285714,26.7142857143,6.04285714286,31.7,22.8,1.8
+sj,2010,53,2010-01-01,,,,,,,,,,,,,,,,,,,,
+sj,2010,1,2010-01-08,0.332,0.0412,0.2023833,0.1897,0.0,298.66,298.828571429,294.777142857,301.7,296.6,17.76,79.3242857143,0.0,16.1514285714,2.91428571429,26.4571428571,6.58571428571,31.7,21.7,0.3
+sj,2010,2,2010-01-15,0.0227,0.0227,0.1767714,0.1582143,6.24,298.452857143,298.664285714,294.4,301.6,296.5,16.97,78.6457142857,6.24,15.7842857143,3.04285714286,25.6142857143,7.07142857143,31.7,20.6,48.6
+sj,2010,3,2010-01-22,0.2409,0.11044,0.1177714,0.1079,0.0,297.837142857,297.957142857,295.218571429,300.5,296.3,56.9,85.5385714286,0.0,16.5514285714,2.02857142857,25.0857142857,4.84285714286,29.4,21.7,207.7
+sj,2010,4,2010-01-29,0.0799,0.03605,0.2159429,0.1729714,8.69,298.541428571,298.642857143,294.9,301.1,296.4,7.77,80.38,8.69,16.2771428571,2.71428571429,25.7857142857,5.54285714286,30.6,22.8,20.3
+sj,2010,5,2010-02-05,0.0375,0.0782,0.1250143,0.1347571,0.0,298.19,298.285714286,292.887142857,299.7,296.6,7.6,72.6085714286,0.0,14.3628571429,2.02857142857,24.9714285714,6.72857142857,28.9,20.0,5.2
+sj,2010,6,2010-02-12,0.478,0.2132333,0.2625286,0.2623,0.0,298.76,298.957142857,293.441428571,301.7,296.1,0.3,72.5285714286,0.0,14.8814285714,3.71428571429,26.3142857143,7.7,31.1,21.7,0.0
+sj,2010,7,2010-02-19,,0.0286,0.13875,0.1762286,0.0,298.837142857,299.192857143,294.394285714,302.3,296.6,2.5,76.6557142857,0.0,15.7971428571,3.98571428571,26.3857142857,7.52857142857,31.1,21.7,1.8
+sj,2010,8,2010-02-26,-0.02973333,-0.06515,0.09831667,0.08487143,20.28,298.607142857,298.714285714,294.44,302.0,296.6,30.3,78.02,20.28,15.84,2.68571428571,26.7571428571,6.6,32.8,22.2,4.8
+sj,2010,9,2010-03-05,0.0479,0.00168,0.1630833,0.1480167,0.0,299.298571429,299.635714286,295.811428571,302.0,297.3,15.29,81.3057142857,0.0,17.2571428571,3.75714285714,27.5714285714,6.77142857143,33.9,22.8,20.6
+sj,2010,10,2010-03-12,,-0.0111,0.04485714,0.02208571,0.0,298.218571429,298.25,294.538571429,302.2,293.8,43.5,80.4328571429,0.0,16.0228571429,3.01428571429,25.9,5.95714285714,33.3,20.0,43.0
+sj,2010,11,2010-03-19,-0.101,-0.1214333,0.2296429,0.1776143,0.0,298.168571429,298.235714286,294.442857143,302.1,295.0,26.1,80.0085714286,0.0,15.9071428571,2.9,26.1857142857,6.51428571429,33.3,21.1,35.1
+sj,2010,12,2010-03-26,-0.008233333,-0.0748,0.2853714,0.1961,6.92,299.937142857,300.135714286,295.708571429,302.9,296.8,1.8,77.8571428571,6.92,17.1071428571,3.58571428571,28.0428571429,8.02857142857,33.3,22.2,0.3
+sj,2010,13,2010-04-02,-0.06055,0.00845,0.3026857,0.2249429,0.0,299.79,300.085714286,294.957142857,301.9,298.0,0.8,74.9657142857,0.0,16.35,3.08571428571,27.5571428571,7.01428571429,31.7,23.3,0.0
+sj,2010,14,2010-04-09,-0.073,-0.05613333,0.2341286,0.1856857,11.01,298.801428571,298.985714286,293.36,302.0,296.2,6.85,72.2,11.01,14.9242857143,2.85714285714,26.7714285714,6.75714285714,33.9,22.2,0.0
+sj,2010,15,2010-04-16,0.0197,0.0132,0.1681286,0.1347571,0.0,298.541428571,298.65,293.574285714,300.6,296.1,12.3,74.1542857143,0.0,15.0142857143,2.67142857143,26.1857142857,6.57142857143,30.0,21.1,17.6
+sj,2010,16,2010-04-23,0.06955,,0.1177429,0.0991,28.28,298.628571429,298.778571429,295.007142857,301.7,297.1,48.3,80.63,28.28,16.4671428571,2.55714285714,26.5285714286,5.8,32.2,22.8,48.4
+sj,2010,17,2010-04-30,-0.2154,-0.04085,0.0683,0.05615714,43.33,299.662857143,299.828571429,296.558571429,301.8,298.2,30.9,83.18,43.33,18.0757142857,2.54285714286,27.8,5.25714285714,32.8,23.3,21.9
+sj,2010,18,2010-05-07,0.00145,-0.0115,0.2146,0.2137857,13.3,300.294285714,300.364285714,296.421428571,303.1,298.2,24.08,79.6928571429,13.3,17.8471428571,3.27142857143,28.5285714286,6.4,34.4,22.8,31.7
+sj,2010,19,2010-05-14,-0.02065,0.004166667,0.1366429,0.1660143,19.1,299.502857143,299.657142857,295.551428571,301.9,297.7,14.2,79.1685714286,19.1,16.99,2.42857142857,27.0,5.62857142857,30.6,23.3,83.3
+sj,2010,20,2010-05-21,0.0653,0.0993,0.1733143,0.1671429,17.51,299.791428571,299.842857143,296.314285714,301.8,298.6,41.5,81.3571428571,17.51,17.7371428571,2.2,27.8714285714,5.25714285714,31.1,24.4,85.3
+sj,2010,21,2010-05-28,0.1254,0.02483333,0.1619,0.2083571,31.56,300.344285714,300.521428571,296.451428571,302.5,298.4,15.6,79.4028571429,31.56,17.9285714286,3.21428571429,28.2142857143,6.75714285714,32.8,23.9,61.5
+sj,2010,22,2010-06-04,0.05803333,0.0776,0.08121667,0.1078571,125.84,300.362857143,300.357142857,297.661428571,302.7,298.2,174.8,85.3457142857,125.84,19.31,2.4,28.4285714286,5.7,32.8,25.0,56.2
+sj,2010,23,2010-06-11,-0.0351,-0.022475,0.15555,0.1512714,62.16,300.938571429,301.128571429,297.394285714,303.2,299.2,8.1,81.3028571429,62.16,18.9528571429,3.11428571429,28.9714285714,5.87142857143,33.3,25.0,17.7
+sj,2010,24,2010-06-18,0.0371,0.072075,0.3342857,0.2732286,18.94,301.03,301.114285714,296.988571429,302.9,299.3,13.08,78.8642857143,18.94,18.4842857143,2.65714285714,28.7,5.81428571429,32.2,25.0,27.4
+sj,2010,25,2010-06-25,0.072175,0.05403333,0.1621,0.1322429,64.77,300.268571429,300.278571429,297.1,302.7,298.3,78.6,83.0014285714,64.77,18.6128571429,2.21428571429,27.4571428571,4.92857142857,31.7,23.3,100.1
+sj,2010,26,2010-07-02,-0.0817,-0.0171,0.1785429,0.1252143,78.93,300.312857143,300.421428571,297.302857143,302.6,298.7,36.12,83.6914285714,78.93,18.8471428571,2.47142857143,27.4285714286,6.24285714286,32.2,23.3,72.2
+sj,2010,27,2010-07-09,-0.0153,-0.005,0.2143857,0.1765571,9.91,300.871428571,300.978571429,297.5,302.7,299.3,27.57,82.0114285714,9.91,19.0614285714,2.58571428571,28.8571428571,5.7,32.2,24.4,46.0
+sj,2010,28,2010-07-16,0.099,0.0356,0.2079,0.2079571,28.44,301.101428571,301.192857143,297.604285714,303.4,298.9,24.47,81.4942857143,28.44,19.2085714286,2.64285714286,29.1857142857,6.25714285714,33.9,23.9,7.2
+sj,2010,29,2010-07-23,0.009833333,0.03178,0.05115714,0.07565714,93.3,300.247142857,300.371428571,297.28,302.2,298.8,100.9,84.0114285714,93.3,18.8357142857,2.57142857143,27.8571428571,5.88571428571,32.2,23.3,105.1
+sj,2010,30,2010-07-30,0.08335,0.052,0.1494714,0.1137857,95.05,300.155714286,300.178571429,297.328571429,302.1,298.6,40.09,84.71,95.05,18.8685714286,2.12857142857,27.3285714286,5.22857142857,31.7,22.8,67.5
+sj,2010,31,2010-08-06,-0.01335,-0.02223333,0.2392714,0.2311714,12.19,300.845714286,300.885714286,297.215714286,302.6,299.1,19.56,80.7428571429,12.19,18.7642857143,2.8,28.8857142857,5.48571428571,31.7,25.0,15.2
+sj,2010,32,2010-08-13,,-0.0004,0.0749,0.1157333,3.1,301.214285714,301.164285714,297.417142857,303.6,299.3,39.9,80.0414285714,3.1,19.02,2.61428571429,29.4571428571,6.0,34.4,25.0,11.4
+sj,2010,33,2010-08-20,-0.08675,-0.0105,0.13295,0.1404833,55.55,300.91,301.007142857,297.335714286,303.3,298.9,40.21,81.0628571429,55.55,18.9071428571,3.12857142857,28.5142857143,5.7,32.2,25.0,67.1
+sj,2010,34,2010-08-27,0.03126667,0.128875,0.2844714,0.2008571,23.58,301.127142857,301.2,297.421428571,303.8,298.5,34.08,80.4528571429,23.58,19.03,2.71428571429,29.2,5.78571428571,33.9,25.0,13.7
+sj,2010,35,2010-09-03,,0.08176667,0.1728857,0.1753,42.86,301.507142857,301.542857143,297.424285714,304.1,299.3,87.1,78.7157142857,42.86,19.0514285714,3.34285714286,28.9428571429,5.17142857143,32.2,24.4,103.4
+sj,2010,36,2010-09-10,0.3101,0.1785667,0.1176333,0.1335167,44.44,301.364285714,301.464285714,297.45,304.0,299.4,31.7,79.5028571429,44.44,19.0871428571,2.9,29.0571428571,5.72857142857,34.4,25.0,32.8
+sj,2010,37,2010-09-17,0.0029,0.02006667,0.2180571,0.1339714,57.8,300.948571429,300.9,297.407142857,302.5,299.3,56.1,81.2114285714,57.8,19.0271428571,2.31428571429,28.4142857143,5.32857142857,31.7,24.4,77.1
+sj,2010,38,2010-09-24,0.1101,0.07806667,0.1541429,0.1087714,11.72,301.09,301.221428571,296.964285714,303.2,299.2,27.6,78.3628571429,11.72,18.5557142857,3.18571428571,28.6428571429,6.5,33.3,25.0,71.7
+sj,2010,39,2010-10-01,,0.08916667,0.1352143,0.1002,28.17,300.905714286,300.835714286,296.91,302.6,298.9,30.65,79.0171428571,28.17,18.4571428571,2.67142857143,27.8714285714,5.42857142857,31.1,24.4,48.0
+sj,2010,40,2010-10-08,0.08545,0.0887,0.1388,0.1544,90.87,300.725714286,300.757142857,297.104285714,302.8,299.0,32.52,80.7928571429,90.87,18.7242857143,2.82857142857,28.1,5.4,32.2,25.0,21.8
+sj,2010,41,2010-10-15,0.2535,0.1899333,0.1137571,0.1099286,132.05,300.831428571,300.885714286,297.372857143,303.3,298.9,37.9,81.6242857143,132.05,19.0285714286,2.85714285714,28.2,6.58571428571,33.3,24.4,85.7
+sj,2010,42,2010-10-22,0.18415,0.164325,0.3621,0.3181286,4.24,300.891428571,300.971428571,296.664285714,303.0,298.1,14.5,77.9928571429,4.24,18.1757142857,3.54285714286,28.0714285714,6.12857142857,32.8,24.4,24.4
+sj,2010,43,2010-10-29,-0.0157,-0.09115,0.3367,0.2160714,1.24,300.914285714,300.985714286,295.712857143,303.3,298.5,4.8,73.4828571429,1.24,17.1542857143,3.05714285714,28.0142857143,6.37142857143,33.3,23.9,12.1
+sj,2010,44,2010-11-05,-0.2052,0.13015,0.1387143,0.1344143,10.37,300.325714286,300.364285714,296.002857143,302.2,298.3,55.3,77.4014285714,10.37,17.4614285714,2.64285714286,27.8857142857,6.34285714286,32.2,22.8,61.7
+sj,2010,45,2010-11-12,0.0532,0.04565,0.1268667,0.08613333,89.65,299.848571429,299.75,296.415714286,301.7,297.8,120.7,81.5514285714,89.65,17.9428571429,1.98571428571,27.5285714286,6.02857142857,32.2,23.3,120.0
+sj,2010,46,2010-11-19,-0.18265,0.1144667,0.10925,0.08024286,42.65,298.954285714,299.121428571,294.737142857,301.7,296.9,34.0,78.03,42.65,16.2385714286,3.12857142857,26.2857142857,5.0,30.0,22.8,48.6
+sj,2010,47,2010-11-26,-0.212,0.0148,0.2818571,0.2147286,1.08,299.258571429,299.271428571,293.544285714,300.7,297.2,17.58,70.9328571429,1.08,14.99,2.17142857143,26.1571428571,5.7,29.4,22.2,27.5
+sj,2010,48,2010-12-03,-0.0527,0.01235,0.1708857,0.175,2.12,298.882857143,298.942857143,293.21,300.3,296.7,19.0,71.0842857143,2.12,14.6957142857,1.94285714286,25.6857142857,5.4,28.9,21.1,6.0
+sj,2010,49,2010-12-10,0.4955,,0.2561,0.2230571,0.0,298.002857143,297.764285714,290.877142857,299.7,294.8,3.7,64.92,0.0,12.7514285714,3.44285714286,24.6571428571,6.8,28.3,20.0,5.1
+sj,2010,50,2010-12-17,-0.1851667,-0.132375,0.209,0.2016571,32.9,298.822857143,298.928571429,294.77,301.3,296.3,8.76,78.5142857143,32.9,16.1842857143,3.57142857143,26.1285714286,5.94285714286,31.1,22.8,45.2
+sj,2010,51,2010-12-24,0.0223,-0.03633333,0.1317143,0.1273571,15.16,298.09,298.15,293.75,301.4,296.1,30.8,77.07,15.16,15.2071428571,2.7,25.2,5.48571428571,30.6,21.1,118.4
+sj,2011,52,2011-01-01,0.065,,0.1623286,0.1499111,7.57,298.247142857,298.2,293.402857143,300.0,296.9,8.3,74.5685714286,7.57,14.7171428571,1.97142857143,25.4285714286,5.08571428571,28.3,22.2,5.7
+sj,2011,1,2011-01-08,0.00895,0.01385,0.1041143,0.07068571,9.17,296.982857143,296.928571429,292.712857143,298.2,295.8,27.68,77.1571428571,9.17,14.1957142857,1.48571428571,24.1571428571,4.04285714286,27.2,20.6,23.2
+sj,2011,2,2011-01-15,,-0.03813333,0.1226143,0.1074,7.58,297.898571429,298.028571429,294.548571429,300.1,296.4,5.7,81.7714285714,7.58,15.8928571429,2.11428571429,25.0857142857,6.67142857143,31.7,21.1,24.1
+sj,2011,3,2011-01-22,-0.1112,-0.041775,0.3041714,0.2455429,10.11,298.294285714,298.478571429,294.584285714,300.1,297.1,7.2,80.0757142857,10.11,15.8742857143,2.12857142857,25.4142857143,5.94285714286,30.0,21.7,16.3
+sj,2011,4,2011-01-29,-0.101,0.0288,0.2506143,0.2021857,0.0,298.314285714,298.557142857,294.244285714,300.3,296.9,0.3,78.2142857143,0.0,15.5442857143,2.85714285714,25.2857142857,6.95714285714,30.0,20.6,2.5
+sj,2011,5,2011-02-05,-0.0679,0.05163333,0.1912429,0.1955286,0.0,298.1,298.414285714,293.485714286,300.1,296.7,1.1,75.5814285714,0.0,14.7942857143,2.8,25.0714285714,6.97142857143,29.4,20.6,6.1
+sj,2011,6,2011-02-12,-0.06153333,0.04316667,0.1529857,0.1240429,0.0,298.05,298.257142857,293.741428571,299.9,296.3,3.7,77.1514285714,0.0,15.05,2.54285714286,25.6285714286,6.64285714286,30.0,21.1,8.8
+sj,2011,7,2011-02-19,,-0.09375,0.2440857,0.1502286,0.0,298.211428571,298.364285714,294.098571429,300.0,296.8,2.44,77.9471428571,0.0,15.3628571429,2.64285714286,26.0,6.5,30.0,22.2,20.9
+sj,2011,8,2011-02-26,-0.04325,0.015975,0.2521857,0.1530286,0.0,297.567142857,297.728571429,293.92,300.2,295.8,22.5,80.1685714286,0.0,15.2185714286,2.48571428571,25.2,6.25714285714,29.4,21.7,25.1
+sj,2011,9,2011-03-05,-0.03105,-0.0164,0.1585,0.1749833,8.04,297.287142857,297.3,291.548571429,298.8,295.4,0.4,70.3257142857,8.04,13.0985714286,2.17142857143,24.7857142857,5.7,28.3,21.1,1.0
+sj,2011,10,2011-03-12,-0.08743333,-0.09346667,0.2900714,0.1417,10.56,297.26,297.35,292.582857143,299.3,295.7,4.4,75.2285714286,10.56,14.0242857143,2.55714285714,25.1571428571,6.67142857143,28.9,20.6,3.3
+sj,2011,11,2011-03-19,-0.16475,-0.0063,0.2117714,0.2136857,0.0,296.95,297.05,290.818571429,298.8,294.7,2.8,68.6885714286,0.0,12.5371428571,2.44285714286,24.9571428571,5.65714285714,28.3,21.1,2.1
+sj,2011,12,2011-03-26,,0.09122,0.2114714,0.1593286,0.0,297.18,297.171428571,292.247142857,299.0,295.0,16.1,74.0228571429,0.0,13.6985714286,2.62857142857,25.1,6.54285714286,29.4,20.6,11.6
+sj,2011,13,2011-04-02,-0.0839,0.03255,0.1813286,0.1812,15.13,297.682857143,297.792857143,294.002857143,300.4,295.1,13.16,80.1414285714,15.13,15.3457142857,2.52857142857,25.7142857143,7.14285714286,31.1,20.6,12.1
+sj,2011,14,2011-04-09,0.05416,0.07942,0.1561429,0.1509571,1.9,298.52,298.671428571,294.791428571,300.6,296.8,6.9,80.0857142857,1.9,16.0928571429,2.74285714286,27.0,7.8,32.8,21.7,4.6
+sj,2011,15,2011-04-16,0.073,0.06053333,0.1756143,0.1548,0.0,298.291428571,298.485714286,293.414285714,300.4,296.8,0.7,74.3985714286,0.0,14.7385714286,2.62857142857,26.0,6.81428571429,30.6,21.7,6.8
+sj,2011,16,2011-04-23,,0.1077,0.2231286,0.2218,31.97,297.895714286,297.971428571,293.735714286,299.6,296.6,12.0,77.7242857143,31.97,15.0814285714,2.14285714286,25.8714285714,5.92857142857,29.4,22.2,23.1
+sj,2011,17,2011-04-30,-0.07795,-0.2118,0.1421571,0.1457,2.95,298.297142857,298.521428571,293.551428571,300.4,296.7,3.7,74.9914285714,2.95,14.9057142857,2.84285714286,26.5142857143,6.27142857143,30.6,22.8,0.3
+sj,2011,18,2011-05-07,-0.04453333,-0.0261,0.1282333,0.1023714,41.53,298.492857143,298.478571429,295.101428571,300.2,297.1,31.1,81.63,41.53,16.3914285714,1.78571428571,26.0857142857,5.07142857143,30.6,22.8,89.5
+sj,2011,19,2011-05-14,-0.06685,0.0039,0.1433286,0.1329429,9.53,298.235714286,298.321428571,293.391428571,299.9,296.7,7.2,74.6028571429,9.53,14.7814285714,1.92857142857,26.0714285714,4.92857142857,29.4,22.8,0.0
+sj,2011,20,2011-05-21,,0.087875,0.1036833,0.09585714,72.74,298.067142857,298.142857143,295.245714286,300.5,295.5,301.4,84.4528571429,72.74,16.5942857143,2.28571428571,26.8,6.02857142857,32.8,21.1,40.4
+sj,2011,21,2011-05-28,0.06186667,0.076725,0.06075714,0.07672857,69.66,298.782857143,298.828571429,296.398571429,300.7,296.8,276.9,86.7814285714,69.66,17.7785714286,2.28571428571,25.9428571429,6.17142857143,30.0,20.6,84.3
+sj,2011,22,2011-06-04,0.05805,0.07835,0.1345286,0.1158429,76.75,299.775714286,299.807142857,296.785714286,301.7,298.1,28.5,83.7085714286,76.75,18.2014285714,1.87142857143,27.4142857143,5.34285714286,30.6,23.9,61.3
+sj,2011,23,2011-06-11,0.0253,0.06476667,0.06235714,0.05914286,71.88,299.498571429,299.592857143,296.714285714,301.5,297.7,37.3,84.7085714286,71.88,18.1214285714,1.81428571429,26.5571428571,6.3,30.6,21.1,108.4
+sj,2011,24,2011-06-18,0.06785,0.09993333,0.1639143,0.2054143,52.92,300.214285714,300.228571429,297.794285714,302.1,297.8,203.8,86.6785714286,52.92,19.34,2.05714285714,27.8428571429,6.75714285714,33.9,22.8,200.6
+sj,2011,25,2011-06-25,0.0753,0.08775,0.241,0.2038571,28.95,300.698571429,300.735714286,297.532857143,302.4,299.4,15.2,82.8971428571,28.95,18.9871428571,1.98571428571,28.2142857143,6.57142857143,33.3,22.2,70.8
+sj,2011,26,2011-07-02,0.09443333,0.10244,0.1341714,0.1007286,75.82,300.641428571,300.671428571,297.311428571,302.5,299.4,13.6,82.08,75.82,18.72,2.0,28.3142857143,5.78571428571,33.3,22.8,6.4
+sj,2011,27,2011-07-09,0.00035,0.03214,0.1324857,0.1008429,70.37,300.132857143,300.164285714,297.242857143,301.8,298.3,28.7,84.2057142857,70.37,18.6685714286,1.87142857143,27.7428571429,5.8,32.2,23.9,33.0
+sj,2011,28,2011-07-16,,0.18825,0.2075714,0.1997,28.3,300.085714286,300.078571429,297.16,301.6,298.8,21.5,84.0614285714,28.3,18.5628571429,1.87142857143,28.1142857143,5.57142857143,31.7,23.3,25.0
+sj,2011,29,2011-07-23,,0.0829,0.1063857,0.1326429,43.48,300.411428571,300.457142857,296.792857143,301.8,299.0,11.6,80.6385714286,43.48,18.1614285714,2.0,27.5,7.05714285714,32.8,22.8,99.6
+sj,2011,30,2011-07-30,-0.0159,0.0503,0.1628429,0.1579429,57.69,300.591428571,300.692857143,297.495714286,302.4,299.1,31.2,83.2285714286,57.69,18.9485714286,2.15714285714,28.5285714286,6.25714285714,32.8,25.0,48.2
+sj,2011,31,2011-08-06,-0.0132,0.051825,0.1594143,0.1967,33.85,300.26,300.228571429,296.972857143,302.1,298.9,42.1,82.2571428571,33.85,18.3842857143,2.11428571429,27.8857142857,6.27142857143,31.1,23.9,80.3
+sj,2011,32,2011-08-13,,,0.2486,0.2465286,85.88,300.608571429,300.664285714,297.688571429,302.6,298.5,22.5,84.1014285714,85.88,19.1814285714,2.04285714286,28.3142857143,5.17142857143,32.2,22.8,83.9
+sj,2011,33,2011-08-20,0.04,0.2155,0.2223571,0.1979,14.22,300.861428571,301.007142857,297.15,302.7,299.3,7.5,80.3342857143,14.22,18.6057142857,2.44285714286,28.5714285714,6.64285714286,33.3,23.3,20.3
+sj,2011,34,2011-08-27,0.0994,0.0998,0.1454857,0.1467857,120.16,300.632857143,300.521428571,297.535714286,302.2,298.4,89.5,83.2857142857,120.16,19.0585714286,1.84285714286,28.2,5.7,32.8,24.4,205.8
+sj,2011,35,2011-09-03,-0.03925,0.000225,0.2394857,0.1892857,93.06,300.672857143,300.671428571,297.31,302.3,299.0,5.9,82.03,93.06,18.7971428571,2.2,27.6,6.51428571429,33.3,22.8,153.1
+sj,2011,36,2011-09-10,,0.06483333,0.2003286,0.1835857,28.09,300.854285714,300.935714286,296.835714286,302.4,299.5,9.3,78.7542857143,28.09,18.2457142857,2.32857142857,28.4857142857,6.25714285714,33.3,24.4,33.3
+sj,2011,37,2011-09-17,0.1231,0.1106,0.1815833,0.1380667,19.72,301.098571429,301.078571429,297.242857143,302.6,299.4,34.1,79.6642857143,19.72,18.7442857143,2.3,28.8,5.61428571429,34.4,25.6,21.5
+sj,2011,38,2011-09-24,-0.00585,0.0351,0.1538857,0.1245857,98.32,300.545714286,300.542857143,296.872857143,302.9,298.1,17.1,80.4257142857,98.32,18.3057142857,2.2,26.8285714286,5.84285714286,32.2,22.8,29.0
+sj,2011,39,2011-10-01,-0.07495,0.1554333,0.3221714,0.2573286,54.67,300.545714286,300.6,297.14,302.2,299.2,25.9,81.7557142857,54.67,18.5871428571,2.14285714286,27.9285714286,6.5,32.2,23.9,48.8
+sj,2011,40,2011-10-08,0.1027,0.1133,0.3673286,0.2589286,27.9,300.92,301.078571429,297.167142857,303.2,299.3,1.9,80.1528571429,27.9,18.6657142857,2.32857142857,28.6142857143,6.72857142857,33.3,23.9,39.4
+sj,2011,41,2011-10-15,0.0313,0.04263333,0.1176714,0.1079667,50.93,300.698571429,300.735714286,296.544285714,302.4,299.3,1.4,78.11,50.93,17.9342857143,2.15714285714,27.8857142857,6.6,32.8,23.3,32.5
+sj,2011,42,2011-10-22,-0.0216,-0.0404,0.1848857,0.1574429,19.83,300.567142857,300.557142857,296.318571429,302.2,298.9,7.3,77.6971428571,19.83,17.7142857143,2.25714285714,27.8428571429,7.32857142857,32.8,23.3,10.4
+sj,2011,43,2011-10-29,-0.0219,-0.0525,0.1477571,0.1242571,6.38,300.341428571,300.364285714,295.611428571,302.5,298.6,6.9,75.4171428571,6.38,16.97,2.5,27.2714285714,6.44285714286,31.1,23.3,58.0
+sj,2011,44,2011-11-05,0.0893,0.0436,0.2261167,0.1855714,4.75,300.397142857,300.5,296.717142857,302.4,298.7,8.1,80.4071428571,4.75,18.14,2.37142857143,27.7142857143,6.5,31.1,22.8,39.0
+sj,2011,45,2011-11-12,0.1903,0.07236667,0.2001167,0.07466667,98.53,300.237142857,300.407142857,296.217142857,302.4,298.6,6.0,78.6428571429,98.53,17.6042857143,2.61428571429,27.1857142857,7.08571428571,32.8,22.8,15.2
+sj,2011,46,2011-11-19,-0.4634,-0.0331,0.1027857,0.0611,44.02,300.134285714,300.307142857,296.257142857,302.0,298.4,25.9,79.3842857143,44.02,17.6357142857,2.32857142857,27.1,6.28571428571,31.7,23.3,31.8
+sj,2011,47,2011-11-26,-0.02486667,0.0261,0.1853143,0.1791857,0.0,299.417142857,299.228571429,295.785714286,300.7,297.7,60.0,80.5971428571,0.0,17.1428571429,2.0,27.0857142857,5.15714285714,30.0,23.3,22.1
+sj,2011,48,2011-12-03,-0.1309333,0.0022,0.2177286,0.2201429,8.85,299.095714286,299.135714286,295.592857143,301.1,297.4,26.0,81.1885714286,8.85,16.9257142857,1.98571428571,26.3,5.31428571429,30.0,22.2,50.2
+sj,2011,49,2011-12-10,0.0886,-0.05363333,0.3307286,0.2199,5.54,298.9,298.985714286,294.268571429,300.3,297.7,5.3,75.6671428571,5.54,15.6314285714,1.85714285714,26.0142857143,5.4,28.9,21.7,93.7
+sj,2011,50,2011-12-17,,0.14165,0.1836,0.1461571,169.34,298.717142857,298.778571429,295.172857143,300.2,297.6,70.8,80.9242857143,169.34,16.5285714286,1.72857142857,25.9142857143,5.21428571429,29.4,22.8,70.9
+sj,2011,51,2011-12-24,0.1028667,0.0522,0.1072857,0.08585714,0.0,298.28,298.264285714,292.768571429,299.7,296.6,6.1,71.7171428571,0.0,14.2271428571,2.1,25.5714285714,5.17142857143,28.9,22.2,27.0
+sj,2012,52,2012-01-01,0.1653,0.099025,0.152875,0.0815125,15.3,298.507142857,298.564285714,293.324285714,300.1,297.0,8.0,73.1871428571,15.3,14.7142857143,2.04285714286,25.8285714286,5.78571428571,29.4,22.2,48.1
+sj,2012,1,2012-01-08,0.02685,0.0642,0.2285143,0.1994,0.0,298.694285714,298.807142857,294.234285714,300.4,297.3,1.4,76.5171428571,0.0,15.55,2.32857142857,26.2,6.11428571429,30.6,22.2,4.7
+sj,2012,2,2012-01-15,-0.1263667,0.01268,0.2306857,0.1241571,0.0,298.204285714,298.292857143,294.264285714,300.2,296.9,10.7,78.8328571429,0.0,15.5314285714,2.12857142857,25.4142857143,6.24285714286,29.4,21.1,13.0
+sj,2012,3,2012-01-22,-0.06515,0.0226,0.15214,0.1840143,0.0,298.35,298.55,293.485714286,300.2,297.1,1.0,74.55,0.0,14.7985714286,2.35714285714,25.4428571429,6.0,29.4,21.7,6.4
+sj,2012,4,2012-01-29,0.31275,0.1132,0.1889857,0.1817429,0.0,297.347142857,297.464285714,293.01,299.1,295.5,13.8,76.8942857143,0.0,14.3657142857,2.15714285714,24.8571428571,6.02857142857,28.3,20.6,27.5
+sj,2012,5,2012-02-05,-0.1114,0.0191,0.1417571,0.1323143,0.0,297.404285714,297.492857143,292.805714286,299.3,296.0,7.9,75.6385714286,0.0,14.1757142857,2.47142857143,24.8285714286,5.78571428571,28.3,21.1,32.2
+sj,2012,6,2012-02-12,-0.0469,0.054,0.255,0.1690857,7.02,297.567142857,297.657142857,293.488571429,299.5,296.2,7.8,78.1057142857,7.02,14.8071428571,2.31428571429,24.9,5.8,28.3,21.1,25.5
+sj,2012,7,2012-02-19,-0.0006333333,-0.1169333,0.1536571,0.1449,0.0,297.932857143,298.15,293.618571429,300.1,296.5,1.9,76.9671428571,0.0,14.9342857143,2.7,25.6428571429,6.82857142857,31.1,21.7,12.5
+sj,2012,8,2012-02-26,-0.0569,0.156225,0.3853833,0.30625,0.0,297.224285714,297.378571429,293.177142857,299.6,295.8,24.5,78.2257142857,0.0,14.5242857143,2.52857142857,24.8857142857,5.64285714286,28.3,20.6,8.2
+sj,2012,9,2012-03-04,-0.01215,0.00042,0.1655429,0.1632714,0.0,298.032857143,298.221428571,293.374285714,300.0,296.6,2.8,75.4257142857,0.0,14.6842857143,2.61428571429,26.1428571429,6.24285714286,30.0,21.7,5.8
+sj,2012,10,2012-03-11,0.0065,0.028225,0.2108714,0.1460429,12.06,297.811428571,297.914285714,293.795714286,299.9,295.4,8.0,78.5142857143,12.06,15.0785714286,2.57142857143,25.9,6.72857142857,30.6,21.7,9.8
+sj,2012,11,2012-03-18,-0.0854,0.0586,0.233,0.1981143,9.11,297.701428571,297.771428571,293.284285714,299.6,295.9,15.5,76.5314285714,9.11,14.6028571429,2.48571428571,25.6285714286,6.1,29.4,22.2,16.0
+sj,2012,12,2012-03-25,,-0.085,0.07594286,0.0711,84.44,297.685714286,297.75,292.761428571,299.7,295.6,3.2,74.1528571429,84.44,14.1485714286,2.61428571429,26.0428571429,6.9,30.6,22.2,0.6
+sj,2012,13,2012-04-01,0.0902,0.0212,0.1131429,0.09855714,93.61,297.075714286,297.071428571,293.832857143,299.8,295.4,71.6,82.2242857143,93.61,15.1642857143,2.08571428571,25.7285714286,6.1,30.0,22.2,134.9
+sj,2012,14,2012-04-08,-0.0487,0.03106667,0.1584429,0.1257286,59.89,297.931428571,297.971428571,294.66,300.7,295.4,35.7,82.1228571429,59.89,15.9414285714,2.4,26.2857142857,6.81428571429,32.2,22.2,75.2
+sj,2012,15,2012-04-15,0.0576,-0.02305,0.1094333,0.0852,19.2,298.638571429,298.671428571,294.6,300.7,297.0,8.3,78.44,19.2,15.91,2.54285714286,26.9,5.94285714286,32.2,23.3,12.4
+sj,2012,16,2012-04-22,0.1528,0.2424,0.2454667,0.2488,26.2,298.2,298.107142857,294.387142857,300.5,295.8,49.7,79.51,26.2,15.7142857143,2.21428571429,26.5285714286,6.42857142857,33.3,22.8,84.1
+sj,2012,17,2012-04-29,0.014975,-0.00362,0.1908571,0.1396,2.49,298.012857143,298.021428571,293.171428571,301.0,295.4,1.1,74.7571428571,2.49,14.7,2.55714285714,26.4285714286,6.35714285714,32.8,21.7,17.5
+sj,2012,18,2012-05-06,-0.0201,0.0003,0.08328333,0.07257143,5.79,298.964285714,299.007142857,295.47,301.2,297.3,16.0,81.1642857143,5.79,16.7785714286,2.21428571429,27.8428571429,6.2,33.3,23.9,20.6
+sj,2012,19,2012-05-13,0.1338667,0.1546,0.1486571,0.1466143,46.85,298.421428571,298.392857143,295.051428571,300.2,297.0,23.92,81.6814285714,46.85,16.3671428571,1.87142857143,26.5142857143,5.38571428571,30.0,22.8,72.0
+sj,2012,20,2012-05-20,-0.1709,-0.0351,0.09203333,0.06088333,45.91,299.447142857,299.514285714,296.382857143,301.5,297.8,2.5,83.3428571429,45.91,17.7485714286,2.25714285714,27.7571428571,5.65714285714,31.7,23.9,17.8
+sj,2012,21,2012-05-27,0.17235,0.06846667,0.1877714,0.1193286,25.74,299.125714286,299.085714286,296.172857143,301.0,297.3,13.7,83.8428571429,25.74,17.4985714286,2.54285714286,27.5142857143,5.98571428571,31.7,23.9,34.6
+sj,2012,22,2012-06-03,-0.0268,0.02413333,0.1911286,0.1526714,0.64,299.475714286,299.564285714,295.035714286,301.4,297.6,3.8,76.7428571429,0.64,16.3414285714,2.78571428571,27.5571428571,6.37142857143,31.7,23.9,6.4
+sj,2012,23,2012-06-10,0.0355,0.0118,0.2532857,0.2030571,6.44,300.437142857,300.478571429,296.354285714,302.5,298.5,0.1,78.6271428571,6.44,17.7057142857,3.15714285714,29.2,7.2,33.9,24.4,3.6
+sj,2012,24,2012-06-17,,0.0373,0.1486833,0.1225,4.51,300.778571429,300.85,296.161428571,302.9,298.2,0.0,76.0514285714,4.51,17.4728571429,3.38571428571,29.5857142857,7.35714285714,33.9,25.0,0.0
+sj,2012,25,2012-06-24,,0.0462,0.2058714,0.1713143,31.52,300.884285714,301.007142857,296.497142857,303.1,299.0,1.2,77.1342857143,31.52,17.8385714286,3.32857142857,30.0,7.27142857143,35.0,26.1,0.6
+sj,2012,26,2012-07-01,,0.01193333,0.1523,0.1498571,0.0,300.87,300.942857143,296.688571429,303.1,299.3,4.5,78.0614285714,0.0,18.0371428571,3.11428571429,30.2714285714,7.58571428571,35.0,25.6,3.1
+sj,2012,27,2012-07-08,-0.0059,0.0495,0.1681571,0.1264571,6.15,300.647142857,300.635714286,296.544285714,303.0,299.0,12.6,78.3971428571,6.15,17.8785714286,2.64285714286,29.5428571429,7.27142857143,33.9,25.0,11.0
+sj,2012,28,2012-07-15,-0.00425,0.06515,0.1304714,0.1351143,58.48,300.288571429,300.307142857,296.641428571,302.2,298.8,21.0,80.54,58.48,17.9971428571,2.07142857143,28.4571428571,6.42857142857,32.8,23.3,52.0
+sj,2012,29,2012-07-22,,-0.04336667,0.11406,0.1218,17.72,300.58,300.628571429,296.862857143,302.7,298.8,5.0,80.3057142857,17.72,18.2628571429,2.51428571429,29.0428571429,5.47142857143,32.8,25.6,13.2
+sj,2012,30,2012-07-29,-0.09,-0.09856667,0.1544714,0.09651429,22.19,300.465714286,300.471428571,297.145714286,302.1,298.7,20.6,82.1842857143,22.19,18.5342857143,2.28571428571,28.6285714286,5.45714285714,32.8,25.0,49.4
+sj,2012,31,2012-08-05,0.0859,0.0095,0.16885,0.1110167,11.16,300.801428571,300.764285714,296.697142857,302.6,299.1,16.0,78.4185714286,11.16,18.0457142857,2.35714285714,28.9857142857,5.55714285714,32.8,25.0,8.7
+sj,2012,32,2012-08-12,,0.0589,0.1974429,0.1661571,62.2,300.474285714,300.485714286,297.047142857,302.2,299.1,50.7,81.6514285714,62.2,18.4371428571,2.05714285714,28.5142857143,5.4,32.8,24.4,50.1
+sj,2012,33,2012-08-19,0.0777,-0.01435,0.07313333,0.08764286,55.64,300.9,301.0,297.337142857,302.7,299.5,15.9,80.9828571429,55.64,18.7785714286,2.42857142857,28.6285714286,6.94285714286,33.9,23.3,69.6
+sj,2012,34,2012-08-26,0.0345,0.04453333,0.09677143,0.09642857,28.97,300.95,301.042857143,297.095714286,302.8,299.4,7.3,79.6314285714,28.97,18.4985714286,2.34285714286,29.1142857143,5.61428571429,33.3,25.6,26.9
+sj,2012,35,2012-09-02,0.2705,-0.08693333,0.1975,0.1766714,76.41,300.325714286,300.3,296.735714286,302.3,298.4,57.4,80.8628571429,76.41,18.1457142857,2.2,28.0142857143,6.02857142857,32.2,23.9,80.2
+sj,2012,36,2012-09-09,0.0011,0.0801,0.3029571,0.2067857,2.13,300.695714286,300.814285714,296.488571429,302.7,299.3,1.8,77.8028571429,2.13,17.8185714286,2.45714285714,28.7714285714,5.7,32.2,25.6,3.1
+sj,2012,37,2012-09-16,0.16795,0.09135,0.2188286,0.2360429,1.26,301.065714286,301.235714286,296.217142857,303.1,299.1,1.3,75.0728571429,1.26,17.5757142857,3.35714285714,29.5428571429,6.58571428571,33.3,25.6,0.0
+sj,2012,38,2012-09-23,0.2986,0.033,0.2189286,0.2298,15.09,301.068571429,301.221428571,296.357142857,302.9,299.5,1.4,75.5814285714,15.09,17.7242857143,2.72857142857,29.6714285714,6.74285714286,33.3,26.1,5.6
+sj,2012,39,2012-09-30,-0.0076,0.0052,0.16935,0.1150571,25.17,301.394285714,301.471428571,296.86,303.0,299.7,2.7,76.5385714286,25.17,18.2928571429,2.45714285714,29.7285714286,6.64285714286,33.9,25.6,5.4
+sj,2012,40,2012-10-07,,0.1445,0.2415143,0.1779429,53.04,301.022857143,301.0,296.801428571,303.0,299.6,4.8,77.8914285714,53.04,18.2257142857,2.22857142857,28.9428571429,6.9,33.3,24.4,42.6
+sj,2012,41,2012-10-14,0.0937,0.0872,0.1617167,0.1427143,18.78,300.768571429,300.871428571,296.275714286,302.8,299.1,13.3,76.6457142857,18.78,17.6685714286,2.54285714286,28.6428571429,6.22857142857,32.2,25.0,17.3
+sj,2012,42,2012-10-21,,0.07615,0.1523714,0.1075714,31.75,300.678571429,300.764285714,297.311428571,302.4,299.2,42.1,81.9,31.75,18.8314285714,2.21428571429,28.5285714286,6.35714285714,33.9,23.3,32.5
+sj,2012,43,2012-10-28,-0.051,0.06735,0.1408857,0.1261143,29.62,300.734285714,300.821428571,296.818571429,302.5,299.1,10.4,79.3171428571,29.62,18.3014285714,2.24285714286,28.6142857143,6.9,33.3,24.4,49.8
+sj,2012,44,2012-11-04,-0.06705,-0.07655,0.1424429,0.08971429,46.91,300.911428571,301.107142857,296.905714286,303.6,299.4,3.6,78.9414285714,46.91,18.4114285714,2.9,29.4,7.28571428571,34.4,24.4,19.3
+sj,2012,45,2012-11-11,,,0.19495,0.1864714,12.28,300.621428571,300.735714286,296.415714286,302.8,299.4,8.3,77.8342857143,12.28,17.7914285714,2.21428571429,28.6714285714,6.02857142857,33.3,25.0,1.5
+sj,2012,46,2012-11-18,-0.1022,0.07423333,0.1327167,0.162,26.44,300.301428571,300.3,296.207142857,302.5,298.3,49.1,78.4885714286,26.44,17.6014285714,2.48571428571,28.5142857143,6.34285714286,32.8,24.4,3.1
+sj,2012,47,2012-11-25,0.1046,0.0023,0.0062,-0.01467143,27.82,300.225714286,300.228571429,296.538571429,302.0,298.9,12.0,80.3028571429,27.82,17.94,2.17142857143,27.9142857143,5.88571428571,31.1,24.4,14.2
+sj,2012,48,2012-12-02,-0.1687667,-0.03216667,0.2129857,0.1879286,26.6,299.762857143,300.014285714,295.638571429,302.0,298.0,21.7,78.2214285714,26.6,16.9814285714,2.45714285714,27.6142857143,5.74285714286,31.1,23.9,46.6
+sj,2012,49,2012-12-09,,0.0163,0.1902429,0.1598571,3.08,299.331428571,299.271428571,295.247142857,301.4,297.5,16.2,78.3071428571,3.08,16.56,2.22857142857,27.1428571429,5.88571428571,31.1,23.3,58.9
+sj,2012,50,2012-12-16,-0.364,-0.1429,0.06725714,0.06585714,34.66,299.15,299.2,294.357142857,300.9,297.1,19.3,75.0814285714,34.66,15.6828571429,2.2,27.0857142857,6.3,32.2,22.8,9.8
+sj,2012,51,2012-12-23,-0.1163,-0.09245,0.07767143,0.05647143,0.0,298.757142857,298.842857143,294.041428571,300.9,296.8,8.9,75.3257142857,0.0,15.3814285714,2.45714285714,26.2428571429,5.7,30.6,21.7,26.4
+sj,2013,1,2013-01-01,-0.3098,-0.11205,0.1436714,0.1408143,31.83,298.295714286,298.414285714,294.692857143,300.3,296.0,15.8,80.5528571429,31.83,15.98,2.37142857143,26.9428571429,6.58571428571,31.1,21.7,22.7
+sj,2013,2,2013-01-08,0.02015,0.0661,0.1156333,0.1182429,0.0,298.798571429,299.014285714,293.987142857,300.6,297.3,2.7,74.9528571429,0.0,15.2757142857,2.22857142857,26.0857142857,5.22857142857,29.4,22.2,8.7
+sj,2013,3,2013-01-15,-0.2749,-0.0832,0.1235714,0.1298571,0.0,298.007142857,297.985714286,292.921428571,299.8,295.8,8.5,73.4928571429,0.0,14.3114285714,1.77142857143,25.6,5.5,28.9,21.1,17.2
+sj,2013,4,2013-01-22,-0.0714,-0.01942,0.2051429,0.1898571,0.0,297.622857143,297.85,293.034285714,299.9,295.8,8.3,75.6685714286,0.0,14.3985714286,2.64285714286,25.1428571429,5.71428571429,28.9,21.7,6.4
+sj,2013,5,2013-01-29,0.2359,0.117,0.1545,0.1411429,0.0,298.155714286,298.25,294.041428571,300.6,296.7,7.7,78.1,0.0,15.3171428571,2.38571428571,26.1285714286,6.27142857143,30.0,22.2,6.1
+sj,2013,6,2013-02-05,0.0082,0.02113333,0.18005,0.06411667,0.0,297.65,297.721428571,293.052857143,299.7,296.0,15.1,75.9385714286,0.0,14.4485714286,2.67142857143,25.3,6.31428571429,29.4,20.6,26.4
+sj,2013,7,2013-02-12,0.1198,0.07885,0.2703714,0.1865,0.0,297.914285714,298.028571429,292.908571429,300.0,296.1,7.6,73.8728571429,0.0,14.3157142857,2.68571428571,25.3285714286,6.58571428571,30.0,21.1,34.8
+sj,2013,8,2013-02-19,-0.0518,-0.025025,0.2097286,0.1870143,0.0,298.035714286,298.3,292.805714286,300.4,296.2,0.3,72.7942857143,0.0,14.19,2.77142857143,25.6285714286,6.97142857143,31.1,21.1,0.3
+sj,2013,9,2013-02-26,-0.006125,0.007633333,0.1280333,0.1348833,0.0,298.088571429,298.335714286,293.092857143,300.1,296.4,1.5,73.9171428571,0.0,14.4557142857,2.87142857143,25.8,6.58571428571,30.0,22.2,4.1
+sj,2013,10,2013-03-05,,-0.0136,0.03192857,0.0005,23.06,298.191428571,298.4,292.972857143,300.7,295.9,4.6,73.0371428571,23.06,14.4114285714,3.62857142857,26.6714285714,8.4,32.8,21.7,6.6
+sj,2013,11,2013-03-12,0.008,0.054875,0.2443286,0.2219429,0.0,297.157142857,297.192857143,291.868571429,300.2,295.2,13.5,72.5628571429,0.0,13.4585714286,2.12857142857,25.3571428571,5.47142857143,30.0,21.7,17.1
+sj,2013,12,2013-03-19,-0.04515,0.006225,0.1075143,0.1167,0.0,297.288571429,297.357142857,290.987142857,299.5,295.3,4.8,68.1814285714,0.0,12.7057142857,3.05714285714,25.8428571429,6.47142857143,29.4,21.7,4.8
+sj,2013,13,2013-03-26,-0.0874,-0.01618333,0.1563429,0.1051857,30.34,298.67,298.885714286,294.675714286,301.3,296.4,2.55,78.78,30.34,15.9857142857,3.31428571429,27.5428571429,7.94285714286,33.9,22.8,3.5
+sj,2013,14,2013-04-02,-0.20325,-0.07783333,0.2041714,0.1789143,6.55,298.035714286,298.157142857,294.628571429,301.5,295.9,64.3,81.65,6.55,15.8814285714,2.82857142857,26.6428571429,6.64285714286,33.3,22.8,17.6
+sj,2013,15,2013-04-09,-0.1176,-0.0082,0.1927,0.1704286,0.0,299.057142857,299.328571429,294.948571429,301.5,297.5,0.7,78.2857142857,0.0,16.2128571429,3.17142857143,27.9142857143,8.11428571429,32.8,23.3,9.4
+sj,2013,16,2013-04-16,0.08275,0.0312,0.1350143,0.07485714,0.0,298.912857143,299.064285714,294.678571429,300.9,297.3,1.4,77.6742857143,0.0,15.9657142857,3.04285714286,27.7285714286,6.94285714286,31.7,23.9,22.9
+sj,2013,17,2013-04-23,-0.0873,-0.04866667,0.1298143,0.1176714,45.47,298.067142857,298.042857143,294.132857143,300.2,296.6,19.9,79.0457142857,45.47,15.4514285714,2.34285714286,26.4428571429,6.74285714286,31.1,21.7,47.5
+iq,2010,26,2010-07-02,0.1837833,0.1425,0.2251286,0.1502143,82.29,297.648571429,299.214285714,296.118571429,307.9,293.7,34.11,92.5814285714,82.29,17.6542857143,9.42857142857,27.44,10.76,33.8,21.5,11.2
+iq,2010,27,2010-07-09,0.2916571,0.2722667,0.3307,0.3209143,25.3,298.224285714,299.464285714,294.831428571,307.7,292.2,9.1,83.8857142857,25.3,16.32,10.1571428571,27.025,9.625,33.0,21.2,8.9
+iq,2010,28,2010-07-16,0.2085429,0.3664571,0.2126286,0.2555143,62.14,297.955714286,298.964285714,296.417142857,306.4,292.5,61.09,92.0571428571,62.14,18.03,9.55714285714,26.95,10.35,33.4,21.6,22.6
+iq,2010,29,2010-07-23,0.08928571,0.06321429,0.1220571,0.08195714,47.8,295.715714286,296.642857143,293.638571429,306.4,289.3,19.6,88.97,47.8,15.3942857143,7.82857142857,26.9,9.7,33.3,14.2,4.8
+iq,2010,30,2010-07-30,0.3061,0.3276833,0.2500857,0.2679143,56.3,298.502857143,300.0,293.892857143,308.1,290.5,18.93,78.61,56.3,15.4685714286,11.7714285714,27.05,11.85,33.5,16.9,3.0
+iq,2010,31,2010-08-06,0.34202,0.3048571,0.3323571,0.3457286,16.95,298.611428571,300.464285714,295.065714286,309.7,293.4,32.92,83.2742857143,16.95,16.6242857143,11.1571428571,27.7,12.6,34.0,20.0,92.2
+iq,2010,32,2010-08-13,0.3322167,0.3848167,0.3566,0.3539167,9.88,298.305714286,299.7,292.085714286,309.3,292.2,10.5,72.4714285714,9.88,13.99,11.8285714286,26.4333333333,12.0333333333,34.2,18.5,0.0
+iq,2010,33,2010-08-20,0.2218143,0.2241,0.2730857,0.2312429,15.76,298.724285714,300.892857143,294.812857143,309.2,293.2,20.3,81.5571428571,15.76,16.3757142857,12.6428571429,27.275,11.375,34.0,21.0,20.3
+iq,2010,34,2010-08-27,0.3190429,0.3158714,0.3267,0.3440571,7.82,299.914285714,301.785714286,292.691428571,311.1,292.3,14.21,68.6157142857,7.82,14.4842857143,14.4857142857,27.4,13.1,34.7,20.0,
+iq,2010,35,2010-09-03,0.3420143,0.3019286,0.3147,0.381,59.06,300.224285714,301.535714286,295.2,310.6,294.1,41.1,77.2028571429,59.06,16.8014285714,12.6714285714,28.175,13.2,36.2,21.0,8.5
+iq,2010,36,2010-09-10,0.1165833,0.1002833,0.1406833,0.1138167,37.9,298.501428571,299.521428571,295.641428571,309.0,292.8,50.0,85.6914285714,37.9,17.17,10.1,27.1,11.1666666667,35.4,21.0,15.0
+iq,2010,37,2010-09-17,0.2591667,0.26732,0.2123286,0.3265429,16.86,299.948571429,301.35,294.56,311.8,293.7,17.7,75.27,16.86,16.1342857143,12.6142857143,28.225,13.175,35.2,21.0,4.1
+iq,2010,38,2010-09-24,0.3062143,0.2635857,0.3215429,0.3791714,46.96,298.704285714,300.414285714,295.687142857,309.2,293.7,156.0,85.72,46.96,17.2942857143,10.6285714286,28.8666666667,13.0666666667,36.2,19.1,26.9
+iq,2010,39,2010-10-01,0.3867857,0.3726286,0.3796143,0.3973571,28.63,300.064285714,301.678571429,294.244285714,311.5,293.3,13.16,73.5128571429,28.63,15.8042857143,13.2428571429,28.4,12.6666666667,35.8,21.2,1.5
+iq,2010,40,2010-10-08,0.30415,0.3368667,0.2538833,0.3275333,26.29,301.935714286,303.328571429,294.082857143,314.1,294.8,249.4,66.31,26.29,15.7071428571,13.6285714286,29.08,14.38,38.4,20.5,14.1
+iq,2010,41,2010-10-15,0.3290429,0.2942714,0.3070286,0.3938143,33.49,299.8,301.714285714,295.312857143,310.7,293.5,28.5,79.7628571429,33.49,16.8957142857,12.3142857143,28.65,12.5,35.7,19.8,25.9
+iq,2010,42,2010-10-22,0.2441286,0.1928833,0.2322286,0.2819286,34.93,298.857142857,301.407142857,296.178571429,311.4,293.8,141.6,87.7528571429,34.93,17.8028571429,12.6142857143,27.8,13.5,35.0,19.8,8.1
+iq,2010,43,2010-10-29,0.2396,0.2375286,0.1940714,0.2292,47.9,299.341428571,300.692857143,296.84,309.6,294.5,75.1,87.8028571429,47.9,18.5414285714,9.78571428571,29.1333333333,11.8666666667,36.0,21.2,4.0
+iq,2010,44,2010-11-05,0.2840286,0.3218429,0.2682429,0.1984286,47.11,299.597142857,301.492857143,297.718571429,310.4,296.0,85.3,90.64,47.11,19.5771428571,9.81428571429,28.48,13.3,36.0,21.2,46.0
+iq,2010,45,2010-11-12,0.3561857,0.3933286,0.2812,0.3909286,65.8,299.572857143,301.007142857,296.244285714,311.7,291.9,229.6,84.3857142857,65.8,17.96,10.8428571429,28.8,14.725,37.4,20.0,35.8
+iq,2010,46,2010-11-19,0.1918714,0.2326571,0.2561857,0.1838714,62.56,298.307142857,300.35,296.478571429,309.8,293.5,143.1,91.3428571429,62.56,18.1714285714,9.64285714286,27.35,11.825,35.1,20.5,41.1
+iq,2010,47,2010-11-26,0.3294714,0.3875286,0.3104,0.2884857,43.51,298.212857143,299.435714286,297.012857143,305.8,294.6,69.53,93.4071428571,43.51,18.7542857143,7.32857142857,27.35,12.35,34.4,20.5,40.2
+iq,2010,48,2010-12-03,0.1851,0.1840714,0.09825714,0.2526571,42.7,299.878571429,301.985714286,296.624285714,309.7,295.4,58.43,85.2885714286,42.7,18.4128571429,11.0571428571,28.65,12.55,36.2,20.9,17.0
+iq,2010,49,2010-12-10,0.2064857,0.2436286,0.2296286,0.2305571,102.94,298.508571429,300.271428571,297.198571429,308.3,295.3,116.57,93.8414285714,102.94,18.9628571429,8.17142857143,27.08,10.32,34.6,21.4,29.2
+iq,2010,50,2010-12-17,0.3063571,0.2906714,0.3378714,0.3118143,26.86,298.977142857,300.557142857,296.377142857,307.1,295.1,34.23,86.9057142857,26.86,18.0428571429,8.94285714286,28.7666666667,13.5333333333,36.2,21.8,9.2
+iq,2010,51,2010-12-24,0.2478143,0.1746,0.2196571,0.2418286,39.13,299.08,300.321428571,294.8,308.6,294.4,19.83,79.9485714286,39.13,16.4042857143,9.75714285714,28.0666666667,13.9666666667,36.2,20.5,7.1
+iq,2011,52,2011-01-01,0.2775,0.3043667,0.2356556,0.2894333,43.67,296.571428571,297.428571429,295.94,303.8,294.2,222.0,96.6271428571,43.67,17.5171428571,4.8,26.9,8.6,33.2,22.0,54.7
+iq,2011,1,2011-01-08,0.3677429,0.3201429,0.3127714,0.3882571,10.08,298.875714286,300.242857143,294.698571429,306.9,293.2,44.87,80.4528571429,10.08,16.4028571429,10.5142857143,27.85,12.35,36.0,21.2,0.0
+iq,2011,2,2011-01-15,0.2194429,0.2352833,0.2000286,0.2779857,48.87,298.168571429,299.464285714,296.037142857,306.6,295.0,134.5,89.6757142857,48.87,17.68,8.1,27.8333333333,10.8,34.4,21.5,33.0
+iq,2011,3,2011-01-22,0.2611286,0.2940286,0.2393286,0.3210571,51.12,298.012857143,299.45,295.991428571,308.8,292.4,28.9,90.4542857143,51.12,17.6485714286,9.38571428571,27.6333333333,10.4666666667,34.1,21.0,40.9
+iq,2011,4,2011-01-29,0.2402,0.2538286,0.2092286,0.2298429,53.22,298.424285714,299.571428571,294.29,306.8,293.1,9.4,80.1285714286,53.22,15.9285714286,10.2571428571,27.45,11.4,35.0,21.2,9.9
+iq,2011,5,2011-02-05,0.1724286,0.1657857,0.1928286,0.1904,50.2,297.481428571,298.442857143,295.764285714,306.3,291.9,98.7,91.44,50.2,17.3842857143,8.31428571429,28.0,11.4,34.0,20.5,34.3
+iq,2011,6,2011-02-12,0.3101429,0.2193286,0.1789571,0.3013429,43.54,298.025714286,299.321428571,296.27,306.1,292.3,62.8,91.3385714286,43.54,17.93,9.58571428571,27.0,11.05,33.0,21.0,0.5
+iq,2011,7,2011-02-19,0.2876429,0.2826143,0.2644571,0.3459714,60.97,297.587142857,299.071428571,296.56,306.4,294.3,280.42,94.5785714286,60.97,18.2271428571,8.0,27.4333333333,11.5333333333,33.6,21.0,41.2
+iq,2011,8,2011-02-26,0.1665714,0.1742714,0.1805,0.1536429,76.73,297.751428571,299.007142857,296.784285714,305.5,292.6,45.9,94.8542857143,76.73,18.4785714286,8.67142857143,27.95,10.8,34.2,21.0,9.0
+iq,2011,9,2011-03-05,0.2160167,0.2520333,0.2109167,0.3020167,42.18,297.561428571,298.592857143,296.878571429,304.4,294.6,126.8,96.3828571429,42.18,18.5814285714,6.35714285714,27.4666666667,11.5666666667,34.2,20.5,13.3
+iq,2011,10,2011-03-12,0.2821,0.2399143,0.2339,0.3507,101.98,297.341428571,298.45,296.247142857,304.4,293.4,87.4,94.4485714286,101.98,17.9,7.78571428571,26.7,9.16666666667,33.4,21.4,22.0
+iq,2011,11,2011-03-19,0.3512429,0.3383286,0.3577857,0.3826429,49.58,297.991428571,299.007142857,296.22,305.5,293.2,54.1,91.1857142857,49.58,17.8757142857,8.92857142857,27.0,10.75,35.0,21.2,1.8
+iq,2011,12,2011-03-26,0.1382571,0.1547143,0.1428286,0.1930857,71.69,297.602857143,298.85,296.712857143,305.8,294.2,73.7,95.4257142857,71.69,18.3857142857,7.61428571429,27.7571428571,10.8571428571,35.2,21.0,44.9
+iq,2011,13,2011-04-02,0.2292,0.2304,0.1851286,0.2082857,54.37,297.55,298.5,296.714285714,305.5,293.5,67.28,95.56,54.37,18.44,6.54285714286,26.9,10.5666666667,33.0,21.4,5.4
+iq,2011,14,2011-04-09,0.3128143,0.3191714,0.3774571,0.3847857,72.16,298.044285714,299.228571429,296.971428571,305.5,293.5,82.1,94.5657142857,72.16,18.6671428571,8.65714285714,27.9,9.7,34.2,20.6,47.0
+iq,2011,15,2011-04-16,0.2731833,0.3287,0.2243571,0.3501714,64.17,296.652857143,297.735714286,296.205714286,303.9,293.4,81.2,97.5985714286,64.17,17.8157142857,5.32857142857,26.1,9.2,33.4,21.2,48.8
+iq,2011,16,2011-04-23,0.2215571,0.2313714,0.1462571,0.1660429,112.69,296.714285714,297.385714286,296.192857143,303.5,293.5,101.0,97.3,112.69,17.81,5.51428571429,27.15,9.25,34.4,21.8,8.1
+iq,2011,17,2011-04-30,0.2891,0.35406,0.1965571,0.2656857,89.33,297.277142857,298.614285714,296.77,305.2,292.8,97.2,97.3014285714,89.33,18.4471428571,7.65714285714,28.1,10.2,33.2,22.3,24.0
+iq,2011,18,2011-05-07,0.2470143,0.2773714,0.2767571,0.2252857,111.09,297.55,298.192857143,297.084285714,303.7,293.9,101.6,97.4814285714,111.09,18.8042857143,6.18571428571,27.425,10.1,33.2,21.2,17.5
+iq,2011,19,2011-05-14,0.2356143,0.36116,0.2586286,0.3281,53.29,295.502857143,296.478571429,294.28,304.7,291.9,42.6,93.8528571429,53.29,15.7828571429,5.7,26.3,8.55,30.8,21.5,39.3
+iq,2011,20,2011-05-21,0.1068857,0.1086571,0.1276429,0.1072857,135.1,296.158571429,297.114285714,295.59,304.5,291.6,69.5,96.9114285714,135.1,17.1842857143,5.77142857143,27.0,8.26666666667,32.6,22.5,18.0
+iq,2011,21,2011-05-28,0.2827571,0.2121714,0.2726429,0.3207,105.13,297.54,298.942857143,295.931428571,307.6,292.2,35.9,92.1285714286,105.13,17.5457142857,9.54285714286,,,33.2,,38.1
+iq,2011,22,2011-06-04,0.1145857,0.1302714,0.1424857,0.2094857,28.1,296.657142857,297.892857143,295.432857143,304.7,292.9,36.5,93.81,28.1,16.9585714286,8.07142857143,,,33.4,,23.4
+iq,2011,23,2011-06-11,0.2767571,0.2575857,0.1826571,0.3158571,152.32,295.778571429,296.464285714,294.741428571,306.6,291.7,36.7,94.9485714286,152.32,16.2171428571,6.15714285714,,,31.4,,27.2
+iq,2011,24,2011-06-18,0.33932,0.26412,0.3501,0.3288,54.27,297.388571429,298.392857143,295.304285714,308.3,291.6,178.1,90.09,54.27,16.87,9.32857142857,,,33.6,,4.1
+iq,2011,25,2011-06-25,0.1635429,0.2133143,0.1999571,0.2143286,59.54,294.554285714,295.235714286,293.484285714,304.2,290.5,44.7,94.75,59.54,14.9828571429,5.72857142857,,,32.2,,35.8
+iq,2011,26,2011-07-02,0.1782429,0.1938714,0.2064714,0.1768143,42.4,296.185714286,296.885714286,294.762857143,304.9,290.4,64.2,92.5014285714,42.4,16.3357142857,8.14285714286,,,33.2,,9.6
+iq,2011,27,2011-07-09,0.1397571,0.13925,0.116,0.1848571,31.44,295.551428571,296.657142857,294.848571429,304.7,291.3,54.0,96.4942857143,31.44,16.3957142857,7.34285714286,,,29.6,,17.2
+iq,2011,28,2011-07-16,0.3302,0.3348429,0.3249571,0.3198429,19.52,295.554285714,296.464285714,293.251428571,305.5,290.6,25.7,88.7785714286,19.52,14.7871428571,9.27142857143,,,31.8,19.5,21.1
+iq,2011,29,2011-07-23,0.2778714,0.2915143,0.2991143,0.3904714,70.29,297.205714286,298.721428571,294.161428571,306.6,290.9,24.8,85.5657142857,70.29,15.6885714286,10.5571428571,26.85,11.7,34.0,20.6,16.3
+iq,2011,30,2011-07-30,0.2031571,0.1922714,0.2074,0.2488833,105.88,296.485714286,298.071428571,294.448571429,304.5,291.3,19.6,90.0714285714,105.88,15.9442857143,10.5142857143,26.7333333333,10.6333333333,33.0,21.0,38.8
+iq,2011,31,2011-08-06,0.3812714,0.3726833,0.3742429,0.4643571,14.96,296.798571429,298.192857143,293.864285714,306.6,291.1,27.3,86.0828571429,14.96,15.4185714286,10.7571428571,27.4333333333,11.6,33.4,20.8,5.1
+iq,2011,32,2011-08-13,0.3229143,0.3349429,0.2934714,0.3355,7.3,297.454285714,299.05,294.522857143,307.9,290.9,79.9,86.3557142857,7.3,16.0328571429,11.6428571429,27.02,11.56,34.2,20.4,
+iq,2011,33,2011-08-20,0.2866429,0.2679667,0.2945571,0.3465429,24.95,297.928571429,298.992857143,292.11,308.3,291.6,10.4,73.6757142857,24.95,13.8428571429,11.6714285714,27.85,11.95,34.8,21.2,11.2
+iq,2011,34,2011-08-27,0.3120857,0.2748,0.2536,0.2944571,24.3,297.938571429,299.328571429,293.695714286,308.4,291.8,24.3,80.4857142857,24.3,15.3014285714,11.8,28.75,12.15,35.2,17.4,23.9
+iq,2011,35,2011-09-03,0.3227286,0.3295429,0.2857571,0.3432857,30.18,298.15,299.8,293.241428571,309.0,290.9,14.4,77.5371428571,30.18,14.8728571429,13.2,28.1,12.2,34.2,17.8,25.1
+iq,2011,36,2011-09-10,0.272,0.2638,0.2696143,0.2356143,23.04,297.72,299.328571429,293.715714286,309.8,291.8,11.4,80.79,23.04,15.2714285714,12.6571428571,27.8,12.2333333333,34.8,21.6,12.9
+iq,2011,37,2011-09-17,0.1696286,0.1409,0.1158,0.1237857,60.78,298.628571429,300.221428571,294.987142857,309.7,292.4,64.5,82.5842857143,60.78,16.5585714286,11.0428571429,27.5333333333,11.3666666667,34.4,21.5,66.0
+iq,2011,38,2011-09-24,0.4299857,0.4121571,0.2781286,0.4019429,56.19,297.778571429,299.007142857,295.05,308.9,291.7,107.8,87.59,56.19,16.6157142857,12.0142857143,27.65,10.65,33.8,21.4,29.0
+iq,2011,39,2011-10-01,0.3460143,0.2842714,0.3458143,0.3687,55.53,298.015714286,299.235714286,295.832857143,307.3,292.0,90.9,89.4428571429,55.53,17.4771428571,10.2714285714,26.8,7.3,33.3,22.2,29.0
+iq,2011,40,2011-10-08,0.3865,0.3082714,0.4066143,0.3867429,62.22,297.098571429,298.135714286,295.755714286,306.7,291.9,47.5,93.28,62.22,17.3371428571,8.27142857143,27.525,11.0,34.2,21.1,38.8
+iq,2011,41,2011-10-15,0.2673,0.2528143,0.2181429,0.2967,43.29,298.13,299.957142857,296.34,308.8,293.0,52.3,91.2657142857,43.29,18.0128571429,9.8,27.75,10.6,33.7,21.4,36.8
+iq,2011,42,2011-10-22,0.2488,0.2852857,0.2442571,0.2892143,51.74,299.761428571,301.078571429,296.897142857,308.8,295.5,35.7,86.1985714286,51.74,18.6985714286,9.98571428571,28.975,10.9,34.7,22.8,10.2
+iq,2011,43,2011-10-29,0.4231714,0.4198429,0.4419143,0.4397571,36.09,298.027142857,299.471428571,296.235714286,307.3,292.2,130.0,90.9985714286,36.09,17.9028571429,11.1142857143,27.2333333333,11.5,34.2,21.2,61.7
+iq,2011,44,2011-11-05,0.4194,0.3701571,0.3908143,0.3687571,25.73,298.482857143,299.835714286,296.044285714,308.4,291.3,51.2,88.5042857143,25.73,17.6857142857,11.7285714286,28.75,12.45,35.5,21.4,43.2
+iq,2011,45,2011-11-12,0.2752714,0.2726571,0.2768429,0.2208429,61.75,298.584285714,299.885714286,296.392857143,309.5,292.7,69.0,89.7214285714,61.75,18.11,11.7428571429,28.8,12.0,35.2,21.2,9.1
+iq,2011,46,2011-11-19,0.1729286,0.2871167,0.1900857,0.2068429,64.85,297.925714286,298.871428571,296.644285714,305.2,294.0,243.6,93.3114285714,64.85,18.3614285714,7.4,27.6,10.8666666667,33.8,21.1,27.5
+iq,2011,47,2011-11-26,0.3111167,0.346,0.3280429,0.2765143,75.37,298.181428571,299.778571429,296.66,308.2,294.5,59.9,92.7,75.37,18.3685714286,8.5,27.375,11.175,34.2,20.7,92.0
+iq,2011,48,2011-12-03,0.3528857,0.3375333,0.3185143,0.3172,61.58,298.792857143,300.064285714,296.471428571,307.6,294.2,40.0,88.8828571429,61.58,18.1685714286,9.35714285714,28.45,11.675,35.1,22.0,11.9
+iq,2011,49,2011-12-10,0.2277143,0.2261714,0.2731857,0.2364286,72.47,298.235714286,299.642857143,296.592857143,306.0,294.3,50.2,91.9528571429,72.47,18.3385714286,9.14285714286,28.3,9.7,34.2,21.8,6.4
+iq,2011,50,2011-12-17,0.2814857,0.2953,0.215,0.3746857,50.22,297.561428571,298.407142857,296.428571429,303.6,292.7,89.5,94.2557142857,50.22,18.1142857143,7.41428571429,27.2,11.1,33.3,21.7,23.1
+iq,2011,51,2011-12-24,0.3317,0.3049,0.28745,0.2900143,104.91,297.221428571,298.042857143,296.375714286,304.9,293.0,172.0,95.78,104.91,18.0671428571,7.31428571429,27.7,9.96666666667,33.8,22.5,47.2
+iq,2012,52,2012-01-01,0.1926,0.2411,0.2246625,0.18485,83.53,298.224285714,299.771428571,296.87,305.5,294.0,120.4,93.2642857143,83.53,18.5814285714,8.17142857143,28.5,11.0,34.0,22.2,57.2
+iq,2012,1,2012-01-08,0.2208857,0.2357286,0.2602714,0.3218143,55.26,296.638571429,297.2,296.134285714,303.1,293.8,140.8,97.4357142857,55.26,17.7657142857,5.8,,,32.8,22.6,35.3
+iq,2012,2,2012-01-15,0.2321571,0.2176143,0.2224143,0.2433857,73.85,296.97,298.178571429,296.295714286,304.6,292.7,116.8,96.4428571429,73.85,17.9128571429,7.44285714286,27.45,9.25,33.1,22.2,14.7
+iq,2012,3,2012-01-22,0.1992571,0.2649571,0.2363,0.2097571,139.06,296.912857143,297.757142857,295.951428571,306.3,293.2,99.8,95.2585714286,139.06,17.57,6.57142857143,27.5333333333,10.0,33.0,20.8,132.3
+iq,2012,4,2012-01-29,0.3079857,0.2530286,0.34325,0.3178857,69.24,297.39,298.471428571,295.485714286,306.3,292.1,46.0,90.5628571429,69.24,17.0971428571,9.42857142857,27.0333333333,10.0333333333,32.8,21.4,51.1
+iq,2012,5,2012-02-05,0.10995,0.1662714,0.2246429,0.2218857,56.99,297.435714286,298.657142857,296.438571429,305.3,292.3,65.7,95.0128571429,56.99,18.1057142857,7.82857142857,27.15,9.55,32.6,22.0,23.0
+iq,2012,6,2012-02-12,0.1666714,0.2257429,0.2215,0.2202714,25.76,297.17,298.228571429,296.624285714,306.0,294.9,245.1,97.1685714286,25.76,18.3,5.37142857143,26.85,8.975,32.4,22.0,39.0
+iq,2012,7,2012-02-19,0.2187857,0.2505143,0.2702143,0.3822,135.04,296.898571429,298.342857143,295.927142857,307.1,293.1,75.9,94.9514285714,135.04,17.5585714286,8.31428571429,27.0,8.7,33.4,21.7,94.5
+iq,2012,8,2012-02-26,0.1739,0.1503429,0.1659429,0.1458,96.59,298.098571429,299.45,295.177142857,306.9,293.1,62.8,86.1657142857,96.59,16.8371428571,10.0428571429,28.0666666667,11.2,34.9,21.7,43.2
+iq,2012,9,2012-03-04,0.2898571,0.2981571,0.2441429,0.2734143,121.79,296.514285714,297.614285714,295.367142857,303.5,291.9,50.3,94.08,121.79,16.9657142857,7.6,26.6,9.3,32.2,20.4,138.1
+iq,2012,10,2012-03-11,0.2039286,0.2261286,0.2998429,0.1779857,144.65,297.038571429,298.007142857,296.195714286,305.1,293.7,118.2,95.7685714286,144.65,17.8057142857,6.78571428571,26.75,9.75,32.6,21.7,87.9
+iq,2012,11,2012-03-18,0.1607,0.2274,0.2210571,0.2001571,79.25,296.352857143,297.55,295.534285714,306.0,292.1,79.2,95.7842857143,79.25,17.1085714286,7.01428571429,26.975,9.5,32.2,21.8,65.0
+iq,2012,12,2012-03-25,0.2969286,0.2631714,0.2453,0.2680143,68.24,297.078571429,297.935714286,295.317142857,306.7,291.5,124.1,91.3385714286,68.24,16.8842857143,9.5,27.2,10.675,34.0,20.8,49.2
+iq,2012,13,2012-04-01,0.2567143,0.2064833,0.2472429,0.2021,149.88,298.25,299.2,296.47,305.4,293.5,59.9,91.5428571429,149.88,18.1457142857,8.68571428571,27.8,9.85,33.8,20.8,39.9
+iq,2012,14,2012-04-08,0.2305714,0.21118,0.1904143,0.2078286,102.08,296.242857143,297.15,295.847142857,304.5,291.9,139.1,97.8928571429,102.08,17.4257142857,5.78571428571,27.85,9.75,33.4,21.7,68.1
+iq,2012,15,2012-04-15,0.1417571,0.1708857,0.1451571,0.2036429,84.86,297.63,299.3,296.705714286,306.6,293.3,109.5,95.3657142857,84.86,18.42,8.94285714286,28.6,10.3,34.0,23.1,34.6
+iq,2012,16,2012-04-22,0.2780286,0.3235143,0.2937571,0.3791286,85.81,297.7,298.728571429,296.855714286,304.9,293.7,125.8,95.76,85.81,18.5257142857,7.22857142857,27.55,9.75,33.1,22.7,212.0
+iq,2012,17,2012-04-29,0.3716571,0.3788857,0.4530429,0.4126143,49.66,297.605714286,298.592857143,296.268571429,307.1,292.2,92.2,93.5957142857,49.66,17.8771428571,8.04285714286,27.82,9.1,32.8,22.2,7.9
+iq,2012,18,2012-05-06,0.2117857,0.1863286,0.1939571,0.2609,61.7,297.028571429,298.65,296.241428571,307.5,293.4,56.6,95.93,61.7,17.8828571429,8.87142857143,27.5666666667,10.7666666667,33.4,21.8,67.9
+iq,2012,19,2012-05-13,0.3063,0.2805571,0.2832857,0.3039857,50.85,296.074285714,297.064285714,294.828571429,304.0,289.8,39.92,93.5171428571,50.85,16.3914285714,8.15714285714,26.85,9.75,33.2,19.4,9.1
+iq,2012,20,2012-05-20,0.3813333,0.3767833,0.3292333,0.4714667,80.29,297.374285714,298.1,296.215714286,304.3,291.2,57.8,94.1742857143,80.29,17.8142857143,8.42857142857,27.1,9.1,32.2,22.2,48.0
+iq,2012,21,2012-05-27,0.1982857,0.2052571,0.2014286,0.1702143,39.78,296.19,297.6,294.81,305.3,291.5,42.7,93.1985714286,39.78,16.2957142857,8.94285714286,27.4,9.85,33.0,21.8,21.1
+iq,2012,22,2012-06-03,0.2482143,0.2148714,0.2555857,0.2077857,26.31,297.257142857,298.578571429,294.668571429,308.1,291.3,16.5,87.76,26.31,16.22,11.1571428571,27.18,9.06,33.1,22.2,68.2
+iq,2012,23,2012-06-10,0.1959714,0.2414286,0.1822857,0.1427714,14.46,297.525714286,298.992857143,295.205714286,306.0,291.4,35.4,88.5385714286,14.46,16.7171428571,9.92857142857,27.15,10.075,32.4,21.3,12.8
+iq,2012,24,2012-06-17,0.16515,0.1638667,0.2271333,0.1948667,55.98,296.212857143,297.1,294.328571429,304.9,288.3,39.0,90.6285714286,55.98,15.8771428571,10.0571428571,24.84,9.18,34.2,17.8,66.6
+iq,2012,25,2012-06-24,0.3135571,0.3152857,0.3249714,0.3508857,33.63,297.05,298.742857143,295.172857143,306.8,291.0,25.5,90.75,33.63,16.6942857143,12.3428571429,27.25,11.6,34.4,20.3,3.8
+iq,2012,26,2012-07-01,0.2218857,0.1698857,0.2181286,0.1972,89.4,297.447142857,298.65,294.972857143,308.0,291.9,181.0,88.5514285714,89.4,16.4642857143,11.2714285714,26.9833333333,11.6166666667,33.8,19.8,37.0
+iq,2012,27,2012-07-08,0.2701,0.2655714,0.2868286,0.1659571,19.02,295.748571429,297.485714286,294.511428571,303.8,290.8,36.2,93.6685714286,19.02,16.02,9.71428571429,25.85,10.525,31.8,20.0,17.0
+iq,2012,28,2012-07-15,0.1930429,0.2625,0.1430571,0.2026857,87.2,296.934285714,297.6,294.104285714,306.1,290.6,64.1,86.6571428571,87.2,15.6428571429,9.45714285714,26.0,11.1428571429,32.0,19.8,13.9
+iq,2012,29,2012-07-22,0.2303143,0.3333571,0.1943143,0.2443,51.46,297.5,299.385714286,294.89,306.7,292.0,147.8,87.7328571429,51.46,16.4885714286,10.0571428571,26.0,9.425,31.4,19.5,22.1
+iq,2012,30,2012-07-29,0.3980571,0.4044857,0.3445,0.4733,35.72,295.854285714,296.314285714,291.954285714,304.1,286.2,15.5,81.1028571429,35.72,13.7371428571,10.3714285714,25.1,11.7666666667,31.5,17.3,9.1
+iq,2012,31,2012-08-05,0.2616857,0.2797286,0.1777143,0.2920857,37.23,296.332857143,297.757142857,293.75,306.9,291.1,16.3,87.39,37.23,15.2785714286,10.0857142857,26.5,12.2,33.8,20.3,1.0
+iq,2012,32,2012-08-12,0.2895,0.3001714,0.2397429,0.3087714,16.38,297.657142857,298.828571429,292.92,307.9,289.3,8.9,77.6428571429,16.38,14.56,13.1142857143,27.0,13.4,34.2,18.3,
+iq,2012,33,2012-08-19,0.1875667,0.1556714,0.1806,0.2584,12.93,297.988571429,299.464285714,292.655714286,308.3,288.4,29.5,76.5642857143,12.93,14.45,13.0142857143,27.5,13.2,34.6,18.4,0.0
+iq,2012,34,2012-08-26,0.3844667,0.4623714,0.4074143,0.5290429,37.47,297.218571429,298.5,295.03,309.2,290.9,102.9,89.8471428571,37.47,16.5628571429,10.2857142857,26.275,11.4,34.2,19.4,41.9
+iq,2012,35,2012-09-02,0.1917,0.1316286,0.1595714,0.1665,34.14,298.911428571,299.564285714,293.958571429,310.0,292.1,39.7,76.9514285714,34.14,15.5785714286,13.0428571429,27.64,11.62,35.3,20.5,17.0
+iq,2012,36,2012-09-09,0.4114,0.3285286,0.2673286,0.3661143,6.4,297.892857143,298.95,293.768571429,308.5,291.9,12.9,80.2285714286,6.4,15.2928571429,11.0142857143,,,,20.1,6.1
+iq,2012,37,2012-09-16,0.389,0.4125667,0.2652571,0.3849286,50.0,298.175714286,299.978571429,294.324285714,310.0,292.2,25.8,82.6628571429,50.0,15.8385714286,12.9,28.65,12.95,35.2,21.0,15.0
+iq,2012,38,2012-09-23,0.3790429,0.4648,0.426,0.4304143,12.4,299.425714286,301.092857143,293.414285714,310.5,293.2,8.5,72.5357142857,12.4,14.9942857143,14.0142857143,28.05,11.925,35.4,20.5,21.3
+iq,2012,39,2012-09-30,0.3430571,0.40106,0.2842714,0.3159714,48.42,299.097142857,300.814285714,294.75,309.8,293.5,58.7,79.9128571429,48.42,16.3085714286,12.5428571429,28.0,12.5,35.6,20.6,28.9
+iq,2012,40,2012-10-07,0.2247143,0.2918667,0.1414286,0.2094571,55.11,298.047142857,299.121428571,294.288571429,309.7,289.7,27.7,82.6157142857,55.11,15.8328571429,11.7,27.15,11.15,36.2,19.8,35.3
+iq,2012,41,2012-10-14,0.2075429,0.2421286,0.2069429,0.1810857,59.72,298.994285714,300.528571429,296.072857143,309.3,294.6,73.8,86.6171428571,59.72,17.7814285714,10.6285714286,28.55,11.9,35.2,22.5,51.5
+iq,2012,42,2012-10-21,0.1821571,0.2493333,0.2398857,0.2293286,51.03,298.435714286,299.921428571,295.825714286,308.3,293.5,35.3,87.4685714286,51.03,17.4157142857,10.7857142857,28.0,11.0666666667,36.0,20.6,14.0
+iq,2012,43,2012-10-28,0.2633714,0.2797143,0.2138429,0.3182429,65.1,298.312857143,299.757142857,296.812857143,310.1,293.6,58.5,93.0357142857,65.1,18.5742857143,9.34285714286,27.3,9.8,35.2,22.0,37.6
+iq,2012,44,2012-11-04,0.3497,0.3603571,0.3145714,0.2966714,44.15,299.425714286,301.064285714,296.327142857,309.4,293.6,51.0,85.7314285714,44.15,18.0328571429,11.7571428571,28.8,13.3,35.4,21.7,34.1
+iq,2012,45,2012-11-11,0.2395429,0.4598667,0.2842286,0.2958143,44.25,299.188571429,300.607142857,296.151428571,308.7,293.7,32.9,85.1385714286,44.25,17.8114285714,11.0428571429,28.8333333333,11.9,35.2,22.0,10.9
+iq,2012,46,2012-11-18,0.2633286,0.3331167,0.2090286,0.2533857,44.21,298.954285714,300.557142857,297.048571429,309.2,294.5,52.31,91.3828571429,44.21,18.8428571429,10.7142857143,27.5,9.55,36.1,22.5,7.1
+iq,2012,47,2012-11-25,0.3198143,0.2968571,0.2724714,0.3493286,47.31,297.89,298.75,297.517142857,302.8,294.3,107.7,97.9828571429,47.31,19.3428571429,6.12857142857,26.65,7.65,32.2,22.1,64.0
+iq,2012,48,2012-12-02,0.3762857,0.3881429,0.4332286,0.3629143,42.66,298.371428571,299.192857143,297.725714286,306.4,295.0,85.7,96.5728571429,42.66,19.5985714286,7.47142857143,28.05,10.025,33.8,22.2,50.0
+iq,2012,49,2012-12-09,0.3676167,0.35498,0.3258167,0.2811333,35.15,299.16,300.528571429,296.494285714,307.1,294.7,38.0,87.3571428571,35.15,18.2014285714,10.1714285714,28.6,11.2,35.4,22.2,30.0
+iq,2012,50,2012-12-16,0.13065,0.2654571,0.2230429,0.1365167,102.24,298.665714286,299.914285714,297.082857143,306.5,294.4,76.7,92.0228571429,102.24,18.8442857143,9.28571428571,27.88,10.5,34.6,21.0,3.0
+iq,2012,51,2012-12-23,0.2569833,0.2234714,0.2338833,0.2531,50.42,298.612857143,299.771428571,297.228571429,305.8,294.1,70.8,92.92,50.42,19.0285714286,8.6,28.2333333333,10.0666666667,34.3,22.0,21.3
+iq,2013,1,2013-01-01,0.2558286,0.2686571,0.2684143,0.2444714,35.33,298.007142857,298.771428571,296.598571429,303.9,294.1,66.7,92.8628571429,35.33,18.2628571429,6.62857142857,28.475,10.45,34.9,22.8,23.8
+iq,2013,2,2013-01-08,0.1882286,0.1391429,0.2527286,0.1705857,33.14,296.241428571,297.4,295.275714286,306.7,292.9,53.1,95.2328571429,33.14,16.7885714286,6.57142857143,26.45,7.9,31.2,21.2,86.8
+iq,2013,3,2013-01-15,0.2522,0.1847429,0.2417,0.2330143,44.02,296.971428571,298.021428571,295.312857143,306.8,292.8,44.6,91.8028571429,44.02,16.9028571429,7.52857142857,26.7,7.46666666667,31.8,22.6,82.0
+iq,2013,4,2013-01-22,0.1837286,0.1270571,0.1659857,0.1637286,97.26,297.698571429,298.964285714,296.708571429,306.9,293.6,71.9,94.8728571429,97.26,18.3914285714,8.21428571429,27.9666666667,10.0333333333,33.6,22.5,36.8
+iq,2013,5,2013-01-29,0.3688571,0.3753286,0.3368714,0.4180143,43.53,297.625714286,298.571428571,296.045714286,307.4,292.7,88.6,92.5128571429,43.53,17.6185714286,7.6,26.7,6.45,33.3,23.2,51.3
+iq,2013,6,2013-02-05,0.2749571,0.2709143,0.2930429,0.2944,97.8,298.005714286,299.678571429,296.985714286,307.1,293.9,104.2,94.7528571429,97.8,18.7242857143,9.52857142857,28.35,9.05,33.4,22.4,15.0
+iq,2013,7,2013-02-12,0.2670286,0.1907286,0.2791857,0.2821857,129.23,297.817142857,298.992857143,296.377142857,305.3,293.5,188.1,92.9057142857,129.23,18.04,7.78571428571,27.8,8.6,33.8,22.4,19.6
+iq,2013,8,2013-02-19,0.2979667,0.32775,0.2443571,0.3086714,66.47,297.747142857,298.942857143,296.782857143,305.5,294.1,152.4,95.3114285714,66.47,18.4657142857,6.91428571429,27.12,9.24,33.0,21.7,33.3
+iq,2013,9,2013-02-26,0.3455167,0.3468667,0.3371167,0.38255,39.19,297.0,298.707142857,296.245714286,305.9,292.7,62.4,96.0228571429,39.19,17.8914285714,7.7,27.6,9.56666666667,34.2,21.8,111.3
+iq,2013,10,2013-03-05,0.2953429,0.3098571,0.2546857,0.2637286,111.09,296.958571429,298.064285714,296.47,303.7,294.2,69.2,97.4785714286,111.09,18.12,6.18571428571,27.7333333333,9.53333333333,34.2,22.6,149.9
+iq,2013,11,2013-03-12,0.2236714,0.11945,0.2248,0.2283714,27.21,297.935714286,299.621428571,297.038571429,305.4,294.4,97.0,95.54,27.21,18.7542857143,8.32857142857,28.3666666667,10.5333333333,34.3,22.2,35.1
+iq,2013,12,2013-03-19,0.2318,0.1955833,0.2047857,0.2501857,76.86,298.188571429,299.407142857,297.562857143,305.3,294.6,111.3,96.7485714286,76.86,19.3771428571,7.12857142857,27.9,9.16666666667,34.9,22.8,0.0
+iq,2013,13,2013-03-26,0.2634286,0.2106143,0.2694143,0.2458714,104.47,298.327142857,299.885714286,297.141428571,307.5,294.1,81.72,94.2185714286,104.47,18.8928571429,8.94285714286,28.15,11.15,34.2,22.0,70.6
+iq,2013,14,2013-04-02,0.2235429,0.2085429,0.2399714,0.2185571,122.6,297.621428571,299.157142857,296.518571429,305.3,294.3,131.3,94.63,122.6,18.1485714286,8.0,28.7,10.8333333333,34.8,21.8,36.8
+iq,2013,15,2013-04-09,0.2632,0.2374,0.2501429,0.1991143,88.07,297.754285714,299.485714286,296.3,307.9,293.7,52.2,93.0914285714,88.07,17.91,9.4,27.6333333333,9.53333333333,33.6,22.0,54.1
+iq,2013,16,2013-04-16,0.3090286,0.2702667,0.2355,0.2596857,44.3,298.647142857,299.778571429,296.885714286,309.5,294.0,121.0,91.8628571429,44.3,18.6328571429,8.35714285714,28.3333333333,10.0,34.2,22.4,53.6
+iq,2013,17,2013-04-23,0.1933143,0.2470571,0.2756429,0.3727286,71.07,297.202857143,297.928571429,296.561428571,304.0,293.0,58.2,96.58,71.07,18.18,7.2,26.95,9.35,33.6,21.2,74.9
+iq,2013,18,2013-04-30,0.3851429,0.3697,0.3759333,0.3542143,2.28,297.981428571,299.2,293.228571429,308.6,289.4,2.6,77.7571428571,2.28,14.8528571429,14.2857142857,27.25,13.125,35.0,18.2,8.9
+iq,2013,19,2013-05-07,0.3963429,0.2924714,0.3334,0.3522714,62.52,298.31,299.792857143,296.792857143,307.8,293.3,52.6,92.25,62.52,18.4785714286,9.67142857143,28.45,9.85,34.6,22.4,7.1
+iq,2013,20,2013-05-14,0.3525571,0.28105,0.3070714,0.2774,46.27,297.367142857,298.157142857,296.435714286,304.0,293.3,105.7,95.3385714286,46.27,18.0385714286,6.4,28.2333333333,9.4,34.1,21.4,38.6
+iq,2013,21,2013-05-21,0.2368286,0.2938571,0.2234429,0.2994286,87.29,296.88,297.792857143,295.85,305.8,292.5,124.2,94.74,87.29,17.3828571429,6.7,26.6333333333,8.9,32.8,21.8,97.3
+iq,2013,22,2013-05-28,0.3014714,0.3800286,0.2806286,0.3831857,41.12,297.774285714,298.964285714,295.638571429,305.5,292.7,67.6,89.99,41.12,17.1857142857,10.1,27.4,9.05,32.6,21.8,33.0
+iq,2013,23,2013-06-04,0.2476,0.2963429,0.2853714,0.3503571,71.52,297.167142857,298.328571429,295.845714286,306.3,291.6,45.7,93.8914285714,71.52,17.4485714286,9.65714285714,27.52,10.72,33.8,21.4,68.0
+iq,2013,24,2013-06-11,0.2387286,0.2510286,0.2525857,0.2497714,78.96,295.831428571,296.607142857,294.894285714,304.6,290.7,45.22,94.9671428571,78.96,16.41,7.38571428571,27.2,10.075,32.6,21.6,93.2
+iq,2013,25,2013-06-18,0.3104286,0.3027,0.4066143,0.4039429,39.54,295.778571429,297.4,293.648571429,305.9,292.5,4.7,89.0571428571,39.54,15.1371428571,8.22857142857,26.7,8.48,32.2,21.8,34.1
+iq,2013,26,2013-06-25,0.3394667,0.2400714,0.3569429,0.2736,51.8,297.372857143,299.0,294.615714286,307.3,289.6,27.8,87.03,51.8,16.1485714286,11.5428571429,27.35,9.675,32.6,22.0,14.9
diff --git a/examples/dengue-fever-time-series/data/dengue_features_train.csv b/examples/dengue-fever-time-series/data/dengue_features_train.csv
new file mode 100644
index 000000000..121a3e8c1
--- /dev/null
+++ b/examples/dengue-fever-time-series/data/dengue_features_train.csv
@@ -0,0 +1,1457 @@
+,city,year,weekofyear,week_start_date,ndvi_ne,ndvi_nw,ndvi_se,ndvi_sw,precipitation_amt_mm,reanalysis_air_temp_k,reanalysis_avg_temp_k,reanalysis_dew_point_temp_k,reanalysis_max_air_temp_k,reanalysis_min_air_temp_k,reanalysis_precip_amt_kg_per_m2,reanalysis_relative_humidity_percent,reanalysis_sat_precip_amt_mm,reanalysis_specific_humidity_g_per_kg,reanalysis_tdtr_k,station_avg_temp_c,station_diur_temp_rng_c,station_max_temp_c,station_min_temp_c,station_precip_mm
+0,sj,1990,18,1990-04-30,0.1226,0.103725,0.1984833,0.1776167,12.42,297.5728571,297.7428571,292.4142857,299.8,295.9,32.0,73.36571429,12.42,14.01285714,2.628571429,25.44285714,6.9,29.4,20.0,16.0
+1,sj,1990,19,1990-05-07,0.1699,0.142175,0.1623571,0.1554857,22.82,298.2114286,298.4428571,293.9514286,300.9,296.4,17.94,77.36857143,22.82,15.37285714,2.371428571,26.71428571,6.371428571,31.7,22.2,8.6
+2,sj,1990,20,1990-05-14,0.03225,0.1729667,0.1572,0.1708429,34.54,298.7814286,298.8785714,295.4342857,300.5,297.3,26.1,82.05285714,34.54,16.84857143,2.3,26.71428571,6.485714286,32.2,22.8,41.4
+3,sj,1990,21,1990-05-21,0.1286333,0.2450667,0.2275571,0.2358857,15.36,298.9871429,299.2285714,295.31,301.4,297.0,13.9,80.33714286,15.36,16.67285714,2.428571429,27.47142857,6.771428571,33.3,23.3,4.0
+4,sj,1990,22,1990-05-28,0.1962,0.2622,0.2512,0.24734,7.52,299.5185714,299.6642857,295.8214286,301.9,297.5,12.2,80.46,7.52,17.21,3.014285714,28.94285714,9.371428571,35.0,23.9,5.8
+5,sj,1990,23,1990-06-04,,0.17485,0.2543143,0.1817429,9.58,299.63,299.7642857,295.8514286,302.4,298.1,26.49,79.89142857,9.58,17.21285714,2.1,28.11428571,6.942857143,34.4,23.9,39.1
+6,sj,1990,24,1990-06-11,0.1129,0.0928,0.2050714,0.2102714,3.48,299.2071429,299.2214286,295.8657143,301.3,297.7,38.6,82.0,3.48,17.23428571,2.042857143,27.41428571,6.771428571,32.2,23.3,29.7
+7,sj,1990,25,1990-06-18,0.0725,0.0725,0.1514714,0.1330286,151.12,299.5914286,299.5285714,296.5314286,300.6,298.4,30.0,83.37571429,151.12,17.97714286,1.571428571,28.37142857,7.685714286,33.9,22.8,21.1
+8,sj,1990,26,1990-06-25,0.10245,0.146175,0.1255714,0.1236,19.32,299.5785714,299.5571429,296.3785714,302.1,297.7,37.51,82.76857143,19.32,17.79,1.885714286,28.32857143,7.385714286,33.9,22.8,21.1
+9,sj,1990,27,1990-07-02,,0.12155,0.1606833,0.2025667,14.41,300.1542857,300.2785714,296.6514286,302.3,298.7,28.4,81.28142857,14.41,18.07142857,2.014285714,28.32857143,6.514285714,33.9,24.4,1.1
+10,sj,1990,28,1990-07-09,0.192875,0.08235,0.1919429,0.1529286,22.27,299.5128571,299.5928571,296.0414286,301.8,298.0,43.72,81.46714286,22.27,17.41857143,2.157142857,27.55714286,7.157142857,31.7,21.7,63.7
+11,sj,1990,29,1990-07-16,0.2916,0.2118,0.3012,0.2806667,59.17,299.6671429,299.75,296.3342857,302.0,297.3,40.9,82.14428571,59.17,17.73714286,2.414285714,28.12857143,6.9,32.8,23.9,12.2
+12,sj,1990,30,1990-07-23,0.1505667,0.1717,0.2269,0.2145571,16.48,299.5585714,299.6357143,295.96,301.8,297.1,42.53,80.74285714,16.48,17.34142857,2.071428571,28.11428571,6.357142857,31.7,22.8,32.6
+13,sj,1990,31,1990-07-30,,0.24715,0.3797,0.3813571,32.66,299.8628571,299.95,296.1728571,303.0,298.3,34.6,80.58428571,32.66,17.59428571,2.585714286,28.24285714,8.085714286,34.4,22.8,37.6
+14,sj,1990,32,1990-08-06,,0.06433333,0.1644429,0.1388571,28.8,300.3914286,300.4785714,296.5328571,302.5,298.8,20.0,79.65,28.8,17.95,2.328571429,28.2,7.557142857,33.3,23.3,11.4
+15,sj,1990,33,1990-08-13,,0.1280333,0.2069571,0.1682429,90.75,299.9585714,299.9571429,297.0357143,302.6,298.5,101.9,84.17857143,90.75,18.51571429,1.857142857,28.04285714,6.685714286,32.8,22.8,44.7
+16,sj,1990,34,1990-08-20,0.1902333,0.1688,0.1676571,0.1722857,32.4,300.3328571,300.4142857,296.7285714,302.5,298.1,25.9,80.94714286,32.4,18.17428571,2.485714286,28.34285714,7.014285714,33.3,23.3,5.4
+17,sj,1990,35,1990-08-27,0.2529,0.33075,0.2641714,0.2843143,40.94,300.1185714,300.2214286,297.0171429,302.2,298.7,39.8,83.34857143,40.94,18.51571429,1.9,28.65714286,6.528571429,32.2,24.4,13.7
+18,sj,1990,36,1990-09-03,0.2354,0.200025,0.2838167,0.2304429,28.86,300.53,300.6357143,296.1171429,303.8,298.0,30.4,77.17285714,28.86,17.56,3.471428571,28.32857143,7.614285714,32.8,23.3,14.2
+19,sj,1990,37,1990-09-10,0.1279667,0.4371,0.1234,0.1482833,64.56,300.6742857,300.7928571,297.1928571,302.9,299.0,24.18,81.55142857,64.56,18.77714286,2.9,28.68571429,8.057142857,33.9,24.4,25.9
+20,sj,1990,38,1990-09-17,0.19635,0.1824333,0.2548286,0.3056857,143.73,299.8571429,299.9,296.4314286,301.7,298.7,36.6,81.63714286,143.73,17.89285714,1.742857143,28.24285714,8.114285714,32.8,23.9,3.3
+21,sj,1990,39,1990-09-24,0.1161,0.2609,0.1994429,0.2442167,51.39,300.4271429,300.6,296.0285714,302.4,299.1,16.4,77.04857143,51.39,17.46857143,2.257142857,28.34285714,7.728571429,32.8,24.4,15.8
+22,sj,1990,40,1990-10-01,0.22855,0.18975,0.2124857,0.2011857,31.18,300.7757143,300.85,296.6642857,303.3,299.1,36.1,78.52,31.18,18.18,2.9,28.77142857,8.028571429,33.3,23.9,11.7
+23,sj,1990,41,1990-10-08,0.17115,0.06755,0.1794667,0.1577167,51.42,299.8571429,299.9428571,296.9285714,301.8,298.1,132.4,84.11,51.42,18.51285714,2.571428571,28.62857143,7.314285714,33.3,24.4,57.7
+24,sj,1990,42,1990-10-15,,0.0702,0.1816167,0.16575,143.55,299.1957143,299.3071429,296.5442857,301.5,297.5,279.6,85.62142857,143.55,18.11571429,1.871428571,27.62857143,7.4,32.8,23.3,61.8
+25,sj,1990,43,1990-10-22,0.1462,0.08975,0.1288286,0.1239286,127.03,298.9028571,299.0428571,296.2571429,300.9,297.2,94.52,85.50285714,127.03,17.75,1.8,26.77142857,7.628571429,32.2,21.7,91.5
+26,sj,1990,44,1990-10-29,0.25225,0.1834333,0.318,0.2959,101.35,299.7271429,299.7785714,296.5342857,301.4,298.5,22.26,82.78714286,101.35,18.03428571,1.785714286,27.97142857,8.642857143,33.3,22.8,6.3
+27,sj,1990,45,1990-11-05,0.1526,0.181775,0.1783286,0.1866286,20.46,299.9728571,300.0357143,296.5642857,302.2,298.5,14.4,81.71571429,20.46,18.07428571,2.385714286,28.47142857,8.428571429,33.3,23.9,6.6
+28,sj,1990,46,1990-11-12,0.2908,0.2246,0.1803857,0.2348857,20.0,300.35,300.5,295.6871429,302.3,298.8,7.1,75.72857143,20.0,17.08571429,2.2,27.54285714,8.6,32.8,22.2,38.9
+29,sj,1990,47,1990-11-19,0.2722,0.33035,0.1316333,0.1253833,20.04,299.5114286,299.6357143,295.3757143,301.6,297.0,36.7,78.15142857,20.04,16.75285714,2.528571429,26.8,7.414285714,31.7,22.2,9.6
+30,sj,1990,48,1990-11-26,0.1367667,0.216525,0.1767857,0.1415857,33.61,298.2385714,298.2642857,294.8114286,300.2,296.5,44.3,81.38571429,33.61,16.20857143,1.985714286,26.2,7.128571429,31.1,20.6,26.7
+31,sj,1990,49,1990-12-03,0.1098,0.0886,0.2667833,0.2517,9.96,298.5428571,298.6857143,294.7828571,300.8,296.7,71.8,79.90857143,9.96,16.16142857,2.057142857,25.98571429,5.542857143,29.4,22.2,69.0
+32,sj,1990,50,1990-12-10,0.12135,0.26166,0.1913857,0.2099857,0.0,298.2028571,298.2785714,292.0042857,300.6,296.1,4.1,68.72285714,0.0,13.61571429,2.985714286,24.68571429,7.771428571,29.4,19.4,2.8
+33,sj,1990,51,1990-12-17,0.2931333,0.2668667,0.2608571,0.3027286,52.45,298.2971429,298.3785714,294.5585714,300.9,296.0,32.31,80.08285714,52.45,15.95428571,2.871428571,25.71428571,6.585714286,30.6,21.1,19.8
+34,sj,1990,52,1990-12-24,0.3025,0.2772333,0.1712667,0.1616222,0.0,298.0385714,298.0857143,292.1057143,299.8,295.3,5.46,69.68142857,0.0,13.68285714,2.285714286,25.15714286,5.842857143,28.9,21.1,20.9
+35,sj,1991,1,1991-01-01,0.1465,0.1404667,0.1515,0.1673143,0.0,297.06,297.1357143,291.9071429,299.0,293.9,4.8,72.93857143,0.0,13.51142857,2.528571429,24.38571429,7.457142857,29.4,18.9,5.3
+36,sj,1991,2,1991-01-08,,0.1004667,0.2519,0.1376167,15.85,297.6742857,297.8285714,293.2828571,299.3,295.8,26.33,76.62857143,15.85,14.67142857,1.885714286,24.91428571,6.314285714,28.3,21.1,31.7
+37,sj,1991,3,1991-01-15,,0.2935667,0.2599429,0.2179,0.0,297.4228571,297.6571429,293.4128571,299.3,296.1,27.4,78.5,0.0,14.79857143,2.0,25.24285714,6.571428571,29.4,21.1,16.5
+38,sj,1991,4,1991-01-22,0.3313,0.3093333,0.2210286,0.2027571,0.0,297.8842857,298.15,292.3828571,300.3,296.0,0.7,71.59714286,0.0,13.87857143,2.557142857,24.71428571,7.771428571,29.4,18.3,6.8
+39,sj,1991,5,1991-01-29,0.0917,0.246425,0.2438571,0.1956,0.0,298.0442857,298.2285714,292.5728571,300.1,295.0,5.7,71.78428571,0.0,14.04428571,2.771428571,24.82857143,8.157142857,30.0,18.9,5.9
+40,sj,1991,6,1991-02-05,0.3801,0.2285667,0.2550429,0.2258,0.0,297.74,297.9285714,293.15,299.7,295.0,19.69,75.79428571,0.0,14.54142857,2.428571429,25.05714286,6.885714286,30.0,20.6,7.3
+41,sj,1991,7,1991-02-12,0.0712,0.2211,0.2762429,0.2673429,18.05,296.8842857,297.1142857,292.9728571,300.2,294.1,21.4,78.89571429,18.05,14.46,3.2,25.14285714,8.871428571,32.2,18.9,5.6
+42,sj,1991,8,1991-02-19,,0.2094,0.1084333,0.1194,0.0,297.4142857,297.6142857,293.6314286,300.1,295.8,26.2,79.74,0.0,15.03571429,2.571428571,25.84285714,8.471428571,32.2,20.0,17.8
+43,sj,1991,9,1991-02-26,0.1702,0.2086,0.13752,0.1914333,31.79,297.5057143,297.8285714,293.4071429,299.8,295.8,23.8,77.97714286,31.79,14.79428571,2.114285714,25.25714286,7.2,30.6,20.0,30.7
+44,sj,1991,10,1991-03-05,0.21075,0.2641,0.2476857,0.2163571,0.0,297.7771429,298.0785714,293.5314286,300.3,296.4,8.3,77.31571429,0.0,14.92,2.242857143,26.01428571,8.314285714,31.1,20.6,10.9
+45,sj,1991,11,1991-03-12,,,0.21325,0.2405429,0.0,297.4314286,297.6357143,293.3357143,300.1,295.7,13.37,78.13857143,0.0,14.78714286,2.728571429,25.92857143,8.971428571,31.7,20.6,3.6
+46,sj,1991,12,1991-03-19,0.1279,0.1784,0.1470143,0.1593,0.0,297.4071429,297.6142857,293.2542857,300.4,295.4,11.1,77.88285714,0.0,14.74571429,2.542857143,26.08571429,6.971428571,32.2,21.1,5.7
+47,sj,1991,13,1991-03-26,0.28035,0.223575,0.2478833,0.2473857,0.0,297.47,297.6928571,293.74,301.0,295.7,21.26,80.00142857,0.0,15.14857143,2.757142857,26.05714286,6.585714286,32.2,22.2,26.9
+48,sj,1991,14,1991-04-02,0.1691,0.216825,0.2605143,0.2219714,12.92,297.0642857,297.1857143,292.48,299.4,295.4,20.9,75.66285714,12.92,13.99142857,2.285714286,25.24285714,6.814285714,28.9,20.6,4.1
+49,sj,1991,15,1991-04-09,0.1765,0.2763,0.1845333,0.1773667,6.0,297.3728571,297.6571429,293.6157143,299.2,295.9,19.78,79.62857143,6.0,14.99285714,2.628571429,25.3,6.514285714,28.9,21.1,18.8
+50,sj,1991,16,1991-04-16,0.0774,0.1024,0.16355,0.2061667,44.57,297.2842857,297.3928571,292.17,298.9,296.0,21.9,73.35142857,44.57,13.73285714,2.014285714,25.51428571,6.271428571,29.4,21.1,19.4
+51,sj,1991,17,1991-04-23,,0.18845,0.1883143,0.2249429,32.72,298.0742857,298.2357143,294.0285714,299.6,296.7,19.7,78.44714286,32.72,15.46142857,2.3,26.52857143,8.014285714,32.8,21.7,3.5
+52,sj,1991,18,1991-04-30,0.2091667,0.160575,0.1761714,0.1761714,0.0,298.8314286,299.0714286,294.97,301.0,297.1,8.38,79.36,0.0,16.31428571,2.8,27.31428571,7.714285714,32.2,22.8,2.8
+53,sj,1991,19,1991-05-07,0.11595,0.180175,0.1063857,0.1111857,35.38,298.6385714,298.7214286,294.8128571,300.9,297.2,20.6,79.54142857,35.38,16.18571429,2.414285714,26.92857143,6.928571429,31.7,22.8,40.2
+54,sj,1991,20,1991-05-14,,0.10455,0.15115,0.0964,4.16,298.3257143,298.4071429,294.6185714,300.1,296.6,35.37,80.06714286,4.16,15.97428571,2.5,26.52857143,6.585714286,30.6,22.8,32.8
+55,sj,1991,21,1991-05-21,0.0669,0.1335667,0.09711667,0.1356,51.16,298.5842857,298.4571429,295.1242857,300.4,297.0,59.3,81.30142857,51.16,16.50142857,1.857142857,27.38571429,6.7,31.7,22.8,3.6
+56,sj,1991,22,1991-05-28,0.1401,0.1594667,0.2143167,0.2571,55.37,298.8085714,298.8857143,295.2742857,301.1,297.3,43.4,81.08857143,55.37,16.64571429,2.142857143,27.94285714,7.014285714,33.3,23.3,5.6
+57,sj,1991,23,1991-06-04,0.08585,0.087,0.1196,0.1659286,8.08,299.5185714,299.75,294.9257143,301.6,297.4,5.0,76.07428571,8.08,16.32428571,2.871428571,28.07142857,7.5,33.3,23.3,20.6
+58,sj,1991,24,1991-06-11,0.1091,0.1564667,0.1734286,0.1739714,6.09,299.8914286,300.0714286,295.4928571,301.8,298.4,5.82,77.03571429,6.09,16.88285714,2.4,28.22857143,7.971428571,33.9,23.9,9.4
+59,sj,1991,25,1991-06-18,0.0596,0.09235,0.1301286,0.1306429,44.25,299.7757143,299.9714286,296.3,301.9,298.4,17.0,81.42142857,44.25,17.70428571,2.171428571,28.92857143,7.142857143,33.9,25.0,3.3
+60,sj,1991,26,1991-06-25,0.07965,0.122,0.1851143,0.1582429,73.76,299.41,299.4785714,296.2285714,302.5,297.7,37.8,82.74571429,73.76,17.62857143,2.042857143,27.91428571,7.4,32.8,22.8,12.4
+61,sj,1991,27,1991-07-02,,0.1779333,0.2015286,0.1981571,26.7,299.3714286,299.3857143,295.9457143,302.4,297.4,51.99,81.69428571,26.7,17.35285714,2.142857143,28.37142857,6.6,32.8,23.9,24.7
+62,sj,1991,28,1991-07-09,0.0969,,0.13805,0.1679167,6.13,300.0014286,300.1714286,295.7914286,302.1,297.9,18.7,77.87714286,6.13,17.15142857,2.428571429,28.41428571,6.671428571,32.8,24.4,4.6
+63,sj,1991,29,1991-07-16,,0.07733333,0.09982857,0.1166429,29.67,300.2342857,300.3428571,296.0814286,302.2,298.6,23.6,78.24142857,29.67,17.47285714,2.428571429,28.8,6.914285714,33.9,23.9,12.2
+64,sj,1991,30,1991-07-23,0.0801,0.00805,0.1380333,0.1290667,56.58,299.8085714,299.9785714,296.3328571,302.1,298.2,27.4,81.48285714,56.58,17.73428571,2.242857143,28.0,5.885714286,32.8,24.4,43.1
+65,sj,1991,31,1991-07-30,,,0.1906429,0.1593286,48.41,299.8528571,299.9642857,296.4785714,302.0,298.3,34.39,81.89714286,48.41,17.87857143,2.3,28.57142857,6.342857143,33.3,25.0,18.0
+66,sj,1991,32,1991-08-06,0.07315,0.1124,0.1925857,0.2093571,13.29,299.8314286,299.8642857,296.4685714,301.8,298.1,31.5,81.96,13.29,17.89571429,2.242857143,28.5,6.514285714,32.8,24.4,12.5
+67,sj,1991,33,1991-08-13,0.0593,,0.1551,0.1567,0.0,300.42,300.65,296.4842857,302.8,298.7,20.4,79.19714286,0.0,17.91142857,2.185714286,29.42857143,5.471428571,33.3,25.6,3.3
+68,sj,1991,34,1991-08-20,0.0569,0.09814,0.1285143,0.1437286,51.88,300.3114286,300.3857143,296.5814286,302.6,298.3,25.47,80.25571429,51.88,18.01142857,2.4,29.27142857,7.514285714,34.4,24.4,1.5
+69,sj,1991,35,1991-08-27,0.0693,0.05705,0.22504,0.1864,55.2,300.1171429,300.2,296.67,302.3,298.6,23.8,81.59428571,55.2,18.09142857,2.371428571,28.15714286,7.0,32.2,23.9,10.7
+70,sj,1991,36,1991-09-03,0.10805,0.091675,0.1398,0.1624143,65.9,300.1057143,300.15,296.7985714,302.3,298.4,42.33,82.31,65.9,18.26285714,2.128571429,28.94285714,7.542857143,34.4,24.4,27.2
+71,sj,1991,37,1991-09-10,0.10475,0.1598333,0.11208,0.1446429,33.56,300.54,300.6357143,296.4514286,302.8,298.7,11.4,78.62714286,33.56,17.89571429,3.042857143,28.97142857,7.7,33.9,23.3,61.0
+72,sj,1991,38,1991-09-17,0.1098,0.1527333,0.1685714,0.1688714,29.53,300.5271429,300.6,296.9014286,303.0,298.8,28.8,80.87714286,29.53,18.4,2.457142857,28.91428571,6.8,33.3,24.4,7.9
+73,sj,1991,39,1991-09-24,0.1676,0.1489,0.1714286,0.2181429,73.55,300.06,300.05,296.59,302.4,298.2,77.5,81.42428571,73.55,18.04428571,2.071428571,28.14285714,6.685714286,32.8,24.4,31.8
+74,sj,1991,40,1991-10-01,0.1291,0.16672,0.177,0.1955571,31.68,299.65,299.6928571,296.3971429,301.6,298.3,60.0,82.48571429,31.68,17.85,2.042857143,27.74285714,6.914285714,32.8,23.3,26.5
+75,sj,1991,41,1991-10-08,0.093,0.093,0.1450833,0.1681667,32.1,299.5628571,299.6714286,295.8871429,302.0,297.6,55.1,80.51571429,32.1,17.34428571,2.257142857,27.65714286,6.614285714,31.7,22.8,8.3
+76,sj,1991,42,1991-10-15,0.0137,0.12886,0.1090429,0.1070286,3.29,299.8971429,299.9214286,296.0185714,302.0,298.1,31.19,79.38285714,3.29,17.43142857,2.3,28.54285714,7.628571429,33.9,24.4,21.3
+77,sj,1991,43,1991-10-22,0.1944,0.1186,0.1808143,0.1998714,50.24,299.8914286,299.9928571,295.4557143,302.0,298.0,12.6,76.77714286,50.24,16.85,2.814285714,27.82857143,7.085714286,32.8,23.3,3.5
+78,sj,1991,44,1991-10-29,0.094,0.09665,0.1255667,0.1213167,72.61,299.9057143,299.9928571,295.9185714,302.4,298.1,26.83,78.98714286,72.61,17.37571429,3.042857143,28.11428571,7.257142857,32.8,24.4,4.8
+79,sj,1991,45,1991-11-05,0.0544,0.05475,0.1121333,0.1193857,42.92,299.09,299.2785714,295.5671429,302.6,297.3,74.83,81.05857143,42.92,16.96714286,2.9,27.18571429,6.757142857,32.2,22.8,41.4
+80,sj,1991,46,1991-11-12,0.0954,0.1114,0.1949429,0.1980571,78.73,298.6857143,298.7857143,295.6157143,301.0,297.4,72.7,83.51428571,78.73,17.06142857,1.971428571,26.65714286,6.742857143,31.1,22.2,28.2
+81,sj,1991,47,1991-11-19,0.00825,0.028425,0.1387429,0.1796429,0.0,298.6985714,298.7071429,294.03,300.8,297.1,15.1,75.54857143,0.0,15.46,2.271428571,26.31428571,6.814285714,30.0,22.2,9.4
+82,sj,1991,48,1991-11-26,0.08786667,0.1519,0.1796286,0.1661857,35.34,298.3757143,298.5,294.9385714,301.1,296.9,78.43,81.48571429,35.34,16.32285714,2.028571429,26.27142857,6.585714286,30.0,22.2,76.2
+83,sj,1991,49,1991-12-03,0.0802,0.14025,0.1336286,0.1344571,0.0,298.6428571,298.8428571,294.9742857,300.5,297.7,35.1,80.27571429,0.0,16.34,1.8,26.72857143,6.057142857,30.6,23.3,19.6
+84,sj,1991,50,1991-12-10,-0.02665,0.2128,0.2224143,0.2289429,0.0,298.5185714,298.5928571,294.5142857,300.2,297.3,26.8,78.62142857,0.0,15.88428571,2.014285714,25.61428571,5.857142857,29.4,21.7,34.2
+85,sj,1991,51,1991-12-17,,0.04613333,0.1144,0.04045714,0.0,298.0842857,298.1357143,292.8657143,299.6,296.6,8.76,72.86142857,0.0,14.33571429,2.071428571,25.0,6.157142857,28.9,20.6,6.1
+86,sj,1991,52,1991-12-24,0.12355,0.1237,0.1379333,0.1297556,0.0,296.5214286,296.5071429,292.0457143,299.2,294.3,19.3,76.12714286,0.0,13.63571429,2.214285714,24.35714286,6.185714286,28.3,19.4,13.7
+87,sj,1992,1,1992-01-01,0.1251,0.1578667,0.1852833,0.1813667,,,,,,,,,,,,,,,,
+88,sj,1992,2,1992-01-08,0.1008333,0.073575,0.1387143,0.1127857,200.85,297.9128571,298.1214286,294.4571429,300.4,296.1,18.3,81.3,200.85,15.87857143,2.3,25.65714286,7.5,30.6,20.6,58.2
+89,sj,1992,3,1992-01-15,0.2224,0.2299,0.1984571,0.1994143,3.12,297.3385714,297.4857143,294.4671429,300.2,295.6,19.8,84.11714286,3.12,15.83285714,1.857142857,25.47142857,6.171428571,31.1,21.7,32.3
+90,sj,1992,4,1992-01-22,0.1225333,0.13105,0.1888429,0.1688714,0.0,297.0914286,297.3357143,293.0214286,299.5,295.6,5.11,78.29142857,0.0,14.48285714,2.357142857,24.85714286,7.442857143,30.6,20.0,1.3
+91,sj,1992,5,1992-01-29,,0.0483,0.1736714,0.1919286,0.0,297.42,297.55,292.7185714,299.3,295.5,6.5,75.22,0.0,14.18571429,2.442857143,24.8,6.585714286,28.9,20.0,9.2
+92,sj,1992,6,1992-02-05,0.1016,0.0846,0.1117167,0.1879571,0.0,296.92,297.1285714,292.6171429,300.7,294.5,16.2,77.05857143,0.0,14.12285714,3.4,24.71428571,7.357142857,30.6,20.0,3.0
+93,sj,1992,7,1992-02-12,,0.1305,0.1957429,0.1788571,,297.7985714,298.0571429,294.65,300.2,295.3,20.1,82.87571429,,16.06,2.2,26.02857143,6.571428571,32.2,20.0,1.3
+94,sj,1992,8,1992-02-19,,0.1844667,0.1946143,0.2030571,,297.8985714,298.1071429,293.6285714,300.1,296.3,4.4,77.29571429,,15.01285714,2.585714286,25.75714286,7.385714286,33.9,21.7,8.9
+95,sj,1992,9,1992-02-26,0.10705,0.0815,0.1652429,0.1630571,,297.4728571,297.6785714,292.9671429,299.3,296.3,14.4,76.03714286,,14.38142857,2.414285714,25.28571429,6.171428571,29.4,21.7,16.0
+96,sj,1992,10,1992-03-04,,0.18218,0.1910857,0.1928571,0.0,297.6514286,297.8,293.3171429,299.8,295.7,5.5,76.87857143,0.0,14.70142857,2.314285714,25.65714286,7.814285714,31.1,20.6,2.9
+97,sj,1992,11,1992-03-11,0.08685,0.09015,0.128,0.1551,23.22,297.6342857,297.7857143,293.54,299.6,296.1,12.6,78.05714286,23.22,14.94428571,2.514285714,25.78571429,7.757142857,31.7,21.7,5.9
+98,sj,1992,12,1992-03-18,0.05305,0.08405,0.1417714,0.1345143,0.0,297.9471429,298.15,293.7085714,300.4,295.5,3.56,77.50571429,0.0,15.13571429,2.7,26.1,7.857142857,31.1,21.7,4.8
+99,sj,1992,13,1992-03-25,,,0.1348429,0.1068,0.0,297.2185714,297.4285714,293.5785714,300.3,295.8,21.0,80.23857143,0.0,14.96857143,2.8,26.2,5.714285714,32.2,22.2,2.3
+100,sj,1992,14,1992-04-01,0.09995,0.07765,0.1930667,0.1769,122.27,297.9828571,298.0714286,293.8842857,300.2,296.0,16.2,78.06714286,122.27,15.26428571,2.742857143,26.22857143,7.528571429,31.1,21.7,24.1
+101,sj,1992,15,1992-04-08,0.1039,0.1315,0.1224714,0.1243857,43.21,298.6828571,298.8785714,294.1957143,301.6,295.9,11.1,76.37571429,43.21,15.61285714,3.614285714,26.98571429,7.842857143,32.8,21.7,0.0
+102,sj,1992,16,1992-04-15,0.07515,0.09743333,0.1590286,0.1729857,83.11,297.8314286,298.0,294.9428571,300.4,296.6,70.6,84.18428571,83.11,16.32428571,2.142857143,26.81428571,5.885714286,31.7,22.8,24.5
+103,sj,1992,17,1992-04-22,0.0922,0.1137,0.1514143,0.1548286,36.16,298.0885714,298.2571429,294.0485714,300.6,296.5,25.8,78.42571429,36.16,15.45285714,2.828571429,26.67142857,7.242857143,31.7,22.2,4.6
+104,sj,1992,18,1992-04-29,0.0125,0.0635,0.07031429,0.08944286,0.0,298.1971429,298.5214286,293.4,302.1,295.6,4.0,74.93285714,0.0,14.9,3.614285714,27.37142857,6.5,33.9,23.3,1.6
+105,sj,1992,19,1992-05-06,0.10875,0.2169,0.1823286,0.2073571,13.92,298.3357143,298.4428571,294.2214286,302.1,296.0,45.0,78.48,13.92,15.75,3.0,26.78571429,6.914285714,33.9,22.2,32.0
+106,sj,1992,20,1992-05-13,0.101875,-0.0088,0.1420667,0.1259,2.94,298.3342857,298.5142857,294.2757143,300.4,296.4,27.5,78.38142857,2.94,15.68714286,2.228571429,27.44285714,5.957142857,31.1,22.8,8.1
+107,sj,1992,21,1992-05-20,0.1024,0.0686,0.06238333,0.0574,71.85,298.4085714,298.5571429,295.7671429,301.0,296.8,570.5,85.64714286,71.85,17.23285714,2.714285714,27.85714286,6.771428571,32.8,23.3,22.1
+108,sj,1992,22,1992-05-27,0.1215,,0.2191571,0.2130143,186.25,298.6157143,298.75,296.3342857,301.4,297.0,130.3,87.30142857,186.25,17.83285714,2.357142857,27.42857143,5.957142857,31.7,23.9,80.2
+109,sj,1992,23,1992-06-03,0.12165,0.13995,0.1100857,0.1022286,42.24,299.1042857,299.2285714,296.5228571,301.0,297.8,50.0,85.82714286,42.24,17.99571429,2.114285714,27.5,6.914285714,31.7,22.8,103.9
+110,sj,1992,24,1992-06-10,0.08395,0.0856,0.1023714,0.1117714,43.21,298.9014286,298.9642857,296.1542857,300.5,297.6,43.8,84.87,43.21,17.57,1.985714286,28.2,6.871428571,32.8,24.4,102.4
+111,sj,1992,25,1992-06-17,0.10445,0.15315,0.1811571,0.1920857,52.07,298.9314286,298.9571429,296.0428571,301.0,297.0,37.1,84.24857143,52.07,17.44142857,2.0,28.28571429,6.742857143,32.8,24.4,29.8
+112,sj,1992,26,1992-06-24,0.1302,0.1302,0.13938,0.11475,52.96,299.5685714,299.55,296.3842857,301.8,298.0,33.7,82.77714286,52.96,17.80714286,1.728571429,28.48571429,7.028571429,32.8,23.9,5.4
+113,sj,1992,27,1992-07-01,0.1194,0.1439,0.1693286,0.1684714,10.74,300.1771429,300.3785714,296.2757143,301.8,298.3,10.0,79.33428571,10.74,17.66714286,2.271428571,29.22857143,6.642857143,33.3,25.6,3.1
+114,sj,1992,28,1992-07-08,,0.192,0.1468571,0.1530714,1.86,300.2857143,300.5642857,296.1985714,302.2,298.7,5.4,78.49714286,1.86,17.56857143,2.785714286,28.72857143,6.614285714,32.8,24.4,1.8
+115,sj,1992,29,1992-07-15,0.112,0.1255,0.14214,0.1825333,94.14,299.79,299.8285714,296.0528571,301.8,298.0,46.1,80.15,94.14,17.43,2.0,27.62857143,6.042857143,31.7,23.9,45.2
+116,sj,1992,30,1992-07-22,-0.1396,0.05918,0.1371286,0.1288714,33.51,299.2271429,299.3714286,295.8757143,301.1,298.0,69.04,81.98428571,33.51,17.24857143,2.028571429,27.55714286,6.857142857,31.7,23.3,41.0
+117,sj,1992,31,1992-07-29,0.0539,0.1261333,0.1337714,0.1499143,31.12,299.0257143,299.1071429,295.7457143,300.8,297.7,58.8,82.34571429,31.12,17.11428571,1.814285714,27.97142857,6.928571429,32.2,22.8,14.2
+118,sj,1992,32,1992-08-05,0.152675,0.173275,0.1500429,0.1450571,59.22,299.7557143,299.9142857,296.1585714,301.5,297.6,27.1,80.78428571,59.22,17.54714286,2.428571429,28.07142857,6.1,31.7,23.3,16.6
+119,sj,1992,33,1992-08-12,0.16395,0.12665,0.2150571,0.2192714,65.55,299.2157143,299.2214286,296.0071429,301.3,297.8,81.8,82.75,65.55,17.41571429,1.957142857,27.67142857,7.557142857,31.7,22.8,41.9
+120,sj,1992,34,1992-08-19,0.1146,0.1368,0.1855857,0.1925714,68.22,299.4914286,299.7357143,296.2142857,301.9,298.3,61.6,82.31714286,68.22,17.60142857,2.242857143,28.21428571,6.928571429,33.9,24.4,42.7
+121,sj,1992,35,1992-08-26,0.0875,0.0817,0.1799429,0.2217571,27.7,300.0671429,300.1571429,296.0571429,302.2,298.1,28.9,78.86428571,27.7,17.45857143,2.428571429,28.27142857,6.828571429,32.2,23.9,3.1
+122,sj,1992,36,1992-09-02,,0.2175,0.1240143,0.1256571,61.55,300.1085714,300.1571429,296.1757143,302.0,298.4,34.36,79.20428571,61.55,17.56428571,2.2,28.72857143,7.485714286,34.4,24.4,6.5
+123,sj,1992,37,1992-09-09,0.123975,0.1768,0.2357429,0.2148286,21.34,299.7271429,299.7571429,295.9371429,302.2,298.2,87.2,79.93,21.34,17.35285714,2.028571429,28.02857143,6.542857143,32.2,23.9,23.6
+124,sj,1992,38,1992-09-16,0.0519,0.07226667,0.1775714,0.1588143,41.32,299.9785714,300.0714286,296.1114286,302.2,298.4,32.6,79.52571429,41.32,17.54142857,2.342857143,28.14285714,7.085714286,32.8,23.9,28.9
+125,sj,1992,39,1992-09-23,0.1435,0.1435,0.1984,0.2122714,95.55,299.2928571,299.3785714,296.2814286,301.4,297.9,116.79,83.7,95.55,17.75142857,2.042857143,27.55714286,7.242857143,32.8,23.3,60.9
+126,sj,1992,40,1992-09-30,0.1972,0.12715,0.1581333,0.09435,97.7,299.6242857,299.7071429,296.13,302.3,297.6,34.2,81.29714286,97.7,17.60428571,2.3,27.97142857,7.228571429,33.3,23.3,22.6
+127,sj,1992,41,1992-10-07,0.137225,0.10745,0.1771857,0.1911,23.1,300.2671429,300.3285714,296.4242857,302.8,298.3,19.4,79.73714286,23.1,17.89714286,3.257142857,28.88571429,7.8,35.0,23.9,0.0
+128,sj,1992,42,1992-10-14,0.3371,0.1979,0.1945857,0.1832286,18.95,300.1185714,300.2285714,295.8928571,302.6,297.7,11.3,77.83428571,18.95,17.30857143,2.971428571,29.15714286,7.114285714,33.3,25.0,8.0
+129,sj,1992,43,1992-10-21,-0.0156,0.0312,0.1042167,0.1129833,12.18,299.8485714,299.9142857,295.6457143,301.6,298.4,21.5,77.87571429,12.18,17.04428571,2.514285714,28.65714286,7.457142857,32.8,23.9,11.9
+130,sj,1992,44,1992-10-28,0.1242,0.1254,0.1156,0.1124286,80.58,299.8028571,299.8428571,295.8057143,302.3,297.0,25.0,78.91,80.58,17.24714286,3.028571429,28.67142857,7.285714286,33.3,23.9,18.6
+131,sj,1992,45,1992-11-04,0.0866,0.1209667,0.2244429,0.2498571,64.0,299.8071429,299.85,296.27,301.5,298.5,27.7,81.05285714,64.0,17.73,2.071428571,28.38571429,7.7,33.3,22.2,14.2
+132,sj,1992,46,1992-11-11,0.118,0.1422,0.08945,0.0668,40.06,299.0414286,299.2071429,295.0742857,300.9,297.4,31.72,79.01285714,40.06,16.48142857,2.414285714,27.54285714,6.842857143,31.7,22.8,161.0
+133,sj,1992,47,1992-11-18,0.0764,0.05613333,0.1343714,0.06401429,43.44,298.3428571,298.2857143,294.6528571,300.6,296.6,49.97,80.25571429,43.44,16.06714286,1.828571429,26.68571429,7.0,31.1,22.2,26.1
+134,sj,1992,48,1992-11-25,0.0971,0.1026333,0.1617143,0.1198286,47.42,298.6642857,298.7428571,296.0414286,301.1,296.9,128.1,85.58714286,47.42,17.52857143,2.0,27.4,6.771428571,32.8,23.3,46.3
+135,sj,1992,49,1992-12-02,0.1083,0.074125,0.1750667,0.15275,53.73,298.46,298.55,295.2528571,300.6,297.0,54.8,82.64857143,53.73,16.67857143,1.928571429,26.62857143,7.242857143,31.1,22.2,62.6
+136,sj,1992,50,1992-12-09,0.0547,0.1099,0.1981571,0.2159667,86.28,298.7342857,298.9142857,294.65,300.5,297.5,19.23,78.31142857,86.28,16.02428571,2.114285714,26.91428571,7.185714286,31.1,22.2,9.4
+137,sj,1992,51,1992-12-16,,0.066425,0.1923429,0.1941286,0.0,298.2857143,298.5071429,293.8285714,300.7,296.4,24.94,76.66142857,0.0,15.25142857,2.642857143,26.68571429,8.385714286,32.2,21.7,47.5
+138,sj,1992,52,1992-12-23,-0.01008,0.06821667,0.0869,0.0733125,0.0,297.1728571,297.35,292.8,299.1,296.1,23.8,76.75714286,0.0,14.32428571,1.928571429,25.91428571,6.485714286,29.4,21.7,5.5
+139,sj,1993,53,1993-01-01,,,,,,,,,,,,,,,,,,,,
+140,sj,1993,1,1993-01-08,0.02835,0.04366667,0.07865714,0.04645714,46.79,297.4671429,297.55,294.15,299.4,296.1,41.9,81.87857143,46.79,15.52,1.9,25.87142857,6.5,30.6,21.7,28.0
+141,sj,1993,2,1993-01-15,0.03006667,0.03785,0.1318857,0.1092,0.0,297.3314286,297.3428571,293.0685714,299.2,296.2,27.5,77.14428571,0.0,14.46714286,1.714285714,24.5,7.042857143,28.3,20.6,23.5
+142,sj,1993,3,1993-01-22,,0.11345,0.2260571,0.2200286,0.0,297.4014286,297.6285714,293.0757143,299.5,296.2,11.2,76.98428571,0.0,14.49,2.2,24.85714286,7.128571429,30.0,20.0,6.6
+143,sj,1993,4,1993-01-29,0.06613333,0.05705,0.1303667,0.1473833,0.0,296.9671429,297.1285714,292.8414286,299.2,295.5,21.8,77.86285714,0.0,14.30714286,2.085714286,24.4,6.1,28.9,20.0,15.2
+144,sj,1993,5,1993-02-05,0.047425,0.02253333,0.09238571,0.09468571,75.97,297.6242857,297.6857143,294.0328571,300.4,295.6,26.3,80.61,75.97,15.45285714,2.085714286,26.67142857,7.642857143,31.7,19.4,9.4
+145,sj,1993,6,1993-02-12,0.2738,0.0558,0.2020857,0.2047857,0.0,296.5942857,296.8,292.8714286,299.7,294.7,14.3,79.82571429,0.0,14.38571429,2.342857143,25.42857143,6.742857143,30.0,20.6,2.1
+146,sj,1993,7,1993-02-19,0.1108667,0.173375,0.2375143,0.2274143,14.71,297.76,297.9714286,293.3428571,299.6,296.4,7.2,76.53285714,14.71,14.75285714,2.485714286,26.27142857,8.1,31.7,20.6,2.8
+147,sj,1993,8,1993-02-26,,0.1339,0.2699286,0.2615857,0.0,296.7685714,296.8714286,292.3014286,300.1,294.6,21.5,76.21714286,0.0,13.82714286,2.771428571,25.7,7.3,32.2,20.6,5.5
+148,sj,1993,9,1993-03-05,0.1744667,0.1338,0.1584833,0.1399167,0.0,297.0142857,297.2428571,291.9114286,299.7,295.2,1.8,73.22571429,0.0,13.49428571,2.8,25.57142857,8.157142857,30.0,21.1,2.3
+149,sj,1993,10,1993-03-12,0.09403333,0.214,0.2035714,0.2538286,0.0,296.4257143,296.6428571,290.7757143,298.9,294.1,2.7,70.64571429,0.0,12.58285714,2.485714286,24.9,7.614285714,29.4,19.4,2.5
+150,sj,1993,11,1993-03-19,-0.0411,-0.0436,0.1725333,0.1717714,9.68,297.8557143,298.0142857,293.6928571,300.4,295.5,10.5,77.78428571,9.68,15.06428571,2.685714286,26.92857143,8.471428571,33.3,21.1,0.5
+151,sj,1993,12,1993-03-26,0.03225,0.10315,0.1850143,0.2041857,27.0,297.5857143,297.6714286,293.2228571,299.8,296.3,13.0,76.84857143,27.0,14.64857143,2.257142857,26.14285714,7.528571429,31.1,20.6,12.8
+152,sj,1993,13,1993-04-02,0.1194,0.08853333,0.1404714,0.1174286,0.0,297.34,297.4428571,293.8128571,299.4,295.7,20.27,80.79571429,0.0,15.2,2.142857143,26.88571429,7.628571429,32.8,22.2,4.1
+153,sj,1993,14,1993-04-09,,0.0423,0.1903667,0.2082143,7.49,297.7457143,297.8928571,293.7528571,300.1,296.2,14.2,78.56428571,7.49,15.16285714,2.357142857,27.2,7.714285714,32.8,21.1,4.6
+154,sj,1993,15,1993-04-16,-0.0158,0.01885,0.068,0.0834,19.74,298.0128571,298.0,294.0657143,300.1,295.9,23.2,78.96142857,19.74,15.5,3.057142857,27.07142857,7.785714286,33.3,22.2,11.7
+155,sj,1993,16,1993-04-23,0.0828,0.0788,0.1334571,0.1317,114.85,297.5285714,297.7428571,294.0728571,300.1,294.5,63.49,81.27142857,114.85,15.48857143,2.771428571,25.87142857,7.442857143,31.1,21.7,8.4
+156,sj,1993,17,1993-04-30,,0.09256667,0.1315167,0.1252286,33.35,298.5914286,298.6928571,295.1942857,300.4,297.0,34.3,81.65571429,33.35,16.59714286,2.471428571,27.48571429,8.385714286,32.8,22.2,28.3
+157,sj,1993,18,1993-05-07,0.07965,0.06415,0.1547429,0.1291571,37.35,298.1528571,298.1857143,295.26,300.1,296.9,40.7,84.08142857,37.35,16.65857143,1.857142857,26.94285714,6.271428571,32.2,22.2,114.3
+158,sj,1993,19,1993-05-14,0.07305,0.052,0.1074857,0.1070286,34.9,297.6714286,297.6928571,294.8471429,300.4,296.1,142.4,84.52142857,34.9,16.26714286,2.5,26.47142857,6.0,31.1,22.8,18.3
+159,sj,1993,20,1993-05-21,0.1769,0.0901,0.1792,0.1866833,14.84,298.6042857,298.7214286,295.3242857,301.2,296.4,55.67,82.43571429,14.84,16.85714286,2.214285714,28.22857143,7.228571429,33.9,23.3,4.6
+160,sj,1993,21,1993-05-28,0.01645,0.10485,0.05147143,0.0644,78.17,299.3642857,299.3785714,296.6757143,301.8,297.6,100.2,85.39857143,78.17,18.18571429,2.271428571,28.94285714,7.228571429,33.9,23.3,32.1
+161,sj,1993,22,1993-06-04,0.00305,0.0506,0.1981857,0.1761,62.2,298.8442857,298.9142857,296.4514286,301.4,297.3,93.2,86.9,62.2,17.95142857,1.914285714,27.64285714,5.885714286,31.1,22.8,58.3
+162,sj,1993,23,1993-06-11,0.1206,,0.1537714,0.1484857,8.48,300.6585714,300.7357143,296.9785714,302.8,298.5,20.2,80.61571429,8.48,18.49142857,2.642857143,29.9,7.385714286,34.4,25.0,1.3
+163,sj,1993,24,1993-06-18,,0.0785,0.2209429,0.2193714,30.65,299.1842857,299.2642857,295.7428571,301.0,297.7,55.5,81.49285714,30.65,17.13,2.1,27.72857143,6.785714286,32.2,23.3,57.9
+164,sj,1993,25,1993-06-25,0.0374,0.1399667,0.1681714,0.1343571,93.75,299.5214286,299.4928571,296.2942857,301.8,297.5,74.0,82.60857143,93.75,17.71285714,1.957142857,27.34285714,6.971428571,33.3,22.2,60.4
+165,sj,1993,26,1993-07-02,0.1237667,0.1522,0.2154143,0.2187714,8.49,299.7042857,299.8428571,296.51,301.6,298.2,27.5,82.83285714,8.49,17.92285714,2.0,28.84285714,5.871428571,32.8,25.0,7.2
+166,sj,1993,27,1993-07-09,0.0689,0.09593333,0.1463429,0.1590429,37.28,299.5671429,299.6285714,296.03,301.6,297.5,72.8,81.14857143,37.28,17.40714286,1.885714286,28.24285714,6.842857143,32.8,24.4,21.0
+167,sj,1993,28,1993-07-16,0.0375,0.09203333,0.1833571,0.2203714,73.94,299.5842857,299.7071429,296.0557143,301.9,297.7,67.7,81.21571429,73.94,17.46,2.5,27.88571429,6.528571429,32.2,22.2,92.2
+168,sj,1993,29,1993-07-23,0.1204,0.1826,0.1665857,0.1923714,4.81,299.8914286,299.9642857,295.94,302.0,298.3,29.4,79.15,4.81,17.31714286,2.471428571,28.5,7.257142857,33.3,24.4,13.0
+169,sj,1993,30,1993-07-30,0.08285,0.10608,0.12255,0.1236,78.03,299.2371429,299.2642857,296.5928571,301.3,298.0,109.0,85.55142857,78.03,18.03428571,1.757142857,27.94285714,6.0,32.2,22.2,71.4
+170,sj,1993,31,1993-08-06,,0.1488,0.2467667,0.2581143,12.38,300.0628571,300.2642857,296.8571429,302.0,298.3,12.6,82.88285714,12.38,18.32714286,2.357142857,29.02857143,6.585714286,32.8,24.4,0.8
+171,sj,1993,32,1993-08-13,0.1016,0.1401,0.2187,0.1692571,7.25,300.1214286,300.35,296.5614286,302.0,298.7,21.8,81.01285714,7.25,17.98857143,2.328571429,29.02857143,6.257142857,32.8,25.0,18.1
+172,sj,1993,33,1993-08-20,0.0969,0.04966667,0.1970714,0.1632857,106.83,299.67,299.7714286,296.5128571,302.3,297.8,62.7,83.07571429,106.83,17.95285714,2.228571429,29.41428571,6.428571429,33.9,24.4,12.7
+173,sj,1993,34,1993-08-27,0.10885,0.24925,0.2105714,0.2159143,1.36,299.9185714,299.9857143,296.49,302.1,297.9,26.9,81.72714286,1.36,17.91714286,2.314285714,28.97142857,7.614285714,33.3,24.4,17.1
+174,sj,1993,35,1993-09-03,0.0979,0.1581,0.1638571,0.1509143,30.85,299.9757143,300.0357143,296.1071429,302.0,298.5,34.4,79.62857143,30.85,17.52714286,2.185714286,28.65714286,7.328571429,32.8,24.4,28.8
+175,sj,1993,36,1993-09-10,0.1121,0.0688,0.0596,0.05133333,43.26,299.7614286,299.8571429,296.1285714,302.6,298.2,42.1,80.68428571,43.26,17.56142857,2.171428571,28.42857143,7.885714286,32.8,23.3,43.4
+176,sj,1993,37,1993-09-17,0.1199,0.0971,0.2044429,0.1865857,14.42,299.6728571,299.7857143,296.2914286,301.9,298.3,50.0,81.79428571,14.42,17.70428571,1.942857143,28.6,7.371428571,32.8,23.9,23.1
+177,sj,1993,38,1993-09-24,0.0054,0.063525,0.1392833,0.1168857,71.36,300.0671429,300.1428571,296.4614286,302.4,298.2,57.9,80.90142857,71.36,17.95285714,2.685714286,28.15714286,6.928571429,32.8,23.3,8.7
+178,sj,1993,39,1993-10-01,0.034,0.0517,0.0726,0.09423333,72.86,299.8857143,299.9428571,296.6514286,302.1,298.4,76.0,82.61,72.86,18.12,2.171428571,28.28571429,6.985714286,32.8,23.9,26.7
+179,sj,1993,40,1993-10-08,0.1213,0.0705,0.1886286,0.1652714,27.62,299.5914286,299.6071429,296.6328571,301.1,298.2,55.36,83.84142857,27.62,18.10428571,1.671428571,28.01428571,7.5,33.3,23.3,16.8
+180,sj,1993,41,1993-10-15,0.1317,0.0645,0.20515,0.1731857,8.01,299.9571429,300.0428571,296.4257143,301.8,298.7,35.8,81.10285714,8.01,17.86,1.942857143,28.4,6.985714286,32.2,24.4,27.0
+181,sj,1993,42,1993-10-22,0.0129,,0.1347,0.1496857,0.0,300.1814286,300.2428571,296.1685714,302.4,298.0,17.0,78.80714286,0.0,17.59285714,2.257142857,28.2,7.7,33.3,23.9,6.4
+182,sj,1993,43,1993-10-29,0.117,0.1143,0.2702,0.1092667,70.07,299.7885714,299.7214286,296.1142857,301.5,298.1,57.6,80.39857143,70.07,17.55571429,1.957142857,28.07142857,7.142857143,32.8,23.9,25.4
+183,sj,1993,44,1993-11-05,,0.1406667,0.1776167,0.1569,0.0,299.8857143,299.9214286,296.0071429,301.9,298.5,16.1,79.50428571,0.0,17.44142857,2.3,27.9,7.242857143,32.8,23.3,4.1
+184,sj,1993,45,1993-11-12,-0.1589,0.0493,0.08248333,0.1696,0.0,299.2285714,299.35,295.2985714,300.9,297.8,25.6,79.03714286,0.0,16.66285714,2.271428571,27.64285714,7.728571429,32.8,23.3,6.7
+185,sj,1993,46,1993-11-19,0.17315,0.013825,0.17535,0.1117429,12.5,298.8457143,299.05,295.1885714,301.0,297.5,70.71,80.37714286,12.5,16.58,1.842857143,27.17142857,6.771428571,31.7,22.8,48.8
+186,sj,1993,47,1993-11-26,0.1071,0.1818,0.2600571,0.2705857,91.81,298.5714286,298.6785714,295.2557143,301.1,296.8,118.1,82.15428571,91.81,16.66142857,1.871428571,26.88571429,6.6,31.7,22.2,46.4
+187,sj,1993,48,1993-12-03,0.3572667,-0.0095,0.12734,0.08941429,6.09,298.6271429,298.7214286,294.9657143,300.5,297.2,25.7,80.46571429,6.09,16.40142857,2.014285714,26.78571429,8.342857143,33.3,21.1,5.5
+188,sj,1993,49,1993-12-10,,,0.1632333,0.08283333,5.29,298.2185714,298.1928571,294.52,300.5,296.6,43.4,80.30285714,5.29,15.93285714,2.357142857,26.52857143,7.085714286,30.6,21.1,20.8
+189,sj,1993,50,1993-12-17,-0.2902,-0.06766667,0.1682857,0.08,14.82,298.5657143,298.5857143,294.16,300.8,296.2,28.6,76.85428571,14.82,15.57142857,2.457142857,26.22857143,7.857142857,31.1,21.1,7.7
+190,sj,1993,51,1993-12-24,-0.0237,-0.02115,0.1181143,0.07024286,42.62,298.2185714,298.3357143,294.2342857,301.2,296.1,33.6,78.82857143,42.62,15.65,2.557142857,26.04285714,6.828571429,31.7,21.7,37.6
+191,sj,1994,52,1994-01-01,,,,,5.25,298.5271429,298.7785714,294.4014286,301.0,296.0,3.4,78.01857143,5.25,15.78,2.442857143,26.97142857,8.2,32.8,21.7,0.3
+192,sj,1994,1,1994-01-08,-0.1209,0.0193,0.09498571,0.1785143,12.6,298.1914286,298.2857143,293.5857143,300.1,296.3,19.5,75.74285714,12.6,14.95142857,2.057142857,25.5,6.742857143,29.4,21.1,41.0
+193,sj,1994,2,1994-01-15,0.1435,0.0974,0.25425,0.21445,0.0,297.59,297.6928571,293.7214286,299.6,296.0,19.4,79.15,0.0,15.09714286,2.214285714,25.45714286,7.271428571,29.4,21.1,13.4
+194,sj,1994,3,1994-01-22,0.0741,0.1664333,0.151,0.1407143,0.0,297.9128571,297.9428571,293.37,299.7,296.2,16.4,75.98428571,0.0,14.77571429,2.114285714,25.08571429,7.428571429,30.0,20.0,26.6
+195,sj,1994,4,1994-01-29,0.0912,-0.1162667,0.1635571,0.1985143,0.0,297.5714286,297.7071429,293.5314286,299.2,296.3,19.04,78.38142857,0.0,14.93857143,2.328571429,25.32857143,7.042857143,29.4,20.6,9.7
+196,sj,1994,5,1994-02-05,0.2588,0.2112,0.2200571,0.2156,0.0,297.5885714,297.7142857,293.23,299.8,295.8,21.8,76.82571429,0.0,14.63428571,2.2,25.78571429,7.1,30.0,20.6,3.6
+197,sj,1994,6,1994-02-12,0.0882,0.117,0.0768,0.069175,0.0,297.5157143,297.5714286,292.8528571,299.2,295.9,11.5,75.31,0.0,14.28857143,1.742857143,25.25714286,7.528571429,29.4,21.1,9.1
+198,sj,1994,7,1994-02-19,0.3633,0.24185,0.2473857,0.2834143,0.0,297.7742857,297.9428571,292.5771429,299.4,295.5,7.2,72.88571429,0.0,14.02,2.285714286,25.7,7.157142857,30.6,21.1,9.7
+199,sj,1994,8,1994-02-26,,0.09243333,0.1377571,0.07407143,0.0,297.4557143,297.5642857,292.6728571,299.3,296.1,11.5,74.78857143,0.0,14.15714286,2.357142857,25.74285714,8.571428571,30.6,20.6,7.9
+200,sj,1994,9,1994-03-05,,0.1446,0.17415,0.1530833,0.0,297.2357143,297.3357143,293.1285714,300.1,295.4,16.7,77.91571429,0.0,14.55857143,2.5,25.31428571,8.542857143,30.6,20.6,16.2
+201,sj,1994,10,1994-03-12,0.1125,0.1038,0.08821429,0.1224143,7.15,297.2685714,297.4071429,293.8871429,299.5,295.5,18.7,81.51857143,7.15,15.25857143,2.442857143,25.88571429,7.057142857,31.1,21.7,15.8
+202,sj,1994,11,1994-03-19,0.1468,-0.04815,0.1946833,0.14055,0.0,297.5014286,297.6714286,292.8642857,299.8,295.6,6.69,75.43571429,0.0,14.33428571,2.571428571,25.84285714,7.957142857,31.1,21.1,16.8
+203,sj,1994,12,1994-03-26,0.0412,0.1005833,0.1528167,0.1368429,0.0,298.0142857,298.2142857,293.1757143,300.5,295.5,2.9,74.64714286,0.0,14.61714286,3.657142857,26.72857143,9.914285714,32.8,20.6,0.0
+204,sj,1994,13,1994-04-02,0.0978,0.15975,0.1270429,0.1195286,46.62,298.2814286,298.4642857,293.5328571,300.1,296.8,6.66,75.08285714,46.62,14.94571429,2.471428571,26.7,8.342857143,33.3,21.1,1.0
+205,sj,1994,14,1994-04-09,0.108,0.05093333,0.1369286,0.1190286,0.0,298.12,298.3142857,293.1514286,300.0,296.8,4.4,73.95142857,0.0,14.54714286,2.4,26.42857143,7.771428571,31.1,21.7,2.3
+206,sj,1994,15,1994-04-16,0.16435,0.13325,0.1874286,0.1552429,0.0,297.5371429,297.6214286,293.7342857,299.6,296.0,37.0,79.51714286,0.0,15.14714286,2.1,25.97142857,6.714285714,30.0,21.1,16.7
+207,sj,1994,16,1994-04-23,,,0.1528286,0.1754571,0.0,297.5414286,297.7357143,292.8528571,299.6,296.3,16.6,75.24714286,0.0,14.29428571,2.128571429,25.97142857,6.4,30.0,22.2,28.7
+208,sj,1994,17,1994-04-30,0.0805,0.0251,0.09804286,0.09371667,0.0,298.3242857,298.4928571,293.4557143,300.9,296.8,4.9,74.51571429,0.0,14.88142857,2.614285714,26.67142857,7.785714286,31.7,22.2,13.2
+209,sj,1994,18,1994-05-07,0.0652,0.08175,0.1644143,0.1321429,68.0,298.9271429,299.0928571,295.2357143,301.1,297.0,14.1,80.35285714,68.0,16.62142857,2.671428571,27.75714286,7.7,33.3,22.8,10.5
+210,sj,1994,19,1994-05-14,0.1111,0.0974,0.1165143,0.1063143,10.46,298.5571429,298.7,294.9242857,300.5,297.2,21.1,80.46285714,10.46,16.28,1.942857143,27.41428571,6.457142857,31.7,23.9,3.3
+211,sj,1994,20,1994-05-21,0.0742,0.0177,0.1722429,0.1608286,16.5,298.4742857,298.55,295.3842857,300.6,297.3,28.9,83.13571429,16.5,16.76714286,1.814285714,27.71428571,8.1,33.3,22.8,29.3
+212,sj,1994,21,1994-05-28,0.1178,0.10975,0.2084714,0.2084857,17.52,299.9414286,300.2285714,296.0642857,302.3,297.7,7.9,79.50285714,17.52,17.48714286,2.885714286,29.1,7.071428571,33.9,24.4,6.9
+213,sj,1994,22,1994-06-04,0.1097,0.1407,0.2008429,0.1616143,6.59,299.5971429,299.7785714,295.3428571,301.7,297.8,16.7,77.66428571,6.59,16.71285714,2.357142857,28.57142857,7.314285714,33.3,23.3,1.6
+214,sj,1994,23,1994-06-11,0.08005,0.06905,0.06161429,0.05854286,42.53,299.3271429,299.5357143,295.6428571,301.3,298.0,21.5,80.38285714,42.53,17.01571429,2.471428571,28.22857143,7.628571429,32.8,23.3,67.3
+215,sj,1994,24,1994-06-18,-0.0286,,0.1592833,0.2158429,13.82,299.6057143,299.8,295.4914286,301.6,298.3,3.7,78.29285714,13.82,16.83142857,2.4,28.32857143,6.771428571,32.8,24.4,5.4
+216,sj,1994,25,1994-06-25,-0.0323,0.04215,0.1387429,0.1391143,38.34,299.5,299.6357143,295.4628571,302.2,298.0,26.51,78.70428571,38.34,16.83714286,2.042857143,28.07142857,6.6,32.8,23.9,23.4
+217,sj,1994,26,1994-07-02,0.1252667,0.11765,0.1234167,0.1551857,12.67,299.8614286,300.0071429,295.8528571,302.3,298.0,22.9,79.02714286,12.67,17.22857143,2.642857143,28.4,6.757142857,32.8,23.9,10.2
+218,sj,1994,27,1994-07-09,0.12325,0.2155667,0.217,0.1133429,15.39,299.1257143,299.1785714,295.1542857,301.5,297.9,54.83,78.80571429,15.39,16.47857143,1.642857143,27.92857143,6.828571429,32.2,23.9,19.5
+219,sj,1994,28,1994-07-16,0.1396,0.22405,0.1846714,0.1805857,9.77,299.4814286,299.65,295.1685714,301.5,297.9,18.52,77.30285714,9.77,16.50285714,2.128571429,28.17142857,6.014285714,32.2,23.9,28.7
+220,sj,1994,29,1994-07-23,0.0424,0.1201667,0.1943429,0.1907429,43.28,299.9328571,300.1,295.5628571,301.7,297.8,9.9,77.10285714,43.28,16.88285714,2.342857143,28.25714286,6.528571429,32.8,23.9,9.8
+221,sj,1994,30,1994-07-30,0.183,0.2658,0.1967286,0.1939,2.79,299.9771429,300.1285714,295.2371429,301.5,298.5,3.3,75.43571429,2.79,16.58,2.457142857,28.51428571,7.228571429,33.3,24.4,1.0
+222,sj,1994,31,1994-08-06,,0.1311,0.1752143,0.1122143,26.96,299.5757143,299.6357143,295.3628571,301.7,297.4,22.9,77.79571429,26.96,16.70857143,2.214285714,28.25714286,6.985714286,33.3,23.9,48.5
+223,sj,1994,32,1994-08-13,0.04465,-0.0402,0.05686667,0.02865,30.03,299.5185714,299.6785714,295.4657143,301.5,297.9,12.5,78.58428571,30.03,16.83142857,2.357142857,28.38571429,7.785714286,33.3,23.9,3.6
+224,sj,1994,33,1994-08-20,0.06666667,-0.0157,0.1766167,0.22135,17.77,300.01,300.1285714,295.4871429,302.2,298.3,16.6,76.43714286,17.77,16.86428571,2.514285714,28.51428571,6.771428571,33.3,24.4,20.4
+225,sj,1994,34,1994-08-27,0.1564,0.130825,0.1920571,0.1767286,3.24,300.3642857,300.5357143,295.9314286,302.7,298.5,11.56,76.92,3.24,17.33857143,2.642857143,28.57142857,6.7,32.8,24.4,4.3
+226,sj,1994,35,1994-09-03,0.02185,0.14525,0.2137857,0.2040857,59.91,300.3928571,300.5357143,296.2957143,302.7,298.7,20.24,78.48285714,59.91,17.70571429,2.528571429,29.42857143,6.885714286,33.9,25.6,11.0
+227,sj,1994,36,1994-09-10,0.04585,0.076225,0.2916857,0.2479714,19.45,300.0742857,300.1785714,296.1314286,302.4,297.6,28.3,79.13857143,19.45,17.52142857,2.642857143,29.28571429,6.357142857,33.3,24.4,14.4
+228,sj,1994,37,1994-09-17,,,0.0955,0.192925,61.11,299.9514286,300.0571429,295.9071429,302.2,298.2,70.4,78.75,61.11,17.30571429,2.457142857,28.55714286,6.9,34.4,23.9,50.8
+229,sj,1994,38,1994-09-24,,,,,39.22,299.8857143,300.0357143,295.9614286,302.3,298.1,50.7,79.31428571,39.22,17.35428571,1.985714286,28.37142857,6.185714286,32.2,24.4,34.3
+230,sj,1994,39,1994-10-01,,,,,55.88,299.5085714,299.6428571,295.8214286,301.8,297.7,45.2,80.37285714,55.88,17.24857143,2.6,28.01428571,6.7,33.9,23.3,31.5
+231,sj,1994,40,1994-10-08,,,,,0.63,300.3771429,300.5,295.3628571,302.5,298.7,2.8,74.11714286,0.63,16.74428571,2.628571429,28.71428571,6.9,34.4,24.4,8.2
+232,sj,1994,41,1994-10-15,,,,,16.7,299.6385714,299.6214286,295.4814286,302.9,297.8,40.8,78.22571429,16.7,16.9,2.728571429,28.32857143,7.657142857,35.0,23.9,39.2
+233,sj,1994,42,1994-10-22,,,,,75.57,300.2385714,300.4,295.6857143,303.0,298.3,15.81,76.34857143,75.57,17.12428571,3.028571429,28.57142857,7.442857143,35.0,23.9,5.4
+234,sj,1994,43,1994-10-29,,,,,111.52,298.8114286,298.8571429,296.1714286,300.5,297.5,64.85,85.41714286,111.52,17.64142857,1.657142857,27.67142857,7.271428571,32.8,23.3,39.2
+235,sj,1994,44,1994-11-05,,,,,5.41,299.8671429,300.05,295.8457143,301.9,298.3,15.6,78.68571429,5.41,17.26428571,2.328571429,28.15714286,6.842857143,32.2,24.4,1.9
+236,sj,1994,45,1994-11-12,,,,,32.26,299.2971429,299.1285714,295.58,301.5,297.2,36.6,80.09571429,32.26,16.98428571,2.228571429,27.31428571,6.928571429,31.7,22.2,54.5
+237,sj,1994,46,1994-11-19,,,,,32.17,299.1985714,299.3,296.1742857,302.2,297.5,47.5,83.58428571,32.17,17.64428571,1.771428571,27.28571429,7.314285714,32.8,22.2,47.5
+238,sj,1994,47,1994-11-26,,,,,11.16,299.4228571,299.4571429,296.3771429,301.9,297.6,23.7,83.50285714,11.16,17.84857143,2.4,27.85714286,7.6,33.9,23.3,49.3
+239,sj,1994,48,1994-12-03,,,,,17.52,298.8514286,298.85,294.8128571,300.7,296.3,27.4,78.56,17.52,16.17857143,2.1,26.88571429,7.571428571,31.7,21.1,35.9
+240,sj,1994,49,1994-12-10,,,,,45.95,297.8085714,297.95,295.2042857,299.4,296.6,106.09,85.57,45.95,16.58,1.5,26.37142857,6.185714286,30.0,22.2,58.2
+241,sj,1994,50,1994-12-17,,,,,0.0,298.6242857,298.7428571,293.9385714,300.5,297.2,16.5,75.45571429,0.0,15.32714286,2.285714286,26.58571429,7.471428571,31.7,21.7,7.4
+242,sj,1994,51,1994-12-24,,,,,0.0,298.5814286,298.6928571,294.2114286,300.6,296.9,12.2,76.91428571,0.0,15.59571429,2.728571429,26.64285714,8.185714286,31.7,22.2,12.9
+243,sj,1995,52,1995-01-01,0.2438,0.045,0.2152556,0.1947778,71.43,298.8385714,299.1071429,295.6742857,301.5,296.7,30.4,82.86714286,71.43,17.06714286,3.271428571,27.31428571,8.742857143,32.8,22.2,9.2
+244,sj,1995,1,1995-01-08,0.223075,0.2193333,0.2886167,0.2587429,0.0,297.33,297.4,292.7342857,300.1,294.7,12.5,75.83857143,0.0,14.25,2.371428571,25.7,7.685714286,31.7,20.0,40.4
+245,sj,1995,2,1995-01-15,,0.1416333,0.1755714,0.1716143,0.0,298.2842857,298.45,293.3085714,299.9,296.8,3.59,74.04714286,0.0,14.69857143,2.357142857,25.77142857,7.685714286,30.0,21.7,10.5
+246,sj,1995,3,1995-01-22,-0.1193,-0.0359,0.2122571,0.2293714,37.99,296.5842857,296.7071429,292.83,299.1,295.0,32.88,79.55285714,37.99,14.28142857,1.785714286,24.75714286,7.114285714,28.9,20.0,29.0
+247,sj,1995,4,1995-01-29,0.05175,0.1268,0.1772286,0.1340714,0.0,297.5928571,298.0142857,293.5328571,300.5,295.0,6.2,78.33,0.0,14.94714286,3.628571429,26.12857143,9.042857143,32.8,20.6,9.9
+248,sj,1995,5,1995-02-05,,0.1449,0.21726,0.2099429,0.0,297.35,297.65,293.91,300.2,295.6,43.3,81.40428571,0.0,15.27428571,2.157142857,25.5,7.285714286,31.7,21.1,26.9
+249,sj,1995,6,1995-02-12,0.03233333,0.059325,0.1748857,0.1713857,0.0,297.8557143,298.0142857,293.0257143,300.5,295.2,3.6,74.65571429,0.0,14.46,3.8,26.08571429,9.614285714,32.8,20.0,0.0
+250,sj,1995,7,1995-02-19,0.0614,,0.1753143,0.2123286,0.0,298.2214286,298.4642857,293.8828571,300.5,295.8,10.07,77.02142857,0.0,15.22714286,2.814285714,26.62857143,8.657142857,32.2,20.6,2.8
+251,sj,1995,8,1995-02-26,0.0935,0.06486667,0.1020143,0.1254143,0.0,297.5085714,297.5142857,293.1328571,299.4,295.9,29.08,76.63428571,0.0,14.53,1.971428571,25.92857143,7.285714286,31.7,21.7,29.5
+252,sj,1995,9,1995-03-05,0.07355,0.06865,0.12292,0.10996,0.0,297.1757143,297.2571429,293.4442857,299.5,295.4,50.73,79.81714286,0.0,14.85285714,2.428571429,25.24285714,8.4,30.6,20.0,51.7
+253,sj,1995,10,1995-03-12,0.14535,0.079575,0.1823429,0.1864857,0.0,297.0814286,297.2785714,293.8114286,299.4,295.2,36.42,82.05285714,0.0,15.19142857,2.071428571,25.5,7.057142857,30.0,21.1,16.9
+254,sj,1995,11,1995-03-19,0.0739,0.1150667,0.1452,0.1547429,19.43,297.11,297.0857143,292.8214286,299.6,294.6,18.6,77.02,19.43,14.30428571,2.057142857,25.25714286,6.757142857,31.7,21.1,16.5
+255,sj,1995,12,1995-03-26,0.031,0.23165,0.2074333,0.2497143,0.0,296.48,296.7071429,290.6314286,300.4,294.0,6.7,69.86142857,0.0,12.48142857,3.3,24.62857143,8.414285714,31.7,18.9,2.3
+256,sj,1995,13,1995-04-02,0.19862,0.259575,0.24515,0.3054571,0.0,296.8871429,297.0428571,290.3785714,300.0,293.5,4.6,67.36428571,0.0,12.33142857,4.0,25.24285714,7.757142857,30.0,20.0,4.1
+257,sj,1995,14,1995-04-09,,0.2494,0.2327857,0.2684143,0.0,297.6657143,297.9214286,292.5557143,300.9,294.6,0.0,73.4,0.0,14.12285714,3.614285714,25.97142857,8.957142857,32.8,19.4,0.0
+258,sj,1995,15,1995-04-16,,0.03495,0.1719143,0.1489429,5.43,298.56,298.7428571,294.3385714,300.6,296.9,2.1,77.60571429,5.43,15.73571429,2.828571429,27.28571429,7.785714286,32.8,22.8,0.0
+259,sj,1995,16,1995-04-23,0.1017,0.1127,0.2601571,0.2366143,6.44,297.83,298.0071429,293.5542857,300.2,296.0,19.6,77.32142857,6.44,15.01,2.614285714,26.65714286,7.3,32.8,21.1,72.0
+260,sj,1995,17,1995-04-30,0.1281,0.150025,0.2205429,0.1873,0.0,297.5114286,297.6857143,292.1,300.2,295.8,2.7,71.93714286,0.0,13.69,2.657142857,26.32857143,6.657142857,31.1,21.7,1.0
+261,sj,1995,18,1995-05-07,,0.1521,0.2145429,0.1579714,20.96,298.7885714,299.0714286,294.2028571,301.6,297.3,4.1,76.07285714,20.96,15.61714286,2.942857143,27.84285714,9.142857143,34.4,22.2,2.8
+262,sj,1995,19,1995-05-14,0.14345,0.1115,0.1990714,0.1708857,9.01,299.1314286,299.3571429,295.4285714,301.8,297.0,9.0,80.26142857,9.01,16.82285714,3.0,27.77142857,7.3,34.4,22.8,29.7
+263,sj,1995,20,1995-05-21,0.0363,0.096525,0.1664333,0.1605714,119.62,298.9957143,299.0857143,295.3985714,301.7,297.1,17.4,80.86571429,119.62,16.78857143,2.857142857,26.91428571,6.271428571,31.1,21.7,101.6
+264,sj,1995,21,1995-05-28,0.0322,0.1621333,0.2318286,0.2402714,204.62,299.4542857,299.5785714,295.9942857,301.7,297.3,17.3,81.44714286,204.62,17.41285714,2.328571429,27.22857143,7.342857143,31.7,22.2,97.5
+265,sj,1995,22,1995-06-04,,0.2412,0.1024714,0.1095714,178.89,299.6028571,299.6071429,295.9928571,302.0,298.1,20.33,80.72714286,178.89,17.41142857,1.957142857,27.7,7.328571429,33.3,23.3,9.1
+266,sj,1995,23,1995-06-11,0.15495,0.0278,0.2666143,0.2119,106.04,298.6885714,298.65,295.8271429,300.2,297.5,86.8,84.34571429,106.04,17.21714286,1.642857143,27.3,7.142857143,31.1,22.8,35.5
+267,sj,1995,24,1995-06-18,0.08955,0.0797,0.1817143,0.1559857,20.16,299.8285714,299.9,295.8928571,301.4,298.4,16.57,79.13714286,20.16,17.29571429,2.314285714,27.77142857,7.471428571,32.8,22.8,43.5
+268,sj,1995,25,1995-06-25,0.22135,0.2174,0.2199714,0.1920429,26.56,300.1157143,300.1428571,296.6257143,302.3,298.2,35.24,81.34,26.56,18.05285714,2.0,28.84285714,7.371428571,33.3,24.4,10.5
+269,sj,1995,26,1995-07-02,0.2319333,0.2115,0.2412286,0.2656857,2.04,300.68,300.8071429,296.7414286,302.7,298.7,13.7,79.38,2.04,18.20714286,2.757142857,29.21428571,6.342857143,33.9,24.4,15.8
+270,sj,1995,27,1995-07-09,0.3093,0.2909,0.2370571,0.2420429,41.18,301.0071429,301.0928571,296.1457143,303.2,298.6,9.22,75.06571429,41.18,17.56571429,3.042857143,29.65714286,7.828571429,34.4,25.0,16.0
+271,sj,1995,28,1995-07-16,,0.17265,0.24245,0.2196714,25.89,299.9442857,299.9785714,296.5828571,302.0,298.5,60.59,81.96,25.89,18.01285714,1.957142857,29.28571429,7.6,34.4,24.4,21.4
+272,sj,1995,29,1995-07-23,0.1175,0.10775,0.1555714,0.1664857,36.58,300.4014286,300.6642857,296.8485714,302.8,299.0,38.3,81.09,36.58,18.35428571,2.728571429,29.22857143,7.3,33.9,25.0,30.6
+273,sj,1995,30,1995-07-30,,0.1898,0.0942,0.1322286,101.64,299.9885714,299.9571429,297.2442857,302.3,298.6,62.31,85.08857143,101.64,18.77714286,1.6,28.55714286,6.571428571,33.3,23.9,43.3
+274,sj,1995,31,1995-08-06,0.0632,0.09466667,0.1584857,0.2030286,60.71,300.0,300.0,297.11,302.5,298.4,102.4,84.37571429,60.71,18.67285714,2.085714286,28.7,6.757142857,33.9,23.9,30.1
+275,sj,1995,32,1995-08-13,0.047,0.047,0.1991833,0.1653571,19.79,300.2628571,300.2857143,296.5585714,302.4,298.6,40.3,80.39714286,19.79,18.04285714,2.142857143,29.0,6.814285714,33.9,23.3,27.3
+276,sj,1995,33,1995-08-20,0.08396667,0.0917,0.1771571,0.1886714,4.05,300.5542857,300.6857143,297.27,303.8,298.2,17.7,82.62571429,4.05,18.85714286,3.342857143,30.07142857,6.942857143,34.4,25.6,8.7
+277,sj,1995,34,1995-08-27,0.1131,0.0862,0.1374,0.1324714,75.11,299.9528571,299.9857143,296.8871429,301.9,298.1,96.1,83.49142857,75.11,18.40428571,2.114285714,28.42857143,7.657142857,33.3,23.3,66.0
+278,sj,1995,35,1995-09-03,0.0326,0.07256667,0.17236,0.1968143,35.83,300.1742857,300.2428571,296.85,302.4,298.5,55.21,82.22571429,35.83,18.39714286,2.228571429,29.11428571,5.928571429,32.2,24.4,12.8
+279,sj,1995,36,1995-09-10,0.1071,0.1836,0.18515,0.1699571,20.23,301.2185714,301.35,296.9942857,303.9,298.2,8.6,78.14571429,20.23,18.54571429,3.7,29.57142857,7.914285714,34.4,23.9,20.4
+280,sj,1995,37,1995-09-17,0.0568,0.0546,0.1436857,0.1392,40.29,300.21,300.2,297.0514286,302.2,298.1,122.7,82.91142857,40.29,18.63,2.371428571,29.37142857,7.442857143,35.0,24.4,77.1
+281,sj,1995,38,1995-09-24,0.1186333,0.0846,0.1810167,0.2176167,121.4,300.0671429,300.1357143,296.9642857,302.5,298.3,82.5,83.31428571,121.4,18.52857143,2.442857143,29.58571429,6.914285714,35.6,25.0,71.2
+282,sj,1995,39,1995-10-01,0.1068,0.08366667,0.092,0.09934286,36.72,300.1557143,300.2071429,296.7714286,301.8,298.7,11.6,81.85428571,36.72,18.25428571,1.9,29.95714286,7.285714286,34.4,25.6,13.3
+283,sj,1995,40,1995-10-08,0.2808,0.2151,0.1463429,0.1295571,68.18,299.7814286,299.7285714,296.66,301.9,297.2,74.5,83.13571429,68.18,18.14571429,2.285714286,28.05714286,6.771428571,32.2,23.9,45.6
+284,sj,1995,41,1995-10-15,0.040825,0.0966,0.1316,0.1375429,45.63,299.54,299.5642857,296.6342857,301.4,298.0,53.98,84.20714286,45.63,18.13857143,1.814285714,28.38571429,6.928571429,32.2,24.4,19.1
+285,sj,1995,42,1995-10-22,0.033625,0.09466,0.09144286,0.1194429,55.67,299.7942857,299.8428571,296.1614286,301.8,297.8,40.8,80.66428571,55.67,17.62142857,2.028571429,27.84285714,7.171428571,33.9,23.3,39.1
+286,sj,1995,43,1995-10-29,,0.1326,0.1581857,0.1374429,54.74,299.4414286,299.4214286,296.3371429,301.8,297.6,46.4,83.21428571,54.74,17.84714286,2.385714286,27.47142857,7.257142857,32.2,23.3,53.6
+287,sj,1995,44,1995-11-05,0.2346,0.07825,0.2700714,0.2854286,30.3,299.7728571,299.9428571,296.17,302.3,298.1,40.4,80.86428571,30.3,17.67,3.0,28.04285714,7.642857143,33.9,23.3,13.5
+288,sj,1995,45,1995-11-12,0.0174,0.02905,0.2089143,0.2354857,0.0,299.0971429,299.2857143,295.22,301.1,297.5,32.4,79.40428571,0.0,16.60428571,1.914285714,27.22857143,6.871428571,31.7,23.3,53.6
+289,sj,1995,46,1995-11-19,0.0406,0.07475,0.19625,0.1903429,24.86,299.6228571,299.8071429,295.37,301.9,297.8,9.9,77.63857143,24.86,16.77,2.557142857,27.15714286,7.185714286,31.1,22.8,2.8
+290,sj,1995,47,1995-11-26,0.0334,0.1148667,0.2400143,0.2549,90.49,299.2757143,299.4,295.14,301.4,297.7,12.7,78.14142857,90.49,16.54142857,2.228571429,27.31428571,7.314285714,32.2,22.8,5.9
+291,sj,1995,48,1995-12-03,,0.076375,0.2411714,0.1688714,20.21,299.4528571,299.55,295.8371429,301.4,298.0,13.69,80.67714286,20.21,17.25714286,2.071428571,27.2,7.542857143,33.3,22.8,13.5
+292,sj,1995,49,1995-12-10,0.1154,0.135,0.2653,0.2371143,0.0,299.2014286,299.4,294.6871429,300.8,297.6,12.8,76.33285714,0.0,16.06571429,2.257142857,27.01428571,7.657142857,31.1,22.2,14.9
+293,sj,1995,50,1995-12-17,-0.0139,0.01473333,0.1795,0.1348,0.0,298.4614286,298.5785714,294.7314286,300.3,297.4,23.6,79.98571429,0.0,16.10571429,1.842857143,26.61428571,7.085714286,30.6,22.2,20.9
+294,sj,1995,51,1995-12-24,,0.03596667,0.1808571,0.1116571,0.0,298.1942857,298.2214286,293.9714286,300.1,296.5,40.3,77.63714286,0.0,15.37142857,1.7,25.71428571,5.857142857,30.0,22.2,53.9
+295,sj,1996,1,1996-01-01,0.014,0.01086667,0.09192857,0.1204429,6.35,297.4128571,297.4571429,294.54,299.5,295.9,57.0,84.13571429,6.35,15.88857143,1.657142857,25.18571429,4.842857143,28.3,21.7,46.5
+296,sj,1996,2,1996-01-08,0.1514333,0.1262333,0.1842429,0.1828,15.0,298.5285714,298.6285714,294.6614286,300.6,296.7,9.32,79.32142857,15.0,16.01571429,2.457142857,26.25714286,7.642857143,31.1,21.7,24.6
+297,sj,1996,3,1996-01-15,0.0149,0.07636667,0.1466571,0.1969857,55.68,297.7528571,297.8642857,294.5514286,299.6,295.9,50.3,82.51571429,55.68,15.91714286,2.071428571,25.97142857,6.885714286,31.1,21.7,40.6
+298,sj,1996,4,1996-01-22,0.0958,0.1381,0.2194571,0.2229,60.67,297.4228571,297.4857143,293.8028571,299.7,296.1,44.85,80.47714286,60.67,15.20857143,1.942857143,25.58571429,5.857142857,28.9,22.2,47.7
+299,sj,1996,5,1996-01-29,0.0627,0.1475333,0.2058429,0.2097286,0.0,296.6285714,296.7571429,292.04,298.2,295.0,28.6,75.69285714,0.0,13.65,1.942857143,24.78571429,6.028571429,28.3,20.0,32.0
+300,sj,1996,6,1996-02-05,0.02765,0.04075,0.1646,0.1686857,0.0,297.3071429,297.4357143,292.5814286,299.4,295.7,11.9,74.96142857,0.0,14.05857143,2.157142857,25.15714286,6.814285714,29.4,21.1,10.8
+301,sj,1996,7,1996-02-12,0.06895,0.13685,0.2188143,0.2143,29.3,297.6257143,297.6857143,293.85,299.9,295.0,15.45,79.66428571,29.3,15.23857143,2.228571429,25.31428571,7.442857143,31.1,21.1,25.5
+302,sj,1996,8,1996-02-19,,0.0583,0.1627857,0.1252143,7.2,297.8828571,298.0928571,293.6985714,300.0,296.1,16.7,77.78285714,7.2,15.12571429,2.728571429,25.97142857,7.714285714,31.7,21.1,22.1
+303,sj,1996,9,1996-02-26,0.076,0.108975,0.2699333,0.2227714,177.58,297.5985714,297.7071429,293.7314286,299.6,296.0,15.67,79.19857143,177.58,15.12857143,2.3,25.55714286,7.214285714,29.4,21.1,4.6
+304,sj,1996,10,1996-03-04,,0.11005,0.1926667,0.1776429,9.96,297.2928571,297.4785714,292.1285714,299.6,295.5,3.2,73.06,9.96,13.69571429,2.528571429,25.57142857,7.914285714,30.6,20.6,3.3
+305,sj,1996,11,1996-03-11,0.03786667,0.0368,0.1764286,0.1658571,0.0,297.9885714,298.1785714,293.5614286,299.9,296.6,8.6,76.48285714,0.0,14.94285714,2.214285714,26.24285714,7.2,31.1,21.7,12.7
+306,sj,1996,12,1996-03-18,0.07713333,0.1118,0.1855286,0.2112714,0.0,297.4285714,297.6,293.8342857,300.6,295.2,28.0,80.64714286,0.0,15.23571429,2.542857143,26.2,7.7,32.2,22.2,14.2
+307,sj,1996,13,1996-03-25,,-0.0457,0.1378857,0.1538429,0.0,298.1885714,298.3642857,293.0842857,300.4,296.7,2.8,73.42571429,0.0,14.52857143,2.928571429,26.4,9.028571429,32.2,20.6,0.5
+308,sj,1996,14,1996-04-01,0.0448,0.024225,0.0851,0.1079429,0.0,297.21,297.4071429,293.3214286,300.3,295.4,28.8,79.02,0.0,14.72714286,2.557142857,25.92857143,6.9,31.1,21.7,21.6
+309,sj,1996,15,1996-04-08,0.0497,0.1488,0.1627286,0.1776429,49.18,298.1357143,298.2071429,294.3657143,300.8,296.3,27.9,79.77571429,49.18,15.75142857,2.528571429,26.22857143,7.685714286,32.2,21.7,80.5
+310,sj,1996,16,1996-04-15,0.08893333,0.12235,0.2162143,0.2278286,46.16,297.8528571,298.0928571,293.8,300.7,295.7,24.22,78.31142857,46.16,15.18571429,2.3,26.12857143,6.728571429,32.2,21.1,8.9
+311,sj,1996,17,1996-04-22,,0.1078,0.1786857,0.1805143,0.0,298.2285714,298.4642857,293.2828571,300.4,297.0,10.9,74.17142857,0.0,14.70571429,2.385714286,26.12857143,6.4,30.0,22.2,8.2
+312,sj,1996,18,1996-04-29,0.3144667,0.1974,0.2231,0.2046286,5.63,298.0071429,298.0928571,293.5385714,299.8,296.6,21.5,76.39428571,5.63,14.93857143,1.842857143,26.01428571,6.628571429,30.0,22.2,25.6
+313,sj,1996,19,1996-05-06,-0.0464,-0.0384,0.0964,0.09445714,0.0,297.71,297.8,292.9157143,299.4,296.3,11.1,74.79285714,0.0,14.36142857,2.171428571,25.44285714,6.328571429,29.4,21.7,10.6
+314,sj,1996,20,1996-05-13,,0.07175,0.1463,0.1586429,21.7,297.5957143,297.6285714,294.4514286,300.1,296.2,68.2,82.84,21.7,15.79714286,1.714285714,25.84285714,5.542857143,29.4,22.2,44.8
+315,sj,1996,21,1996-05-20,0.0339,0.0557,0.2153167,0.21815,44.07,298.6585714,298.9214286,295.4671429,300.7,297.4,17.9,82.78,44.07,16.85714286,2.442857143,26.72857143,6.342857143,30.6,22.8,0.8
+316,sj,1996,22,1996-05-27,0.09985,0.1066,0.1409857,0.1087857,68.06,299.4414286,299.5928571,296.2371429,301.8,297.5,21.71,82.75142857,68.06,17.66,2.814285714,28.11428571,6.914285714,33.3,23.3,9.4
+317,sj,1996,23,1996-06-03,0.0529,0.080075,0.1793143,0.1579,137.06,299.2542857,299.1928571,296.0057143,301.4,297.9,24.38,82.36857143,137.06,17.39428571,2.071428571,27.81428571,7.028571429,32.2,23.9,2.3
+318,sj,1996,24,1996-06-10,0.0986,0.0893,0.12375,0.13545,27.82,298.7428571,298.8285714,295.4385714,300.6,297.5,43.3,82.23571429,27.82,16.8,2.028571429,26.94285714,5.985714286,31.1,23.3,40.9
+319,sj,1996,25,1996-06-17,0.07125,0.0646,0.1461,0.1561714,47.93,298.49,298.5642857,295.4357143,300.8,297.1,73.7,83.32285714,47.93,16.81,1.928571429,26.44285714,5.8,30.6,22.8,84.6
+320,sj,1996,26,1996-06-24,0.16555,0.1205,0.1861857,0.1705857,15.99,299.6414286,299.7071429,296.0442857,301.8,297.6,22.5,80.90714286,15.99,17.46857143,2.242857143,27.68571429,5.928571429,32.8,23.3,19.3
+321,sj,1996,27,1996-07-01,,0.07375,0.2217833,0.1834333,6.01,299.5814286,299.6857143,295.8342857,301.5,297.5,23.9,80.06142857,6.01,17.21142857,1.971428571,27.94285714,6.371428571,32.2,24.4,5.9
+322,sj,1996,28,1996-07-08,0.05763333,0.07825,0.1641167,0.1680333,24.35,299.7342857,299.8357143,296.3414286,302.0,297.9,35.23,81.83571429,24.35,17.76428571,2.242857143,28.01428571,6.371428571,32.8,23.3,43.5
+323,sj,1996,29,1996-07-15,0.1121,0.095425,0.1674286,0.1645429,97.22,299.0185714,299.0642857,296.1242857,301.4,297.1,123.2,84.32285714,97.22,17.53857143,2.242857143,27.27142857,5.628571429,31.1,23.9,53.6
+324,sj,1996,30,1996-07-22,0.0038,-0.0106,0.14715,0.1767833,14.89,299.7142857,299.9642857,295.7942857,302.0,298.0,15.8,79.19857143,14.89,17.14571429,2.328571429,27.51428571,5.471428571,31.1,23.9,9.9
+325,sj,1996,31,1996-07-29,0.09683333,0.115,0.1986143,0.2044429,41.78,299.3942857,299.4571429,296.03,301.4,297.5,39.1,81.91,41.78,17.39,2.2,27.17142857,5.157142857,30.0,23.9,79.3
+326,sj,1996,32,1996-08-05,,0.05435,0.1329714,0.1440857,34.04,299.1371429,299.1214286,296.4085714,300.7,297.7,67.71,85.01,34.04,17.81,1.7,27.67142857,5.342857143,30.6,24.4,31.9
+327,sj,1996,33,1996-08-12,0.0795,0.0291,0.14252,0.2317,19.92,299.6514286,299.7928571,296.0785714,301.8,298.1,29.2,80.93571429,19.92,17.48,2.614285714,28.01428571,6.128571429,31.7,22.8,14.3
+328,sj,1996,34,1996-08-19,,0.09555,0.3094667,0.2312,110.91,298.9842857,299.0428571,296.1285714,300.7,297.6,68.7,84.34428571,110.91,17.52285714,1.971428571,26.78571429,6.628571429,31.1,22.8,80.6
+329,sj,1996,35,1996-08-26,0.01203333,0.07396667,0.2981857,0.3126,15.74,299.9457143,300.0357143,295.9857143,302.4,298.0,33.7,79.27285714,15.74,17.42285714,2.557142857,27.75714286,6.214285714,33.3,23.9,22.6
+330,sj,1996,36,1996-09-02,0.0364,0.03065,0.1729,0.1757857,10.59,300.3728571,300.7428571,296.9114286,303.3,298.6,21.95,81.54,10.59,18.48571429,3.457142857,28.48571429,5.871428571,33.3,23.3,35.1
+331,sj,1996,37,1996-09-09,0.1043,0.1068,0.1678667,0.1728,63.31,299.8028571,299.8857143,296.4528571,301.5,297.8,89.24,81.98571429,63.31,17.97,1.8,27.94285714,6.514285714,32.8,23.3,51.1
+332,sj,1996,38,1996-09-16,,0.02845,0.1504286,0.1078167,243.55,299.4828571,299.4428571,296.88,301.3,297.6,151.7,85.69,243.55,18.40714286,1.828571429,27.04285714,5.828571429,31.7,22.8,305.9
+333,sj,1996,39,1996-09-23,0.04044,0.00445,0.1859,0.1818857,59.12,300.32,300.4428571,297.0928571,302.3,299.1,19.32,82.63857143,59.12,18.59571429,1.885714286,27.87142857,6.357142857,32.8,23.9,7.3
+334,sj,1996,40,1996-09-30,-0.0385,0.06813333,0.1651286,0.1952143,27.58,300.0185714,300.2071429,296.09,302.4,298.6,27.2,79.17714286,27.58,17.52142857,2.1,27.41428571,5.885714286,31.1,23.9,20.9
+335,sj,1996,41,1996-10-07,-0.0066,-0.0355,0.2071833,0.2196167,28.18,299.9628571,300.1142857,296.46,302.3,298.1,23.54,81.26,28.18,17.94142857,2.542857143,27.28571429,6.242857143,31.7,23.3,17.6
+336,sj,1996,42,1996-10-14,,0.0609,0.2202286,0.2358,4.62,299.8042857,299.8428571,296.0485714,301.8,298.2,23.7,79.95714286,4.62,17.48571429,2.171428571,27.57142857,6.642857143,31.7,23.3,8.9
+337,sj,1996,43,1996-10-21,-0.0969,-0.0902,0.1490143,0.1663143,17.37,300.3442857,300.4642857,296.7171429,302.1,298.7,7.1,80.73428571,17.37,18.23,2.642857143,29.04285714,7.385714286,33.9,24.4,6.6
+338,sj,1996,44,1996-10-28,0.00525,0.0158,0.1809429,0.1463571,16.06,299.2514286,299.3428571,295.72,302.3,297.7,65.2,81.13,16.06,17.14428571,2.085714286,27.04285714,6.1,31.1,21.7,28.9
+339,sj,1996,45,1996-11-04,-0.05675,-0.00865,0.1236143,0.1353,51.59,299.1685714,299.2357143,296.26,301.5,297.5,59.22,84.11142857,51.59,17.70142857,2.042857143,26.84285714,6.285714286,31.1,22.2,35.6
+340,sj,1996,46,1996-11-11,-0.03006667,0.0881,0.07505714,0.098,34.32,298.2457143,298.2142857,295.2657143,299.7,296.8,219.9,83.64,34.32,16.67714286,1.8,26.15714286,6.028571429,30.0,22.2,25.0
+341,sj,1996,47,1996-11-18,,0.039525,0.06076667,0.0578,42.76,298.4771429,298.5571429,295.4385714,300.5,296.8,113.55,83.39714286,42.76,16.84285714,1.6,25.87142857,5.6,29.4,22.2,88.3
+342,sj,1996,48,1996-11-25,,0.1038667,0.1649714,0.1447714,65.18,298.1971429,298.4214286,295.6671429,300.5,296.6,49.0,86.07142857,65.18,17.12857143,2.042857143,25.61428571,4.585714286,28.3,22.8,39.5
+343,sj,1996,49,1996-12-02,-0.1171,-0.01016667,0.2602714,0.2308429,0.0,297.6428571,297.6785714,292.9414286,299.7,295.6,20.57,75.29285714,0.0,14.45857143,1.9,25.01428571,5.057142857,28.3,21.7,19.6
+344,sj,1996,50,1996-12-09,,0.0495,0.1559143,0.176,0.0,297.8271429,297.9785714,292.6628571,300.6,295.2,3.8,73.25285714,0.0,14.24571429,2.757142857,24.8,6.571428571,30.0,20.6,3.1
+345,sj,1996,51,1996-12-16,,0.1639,0.1702286,0.1818571,0.0,296.6357143,296.7714286,292.7871429,299.1,295.6,40.7,79.37285714,0.0,14.33285714,1.828571429,24.95714286,4.7,28.9,21.1,25.4
+346,sj,1996,52,1996-12-23,0.0214,0.0214,0.156975,0.1470375,0.0,297.0314286,297.1142857,291.4242857,299.0,294.5,3.93,71.06285714,0.0,13.15285714,2.485714286,24.51428571,5.785714286,27.8,19.4,4.0
+347,sj,1997,1,1997-01-01,0.1526333,0.1094,0.2077429,0.1732857,0.0,299.6771429,299.8214286,295.0142857,301.5,297.7,3.24,75.67857143,0.0,16.37714286,2.357142857,26.62857143,7.714285714,31.7,21.7,0.5
+348,sj,1997,2,1997-01-08,,0.1839,0.2683714,0.1435857,0.0,297.1885714,297.4285714,293.5585714,299.2,295.6,24.14,80.3,0.0,14.96714286,2.371428571,24.67142857,5.642857143,27.8,21.1,29.0
+349,sj,1997,3,1997-01-15,-0.1459,0.0338,0.2233714,0.2170857,0.0,297.5685714,297.6642857,292.7971429,299.4,296.1,7.79,74.94,0.0,14.27857143,2.242857143,24.38571429,6.657142857,28.9,19.4,0.6
+350,sj,1997,4,1997-01-22,0.0495,0.07316667,0.1704714,0.1861429,6.65,297.4857143,297.7428571,293.7871429,300.9,295.2,23.5,80.09285714,6.65,15.17428571,3.142857143,24.9,6.428571429,28.9,21.1,2.0
+351,sj,1997,5,1997-01-29,0.0451,0.04505,0.1107571,0.1018,66.05,296.7414286,296.8428571,293.5328571,298.9,295.3,81.3,82.38857143,66.05,14.89857143,1.828571429,24.62857143,4.685714286,28.3,21.1,58.9
+352,sj,1997,6,1997-02-05,0.04245,0.03413333,0.1372714,0.1156857,53.52,297.27,297.4071429,292.5757143,299.1,295.8,14.3,75.07571429,53.52,14.05857143,2.071428571,23.7,6.1,27.8,19.4,49.5
+353,sj,1997,7,1997-02-12,0.0455,0.1281,0.1796714,0.1705857,24.98,297.12,297.2928571,293.6371429,298.8,295.7,50.58,80.94714286,24.98,15.01714286,1.7,24.57142857,5.7,27.8,21.1,25.4
+354,sj,1997,8,1997-02-19,0.0297,0.07732,0.1488286,0.1815429,0.0,297.5871429,297.7142857,293.2214286,299.2,296.2,15.14,76.71285714,0.0,14.61428571,2.057142857,24.68571429,6.271428571,28.3,21.1,22.9
+355,sj,1997,9,1997-02-26,,0.04896667,0.15534,0.1579,0.0,297.2642857,297.3571429,292.4728571,298.8,295.7,15.1,74.63142857,0.0,13.93142857,2.171428571,24.47142857,5.542857143,27.8,21.1,30.0
+356,sj,1997,10,1997-03-05,,,0.2277,0.2670143,0.0,297.2928571,297.3928571,292.41,299.0,295.5,9.5,74.25571429,0.0,13.88571429,2.214285714,24.57142857,4.985714286,27.8,21.1,15.5
+357,sj,1997,11,1997-03-12,,0.0864,0.1700714,0.1512429,0.0,297.1385714,297.35,292.4957143,299.3,295.8,14.3,75.37285714,0.0,13.97714286,2.157142857,24.35714286,5.785714286,27.8,21.1,13.8
+358,sj,1997,12,1997-03-19,0.1409,0.12525,0.2582143,0.2533286,0.0,297.0785714,297.2214286,292.7671429,299.1,296.0,17.92,76.90428571,0.0,14.22285714,1.9,24.74285714,6.585714286,28.9,21.1,15.2
+359,sj,1997,13,1997-03-26,0.11245,0.107,0.2076143,0.2154,0.0,297.7214286,297.9214286,292.7585714,300.6,295.7,7.0,74.11857143,0.0,14.22714286,3.442857143,25.31428571,8.071428571,31.1,20.6,1.5
+360,sj,1997,14,1997-04-02,,0.123,0.1983167,0.1916833,0.0,297.6928571,297.8571429,292.7757143,299.9,295.5,5.9,74.20571429,0.0,14.23142857,2.685714286,25.08571429,7.457142857,29.4,20.6,2.9
+361,sj,1997,15,1997-04-09,0.0602,0.069825,0.2164286,0.2027714,6.65,296.5957143,296.6357143,291.8428571,300.7,294.3,18.73,74.85,6.65,13.49285714,2.385714286,25.35714286,5.614285714,31.1,21.7,0.6
+362,sj,1997,16,1997-04-16,0.033075,0.05155,0.2085429,0.2354857,0.0,297.1785714,297.4642857,291.6742857,299.6,295.1,7.5,71.55857143,0.0,13.35,2.785714286,25.9,7.928571429,31.7,20.0,0.8
+363,sj,1997,17,1997-04-23,0.0388,0.023,0.2024429,0.2222571,0.0,298.8214286,299.05,294.0985714,301.7,296.7,16.2,75.41714286,0.0,15.50142857,3.842857143,27.67142857,9.614285714,34.4,21.1,0.0
+364,sj,1997,18,1997-04-30,-0.0035,0.007333333,0.1991,0.1928833,5.73,299.2042857,299.3857143,294.82,301.7,296.7,4.0,76.95285714,5.73,16.17,3.457142857,27.77142857,8.271428571,33.9,22.8,0.5
+365,sj,1997,19,1997-05-07,-0.0597,0.0331,0.1650857,0.1324571,0.0,299.35,299.5071429,294.7271429,301.1,297.8,1.5,75.87857143,0.0,16.07857143,2.7,27.92857143,8.428571429,33.9,23.3,0.3
+366,sj,1997,20,1997-05-14,0.1019,0.0747,0.1175167,0.1297857,33.03,298.85,298.9857143,294.7985714,301.4,297.1,27.3,78.53714286,33.03,16.14428571,2.542857143,27.57142857,8.671428571,32.8,22.2,12.6
+367,sj,1997,21,1997-05-21,0.0798,0.1065333,0.1590333,0.09873333,0.0,299.2414286,299.3857143,294.6614286,301.1,297.8,10.1,75.98285714,0.0,15.99714286,2.428571429,27.58571429,7.085714286,32.2,23.9,12.9
+368,sj,1997,22,1997-05-28,0.0235,0.05535,0.2090857,0.1450571,64.1,299.2814286,299.4357143,295.2628571,301.4,297.7,10.5,78.71142857,64.1,16.66,2.671428571,27.31428571,7.028571429,31.7,22.8,30.5
+369,sj,1997,23,1997-06-04,0.0557,0.08895,0.1841571,0.1623571,118.35,298.9957143,299.0428571,295.9785714,300.6,297.9,41.7,83.48571429,118.35,17.36857143,1.971428571,27.27142857,7.071428571,32.8,22.2,31.3
+370,sj,1997,24,1997-06-11,0.1197,0.0904,0.1477167,0.1914143,0.0,300.0014286,300.2642857,296.1742857,302.3,298.2,9.9,79.74571429,0.0,17.62,2.871428571,28.6,7.0,32.8,23.9,0.3
+371,sj,1997,25,1997-06-18,0.0108,0.05426667,0.1710429,0.2157,2.43,300.3671429,300.6,296.4114286,302.6,298.0,7.8,79.36428571,2.43,17.84714286,2.914285714,29.01428571,7.514285714,33.9,23.9,0.5
+372,sj,1997,26,1997-06-25,0.0749,0.07762,0.1302143,0.1368,34.69,300.0442857,300.0928571,296.3228571,302.0,298.4,23.4,80.24571429,34.69,17.73285714,2.185714286,28.65714286,6.685714286,32.8,23.9,18.6
+373,sj,1997,27,1997-07-02,0.1012,0.09026667,0.1940286,0.1983714,38.84,300.2957143,300.5142857,296.2385714,302.3,298.3,24.3,78.63857143,38.84,17.63571429,2.914285714,28.41428571,6.428571429,32.2,24.4,4.1
+374,sj,1997,28,1997-07-09,0.0883,0.07483333,0.1354571,0.1118571,5.87,300.4885714,300.6428571,296.4157143,302.3,299.0,21.3,78.62,5.87,17.84571429,2.428571429,29.01428571,7.542857143,33.9,23.9,8.7
+375,sj,1997,29,1997-07-16,-0.0562,0.0112,0.1573143,0.1659714,24.42,300.0942857,300.1714286,296.5114286,302.2,298.1,35.4,80.91714286,24.42,17.94857143,2.542857143,28.61428571,6.742857143,32.8,24.4,40.9
+376,sj,1997,30,1997-07-23,-0.1562,,0.1646429,0.1496857,41.34,299.9585714,299.9428571,296.6028571,302.7,298.2,73.74,82.13285714,41.34,18.04571429,1.771428571,27.9,6.285714286,31.7,23.3,51.2
+377,sj,1997,31,1997-07-30,0.1393,0.07825,0.2511714,0.1919429,29.9,300.1171429,300.2142857,296.2157143,302.4,297.8,33.6,79.45428571,29.9,17.61714286,2.742857143,27.82857143,6.6,31.7,22.8,16.3
+378,sj,1997,32,1997-08-06,0.0981,0.0981,0.1404571,0.1142286,19.57,300.2942857,300.4142857,296.7357143,302.5,297.8,28.6,81.10428571,19.57,18.18,2.514285714,28.64285714,5.942857143,32.2,25.0,5.2
+379,sj,1997,33,1997-08-13,0.008933333,0.046675,0.1411,0.1585714,57.65,299.84,299.9928571,296.5728571,301.9,298.1,42.79,82.39285714,57.65,17.98857143,2.471428571,28.28571429,6.614285714,32.8,23.9,53.4
+380,sj,1997,34,1997-08-20,,0.11135,0.1741857,0.1446,20.35,299.7614286,299.8,296.6585714,301.8,298.2,45.7,83.28,20.35,18.09142857,2.028571429,28.41428571,6.514285714,32.2,24.4,52.3
+381,sj,1997,35,1997-08-27,0.06065,0.08936667,0.1869714,0.2091857,94.72,300.2657143,300.3357143,296.7042857,302.5,298.8,35.9,81.14285714,94.72,18.18285714,2.1,27.98571429,6.442857143,32.2,22.8,50.0
+382,sj,1997,36,1997-09-03,0.1072,0.1159667,0.2084,0.1735571,8.83,300.1385714,300.1214286,296.8042857,302.0,298.5,35.9,82.22,8.83,18.30857143,2.071428571,28.72857143,6.585714286,32.8,25.0,17.0
+383,sj,1997,37,1997-09-10,0.03495,0.0815,0.1973143,0.1827714,11.47,300.5485714,300.7214286,297.4142857,302.6,298.9,46.4,83.16428571,11.47,19.04428571,2.585714286,28.95714286,6.128571429,32.8,24.4,15.8
+384,sj,1997,38,1997-09-17,-0.049,0.01545,0.1992286,0.1866286,86.14,300.6828571,300.8071429,297.2471429,303.6,299.0,36.89,81.80857143,86.14,18.82857143,2.585714286,28.9,6.671428571,34.4,25.0,18.1
+385,sj,1997,39,1997-09-24,0.12258,0.09823333,0.1432143,0.1434143,13.18,300.42,300.5142857,296.3857143,302.6,298.0,39.6,78.78,13.18,17.82857143,2.4,28.4,6.742857143,32.2,23.9,25.4
+386,sj,1997,40,1997-10-01,0.1123,0.1054,0.2000571,0.1438857,46.15,300.1328571,300.2071429,297.2685714,302.6,298.7,39.0,84.43714286,46.15,18.81428571,2.128571429,27.58571429,6.757142857,32.2,21.7,31.2
+387,sj,1997,41,1997-10-08,0.0019,0.095825,0.09027143,0.0999,70.29,300.5642857,300.7357143,296.7871429,303.2,298.5,26.0,80.08428571,70.29,18.31,2.642857143,28.5,7.3,33.3,23.3,44.4
+388,sj,1997,42,1997-10-15,-0.01515,0.0831,0.2018667,0.2107333,99.33,299.4785714,299.4357143,296.4357143,302.9,297.6,182.0,83.57571429,99.33,17.92714286,1.842857143,27.35714286,6.428571429,31.1,22.8,6.3
+389,sj,1997,43,1997-10-22,,0.1966,0.3152429,0.2916429,80.85,299.6085714,299.8428571,296.3042857,302.3,296.4,27.34,82.23428571,80.85,17.81857143,3.342857143,27.7,5.885714286,32.8,23.9,8.7
+390,sj,1997,44,1997-10-29,,0.1695,0.2978143,0.2102,0.78,300.3814286,300.55,296.1014286,302.3,298.1,7.27,77.53285714,0.78,17.55142857,2.7,28.38571429,5.814285714,32.8,24.4,0.0
+391,sj,1997,45,1997-11-05,0.07745,,0.1989571,0.1767429,2.08,300.0314286,300.0928571,295.6957143,301.9,298.6,9.5,77.30714286,2.08,17.09571429,2.042857143,27.74285714,6.114285714,31.1,23.9,27.1
+392,sj,1997,46,1997-11-12,0.0695,0.12345,0.1481429,0.1022714,18.83,299.6871429,299.7928571,295.3457143,302.6,297.9,9.0,77.16285714,18.83,16.76428571,2.242857143,27.34285714,7.4,32.8,22.8,34.6
+393,sj,1997,47,1997-11-19,,-0.1026,0.2017857,0.1477857,50.55,299.4914286,299.5285714,296.3128571,301.8,298.0,40.5,82.76571429,50.55,17.73857143,1.8,27.32857143,6.0,31.1,23.9,6.1
+394,sj,1997,48,1997-11-26,0.2192,0.1606,0.1749286,0.2117571,4.76,299.62,299.7,296.3371429,301.9,297.9,42.9,82.27,4.76,17.77142857,2.2,27.25714286,5.671428571,30.6,23.9,81.8
+395,sj,1997,49,1997-12-03,0.0568,0.0661,0.3493143,0.3120714,3.01,299.4557143,299.5071429,295.5757143,301.3,298.2,14.7,79.39571429,3.01,17.00142857,1.871428571,26.67142857,6.614285714,31.7,23.3,39.9
+396,sj,1997,50,1997-12-10,,-0.0448,0.2314143,0.2354714,0.0,300.1328571,300.35,295.1528571,302.0,298.8,0.3,74.28142857,0.0,16.53,2.671428571,26.75714286,8.257142857,32.2,21.7,0.0
+397,sj,1997,51,1997-12-17,,0.0001,0.2579571,0.2339,0.0,299.6385714,299.6642857,294.7957143,301.6,298.1,3.9,74.79571429,0.0,16.14571429,2.471428571,26.57142857,7.3,32.2,22.2,1.5
+398,sj,1997,52,1997-12-24,0.0663,0.075925,0.2132111,0.2257889,22.52,299.2142857,299.2857143,295.3514286,301.7,297.6,16.3,79.47,22.52,16.70428571,2.571428571,26.71428571,7.571428571,31.7,22.2,17.3
+399,sj,1998,1,1998-01-01,0.0455,0.0478,0.1239857,0.08344286,,,,,,,,,,,,,,,,
+400,sj,1998,2,1998-01-08,0.05076667,0.0341,0.2233714,0.1341571,10.59,298.8271429,298.9928571,295.03,300.7,297.2,44.4,79.63142857,10.59,16.36285714,2.157142857,26.35714286,6.142857143,31.7,22.8,33.3
+401,sj,1998,3,1998-01-15,-0.01615,-0.008225,0.2047143,0.1985714,106.97,297.6128571,297.6857143,294.8528571,300.2,296.4,53.2,84.69428571,106.97,16.20857143,1.885714286,24.88571429,5.857142857,29.4,20.6,152.4
+402,sj,1998,4,1998-01-22,0.1797,0.03345,0.2514571,0.1921,0.0,298.6114286,298.8,294.51,300.6,296.8,8.4,78.18285714,0.0,15.88142857,2.4,25.61428571,6.485714286,29.4,21.1,4.8
+403,sj,1998,5,1998-01-29,0.13155,0.045825,0.1461143,0.1313571,7.72,298.6942857,298.8571429,294.19,300.6,297.0,16.3,76.26142857,7.72,15.56142857,2.342857143,26.54285714,7.257142857,31.1,22.2,1.3
+404,sj,1998,6,1998-02-05,-0.0479,-0.0525,0.1274857,0.09734286,0.0,298.5785714,298.8071429,293.9714286,301.3,296.6,8.6,75.77714286,0.0,15.36142857,3.271428571,26.58571429,8.114285714,31.7,21.1,0.0
+405,sj,1998,7,1998-02-12,0.11825,0.0559,0.1819,0.1763143,142.6,299.0585714,299.25,295.6285714,302.2,296.7,18.5,81.61285714,142.6,17.08857143,2.957142857,27.25714286,6.9,32.2,22.8,79.2
+406,sj,1998,8,1998-02-19,,0.0754,0.2395714,0.2387,0.0,297.59,297.8357143,291.9014286,300.2,296.2,3.1,70.70142857,0.0,13.51285714,2.242857143,24.41428571,6.085714286,28.9,20.0,8.7
+407,sj,1998,9,1998-02-26,0.1545,0.0849,0.24338,0.1549833,0.0,298.8928571,299.1285714,294.1142857,300.6,297.8,1.1,75.01571429,0.0,15.47714286,2.285714286,26.27142857,7.942857143,31.1,21.1,6.4
+408,sj,1998,10,1998-03-05,0.06366667,0.09633333,0.1728429,0.1622143,0.0,297.6557143,297.7928571,293.5,301.1,295.0,10.3,77.92428571,0.0,14.93571429,2.842857143,25.61428571,7.257142857,32.2,21.1,7.0
+409,sj,1998,11,1998-03-12,,0.0797,0.1391714,0.1625286,0.0,298.2785714,298.3857143,294.6971429,301.2,295.7,42.78,80.77857143,0.0,16.08142857,2.228571429,25.81428571,6.9,32.2,21.1,15.1
+410,sj,1998,12,1998-03-19,0.0604,0.08823333,0.2129286,0.2124143,0.0,298.1757143,298.3714286,292.9071429,300.4,296.2,0.6,72.64285714,0.0,14.36714286,2.514285714,24.88571429,7.014285714,28.9,20.6,27.7
+411,sj,1998,13,1998-03-26,,0.0731,0.1881667,0.1685,0.0,298.5028571,298.6642857,294.0985714,300.7,296.5,21.0,76.67571429,0.0,15.48,2.557142857,26.22857143,6.9,31.1,22.2,16.5
+412,sj,1998,14,1998-04-02,0.0672,0.02766667,0.1485333,0.1277429,72.98,298.0442857,298.1928571,294.6285714,301.1,296.5,41.2,81.40571429,72.98,15.99857143,2.528571429,25.71428571,6.2,31.7,21.7,15.5
+413,sj,1998,15,1998-04-09,0.048,0.0652,0.09894286,0.1027714,12.01,297.8714286,298.2,294.2157143,300.8,295.6,19.0,80.19,12.01,15.63571429,3.0,26.02857143,6.357142857,31.7,21.7,10.7
+414,sj,1998,16,1998-04-16,0.0308,0.076,0.1139714,0.1258571,0.0,298.4728571,298.5785714,294.97,300.7,296.5,23.9,81.14571429,0.0,16.40285714,2.157142857,26.92857143,6.114285714,33.9,22.2,7.9
+415,sj,1998,17,1998-04-23,0.0671,0.09136667,0.1444857,0.1479571,22.22,297.7357143,297.7928571,293.5428571,299.8,296.2,24.3,77.71285714,22.22,15.01428571,2.157142857,25.6,5.857142857,29.4,21.7,73.4
+416,sj,1998,18,1998-04-30,0.1063,0.0461,0.2191857,0.2073286,71.64,299.5657143,299.8357143,295.8342857,301.5,298.2,11.7,80.07285714,71.64,17.23142857,2.357142857,26.87142857,6.9,31.1,22.8,16.3
+417,sj,1998,19,1998-05-07,,0.09693333,0.1582429,0.1198143,0.0,299.1328571,299.2928571,294.8271429,301.3,297.7,17.6,77.33142857,0.0,16.22142857,2.185714286,26.78571429,6.2,31.1,22.2,6.9
+418,sj,1998,20,1998-05-14,,0.04255,0.1317833,0.1003,55.76,299.2,299.4,295.11,302.9,296.6,10.3,78.40142857,55.76,16.50285714,3.628571429,27.14285714,7.014285714,33.9,22.2,7.1
+419,sj,1998,21,1998-05-21,-0.003,0.033625,0.1648667,0.1742,56.4,300.0242857,300.0857143,297.0628571,302.9,297.8,53.7,84.07142857,56.4,18.61428571,2.828571429,27.91428571,6.971428571,34.4,23.3,59.1
+420,sj,1998,22,1998-05-28,0.0484,0.0372,0.1550833,0.1645167,15.86,299.8428571,299.9357143,297.02,302.3,298.4,59.4,84.63571429,15.86,18.51142857,2.185714286,27.97142857,5.657142857,31.1,24.4,13.8
+421,sj,1998,23,1998-06-04,-0.0427,0.07076667,0.1536,0.1221429,8.19,299.6185714,299.8071429,296.3514286,301.4,298.1,35.8,82.46,8.19,17.76571429,2.328571429,27.85714286,6.2,32.2,23.9,10.5
+422,sj,1998,24,1998-06-11,0.12125,0.12125,0.2368143,0.2751714,86.21,300.7571429,300.8428571,297.4514286,302.7,299.2,20.7,82.30571429,86.21,18.99142857,2.428571429,28.42857143,6.985714286,32.8,23.9,38.6
+423,sj,1998,25,1998-06-18,0.0725,0.0509,0.2078286,0.1756286,49.52,300.5171429,300.5642857,296.4357143,303.0,298.9,15.4,78.53,49.52,17.85428571,2.385714286,28.1,6.528571429,32.8,23.9,23.4
+424,sj,1998,26,1998-06-25,0.03745,0.0167,0.1447,0.1523571,72.08,299.9442857,299.95,296.9957143,302.3,298.3,71.33,84.02571429,72.08,18.47,2.357142857,28.21428571,6.742857143,32.2,23.9,20.6
+425,sj,1998,27,1998-07-02,0.0715,0.096075,0.1718429,0.1558857,20.06,300.5957143,300.7214286,296.8471429,302.7,299.0,33.31,80.08571429,20.06,18.27857143,2.3,28.61428571,5.857142857,32.2,25.0,0.0
+426,sj,1998,28,1998-07-09,-0.03095,0.0628,0.1886286,0.1695286,54.05,300.4528571,300.4357143,296.9242857,302.9,298.5,45.31,81.29,54.05,18.39142857,2.3,28.38571429,6.742857143,32.8,22.8,11.7
+427,sj,1998,29,1998-07-16,0.0289,0.04713333,0.08254286,0.06893333,10.42,300.3371429,300.4571429,296.2885714,302.8,298.1,30.86,78.99,10.42,17.71571429,2.714285714,28.38571429,7.071428571,33.3,23.9,62.5
+428,sj,1998,30,1998-07-23,0.0554,0.1065,0.1776429,0.1602571,68.74,299.8228571,299.8857143,296.5028571,302.2,298.1,93.68,82.21285714,68.74,17.94571429,1.885714286,27.55714286,6.685714286,31.7,23.9,81.9
+429,sj,1998,31,1998-07-30,0.14065,0.127,0.26975,0.2465286,16.03,300.0614286,300.0357143,297.0385714,302.0,298.5,107.87,83.74285714,16.03,18.54714286,2.042857143,28.27142857,5.728571429,31.7,23.9,20.5
+430,sj,1998,32,1998-08-06,0.02866667,0.057625,0.1758571,0.1526857,25.79,300.6628571,300.8857143,297.1271429,303.2,298.6,27.7,81.21714286,25.79,18.63142857,2.914285714,28.45714286,6.185714286,32.2,24.4,6.2
+431,sj,1998,33,1998-08-13,0.05346667,0.0935,0.1854333,0.1739,38.44,300.6685714,300.6214286,297.4571429,303.1,298.9,55.9,82.8,38.44,19.01571429,2.271428571,29.07142857,6.342857143,32.8,24.4,3.8
+432,sj,1998,34,1998-08-20,0.1072,0.0567,0.1809667,0.1720333,24.34,300.3671429,300.35,297.4671429,303.0,298.9,63.2,84.20285714,24.34,19.01,1.728571429,29.21428571,6.414285714,32.8,25.0,20.4
+433,sj,1998,35,1998-08-27,0.0307,0.07575,0.1548167,0.1902571,96.58,300.4685714,300.5785714,297.4014286,303.1,298.7,98.3,83.45,96.58,19.02714286,2.671428571,28.04285714,6.828571429,33.9,23.3,146.4
+434,sj,1998,36,1998-09-03,0.0388,0.05403333,0.1585429,0.1456429,47.74,300.6871429,300.7071429,297.3285714,303.4,298.4,52.5,82.19285714,47.74,18.90857143,2.9,28.75714286,7.128571429,33.9,22.8,27.4
+435,sj,1998,37,1998-09-10,0.07465,0.05796667,0.1518857,0.122,72.73,300.1471429,300.2,297.16,302.0,298.7,73.6,84.00285714,72.73,18.72428571,2.028571429,28.32857143,6.842857143,32.2,24.4,61.3
+436,sj,1998,38,1998-09-17,,0.0401,0.1554833,0.14148,35.03,300.5871429,300.6071429,297.2757143,303.0,298.8,33.83,82.33285714,35.03,18.84714286,2.185714286,28.72857143,6.985714286,34.4,24.4,39.7
+437,sj,1998,39,1998-09-24,0.05085,0.04685,0.2315857,0.2066857,82.87,300.13,300.1857143,297.06,302.1,298.8,55.8,83.33142857,82.87,18.58142857,1.857142857,27.77142857,6.228571429,32.2,24.4,123.6
+438,sj,1998,40,1998-10-01,-0.0022,0.0382,0.1618857,0.1683143,223.61,300.5971429,300.7571429,296.5385714,302.9,298.5,124.4,78.78285714,223.61,18.06142857,2.8,27.91428571,6.285714286,32.8,23.9,24.7
+439,sj,1998,41,1998-10-08,,-0.019,0.1630571,0.1492,33.26,300.7128571,300.7428571,296.9214286,302.9,298.9,28.3,79.99857143,33.26,18.41857143,2.342857143,28.25714286,5.5,31.7,24.4,25.0
+440,sj,1998,42,1998-10-15,,0.08155,0.1864143,0.1386857,25.94,300.7957143,300.8571429,296.6128571,302.9,299.3,18.5,78.09857143,25.94,18.09142857,2.685714286,27.75714286,6.314285714,31.7,23.3,15.5
+441,sj,1998,43,1998-10-22,0.0213,0.085,0.1969667,0.1962,32.09,300.2471429,300.2357143,296.9,301.9,298.8,36.5,82.03857143,32.09,18.41,2.128571429,28.15714286,6.928571429,33.9,23.9,26.7
+442,sj,1998,44,1998-10-29,-0.0359,-0.0726,0.1117286,0.09242857,182.46,299.8485714,299.9857143,296.8671429,302.1,297.7,92.4,83.86571429,182.46,18.37571429,2.085714286,27.71428571,6.128571429,32.8,23.3,54.6
+443,sj,1998,45,1998-11-05,,-0.00225,0.2212286,0.1698,121.65,299.6528571,299.6928571,296.9428571,301.7,298.5,89.5,85.12,121.65,18.48428571,1.785714286,27.42857143,6.457142857,31.1,23.3,81.5
+444,sj,1998,46,1998-11-12,0.003866667,-0.05725,0.1859167,0.09834286,18.07,300.0028571,300.05,296.42,302.4,297.9,36.1,80.91428571,18.07,17.86857143,2.071428571,27.78571429,6.671428571,32.8,23.3,8.7
+445,sj,1998,47,1998-11-19,,,0.2537429,0.2166143,110.03,298.6757143,298.6571429,296.1828571,300.3,297.3,143.4,86.21428571,110.03,17.62714286,1.485714286,26.72857143,6.214285714,30.6,23.3,71.3
+446,sj,1998,48,1998-11-26,0.0501,0.06575,0.1662429,0.1467571,0.0,299.2328571,299.3214286,295.4928571,301.4,297.4,57.1,80.02142857,0.0,16.86714286,2.014285714,26.55714286,5.685714286,30.0,22.8,29.8
+447,sj,1998,49,1998-12-03,0.05675,0.06565,0.06918571,0.05278571,22.35,298.3014286,298.2571429,295.1728571,300.4,296.5,115.77,83.02428571,22.35,16.58714286,1.885714286,25.64285714,5.942857143,29.4,22.2,48.2
+448,sj,1998,50,1998-12-10,0.0619,0.002633333,0.2133,0.1730143,152.94,298.0942857,298.15,295.54,299.8,297.1,158.72,85.91142857,152.94,16.96571429,1.357142857,25.81428571,5.014285714,28.9,22.8,97.6
+449,sj,1998,51,1998-12-17,-0.08216667,-0.091675,0.2399,0.1700571,16.76,299.0428571,299.1,295.0328571,300.9,297.6,10.2,78.66857143,16.76,16.40857143,1.971428571,26.07142857,5.542857143,31.1,22.8,18.9
+450,sj,1998,52,1998-12-24,0.06056667,-0.13095,0.15715,0.0981875,0.0,299.2828571,299.4357143,295.2157143,301.4,298.0,12.8,78.41857143,0.0,16.56428571,2.128571429,25.92857143,6.042857143,30.0,22.2,29.7
+451,sj,1999,53,1999-01-01,,,,,,,,,,,,,,,,,,,,
+452,sj,1999,1,1999-01-08,,-0.0876,0.1887,0.1634167,45.39,298.7,298.8142857,295.0971429,300.7,297.3,17.72,80.59714286,45.39,16.45285714,2.428571429,25.57142857,5.471428571,28.9,22.2,16.2
+453,sj,1999,2,1999-01-15,-0.1399,-0.03763333,0.1813833,0.1448429,0.0,298.4828571,298.55,294.12,300.1,297.4,12.6,76.95428571,0.0,15.49285714,1.671428571,25.07142857,5.728571429,28.3,20.0,20.6
+454,sj,1999,3,1999-01-22,-0.0698,-0.03795,0.1808,0.1158429,47.16,297.8614286,297.9714286,294.4085714,300.0,296.1,20.62,81.31,47.16,15.76857143,2.2,24.98571429,6.885714286,30.0,21.1,27.2
+455,sj,1999,4,1999-01-29,0.0535,-0.10875,0.1818429,0.1406143,0.0,297.4428571,297.5714286,293.7014286,299.1,295.8,40.75,79.67142857,0.0,15.07285714,1.771428571,24.88571429,6.414285714,28.3,21.1,8.6
+456,sj,1999,5,1999-02-05,,0.05145,0.2175,0.1739286,0.0,296.7728571,296.7571429,290.9557143,299.3,294.5,14.9,70.19857143,0.0,12.74142857,2.0,24.17142857,5.642857143,27.8,19.4,18.0
+457,sj,1999,6,1999-02-12,0.0669,,0.2283286,0.2092,0.0,296.6685714,296.7857143,290.5528571,298.9,295.3,4.7,68.64142857,0.0,12.36571429,1.914285714,23.4,7.385714286,27.8,17.8,2.9
+458,sj,1999,7,1999-02-19,0.0263,0.0364,0.1718571,0.1876,18.66,297.2185714,297.4428571,292.73,299.4,295.5,18.64,76.24571429,18.66,14.22571429,2.571428571,24.32857143,7.514285714,29.4,19.4,24.8
+459,sj,1999,8,1999-02-26,0.12905,0.086,0.1234714,0.1325,23.9,295.9385714,296.1142857,290.6342857,299.7,293.7,8.7,72.25142857,23.9,12.49285714,2.714285714,24.04285714,6.9,28.9,18.9,0.0
+460,sj,1999,9,1999-03-05,-0.0509,0.03793333,0.1977167,0.1614667,0.0,297.5428571,297.6785714,293.3114286,299.7,295.3,8.3,77.42714286,0.0,14.73,2.785714286,25.0,7.428571429,29.4,20.6,40.1
+461,sj,1999,10,1999-03-12,-0.071225,0.043425,0.1611167,0.2284286,0.0,297.8828571,298.0714286,292.4214286,299.7,296.0,0.4,71.69142857,0.0,13.93571429,2.485714286,24.95714286,7.514285714,29.4,20.6,0.0
+462,sj,1999,11,1999-03-19,-0.10475,0.0402,0.2573714,0.2754429,5.5,297.5428571,297.8,292.7642857,300.0,295.8,5.5,74.80428571,5.5,14.24428571,3.0,24.88571429,7.342857143,31.1,20.6,8.4
+463,sj,1999,12,1999-03-26,0.135,0.03233333,0.1988,0.1830571,5.24,298.2228571,298.45,293.23,300.5,296.3,3.1,73.94,5.24,14.67142857,2.842857143,25.67142857,7.671428571,30.6,21.1,0.0
+464,sj,1999,13,1999-04-02,0.0541,-0.0981,0.1572667,0.1370571,15.91,298.3085714,298.4142857,294.3771429,300.4,296.1,8.9,78.91,15.91,15.73285714,2.314285714,25.74285714,6.9,30.6,21.7,7.9
+465,sj,1999,14,1999-04-09,,0.00075,0.2009429,0.2108429,18.76,297.9757143,298.0928571,293.2728571,300.1,295.7,16.2,75.38857143,18.76,14.74571429,2.585714286,25.61428571,6.028571429,29.4,21.1,30.8
+466,sj,1999,15,1999-04-16,0.0341,0.0351,0.1027857,0.09751429,75.59,297.4814286,297.6428571,292.4057143,301.0,295.2,12.76,73.64142857,75.59,13.97428571,3.6,25.38571429,6.671428571,30.0,21.1,19.8
+467,sj,1999,16,1999-04-23,0.0869,0.03965,0.1907857,0.1153857,0.0,299.2542857,299.4571429,294.5242857,301.4,296.7,2.0,75.39,0.0,15.86857143,3.2,26.91428571,7.485714286,32.2,22.8,9.2
+468,sj,1999,17,1999-04-30,0.07295,0.02765,0.1945833,0.1375,10.2,299.0357143,299.15,294.2014286,301.0,297.2,5.35,74.79857143,10.2,15.56142857,2.728571429,26.68571429,7.385714286,31.7,22.2,4.1
+469,sj,1999,18,1999-05-07,0.064,0.04806667,0.1721429,0.1899429,88.2,299.4314286,299.5,295.4157143,301.8,298.0,13.3,78.68285714,88.2,16.79571429,2.085714286,28.22857143,9.214285714,33.9,22.2,0.5
+470,sj,1999,19,1999-05-14,,0.0578,0.0804,0.08112,46.5,299.0985714,299.1214286,294.5728571,301.0,297.2,14.28,76.30857143,46.5,15.96714286,2.585714286,26.95714286,7.628571429,32.8,21.7,73.1
+471,sj,1999,20,1999-05-21,,0.09066667,0.1944714,0.1691571,33.82,299.7757143,299.9357143,295.2685714,302.6,297.0,22.1,76.59857143,33.82,16.65142857,3.185714286,27.82857143,7.328571429,33.3,23.3,14.3
+472,sj,1999,21,1999-05-28,,0.0738,0.1826429,0.1713286,15.26,300.0528571,300.1642857,296.2142857,302.4,298.6,18.64,79.71714286,15.26,17.63857143,2.214285714,28.38571429,6.742857143,33.3,24.4,8.2
+473,sj,1999,22,1999-06-04,0.04023333,-0.0127,0.1208833,0.09056667,2.16,300.5871429,300.6714286,296.2357143,302.7,298.4,6.6,77.37142857,2.16,17.64428571,3.257142857,28.41428571,6.571428571,33.3,23.9,5.9
+474,sj,1999,23,1999-06-11,0.0499,0.0499,0.07223333,0.08013333,100.35,300.0257143,299.9785714,296.43,302.0,298.3,24.8,80.75428571,100.35,17.85428571,2.5,27.91428571,7.557142857,33.9,22.8,56.8
+475,sj,1999,24,1999-06-18,,0.06756667,0.1184833,0.09545,115.14,300.3514286,300.3785714,296.54,302.3,298.7,30.1,79.75,115.14,17.98285714,2.385714286,27.7,6.842857143,31.7,23.9,17.6
+476,sj,1999,25,1999-06-25,,0.01375,0.0755,0.13685,96.93,299.3671429,299.3142857,296.4157143,301.6,297.9,81.61,83.96142857,96.93,17.84428571,1.942857143,27.21428571,5.885714286,31.1,22.8,60.6
+477,sj,1999,26,1999-07-02,,0.063,0.1645714,0.1307143,17.32,300.1485714,300.2571429,296.6228571,302.4,298.3,25.74,81.25,17.32,18.05142857,2.342857143,28.44285714,5.328571429,31.7,25.0,5.4
+478,sj,1999,27,1999-07-09,0.09746667,0.08616667,0.1838571,0.1788857,73.3,299.5042857,299.5357143,295.92,301.4,297.8,55.1,80.79857143,73.3,17.29571429,2.357142857,27.4,5.728571429,31.1,22.8,36.6
+479,sj,1999,28,1999-07-16,0.0545,0.067425,0.1345667,0.09766,29.53,299.79,299.8357143,296.3942857,302.4,297.5,58.2,81.84714286,29.53,17.80428571,2.5,27.27142857,6.671428571,32.8,23.3,17.5
+480,sj,1999,29,1999-07-23,0.1169,0.0494,0.2071143,0.1935286,96.36,299.85,299.8571429,296.8614286,301.9,298.5,66.52,83.91857143,96.36,18.32285714,2.0,26.7,5.471428571,31.1,21.7,56.2
+481,sj,1999,30,1999-07-30,0.0101,0.089,0.2987143,0.1783571,8.53,300.0642857,300.15,296.4742857,302.6,298.0,32.44,80.96857143,8.53,17.90285714,2.471428571,28.1,6.528571429,32.8,23.9,19.9
+482,sj,1999,31,1999-08-06,-0.07305,0.020225,0.1632429,0.1692429,22.01,300.4985714,300.4857143,297.0471429,302.8,298.8,29.35,81.67285714,22.01,18.55714286,2.428571429,28.37142857,6.271428571,32.8,22.8,18.8
+483,sj,1999,32,1999-08-13,,0.11395,0.2125714,0.1689143,44.23,299.97,300.0071429,296.7428571,302.6,298.4,61.7,82.64571429,44.23,18.21285714,1.842857143,28.08571429,6.357142857,31.7,23.9,26.7
+484,sj,1999,33,1999-08-20,0.01015,0.0687,0.1973,0.1710857,31.78,300.3271429,300.2857143,296.8571429,302.4,298.9,46.2,81.38714286,31.78,18.33285714,2.028571429,28.37142857,6.357142857,31.7,25.0,10.0
+485,sj,1999,34,1999-08-27,-0.01465,0.03655,0.1689,0.1532571,133.65,300.2271429,300.2857143,296.86,302.8,298.7,61.8,81.99857143,133.65,18.36,2.142857143,27.85714286,6.842857143,33.9,23.9,78.5
+486,sj,1999,35,1999-09-03,,-0.0331,0.2106571,0.1876,30.98,300.4585714,300.4357143,296.8957143,302.7,299.1,25.74,81.00285714,30.98,18.41,1.985714286,28.18571429,7.028571429,32.8,23.9,69.7
+487,sj,1999,36,1999-09-10,0.087,0.06035,0.0897,0.0988,66.06,300.5842857,300.6214286,296.8014286,302.8,298.8,40.7,79.96571429,66.06,18.31,2.214285714,28.3,6.042857143,31.7,25.0,32.5
+488,sj,1999,37,1999-09-17,-0.0121,0.067475,0.1585833,0.1250857,121.24,300.9614286,301.0214286,297.0842857,303.2,299.5,34.13,79.69714286,121.24,18.71,2.157142857,28.41428571,6.842857143,33.9,24.4,35.1
+489,sj,1999,38,1999-09-24,0.08305,0.06535,0.1360286,0.1046286,44.44,300.5728571,300.6214286,296.7014286,302.8,298.3,30.4,79.39,44.44,18.21428571,2.7,28.45714286,6.6,32.2,24.4,31.3
+490,sj,1999,39,1999-10-01,0.05016667,0.03946667,0.1699833,0.1612833,62.41,300.6442857,300.6357143,296.8242857,303.5,298.9,64.72,79.83714286,62.41,18.34571429,2.214285714,28.71428571,7.957142857,34.4,23.9,38.9
+491,sj,1999,40,1999-10-08,0.1322,0.01383333,0.2102286,0.1405857,52.34,300.4971429,300.6,296.6571429,302.5,298.5,22.37,79.67428571,52.34,18.12,1.942857143,28.0,6.985714286,32.8,23.3,16.2
+492,sj,1999,41,1999-10-15,-0.0864,0.12685,0.09071667,0.05796667,45.32,299.8271429,299.8357143,295.8714286,301.7,298.5,41.31,79.16,45.32,17.30428571,1.957142857,27.17142857,6.442857143,31.1,23.3,27.8
+493,sj,1999,42,1999-10-22,,-0.0368,0.036,0.037475,171.59,300.0257143,300.0142857,296.82,301.6,298.7,40.8,82.65714286,171.59,18.31571429,1.857142857,26.75714286,5.042857143,31.1,23.9,71.5
+494,sj,1999,43,1999-10-29,,0.009325,0.1754833,0.07245714,67.94,299.8042857,300.0357143,297.13,301.9,298.7,138.1,85.37714286,67.94,18.74285714,2.185714286,27.67142857,6.3,32.2,23.3,58.4
+495,sj,1999,44,1999-11-05,0.06275,0.1034,0.1734571,0.1658833,4.84,299.96,299.9428571,296.5314286,302.0,298.0,24.52,81.62857143,4.84,18.01428571,1.885714286,27.44285714,6.542857143,32.2,23.9,40.9
+496,sj,1999,45,1999-11-12,0.1235,0.095575,0.08925,0.08956667,20.03,299.3042857,299.3785714,295.8714286,301.0,298.0,53.27,81.48857143,20.03,17.29857143,2.042857143,26.88571429,5.857142857,30.6,23.9,37.1
+497,sj,1999,46,1999-11-19,-0.0454,0.0747,0.05148,0.03943333,83.66,298.9685714,299.0785714,296.33,301.3,298.0,104.51,85.40428571,83.66,17.81714286,1.814285714,26.71428571,5.8,30.6,22.8,62.1
+498,sj,1999,47,1999-11-26,0.0005,0.0712,0.1077,0.08874,224.9,298.7328571,298.8785714,296.2857143,300.8,297.1,140.2,86.40571429,224.9,17.87,1.9,26.6,4.528571429,31.7,23.3,88.9
+499,sj,1999,48,1999-12-03,0.1536,0.104775,0.1132333,0.09898571,2.11,298.7828571,299.0571429,294.7757143,301.0,296.8,8.7,78.68285714,2.11,16.20714286,3.257142857,26.1,7.471428571,30.6,21.1,13.2
+500,sj,1999,49,1999-12-10,,0.0881,0.2564667,0.2146,63.47,297.3328571,297.3,293.9742857,298.9,296.2,107.84,81.86428571,63.47,15.41571429,1.4,24.92857143,4.614285714,28.9,21.7,126.0
+501,sj,1999,50,1999-12-17,0.10558,0.078075,0.1300286,0.07642857,0.0,297.4,297.3928571,292.1614286,298.7,296.3,8.78,72.65285714,0.0,13.73,1.814285714,24.94285714,4.828571429,28.3,20.6,7.6
+502,sj,1999,51,1999-12-24,0.1088,0.12705,0.1088714,0.09908571,0.0,297.3828571,297.5142857,292.9642857,299.4,296.1,14.5,76.49714286,0.0,14.43714286,1.8,24.84285714,4.9,27.8,21.7,10.9
+503,sj,2000,52,2000-01-01,-0.1336,-0.061225,0.1682,0.08631111,40.35,298.3671429,298.3071429,293.8871429,300.3,296.4,12.34,76.31714286,40.35,15.25714286,2.642857143,25.47142857,6.557142857,29.4,21.1,7.9
+504,sj,2000,1,2000-01-08,0.20635,0.1613,0.1398833,0.09583333,81.73,298.1485714,298.1642857,294.3557143,299.9,296.5,32.3,79.60714286,81.73,15.72285714,1.9,25.12857143,5.314285714,29.4,21.7,28.6
+505,sj,2000,2,2000-01-15,0.337,0.30785,0.2466857,0.1686286,45.19,297.4414286,297.5857143,293.1914286,299.1,296.1,47.1,77.34285714,45.19,14.61285714,2.057142857,25.11428571,5.157142857,28.3,21.7,12.0
+506,sj,2000,3,2000-01-22,0.353,0.3073,0.3262714,0.2914286,0.0,296.5885714,296.4785714,290.8528571,299.0,293.2,14.7,70.45714286,0.0,12.61,1.842857143,23.61428571,4.828571429,27.2,20.0,17.7
+507,sj,2000,4,2000-01-29,0.3419,0.228,0.32975,0.38142,0.0,296.1842857,296.3642857,289.8271429,299.0,292.6,0.7,67.76571429,0.0,11.96428571,3.1,22.84285714,6.842857143,28.3,17.8,2.0
+508,sj,2000,5,2000-02-05,0.29455,0.2239,0.2389333,0.1607,0.0,297.6714286,297.8642857,292.7342857,299.8,295.8,2.02,74.06285714,0.0,14.21285714,2.242857143,25.17142857,7.442857143,30.0,20.6,14.1
+509,sj,2000,6,2000-02-12,,0.1061,0.2147429,0.1499286,24.19,297.6757143,297.9,293.27,299.9,296.3,2.6,76.50285714,24.19,14.65285714,2.114285714,24.92857143,7.128571429,30.0,20.6,3.0
+510,sj,2000,7,2000-02-19,0.1931667,0.17314,0.1632714,0.08688571,0.0,297.7457143,297.9785714,293.25,299.9,296.3,3.1,76.11714286,0.0,14.61857143,2.357142857,25.2,7.285714286,30.0,21.1,3.8
+511,sj,2000,8,2000-02-26,,0.2075,0.1507571,0.1469167,7.67,297.0885714,297.2214286,292.1742857,298.9,295.3,13.41,74.06428571,7.67,13.67,1.985714286,24.77142857,6.628571429,28.3,20.6,3.8
+512,sj,2000,9,2000-03-04,0.17025,0.1962,0.2178,0.1580429,98.45,296.5528571,296.6785714,291.9528571,298.9,294.5,14.91,75.72142857,98.45,13.58714286,2.471428571,24.52857143,6.814285714,29.4,20.0,15.0
+513,sj,2000,10,2000-03-11,0.3779,0.22,0.16348,0.1562286,11.48,296.2028571,296.3571429,289.6428571,299.1,294.4,1.1,66.73571429,11.48,11.71571429,3.028571429,24.0,8.028571429,29.4,19.4,0.0
+514,sj,2000,11,2000-03-18,0.2311,0.230875,0.1591,0.0873,25.96,296.3157143,296.45,290.9985714,298.4,294.0,3.29,72.14285714,25.96,12.73857143,2.357142857,25.07142857,5.557142857,28.9,21.1,0.8
+515,sj,2000,12,2000-03-25,0.2204,0.1969,0.2298571,0.1853,0.0,296.7442857,296.9071429,291.2257143,298.8,294.6,6.8,71.39,0.0,12.93,2.328571429,24.8,7.385714286,29.4,19.4,3.5
+516,sj,2000,13,2000-04-01,,0.1460667,0.25795,0.2118429,2.09,296.3528571,296.6071429,290.81,299.3,293.6,5.14,71.35142857,2.09,12.63714286,4.071428571,24.4,7.142857143,28.9,20.0,3.1
+517,sj,2000,14,2000-04-08,0.2050333,0.04636667,0.1806286,0.2042857,7.23,297.8171429,297.9642857,293.6328571,300.1,296.0,17.9,77.78571429,7.23,15.05857143,2.557142857,25.58571429,7.057142857,30.6,21.7,13.3
+518,sj,2000,15,2000-04-15,0.07435,0.102575,0.1650857,0.1372286,0.0,297.7528571,297.8714286,293.1871429,299.9,293.9,5.3,75.84285714,0.0,14.65,3.542857143,25.97142857,7.3,30.6,20.6,6.3
+519,sj,2000,16,2000-04-22,-0.287,0.0767,0.08985,0.07655714,0.0,297.6228571,297.7857143,292.83,299.8,296.1,14.9,74.75428571,0.0,14.27142857,2.228571429,25.8,6.714285714,29.4,20.6,18.6
+520,sj,2000,17,2000-04-29,0.1544,0.13275,0.2154143,0.1837429,82.06,298.3428571,298.5857143,294.2542857,300.6,296.3,5.0,78.24428571,82.06,15.62285714,3.2,26.92857143,8.414285714,32.2,22.2,1.3
+521,sj,2000,18,2000-05-06,0.1302,0.1127,0.1250143,0.1334571,6.13,298.6485714,298.7214286,294.1385714,300.4,297.0,3.4,76.21428571,6.13,15.48,2.442857143,27.14285714,7.8,32.2,21.7,3.6
+522,sj,2000,19,2000-05-13,,0.09815,0.1490857,0.1343857,21.53,298.32,298.4428571,294.2642857,300.4,296.6,16.35,78.33714286,21.53,15.63857143,2.771428571,26.64285714,6.914285714,30.6,22.2,7.7
+523,sj,2000,20,2000-05-20,0.0865,0.08775,0.1752833,0.1601286,68.14,298.7714286,298.9642857,294.5542857,301.0,297.0,10.06,77.71285714,68.14,15.91857143,2.642857143,26.6,7.128571429,32.2,21.1,83.3
+524,sj,2000,21,2000-05-27,0.1882,0.1144,0.1839857,0.1126714,39.45,298.7785714,299.1428571,294.8657143,301.2,297.0,13.8,79.19714286,39.45,16.23714286,2.914285714,26.81428571,6.014285714,31.1,22.8,0.3
+525,sj,2000,22,2000-06-03,0.0849,0.11876,0.20226,0.1301571,48.51,299.28,299.4,295.2271429,301.7,297.3,17.1,78.53714286,48.51,16.58714286,2.428571429,27.55714286,6.842857143,32.2,23.3,25.6
+526,sj,2000,23,2000-06-10,0.1459,0.138175,0.1687286,0.1188429,46.02,299.6242857,299.7571429,295.6671429,301.7,297.7,10.95,79.05142857,46.02,17.03428571,2.457142857,27.85714286,6.442857143,31.7,23.3,4.8
+527,sj,2000,24,2000-06-17,0.1097,0.0902,0.2046833,0.1521833,46.38,299.7857143,299.8642857,295.1357143,301.9,297.9,21.3,75.74857143,46.38,16.45428571,2.357142857,27.98571429,6.442857143,32.8,23.3,26.2
+528,sj,2000,25,2000-06-24,0.1431,0.1623333,0.2898,0.2421286,45.96,299.5028571,299.5785714,295.94,301.7,297.5,30.64,80.84571429,45.96,17.28857143,2.328571429,27.42857143,5.842857143,31.1,23.9,15.6
+529,sj,2000,26,2000-07-01,0.11045,0.1341,0.1740429,0.1527333,33.94,299.6071429,299.6357143,295.3671429,301.4,297.7,19.02,77.61714286,33.94,16.70571429,2.157142857,27.77142857,6.614285714,31.7,23.3,31.5
+530,sj,2000,27,2000-07-08,0.0812,0.07275,0.1071,0.06248333,7.95,300.1185714,300.2142857,295.8714286,301.8,298.6,12.7,77.68142857,7.95,17.23857143,2.285714286,27.97142857,5.557142857,31.1,24.4,27.1
+531,sj,2000,28,2000-07-15,0.17185,0.17685,0.2847857,0.2321714,5.81,300.0257143,300.1857143,295.8757143,301.9,298.4,16.7,78.12571429,5.81,17.24571429,2.285714286,28.27142857,6.342857143,32.2,24.4,3.5
+532,sj,2000,29,2000-07-22,0.22305,0.18965,0.2902,0.2455143,9.53,300.1642857,300.3357143,296.0785714,302.6,297.9,23.18,78.60428571,9.53,17.46285714,2.9,28.52857143,6.514285714,32.8,23.3,22.7
+533,sj,2000,30,2000-07-29,0.1667,0.3276,0.2619143,0.2189714,0.0,299.9085714,300.1071429,295.9614286,301.9,298.2,19.7,79.00857143,0.0,17.33285714,2.357142857,28.32857143,6.5,32.8,23.9,7.9
+534,sj,2000,31,2000-08-05,0.13025,0.1474,0.12684,0.1106,32.67,300.0342857,300.1214286,296.4114286,302.1,298.0,33.7,80.75142857,32.67,17.84571429,2.328571429,28.21428571,6.557142857,33.3,22.8,32.7
+535,sj,2000,32,2000-08-12,0.14415,0.1204667,0.2751571,0.2257571,60.71,299.9242857,299.9714286,296.5642857,302.0,298.1,60.66,82.02142857,60.71,18.00428571,2.514285714,28.27142857,6.828571429,32.8,22.8,37.2
+536,sj,2000,33,2000-08-19,0.17645,0.1304,0.2522,0.2054571,8.62,300.5285714,300.5571429,296.6357143,302.8,298.6,27.72,79.50714286,8.62,18.06714286,2.2,28.61428571,6.442857143,32.8,23.9,26.9
+537,sj,2000,34,2000-08-26,0.2156667,0.1542333,0.1988667,0.1828714,27.4,300.4685714,300.7,296.5985714,303.2,298.5,29.66,79.55857143,27.4,18.03857143,2.828571429,28.72857143,6.6,32.8,23.9,13.7
+538,sj,2000,35,2000-09-02,,0.2435,0.2776,0.1937857,164.26,299.96,300.0928571,296.7357143,302.3,298.4,87.78,82.67571429,164.26,18.23142857,2.3,27.18571429,6.442857143,31.1,21.7,156.6
+539,sj,2000,36,2000-09-09,0.1591,0.0836,0.2533667,0.21125,26.9,300.5171429,300.5428571,296.8914286,302.8,298.0,22.0,80.67857143,26.9,18.40428571,2.714285714,27.98571429,6.271428571,31.7,23.9,16.8
+540,sj,2000,37,2000-09-16,0.0577,0.1507,0.2971857,0.2543429,30.52,300.7942857,300.8857143,296.8114286,302.7,299.1,18.79,78.94857143,30.52,18.31428571,2.285714286,28.18571429,6.985714286,33.3,22.8,9.3
+541,sj,2000,38,2000-09-23,0.1961,0.1446667,0.17028,0.20995,50.88,300.5771429,300.7785714,296.6842857,303.1,297.8,56.4,79.58428571,50.88,18.16285714,2.471428571,27.75714286,6.7,31.7,23.9,18.5
+542,sj,2000,39,2000-09-30,,0.1337,0.10358,0.1369667,42.65,299.88,299.9214286,296.5971429,301.5,298.8,42.8,82.28285714,42.65,18.08571429,1.728571429,27.52857143,6.042857143,31.1,23.9,30.6
+543,sj,2000,40,2000-10-07,0.253975,0.16295,0.3692714,0.2687429,126.67,300.2028571,300.2714286,296.9742857,302.1,298.8,35.3,82.58571429,126.67,18.49142857,2.371428571,27.77142857,5.885714286,32.8,23.9,16.1
+544,sj,2000,41,2000-10-14,0.38,0.26065,0.3931286,0.27105,8.57,300.2714286,300.2357143,295.7371429,302.7,298.1,15.4,76.37142857,8.57,17.13142857,3.414285714,27.8,7.385714286,32.8,23.3,20.1
+545,sj,2000,42,2000-10-21,0.10035,0.0895,0.2096857,0.08204286,37.34,300.4185714,300.4214286,296.2671429,302.6,298.3,11.22,78.18142857,37.34,17.70428571,3.785714286,28.05714286,7.185714286,33.3,23.9,21.8
+546,sj,2000,43,2000-10-28,0.1535,0.2298,0.14888,0.091525,62.57,300.0185714,299.9714286,295.7257143,302.6,298.0,15.3,77.44285714,62.57,17.11714286,3.457142857,27.14285714,6.528571429,31.1,23.3,24.1
+547,sj,2000,44,2000-11-04,0.19015,0.168,0.1864333,0.1104333,80.61,300.2614286,300.2357143,296.5,302.4,298.4,20.3,80.00714286,80.61,17.99428571,2.9,27.54285714,6.371428571,32.2,23.3,18.8
+548,sj,2000,45,2000-11-11,0.1105667,0.0267,0.1561,0.04188571,77.9,299.0614286,299.0857143,293.6385714,301.9,295.9,28.8,72.68428571,77.9,15.25857143,3.628571429,25.87142857,6.414285714,30.6,21.7,44.9
+549,sj,2000,46,2000-11-18,0.0979,0.012,0.1572,0.06461429,6.3,299.1871429,299.2071429,293.4485714,301.7,295.9,2.1,70.97714286,6.3,14.99142857,4.1,26.32857143,5.542857143,30.0,22.2,1.3
+550,sj,2000,47,2000-11-25,,0.0323,0.2099,0.09903333,0.0,299.92,299.8571429,294.66,301.6,297.5,7.18,72.92571429,0.0,16.03714286,2.714285714,26.87142857,6.785714286,30.6,22.8,14.7
+551,sj,2000,48,2000-12-02,0.12015,0.13648,0.1959,0.1356667,11.07,299.6185714,299.6357143,295.3885714,301.2,298.0,24.8,77.64857143,11.07,16.75428571,2.357142857,26.3,6.0,29.4,22.8,30.0
+552,sj,2000,49,2000-12-09,0.11875,0.0806,0.1176333,0.04611667,19.69,299.7028571,299.7285714,295.4028571,301.5,297.9,6.8,77.35714286,19.69,16.77142857,2.057142857,26.81428571,6.371428571,31.1,22.8,6.4
+553,sj,2000,50,2000-12-16,0.0044,0.08713333,0.1021,-0.02248571,0.0,299.27,299.3785714,293.8814286,301.3,297.5,3.99,72.26142857,0.0,15.25285714,2.528571429,25.91428571,7.214285714,31.1,21.7,7.1
+554,sj,2000,51,2000-12-23,0.0632,0.04675,0.0446,-0.06345714,0.0,298.5814286,298.5857143,294.1328571,300.4,296.7,37.39,76.52571429,0.0,15.46285714,1.714285714,25.38571429,5.542857143,28.9,21.7,63.2
+555,sj,2001,1,2001-01-01,0.004833333,0.006633333,0.2108143,0.2024143,0.0,298.4771429,298.4428571,294.0342857,301.2,295.6,1.3,76.50571429,0.0,15.44428571,3.285714286,25.12857143,7.685714286,30.0,20.6,1.9
+556,sj,2001,2,2001-01-08,0.09436667,0.0958,0.2041,0.1646833,49.81,298.6185714,298.7857143,293.6871429,300.9,296.3,1.0,74.33571429,49.81,15.07857143,3.314285714,25.31428571,7.585714286,30.6,21.1,15.2
+557,sj,2001,3,2001-01-15,,0.02165,0.18585,0.1796857,0.0,297.8285714,297.9928571,292.4057143,300.7,295.5,1.1,71.94142857,0.0,13.92142857,3.414285714,25.07142857,8.157142857,30.6,19.4,4.8
+558,sj,2001,4,2001-01-22,0.0411,0.0514,0.2184714,0.2287714,0.0,298.0171429,298.2,293.3585714,299.9,296.6,10.24,75.38,0.0,14.73285714,2.142857143,24.95714286,6.871428571,29.4,20.6,31.5
+559,sj,2001,5,2001-01-29,0.00915,0.041225,0.2434714,0.2032571,23.78,297.9728571,298.1571429,294.0528571,300.7,295.5,32.36,79.03142857,23.78,15.37857143,2.742857143,25.24285714,6.814285714,30.6,21.1,21.6
+560,sj,2001,6,2001-02-05,,-0.0056,0.1645,0.1619714,10.73,297.8771429,297.9857143,292.9814286,299.7,296.1,11.2,74.34428571,10.73,14.40857143,2.114285714,25.0,6.828571429,29.4,21.1,8.5
+561,sj,2001,7,2001-02-12,-0.04485,0.0056,0.1603,0.1674286,0.0,297.9342857,298.1571429,293.3771429,299.9,296.3,22.28,75.85142857,0.0,14.75428571,2.342857143,25.34285714,6.885714286,29.4,21.1,4.8
+562,sj,2001,8,2001-02-19,0.2170333,0.1452333,0.2280714,0.2104571,0.0,297.8171429,298.0428571,292.6685714,299.7,296.7,3.02,73.07285714,0.0,14.09857143,2.142857143,24.75714286,7.0,28.9,19.4,17.6
+563,sj,2001,9,2001-02-26,0.4462667,0.3123,0.3375,0.2732833,0.0,297.1528571,297.2357143,292.8157143,299.0,295.5,25.89,76.90714286,0.0,14.26571429,2.014285714,24.81428571,5.242857143,28.3,21.7,53.1
+564,sj,2001,10,2001-03-05,0.2485,0.25445,0.2764286,0.2567143,6.84,297.1342857,297.3571429,292.0557143,300.7,294.4,0.5,73.38714286,6.84,13.67142857,3.142857143,24.7,7.457142857,31.7,19.4,0.0
+565,sj,2001,11,2001-03-12,0.4229,0.4229,0.1950143,0.1967143,0.0,298.5585714,298.8857143,294.0271429,301.3,295.9,10.5,76.24714286,0.0,15.38714286,3.628571429,26.7,6.914285714,31.7,22.2,0.5
+566,sj,2001,12,2001-03-19,0.1274333,0.059925,0.1592286,0.1408857,0.0,298.3728571,298.5928571,293.0457143,300.3,296.8,1.69,72.44285714,0.0,14.48285714,2.442857143,26.32857143,7.528571429,30.6,21.7,12.7
+567,sj,2001,13,2001-03-26,,0.2705,0.2435714,0.2178143,6.11,297.6928571,297.8785714,294.1671429,300.5,295.8,21.55,80.83571429,6.11,15.55571429,2.1,26.04285714,6.514285714,32.2,21.7,26.7
+568,sj,2001,14,2001-04-02,0.2127,0.1044,0.1409,0.1628857,0.0,298.8714286,299.0928571,293.9828571,301.0,297.2,3.45,74.43,0.0,15.33571429,2.671428571,27.08571429,8.128571429,32.2,22.2,0.5
+569,sj,2001,15,2001-04-09,,0.30695,0.31445,0.2761833,5.2,298.1128571,298.2571429,293.7857143,299.8,296.3,23.5,77.02285714,5.2,15.15285714,2.371428571,26.27142857,7.085714286,30.6,21.7,13.0
+570,sj,2001,16,2001-04-16,0.0728,0.07826667,0.2111714,0.2161286,11.84,298.2671429,298.4071429,292.9828571,301.2,295.5,3.59,72.64,11.84,14.41714286,3.814285714,26.7,7.214285714,32.2,22.2,8.1
+571,sj,2001,17,2001-04-23,,0.05855,0.1227286,0.1131857,35.69,298.7514286,298.8357143,294.2814286,301.3,296.7,22.36,76.58142857,35.69,15.63,3.128571429,27.2,7.771428571,33.3,22.8,20.6
+572,sj,2001,18,2001-04-30,,-0.1055,0.1861714,0.1770571,19.98,298.2871429,298.3,293.68,300.5,296.0,9.03,75.71428571,19.98,15.06142857,2.6,26.75714286,7.157142857,31.1,22.2,16.0
+573,sj,2001,19,2001-05-07,0.0371,0.0705,0.04781429,0.06374286,59.89,299.4185714,299.5,295.3657143,302.0,297.4,16.8,78.56714286,59.89,16.77142857,3.2,27.48571429,7.057142857,32.2,22.8,64.3
+574,sj,2001,20,2001-05-14,0.1031,0.0941,0.1984833,0.1765571,77.36,299.1342857,299.2571429,295.8557143,301.7,297.3,78.1,82.35,77.36,17.26857143,2.942857143,27.85714286,6.042857143,32.2,24.4,60.5
+575,sj,2001,21,2001-05-21,0.08608,0.07736,0.1701429,0.1679429,35.54,299.9514286,299.9857143,295.3457143,302.2,297.6,2.0,76.07,35.54,16.73,3.828571429,28.82857143,8.328571429,33.9,23.3,7.4
+576,sj,2001,22,2001-05-28,0.0619,0.0333,0.1977333,0.1659857,10.8,299.7814286,299.8428571,295.6414286,302.0,298.0,8.1,78.15142857,10.8,16.99571429,3.085714286,28.47142857,6.585714286,32.8,25.0,16.6
+577,sj,2001,23,2001-06-04,0.0312,0.02535,0.1706286,0.1901,61.33,299.9442857,299.85,295.5685714,302.2,297.6,5.85,77.16285714,61.33,16.92285714,3.642857143,28.07142857,7.228571429,32.8,23.9,6.7
+578,sj,2001,24,2001-06-11,,0.0271,0.2708714,0.2212,21.93,300.4242857,300.4,295.8885714,302.6,298.2,7.0,76.42571429,21.93,17.25,3.114285714,28.51428571,6.742857143,33.9,23.9,20.9
+579,sj,2001,25,2001-06-18,-0.02865,-0.01266667,0.1246571,0.1255571,63.35,299.9185714,299.8642857,295.2071429,302.0,297.4,7.02,75.46142857,63.35,16.56285714,3.242857143,27.72857143,6.928571429,31.7,23.9,2.3
+580,sj,2001,26,2001-06-25,0.02185,-0.0601,0.2032571,0.1855857,37.72,300.54,300.4928571,296.2485714,302.9,298.5,13.37,77.61714286,37.72,17.63571429,3.128571429,28.62857143,6.757142857,33.3,23.9,11.1
+581,sj,2001,27,2001-07-02,-0.0227,0.09093333,0.2069143,0.1882286,85.42,300.2071429,300.2785714,296.3542857,302.5,298.1,28.1,79.57857143,85.42,17.74571429,2.757142857,28.22857143,6.757142857,32.8,24.4,16.8
+582,sj,2001,28,2001-07-09,-0.0817,0.0287,0.1961143,0.1808,21.89,300.6428571,300.6642857,296.3485714,302.4,298.2,13.5,77.58285714,21.89,17.74428571,2.728571429,28.34285714,6.428571429,31.7,23.9,20.0
+583,sj,2001,29,2001-07-16,0.0073,0.06943333,0.2002286,0.1976857,49.38,300.3714286,300.3714286,296.0857143,303.1,298.1,18.3,77.58714286,49.38,17.47428571,3.114285714,28.11428571,7.542857143,32.8,22.8,10.6
+584,sj,2001,30,2001-07-23,-0.0198,0.0057,0.1865714,0.1818,35.85,300.5557143,300.5571429,296.3571429,303.0,298.6,21.24,78.06142857,35.85,17.77142857,3.257142857,28.58571429,7.142857143,33.9,23.9,4.5
+585,sj,2001,31,2001-07-30,0.0287,0.1132,0.1347143,0.1439429,73.2,300.3985714,300.4571429,296.3642857,302.7,298.6,50.34,78.67,73.2,17.75857143,2.657142857,28.05714286,6.914285714,32.2,23.3,46.0
+586,sj,2001,32,2001-08-06,0.2467,0.2009,0.1926714,0.1882286,40.4,300.7128571,300.7142857,296.9,302.6,299.2,32.62,79.71285714,40.4,18.33142857,2.542857143,27.92857143,6.357142857,32.2,23.9,49.0
+587,sj,2001,33,2001-08-13,0.08985,0.1278333,0.2008143,0.2051143,29.0,300.7428571,300.8571429,297.38,302.9,298.8,50.46,82.08714286,29.0,18.89285714,2.6,28.64285714,5.585714286,32.2,25.6,24.3
+588,sj,2001,34,2001-08-20,0.0172,0.01255,0.2017286,0.2022143,40.3,300.7914286,300.7571429,297.2271429,302.7,298.4,62.4,81.07571429,40.3,18.75285714,2.542857143,28.97142857,5.785714286,32.8,25.6,1.8
+589,sj,2001,35,2001-08-27,,,0.2212714,0.2011286,132.53,300.76,300.7428571,296.4,303.1,298.7,44.3,77.34714286,132.53,17.82428571,3.457142857,28.27142857,7.542857143,32.8,23.3,65.0
+590,sj,2001,36,2001-09-03,-0.0273,0.068075,0.2792857,0.2707857,68.85,300.7514286,300.7714286,296.73,303.2,298.9,23.4,78.82714286,68.85,18.18571429,3.057142857,27.9,7.057142857,32.2,23.3,71.5
+591,sj,2001,37,2001-09-10,0.1954,0.2356,0.3660714,0.3778571,9.73,300.8057143,300.8571429,296.4528571,303.3,297.9,14.7,77.41,9.73,17.90285714,3.485714286,28.37142857,6.757142857,32.2,23.9,5.6
+592,sj,2001,38,2001-09-17,-0.0412,0.04766667,0.1706333,0.1342857,10.01,301.07,301.0928571,296.7,303.4,298.8,12.9,77.23571429,10.01,18.17571429,3.214285714,28.08571429,7.157142857,33.3,23.9,56.8
+593,sj,2001,39,2001-09-24,0.0986,0.122075,0.2545714,0.2469286,84.76,300.7385714,300.7857143,296.4371429,303.1,298.7,19.69,77.55571429,84.76,17.90142857,3.171428571,27.97142857,6.928571429,32.8,23.9,15.8
+594,sj,2001,40,2001-10-01,0.16025,0.08955,0.2391714,0.1799714,20.8,301.2557143,301.2785714,296.9571429,303.8,299.1,16.4,77.63,20.8,18.47571429,3.271428571,29.22857143,7.842857143,34.4,24.4,6.6
+595,sj,2001,41,2001-10-08,0.0633,0.0633,0.2143286,0.2125857,27.82,300.93,300.8,296.9171429,302.6,299.0,42.3,78.89142857,27.82,18.39714286,2.371428571,28.4,6.814285714,33.3,23.9,32.0
+596,sj,2001,42,2001-10-15,,,0.2187571,0.163,91.83,300.3257143,300.3,296.3971429,302.4,297.8,53.0,79.27,91.83,17.87714286,2.885714286,26.85714286,6.757142857,32.2,22.8,67.6
+597,sj,2001,43,2001-10-22,-0.0141,0.2121,0.2529,0.2228286,39.7,300.2585714,300.3,296.53,302.2,298.4,25.68,80.13142857,39.7,18.01142857,2.742857143,27.91428571,6.585714286,32.2,22.8,15.0
+598,sj,2001,44,2001-10-29,-0.01935,0.05955,0.2274571,0.1600286,0.49,300.3914286,300.4214286,296.6871429,302.1,298.2,21.91,80.27,0.49,18.15571429,2.471428571,27.94285714,6.357142857,31.1,24.4,11.3
+599,sj,2001,45,2001-11-05,0.0284,0.0086,0.09473333,0.09162857,28.03,300.0628571,300.1428571,295.3242857,302.3,297.6,17.86,75.42428571,28.03,16.75142857,3.6,26.72857143,7.714285714,32.2,20.0,36.7
+600,sj,2001,46,2001-11-12,0.0941,0.1127,0.1961714,0.2132,287.55,299.42,299.4357143,295.8757143,303.3,297.2,133.93,81.08142857,287.55,17.30857143,2.242857143,26.58571429,5.557142857,33.3,22.2,96.0
+601,sj,2001,47,2001-11-19,0.1663,0.189975,0.2202286,0.2337,45.8,299.3457143,299.7285714,295.56,302.5,297.3,18.9,79.86142857,45.8,16.97285714,3.8,26.52857143,6.1,31.1,22.8,2.9
+602,sj,2001,48,2001-11-26,0.21515,0.22615,0.2206286,0.1987,9.43,298.91,298.9642857,293.9514286,302.3,296.7,7.81,74.34428571,9.43,15.41428571,3.385714286,26.34285714,5.457142857,29.4,22.8,4.4
+603,sj,2001,49,2001-12-03,-0.0468,-0.0406,0.09694286,0.0865,43.91,298.2457143,298.2571429,293.2357143,300.8,295.1,13.2,74.03857143,43.91,14.77142857,3.485714286,25.28571429,7.2,31.1,20.6,44.0
+604,sj,2001,50,2001-12-10,0.0081,0.097475,0.2047143,0.1787714,31.01,299.0571429,299.05,295.7585714,300.7,297.5,33.78,82.16714286,31.01,17.19142857,2.214285714,26.31428571,5.7,29.4,22.8,87.8
+605,sj,2001,51,2001-12-17,0.02285,0.05653333,0.0712,0.05045714,91.66,298.4314286,298.35,295.5114286,300.0,296.8,100.6,84.01,91.66,16.92,1.985714286,25.6,4.614285714,29.4,22.8,80.3
+606,sj,2001,52,2001-12-24,0.1814,0.1358667,0.2236222,0.1965111,72.18,298.4271429,298.5,295.7971429,301.0,296.8,35.2,85.51428571,72.18,17.23428571,1.828571429,25.67142857,4.671428571,30.0,22.8,106.2
+607,sj,2002,1,2002-01-01,0.05475,0.08103333,0.1975429,0.1423286,0.0,298.9557143,299.1,294.4814286,300.5,297.1,2.5,76.43428571,0.0,15.81,2.514285714,25.52857143,7.6,30.0,20.6,24.9
+608,sj,2002,2,2002-01-08,0.106425,0.29,0.2464333,0.1778167,0.0,298.4528571,298.5071429,294.8414286,301.0,296.8,13.8,80.57285714,0.0,16.17857143,2.785714286,25.45714286,6.385714286,29.4,21.7,13.7
+609,sj,2002,3,2002-01-15,0.0594,0.0526,0.1956714,0.1562857,0.0,298.5514286,298.5571429,294.1457143,300.6,296.2,1.21,76.73428571,0.0,15.51857143,3.2,25.32857143,7.042857143,29.4,21.1,2.9
+610,sj,2002,4,2002-01-22,0.0288,0.06663333,0.1341,0.1462286,0.0,298.3157143,298.5142857,294.2128571,299.9,297.1,12.44,78.07857143,0.0,15.55142857,1.942857143,26.21428571,6.4,30.6,22.2,19.1
+611,sj,2002,5,2002-01-29,,,,,0.0,298.2,298.35,293.8471429,300.1,296.3,10.8,76.92,0.0,15.18714286,2.185714286,25.65714286,5.771428571,29.4,21.7,38.1
+612,sj,2002,6,2002-02-05,-0.0674,0.0468,0.1591714,0.1097286,0.0,297.7228571,297.8142857,293.3442857,299.6,296.3,24.0,76.72285714,0.0,14.73428571,2.2,24.97142857,6.414285714,28.9,20.6,21.1
+613,sj,2002,7,2002-02-12,0.0491,0.092325,0.2546714,0.1978,0.0,297.9885714,298.0642857,293.3657143,299.7,295.6,3.6,75.57714286,0.0,14.75428571,2.557142857,25.41428571,5.942857143,29.4,20.6,4.3
+614,sj,2002,8,2002-02-19,0.0478,0.06175,0.222,0.1773143,0.0,298.1014286,298.2428571,293.5457143,300.6,296.1,3.9,75.93285714,0.0,14.93142857,3.142857143,25.78571429,7.928571429,31.7,21.1,6.4
+615,sj,2002,9,2002-02-26,0.0315,0.0962,0.1402,0.1603429,0.0,297.1657143,297.2357143,292.0,300.5,294.9,12.8,73.14714286,0.0,13.59285714,3.071428571,25.2,6.342857143,30.0,21.1,3.3
+616,sj,2002,10,2002-03-05,0.042,0.0511,0.1984167,0.2499833,0.0,297.09,297.1142857,292.2528571,299.4,294.0,7.8,74.42714286,0.0,13.78142857,2.771428571,25.45714286,5.628571429,28.9,20.6,0.6
+617,sj,2002,11,2002-03-12,0.0709,0.12545,0.2196286,0.1894857,40.27,297.5928571,297.7285714,293.0814286,299.2,296.3,11.8,76.16857143,40.27,14.53,2.2,25.84285714,6.314285714,30.0,22.2,14.1
+618,sj,2002,12,2002-03-19,0.1535,0.1688,0.2791,0.2480857,0.0,297.9857143,298.0785714,293.2171429,299.8,295.6,0.6,74.91714286,0.0,14.62857143,3.071428571,25.78571429,6.957142857,30.0,20.6,6.5
+619,sj,2002,13,2002-03-26,0.1777,0.3167,0.3203857,0.3209286,0.0,298.2757143,298.4785714,293.5428571,300.8,296.3,2.2,75.21571429,0.0,14.97,3.1,26.75714286,7.214285714,32.8,22.2,0.6
+620,sj,2002,14,2002-04-02,-0.0056,0.0013,0.2157714,0.1786,49.74,298.08,298.3285714,294.0542857,301.6,295.9,17.8,78.56571429,49.74,15.46857143,3.571428571,26.22857143,7.071428571,30.6,21.7,7.7
+621,sj,2002,15,2002-04-09,-0.0263,0.03695,0.1263571,0.1143571,50.67,298.3228571,298.4428571,294.8314286,300.8,296.2,55.1,81.14142857,50.67,16.20857143,2.685714286,27.11428571,6.657142857,32.2,22.8,15.7
+622,sj,2002,16,2002-04-16,,,0.2039714,0.1771857,0.0,297.0442857,297.0285714,292.0614286,299.5,294.8,22.4,73.84,0.0,13.63857143,2.657142857,25.45714286,5.714285714,30.0,21.7,17.8
+623,sj,2002,17,2002-04-23,-0.0176,0.0519,0.1135714,0.1116286,214.76,297.97,298.0714286,295.01,300.8,296.4,31.0,83.65714286,214.76,16.36857143,2.514285714,25.7,6.185714286,30.6,21.7,69.7
+624,sj,2002,18,2002-04-30,0.1506,0.1616,0.2115857,0.1536571,74.01,298.5371429,298.4785714,295.1614286,300.3,296.7,18.0,81.70285714,74.01,16.53571429,2.814285714,26.45714286,6.014285714,30.0,22.8,10.5
+625,sj,2002,19,2002-05-07,0.19375,0.1611,0.211,0.1759143,87.81,298.9642857,299.0928571,294.95,300.5,297.2,11.0,78.60714286,87.81,16.30857143,2.5,26.44285714,6.014285714,30.0,22.8,56.5
+626,sj,2002,20,2002-05-14,0.1138,0.09725,0.2559286,0.2269286,0.0,298.9942857,299.1142857,294.4414286,300.6,297.2,9.3,76.08714286,0.0,15.78857143,2.4,26.14285714,6.642857143,30.0,21.7,15.4
+627,sj,2002,21,2002-05-21,0.03345,0.1033,0.2122857,0.2002714,41.09,299.6671429,299.85,295.2742857,301.3,298.2,5.5,76.90142857,41.09,16.62714286,2.471428571,27.71428571,6.528571429,31.7,23.3,2.9
+628,sj,2002,22,2002-05-28,0.05325,0.0778,0.1880286,0.1696,3.99,299.7528571,299.9,295.38,302.4,297.7,8.2,77.09285714,3.99,16.75714286,2.571428571,28.17142857,7.328571429,32.8,23.3,4.8
+629,sj,2002,23,2002-06-04,0.04185,0.0722,0.1304429,0.1511429,65.82,299.6014286,299.6642857,296.2157143,302.1,297.5,15.65,81.85142857,65.82,17.65857143,2.871428571,28.44285714,7.371428571,33.3,23.3,12.9
+630,sj,2002,24,2002-06-11,,0.05743333,0.1073143,0.1113286,84.35,299.8871429,299.9642857,296.3385714,302.2,297.8,17.55,81.04285714,84.35,17.76714286,3.185714286,28.45714286,6.742857143,33.3,24.4,4.5
+631,sj,2002,25,2002-06-18,,0.04446667,0.2042143,0.1528143,0.0,300.2214286,300.2071429,296.3971429,302.2,298.4,15.73,79.73,0.0,17.80142857,2.785714286,28.52857143,7.228571429,32.8,24.4,12.7
+632,sj,2002,26,2002-06-25,,0.1173,0.2136,0.1969143,5.94,299.8557143,299.95,295.99,301.8,298.0,24.1,79.50857143,5.94,17.35714286,2.471428571,27.58571429,6.942857143,31.7,22.8,25.0
+633,sj,2002,27,2002-07-02,-0.009666667,0.0065,0.2072429,0.1649286,2.3,300.4114286,300.55,296.0628571,302.4,298.4,10.8,77.19857143,2.3,17.39857143,2.328571429,28.34285714,6.2,31.7,25.0,3.6
+634,sj,2002,28,2002-07-09,-0.02455,0.0196,0.2541286,0.2121,22.49,300.0842857,300.1285714,296.0657143,301.8,298.2,11.65,78.74714286,22.49,17.43285714,2.457142857,28.15714286,6.914285714,32.2,23.3,29.6
+635,sj,2002,29,2002-07-16,,0.03774,0.1880429,0.1803286,58.06,300.54,300.5857143,296.42,302.4,298.6,10.3,78.31142857,58.06,17.80857143,2.971428571,28.28571429,6.842857143,32.8,23.9,57.2
+636,sj,2002,30,2002-07-23,-0.07045,-0.02133333,0.2192857,0.2245429,1.07,300.5471429,300.6785714,295.9128571,302.5,298.8,7.09,75.86714286,1.07,17.26,2.614285714,28.22857143,6.9,32.8,23.3,16.3
+637,sj,2002,31,2002-07-30,-0.0836,0.0278,0.1435833,0.1011714,44.7,300.4314286,300.5285714,296.9871429,303.0,298.7,47.12,81.62285714,44.7,18.44714286,2.571428571,28.48571429,5.971428571,32.8,24.4,28.0
+638,sj,2002,32,2002-08-06,-0.0006,0.0551,0.2511429,0.2696571,39.52,301.0028571,301.2,296.7428571,303.3,298.0,9.36,77.78857143,39.52,18.20142857,3.514285714,28.47142857,6.1,32.2,25.0,3.6
+639,sj,2002,33,2002-08-13,0.0001,0.03865,0.1990571,0.1385286,33.21,300.8928571,300.9857143,296.8971429,303.0,299.2,23.78,78.94428571,33.21,18.36428571,2.8,28.74285714,7.614285714,33.3,23.9,13.6
+640,sj,2002,34,2002-08-20,0.0776,-0.0772,0.2146333,0.1704,22.89,300.7742857,300.8357143,296.8,302.9,298.8,39.62,79.09428571,22.89,18.24571429,2.442857143,28.0,6.814285714,32.8,23.3,48.1
+641,sj,2002,35,2002-08-27,0.0009,-0.00445,0.1957857,0.1185286,18.67,301.1371429,301.2571429,296.5414286,302.9,299.3,15.0,76.18857143,18.67,17.97285714,2.771428571,28.64285714,6.428571429,32.2,24.4,13.5
+642,sj,2002,36,2002-09-03,0.0895,0.0648,0.1647667,0.1637571,109.38,300.6957143,300.7928571,296.6042857,302.8,299.0,46.4,78.60714286,109.38,18.09857143,2.3,27.5,6.442857143,31.7,22.8,105.0
+643,sj,2002,37,2002-09-10,0.033,-0.02545,0.2319714,0.2399571,7.92,301.2228571,301.4071429,296.7228571,303.7,299.1,10.9,76.67857143,7.92,18.19142857,3.357142857,29.15714286,7.685714286,34.4,24.4,2.3
+644,sj,2002,38,2002-09-17,,0.01655,0.1659286,0.1409857,57.98,301.2385714,301.2285714,297.1242857,303.1,299.4,27.5,78.48857143,57.98,18.65142857,2.6,28.65714286,7.3,33.3,23.3,53.2
+645,sj,2002,39,2002-09-24,0.0541,0.03885,0.1283571,0.08348571,26.31,300.9871429,301.1071429,296.7328571,303.1,298.5,13.4,77.85142857,26.31,18.24428571,3.242857143,28.2,7.571428571,32.8,23.9,48.0
+646,sj,2002,40,2002-10-01,0.07375,0.07326667,0.0796,0.06807143,73.11,301.0614286,301.1571429,297.1285714,303.2,299.5,20.0,79.28142857,73.11,18.67428571,2.428571429,27.77142857,6.871428571,33.3,22.8,72.7
+647,sj,2002,41,2002-10-08,-0.05385,-0.0739,0.2429714,0.2187286,17.48,300.7285714,300.7071429,296.6942857,302.3,298.5,25.5,78.80857143,17.48,18.19142857,2.728571429,27.94285714,6.685714286,31.7,23.9,26.0
+648,sj,2002,42,2002-10-15,,0.03505,0.1269143,0.1894143,91.69,300.47,300.6,296.4785714,302.5,298.6,23.5,78.94857143,91.69,17.95,2.6,27.54285714,7.257142857,32.2,23.3,6.1
+649,sj,2002,43,2002-10-22,-0.1115,-0.1136,0.2304,0.2082429,9.5,300.5485714,300.5285714,296.6357143,302.3,298.8,27.0,79.21714286,9.5,18.10428571,2.485714286,27.98571429,7.171428571,33.3,23.9,53.3
+650,sj,2002,44,2002-10-29,0.00735,-0.02545,0.1993429,0.1795429,33.29,300.5185714,300.55,296.24,302.4,298.4,34.7,77.62,33.29,17.68857143,2.585714286,27.54285714,6.571428571,31.7,23.3,31.3
+651,sj,2002,45,2002-11-05,0.2614,0.11022,0.2918,0.3185,14.05,300.44,300.65,295.8528571,302.4,298.9,9.5,76.16714286,14.05,17.26571429,3.1,27.38571429,6.542857143,31.1,23.3,8.4
+652,sj,2002,46,2002-11-12,0.1478333,-0.003125,0.2781571,0.2477286,0.0,300.5457143,300.7571429,295.4471429,302.3,298.7,7.6,73.78142857,0.0,16.81857143,2.685714286,27.31428571,7.014285714,31.1,22.8,3.8
+653,sj,2002,47,2002-11-19,,-0.1225,0.2220571,0.1913857,100.94,299.9828571,299.8857143,295.9428571,302.1,298.2,32.3,78.60571429,100.94,17.33857143,2.685714286,27.21428571,6.842857143,32.2,23.3,30.8
+654,sj,2002,48,2002-11-26,-0.005633333,-0.03725,0.2773286,0.2907286,11.61,300.0485714,300.1285714,296.0928571,302.3,297.8,22.77,78.96285714,11.61,17.51,2.485714286,26.98571429,7.0,32.2,21.7,28.0
+655,sj,2002,49,2002-12-03,-0.2439,-0.1209333,0.2790857,0.2488429,0.0,300.17,300.3142857,295.2057143,302.0,298.0,5.9,74.37285714,0.0,16.57857143,2.714285714,26.42857143,7.285714286,31.1,21.7,2.9
+656,sj,2002,50,2002-12-10,-0.1743,-0.0723,0.1993,0.1713,7.32,299.8928571,299.9285714,294.9785714,301.4,298.3,7.45,74.51714286,7.32,16.32714286,1.771428571,26.07142857,6.642857143,30.0,21.7,40.6
+657,sj,2002,51,2002-12-17,-0.043,-0.12895,0.1854143,0.2088,0.0,299.3785714,299.6,294.5771429,301.2,297.7,8.3,74.94285714,0.0,15.91857143,2.371428571,25.92857143,6.971428571,30.6,21.7,18.6
+658,sj,2002,52,2002-12-24,0.0358,-0.2528,0.2434333,0.1369286,6.58,298.6385714,298.8071429,294.8057143,301.1,296.7,19.7,79.48285714,6.58,16.16,2.785714286,25.7,5.771428571,29.4,22.2,31.7
+659,sj,2003,1,2003-01-01,-0.07195,-0.04525,0.2304571,0.1757143,0.0,298.0414286,298.0857143,294.3814286,300.3,295.8,20.5,80.30857143,0.0,15.84571429,1.657142857,25.05714286,5.871428571,28.9,21.1,25.7
+660,sj,2003,2,2003-01-08,-0.2,-0.07096667,0.18055,0.1824833,0.0,298.6157143,298.7214286,294.6042857,300.7,296.8,36.6,78.67142857,0.0,15.94,2.042857143,25.45714286,6.657142857,30.0,21.1,35.3
+661,sj,2003,3,2003-01-15,0.0466,0.008225,0.2926429,0.2266286,0.0,298.8614286,299.1214286,294.2171429,301.1,296.0,2.5,75.70285714,0.0,15.58714286,3.071428571,25.72857143,7.942857143,31.1,20.6,0.0
+662,sj,2003,4,2003-01-22,0.05374,0.071375,0.1781714,0.1565714,0.0,299.0428571,299.35,294.2685714,301.0,297.4,3.6,75.01571429,0.0,15.6,2.7,25.68571429,7.442857143,30.6,21.1,2.9
+663,sj,2003,5,2003-01-29,0.0214,0.0542,0.08465,0.1010286,0.0,298.1814286,298.3571429,294.3371429,301.1,296.4,32.3,79.51714286,0.0,15.7,2.657142857,25.32857143,7.1,30.6,20.6,59.7
+664,sj,2003,6,2003-02-05,0.0567,0.0702,0.1939857,0.1746714,25.2,298.2114286,298.3214286,294.2571429,300.9,296.4,18.4,78.84142857,25.2,15.63,2.7,25.2,6.971428571,29.4,21.1,19.4
+665,sj,2003,7,2003-02-12,,-0.09663333,0.1922667,0.2225,68.17,298.37,298.4357143,294.5771429,300.3,296.3,33.6,79.72428571,68.17,15.91428571,2.328571429,25.4,6.171428571,29.4,21.7,37.1
+666,sj,2003,8,2003-02-19,0.0015,-0.03445,0.1614286,0.1584857,0.0,298.78,299.0,294.0257143,300.9,297.3,9.7,75.07714286,0.0,15.37,2.657142857,25.58571429,7.057142857,30.6,20.6,7.4
+667,sj,2003,9,2003-02-26,-0.03046667,-0.0001,0.1286333,0.1561167,0.0,298.67,298.8357143,293.8542857,300.6,296.9,7.2,74.73428571,0.0,15.19428571,2.3,25.62857143,6.742857143,30.0,21.1,8.2
+668,sj,2003,10,2003-03-05,-0.20635,-0.141,0.3221857,0.2998286,0.0,298.7357143,298.9928571,293.4757143,300.7,296.9,0.5,72.69,0.0,14.87285714,3.014285714,25.28571429,8.042857143,29.4,20.6,5.1
+669,sj,2003,11,2003-03-12,0.02535,0.0481,0.1018429,0.1365286,0.0,299.0042857,299.2714286,294.1085714,300.9,297.1,2.7,74.60857143,0.0,15.49,2.628571429,26.54285714,7.385714286,31.1,21.7,2.6
+670,sj,2003,12,2003-03-19,-0.05203333,0.01422,0.1556429,0.1822714,0.0,298.8814286,299.0571429,293.4842857,300.8,297.4,1.8,72.13571429,0.0,14.88428571,2.428571429,26.45714286,7.928571429,31.1,21.7,1.3
+671,sj,2003,13,2003-03-26,-0.1169,-0.091575,0.1527286,0.1867714,0.0,298.7528571,299.0357143,293.8014286,301.6,296.3,7.3,74.32571429,0.0,15.22142857,3.757142857,26.92857143,7.057142857,32.2,22.8,2.0
+672,sj,2003,14,2003-04-02,0.0925,-0.05085,0.1298,0.1214286,0.0,298.9,299.0428571,294.3314286,301.9,296.8,7.5,76.13428571,0.0,15.73,3.371428571,26.7,6.985714286,33.3,22.2,30.0
+673,sj,2003,15,2003-04-09,0.12815,0.09896667,0.1515,0.1395429,38.52,298.33,298.4071429,294.5428571,301.1,296.1,43.64,79.63571429,38.52,15.90142857,2.7,26.4,6.171428571,32.2,22.8,28.2
+674,sj,2003,16,2003-04-16,,-0.0029,0.07464286,0.09557143,5.96,298.7028571,298.7714286,295.0071429,301.3,296.8,23.5,80.24142857,5.96,16.38142857,2.742857143,26.42857143,6.685714286,31.7,22.8,46.5
+675,sj,2003,17,2003-04-23,-0.078,-0.1252,0.1486714,0.1594714,389.6,298.4457143,298.4214286,295.4828571,301.4,296.3,111.7,83.75142857,389.6,16.88571429,2.785714286,25.35714286,6.428571429,30.6,20.6,88.2
+676,sj,2003,18,2003-04-30,0.0681,0.0355,0.2512714,0.2120714,26.56,299.1857143,299.4,295.4471429,302.3,296.8,15.2,80.07142857,26.56,16.83285714,3.085714286,26.92857143,6.5,32.2,23.3,75.2
+677,sj,2003,19,2003-05-07,-0.0477,0.072125,0.2656833,0.2382143,16.65,300.0385714,300.2071429,295.18,302.2,298.3,1.5,74.80857143,16.65,16.51714286,3.014285714,27.64285714,7.571428571,32.8,23.3,2.5
+678,sj,2003,20,2003-05-14,0.01485,-0.0432,0.1687571,0.1725429,10.86,299.5771429,299.7285714,294.6014286,301.5,297.7,7.7,74.23,10.86,15.93,2.714285714,26.9,6.828571429,31.1,22.8,7.0
+679,sj,2003,21,2003-05-21,,0.0041,0.1526143,0.1243571,60.93,299.6342857,299.7071429,295.1842857,301.5,298.0,13.76,76.70428571,60.93,16.57285714,2.328571429,27.05714286,6.771428571,31.1,22.8,10.1
+680,sj,2003,22,2003-05-28,-0.0457,-0.007566667,0.1959143,0.1780571,111.7,299.5085714,299.6857143,296.0171429,301.8,297.0,28.3,81.29142857,111.7,17.42428571,2.4,27.75714286,6.757142857,32.2,22.8,22.9
+681,sj,2003,23,2003-06-04,,0.06276667,0.1974571,0.175,9.1,300.0914286,300.3357143,295.5557143,302.4,298.2,1.6,76.33428571,9.1,16.90142857,2.728571429,27.97142857,7.385714286,32.2,22.8,3.3
+682,sj,2003,24,2003-06-11,0.05063333,0.055875,0.10935,0.09871429,18.25,299.7528571,299.8428571,295.3971429,301.6,297.8,20.1,77.14142857,18.25,16.75857143,2.714285714,27.4,6.657142857,31.1,22.8,33.8
+683,sj,2003,25,2003-06-18,0.0675,0.0484,0.1730429,0.1369857,39.21,299.8857143,300.0142857,295.6314286,301.6,297.9,21.81,77.73142857,39.21,17.02285714,2.457142857,27.47142857,5.585714286,30.6,23.9,36.6
+684,sj,2003,26,2003-06-25,-0.1798,-0.05245,0.1182714,0.1597286,17.92,299.9114286,300.1428571,296.3528571,301.9,298.5,18.4,80.98,17.92,17.75428571,2.4,28.02857143,6.042857143,32.2,24.4,0.6
+685,sj,2003,27,2003-07-02,-0.0853,0.02575,0.2083857,0.2085571,0.0,300.3557143,300.5,296.3628571,302.0,298.4,5.8,78.92857143,0.0,17.74428571,2.542857143,28.64285714,6.1,32.8,24.4,13.0
+686,sj,2003,28,2003-07-09,,0.296,0.1916857,0.175,10.83,299.9271429,299.9571429,296.1,301.8,298.1,44.04,79.65857143,10.83,17.48714286,2.542857143,28.04285714,6.185714286,31.7,23.9,17.9
+687,sj,2003,29,2003-07-16,-0.05675,-0.1126667,0.2248714,0.1869,62.57,300.1542857,300.3428571,296.3157143,301.7,298.4,21.9,79.74428571,62.57,17.72428571,1.914285714,27.47142857,5.885714286,31.7,21.7,43.0
+688,sj,2003,30,2003-07-23,0.1045,0.0661,0.1618571,0.1561714,0.0,300.5014286,300.4857143,296.2928571,302.6,298.2,13.4,77.8,0.0,17.65857143,2.8,28.14285714,6.114285714,32.8,23.3,8.0
+689,sj,2003,31,2003-07-30,0.04995,-0.03565,0.1580333,0.192,41.92,300.13,300.3,296.8942857,301.8,298.9,46.9,82.60142857,41.92,18.33857143,1.828571429,27.87142857,5.557142857,31.7,24.4,48.9
+690,sj,2003,32,2003-08-06,0.0785,0.03633333,0.2077857,0.2106714,28.0,300.38,300.5714286,296.79,302.1,298.8,22.5,80.84,28.0,18.21571429,2.257142857,28.07142857,5.8,31.7,25.0,8.2
+691,sj,2003,33,2003-08-13,0.0348,0.0317,0.2225714,0.2039857,11.37,300.5128571,300.5785714,296.69,302.5,298.8,29.1,79.78857143,11.37,18.14571429,2.557142857,27.92857143,5.871428571,32.2,24.4,17.0
+692,sj,2003,34,2003-08-20,0.0726,0.0519,0.1617286,0.1578143,42.46,300.7742857,300.7928571,296.6114286,302.8,298.9,31.0,78.25428571,42.46,18.06142857,2.785714286,28.14285714,6.928571429,32.2,23.9,25.7
+693,sj,2003,35,2003-08-27,,0.1,0.2043714,0.1603571,98.68,300.6685714,300.7285714,297.0485714,302.8,298.7,50.86,80.79714286,98.68,18.57142857,2.542857143,27.91428571,6.457142857,31.7,23.3,69.6
+694,sj,2003,36,2003-09-03,,,0.2036286,0.2409286,86.4,300.6314286,300.75,297.4185714,302.7,298.7,63.0,82.78428571,86.4,18.96857143,2.185714286,27.68571429,6.071428571,31.7,24.4,29.8
+695,sj,2003,37,2003-09-10,0.09445,-0.01352,0.2407,0.2419286,16.81,300.9671429,301.2285714,297.1085714,303.7,299.0,12.5,79.70428571,16.81,18.63571429,3.142857143,28.72857143,6.328571429,34.4,25.0,20.9
+696,sj,2003,38,2003-09-17,-0.0939,0.086425,0.2489,0.2247429,38.7,301.1428571,301.4,296.7757143,304.3,298.8,13.9,77.36714286,38.7,18.29857143,3.457142857,28.87142857,6.485714286,34.4,25.0,2.3
+697,sj,2003,39,2003-09-24,-0.0874,0.09725,0.2545714,0.2119143,99.61,300.7914286,300.9142857,297.12,303.3,298.7,26.59,80.53,99.61,18.67857143,2.714285714,28.04285714,7.442857143,33.9,22.2,76.5
+698,sj,2003,40,2003-10-01,,0.0151,0.2174857,0.2088143,78.94,301.1942857,301.4071429,297.2671429,303.5,299.5,11.0,79.35571429,78.94,18.82428571,2.9,28.6,6.185714286,32.2,25.0,9.9
+699,sj,2003,41,2003-10-08,0.0204,0.03275,0.1634429,0.1103714,0.61,300.9328571,301.1,296.3842857,303.2,299.2,6.3,76.43571429,0.61,17.88428571,2.857142857,28.1,6.042857143,31.7,24.4,0.8
+700,sj,2003,42,2003-10-15,0.0161,0.0371,0.2434,0.2677286,118.5,300.6785714,300.8285714,296.94,302.9,298.3,97.7,80.25,118.5,18.48571429,2.514285714,27.12857143,6.685714286,32.2,22.8,61.0
+701,sj,2003,43,2003-10-22,-0.0416,0.0553,0.1699286,0.1281714,20.44,301.09,301.1571429,296.79,302.9,299.0,10.7,77.53142857,20.44,18.30142857,2.857142857,28.02857143,7.0,32.8,23.9,10.9
+702,sj,2003,44,2003-10-29,0.0892,0.00035,0.09465,0.08811429,96.7,300.9528571,301.1142857,296.6514286,303.4,298.6,17.08,77.56142857,96.7,18.15714286,2.8,27.8,6.928571429,33.3,23.9,11.0
+703,sj,2003,45,2003-11-05,,0.1635,0.1377167,0.1248,79.96,300.1628571,300.2357143,296.0,302.7,297.5,35.9,78.08,79.96,17.47,3.271428571,27.37142857,7.185714286,32.8,22.2,62.4
+704,sj,2003,46,2003-11-12,0.06925,0.055375,0.06548571,0.07488571,97.28,300.0542857,300.05,296.6657143,301.7,298.3,92.1,81.82571429,97.28,18.16,2.3,27.15714286,6.857142857,31.7,22.8,74.7
+705,sj,2003,47,2003-11-19,-0.21795,0.015,0.1281429,0.1350143,390.6,299.0728571,299.15,296.8314286,300.7,297.7,181.74,87.57571429,390.6,18.37,1.985714286,26.3,4.685714286,31.7,23.9,133.2
+706,sj,2003,48,2003-11-26,-0.07015,-0.037775,0.2369429,0.2084571,16.2,298.8142857,298.9071429,295.76,301.0,297.2,38.7,83.41,16.2,17.22714286,2.357142857,25.97142857,6.114285714,30.6,22.8,54.2
+707,sj,2003,49,2003-12-03,-0.00305,0.0534,0.1275667,0.1174857,0.0,299.1071429,299.2428571,294.8085714,300.7,297.4,10.26,77.30857143,0.0,16.20428571,1.942857143,26.18571429,5.614285714,29.4,21.7,2.1
+708,sj,2003,50,2003-12-10,-0.1476,-0.1538,0.1616833,0.1077714,182.81,299.1742857,299.1857143,295.0314286,301.5,297.5,50.6,78.23285714,182.81,16.46857143,2.142857143,25.64285714,5.014285714,29.4,22.2,82.8
+709,sj,2003,51,2003-12-17,-0.03753333,-0.0526,0.2905667,0.1977429,0.0,298.5557143,298.6071429,294.9928571,300.5,296.9,12.28,80.79714286,0.0,16.39,2.157142857,25.84285714,5.414285714,29.4,22.2,11.0
+710,sj,2003,52,2003-12-24,0.02085,-0.0398,0.1581375,0.1479444,1.96,299.0442857,299.1785714,295.0257143,300.8,297.2,9.14,78.68857143,1.96,16.37571429,2.7,26.01428571,6.5,30.0,21.1,12.0
+711,sj,2004,1,2004-01-01,-0.2683,-0.1237,0.2237571,0.1765429,,,,,,,,,,,,,,,,
+712,sj,2004,2,2004-01-08,-0.0731,0.0172,0.2147286,0.2224429,0.0,297.6485714,297.5714286,292.3742857,299.3,296.1,20.7,72.57714286,0.0,13.88142857,2.028571429,24.38571429,5.557142857,27.8,20.6,15.6
+713,sj,2004,3,2004-01-15,,0.0026,0.2821,0.2899,36.07,297.8,297.9714286,293.8957143,299.5,296.5,20.2,78.94285714,36.07,15.25714286,2.171428571,24.34285714,5.957142857,28.3,20.0,23.7
+714,sj,2004,4,2004-01-22,-0.18635,-0.178625,-0.01553333,0.01025,0.0,297.7285714,298.1071429,293.6657143,300.2,295.7,1.1,78.26428571,0.0,15.06142857,3.042857143,24.52857143,6.1,27.8,20.6,10.2
+715,sj,2004,5,2004-01-29,-0.0535,-0.108,0.2362571,0.2804143,0.0,297.56,297.6,292.8785714,300.0,295.8,2.0,75.42285714,0.0,14.39,2.457142857,24.62857143,6.2,28.9,20.0,1.8
+716,sj,2004,6,2004-02-05,,-0.0489,0.2528429,0.2169857,0.0,297.9714286,298.25,293.5371429,300.8,295.6,3.8,76.52285714,0.0,14.94142857,2.842857143,24.98571429,7.928571429,31.1,19.4,4.6
+717,sj,2004,7,2004-02-12,-0.0423,0.0231,0.2463857,0.1925571,0.0,298.3257143,298.5071429,293.5185714,299.8,297.3,3.04,74.65,0.0,14.87428571,1.985714286,24.88571429,6.728571429,28.9,20.0,15.0
+718,sj,2004,8,2004-02-19,-0.1567,-0.0768,0.1538429,0.1494,0.0,298.2885714,298.5714286,293.27,300.1,297.2,1.7,73.79142857,0.0,14.65285714,2.457142857,25.2,6.942857143,29.4,20.6,11.4
+719,sj,2004,9,2004-02-26,0.05716667,0.052025,0.139,0.1584429,0.0,297.5342857,297.9571429,293.6185714,300.6,295.8,19.92,79.02714286,0.0,15.00428571,2.628571429,24.18571429,6.728571429,28.3,19.4,19.3
+720,sj,2004,10,2004-03-04,-0.0638,0.0905,0.2206,0.2357714,0.0,297.8242857,298.0571429,293.6457143,301.2,296.0,16.2,77.76142857,0.0,15.06571429,2.685714286,25.15714286,7.214285714,31.1,20.6,15.8
+721,sj,2004,11,2004-03-11,-0.0505,0.02825,0.1867,0.1538,0.0,297.5042857,297.6285714,292.1857143,300.0,296.0,6.27,72.30571429,0.0,13.67142857,2.228571429,25.42857143,5.957142857,30.6,21.1,2.5
+722,sj,2004,12,2004-03-18,,,0.02834286,0.0116,0.0,298.2542857,298.4285714,294.2514286,300.3,296.0,13.81,78.54714286,0.0,15.59142857,2.571428571,25.91428571,6.642857143,31.1,20.6,12.2
+723,sj,2004,13,2004-03-25,-0.40625,0.07343333,0.1199,0.1322667,0.0,298.32,298.6,293.9614286,300.1,297.3,11.1,76.87142857,0.0,15.33857143,2.285714286,25.55714286,6.728571429,30.0,21.1,3.0
+724,sj,2004,14,2004-04-01,,0.023175,0.1476286,0.1583857,28.35,296.8942857,296.9214286,293.2814286,299.9,294.3,81.1,80.36571429,28.35,14.72142857,2.414285714,24.7,6.028571429,28.9,20.6,60.7
+725,sj,2004,15,2004-04-08,0.4934,0.1412,0.3543429,0.2740857,0.0,297.7585714,298.0857143,293.3228571,300.9,295.6,11.0,76.44571429,0.0,14.75571429,3.2,25.4,7.385714286,31.1,20.6,5.6
+726,sj,2004,16,2004-04-15,0.0061,0.0162,0.1967286,0.1820857,5.75,298.6942857,298.9071429,294.3328571,301.1,296.6,2.6,77.06,5.75,15.74857143,3.1,25.95714286,6.085714286,29.4,22.8,31.5
+727,sj,2004,17,2004-04-22,,-0.04705,0.2125571,0.2720286,23.59,298.66,298.8714286,293.1828571,300.7,297.2,13.8,71.95428571,23.59,14.66285714,2.571428571,25.84285714,6.185714286,29.4,21.7,5.6
+728,sj,2004,18,2004-04-29,,-0.08976667,0.0633,0.1553833,75.28,299.0642857,299.3285714,295.0485714,301.4,297.5,11.86,78.60285714,75.28,16.42,2.514285714,26.15714286,5.714285714,30.0,22.8,23.4
+729,sj,2004,19,2004-05-06,,,0.09315,0.1181333,9.57,299.09,299.2071429,294.38,301.1,297.3,20.56,75.38571429,9.57,15.75,2.3,26.27142857,6.271428571,30.6,22.2,30.2
+730,sj,2004,20,2004-05-13,-0.0904,0.118525,0.1076333,0.21006,15.78,298.7657143,298.9142857,295.37,301.3,297.2,36.9,81.71142857,15.78,16.73,2.657142857,26.72857143,5.528571429,31.1,22.8,18.1
+731,sj,2004,21,2004-05-20,0.05286667,0.06016667,0.1156429,0.1297857,96.99,298.1214286,298.1142857,295.1542857,300.0,296.5,79.0,83.83285714,96.99,16.52142857,1.771428571,26.04285714,4.671428571,29.4,22.8,53.6
+732,sj,2004,22,2004-05-27,-0.02563333,-0.008066667,0.1591143,0.1588,175.41,298.3657143,298.4571429,295.3471429,300.4,297.2,90.2,83.55,175.41,16.74,2.0,24.81428571,4.914285714,28.9,21.7,145.8
+733,sj,2004,23,2004-06-03,-0.07055,-0.02854,0.08158571,0.1132429,13.51,300.0542857,300.2071429,296.4457143,302.2,298.2,5.36,80.91428571,13.51,17.88142857,2.9,27.95714286,7.542857143,33.3,22.8,4.6
+734,sj,2004,24,2004-06-10,0.0218,-0.0441,0.1412,0.1782429,6.12,299.8171429,299.7571429,296.1014286,301.5,298.0,30.07,80.17714286,6.12,17.47571429,2.314285714,28.04285714,6.342857143,31.7,23.9,17.6
+735,sj,2004,25,2004-06-17,0.017425,0.07494,0.1466571,0.1337429,13.07,300.0371429,300.1357143,296.5885714,302.5,297.8,20.0,81.56142857,13.07,17.98428571,3.242857143,28.32857143,7.128571429,33.3,22.8,81.5
+736,sj,2004,26,2004-06-24,0.0101,-0.00385,0.1837714,0.1702143,41.41,300.5371429,300.6428571,296.4157143,302.5,297.9,17.0,78.29714286,41.41,17.79428571,2.857142857,28.22857143,6.271428571,32.2,23.9,8.9
+737,sj,2004,27,2004-07-01,,0.0083,0.1515714,0.1447429,28.37,300.6442857,300.6785714,296.5571429,302.5,298.4,32.2,78.48142857,28.37,17.95142857,2.614285714,28.34285714,6.185714286,32.2,23.3,67.6
+738,sj,2004,28,2004-07-08,-0.0267,-0.01173333,0.1683286,0.1751143,39.05,300.2585714,300.2571429,296.33,301.9,298.6,43.83,79.18142857,39.05,17.72857143,2.571428571,27.82857143,6.428571429,31.1,23.3,76.5
+739,sj,2004,29,2004-07-15,-0.0529,-0.101,0.1853143,0.1498429,59.15,300.5757143,300.6714286,296.7971429,302.4,299.0,15.8,79.99571429,59.15,18.25285714,2.2,28.24285714,5.242857143,31.7,25.0,16.0
+740,sj,2004,30,2004-07-22,0.0674,0.08983333,0.1748286,0.1487429,23.74,300.4014286,300.4,296.0957143,302.3,298.4,31.21,77.49857143,23.74,17.51,2.685714286,28.01428571,6.528571429,31.7,23.9,26.2
+741,sj,2004,31,2004-07-29,-0.0117,-0.05443333,0.1905286,0.1573,40.86,300.2342857,300.2857143,296.8228571,302.1,298.5,31.51,81.80714286,40.86,18.30714286,2.571428571,28.04285714,6.371428571,31.7,23.9,44.0
+742,sj,2004,32,2004-08-05,0.0058,0.0327,0.1741,0.1838143,35.99,300.5885714,300.6428571,296.6,302.7,298.4,24.6,79.02571429,35.99,18.05285714,2.971428571,28.52857143,6.585714286,32.2,24.4,12.8
+743,sj,2004,33,2004-08-12,0.0374,0.1084,0.1253,0.1774143,20.92,300.9957143,301.2,296.4,302.9,299.2,14.1,76.17142857,20.92,17.81857143,2.657142857,28.94285714,7.228571429,33.9,24.4,10.5
+744,sj,2004,34,2004-08-19,-0.0164,-0.021875,0.1816,0.1706,37.3,300.7942857,300.85,297.2685714,302.6,298.6,44.4,81.26428571,37.3,18.77428571,2.585714286,29.0,6.314285714,32.2,24.4,28.3
+745,sj,2004,35,2004-08-26,0.0996,0.0633,0.1006571,0.1094286,20.3,300.9128571,301.05,297.0542857,302.6,298.7,13.5,79.68428571,20.3,18.53142857,2.642857143,29.05714286,6.485714286,33.3,25.0,20.6
+746,sj,2004,36,2004-09-02,0.0414,0.0498,0.1631286,0.1992,62.61,300.8614286,300.9,296.39,302.6,298.9,25.37,76.71142857,62.61,17.82285714,2.628571429,28.61428571,7.057142857,32.8,24.4,23.8
+747,sj,2004,37,2004-09-09,0.1076,0.074925,0.1059143,0.09598571,42.51,300.9585714,301.0,297.15,302.8,299.3,33.4,79.86571429,42.51,18.71714286,2.342857143,28.98571429,6.971428571,33.9,25.0,20.6
+748,sj,2004,38,2004-09-16,0.04015,,0.09487143,0.1394429,52.29,301.1,301.2571429,297.3042857,303.3,299.3,16.0,80.03285714,52.29,18.90428571,2.428571429,28.64285714,6.114285714,32.2,24.4,32.8
+749,sj,2004,39,2004-09-23,,-0.06745,0.2252571,0.2332,245.73,299.7985714,299.9571429,297.0814286,302.9,297.7,254.95,85.33,245.73,18.64571429,2.542857143,27.22857143,6.057142857,33.9,23.3,158.2
+750,sj,2004,40,2004-09-30,0.033475,0.007625,0.24358,0.1786333,10.06,301.0285714,301.2071429,296.4785714,303.6,298.7,8.57,76.47142857,10.06,17.96428571,3.671428571,29.14285714,8.085714286,34.4,24.4,21.8
+751,sj,2004,41,2004-10-07,-0.0168,0.02526667,0.09047143,0.05836667,34.73,300.68,300.6785714,296.5842857,302.5,298.9,35.7,78.47714286,34.73,18.07285714,2.557142857,28.28571429,6.214285714,31.7,24.4,24.4
+752,sj,2004,42,2004-10-14,,0.09375,0.2360286,0.2138714,83.2,300.5085714,300.6785714,296.8642857,303.4,298.6,41.4,80.66571429,83.2,18.40285714,3.157142857,28.12857143,6.185714286,32.2,23.9,41.4
+753,sj,2004,43,2004-10-21,0.0969,0.07463333,0.08211667,0.0797,10.82,300.6471429,300.8071429,296.2214286,302.7,299.2,18.0,76.92285714,10.82,17.69571429,2.442857143,28.28571429,6.728571429,32.2,23.9,15.1
+754,sj,2004,44,2004-10-28,0.0802,0.088,0.096,0.1182286,96.72,299.8928571,300.1571429,296.26,302.4,298.6,25.2,80.65571429,96.72,17.76428571,2.371428571,27.5,5.642857143,31.7,23.9,34.1
+755,sj,2004,45,2004-11-04,0.1337,0.1288,0.24505,0.1911143,105.49,299.67,299.9,295.3757143,301.8,298.2,31.2,77.53285714,105.49,16.81857143,2.4,27.05714286,6.528571429,30.6,22.8,109.0
+756,sj,2004,46,2004-11-11,0.0199,-0.00135,0.039,0.06477143,18.75,299.9214286,299.9714286,295.5985714,302.1,298.3,24.5,77.31142857,18.75,17.03857143,2.4,27.24285714,6.357142857,31.1,23.9,7.7
+757,sj,2004,47,2004-11-18,0.3274,-0.0064,0.2224857,0.1364714,122.87,298.5471429,298.5571429,295.5571429,300.4,296.9,145.8,83.62857143,122.87,17.00714286,1.857142857,26.32857143,4.628571429,28.9,23.3,70.7
+758,sj,2004,48,2004-11-25,0.0435,-0.0607,0.1951571,0.2427714,18.37,298.43,298.4571429,293.4557143,300.0,297.0,24.9,74.30285714,18.37,14.92142857,1.971428571,26.32857143,4.9,29.4,23.3,26.9
+759,sj,2004,49,2004-12-02,-0.1613,-0.08855,0.2108714,0.2731429,0.0,298.7914286,298.9,293.74,300.3,297.6,2.71,73.75714286,0.0,15.16285714,2.114285714,25.64285714,6.442857143,28.9,21.1,7.7
+760,sj,2004,50,2004-12-09,-0.0039,-0.0262,0.2083167,0.17965,0.0,298.1642857,298.3642857,293.2742857,300.2,296.1,2.8,74.32571429,0.0,14.70857143,2.357142857,25.15714286,6.314285714,28.9,20.6,10.4
+761,sj,2004,51,2004-12-16,-0.15165,-0.0214,0.1828167,0.1342571,5.54,298.8028571,298.95,295.2528571,300.8,297.5,29.32,80.88857143,5.54,16.62142857,2.242857143,26.27142857,5.628571429,30.6,22.8,30.6
+762,sj,2004,52,2004-12-23,-0.1261,-0.06296667,0.1994857,0.14035,150.31,298.6828571,298.8714286,295.7414286,300.9,296.9,41.3,83.95285714,150.31,17.14857143,2.057142857,26.24285714,5.714285714,30.0,22.8,55.7
+763,sj,2005,53,2005-01-01,,,,,,,,,,,,,,,,,,,,
+764,sj,2005,1,2005-01-08,0.0079,-0.04963333,0.1246571,0.1004429,0.0,297.5871429,297.6642857,292.7714286,299.5,296.1,21.68,74.77857143,0.0,14.26142857,1.957142857,24.98571429,4.9,28.3,21.1,23.8
+765,sj,2005,2,2005-01-15,0.02435,-0.019275,0.1335429,0.1272429,0.0,297.6,297.6142857,293.6671429,298.9,296.2,43.1,78.79857143,0.0,15.04285714,1.914285714,25.2,5.385714286,28.3,22.2,55.6
+766,sj,2005,3,2005-01-22,-0.1118333,-0.07645,0.2029,0.2233571,14.67,297.3957143,297.5571429,294.3085714,299.4,295.8,76.36,83.05571429,14.67,15.67142857,1.914285714,25.22857143,4.914285714,28.3,21.7,32.4
+767,sj,2005,4,2005-01-29,-0.0479,0.0431,0.1743,0.1456429,15.2,296.5357143,296.6142857,292.5128571,299.0,294.8,31.85,78.53857143,15.2,14.09142857,2.657142857,23.75714286,6.328571429,28.3,17.8,34.0
+768,sj,2005,5,2005-02-05,0.0442,-0.0758,0.2056,0.1781429,0.0,296.1528571,296.1714286,292.2,297.8,294.3,31.8,78.64,0.0,13.77,1.971428571,23.71428571,4.528571429,27.8,19.4,5.4
+769,sj,2005,6,2005-02-12,-0.08175,-0.03735,0.2976571,0.3102571,0.0,296.1014286,296.1714286,290.4671429,299.5,293.3,6.4,70.79571429,0.0,12.36285714,3.114285714,23.31428571,5.985714286,26.7,19.4,10.1
+770,sj,2005,7,2005-02-19,,0.093,0.1756571,0.1842857,0.0,296.3528571,296.4,291.0371429,298.7,293.4,5.3,72.24571429,0.0,12.80714286,3.085714286,23.41428571,6.228571429,26.7,18.9,4.6
+771,sj,2005,8,2005-02-26,0.1083,-0.04855,0.1908714,0.1969714,0.0,296.48,296.55,291.5842857,298.0,295.0,10.1,74.19142857,0.0,13.24142857,2.157142857,24.48571429,4.614285714,27.2,21.7,2.1
+772,sj,2005,9,2005-03-05,-0.1036667,-0.04113333,0.1607,0.1097667,0.0,297.2714286,297.45,293.2742857,300.3,295.5,5.92,78.66714286,0.0,14.75,2.957142857,25.02857143,7.128571429,30.6,20.0,5.3
+773,sj,2005,10,2005-03-12,,0.0781,0.2434571,0.2521571,3.93,298.0614286,298.2214286,293.77,301.4,295.5,3.3,77.39285714,3.93,15.20428571,4.357142857,26.01428571,7.7,31.1,20.0,0.0
+774,sj,2005,11,2005-03-19,0.0644,0.01095,0.1937429,0.2441714,0.0,297.8514286,297.9142857,292.7857143,301.6,294.8,0.3,73.58571429,0.0,14.28285714,4.257142857,25.84285714,8.414285714,33.3,20.0,0.0
+775,sj,2005,12,2005-03-26,-0.044,-0.0753,0.1609286,0.2079714,0.0,298.2471429,298.5,293.2171429,301.2,295.6,0.2,73.86714286,0.0,14.66857143,3.914285714,26.4,8.514285714,32.8,20.0,0.0
+776,sj,2005,13,2005-04-02,,-0.0987,0.1752,0.1482286,0.0,299.0728571,299.3142857,294.4442857,301.0,297.3,0.2,75.73714286,0.0,15.78285714,2.8,27.48571429,8.671428571,33.3,22.2,0.0
+777,sj,2005,14,2005-04-09,0.0045,-0.00048,0.1233167,0.1557833,13.44,299.1071429,299.3642857,294.9285714,301.5,297.4,8.0,78.00285714,13.44,16.30428571,3.014285714,27.3,7.485714286,33.3,22.2,7.4
+778,sj,2005,15,2005-04-16,-0.1235,-0.1235,0.1525833,0.1210857,33.69,299.19,299.3785714,294.9471429,301.9,296.8,23.7,77.65,33.69,16.31571429,3.385714286,27.4,8.157142857,32.8,22.8,21.1
+779,sj,2005,16,2005-04-23,0.01683333,0.005433333,0.09328333,0.1092167,42.88,300.0128571,300.1071429,295.6485714,302.7,297.1,3.6,77.24285714,42.88,17.05571429,3.728571429,28.17142857,8.414285714,33.9,22.2,97.3
+780,sj,2005,17,2005-04-30,-0.09295,,0.1012333,0.106,234.13,298.9171429,299.0214286,295.5385714,301.6,296.4,98.5,81.75142857,234.13,16.96428571,3.585714286,26.78571429,6.885714286,32.8,22.8,207.5
+781,sj,2005,18,2005-05-07,-0.1362,-0.2498,0.2218,0.2113714,0.0,299.54,299.5642857,295.5542857,301.9,297.5,11.0,78.90714286,0.0,16.96285714,2.757142857,27.37142857,5.7,31.7,23.3,48.2
+782,sj,2005,19,2005-05-14,0.06313333,0.082275,0.1302667,0.09501667,38.66,299.9485714,299.9428571,295.3,301.8,297.9,10.11,75.69857143,38.66,16.67285714,2.914285714,27.3,6.228571429,31.7,23.3,11.4
+783,sj,2005,20,2005-05-21,,0.0481,0.07107143,0.04847143,102.56,299.0657143,298.9857143,296.0757143,301.6,296.8,96.0,83.76285714,102.56,17.53285714,2.514285714,26.27142857,5.957142857,30.6,22.2,110.9
+784,sj,2005,21,2005-05-28,0.0476,0.06735,0.0966,0.08731429,156.94,299.8057143,300.0357143,296.9,303.0,297.1,145.7,84.33571429,156.94,18.48571429,3.071428571,28.38571429,6.657142857,35.0,23.9,71.2
+785,sj,2005,22,2005-06-04,-0.0143,-0.004475,0.1778,0.1467571,84.78,300.84,300.8785714,297.5985714,303.4,298.7,14.59,82.63,84.78,19.20714286,2.9,28.84285714,6.342857143,34.4,25.0,23.9
+786,sj,2005,23,2005-06-11,0.0606,0.09883333,0.1881857,0.1763,32.02,301.1171429,301.1285714,296.6885714,303.0,299.4,4.5,76.94,32.02,18.16571429,2.571428571,28.72857143,5.957142857,32.8,24.4,4.4
+787,sj,2005,24,2005-06-18,0.0449,0.1177,0.1211143,0.1242143,97.46,299.9814286,300.1071429,296.5442857,302.1,298.3,15.9,81.51571429,97.46,18.02857143,2.871428571,27.51428571,5.8,31.1,23.9,44.5
+788,sj,2005,25,2005-06-25,,0.0634,0.2097429,0.2099286,8.36,301.3371429,301.3571429,297.4585714,304.0,298.5,4.2,79.71857143,8.36,19.04142857,3.514285714,30.02857143,7.657142857,34.4,25.0,0.0
+789,sj,2005,26,2005-07-02,0.0892,0.07075,0.09012857,0.09425714,23.36,301.0885714,301.0785714,297.3142857,302.8,298.9,28.59,80.01285714,23.36,18.84571429,2.585714286,29.04285714,6.814285714,33.3,24.4,52.3
+790,sj,2005,27,2005-07-09,0.0854,0.246675,0.1717857,0.2381,42.06,301.2814286,301.2857143,297.3642857,303.7,299.2,32.4,79.37714286,42.06,18.88571429,2.942857143,29.02857143,6.257142857,33.9,25.0,34.8
+791,sj,2005,28,2005-07-16,0.0514,0.051625,0.1122571,0.1370143,92.52,300.6671429,300.6214286,297.0,302.5,298.7,45.28,80.56142857,92.52,18.50857143,2.614285714,28.44285714,6.342857143,32.8,24.4,52.8
+792,sj,2005,29,2005-07-23,-0.0665,-0.021,0.2358286,0.2333429,39.49,300.8714286,300.8928571,296.9814286,303.1,298.8,31.9,79.48142857,39.49,18.48142857,2.442857143,28.38571429,7.1,32.8,23.9,50.3
+793,sj,2005,30,2005-07-30,-0.1087,-0.00945,0.2564429,0.2153714,64.25,300.8528571,300.9214286,297.58,302.9,298.7,34.3,82.40857143,64.25,19.11428571,2.728571429,28.92857143,6.171428571,32.2,23.9,73.8
+794,sj,2005,31,2005-08-06,-0.06475,-0.0267,0.1404,0.1212,80.34,301.1585714,301.1071429,297.2914286,303.0,299.3,54.1,79.62142857,80.34,18.83142857,2.871428571,28.94285714,5.928571429,33.3,25.0,41.0
+795,sj,2005,32,2005-08-13,,0.02365,0.2691286,0.1919286,18.15,301.3485714,301.3785714,297.3671429,303.5,299.2,11.93,79.25285714,18.15,18.93857143,2.985714286,29.47142857,6.971428571,33.9,25.6,12.6
+796,sj,2005,33,2005-08-20,0.0479,0.069675,0.08632857,0.09587143,29.86,301.4657143,301.4642857,297.1885714,303.7,299.2,21.1,77.74,29.86,18.72,3.414285714,29.32857143,6.5,33.3,25.6,18.1
+797,sj,2005,34,2005-08-27,-0.1224,0.051,0.1057714,0.1418714,99.02,301.1785714,301.2214286,296.6928571,303.7,299.1,28.1,76.73428571,99.02,18.17428571,3.385714286,27.92857143,7.928571429,33.3,22.8,31.7
+798,sj,2005,35,2005-09-03,,-0.0073,0.11122,0.1085857,77.05,301.2914286,301.3928571,297.2871429,303.4,299.5,30.0,79.08142857,77.05,18.86714286,3.185714286,28.08571429,6.571428571,32.2,22.2,104.4
+799,sj,2005,36,2005-09-10,0.0022,-0.0271,0.2050286,0.2202333,23.3,301.4657143,301.5142857,296.6428571,304.1,298.6,3.7,75.43857143,23.3,18.15714286,4.428571429,28.85714286,7.057142857,33.9,24.4,8.9
+800,sj,2005,37,2005-09-17,0.0073,0.0049,0.1523429,0.1456286,43.57,302.2,302.1642857,297.7957143,304.3,299.9,11.9,77.27285714,43.57,19.44,3.385714286,29.24285714,7.557142857,33.9,24.4,61.0
+801,sj,2005,38,2005-09-24,0.0252,-0.05933333,0.1554286,0.1780286,66.86,301.4957143,301.5142857,297.0,303.7,298.9,14.6,76.66142857,66.86,18.50571429,3.571428571,28.58571429,6.657142857,32.2,24.4,15.1
+802,sj,2005,39,2005-10-01,0.0012,-0.02986667,0.1802833,0.1557333,36.86,301.1142857,301.3714286,297.1285714,304.0,298.8,38.4,79.08285714,36.86,18.70428571,3.542857143,28.62857143,6.157142857,32.2,25.0,19.8
+803,sj,2005,40,2005-10-08,0.0488,0.0394,0.1125571,0.07724286,68.31,301.09,301.1285714,296.9571429,303.3,299.5,27.3,78.35142857,68.31,18.49857143,2.685714286,28.01428571,6.342857143,32.8,23.3,18.6
+804,sj,2005,41,2005-10-15,0.0419,0.02793333,0.05515,0.04244286,157.83,299.8342857,300.0142857,296.5471429,303.0,297.9,60.4,82.26428571,157.83,18.03571429,2.542857143,27.01428571,7.228571429,32.2,22.8,126.9
+805,sj,2005,42,2005-10-22,0.02275,0.0278,0.2403571,0.2043429,112.16,300.6242857,300.8785714,297.3271429,303.1,298.0,18.7,82.39,112.16,18.95857143,2.928571429,28.04285714,6.442857143,33.9,23.3,45.5
+806,sj,2005,43,2005-10-29,-0.029975,0.05126667,0.1705571,0.1623143,20.75,300.6914286,300.7071429,297.3871429,303.1,298.7,70.3,82.42285714,20.75,18.99142857,2.442857143,27.97142857,7.071428571,33.3,23.9,55.1
+807,sj,2005,44,2005-11-05,0.07596667,-0.0622,0.2535143,0.2017429,39.72,300.8414286,300.9428571,296.8314286,302.9,298.9,26.26,78.97,39.72,18.34,2.571428571,27.95714286,7.4,32.8,23.9,57.2
+808,sj,2005,45,2005-11-12,-0.00135,0.06455,0.2022143,0.1520714,27.22,300.6642857,300.7357143,296.7485714,302.6,299.0,20.43,79.32714286,27.22,18.22857143,2.128571429,27.87142857,7.014285714,32.8,23.3,32.5
+809,sj,2005,46,2005-11-19,0.0507,0.0174,0.2004429,0.1821714,37.36,299.9714286,299.8142857,296.1942857,301.6,298.0,93.9,79.90142857,37.36,17.63857143,2.257142857,27.15714286,6.542857143,31.1,23.3,41.5
+810,sj,2005,47,2005-11-26,,0.1654,0.2159143,0.1852286,14.49,299.4671429,299.5642857,295.1171429,301.4,298.0,40.81,77.24571429,14.49,16.54857143,2.585714286,26.52857143,6.085714286,30.0,22.2,23.6
+811,sj,2005,48,2005-12-03,,0.1823,0.2686,0.2481857,26.65,299.1828571,299.2357143,295.1242857,302.2,297.8,36.65,78.62428571,26.65,16.57142857,2.414285714,26.22857143,5.871428571,30.6,22.8,80.7
+812,sj,2005,49,2005-12-10,-0.03396667,0.04135,0.1812667,0.20685,0.0,298.5785714,298.5428571,293.0157143,300.5,295.9,11.2,71.45571429,0.0,14.50714286,2.742857143,24.98571429,6.328571429,28.9,20.6,27.5
+813,sj,2005,50,2005-12-17,-0.0587,-0.07753333,0.1667571,0.1695143,0.0,299.1314286,299.2428571,294.3328571,300.8,297.5,13.6,75.07571429,0.0,15.72142857,2.171428571,25.45714286,6.028571429,29.4,21.1,30.0
+814,sj,2005,51,2005-12-24,0.1077,0.0531,0.2853429,0.2935714,0.0,298.44,298.65,294.1385714,300.9,296.5,20.64,77.31571429,0.0,15.53285714,2.528571429,24.62857143,6.185714286,28.9,20.6,29.1
+815,sj,2006,52,2006-01-01,-0.1062,-0.1376,0.1835,0.1697667,64.08,299.1471429,299.3071429,294.6828571,301.4,297.5,22.5,76.57857143,64.08,16.02714286,2.242857143,25.88571429,6.271428571,30.0,21.1,18.6
+816,sj,2006,1,2006-01-08,-0.008233333,-0.04533333,0.1100714,0.09948571,16.27,298.6771429,298.8642857,293.8042857,300.3,297.2,5.76,74.50857143,16.27,15.20285714,2.1,24.65714286,6.257142857,28.3,20.6,8.1
+817,sj,2006,2,2006-01-15,-0.04245,0.00455,0.2592714,0.2393143,72.69,298.3328571,298.55,293.1085714,300.1,296.6,10.9,72.92857143,72.69,14.57142857,2.442857143,24.05714286,6.8,27.8,18.9,21.9
+818,sj,2006,3,2006-01-22,-0.1942333,-0.11174,0.1015143,0.1011143,74.41,298.4014286,298.5285714,294.4171429,300.9,296.7,41.5,78.72,74.41,15.79428571,2.428571429,24.71428571,6.357142857,30.6,20.6,101.1
+819,sj,2006,4,2006-01-29,0.009,-0.0458,0.1000167,0.1076833,0.0,298.2871429,298.3357143,293.5128571,299.9,296.6,16.8,74.89714286,0.0,14.89714286,2.014285714,24.28571429,5.142857143,27.2,20.6,29.2
+820,sj,2006,5,2006-02-05,0.0443,-0.005,0.1681333,0.1399571,0.0,297.5414286,297.6357143,292.3471429,300.2,295.5,9.89,72.87285714,0.0,13.86,2.157142857,23.41428571,6.114285714,28.9,18.9,7.6
+821,sj,2006,6,2006-02-12,-0.3084,-0.1369,0.2661,0.2104571,18.15,297.8257143,297.9928571,293.4571429,300.1,296.5,9.7,76.90714286,18.15,14.89857143,2.214285714,23.91428571,6.385714286,28.3,19.4,26.6
+822,sj,2006,7,2006-02-19,0.3255,-0.02752,0.1900714,0.2061857,0.0,297.9557143,298.2428571,293.9085714,300.9,295.6,10.37,78.49428571,0.0,15.28142857,3.028571429,24.74285714,7.057142857,30.6,20.0,15.0
+823,sj,2006,8,2006-02-26,-0.1032,0.1611,0.2396714,0.2859714,11.8,298.0557143,298.2071429,292.9714286,300.1,296.7,8.1,73.41428571,11.8,14.38857143,2.385714286,24.85714286,6.342857143,28.9,21.1,2.6
+824,sj,2006,9,2006-03-05,-0.16734,-0.105825,0.16068,0.2190667,0.0,298.1585714,298.5642857,292.4614286,300.9,296.3,0.2,70.69714286,0.0,13.95142857,2.642857143,25.3,6.485714286,30.6,21.1,0.0
+825,sj,2006,10,2006-03-12,-0.01313333,0.018275,0.1773,0.1503,0.0,297.9885714,298.1428571,293.07,300.8,295.4,7.5,74.28,0.0,14.49714286,3.428571429,25.52857143,6.842857143,30.6,21.1,3.3
+826,sj,2006,11,2006-03-19,0.0109,-0.01436,0.1671,0.1572143,16.74,297.2614286,297.3928571,292.1314286,300.3,295.4,19.63,73.21,16.74,13.7,2.614285714,25.51428571,6.185714286,29.4,21.7,2.2
+827,sj,2006,12,2006-03-26,,-0.10425,0.1246429,0.1394,31.34,298.0614286,298.3,293.4057143,300.4,296.0,10.35,75.52714286,31.34,14.82285714,2.857142857,25.68571429,6.185714286,29.4,21.7,7.4
+828,sj,2006,13,2006-04-02,,0.0471,0.09765,0.08703333,24.44,298.3028571,298.5214286,293.5271429,301.3,296.5,5.0,74.98428571,24.44,14.93714286,3.357142857,26.65714286,7.142857143,32.8,22.2,7.9
+829,sj,2006,14,2006-04-09,0.0455,0.07005,0.08821429,0.0959,174.04,298.24,298.55,294.4185714,301.2,296.2,36.3,79.60285714,174.04,15.79428571,3.185714286,25.42857143,5.642857143,30.6,21.1,84.6
+830,sj,2006,15,2006-04-16,0.0165,0.01794,0.1163167,0.1032857,44.84,298.6728571,298.8142857,294.1728571,300.6,297.0,12.6,76.33285714,44.84,15.56571429,2.8,25.85714286,6.014285714,30.6,22.2,48.3
+831,sj,2006,16,2006-04-23,-0.012,-0.1001,0.1578167,0.1299714,60.86,298.5914286,298.8214286,294.4528571,301.1,296.8,28.63,78.02428571,60.86,15.86571429,3.1,26.68571429,6.128571429,30.6,22.8,5.4
+832,sj,2006,17,2006-04-30,0.0351,0.0351,0.1158857,0.08678571,103.35,298.8985714,299.1928571,294.4385714,302.0,296.6,26.99,76.60428571,103.35,15.83285714,3.271428571,26.31428571,6.114285714,30.6,22.8,75.2
+833,sj,2006,18,2006-05-07,0.0144,0.04355,0.1209,0.09565714,54.47,298.8728571,299.1928571,294.7271429,302.2,296.5,29.05,78.09857143,54.47,16.12428571,3.385714286,26.5,6.014285714,31.1,22.2,66.1
+834,sj,2006,19,2006-05-14,,0.0534,0.07054286,0.08275714,12.09,298.12,298.2928571,293.5157143,300.0,296.7,19.4,75.92714286,12.09,14.98571429,2.357142857,25.94285714,5.071428571,29.4,22.2,80.8
+835,sj,2006,20,2006-05-21,0.0802,0.04546667,0.2060857,0.1872143,103.95,299.1714286,299.3071429,296.2957143,301.9,297.2,90.4,84.31,103.95,17.73428571,2.785714286,27.81428571,7.242857143,33.3,23.3,15.6
+836,sj,2006,21,2006-05-28,,-0.1001333,0.2400833,0.2095714,3.7,300.5014286,300.7142857,296.3657143,302.8,299.0,6.07,78.4,3.7,17.79285714,2.971428571,29.02857143,7.714285714,33.9,24.4,0.5
+837,sj,2006,22,2006-06-04,0.0582,0.033525,0.1129667,0.1009571,64.92,300.57,300.7714286,295.9128571,302.8,298.6,6.19,75.81142857,64.92,17.29,3.0,28.58571429,7.142857143,33.9,24.4,22.1
+838,sj,2006,23,2006-06-11,0.0144,0.0144,0.10458,0.1338286,19.93,300.7685714,300.9071429,296.0528571,303.2,298.6,7.3,75.6,19.93,17.46428571,3.042857143,28.91428571,8.342857143,34.4,24.4,1.3
+839,sj,2006,24,2006-06-18,-0.01003333,-0.0572,0.1517,0.1498833,7.56,301.0214286,301.1428571,296.3614286,303.3,299.6,12.4,75.92,7.56,17.78428571,2.742857143,28.94285714,7.671428571,34.4,23.3,34.0
+840,sj,2006,25,2006-06-25,0.0255,0.04276667,0.1070429,0.1105571,19.95,300.4785714,300.5357143,296.6428571,302.4,298.7,39.52,79.69571429,19.95,18.09142857,2.814285714,28.07142857,6.757142857,33.3,23.9,25.5
+841,sj,2006,26,2006-07-02,0.1035,0.1977,0.1338714,0.1229429,111.15,300.5042857,300.6357143,297.1614286,303.0,299.0,38.37,82.16,111.15,18.67142857,2.242857143,27.87142857,6.814285714,33.3,22.8,58.2
+842,sj,2006,27,2006-07-09,0.063875,0.05485,0.1770333,0.1333333,52.63,300.5842857,300.6071429,296.5185714,302.4,298.8,35.3,78.60428571,52.63,17.91571429,2.614285714,27.94285714,6.842857143,32.2,22.8,26.7
+843,sj,2006,28,2006-07-16,0.0193,0.06923333,0.1232714,0.1058286,56.73,300.2628571,300.4285714,296.78,303.0,298.4,64.68,81.47714286,56.73,18.21571429,2.685714286,27.84285714,6.514285714,32.8,22.8,51.6
+844,sj,2006,29,2006-07-23,0.04735,0.02816667,0.1966857,0.1615429,16.61,300.2442857,300.2214286,296.5871429,302.3,298.3,40.4,80.53857143,16.61,18.01142857,2.557142857,27.48571429,6.471428571,31.7,22.8,36.8
+845,sj,2006,30,2006-07-30,-0.05556667,-0.10605,0.1034143,0.1018,29.74,300.7942857,300.95,296.7628571,302.8,298.6,19.1,78.77285714,29.74,18.20714286,2.671428571,28.6,6.657142857,33.9,23.9,13.3
+846,sj,2006,31,2006-08-06,-0.1145,0.09955,0.1523286,0.1531286,93.78,300.4,300.4714286,296.9585714,302.7,298.4,72.24,81.64571429,93.78,18.42714286,2.8,27.82857143,6.271428571,32.2,22.8,100.0
+847,sj,2006,32,2006-08-13,0.00174,0.0136,0.1457429,0.1309857,63.83,300.2085714,300.3714286,296.57,303.1,297.9,171.58,80.65428571,63.83,18.00714286,2.857142857,27.44285714,5.4,31.1,23.9,40.9
+848,sj,2006,33,2006-08-20,,0.0139,0.2238143,0.1753,3.19,300.91,301.1214286,296.84,303.0,299.3,13.5,78.62714286,3.19,18.32714286,2.471428571,28.64285714,5.3,32.2,24.4,1.5
+849,sj,2006,34,2006-08-27,0.06405,0.00345,0.1773,0.1789833,70.61,300.8214286,300.9642857,297.0014286,303.1,299.0,39.5,79.81428571,70.61,18.50714286,2.757142857,27.98571429,6.771428571,32.2,23.9,30.7
+850,sj,2006,35,2006-09-03,0.07515,0.079825,0.1567,0.1232,51.48,301.0685714,301.2214286,297.13,303.2,299.1,22.2,79.15428571,51.48,18.63285714,2.471428571,28.12857143,5.571428571,31.7,23.3,33.8
+851,sj,2006,36,2006-09-10,0.01235,-0.02706667,0.1379857,0.1328,24.11,301.0714286,301.1571429,296.8814286,303.1,298.8,15.5,78.12428571,24.11,18.40142857,3.0,28.54285714,6.342857143,32.2,24.4,9.8
+852,sj,2006,37,2006-09-17,0.026125,-0.0535,0.1424143,0.1815,67.31,301.0985714,301.3642857,296.8614286,304.2,298.8,27.2,77.93,67.31,18.38285714,3.5,28.52857143,7.2,33.3,23.9,25.3
+853,sj,2006,38,2006-09-24,-0.0556,-0.0162,0.1977,0.1719286,27.18,301.4185714,301.5642857,296.7214286,303.6,299.2,9.6,75.86142857,27.18,18.21,3.414285714,28.82857143,6.8,33.3,23.9,2.3
+854,sj,2006,39,2006-10-01,-0.0265,-0.03535,0.1945429,0.1676,27.63,301.3442857,301.5357143,296.8985714,304.2,299.0,18.86,76.95285714,27.63,18.39857143,3.614285714,28.95714286,6.285714286,32.8,25.0,6.2
+855,sj,2006,40,2006-10-08,,,0.1755,0.1958714,12.22,301.4742857,301.6928571,296.5471429,303.7,299.6,14.1,74.73285714,12.22,18.00142857,3.071428571,28.85714286,7.385714286,33.9,24.4,7.3
+856,sj,2006,41,2006-10-15,0.06305,-0.1497,0.2367333,0.2508833,44.38,301.3971429,301.4285714,296.7642857,303.2,299.2,20.4,76.00714286,44.38,18.26285714,2.542857143,28.7,7.214285714,33.3,23.9,28.0
+857,sj,2006,42,2006-10-22,0.12335,0.1152,0.07027143,0.05842857,64.15,300.7557143,300.7714286,296.8442857,302.9,298.6,37.0,79.41428571,64.15,18.39428571,3.028571429,28.35714286,7.528571429,33.3,23.9,140.8
+858,sj,2006,43,2006-10-29,0.04593333,-0.0364,0.1736714,0.12805,95.43,300.6828571,300.8285714,296.8771429,302.9,299.0,27.2,79.93,95.43,18.46,3.085714286,28.11428571,7.014285714,32.8,23.3,65.8
+859,sj,2006,44,2006-11-05,,0.0707,0.1566143,0.1134143,15.91,300.9357143,301.0285714,297.3657143,303.4,299.3,54.12,81.08571429,15.91,18.94714286,2.771428571,28.5,5.771428571,32.2,25.0,38.0
+860,sj,2006,45,2006-11-12,-0.2761,-0.0331,0.2153167,0.1843571,6.61,300.88,300.9928571,296.1642857,302.8,299.2,8.2,75.56857143,6.61,17.61714286,2.585714286,27.98571429,6.128571429,31.7,24.4,18.0
+861,sj,2006,46,2006-11-19,-0.1686,-0.4561,0.1658143,0.1308143,21.29,300.4128571,300.5642857,295.0628571,302.8,298.5,13.2,72.68428571,21.29,16.46428571,2.471428571,27.18571429,6.628571429,31.7,23.3,18.5
+862,sj,2006,47,2006-11-26,0.0947,-0.01176667,0.1773286,0.1929,57.01,299.3285714,299.4857143,294.6557143,302.4,296.5,26.82,75.6,57.01,16.08,3.257142857,27.04285714,7.157142857,32.8,22.8,0.8
+863,sj,2006,48,2006-12-03,0.0115,,0.08832857,0.02602857,51.3,300.3428571,300.4071429,295.9157143,302.2,298.4,14.56,76.82857143,51.3,17.34571429,2.9,27.41428571,7.4,32.2,22.2,88.7
+864,sj,2006,49,2006-12-10,0.0516,-0.05264,0.2320286,0.09608571,25.02,299.4957143,299.4642857,294.5742857,300.8,297.5,42.55,74.43142857,25.02,15.97,2.014285714,25.94285714,5.771428571,29.4,22.2,68.0
+865,sj,2006,50,2006-12-17,-0.04176667,0.025325,0.1784571,0.1963143,0.0,299.63,299.7357143,295.5914286,301.3,298.2,18.4,78.63857143,0.0,16.98714286,2.1,26.52857143,5.942857143,30.0,22.8,6.9
+866,sj,2006,51,2006-12-24,-0.0548,0.0318,0.10776,0.1255167,0.0,299.3028571,299.4714286,294.5514286,300.8,297.7,14.5,75.24,0.0,15.91714286,1.971428571,25.92857143,6.171428571,30.0,22.2,26.9
+867,sj,2007,1,2007-01-01,0.2643,0.05124,0.1484429,0.1446,0.0,298.6671429,298.8928571,294.2328571,300.2,297.6,12.4,76.52857143,0.0,15.59571429,1.871428571,25.35714286,4.985714286,28.3,21.7,21.7
+868,sj,2007,2,2007-01-08,,-0.03805,0.1851571,0.2065429,0.0,298.5671429,298.6857143,293.76,300.3,296.7,16.3,74.81142857,0.0,15.11571429,2.114285714,25.08571429,6.557142857,29.4,21.1,14.8
+869,sj,2007,3,2007-01-15,-0.0192,-0.0043,0.0963,0.06577143,63.41,298.2171429,298.3214286,294.0157143,300.6,295.9,60.49,77.64714286,63.41,15.36857143,3.042857143,24.97142857,6.185714286,28.3,20.6,21.4
+870,sj,2007,4,2007-01-22,0.1288333,0.1152,0.2486833,0.2523286,0.0,298.2042857,298.3285714,293.2142857,299.5,296.6,9.33,73.80428571,0.0,14.61428571,1.971428571,25.0,5.714285714,28.3,21.1,16.8
+871,sj,2007,5,2007-01-29,,0.041,0.1046857,0.1395429,0.0,297.9457143,298.2214286,292.6971429,301.3,295.5,0.0,72.76,0.0,14.16285714,3.785714286,25.08571429,7.771428571,30.6,20.6,0.0
+872,sj,2007,6,2007-02-05,-0.2156,0.0658,0.2048429,0.2347,0.0,298.5485714,298.7928571,293.7385714,300.4,296.7,0.6,74.8,0.0,15.10285714,2.5,25.6,7.057142857,30.0,21.1,3.3
+873,sj,2007,7,2007-02-12,-0.0752,-0.07194,0.2439429,0.1923143,0.0,298.4442857,298.5857143,293.8271429,301.4,295.8,1.2,75.75428571,0.0,15.18428571,3.457142857,26.15714286,7.6,32.2,21.1,0.3
+874,sj,2007,8,2007-02-19,0.2121,0.1016,0.1901429,0.1567857,0.0,298.71,298.8928571,293.69,301.2,295.7,6.73,73.93285714,0.0,15.09142857,3.442857143,26.41428571,8.485714286,31.1,21.7,1.5
+875,sj,2007,9,2007-02-26,,-0.01975,0.006183333,0.05438333,0.0,298.3157143,298.5142857,294.2042857,301.0,296.2,23.12,78.12571429,0.0,15.56142857,2.885714286,25.62857143,7.0,31.7,21.1,22.9
+876,sj,2007,10,2007-03-05,0.0543,-0.0189,0.1837,0.1208571,0.0,299.1142857,299.25,294.3285714,301.5,296.9,3.7,75.01428571,0.0,15.69714286,3.071428571,26.55714286,7.671428571,32.2,22.2,8.4
+877,sj,2007,11,2007-03-12,0.0373,0.0018,0.1647571,0.1754857,0.0,299.0157143,299.3357143,294.02,301.0,296.6,1.5,74.02571429,0.0,15.38285714,2.985714286,26.71428571,8.042857143,31.7,21.7,0.3
+878,sj,2007,12,2007-03-19,0.0117,0.01655,0.1626714,0.1492,9.12,298.4528571,298.6571429,293.77,301.8,296.8,5.1,75.43857143,9.12,15.16714286,2.628571429,26.85714286,7.542857143,32.8,22.2,0.5
+879,sj,2007,13,2007-03-26,0.02285,0.035575,0.0701,0.08295714,33.72,298.7557143,298.85,294.3757143,300.9,297.1,25.2,76.78428571,33.72,15.74142857,2.528571429,27.12857143,7.8,33.3,22.8,7.6
+880,sj,2007,14,2007-04-02,0.01886667,0.03325,0.1870571,0.1638429,90.68,297.7771429,297.8642857,293.27,299.9,296.5,36.3,76.21428571,90.68,14.77285714,2.071428571,25.6,6.014285714,30.0,21.7,40.2
+881,sj,2007,15,2007-04-09,-0.0743,0.0033,0.2062167,0.2322286,13.09,298.5528571,298.6928571,293.3842857,301.2,295.9,1.2,73.30142857,13.09,14.90857143,3.071428571,26.38571429,7.628571429,32.8,20.6,3.3
+882,sj,2007,16,2007-04-16,0.0689,0.04426667,0.1083571,0.08502857,0.0,299.3357143,299.5571429,294.5071429,301.7,297.6,2.22,74.83285714,0.0,15.85428571,3.0,27.72857143,8.014285714,33.3,22.8,1.8
+883,sj,2007,17,2007-04-23,0.0216,0.02055,0.09744286,0.0642,69.7,299.0228571,299.25,295.4914286,302.8,296.9,63.1,81.11285714,69.7,16.90714286,3.357142857,26.87142857,7.428571429,34.4,21.7,163.1
+884,sj,2007,18,2007-04-30,0.0392,0.01195,0.1393857,0.1175571,93.03,298.7757143,298.8785714,295.4685714,301.0,296.6,63.81,82.08428571,93.03,16.81714286,2.214285714,26.21428571,5.471428571,30.0,22.2,79.8
+885,sj,2007,19,2007-05-07,-0.06205,-0.02765,0.1429286,0.1718429,9.83,299.4671429,299.5142857,295.54,301.8,297.6,40.3,79.19428571,9.83,16.94714286,2.771428571,27.32857143,6.771428571,31.7,23.3,20.5
+886,sj,2007,20,2007-05-14,0.0019,0.01205,0.2544143,0.2370857,6.8,300.66,300.8428571,296.1757143,303.1,298.8,8.4,76.76,6.8,17.60857143,3.171428571,29.0,7.671428571,33.3,24.4,0.3
+887,sj,2007,21,2007-05-21,0.05825,0.0211,0.06742857,0.07848571,6.2,300.6928571,300.85,295.6142857,302.7,298.7,2.2,73.98142857,6.2,17.00571429,3.071428571,28.75714286,8.028571429,33.3,23.9,0.5
+888,sj,2007,22,2007-05-28,,0.1007333,0.1275429,0.1072571,45.7,300.4614286,300.7214286,295.85,303.3,298.3,24.9,76.02285714,45.7,17.25714286,3.557142857,28.45714286,7.057142857,32.8,23.9,17.0
+889,sj,2007,23,2007-06-04,-0.0118,-0.0616,0.1468429,0.1657286,85.81,300.9614286,301.1714286,296.1071429,303.3,298.9,17.74,74.96285714,85.81,17.50714286,3.428571429,29.2,7.4,33.9,23.3,33.3
+890,sj,2007,24,2007-06-11,-0.0054,-0.02493333,0.1035571,0.08591429,62.42,300.55,300.5642857,295.9757143,302.9,298.4,25.3,76.16285714,62.42,17.37,2.385714286,28.54285714,7.214285714,34.4,23.9,47.6
+891,sj,2007,25,2007-06-18,0.1058,0.04328,0.1976143,0.2087,15.76,301.1457143,301.3714286,296.0857143,303.6,298.9,4.2,74.16,15.76,17.48857143,2.971428571,29.01428571,7.5,33.9,24.4,4.3
+892,sj,2007,26,2007-06-25,0.2484,0.11865,0.2273429,0.1632,46.08,301.0971429,301.3071429,296.54,303.7,299.3,9.7,76.32857143,46.08,17.94714286,2.671428571,29.27142857,6.542857143,33.9,25.0,1.5
+893,sj,2007,27,2007-07-02,0.0501,0.005633333,0.22295,0.1635714,19.09,301.0157143,301.1071429,296.1557143,303.2,299.1,20.5,74.92142857,19.09,17.51285714,3.1,28.84285714,6.671428571,33.3,24.4,17.3
+894,sj,2007,28,2007-07-09,,0.05715,0.1622167,0.1797571,1.13,300.9714286,301.0,296.1771429,303.0,298.7,11.56,75.24142857,1.13,17.56142857,2.8,28.87142857,6.728571429,33.3,24.4,10.0
+895,sj,2007,29,2007-07-16,0.0826,0.0875,0.1183571,0.0914,40.7,300.9471429,301.0857143,296.1328571,303.2,298.8,22.32,75.14285714,40.7,17.50571429,2.914285714,28.57142857,6.757142857,33.3,24.4,21.3
+896,sj,2007,30,2007-07-23,-0.00695,0.0335,0.1045571,0.1148571,85.11,300.4957143,300.5428571,296.8728571,302.9,298.4,40.34,80.80857143,85.11,18.35142857,2.857142857,28.57142857,6.271428571,33.3,25.0,69.8
+897,sj,2007,31,2007-07-30,0.0746,0.1004,0.2338667,0.2433714,1.02,301.0814286,301.1714286,296.0628571,303.1,299.1,8.3,74.26428571,1.02,17.46714286,2.828571429,28.62857143,6.142857143,32.8,24.4,14.5
+898,sj,2007,32,2007-08-06,0.0156,0.03105,0.1343143,0.1158571,37.75,301.17,301.2571429,296.9157143,303.0,299.0,21.41,77.76571429,37.75,18.40714286,2.571428571,28.61428571,5.814285714,31.7,24.4,6.4
+899,sj,2007,33,2007-08-13,,0.00625,0.1273571,0.1259429,72.44,300.9871429,301.0928571,296.9228571,303.0,299.0,25.69,78.64,72.44,18.41142857,2.528571429,28.38571429,5.985714286,31.7,23.3,24.9
+900,sj,2007,34,2007-08-20,0.0331,0.0927,0.2873286,0.2724857,34.47,300.9114286,301.0642857,296.8014286,302.9,298.9,56.82,78.46142857,34.47,18.30571429,2.785714286,28.45714286,6.742857143,33.9,23.9,35.3
+901,sj,2007,35,2007-08-27,0.0821,0.06376667,0.1511429,0.1315429,62.56,300.8285714,300.9785714,296.5328571,303.7,299.0,30.89,77.56428571,62.56,18.0,2.7,28.38571429,6.928571429,33.9,23.9,20.1
+902,sj,2007,36,2007-09-03,,0.0433,0.2283333,0.2021857,30.77,301.2185714,301.2428571,296.4457143,303.3,298.9,19.74,75.34571429,30.77,17.87,3.0,28.31428571,6.585714286,33.3,23.9,25.9
+903,sj,2007,37,2007-09-10,,0.0569,0.2385429,0.1874857,10.37,301.1171429,301.15,296.2885714,303.5,298.8,22.24,75.19571429,10.37,17.72,3.157142857,28.87142857,6.514285714,33.9,25.0,10.4
+904,sj,2007,38,2007-09-17,-0.01345,0.0749,0.1525714,0.1319286,70.39,301.2171429,301.3071429,296.5614286,303.1,298.9,26.14,75.97,70.39,18.03714286,2.814285714,28.3,6.285714286,32.8,24.4,26.9
+905,sj,2007,39,2007-09-24,-0.0307,-0.00294,0.1527286,0.1446286,94.37,301.0528571,301.1785714,296.51,303.5,299.0,16.15,76.40571429,94.37,17.98142857,3.585714286,28.17142857,6.028571429,32.2,24.4,21.3
+906,sj,2007,40,2007-10-01,0.096,0.02476667,0.1853,0.1177286,74.5,301.0228571,301.0285714,296.6428571,303.5,299.1,17.6,77.19,74.5,18.11857143,2.685714286,27.98571429,7.242857143,32.8,22.2,86.6
+907,sj,2007,41,2007-10-08,0.009,0.104,0.1181286,0.1263429,108.26,300.79,300.9428571,296.8357143,302.9,299.3,21.98,79.17857143,108.26,18.37571429,3.0,28.12857143,6.914285714,33.3,23.9,14.5
+908,sj,2007,42,2007-10-15,0.021,0.1326667,0.2459429,0.1897571,17.56,301.4928571,301.6357143,296.3542857,303.6,299.4,8.3,73.86714286,17.56,17.84571429,3.185714286,29.1,7.542857143,33.9,24.4,10.2
+909,sj,2007,43,2007-10-22,,-0.00915,0.1911857,0.1764,16.48,301.0071429,301.0928571,295.8742857,302.8,299.0,15.66,73.66142857,16.48,17.27571429,2.471428571,27.95714286,6.442857143,32.2,24.4,8.6
+910,sj,2007,44,2007-10-29,0.1243,0.0543,0.1568143,0.1235286,137.55,299.4585714,299.5428571,296.02,302.1,297.7,174.64,81.59428571,137.55,17.50285714,2.6,26.2,5.4,30.6,22.2,89.2
+911,sj,2007,45,2007-11-05,-0.2517,-0.0486,0.2051714,0.1728833,15.25,300.6042857,300.6857143,295.8385714,302.6,298.2,10.3,75.35,15.25,17.29571429,2.257142857,27.44285714,6.857142857,32.2,22.8,4.1
+912,sj,2007,46,2007-11-12,-0.0589,-0.06255,0.2057429,0.2025429,42.0,299.9342857,300.1857143,295.6385714,303.1,297.5,21.4,77.48142857,42.0,17.08285714,3.542857143,26.81428571,6.685714286,31.1,22.8,65.7
+913,sj,2007,47,2007-11-19,,,0.2044857,0.1562857,73.37,299.8214286,299.8857143,295.7528571,301.8,297.9,43.4,78.52571429,73.37,17.18714286,2.514285714,26.9,6.2,31.1,22.8,40.4
+914,sj,2007,48,2007-11-26,-0.0595,-0.04166667,0.09091667,0.1290857,15.95,299.09,299.1928571,293.3514286,300.7,297.3,9.78,70.72714286,15.95,14.76857143,2.071428571,25.44285714,5.385714286,28.9,22.2,36.4
+915,sj,2007,49,2007-12-03,,-0.04235,0.0956,0.089,17.85,299.02,299.0214286,294.2885714,300.8,297.1,68.0,75.36857143,17.85,15.67571429,2.1,25.84285714,5.4,29.4,22.8,34.5
+916,sj,2007,50,2007-12-10,-0.13305,-0.04555,0.15144,0.1431714,31.3,298.9,298.9714286,294.7742857,300.9,297.0,66.72,78.01571429,31.3,16.13,2.485714286,25.77142857,5.085714286,28.9,22.2,30.2
+917,sj,2007,51,2007-12-17,,-0.039,0.1734167,0.1501714,62.11,298.6685714,298.7571429,294.9771429,300.4,296.2,50.53,80.17857143,62.11,16.34428571,2.371428571,25.07142857,4.914285714,28.9,21.7,108.2
+918,sj,2007,52,2007-12-24,0.0148,0.0163,0.2072667,0.1445778,0.0,298.6028571,298.75,293.9285714,300.8,295.5,2.36,75.44857143,0.0,15.31857143,2.985714286,25.08571429,6.242857143,28.3,21.1,16.8
+919,sj,2008,1,2008-01-01,0.0006,-0.3096,0.2398143,0.1955571,0.0,298.0385714,298.1214286,293.5142857,299.9,296.6,27.99,76.14857143,0.0,14.91142857,1.842857143,25.4,5.3,29.4,22.2,55.5
+920,sj,2008,2,2008-01-08,,-0.10825,0.3304857,0.2442857,37.24,298.1428571,298.2285714,293.5957143,300.0,296.3,37.66,76.13142857,37.24,14.98,2.057142857,24.97142857,5.014285714,28.3,21.1,64.8
+921,sj,2008,3,2008-01-15,,0.0383,0.125,0.1088429,0.0,297.6271429,297.8714286,293.02,300.1,295.3,4.1,75.64285714,0.0,14.48857143,3.0,24.42857143,5.628571429,27.8,20.6,2.5
+922,sj,2008,4,2008-01-22,-0.0268,-0.2153,0.1126143,0.1602143,81.22,297.9685714,298.1285714,293.6357143,299.5,296.4,27.16,77.16714286,81.22,15.06571429,2.0,24.52857143,4.585714286,27.8,21.1,83.1
+923,sj,2008,5,2008-01-29,,-0.1354,0.2233,0.1709429,0.0,298.0214286,298.1785714,292.9571429,300.7,294.3,2.7,73.56571429,0.0,14.40857143,3.3,24.57142857,6.442857143,28.9,20.0,3.1
+924,sj,2008,6,2008-02-05,-0.1117,-0.0032,0.2328429,0.2711714,0.0,297.2371429,297.2785714,291.5371429,299.3,295.4,19.7,70.64285714,0.0,13.22571429,2.071428571,24.21428571,5.157142857,27.2,21.1,35.9
+925,sj,2008,7,2008-02-12,0.072,-0.0631,0.1502,0.1492714,0.0,297.8385714,297.9071429,292.9414286,299.3,296.5,10.17,74.22857143,0.0,14.36714286,2.157142857,24.8,6.242857143,28.3,21.1,6.4
+926,sj,2008,8,2008-02-19,-0.13865,-0.09506667,0.2460571,0.2281286,0.0,297.9071429,298.0571429,293.1342857,299.6,296.4,8.3,74.78571429,0.0,14.53857143,1.885714286,24.9,5.785714286,28.3,21.7,13.3
+927,sj,2008,9,2008-02-26,,0.01542,0.2116286,0.1173429,0.0,297.7657143,298.0714286,292.5028571,299.9,296.3,6.46,72.66,0.0,13.96714286,2.285714286,24.74285714,5.5,27.8,21.1,12.9
+928,sj,2008,10,2008-03-04,-0.0889,-0.09003333,0.2232429,0.1541857,0.0,297.8785714,298.0071429,293.0528571,299.9,295.5,6.5,74.68142857,0.0,14.47428571,2.614285714,25.11428571,6.114285714,29.4,21.1,13.0
+929,sj,2008,11,2008-03-11,-0.3214,-0.1412,0.1106429,0.1410143,0.0,297.5957143,297.6428571,292.1971429,299.5,296.1,9.38,71.93428571,0.0,13.72142857,2.085714286,25.32857143,5.814285714,28.9,22.2,4.4
+930,sj,2008,12,2008-03-18,0.0449,0.02445,0.1016286,0.088,0.0,297.4042857,297.4357143,292.2057143,299.8,294.9,0.9,72.91571429,0.0,13.73714286,3.871428571,25.2,7.042857143,30.0,20.6,0.5
+931,sj,2008,13,2008-03-25,0.07785,-0.0399,0.3104714,0.2962429,27.19,296.9585714,296.9571429,292.0957143,299.7,294.4,7.55,74.24714286,27.19,13.64428571,2.885714286,25.04285714,5.785714286,30.0,21.1,1.8
+932,sj,2008,14,2008-04-01,-0.038,-0.01683333,0.1193714,0.06638571,3.82,298.0814286,298.2285714,293.2357143,299.8,296.5,3.67,74.6,3.82,14.66285714,2.714285714,26.24285714,6.814285714,30.6,22.2,0.5
+933,sj,2008,15,2008-04-08,-0.1552,-0.05275,0.1377571,0.1412143,16.96,297.46,297.5642857,292.7328571,299.4,295.8,35.0,75.02714286,16.96,14.18428571,2.185714286,25.0,5.714285714,29.4,21.7,30.7
+934,sj,2008,16,2008-04-15,0.0018,,0.2039,0.2098429,0.0,297.63,297.7785714,292.2742857,299.7,295.9,4.82,72.28571429,0.0,13.85857143,2.785714286,25.31428571,6.242857143,29.4,21.7,11.2
+935,sj,2008,17,2008-04-22,-0.037,-0.01036667,0.07731429,0.09058571,0.0,298.6728571,298.6928571,294.28,300.9,295.9,2.17,76.96,0.0,15.67142857,3.957142857,27.04285714,7.514285714,31.7,23.3,0.3
+936,iq,2000,26,2000-07-01,0.1928857,0.1322571,0.3408857,0.2472,25.41,296.74,298.45,295.1842857,307.3,293.1,43.19,92.41857143,25.41,16.65142857,8.928571429,26.4,10.775,32.5,20.7,3.0
+937,iq,2000,27,2000-07-08,0.2168333,0.2761,0.2894571,0.2416571,60.61,296.6342857,298.4285714,295.3585714,306.6,291.1,46.0,93.58142857,60.61,16.86285714,10.31428571,26.9,11.56666667,34.0,20.8,55.6
+938,iq,2000,28,2000-07-15,0.1767571,0.1731286,0.2041143,0.1280143,55.52,296.4157143,297.3928571,295.6228571,304.5,292.6,64.77,95.84857143,55.52,17.12,7.385714286,26.8,11.46666667,33.0,20.7,38.1
+939,iq,2000,29,2000-07-22,0.2277286,0.1454286,0.2542,0.2003143,5.6,295.3571429,296.2285714,292.7971429,303.6,288.6,23.96,87.23428571,5.6,14.43142857,9.114285714,25.76666667,10.53333333,31.5,14.7,30.0
+940,iq,2000,30,2000-07-29,0.3286429,0.3221286,0.2543714,0.3610429,62.76,296.4328571,297.6357143,293.9571429,307.0,291.5,31.8,88.16142857,62.76,15.44428571,9.5,26.6,11.48,33.3,19.1,4.0
+941,iq,2000,31,2000-08-05,0.2055286,0.1907571,0.2316714,0.2553143,16.24,297.1914286,298.2857143,291.7257143,306.2,288.5,1.0,74.72857143,16.24,13.42142857,13.77142857,25.34,10.94,32.0,17.0,11.5
+942,iq,2000,32,2000-08-12,0.3124857,0.3299857,0.3805857,0.3872714,89.37,297.32,298.9785714,293.8214286,308.8,292.1,26.68,83.27571429,89.37,15.31142857,11.47142857,27.01666667,11.65,34.0,19.9,72.9
+943,iq,2000,33,2000-08-19,0.3841333,0.39224,0.34178,0.38275,42.08,297.6271429,299.3357143,293.9928571,307.9,290.6,16.9,82.49,42.08,15.46571429,13.7,26.58333333,10.31666667,33.0,20.5,50.1
+944,iq,2000,34,2000-08-26,0.4081571,0.3221571,0.4067143,0.3027143,49.22,298.2385714,299.5714286,292.9042857,310.1,291.3,5.59,74.74,49.22,14.44428571,13.77142857,26.9,13.4,34.0,19.0,89.2
+945,iq,2000,35,2000-09-02,0.3320429,0.3210571,0.3146143,0.3242571,53.65,299.2185714,300.9285714,293.4728571,310.5,292.9,16.07,74.15142857,53.65,15.05714286,12.45714286,27.11666667,12.26666667,34.0,20.0,78.0
+946,iq,2000,36,2000-09-09,0.2955857,0.2956833,0.3122143,0.2659286,23.12,300.8028571,301.9357143,290.6357143,312.8,291.5,2.5,57.78714286,23.12,12.65285714,14.9,28.36666667,12.9,35.8,21.7,56.9
+947,iq,2000,37,2000-09-16,0.2846571,0.3097571,0.3878833,0.3281571,34.62,299.8585714,301.3714286,293.64,310.7,292.3,4.1,71.66,34.62,15.22714286,13.85714286,27.425,12.775,34.5,20.5,18.9
+948,iq,2000,38,2000-09-23,0.3488143,0.2957167,0.4048429,0.2425714,97.55,297.4357143,298.5142857,292.7071429,310.2,288.3,3.2,77.48714286,97.55,14.33857143,11.31428571,27.53333333,12.56666667,36.0,20.5,104.2
+949,iq,2000,39,2000-09-30,0.1756857,0.09948333,0.2257143,0.1827857,95.89,299.3557143,300.8857143,293.2171429,310.8,290.0,2.6,71.46285714,95.89,14.79857143,14.94285714,27.15,12.175,34.0,20.5,57.9
+950,iq,2000,40,2000-10-07,0.33754,0.2769429,0.2775,0.25505,46.22,298.3728571,300.5,294.6642857,309.8,292.7,16.6,82.37142857,46.22,16.14857143,11.97142857,26.7,11.675,34.0,20.0,63.0
+951,iq,2000,41,2000-10-14,0.2235333,0.1339143,0.3498,0.1009167,31.1,298.4742857,300.2857143,294.5928571,309.2,291.9,21.9,81.52285714,31.1,16.07142857,13.48571429,27.65714286,11.3,34.0,21.0,3.0
+952,iq,2000,42,2000-10-21,0.2748,0.1870571,0.3739429,0.2794714,25.21,299.2114286,301.15,294.0071429,311.8,292.3,9.9,75.54,25.21,15.52857143,14.92857143,27.775,12.275,36.0,21.0,45.2
+953,iq,2000,43,2000-10-28,0.3673,0.30555,0.45538,0.3258,49.25,299.5414286,301.1,294.7085714,310.2,291.9,23.3,76.94142857,49.25,16.19571429,13.45714286,28.0,12.46666667,34.6,20.0,57.9
+954,iq,2000,44,2000-11-04,0.2951,0.21152,0.3044,0.2796167,67.64,299.44,300.8214286,295.2742857,312.2,292.4,20.2,79.42857143,67.64,16.86857143,13.32857143,27.6,12.33333333,35.5,21.1,7.1
+955,iq,2000,45,2000-11-11,0.2713667,0.1515667,0.34725,0.2318667,51.83,300.7485714,301.8071429,295.28,310.4,294.3,19.2,74.80285714,51.83,16.84714286,12.87142857,28.175,12.25,35.2,21.5,13.5
+956,iq,2000,46,2000-11-18,0.09993333,0.03586,0.1954857,0.06418333,39.25,301.6371429,302.6142857,294.2328571,311.8,294.2,3.6,67.18571429,39.25,15.88,13.37142857,29.025,13.1,36.4,21.7,0.0
+957,iq,2000,47,2000-11-25,0.1699833,0.2893,0.3009833,0.1709167,55.91,300.8728571,301.9142857,293.06,311.1,293.6,11.2,66.04285714,55.91,14.76857143,13.14285714,27.7,11.35,36.5,21.5,
+958,iq,2000,48,2000-12-02,0.2519714,0.2538,0.3235143,0.3191,20.65,299.23,301.2642857,294.7171429,310.0,293.5,14.5,78.88571429,20.65,16.24428571,12.01428571,27.05,11.575,34.2,21.0,19.0
+959,iq,2000,49,2000-12-09,0.1658333,0.1824143,0.2545667,0.18625,24.53,300.2428571,301.0285714,293.3057143,312.2,292.0,1.7,68.55714286,24.53,14.9,15.45714286,28.0,12.0,34.0,22.0,0.8
+960,iq,2000,50,2000-12-16,0.3387857,0.3168286,0.3503429,0.2977,111.06,298.7571429,300.3428571,294.52,311.4,291.9,48.76,80.40857143,111.06,16.09857143,11.97142857,26.61666667,9.65,33.8,21.0,67.2
+961,iq,2000,51,2000-12-23,0.2650143,0.1690571,0.2348667,0.3022429,3.9,300.4114286,302.0,291.0928571,311.2,294.6,5.7,60.64142857,3.9,13.18857143,13.0,28.2,12.28333333,35.0,21.0,0.0
+962,iq,2001,1,2001-01-01,0.2547143,0.2285286,0.2505857,0.287,59.11,297.9585714,298.9857143,296.99,305.5,293.2,64.6,94.95571429,59.11,18.67285714,6.942857143,27.33333333,11.0,33.3,21.8,38.9
+963,iq,2001,2,2001-01-08,0.3021333,0.2035167,0.2674333,0.274,69.85,298.0442857,299.4142857,294.3457143,309.8,292.5,22.98,82.34714286,69.85,15.85857143,11.08571429,27.0,11.225,33.2,20.7,59.9
+964,iq,2001,3,2001-01-15,0.1747571,0.1033167,0.2582429,0.1767286,149.71,298.3685714,300.2357143,295.0614286,308.7,294.0,24.92,84.17571429,149.71,16.6,11.01428571,27.05,10.9,33.0,20.5,52.0
+965,iq,2001,4,2001-01-22,0.2376,0.1912667,0.1258571,0.2314429,50.02,295.7228571,296.6714286,294.5942857,301.8,292.3,88.03,94.05714286,50.02,16.07142857,5.628571429,25.71666667,9.433333333,31.2,20.0,166.9
+966,iq,2001,5,2001-01-29,0.3415,0.2606667,0.3293857,0.3690714,87.18,295.2971429,296.1,294.4114286,302.2,292.2,80.95,95.40714286,87.18,15.86,5.142857143,26.43333333,9.666666667,33.0,20.0,147.8
+967,iq,2001,6,2001-02-05,0.2335857,0.161,0.1966143,0.2267,31.93,295.5114286,296.1285714,293.4085714,303.6,292.5,16.4,89.08,31.93,14.94714286,6.171428571,27.35,10.025,34.2,21.7,3.3
+968,iq,2001,7,2001-02-12,0.1554143,0.1350167,0.1485286,0.1571,66.84,295.37,296.4928571,294.4385714,304.4,292.3,37.96,94.88428571,66.84,15.93,6.042857143,26.3,8.95,33.0,21.0,83.1
+969,iq,2001,8,2001-02-19,0.1353714,0.0823,0.1297571,0.1840429,16.17,296.07,296.9785714,294.73,304.4,290.6,34.18,92.84285714,16.17,16.25142857,7.585714286,26.93333333,10.0,33.2,21.0,38.1
+970,iq,2001,9,2001-02-26,0.30764,0.2282167,0.2245,0.2912833,47.14,297.0385714,298.3071429,295.7671429,305.1,293.7,26.96,93.31428571,47.14,17.30857143,7.385714286,26.56,9.48,33.2,20.5,21.1
+971,iq,2001,10,2001-03-05,0.1820429,0.289,0.2068714,0.2063286,118.07,297.6185714,298.6928571,296.46,305.8,294.8,83.89,94.09285714,118.07,18.05571429,6.585714286,27.2,10.15,33.3,20.0,87.1
+972,iq,2001,11,2001-03-12,0.2053833,0.1769,0.2063571,0.2041286,74.34,296.79,298.1285714,295.5442857,309.3,292.8,195.2,94.09428571,74.34,17.06571429,8.285714286,27.05,12.1,34.2,20.0,39.9
+973,iq,2001,12,2001-03-19,0.1883429,0.1950333,0.1635429,0.2841429,90.35,298.7014286,299.75,295.1571429,309.7,293.2,32.6,82.80142857,90.35,16.75714286,10.61428571,27.43333333,11.43333333,34.1,20.0,70.8
+974,iq,2001,13,2001-03-26,0.16238,0.1508167,0.09465714,0.1322571,94.06,296.8528571,297.6,296.0785714,303.2,292.8,304.52,95.92428571,94.06,17.66857143,6.2,27.05,10.95,34.2,20.0,80.0
+975,iq,2001,14,2001-04-02,0.2678143,0.3126429,0.2615,0.2584,86.46,296.3057143,297.8285714,295.6957143,305.5,292.9,91.43,96.73714286,86.46,17.21,6.657142857,27.16,10.98,35.0,20.5,46.2
+976,iq,2001,15,2001-04-09,0.3827571,0.3709714,0.3438857,0.3762714,80.82,297.1757143,298.3,296.13,305.5,292.1,110.1,94.60285714,80.82,17.69571429,6.771428571,26.46,11.66,34.0,19.5,120.1
+977,iq,2001,16,2001-04-16,0.3125429,0.2822143,0.2621286,0.4074857,77.73,297.0628571,298.15,295.9857143,305.1,292.8,120.32,94.61571429,77.73,17.52,7.5,27.34,11.04,33.5,20.4,45.3
+978,iq,2001,17,2001-04-23,0.2456143,0.2148429,0.2733714,0.2288,78.01,297.9614286,299.2071429,295.4285714,307.8,293.2,78.3,88.14857143,78.01,16.96857143,10.24285714,27.63333333,10.93333333,34.3,21.0,14.9
+979,iq,2001,18,2001-04-30,0.2540143,0.179,0.3128286,0.2625571,94.77,297.2857143,298.65,295.74,305.6,293.1,103.87,92.19285714,94.77,17.30571429,7.414285714,27.625,11.325,35.2,20.5,51.0
+980,iq,2001,19,2001-05-07,0.2664571,0.1886,0.1962,0.2273286,45.56,297.1357143,298.2,296.3328571,305.1,292.1,85.9,95.82,45.56,17.89142857,7.085714286,26.6,8.8,32.7,21.4,66.0
+981,iq,2001,20,2001-05-14,0.3153429,0.31965,0.2627,0.3034857,74.08,297.2971429,298.3071429,296.99,305.6,294.7,80.3,98.34142857,74.08,18.64,5.642857143,,,32.5,,0.0
+982,iq,2001,21,2001-05-21,0.2985857,0.3796667,0.1842429,0.2685286,70.81,296.9228571,297.9571429,295.8271429,305.6,293.0,53.1,94.71,70.81,17.36857143,8.542857143,27.43333333,11.93333333,34.2,20.5,64.1
+983,iq,2001,22,2001-05-28,0.2999429,0.3029429,0.3187143,0.3874429,90.07,296.8457143,298.0,295.18,304.8,291.8,20.3,91.46571429,90.07,16.69428571,8.8,27.25,12.65,34.8,20.5,32.0
+984,iq,2001,23,2001-06-04,0.3635667,0.1819143,0.2539714,0.2467286,126.46,296.6914286,297.8928571,294.46,307.6,291.5,30.63,89.48714286,126.46,15.96857143,9.728571429,26.86666667,10.73333333,34.0,19.8,17.0
+985,iq,2001,24,2001-06-11,0.3170833,0.2989667,0.2198714,0.2173429,47.13,295.4828571,296.4357143,294.3414286,302.6,291.9,95.06,94.01714286,47.13,15.78285714,7.271428571,26.88,10.68,33.4,20.0,37.1
+986,iq,2001,25,2001-06-18,0.1041,0.1082429,0.05965714,0.1137571,53.93,296.0,297.3214286,293.6471429,305.2,291.0,13.45,88.17142857,53.93,15.13428571,9.414285714,26.4,10.05,33.2,20.5,9.9
+987,iq,2001,26,2001-06-25,0.1923,0.2752857,0.3164571,0.3254143,1.22,294.8457143,296.0,290.5728571,306.1,288.4,1.82,79.32285714,1.22,12.46428571,12.34285714,,,32.3,17.1,31.0
+988,iq,2001,27,2001-07-02,0.2290833,0.1932667,0.2704571,0.2421857,52.1,295.7957143,297.05,292.7528571,305.0,291.3,23.6,84.85714286,52.1,14.29714286,8.557142857,26.5,11.36666667,33.2,20.0,70.1
+989,iq,2001,28,2001-07-09,0.3597167,0.3110571,0.2649857,0.4388429,39.09,295.8085714,297.0214286,293.4385714,307.2,290.3,16.7,88.32285714,39.09,14.92857143,9.7,27.35,10.95,33.5,19.5,22.3
+990,iq,2001,29,2001-07-16,0.3195,0.2050857,0.1947429,0.3616333,52.05,297.5557143,298.9285714,294.1157143,307.9,291.1,18.0,84.24571429,52.05,15.60571429,11.42857143,26.76666667,10.06666667,32.8,21.0,36.8
+991,iq,2001,30,2001-07-23,0.2911571,0.2526333,0.2182,0.3259857,54.52,296.8157143,298.2214286,294.9914286,306.0,292.0,38.29,90.81428571,54.52,16.50571429,10.27142857,27.36666667,11.4,34.0,21.2,25.2
+992,iq,2001,31,2001-07-30,0.2371167,0.1956167,0.1883143,0.1339,27.97,297.2914286,299.1785714,293.4528571,308.1,289.8,9.71,82.22571429,27.97,14.98571429,12.87142857,26.52,10.88,34.0,18.4,10.9
+993,iq,2001,32,2001-08-06,0.2007571,0.2377286,0.2236429,0.2043571,0.0,298.5371429,300.1357143,291.3871429,308.7,291.0,0.2,66.66428571,0.0,13.15857143,14.64285714,27.1,12.175,33.5,17.8,
+994,iq,2001,33,2001-08-13,0.2821714,0.2735571,0.2658571,0.3664571,5.14,298.3957143,299.7857143,292.0242857,309.7,292.0,0.0,69.47571429,5.14,13.71571429,13.31428571,27.125,12.25,33.4,20.0,18.0
+995,iq,2001,34,2001-08-20,0.2407571,0.1931143,0.2063429,0.2469143,9.97,298.44,299.8142857,294.0171429,308.8,291.7,30.1,78.38857143,9.97,15.51142857,12.2,27.6,11.68,34.2,20.0,47.9
+996,iq,2001,35,2001-08-27,0.2280714,0.1999857,0.2331429,0.2646429,47.58,298.7514286,300.5142857,293.7257143,311.2,293.0,16.9,76.95571429,47.58,15.25142857,12.8,27.2,12.46666667,35.2,20.0,31.0
+997,iq,2001,36,2001-09-03,0.30695,0.2410286,0.1908714,0.3389429,44.45,298.6914286,300.5214286,294.9057143,311.2,291.7,39.8,81.98714286,44.45,16.43714286,13.44285714,27.375,12.15,34.3,20.8,35.1
+998,iq,2001,37,2001-09-10,0.3084571,0.2503143,0.2983,0.4290714,36.2,298.6657143,300.1214286,294.1228571,311.5,290.9,19.6,78.95714286,36.2,15.65857143,13.78571429,27.375,11.525,35.2,20.1,41.9
+999,iq,2001,38,2001-09-17,0.3533143,0.3439714,0.3586714,0.3530429,66.4,297.9628571,299.4214286,294.5971429,309.0,292.9,65.54,84.03285714,66.4,16.10428571,10.92857143,27.525,12.75,35.0,20.2,69.0
+1000,iq,2001,39,2001-09-24,0.3346714,0.3886143,0.2854,0.3197714,26.48,298.7071429,300.9071429,294.2957143,310.4,291.7,21.9,79.36571429,26.48,15.89428571,14.04285714,27.25,11.925,33.4,20.3,13.2
+1001,iq,2001,40,2001-10-01,0.3343857,0.2712857,0.2416857,0.4444,63.42,299.5471429,300.7071429,294.7685714,311.0,291.8,32.6,78.33,63.42,16.34,14.12857143,28.3,13.34,35.5,20.4,14.2
+1002,iq,2001,41,2001-10-08,0.4202857,0.3819571,0.4438,0.5460167,58.75,299.1585714,300.2857143,293.8128571,312.3,290.8,12.3,74.41857143,58.75,15.32714286,11.34285714,28.525,12.475,36.8,21.8,30.9
+1003,iq,2001,42,2001-10-15,0.3102,0.2971286,0.3454857,0.3820571,77.89,300.3085714,302.2,294.2142857,312.9,292.4,49.2,72.16285714,77.89,15.87285714,12.88571429,27.63333333,12.53333333,36.7,20.0,159.0
+1004,iq,2001,43,2001-10-22,0.1244833,0.2392667,0.1845,0.2055714,77.15,298.5842857,300.0714286,296.6071429,310.6,293.9,114.36,90.26571429,77.15,18.26714286,9.857142857,28.06666667,11.96666667,35.0,21.0,89.1
+1005,iq,2001,44,2001-10-29,0.2108857,0.2075667,0.2066143,0.232,83.53,298.3414286,299.5071429,295.3057143,308.8,292.0,46.46,85.57285714,83.53,16.95857143,11.27142857,27.64,10.38,35.8,21.5,76.0
+1006,iq,2001,45,2001-11-05,0.3581429,0.2793429,0.3059714,0.3714,34.54,298.5142857,299.75,296.1957143,309.7,292.5,164.74,89.00428571,34.54,17.82142857,10.1,27.525,11.025,34.4,21.3,35.1
+1007,iq,2001,46,2001-11-12,0.2773286,0.2303,0.2773,0.2969714,61.82,298.8471429,300.5785714,296.1985714,310.5,294.0,181.2,87.48142857,61.82,17.8,9.7,28.44,10.18,34.5,21.0,43.9
+1008,iq,2001,47,2001-11-19,0.3297,0.3304167,0.3406429,0.4415714,65.89,299.12,300.4857143,296.7528571,309.5,294.2,56.3,88.83714286,65.89,18.45142857,9.228571429,27.575,11.575,33.7,20.8,31.0
+1009,iq,2001,48,2001-11-26,0.3015,0.3613,0.3055714,0.3699167,47.46,298.5557143,299.6357143,295.8114286,310.0,294.4,31.5,87.37714286,47.46,17.42714286,8.014285714,28.23333333,11.66666667,35.3,21.8,12.2
+1010,iq,2001,49,2001-12-03,0.3250571,0.2264714,0.2992571,0.3504714,46.86,298.7542857,300.2214286,295.9814286,308.5,294.6,158.5,87.24,46.86,17.59571429,8.871428571,28.425,11.65,35.5,21.2,23.1
+1011,iq,2001,50,2001-12-10,0.3260333,0.2355333,0.3155714,0.3066429,138.22,298.2457143,299.5928571,297.5,305.8,293.9,72.94,96.11857143,138.22,19.30571429,7.785714286,27.84,10.96,35.0,21.0,75.0
+1012,iq,2001,51,2001-12-17,0.2229429,0.2240714,0.2128143,0.1841286,43.95,298.5642857,299.6785714,297.2114286,309.3,295.1,85.9,93.94714286,43.95,18.96571429,7.385714286,27.075,9.5,32.9,21.0,57.9
+1013,iq,2001,52,2001-12-24,0.2981889,0.3380778,0.2887889,0.3417,100.72,298.2385714,299.35,297.5114286,306.7,294.7,109.64,96.35571429,100.72,19.30285714,6.5,27.35,8.65,33.3,22.0,25.1
+1014,iq,2002,1,2002-01-01,0.4057286,0.3484,0.3686429,0.3800143,70.16,297.1328571,297.8714286,296.06,304.5,292.5,109.8,94.58857143,70.16,17.61857143,5.942857143,27.95,9.45,33.2,23.0,45.3
+1015,iq,2002,2,2002-01-08,0.3275833,0.3759167,0.4102667,0.3833333,64.79,300.0128571,301.2714286,294.9128571,309.8,294.8,5.5,76.60285714,64.79,16.48285714,11.4,28.96666667,11.93333333,35.4,21.0,7.1
+1016,iq,2002,3,2002-01-15,0.2410857,0.14565,0.2780286,0.1976429,22.77,299.8771429,300.9071429,294.6057143,309.4,291.8,4.7,75.20428571,22.77,16.15714286,12.12857143,28.8,12.76666667,36.0,22.0,5.0
+1017,iq,2002,4,2002-01-22,0.1041286,0.1483286,0.1121857,0.1419143,121.07,298.9157143,299.8785714,295.11,308.7,293.2,19.91,81.52714286,121.07,16.67714286,10.21428571,27.94,11.8,35.8,21.0,18.0
+1018,iq,2002,5,2002-01-29,,,,,59.4,296.8585714,297.9,296.1371429,304.2,294.1,43.12,96.26714286,59.4,17.69,5.228571429,26.3,9.7,32.5,20.8,120.2
+1019,iq,2002,6,2002-02-05,0.1849167,0.1733286,0.1687429,0.1844286,4.68,295.9128571,296.6928571,295.2314286,304.2,292.0,69.96,96.64142857,4.68,16.72285714,5.185714286,26.625,9.725,34.0,20.8,70.4
+1020,iq,2002,7,2002-02-12,0.2919714,0.2241429,0.3051,0.3732714,104.37,297.8471429,299.2928571,296.5442857,304.7,294.5,33.3,93.43857143,104.37,18.14714286,7.7,27.85,10.725,33.6,20.8,62.8
+1021,iq,2002,8,2002-02-19,0.1288,0.1224333,0.09594286,0.1251714,37.46,297.6957143,299.0214286,296.1228571,305.5,293.9,49.43,92.05,37.46,17.68714286,7.728571429,27.02,9.78,33.5,21.0,14.0
+1022,iq,2002,9,2002-02-26,0.1162,0.1787429,0.08991429,0.2104143,80.14,297.0628571,298.1928571,296.5142857,305.0,294.5,201.2,97.15714286,80.14,18.12571429,5.814285714,26.7,9.6,32.2,20.5,47.6
+1023,iq,2002,10,2002-03-05,0.3183667,0.2556,0.266,0.2973833,92.84,298.54,299.9571429,296.6985714,308.8,294.5,160.1,91.22142857,92.84,18.36142857,8.971428571,27.85,13.2,35.7,21.0,48.3
+1024,iq,2002,11,2002-03-12,0.2483857,0.1795,0.2698143,0.2992333,41.96,298.3585714,300.15,296.2385714,309.2,293.8,46.9,89.77857143,41.96,17.79571429,9.414285714,26.95,10.45,34.5,21.6,9.1
+1025,iq,2002,12,2002-03-19,0.2265857,0.2483333,0.2302,0.2435143,61.18,297.9514286,299.2428571,296.81,305.8,294.1,92.4,94.16571429,61.18,18.44285714,7.371428571,26.95,11.775,33.3,20.6,76.8
+1026,iq,2002,13,2002-03-26,0.2127857,0.27455,0.1987,0.2284571,110.42,296.4071429,297.2142857,296.1085714,303.6,293.9,127.9,98.45714286,110.42,17.68,4.4,26.1,10.3,32.3,20.7,49.0
+1027,iq,2002,14,2002-04-02,0.19708,0.2962286,0.1805,0.2763286,94.01,297.1742857,298.0642857,296.7414286,303.9,294.5,122.3,97.77571429,94.01,18.39571429,6.185714286,27.3,10.4,32.5,20.2,20.1
+1028,iq,2002,15,2002-04-09,0.2698286,0.1968143,0.2025857,0.2662857,75.98,296.8628571,297.7,296.3514286,303.3,294.1,187.8,97.24428571,75.98,17.93,5.142857143,26.3,9.4,31.4,20.8,13.0
+1029,iq,2002,16,2002-04-16,0.26935,0.2121571,0.1889286,0.1949429,109.49,297.7642857,298.9214286,296.31,305.0,294.4,49.8,92.61571429,109.49,17.93571429,6.728571429,27.2,13.0,34.6,20.3,
+1030,iq,2002,17,2002-04-23,0.2678429,0.2614143,0.2485,0.2669286,45.59,297.5842857,298.8142857,296.6314286,305.2,293.9,96.1,95.25142857,45.59,18.22285714,7.314285714,27.26666667,10.7,33.3,21.7,53.9
+1031,iq,2002,18,2002-04-30,0.1703571,0.1418286,0.1977286,0.2570714,60.05,297.4085714,298.55,296.2228571,303.8,292.8,52.6,93.84571429,60.05,17.80714286,7.5,,,33.5,21.2,1.0
+1032,iq,2002,19,2002-05-07,0.2272571,0.1782429,0.1773857,0.2101143,101.3,297.3557143,298.4357143,296.4442857,304.4,293.0,66.85,95.22,101.3,18.02428571,8.042857143,27.5,11.525,34.0,21.3,25.4
+1033,iq,2002,20,2002-05-14,0.1338,0.1096333,0.2196143,0.1417,46.79,296.7842857,297.5857143,296.2214286,303.7,293.9,93.4,97.24285714,46.79,17.74428571,5.085714286,26.86666667,9.7,32.3,20.8,543.3
+1034,iq,2002,21,2002-05-21,0.1921143,0.1776429,0.2308571,0.2222,51.25,297.05,298.6214286,296.0242857,306.2,292.7,32.3,94.80428571,51.25,17.58428571,8.5,27.7,12.15,33.8,20.8,9.1
+1035,iq,2002,22,2002-05-28,0.1764571,0.1749143,0.1881571,0.2386286,41.54,297.5571429,298.7142857,296.2714286,305.9,292.4,58.02,93.78857143,41.54,17.82285714,7.657142857,26.325,9.775,32.3,20.8,146.7
+1036,iq,2002,23,2002-06-04,0.3204714,0.2780857,0.2377286,0.3431857,72.76,296.2671429,297.0857143,295.2357143,305.3,291.5,19.12,94.34571429,72.76,16.77428571,8.742857143,27.3,11.63333333,34.3,20.7,28.0
+1037,iq,2002,24,2002-06-11,0.3862667,0.2591333,0.3284143,0.3916286,69.62,297.2571429,298.9714286,296.1071429,305.8,293.4,39.48,94.14428571,69.62,17.63857143,8.971428571,27.8,11.5,34.0,20.7,1.0
+1038,iq,2002,25,2002-06-18,0.2212714,0.1735143,0.2119714,0.2252143,39.16,296.8071429,297.5142857,293.8714286,306.4,288.4,22.95,85.73714286,39.16,15.41428571,10.71428571,26.23333333,8.733333333,33.0,18.8,31.0
+1039,iq,2002,26,2002-06-25,0.1791714,0.2791,0.1326143,0.2132857,3.18,295.8085714,296.9071429,292.1471429,305.3,290.0,14.1,82.16714286,3.18,13.87,10.72857143,26.15,10.8,32.6,18.6,7.1
+1040,iq,2002,27,2002-07-02,0.1015429,0.1266,0.1193571,0.07624286,3.27,294.6357143,294.8928571,291.7942857,305.1,287.4,6.2,85.56571429,3.27,13.45428571,8.7,26.275,9.5,32.6,20.7,5.1
+1041,iq,2002,28,2002-07-09,0.21602,0.2350667,0.1511857,0.2129714,5.71,295.8828571,297.0357143,292.95,307.1,291.2,8.7,85.67285714,5.71,14.46428571,8.785714286,26.13333333,10.63333333,32.3,20.3,26.3
+1042,iq,2002,29,2002-07-16,0.1080429,0.07298571,0.1112286,0.1179714,63.0,296.4428571,297.7428571,293.3271429,306.3,290.6,8.3,84.66857143,63.0,14.81857143,11.17142857,25.4,9.0,30.1,20.1,0.0
+1043,iq,2002,30,2002-07-23,0.2225,0.2631,0.2489857,0.3464714,65.55,296.8757143,298.3,293.4228571,307.4,288.3,12.41,83.49714286,65.55,14.93,11.97142857,27.8,11.6,33.6,19.5,68.1
+1044,iq,2002,31,2002-07-30,0.3870143,0.2601714,0.3492714,0.2830571,89.93,297.1614286,298.7285714,294.6242857,308.5,292.8,23.33,87.03428571,89.93,16.07571429,10.6,26.7,11.14,33.8,19.3,35.6
+1045,iq,2002,32,2002-08-06,0.3041167,0.2788429,0.3074571,0.3378429,14.34,296.7957143,298.6428571,292.6742857,308.0,289.1,5.44,80.47,14.34,14.24571429,13.45714286,27.25,12.8,34.0,20.2,0.0
+1046,iq,2002,33,2002-08-13,0.3771571,0.3059,0.2884,0.3608429,9.81,298.3042857,299.3357143,291.6785714,308.9,290.8,1.7,69.06,9.81,13.44142857,14.38571429,27.83333333,12.23333333,35.1,20.6,7.1
+1047,iq,2002,34,2002-08-20,0.345425,0.31354,0.29505,0.3092667,31.71,296.1842857,296.7357143,292.4514286,308.6,288.8,5.61,82.14142857,31.71,14.04571429,12.75714286,,,33.1,20.8,70.6
+1048,iq,2002,35,2002-08-27,0.3045429,0.2694429,0.2508571,0.3224714,38.8,298.4128571,299.9857143,293.8742857,310.3,291.6,10.7,77.76571429,38.8,15.41285714,12.8,27.4,11.15,35.1,20.9,24.1
+1049,iq,2002,36,2002-09-03,0.2290143,0.1319714,0.2494571,0.1908857,81.85,299.3957143,300.6785714,294.5314286,310.5,293.9,13.1,77.08285714,81.85,16.03428571,11.92857143,27.4,10.475,33.3,21.7,17.0
+1050,iq,2002,37,2002-09-10,0.3075429,0.2941714,0.3234,0.1907714,25.36,299.0157143,300.2071429,293.2114286,310.0,290.0,3.2,73.14142857,25.36,14.74571429,14.04285714,28.23333333,13.23333333,35.9,19.9,89.9
+1051,iq,2002,38,2002-09-17,0.3274143,0.3472571,0.3386714,0.3838714,11.49,300.32,301.0428571,292.2714286,311.2,291.8,0.8,64.68857143,11.49,13.97428571,16.02857143,28.9,12.7,36.6,21.5,0.8
+1052,iq,2002,39,2002-09-24,0.2379833,0.3084286,0.2681143,0.3200429,38.56,299.2385714,301.1142857,294.4142857,312.6,291.5,41.1,79.56285714,38.56,16.18,13.17142857,27.9,12.2,36.0,20.4,86.9
+1053,iq,2002,40,2002-10-01,0.2721143,0.1793667,0.3142429,0.2741714,70.98,299.6542857,301.2357143,293.8142857,313.2,291.8,24.1,74.25,70.98,15.63428571,13.75714286,29.2,14.13333333,37.7,21.7,74.2
+1054,iq,2002,41,2002-10-08,0.37815,0.3857833,0.2314286,0.2459333,70.22,298.7171429,300.55,295.6614286,310.6,293.4,34.4,85.13714286,70.22,17.21142857,12.52857143,28.075,11.45,34.6,21.8,79.8
+1055,iq,2002,42,2002-10-15,0.1992714,0.1592429,0.2581286,0.2277143,21.96,298.2971429,299.7142857,295.5857143,308.8,292.1,40.7,86.99857143,21.96,17.18571429,10.65714286,28.0,11.63333333,34.2,22.0,4.5
+1056,iq,2002,43,2002-10-22,0.2278714,0.2144571,0.2997714,0.2229429,48.94,297.3314286,298.15,294.9614286,304.5,292.5,35.4,87.71714286,48.94,16.49,8.5,27.95,10.3,36.0,21.8,167.8
+1057,iq,2002,44,2002-10-29,0.3290857,0.2862143,0.2940571,0.3159286,89.77,298.5185714,300.2428571,296.9,307.3,294.9,39.7,91.94428571,89.77,18.60285714,9.028571429,,,34.1,22.5,34.1
+1058,iq,2002,45,2002-11-05,0.3071429,0.27695,0.2879286,0.3642857,95.47,297.5371429,298.6571429,296.6371429,306.5,293.9,124.2,95.28571429,95.47,18.26714286,6.514285714,28.3,11.0,33.8,22.6,63.9
+1059,iq,2002,46,2002-11-12,0.2368333,0.2021571,0.2095143,0.1620286,91.36,297.1657143,298.0214286,296.3228571,306.6,293.9,91.33,96.04714286,91.36,17.90714286,5.471428571,27.6,10.7,33.6,21.4,212.6
+1060,iq,2002,47,2002-11-19,0.2506143,0.2791333,0.2156333,0.2982667,61.69,297.3757143,298.8285714,296.7814286,305.9,294.4,85.8,96.84,61.69,18.41571429,7.4,27.35,8.9,33.5,21.7,77.0
+1061,iq,2002,48,2002-11-26,0.3109286,0.2852286,0.2907286,0.2563286,60.15,298.35,299.8928571,297.0728571,309.5,292.0,56.92,93.39571429,60.15,18.78428571,10.38571429,28.1,10.55,34.0,22.0,17.2
+1062,iq,2002,49,2002-12-03,0.3008,0.2528,0.3449571,0.3483286,49.69,298.3242857,299.6571429,296.4857143,306.8,294.3,49.2,90.66285714,49.69,18.10571429,8.0,28.5,9.75,33.7,22.9,46.0
+1063,iq,2002,50,2002-12-10,0.2680286,0.1424286,0.2886714,0.1850714,35.02,297.8842857,298.95,296.39,307.4,294.2,30.89,92.61428571,35.02,18.00428571,7.928571429,27.65,9.45,34.0,22.9,57.2
+1064,iq,2002,51,2002-12-17,0.2542286,0.1839143,0.2707143,0.2090286,25.73,297.8185714,299.0571429,296.6271429,306.0,294.8,24.3,93.84571429,25.73,18.26142857,6.857142857,27.98,8.72,34.0,23.3,24.0
+1065,iq,2002,52,2002-12-24,0.1194,0.1364,0.1718286,0.1895857,151.73,297.8728571,299.1714286,296.63,305.7,293.8,54.7,93.40857143,151.73,18.23571429,8.0,27.975,10.65,33.8,21.9,137.9
+1066,iq,2003,1,2003-01-01,0.3234143,0.3004143,0.3291857,0.3184286,46.91,299.3757143,300.8214286,295.8714286,308.6,293.1,28.3,84.06,46.91,17.45285714,12.1,28.45,9.95,34.4,22.4,92.9
+1067,iq,2003,2,2003-01-08,0.4884,0.4024429,0.4149286,0.4697,11.77,297.6842857,299.1714286,295.9442857,308.6,291.5,33.6,91.56,11.77,17.49714286,8.428571429,28.93333333,10.2,35.0,22.1,35.1
+1068,iq,2003,3,2003-01-15,0.303,0.1694667,0.2915429,0.3012857,60.46,296.92,298.6142857,295.9014286,305.2,293.4,27.9,94.37428571,60.46,17.43,7.742857143,28.0,9.5,33.3,22.5,164.4
+1069,iq,2003,4,2003-01-22,0.2249571,0.2602714,0.2069286,0.2895,84.05,298.1257143,299.5642857,295.0014286,307.7,291.6,8.8,84.46,84.05,16.51428571,10.27142857,28.4,10.6,34.2,23.0,67.1
+1070,iq,2003,5,2003-01-29,0.1660286,0.1406286,0.1913857,0.1834429,35.05,299.4871429,300.2428571,294.0128571,310.0,292.5,6.26,74.88428571,35.05,15.59285714,11.77142857,28.6,12.0,35.4,22.5,7.9
+1071,iq,2003,6,2003-02-05,0.19145,0.08642857,0.1368,0.1567143,56.36,297.2185714,298.4,296.2185714,304.9,292.0,170.6,94.55285714,56.36,17.85285714,7.457142857,26.6,7.0,33.8,22.4,41.9
+1072,iq,2003,7,2003-02-12,0.3137143,0.2284143,0.2521143,0.2864714,70.63,296.5857143,297.6714286,295.52,302.9,293.2,38.7,94.35428571,70.63,17.01571429,6.028571429,26.75,8.35,33.2,22.4,55.9
+1073,iq,2003,8,2003-02-19,0.1262571,0.1355143,0.1036571,0.1337143,25.03,298.5671429,300.1,296.3928571,308.6,292.5,41.1,89.97428571,25.03,18.02,10.88571429,,,32.4,23.3,121.9
+1074,iq,2003,9,2003-02-26,0.2976,0.2366333,0.22915,0.2072833,132.2,299.35,300.5142857,296.41,308.6,294.4,53.6,86.01285714,132.2,18.04428571,9.114285714,29.4,11.2,35.0,22.9,0.0
+1075,iq,2003,10,2003-03-05,0.1695286,0.1389571,0.2340571,0.1851429,63.71,297.5085714,298.8928571,295.9428571,306.6,294.3,134.46,92.46857143,63.71,17.5,7.9,27.95,9.1,32.9,22.9,5.0
+1076,iq,2003,11,2003-03-12,0.2,0.1902857,0.1589429,0.1636286,47.97,296.68,297.6357143,295.9414286,305.9,292.4,186.8,96.17142857,47.97,17.51571429,6.242857143,26.7,7.5,32.0,22.1,98.4
+1077,iq,2003,12,2003-03-19,0.2142143,0.2251571,0.2191714,0.2485,109.04,297.8928571,299.1714286,296.6328571,308.9,293.4,362.03,93.62857143,109.04,18.25285714,8.342857143,27.6,9.9,33.5,22.7,61.9
+1078,iq,2003,13,2003-03-26,0.1475286,0.2694571,0.1268571,0.2059143,93.61,298.6442857,300.3928571,296.8185714,308.1,294.3,44.5,91.59428571,93.61,18.48428571,9.471428571,30.8,15.8,42.2,21.8,75.9
+1079,iq,2003,14,2003-04-02,0.2482,0.2627714,0.2065,0.2886857,89.38,298.0771429,299.6428571,296.6428571,307.5,292.9,44.72,93.01428571,89.38,18.27857143,9.342857143,28.26,9.96,34.2,22.6,75.0
+1080,iq,2003,15,2003-04-09,0.2052429,0.1842,0.1931286,0.2087857,78.59,298.0828571,298.9714286,297.3585714,305.9,293.9,86.23,96.27,78.59,19.07857143,7.028571429,28.175,9.675,34.5,22.9,79.0
+1081,iq,2003,16,2003-04-16,0.2668286,0.2182286,0.1998714,0.2621429,51.14,296.7471429,297.5214286,295.99,304.0,293.2,43.85,95.99285714,51.14,17.53428571,4.757142857,27.72,8.48,34.2,22.4,49.0
+1082,iq,2003,17,2003-04-23,0.3234429,0.2531714,0.2852286,0.2931,77.34,297.9928571,299.4785714,296.5014286,306.3,293.4,56.6,92.54714286,77.34,18.15571429,8.385714286,28.2,10.45,33.9,21.8,82.9
+1083,iq,2003,18,2003-04-30,0.4350571,0.3769143,0.2636143,0.3348429,65.43,296.6914286,297.5857143,296.16,304.5,294.0,247.6,97.27714286,65.43,17.68857143,5.085714286,27.2,8.333333333,32.9,22.7,105.9
+1084,iq,2003,19,2003-05-07,0.1994286,0.1501,0.1834667,0.1477,138.05,296.4542857,297.9642857,295.7042857,305.2,292.9,59.5,96.14,138.05,17.22285714,7.157142857,28.35,9.316666667,33.6,23.4,69.0
+1085,iq,2003,20,2003-05-14,0.2454286,0.1847,0.2614571,0.2688857,84.16,294.9228571,295.2428571,294.5671429,301.5,290.1,95.3,98.13285714,84.16,16.08571429,4.771428571,27.0,8.8,32.5,22.0,246.2
+1086,iq,2003,21,2003-05-21,0.1892571,0.16695,0.1843,0.1707429,23.7,295.8785714,296.8357143,295.0357143,304.1,291.6,34.56,95.85428571,23.7,16.51571429,6.757142857,27.46666667,8.9,32.5,22.3,145.8
+1087,iq,2003,22,2003-05-28,0.2411429,0.1987,0.2537286,0.2544571,166.52,297.6485714,298.9714286,296.08,306.1,293.3,113.8,92.46142857,166.52,17.61857143,9.314285714,27.7,8.72,35.0,22.4,187.9
+1088,iq,2003,23,2003-06-04,0.2369571,0.1213143,0.1923143,0.2074,70.25,296.5914286,297.7571429,296.1271429,303.9,294.2,40.7,97.61714286,70.25,17.65142857,5.514285714,27.2,8.15,33.4,22.4,72.1
+1089,iq,2003,24,2003-06-11,0.3135857,0.3539833,0.2658571,0.2809143,98.72,296.8371429,297.8071429,296.1171429,303.4,292.8,61.8,96.22285714,98.72,17.66857143,7.071428571,27.7,9.575,33.2,21.6,107.0
+1090,iq,2003,25,2003-06-18,0.3237,0.2755,0.3547571,0.2723143,47.15,296.0085714,296.7571429,293.9785714,304.9,291.0,5.56,90.04857143,47.15,15.47714286,8.914285714,27.525,10.725,33.5,21.8,40.4
+1091,iq,2003,26,2003-06-25,0.1882571,0.2322667,0.1737714,0.1928,88.88,295.3871429,296.3571429,294.5428571,303.7,291.8,38.1,95.57571429,88.88,15.98571429,6.542857143,26.95,9.45,32.7,21.9,93.5
+1092,iq,2003,27,2003-07-02,0.2618143,0.1715857,0.3099429,0.2584286,61.09,295.1285714,295.9928571,294.0371429,305.5,291.7,42.5,94.12714286,61.09,15.51142857,6.5,25.86666667,7.5,33.8,21.7,79.3
+1093,iq,2003,28,2003-07-09,0.1802714,0.1629714,0.1541286,0.1611,53.58,296.9428571,298.3071429,294.1542857,307.3,291.4,13.55,86.65571429,53.58,15.61857143,10.1,27.075,10.875,33.2,20.7,1.5
+1094,iq,2003,29,2003-07-16,0.1935714,0.16885,0.1590857,0.2314714,65.2,296.79,298.1714286,293.6428571,306.6,287.3,27.06,85.61142857,65.2,15.29714286,12.0,27.66666667,10.83333333,33.4,17.4,23.8
+1095,iq,2003,30,2003-07-23,0.2858143,0.1630714,0.2880286,0.2774571,2.64,296.4857143,298.0428571,291.85,305.4,289.2,6.39,77.80428571,2.64,13.55857143,11.42857143,26.46666667,10.36666667,32.1,18.0,9.9
+1096,iq,2003,31,2003-07-30,0.2077857,0.1562143,0.1743286,0.2188143,24.64,296.8228571,298.3571429,293.1842857,306.9,291.2,12.0,82.27,24.64,14.68571429,10.31428571,27.225,9.9,32.4,21.3,69.1
+1097,iq,2003,32,2003-08-06,0.2443714,0.1746429,0.2174143,0.2323,89.28,297.6585714,298.55,293.0457143,308.2,290.8,6.5,77.86142857,89.28,14.58428571,12.64285714,27.85,11.2,34.2,21.3,117.0
+1098,iq,2003,33,2003-08-13,0.2471143,0.1711143,0.2337429,0.2638,52.47,297.3385714,298.2714286,294.1185714,307.0,291.3,21.0,83.92714286,52.47,15.58857143,10.65714286,27.4,10.05,34.4,21.7,79.0
+1099,iq,2003,34,2003-08-20,0.4252429,0.3624833,0.3566143,0.3855286,45.38,297.3657143,298.8571429,293.5114286,308.1,292.0,35.1,81.94285714,45.38,15.01,10.05714286,27.75,11.9,34.0,20.0,18.3
+1100,iq,2003,35,2003-08-27,0.2495857,0.2122,0.2508143,0.2652143,29.51,297.8757143,299.6714286,294.9328571,306.6,291.2,18.03,85.72571429,29.51,16.44571429,10.88571429,28.0,12.1,34.4,21.4,95.7
+1101,iq,2003,36,2003-09-03,0.3417,0.2863143,0.2101857,0.2659857,8.84,297.3814286,298.4428571,290.97,309.5,289.1,33.5,70.92857143,8.84,12.94714286,12.77142857,26.65,11.9,33.9,18.5,0.8
+1102,iq,2003,37,2003-09-10,0.2232286,0.2028714,0.1952571,0.2701857,36.42,298.8314286,300.1928571,293.9271429,310.2,292.0,6.0,76.53285714,36.42,15.44714286,12.67142857,27.83333333,12.3,34.3,21.0,53.1
+1103,iq,2003,38,2003-09-17,0.3644857,0.2609857,0.3164571,0.3851571,55.73,296.9485714,297.7071429,293.6842857,310.6,288.2,115.2,85.03,55.73,15.31142857,10.75714286,27.8,11.6,35.3,16.8,92.3
+1104,iq,2003,39,2003-09-24,0.4011857,0.3545167,0.3276714,0.3920429,100.55,298.1442857,299.2928571,295.7371429,307.9,293.0,53.36,88.11714286,100.55,17.26285714,9.471428571,28.03333333,10.63333333,34.7,21.8,27.2
+1105,iq,2003,40,2003-10-01,0.2535,0.2371143,0.2290286,0.2321714,74.6,299.3571429,300.7,295.8285714,310.6,292.9,253.3,83.68285714,74.6,17.45142857,11.6,28.575,12.175,35.5,21.8,34.5
+1106,iq,2003,41,2003-10-08,0.1760286,0.1963833,0.2257571,0.2349286,38.3,297.9157143,299.8857143,296.3128571,309.0,292.5,42.5,92.16571429,38.3,17.91428571,11.2,27.2,9.35,35.7,22.3,138.2
+1107,iq,2003,42,2003-10-15,0.2758286,0.2288429,0.2752,0.2871143,44.16,298.1628571,299.35,296.2014286,305.6,293.8,34.6,90.34285714,44.16,17.79714286,8.528571429,28.3,10.65,34.4,22.9,36.0
+1108,iq,2003,43,2003-10-22,0.4750143,0.3795,0.4249429,0.4324429,39.52,298.9571429,300.6785714,296.2242857,311.2,294.6,41.2,87.37,39.52,17.89571429,9.957142857,27.975,10.475,34.5,20.7,32.1
+1109,iq,2003,44,2003-10-29,0.1345143,0.1314714,0.1153571,0.1212714,32.47,300.0414286,300.8428571,295.2957143,310.1,292.3,6.1,77.78428571,32.47,16.87285714,12.08571429,28.73333333,11.13333333,35.5,22.8,56.4
+1110,iq,2003,45,2003-11-05,0.3946571,0.3269571,0.3912143,0.4190429,105.14,298.1357143,299.9571429,295.74,310.8,292.3,85.3,88.48,105.14,17.39,9.428571429,27.6,9.566666667,34.0,21.9,139.7
+1111,iq,2003,46,2003-11-12,0.3176857,0.3246,0.2498,0.3244714,31.08,298.3671429,300.1714286,295.6457143,308.4,290.9,36.4,86.75571429,31.08,17.29285714,10.62857143,28.5,10.85,35.5,20.8,79.0
+1112,iq,2003,47,2003-11-19,0.2636429,0.2816571,0.2466667,0.3012571,123.63,298.6814286,300.1071429,296.7257143,307.0,294.8,40.8,90.88285714,123.63,18.37857143,9.042857143,27.9,10.55,36.0,22.4,284.4
+1113,iq,2003,48,2003-11-26,0.2749,0.2452,0.3094571,0.2953286,81.27,299.2228571,299.6071429,296.53,308.5,294.3,51.4,86.99571429,81.27,18.27,9.071428571,28.3,10.23333333,34.7,22.0,26.2
+1114,iq,2003,49,2003-12-03,0.4003429,0.3180571,0.3287714,0.3696429,72.23,298.3157143,299.7357143,296.1357143,309.4,293.5,77.83,89.20714286,72.23,17.74571429,9.7,28.76666667,10.16666667,35.1,22.0,138.0
+1115,iq,2003,50,2003-12-10,0.3586286,0.24435,0.3519,0.3588,108.62,298.6857143,300.25,297.3385714,306.4,294.8,178.89,93.23142857,108.62,19.10714286,8.271428571,28.4,11.7,34.2,22.5,47.4
+1116,iq,2003,51,2003-12-17,0.1926667,0.2244,0.1361143,0.1363143,64.95,298.1685714,299.5428571,296.8514286,308.5,294.1,65.04,93.91714286,64.95,18.53285714,8.342857143,28.3,10.45,34.8,22.1,66.8
+1117,iq,2003,52,2003-12-24,0.2850778,0.2306556,0.2676444,0.2647778,49.42,296.2971429,297.05,295.6828571,302.6,294.3,82.68,96.93714286,49.42,17.17285714,4.185714286,27.3,9.6,33.1,22.3,185.7
+1118,iq,2004,1,2004-01-01,0.2025714,0.1989667,0.2445571,0.1879571,,,,,,,,,,,,,,,,
+1119,iq,2004,2,2004-01-08,0.24942,0.30885,0.2086286,0.2590143,78.53,297.4371429,298.7428571,296.6371429,304.0,294.9,55.3,95.79428571,78.53,18.25571429,6.2,27.43333333,8.666666667,34.2,22.4,137.2
+1120,iq,2004,3,2004-01-15,0.32786,0.29844,0.30672,0.34024,63.47,297.7528571,298.9571429,297.02,306.2,294.5,62.5,96.12857143,63.47,18.71285714,6.828571429,28.7,9.9,34.1,23.1,68.1
+1121,iq,2004,4,2004-01-22,0.3205857,0.3365286,0.2566,0.3441143,29.23,299.62,300.8285714,295.89,308.3,293.6,19.4,82.46714286,29.23,17.49142857,11.22857143,28.73333333,11.4,34.6,21.8,20.1
+1122,iq,2004,5,2004-01-29,0.2330143,0.2351857,0.1964857,0.2055429,4.65,300.9,302.15,292.8328571,309.7,293.2,1.6,65.28428571,4.65,14.54857143,13.64285714,28.925,12.125,35.6,22.3,0.0
+1123,iq,2004,6,2004-02-05,0.1235429,0.0993,0.1128571,0.1172,13.2,299.9028571,301.3714286,293.9885714,309.8,293.2,9.0,72.92714286,13.2,15.56714286,14.08571429,29.2,13.525,36.4,20.6,24.1
+1124,iq,2004,7,2004-02-12,0.2787429,0.2987571,0.3127143,0.3048286,24.83,298.27,299.55,295.64,307.2,294.8,33.46,86.76571429,24.83,17.17428571,8.5,27.925,9.5,33.3,22.8,13.4
+1125,iq,2004,8,2004-02-19,0.2366286,0.1670429,0.1970286,0.2225143,39.06,298.0814286,299.75,295.6428571,310.1,292.6,34.5,87.71857143,39.06,17.20857143,9.728571429,26.6,8.1,35.5,22.0,8.6
+1126,iq,2004,9,2004-02-26,0.3190571,0.3352333,0.2176286,0.3000286,125.04,297.8828571,299.4357143,296.3485714,308.0,294.3,83.27,93.01285714,125.04,17.95,7.814285714,27.46666667,10.13333333,34.4,20.6,18.9
+1127,iq,2004,10,2004-03-04,0.2094714,0.2086571,0.1715,0.1935714,52.08,297.9814286,299.4285714,296.4557143,308.1,293.2,49.36,92.56142857,52.08,18.09428571,9.085714286,28.4,11.3,34.5,22.3,79.0
+1128,iq,2004,11,2004-03-11,0.3076833,0.2140167,0.33865,0.3110429,80.33,296.7771429,297.5214286,296.0685714,304.4,293.5,76.75,96.28857143,80.33,17.61,5.242857143,28.0,11.0,33.5,22.5,24.1
+1129,iq,2004,12,2004-03-18,0.3859857,0.4247833,0.3514143,0.3465286,137.83,297.8871429,299.5357143,296.6214286,305.5,292.9,75.16,93.62857143,137.83,18.24857143,9.785714286,28.3,9.5,34.3,21.7,187.2
+1130,iq,2004,13,2004-03-25,0.3062833,0.19872,0.02988,0.29015,120.1,297.3128571,298.2,296.6071429,303.5,294.0,76.2,96.23857143,120.1,18.23714286,5.714285714,28.65,9.3,34.0,23.6,142.6
+1131,iq,2004,14,2004-04-01,0.136,0.138,0.1862333,0.1294333,101.22,297.2028571,298.2642857,296.8157143,303.9,293.8,88.9,97.94142857,101.22,18.47,5.214285714,28.06666667,9.1,33.9,22.7,2.0
+1132,iq,2004,15,2004-04-08,0.3592143,0.3348429,0.2791571,0.3612714,47.26,297.8128571,298.9785714,297.1757143,305.6,294.2,135.4,96.49857143,47.26,18.82571429,6.271428571,27.65,9.5,33.1,22.3,4.0
+1133,iq,2004,16,2004-04-15,0.2441857,0.1958286,0.1747,0.1882286,61.8,298.2171429,299.65,296.6371429,308.4,292.9,54.89,92.32,61.8,18.30857143,8.985714286,28.03333333,10.36666667,33.6,21.7,36.9
+1134,iq,2004,17,2004-04-22,0.3742857,0.3308,0.2340333,0.2549429,113.62,297.78,298.5142857,296.7714286,304.0,293.9,90.3,94.78857143,113.62,18.40857143,6.0,28.0,10.65,34.5,22.5,39.6
+1135,iq,2004,18,2004-04-29,0.27884,0.1637667,0.1911833,0.3266286,65.82,297.1271429,297.8285714,296.7085714,303.5,293.6,133.17,97.80857143,65.82,18.34,5.028571429,27.53333333,8.666666667,32.9,22.6,148.5
+1136,iq,2004,19,2004-05-06,0.1575667,0.1215429,0.1904143,0.1225333,83.93,297.7985714,299.1285714,296.8357143,305.9,293.1,56.52,95.11571429,83.93,18.51142857,8.714285714,27.23333333,9.933333333,33.3,22.0,97.0
+1137,iq,2004,20,2004-05-13,0.1716667,0.1522333,0.1598333,0.1769,34.81,296.4142857,297.2142857,295.27,303.4,292.6,45.5,93.89714286,34.81,16.77857143,5.771428571,27.3,8.4,33.0,19.5,91.8
+1138,iq,2004,21,2004-05-20,0.2254667,0.18515,0.1942,0.2483167,173.45,297.6028571,299.1785714,295.82,308.2,292.0,83.0,91.62714286,173.45,17.40142857,9.1,26.65,7.4,34.2,22.5,296.9
+1139,iq,2004,22,2004-05-27,0.1903143,0.07784286,0.1931714,0.1023286,35.43,297.3057143,298.3285714,295.9585714,306.4,291.7,42.6,93.57571429,35.43,17.5,9.628571429,,,33.3,20.5,28.2
+1140,iq,2004,23,2004-06-03,0.1073,0.1170667,0.1967857,0.1106143,88.62,296.7671429,297.8214286,295.6971429,304.1,292.8,36.63,94.69285714,88.62,17.21285714,8.185714286,27.5,9.5,32.8,19.8,203.0
+1141,iq,2004,24,2004-06-10,0.2378429,0.2350833,0.1669571,0.2119714,85.28,295.5742857,296.25,294.99,300.0,293.0,51.89,96.87571429,85.28,16.42,5.042857143,26.8,8.566666667,32.0,20.9,87.9
+1142,iq,2004,25,2004-06-17,0.3329571,0.191,0.2340429,0.3255143,94.52,296.2042857,297.3214286,294.7057143,306.0,292.1,24.5,92.37142857,94.52,16.13857143,7.785714286,25.9,8.4,33.3,21.5,43.2
+1143,iq,2004,26,2004-06-24,0.2392333,0.1535429,0.1328286,0.1970429,32.95,295.6342857,296.8142857,293.86,304.2,289.8,25.9,90.44714286,32.95,15.31285714,8.4,25.075,9.075,32.1,18.6,98.5
+1144,iq,2004,27,2004-07-01,0.2572143,0.3249286,0.1978,0.1967571,46.39,296.1514286,297.5857143,295.0414286,304.4,291.8,50.7,94.66857143,46.39,16.51428571,8.457142857,25.9,8.15,30.9,21.1,170.1
+1145,iq,2004,28,2004-07-08,0.3175571,0.3013857,0.2793714,0.3355429,83.94,296.6171429,298.0857143,294.8142857,305.1,291.8,18.67,90.90571429,83.94,16.25285714,9.485714286,26.55,8.85,32.0,21.8,43.2
+1146,iq,2004,29,2004-07-15,0.2328286,0.2737667,0.2338,0.1532429,48.09,297.5014286,298.9357143,294.3585714,306.9,291.4,24.76,85.15857143,48.09,15.86,11.21428571,26.8,11.7,33.1,20.5,31.0
+1147,iq,2004,30,2004-07-22,0.2679429,0.2995,0.2177,0.2849857,53.78,296.8128571,298.1142857,294.9971429,304.4,291.8,25.42,90.92857143,53.78,16.48,10.2,26.3,8.8,32.1,21.9,103.1
+1148,iq,2004,31,2004-07-29,0.2089,0.1555,0.2203,0.2542571,85.96,296.0171429,297.2928571,294.4714286,306.1,291.7,27.62,92.52714286,85.96,15.97571429,8.842857143,,,32.9,19.4,6.0
+1149,iq,2004,32,2004-08-05,0.2489,0.2659571,0.2185286,0.2375571,29.82,297.5171429,298.9642857,293.1442857,307.4,291.0,3.9,79.71857143,29.82,14.69428571,12.15714286,,,34.0,18.3,55.1
+1150,iq,2004,33,2004-08-12,0.1910714,0.227,0.1685286,0.2957,18.44,296.53,297.6357143,292.2228571,307.2,288.1,4.1,79.23571429,18.44,13.82428571,12.18571429,,,31.3,20.0,0.5
+1151,iq,2004,34,2004-08-19,0.3931286,0.3286429,0.2767714,0.3885143,23.78,297.82,299.9857143,293.4214286,308.3,290.2,7.9,78.48142857,23.78,14.96142857,14.28571429,,,,21.7,0.5
+1152,iq,2004,35,2004-08-26,0.3113,0.2609286,0.2330143,0.2997857,42.86,298.1428571,299.8071429,294.5671429,310.1,291.1,23.2,83.17285714,42.86,16.07714286,12.52857143,,,32.8,20.4,0.0
+1153,iq,2004,36,2004-09-02,0.3343571,0.3720286,0.3420143,0.2845857,147.32,297.7714286,299.3785714,294.9885714,307.8,291.7,41.89,86.54,147.32,16.48428571,11.12857143,27.1,9.8,32.0,20.9,195.1
+1154,iq,2004,37,2004-09-09,0.1302667,0.15128,0.1108143,0.1174857,46.58,298.4571429,300.5142857,296.1157143,308.2,294.7,35.7,88.74285714,46.58,17.67,10.28571429,27.4,8.7,34.3,23.0,23.2
+1155,iq,2004,38,2004-09-16,0.2680714,0.2102286,0.2273429,0.32515,36.64,297.7214286,299.0642857,295.88,308.9,293.3,59.5,91.2,36.64,17.44,8.928571429,27.16666667,9.5,33.0,20.4,87.3
+1156,iq,2004,39,2004-09-23,0.3915333,0.3207286,0.1595857,0.3325286,48.68,298.6285714,299.9714286,294.3828571,309.8,292.4,6.9,79.55714286,48.68,15.90142857,13.2,28.0,13.5,34.7,18.8,20.1
+1157,iq,2004,40,2004-09-30,0.2754571,0.2193,0.2612571,0.3283857,85.69,299.17,300.9142857,296.1157143,310.6,293.8,70.02,84.80714286,85.69,17.71142857,11.65714286,28.65,13.1,35.5,21.8,40.1
+1158,iq,2004,41,2004-10-07,0.2614714,0.1862429,0.3057286,0.2577429,52.27,297.5685714,298.7428571,295.3142857,305.5,292.7,39.9,88.82571429,52.27,16.82428571,8.828571429,26.975,10.875,33.0,20.6,27.9
+1159,iq,2004,42,2004-10-14,0.3523286,0.2841714,0.3764143,0.3553429,65.25,298.0571429,299.2642857,296.8671429,307.2,293.3,51.6,94.16,65.25,18.54714286,8.357142857,28.55,11.3,34.5,21.4,120.6
+1160,iq,2004,43,2004-10-21,0.2538429,0.1996667,0.3036857,0.2235571,35.61,299.4285714,300.9214286,296.2957143,309.6,292.8,23.1,85.06571429,35.61,17.90142857,13.15714286,27.7,9.55,35.6,22.4,13.0
+1161,iq,2004,44,2004-10-28,0.2953286,0.2312286,0.2604,0.3197714,74.01,298.4414286,299.9428571,295.9071429,312.3,292.2,48.5,87.87,74.01,17.53714286,12.31428571,27.4,10.0,35.8,21.3,89.9
+1162,iq,2004,45,2004-11-04,0.4148857,0.3245571,0.2727429,0.3656714,91.63,299.5042857,300.7857143,296.1785714,309.2,294.3,67.0,84.82714286,91.63,17.80571429,10.65714286,28.35,12.35,34.9,21.8,101.4
+1163,iq,2004,46,2004-11-11,0.3466857,0.3154143,0.2708571,0.3742,74.68,297.1685714,297.7071429,296.4842857,304.2,292.4,53.9,96.35428571,74.68,18.12142857,5.928571429,27.2,8.9,33.7,22.4,184.2
+1164,iq,2004,47,2004-11-18,0.2278714,0.1945,0.1909143,0.2095571,74.08,299.4185714,301.2357143,296.0971429,309.3,293.6,26.8,84.61142857,74.08,17.73857143,11.64285714,28.25,11.0,35.8,22.5,107.4
+1165,iq,2004,48,2004-11-25,0.2153167,0.1672857,0.2026286,0.2191286,71.98,297.9585714,299.2,297.02,306.1,293.6,56.8,95.25142857,71.98,18.71428571,7.914285714,28.0,10.36,35.3,22.6,77.0
+1166,iq,2004,49,2004-12-02,0.2019429,0.1593667,0.1590429,0.2410857,53.01,299.1771429,300.3785714,296.44,309.5,293.3,36.83,87.13,53.01,18.11,10.95714286,27.9,11.0,34.1,22.4,64.0
+1167,iq,2004,50,2004-12-09,0.3234286,0.3095143,0.2758286,0.3359,70.04,297.7871429,298.8357143,296.5742857,305.8,294.5,91.0,93.93857143,70.04,18.20714286,6.5,,,,,9.9
+1168,iq,2004,51,2004-12-16,0.2611429,0.2033143,0.2437429,0.2363571,49.56,298.7014286,300.0357143,296.3857143,308.5,293.8,38.0,88.78,49.56,18.04,10.21428571,28.375,9.65,34.0,22.6,128.3
+1169,iq,2004,52,2004-12-23,0.3648625,0.3266,0.4031125,0.3162,109.83,298.4042857,299.6571429,297.1228571,306.3,294.8,29.79,93.25285714,109.83,18.85571429,8.228571429,27.8,8.5,33.3,22.6,100.8
+1170,iq,2005,53,2005-01-01,,,,,,,,,,,,,,,,,,,,
+1171,iq,2005,1,2005-01-08,0.3148429,0.1866286,0.3033,0.2704,70.6,298.1628571,300.0071429,296.7128571,307.9,293.5,61.61,93.00571429,70.6,18.37,9.757142857,28.5,9.1,33.2,23.0,74.9
+1172,iq,2005,2,2005-01-15,0.3044143,0.3612571,0.3126,0.3156286,93.73,297.6628571,298.8428571,296.7271429,307.6,291.6,96.21,95.53,93.73,18.40857143,7.228571429,28.4,10.4,34.2,22.5,232.1
+1173,iq,2005,3,2005-01-22,0.3459333,0.3118,0.291,0.3379714,60.52,300.0685714,301.5642857,296.58,308.7,295.0,26.7,83.3,60.52,18.25857143,11.35714286,28.86666667,11.16666667,35.5,22.5,194.0
+1174,iq,2005,4,2005-01-29,0.3643667,0.2779143,0.2925571,0.2806857,25.67,299.6485714,301.1071429,296.9314286,308.1,294.9,42.24,87.31285714,25.67,18.64571429,9.985714286,28.86666667,12.06666667,35.1,22.1,0.0
+1175,iq,2005,5,2005-02-05,0.1582286,0.16725,0.1518143,0.1266,88.96,299.0614286,300.8285714,296.9071429,308.4,295.3,47.3,89.42714286,88.96,18.63571429,9.342857143,28.525,10.725,35.4,22.2,3.8
+1176,iq,2005,6,2005-02-12,0.2151857,0.1728143,0.2623,0.2283571,52.61,296.7528571,297.6928571,295.9957143,304.4,294.2,56.8,95.97714286,52.61,17.57571429,5.185714286,27.46666667,8.733333333,32.8,21.4,70.4
+1177,iq,2005,7,2005-02-19,0.1995,0.2024571,0.2189,0.1806857,125.35,298.0271429,299.1642857,297.2214286,304.6,294.5,189.06,95.74857143,125.35,18.94714286,6.985714286,27.5,9.5,32.3,22.3,350.9
+1178,iq,2005,8,2005-02-26,0.2011,0.2081429,0.2812143,0.2109,46.98,298.2957143,299.2857143,296.5428571,306.5,294.4,39.6,91.57714286,46.98,18.20142857,7.857142857,28.65,10.9,35.2,22.4,84.1
+1179,iq,2005,9,2005-03-05,0.2937167,0.2696167,0.2308,0.2771,54.22,298.1585714,299.3928571,297.0457143,305.9,294.4,44.51,94.40142857,54.22,18.73142857,8.014285714,28.26666667,9.2,33.8,23.3,19.0
+1180,iq,2005,10,2005-03-12,0.1558429,0.1370833,0.2418714,0.1464286,155.54,297.9571429,298.6857143,297.5285714,304.9,295.6,201.4,97.68714286,155.54,19.27428571,4.828571429,26.8,6.7,34.8,23.4,8.6
+1181,iq,2005,11,2005-03-19,0.2515167,0.1817667,0.1545286,0.2099571,162.51,297.3142857,298.6785714,295.85,304.5,291.9,21.7,92.26714286,162.51,17.39857143,7.814285714,28.7,9.85,33.8,22.5,146.1
+1182,iq,2005,12,2005-03-26,0.2150714,0.2127,0.1209286,0.2354286,99.37,298.37,299.8285714,296.2514286,306.6,294.7,32.8,89.82,99.37,17.82,9.342857143,27.72,8.96,33.4,22.5,108.8
+1183,iq,2005,13,2005-04-02,0.3816857,0.3683143,0.3837714,0.3666571,55.12,297.37,298.5857143,296.0885714,308.6,293.0,67.5,93.80142857,55.12,17.62428571,7.628571429,28.25,10.85,34.3,20.8,73.9
+1184,iq,2005,14,2005-04-09,0.3091143,0.2173571,0.3001,0.2446571,87.41,297.7085714,299.0,296.2357143,306.5,292.4,68.0,92.41714286,87.41,17.89285714,8.457142857,28.1,10.85,33.8,21.6,71.1
+1185,iq,2005,15,2005-04-16,0.1869333,0.1447571,0.1957429,0.1824286,40.03,297.7014286,298.4642857,297.2028571,304.0,295.0,90.2,97.32285714,40.03,18.88571429,6.414285714,27.65,9.35,32.9,22.5,3.6
+1186,iq,2005,16,2005-04-23,0.2082833,0.1649167,0.2776667,0.1962667,37.6,297.4371429,298.1928571,296.9614286,306.4,294.0,178.2,97.38142857,37.6,18.59714286,5.357142857,28.85,10.05,34.0,22.7,105.6
+1187,iq,2005,17,2005-04-30,0.2141,0.2315333,0.1616857,0.2017714,78.8,297.9271429,298.8642857,297.4028571,303.9,294.1,54.9,97.16285714,78.8,19.15285714,6.642857143,28.6,9.1,33.8,23.7,14.5
+1188,iq,2005,18,2005-05-07,0.1465333,0.1345833,0.1343143,0.1880571,33.29,297.33,298.4357143,296.5757143,304.8,293.3,64.1,95.93714286,33.29,18.18142857,6.1,25.8,7.5,33.5,21.0,13.0
+1189,iq,2005,19,2005-05-14,0.2484333,0.2341,0.2020667,0.1930667,49.07,298.6842857,299.7214286,296.3414286,306.7,293.6,54.89,88.29428571,49.07,17.94,9.271428571,27.9,11.6,34.6,21.0,28.0
+1190,iq,2005,20,2005-05-21,0.2700857,0.1737571,0.2104571,0.2297429,56.22,297.5328571,298.3428571,296.3528571,304.9,293.6,49.1,93.91857143,56.22,17.95714286,7.542857143,,,33.2,23.6,95.9
+1191,iq,2005,21,2005-05-28,0.3118143,0.3585429,0.2806571,0.2474571,43.14,299.0057143,300.6142857,295.8042857,308.1,294.0,21.1,84.65857143,43.14,17.40714286,10.94285714,27.4,8.7,33.6,22.4,37.9
+1192,iq,2005,22,2005-06-04,0.3782857,0.3693714,0.3631857,0.3612429,61.75,298.4342857,299.4785714,295.6785714,307.3,292.7,34.92,86.70142857,61.75,17.2,10.01428571,,,33.9,20.9,78.9
+1193,iq,2005,23,2005-06-11,0.1395143,0.1401,0.14235,0.1185429,40.44,297.3042857,298.4857143,296.2271429,303.9,293.7,51.0,94.59285714,40.44,17.78857143,7.171428571,27.1,9.166666667,32.4,22.0,19.5
+1194,iq,2005,24,2005-06-18,0.2890857,0.2256429,0.2247143,0.2651286,104.83,297.3771429,298.6214286,295.32,304.8,293.4,29.01,89.19428571,104.83,16.82428571,8.528571429,27.66666667,9.833333333,33.3,22.0,73.7
+1195,iq,2005,25,2005-06-25,0.2915571,0.2460714,0.3518571,0.2604571,50.88,297.8571429,299.0571429,294.6442857,307.7,291.9,11.0,84.46714286,50.88,16.16857143,10.48571429,27.35,9.55,32.8,22.4,89.2
+1196,iq,2005,26,2005-07-02,0.2747143,0.1780143,0.2843143,0.2271714,23.6,296.82,298.4928571,294.4085714,307.4,292.4,26.6,88.38714286,23.6,15.87714286,10.72857143,26.83333333,8.766666667,33.7,20.8,92.0
+1197,iq,2005,27,2005-07-09,0.2008,0.2010667,0.1622667,0.2214,43.24,297.8657143,299.4214286,294.5285714,308.3,290.4,23.91,84.69285714,43.24,16.03857143,11.1,27.8,10.7,34.5,21.6,40.9
+1198,iq,2005,28,2005-07-16,0.3869286,0.3350571,0.3298429,0.4413429,109.71,296.9885714,297.5928571,292.23,308.2,288.3,8.7,77.37285714,109.71,13.92857143,11.81428571,27.8,11.13333333,34.2,17.6,167.1
+1199,iq,2005,29,2005-07-23,0.1680286,0.1343286,0.1865571,0.1472571,27.33,297.7942857,298.9285714,292.4557143,307.7,287.5,8.9,75.69714286,27.33,14.19142857,13.51428571,26.55,12.7,33.8,18.2,0.0
+1200,iq,2005,30,2005-07-30,0.3474857,0.2537,0.2769571,0.3653143,42.32,296.8985714,298.0142857,293.75,306.3,290.1,15.3,84.23857143,42.32,15.26,10.08571429,21.4,5.7,32.3,18.5,71.1
+1201,iq,2005,31,2005-08-06,0.3286857,0.3132571,0.2262143,0.2740143,0.0,298.2214286,299.7285714,293.0357143,308.2,292.6,8.64,75.57142857,0.0,14.60857143,11.48571429,26.25,10.6,32.3,19.2,0.0
+1202,iq,2005,32,2005-08-13,0.2826429,0.2270286,0.2825571,0.239,38.17,298.9257143,300.3357143,293.64,309.7,293.5,1.99,74.85571429,38.17,15.15,12.18571429,27.325,11.85,33.5,19.8,36.6
+1203,iq,2005,33,2005-08-20,0.2669857,0.2939286,0.336,0.2924857,17.85,299.6057143,300.4285714,291.7785714,310.5,290.7,6.0,64.65857143,17.85,13.59,14.2,,,32.8,17.3,69.6
+1204,iq,2005,34,2005-08-27,0.3288,0.2715571,0.2723,0.3005,69.62,298.4285714,299.6785714,294.9457143,309.0,292.9,15.82,83.85428571,69.62,16.44,10.81428571,27.75,13.1,35.0,20.3,127.0
+1205,iq,2005,35,2005-09-03,0.4568333,0.3595833,0.35945,0.3801167,12.81,298.1842857,299.3714286,293.9185714,308.6,292.4,11.0,79.64714286,12.81,15.42857143,10.94285714,26.8,10.25,35.2,21.4,37.0
+1206,iq,2005,36,2005-09-10,0.3354286,0.2007143,0.3228857,0.3091429,36.98,300.0585714,301.2142857,294.0057143,309.3,293.4,4.2,71.97142857,36.98,15.51857143,13.71428571,,,,21.8,44.0
+1207,iq,2005,37,2005-09-17,0.2394286,0.2148714,0.2390429,0.2276,18.66,298.88,299.8071429,295.6585714,307.3,292.9,35.3,83.73,18.66,17.22285714,9.928571429,,,,,1.3
+1208,iq,2005,38,2005-09-24,0.1845667,0.1952571,0.1543857,0.2124833,2.56,298.4985714,299.7642857,293.5557143,309.1,292.4,13.7,76.59571429,2.56,15.06,11.78571429,25.76666667,12.23333333,34.3,16.9,38.1
+1209,iq,2005,39,2005-10-01,0.4054167,0.4287714,0.3706,0.4210857,29.8,301.1757143,302.9285714,293.7528571,314.0,294.8,4.2,67.21285714,29.8,15.33142857,14.82857143,28.65,13.5,37.1,20.7,
+1210,iq,2005,40,2005-10-08,0.3321571,0.3463667,0.2586143,0.3210429,54.7,299.11,300.25,293.8971429,312.7,292.1,4.6,74.95285714,54.7,15.43571429,12.35714286,28.8,14.9,36.3,21.0,80.8
+1211,iq,2005,41,2005-10-15,0.3734286,0.2774833,0.3742286,0.3522714,60.0,299.5157143,300.8571429,294.3857143,313.2,293.2,22.2,75.50857143,60.0,15.91571429,11.68571429,28.5,11.8,37.0,22.3,233.2
+1212,iq,2005,42,2005-10-22,0.3072571,0.2782143,0.3548286,0.2869571,73.97,299.5785714,301.1928571,295.7685714,310.5,291.9,35.08,81.69142857,73.97,17.41714286,12.24285714,29.1,12.7,36.5,21.7,64.0
+1213,iq,2005,43,2005-10-29,0.3635571,0.3000429,0.2898286,0.3261429,100.06,298.0657143,299.1642857,295.8028571,307.4,294.0,59.7,89.14285714,100.06,17.36428571,8.642857143,28.3,10.95,34.3,21.3,235.2
+1214,iq,2005,44,2005-11-05,0.1875714,0.2133714,0.1718571,0.1789571,59.15,299.4585714,301.4785714,296.8057143,308.6,294.9,49.85,87.23142857,59.15,18.55,10.78571429,28.23333333,10.3,34.3,21.8,102.1
+1215,iq,2005,45,2005-11-12,0.3938,0.2986286,0.4019857,0.4103714,75.36,298.6,300.0785714,296.36,309.4,292.9,143.8,89.31,75.36,17.97428571,9.7,,,34.6,22.3,8.9
+1216,iq,2005,46,2005-11-19,0.4424286,0.3481714,0.3430714,0.4731429,49.87,298.31,300.0928571,296.8957143,307.2,295.0,45.0,93.17714286,49.87,18.58285714,8.557142857,27.6,10.15,34.5,21.5,139.5
+1217,iq,2005,47,2005-11-26,0.2825714,0.2206,0.2882143,0.2400857,72.34,299.4128571,300.6285714,297.3942857,309.1,295.2,63.53,90.34857143,72.34,19.19428571,8.914285714,28.5,11.0,35.0,21.8,5.1
+1218,iq,2005,48,2005-12-03,0.3178143,0.3027,0.3369429,0.4171286,78.52,299.42,300.45,296.6128571,307.6,294.1,34.95,86.40857143,78.52,18.30428571,9.728571429,28.26666667,11.4,34.3,21.7,77.9
+1219,iq,2005,49,2005-12-10,0.3585857,0.2194857,0.2579143,0.2992714,60.5,299.2171429,300.7071429,296.6571429,308.4,295.4,71.8,87.72142857,60.5,18.36428571,9.1,28.1,12.5,34.8,21.5,54.1
+1220,iq,2005,50,2005-12-17,0.1984429,0.1941,0.1930143,0.247,46.91,298.5742857,300.2571429,297.1871429,307.0,295.4,46.9,92.95714286,46.91,18.94571429,8.2,28.1,11.55,34.0,22.3,6.0
+1221,iq,2005,51,2005-12-24,0.180575,0.1413333,0.2552833,0.1383714,151.0,298.0214286,299.3714286,297.1914286,304.4,295.5,113.36,95.67428571,151.0,18.91571429,6.485714286,28.3,9.9,33.6,22.9,81.1
+1222,iq,2006,52,2006-01-01,0.3546,0.21995,0.3225167,0.2563333,114.58,298.1814286,299.5785714,296.9357143,306.5,294.9,210.5,93.82142857,114.58,18.58428571,7.385714286,27.45,9.7,32.7,22.4,273.5
+1223,iq,2006,1,2006-01-08,0.1995143,0.2393429,0.2276571,0.2155,38.78,298.8328571,299.6428571,292.8785714,307.8,292.4,15.2,73.16142857,38.78,14.52428571,12.31428571,,,34.5,19.7,70.1
+1224,iq,2006,2,2006-01-15,0.2284,0.2020714,0.19475,0.23035,138.46,298.7285714,300.3,296.3714286,307.7,293.5,47.6,88.33571429,138.46,18.16571429,9.885714286,27.78,11.0,34.5,21.4,60.1
+1225,iq,2006,3,2006-01-22,0.1743,0.1336429,0.1117571,0.1944286,88.85,298.46,300.1142857,296.3214286,307.3,295.0,52.2,89.95571429,88.85,17.94142857,9.142857143,,,33.8,21.5,54.8
+1226,iq,2006,4,2006-01-29,0.1517667,0.1377,0.1478,0.1607833,49.32,297.1885714,298.2928571,295.7771429,304.8,294.4,52.2,93.11428571,49.32,17.36428571,6.214285714,27.3,8.95,33.5,22.3,250.9
+1227,iq,2006,5,2006-02-05,0.3791143,0.3053286,0.3459714,0.3715714,34.17,297.1657143,298.2214286,296.6471429,302.7,294.3,63.98,97.32,34.17,18.26428571,5.528571429,,,33.7,21.5,118.9
+1228,iq,2006,6,2006-02-12,0.2568143,0.13605,0.1978286,0.2583143,71.87,297.64,298.3785714,296.8085714,304.2,294.0,67.0,95.82714286,71.87,18.44285714,5.785714286,28.0,8.8,32.6,23.6,101.1
+1229,iq,2006,7,2006-02-19,0.3827,0.2506,0.2436571,0.2856,44.35,297.0642857,298.1428571,295.3642857,305.2,292.8,33.0,91.09857143,44.35,16.92714286,7.285714286,28.6,8.9,33.8,24.2,0.0
+1230,iq,2006,8,2006-02-26,0.2621143,0.1248,0.2153571,0.1447857,23.44,298.9385714,300.7785714,295.9614286,308.3,292.9,72.2,86.03142857,23.44,17.60571429,10.78571429,28.24,10.64,34.3,21.3,0.3
+1231,iq,2006,9,2006-03-05,0.1786667,0.1959333,0.1412667,0.1282833,79.13,298.2528571,299.8714286,296.7642857,306.9,295.1,50.38,92.60571429,79.13,18.40142857,8.028571429,27.43333333,9.566666667,32.9,21.9,26.9
+1232,iq,2006,10,2006-03-12,0.4246286,0.4113,0.3731857,0.3158571,94.99,297.9257143,299.1071429,297.2071429,304.0,294.7,130.6,96.36,94.99,18.90285714,6.414285714,28.0,9.55,33.3,21.9,93.0
+1233,iq,2006,11,2006-03-19,0.1924286,0.1158857,0.1940571,0.1712714,121.69,297.9314286,299.0071429,296.5814286,305.3,294.5,58.83,93.34714286,121.69,18.2,7.014285714,27.975,9.2,33.7,22.4,16.0
+1234,iq,2006,12,2006-03-26,0.2885667,0.17954,0.2972714,0.2236429,120.62,297.4942857,298.7857143,296.2957143,305.3,292.5,70.0,93.78714286,120.62,17.91142857,7.342857143,27.4,8.7,32.3,23.0,97.0
+1235,iq,2006,13,2006-04-02,0.24505,0.18885,0.2235333,0.1816667,121.46,298.04,299.2357143,297.0671429,304.9,294.8,88.81,95.02428571,121.46,18.73428571,6.957142857,28.3,10.0,33.7,22.0,53.9
+1236,iq,2006,14,2006-04-09,0.2416714,0.2054,0.1560143,0.2833143,41.68,297.7742857,299.4428571,296.0471429,308.3,293.8,87.9,91.81142857,41.68,17.61,9.571428571,27.93333333,10.26666667,33.7,22.6,178.1
+1237,iq,2006,15,2006-04-16,0.3011286,0.2650571,0.2553143,0.2626857,75.33,297.8257143,298.8142857,296.9657143,305.5,292.9,66.46,95.51,75.33,18.71428571,7.428571429,28.3,10.3,33.9,21.4,49.0
+1238,iq,2006,16,2006-04-23,0.3309,0.2654714,0.3195571,0.2849429,69.6,298.0614286,299.1785714,296.4571429,306.4,293.9,54.86,92.11142857,69.6,18.08285714,7.442857143,27.4,8.35,32.8,22.5,11.9
+1239,iq,2006,17,2006-04-30,0.2055714,0.23605,0.1919143,0.1393714,74.93,296.85,297.7071429,295.0514286,305.3,291.7,39.6,90.86428571,74.93,16.55857143,7.757142857,27.0,8.466666667,33.5,19.5,34.0
+1240,iq,2006,18,2006-05-07,0.1516,0.0846,0.1763143,0.1137286,65.07,297.63,299.0214286,296.3842857,306.3,293.6,38.84,93.63571429,65.07,17.96285714,8.414285714,27.85,9.1,33.3,22.5,115.0
+1241,iq,2006,19,2006-05-14,0.2866571,0.1871571,0.2665143,0.2874571,127.24,296.1842857,297.5571429,295.4528571,304.3,291.8,70.0,96.09857143,127.24,16.97714286,6.628571429,24.3,5.2,32.3,21.7,270.9
+1242,iq,2006,20,2006-05-21,0.3392857,0.3482857,0.3158286,0.3745714,1.52,296.0542857,296.9142857,290.0885714,305.6,287.2,0.1,72.03428571,1.52,12.11142857,12.37142857,25.2,11.7,31.7,19.4,2.0
+1243,iq,2006,21,2006-05-28,0.2065143,0.1171429,0.1692714,0.1700714,91.4,297.9928571,299.1142857,293.7771429,307.7,288.8,12.47,80.38571429,91.4,15.46,10.88571429,27.46666667,10.43333333,34.0,21.7,83.0
+1244,iq,2006,22,2006-06-04,0.09837143,0.1010667,0.1863143,0.09775,79.48,295.9871429,297.1714286,294.5571429,304.1,291.3,44.65,92.50571429,79.48,16.02571429,6.885714286,25.6,8.933333333,31.9,19.3,150.2
+1245,iq,2006,23,2006-06-11,0.3404429,0.1908571,0.3513429,0.2586143,130.66,297.0442857,298.5642857,295.6957143,307.2,292.3,37.6,93.47571429,130.66,17.19571429,8.9,26.2,8.6,33.0,21.5,105.2
+1246,iq,2006,24,2006-06-18,0.1732714,0.185,0.1369286,0.1680429,84.99,297.4271429,298.1357143,294.75,307.2,290.3,21.5,87.21428571,84.99,16.25857143,10.07142857,28.1,12.7,34.4,21.4,79.5
+1247,iq,2006,25,2006-06-25,0.22138,0.22336,0.3714167,0.22146,71.69,296.7242857,297.9785714,294.2757143,306.3,289.5,27.29,88.47142857,71.69,15.80142857,10.78571429,26.6,10.35,32.5,20.4,74.9
+1248,iq,2006,26,2006-07-02,0.3118571,0.2039333,0.3360286,0.3046286,17.21,296.8514286,297.6142857,293.5171429,307.2,289.2,9.16,83.46714286,17.21,15.02,10.74285714,27.2,10.3,33.4,19.8,21.9
+1249,iq,2006,27,2006-07-09,0.3201714,0.2081,0.2921143,0.2326857,20.72,296.4485714,297.9142857,294.5928571,304.8,292.6,13.62,90.43285714,20.72,16.00571429,7.971428571,26.7,9.4,33.0,21.7,110.6
+1250,iq,2006,28,2006-07-16,0.3499857,0.2920429,0.2884571,0.2949167,1.17,297.6214286,298.8571429,292.8328571,306.7,292.1,1.8,77.27142857,1.17,14.41714286,11.42857143,26.25,10.4,33.1,20.6,0.5
+1251,iq,2006,29,2006-07-23,0.3602857,0.341,0.3629571,0.3211286,54.72,297.3971429,299.0857143,294.2585714,307.3,291.8,40.0,85.14,54.72,15.78857143,11.0,27.4,12.125,34.1,19.9,47.0
+1252,iq,2006,30,2006-07-30,0.3186857,0.3523429,0.3766429,0.2859,28.66,297.5042857,298.7428571,293.26,307.7,289.7,15.4,79.74285714,28.66,14.88,11.71428571,26.6,11.04,32.6,18.5,11.4
+1253,iq,2006,31,2006-08-06,0.2016857,0.1625571,0.2003286,0.2015571,44.96,297.51,299.3428571,295.2,308.4,292.7,38.07,88.70714286,44.96,16.70714286,11.22857143,27.225,11.625,34.2,19.7,4.0
+1254,iq,2006,32,2006-08-13,0.4397857,0.3675857,0.3333143,0.3809857,11.79,297.5,299.5142857,293.08,308.9,291.0,12.39,79.24285714,11.79,14.63142857,12.22857143,27.6,12.2,33.9,19.4,26.6
+1255,iq,2006,33,2006-08-20,0.2908,0.238675,0.2856571,0.3337,47.74,298.6485714,300.6357143,295.5457143,307.9,294.6,22.19,84.62,47.74,17.06571429,10.27142857,27.66666667,10.43333333,33.3,20.9,75.5
+1256,iq,2006,34,2006-08-27,0.2736429,0.2089429,0.2408857,0.2427571,68.6,298.7357143,299.7357143,295.1442857,308.7,292.5,23.6,83.04714286,68.6,16.69142857,11.27142857,27.3,10.3,34.9,20.9,71.1
+1257,iq,2006,35,2006-09-03,0.3097833,0.3501286,0.2846833,0.3948167,68.0,298.28,299.9,295.2728571,310.0,293.1,22.24,85.37285714,68.0,16.77714286,11.17142857,26.5,10.03333333,33.2,20.3,176.0
+1258,iq,2006,36,2006-09-10,0.2277857,0.2833143,0.2443714,0.2834143,90.33,299.2657143,300.35,293.9028571,310.3,290.2,9.4,75.53,90.33,15.45714286,13.72857143,27.42,12.0,34.1,20.6,15.3
+1259,iq,2006,37,2006-09-17,0.28004,0.2367167,0.2361833,0.25855,111.87,297.8028571,299.1642857,293.0371429,308.7,291.9,16.4,77.25428571,111.87,14.64285714,11.32857143,28.35,11.85,35.0,17.8,0.5
+1260,iq,2006,38,2006-09-24,0.3807286,0.3783667,0.3023,0.3075714,82.2,299.34,300.8571429,294.35,311.2,291.5,35.7,77.51428571,82.2,15.91,13.74285714,27.93333333,10.93333333,34.8,21.4,93.9
+1261,iq,2006,39,2006-10-01,0.4655,0.2415429,0.4734,0.4934429,134.64,299.3814286,300.6857143,295.7385714,308.6,294.3,44.62,82.84571429,134.64,17.25428571,11.28571429,28.56666667,12.4,35.2,22.0,63.0
+1262,iq,2006,40,2006-10-08,0.35495,0.2479333,0.3508143,0.3139167,60.48,299.4657143,300.4357143,295.16,310.3,292.0,24.8,80.49,60.48,16.73857143,12.78571429,28.7,14.5,35.9,21.1,68.9
+1263,iq,2006,41,2006-10-15,0.1556167,0.19152,0.2151857,0.1546143,41.69,299.3457143,301.0285714,296.7514286,309.5,293.8,29.5,86.85285714,41.69,18.44714286,12.05714286,28.06,10.1,33.7,22.1,162.6
+1264,iq,2006,42,2006-10-22,0.3215,0.2769,0.2100857,0.3337571,103.77,299.6485714,301.0142857,297.7642857,308.1,295.7,55.5,90.37857143,103.77,19.59571429,8.571428571,28.6,10.1,35.4,22.8,8.1
+1265,iq,2006,43,2006-10-29,0.4882286,0.3681429,0.4377429,0.3788286,55.94,298.7942857,300.4142857,296.6614286,308.3,294.0,54.8,89.7,55.94,18.31142857,9.342857143,27.56,10.42,33.8,19.8,143.3
+1266,iq,2006,44,2006-11-05,0.3603286,0.2740143,0.3477143,0.3247857,67.5,300.4671429,301.8785714,296.8828571,309.8,295.1,42.73,82.93428571,67.5,18.63,11.61428571,28.83333333,11.26666667,35.7,22.0,14.0
+1267,iq,2006,45,2006-11-12,0.2951286,0.2463857,0.3020714,0.277,80.25,299.4328571,300.9142857,297.8528571,307.8,295.3,68.0,92.08857143,80.25,19.73142857,8.2,28.25,9.55,33.9,22.4,108.7
+1268,iq,2006,46,2006-11-19,0.3191429,0.1862857,0.2737,0.2470286,86.65,297.2957143,298.4357143,296.2014286,304.5,293.5,87.2,94.44,86.65,17.79142857,7.357142857,27.6,10.16666667,33.2,21.8,85.6
+1269,iq,2006,47,2006-11-26,0.3405571,0.2662571,0.3427286,0.3283857,43.59,298.0985714,299.5571429,296.9614286,307.3,294.7,61.43,94.30285714,43.59,18.63857143,7.371428571,27.0,9.0,32.3,22.5,205.3
+1270,iq,2006,48,2006-12-03,0.1504714,0.1515714,0.1926,0.1557286,75.33,299.1971429,300.9357143,296.9885714,309.1,294.0,61.28,89.55,75.33,18.74428571,10.75714286,27.9,9.033333333,34.9,22.9,115.1
+1271,iq,2006,49,2006-12-10,0.4470833,0.3015143,0.3405714,0.4276,99.89,298.2028571,299.2,297.6085714,304.6,294.6,95.02,96.79571429,99.89,19.42571429,6.914285714,28.4,8.8,33.7,23.2,10.9
+1272,iq,2006,50,2006-12-17,0.3785,0.3020333,0.3492286,0.4147857,157.75,298.1585714,299.0714286,297.3514286,304.4,294.2,63.0,95.87571429,157.75,19.11142857,6.4,,,33.8,,
+1273,iq,2006,51,2006-12-24,0.32782,0.26192,0.3814667,0.35295,111.48,297.68,298.9857143,296.7257143,306.7,294.3,80.2,95.07857143,111.48,18.35857143,6.542857143,,,32.9,23.5,
+1274,iq,2007,1,2007-01-01,0.2201167,0.1589571,0.1905714,0.1324,79.94,297.2885714,298.2071429,296.5171429,306.3,293.2,88.9,95.92714286,79.94,18.14428571,7.414285714,26.6,7.95,31.9,21.5,133.4
+1275,iq,2007,2,2007-01-08,0.1732857,0.2069333,0.1343,0.2379571,37.06,297.1042857,298.5785714,296.3885714,304.6,294.6,144.59,96.23857143,37.06,17.96285714,6.728571429,26.825,7.725,31.7,22.9,61.5
+1276,iq,2007,3,2007-01-15,0.2719,0.2938,0.2094143,0.2523,126.89,297.3871429,298.4357143,296.3885714,305.5,293.3,52.2,94.64714286,126.89,17.97571429,7.042857143,27.775,9.55,33.4,22.2,178.0
+1277,iq,2007,4,2007-01-22,0.1936714,0.1394714,0.2619,0.3068571,95.47,297.6142857,298.45,297.0257143,303.7,294.9,180.99,96.99714286,95.47,18.68857143,5.528571429,27.7,9.12,33.6,22.0,149.9
+1278,iq,2007,5,2007-01-29,0.1744143,0.1805,0.1590714,0.2003143,83.7,298.1442857,299.6142857,296.7742857,307.8,294.3,65.1,93.13571429,83.7,18.41428571,9.0,27.725,10.3,35.0,22.3,60.3
+1279,iq,2007,6,2007-02-05,0.3175,0.4014857,0.3285429,0.4429286,61.8,298.33,299.6857143,295.77,309.7,293.4,11.7,87.53,61.8,17.32285714,10.71428571,28.6,10.9,35.4,22.4,9.9
+1280,iq,2007,7,2007-02-12,0.2858,0.2957,0.2570286,0.3195714,14.19,299.1714286,300.2857143,294.15,308.7,291.4,2.1,75.80428571,14.19,15.68571429,11.22857143,28.85,13.03333333,36.7,21.4,61.3
+1281,iq,2007,8,2007-02-19,0.2570143,0.1182333,0.1790857,0.2372286,25.7,300.5657143,302.1785714,294.1657143,310.2,294.4,11.55,72.44571429,25.7,15.91857143,13.18571429,28.74,13.36,36.2,21.2,0.0
+1282,iq,2007,9,2007-02-26,0.1735,0.1996333,0.1745,0.1659167,55.56,299.0585714,300.6357143,294.29,309.2,291.5,35.33,78.58571429,55.56,16.02,11.55714286,28.56,13.34,35.8,20.4,28.0
+1283,iq,2007,10,2007-03-05,0.216,0.2136,0.1889143,0.2275286,117.07,297.45,298.7142857,296.3171429,305.8,293.4,227.25,94.34857143,117.07,17.91142857,7.371428571,27.3,9.9,33.0,21.9,205.3
+1284,iq,2007,11,2007-03-12,0.3033167,0.2850333,0.2571429,0.2926143,55.47,296.9514286,298.1,296.3014286,303.8,293.8,51.3,96.52285714,55.47,17.88142857,6.114285714,28.0,10.1,33.1,21.7,138.0
+1285,iq,2007,12,2007-03-19,0.21324,0.2231286,0.2643714,0.2218286,150.33,297.6842857,298.7285714,295.89,305.4,292.6,59.2,90.85857143,150.33,17.47,8.171428571,27.0,10.65,33.9,21.7,252.7
+1286,iq,2007,13,2007-03-26,0.2386714,0.2447429,0.2162286,0.2591857,93.14,297.8357143,299.15,296.56,307.2,292.8,58.4,93.58571429,93.14,18.21428571,8.242857143,28.25,9.6,34.6,21.5,66.1
+1287,iq,2007,14,2007-04-02,0.2381,0.1912,0.2749571,0.2738,97.04,297.7171429,298.8071429,296.9214286,305.5,294.3,238.2,95.82,97.04,18.59428571,6.614285714,27.26666667,8.833333333,34.0,22.6,94.3
+1288,iq,2007,15,2007-04-09,0.1525167,0.1494857,0.2294143,0.1575571,98.94,297.5557143,298.5928571,296.6885714,304.1,292.4,147.57,95.52714286,98.94,18.32857143,6.728571429,27.85,8.85,34.4,21.3,60.4
+1289,iq,2007,16,2007-04-16,0.1430857,0.2071571,0.1684571,0.2743143,93.62,297.0314286,298.0928571,296.0142857,304.8,292.0,46.45,94.72142857,93.62,17.55142857,7.528571429,27.4,9.5,33.5,22.1,97.1
+1290,iq,2007,17,2007-04-23,0.2713714,0.1836571,0.203,0.3006,157.86,297.3428571,298.2785714,296.5028571,304.9,292.9,62.3,95.52571429,157.86,18.10428571,7.3,27.03333333,7.766666667,34.1,22.0,261.7
+1291,iq,2007,18,2007-04-30,0.1947143,0.1541,0.2957143,0.1730857,103.39,297.2257143,298.0714286,295.9428571,304.7,293.6,47.24,93.47,103.39,17.51714286,7.371428571,27.85,9.75,33.0,21.0,118.2
+1292,iq,2007,19,2007-05-07,0.1582571,0.1622857,0.1830714,0.2322714,89.15,296.9057143,298.2214286,295.9942857,306.6,291.7,56.1,95.03714286,89.15,17.61142857,9.357142857,28.1,9.2,33.5,21.5,38.1
+1293,iq,2007,20,2007-05-14,0.1701857,0.1714,0.162,0.2290714,45.23,295.5957143,296.5,294.0128571,304.4,290.7,86.9,91.83285714,45.23,15.64857143,8.314285714,28.1,8.7,32.5,19.0,191.4
+1294,iq,2007,21,2007-05-21,0.3646143,0.2568286,0.3299,0.3496857,64.11,297.2328571,298.7071429,296.1685714,307.3,292.5,65.6,94.85285714,64.11,17.71857143,8.957142857,28.25,10.55,33.8,21.7,86.6
+1295,iq,2007,22,2007-05-28,0.09005714,0.08222857,0.1110571,0.06474286,76.68,296.1785714,297.1857143,294.0385714,306.8,286.9,29.1,89.28,76.68,15.74,10.2,24.7,10.63333333,32.8,17.5,61.8
+1296,iq,2007,23,2007-06-04,0.2085,0.25695,0.2148833,0.2338571,39.11,296.8614286,298.2428571,295.23,305.2,292.1,33.48,91.72,39.11,16.72714286,9.0,26.5,9.7,31.3,20.4,0.5
+1297,iq,2007,24,2007-06-11,0.3420714,0.2853,0.3405571,0.3012286,54.78,296.65,298.1714286,294.9285714,304.8,290.3,30.9,91.45857143,54.78,16.38857143,9.914285714,26.6,9.65,32.6,20.7,12.9
+1298,iq,2007,25,2007-06-18,0.1667,0.1207857,0.1729714,0.1659,78.83,296.1185714,297.3857143,294.9714286,304.4,292.8,70.3,94.06571429,78.83,16.42285714,6.885714286,25.96666667,7.6,32.0,21.2,126.0
+1299,iq,2007,26,2007-06-25,0.1534571,0.1744571,0.2022143,0.1292571,11.41,296.5714286,298.0142857,295.1785714,305.0,292.7,22.8,92.67142857,11.41,16.63142857,8.771428571,26.56666667,8.633333333,31.7,20.7,10.2
+1300,iq,2007,27,2007-07-02,0.1814429,0.2692286,0.1934571,0.2099429,1.59,296.8285714,298.1142857,292.1771429,305.8,290.2,1.4,78.07428571,1.59,13.80428571,12.22857143,25.9,10.56666667,32.0,19.6,
+1301,iq,2007,28,2007-07-09,0.3217667,0.2734,0.2545,0.3513,18.78,297.3857143,299.0071429,293.9314286,306.9,290.7,13.04,83.38714286,18.78,15.41571429,10.87142857,26.75,10.375,32.7,19.9,54.1
+1302,iq,2007,29,2007-07-16,0.3075571,0.3397,0.3642429,0.3648429,26.29,296.0585714,296.75,294.9414286,303.6,291.1,39.52,94.24714286,26.29,16.39142857,7.728571429,26.53333333,7.833333333,31.3,20.9,22.9
+1303,iq,2007,30,2007-07-23,0.3589714,0.4017571,0.2960857,0.4225,27.91,297.64,299.0785714,294.3457143,308.2,290.1,11.64,84.15571429,27.91,15.84571429,12.35714286,27.35,10.1,33.2,20.7,11.9
+1304,iq,2007,31,2007-07-30,0.4172286,0.3699286,0.3669714,0.4898714,70.88,296.7242857,297.9357143,293.0,305.6,290.0,25.5,82.57142857,70.88,14.71857143,11.5,24.25,9.75,34.0,16.4,55.9
+1305,iq,2007,32,2007-08-06,0.2782429,0.2361286,0.2923,0.2669571,35.77,297.82,299.3428571,292.7085714,308.2,289.7,6.08,76.61857143,35.77,14.33714286,12.77142857,26.475,12.0,32.7,17.2,30.3
+1306,iq,2007,33,2007-08-13,0.2666667,0.2719333,0.2438857,0.1964571,36.78,298.0914286,298.9428571,294.0728571,308.0,291.8,9.21,80.93571429,36.78,15.56571429,9.714285714,26.9,11.0,33.1,21.3,76.5
+1307,iq,2007,34,2007-08-20,0.3393714,0.3569714,0.3291286,0.3687143,9.06,298.7857143,300.6714286,294.1957143,308.1,294.3,12.4,79.33428571,9.06,15.75714286,11.57142857,27.125,10.825,33.3,19.9,22.1
+1308,iq,2007,35,2007-08-27,0.2787857,0.2463571,0.2349857,0.3737429,30.26,300.6671429,301.5928571,293.1242857,312.4,293.4,12.8,67.75714286,30.26,14.79428571,13.38571429,27.05,12.175,34.7,19.9,0.0
+1309,iq,2007,36,2007-09-03,0.27955,0.2826857,0.3277143,0.3280571,76.28,297.0985714,298.3571429,295.6828571,304.4,293.5,56.85,92.65714286,76.28,17.18285714,7.885714286,26.3,7.9,34.0,20.9,37.1
+1310,iq,2007,37,2007-09-10,0.2888167,0.2889571,0.2660714,0.3393,49.85,298.56,300.1214286,295.1628571,308.6,293.0,26.2,84.41285714,49.85,16.65,12.15714286,26.9,10.625,32.9,21.4,150.9
+1311,iq,2007,38,2007-09-17,0.3156571,0.3545,0.3326429,0.4172,58.22,298.5085714,300.7142857,295.8342857,309.2,293.3,34.27,86.70714286,58.22,17.36714286,12.4,27.2,10.83333333,33.0,21.6,16.3
+1312,iq,2007,39,2007-09-24,0.2309,0.2363429,0.2308857,0.3128,59.79,299.6985714,301.4285714,295.3,310.6,292.7,10.3,78.56428571,59.79,16.80428571,13.8,27.83333333,11.7,34.1,21.1,34.0
+1313,iq,2007,40,2007-10-01,0.3199714,0.2544167,0.3151,0.2934714,37.28,298.2814286,299.8214286,296.2871429,310.8,294.7,73.33,89.84428571,37.28,17.84,9.1,28.4,12.65,35.5,21.6,107.9
+1314,iq,2007,41,2007-10-08,0.3851857,0.4050714,0.3106286,0.4381286,39.09,299.5757143,301.3857143,295.4471429,309.6,294.8,38.28,80.45,39.09,17.01,11.6,28.4,10.6,34.2,21.8,145.1
+1315,iq,2007,42,2007-10-15,0.2251286,0.1505143,0.1959857,0.2383857,74.52,299.4442857,300.8285714,296.5871429,310.2,295.0,86.4,86.70571429,74.52,18.26571429,9.828571429,29.0,12.3,35.2,21.9,4.1
+1316,iq,2007,43,2007-10-22,0.4034714,0.3202286,0.4087,0.4229,106.73,296.9714286,298.1928571,295.96,305.1,291.9,67.93,94.78142857,106.73,17.54285714,7.757142857,26.9,9.366666667,32.1,20.9,79.3
+1317,iq,2007,44,2007-10-29,0.2657429,0.2856,0.2923143,0.2469143,51.28,297.83,299.6642857,296.9785714,306.3,293.7,67.47,95.59285714,51.28,18.67285714,9.357142857,27.0,9.366666667,34.0,21.6,0.0
+1318,iq,2007,45,2007-11-05,0.3334571,0.3242571,0.2469,0.3311286,69.88,299.4785714,300.5571429,296.2485714,308.5,294.3,50.6,84.85,69.88,17.97857143,9.485714286,28.7,11.43333333,34.8,22.5,22.1
+1319,iq,2007,46,2007-11-12,0.1784286,0.12875,0.2167714,0.1853,109.5,298.1342857,299.7428571,296.83,308.6,294.6,103.3,93.55428571,109.5,18.54857143,8.685714286,27.675,10.85,33.5,21.6,111.3
+1320,iq,2007,47,2007-11-19,0.2284714,0.1886571,0.2345571,0.1996714,52.27,297.6814286,298.3714286,296.9385714,305.7,294.3,124.2,96.21428571,52.27,18.61285714,5.742857143,26.62,7.86,33.3,21.8,80.0
+1321,iq,2007,48,2007-11-26,0.16564,0.1793,0.1276,0.1819143,129.33,297.88,299.3285714,297.2171429,305.2,294.4,65.57,96.52285714,129.33,18.92428571,6.942857143,27.125,8.35,32.3,22.4,293.1
+1322,iq,2007,49,2007-12-03,0.2993714,0.3367143,0.2615857,0.3498429,73.16,298.52,299.6071429,296.9042857,305.5,294.3,57.8,91.65428571,73.16,18.60714286,8.3,27.9,10.0,33.0,22.8,142.0
+1323,iq,2007,50,2007-12-10,0.3138333,0.2335143,0.2426,0.2937429,83.39,299.0485714,300.2714286,296.2614286,307.8,294.3,42.68,86.75571429,83.39,17.91,9.914285714,28.85,10.25,34.2,22.6,23.1
+1324,iq,2007,51,2007-12-17,0.2698,0.2756857,0.2755143,0.2367143,146.13,297.1414286,298.2428571,296.3971429,306.6,293.3,89.72,96.07428571,146.13,18.03428571,5.685714286,27.625,9.0,32.9,22.4,261.3
+1325,iq,2007,52,2007-12-24,0.1992,0.1947667,0.1711111,0.2308222,53.57,297.64,298.7285714,296.3685714,304.9,294.3,62.14,93.46857143,53.57,17.98285714,7.428571429,27.7,8.75,32.1,21.7,28.1
+1326,iq,2008,1,2008-01-01,0.1914714,0.1554143,0.1760143,0.1872429,19.95,299.2771429,300.5357143,294.6685714,308.2,294.1,21.4,78.67,19.95,16.26,10.72857143,28.275,11.575,36.0,21.5,
+1327,iq,2008,2,2008-01-08,0.4449333,0.27585,0.3569,0.4697286,71.84,296.0957143,296.5357143,295.2,302.1,293.3,62.61,95.28,71.84,16.68142857,5.1,25.8,6.3,31.4,22.6,104.4
+1328,iq,2008,3,2008-01-15,0.1882286,0.2208286,0.2332429,0.1699714,95.97,298.0342857,299.4785714,297.09,305.5,292.4,63.92,94.96857143,95.97,18.86571429,8.585714286,27.43333333,9.466666667,33.8,21.8,125.3
+1329,iq,2008,4,2008-01-22,0.2779714,0.3249286,0.2219143,0.2956714,102.59,297.2071429,298.3428571,296.25,304.8,294.8,93.43,95.12571429,102.59,17.84,5.971428571,,,31.3,21.9,46.3
+1330,iq,2008,5,2008-01-29,0.35195,0.3705714,0.3138,0.4029714,110.0,298.3985714,299.9714286,297.0114286,307.6,294.2,66.0,93.0,110.0,18.68571429,9.085714286,27.56666667,8.9,32.2,22.8,121.2
+1331,iq,2008,6,2008-02-05,0.2256429,0.17075,0.1981,0.1860714,38.72,299.49,300.7642857,294.6285714,308.4,293.5,28.0,78.13142857,38.72,16.28428571,11.55714286,27.86666667,11.1,34.5,20.5,5.1
+1332,iq,2008,7,2008-02-12,0.1739429,0.1989167,0.1684286,0.1734286,47.23,297.77,299.1714286,296.9228571,306.0,294.8,103.22,95.70714286,47.23,18.55714286,6.714285714,26.6,8.033333333,31.7,22.1,9.2
+1333,iq,2008,8,2008-02-19,0.24095,0.2236,0.1620429,0.1874429,122.64,297.0957143,298.3214286,295.6085714,304.1,292.9,33.9,92.37,122.64,17.13,7.614285714,28.0,10.8,33.4,22.0,115.3
+1334,iq,2008,9,2008-02-26,0.3493143,0.2227286,0.2677286,0.3878714,101.33,296.9642857,297.7214286,296.3814286,302.3,294.1,70.83,96.92714286,101.33,17.94714286,5.414285714,26.85,8.35,32.5,22.5,127.6
+1335,iq,2008,10,2008-03-04,0.1697429,0.1386667,0.1700571,0.2008429,210.83,297.7542857,299.3357143,295.52,307.9,293.3,39.1,88.97285714,210.83,17.06428571,8.957142857,27.18,8.88,33.3,21.9,119.6
+1336,iq,2008,11,2008-03-11,0.1292429,0.1729571,0.1260286,0.1506571,96.05,298.0171429,299.5928571,295.9,305.5,293.0,32.17,89.26857143,96.05,17.50571429,9.014285714,26.25,7.8,33.2,22.2,64.4
+1337,iq,2008,12,2008-03-18,0.2383333,0.2327286,0.1239429,0.2000714,91.87,296.7557143,297.9928571,295.4757143,305.0,293.3,90.5,93.45142857,91.87,16.99714286,7.214285714,,,31.7,22.0,100.9
+1338,iq,2008,13,2008-03-25,0.3366,0.3042143,0.3229,0.3773143,62.13,297.0942857,297.9928571,295.9485714,303.7,293.1,53.36,94.07428571,62.13,17.50714286,6.557142857,26.9,8.266666667,31.7,22.6,282.7
+1339,iq,2008,14,2008-04-01,0.2700833,0.1902714,0.1906571,0.2151571,107.0,297.6942857,298.8428571,295.8542857,305.4,293.7,24.9,90.95714286,107.0,17.42142857,8.6,27.86666667,9.0,33.4,22.5,21.1
+1340,iq,2008,15,2008-04-08,0.2843571,0.3536714,0.3217857,0.3028286,71.45,297.5371429,298.9,296.6328571,306.1,292.8,99.96,95.15714286,71.45,18.31571429,7.4,28.3,9.0,32.8,21.0,53.1
+1341,iq,2008,16,2008-04-15,0.3026143,0.2446714,0.2963143,0.3287571,79.74,297.4471429,298.6642857,295.9357143,305.5,293.8,45.96,92.12428571,79.74,17.50428571,7.785714286,26.8,8.1,33.6,21.7,61.0
+1342,iq,2008,17,2008-04-22,0.2706,0.3713143,0.3442286,0.2830714,42.05,296.76,297.4142857,296.3828571,301.9,293.7,62.52,97.97142857,42.05,17.96428571,4.885714286,26.65,7.7,33.0,21.6,85.9
+1343,iq,2008,18,2008-04-29,0.06172857,0.1339,0.09471429,0.1178429,42.12,298.0728571,299.4142857,296.7414286,306.3,293.1,115.99,93.66285714,42.12,18.39857143,8.685714286,27.86666667,8.0,32.5,22.7,31.2
+1344,iq,2008,19,2008-05-06,0.1361571,0.1631571,0.1391571,0.1345571,50.5,295.9757143,296.8714286,294.6657143,304.5,290.6,47.1,93.15857143,50.5,16.18,6.971428571,26.6,8.966666667,32.4,20.6,18.0
+1345,iq,2008,20,2008-05-13,0.1963857,0.29632,0.2641571,0.2255857,30.08,294.85,295.4214286,293.2442857,304.4,288.5,18.08,91.50428571,30.08,14.78,7.385714286,26.16666667,7.9,31.0,18.0,6.1
+1346,iq,2008,21,2008-05-20,0.2210167,0.2353167,0.1804429,0.1994714,45.69,296.2685714,296.9357143,295.6385714,303.4,291.7,59.4,96.62142857,45.69,17.14428571,5.957142857,26.35,8.85,31.5,21.4,58.2
+1347,iq,2008,22,2008-05-27,0.12245,0.1571,0.086,0.1033143,72.04,296.7414286,297.6928571,295.9942857,304.1,293.8,134.66,96.02571429,72.04,17.52,5.757142857,27.2,9.2,32.3,21.7,76.1
+1348,iq,2008,23,2008-06-03,0.1951857,0.1577143,0.1844286,0.1336143,30.09,296.4,297.3571429,295.21,304.4,292.2,73.01,93.98285714,30.09,16.71142857,6.771428571,26.9,7.55,31.1,20.4,13.6
+1349,iq,2008,24,2008-06-10,0.2937429,0.2643667,0.2466286,0.2919571,13.27,296.1871429,297.3642857,293.8914286,305.8,288.2,12.9,88.81,13.27,15.37571429,9.3,,,,17.8,6.4
+1350,iq,2008,25,2008-06-17,0.2240286,0.1754714,0.2656571,0.2452143,111.18,296.7428571,297.65,295.9342857,304.4,293.8,57.87,95.86,111.18,17.44714286,6.957142857,,,,21.0,79.8
+1351,iq,2008,26,2008-06-24,0.1970429,0.2779833,0.2139429,0.2656143,89.88,296.4585714,297.25,295.1928571,304.8,291.2,61.8,93.79571429,89.88,16.71285714,7.385714286,,,,18.0,93.5
+1352,iq,2008,27,2008-07-01,0.3048286,0.2336714,0.2489143,0.2558143,0.0,296.5428571,297.8071429,293.83,304.9,290.7,9.4,86.52428571,0.0,15.28571429,9.442857143,,,,20.8,1.3
+1353,iq,2008,28,2008-07-08,0.15385,0.1495857,0.3294429,0.1328857,0.0,296.5457143,297.4785714,293.5942857,305.9,290.5,7.47,85.65571429,0.0,15.08,9.271428571,,,,21.0,0.0
+1354,iq,2008,29,2008-07-15,0.2323857,0.2139571,0.2203,0.1984286,62.84,296.0785714,297.4071429,294.6914286,304.6,291.8,27.33,93.05571429,62.84,16.14285714,8.442857143,,,,21.0,44.2
+1355,iq,2008,30,2008-07-22,0.3270167,0.2091167,0.2837667,0.30955,52.36,296.5457143,297.3142857,295.0028571,306.8,287.8,47.59,92.77714286,52.36,16.58285714,8.6,26.6,9.775,32.4,20.8,18.1
+1356,iq,2008,31,2008-07-29,0.3548,0.34655,0.2674167,0.3921167,44.63,297.0442857,298.5,295.37,307.5,292.9,39.0,92.04857143,44.63,16.87285714,9.771428571,26.68,11.24,33.4,20.6,36.4
+1357,iq,2008,32,2008-08-05,0.2002,0.2513857,0.2113429,0.1997286,32.45,297.31,298.5714286,295.5057143,307.4,292.6,143.35,91.09285714,32.45,17.05714286,9.742857143,27.4,12.1,34.2,18.5,18.1
+1358,iq,2008,33,2008-08-12,0.4303714,0.4330143,0.4369143,0.4657286,26.03,297.2142857,298.5,295.3471429,305.6,292.7,39.69,90.72714286,26.03,16.84714286,9.342857143,27.9,11.225,34.8,19.8,11.0
+1359,iq,2008,34,2008-08-19,0.2833,0.3044714,0.2744571,0.3805,12.88,299.2285714,300.3071429,294.4185714,310.2,291.8,33.0,78.27714286,12.88,15.99857143,13.55714286,28.0,14.075,38.6,19.2,7.9
+1360,iq,2008,35,2008-08-26,0.3181857,0.3197667,0.3081714,0.3236,58.2,298.5742857,300.1428571,295.0928571,310.4,292.7,37.0,84.49142857,58.2,16.65285714,10.74285714,27.83333333,12.53333333,35.1,20.4,44.0
+1361,iq,2008,36,2008-09-02,0.3398,0.3691,0.2888,0.3092333,34.59,298.5314286,300.0714286,294.8614286,309.3,293.2,29.0,83.05,34.59,16.46571429,10.65714286,27.35,13.225,36.2,20.4,8.1
+1362,iq,2008,37,2008-09-09,0.2319,0.27625,0.2612,0.2327833,86.14,296.9214286,298.2428571,295.4842857,305.9,293.4,59.1,92.65285714,86.14,17.03,7.685714286,27.96666667,12.58333333,36.2,20.8,16.5
+1363,iq,2008,38,2008-09-16,0.2168,0.2773333,0.2089333,0.3362667,65.43,297.5885714,298.4285714,295.3071429,306.7,292.1,53.5,88.52571429,65.43,16.81857143,8.571428571,27.8,11.6,35.6,20.7,50.1
+1364,iq,2008,39,2008-09-23,0.41495,0.3634286,0.3224,0.4006857,61.38,297.66,298.6214286,295.49,309.3,292.7,63.27,90.18142857,61.38,17.04714286,8.157142857,27.75,12.45,37.0,20.8,26.9
+1365,iq,2008,40,2008-09-30,0.3930857,0.3782714,0.3437,0.4048429,24.28,299.1785714,301.15,294.7614286,310.2,292.4,121.3,79.50285714,24.28,16.33142857,12.78571429,,,36.0,19.6,1.0
+1366,iq,2008,41,2008-10-07,0.1605571,0.1638714,0.1949333,0.2061143,69.47,300.1014286,301.4071429,295.3614286,310.4,294.0,53.9,78.45428571,69.47,17.01857143,12.01428571,30.03333333,13.96666667,37.0,21.5,57.7
+1367,iq,2008,42,2008-10-14,0.2882,0.2278571,0.2807571,0.3579714,69.39,298.35,299.9,295.9157143,310.5,292.7,67.9,88.85714286,69.39,17.52714286,9.971428571,26.45,9.1,34.7,21.0,24.9
+1368,iq,2008,43,2008-10-21,0.3291571,0.2279,0.2733429,0.2568429,52.65,297.8671429,298.9857143,296.7014286,305.0,292.7,111.9,93.85428571,52.65,18.38857143,8.714285714,27.33333333,10.06666667,35.5,21.5,24.2
+1369,iq,2008,44,2008-10-28,0.1617429,0.1962,0.1982714,0.2196143,43.6,298.3728571,299.8,296.8257143,308.5,294.0,149.1,92.60857143,43.6,18.48428571,8.571428571,27.4,11.35,35.0,21.2,0.0
+1370,iq,2008,45,2008-11-04,0.5010286,0.445,0.4276857,0.5457286,57.85,298.4642857,299.5285714,297.4685714,307.2,293.1,107.48,95.29,57.85,19.25285714,7.085714286,27.82,12.1,35.6,21.2,109.0
+1371,iq,2008,46,2008-11-11,0.3042857,0.2946429,0.3062714,0.4003857,60.36,298.4985714,300.2214286,296.01,309.6,293.7,63.9,88.32857143,60.36,17.62571429,10.01428571,28.3,12.86666667,36.0,20.5,42.6
+1372,iq,2008,47,2008-11-18,0.1930571,0.1965286,0.1762571,0.1830571,59.44,298.89,300.3071429,297.7414286,307.2,295.2,199.52,94.14142857,59.44,19.61714286,7.814285714,27.96666667,12.1,34.5,21.7,10.6
+1373,iq,2008,48,2008-11-25,0.2510143,0.2883143,0.2537,0.3213,81.11,298.53,299.7214286,297.5771429,306.1,294.7,90.68,95.26,81.11,19.38857143,7.1,26.1,8.35,33.5,21.0,59.0
+1374,iq,2008,49,2008-12-02,0.1643667,0.19635,0.1731333,0.1549167,45.03,298.1114286,299.1285714,297.0442857,305.2,293.4,139.55,94.64,45.03,18.77857143,7.142857143,26.96,10.64,33.7,21.0,80.0
+1375,iq,2008,50,2008-12-09,0.2894167,0.34778,0.2748286,0.2580857,64.03,298.6514286,300.2142857,296.1828571,308.9,295.1,53.25,88.55142857,64.03,17.78428571,9.2,27.8,11.175,35.0,21.2,17.2
+1376,iq,2008,51,2008-12-16,0.1783857,0.2191714,0.2497286,0.1923,70.92,298.5285714,300.2571429,296.8471429,306.3,295.2,57.61,91.77714286,70.92,18.57285714,9.057142857,27.825,12.15,35.0,20.5,51.0
+1377,iq,2008,52,2008-12-23,0.2634125,0.219875,0.2000875,0.226625,55.11,299.5571429,300.7714286,295.5942857,308.3,293.9,41.6,81.86857143,55.11,17.24857143,10.34285714,28.08,12.02,35.4,21.2,0.5
+1378,iq,2009,1,2009-01-01,0.1512857,0.1616857,0.1532714,0.1194429,,,,,,,,,,,,,,,,
+1379,iq,2009,2,2009-01-08,0.2299167,0.12234,0.2611667,0.22305,52.28,297.7257143,299.0071429,296.7842857,304.6,294.2,93.55,95.22285714,52.28,18.46142857,7.5,27.26666667,11.1,34.8,21.1,86.1
+1380,iq,2009,3,2009-01-15,0.1884857,0.1881857,0.2039143,0.2775,72.03,296.6828571,297.4142857,296.4185714,304.0,295.2,149.77,98.61,72.03,17.99571429,3.714285714,27.18,10.24,33.3,21.1,72.8
+1381,iq,2009,4,2009-01-22,0.1884571,0.1993143,0.2027,0.2139286,76.16,296.55,297.5142857,295.1371429,303.5,292.7,53.81,92.46714286,76.16,16.64142857,6.485714286,27.56666667,10.7,34.0,21.8,11.2
+1382,iq,2009,5,2009-01-29,0.1667333,0.1737333,0.1904333,0.1617167,118.54,297.4957143,298.8,296.5142857,304.4,294.0,66.1,94.92857143,118.54,18.13,8.142857143,27.65,11.65,33.9,21.1,67.8
+1383,iq,2009,6,2009-02-05,0.2799143,0.2402857,0.1957286,0.3076571,149.06,297.4057143,298.1928571,296.84,302.7,294.5,93.3,97.00714286,149.06,18.48428571,5.185714286,27.46666667,12.33333333,35.0,21.0,44.1
+1384,iq,2009,7,2009-02-12,0.1702714,0.1511143,0.1404714,0.1429714,60.51,297.3228571,298.4714286,296.1942857,305.7,292.9,48.72,94.23428571,60.51,17.76571429,7.171428571,28.1,12.33333333,35.0,21.2,14.0
+1385,iq,2009,8,2009-02-19,0.1887857,0.1594571,0.1568714,0.2029857,124.8,297.6857143,299.0142857,296.2542857,306.7,294.2,124.0,92.90571429,124.8,17.85285714,6.828571429,27.7,12.54,35.0,20.5,111.4
+1386,iq,2009,9,2009-02-26,0.28236,0.3051167,0.2940833,0.3160167,147.44,297.3914286,298.8642857,296.4942857,306.6,294.3,102.72,95.12142857,147.44,18.12857143,7.071428571,26.58,10.52,33.2,20.5,84.1
+1387,iq,2009,10,2009-03-05,0.3620714,0.3367,0.3453,0.3792857,58.56,297.8442857,299.0,296.71,304.6,294.5,87.28,94.37857143,58.56,18.35428571,6.8,28.4,11.45,35.0,21.0,49.1
+1388,iq,2009,11,2009-03-12,0.2034286,0.1784429,0.2259714,0.2018714,97.8,297.0585714,298.0142857,296.7157143,304.0,293.6,108.83,98.13428571,97.8,18.35285714,6.028571429,27.3,11.8,33.8,21.0,0.0
+1389,iq,2009,12,2009-03-19,0.1578833,0.1921,0.2137286,0.2013857,106.68,297.3657143,298.25,296.5,304.6,293.6,66.83,95.70857143,106.68,18.10571429,6.185714286,27.8,10.5,33.7,21.0,14.3
+1390,iq,2009,13,2009-03-26,0.2235857,0.2591333,0.2632857,0.3057857,100.78,297.1528571,298.3214286,296.1842857,303.3,294.6,49.93,94.90285714,100.78,17.78,6.357142857,28.5,11.5,34.4,21.5,45.0
+1391,iq,2009,14,2009-04-02,0.08905714,0.05895,0.08927143,0.09934286,131.17,297.2457143,298.3857143,296.5457143,304.5,294.1,63.3,96.39571429,131.17,18.17571429,6.742857143,27.95,10.9,34.2,21.7,19.0
+1392,iq,2009,15,2009-04-09,0.1468429,0.1416571,0.1411857,0.1487714,133.47,297.89,298.9,295.8042857,306.8,293.1,50.64,89.67285714,133.47,17.42,9.028571429,27.13333333,10.86666667,35.0,21.0,134.9
+1393,iq,2009,16,2009-04-16,0.2236,0.1788286,0.175,0.2161429,99.77,296.6357143,297.6214286,296.1357143,304.7,292.6,74.5,97.3,99.77,17.70428571,6.385714286,26.9,10.83333333,33.0,21.2,87.3
+1394,iq,2009,17,2009-04-23,0.1953429,0.2856714,0.1611857,0.2023857,52.74,297.5457143,298.2785714,296.8871429,303.6,294.9,62.74,96.66428571,52.74,18.50428571,4.985714286,26.8,8.7,34.4,21.2,41.2
+1395,iq,2009,18,2009-04-30,0.2835857,0.3455143,0.2374429,0.3161286,99.89,297.4042857,298.3214286,296.4485714,303.6,294.3,93.8,95.07857143,99.89,18.01857143,6.271428571,27.15,10.75,34.0,21.0,30.8
+1396,iq,2009,19,2009-05-07,0.1907571,0.2645571,0.2538857,0.2192,30.73,297.5628571,298.5428571,296.4842857,306.8,292.9,59.5,95.1,30.73,18.09,7.142857143,28.1,10.5,35.0,22.0,44.0
+1397,iq,2009,20,2009-05-14,0.2077429,0.2278571,0.2542,0.2160429,38.51,297.6071429,299.0071429,296.2714286,306.5,292.7,46.43,93.29857143,38.51,17.85857143,9.071428571,28.075,11.425,35.0,22.0,11.2
+1398,iq,2009,21,2009-05-21,0.3312143,0.2172,0.2093857,0.3445143,66.46,297.7242857,299.5214286,296.0128571,307.1,293.4,39.89,91.79,66.46,17.58571429,10.07142857,28.35,11.45,34.6,21.4,50.5
+1399,iq,2009,22,2009-05-28,0.2383429,0.1973167,0.1655,0.1901429,40.04,296.7042857,297.5214286,296.2642857,305.1,292.7,73.0,97.74285714,40.04,17.83,5.614285714,27.6,10.26666667,34.4,21.0,19.3
+1400,iq,2009,23,2009-06-04,0.114,0.09244286,0.09747143,0.1262857,42.22,296.1257143,296.7785714,295.2671429,302.5,292.8,53.91,95.50714286,42.22,16.75714286,6.071428571,28.1,11.8,34.0,22.2,
+1401,iq,2009,24,2009-06-11,0.1871286,0.1578,0.1434571,0.1994714,8.74,295.1042857,295.7785714,293.91,305.2,289.9,112.31,94.13,8.74,15.48285714,6.242857143,24.66666667,8.633333333,33.5,20.0,23.9
+1402,iq,2009,25,2009-06-18,0.2916714,0.3070286,0.3562286,0.3891143,43.32,296.0314286,297.3142857,294.8628571,305.2,292.0,45.97,93.97142857,43.32,16.36285714,7.714285714,27.05,10.9,33.5,19.4,21.0
+1403,iq,2009,26,2009-06-25,0.2708,0.2051833,0.2401286,0.2001571,141.65,297.2171429,298.5214286,296.11,305.6,293.2,66.41,94.55571429,141.65,17.66714286,8.642857143,27.375,11.125,33.4,21.2,40.6
+1404,iq,2009,27,2009-07-02,0.1868571,0.1769143,0.2230714,0.2189857,68.15,296.4528571,297.8214286,295.3571429,304.6,292.3,55.5,94.53857143,68.15,16.87428571,8.642857143,27.45,10.7,33.4,21.4,14.0
+1405,iq,2009,28,2009-07-09,0.3859143,0.2903833,0.3364286,0.2927857,91.4,296.0657143,296.9928571,295.1671429,306.2,291.4,39.67,95.38571429,91.4,16.68,8.128571429,27.6,10.76666667,33.4,21.6,2.0
+1406,iq,2009,29,2009-07-16,0.21965,0.37805,0.2238714,0.2659,65.19,296.5271429,297.6642857,295.4114286,306.8,292.7,40.1,94.62428571,65.19,16.92,7.271428571,26.825,10.425,34.5,21.3,38.9
+1407,iq,2009,30,2009-07-23,0.2078833,0.28085,0.1756,0.2616,35.82,296.5257143,297.9642857,294.0528571,306.7,292.3,12.93,88.23,35.82,15.51,9.528571429,26.95,10.25,32.2,21.0,20.4
+1408,iq,2009,31,2009-07-30,0.1543571,0.1152714,0.1534571,0.1559,51.77,297.0871429,298.2357143,295.0457143,307.9,290.4,39.3,89.97142857,51.77,16.60285714,9.757142857,27.0,11.5,33.5,20.5,32.0
+1409,iq,2009,32,2009-08-06,0.395,0.3527333,0.4842857,0.4019143,9.79,297.37,298.8785714,294.8242857,307.9,290.7,34.4,87.81142857,9.79,16.33714286,11.75714286,27.975,12.1,35.4,20.5,
+1410,iq,2009,33,2009-08-13,0.3308857,0.4083,0.4433571,0.3347714,35.23,298.3571429,299.9857143,295.5071429,308.2,292.2,43.2,87.11,35.23,17.04,11.34285714,27.7,11.5,33.4,21.0,20.1
+1411,iq,2009,34,2009-08-20,0.2206286,0.1943571,0.2785714,0.2604571,6.52,298.6771429,300.1071429,294.7085714,309.3,293.0,25.3,80.64,6.52,16.22857143,10.92857143,28.32,12.86,36.2,21.2,1.0
+1412,iq,2009,35,2009-08-27,0.2453429,0.1859857,0.1813429,0.2820571,95.83,298.9971429,300.9214286,296.4442857,310.4,293.4,45.34,88.17714286,95.83,18.12285714,11.78571429,29.0,13.0,36.2,22.0,27.2
+1413,iq,2009,36,2009-09-03,0.5083571,0.4544286,0.5383143,0.5148286,83.02,297.3885714,298.45,296.3885714,305.0,293.5,78.37,94.99285714,83.02,17.98857143,7.642857143,27.6,13.2,34.2,21.0,47.5
+1414,iq,2009,37,2009-09-10,0.1896167,0.192,0.2368143,0.2696857,13.74,299.8557143,300.75,294.3142857,310.0,291.8,9.3,75.23285714,13.74,15.86571429,13.04285714,29.16666667,14.13333333,37.4,21.4,6.1
+1415,iq,2009,38,2009-09-17,0.26632,0.3133667,0.1956571,0.3070714,40.17,299.47,300.8142857,294.6185714,310.0,293.5,23.01,78.11857143,40.17,16.20285714,11.6,28.85,12.75,37.2,20.4,0.8
+1416,iq,2009,39,2009-09-24,0.2943143,0.2706714,0.3020714,0.2540143,78.68,299.3242857,301.0285714,295.8271429,309.8,293.7,33.0,83.76285714,78.68,17.38,11.0,28.86666667,13.3,37.0,21.0,8.1
+1417,iq,2009,40,2009-10-01,0.2063,0.2552571,0.2799571,0.2066571,57.18,298.0342857,299.5714286,296.3442857,307.4,294.8,79.1,91.57571429,57.18,17.94714286,8.514285714,27.95,12.225,35.2,20.5,33.1
+1418,iq,2009,41,2009-10-08,0.2322714,0.2725,0.2715714,0.2853857,20.58,298.7071429,300.1285714,296.5614286,308.3,294.3,43.94,89.31,20.58,18.13428571,9.285714286,27.64,11.66,34.8,21.0,29.4
+1419,iq,2009,42,2009-10-15,0.2974143,0.2821714,0.2559286,0.3197857,30.49,299.7371429,301.0,295.35,311.3,293.8,18.1,79.22285714,30.49,16.89571429,11.88571429,27.75,10.65,34.2,21.2,11.2
+1420,iq,2009,43,2009-10-22,0.2968,0.3084857,0.3623,0.3616571,82.59,298.8557143,300.2857143,296.9185714,307.2,294.1,67.4,90.65714286,82.59,18.66142857,8.571428571,27.73333333,12.2,35.3,21.0,137.1
+1421,iq,2009,44,2009-10-29,0.2907571,0.23795,0.3176857,0.2616,77.38,298.6785714,300.0714286,297.4428571,310.8,294.9,84.54,93.80857143,77.38,19.25428571,8.342857143,27.8,11.32,35.2,21.0,11.2
+1422,iq,2009,45,2009-11-05,0.3886714,0.3728167,0.2499,0.3730143,45.79,299.1614286,300.4785714,297.14,309.7,292.2,47.31,90.37285714,45.79,18.93714286,10.18571429,29.86666667,12.73333333,36.8,21.2,3.5
+1423,iq,2009,46,2009-11-12,0.3688714,0.3799571,0.3800286,0.4679286,96.23,300.3214286,301.7857143,296.9257143,308.7,296.0,31.65,84.31142857,96.23,18.66428571,10.45714286,28.94,11.96,35.3,21.9,88.2
+1424,iq,2009,47,2009-11-19,0.40705,0.3351,0.3665,0.38935,29.72,300.4857143,301.75,296.1085714,311.0,294.5,47.0,80.78714286,29.72,17.80714286,11.92857143,28.9,12.33333333,36.2,22.3,39.1
+1425,iq,2009,48,2009-11-26,0.3361143,0.2877667,0.3254571,0.3576,38.17,299.4557143,300.6142857,297.2257143,308.7,295.1,60.7,89.59428571,38.17,19.00142857,8.714285714,28.43333333,11.83333333,36.2,21.8,17.0
+1426,iq,2009,49,2009-12-03,0.3485286,0.2904,0.4106143,0.3704571,73.45,298.7628571,299.9357143,296.97,308.9,295.0,134.43,91.70857143,73.45,18.67142857,7.757142857,28.025,10.375,35.3,22.2,49.0
+1427,iq,2009,50,2009-12-10,0.1922,0.1935286,0.2398857,0.2858857,85.62,299.1985714,300.6785714,296.5957143,308.6,294.6,49.32,87.75285714,85.62,18.30428571,10.44285714,28.55,11.0,35.2,21.2,41.9
+1428,iq,2009,51,2009-12-17,0.2176,0.2403,0.1817714,0.2623,81.21,298.3471429,299.35,296.9057143,307.5,295.0,208.87,92.95857143,81.21,18.60142857,6.671428571,28.2,11.125,35.6,22.0,54.1
+1429,iq,2009,52,2009-12-24,0.2104222,0.2571375,0.2211333,0.3002556,98.79,297.1814286,298.1857143,296.5571429,302.9,294.9,66.3,96.88571429,98.79,18.18,5.257142857,27.2,8.2,32.2,21.8,31.2
+1430,iq,2010,53,2010-01-01,,,,,,,,,,,,,,,,,,,,
+1431,iq,2010,1,2010-01-08,0.1245714,0.1791286,0.1638429,0.1354714,27.04,299.2642857,300.5214286,294.53,308.6,292.8,8.5,78.27142857,27.04,16.12714286,11.1,28.6,12.3,35.1,21.8,
+1432,iq,2010,2,2010-01-15,0.1452857,0.1423143,0.1353,0.1675286,32.99,298.2971429,299.9357143,296.1471429,308.0,293.8,144.6,89.80714286,32.99,17.75857143,9.157142857,27.83333333,11.3,34.2,22.1,15.0
+1433,iq,2010,3,2010-01-22,0.2521143,0.2304857,0.1873286,0.3027857,19.04,298.9257143,300.4571429,296.38,307.8,294.8,31.2,87.64142857,19.04,18.00142857,8.628571429,28.96666667,11.26666667,35.2,22.5,0.8
+1434,iq,2010,4,2010-01-29,0.2632714,0.2306,0.2188714,0.2612857,138.51,298.2914286,299.6142857,296.56,308.3,295.0,65.76,91.79857143,138.51,18.19285714,7.685714286,27.8,10.52,35.3,22.4,166.0
+1435,iq,2010,5,2010-02-05,0.1701,0.1421167,0.1179143,0.1393429,47.31,298.7542857,300.3428571,296.8371429,306.1,295.6,95.83,90.64857143,47.31,18.52285714,8.314285714,27.8,9.266666667,34.2,22.0,62.3
+1436,iq,2010,6,2010-02-12,0.2307571,0.1892571,0.1634857,0.2388714,78.25,298.2514286,299.6785714,297.5685714,306.2,295.5,172.7,96.51571429,78.25,19.34571429,6.328571429,27.0,8.3,33.2,22.9,14.5
+1437,iq,2010,7,2010-02-19,0.2933,0.2478286,0.2066286,0.2666714,32.19,299.6485714,300.95,297.09,309.2,294.5,54.2,88.36571429,32.19,18.85714286,9.414285714,27.3,11.8,35.5,21.4,60.9
+1438,iq,2010,8,2010-02-26,0.3036571,0.2600571,0.2254857,0.3333143,84.67,298.9171429,300.4857143,297.9285714,308.2,295.2,288.4,94.91571429,84.67,19.77285714,8.171428571,28.02,10.36,35.4,21.4,29.9
+1439,iq,2010,9,2010-03-05,0.1273167,0.18116,0.1204667,0.1427667,80.58,298.3371429,299.6642857,297.9171429,306.3,295.8,144.98,97.7,80.58,19.75428571,6.242857143,28.5,9.9,35.4,21.2,9.9
+1440,iq,2010,10,2010-03-12,0.3117286,0.2926857,0.2725857,0.3948,57.78,298.8371429,300.0928571,298.1414286,306.9,292.8,86.1,96.25,57.78,20.09142857,8.814285714,28.55,10.05,35.4,21.4,44.5
+1441,iq,2010,11,2010-03-19,0.2946,0.2509714,0.2814714,0.3416429,121.2,299.1914286,300.9285714,298.45,307.4,294.0,191.76,96.12428571,121.2,20.46142857,8.828571429,30.0,12.0,36.0,22.0,22.9
+1442,iq,2010,12,2010-03-26,0.2662857,0.3012333,0.296,0.2957429,51.29,299.0042857,300.3,297.5557143,307.9,294.6,214.9,93.08285714,51.29,19.36857143,8.028571429,27.46666667,9.333333333,34.5,21.0,20.0
+1443,iq,2010,13,2010-04-02,0.1414333,0.2047286,0.2509714,0.1452429,49.8,299.0028571,300.7142857,296.5685714,309.1,294.2,24.25,88.70714286,49.8,18.21428571,9.514285714,27.93333333,12.3,35.3,21.0,16.0
+1444,iq,2010,14,2010-04-09,0.2428429,0.2727571,0.2022714,0.2601143,93.76,299.1157143,300.2714286,298.1614286,308.4,294.6,164.7,95.18285714,93.76,20.07857143,7.714285714,29.2,12.3,35.4,22.5,
+1445,iq,2010,15,2010-04-16,0.1576857,0.1566143,0.1840143,0.1358857,17.33,298.3057143,299.5571429,297.0028571,307.3,294.3,150.8,93.65571429,17.33,18.67714286,7.228571429,27.15,9.6,33.0,21.2,18.0
+1446,iq,2010,16,2010-04-23,0.2314857,0.2946857,0.3316571,0.2444,86.7,298.4385714,299.5071429,297.6785714,304.7,294.7,81.4,95.99571429,86.7,19.44857143,7.757142857,27.85,9.6,33.5,22.5,51.1
+1447,iq,2010,17,2010-04-30,0.2397429,0.2592714,0.3077857,0.3079429,26.0,299.0485714,300.0285714,296.4685714,308.4,294.6,23.6,87.65714286,26.0,18.06857143,8.257142857,28.85,12.125,36.2,21.4,35.4
+1448,iq,2010,18,2010-05-07,0.2608143,0.2557857,0.2577714,0.3402857,73.97,297.6171429,298.5857143,296.9757143,304.7,294.6,85.46,96.71285714,73.97,18.60285714,5.714285714,27.6,9.6,33.2,21.4,8.1
+1449,iq,2010,19,2010-05-14,0.1686857,0.1585,0.1330714,0.1456,59.4,297.2785714,297.9357143,296.7385714,306.0,294.0,87.3,97.44571429,59.4,18.39142857,6.185714286,27.4,10.4,33.7,21.2,32.0
+1450,iq,2010,20,2010-05-21,0.2630714,0.2725,0.2582714,0.2445,1.15,297.6485714,298.7071429,293.2271429,308.7,290.1,8.8,78.99857143,1.15,14.90857143,11.24285714,25.63333333,9.2,34.0,20.0,2.5
+1451,iq,2010,21,2010-05-28,0.34275,0.3189,0.2563429,0.2925143,55.3,299.3342857,300.7714286,296.8257143,309.7,294.5,45.0,88.76571429,55.3,18.48571429,9.8,28.63333333,11.93333333,35.4,22.4,27.0
+1452,iq,2010,22,2010-06-04,0.1601571,0.1603714,0.1360429,0.2256571,86.47,298.33,299.3928571,296.4528571,308.5,291.9,207.1,91.6,86.47,18.07,7.471428571,27.43333333,10.5,34.7,21.7,36.6
+1453,iq,2010,23,2010-06-11,0.2470571,0.1460571,0.2503571,0.2337143,58.94,296.5985714,297.5928571,295.5014286,305.5,292.4,50.6,94.28,58.94,17.00857143,7.5,24.4,6.9,32.2,19.2,7.4
+1454,iq,2010,24,2010-06-18,0.3339143,0.2457714,0.2788857,0.3254857,59.67,296.3457143,297.5214286,295.3242857,306.1,291.9,62.33,94.66,59.67,16.81571429,7.871428571,25.43333333,8.733333333,31.2,21.0,16.0
+1455,iq,2010,25,2010-06-25,0.2981857,0.2329714,0.2742143,0.3157571,63.22,298.0971429,299.8357143,295.8071429,307.8,292.3,36.9,89.08285714,63.22,17.35571429,11.01428571,27.475,9.9,33.7,22.2,20.4
diff --git a/examples/dengue-fever-time-series/data/dengue_labels_train.csv b/examples/dengue-fever-time-series/data/dengue_labels_train.csv
new file mode 100644
index 000000000..8dafe00ec
--- /dev/null
+++ b/examples/dengue-fever-time-series/data/dengue_labels_train.csv
@@ -0,0 +1,1457 @@
+city,year,weekofyear,total_cases
+sj,1990,18,4
+sj,1990,19,5
+sj,1990,20,4
+sj,1990,21,3
+sj,1990,22,6
+sj,1990,23,2
+sj,1990,24,4
+sj,1990,25,5
+sj,1990,26,10
+sj,1990,27,6
+sj,1990,28,8
+sj,1990,29,2
+sj,1990,30,6
+sj,1990,31,17
+sj,1990,32,23
+sj,1990,33,13
+sj,1990,34,21
+sj,1990,35,28
+sj,1990,36,24
+sj,1990,37,20
+sj,1990,38,40
+sj,1990,39,27
+sj,1990,40,42
+sj,1990,41,33
+sj,1990,42,43
+sj,1990,43,37
+sj,1990,44,57
+sj,1990,45,71
+sj,1990,46,44
+sj,1990,47,56
+sj,1990,48,53
+sj,1990,49,52
+sj,1990,50,47
+sj,1990,51,26
+sj,1990,52,27
+sj,1991,1,21
+sj,1991,2,21
+sj,1991,3,26
+sj,1991,4,34
+sj,1991,5,37
+sj,1991,6,17
+sj,1991,7,19
+sj,1991,8,25
+sj,1991,9,18
+sj,1991,10,21
+sj,1991,11,17
+sj,1991,12,17
+sj,1991,13,16
+sj,1991,14,16
+sj,1991,15,15
+sj,1991,16,23
+sj,1991,17,16
+sj,1991,18,17
+sj,1991,19,12
+sj,1991,20,17
+sj,1991,21,10
+sj,1991,22,15
+sj,1991,23,19
+sj,1991,24,21
+sj,1991,25,14
+sj,1991,26,18
+sj,1991,27,13
+sj,1991,28,14
+sj,1991,29,18
+sj,1991,30,23
+sj,1991,31,25
+sj,1991,32,62
+sj,1991,33,60
+sj,1991,34,76
+sj,1991,35,66
+sj,1991,36,64
+sj,1991,37,68
+sj,1991,38,89
+sj,1991,39,92
+sj,1991,40,140
+sj,1991,41,116
+sj,1991,42,142
+sj,1991,43,129
+sj,1991,44,140
+sj,1991,45,140
+sj,1991,46,127
+sj,1991,47,129
+sj,1991,48,169
+sj,1991,49,141
+sj,1991,50,108
+sj,1991,51,78
+sj,1991,52,70
+sj,1992,1,81
+sj,1992,2,104
+sj,1992,3,90
+sj,1992,4,85
+sj,1992,5,55
+sj,1992,6,53
+sj,1992,7,65
+sj,1992,8,33
+sj,1992,9,38
+sj,1992,10,59
+sj,1992,11,40
+sj,1992,12,37
+sj,1992,13,29
+sj,1992,14,30
+sj,1992,15,30
+sj,1992,16,28
+sj,1992,17,23
+sj,1992,18,24
+sj,1992,19,29
+sj,1992,20,26
+sj,1992,21,23
+sj,1992,22,20
+sj,1992,23,19
+sj,1992,24,20
+sj,1992,25,26
+sj,1992,26,29
+sj,1992,27,31
+sj,1992,28,28
+sj,1992,29,26
+sj,1992,30,32
+sj,1992,31,35
+sj,1992,32,33
+sj,1992,33,30
+sj,1992,34,52
+sj,1992,35,59
+sj,1992,36,67
+sj,1992,37,65
+sj,1992,38,74
+sj,1992,39,70
+sj,1992,40,61
+sj,1992,41,53
+sj,1992,42,76
+sj,1992,43,61
+sj,1992,44,57
+sj,1992,45,44
+sj,1992,46,34
+sj,1992,47,47
+sj,1992,48,60
+sj,1992,49,60
+sj,1992,50,53
+sj,1992,51,36
+sj,1992,52,31
+sj,1993,53,30
+sj,1993,1,32
+sj,1993,2,28
+sj,1993,3,33
+sj,1993,4,33
+sj,1993,5,35
+sj,1993,6,22
+sj,1993,7,13
+sj,1993,8,13
+sj,1993,9,21
+sj,1993,10,17
+sj,1993,11,11
+sj,1993,12,8
+sj,1993,13,8
+sj,1993,14,6
+sj,1993,15,6
+sj,1993,16,7
+sj,1993,17,12
+sj,1993,18,17
+sj,1993,19,10
+sj,1993,20,10
+sj,1993,21,18
+sj,1993,22,19
+sj,1993,23,12
+sj,1993,24,22
+sj,1993,25,12
+sj,1993,26,21
+sj,1993,27,18
+sj,1993,28,16
+sj,1993,29,16
+sj,1993,30,22
+sj,1993,31,17
+sj,1993,32,25
+sj,1993,33,23
+sj,1993,34,12
+sj,1993,35,25
+sj,1993,36,28
+sj,1993,37,27
+sj,1993,38,18
+sj,1993,39,23
+sj,1993,40,23
+sj,1993,41,29
+sj,1993,42,38
+sj,1993,43,36
+sj,1993,44,43
+sj,1993,45,46
+sj,1993,46,31
+sj,1993,47,25
+sj,1993,48,40
+sj,1993,49,31
+sj,1993,50,38
+sj,1993,51,30
+sj,1994,52,22
+sj,1994,1,31
+sj,1994,2,26
+sj,1994,3,35
+sj,1994,4,36
+sj,1994,5,39
+sj,1994,6,25
+sj,1994,7,31
+sj,1994,8,37
+sj,1994,9,33
+sj,1994,10,25
+sj,1994,11,24
+sj,1994,12,18
+sj,1994,13,23
+sj,1994,14,13
+sj,1994,15,18
+sj,1994,16,14
+sj,1994,17,17
+sj,1994,18,22
+sj,1994,19,13
+sj,1994,20,24
+sj,1994,21,31
+sj,1994,22,34
+sj,1994,23,31
+sj,1994,24,31
+sj,1994,25,38
+sj,1994,26,49
+sj,1994,27,42
+sj,1994,28,49
+sj,1994,29,55
+sj,1994,30,80
+sj,1994,31,84
+sj,1994,32,72
+sj,1994,33,89
+sj,1994,34,115
+sj,1994,35,179
+sj,1994,36,202
+sj,1994,37,272
+sj,1994,38,302
+sj,1994,39,395
+sj,1994,40,426
+sj,1994,41,461
+sj,1994,42,381
+sj,1994,43,333
+sj,1994,44,353
+sj,1994,45,410
+sj,1994,46,364
+sj,1994,47,359
+sj,1994,48,288
+sj,1994,49,221
+sj,1994,50,149
+sj,1994,51,112
+sj,1995,52,154
+sj,1995,1,91
+sj,1995,2,72
+sj,1995,3,56
+sj,1995,4,46
+sj,1995,5,37
+sj,1995,6,26
+sj,1995,7,17
+sj,1995,8,17
+sj,1995,9,20
+sj,1995,10,11
+sj,1995,11,7
+sj,1995,12,16
+sj,1995,13,14
+sj,1995,14,16
+sj,1995,15,5
+sj,1995,16,2
+sj,1995,17,6
+sj,1995,18,5
+sj,1995,19,4
+sj,1995,20,3
+sj,1995,21,4
+sj,1995,22,16
+sj,1995,23,8
+sj,1995,24,7
+sj,1995,25,10
+sj,1995,26,14
+sj,1995,27,7
+sj,1995,28,9
+sj,1995,29,11
+sj,1995,30,23
+sj,1995,31,17
+sj,1995,32,19
+sj,1995,33,24
+sj,1995,34,17
+sj,1995,35,28
+sj,1995,36,40
+sj,1995,37,33
+sj,1995,38,31
+sj,1995,39,33
+sj,1995,40,29
+sj,1995,41,30
+sj,1995,42,36
+sj,1995,43,48
+sj,1995,44,40
+sj,1995,45,28
+sj,1995,46,36
+sj,1995,47,19
+sj,1995,48,34
+sj,1995,49,23
+sj,1995,50,17
+sj,1995,51,17
+sj,1996,1,23
+sj,1996,2,14
+sj,1996,3,20
+sj,1996,4,13
+sj,1996,5,23
+sj,1996,6,20
+sj,1996,7,16
+sj,1996,8,16
+sj,1996,9,23
+sj,1996,10,14
+sj,1996,11,15
+sj,1996,12,4
+sj,1996,13,5
+sj,1996,14,5
+sj,1996,15,11
+sj,1996,16,11
+sj,1996,17,7
+sj,1996,18,4
+sj,1996,19,6
+sj,1996,20,5
+sj,1996,21,2
+sj,1996,22,4
+sj,1996,23,2
+sj,1996,24,4
+sj,1996,25,6
+sj,1996,26,6
+sj,1996,27,4
+sj,1996,28,6
+sj,1996,29,11
+sj,1996,30,16
+sj,1996,31,9
+sj,1996,32,12
+sj,1996,33,13
+sj,1996,34,27
+sj,1996,35,21
+sj,1996,36,19
+sj,1996,37,17
+sj,1996,38,24
+sj,1996,39,27
+sj,1996,40,30
+sj,1996,41,29
+sj,1996,42,25
+sj,1996,43,35
+sj,1996,44,33
+sj,1996,45,30
+sj,1996,46,29
+sj,1996,47,31
+sj,1996,48,29
+sj,1996,49,22
+sj,1996,50,27
+sj,1996,51,24
+sj,1996,52,26
+sj,1997,1,29
+sj,1997,2,22
+sj,1997,3,33
+sj,1997,4,24
+sj,1997,5,30
+sj,1997,6,20
+sj,1997,7,17
+sj,1997,8,24
+sj,1997,9,28
+sj,1997,10,18
+sj,1997,11,13
+sj,1997,12,9
+sj,1997,13,14
+sj,1997,14,11
+sj,1997,15,11
+sj,1997,16,19
+sj,1997,17,10
+sj,1997,18,8
+sj,1997,19,8
+sj,1997,20,9
+sj,1997,21,3
+sj,1997,22,7
+sj,1997,23,14
+sj,1997,24,4
+sj,1997,25,9
+sj,1997,26,14
+sj,1997,27,7
+sj,1997,28,9
+sj,1997,29,3
+sj,1997,30,3
+sj,1997,31,14
+sj,1997,32,12
+sj,1997,33,10
+sj,1997,34,21
+sj,1997,35,26
+sj,1997,36,47
+sj,1997,37,42
+sj,1997,38,31
+sj,1997,39,34
+sj,1997,40,33
+sj,1997,41,52
+sj,1997,42,56
+sj,1997,43,70
+sj,1997,44,112
+sj,1997,45,70
+sj,1997,46,47
+sj,1997,47,48
+sj,1997,48,49
+sj,1997,49,66
+sj,1997,50,56
+sj,1997,51,61
+sj,1997,52,67
+sj,1998,1,64
+sj,1998,2,68
+sj,1998,3,49
+sj,1998,4,50
+sj,1998,5,56
+sj,1998,6,75
+sj,1998,7,63
+sj,1998,8,62
+sj,1998,9,41
+sj,1998,10,50
+sj,1998,11,34
+sj,1998,12,31
+sj,1998,13,38
+sj,1998,14,30
+sj,1998,15,32
+sj,1998,16,26
+sj,1998,17,30
+sj,1998,18,36
+sj,1998,19,35
+sj,1998,20,46
+sj,1998,21,48
+sj,1998,22,44
+sj,1998,23,51
+sj,1998,24,59
+sj,1998,25,71
+sj,1998,26,102
+sj,1998,27,128
+sj,1998,28,127
+sj,1998,29,150
+sj,1998,30,191
+sj,1998,31,256
+sj,1998,32,329
+sj,1998,33,263
+sj,1998,34,220
+sj,1998,35,204
+sj,1998,36,181
+sj,1998,37,99
+sj,1998,38,54
+sj,1998,39,80
+sj,1998,40,102
+sj,1998,41,127
+sj,1998,42,73
+sj,1998,43,68
+sj,1998,44,64
+sj,1998,45,55
+sj,1998,46,67
+sj,1998,47,84
+sj,1998,48,85
+sj,1998,49,67
+sj,1998,50,73
+sj,1998,51,89
+sj,1998,52,68
+sj,1999,53,59
+sj,1999,1,56
+sj,1999,2,77
+sj,1999,3,75
+sj,1999,4,47
+sj,1999,5,50
+sj,1999,6,42
+sj,1999,7,28
+sj,1999,8,37
+sj,1999,9,37
+sj,1999,10,27
+sj,1999,11,12
+sj,1999,12,15
+sj,1999,13,22
+sj,1999,14,8
+sj,1999,15,15
+sj,1999,16,17
+sj,1999,17,10
+sj,1999,18,9
+sj,1999,19,11
+sj,1999,20,20
+sj,1999,21,13
+sj,1999,22,11
+sj,1999,23,16
+sj,1999,24,11
+sj,1999,25,7
+sj,1999,26,17
+sj,1999,27,14
+sj,1999,28,13
+sj,1999,29,15
+sj,1999,30,30
+sj,1999,31,25
+sj,1999,32,40
+sj,1999,33,44
+sj,1999,34,25
+sj,1999,35,21
+sj,1999,36,48
+sj,1999,37,56
+sj,1999,38,60
+sj,1999,39,45
+sj,1999,40,55
+sj,1999,41,32
+sj,1999,42,46
+sj,1999,43,61
+sj,1999,44,42
+sj,1999,45,37
+sj,1999,46,43
+sj,1999,47,34
+sj,1999,48,40
+sj,1999,49,25
+sj,1999,50,16
+sj,1999,51,17
+sj,2000,52,17
+sj,2000,1,16
+sj,2000,2,23
+sj,2000,3,18
+sj,2000,4,18
+sj,2000,5,9
+sj,2000,6,7
+sj,2000,7,7
+sj,2000,8,4
+sj,2000,9,3
+sj,2000,10,2
+sj,2000,11,8
+sj,2000,12,3
+sj,2000,13,1
+sj,2000,14,1
+sj,2000,15,2
+sj,2000,16,3
+sj,2000,17,3
+sj,2000,18,2
+sj,2000,19,0
+sj,2000,20,0
+sj,2000,21,2
+sj,2000,22,2
+sj,2000,23,0
+sj,2000,24,6
+sj,2000,25,3
+sj,2000,26,6
+sj,2000,27,2
+sj,2000,28,3
+sj,2000,29,2
+sj,2000,30,4
+sj,2000,31,5
+sj,2000,32,2
+sj,2000,33,9
+sj,2000,34,2
+sj,2000,35,4
+sj,2000,36,8
+sj,2000,37,6
+sj,2000,38,3
+sj,2000,39,11
+sj,2000,40,14
+sj,2000,41,15
+sj,2000,42,20
+sj,2000,43,9
+sj,2000,44,20
+sj,2000,45,28
+sj,2000,46,38
+sj,2000,47,30
+sj,2000,48,30
+sj,2000,49,23
+sj,2000,50,16
+sj,2000,51,22
+sj,2001,1,28
+sj,2001,2,14
+sj,2001,3,17
+sj,2001,4,20
+sj,2001,5,17
+sj,2001,6,10
+sj,2001,7,13
+sj,2001,8,20
+sj,2001,9,9
+sj,2001,10,18
+sj,2001,11,9
+sj,2001,12,8
+sj,2001,13,19
+sj,2001,14,11
+sj,2001,15,4
+sj,2001,16,6
+sj,2001,17,6
+sj,2001,18,8
+sj,2001,19,13
+sj,2001,20,8
+sj,2001,21,8
+sj,2001,22,5
+sj,2001,23,16
+sj,2001,24,12
+sj,2001,25,11
+sj,2001,26,18
+sj,2001,27,10
+sj,2001,28,22
+sj,2001,29,14
+sj,2001,30,16
+sj,2001,31,18
+sj,2001,32,27
+sj,2001,33,38
+sj,2001,34,35
+sj,2001,35,41
+sj,2001,36,51
+sj,2001,37,65
+sj,2001,38,55
+sj,2001,39,54
+sj,2001,40,62
+sj,2001,41,64
+sj,2001,42,56
+sj,2001,43,65
+sj,2001,44,71
+sj,2001,45,75
+sj,2001,46,71
+sj,2001,47,72
+sj,2001,48,47
+sj,2001,49,27
+sj,2001,50,35
+sj,2001,51,25
+sj,2001,52,19
+sj,2002,1,37
+sj,2002,2,38
+sj,2002,3,34
+sj,2002,4,26
+sj,2002,5,19
+sj,2002,6,18
+sj,2002,7,22
+sj,2002,8,16
+sj,2002,9,18
+sj,2002,10,6
+sj,2002,11,12
+sj,2002,12,6
+sj,2002,13,6
+sj,2002,14,3
+sj,2002,15,7
+sj,2002,16,6
+sj,2002,17,1
+sj,2002,18,3
+sj,2002,19,2
+sj,2002,20,2
+sj,2002,21,1
+sj,2002,22,10
+sj,2002,23,3
+sj,2002,24,3
+sj,2002,25,1
+sj,2002,26,1
+sj,2002,27,2
+sj,2002,28,6
+sj,2002,29,3
+sj,2002,30,3
+sj,2002,31,5
+sj,2002,32,4
+sj,2002,33,7
+sj,2002,34,6
+sj,2002,35,5
+sj,2002,36,7
+sj,2002,37,6
+sj,2002,38,4
+sj,2002,39,4
+sj,2002,40,7
+sj,2002,41,9
+sj,2002,42,5
+sj,2002,43,5
+sj,2002,44,10
+sj,2002,45,6
+sj,2002,46,13
+sj,2002,47,6
+sj,2002,48,5
+sj,2002,49,5
+sj,2002,50,9
+sj,2002,51,3
+sj,2002,52,6
+sj,2003,1,11
+sj,2003,2,7
+sj,2003,3,7
+sj,2003,4,15
+sj,2003,5,9
+sj,2003,6,6
+sj,2003,7,6
+sj,2003,8,6
+sj,2003,9,7
+sj,2003,10,10
+sj,2003,11,8
+sj,2003,12,7
+sj,2003,13,12
+sj,2003,14,3
+sj,2003,15,2
+sj,2003,16,7
+sj,2003,17,5
+sj,2003,18,5
+sj,2003,19,7
+sj,2003,20,7
+sj,2003,21,7
+sj,2003,22,7
+sj,2003,23,10
+sj,2003,24,13
+sj,2003,25,10
+sj,2003,26,14
+sj,2003,27,11
+sj,2003,28,20
+sj,2003,29,25
+sj,2003,30,17
+sj,2003,31,18
+sj,2003,32,25
+sj,2003,33,21
+sj,2003,34,31
+sj,2003,35,32
+sj,2003,36,26
+sj,2003,37,35
+sj,2003,38,28
+sj,2003,39,37
+sj,2003,40,41
+sj,2003,41,34
+sj,2003,42,30
+sj,2003,43,39
+sj,2003,44,39
+sj,2003,45,39
+sj,2003,46,34
+sj,2003,47,30
+sj,2003,48,37
+sj,2003,49,29
+sj,2003,50,26
+sj,2003,51,15
+sj,2003,52,22
+sj,2004,1,15
+sj,2004,2,20
+sj,2004,3,14
+sj,2004,4,10
+sj,2004,5,21
+sj,2004,6,14
+sj,2004,7,14
+sj,2004,8,9
+sj,2004,9,11
+sj,2004,10,5
+sj,2004,11,6
+sj,2004,12,7
+sj,2004,13,11
+sj,2004,14,4
+sj,2004,15,3
+sj,2004,16,2
+sj,2004,17,6
+sj,2004,18,10
+sj,2004,19,7
+sj,2004,20,5
+sj,2004,21,3
+sj,2004,22,12
+sj,2004,23,13
+sj,2004,24,10
+sj,2004,25,13
+sj,2004,26,13
+sj,2004,27,8
+sj,2004,28,21
+sj,2004,29,18
+sj,2004,30,8
+sj,2004,31,7
+sj,2004,32,20
+sj,2004,33,14
+sj,2004,34,14
+sj,2004,35,7
+sj,2004,36,14
+sj,2004,37,10
+sj,2004,38,13
+sj,2004,39,27
+sj,2004,40,13
+sj,2004,41,18
+sj,2004,42,16
+sj,2004,43,16
+sj,2004,44,20
+sj,2004,45,17
+sj,2004,46,4
+sj,2004,47,15
+sj,2004,48,8
+sj,2004,49,6
+sj,2004,50,12
+sj,2004,51,15
+sj,2004,52,11
+sj,2005,53,10
+sj,2005,1,15
+sj,2005,2,17
+sj,2005,3,7
+sj,2005,4,7
+sj,2005,5,8
+sj,2005,6,9
+sj,2005,7,12
+sj,2005,8,12
+sj,2005,9,5
+sj,2005,10,4
+sj,2005,11,11
+sj,2005,12,4
+sj,2005,13,5
+sj,2005,14,7
+sj,2005,15,1
+sj,2005,16,1
+sj,2005,17,4
+sj,2005,18,2
+sj,2005,19,6
+sj,2005,20,3
+sj,2005,21,4
+sj,2005,22,10
+sj,2005,23,12
+sj,2005,24,21
+sj,2005,25,26
+sj,2005,26,21
+sj,2005,27,30
+sj,2005,28,45
+sj,2005,29,56
+sj,2005,30,75
+sj,2005,31,83
+sj,2005,32,82
+sj,2005,33,126
+sj,2005,34,119
+sj,2005,35,137
+sj,2005,36,131
+sj,2005,37,112
+sj,2005,38,82
+sj,2005,39,73
+sj,2005,40,43
+sj,2005,41,55
+sj,2005,42,55
+sj,2005,43,53
+sj,2005,44,46
+sj,2005,45,43
+sj,2005,46,29
+sj,2005,47,22
+sj,2005,48,26
+sj,2005,49,13
+sj,2005,50,17
+sj,2005,51,8
+sj,2006,52,13
+sj,2006,1,10
+sj,2006,2,17
+sj,2006,3,19
+sj,2006,4,9
+sj,2006,5,9
+sj,2006,6,9
+sj,2006,7,3
+sj,2006,8,7
+sj,2006,9,7
+sj,2006,10,0
+sj,2006,11,2
+sj,2006,12,3
+sj,2006,13,3
+sj,2006,14,1
+sj,2006,15,3
+sj,2006,16,3
+sj,2006,17,3
+sj,2006,18,7
+sj,2006,19,3
+sj,2006,20,5
+sj,2006,21,11
+sj,2006,22,5
+sj,2006,23,5
+sj,2006,24,6
+sj,2006,25,6
+sj,2006,26,4
+sj,2006,27,4
+sj,2006,28,8
+sj,2006,29,14
+sj,2006,30,12
+sj,2006,31,16
+sj,2006,32,10
+sj,2006,33,16
+sj,2006,34,18
+sj,2006,35,15
+sj,2006,36,23
+sj,2006,37,17
+sj,2006,38,33
+sj,2006,39,15
+sj,2006,40,13
+sj,2006,41,11
+sj,2006,42,14
+sj,2006,43,17
+sj,2006,44,19
+sj,2006,45,20
+sj,2006,46,12
+sj,2006,47,21
+sj,2006,48,7
+sj,2006,49,19
+sj,2006,50,10
+sj,2006,51,13
+sj,2007,1,10
+sj,2007,2,8
+sj,2007,3,21
+sj,2007,4,11
+sj,2007,5,9
+sj,2007,6,14
+sj,2007,7,14
+sj,2007,8,15
+sj,2007,9,18
+sj,2007,10,16
+sj,2007,11,12
+sj,2007,12,20
+sj,2007,13,8
+sj,2007,14,3
+sj,2007,15,13
+sj,2007,16,4
+sj,2007,17,1
+sj,2007,18,10
+sj,2007,19,8
+sj,2007,20,13
+sj,2007,21,10
+sj,2007,22,21
+sj,2007,23,18
+sj,2007,24,21
+sj,2007,25,34
+sj,2007,26,25
+sj,2007,27,34
+sj,2007,28,33
+sj,2007,29,40
+sj,2007,30,42
+sj,2007,31,36
+sj,2007,32,72
+sj,2007,33,75
+sj,2007,34,76
+sj,2007,35,92
+sj,2007,36,71
+sj,2007,37,112
+sj,2007,38,106
+sj,2007,39,101
+sj,2007,40,170
+sj,2007,41,135
+sj,2007,42,106
+sj,2007,43,68
+sj,2007,44,48
+sj,2007,45,48
+sj,2007,46,26
+sj,2007,47,33
+sj,2007,48,29
+sj,2007,49,17
+sj,2007,50,12
+sj,2007,51,13
+sj,2007,52,17
+sj,2008,1,15
+sj,2008,2,14
+sj,2008,3,15
+sj,2008,4,10
+sj,2008,5,9
+sj,2008,6,2
+sj,2008,7,6
+sj,2008,8,8
+sj,2008,9,5
+sj,2008,10,1
+sj,2008,11,2
+sj,2008,12,3
+sj,2008,13,4
+sj,2008,14,3
+sj,2008,15,1
+sj,2008,16,3
+sj,2008,17,5
+iq,2000,26,0
+iq,2000,27,0
+iq,2000,28,0
+iq,2000,29,0
+iq,2000,30,0
+iq,2000,31,0
+iq,2000,32,0
+iq,2000,33,0
+iq,2000,34,0
+iq,2000,35,0
+iq,2000,36,1
+iq,2000,37,0
+iq,2000,38,0
+iq,2000,39,0
+iq,2000,40,0
+iq,2000,41,1
+iq,2000,42,1
+iq,2000,43,0
+iq,2000,44,0
+iq,2000,45,0
+iq,2000,46,0
+iq,2000,47,0
+iq,2000,48,0
+iq,2000,49,0
+iq,2000,50,1
+iq,2000,51,0
+iq,2001,1,0
+iq,2001,2,0
+iq,2001,3,0
+iq,2001,4,0
+iq,2001,5,0
+iq,2001,6,0
+iq,2001,7,0
+iq,2001,8,0
+iq,2001,9,0
+iq,2001,10,0
+iq,2001,11,0
+iq,2001,12,0
+iq,2001,13,0
+iq,2001,14,0
+iq,2001,15,0
+iq,2001,16,1
+iq,2001,17,0
+iq,2001,18,0
+iq,2001,19,0
+iq,2001,20,0
+iq,2001,21,1
+iq,2001,22,1
+iq,2001,23,0
+iq,2001,24,0
+iq,2001,25,1
+iq,2001,26,0
+iq,2001,27,0
+iq,2001,28,0
+iq,2001,29,0
+iq,2001,30,0
+iq,2001,31,0
+iq,2001,32,0
+iq,2001,33,0
+iq,2001,34,0
+iq,2001,35,0
+iq,2001,36,0
+iq,2001,37,0
+iq,2001,38,0
+iq,2001,39,0
+iq,2001,40,0
+iq,2001,41,0
+iq,2001,42,0
+iq,2001,43,0
+iq,2001,44,0
+iq,2001,45,0
+iq,2001,46,0
+iq,2001,47,1
+iq,2001,48,1
+iq,2001,49,1
+iq,2001,50,2
+iq,2001,51,4
+iq,2001,52,1
+iq,2002,1,4
+iq,2002,2,11
+iq,2002,3,16
+iq,2002,4,23
+iq,2002,5,12
+iq,2002,6,14
+iq,2002,7,18
+iq,2002,8,8
+iq,2002,9,7
+iq,2002,10,10
+iq,2002,11,7
+iq,2002,12,10
+iq,2002,13,5
+iq,2002,14,11
+iq,2002,15,8
+iq,2002,16,18
+iq,2002,17,13
+iq,2002,18,9
+iq,2002,19,22
+iq,2002,20,10
+iq,2002,21,5
+iq,2002,22,13
+iq,2002,23,2
+iq,2002,24,11
+iq,2002,25,11
+iq,2002,26,3
+iq,2002,27,7
+iq,2002,28,7
+iq,2002,29,4
+iq,2002,30,5
+iq,2002,31,6
+iq,2002,32,7
+iq,2002,33,7
+iq,2002,34,4
+iq,2002,35,9
+iq,2002,36,17
+iq,2002,37,8
+iq,2002,38,22
+iq,2002,39,18
+iq,2002,40,21
+iq,2002,41,16
+iq,2002,42,31
+iq,2002,43,25
+iq,2002,44,28
+iq,2002,45,26
+iq,2002,46,18
+iq,2002,47,27
+iq,2002,48,11
+iq,2002,49,38
+iq,2002,50,29
+iq,2002,51,21
+iq,2002,52,11
+iq,2003,1,10
+iq,2003,2,5
+iq,2003,3,6
+iq,2003,4,2
+iq,2003,5,1
+iq,2003,6,2
+iq,2003,7,2
+iq,2003,8,3
+iq,2003,9,5
+iq,2003,10,1
+iq,2003,11,4
+iq,2003,12,2
+iq,2003,13,4
+iq,2003,14,0
+iq,2003,15,0
+iq,2003,16,0
+iq,2003,17,0
+iq,2003,18,1
+iq,2003,19,1
+iq,2003,20,1
+iq,2003,21,1
+iq,2003,22,1
+iq,2003,23,2
+iq,2003,24,3
+iq,2003,25,4
+iq,2003,26,6
+iq,2003,27,2
+iq,2003,28,2
+iq,2003,29,5
+iq,2003,30,1
+iq,2003,31,1
+iq,2003,32,0
+iq,2003,33,0
+iq,2003,34,0
+iq,2003,35,0
+iq,2003,36,2
+iq,2003,37,0
+iq,2003,38,3
+iq,2003,39,0
+iq,2003,40,0
+iq,2003,41,0
+iq,2003,42,2
+iq,2003,43,2
+iq,2003,44,3
+iq,2003,45,3
+iq,2003,46,3
+iq,2003,47,1
+iq,2003,48,2
+iq,2003,49,3
+iq,2003,50,6
+iq,2003,51,5
+iq,2003,52,1
+iq,2004,1,4
+iq,2004,2,5
+iq,2004,3,8
+iq,2004,4,5
+iq,2004,5,2
+iq,2004,6,3
+iq,2004,7,3
+iq,2004,8,1
+iq,2004,9,6
+iq,2004,10,4
+iq,2004,11,1
+iq,2004,12,2
+iq,2004,13,3
+iq,2004,14,1
+iq,2004,15,8
+iq,2004,16,4
+iq,2004,17,6
+iq,2004,18,7
+iq,2004,19,5
+iq,2004,20,8
+iq,2004,21,6
+iq,2004,22,5
+iq,2004,23,6
+iq,2004,24,6
+iq,2004,25,13
+iq,2004,26,2
+iq,2004,27,10
+iq,2004,28,3
+iq,2004,29,12
+iq,2004,30,7
+iq,2004,31,6
+iq,2004,32,5
+iq,2004,33,6
+iq,2004,34,6
+iq,2004,35,6
+iq,2004,36,8
+iq,2004,37,6
+iq,2004,38,9
+iq,2004,39,12
+iq,2004,40,19
+iq,2004,41,8
+iq,2004,42,16
+iq,2004,43,21
+iq,2004,44,6
+iq,2004,45,22
+iq,2004,46,37
+iq,2004,47,33
+iq,2004,48,18
+iq,2004,49,83
+iq,2004,50,116
+iq,2004,51,32
+iq,2004,52,7
+iq,2005,53,9
+iq,2005,1,10
+iq,2005,2,5
+iq,2005,3,8
+iq,2005,4,7
+iq,2005,5,8
+iq,2005,6,11
+iq,2005,7,6
+iq,2005,8,7
+iq,2005,9,7
+iq,2005,10,14
+iq,2005,11,7
+iq,2005,12,9
+iq,2005,13,13
+iq,2005,14,16
+iq,2005,15,7
+iq,2005,16,9
+iq,2005,17,2
+iq,2005,18,13
+iq,2005,19,8
+iq,2005,20,3
+iq,2005,21,5
+iq,2005,22,4
+iq,2005,23,8
+iq,2005,24,2
+iq,2005,25,3
+iq,2005,26,5
+iq,2005,27,7
+iq,2005,28,3
+iq,2005,29,5
+iq,2005,30,6
+iq,2005,31,5
+iq,2005,32,5
+iq,2005,33,4
+iq,2005,34,0
+iq,2005,35,0
+iq,2005,36,0
+iq,2005,37,0
+iq,2005,38,0
+iq,2005,39,2
+iq,2005,40,4
+iq,2005,41,4
+iq,2005,42,3
+iq,2005,43,3
+iq,2005,44,5
+iq,2005,45,6
+iq,2005,46,14
+iq,2005,47,3
+iq,2005,48,7
+iq,2005,49,11
+iq,2005,50,2
+iq,2005,51,6
+iq,2006,52,8
+iq,2006,1,25
+iq,2006,2,21
+iq,2006,3,10
+iq,2006,4,28
+iq,2006,5,39
+iq,2006,6,20
+iq,2006,7,24
+iq,2006,8,28
+iq,2006,9,26
+iq,2006,10,8
+iq,2006,11,9
+iq,2006,12,12
+iq,2006,13,18
+iq,2006,14,9
+iq,2006,15,9
+iq,2006,16,6
+iq,2006,17,6
+iq,2006,18,8
+iq,2006,19,5
+iq,2006,20,7
+iq,2006,21,6
+iq,2006,22,5
+iq,2006,23,3
+iq,2006,24,1
+iq,2006,25,0
+iq,2006,26,1
+iq,2006,27,2
+iq,2006,28,3
+iq,2006,29,2
+iq,2006,30,2
+iq,2006,31,2
+iq,2006,32,2
+iq,2006,33,2
+iq,2006,34,4
+iq,2006,35,0
+iq,2006,36,6
+iq,2006,37,3
+iq,2006,38,2
+iq,2006,39,6
+iq,2006,40,2
+iq,2006,41,7
+iq,2006,42,4
+iq,2006,43,6
+iq,2006,44,6
+iq,2006,45,2
+iq,2006,46,13
+iq,2006,47,10
+iq,2006,48,5
+iq,2006,49,2
+iq,2006,50,0
+iq,2006,51,1
+iq,2007,1,0
+iq,2007,2,14
+iq,2007,3,6
+iq,2007,4,10
+iq,2007,5,5
+iq,2007,6,12
+iq,2007,7,9
+iq,2007,8,5
+iq,2007,9,11
+iq,2007,10,2
+iq,2007,11,6
+iq,2007,12,7
+iq,2007,13,6
+iq,2007,14,5
+iq,2007,15,9
+iq,2007,16,5
+iq,2007,17,8
+iq,2007,18,3
+iq,2007,19,4
+iq,2007,20,11
+iq,2007,21,5
+iq,2007,22,8
+iq,2007,23,4
+iq,2007,24,3
+iq,2007,25,1
+iq,2007,26,2
+iq,2007,27,3
+iq,2007,28,4
+iq,2007,29,1
+iq,2007,30,8
+iq,2007,31,5
+iq,2007,32,3
+iq,2007,33,2
+iq,2007,34,7
+iq,2007,35,1
+iq,2007,36,6
+iq,2007,37,7
+iq,2007,38,5
+iq,2007,39,2
+iq,2007,40,6
+iq,2007,41,11
+iq,2007,42,6
+iq,2007,43,3
+iq,2007,44,11
+iq,2007,45,11
+iq,2007,46,5
+iq,2007,47,4
+iq,2007,48,9
+iq,2007,49,23
+iq,2007,50,28
+iq,2007,51,26
+iq,2007,52,7
+iq,2008,1,29
+iq,2008,2,58
+iq,2008,3,26
+iq,2008,4,38
+iq,2008,5,35
+iq,2008,6,37
+iq,2008,7,20
+iq,2008,8,29
+iq,2008,9,25
+iq,2008,10,23
+iq,2008,11,9
+iq,2008,12,3
+iq,2008,13,6
+iq,2008,14,6
+iq,2008,15,3
+iq,2008,16,1
+iq,2008,17,3
+iq,2008,18,1
+iq,2008,19,1
+iq,2008,20,0
+iq,2008,21,2
+iq,2008,22,1
+iq,2008,23,1
+iq,2008,24,0
+iq,2008,25,0
+iq,2008,26,1
+iq,2008,27,0
+iq,2008,28,3
+iq,2008,29,3
+iq,2008,30,1
+iq,2008,31,5
+iq,2008,32,2
+iq,2008,33,5
+iq,2008,34,5
+iq,2008,35,5
+iq,2008,36,9
+iq,2008,37,17
+iq,2008,38,19
+iq,2008,39,25
+iq,2008,40,45
+iq,2008,41,34
+iq,2008,42,63
+iq,2008,43,44
+iq,2008,44,50
+iq,2008,45,35
+iq,2008,46,16
+iq,2008,47,16
+iq,2008,48,13
+iq,2008,49,9
+iq,2008,50,15
+iq,2008,51,4
+iq,2008,52,0
+iq,2009,1,1
+iq,2009,2,10
+iq,2009,3,11
+iq,2009,4,29
+iq,2009,5,35
+iq,2009,6,30
+iq,2009,7,20
+iq,2009,8,21
+iq,2009,9,12
+iq,2009,10,9
+iq,2009,11,11
+iq,2009,12,9
+iq,2009,13,5
+iq,2009,14,11
+iq,2009,15,3
+iq,2009,16,5
+iq,2009,17,5
+iq,2009,18,4
+iq,2009,19,4
+iq,2009,20,1
+iq,2009,21,0
+iq,2009,22,2
+iq,2009,23,3
+iq,2009,24,3
+iq,2009,25,5
+iq,2009,26,2
+iq,2009,27,1
+iq,2009,28,2
+iq,2009,29,0
+iq,2009,30,0
+iq,2009,31,3
+iq,2009,32,5
+iq,2009,33,5
+iq,2009,34,7
+iq,2009,35,5
+iq,2009,36,2
+iq,2009,37,2
+iq,2009,38,2
+iq,2009,39,0
+iq,2009,40,2
+iq,2009,41,1
+iq,2009,42,1
+iq,2009,43,2
+iq,2009,44,2
+iq,2009,45,3
+iq,2009,46,9
+iq,2009,47,5
+iq,2009,48,5
+iq,2009,49,4
+iq,2009,50,4
+iq,2009,51,1
+iq,2009,52,0
+iq,2010,53,0
+iq,2010,1,10
+iq,2010,2,9
+iq,2010,3,17
+iq,2010,4,16
+iq,2010,5,11
+iq,2010,6,12
+iq,2010,7,19
+iq,2010,8,15
+iq,2010,9,12
+iq,2010,10,12
+iq,2010,11,16
+iq,2010,12,9
+iq,2010,13,4
+iq,2010,14,9
+iq,2010,15,6
+iq,2010,16,8
+iq,2010,17,4
+iq,2010,18,2
+iq,2010,19,7
+iq,2010,20,6
+iq,2010,21,5
+iq,2010,22,8
+iq,2010,23,1
+iq,2010,24,1
+iq,2010,25,4

From 3a1d1439ee342abe2f661a268203d25dfdb2d53c Mon Sep 17 00:00:00 2001
From: Dominik Jain <dominik.jain@outlook.com>
Date: Thu, 10 Oct 2024 00:44:13 +0200
Subject: [PATCH 3/6] Add early stopping to LSTNet-based model

---
 .../dengue-fever-time-series/dengai/models/model_factory.py     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/dengue-fever-time-series/dengai/models/model_factory.py b/examples/dengue-fever-time-series/dengai/models/model_factory.py
index 2bd8a759d..c04e63e16 100644
--- a/examples/dengue-fever-time-series/dengai/models/model_factory.py
+++ b/examples/dengue-fever-time-series/dengai/models/model_factory.py
@@ -62,7 +62,7 @@ def create_lstnet_encoder_decoder(cls, week_window_size: int):
         encoder_factory = LSTNetworkEncoderFactory(week_window_size-1, 100, 4, 32, 0, 0)
         decoder_factory = SingleTargetDecoderFactory(LinearPredictorFactory())
         # decoder_factory = SingleTargetDecoderFactory(MLPPredictorFactory(output_activation_fn=ActivationFunction.RELU))
-        nn_optimiser_params = NNOptimiserParams(batch_size=64, shuffle=True)
+        nn_optimiser_params = NNOptimiserParams(batch_size=64, shuffle=True, early_stopping_epochs=50)
         latent_dim = encoder_factory.get_latent_dim()
         return EncoderDecoderVectorRegressionModel(False,
                     COL_FGEN_HISTORY_WINDOW, history_sequence_vectoriser, False,

From 7f3ec131bc1400734305196d3ce1f29f09725516 Mon Sep 17 00:00:00 2001
From: Dominik Jain <dominik.jain@outlook.com>
Date: Thu, 10 Oct 2024 00:44:30 +0200
Subject: [PATCH 4/6] Add README file for DengAI example

---
 examples/dengue-fever-time-series/README.md | 38 +++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 examples/dengue-fever-time-series/README.md

diff --git a/examples/dengue-fever-time-series/README.md b/examples/dengue-fever-time-series/README.md
new file mode 100644
index 000000000..c11a178e2
--- /dev/null
+++ b/examples/dengue-fever-time-series/README.md
@@ -0,0 +1,38 @@
+# Dengue Fever Time Series Prediction with sensAI
+
+This example demonstrates how to use the sensAI library to predict the number of dengue fever cases in San Juan, 
+Puerto Rico and Iquitos, Peru on a weekly basis.
+The data is a slightly adapted version of the [DengAI dataset](https://www.kaggle.com/datasets/qianyigang129/dengai-dataset/data) from Kaggle, which is licensed under CC0 (public domain).
+
+This example demonstrates
+  * time series prediction with sensAI
+  * the use of vastly different models with entirely different input pipelines,
+    comparing complex dynamic models (that make use the preceding time series)
+    with simpler regression models
+  * how to use MLflow to record and compare the results of different models
+  * hyperparameter optimization with sensAI in conjunction with hyperopt
+  * recursive feature elimination
+
+## Setup
+
+Set up your Python virtual environment using [conda](https://docs.anaconda.com/miniconda/miniconda-install/):
+
+    conda env create -f environment.yml
+
+This will create a new environment called `dengai`.
+
+    conda activate dengai
+
+## Entry Points
+
+Initial data analysis with some insights on the dataset can be found in the Jupyter notebook `nb_data_analysis.ipynb`.
+
+Main scripts:
+ * `run_model_evaluation.py` to train and evaluate the models
+     * Before running it,
+        * edit the script and uncomment all the models you want to evaluate.
+        * configure the main script at the bottom to configure the concrete task to run.
+     * Run the script
+     * Inspect results in the `results/` folder or via the MLflow UI (run `mlflow ui`)
+ * `run_hyperopt.py` to perform hyperparameter optimization on an XGBoost model
+ * `run_rfe.py` to perform recursive feature elimination on an XGBoost model

From a9d00d9e6d835798bd2e1a768afac86af7c582bb Mon Sep 17 00:00:00 2001
From: Dominik Jain <dominik.jain@outlook.com>
Date: Thu, 10 Oct 2024 01:58:47 +0200
Subject: [PATCH 5/6] Add environment.yml for DengAI example

---
 .../dengue-fever-time-series/environment.yml  | 23 ++++++++++---------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/examples/dengue-fever-time-series/environment.yml b/examples/dengue-fever-time-series/environment.yml
index 2439cf821..8fc61f043 100644
--- a/examples/dengue-fever-time-series/environment.yml
+++ b/examples/dengue-fever-time-series/environment.yml
@@ -4,16 +4,17 @@ channels:
   - nvidia
   - conda-forge
 dependencies:
-  - python=3.10
+  - python=3.10.15
   - pip
-  - pytorch
-  - scikit-learn
-  - scipy
-  - pandas
-  - matplotlib
-  - seaborn
-  - xgboost
-  - mlflow
-  - hyperopt
+  - pytorch=2.4.1
+  - scikit-learn=1.5.2
+  - scipy=1.14.1
+  - pandas=2.2.3
+  - matplotlib=3.9.2
+  - seaborn=0.13.2
+  - xgboost=2.1.1
+  - mlflow=2.16.2
+  - hyperopt=0.2.7
   - pip:
-      - jupyter
+      - jupyter==1.1.1
+      - sensai==1.2.1

From af18fd6a3515e0065baf5f63a7ecb1cc07be8e12 Mon Sep 17 00:00:00 2001
From: Dominik Jain <dominik.jain@outlook.com>
Date: Thu, 10 Oct 2024 01:58:58 +0200
Subject: [PATCH 6/6] Enable more models

---
 .../dengue-fever-time-series/run_model_evaluation.py   | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/dengue-fever-time-series/run_model_evaluation.py b/examples/dengue-fever-time-series/run_model_evaluation.py
index 91f2271fd..bf3af9477 100644
--- a/examples/dengue-fever-time-series/run_model_evaluation.py
+++ b/examples/dengue-fever-time-series/run_model_evaluation.py
@@ -27,19 +27,19 @@ def eval_models(city_only: Optional[str] = None, use_cross_validation=False):
 
     # define models to evaluate
     model_factories = []
-    #model_factories.append(lambda: ModelFactory.create_baseline())
-    #model_factories.append(lambda: ModelFactory.create_glm_benchmark())
+    model_factories.append(lambda: ModelFactory.create_baseline())
+    model_factories.append(lambda: ModelFactory.create_glm_benchmark())
     #model_factories.append(lambda: ModelFactory.create_rnn_mlp(week_window_size, batch_size=64))
     #model_factories.append(lambda: ModelFactory.create_rnn_mlp_autoreg(week_window_size))
     #model_factories.append(lambda: ModelFactory.create_rnn_mlp(week_window_size, feature_columns=ModelFactory.COLS_FEATURES_SEL))
     model_factories.append(lambda: ModelFactory.create_lstnet_encoder_decoder(week_window_size))
     #model_factories.append(lambda: ModelFactory.create_mlp(week_window_size))
-    #model_factories.append(lambda: ModelFactory.create_xgb())
+    model_factories.append(lambda: ModelFactory.create_xgb())
     #model_factories.append(lambda: ModelFactory.create_xgb_fsel())
     #model_factories.append(lambda: ModelFactory.create_xgb_window(week_window_size, min_child_weight=1))
     #model_factories.append(lambda: ModelFactory.create_xgb_window(week_window_size, min_child_weight=1, feature_columns=ModelFactory.COLS_FEATURES_SEL))
-    #model_factories.append(lambda: ModelFactory.create_xgb_window_opt(week_window_size))
-    #model_factories.append(lambda: ModelFactory.create_mean_past_year_week())
+    model_factories.append(lambda: ModelFactory.create_xgb_window_opt(week_window_size))
+    model_factories.append(lambda: ModelFactory.create_mean_past_year_week())
 
     # evaluate models
     ev = pred.create_multi_data_evaluator()