diff --git a/.gitignore b/.gitignore
index 9f76b71..d379779 100644
--- a/.gitignore
+++ b/.gitignore
@@ -161,5 +161,5 @@ cython_debug/
 
 # Precommit hooks: ruff cache
 .ruff_cache
-
+.DS_Store
 data/
\ No newline at end of file
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 80d7fab..510b0cc 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,7 +1,7 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
     # Ruff version.
-    rev: "v0.0.254"
+    rev: "v0.3.7"
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
diff --git a/app/README.md b/app/README.md
new file mode 100644
index 0000000..ae102df
--- /dev/null
+++ b/app/README.md
@@ -0,0 +1,5 @@
+Pour exécuter l'application Streamlit de , lancer la commande suivante depuis ce répertoire : 
+    `streamlit run odi_streamlit.py`
+
+Note: 
+L'application streamlit `analyse_app_OLD.py` sera à supprimer. 
diff --git a/app/analyse_app_OLD.py b/app/analyse_app_OLD.py
new file mode 100644
index 0000000..dce7f36
--- /dev/null
+++ b/app/analyse_app_OLD.py
@@ -0,0 +1,63 @@
+"""
+# My first app with Streamlit https://streamlit.io/
+Here's our first attempt at using data to create a table:
+"""
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import streamlit as st
+
+st.title("Observatoire des Imaginaires")
+st.divider()
+st.header("Fait par la dream team _Analyse de données_")
+st.write(
+    (
+        "Cette application analyse les données du PoC. On peut se faire plaisir"
+        " en y ajoutant tous les graphiques nécessaires. "
+        "Le code est à nettoyer pour une meilleure maintenance ;-) "
+    ),
+)
+
+
+st.container()
+st.header("Aperçu des données")
+# Load the data
+file_path = "../data/Analyse réponses.xlsx - Treated data.csv"
+
+# ne pas lire la première ligne
+data = pd.read_csv(file_path, skiprows=1)
+
+# Supprimer les lignes où la première colonne contient "Contenu XXX"
+# XXX est un nombre
+# Et Supprimer les lignes où toutes les valeurs sont NaN
+df = data[~data["TITRE"].str.contains(r"Contenu \d+", na=False)].dropna(how="all")
+
+# ne conserver qu'une ligne sur 4  (ce qui revient à supprimer les informations
+# des personnages 2, 3, 4 quand ils existent)
+df_truncated = df.iloc[::4]
+# Nettoyage du data set
+
+# mettre les titres en majuscule
+df_truncated["TITRE"] = df_truncated["TITRE"].str.upper()
+
+### Convertir les types de données correctement ici
+# Convertir les années en entier
+annee = "ANNEE"
+df_truncated[annee] = pd.to_numeric(df_truncated[annee], errors="coerce").fillna(0).astype(int)
+# Trouver les titres qui apparaissent plus de 4 fois dans la colonne "TITRE"
+# (car chaque titre a 4 lignes, une pour chaque personnage)
+titles_more_than_once = df_truncated["TITRE"].value_counts()
+titles_more_than_once = titles_more_than_once[titles_more_than_once > 1]
+
+# Afficher un bar chart des titres les plus fréquents
+# Affichage d'un bar chart horizontal
+
+
+st.header("Films les plus fréquents")
+# Création du graphique
+fig, ax = plt.subplots()
+t = titles_more_than_once.sort_values(ascending=True)
+t.plot(kind="barh", color="skyblue", ax=ax)
+ax.set_xlabel("Nb")
+ax.set_title("Fréquence des films/séries")
+st.pyplot(fig)
diff --git a/app/odi_streamlit.py b/app/odi_streamlit.py
new file mode 100644
index 0000000..6efc676
--- /dev/null
+++ b/app/odi_streamlit.py
@@ -0,0 +1,354 @@
+"""
+# My first app with Streamlit https://streamlit.io/
+Here's our first attempt at using data to create a table:
+"""
+
+
+# Export fichier
+
+# Datavisualisation
+
+import pandas as pd
+import plotly.express as px
+
+# O.Importation des librairies nécessaires pour le script
+# Core Pkgs - Web application
+import streamlit as st
+
+# Other Pkgs
+
+# 3.Setup de l'application Streamlit  - Streamlit webpage properties / set up the app
+# with wide view preset and a title
+st.set_page_config(
+    page_title="Observatoire des Imaginaires",
+    page_icon="herb",
+    layout="wide",
+)
+
+
+@st.cache_data  # 👈 Add the caching decorator
+def load_data(file: str) -> pd.DataFrame:
+    df = pd.read_csv(file, skiprows=1)
+    return df
+
+
+# Load the data
+file_path = "../data/AnalyseReponsesTreatedData.csv"  #'../data/Analyse réponses.xlsx - Treated data.csv'  # noqa: E501
+# ne pas lire la première ligne
+data = load_data(file_path)
+
+
+# if 'df' not in st.session_state:
+# if 'dico' not in st.session_state:
+# if 'liste_ean' not in st.session_state:
+# if 'select_editeur' not in st.session_state:
+# if 'liste_ouvrage' not in st.session_state:
+#
+## 1. Classe lancée si choix de "rentrée littéraire" dans le menu en sidebar
+# class InfoRentreeLitt():
+# 	def get_data(df,dico):
+
+
+### A. Sidebar
+with st.sidebar:
+    st.image(
+        "https://media.licdn.com/dms/image/D4E0BAQEZHVBxFn3OXQ/company-logo_200_200/0/1697116934909/cercle_thmatique_culture_the_shifters_logo?e=1718841600&v=beta&t=_2DWaEBrblIgXhgVASUipHTcJesOL6s1Sk2uH73Kx58",
+        use_column_width=True,
+    )  # width=50
+
+    st.title("Fait par la dream team _Analyse de données_")
+    st.write(
+        (
+            "Cette application analyse les données du PoC. On peut se faire plaisir"
+            " en y ajoutant tous les graphiques nécessaires. "
+            "Le code est à nettoyer pour une meilleure maintenance ;-) "
+        ),
+    )
+
+
+### B. Container du header
+header = st.container()
+header.title("Observatoire des Imaginaires")
+header.write("""<div class='fixed-header'/>""", unsafe_allow_html=True)
+
+### Custom CSS for the sticky header #74d1b4
+# st.markdown(
+#    """
+# <style>
+#    div[data-testid="stVerticalBlock"] div:has(div.fixed-header) {
+#        top: 2.875rem;
+#    .fixed-header {
+#        border-bottom: 1px solid white;
+# </style>
+#    """,
+
+### C. Container des métriques
+cont_metric = st.container(border=True)  # border = True
+
+
+# Supprimer les lignes où la première colonne contient "Contenu XXX"
+# XXX est un nombre
+# Et Supprimer les lignes où toutes les valeurs sont NaN
+df = data[~data["TITRE"].str.contains(r"Contenu \d+", na=False)].dropna(how="all")
+
+# ne conserver qu'une ligne sur 4  (ce qui revient à supprimer
+# les informations des personnages 2, 3, 4 quand ils existent)
+df_truncated = df.iloc[::4]
+
+# Nettoyage du data set
+
+# mettre les titres en majuscule
+df_truncated["TITRE"] = df_truncated["TITRE"].str.upper()
+# mettre les pays en majuscule et supprimer les espaces au début et à la fin
+df_truncated["PAYS"] = df_truncated["PAYS"].str.strip().str.upper()
+df_truncated["PAYS"] = df_truncated["PAYS"].apply(lambda p: p.replace(" ET ", ";"))
+df_truncated.insert(
+    3,
+    "pays_rework",
+    [
+        pays if len(pays.split(";")) == 1 else "INTERNATIONAL"
+        for pays in df_truncated["PAYS"]
+    ],
+)
+
+### Convertir les types de données correctement ici
+# Convertir les années en entier
+annee = "ANNEE"
+df_truncated[annee] = (
+    pd.to_numeric(df_truncated[annee], errors="coerce").fillna(0).astype(int)
+)
+
+with cont_metric:
+    with st.expander("Aperçu des donnéess"):
+        st.dataframe(df_truncated)
+
+    ### A. Affichage des métriques macro
+    col_nb_livre, col_nb_editeur, col_nb_prem_roman = st.columns([2, 2, 2])
+    with col_nb_livre:
+        # Metric nb Ouvrages
+        st.metric(label="Oeuvres analysées", value=len(set(df_truncated["TITRE"])))
+    with col_nb_editeur:
+        # Metric nb Editeurs
+        st.metric(
+            label="Films",
+            value=len(set(df_truncated[df_truncated.TYPE == "FILM"]["TITRE"])),
+        )
+    with col_nb_prem_roman:
+        # Metric Premier Roman
+        st.metric(
+            label="Séries",
+            value=len(set(df_truncated[df_truncated.TYPE == "SÉRIE"]["TITRE"])),
+        )
+
+    st.write()
+    st.write(
+        f":blue[{round(100*len(set(df_truncated[df_truncated.TYPE == 'FILM']['TITRE']))/len(set(df_truncated['TITRE'])),2)}%] des contenus renseignés sont des films vs :blue[{round(100*len(set(df_truncated[df_truncated.TYPE == 'SÉRIE']['TITRE']))/len(set(df_truncated['TITRE'])),2)}%] des séries.",  # noqa: E501
+    )
+
+# Trouver les titres qui apparaissent plus de 4 fois dans la colonne "TITRE"
+# (car chaque titre a 4 lignes, une pour chaque personnage)
+
+
+titles_more_than_once = (
+    df_truncated.groupby(["TITRE", "TYPE"]).agg(compte=("TITRE", "count")).reset_index()
+)
+titles_more_than_once = titles_more_than_once[titles_more_than_once["compte"] > 1]
+
+
+# Afficher un bar chart des titres les plus fréquents
+# Affichage d'un bar chart horizontal
+
+with st.container(border=True):
+    st.header("Films les plus fréquents")
+    col_freq_film_select, col_freq_film_vide, col_freq_film_graph = st.columns(
+        [2, 0.5, 5],
+    )
+    with col_freq_film_select:
+        type_choice = st.selectbox(
+            "Choisir un type",
+            titles_more_than_once["TYPE"].unique(),
+            index=None,
+        )
+    with col_freq_film_graph:
+        if type_choice == "FILM":
+            t = titles_more_than_once.loc[
+                titles_more_than_once["TYPE"] == "FILM"
+            ].sort_values(
+                by="compte",
+                ascending=True,
+            )
+        elif type_choice == "SÉRIE":
+            t = titles_more_than_once.loc[
+                titles_more_than_once["TYPE"] == "SÉRIE"
+            ].sort_values(
+                by="compte",
+                ascending=True,
+            )
+        else:
+            t = titles_more_than_once.sort_values(by="compte", ascending=True)
+
+        st.bar_chart(t, x="TITRE", y="compte")
+
+# Types de contenus et pays d'origine
+with st.container(border=True):
+    st.header("Types de contenus")
+    col_contenu_date, col_contenu_vide, col_contenu_graph = st.columns([4, 0.5, 4])
+
+    with col_contenu_date:
+        date_group_df = (
+            df_truncated.groupby("ANNEE")
+            .count()
+            .reset_index()[["ANNEE", "TITRE"]]
+            .rename(columns={"TITRE": "nb_titre"})
+        )
+        date_group_df["periode_percent"] = 100 * (
+            1 - (date_group_df.nb_titre.cumsum() / date_group_df.nb_titre.sum())
+        )
+
+        date_min = str(df_truncated.ANNEE.min())
+        date_max = str(df_truncated.ANNEE.max())
+        date_pareto = (
+            date_group_df[date_group_df["periode_percent"] <= 80]["ANNEE"].min()  # noqa: PLR2004
+        )
+        date_value_pareto = int(
+            round(
+                date_group_df[date_group_df["periode_percent"] <= 80][  # noqa: PLR2004
+                    "periode_percent"
+                ].max(),
+                0,
+            ),
+        )
+
+        st.markdown(
+            (
+                f"Les contenus datent d`une période qui s`étend de {date_min}"
+                f" à {date_max}. {date_value_pareto}% des contenus sont postérieurs à"
+                f" {date_pareto}."
+            ),
+        )
+
+        st.bar_chart(date_group_df, x="ANNEE", y="nb_titre")
+
+    with col_contenu_graph:
+        country_group_df = df_truncated
+        country_group_df = (
+            country_group_df.groupby("pays_rework")
+            .count()
+            .reset_index()[["pays_rework", "TITRE"]]
+            .rename(columns={"TITRE": "nb_titre"})
+            .sort_values("nb_titre")
+        )
+        country_group_df["country_percent_cumul"] = round(
+            100
+            * (
+                1
+                - (country_group_df.nb_titre.cumsum() / country_group_df.nb_titre.sum())
+            ),
+            0,
+        )
+        country_group_df["country_percent"] = round(
+            100 * (country_group_df.nb_titre / country_group_df.nb_titre.sum()),
+            2,
+        )
+
+        country_value_pareto = int(
+            round(
+                country_group_df[country_group_df["country_percent"] >= 10][  # noqa: PLR2004
+                    "country_percent"
+                ].sum(),
+                2,
+            ),
+        )
+        country_group_df_pareto = country_group_df[
+            country_group_df["country_percent"] >= 10  # noqa: PLR2004
+        ][["pays_rework", "country_percent"]].sort_values(
+            "country_percent",
+            ascending=False,
+        )
+
+        st.write(
+            f"A **:blue[{country_value_pareto}%]**, les 2 principaux pays dont les contenus sont les plus visionnés sont : {country_group_df.nlargest(2,'country_percent').reset_index(drop=True)['pays_rework'][0].capitalize()} ({country_group_df.nlargest(2,'country_percent').reset_index(drop=True)['country_percent'][0]}%) et {country_group_df.nlargest(2,'country_percent').reset_index(drop=True)['pays_rework'][1].capitalize()} ({country_group_df.nlargest(2,'country_percent').reset_index(drop=True)['country_percent'][1]}%).",  # noqa: E501
+        )
+
+        fig_type = px.bar(
+            country_group_df,
+            y="pays_rework",
+            x="nb_titre",
+            orientation="h",
+            text_auto=True,
+        )
+        st.plotly_chart(fig_type, use_container_width=True)
+
+# LIEUX VISIONNAGE
+with st.container(border=True):
+    canal_group_df = (
+        df_truncated.groupby("CANAL")
+        .count()[["TITRE"]]
+        .rename(columns={"TITRE": "nb_titre"})
+        .sort_values("nb_titre", ascending=False)
+    )
+    canal_group_df["canal_percent"] = 100 * (
+        canal_group_df.nb_titre / canal_group_df.nb_titre.sum()
+    )
+    canal_country_group_df = (
+        df_truncated.groupby(["CANAL", "pays_rework"])
+        .count()[["TITRE"]]
+        .rename(columns={"TITRE": "nb_titre"})
+        .sort_values("nb_titre", ascending=False)
+        .reset_index()
+    )
+
+    col_text_canal, col_table_canal = st.columns([5, 3])
+    with col_text_canal:
+        canal_visionne1 = canal_group_df.nb_titre.nlargest(2).reset_index()["CANAL"][0]
+        percent_canal_visionne1 = round(canal_group_df.canal_percent.nlargest(2)[0], 2)
+        canal_visionne2 = canal_group_df.nb_titre.nlargest(2).reset_index()["CANAL"][1]
+        percent_canal_visionne2 = round(canal_group_df.canal_percent.nlargest(2)[1], 2)
+
+        st.markdown(
+            f"Les contenus sont visionnés principalement sur :blue[{canal_visionne1.capitalize()}] (:blue[{percent_canal_visionne1}%]) et :blue[{canal_visionne2.capitalize()}] (:blue[{percent_canal_visionne2}%]).\n\n La majorité des contenus visionnés sur :blue[{canal_visionne1.capitalize()}] ont pour pays d'origine :blue[{canal_country_group_df[canal_country_group_df['CANAL']==canal_visionne1].nlargest(1,'nb_titre').reset_index()['pays_rework'][0]}] (:blue[%]), alors que la majorité des contenus français sont visionnés xxx (xxx%).\n\n :blue[{round(canal_group_df.loc['Autre','canal_percent'],2)}%] des contenus sont visionnés sur un canal `Autre` que la liste proposée (cf ci-contre)",  # noqa: E501
+        )
+
+        # Les contenus sont visionnés principalement sur Netflix (29.91%) ou dans
+        # une salle de cinéma (28.97%). La majorité des contenus américains sont
+        # visionnés sur Netflix (40.48% des contenus US), alors que la majorité
+        # des contenus français sont visionnés au cinéma (44.19%).
+    # 23.36% des contenus sont visionnés sur un canal `autre`
+    # que la liste proposée (cf ci-dessous)
+
+    with col_table_canal:
+        st.markdown(set(canal_group_df.reset_index().CANAL))
+
+st.subheader("EPOQUE DE RECITS")
+st.write(set(df_truncated["EPOQUE DU RECIT"]))
+
+st.subheader("TYPE DE MONDE")
+st.write(set(df_truncated["TYPE DE MONDE"]))
+st.dataframe(
+    df_truncated[["TITRE", "TRAITEMENT DU RECIT", "TYPE DE MONDE"]]
+    .groupby(["TRAITEMENT DU RECIT", "TYPE DE MONDE"])
+    .count(),
+)
+
+#
+# 				with st.container():
+
+#
+# fig.add_trace(go.Pie(labels=gender_viz_crew.gender_text, values=gender_viz_crew.nb_by_genre, name="Equipe tech"),  # noqa: E501
+#              1, 2)
+#
+#
+#
+#
+# fig.update_layout(width = 400,
+# 			margin=dict(t=0, b=0, l=0, r=0),)
+# 	x=1),
+# Add annotations in the center of the donut pies.
+# annotations=[dict(text='Casting', x=0.15, y=0.5, font_size=20, showarrow=False),
+#             dict(text='Crew', x=0.83, y=0.5, font_size=20, showarrow=False)])
+#
+#
+#    data=[go.Bar(x=country_group_df.pays_rework ,
+# 				 y=country_group_df.nb_titre)])
+#
+# 		with colinfofilm.expander("Table de données"):
diff --git a/notebooks/analyse-poc-treated-data.ipynb b/notebooks/analyse-poc-treated-data.ipynb
new file mode 100644
index 0000000..3af52f9
--- /dev/null
+++ b/notebooks/analyse-poc-treated-data.ipynb
@@ -0,0 +1,735 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "title: \"Analyse des résultats (PoC V1)\"\n",
+    "format: html\n",
+    "---\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/s4/6jbnvfsj1v10f2txtlkndj5w0000gp/T/ipykernel_38954/2759663841.py:8: DeprecationWarning: \n",
+      "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n",
+      "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n",
+      "but was not found to be installed on your system.\n",
+      "If this would cause problems for you,\n",
+      "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n",
+      "        \n",
+      "  import pandas as pd\n"
+     ]
+    },
+    {
+     "data": {
+      "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>TITRE</th>\n",
+       "      <th>ANNEE</th>\n",
+       "      <th>PAYS</th>\n",
+       "      <th>CANAL</th>\n",
+       "      <th>TYPE</th>\n",
+       "      <th>SAISON</th>\n",
+       "      <th>LIEU(X) DE L'ACTION</th>\n",
+       "      <th>EPOQUE DU RECIT</th>\n",
+       "      <th>TRAITEMENT DU RECIT</th>\n",
+       "      <th>TYPE DE MONDE</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Epoque</th>\n",
+       "      <th>Traitement</th>\n",
+       "      <th>Monde</th>\n",
+       "      <th>Genre</th>\n",
+       "      <th>Conso</th>\n",
+       "      <th>Vie</th>\n",
+       "      <th>Vivant</th>\n",
+       "      <th>Climat</th>\n",
+       "      <th>Recul</th>\n",
+       "      <th>Nécessité</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Une nuit</td>\n",
+       "      <td>2023.0</td>\n",
+       "      <td>France</td>\n",
+       "      <td>SALLE DE CINÉMA</td>\n",
+       "      <td>FILM</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>France, Paris</td>\n",
+       "      <td>2020-2030</td>\n",
+       "      <td>Ni dystopique ni utopique</td>\n",
+       "      <td>Réaliste (monde proche du nôtre dans son fonct...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2020-2030</td>\n",
+       "      <td>Ni dystopique ni utopique</td>\n",
+       "      <td>Réaliste (monde proche du nôtre dans son fonct...</td>\n",
+       "      <td>Comédie-romantique</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>Non applicable, les scores obtenus sont neutre...</td>\n",
+       "      <td>Non applicable, les scores obtenus sont neutre...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2020-2030</td>\n",
+       "      <td>Ni dystopique ni utopique</td>\n",
+       "      <td>Réaliste (monde proche du nôtre dans son fonct...</td>\n",
+       "      <td>Comédie-romantique</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>Non applicable, les scores obtenus sont neutre...</td>\n",
+       "      <td>Non applicable, les scores obtenus sont neutre...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>2 rows × 104 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      TITRE   ANNEE    PAYS            CANAL  TYPE SAISON LIEU(X) DE L'ACTION  \\\n",
+       "0  Une nuit  2023.0  France  SALLE DE CINÉMA  FILM    NaN       France, Paris   \n",
+       "1       NaN     NaN     NaN              NaN   NaN    NaN                 NaN   \n",
+       "\n",
+       "  EPOQUE DU RECIT        TRAITEMENT DU RECIT  \\\n",
+       "0       2020-2030  Ni dystopique ni utopique   \n",
+       "1             NaN                        NaN   \n",
+       "\n",
+       "                                       TYPE DE MONDE  ...     Epoque  \\\n",
+       "0  Réaliste (monde proche du nôtre dans son fonct...  ...  2020-2030   \n",
+       "1                                                NaN  ...  2020-2030   \n",
+       "\n",
+       "                  Traitement  \\\n",
+       "0  Ni dystopique ni utopique   \n",
+       "1  Ni dystopique ni utopique   \n",
+       "\n",
+       "                                               Monde               Genre  \\\n",
+       "0  Réaliste (monde proche du nôtre dans son fonct...  Comédie-romantique   \n",
+       "1  Réaliste (monde proche du nôtre dans son fonct...  Comédie-romantique   \n",
+       "\n",
+       "  Conso  Vie  Vivant Climat  \\\n",
+       "0  -1.0  0.0     0.0    0.0   \n",
+       "1  -1.0  0.0     0.0    0.0   \n",
+       "\n",
+       "                                               Recul  \\\n",
+       "0  Non applicable, les scores obtenus sont neutre...   \n",
+       "1  Non applicable, les scores obtenus sont neutre...   \n",
+       "\n",
+       "                                           Nécessité  \n",
+       "0  Non applicable, les scores obtenus sont neutre...  \n",
+       "1  Non applicable, les scores obtenus sont neutre...  \n",
+       "\n",
+       "[2 rows x 104 columns]"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Getting started\n",
+    "\n",
+    "# A simple notebooks for testing some analyses on the first version of the questionnaire.\n",
+    "# Data are not pushed to github due to privacy reasons. \n",
+    "# The raw_data.csv should be copied to the data/ folder. \n",
+    "\n",
+    "# Let's first load the data to understand its structure and then compute general statistical information.\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Load the data\n",
+    "file_path = '../data/Analyse réponses.xlsx - Treated data.csv'\n",
+    "\n",
+    "# ne pas lire la première ligne\n",
+    "data = pd.read_csv(file_path, skiprows=1)\n",
+    "\n",
+    "# Display the first few rows of the dataframe to understand its structure\n",
+    "data.head(2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['TITRE', 'ANNEE', 'PAYS', 'CANAL', 'TYPE', 'SAISON', \"LIEU(X) DE L'ACTION\", 'EPOQUE DU RECIT', 'TRAITEMENT DU RECIT', 'TYPE DE MONDE', 'GENRE', 'POSITION DANS LE RECIT', 'GENRE.1', 'AGE', 'ETHNICITÉ', 'BEAUTE', 'POIDS', 'PAYS DE RESIDENCE', \"TYPE D'HABITAT\", \"LIEU D'HABITAT\", 'Appartement', 'Colocation', 'Maison', 'Studio', 'Hôtel', 'Ferme', 'Alternatif / Communautaire', 'Ne sait pas / Autre', 'ACTIVITE', \"SECTEUR D'ACTIVITE\", 'CATEGORIE SOCIALE', 'ASPIRATIONS', 'Unnamed: 32', 'Unnamed: 33', 'Unnamed: 34', 'Unnamed: 35', 'Unnamed: 36', 'Unnamed: 37', 'Unnamed: 38', 'Unnamed: 39', 'Unnamed: 40', 'Unnamed: 41', 'Unnamed: 42', 'Unnamed: 43', 'Unnamed: 44', 'Unnamed: 45', 'Unnamed: 46', 'Unnamed: 47', 'Unnamed: 48', 'Unnamed: 49', 'Unnamed: 50', 'Unnamed: 51', 'VALEURS / TRAITS DE CARACTÈRE', 'Unnamed: 53', 'Unnamed: 54', 'Unnamed: 55', 'Unnamed: 56', 'Unnamed: 57', 'Unnamed: 58', 'Unnamed: 59', 'Unnamed: 60', 'Unnamed: 61', 'Unnamed: 62', 'Unnamed: 63', 'Unnamed: 64', 'Unnamed: 65', 'Unnamed: 66', 'Unnamed: 67', 'Unnamed: 68', 'Unnamed: 69', 'Unnamed: 70', 'Unnamed: 71', 'Unnamed: 72', 'EMPREINTE PERSO', 'CONSOMMATION & MATERIALISME', 'CONSOMMATION & MATERIALISME.1', 'MODES DE VIE', 'MODES DE VIE.1', 'RAPPORT AU VIVANT', 'RAPPORT AU VIVANT.1', 'CRISE ENVIRONNEMENTALE', 'CRISE ENVIRONNEMENTALE.1', 'Y A-T-IL UNE PRISE DE RECUL ?', 'EST-CE NECESSAIRE ?', 'QUELQUE CHOSE A AJOUTER ?', 'VOTRE EMAIL ?', 'Label / corpus', 'TYPOLOGIE', 'Corpus', 'Année', 'Pays', 'Canal', 'Type', 'Lieux action', 'Epoque', 'Traitement', 'Monde', 'Genre', 'Conso', 'Vie', 'Vivant', 'Climat', 'Recul', 'Nécessité']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# colonnes\n",
+    "print(list(data.columns))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "nb lignes et nb colonnes\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(812, 104)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Supprimer les lignes où la première colonne contient \"Contenu XXX\"\n",
+    "# XXX est un nombre\n",
+    "# Et Supprimer les lignes où toutes les valeurs sont NaN\n",
+    "df  = data[~data['TITRE'].str.contains(r'Contenu \\d+', na=False)].dropna(how='all')\n",
+    "print('nb lignes et nb colonnes')\n",
+    "df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Nombre de réponses analysées : 203\n",
+      "Nombre de colonnes dans l'analyse : 104\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ne conserver qu'une ligne sur 4  (ce qui revient à supprimer les informations des personnages 2, 3, 4 quand ils existent)\n",
+    "df_truncated = df.iloc[::4]\n",
+    "\n",
+    "# Pour afficher séparément le nombre de lignes et de colonnes\n",
+    "nb_lignes, nb_colonnes = df_truncated.shape\n",
+    "print(f\"Nombre de réponses analysées : {nb_lignes}\")\n",
+    "print(f\"Nombre de colonnes dans l'analyse : {nb_colonnes}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/s4/6jbnvfsj1v10f2txtlkndj5w0000gp/T/ipykernel_38954/3001236423.py:4: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  df_truncated['TITRE'] = df_truncated['TITRE'].str.upper()\n",
+      "/var/folders/s4/6jbnvfsj1v10f2txtlkndj5w0000gp/T/ipykernel_38954/3001236423.py:9: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  df_truncated[annee] = pd.to_numeric(df_truncated[annee], errors='coerce').fillna(0).astype(int)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Nettoyage du data set\n",
+    "\n",
+    "# mettre les titres en majuscule \n",
+    "df_truncated['TITRE'] = df_truncated['TITRE'].str.upper()\n",
+    "\n",
+    "### Convertir les types de données correctement ici \n",
+    "# Convertir les années en entier\n",
+    "annee = \"ANNEE\"\n",
+    "df_truncated[annee] = pd.to_numeric(df_truncated[annee], errors='coerce').fillna(0).astype(int)\n",
+    "\n",
+    "# print(df_truncated.dtypes)  # Afficher les types de données des colonnes pour vérifier\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "TITRE\n",
+       "POLAR PARK                   6\n",
+       "LE RÈGNE ANIMAL              4\n",
+       "UNE ANNÉE DIFFICILE          3\n",
+       "SAMBRE                       3\n",
+       "VOLEUSES                     2\n",
+       "SECOND TOUR                  2\n",
+       "THE CROWN                    2\n",
+       "PAST LIVES                   2\n",
+       "BODIES                       2\n",
+       "LE LIVRE DES SOLUTIONS       2\n",
+       "À PLEIN TEMPS                2\n",
+       "REVOIR PARIS                 2\n",
+       "D'ARGENT ET DE SANG          2\n",
+       "YANNICK                      2\n",
+       "SENSE8                       2\n",
+       "ANATOMIE D'UNE CHUTE         2\n",
+       "LE THÉORÈME DE MARGUERITE    2\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Trouver les titres qui apparaissent plus de 4 fois dans la colonne \"TITRE\" (car chaque titre a 4 lignes, une pour chaque personnage)\n",
+    "titles_more_than_once = df_truncated['TITRE'].value_counts()\n",
+    "titles_more_than_once = titles_more_than_once[titles_more_than_once > 1]\n",
+    "\n",
+    "titles_more_than_once\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABBIAAAIjCAYAAAC+rjj0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAChq0lEQVR4nOzdd3RU1fr/8c+QQAoTJhBKAoYaEiBUCyAIBIUbiqBIC9JiYgREpChdAaMCIk1BrCmg9CpyFaVFkCIiBKRJjeAlUYwkoQYC8/uDX+bLOJPkBIKgvF9r7bWcfXZ5zplw1z3P7LOPyWq1WgUAAAAAAGBAoTsdAAAAAAAA+OcgkQAAAAAAAAwjkQAAAAAAAAwjkQAAAAAAAAwjkQAAAAAAAAwjkQAAAAAAAAwjkQAAAAAAAAwjkQAAAAAAAAwjkQAAAAD8A1y5ckUTJ07UF198cadDAXCPI5EAAAD+ceLj42UymbRjx447HcpdY9y4cTKZTHc6jAJRsWJFhYeH31TfpKQkmUwmxcfHF1g8JpNJ48aNK7DxbtaIESP0ySefqGHDhob7ZP9bSUpKun2BAbjnkEgAAOAel32jcWMpXbq0mjdvrq+++upvj2f58uVq3bq1SpYsqSJFiqhs2bLq0qWL1q9f/7fHkm3WrFn5ujE1mUx64YUXnB77tydBvvzyy7vipvtudu7cOY0dO1Y1a9ZU0aJF5ePjo7p162rgwIE6deqU0z6ff/65PvvsM61evVqlSpX6myMGAHskEgAAgCQpOjpan376qebMmaNhw4bp9OnTatOmjVatWvW3zG+1WvXMM8/oqaee0m+//aYhQ4bogw8+UP/+/XXs2DE99thj2rJly98Sy1/lN5FwJ7zyyiu6ePHinQ5DX375pV577bU7HcZd68qVK2ratKnefvttNWnSRFOnTtWoUaN0//33a968eTp06JDTfklJSfrqq68UEBCQr/l69uypixcvqkKFCgURPgBIklzvdAAAAODu0Lp1az344IO2z5GRkSpTpozmz5+vxx9//JbHv3btmi5fvix3d3enx6dMmaL4+HgNGjRIU6dOtVumP3r0aH366adydf17/6/LhQsX5Onp+bfOmV/nz59X0aJF5erq+rdfH+TfihUrtGvXLs2dO1dPP/203bFLly7p8uXLTvsNHDgwX/Nk/124uLjIxcXlpuMFAGdYkQAAAJzy9vaWh4eHw83p5MmT1ahRI/n4+MjDw0MPPPCAlixZ4tA/e3n/3LlzFRwcLDc3N61evdrpXBcvXtSECRNUrVo1TZ482emz/j179lT9+vXt6jIzMzVkyBCVKlVKRYsWVYcOHXT69Gm7Np9//rnatm2rsmXLys3NTVWqVNHrr7+uq1ev2rULCQlRzZo19eOPP6pp06by9PTUqFGjVLFiRe3bt0/ffvut7dGPkJAQI5cwX9avX68mTZqoaNGi8vb21hNPPKEDBw7YtcneB2H//v16+umnVbx4cT3yyCN2x7KFh4c7PLKSXW589OD333+3JY3c3d1Vp04dzZ49227e7H0HJk+erI8++khVqlSRm5ubHnroIf3www92c7733nuSZDdfNqN/O0alpaUpPDxcFotF3t7e6t27t9LS0py2PXjwoDp16qQSJUrI3d1dDz74oFauXHlT8/7yyy96/vnnFRQUJA8PD/n4+Khz586G9iE4evSoJKlx48YOx9zd3VWsWLF8x539uMy3336r559/XqVLl9Z9991nd+yvsX311Ve2vzcvLy+1bdtW+/bty8dVAHAvI20NAAAkSenp6frjjz9ktVr1+++/a8aMGTp37px69Ohh1+6dd95R+/bt1b17d12+fFkLFixQ586dtWrVKrVt29au7fr167Vo0SK98MILKlmypCpWrOh07u+++05//vmnBg0alK9fTwcMGKDixYtr7NixSkpK0vTp0/XCCy9o4cKFtjbx8fEym80aMmSIzGaz1q9frzFjxigjI0Nvv/223Xipqalq3bq1wsLC1KNHD5UpU0YhISEaMGCAzGazRo8eLUkqU6ZMnrFdunRJf/zxh0P9uXPnHOrWrl2r1q1bq3Llyho3bpwuXryoGTNmqHHjxtq5c6fDdevcubOqVq2q8ePHy2q1Op2/T58+atGihV3d6tWrNXfuXJUuXVrS9QROSEiIjhw5ohdeeEGVKlXS4sWLFR4errS0NIdfwefNm6ezZ8+qT58+MplMmjRpkp566ikdO3ZMhQsXVp8+fXTq1CmtWbNGn376qUNM+fnbyYvVatUTTzyh7777Tn379lX16tW1fPly9e7d26Htvn371LhxY5UrV04jRoxQ0aJFtWjRIj355JNaunSpOnTokK+5f/jhB23ZskVhYWG67777lJSUpPfff18hISHav39/rqtYsh8xmDNnjl555ZVcN8jMb9zPP/+8SpUqpTFjxuj8+fM5jvvpp5+qd+/eCg0N1VtvvaULFy7o/fff1yOPPKJdu3bl+O8UAGysAADgnhYXF2eV5FDc3Nys8fHxDu0vXLhg9/ny5cvWmjVrWh999FG7eknWQoUKWfft25dnDO+8845VknX58uX5irlFixbWa9eu2eoHDx5sdXFxsaalpeUYr9Vqtfbp08fq6elpvXTpkq2uWbNmVknWDz74wKF9cHCwtVmzZoZis1qtTq/nX8sPP/xga1+3bl1r6dKlrampqba63bt3WwsVKmTt1auXrW7s2LFWSdZu3bo5zJl9LCeHDx+2WiwWa8uWLa1ZWVlWq9VqnT59ulWS9bPPPrO1u3z5svXhhx+2ms1ma0ZGhtVqtVqPHz9ulWT18fGx/vnnn7a2n3/+uVWS9YsvvrDV9e/fP8c4jP7tVKhQwdq7d+8cz8VqtVpXrFhhlWSdNGmSrS4rK8vapEkTqyRrXFycrf6xxx6z1qpVy+77vnbtmrVRo0bWqlWr5jqP1Xr9+xw7dmyO52G1Wq1bt261SrLOmTMn17EuXLhgDQoKskqyVqhQwRoeHm6NiYmx/vbbbw5tjcad/e/hkUcesX23fz12/Phxq9VqtZ49e9bq7e1tjYqKsmuXkpJitVgsDvUA4AyPNgAAAEnSe++9pzVr1mjNmjX67LPP1Lx5cz377LNatmyZXTsPDw/bf585c0bp6elq0qSJdu7c6TBms2bNVKNGjTznzsjIkCR5eXnlK+bnnnvO7hfdJk2a6OrVq/rll1+cxnv27Fn98ccfatKkiS5cuKCDBw/ajefm5qZnnnkmXzHk5IknnrBdzxvL0KFD7dolJycrMTFR4eHhKlGihK2+du3aatmypb788kuHsfv27ZuvWM6fP68OHTqoePHimj9/vm3Vx5dffilfX19169bN1rZw4cJ68cUXde7cOX377bd243Tt2lXFixe3fW7SpIkk6dixY4biyM/fTl6+/PJLubq6ql+/frY6FxcXDRgwwK7dn3/+qfXr16tLly627/+PP/5QamqqQkNDdfjwYf3vf//L19w3nseVK1eUmpqqgIAAeXt753kuHh4e+v77721/B/Hx8YqMjJSfn58GDBigzMzMm447KioqzxU9a9asUVpamrp162Yb848//pCLi4saNGigDRs25OtaALg38WgDAACQJNWvX99us8Vu3bqpXr16euGFF/T444+rSJEikqRVq1bpjTfeUGJiou2mR5LTJdqVKlUyNHf2c+Fnz57NV8zly5e3+5x9k3vmzBlb3b59+/TKK69o/fr1toRFtvT0dLvP5cqVs53nrbrvvvscHi2QpF9//dXuc3bSIygoyKFt9erV9fXXX9s2zstm9Lpmi4qK0tGjR7Vlyxb5+PjYzV21alUVKmT/21L16tXtYstm5HrnJj9/O3n55Zdf5OfnJ7PZbFf/1+t45MgRWa1Wvfrqq3r11VedjvX777+rXLlyhufO3tMjLi5O//vf/+weL/nr35QzFotFkyZN0qRJk/TLL79o3bp1mjx5smbOnCmLxaI33njjpuI28ndx+PBhSdKjjz7q9Phf92gAAGdIJAAAAKcKFSqk5s2b65133tHhw4cVHBysTZs2qX379mratKlmzZolPz8/FS5cWHFxcZo3b57DGDf+cpubatWqSZJ++uknPfnkk4ZjzOnX1+wbu7S0NDVr1kzFihVTdHS0qlSpInd3d+3cuVPDhw/XtWvXbireOy0/cb7zzjuaP3++PvvsM9WtW/eW5s3reucmv387BSX7O3755ZcVGhrqtE1+X6k4YMAAxcXFadCgQXr44YdlsVhkMpkUFhbm8DeVlwoVKigiIkIdOnRQ5cqVNXfuXL3xxhs3FbeRv4vscT/99FP5+vo6HOfNHwCM4H8pAABAjrKysiT93waBS5culbu7u77++mu5ubnZ2sXFxd3SPI888oht2f2oUaMK7HV1CQkJSk1N1bJly9S0aVNb/fHjx/M1zs38Ym5U9uZ7P//8s8OxgwcPqmTJknarEfJj06ZNevnllzVo0CB1797d6dx79uzRtWvX7FYlZD/ykR1bfuR0rQr6b6dChQpat26dzp07Z7cq4a/XsXLlypKuP7LhbIXIzViyZIl69+6tKVOm2OouXbqU4xsjjChevLiqVKmivXv3Sro9cUtSlSpVJEmlS5cu0HEB3FvYIwEAADh15coVffPNNypSpIhtqbuLi4tMJpPdqxOTkpK0YsWKW5rL09NTw4cP14EDBzR8+HCnv3B/9tln2r59e77GzU5I3Dje5cuXNWvWrHyNU7Ro0Vu6ScyNn5+f6tatq9mzZ9vNsXfvXn3zzTdq06bNTY2bnJysLl266JFHHnF4O0W2Nm3aKCUlxe4tF1lZWZoxY4bMZrOaNWuW73mzkx5/vV4F/bfTpk0bZWVl6f3337fVXb16VTNmzLBrV7p0aYWEhOjDDz9UcnKywzh/fV2oES4uLg5/ozNmzHB4pagzu3fvdvo2j19++UX79++3PZpxO+KWpNDQUBUrVkzjx4/XlStXCmxcAPcWViQAAABJ198rn/1L9O+//6558+bp8OHDGjFihO256bZt22rq1Klq1aqVnn76af3+++967733FBAQoD179tzS/EOHDtW+ffs0ZcoUbdiwQZ06dZKvr69SUlK0YsUKbd++XVu2bMnXmI0aNVLx4sXVu3dvvfjiizKZTPr0008NLcW/0QMPPKD3339fb7zxhgICAlS6dOkcnzG/GW+//bZat26thx9+WJGRkbbXP1osFo0bN+6mxnzxxRd1+vRpDRs2TAsWLLA7Vrt2bdWuXVvPPfecPvzwQ4WHh+vHH39UxYoVtWTJEm3evFnTp0/P9+aX0vVrlT1/aGioXFxcFBYWVuB/O+3atVPjxo01YsQIJSUlqUaNGlq2bJnTPQree+89PfLII6pVq5aioqJUuXJl/fbbb9q6dat+/fVX7d69O19zP/744/r0009lsVhUo0YNbd26VWvXrrXbfyIna9as0dixY9W+fXs1bNhQZrNZx44dU2xsrDIzM+2+74KOW7q+B8L777+vnj176v7771dYWJhKlSqlEydO6L///a8aN26smTNn5ntcAPeYO/a+CAAAcFdw9vpHd3d3a926da3vv/++3esVrVarNSYmxlq1alWrm5ubtVq1ata4uDinrx6UZO3fv3++41myZIn1P//5j7VEiRJWV1dXq5+fn7Vr167WhIQEh5hvfIWi1Wq1btiwwSrJumHDBlvd5s2brQ0bNrR6eHhYy5Ytax02bJj166+/dmjXrFkza3BwsNOYUlJSrG3btrV6eXlZJeX5Ksjczj2n2NeuXWtt3Lix1cPDw1qsWDFru3btrPv377drk32dT58+7TDuX7+D7NdZOis3vsrwt99+sz7zzDPWkiVLWosUKWKtVauW3asTrdb/e/3j22+/7fRcbxwvKyvLOmDAAGupUqWsJpPJLiajfztGXv9otVqtqamp1p49e1qLFStmtVgs1p49e1p37drl8PpHq9VqPXr0qLVXr15WX19fa+HCha3lypWzPv7449YlS5bkOc9fz/HMmTO2a2Y2m62hoaHWgwcPGor72LFj1jFjxlgbNmxoLV26tNXV1dVaqlQpa9u2ba3r1693aG8k7pz+pm48lv36x2wbNmywhoaGWi0Wi9Xd3d1apUoVa3h4uHXHjh15Xg8AMFmt+UzJAwAAAACAexZ7JAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNc73QAAO6sa9eu6dSpU/Ly8pLJZLrT4QAAAAC4Q6xWq86ePauyZcuqUKGc1x2QSADucadOnZK/v/+dDgMAAADAXeLkyZO67777cjxOIgG4x3l5eUm6/j8WxYoVu8PRAAAAALhTMjIy5O/vb7tHyAmJBOAel/04Q7FixUgkAAAAAMjzkWc2WwQAAAAAAIaRSAAAAAAAAIaRSAAAAAAAAIaRSAAAAAAAAIax2SIASdLU3alyN1++02EAAAAA94wR9Ure6RBuCisSAAAAAACAYSQScFcIDw+XyWSSyWRSkSJFFBAQoOjoaGVlZdnaXL16VdOmTVOtWrXk7u6u4sWLq3Xr1tq8ebPdWPHx8fL29jY0b7Vq1eTm5qaUlBSHYyEhIbaY3N3dFRgYqAkTJshqteY65l/71ahRQ7NmzSrwuZOSkmQymZSYmGirO3v2rJo3b64aNWro119/NXQNAAAAACA/SCTgrtGqVSslJyfr8OHDeumllzRu3Di9/fbbkiSr1aqwsDBFR0dr4MCBOnDggBISEuTv76+QkBCtWLEi3/N99913unjxojp16qTZs2c7bRMVFaXk5GT9/PPPGjlypMaMGaMPPvggz7Gz++3fv19dunRR//79NX/+/Ns69+nTp9W8eXOdP39emzZt0n333ZdnnAAAAACQXyQScNdwc3OTr6+vKlSooH79+qlFixZauXKlJGnRokVasmSJ5syZo2effVaVKlVSnTp19NFHH6l9+/Z69tlndf78+XzNFxMTo6efflo9e/ZUbGys0zaenp62mJ555hnVrl1ba9asyXPs7H6VK1fWuHHjVLVqVdu53I65T548qSZNmshisWj9+vXy8fExcAUAAAAAIP9IJOCu5eHhocuXr2/+N2/ePAUGBqpdu3YO7V566SWlpqYausHPdvbsWS1evFg9evRQy5YtlZ6erk2bNuXY3mq1atOmTTp48KCKFClyS+dS0HP//PPPaty4sWrUqKEvv/xSZrM511gyMzOVkZFhVwAAAADAKBIJuOtYrVatXbtWX3/9tR599FFJ0qFDh1S9enWn7bPrDx06ZHiOBQsWqGrVqgoODpaLi4vCwsIUExPj0G7WrFkym81yc3NT06ZNde3aNb344ouG57l69ao+++wz7dmzx3YuBT13r169FBAQoMWLF8vNzS3PmCZMmCCLxWIr/v7+hs8HAAAAAEgk4K6xatUqmc1mubu7q3Xr1uratavGjRtnO57XJof5ERsbqx49etg+9+jRQ4sXL9bZs2ft2nXv3l2JiYnavHmzWrdurdGjR6tRo0Z5jp+dBPDw8FBUVJQGDx6sfv363Za527dvr02bNmnZsmWGzn3kyJFKT0+3lZMnTxrqBwAAAACS5HqnAwCyNW/eXO+//76KFCmismXLytX1//48AwMDdeDAAaf9susDAwMNzbN//35t27ZN27dv1/Dhw231V69e1YIFCxQVFWWrs1gsCggIkHR9n4aAgAA1bNhQLVq0yHWO7t27a/To0fLw8JCfn58KFSp02+YePXq0ateuraefflpWq1VdunTJNTY3NzdDKxcAAAAAwBlWJOCuUbRoUQUEBKh8+fJ2SQRJCgsL0+HDh/XFF1849JsyZYp8fHzUsmVLQ/PExMSoadOm2r17txITE21lyJAhTh8xyGY2mzVw4EC9/PLLea6OyE4ClCtXzpZEuJ1zv/rqqxo3bpy6d++uhQsXGrgKAAAAAHBzSCTgHyEsLEwdOnRQ7969FRMTo6SkJO3Zs0d9+vTRypUr9cknn6ho0aK29levXrW7UU9MTNSBAwd05coVffrpp+rWrZtq1qxpV5599ll9//332rdvX45x9OnTR4cOHdLSpUvzfQ63e+7Ro0fr9ddfV/fu3e1eNQkAAAAABYlEAv4RTCaTFi1apFGjRmnatGkKCgpSkyZN9MsvvyghIUFPPvmkXftz586pXr16dqVdu3ZauXKlUlNT1aFDB4c5qlevrurVq+e6MqBEiRLq1auXxo0bp2vXruXrHP6OuUeMGKHx48erZ8+emjdvXr7iAwAAAAAjTNaC3MEOwD9ORkaGLBaLxm48Jnez150OBwAAALhnjKhX8k6HYCf73iA9PV3FihXLsR2bLQKQJA2p45Pr/1gAAAAAgMSjDQAAAAAAIB9IJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNIJAAAAAAAAMNc73QAuDf88MMP6tWrl/773/+qcuXKdzocODF1d6rczZfvdBgAACAHI+qVvNMhAIAkViTgb/LQQw9p0aJF2rp1650OBQAAAABwC1iRgL9NrVq1VKtWrTsdBgAAAADgFrAi4R4RHh6uJ598MsfjFStWlMlkcigTJ07MsU9ISIitnbu7uwIDAzVhwgRZrVZbm6SkJKfjmkwmbdu2zdbu8uXLevvtt3X//feraNGislgsqlOnjl555RWdOnXK7jycxbVixQqZTCbb54SEhBznTUlJyfN6hYaGysXFRT/88IPDsfzGkJaWZve5ePHiunTpkl3fH374wRafM9WqVZObm5vT2ENCQjRo0KA8zwkAAAAACgKJBNhER0crOTnZrgwYMCDXPlFRUUpOTtbPP/+skSNHasyYMfrggw8c2q1du9Zh7AceeECSlJmZqZYtW2r8+PEKDw/Xxo0b9dNPP+ndd9/VH3/8oRkzZtiN5e7urrfeektnzpzJ85x+/vlnh3lLly6da58TJ05oy5YteuGFFxQbG+u0TX5i+CsvLy8tX77cri4mJkbly5d32v67777TxYsX1alTJ82ePTvf8wEAAABAQSKRABsvLy/5+vralaJFi+bax9PTU76+vqpQoYKeeeYZ1a5dW2vWrHFo5+Pj4zB24cKFJUnTpk3Td999p/Xr1+vFF1/UAw88oPLly6tZs2b64IMPNH78eLuxWrRoIV9fX02YMCHPcypdurTDvIUK5f5nHxcXp8cff1z9+vXT/PnzdfHiRYc2+Ynhr3r37m2XoLh48aIWLFig3r17O20fExOjp59+Wj179swxsZEfmZmZysjIsCsAAAAAYBSJBBQIq9WqTZs26eDBgypSpEi++s6fP18tW7ZUvXr1nB7/63J/FxcXjR8/XjNmzNCvv/560zE7Y7VaFRcXpx49eqhatWoKCAjQkiVLHNrdSgw9e/bUpk2bdOLECUnS0qVLVbFiRd1///0Obc+ePavFixerR48eatmypdLT07Vp06abO7n/b8KECbJYLLbi7+9/S+MBAAAAuLeQSIDN8OHDZTab7UpeN62zZs2S2WyWm5ubmjZtqmvXrunFF190aNeoUSOHsbMdOnRIQUFBdu07dOhga9eoUSOH8Tp06KC6detq7NixucZ333332c0ZHByca/u1a9fqwoULCg0NlST16NFDMTExTtsajeGvSpcurdatWys+Pl6SFBsbq4iICKdtFyxYoKpVqyo4OFguLi4KCwvLMR6jRo4cqfT0dFs5efLkLY0HAAAA4N7CWxtgM3ToUIWHh9vVlStXLtc+3bt31+jRo3XmzBmNHTtWjRo1cnrjv3DhQlWvXt1wLLNmzdL58+f17rvvauPGjU7bvPXWW3r00Uf18ssv5zjOpk2b5OXlZfuc/ThFTmJjY9W1a1e5ul7/p9GtWzcNHTpUR48eVZUqVW4qBmciIiI0cOBA9ejRQ1u3btXixYudJm1iY2PVo0cP2+cePXqoWbNmmjFjht155Yebm5vc3Nxuqi8AAAAAsCIBNiVLllRAQIBd8fDwyLWPxWJRQECAHnroIS1atEgzZ87U2rVrHdr5+/s7jJ2tatWq+vnnn+3a+/n5KSAgQCVKlMhx7qZNmyo0NFQjR47MsU2lSpXs5qxQoUKObf/8808tX75cs2bNkqurq1xdXVWuXDllZWXluDeBkRicad26tS5evKjIyEi1a9dOPj4+Dm3279+vbdu2adiwYbZ4GjZsqAsXLmjBggX5mg8AAAAACgqJBBQYs9msgQMH6uWXX7Z7BWReunXrpjVr1mjXrl35nnPixIn64osvtHXr1nz3/au5c+fqvvvu0+7du5WYmGgrU6ZMUXx8vK5evVpgMbi6uqpXr15KSEjI8bGGmJgYNW3a1CGeIUOG3PLjDQAAAABws3i04R6Snp6uxMREuzofHx/bZntnz55VSkqK3XFPT08VK1bM8Bx9+vTR66+/rqVLl6pTp062+tTUVIexvb295e7ursGDB+u///2vHnvsMY0dO1ZNmjRR8eLFdejQIX311VdycXHJcb5atWqpe/fuevfdd50e//3333Xp0iWHc3b2iENMTIw6deqkmjVr2tX7+/tr5MiRWr16tdq2bZvvGHLy+uuva+jQoU5XI1y5ckWffvqpoqOjHeJ59tlnNXXqVO3bt8+258Pp06cdvls/Pz+VKVMmXzEBAAAAQF5YkXAPSUhIUL169ezKa6+9Zjs+ZswY+fn52ZVhw4bla44SJUqoV69eGjdunK5du2arb9GihcPYK1askCS5u7tr3bp1Gj58uOLi4vTII4+oevXqGjRokBo3bmxrl5Po6Gi7uW4UFBTkMO+PP/7o0O7HH3/U7t271bFjR4djFotFjz32WK6rAHKLISdFihRRyZIlHd5KIUkrV65UamqqOnTo4HCsevXqql69ul088+bNc/huP/7443zFAwAAAABGmKz5WYMO4F8nIyNDFotF6enp+Vp9AgAAAODfxei9ASsSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYSQSAAAAAACAYa53OgDgRteuXVOnTp10//3365VXXrnT4dxTpu5Olbv58p0OAwCQTyPqlbzTIQAA7jEkEnBX2bdvnzp27Kju3bvf6VAAAAAAAE6QSMBdpVatWqpVq9adDgMAAAAAkAP2SLhLhISEaNCgQQ718fHx8vb2tn0eN26cTCaT+vbta9cuMTFRJpNJSUlJkqSkpCSZTCanZdu2bXnG06dPH7m4uGjx4sUOx/IbQ+nSpXX27Fm7tnXr1tW4cePszt9ZrDfOkdP5LFiwIMfzqFixoq2dh4eHKlasqC5dumj9+vV27bJjTUxMzPX69ejRI1/Hs8fLtnTpUoWEhMhischsNqt27dqKjo7Wn3/+Kcnx+/7r578KDw93GkerVq1y7AMAAAAAt4JEwj+Qu7u7YmJidPjw4Tzbrl27VsnJyXblgQceyLXPhQsXtGDBAg0bNkyxsbG3HMPZs2c1efLkPNtFRUU5xDpp0iS7NnFxcQ5tnnzyyVzHjY6OVnJysn7++WfNmTNH3t7eatGihd588808Y/rr9XvvvffydfxGo0ePVteuXfXQQw/pq6++0t69ezVlyhTt3r1bn376aZ6x5KRVq1YO12T+/Pk3PR4AAAAA5IZHG/6BgoKCVLp0aY0ePVqLFi3Kta2Pj498fX3zNf7ixYtVo0YNjRgxQmXLltXJkyfl7+9/0zEMGDBAU6dOVf/+/VW6dOkc23l6euYZq7e3d77Px8vLy9anfPnyatq0qfz8/DRmzBh16tRJQUFBOfbN6/oZvb7bt2/X+PHjNX36dA0cONBWX7FiRbVs2VJpaWnGT+gv3Nzc8n1NAAAAAOBmsSLhH2rixIlaunSpduzYUeBjx8TEqEePHrJYLGrdurXi4+NvKYZu3bopICBA0dHRBR7rzRo4cKCsVqs+//zzv2W+uXPnymw26/nnn3d6PLfHFwpaZmamMjIy7AoAAAAAGEUi4R/q/vvvV5cuXTR8+PBc2zVq1Ehms9mu5Obw4cPatm2bunbtKknq0aOH4uLiZLVabzoGk8mkiRMn6qOPPtLRo0dzbDdr1iyHWOfOnWvXplu3bg5tTpw4kev8zpQoUUKlS5e27eeQk79ev127duXreLbDhw+rcuXKKly4cL5jzcuqVascrsn48eNzbD9hwgRZLBZb+etqEwAAAADIDY82/IO98cYbql69ur755pscHxlYuHChqlevbnjM2NhYhYaGqmTJ6++kbtOmjSIjI7V+/Xo99thjNxWDJIWGhuqRRx7Rq6++qnnz5jlt0717d40ePdqurkyZMnafp02bphYtWtjVlS1b1tC5/ZXVapXJZMq1zV+v319vuvM6fuNct0vz5s31/vvv29WVKFEix/YjR47UkCFDbJ8zMjJIJgAAAAAwjETCXaJYsWJKT093qE9LS5PFYnHap0qVKoqKitKIESMUExPjtI2/v78CAgIMxXD16lXNnj1bKSkpcnV1tauPjY11mkgwEkO2iRMn6uGHH9bQoUOdHrdYLHnG6uvra/h8cpOamqrTp0+rUqVKubbL6/oZvb6BgYH67rvvdOXKlQJflVC0aNF8XRM3Nze5ubkVaAwAAAAA7h082nCXCAoK0s6dOx3qd+7cqcDAwBz7jRkzRocOHcr1FYhGffnllzp79qx27dqlxMREW5k/f76WLVuW44aARmOoX7++nnrqKY0YMeKWY71V77zzjgoVKpTnGx8KytNPP61z585p1qxZTo/fymaLAAAAAPB3YkXCXaJfv36aOXOmXnzxRT377LNyc3PTf//7X82fP19ffPFFjv3KlCmjIUOG6O2333Z6PDU1VSkpKXZ13t7ecnd3d2gbExOjtm3bqk6dOnb1NWrU0ODBgzV37lz1798/3zHc6M0331RwcLDdiodsFy5ccIjVzc1NxYsXt31OS0tzaOPl5aWiRYvmOOfZs2eVkpKiK1eu6Pjx4/rss8/0ySefaMKECQWyusGIBg0aaNiwYXrppZf0v//9Tx06dFDZsmV15MgRffDBB3rkkUfs3uZwo6tXryoxMdGuzs3NzfZIRWZmpsM1cXV1tT2eAgAAAAAFiRUJd4nKlStr48aNOnjwoFq0aKEGDRpo0aJFWrx4sVq1apVr35dffjnHTRRbtGghPz8/u7JixQqHdr/99pv++9//qmPHjg7HChUqpA4dOuT66EJuMdwoMDBQERERunTpksOxjz/+2CHWbt262bV55plnHNrMmDEj1znHjBkjPz8/BQQEqGfPnkpPT9e6devy3CSyoL311luaN2+evv/+e4WGhio4OFhDhgxR7dq11bt37xz7nTt3TvXq1bMr7dq1sx1fvXq1wzV55JFH/o5TAgAAAHAPMllv5y5wAO56GRkZslgsSk9PV7Fixe50OAAAAADuEKP3BqxIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhrne6QAA3B2m7k6Vu/nynQ4DAJBPI+qVvNMhAADuMaxIAAAAAAAAhpFIAAAAAAAAhpFIwD3r9OnT6tevn8qXLy83Nzf5+voqNDRUmzdvtmu3detWubi4qG3btg5jJCUlyWQyycXFRf/73//sjiUnJ8vV1VUmk0lJSUl27bNLkSJFFBAQoDfeeENWq9XWd9y4cbY2Li4u8vf313PPPac///zTbo6KFSvajZddJk6cWEBXCQAAAADssUcC7lkdO3bU5cuXNXv2bFWuXFm//fab1q1bp9TUVLt2MTExGjBggGJiYnTq1CmVLVvWYaxy5cppzpw5GjlypK1u9uzZKleunE6cOOHQfu3atQoODlZmZqa+++47Pfvss/Lz81NkZKStTXBwsNauXaurV6/qwIEDioiIUHp6uhYuXGg3VnR0tKKiouzqvLy8buqaAAAAAEBeSCTgnpSWlqZNmzYpISFBzZo1kyRVqFBB9evXt2t37tw5LVy4UDt27FBKSori4+M1atQoh/F69+6tuLg4u0RCXFycevfurddff92hvY+Pj3x9fW3zxsXFaefOnXaJBFdXV1ubcuXKqXPnzoqLi3MYy8vLy9YOAAAAAG43Hm3APclsNstsNmvFihXKzMzMsd2iRYtUrVo1BQUFqUePHoqNjbV7BCFb+/btdebMGX333XeSpO+++05nzpxRu3bt8oxlx44d+vHHH9WgQYMc2yQlJenrr79WkSJFDJxd7jIzM5WRkWFXAAAAAMAoEgm4J7m6uio+Pl6zZ8+Wt7e3GjdurFGjRmnPnj127WJiYtSjRw9JUqtWrZSenq5vv/3WYbzChQvbEg2SFBsbqx49eqhw4cJO52/UqJHMZrOKFCmihx56SF26dFGvXr3s2vz0008ym83y8PBQpUqVtG/fPg0fPtxhrOHDh9sSI9ll06ZNOZ77hAkTZLFYbMXf3z/3iwUAAAAANyCRgHtWx44dderUKa1cuVKtWrVSQkKC7r//fsXHx0uSfv75Z23fvl3dunWTdD350LVrV8XExDgdLyIiQosXL1ZKSooWL16siIiIHOdeuHChEhMTtXv3bi1atEiff/65RowYYdcmKChIiYmJ+uGHHzR8+HCFhoZqwIABDmMNHTpUiYmJduXBBx/Mce6RI0cqPT3dVk6ePJnXpQIAAAAAGxIJuKe5u7urZcuWevXVV7VlyxaFh4dr7Nixkq6vRsjKylLZsmXl6uoqV1dXvf/++1q6dKnS09MdxqpVq5aqVaumbt26qXr16qpZs2aO8/r7+ysgIEDVq1dX586dNWjQIE2ZMkWXLl2ytcl+o0PNmjU1ceJEubi46LXXXnMYq2TJkgoICLArHh4eOc7t5uamYsWK2RUAAAAAMIpEAnCDGjVq6Pz588rKytKcOXM0ZcoUu1/6d+/erbJly2r+/PlO+0dERCghISHX1QjOuLi4KCsrS5cvX86xzSuvvKLJkyfr1KlT+RobAAAAAAoSb23APSk1NVWdO3dWRESEateuLS8vL+3YsUOTJk3SE088oVWrVunMmTOKjIyUxWKx69uxY0fFxMSob9++DuNGRUWpc+fO8vb2znP+lJQUZWVl6aefftI777yj5s2b57o64OGHH1bt2rU1fvx4zZw501Z/9uxZpaSk2LX19PRkpQEAAACA24IVCbgnmc1mNWjQQNOmTVPTpk1Vs2ZNvfrqq4qKitLMmTMVExOjFi1aOCQRpOuJhB07djhszChd30ehZMmScnXNPUfXokUL+fn5qWLFinruuefUpk0bLVy4MM+4Bw8erE8++cRuX4MxY8bIz8/PrgwbNszAVQAAAACA/DNZnb3LDsA9IyMjQxaLRWM3HpO72etOhwMAyKcR9Ure6RAAAP8S2fcG6enpua5w5tEGAJKkIXV8eBwCAAAAQJ54tAEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABjmeqcDAHB3mLo7Ve7my3c6DAAFZES9knc6BAAA8C/FigQAAAAAAGAYiQQAAAAAAGAYiQT8o4SHh8tkMslkMqlIkSIKCAhQdHS0srKy7NqFhobKxcVFP/zwg8MYp0+fVr9+/VS+fHm5ubnJ19dXoaGh2rx5sxISEmzj51QSEhKcxmYymbRixQqnx7LHTUtL09KlS+Xi4qL//e9/TttWrVpVQ4YMkSSFhIQ4jaFv37629t9++60effRRlShRQp6enqpatap69+6ty5d5TAEAAABAwWOPBPzjtGrVSnFxccrMzNSXX36p/v37q3Dhwho5cqQk6cSJE9qyZYteeOEFxcbG6qGHHrLr37FjR12+fFmzZ89W5cqV9dtvv2ndunVKTU1Vq1atlJycbGs7cOBAZWRkKC4uzlZXokSJW4q/ffv28vHx0ezZszVq1Ci7Yxs3btSRI0cUGRlpq4uKilJ0dLRdO09PT0nS/v371apVKw0YMEDvvvuuPDw8dPjwYS1dulRXr169pTgBAAAAwBkSCfjHyV5FIEn9+vXT8uXLtXLlSlsiIS4uTo8//rj69eunhg0baurUqfLw8JAkpaWladOmTUpISFCzZs0kSRUqVFD9+vVt42ePLUkeHh7KzMy0q7tVhQsXVs+ePRUfH++QSIiNjVWDBg0UHBxsq/P09Mxx/m+++Ua+vr6aNGmSra5KlSpq1apVgcULAAAAADfi0Qb843l4eNiW8VutVsXFxalHjx6qVq2aAgICtGTJEltbs9kss9msFStWKDMz806FrMjISB0+fFgbN2601Z07d05LliyxW42QF19fXyUnJ9uNk5fMzExlZGTYFQAAAAAwikQC/rGsVqvWrl2rr7/+Wo8++qgkae3atbpw4YJCQ0MlST169FBMTIytj6urq+Lj4zV79mx5e3urcePGGjVqlPbs2fO3xl6jRg01bNhQsbGxtrpFixbJarUqLCzMru2sWbNsCZDsMnfuXElS586d1a1bNzVr1kx+fn7q0KGDZs6cmWtyYMKECbJYLLbi7+9/e04SAAAAwL8SiQT846xatUpms1nu7u5q3bq1unbtqnHjxkm6/mhA165d5ep6/amdbt26afPmzTp69Kitf8eOHXXq1CmtXLlSrVq1UkJCgu6//37Fx8f/recRERGhJUuW6OzZs7bYO3fuLC8vL7t23bt3V2Jiol1p3769JMnFxUVxcXH69ddfNWnSJJUrV07jx49XcHCw3V4PNxo5cqTS09Nt5eTJk7f3RAEAAAD8q5BIwD9O8+bNlZiYqMOHD+vixYuaPXu2ihYtqj///FPLly/XrFmz5OrqKldXV5UrV05ZWVl2v/xLkru7u1q2bKlXX31VW7ZsUXh4uMaOHfu3nkf2yoNFixbp8OHD2rx5s9PHGiwWiwICAuzKX5MN5cqVU8+ePTVz5kzt27dPly5d0gcffOB0Xjc3NxUrVsyuAAAAAIBRbLaIf5yiRYsqICDAoX7u3Lm67777HF7B+M0332jKlCmKjo6Wi4uL0zFr1KiR46sbbxcvLy917txZsbGxOnr0qAIDA9WkSZNbHrd48eLy8/PT+fPnCyBKAAAAALBHIgH/GjExMerUqZNq1qxpV+/v76+RI0dq9erVatiwoTp37qyIiAjVrl1bXl5e2rFjhyZNmqQnnnjilmM4fvy4EhMT7eqqVq2aY/vIyEg1adJEBw4c0PDhw522uXDhglJSUuzq3NzcVLx4cX344YdKTExUhw4dVKVKFV26dElz5szRvn37NGPGjFs+HwAAAAD4KxIJ+Ff48ccftXv3bn388ccOxywWix577DHFxMSoRYsWatCggaZNm6ajR4/qypUr8vf3V1RUlMOrGG/GkCFDHOo2bdqUY/tHHnlEQUFBOnLkiHr16uW0zccff+xwXqGhoVq9erXq16+v7777Tn379tWpU6dkNpsVHBysFStW2F5vCQAAAAAFyWS1Wq13OggAd05GRoYsFovGbjwmd7NX3h0A/COMqFfyTocAAAD+YbLvDdLT03PdS40VCQAkSUPq+LDxIgAAAIA88dYGAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgGIkEAAAAAABgmOudDgDA3WHq7lS5my/f6TAAFJAR9Ure6RAAAMC/FCsSAAAAAACAYSQSAAAAAACAYSQS8I/Vrl07tWrVyumxTZs2yWQyac+ePbp48aLGjh2rwMBAubm5qWTJkurcubP27dtn12fcuHGqW7dujvOFhITIZDI5lL59+0qSkpKSZDKZlJiY6LTvoEGDbJ93796t9u3bq3Tp0nJ3d1fFihXVtWtX/f7773ZjOSvbtm2TJF29elUTJ05UtWrV5OHhoRIlSqhBgwb65JNP8nEVAQAAACB/2CMB/1iRkZHq2LGjfv31V9133312x+Li4vTggw8qKChIjz76qE6cOKEpU6aoQYMG+u233zRhwgQ1aNBAa9euVcOGDQ3PGRUVpejoaLs6T0/PfMV9+vRpPfbYY3r88cf19ddfy9vbW0lJSVq5cqXOnz9v13bt2rUKDg62q/Px8ZEkvfbaa/rwww81c+ZMPfjgg8rIyNCOHTt05syZfMUDAAAAAPlBIgH/WI8//rhKlSql+Ph4vfLKK7b6c+fOafHixXr77bc1ffp0bd26Vbt27VKdOnUkSRUqVNDSpUvVoEEDRUZGau/evTKZTIbm9PT0lK+v7y3FvXnzZqWnp+uTTz6Rq+v1f4KVKlVS8+bNHdr6+PjkON/KlSv1/PPPq3Pnzra67HMEAAAAgNuFRxvwj+Xq6qpevXopPj5eVqvVVr948WJdvXpV3bp107x589SyZUuHG+xChQpp8ODB2r9/v3bv3v23xu3r66usrCwtX77cLu6bGWf9+vU6ffp0vvplZmYqIyPDrgAAAACAUSQS8I8WERGho0eP6ttvv7XVxcXFqWPHjrJYLDp06JCqV6/utG92/aFDhwzPN2vWLJnNZrsyd+7cfMXcsGFDjRo1Sk8//bRKliyp1q1b6+2339Zvv/3m0LZRo0YO82WbOnWqTp8+LV9fX9WuXVt9+/bVV199lef8EyZMkMVisRV/f/98xQ8AAADg3kYiAf9o1apVU6NGjRQbGytJOnLkiDZt2qTIyEhbm1v51f+vunfvrsTERLvSvn37fI/z5ptvKiUlRR988IGCg4P1wQcfqFq1avrpp5/s2i1cuNBhvmw1atTQ3r17tW3bNkVEROj3339Xu3bt9Oyzz+Y698iRI5Wenm4rJ0+ezHf8AAAAAO5dJBLwjxcZGamlS5fq7NmziouLU5UqVdSsWTNJUmBgoA4cOOC0X3Z9YGCg4bksFosCAgLsipeXlySpWLFikqT09HSHfmlpabJYLHZ1Pj4+6ty5syZPnqwDBw6obNmymjx5sl0bf39/h/luVKhQIT300EMaNGiQli1bpvj4eMXExOj48eM5noObm5uKFStmVwAAAADAKBIJ+Mfr0qWLChUqpHnz5mnOnDmKiIiwbZ4YFhamtWvXOuyDcO3aNU2bNk01atQosA0KS5QooZIlS+rHH3+0q8/IyNCRI0dyTVgUKVJEVapUcXhrQ37VqFFDkm55HAAAAADICW9twD+e2WxW165dNXLkSGVkZCg8PNx2bPDgwfr888/Vrl07u9c/jh8/XgcOHNDatWvt3thw8eJFu8cHJMnLy0tVqlSRJF24cEEpKSl2x93c3FS8eHFJ0pAhQzR+/HiVKVNGDRs2VGpqql5//XWVKlVKTz31lCRp1apVWrBggcLCwhQYGCir1aovvvhCX375peLi4uzGTk1NdZjP29tb7u7u6tSpkxo3bqxGjRrJ19dXx48f18iRIxUYGKhq1ard0jUFAAAAgJyQSMC/QmRkpGJiYtSmTRuVLVvWVu/u7q7169dr/PjxGjVqlH755Rd5eXmpefPm2rZtm2rWrGk3zqFDh1SvXj27uscee0xr166VJH388cf6+OOP7Y6HhoZq9erVkqRhw4bJbDbrrbfe0tGjR1WiRAk1btxYGzZskIeHh6TrqwY8PT310ksv6eTJk3Jzc1PVqlX1ySefqGfPnnZjt2jRwuFc58+fr7CwMIWGhmr+/PmaMGGC0tPT5evrq0cffVTjxo2zvVYSAAAAAAqayVqQO9EB+MfJyMiQxWLR2I3H5G72utPhACggI+qVvNMhAACAf5jse4P09PRc91LjZ0sAkqQhdXzYeBEAAABAnthsEQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGEYiAQAAAAAAGOZ6pwMAcHeYujtV7ubLdzoMAAVkRL2SdzoEAADwL8WKBAAAAAAAYBiJBBSI06dPq1+/fipfvrzc3Nzk6+ur0NBQbd682damYsWKMplMDmXixIl2Yy1dulQhISGyWCwym82qXbu2oqOj9eeff9raXLx4UWPHjlVgYKDc3NxUsmRJde7cWfv27bMba9y4cTKZTOrbt69dfWJiokwmk5KSkiRJSUlJdjF5eXkpODhY/fv31+HDh3M87/j4eKfndGPJnuPPP//UoEGDVKFCBRUpUkRly5ZVRESETpw4YTdmSEiIBg0a5HQub29vh3MzmUxycXGRv7+/nnvuObvrBAAAAAAFjUQCCkTHjh21a9cuzZ49W4cOHdLKlSsVEhKi1NRUu3bR0dFKTk62KwMGDLAdHz16tLp27aqHHnpIX331lfbu3aspU6Zo9+7d+vTTTyVJmZmZatGihWJjY/XGG2/o0KFD+vLLL5WVlaUGDRpo27ZtdnO6u7srJiYm14RAtrVr1yo5OVm7d+/W+PHjdeDAAdWpU0fr1q1z2r5r16525/Lwww8rKirKrs7f319//vmnGjZsqLVr1+qDDz7QkSNHtGDBAh05ckQPPfSQjh07lt9LLkkKDg5WcnKyTpw4obi4OK1evVr9+vW7qbEAAAAAwAj2SMAtS0tL06ZNm5SQkKBmzZpJkipUqKD69es7tPXy8pKvr6/TcbZv367x48dr+vTpGjhwoK2+YsWKatmypdLS0iRJ06dP19atW7Vr1y7VqVPHNt/SpUvVoEEDRUZGau/evTKZTJKkoKAglS5dWqNHj9aiRYtyPRcfHx9bfJUrV1a7du302GOPKTIyUkePHpWLi4tdew8PD3l4eNg+FylSRJ6eng7nOHr0aJ06dUpHjhyxHStfvry+/vprVa1aVf3799dXX32Va2zOuLq62sYrV66cOnfurLi4uHyPAwAAAABGsSIBt8xsNstsNmvFihXKzMy86XHmzp0rs9ms559/3unx7GX98+bNU8uWLW1JhGyFChXS4MGDtX//fu3evdvu2MSJE7V06VLt2LEjXzEVKlRIAwcO1C+//KIff/wxX32zXbt2TQsWLFD37t0dEgweHh56/vnn9fXXX9/yIwlJSUn6+uuvVaRIkVzbZWZmKiMjw64AAAAAgFEkEnDLXF1dFR8fr9mzZ8vb21uNGzfWqFGjtGfPHoe2w4cPtyUessumTZskSYcPH1blypVVuHDhXOc7dOiQqlev7vRYdv2hQ4fs6u+//3516dJFw4cPz/f5VatWTZJsex3k1+nTp5WWlpZrzFarVUeOHMn32D/99JPMZrM8PDxUqVIl7du3L89znDBhgiwWi634+/vne14AAAAA9y4SCSgQHTt21KlTp7Ry5Uq1atVKCQkJuv/++xUfH2/XbujQoUpMTLQrDz74oCTJarUani8/bbO98cYb2rRpk7755pt89cueK/tRiZt1MzHnJSgoSImJifrhhx80fPhwhYaG2u054czIkSOVnp5uKydPnizwuAAAAAD8e5FIQIFxd3dXy5Yt9eqrr2rLli0KDw/X2LFj7dqULFlSAQEBdiV7j4HAwEAdO3ZMV65cyXWewMBAHThwwOmx7PrAwECHY1WqVFFUVJRGjBiRr5v67DErVapkuM+NSpUqJW9v71xjNplMCggIkCQVK1ZM6enpDu3S0tJksVjs6ooUKaKAgADVrFlTEydOlIuLi1577bVc43Fzc1OxYsXsCgAAAAAYRSIBt02NGjV0/vx5w+2ffvppnTt3TrNmzXJ6PHuzxbCwMK1du9ZhH4Rr165p2rRpqlGjhsP+CdnGjBmjQ4cOacGCBYZiunbtmt59911VqlRJ9erVM3wuNypUqJC6dOmiefPmKSUlxe7YxYsXNWvWLIWGhqpEiRKSrq8y2Llzp8M4O3fudJogudErr7yiyZMn69SpUzcVKwAAAADkhUQCbllqaqoeffRRffbZZ9qzZ4+OHz+uxYsXa9KkSXriiSfs2p49e1YpKSl2JXuzvwYNGmjYsGF66aWXNGzYMG3dulW//PKL1q1bp86dO2v27NmSpMGDB6t+/fpq166dFi9erBMnTuiHH35Qx44ddeDAAcXExOT4GEKZMmU0ZMgQvfvuuzmeS0pKio4dO6aVK1eqRYsW2r59u2JiYhze2JAf48ePl6+vr1q2bKmvvvpKJ0+e1MaNGxUaGqorV67ovffes7Xt16+fDh06pBdffFF79uzRzz//rKlTp2r+/Pl66aWXcp3n4YcfVu3atTV+/PibjhUAAAAAckMiAbfMbDarQYMGmjZtmpo2baqaNWvq1VdfVVRUlGbOnGnXdsyYMfLz87Mrw4YNsx1/6623NG/ePH3//fcKDQ1VcHCwhgwZotq1a6t3796Srj9CsX79evXq1UujRo1SQECAWrVqJRcXF23btk0NGzbMNd6XX35ZZrPZ6bEWLVrIz89PtWrV0ogRI1S9enXt2bNHzZs3v6Vr5OPjo23btql58+bq06ePqlSpoi5duqhKlSr64YcfVLlyZVvbypUra+PGjTp48KBatGihBg0aaNGiRVq8eLFatWqV51yDBw/WJ598wt4HAAAAAG4Lk/V27AAH4B8jIyNDFotFYzcek7vZ606HA6CAjKhX8k6HAAAA/mGy7w3S09Nz3UvN9W+MCcBdbEgdHzZeBAAAAJAnHm0AAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGkUgAAAAAAACGud7pAADcHabuTpW7+fKdDgNAARlRr+SdDgEAAPxLsSIBAAAAAAAYRiIBAAAAAAAYRiIBdwWTyZRrGTdunJKSkmQymZSYmOjQPyQkRIMGDbL77Gycvn375hpHSkqKBgwYoMqVK8vNzU3+/v5q166d1q1bZ2tTsWJF23ienp6qVauWPvnkE4exrl69qmnTpqlWrVpyd3dX8eLF1bp1a23evNnW5uDBgzKZTNq2bZtd34YNG8rd3V2XLl2y1V26dEnu7u6KiYmRJIWHh8tkMmnixIl2fVesWCGTyZTreQIAAADAzSKRgLtCcnKyrUyfPl3FihWzq3v55ZfzPWZUVJTdGMnJyZo0aVKO7ZOSkvTAAw9o/fr1evvtt/XTTz9p9erVat68ufr372/XNjo6WsnJydq7d6969OihqKgoffXVV7bjVqtVYWFhio6O1sCBA3XgwAElJCTI399fISEhWrFihSSpWrVq8vX1VUJCgq3v2bNntXPnTpUqVcouwbB161ZlZmbq0UcftdW5u7vrrbfe0pkzZ/J9fQAAAADgZrDZIu4Kvr6+tv+2WCwymUx2dZL0xx9/5GtMT09PhzFy8/zzz8tkMmn79u0qWrSorT44OFgRERF2bb28vGxjDx8+XJMmTdKaNWvUunVrSdKiRYu0ZMkSrVy5Uu3atbP1++ijj5Samqpnn31WLVu2VNGiRdW8eXMlJCRoxIgRkqTvvvtOgYGBatq0qRISEhQSEiJJSkhIUIUKFVSpUiXbeC1atNCRI0c0YcKEXJMkAAAAAFBQWJEASPrzzz+1evVq9e/f3y6JkM3b29tpv2vXrmnp0qU6c+aMihQpYqufN2+eAgMD7ZII2V566SWlpqZqzZo1kqTmzZvru+++U1ZWliRpw4YNCgkJUbNmzbRhwwZbvw0bNqh58+Z2Y7m4uGj8+PGaMWOGfv31V0PnmpmZqYyMDLsCAAAAAEaRSMA/TqNGjWQ2m+3Kpk2bHNrNmjXLod3cuXOdjnnkyBFZrVZVq1bNUAzDhw+X2WyWm5ubOnXqpOLFi+vZZ5+1HT906JCqV6/utG92/aFDhyRdTyScP39eP/zwg6TrKw+aNWumpk2b6vvvv9elS5d08eJFbd++3SGRIEkdOnRQ3bp1NXbsWEOxT5gwQRaLxVb8/f0N9QMAAAAAiUcb8A+0cOFCh5v07t27O7Tr3r27Ro8ebVdXpkwZp2NardZ8xTB06FCFh4crOTlZQ4cO1fPPP6+AgICbGjMgIED33XefEhISFBwcrF27dqlZs2YqXbq0ypcvr61bt8pqtSozM9NpIkGS3nrrLT366KOG9pIYOXKkhgwZYvuckZFBMgEAAACAYSQS8I/j7+/vcNPu4eHh0M5isTi0y0nVqlVlMpl08OBBQ+1LliypgIAABQQEaPHixapVq5YefPBB1ahRQ5IUGBioAwcOOO2bXR8YGGirCwkJ0YYNG1S7dm1VrVpVpUuXliTb4w1Wq1UBAQE53vA3bdpUoaGhGjlypMLDw3ON3c3NTW5ubobOEwAAAAD+ikcbAEklSpRQaGio3nvvPZ0/f97heFpaWo59/f391bVrV40cOdJWFxYWpsOHD+uLL75waD9lyhT5+PioZcuWtrrmzZtry5YtWrNmjW1zRUm2DRcTEhJyXI2QbeLEifriiy+0devWXNsBAAAAwK0gkYB/rQsXLiglJcWu5PaaxPfee09Xr15V/fr1tXTpUh0+fFgHDhzQu+++q4cffjjXuQYOHKgvvvhCO3bskHQ9kdChQwf17t1bMTExSkpK0p49e9SnTx+tXLlSn3zyid2mjtn7JMTGxqpZs2a2+mbNmun777/PcX+EG9WqVUvdu3fXu+++a+TyAAAAAMBNIZGAf62PP/5Yfn5+dqVbt245tq9cubJ27typ5s2b66WXXlLNmjXVsmVLrVu3Tu+//36uc9WoUUP/+c9/NGbMGEmSyWTSokWLNGrUKE2bNk1BQUFq0qSJfvnlFyUkJOjJJ5+061+pUiVVqFBBZ8+etUsklC9fXmXLltXly5ftVirkJDo6WteuXcuzHQAAAADcLJM1v7vMAfhXycjIkMViUXp6uooVK3anwwEAAABwhxi9N2BFAgAAAAAAMIxEAgAAAAAAMMxwImHRokW6fPmy7fOvv/5q9yz2hQsXNGnSpIKNDgAAAAAA3FUMJxK6detm9wq8GjVqKCkpyfb57Nmzdq+/AwAAAAAA/z6GEwl/3ZORPRoBAAAAALj3sEcCAAAAAAAwjEQCAAAAAAAwzDU/jb/++mtZLBZJ0rVr17Ru3Trt3btXkuz2TwAAAAAAAP9OJqvBzQ4KFcp78YLJZNLVq1dvOSgAf5+MjAxZLBalp6erWLFidzocAAAAAHeI0XsDwysSbnzVIwAAAAAAuDcV6B4JFy9eLMjhAAAAAADAXaZAEgmZmZmaMmWKKlWqVBDDAQAAAACAu5ThREJmZqZGjhypBx98UI0aNdKKFSskSXFxcapUqZKmT5+uwYMH3644AQAAAADAXcDwHgljxozRhx9+qBYtWmjLli3q3LmznnnmGW3btk1Tp05V586d5eLicjtjvWMuXryoli1bKioqSr17977t8129elWRkZHy8fHRlClTbvt8gCRN3Z0qd/PlOx0GgAIyol7JOx0CAAD4lzK8ImHx4sWaM2eOlixZom+++UZXr15VVlaWdu/erbCwsH9tEkGSduzYoZEjR/4tSQRJcnFxUVxcnCpXrqz//e9/f8ucAAAAAAAYYfj1j0WKFNHx48dVrlw5SZKHh4e2b9+uWrVq3dYAAdxe2a94GbvxmNzNXnc6HAAFhBUJAAAgv4y+/tHwioSrV6+qSJEits+urq4ym823FGR4eLiefPLJHI9XrFhRJpPJoUycONGhbVJSktO2N5b4+HglJCTIZDIpLS3N6XzTp0/P9/yzZ8/WQw89JE9PT3l5ealZs2ZatWqVXZvsebNLqVKl1KZNG/30008O18TZnK1atXKIa8GCBQ7nEBwcbDvXm7mO2UJCQmzt3NzcVK5cObVr107Lli1zaJvT9XYW382eQ7YJEybIxcVFb7/9tsOx+Ph429yFChWSn5+funbtqhMnTji0PXLkiCIiIlS+fHnb+T322GOaO3eusrKyJP3f31RiYqLT6zNo0CCH88npGv/177NEiRJq1qyZNm3aZDfuuHHjVLdu3VzHzC7h4eGSbu76AwAAAMDNMrxHgtVqVXh4uNzc3CRJly5dUt++fVW0aFG7ds5uNG9FdHS0oqKi7Oq8vBx/NfX391dycrLt8+TJk7V69WqtXbvWVmexWPT9998X6Pwvv/yyZs6cqTfeeENPPvmkrly5os8++0xPPPGE3nnnHb3wwgt2fX/++WcVK1ZMp06d0tChQ9W2bVsdOXLELknTqlUrxcXF2fXLvu43nm9cXJzCwsJsddu2bVNKSorDd2LkPJyJiopSdHS0srKy9Ouvv2r58uUKCwtTeHi4PvroI7u2cXFxdskOSfL29s51/PyegyTFxsZq2LBhio2N1dChQx2OFytWTD///LOsVquOHz+u559/Xp07d7b73rdv364WLVooODhY7733nqpVqybp+iMs7733nmrWrKk6derkGrszRq7x2rVrFRwcrD/++ENvvvmmHn/8cR06dEhlypRxGO+HH37Q1atXJUlbtmxRx44dbX8/0vVVQdlu5voDAAAAwM0wnEjo1auXTCaT7XOPHj1uS0B/5eXlJV9f3zzbubi42LUzm81ydXU11Pdm59+2bZumTJmid999VwMGDLDVv/nmm7p06ZKGDBmiJ554Qv7+/rZjpUuXlre3t3x9fTVo0CC1b99eBw8eVO3atW1t3Nzc8oy7e/fumjZtmk6ePGkbPzY2Vt27d9ecOXPydR458fT0tPW577771LBhQ1WrVk0RERHq0qWLWrRoYWubfU75kd9z+Pbbb3Xx4kVFR0drzpw52rJlixo1amTXxmQy2eLw8/NTZGSkXnzxRWVkZKhYsWK2hFhgYKA2b96sQoX+b1FO1apV1a1bNxl82seBkWvs4+MjX19f+fr6atSoUVqwYIG+//57tW/f3qFtqVKlbP9dokQJSf/39/NXN3P9AQAAAOBmGE4kOFtmfq+bP3++zGaz+vTp43DspZde0tSpU7V06VK7JfDZ0tPTbUvPb1yNYFSZMmUUGhqq2bNn65VXXtGFCxe0cOFCffvtt05vwgtK79699dJLL2nZsmV2iYSbkd9ziImJUbdu3VS4cGF169ZNMTExDomEG/3+++9avny5XFxcbJuBJiYm6sCBA5o/f75dEuFGNybMbpeLFy/azvFmvv9bkZmZqczMTNvnjIyMv3V+AAAAAP9shvdIcHFx0e+//347Y3Fq+PDhMpvNduWvz5XfjPvuu89hXGfP0uc2/6FDh1SlShWnN4Jly5ZVsWLFdOjQIafzent7a968eWrfvr1taX22VatWOcw5fvx4hzkiIiIUHx8vq9WqJUuWqEqVKrbn6/NzHvlRqFAhBQYGKikpya6+W7duhq7nzZ5DRkaGlixZYlsJ06NHDy1atEjnzp2za5eeni6z2ayiRYuqTJky2rBhg/r37297VCL7+wgKCrL1+f333+3injVrVn4uiY2Ra9yoUSNbfJMnT9YDDzygxx577Kbmu1F+rv+ECRNksVhs5cYVMwAAAACQl3ztkXAnDB061LapXLbsN0fcik2bNjk8vx4SEpLv+fN7XTZt2iRPT09t27ZN48eP1wcffODQpnnz5nr//fft6rKXtt+obdu26tOnjzZu3KjY2FhFRETkOG9BXker1erwq/20adMcViiULVs2z7GMnsP8+fNVpUoV294FdevWVYUKFbRw4UJFRkba2nl5eWnnzp26cuWKvvrqK82dO1dvvvlmrjH4+PjYNlQMCQnR5cuX84zbGSPXeOHChapWrZr27t2rYcOGKT4+XoULF76p+W6Un+s/cuRIDRkyxPY5IyODZAIAAAAAwwwnEu6UkiVLKiAgoMDHrVSpksOz5q6ujpcjt/kDAwP13Xff6fLlyw6rEk6dOqWMjAwFBgY6nTcoKEi///67unbtqo0bN9q1KVq0qKFzdnV1Vc+ePTV27Fh9//33Wr58eY5tC+o6Xr16VYcPH9ZDDz1kV+/r63tT4xs9h5iYGO3bt8/uO7p27ZpiY2PtEgmFChWyxVG9enUdPXpU/fr106effirp+j4I0vVNL+vVqyfp+mqb7D43jp+9qWF6erpDPGlpabJYLHZ1Rq6xv7+/qlatqqpVqyorK0sdOnTQ3r17HTbTzK/8XH83N7dbng8AAADAvcvwow2S9Mknn+jdd9/NtdxLwsLCdO7cOX344YcOxyZPnqzChQurY8eOOfbv37+/9u7dm2sCIC8RERH69ttv9cQTT6h48eI3PY5Rs2fP1pkzZ3I9r/zK6xx++ukn7dixQwkJCUpMTLSVhIQEbd26VQcPHsxx7BEjRmjhwoXauXOnJKlevXqqVq2aJk+erGvXruUaV4kSJVSyZEn9+OOPdvUZGRk6cuSIQ5Iovzp16iRXV9ebfpQCAAAAAO6EfK1I+OCDD2yb1jljMpn04osv5iuA9PR027LybD4+Pral1mfPnlVKSordcU9PT9uvxbdbbvM//PDDGjhwoIYOHarLly/bvf7xnXfe0fTp03NdMu7p6amoqCiNHTtWTz75pO1xgczMTIc5XV1dVbJkSYcxqlevrj/++EOenp43fR45uXDhglJSUuxe/zht2jT169dPzZs3t2ublpbmML6Xl1eOr3HMzznExMSofv36atq0qcOxhx56SDExMXr77bed9vX391eHDh00ZswYrVq1SiaTSXFxcWrZsqUaN26skSNHqnr16rpy5Yo2btyo06dP2/2NDxkyROPHj1eZMmXUsGFDpaam6vXXX1epUqX01FNP2c2V32uc/e9l3Lhx6tOnT57fYW5u5foDAAAAQH7ka0XCjh07dPz48RzLsWPH8h1AQkKC6tWrZ1dee+012/ExY8bIz8/PrgwbNizf89ysvOafPn26Zs2apfnz56tmzZp68MEHtXHjRq1YscLulZA5eeGFF3TgwAEtXrzYVrd69WqHOR955JEcx/Dx8ZGHh8ctnYczH3/8sfz8/FSlShU99dRT2r9/vxYuXOj0F/RnnnnGYfwZM2bkcfZ5n8Ply5f12Wef5bgComPHjpozZ46uXLmS49iDBw/Wf//7X23fvl2S1LBhQ/34448KCgpS//79VaNGDTVq1Ejz58+3JUqyDRs2TGPHjtVbb72l2rVrq2PHjipatKg2bNjgEO/NXOPevXvrypUrmjlzZq7t8nKr1x8AAAAAjDJZDe4W6OLiouTkZJUuXfp2xwTgb5SRkSGLxaKxG4/J3eyVdwcA/wgj6jmuYgMAAMhN9r1Benp6rqvX7/q3NgD4ewyp4/O3PTIEAAAA4J/L8KMNY8eOldlsvp2xAAAAAACAu5zhFQkdOnTQkSNH8mxXu3btWwoIAAAAAADcvQwnEurWrSuTyeT0EYfsepPJpKtXrxZogAAAAAAA4O5hOJFw/Pjx2xkHAAAAAAD4BzCcSJg9e7ZefvnlW3rXPQAAAAAA+GczvNnia6+9pnPnzt3OWAAAAAAAwF3OcCKB1z8CAAAAAADDiQTp+qaKAAAAAADg3mV4jwRJCgwMzDOZ8Oeff95SQAAAAAAA4O6Vr0TCa6+9JovFcrtiAQAAAAAAd7l8JRLCwsJUunTp2xULAAAAAAC4yxneI4H9EQAAAAAAgOEVCby1Afh3m7o7Ve7my3c6DAAFZES9knc6BAAA8C9lOJFw7dq12xkHAAAAAAD4B8jX6x8BAAAAAMC9jUTCTdq6datcXFzUtm1bh2NJSUkymUwqXbq0zp49a3esbt26GjdunEOf+fPny8XFRf3797fVhYSEyGQy5VhCQkJsbbds2aI2bdqoePHicnd3V61atTR16lRdvXrVbp7svtu2bbOrz8zMlI+Pj0wmkxISEuzar1ixwqH/X8uCBQtyvFYVK1a0tfPw8FDFihXVpUsXrV+/3ul1yxYfHy9vb2+nY94YV36ud07XtG/fvjnGL0kpKSkaMGCAKleuLDc3N/n7+6tdu3Zat26d3XlOnz7doe+4ceNUt25d2+fw8HA9+eSTDu0SEhJkMpmUlpZm+Lu/8dreWCZOnJjr+QAAAADAzSKRcJNiYmI0YMAAbdy4UadOnXLa5uzZs5o8ebLh8YYNG6b58+fr0qVLkqRly5YpOTlZycnJ2r59uyRp7dq1trply5ZJkpYvX65mzZrpvvvu04YNG3Tw4EENHDhQb7zxhsLCwhz2t/D391dcXJxd3fLly2U2mw3FGhcXZ4shuzi7Mb5RdHS0kpOT9fPPP2vOnDny9vZWixYt9Oabbxqa0wij1zsqKsoh/kmTJuXYPikpSQ888IDWr1+vt99+Wz/99JNWr16t5s2b2yV+CpLR7176v2t7YxkwYMBtiQsAAAAA8vX6R1x37tw5LVy4UDt27FBKSori4+M1atQoh3YDBgzQ1KlT1b9//1xfm3n8+HFt2bJFS5cu1YYNG7Rs2TI9/fTTKlGihK1NdnLBx8dHvr6+tvrz588rKipK7du310cffWSrf/bZZ1WmTBm1b99eixYtUteuXW3HevfurXfffVfTp0+Xh4eHJCk2Nla9e/fW66+/nuf5e3t728VghJeXl61P+fLl1bRpU/n5+WnMmDHq1KmTgoKC8jWeM0avt6enZ77if/7552UymbR9+3YVLVrUVh8cHKyIiIhbijknRr77bDdeWwAAAAC43ViRcBMWLVqkatWqKSgoSD169FBsbKzTt1p069ZNAQEBio6OznW8uLg4tW3bVhaLRT169FBMTIzhWL755hulpqbq5ZdfdjjWrl07BQYGav78+Xb1DzzwgCpWrKilS5dKkk6cOKGNGzeqZ8+ehuctCAMHDpTVatXnn39eIOMZvd758eeff2r16tXq37+/XRIhW06PXtzNMjMzlZGRYVcAAAAAwCgSCTchJiZGPXr0kCS1atVK6enp+vbbbx3aZT+r/tFHH+no0aNOx7p27Zri4+Nt44WFhem7777T8ePHDcVy6NAhSVL16tWdHq9WrZqtzY0iIiIUGxsr6fpeBG3atFGpUqUMzdmtWzeZzWa7cuLECUN9b1SiRAmVLl1aSUlJkq4/738rrxk1cr0ladasWQ7xz50712nbI0eOyGq1qlq1aoZiGD58uMPY48ePv6nzMcrZnJs2bcqx/YQJE2SxWGzF39//tsYHAAAA4N+FREI+/fzzz9q+fbu6desmSXJ1dVXXrl1zXEUQGhqqRx55RK+++qrT42vWrNH58+fVpk0bSVLJkiXVsmVL202+Ufm9Ae/Ro4e2bt2qY8eOKT4+Pl9L9KdNm6bExES7UrZs2XzNn81qtdptsHir8rrektS9e3eH+Nu3b59jfPkxdOhQh7Hz2sjxVjmb88EHH8yx/ciRI5Wenm4rJ0+evK3xAQAAAPh3YY+EfIqJiVFWVpbdjbPVapWbm5tmzpwpi8Xi0GfixIl6+OGHNXToUKfj/fnnn7a9CqTrqxT27Nmj1157TYUK5Z7rCQwMlCQdOHBAjRo1cjh+4MAB1ahRw6Hex8dHjz/+uCIjI3Xp0iW1bt3a4Y0HOfH19VVAQIChtrlJTU3V6dOnValSJafHixUrpvPnz+vatWt21yEtLU2SnF5rKffrnd3PaPxVq1aVyWTSwYMHDbUvWbKkw9g37ncgXT+vX375xaFvWlqaXFxcnD5Ckd85c+Pm5iY3N7d8zQEAAAAA2ViRkA9ZWVmaM2eOpkyZYvfr7+7du1W2bFmHvQiy1a9fX0899ZRGjBhhV5+amqrPP/9cCxYssBtv165dOnPmjL755ps8Y/rPf/6jEiVKaMqUKQ7HVq5cqcOHD9tWT/xVRESEEhIS1KtXL7m4uBi4AgXrnXfeUaFChXJ840NQUJCysrKUmJhoV79z505J/5dE+aucrvfNKFGihEJDQ/Xee+/p/PnzDsezkxr5ERQUpH379ikzM9OufufOnapUqZIKFy58s+ECAAAAwG3HioR8WLVqlc6cOaPIyEiHX8M7duyomJiYHJexv/nmmwoODpar6/9d8k8//VQ+Pj7q0qWLw/L+Nm3aKCYmRq1atco1pqJFi+rDDz9UWFiYnnvuOb3wwgsqVqyY1q1bp6FDh6pTp07q0qWL076tWrXS6dOnVaxYMSOnb5OWlqaUlBS7Oi8vr1x/ST979qxSUlJ05coVHT9+XJ999pk++eQTTZgwIcdf04ODg/Wf//xHERERmjJliipXrqyff/5ZgwYNUteuXVWuXLkc53N2vbNduHDBIX43NzcVL17c6VjvvfeeGjdurPr16ys6Olq1a9dWVlaW1qxZo/fff18HDhzIMQ5nunfvrujoaPXq1UvDhg2TxWLRxo0bNX369FxfQ5mT7Gt7I09Pz3x/rwAAAABgBCsS8iEmJkYtWrRwuqS+Y8eO2rFjh/bs2eO0b2BgoCIiImyv8pOuv3KxQ4cOTvcI6Nixo1auXKk//vgjz7g6deqkDRs26MSJE2rSpImCgoI0bdo0jR49WgsWLMhxDwKTyaSSJUuqSJEiec5xo2eeeUZ+fn52ZcaMGbn2GTNmjPz8/BQQEKCePXsqPT1d69at0/Dhw3Ptt3DhQjVr1kx9+vRRcHCwXnzxRT3xxBP65JNPcu3n7Hpn+/jjjx3iz2nVhiRVrlxZO3fuVPPmzfXSSy+pZs2aatmypdatW6f3338/1zic8fb21qZNm3TlyhW1b99edevW1bvvvqupU6eqT58++R4v+9reWIYNG5bvcQAAAADACJP1VrbJB/CPl5GRIYvForEbj8nd7HWnwwFQQEbUK3mnQwAAAP8w2fcG6enpua5w5tEGAJKkIXV8eBwCAAAAQJ54tAEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABjmeqcDAHB3mLo7Ve7my3c6DAAFZES9knc6BAAA8C/FigQAAAAAAGAYiQQAAAAAAGAYiYQ8hIeH68knn8zxeMWKFWUymRzKxIkTc+wTEhKiQYMG5XjcZDJpxYoV+u2331S4cGEtWLDAabvIyEjdf//9kqRx48bZ5nZxcZG/v7+ee+45/fnnnwUSb3Y7Nzc3lStXTu3atdOyZcucxu6s3HgOH3/8serUqSOz2Sxvb2/Vq1dPEyZMyHF+SVq+fLkaNmwoi8UiLy8vBQcHO1zDixcvauzYsQoMDJSbm5tKliypzp07a9++fXbtxo0bp7p16zqdJ6fvOyEhQSaTSWlpaXbXw1kJCQmRdP1aT58+3W6cLVu2qE2bNipevLjc3d1Vq1YtTZ06VVevXnW4ju7u7vrll1/s6p988kmFh4fbPp8+fVr9+vVT+fLl5ebmJl9fX4WGhmrz5s05XksAAAAAuBXskVAAoqOjFRUVZVfn5eV1y+OWKVNGbdu2VWxsrMLCwuyOnT9/XosWLbJLAAQHB2vt2rW6evWqDhw4oIiICKWnp2vhwoW3HG9UVJSio6OVlZWlX3/9VcuXL1dYWJjCw8P10Ucf2bWNi4tTq1at7Oq8vb0lSbGxsRo0aJDeffddNWvWTJmZmdqzZ4/27t2b49zr1q1T165d9eabb6p9+/YymUzav3+/1qxZY2uTmZmpFi1a6MSJE5oyZYoaNGig3377TRMmTFCDBg20du1aNWzYMNdzNGrZsmW6fPn6XgInT55U/fr1tXbtWgUHB0uSihQp4rTf8uXL1aVLFz3zzDPasGGDvL29tXbtWg0bNkxbt27VokWLZDKZbO1NJpPGjBmj2bNn5xhLx44ddfnyZc2ePVuVK1fWb7/9pnXr1ik1NbVAzhUAAAAA/opEQgHw8vKSr6/vbRk7MjJSTz75pE6cOKHy5cvb6hcvXqysrCx1797dVufq6mqLo1y5curcubPi4uIKJF5PT09bn/vuu08NGzZUtWrVFBERoS5duqhFixa2tt7e3jmOv3LlSnXp0kWRkZG2uuwb8Jx88cUXaty4sYYOHWqrCwwMtFs5MH36dG3dulW7du1SnTp1JEkVKlTQ0qVL1aBBA0VGRmrv3r12N+o3q0SJErb/vnTpkiTJx8cn12t6/vx5RUVFqX379naJl2effVZlypRR+/bttWjRInXt2tV27IUXXtDUqVM1dOhQ1axZ02HMtLQ0bdq0SQkJCWrWrJntnOvXr3/L5wgAAAAAOeHRhrtcmzZtVKZMGcXHx9vVx8XF6amnnrL90v9XSUlJ+vrrr3P8dbwg9O7dW8WLF3f6iENOfH19tW3bNocl+3n12bdvX66rFubNm6eWLVvakgjZChUqpMGDB2v//v3avXu34TkL2jfffKPU1FS9/PLLDsfatWunwMBAzZ8/366+cePGevzxxzVixAinY5rNZpnNZq1YsUKZmZmGY8nMzFRGRoZdAQAAAACjSCQUgOHDh9tu6rLLpk2bCmRsFxcX9e7dW/Hx8bJarZKko0ePatOmTYqIiLBr+9NPP8lsNsvDw0OVKlXSvn37NHz48NsWb6FChRQYGKikpCS7+m7dujmMf+LECUnS2LFj5e3trYoVKyooKEjh4eFatGiRrl27luM8AwYM0EMPPaRatWqpYsWKCgsLU2xsrN3N86FDh1S9enWn/bPrDx06lO9zLCjZc+cUY7Vq1ZzGN2HCBK1evdrp9+Pq6qr4+HjNnj1b3t7eaty4sUaNGqU9e/bkGsuECRNksVhsxd/f/ybOCAAAAMC9ikRCARg6dKgSExPtyoMPPlhg40dEROj48ePasGGDpOurESpWrKhHH33Url1QUJASExP1ww8/aPjw4QoNDdWAAQNua7xWq9XhcYFp06Y5jF+2bFlJkp+fn7Zu3aqffvpJAwcOVFZWlnr37q1WrVrlmEwoWrSo/vvf/+rIkSN65ZVXZDab9dJLL6l+/fq6cOGCXSx3u/zGWKNGDfXq1SvHVQkdO3bUqVOntHLlSrVq1UoJCQm6//77HVaw3GjkyJFKT0+3lZMnT+YrJgAAAAD3NhIJBaBkyZIKCAiwKx4eHgU2ftWqVdWkSRPFxcXp2rVrmjNnjp555hmHG/giRYooICBANWvW1MSJE+Xi4qLXXnvttsV79epVHT58WJUqVbKr9/X1dRjf1dV+O46aNWvq+eef12effaY1a9ZozZo1+vbbb3Odr0qVKnr22Wf1ySefaOfOndq/f79tI8nAwEAdOHDAab/s+sDAwDzPqVixYkpPT3eoT0tLk4uLi4oWLZrnGM5kz51bjDnF99prr2nnzp1asWKF0+Pu7u5q2bKlXn31VW3ZskXh4eEaO3ZsjrG4ubmpWLFidgUAAAAAjCKR8A8RGRmppUuXaunSpfrf//5n9wrAnLzyyiuaPHmyTp06dVtimj17ts6cOaOOHTve0jg1atSQdH1DQqMqVqwoT09PW5+wsDCtXbvWYR+Ea9euadq0aapRo4bD/gnOBAUFad++fQ57DuzcuVOVKlVS4cKFDcd4o//85z8qUaKEpkyZ4nBs5cqVOnz4sLp16+a0r7+/v1544QWNGjXK4TWRztSoUSNf1xIAAAAA8oO3NhiQnp6uxMREuzofHx/bs+Vnz55VSkqK3XFPT89cf+k9ffq0w5h+fn4qU6aM0/adO3fWiy++qD59+ug///mPoefaH374YdWuXVvjx4/XzJkzbfU3E++FCxeUkpJi9/rHadOmqV+/fmrevLld27S0NIfxvby8VLRoUfXr109ly5bVo48+qvvuu0/Jycl64403VKpUKT388MNO5x43bpwuXLigNm3aqEKFCkpLS9O7776rK1euqGXLlpKkwYMH6/PPP1e7du3sXv84fvx4HThwQGvXrrVbwXHx4kWH6+/l5aXu3bsrOjpavXr10rBhw2SxWLRx40ZNnz5dkyZNyvli56Fo0aL68MMPFRYWpueee04vvPCCihUrpnXr1mno0KHq1KmTunTpkmP/kSNH6uOPP9bx48dtb3ZITU1V586dFRERodq1a8vLy0s7duzQpEmT9MQTT9x0rAAAAACQG1YkGJCQkKB69erZlRsfGRgzZoz8/PzsyrBhw3Idc968eQ5jfvzxxzm29/T0VFhYmM6cOeOwyWJuBg8erE8++cTuOfibiffjjz+Wn5+fqlSpoqeeesr2WMGsWbMc2j7zzDMO48+YMUOS1KJFC23btk2dO3dWYGCgOnbsKHd3d61bt04+Pj5O527WrJmOHTumXr16qVq1amrdurVSUlL0zTffKCgoSNL15f3r169Xr169NGrUKAUEBKhVq1ZycXHRtm3b1LBhQ7sxDx065HD9+/TpI29vb23atElXrlxR+/btVbduXb377ruaOnWq+vTpY/i6O9OpUydt2LBBJ06cUJMmTRQUFKRp06Zp9OjRWrBgQa6vpixRooSGDx9ue92kdP2tDQ0aNNC0adPUtGlT1axZU6+++qqioqLsEkcAAAAAUJBM1n/CDnUAbpuMjAxZLBaN3XhM7mavOx0OgAIyol7JOx0CAAD4h8m+N0hPT891xTqPNgCQJA2p48PGiwAAAADyxKMNAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMBIJAAAAAADAMNc7HQD+PT7++GN9+umn+uabb+Tu7n6nw0E+Td2dKnfz5TsdBoACMqJeyTsdAgAA+JcikYACExUVJV9fX/34449q3LjxnQ4HAAAAAHAbkEhAgWrXrt2dDgEAAAAAcBuxRwIKzNatW+Xi4qK2bdsaah8SEiKTySSTySR3d3fVqFFDs2bNsh2Pj4+Xt7d3jv3Dw8Nt/W8srVq1srWpWLGipk+fbvfZZDJp27ZtdmMNGjRIISEhTucZN26c03luLPmJx2QyacGCBQ7zBAcHy2QyKT4+3qG9yWRS0aJFdf/992vx4sW24xcuXNDIkSNVpUoVubu7q1SpUmrWrJk+//zzHK8bAAAAANwKEgkoMDExMRowYIA2btyoU6dOGeoTFRWl5ORk7d+/X126dFH//v01f/58w3O2atVKycnJdiWv/u7u7ho+fLjhOV5++WW78e+77z5FR0fb1eUnHn9/f8XFxdnVbdu2TSkpKSpatKjD/Nlz7dq1Sw899JC6du2qLVu2SJL69u2rZcuWacaMGTp48KBWr16tTp06KTU11fD5AQAAAEB+kEhAgTh37pwWLlyofv36qW3btna/qufG09NTvr6+qly5ssaNG6eqVatq5cqVhud1c3OTr6+vXSlevHiufZ577jlt27ZNX375paE5zGaz3fguLi7y8vKyq8tPPN27d9e3336rkydP2upiY2PVvXt3ubo6Pm2UPVdgYKDee+89eXh46IsvvpAkrVy5UqNGjVKbNm1UsWJFPfDAAxowYIAiIiIMnRsAAAAA5BeJBBSIRYsWqVq1agoKClKPHj0UGxsrq9Wa73E8PDx0+fLtfXNApUqV1LdvX40cOVLXrl27rXM5U6ZMGYWGhmr27NmSrj+esHDhQkM3/66uripcuLDtGvn6+urLL7/U2bNnDc+fmZmpjIwMuwIAAAAARpFIQIGIiYlRjx49JF1f3p+enq5vv/3WcP+rV6/qs88+0549e/Too48a7rdq1SqZzWa7Mn78+Dz7vfLKKzp+/Ljmzp1reK6CjCciIkLx8fGyWq1asmSJqlSporp16+Y69uXLlzVhwgSlp6fbrtFHH32kLVu2yMfHRw899JAGDx6szZs35zrOhAkTZLFYbMXf3/+mzxcAAADAvYdEAm7Zzz//rO3bt6tbt26Srv9q3rVrV8XExOTZd9asWTKbzfLw8FBUVJQGDx6sfv36GZ67efPmSkxMtCt9+/bNs1+pUqX08ssva8yYMQW6AsJoPG3bttW5c+e0ceNGxcbG5roaYfjw4TKbzfL09NRbb72liRMn2ja0bNq0qY4dO6Z169apU6dO2rdvn5o0aaLXX389x/FGjhyp9PR0W7nxEQsAAAAAyAuvf8Qti4mJUVZWlsqWLWurs1qtcnNz08yZM2WxWHLs2717d40ePVoeHh7y8/NToUL5y20VLVpUAQEBNxX3kCFDNGvWLLs3Rdwqo/G4urqqZ8+eGjt2rL7//nstX748x7ZDhw5VeHi4zGazypQpY3tLRLbChQurSZMmatKkiYYPH6433nhD0dHRGj58uIoUKeIwnpubm9zc3PJ/cgAAAAAgViTgFmVlZWnOnDmaMmWK3a/wu3fvVtmyZfN8g4LFYlFAQIDKlSuX7yTCrTKbzXr11Vf15ptv5muPgYISERGhb7/9Vk888USuG0SWLFlSAQEB8vX1dUgiOFOjRg1lZWXp0qVLBRkuAAAAAEhiRQJu0apVq3TmzBlFRkY6rDzo2LGjYmJiDD1qkJOrV68qMTHRrs7NzU3Vq1eXdH3jwJSUFLvjrq6uKlmypKHxn3vuOU2bNk3z5s1TgwYNbjrObPmJp3r16vrjjz/k6el50/OFhISoW7duevDBB+Xj46P9+/dr1KhRat68uYoVK3bT4wIAAABATkgk4JbExMSoRYsWTh9f6NixoyZNmqQ9e/aodu3aNzX+uXPnVK9ePbu6KlWq6MiRI5Kk1atXy8/Pz+54UFCQDh48aGj8woUL6/XXX9fTTz99U/H9VX7j8fHxuaX5st/+MGrUKF24cEFly5bV448/rjFjxtzSuAAAAACQE5P1Zt7RB+BfIyMjQxaLRWM3HpO72etOhwOggIyoZ2xlFgAAQLbse4P09PRcVzizIgGAJGlIHR8ehwAAAACQJzZbBAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhpFIAAAAAAAAhrne6QAA3B2m7k6Vu/nynQ4DQAEZUa/knQ4BAAD8S7EiAQAAAAAAGEYiAQAAAAAAGEYiAbddeHi4TCaTTCaTChcurEqVKmnYsGG6dOmSXbvsNn8tCxYs0NKlS+Xi4qL//e9/TueoWrWqhgwZYvu8atUqNWvWTF5eXvL09NRDDz2k+Ph4uz5JSUkymUxKTEy0+5xdSpQooWbNmmnTpk25nt9f+/n4+Og///mPdu3aZddu69atcnFxUdu2bfMcI6e5x40bp7p169o+X7hwQSNHjlSVKlXk7u6uUqVKqVmzZvr8889zjRkAAAAAbhaJBPwtWrVqpeTkZB07dkzTpk3Thx9+qLFjxzq0i4uLU3Jysl158skn1b59e/n4+Gj27NkOfTZu3KgjR44oMjJSkjRjxgw98cQTaty4sb7//nvt2bNHYWFh6tu3r15++eU8Y127dq2Sk5O1ceNGlS1bVo8//rh+++03w/2+/vprnTt3Tq1bt1ZaWprteExMjAYMGKCNGzfq1KlTBTJ33759tWzZMs2YMUMHDx7U6tWr1alTJ6WmpuYZLwAAAADcDBIJ+Fu4ubnJ19dX/v7+evLJJ9WiRQutWbPGoZ23t7d8fX3tiru7uwoXLqyePXs6rCqQpNjYWDVo0EDBwcE6efKkXnrpJQ0aNEjjx49XjRo1FBAQoJdeeklvv/22pkyZou+//z7XWH18fOTr66uaNWtq1KhRysjIyLPPjf0efPBBTZ48Wb/99put37lz57Rw4UL169dPbdu2dXoeNzP3ypUrNWrUKLVp00YVK1bUAw88oAEDBigiIiLHPpmZmcrIyLArAAAAAGAUiQT87fbu3astW7aoSJEi+eoXGRmpw4cPa+PGjba6c+fOacmSJbbVCEuWLNGVK1ecrjzo06ePzGaz5s+fb2i+ixcvas6cOZKU71g9PDwkSZcvX38LwqJFi1StWjUFBQWpR48eio2NldVqveW5fX199eWXX+rs2bOGY5swYYIsFout+Pv7G+4LAAAAALz+EX+LVatWyWw2KysrS5mZmSpUqJBmzpzp0K5bt25ycXGxq9u/f7/Kly+vGjVqqGHDhoqNjVXTpk0lXb9Bt1qtCgsLkyQdOnRIFotFfn5+DmMXKVJElStX1qFDh3KNtVGjRipUqJAuXLggq9WqBx54QI899pjhc01LS9Prr78us9ms+vXrS7r+WEOPHj0kXX/MIz09Xd9++61CQkJuae6PPvpI3bt3l4+Pj+rUqaNHHnlEnTp1UuPGjXPsM3LkSLv9JDIyMkgmAAAAADCMFQn4WzRv3lyJiYn6/vvv1bt3bz3zzDPq2LGjQ7tp06YpMTHRrpQtW9Z2PCIiQkuWLLH9Ah8bG6vOnTvLy8urwGJduHChdu3apaVLlyogIEDx8fEqXLhwnv0aNWoks9ms4sWLa/fu3Vq4cKHKlCmjn3/+Wdu3b1e3bt0kSa6ururatatiYmJuee6mTZvq2LFjWrdunTp16qR9+/apSZMmev3113Ps4+bmpmLFitkVAAAAADCKFQn4WxQtWlQBAQGSrt/816lTRzExMbZHErL5+vra2jkTFhamwYMHa9GiRWratKk2b96sCRMm2I4HBgYqPT1dp06dsktASNcfMzh69KiaN2+ea6z+/v6qWrWqqlatqqysLHXo0EF79+6Vm5tbrv0WLlyoGjVqyMfHR97e3rb6mJgYZWVl2cVjtVrl5uammTNnymKx3NLchQsXVpMmTdSkSRMNHz5cb7zxhqKjozV8+PB8P5IBAAAAAHlhRQL+doUKFdKoUaP0yiuv6OLFi/nq6+Xlpc6dOys2NlZxcXEKDAxUkyZNbMc7duyowoULa8qUKQ59P/jgA50/f962MsCITp06ydXVVbNmzcqzrb+/v6pUqWKXRMjKytKcOXM0ZcoUu1UWu3fvVtmyZXPdryE/c9+oRo0aysrKcni9JgAAAAAUBBIJuCM6d+4sFxcXvffee3b1aWlpSklJsSvnz5+3axMZGaktW7bogw8+cHg7Qfny5TVp0iRNnz5do0eP1sGDB3X06FFNnTpVw4YN00svvaQGDRoYjtNkMunFF1/UxIkTdeHChXyf56pVq3TmzBlFRkaqZs2adqVjx45OH2/Iz9whISH68MMP9eOPPyopKUlffvmlRo0apebNm/PIAgAAAIDbgkQC7ghXV1e98MILmjRpkl2i4JlnnpGfn59dmTFjhl3fRx55REFBQcrIyFCvXr0cxh40aJCWL1+uTZs26cEHH1TNmjU1b948vf/++5o8eXK+Y+3du7euXLnidHPIvMTExKhFixZ2jy9k69ixo3bs2KE9e/bc9NyhoaGaPXu2/vOf/6h69eoaMGCAQkNDtWjRonzHCgAAAABGmKy5vYMOwL9eRkaGLBaL0tPTWcUAAAAA3MOM3huwIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABhGIgEAAAAAABjmeqcDAHB3mLo7Ve7my3c6DAAFZES9knc6BAAA8C/FigQAAAAAAGAYiQQAAAAAAGAYiYTbKDw8XCaTSSaTSYULF1aZMmXUsmVLxcbG6tq1a3ZtK1asqISEBIcx+vTpIxcXFy1evNjh2Lhx42zju7i4yN/fX88995z+/PNPh7a7du1S165d5efnJzc3N1WoUEGPP/64vvjiC1mtVklSUlKSbby/lm3btkmS4uPjZTKZ1KpVK7vx09LSZDKZlJCQYGuTW0lKSnKIMa/5Q0JCch0zJCTE6fdw43VydXVVyZIl1bRpU02fPl2ZmZl2bXOao2/fvk7HlqTTp0+rX79+Kl++vNzc3OTr66vQ0FBt3rzZoe3WrVvl4uKitm3b5nj+pUuX1tmzZ+2O1a1bV+PGjbOrO3LkiCIiImzzlitXTo899pjmzp2rrKysHOMFAAAAgFtBIuE2a9WqlZKTk5WUlKSvvvpKzZs318CBA/X444/nebN34cIFLViwQMOGDVNsbKzTNsHBwUpOTtaJEycUFxen1atXq1+/fnZtPv/8czVs2FDnzp3T7NmzdeDAAa1evVodOnTQK6+8ovT0dLv2a9euVXJysl154IEHbMddXV21du1abdiwwWlMXbt2tev78MMPKyoqyq7O398/x/POaf5ly5bZPm/fvt2h7bJly3Ic88brtGHDBnXu3FkTJkxQo0aNHG7a/xprcnKyJk2alOPYHTt21K5duzR79mwdOnRIK1euVEhIiFJTUx3axsTEaMCAAdq4caNOnTrldLyzZ89q8uTJOc4nSdu3b9f999+vAwcO6L333tPevXuVkJCgZ599Vu+//7727duXa38AAAAAuFlstnibZf9CLUnlypXT/fffr4YNG+qxxx5TfHy8nn322Rz7Ll68WDVq1NCIESNUtmxZnTx50uEG3NXV1W78zp07Ky4uznb8/PnzioyMVNu2bR1utKtXr67IyEjbioRsPj4+tjGdKVq0qLp06aIRI0bo+++/dzju4eEhDw8P2+ciRYrI09Mz1zGNzF+iRAnbf1+6dMlQrNluvE5ly5ZVrVq11LJlS9WpU0dvvfWW3njjDVvb/MSalpamTZs2KSEhQc2aNZMkVahQQfXr13doe+7cOS1cuFA7duxQSkqK4uPjNWrUKId2AwYM0NSpU9W/f3+VLl3a4bjValV4eLgCAwO1efNmFSr0f/nAqlWrqlu3bg7fKQAAAAAUFFYk3AGPPvqo6tSpk+sv6NL1X6979Oghi8Wi1q1bKz4+Ptf2SUlJ+vrrr1WkSBFb3TfffKPU1FQNGzYsx34mkylf8UvXHxf46aeftGTJknz3vVtUq1ZNrVu3zvN7yI3ZbJbZbNaKFSscHpP4q0WLFqlatWoKCgpSjx49FBsb6/SGv1u3bgoICFB0dLTTcRITE3XgwAG9/PLLdkmEG+X2nWZmZiojI8OuAAAAAIBRJBLukGrVqtntE5CUlGT3jP/hw4e1bds2de3aVZLUo0cPxcXFOdx4/vTTTzKbzfLw8FClSpW0b98+DR8+3Hb80KFDkqSgoCBb3Q8//GC7ATabzVq1apXdmI0aNbI7bjabHeIvW7asBg4cqNGjRxf48/hG5i8of/0eJGnWrFkO88+dO9dpf1dXV8XHx2v27Nny9vZW48aNNWrUKO3Zs8ehbXZiSLr+yEt6erq+/fZbh3Ymk0kTJ07URx99pKNHjzocd/ad/v7773bxzpo1K8dznjBhgiwWi63k9pjJ/2vv3sOirPP/j78GiEE5DIoakIiagkqimIaHMjwQuGpShoc0Mc3W1iwzUqk8kacsU1u11hNYechDklliXhrmmuWhJbW1dD2klihfNjm4LRrM7w9jfk0McGuwo/F8XNfnunbu+3N/Pq977sWuec/nvgcAAAAAfotCgpNYrdZyvzVevny5YmJiVKfO1d8B/9Of/qTc3Fzt2LHDrl9oaKgyMzO1b98+jR8/XjExMRo9enS5c4eHhyszM1OZmZm6dOlSqULAu+++a9tf0hwZP368srOzy3x+w/UyOn9lcHQdBg0aVGr++++/v8wx+vbtqx9++EGbNm1SbGysMjIy1KZNG7sVJN9++6327t2rgQMHSrpagOjfv7+WLVvmcMyYmBjdfffdmjhxoqHz8PPzs2X19fXV5cuXy+yblJSk3NxcWztz5oyhOQAAAABA4hkJTnPkyBE1atTI4b6ioiKtWLFCWVlZcnNzs9u+fPlydevWzbbN3d1dTZo0kSTNmjVLPXv21NSpU/XSSy9JunrPvHT1g2z79u0lXX1uQ8kxjgQFBZW7v4Svr6+SkpI0depU9erVq8L+RhmdvzI4ug4Wi+Wa5/fw8FB0dLSio6M1ceJEPfbYY5o8ebKGDh0q6epqhJ9//lmBgYG2Y6xWq8xmsxYsWCCLxVJqzFmzZqlDhw567rnn7Lb/+ppGRERIklxdXW2Zf/3/GUfMZrPMZvM1nR8AAAAAlGBFghPs2LFDhw4dUt++fR3u/+ijj5Sfn69//OMfdt+Kr169Wu+9954uXrxY5tgvvviiXn31VdsvAtx3332qXbu2Xn755ao4FY0ePVouLi6aP39+lYxflb755hulp6eXeR1+jxYtWujSpUuSpJ9//llvvfWW5syZY3c9v/rqKwUGBmr16tUOx7jrrrv04IMPasKECXbbIyIi1KxZM7366qulfkYUAAAAAKoaKxKqWGFhobKyslRUVKTz588rPT1dM2fOVK9evTRkyBCHxyxbtkw9e/ZUq1at7La3aNFCzzzzjFauXKlRo0Y5PLZDhw4KDw/XjBkztGDBAnl5eWnp0qXq37+/evbsqaeeekpNmzZVQUGB0tPTJV39NvvXcnJylJWVZbfN19dXHh4epebz8PDQ1KlTy8xzPa5lfqN+/vlnZWVlqbi4WDk5OcrIyNC0adPUunXrUt/4/+c//yk1v9lsVq1atRxmjY+P17BhwxQeHi5vb2/t379fs2fPVp8+fSRJmzdv1o8//qjhw4eXWnnQt29fLVu2TCNHjnSYe/r06QoLC7NbZWAymZSSkqLo6Gh16tRJSUlJat68ua5cuaJPP/1U2dnZpa4pAAAAAFQWViRUsfT0dAUEBKhhw4aKjY3VJ598otdff13vv/++ww9758+f14cffujwW3IXFxc98MADZd5XX+KZZ57R0qVLbfe+P/DAA/rss89Us2ZNDRkyRKGhoeratat27NihNWvWlLotoXv37goICLBraWlpZc6XkJCgxo0bG3g3jLnW+Y34+uuvFRAQoAYNGigqKkpr165VUlKSdu3aVephjkuWLCk1f8mzDX7Ly8tLkZGRmjt3rjp37qw77rhDEydO1IgRI7RgwQJJVwtD3bt3d3j7Qt++fbV//36HD2eUpJCQEA0bNsz2c5cl2rdvrwMHDig0NFSjRo1SixYt1LFjR61evVpz587VE088cT1vEwAAAABUyGTlB+eBai0vL08Wi0W5ubny8fFxdhwAAAAATmL0swErEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGEUEgAAAAAAgGFuzg4A4Mbw2lc58vC67OwYACrJhIg6zo4AAAD+oFiRAAAAAAAADKOQAAAAAAAADKOQgGrFarWqe/fuiomJKbVv0aJF8vX11dmzZ/XTTz+pdu3aqlOnjgoLC0v1bdiwoUwmkz7//HO77WPGjFFUVJTt9ZQpU2QymTRy5Ei7fpmZmTKZTDp16pQk6dSpUzKZTMrMzLTrt2HDBkVFRcliscjLy0vh4eFKTk7Wv//9b0lSamqqfH197Y45cuSIgoKCFB8fr8uXuVUBAAAAQOWikIBqxWQyKSUlRV988YX+9re/2bafPHlS48aN01//+lfVr19fGzZsUFhYmJo1a6a0tDSHY3l4eGj8+PEVzunh4aFly5bp2LFj15T1hRdeUP/+/dWuXTtt2bJFhw8f1pw5c/TVV1/p7bffdnjMvn37dM899yg2Nlbvvvuu3N3dr2lOAAAAAKgIhQRUO0FBQZo/f74SExN18uRJWa1WDR8+XPfdd58eeeQRSdKyZcs0ePBgDR48WMuWLXM4zuOPP67PP/9cH330UbnzhYaGqkuXLnrhhRcMZ9y7d69mzJihOXPm6JVXXlHHjh3VsGFDRUdHa8OGDUpISCh1zI4dO9S1a1cNHz5cS5YskYsLf94AAAAAKh+fNFAtJSQkqFu3bho2bJgWLFigw4cP21YoHD9+XHv27FG/fv3Ur18/7dq1S999912pMRo1aqSRI0cqKSlJxcXF5c43a9YsbdiwQfv37zeUb+XKlfLy8tJf/vIXh/t/ezvDxo0b1bNnT7344ot6+eWXyx27sLBQeXl5dg0AAAAAjKKQgGpr8eLFOnz4sMaMGaPFixerbt26kqTly5erR48eqlWrlmrXrq2YmBilpKQ4HOPFF1/UyZMntXLlynLnatOmjfr162foVghJOnbsmBo3bqxbbrmlwr4FBQWKj4/Xc889Z2j8mTNnymKx2FpQUJChTAAAAAAgUUhANVavXj39+c9/VvPmzRUXFydJKioq0ooVKzR48GBbv8GDBys1NdXhqoO6desqMTFRkyZNqvDBhtOmTdOuXbv08ccfV5jNarUaPo8aNWooOjpaS5Ys0ZEjRyrsn5SUpNzcXFs7c+aM4bkAAAAAgEICqjU3Nze5ubnZXm/dulXff/+9+vfvb9s3YMAAfffdd9q+fbvDMcaOHauffvpJixYtKneu22+/XSNGjNCECRMqLBSEhIToxIkTunLlSoXn4OrqqrS0NLVp00ZdunSpsJhgNpvl4+Nj1wAAAADAKAoJwK8sW7ZMAwYMUGZmpl0bMGBAmQ9d9PLy0sSJEzV9+nTl5+eXO/6kSZN09OhRrVmzptx+Dz/8sAoKCsosTly8eNHutdls1nvvvad27dqpS5cu+uc//1nu+AAAAABwvSgkAL/Izs7WBx98oISEBN1xxx12bciQIUpLS9O///1vh8c+/vjjslgsWrVqVblz3HrrrRo7dqxef/31cvtFRkZq3LhxevbZZzVu3Djt2bPHtioiPj5eK1asKHWM2WzWhg0bFBkZqS5duujrr782fvIAAAAAYBCFBOAXb731ljw9PdWtW7dS+7p166YaNWronXfecXjsLbfcopdeekn//e9/K5wnMTFRXl5eFfZ7+eWXtWrVKn3xxReKiYlRWFiYxo4dq/DwcIc//yhJ7u7uWr9+vTp27KguXbro8OHDFc4DAAAAANfCZL2Wp7oB+MPJy8uTxWLR5E9PyMPL29lxAFSSCRF1nB0BAADcZEo+G+Tm5pb7LDW3MvcAqFbGtvLjwYsAAAAAKsStDQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDAKCQAAAAAAwDA3ZwcAcGN47asceXhddnYMAJVkQkQdZ0cAAAB/UKxIAAAAAAAAhlFIAAAAAAAAhlFIAH4lOztbTzzxhBo0aCCz2Sx/f3/FxMRo9+7dkqSGDRvKZDKVarNmzZIknTp1SiaTSfXq1VN+fr7d2K1bt9aUKVNsr0+ePKmHH35YgYGB8vDwUP369dWnTx998803tj6O5jKZTFqzZo2tz9atW9W+fXt5e3urbt266tu3r06dOlV1bxIAAACAao1nJAC/0rdvX12+fFkrVqxQ48aNdf78eW3fvl05OTm2PsnJyRoxYoTdcd7e3nav8/Pz9eqrr2rq1KkO57ly5Yqio6MVGhqq9957TwEBATp79qy2bNmiixcv2vVNSUlRbGys3TZfX19JV4sRffr00dixY7Vy5Url5ubqmWee0YMPPqgvv/zyOt8FAAAAACgbhQTgFxcvXtSuXbuUkZGhe++9V5IUHBysu+66y66ft7e3/P39yx1r9OjReu211zRq1CjVq1ev1P6vv/5ax48f1/bt2xUcHGybq1OnTqX6+vr6ljnfgQMHVFRUpGnTpsnF5eoCo8TERPXp00dXrlzRLbfcUvGJAwAAAMA14NYG4BdeXl7y8vJSWlqaCgsLf9dYAwcOVJMmTZScnOxwf926deXi4qL169erqKjouue588475eLiopSUFBUVFSk3N1dvv/22unfvXmYRobCwUHl5eXYNAAAAAIyikAD8ws3NTampqVqxYoV8fX3VqVMnPf/88zp48KBdv/Hjx9uKDiVt165ddn1KnpuwePFiHT9+vNRct912m15//XVNmjRJtWrVUteuXfXSSy/pxIkTpfoOHDiw1HynT5+WJDVq1Egff/yxnn/+eZnNZvn6+urs2bNau3Ztmec5c+ZMWSwWWwsKCrqetwsAAABANUUhAfiVvn376ocfftCmTZsUGxurjIwMtWnTRqmpqbY+zz33nDIzM+1a27ZtS40VExOju+++WxMnTnQ416hRo5SVlaWVK1eqQ4cOWrduncLCwrRt2za7fnPnzi01X2BgoCQpKytLI0aMUEJCgvbt26edO3fK3d1dDz30kKxWq8N5k5KSlJuba2tnzpy5zncLAAAAQHXEMxKA3/Dw8FB0dLSio6M1ceJEPfbYY5o8ebKGDh0qSapTp46aNGliaKxZs2apQ4cOeu655xzu9/b2Vu/evdW7d29NmzZNMTExmjZtmqKjo219/P39y5xv4cKFslgsmj17tm3bO++8o6CgIH3xxRdq3759qWPMZrPMZrOh/AAAAADwW6xIACrQokULXbp06bqOveuuu/Tggw9qwoQJFfY1mUxq1qzZNc31n//8x/aQxRKurq6SpOLi4msLCwAAAAAGsCIB+EVOTo7i4+M1bNgwhYeHy9vbW/v379fs2bPVp08fW7/8/HxlZWXZHVuzZk35+Pg4HHf69OkKCwuTm9v//3PLzMzU5MmT9cgjj6hFixZyd3fXzp07tXz5co0fP97u+IsXL5aaz9vbW56enurZs6fmzp2r5ORkDRw4UPn5+Xr++ecVHBysiIiI3/uWAAAAAEAprEgAfuHl5aXIyEjNnTtXnTt31h133KGJEydqxIgRWrBgga3fpEmTFBAQYNfGjRtX5rghISEaNmyY/vvf/9q21a9fXw0bNtTUqVMVGRmpNm3aaP78+Zo6dapeeOEFu+MfffTRUvP99a9/lSR17dpVq1atUlpamiIiIhQbGyuz2az09HTVqFGjkt8hAAAAAJBM1rKeyAagWsjLy5PFYtHkT0/Iw8vb2XEAVJIJEXWcHQEAANxkSj4b5ObmlrniWuLWBgC/GNvKr9x/LAAAAABA4tYGAAAAAABwDSgkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAwygkAAAAAAAAw9ycHQDAjeG1r3Lk4XXZ2TEAVJIJEXWcHQEAAPxBsSIBAAAAAAAYRiEBAAAAAAAYRiEB+I2hQ4fKZDLZmp+fn2JjY3Xw4EFbn6KiIs2dO1ctW7aUh4eHatWqpR49emj37t12Y6WmptrGcXV1Va1atRQZGank5GTl5uaWmjcuLq7MHCUtNjbW1uerr77S/fffr3r16snDw0MNGzZU//79deHChap5cwAAAABUexQSAAdiY2N17tw5nTt3Ttu3b5ebm5t69eolSbJarRowYICSk5P19NNP68iRI8rIyFBQUJCioqKUlpZmN5aPj4/OnTuns2fP6rPPPtPjjz+ut956S61bt9YPP/xgOEdJW716tSQpOztb3bp1U+3atbV161YdOXJEKSkpCgwM1KVLl6rkfQEAAAAAHrYIOGA2m+Xv7y9J8vf314QJE3TPPfcoOztbO3bs0Pr167Vp0yb17t3bdszixYuVk5Ojxx57TNHR0fL09JQkmUwm21gBAQFq3ry5evfurbCwMI0bN07vvPOOoRy/tXv3buXm5mrp0qVyc7v6p9yoUSN16dKlUt4DAAAAAHCEFQlABQoKCvTOO++oSZMm8vPz06pVqxQSEmJXRCjx7LPPKicnR9u2bSt3zHr16mnQoEHatGmTioqKriuXv7+/fv75Z23cuFFWq9XwcYWFhcrLy7NrAAAAAGAUhQTAgc2bN8vLy0teXl7y9vbWpk2b9O6778rFxUVHjx5V8+bNHR5Xsv3o0aMVztGsWTPl5+crJyfHUI6SNmPGDElS+/bt9fzzz+vhhx9WnTp11KNHD73yyis6f/58ufPOnDlTFovF1oKCgirMCgAAAAAlKCQADnTp0kWZmZnKzMzU3r17FRMTox49eui7776TpGtaAVCWkjFMJpOhHCVt5MiRtv3Tp09XVlaW3nzzTYWFhenNN99Us2bNdOjQoTLHTEpKUm5urq2dOXPmd58LAAAAgOqDZyQADnh6eqpJkya210uXLpXFYtGSJUsUEhKiI0eOODyuZHtISEiFcxw5ckQ+Pj7y8/MznMMRPz8/xcfHKz4+XjNmzFBERIReffVVrVixwmF/s9kss9lcYT4AAAAAcIQVCYABJpNJLi4u+umnnzRgwAAdO3ZMH3zwQal+c+bMkZ+fn6Kjo8sd78KFC1q1apXi4uLk4lJ5f4bu7u66/fbb+dUGAAAAAFWGFQmAA4WFhcrKypIk/fjjj1qwYIEKCgrUu3dv3XvvvVq3bp0SEhL0yiuvqFu3bsrLy9PChQu1adMmrVu3zvaLDdLVWxiysrJktVp18eJF7dmzRzNmzJDFYtGsWbMM5yjh5uamOnXqaPPmzVqzZo0GDBigkJAQWa1WffDBB/roo4+UkpJS+W8KAAAAAIhCAuBQenq6AgICJEne3t5q1qyZ1q1bp6ioKEnS2rVrNW/ePM2dO1d/+ctf5OHhoQ4dOigjI0OdOnWyGysvL08BAQEymUzy8fFRaGioEhIS9PTTT8vHx8dwjhKhoaH65ptv1KJFC9WsWVPPPvuszpw5I7PZrKZNm2rp0qV65JFHKu/NAAAAAIBfMVkr46lxAG5aeXl5slgsmvzpCXl4eTs7DoBKMiGijrMjAACAm0zJZ4Pc3Nxyv/RkRQIASdLYVn4VrpAAAAAAAB62CAAAAAAADKOQAAAAAAAADKOQAAAAAAAADKOQAAAAAAAADKOQAAAAAAAADONXG4BqruQXYPPy8pycBAAAAIAzlXwmKPmMUBYKCUA1l5OTI0kKCgpychIAAAAAN4L8/HxZLJYy91NIAKq52rVrS5JOnz5d7j8WuPnl5eUpKChIZ86ckY+Pj7PjoApxrasPrnX1wbWuPrjW1ceNeK2tVqvy8/MVGBhYbj8KCUA15+Jy9VEpFovlhvkHDFXLx8eHa11NcK2rD6519cG1rj641tXHjXatjXy5yMMWAQAAAACAYRQSAAAAAACAYRQSgGrObDZr8uTJMpvNzo6CKsa1rj641tUH17r64FpXH1zr6uNmvtYma0W/6wAAAAAAAPALViQAAAAAAADDKCQAAAAAAADDKCQAAAAAAADDKCQAAAAAAADDKCQA1djChQvVsGFDeXh4KDIyUnv37nV2JFSBTz/9VL1791ZgYKBMJpPS0tKcHQlVYObMmWrXrp28vb1Vr149xcXF6dtvv3V2LFSBN954Q+Hh4fLx8ZGPj486dOigLVu2ODsW/gdmzZolk8mkMWPGODsKKtmUKVNkMpnsWrNmzZwdC1Xk+++/1+DBg+Xn56caNWqoZcuW2r9/v7NjXRMKCUA19e6772rs2LGaPHmyvvzyS7Vq1UoxMTG6cOGCs6Ohkl26dEmtWrXSwoULnR0FVWjnzp0aNWqUPv/8c23btk1XrlzRfffdp0uXLjk7GipZ/fr1NWvWLB04cED79+9X165d1adPH3399dfOjoYqtG/fPv3tb39TeHi4s6OgioSFhencuXO29ve//93ZkVAFfvzxR3Xq1Em33HKLtmzZon/+85+aM2eOatWq5exo14SffwSqqcjISLVr104LFiyQJBUXFysoKEijR4/WhAkTnJwOVcVkMmnjxo2Ki4tzdhRUsezsbNWrV087d+5U586dnR0HVax27dp65ZVXNHz4cGdHQRUoKChQmzZttGjRIk2bNk2tW7fWvHnznB0LlWjKlClKS0tTZmams6Ogik2YMEG7d+/Wrl27nB3ld2FFAlANXb58WQcOHFD37t1t21xcXNS9e3ft2bPHickAVJbc3FxJVz9g4o+rqKhIa9as0aVLl9ShQwdnx0EVGTVqlHr27Gn332388Rw7dkyBgYFq3LixBg0apNOnTzs7EqrApk2b1LZtW8XHx6tevXqKiIjQkiVLnB3rmlFIAKqh//u//1NRUZFuvfVWu+233nqrsrKynJQKQGUpLi7WmDFj1KlTJ91xxx3OjoMqcOjQIXl5eclsNmvkyJHauHGjWrRo4exYqAJr1qzRl19+qZkzZzo7CqpQZGSkUlNTlZ6erjfeeEMnT57UPffco/z8fGdHQyU7ceKE3njjDTVt2lRbt27VE088oaeeekorVqxwdrRr4ubsAAAAoHKNGjVKhw8f5v7aP7DQ0FBlZmYqNzdX69evV0JCgnbu3Ekx4Q/mzJkzevrpp7Vt2zZ5eHg4Ow6qUI8ePWz/Ozw8XJGRkQoODtbatWu5ZekPpri4WG3bttWMGTMkSRERETp8+LDefPNNJSQkODmdcaxIAKqhOnXqyNXVVefPn7fbfv78efn7+zspFYDK8OSTT2rz5s365JNPVL9+fWfHQRVxd3dXkyZNdOedd2rmzJlq1aqV5s+f7+xYqGQHDhzQhQsX1KZNG7m5ucnNzU07d+7U66+/Ljc3NxUVFTk7IqqIr6+vQkJC9K9//cvZUVDJAgICShV9mzdvftPdykIhAaiG3N3ddeedd2r79u22bcXFxdq+fTv32AI3KavVqieffFIbN27Ujh071KhRI2dHwv9QcXGxCgsLnR0Dlaxbt246dOiQMjMzba1t27YaNGiQMjMz5erq6uyIqCIFBQU6fvy4AgICnB0FlaxTp06lfp756NGjCg4OdlKi68OtDUA1NXbsWCUkJKht27a66667NG/ePF26dEmPPvqos6OhkhUUFNh9o3Hy5EllZmaqdu3aatCggROToTKNGjVKq1at0vvvvy9vb2/b804sFotq1Kjh5HSoTElJSerRo4caNGig/Px8rVq1ShkZGdq6dauzo6GSeXt7l3rOiaenp/z8/Hj+yR9MYmKievfureDgYP3www+aPHmyXF1dNXDgQGdHQyV75pln1LFjR82YMUP9+vXT3r17tXjxYi1evNjZ0a4JhQSgmurfv7+ys7M1adIkZWVlqXXr1kpPTy/1AEbc/Pbv368uXbrYXo8dO1aSlJCQoNTUVCelQmV74403JElRUVF221NSUjR06ND/fSBUmQsXLmjIkCE6d+6cLBaLwsPDtXXrVkVHRzs7GoDrdPbsWQ0cOFA5OTmqW7eu7r77bn3++eeqW7eus6OhkrVr104bN25UUlKSkpOT1ahRI82bN0+DBg1ydrRrYrJarVZnhwAAAAAAADcHnpEAAAAAAAAMo5AAAAAAAAAMo5AAAAAAAAAMo5AAAAAAAAAMo5AAAAAAAAAMo5AAAAAAAAAMo5AAAAAAAAAMo5AAAAAAAAAMo5AAAABQDURFRWnMmDHOjgEA+AOgkAAAAHCD6927t2JjYx3u27Vrl0wmkw4ePPg/TgUAqK4oJAAAANzghg8frm3btuns2bOl9qWkpKht27YKDw93QjJ7ly9fdnYEAMD/AIUEAACAG1yvXr1Ut25dpaam2m0vKCjQunXrFBcXp4EDB+q2225TzZo11bJlS61evbrcMQsLC5WYmKjbbrtNnp6eioyMVEZGhm3/lClT1Lp1a7tj5s2bp4YNG9peDx06VHFxcZo+fboCAwMVGhoqSVq0aJGaNm0qDw8P3XrrrXrooYd+z+kDAG4wFBIAAABucG5ubhoyZIhSU1NltVpt29etW6eioiINHjxYd955pz788EMdPnxYjz/+uB555BHt3bu3zDGffPJJ7dmzR2vWrNHBgwcVHx+v2NhYHTt27Jqybd++Xd9++622bdumzZs3a//+/XrqqaeUnJysb7/9Vunp6ercufN1nzsA4MZDIQEAAOAmMGzYMB0/flw7d+60bUtJSVHfvn0VHBysxMREtW7dWo0bN9bo0aMVGxurtWvXOhzr9OnTSklJ0bp163TPPffo9ttvV2Jiou6++26lpKRcUy5PT08tXbpUYWFhCgsL0+nTp+Xp6alevXopODhYEREReuqpp37XuQMAbixuzg4AAACAijVr1kwdO3bU8uXLFRUVpX/961/atWuXkpOTVVRUpBkzZmjt2rX6/vvvdfnyZRUWFqpmzZoOxzp06JCKiooUEhJit72wsFB+fn7XlKtly5Zyd3e3vY6OjlZwcLAaN26s2NhYxcbG6oEHHigzCwDg5kMhAQAA4CYxfPhwjR49WgsXLlRKSopuv/123XvvvXr55Zc1f/58zZs3Ty1btpSnp6fGjBlT5sMPCwoK5OrqqgMHDsjV1dVun5eXlyTJxcXF7jYKSbpy5UqpsTw9Pe1ee3t768svv1RGRoY+/vhjTZo0SVOmTNG+ffvk6+v7O84eAHCj4NYGAACAm0S/fv3k4uKiVatW6a233tKwYcNkMpm0e/du9enTR4MHD1arVq3UuHFjHT16tMxxIiIiVFRUpAsXLqhJkyZ2zd/fX5JUt25dZWVl2RUTMjMzDeV0c3NT9+7dNXv2bB08eFCnTp3Sjh07fte5AwBuHKxIAAAAuEl4eXmpf//+SkpKUl5enoYOHSpJatq0qdavX6/PPvtMtWrV0muvvabz58+rRYsWDscJCQnRoEGDNGTIEM2ZM0cRERHKzs7W9u3bFR4erp49eyoqKkrZ2dmaPXu2HnroIaWnp2vLli3y8fEpN+PmzZt14sQJde7cWbVq1dJHH32k4uJi2y86AABufqxIAAAAuIkMHz5cP/74o2JiYhQYGChJevHFF9WmTRvFxMQoKipK/v7+iouLK3eclJQUDRkyRM8++6xCQ0MVFxenffv2qUGDBpKk5s2ba9GiRVq4cKFatWqlvXv3KjExscJ8vr6+eu+999S1a1c1b95cb775plavXq2wsLDffe4AgBuDyfrbm98AAAAAAADKwIoEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABgGIUEAAAAAABg2P8D5/FuTE8BhSUAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Afficher un bar chart des titres les plus fréquents\n",
+    "# Affichage d'un bar chart horizontal\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "titles_more_than_once.sort_values(ascending=True).plot(kind='barh', color='skyblue',)\n",
+    "plt.xlabel('Nb')\n",
+    "plt.title('Fréquence des films/séries')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([2023, 2016, 2022, 1997, 2015, 2006, 2018, 2021, 1984, 1968, 2020,\n",
+       "       2019, 1971, 2017, 2001, 2012, 1987, 2005, 1975, 1982, 2013, 2014,\n",
+       "       2010, 1994, 2009, 1988, 2000, 2011, 1999, 1957, 2002])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "# Extract unique values from the \"ANNEE\" column to understand its format\n",
+    "unique_years = df_truncated[annee].unique()\n",
+    "\n",
+    "# Display a few unique values for inspection\n",
+    "unique_years[:100]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def visualize_year_distribution(years_data, chart_title):\n",
+    "    \"\"\"\n",
+    "    Visualise la distribution des années, y compris les intervalles, dans un ensemble de données d'années.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    - years_data (list or pd.Series): Un tableau ou une série Pandas contenant des années ou des intervalles d'années.\n",
+    "    \n",
+    "    Returns:\n",
+    "    - Affiche un histogramme de la distribution des années.\n",
+    "    \"\"\"\n",
+    "    import pandas as pd\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    import re  # For regular expression operations\n",
+    "    \n",
+    "    \n",
+    "    # Convertir toutes les valeurs en chaînes pour gérer les intervalles potentiels comme des entrées uniques\n",
+    "    years_data = years_data.astype(str)\n",
+    "    \n",
+    "    # Séparer les intervalles en années individuelles et compter la fréquence de chaque année\n",
+    "    all_years = []\n",
+    "    # Utilise un set pour les valeurs non numériques\n",
+    "    non_numeric_entries = set()\n",
+    "    \n",
+    "    for year in years_data:\n",
+    "        if re.search(r'[a-z]', year):  # If there are no digits in the string\n",
+    "            non_numeric_entries.add(year)\n",
+    "        elif \",\" in year:\n",
+    "            years_list = year.split(\",\")\n",
+    "            for y in years_list:\n",
+    "                all_years.append(int(y.strip()))  # Ajouter chaque année en la convertissant en entier\n",
+    "        elif \"+/-\" in year:  # Vérifier si c'est un intervalle\n",
+    "            start_year, uncertainty = year.split(\"+/-\")\n",
+    "            if (start_year != ''):\n",
+    "                 all_years.extend(range(int(start_year), int(start_year) + uncertainty + 1))\n",
+    "                 print(year)\n",
+    "            else:\n",
+    "                non_numeric_entries.add(year)\n",
+    "        elif \"-\" in year:  # Vérifier si c'est un intervalle\n",
+    "            start_year, end_year = year.split(\"-\")\n",
+    "            all_years.extend(range(int(start_year), int(end_year) + 1))\n",
+    "        elif  \"/\" in year:  # Vérifier si c'est un intervalle\n",
+    "            start_year, end_year = year.split(\"/\")\n",
+    "            all_years.extend(range(int(start_year), int(end_year) + 1))\n",
+    "        else:\n",
+    "            all_years.append(int(year))\n",
+    "    \n",
+    "    # Print non-numeric entries if any\n",
+    "    if non_numeric_entries:\n",
+    "        print(\"Non-numeric entries found:\", non_numeric_entries)\n",
+    "    \n",
+    "    # Proceed with visualization only if there are numeric years\n",
+    "    if all_years:\n",
+    "        # Créer un DataFrame à partir de la liste des années pour faciliter la visualisation\n",
+    "        df_years = pd.DataFrame(all_years, columns=[\"Year\"])\n",
+    "        \n",
+    "        # Visualiser la distribution des années avec un histogramme\n",
+    "        plt.figure(figsize=(10, 6))\n",
+    "        df_years[\"Year\"].hist(bins=len(df_years[\"Year\"].unique()), color=\"skyblue\", edgecolor=\"black\")\n",
+    "        plt.title(chart_title)\n",
+    "        plt.xlabel(\"Année\")\n",
+    "        plt.ylabel(\"Fréquence\")\n",
+    "        plt.xticks(rotation=45)\n",
+    "        plt.tight_layout()\n",
+    "        plt.show()\n",
+    "    else:\n",
+    "        print(\"No numeric years found for visualization.\")\n",
+    "    return all_years\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/s4/6jbnvfsj1v10f2txtlkndj5w0000gp/T/ipykernel_38954/2978788642.py:4: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  df_truncated[annee] = df_truncated[annee].astype(str)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Convertir toutes les valeurs en chaînes pour gérer les intervalles potentiels comme des entrées uniques\n",
+    "df_truncated[annee] = df_truncated[annee].astype(str)\n",
+    "all_prod_years = visualize_year_distribution(df_truncated[annee], 'Distribution des années de production')\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Non-numeric entries found: {'Années 50', 'Actuelle', 'Futur proche', 'notre époque', 'Contemporain ', 'Milieu du XXI siècle', 'Contemporain', 'Futur très proche', \"Aujourd'hui \", 'Futur', 'Tous les 33 ans ', 'Sur plusieurs siecles', '1969-1995 (mais uchronie...)', 'Années 2010/2020', 'Actuel ', '+/- 1930', 'années 2000'}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/s4/6jbnvfsj1v10f2txtlkndj5w0000gp/T/ipykernel_38954/2873658588.py:4: SettingWithCopyWarning: \n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
+      "  df_truncated[epoque] = df_truncated[epoque].astype(str)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "epoque = \"EPOQUE DU RECIT\"\n",
+    "\n",
+    "# Convertir toutes les valeurs en chaînes pour gérer les intervalles potentiels comme des entrées uniques\n",
+    "df_truncated[epoque] = df_truncated[epoque].astype(str)\n",
+    "all_years = visualize_year_distribution(df_truncated[epoque], 'Distribution des époques du récit')\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# keep years under 2500\n",
+    "before2500 = [x for x in all_years if x < 2500]\n",
+    "df = pd.DataFrame(before2500, columns=['Année']) \n",
+    "all_years_before_2500 = visualize_year_distribution(df['Année'], 'Distribution des époques du récit')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[22000]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Future dates\n",
+    "# keep years after 2500\n",
+    "[x for x in all_years if x >= 2500]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['Entre 2 et 10 tonnes', 'Entre 10 et 30 tonnes', 'Entre 0 et 2 tonnes',\n",
+       "       'Entre 30 et 80 tonnes', 'Au-delà de 80 tonnes'],\n",
+       "      dtype='object', name='EMPREINTE PERSO')"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "co2 = data[\"EMPREINTE PERSO\"]\n",
+    "c = co2.value_counts()\n",
+    "c.index\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Construction du camembert\n",
+    "plt.figure(figsize=(8, 8))\n",
+    "plt.pie(c, autopct='%1.1f%%', startangle=140)\n",
+    "plt.title(\"Empreinte Personnelle\")\n",
+    "\n",
+    "plt.axis('equal')  # S'assure que le camembert est dessiné comme un cercle.\n",
+    "plt.title('Empreinte carbone')\n",
+    "plt.legend(c.index)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'Non-empty count': 54,\n",
+       " 'Unique non-empty entries': 54,\n",
+       " 'Sample entries': ['Très compliqué pour cette série. ',\n",
+       "  'Le film me semble représenter une vie bas carbone souhaitable',\n",
+       "  'Approche très intéressante, je laisse mon mail pour en savoir plus :) ',\n",
+       "  \"La série met en marge des personnages plutôt en marge de la société de consommation, mais montre pourtant bien l'emprise du  système du Tout voiture\",\n",
+       "  \"C'est une série israélienne qui traite du problème palestinien... Il y a donc forcément un biais. Les méchants sont palestiniens. \"]}"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "col_qqch_ajouter = df_truncated[\"QUELQUE CHOSE A AJOUTER ?\"]\n",
+    "\n",
+    "# Analyzing the \"QUELQUE CHOSE A AJOUTER ?\" column to understand its content\n",
+    "# Check if the column exists\n",
+    "if \"QUELQUE CHOSE A AJOUTER ?\" in df_truncated.columns:\n",
+    "    # Basic analysis of the column\n",
+    "    # Count of non-empty entries\n",
+    "    non_empty_count = col_qqch_ajouter.notna().sum()\n",
+    "    # Unique non-empty entries\n",
+    "    unique_non_empty_entries = col_qqch_ajouter.nunique()\n",
+    "    # Sample of non-empty entries\n",
+    "    sample_entries = col_qqch_ajouter.dropna().sample(min(5, non_empty_count)).tolist()\n",
+    "    analysis_results = {\n",
+    "        \"Non-empty count\": non_empty_count,\n",
+    "        \"Unique non-empty entries\": unique_non_empty_entries,\n",
+    "        \"Sample entries\": sample_entries\n",
+    "    }\n",
+    "else:\n",
+    "    analysis_results = \"Column 'QUELQUE CHOSE A AJOUTER ?' does not exist in the dataset.\"\n",
+    "\n",
+    "analysis_results\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/analyse-poc.ipynb b/notebooks/analyse-poc.ipynb
new file mode 100644
index 0000000..0b1b46a
--- /dev/null
+++ b/notebooks/analyse-poc.ipynb
@@ -0,0 +1,1019 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "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>Horodateur</th>\n",
+       "      <th>TITRE DU CONTENU</th>\n",
+       "      <th>ANNÉE DE PRODUCTION</th>\n",
+       "      <th>PAYS DE PRODUCTION</th>\n",
+       "      <th>CANAL DE DIFFUSION</th>\n",
+       "      <th>SÉRIE OU FILM ?</th>\n",
+       "      <th>QUELLE SAISON ?</th>\n",
+       "      <th>LIEU(X) DE L'ACTION</th>\n",
+       "      <th>EPOQUE DU RECIT</th>\n",
+       "      <th>GENRE</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Unnamed: 116</th>\n",
+       "      <th>Unnamed: 117</th>\n",
+       "      <th>Unnamed: 118</th>\n",
+       "      <th>Unnamed: 119</th>\n",
+       "      <th>Unnamed: 120</th>\n",
+       "      <th>Unnamed: 121</th>\n",
+       "      <th>Unnamed: 122</th>\n",
+       "      <th>Unnamed: 123</th>\n",
+       "      <th>Unnamed: 124</th>\n",
+       "      <th>Unnamed: 125</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>7/29/23 13:06</td>\n",
+       "      <td>Une nuit</td>\n",
+       "      <td>2023</td>\n",
+       "      <td>France</td>\n",
+       "      <td>SALLE DE CINÉMA</td>\n",
+       "      <td>FILM</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Paris</td>\n",
+       "      <td>2023</td>\n",
+       "      <td>Comédie-romantique, Réaliste</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>7/30/23 15:18</td>\n",
+       "      <td>David Brent, Life on the road</td>\n",
+       "      <td>2016</td>\n",
+       "      <td>UK</td>\n",
+       "      <td>NETFLIX</td>\n",
+       "      <td>FILM</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Angleterre</td>\n",
+       "      <td>2016</td>\n",
+       "      <td>Comédie, Réaliste</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7/30/23 15:47</td>\n",
+       "      <td>Survival of the thickest</td>\n",
+       "      <td>2022</td>\n",
+       "      <td>Etats-Unis</td>\n",
+       "      <td>NETFLIX</td>\n",
+       "      <td>SÉRIE</td>\n",
+       "      <td>1</td>\n",
+       "      <td>New York</td>\n",
+       "      <td>2022</td>\n",
+       "      <td>Comédie-romantique</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>7/30/23 16:18</td>\n",
+       "      <td>Meurtres à</td>\n",
+       "      <td>2016</td>\n",
+       "      <td>France</td>\n",
+       "      <td>FRANCE TV</td>\n",
+       "      <td>SÉRIE</td>\n",
+       "      <td>???? je ne sais pas</td>\n",
+       "      <td>en France, dans différentes régions selon les ...</td>\n",
+       "      <td>2016</td>\n",
+       "      <td>Thriller / Policier</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7/31/23 9:28</td>\n",
+       "      <td>Dernière nuit Milan</td>\n",
+       "      <td>2022</td>\n",
+       "      <td>Italie</td>\n",
+       "      <td>SALLE DE CINÉMA</td>\n",
+       "      <td>FILM</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Milan</td>\n",
+       "      <td>2022</td>\n",
+       "      <td>Thriller / Policier</td>\n",
+       "      <td>...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 126 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      Horodateur               TITRE DU CONTENU  ANNÉE DE PRODUCTION  \\\n",
+       "0  7/29/23 13:06                       Une nuit                 2023   \n",
+       "1  7/30/23 15:18  David Brent, Life on the road                 2016   \n",
+       "2  7/30/23 15:47       Survival of the thickest                 2022   \n",
+       "3  7/30/23 16:18                     Meurtres à                 2016   \n",
+       "4   7/31/23 9:28            Dernière nuit Milan                 2022   \n",
+       "\n",
+       "  PAYS DE PRODUCTION CANAL DE DIFFUSION SÉRIE OU FILM ?      QUELLE SAISON ?  \\\n",
+       "0             France    SALLE DE CINÉMA            FILM                  NaN   \n",
+       "1                 UK            NETFLIX            FILM                  NaN   \n",
+       "2         Etats-Unis            NETFLIX           SÉRIE                    1   \n",
+       "3             France          FRANCE TV           SÉRIE  ???? je ne sais pas   \n",
+       "4             Italie    SALLE DE CINÉMA            FILM                  NaN   \n",
+       "\n",
+       "                                 LIEU(X) DE L'ACTION EPOQUE DU RECIT  \\\n",
+       "0                                              Paris            2023   \n",
+       "1                                         Angleterre            2016   \n",
+       "2                                           New York            2022   \n",
+       "3  en France, dans différentes régions selon les ...            2016   \n",
+       "4                                              Milan            2022   \n",
+       "\n",
+       "                          GENRE  ... Unnamed: 116 Unnamed: 117 Unnamed: 118  \\\n",
+       "0  Comédie-romantique, Réaliste  ...          NaN          NaN          NaN   \n",
+       "1             Comédie, Réaliste  ...          NaN          NaN          NaN   \n",
+       "2            Comédie-romantique  ...          NaN          NaN          NaN   \n",
+       "3           Thriller / Policier  ...          NaN          NaN          NaN   \n",
+       "4           Thriller / Policier  ...          NaN          NaN          NaN   \n",
+       "\n",
+       "  Unnamed: 119  Unnamed: 120 Unnamed: 121 Unnamed: 122 Unnamed: 123  \\\n",
+       "0          NaN           NaN          NaN          NaN          NaN   \n",
+       "1          NaN           NaN          NaN          NaN          NaN   \n",
+       "2          NaN           NaN          NaN          NaN          NaN   \n",
+       "3          NaN           NaN          NaN          NaN          NaN   \n",
+       "4          NaN           NaN          NaN          NaN          NaN   \n",
+       "\n",
+       "  Unnamed: 124 Unnamed: 125  \n",
+       "0          NaN          NaN  \n",
+       "1          NaN          NaN  \n",
+       "2          NaN          NaN  \n",
+       "3          NaN          NaN  \n",
+       "4          NaN          NaN  \n",
+       "\n",
+       "[5 rows x 126 columns]"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Getting started\n",
+    "\n",
+    "# A simple notebooks for testing some analyses on the first version of the questionnaire.\n",
+    "# Data are not pushed to github due to privacy reasons. \n",
+    "# The raw_data.csv should be copied to the data/ folder. \n",
+    "\n",
+    "# Let's first load the data to understand its structure and then compute general statistical information.\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Load the data\n",
+    "# file_path = './data/Treated_data.csv'\n",
+    "file_path = '../data/raw_data.csv'\n",
+    "data = pd.read_csv(file_path)\n",
+    "\n",
+    "# Display the first few rows of the dataframe to understand its structure\n",
+    "data.head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "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>ANNÉE DE PRODUCTION</th>\n",
+       "      <th>MORPHOLOGIE 1/2 (OPTIONNEL)</th>\n",
+       "      <th>MORPHOLOGIE 1/2 (OPTIONNEL).1</th>\n",
+       "      <th>TYPE DE RESIDENCE [Studio].1</th>\n",
+       "      <th>MORPHOLOGIE 1/2 (OPTIONNEL).2</th>\n",
+       "      <th>TYPE DE RESIDENCE [Colocation].2</th>\n",
+       "      <th>TYPE DE RESIDENCE [Studio].2</th>\n",
+       "      <th>TYPE DE RESIDENCE [Hotel].2</th>\n",
+       "      <th>VALEURS / TRAITS DE CARACTERE.2</th>\n",
+       "      <th>MORPHOLOGIE 1/2 (OPTIONNEL).3</th>\n",
+       "      <th>...</th>\n",
+       "      <th>MORPHOLOGIE 2/2 (OPTIONNEL).1</th>\n",
+       "      <th>MORPHOLOGIE 2/2 (OPTIONNEL).2</th>\n",
+       "      <th>MORPHOLOGIE 2/2 (OPTIONNEL).3</th>\n",
+       "      <th>Unnamed: 119</th>\n",
+       "      <th>Unnamed: 120</th>\n",
+       "      <th>Unnamed: 121</th>\n",
+       "      <th>Unnamed: 122</th>\n",
+       "      <th>Unnamed: 123</th>\n",
+       "      <th>Unnamed: 124</th>\n",
+       "      <th>Unnamed: 125</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>203.000000</td>\n",
+       "      <td>199.000000</td>\n",
+       "      <td>75.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>20.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>73.000000</td>\n",
+       "      <td>20.000000</td>\n",
+       "      <td>7.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>2017.832512</td>\n",
+       "      <td>3.733668</td>\n",
+       "      <td>3.813333</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.35000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.714286</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.136986</td>\n",
+       "      <td>2.300000</td>\n",
+       "      <td>2.285714</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>10.463114</td>\n",
+       "      <td>0.986997</td>\n",
+       "      <td>1.086693</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.03999</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.496026</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.071280</td>\n",
+       "      <td>1.128576</td>\n",
+       "      <td>1.112697</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>1957.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.00000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25%</th>\n",
+       "      <td>2018.000000</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.00000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.500000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.500000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>2022.000000</td>\n",
+       "      <td>4.000000</td>\n",
+       "      <td>4.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.00000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.000000</td>\n",
+       "      <td>2.500000</td>\n",
+       "      <td>2.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75%</th>\n",
+       "      <td>2023.000000</td>\n",
+       "      <td>4.500000</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>4.00000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.500000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>2023.000000</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>5.00000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>4.000000</td>\n",
+       "      <td>4.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>8 rows × 35 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       ANNÉE DE PRODUCTION  MORPHOLOGIE 1/2 (OPTIONNEL)  \\\n",
+       "count           203.000000                   199.000000   \n",
+       "mean           2017.832512                     3.733668   \n",
+       "std              10.463114                     0.986997   \n",
+       "min            1957.000000                     1.000000   \n",
+       "25%            2018.000000                     3.000000   \n",
+       "50%            2022.000000                     4.000000   \n",
+       "75%            2023.000000                     4.500000   \n",
+       "max            2023.000000                     5.000000   \n",
+       "\n",
+       "       MORPHOLOGIE 1/2 (OPTIONNEL).1  TYPE DE RESIDENCE [Studio].1  \\\n",
+       "count                      75.000000                           0.0   \n",
+       "mean                        3.813333                           NaN   \n",
+       "std                         1.086693                           NaN   \n",
+       "min                         1.000000                           NaN   \n",
+       "25%                         3.000000                           NaN   \n",
+       "50%                         4.000000                           NaN   \n",
+       "75%                         5.000000                           NaN   \n",
+       "max                         5.000000                           NaN   \n",
+       "\n",
+       "       MORPHOLOGIE 1/2 (OPTIONNEL).2  TYPE DE RESIDENCE [Colocation].2  \\\n",
+       "count                       20.00000                               0.0   \n",
+       "mean                         3.35000                               NaN   \n",
+       "std                          1.03999                               NaN   \n",
+       "min                          1.00000                               NaN   \n",
+       "25%                          3.00000                               NaN   \n",
+       "50%                          3.00000                               NaN   \n",
+       "75%                          4.00000                               NaN   \n",
+       "max                          5.00000                               NaN   \n",
+       "\n",
+       "       TYPE DE RESIDENCE [Studio].2  TYPE DE RESIDENCE [Hotel].2  \\\n",
+       "count                           0.0                          0.0   \n",
+       "mean                            NaN                          NaN   \n",
+       "std                             NaN                          NaN   \n",
+       "min                             NaN                          NaN   \n",
+       "25%                             NaN                          NaN   \n",
+       "50%                             NaN                          NaN   \n",
+       "75%                             NaN                          NaN   \n",
+       "max                             NaN                          NaN   \n",
+       "\n",
+       "       VALEURS / TRAITS DE CARACTERE.2  MORPHOLOGIE 1/2 (OPTIONNEL).3  ...  \\\n",
+       "count                              0.0                       7.000000  ...   \n",
+       "mean                               NaN                       2.714286  ...   \n",
+       "std                                NaN                       1.496026  ...   \n",
+       "min                                NaN                       1.000000  ...   \n",
+       "25%                                NaN                       1.500000  ...   \n",
+       "50%                                NaN                       3.000000  ...   \n",
+       "75%                                NaN                       3.500000  ...   \n",
+       "max                                NaN                       5.000000  ...   \n",
+       "\n",
+       "       MORPHOLOGIE 2/2 (OPTIONNEL).1  MORPHOLOGIE 2/2 (OPTIONNEL).2  \\\n",
+       "count                      73.000000                      20.000000   \n",
+       "mean                        2.136986                       2.300000   \n",
+       "std                         1.071280                       1.128576   \n",
+       "min                         1.000000                       1.000000   \n",
+       "25%                         1.000000                       1.000000   \n",
+       "50%                         2.000000                       2.500000   \n",
+       "75%                         3.000000                       3.000000   \n",
+       "max                         5.000000                       4.000000   \n",
+       "\n",
+       "       MORPHOLOGIE 2/2 (OPTIONNEL).3  Unnamed: 119  Unnamed: 120  \\\n",
+       "count                       7.000000           0.0           0.0   \n",
+       "mean                        2.285714           NaN           NaN   \n",
+       "std                         1.112697           NaN           NaN   \n",
+       "min                         1.000000           NaN           NaN   \n",
+       "25%                         1.500000           NaN           NaN   \n",
+       "50%                         2.000000           NaN           NaN   \n",
+       "75%                         3.000000           NaN           NaN   \n",
+       "max                         4.000000           NaN           NaN   \n",
+       "\n",
+       "       Unnamed: 121  Unnamed: 122  Unnamed: 123  Unnamed: 124  Unnamed: 125  \n",
+       "count           0.0           0.0           0.0           0.0           0.0  \n",
+       "mean            NaN           NaN           NaN           NaN           NaN  \n",
+       "std             NaN           NaN           NaN           NaN           NaN  \n",
+       "min             NaN           NaN           NaN           NaN           NaN  \n",
+       "25%             NaN           NaN           NaN           NaN           NaN  \n",
+       "50%             NaN           NaN           NaN           NaN           NaN  \n",
+       "75%             NaN           NaN           NaN           NaN           NaN  \n",
+       "max             NaN           NaN           NaN           NaN           NaN  \n",
+       "\n",
+       "[8 rows x 35 columns]"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Compute general statistical information for the numerical columns in the data\n",
+    "statistical_info = data.describe()\n",
+    "\n",
+    "# Display the statistical information\n",
+    "statistical_info\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Horodateur', 'TITRE DU CONTENU', 'ANNÉE DE PRODUCTION', 'PAYS DE PRODUCTION', 'CANAL DE DIFFUSION', 'SÉRIE OU FILM ?', 'QUELLE SAISON ?', \"LIEU(X) DE L'ACTION\", 'EPOQUE DU RECIT', 'GENRE', 'POSITION DANS LE RECIT', 'GENRE.1', 'AGE', 'ETHNICITE PERCUE (OPTIONNEL)', 'MORPHOLOGIE 1/2 (OPTIONNEL)', 'PAYS DE RESIDENCE', 'TYPE DE RESIDENCE [Appartement]', 'TYPE DE RESIDENCE [Colocation]', 'TYPE DE RESIDENCE [Maison individuelle]', 'TYPE DE RESIDENCE [Studio]', 'TYPE DE RESIDENCE [Hotel]', 'TYPE DE RESIDENCE [Ferme]', 'TYPE DE RESIDENCE [Alternatif/communautaire]', 'TYPE DE RESIDENCE [On ne sait pas / Autre ]', 'METIER / OCCUPATION ?', 'CATEGORIE SOCIALE PERCUE ?', 'ASPIRATIONS', 'VALEURS / TRAITS DE CARACTERE', 'SOUHAITEZ-VOUS AJOUTER UN PERSONNAGE ?', 'POSITION DANS LE RECIT.1', 'GENRE.2', 'AGE.1', 'ETHNICITE PERCUE (OPTIONNEL).1', 'MORPHOLOGIE 1/2 (OPTIONNEL).1', 'PAYS DE RESIDENCE.1', 'TYPE DE RESIDENCE [Appartement].1', 'TYPE DE RESIDENCE [Colocation].1', 'TYPE DE RESIDENCE [Maison individuelle].1', 'TYPE DE RESIDENCE [Studio].1', 'TYPE DE RESIDENCE [Hotel].1', 'TYPE DE RESIDENCE [Ferme].1', 'TYPE DE RESIDENCE [Alternatif/communautaire].1', 'TYPE DE RESIDENCE [On ne sait pas / Autre ].1', 'METIER / OCCUPATION ?.1', 'CATEGORIE SOCIALE PERCUE ?.1', 'ASPIRATIONS.1', 'VALEURS / TRAITS DE CARACTERE.1', 'SOUHAITEZ-VOUS AJOUTER UN PERSONNAGE ?.1', 'POSITION DANS LE RECIT.2', 'GENRE.3', 'AGE.2', 'ETHNICITE PERCUE (OPTIONNEL).2', 'MORPHOLOGIE 1/2 (OPTIONNEL).2', 'PAYS DE RESIDENCE.2', 'TYPE DE RESIDENCE [Appartement].2', 'TYPE DE RESIDENCE [Colocation].2', 'TYPE DE RESIDENCE [Maison individuelle].2', 'TYPE DE RESIDENCE [Studio].2', 'TYPE DE RESIDENCE [Hotel].2', 'TYPE DE RESIDENCE [Ferme].2', 'TYPE DE RESIDENCE [Alternatif/communautaire].2', 'TYPE DE RESIDENCE [On ne sait pas / Autre ].2', 'METIER / OCCUPATION ?.2', 'CATEGORIE SOCIALE PERCUE ?.2', 'ASPIRATIONS.2', 'VALEURS / TRAITS DE CARACTERE.2', 'SOUHAITEZ-VOUS AJOUTER UN PERSONNAGE ?.2', 'POSITION DANS LE RECIT.3', 'GENRE.4', 'AGE.3', 'ETHNICITE PERCUE (OPTIONNEL).3', 'MORPHOLOGIE 1/2 (OPTIONNEL).3', 'PAYS DE RESIDENCE.3', 'TYPE DE RESIDENCE [Appartement].3', 'TYPE DE RESIDENCE [Colocation].3', 'TYPE DE RESIDENCE [Maison individuelle].3', 'TYPE DE RESIDENCE [Studio].3', 'TYPE DE RESIDENCE [Hotel].3', 'TYPE DE RESIDENCE [Ferme].3', 'TYPE DE RESIDENCE [Alternatif/communautaire].3', 'TYPE DE RESIDENCE [On ne sait pas / Autre ].3', 'METIER / OCCUPATION ?.3', 'CATEGORIE SOCIALE PERCUE ?.3', 'ASPIRATIONS.3', 'VALEURS / TRAITS DE CARACTERE.3', \"QUELLE EST L'EMPREINTE CARBONE ANNUELLE DU PERSONNAGE ?\", \"Voulez-vous estimer l'empreinte carbone d'un autre personnage ?\", \"QUELLE EST L'EMPREINTE CARBONE ANNUELLE DU PERSONNAGE ?.1\", \"Voulez-vous estimer l'empreinte carbone d'un autre personnage ?.1\", \"QUELLE EST L'EMPREINTE CARBONE ANNUELLE DU PERSONNAGE ?.2\", \"Voulez-vous estimer l'empreinte carbone d'un autre personnage ?.2\", \"QUELLE EST L'EMPREINTE CARBONE ANNUELLE DU PERSONNAGE ?.3\", 'CONSOMMATION & MATERIALISME', 'CONSOMMATION & MATERIALISME.1', 'MODES DE VIE', 'MODES DE VIE.1', 'RAPPORT AU VIVANT', 'RAPPORT AU VIVANT.1', 'CRISE ENVIRONNEMENTALE', 'CRISE ENVIRONNEMENTALE.1', 'Y A-T-IL UNE PRISE DE RECUL ?', 'EST-CE NECESSAIRE ?', 'QUELQUE CHOSE A AJOUTER ?', 'VOTRE EMAIL ?', 'Traitement du récit', 'Type de monde du récit', 'VALEURS / TRAITS DE CARACTÈRE', 'MORPHOLOGIE 2/2 (OPTIONNEL)', 'VALEURS / TRAITS DE CARACTÈRE.1', 'VALEURS / TRAITS DE CARACTÈRE.2', 'MORPHOLOGIE 2/2 (OPTIONNEL).1', 'MORPHOLOGIE 2/2 (OPTIONNEL).2', 'MORPHOLOGIE 2/2 (OPTIONNEL).3', 'VALEURS / TRAITS DE CARACTERE.4', 'VALEURS / TRAITS DE CARACTERE.5', 'VALEURS / TRAITS DE CARACTERE.6', 'Unnamed: 116', 'Unnamed: 117', 'Unnamed: 118', 'Unnamed: 119', 'Unnamed: 120', 'Unnamed: 121', 'Unnamed: 122', 'Unnamed: 123', 'Unnamed: 124', 'Unnamed: 125']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# colonnes\n",
+    "print(list(data.columns))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Le nombre de réponses est de \n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "203"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "titre = \"TITRE DU CONTENU\"\n",
+    "c = data[titre].count()\n",
+    "print('Le nombre de réponses est de ')\n",
+    "c "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'Non-empty count': 54,\n",
+       " 'Unique non-empty entries': 54,\n",
+       " 'Sample entries': [\"Ce genre de série ne s'intéresse pas au mode de vie des protagonistes principaux, on est concentré sur leur boulot et leur problèmes sentimentaux. Néanmoins dans le boulot utilisation de gros SUV ou 4x4 non indispensables\",\n",
+       "  'Un film assez ancien des années 80 mais finalement qui interroge sur le mode de vie \"moderne\" et considéré comme l\\'aspiration et la norme de l\\'époque. ',\n",
+       "  'Série plutôt écolo mais pas spécialement proactive sur le sujet. Prône l’égalité et le dialogue, ce qui est déjà beaucoup !',\n",
+       "  'Série qui correspond vraiment à la mentalité des années 2000 sur ces sujets.',\n",
+       "  'Voilà un exemple très intéressant : le film se passe dans un monde pour l\\'essentiel réaliste, dans une société contemporaine et occidental. Il obtient pourtant un score très neutre pour deux raisons : il y a des objets, des voitures, des smartphones, mais on ne les \"voit\" pas, ils ne sont jamais saillants, ils sont toujours intégré dans l\\'image d\\'une manière qui renforce son effet graphique sans les valoriser ou mettre en évidence leur fonction. Deux : la nature occupe une place importante (c\\'est peut-être réellement le cas à la Nouvelle Orléans ?) et, alors même que l\\'action se déroule en ville, on ne se sent pas oppressé']}"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "# Analyzing the \"QUELQUE CHOSE A AJOUTER ?\" column to understand its content\n",
+    "# Check if the column exists\n",
+    "if \"QUELQUE CHOSE A AJOUTER ?\" in data.columns:\n",
+    "    # Basic analysis of the column\n",
+    "    # Count of non-empty entries\n",
+    "    non_empty_count = data[\"QUELQUE CHOSE A AJOUTER ?\"].notna().sum()\n",
+    "    # Unique non-empty entries\n",
+    "    unique_non_empty_entries = data[\"QUELQUE CHOSE A AJOUTER ?\"].nunique()\n",
+    "    # Sample of non-empty entries\n",
+    "    sample_entries = data[\"QUELQUE CHOSE A AJOUTER ?\"].dropna().sample(min(5, non_empty_count)).tolist()\n",
+    "    analysis_results = {\n",
+    "        \"Non-empty count\": non_empty_count,\n",
+    "        \"Unique non-empty entries\": unique_non_empty_entries,\n",
+    "        \"Sample entries\": sample_entries\n",
+    "    }\n",
+    "else:\n",
+    "    analysis_results = \"Column 'QUELQUE CHOSE A AJOUTER ?' does not exist in the dataset.\"\n",
+    "\n",
+    "analysis_results\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "TITRE DU CONTENU\n",
+       "Polar park                3\n",
+       "Une année difficile       3\n",
+       "Sambre                    3\n",
+       "Le règne animal           3\n",
+       "Anatomie d'une chute      2\n",
+       "Voleuses                  2\n",
+       "D'argent et de sang       2\n",
+       "The Crown                 2\n",
+       "Polar Park                2\n",
+       "Bodies                    2\n",
+       "À plein temps             2\n",
+       "Revoir Paris              2\n",
+       "Le livre des solutions    2\n",
+       "Yannick                   2\n",
+       "Sense8                    2\n",
+       "Second Tour               2\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Trouver les titres qui apparaissent plus de 4 fois dans la colonne \"TITRE\" (car chaque titre a 4 lignes, une pour chaque personnage)\n",
+    "titles_more_than_once = data[titre].value_counts()\n",
+    "titles_more_than_once = titles_more_than_once[titles_more_than_once > 1]\n",
+    "\n",
+    "titles_more_than_once\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([2023, 2016, 2022, 1997, 2015, 2006, 2018, 2021, 1984, 1968, 2020,\n",
+       "       2019, 1971, 2017, 2001, 2012, 1987, 2005, 1975, 1982, 2013, 2014,\n",
+       "       2010, 1994, 2009, 1988, 2000, 2011, 1999, 1957, 2002])"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# annee = \"ANNEE\"\n",
+    "annee = \"ANNÉE DE PRODUCTION\"\n",
+    "\n",
+    "# Extract unique values from the \"ANNEE\" column to understand its format\n",
+    "unique_years = data[annee].unique()\n",
+    "\n",
+    "# Display a few unique values for inspection\n",
+    "unique_years[:100]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def visualize_year_distribution(years_data, chart_title):\n",
+    "    \"\"\"\n",
+    "    Visualise la distribution des années, y compris les intervalles, dans un ensemble de données d'années.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    - years_data (list or pd.Series): Un tableau ou une série Pandas contenant des années ou des intervalles d'années.\n",
+    "    \n",
+    "    Returns:\n",
+    "    - Affiche un histogramme de la distribution des années.\n",
+    "    \"\"\"\n",
+    "    import pandas as pd\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    import re  # For regular expression operations\n",
+    "    \n",
+    "    \n",
+    "    # Convertir toutes les valeurs en chaînes pour gérer les intervalles potentiels comme des entrées uniques\n",
+    "    years_data = years_data.astype(str)\n",
+    "    \n",
+    "    # Séparer les intervalles en années individuelles et compter la fréquence de chaque année\n",
+    "    all_years = []\n",
+    "    # Utilise un set pour les valeurs non numériques\n",
+    "    non_numeric_entries = set()\n",
+    "    \n",
+    "    for year in years_data:\n",
+    "        if re.search(r'[a-z]', year):  # If there are no digits in the string\n",
+    "            non_numeric_entries.add(year)\n",
+    "        elif \",\" in year:\n",
+    "            years_list = year.split(\",\")\n",
+    "            for y in years_list:\n",
+    "                all_years.append(int(y.strip()))  # Ajouter chaque année en la convertissant en entier\n",
+    "        elif \"+/-\" in year:  # Vérifier si c'est un intervalle\n",
+    "            start_year, uncertainty = year.split(\"+/-\")\n",
+    "            if (start_year != ''):\n",
+    "                 all_years.extend(range(int(start_year), int(start_year) + uncertainty + 1))\n",
+    "                 print(year)\n",
+    "            else:\n",
+    "                non_numeric_entries.add(year)\n",
+    "        elif \"-\" in year:  # Vérifier si c'est un intervalle\n",
+    "            start_year, end_year = year.split(\"-\")\n",
+    "            all_years.extend(range(int(start_year), int(end_year) + 1))\n",
+    "        elif  \"/\" in year:  # Vérifier si c'est un intervalle\n",
+    "            start_year, end_year = year.split(\"/\")\n",
+    "            all_years.extend(range(int(start_year), int(end_year) + 1))\n",
+    "        else:\n",
+    "            all_years.append(int(year))\n",
+    "    \n",
+    "    # Print non-numeric entries if any\n",
+    "    if non_numeric_entries:\n",
+    "        print(\"Non-numeric entries found:\", non_numeric_entries)\n",
+    "    \n",
+    "    # Proceed with visualization only if there are numeric years\n",
+    "    if all_years:\n",
+    "        # Créer un DataFrame à partir de la liste des années pour faciliter la visualisation\n",
+    "        df_years = pd.DataFrame(all_years, columns=[\"Year\"])\n",
+    "        \n",
+    "        # Visualiser la distribution des années avec un histogramme\n",
+    "        plt.figure(figsize=(10, 6))\n",
+    "        df_years[\"Year\"].hist(bins=len(df_years[\"Year\"].unique()), color=\"skyblue\", edgecolor=\"black\")\n",
+    "        plt.title(chart_title)\n",
+    "        plt.xlabel(\"Année\")\n",
+    "        plt.ylabel(\"Fréquence\")\n",
+    "        plt.xticks(rotation=45)\n",
+    "        plt.tight_layout()\n",
+    "        plt.show()\n",
+    "    else:\n",
+    "        print(\"No numeric years found for visualization.\")\n",
+    "    return all_years\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Convertir toutes les valeurs en chaînes pour gérer les intervalles potentiels comme des entrées uniques\n",
+    "data[annee] = data[annee].astype(str)\n",
+    "all_prod_years = visualize_year_distribution(data[annee], 'Distribution des années de production')\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Non-numeric entries found: {'autour de 2020/2030', 'Dans le futur, année non précisée ', 'Milieu du XXI siècle', 'Contemporaine', 'Actuel ', 'Dans un futur très proche ', 'Années 1970s', 'Actuelle', '2030 - 2040 (futur proche)', 'Années 80', '+/- 1930', 'le futur (relation avec notre époque non connue par les personnages)', 'Années 2010/2020', 'Contemporain', 'Actuellement et il y a environ 50 ans', '1969-1995 (mais uchronie...)', 'Periode actuelle', 'Futur tres proche', 'De nos jours', 'Futur proche ou epoque parallele', \"Aujourd'hui \", 'Tous les 33 ans ', 'notre époque', 'Sur plusieurs siecles', 'autour de 2020', 'Contemporainre', 'Années 50', 'années 80', 'Années 2020', 'un futur proche ', 'actuelle', 'Futur ressemblant aux USA actuels', '2022 post Covid ', 'années 2000', 'Contemporain ', 'Décembre 1999 et avril 2010'}\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAJOCAYAAABBfN/cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkeklEQVR4nO3de3yP9f/H8edns82GbUY2Q8gx51NJ5JAxx0pKJEnDt6JCRx2ElEiIlHwrUiqpSApbqJXkfIjklENOWwyzjW32ef/+8N3n52Nz2OzyuWyP++3WLdd1vT+f63V9Xru2PXedHMYYIwAAAAAAYAkvTxcAAAAAAEB+RvAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAHDFJk+erE8++cTTZeAypaen64033tB3333n6VIAoEAgeAMArtjw4cPlcDiuyrpatmypli1buqZ/+uknORwOffXVV1dl/Q899JAqVKhwVdZ1OTK3/6effvJYDZMnT9bIkSN1yy23eKyGa9GMGTPkcDi0Z8+eq77u559/Xh988EGuerZnzx45HA7NmDEj7wsDgHyK4A0AcJMZBjL/K1y4sMLDwxUZGalJkybp5MmTebKegwcPavjw4dqwYUOevF9esnNtdrN69WoNGzZM3333napUqeLpcnAZvv32W3366adatGiRrrvuujx5zx9++EHDhw/Pk/cCgPyI4A0AyNbIkSP1ySef6L333tPjjz8uSRo0aJBq166tTZs2uY196aWXdOrUqRy9/8GDBzVixIgch9vo6GhFR0fn6DU5dbHa/vvf/2rbtm2Wrv9asmXLFn399dcc7b6G7NmzRwsXLlTlypVz9fry5cvr1KlT6tWrl2veDz/8oBEjRuRViQCQ7xTydAEAAHtq3769GjVq5JoeOnSoli5dqk6dOumOO+7Q1q1b5e/vL0kqVKiQChWy9kdKSkqKAgIC5Ovra+l6LsXHx8ej67ebhx56yNMl4CLOnDkjp9Pptt88+eSTV/SemWfCAAAuH0e8AQCX7fbbb9fLL7+svXv36tNPP3XNz+4a75iYGDVr1kzBwcEqWrSoqlWrphdeeEHS2euSb7rpJklSnz59XKe1Z14z2rJlS9WqVUtr165V8+bNFRAQ4Hrt+dd4Z8rIyNALL7ygsLAwFSlSRHfccYf++ecftzEVKlTINiie+56Xqi27a7yTk5P11FNPqVy5cvLz81O1atU0btw4GWPcxjkcDg0cOFDz5s1TrVq15Ofnp5o1a2rRokXZf+Dn2b9/v+666y4VKVJEpUqV0uDBg5Wamprt2JUrV6pdu3YKCgpSQECAWrRooeXLl7uNOXnypAYNGqQKFSrIz89PpUqVUps2bbRu3bpL1nLgwAE9/PDDCg0NdW3HRx995DYm8/rz2bNnX7I3kjRnzhw1bNhQ/v7+KlmypB544AEdOHAgy7jMz69w4cKqVauW5s6dm6UvF7r2/ULXJ//111+65557FBISosKFC6tRo0aaP3++25j09HSNGDFCVapUUeHChVWiRAk1a9ZMMTExl/y8tmzZottvv13+/v4qW7asRo0aJafTmWWcw+HI9pTtC33tZrdt48aN08SJE1WpUiX5+fnpzz//vOxtlKTjx49r8ODBrq+LsmXL6sEHH9SRI0fc1nPuPjFlyhRX/Zn/AQD+H0e8AQA50qtXL73wwguKjo5Wv379sh2zZcsWderUSXXq1NHIkSPl5+ennTt3uoLfjTfeqJEjR2rYsGHq37+/brvtNknSrbfe6nqPo0ePqn379urevbseeOABhYaGXrSu1157TQ6HQ88995zi4+M1ceJERUREaMOGDa4j85fjcmo7lzFGd9xxh5YtW6aoqCjVq1dPixcv1jPPPKMDBw5owoQJbuN//fVXffPNN3rsscdUrFgxTZo0SV27dtW+fftUokSJC9Z16tQptW7dWvv27dMTTzyh8PBwffLJJ1q6dGmWsUuXLlX79u3VsGFDvfLKK/Ly8tL06dN1++2365dfftHNN98sSXrkkUf01VdfaeDAgapRo4aOHj2qX3/9VVu3blWDBg0uWEtcXJxuueUW1x8SrrvuOi1cuFBRUVFKTEzUoEGD3MZfTm9mzJihPn366KabbtLo0aMVFxent99+W8uXL9f69esVHBws6eylBl27dlWNGjU0evRoHT16VH369FHZsmUvWO+lbNmyRU2bNlWZMmX0/PPPq0iRIvryyy9111136euvv1aXLl0knf0D0+jRo9W3b1/dfPPNSkxM1Jo1a7Ru3Tq1adPmgu9/+PBhtWrVSmfOnHG9/7Rp03L0dZkT06dP1+nTp9W/f3/5+fkpJCTksrcxKSlJt912m7Zu3aqHH35YDRo00JEjRzR//nzt379fJUuWzLK+//znPzp48KBiYmK4sz0AXIgBAOAc06dPN5LM6tWrLzgmKCjI1K9f3zX9yiuvmHN/pEyYMMFIMv/+++8F32P16tVGkpk+fXqWZS1atDCSzNSpU7Nd1qJFC9f0smXLjCRTpkwZk5iY6Jr/5ZdfGknm7bffds0rX7686d279yXf82K19e7d25QvX941PW/ePCPJjBo1ym3cPffcYxwOh9m5c6drniTj6+vrNm/jxo1Gkpk8eXKWdZ1r4sSJRpL58ssvXfOSk5NN5cqVjSSzbNkyY4wxTqfTVKlSxURGRhqn0+kam5KSYipWrGjatGnjmhcUFGQGDBhw0fVmJyoqypQuXdocOXLEbX737t1NUFCQSUlJMcZcfm/S0tJMqVKlTK1atcypU6dc4xYsWGAkmWHDhrnm1atXz5QuXdocP37cNS86OtpIcutL5rozP5dMu3fvztLb1q1bm9q1a5vTp0+75jmdTnPrrbeaKlWquObVrVvXdOzYMQef1FmDBg0ykszKlStd8+Lj401QUJCRZHbv3u2aL8m88sorWd7jQl+72W1bYGCgiY+Pd1t2uds4bNgwI8l88803Wd4/8+spu89wwIABhl8rAeDCONUcAJBjRYsWvejdzTOPTn777bfZnk57Ofz8/NSnT5/LHv/ggw+qWLFirul77rlHpUuX1g8//JCr9V+uH374Qd7e3nriiSfc5j/11FMyxmjhwoVu8yMiIlSpUiXXdJ06dRQYGKi///77kuspXbq07rnnHte8gIAA9e/f323chg0btGPHDt1///06evSojhw5oiNHjig5OVmtW7dWbGysqyfBwcFauXKlDh48eNnba4zR119/rc6dO8sY43r/I0eOKDIyUidOnMhyqvqlerNmzRrFx8frsccec7t2uGPHjqpevbq+//57SdKhQ4e0YcMG9e7dW0FBQa5xbdq0UY0aNS57G86VkJCgpUuXqlu3bjp58qRrW44eParIyEjt2LHDdbp7cHCwtmzZoh07duRoHT/88INuueUW15kGknTdddepZ8+euar5Urp27ep2t/KcbOPXX3+tunXruo6An4vTxwEg9wjeAIAcS0pKcgtS57vvvvvUtGlT9e3bV6Ghoerevbu+/PLLHIXwMmXK5OhGauc/ysrhcKhy5cqWPyN57969Cg8Pz/J53Hjjja7l57r++uuzvEfx4sV17NixS66ncuXKWcJPtWrV3KYzQ2Hv3r113XXXuf33wQcfKDU1VSdOnJAkjR07Vps3b1a5cuV08803a/jw4Zf8A8C///6r48ePa9q0aVneP/MPJfHx8W6vuVRvMj+j87dFkqpXr+5anvn/7B5blt1rL8fOnTtljNHLL7+cZXteeeUVt+0ZOXKkjh8/rqpVq6p27dp65plnstzhPzt79+7N05ovpWLFim7TOdnGXbt2qVatWpbUBQAFGdd4AwByZP/+/Tpx4sRFH0Xk7++v2NhYLVu2TN9//70WLVqk2bNn6/bbb1d0dLS8vb0vuR4rrn+90BG7jIyMy6opL1xoPea8G7HlVuYfN958803Vq1cv2zFFixaVJHXr1k233Xab5s6dq+joaL355psaM2aMvvnmG7Vv3/6i7//AAw+od+/e2Y6pU6fOFW7FlbtYr8+VuT1PP/20IiMjs31N5td68+bNtWvXLn377beKjo7WBx98oAkTJmjq1Knq27dvHlZ/6bov5vx9JyfbCACwBsEbAJAjmTdPutAv8Jm8vLzUunVrtW7dWuPHj9frr7+uF198UcuWLVNERESen7Z6/um/xhjt3LnTLQQWL15cx48fz/LavXv36oYbbnBN56S28uXL68cff9TJkyfdjnr/9ddfruV5oXz58tq8ebOMMW71nf9M8czT2AMDAxUREXHJ9y1durQee+wxPfbYY4qPj1eDBg302muvXTB4X3fddSpWrJgyMjIu6/2lS/cm8zPatm2bbr/9drex27Ztcy3P/H92p3qf/zkUL15ckrL0+/wzEDL77uPjc1nbExISoj59+qhPnz5KSkpS8+bNNXz48IsG7/Lly19WzZl1n19zWlqaDh06dMnaLiQn21ipUiVt3rw5x+vgNHQAuDhONQcAXLalS5fq1VdfVcWKFS96fWpCQkKWeZlHXzMff1WkSBFJWYNRbs2cOdPtuvOvvvpKhw4dcguQlSpV0u+//660tDTXvAULFmR5tFVOauvQoYMyMjL0zjvvuM2fMGGCHA7HBQNsTnXo0EEHDx7UV1995ZqXkpKiadOmuY1r2LChKlWqpHHjxikpKSnL+/z777+Szh5BzTzlPFOpUqUUHh5+wUeUSWeP2Hft2lVff/11tgEt8/3PdaneNGrUSKVKldLUqVPd1r1w4UJt3bpVHTt2lHT2jwT16tXTxx9/7FZ7TEyM65FZmcqXLy9vb2/Fxsa6zX/33XezbHPLli31/vvvZxtuz92eo0ePui0rWrSoKleufNHPSzrbu99//12rVq1ye99Zs2ZlGVupUqUsNU+bNi1HR7zPl5Nt7Nq1qzZu3Ki5c+dmGXexszLyen8GgPyGI94AgGwtXLhQf/31l86cOaO4uDgtXbpUMTExKl++vObPn+92E6zzjRw5UrGxserYsaPKly+v+Ph4vfvuuypbtqyaNWsm6WzACA4O1tSpU1WsWDEVKVJEjRs3znJ96uUKCQlRs2bN1KdPH8XFxWnixImqXLmy2yPP+vbtq6+++krt2rVTt27dtGvXLn366aduNzvLaW2dO3dWq1at9OKLL2rPnj2qW7euoqOj9e2332rQoEFZ3ju3+vXrp3feeUcPPvig1q5dq9KlS+uTTz5RQECA2zgvLy998MEHat++vWrWrKk+ffqoTJkyOnDggJYtW6bAwEB99913OnnypMqWLat77rlHdevWVdGiRfXjjz9q9erVeuutty5ayxtvvKFly5apcePG6tevn2rUqKGEhAStW7dOP/74Y5Y/vFyqNz4+PhozZoz69OmjFi1aqEePHq7HiVWoUEGDBw92vdfo0aPVsWNHNWvWTA8//LASEhI0efJk1axZ0+0PDUFBQbr33ns1efJkORwOVapUSQsWLMhy/bkkTZkyRc2aNVPt2rXVr18/3XDDDYqLi9OKFSu0f/9+bdy4UZJUo0YNtWzZUg0bNlRISIjWrFnjehzbxTz77LP65JNP1K5dOz355JOux4mVL18+yzXiffv21SOPPKKuXbuqTZs22rhxoxYvXpztY7xy4nK38ZlnntFXX32le++9Vw8//LAaNmyohIQEzZ8/X1OnTlXdunWzff+GDRtKkp544glFRkbK29tb3bt3v6KaASBf8dTt1AEA9pT5OLHM/3x9fU1YWJhp06aNefvtt90eC5Xp/MeJLVmyxNx5550mPDzc+Pr6mvDwcNOjRw+zfft2t9d9++23pkaNGqZQoUJujydq0aKFqVmzZrb1XehxYp9//rkZOnSoKVWqlPH39zcdO3Y0e/fuzfL6t956y5QpU8b4+fmZpk2bmjVr1mR5z4vVdv7jxIwx5uTJk2bw4MEmPDzc+Pj4mCpVqpg333zT7XFexpx9VFR2j++6nEdFGWPM3r17zR133GECAgJMyZIlzZNPPmkWLVqU7WOz1q9fb+6++25TokQJ4+fnZ8qXL2+6detmlixZYowxJjU11TzzzDOmbt26plixYqZIkSKmbt265t13371kHcYYExcXZwYMGGDKlStnfHx8TFhYmGndurWZNm2aa0xOezN79mxTv3594+fnZ0JCQkzPnj3N/v37s4z7+uuvzY033mj8/PxMjRo1zDfffJNtX/7991/TtWtXExAQYIoXL27+85//mM2bN2f7qLhdu3aZBx980ISFhRkfHx9TpkwZ06lTJ/PVV1+5xowaNcrcfPPNJjg42Pj7+5vq1aub1157zaSlpV3y89q0aZNp0aKFKVy4sClTpox59dVXzYcffpjlcWIZGRnmueeeMyVLljQBAQEmMjLS7Ny5M0ePE3vzzTezXX4522iMMUePHjUDBw40ZcqUMb6+vqZs2bKmd+/ersfHZfc4sTNnzpjHH3/cXHfddcbhcPBoMQA4j8OYPLqbCwAAwDl++ukntWrVSnPmzHF7DJoVHnroIf3000+W38UeAIDc4BpvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACzENd4AAAAAAFiII94AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWKiQpwu4VjidTh08eFDFihWTw+HwdDkAAAAAAA8yxujkyZMKDw+Xl9fFj2kTvC/TwYMHVa5cOU+XAQAAAACwkX/++Udly5a96BiC92UqVqyYpLMfamBgoIeryV56erqio6PVtm1b+fj4eLociJ7YFX2xH3piP/TEnuiL/dAT+6En9pQf+5KYmKhy5cq5suLFELwvU+bp5YGBgbYO3gEBAQoMDMw3X8zXOnpiT/TFfuiJ/dATe6Iv9kNP7Iee2FN+7svlXIrMzdUAAAAAALCQx4N3bGysOnfurPDwcDkcDs2bN++CYx955BE5HA5NnDjRbX5CQoJ69uypwMBABQcHKyoqSklJSW5jNm3apNtuu02FCxdWuXLlNHbsWAu2BgAAAAAAdx4P3snJyapbt66mTJly0XFz587V77//rvDw8CzLevbsqS1btigmJkYLFixQbGys+vfv71qemJiotm3bqnz58lq7dq3efPNNDR8+XNOmTcvz7QEAAAAA4Fwev8a7ffv2at++/UXHHDhwQI8//rgWL16sjh07ui3bunWrFi1apNWrV6tRo0aSpMmTJ6tDhw4aN26cwsPDNWvWLKWlpemjjz6Sr6+vatasqQ0bNmj8+PFuAR0AAAAAgLzm8SPel+J0OtWrVy8988wzqlmzZpblK1asUHBwsCt0S1JERIS8vLy0cuVK15jmzZvL19fXNSYyMlLbtm3TsWPHrN8IAAAAAECB5fEj3pcyZswYFSpUSE888US2yw8fPqxSpUq5zStUqJBCQkJ0+PBh15iKFSu6jQkNDXUtK168eJb3TU1NVWpqqms6MTFR0tm78aWnp+d+gyyUWZdd6yuI6Ik90Rf7oSf2Q0/sib7YDz2xH3piT/mxLznZFlsH77Vr1+rtt9/WunXrLusW7Xlp9OjRGjFiRJb50dHRCggIuKq15FRMTIynS8B56Ik90Rf7oSf2Q0/sib7YDz2xH3piT/mpLykpKZc91tbB+5dfflF8fLyuv/5617yMjAw99dRTmjhxovbs2aOwsDDFx8e7ve7MmTNKSEhQWFiYJCksLExxcXFuYzKnM8ecb+jQoRoyZIhrOvPh6G3btrX1c7xjYmLUpk2bfPdsvGsVPbEn+mI/9MR+6Ik90Rf7oSf2Q0/sKT/2JfOs6Mth6+Ddq1cvRUREuM2LjIxUr1691KdPH0lSkyZNdPz4ca1du1YNGzaUJC1dulROp1ONGzd2jXnxxReVnp7uanJMTIyqVauW7WnmkuTn5yc/P78s8318fGz/hXIt1FjQ0BN7oi/2Q0/sh57YE32xH3piP/TEnvJTX3KyHR4P3klJSdq5c6drevfu3dqwYYNCQkJ0/fXXq0SJEm7jfXx8FBYWpmrVqkmSbrzxRrVr1079+vXT1KlTlZ6eroEDB6p79+6uR4/df//9GjFihKKiovTcc89p8+bNevvttzVhwoSrt6EAAAAAgALJ48F7zZo1atWqlWs68/Tu3r17a8aMGZf1HrNmzdLAgQPVunVreXl5qWvXrpo0aZJreVBQkKKjozVgwAA1bNhQJUuW1LBhw3iUGAAAAADAch4P3i1btpQx5rLH79mzJ8u8kJAQffbZZxd9XZ06dfTLL7/ktDwAAAAAAK6I7Z/jDQAAAADAtYzgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWMjjz/FG3tu4caO8vM7+TaVkyZK6/vrrPVwRAAAAABRcBO98ZP/+/ZKk5s2b69SpU5Ik/4AA/bV1K+EbAAAAADyE4J2PHD16VJLU5eUJCilfWfG7d+jLlx7VkSNHCN4AAAAA4CEE73zouvKVFHZjXU+XAQAAAAAQN1cDAAAAAMBSBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALOTx4B0bG6vOnTsrPDxcDodD8+bNcy1LT0/Xc889p9q1a6tIkSIKDw/Xgw8+qIMHD7q9R0JCgnr27KnAwEAFBwcrKipKSUlJbmM2bdqk2267TYULF1a5cuU0duzYq7F5AAAAAIACzuPBOzk5WXXr1tWUKVOyLEtJSdG6dev08ssva926dfrmm2+0bds23XHHHW7jevbsqS1btigmJkYLFixQbGys+vfv71qemJiotm3bqnz58lq7dq3efPNNDR8+XNOmTbN8+wAAAAAABVshTxfQvn17tW/fPttlQUFBiomJcZv3zjvv6Oabb9a+fft0/fXXa+vWrVq0aJFWr16tRo0aSZImT56sDh06aNy4cQoPD9esWbOUlpamjz76SL6+vqpZs6Y2bNig8ePHuwV0AAAAAADymsePeOfUiRMn5HA4FBwcLElasWKFgoODXaFbkiIiIuTl5aWVK1e6xjRv3ly+vr6uMZGRkdq2bZuOHTt2VesHAAAAABQsHj/inROnT5/Wc889px49eigwMFCSdPjwYZUqVcptXKFChRQSEqLDhw+7xlSsWNFtTGhoqGtZ8eLFs6wrNTVVqamprunExERJZ687T09Pz7uNykNOp1OS5C0jL+cZecvI399fTqfTtjXnd5mfO5+/vdAX+6En9kNP7Im+2A89sR96Yk/5sS852ZZrJninp6erW7duMsbovffes3x9o0eP1ogRI7LMj46OVkBAgOXrvxLNi6RI+1eqWhGp1eef68CBAzpw4ICnyyrQzr9kAvZAX+yHntgPPbEn+mI/9MR+6Ik95ae+pKSkXPbYayJ4Z4buvXv3aunSpa6j3ZIUFham+Ph4t/FnzpxRQkKCwsLCXGPi4uLcxmROZ44539ChQzVkyBDXdGJiosqVK6e2bdu6rd9O1q9fr0OHDik2OUCh1Wrr4LbNmtb3DsXGxqpu3bqeLq9ASk9PV0xMjNq0aSMfHx9Pl4P/oS/2Q0/sh57YE32xH3piP/TEnvJjXzLPir4ctg/emaF7x44dWrZsmUqUKOG2vEmTJjp+/LjWrl2rhg0bSpKWLl0qp9Opxo0bu8a8+OKLSk9PdzU5JiZG1apVy/Y0c0ny8/OTn59flvk+Pj62/ULx8jp7yX6GHHJ6FVKGHDp16pS8vLxsW3NBYeevm4KMvtgPPbEfemJP9MV+6In90BN7yk99ycl2ePzmaklJSdqwYYM2bNggSdq9e7c2bNigffv2KT09Xffcc4/WrFmjWbNmKSMjQ4cPH9bhw4eVlpYmSbrxxhvVrl079evXT6tWrdLy5cs1cOBAde/eXeHh4ZKk+++/X76+voqKitKWLVs0e/Zsvf32225HtAEAAAAAsILHj3ivWbNGrVq1ck1nhuHevXtr+PDhmj9/viSpXr16bq9btmyZWrZsKUmaNWuWBg4cqNatW8vLy0tdu3bVpEmTXGODgoIUHR2tAQMGqGHDhipZsqSGDRvGo8QAAAAAAJbzePBu2bKljDEXXH6xZZlCQkL02WefXXRMnTp19Msvv+S4PgAAAAAAroTHTzUHAAAAACA/I3gDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGPB+/Y2Fh17txZ4eHhcjgcmjdvnttyY4yGDRum0qVLy9/fXxEREdqxY4fbmISEBPXs2VOBgYEKDg5WVFSUkpKS3MZs2rRJt912mwoXLqxy5cpp7NixVm8aAAAAAACeD97JycmqW7eupkyZku3ysWPHatKkSZo6dapWrlypIkWKKDIyUqdPn3aN6dmzp7Zs2aKYmBgtWLBAsbGx6t+/v2t5YmKi2rZtq/Lly2vt2rV68803NXz4cE2bNs3y7QMAAAAAFGyFPF1A+/bt1b59+2yXGWM0ceJEvfTSS7rzzjslSTNnzlRoaKjmzZun7t27a+vWrVq0aJFWr16tRo0aSZImT56sDh06aNy4cQoPD9esWbOUlpamjz76SL6+vqpZs6Y2bNig8ePHuwV0AAAAAADymseD98Xs3r1bhw8fVkREhGteUFCQGjdurBUrVqh79+5asWKFgoODXaFbkiIiIuTl5aWVK1eqS5cuWrFihZo3by5fX1/XmMjISI0ZM0bHjh1T8eLFs6w7NTVVqamprunExERJUnp6utLT063Y3CvmdDolSd4y8nKekbeM/P395XQ6bVtzfpf5ufP52wt9sR96Yj/0xJ7oi/3QE/uhJ/aUH/uSk22xdfA+fPiwJCk0NNRtfmhoqGvZ4cOHVapUKbflhQoVUkhIiNuYihUrZnmPzGXZBe/Ro0drxIgRWeZHR0crICAgl1t0dTQvkiLtX6lqRaRWn3+uAwcO6MCBA54uq0CLiYnxdAnIBn2xH3piP/TEnuiL/dAT+6En9pSf+pKSknLZY20dvD1p6NChGjJkiGs6MTFR5cqVU9u2bRUYGOjByi5s/fr1OnTokGKTAxRarbYObtusaX3vUGxsrOrWrevp8gqk9PR0xcTEqE2bNvLx8fF0Ofgf+mI/9MR+6Ik90Rf7oSf2Q0/sKT/2JfOs6Mth6+AdFhYmSYqLi1Pp0qVd8+Pi4lSvXj3XmPj4eLfXnTlzRgkJCa7Xh4WFKS4uzm1M5nTmmPP5+fnJz88vy3wfHx/bfqF4eZ29V16GHHJ6FVKGHDp16pS8vLxsW3NBYeevm4KMvtgPPbEfemJP9MV+6In90BN7yk99ycl2ePyu5hdTsWJFhYWFacmSJa55iYmJWrlypZo0aSJJatKkiY4fP661a9e6xixdulROp1ONGzd2jYmNjXU7Bz8mJkbVqlXL9jRzAAAAAADyiseDd1JSkjZs2KANGzZIOntDtQ0bNmjfvn1yOBwaNGiQRo0apfnz5+uPP/7Qgw8+qPDwcN11112SpBtvvFHt2rVTv379tGrVKi1fvlwDBw5U9+7dFR4eLkm6//775evrq6ioKG3ZskWzZ8/W22+/7XYqOQAAAAAAVvD4qeZr1qxRq1atXNOZYbh3796aMWOGnn32WSUnJ6t///46fvy4mjVrpkWLFqlw4cKu18yaNUsDBw5U69at5eXlpa5du2rSpEmu5UFBQYqOjtaAAQPUsGFDlSxZUsOGDeNRYgAAAAAAy3k8eLds2VLGmAsudzgcGjlypEaOHHnBMSEhIfrss88uup46derol19+yXWdAAAAAADkhsdPNQcAAAAAID8jeAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFrJ98M7IyNDLL7+sihUryt/fX5UqVdKrr74qY4xrjDFGw4YNU+nSpeXv76+IiAjt2LHD7X0SEhLUs2dPBQYGKjg4WFFRUUpKSrramwMAAAAAKGCuOHjv3LlTixcv1qlTpyTJLRDnhTFjxui9997TO++8o61bt2rMmDEaO3asJk+e7BozduxYTZo0SVOnTtXKlStVpEgRRUZG6vTp064xPXv21JYtWxQTE6MFCxYoNjZW/fv3z9NaAQAAAAA4X66D99GjRxUREaGqVauqQ4cOOnTokCQpKipKTz31VJ4V+Ntvv+nOO+9Ux44dVaFCBd1zzz1q27atVq1aJels0J84caJeeukl3XnnnapTp45mzpypgwcPat68eZKkrVu3atGiRfrggw/UuHFjNWvWTJMnT9YXX3yhgwcP5lmtAAAAAACcr1BuXzh48GAVKlRI+/bt04033uiaf99992nIkCF666238qTAW2+9VdOmTdP27dtVtWpVbdy4Ub/++qvGjx8vSdq9e7cOHz6siIgI12uCgoLUuHFjrVixQt27d9eKFSsUHBysRo0aucZERETIy8tLK1euVJcuXbKsNzU1Vampqa7pxMRESVJ6errS09PzZNvymtPplCR5y8jLeUbeMvL395fT6bRtzfld5ufO528v9MV+6In90BN7oi/2Q0/sh57YU37sS062JdfBOzo6WosXL1bZsmXd5lepUkV79+7N7dtm8fzzzysxMVHVq1eXt7e3MjIy9Nprr6lnz56SpMOHD0uSQkND3V4XGhrqWnb48GGVKlXKbXmhQoUUEhLiGnO+0aNHa8SIEVnmR0dHKyAg4Iq3y0rNi6RI+1eqWhGp1eef68CBAzpw4ICnyyrQYmJiPF0CskFf7Iee2A89sSf6Yj/0xH7oiT3lp76kpKRc9thcB+/k5ORsA2hCQoL8/Pxy+7ZZfPnll5o1a5Y+++wz1axZUxs2bNCgQYMUHh6u3r1759l6zjd06FANGTLENZ2YmKhy5cqpbdu2CgwMtGy9V2L9+vU6dOiQYpMDFFqttg5u26xpfe9QbGys6tat6+nyCqT09HTFxMSoTZs28vHx8XQ5+B/6Yj/0xH7oiT3RF/uhJ/ZDT+wpP/Yl86zoy5Hr4H3bbbdp5syZevXVVyVJDodDTqdTY8eOVatWrXL7tlk888wzev7559W9e3dJUu3atbV3716NHj1avXv3VlhYmCQpLi5OpUuXdr0uLi5O9erVkySFhYUpPj7e7X3PnDmjhIQE1+vP5+fnl+0fEHx8fGz7heLldfaS/Qw55PQqpAw5dOrUKXl5edm25oLCzl83BRl9sR96Yj/0xJ7oi/3QE/uhJ/aUn/qSk+3IdfAeO3asWrdurTVr1igtLU3PPvustmzZooSEBC1fvjy3b5tFSkqKK1Bm8vb2dl3PXLFiRYWFhWnJkiWuoJ2YmKiVK1fq0UcflSQ1adJEx48f19q1a9WwYUNJ0tKlS+V0OtW4ceM8qxUAAAAAgPPlOnjXqlVL27dv1zvvvKNixYopKSlJd999twYMGOB25PlKde7cWa+99pquv/561axZU+vXr9f48eP18MMPSzp7pH3QoEEaNWqUqlSpoooVK+rll19WeHi47rrrLknSjTfeqHbt2qlfv36aOnWq0tPTNXDgQHXv3l3h4eF5VisAAAAAAOfLdfCWzt49/MUXX8yrWrI1efJkvfzyy3rssccUHx+v8PBw/ec//9GwYcNcY5599lklJyerf//+On78uJo1a6ZFixapcOHCrjGzZs3SwIED1bp1a3l5ealr166aNGmSpbUDAAAAAJDr4D19+nQVLVpU9957r9v8OXPmKCUlJc9ufFasWDFNnDhREydOvOAYh8OhkSNHauTIkRccExISos8++yxPagIAAAAA4HJ5XXpI9kaPHq2SJUtmmV+qVCm9/vrrV1QUAAAAAAD5Ra6D9759+1SxYsUs88uXL699+/ZdUVEAAAAAAOQXuQ7epUqV0qZNm7LM37hxo0qUKHFFRQEAAAAAkF/kOnj36NFDTzzxhJYtW6aMjAxlZGRo6dKlevLJJ13P3AYAAAAAoKDL9c3VXn31Ve3Zs0etW7dWoUJn38bpdOrBBx/kGm8AAAAAAP4n18Hb19dXs2fP1quvvqqNGzfK399ftWvXVvny5fOyPgAAAAAArmlX9BxvSapataqqVq2aF7UAAAAAAJDv5Dp4Z2RkaMaMGVqyZIni4+PldDrdli9duvSKiwMAAAAA4FqX6+D95JNPasaMGerYsaNq1aolh8ORl3UBAAAAAJAv5Dp4f/HFF/ryyy/VoUOHvKwHAAAAAIB8JdePE/P19VXlypXzshYAAAAAAPKdXAfvp556Sm+//baMMXlZDwAAAAAA+UquTzX/9ddftWzZMi1cuFA1a9aUj4+P2/JvvvnmiosDAAAAAOBal+vgHRwcrC5duuRlLQAAAAAA5Du5Dt7Tp0/PyzoAAAAAAMiXcn2NtySdOXNGP/74o95//32dPHlSknTw4EElJSXlSXEAAAAAAFzrcn3Ee+/evWrXrp327dun1NRUtWnTRsWKFdOYMWOUmpqqqVOn5mWdAAAAAABck3J9xPvJJ59Uo0aNdOzYMfn7+7vmd+nSRUuWLMmT4gAAAAAAuNbl+oj3L7/8ot9++02+vr5u8ytUqKADBw5ccWEAAAAAAOQHuT7i7XQ6lZGRkWX+/v37VaxYsSsqCgAAAACA/CLXwbtt27aaOHGia9rhcCgpKUmvvPKKOnTokBe1AQAAAABwzcv1qeZvvfWWIiMjVaNGDZ0+fVr333+/duzYoZIlS+rzzz/PyxoBAAAAALhm5Tp4ly1bVhs3btQXX3yhTZs2KSkpSVFRUerZs6fbzdYAAAAAACjIch28JalQoUJ64IEH8qoWAAAAAADynVwH75kzZ150+YMPPpjbtwYAAAAAIN/IdfB+8skn3abT09OVkpIiX19fBQQEELwBAAAAANAV3NX82LFjbv8lJSVp27ZtatasGTdXAwAAAADgf3IdvLNTpUoVvfHGG1mOhgMAAAAAUFDlafCWzt5w7eDBg3n9tgAAAAAAXJNyfY33/Pnz3aaNMTp06JDeeecdNW3a9IoLAwAAAAAgP8h18L7rrrvcph0Oh6677jrdfvvteuutt660LgAAAAAA8oVcB2+n05mXdQAAAAAAkC/l+TXeAAAAAADg/+X6iPeQIUMue+z48eNzuxoAAAAAAK5puQ7e69ev1/r165Wenq5q1apJkrZv3y5vb281aNDANc7hcFx5lQAAAAAAXKNyHbw7d+6sYsWK6eOPP1bx4sUlSceOHVOfPn1022236amnnsqzIgEAAAAAuFbl+hrvt956S6NHj3aFbkkqXry4Ro0axV3NAQAAAAD4n1wH78TERP37779Z5v/77786efLkFRUFAAAAAEB+kevg3aVLF/Xp00fffPON9u/fr/379+vrr79WVFSU7r777rysEQAAAACAa1aur/GeOnWqnn76ad1///1KT08/+2aFCikqKkpvvvlmnhUIAAAAAMC1LNfBOyAgQO+++67efPNN7dq1S5JUqVIlFSlSJM+KAwAAAADgWpfrU80zHTp0SIcOHVKVKlVUpEgRGWPyoi4AAAAAAPKFyw7eTqfTbfro0aNq3bq1qlatqg4dOujQoUOSpKioKB4lBgAAAADA/1x28B4/frx++OEH1/TgwYPl4+Ojffv2KSAgwDX/vvvu06JFi/K2SgAAAAAArlGXfY13mzZt1LVrVx06dEhRUVGKjo7W4sWLVbZsWbdxVapU0d69e/O8UAAAAAAArkWXfcS7bt26WrVqlebNmydJSk5OdjvSnSkhIUF+fn55ViAAAAAAANeyHN1cLSQkRN99950k6bbbbtPMmTNdyxwOh5xOp8aOHatWrVrlbZUAAAAAAFyjcv04sbFjx6p169Zas2aN0tLS9Oyzz2rLli1KSEjQ8uXL87JGAAAAAACuWbl+nFitWrW0fft2NWvWTHfeeaeSk5N19913a/369apUqVJe1ggAAAAAwDUrV0e809PT1a5dO02dOlUvvvhiXtcEAAAAAEC+kasj3j4+Ptq0aVNe1wIAAAAAQL6T61PNH3jgAX344Yd5WQsAAAAAAPlOrm+udubMGX300Uf68ccf1bBhQxUpUsRt+fjx46+4OAAAAAAArnU5Dt5///23KlSooM2bN6tBgwaSpO3bt7uNcTgceVMdAAAAAADXuBwH7ypVqujQoUNatmyZJOm+++7TpEmTFBoamufFAQAAAABwrcvxNd7GGLfphQsXKjk5Oc8KAgAAAAAgP8n1zdUynR/EAQAAAADA/8tx8HY4HFmu4bb6mu4DBw7ogQceUIkSJeTv76/atWtrzZo1ruXGGA0bNkylS5eWv7+/IiIitGPHDrf3SEhIUM+ePRUYGKjg4GBFRUUpKSnJ0roBAAAAAMjxNd7GGD300EPy8/OTJJ0+fVqPPPJIlruaf/PNN3lS4LFjx9S0aVO1atVKCxcu1HXXXacdO3aoePHirjFjx47VpEmT9PHHH6tixYp6+eWXFRkZqT///FOFCxeWJPXs2VOHDh1STEyM0tPT1adPH/Xv31+fffZZntQJAAAAAEB2chy8e/fu7Tb9wAMP5Fkx2RkzZozKlSun6dOnu+ZVrFjR9W9jjCZOnKiXXnpJd955pyRp5syZCg0N1bx589S9e3dt3bpVixYt0urVq9WoUSNJ0uTJk9WhQweNGzdO4eHhlm4DAAAAAKDgynHwPjcAXw3z589XZGSk7r33Xv38888qU6aMHnvsMfXr10+StHv3bh0+fFgRERGu1wQFBalx48ZasWKFunfvrhUrVig4ONgVuiUpIiJCXl5eWrlypbp06ZJlvampqUpNTXVNJyYmSpLS09OVnp5u1eZeEafTKUnylpGX84y8ZeTv7y+n02nbmvO7zM+dz99e6Iv90BP7oSf2RF/sh57YDz2xp/zYl5xsi8PY/O5omaeKDxkyRPfee69Wr16tJ598UlOnTlXv3r3122+/qWnTpjp48KBKly7tel23bt3kcDg0e/Zsvf766/r444+1bds2t/cuVaqURowYoUcffTTLeocPH64RI0Zkmf/ZZ58pICAgj7cSAAAAAHAtSUlJ0f33368TJ04oMDDwomNzfMT7anM6nWrUqJFef/11SVL9+vW1efNmV/C2ytChQzVkyBDXdGJiosqVK6e2bdte8kP1lPXr1+vQoUOKTQ5QaLXaOrhts6b1vUOxsbGqW7eup8srkNLT0xUTE6M2bdrIx8fH0+Xgf+iL/dAT+6En9kRf7Iee2A89saf82JfMs6Ivh+2Dd+nSpVWjRg23eTfeeKO+/vprSVJYWJgkKS4uzu2Id1xcnOrVq+caEx8f7/YeZ86cUUJCguv15/Pz83PdQO5cPj4+tv1C8fI6e5P6DDnk9CqkDDl06tQpeXl52bbmgsLOXzcFGX2xH3piP/TEnuiL/dAT+6En9pSf+pKT7bji53hbrWnTpllOEd++fbvKly8v6eyN1sLCwrRkyRLX8sTERK1cuVJNmjSRJDVp0kTHjx/X2rVrXWOWLl0qp9Opxo0bX4WtAAAAAAAUVLY/4j148GDdeuutev3119WtWzetWrVK06ZN07Rp0ySdfYb4oEGDNGrUKFWpUsX1OLHw8HDdddddks4eIW/Xrp369eunqVOnKj09XQMHDlT37t25ozkAAAAAwFK2D9433XST5s6dq6FDh2rkyJGqWLGiJk6cqJ49e7rGPPvss0pOTlb//v11/PhxNWvWTIsWLXLdmE2SZs2apYEDB6p169by8vJS165dNWnSJE9sEgAAAACgALF98JakTp06qVOnThdc7nA4NHLkSI0cOfKCY0JCQvTZZ59ZUR4AAAAAABdk+2u8AQAAAAC4lhG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALXXPB+4033pDD4dCgQYNc806fPq0BAwaoRIkSKlq0qLp27aq4uDi31+3bt08dO3ZUQECASpUqpWeeeUZnzpy5ytUDAAAAAAqaayp4r169Wu+//77q1KnjNn/w4MH67rvvNGfOHP388886ePCg7r77btfyjIwMdezYUWlpafrtt9/08ccfa8aMGRo2bNjV3gQAAAAAQAFzzQTvpKQk9ezZU//9739VvHhx1/wTJ07oww8/1Pjx43X77berYcOGmj59un777Tf9/vvvkqTo6Gj9+eef+vTTT1WvXj21b99er776qqZMmaK0tDRPbRIAAAAAoAC4ZoL3gAED1LFjR0VERLjNX7t2rdLT093mV69eXddff71WrFghSVqxYoVq166t0NBQ15jIyEglJiZqy5YtV2cDAAAAAAAFUiFPF3A5vvjiC61bt06rV6/Osuzw4cPy9fVVcHCw2/zQ0FAdPnzYNebc0J25PHNZdlJTU5WamuqaTkxMlCSlp6crPT0919tiJafTKUnylpGX84y8ZeTv7y+n02nbmvO7zM+dz99e6Iv90BP7oSf2RF/sh57YDz2xp/zYl5xsi+2D9z///KMnn3xSMTExKly48FVb7+jRozVixIgs86OjoxUQEHDV6siN5kVSpP0rVa2I1Orzz3XgwAEdOHDA02UVaDExMZ4uAdmgL/ZDT+yHntgTfbEfemI/9MSe8lNfUlJSLnus7YP32rVrFR8frwYNGrjmZWRkKDY2Vu+8844WL16stLQ0HT9+3O2od1xcnMLCwiRJYWFhWrVqldv7Zt71PHPM+YYOHaohQ4a4phMTE1WuXDm1bdtWgYGBebV5eWr9+vU6dOiQYpMDFFqttg5u26xpfe9QbGys6tat6+nyCqT09HTFxMSoTZs28vHx8XQ5+B/6Yj/0xH7oiT3RF/uhJ/ZDT+wpP/Yl86zoy2H74N26dWv98ccfbvP69Omj6tWr67nnnlO5cuXk4+OjJUuWqGvXrpKkbdu2ad++fWrSpIkkqUmTJnrttdcUHx+vUqVKSTr7l5bAwEDVqFEj2/X6+fnJz88vy3wfHx/bfqF4eZ29ZD9DDjm9CilDDp06dUpeXl62rbmgsPPXTUFGX+yHntgPPbEn+mI/9MR+6Ik95ae+5GQ7bB+8ixUrplq1arnNK1KkiEqUKOGaHxUVpSFDhigkJESBgYF6/PHH1aRJE91yyy2SpLZt26pGjRrq1auXxo4dq8OHD+ull17SgAEDsg3XAAAAAADkFdsH78sxYcIEeXl5qWvXrkpNTVVkZKTeffdd13Jvb28tWLBAjz76qJo0aaIiRYqod+/eGjlypAerBgAAAAAUBNdk8P7pp5/cpgsXLqwpU6ZoypQpF3xN+fLl9cMPP1hcGQAAAAAA7q6Z53gDAAAAAHAtIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABayffAePXq0brrpJhUrVkylSpXSXXfdpW3btrmNOX36tAYMGKASJUqoaNGi6tq1q+Li4tzG7Nu3Tx07dlRAQIBKlSqlZ555RmfOnLmamwIAAAAAKIBsH7x//vlnDRgwQL///rtiYmKUnp6utm3bKjk52TVm8ODB+u677zRnzhz9/PPPOnjwoO6++27X8oyMDHXs2FFpaWn67bff9PHHH2vGjBkaNmyYJzYJAAAAAFCAFPJ0AZeyaNEit+kZM2aoVKlSWrt2rZo3b64TJ07oww8/1Geffabbb79dkjR9+nTdeOON+v3333XLLbcoOjpaf/75p3788UeFhoaqXr16evXVV/Xcc89p+PDh8vX19cSmAQAAAAAKANsf8T7fiRMnJEkhISGSpLVr1yo9PV0RERGuMdWrV9f111+vFStWSJJWrFih2rVrKzQ01DUmMjJSiYmJ2rJly1WsHgAAAABQ0Nj+iPe5nE6nBg0apKZNm6pWrVqSpMOHD8vX11fBwcFuY0NDQ3X48GHXmHNDd+byzGXZSU1NVWpqqms6MTFRkpSenq709PQ82Z685nQ6JUneMvJynpG3jPz9/eV0Om1bc36X+bnz+dsLfbEfemI/9MSe6Iv90BP7oSf2lB/7kpNtuaaC94ABA7R582b9+uuvlq9r9OjRGjFiRJb50dHRCggIsHz9V6J5kRRp/0pVKyK1+vxzHThwQAcOHPB0WQVaTEyMp0tANuiL/dAT+6En9kRf7Iee2A89saf81JeUlJTLHnvNBO+BAwdqwYIFio2NVdmyZV3zw8LClJaWpuPHj7sd9Y6Li1NYWJhrzKpVq9zeL/Ou55ljzjd06FANGTLENZ2YmKhy5cqpbdu2CgwMzKvNylPr16/XoUOHFJscoNBqtXVw22ZN63uHYmNjVbduXU+XVyClp6crJiZGbdq0kY+Pj6fLwf/QF/uhJ/ZDT+yJvtgPPbEfemJP+bEvmWdFXw7bB29jjB5//HHNnTtXP/30kypWrOi2vGHDhvLx8dGSJUvUtWtXSdK2bdu0b98+NWnSRJLUpEkTvfbaa4qPj1epUqUknf1LS2BgoGrUqJHtev38/OTn55dlvo+Pj22/ULy8zl6ynyGHnF6FlCGHTp06JS8vL9vWXFDY+eumIKMv9kNP7Iee2BN9sR96Yj/0xJ7yU19ysh22D94DBgzQZ599pm+//VbFihVzXZMdFBQkf39/BQUFKSoqSkOGDFFISIgCAwP1+OOPq0mTJrrlllskSW3btlWNGjXUq1cvjR07VocPH9ZLL72kAQMGZBuuAQAAAADIK7YP3u+9954kqWXLlm7zp0+froceekiSNGHCBHl5ealr165KTU1VZGSk3n33XddYb29vLViwQI8++qiaNGmiIkWKqHfv3ho5cuTV2gwAAAAAQAFl++BtjLnkmMKFC2vKlCmaMmXKBceUL19eP/zwQ16WBgAAAADAJV1zz/EGAAAAAOBaQvAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIFKnhPmTJFFSpUUOHChdW4cWOtWrXK0yUBAAAAAPK5AhO8Z8+erSFDhuiVV17RunXrVLduXUVGRio+Pt7TpQEAAAAA8rECE7zHjx+vfv36qU+fPqpRo4amTp2qgIAAffTRR54uDQAAAACQjxXydAFXQ1pamtauXauhQ4e65nl5eSkiIkIrVqzI9jWpqalKTU11TZ84cUKSlJCQoPT0dGsLzqXExESlpKQobscepaYk6+g/u1W4cGGtXbtWiYmJ8vLyktPpdI3PybRVY6/WejxVkySlpKTol19+kZeXV4Hadjus50LLnE6nUlJStHz5cp2rIGy7XdeT2ZPMfcUONRX09UgX/v6V37fdzjV58vuXp7fdk+u52LL8/v3LjjVd6rVS3nz/uha33c7rye7716XeNzQ0VKVKlZJdnTx5UpJkjLnk2AIRvI8cOaKMjAyFhoa6zQ8NDdVff/2V7WtGjx6tESNGZJlfsWJFS2q0Uv/+/T1dAgAAAADkSydPnlRQUNBFxxSI4J0bQ4cO1ZAhQ1zTTqdTCQkJKlGihBwOhwcru7DExESVK1dO//zzjwIDAz1dDkRP7Iq+2A89sR96Yk/0xX7oif3QE3vKj30xxujkyZMKDw+/5NgCEbxLliwpb29vxcXFuc2Pi4tTWFhYtq/x8/OTn5+f27zg4GCrSsxTgYGB+eaLOb+gJ/ZEX+yHntgPPbEn+mI/9MR+6Ik95be+XOpId6YCcXM1X19fNWzYUEuWLHHNczqdWrJkiZo0aeLBygAAAAAA+V2BOOItSUOGDFHv3r3VqFEj3XzzzZo4caKSk5PVp08fT5cGAAAAAMjHCkzwvu+++/Tvv/9q2LBhOnz4sOrVq6dFixZlueHatczPz0+vvPJKllPk4Tn0xJ7oi/3QE/uhJ/ZEX+yHntgPPbGngt4Xh7mce58DAAAAAIBcKRDXeAMAAAAA4CkEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGPMTpdHq6BOCawL4CAACudQRv4Crbu3evDhw4IC8vdj/gYthX7I2HotgPPbEfemJP9AWewG8z+djOnTs1YcIEPfvss1q4cKHi4uI8XVKBt2HDBjVs2FC//PKLp0vBOdhX7Id9xZ5Onz6tlJQUSZLD4ZDEL7CetmnTJg0bNkzS//cEnsV+Yk/sK/ZT0H7/InjnU5s3b9bNN9+sb775RrGxserSpYsGDx6shQsXerq0Amvjxo269dZb9dBDD6l79+5uy/iB7DnsK/bDvmJPmzdvVocOHdS8eXM1btxY7777rg4ePCiHw8HlAB6yceNG3XLLLVk+f/YTz2E/sSf2FfspiL9/OQxfcfnOqVOn1K1bN1WsWFETJkyQt7e3Fi1apAkTJigtLU1PPPGEunTp4ukyC5Rt27apbt26Gjp0qF555RVlZGTo999/V3x8vCpXrqwaNWrI29vb02UWOOwr9sO+Yk9///23GjVqpHvuuUe33XabFi1apL/++kvh4eGaMGGCKleuLKfTyWUBV9HGjRvVtGlTPfLIIxo3bly2Y4wxHNm7ithP7Il9xX4K6u9f7Pn5kK+vrw4cOKDQ0FDXL6jt2rXTiBEjFBgYqGnTpmnlypUerrLgSE1N1ciRI1WkSBF17NhRktSlSxf95z//Uf/+/VW/fn0NHTpUu3fv9nClBQ/7ir2cPn2afcWmFi5cqJtuuknTpk1Tr169NGvWLA0ZMkQpKSnq37+/du/eLS8vL44eXSX//POPmjZtqh49emjcuHFKS0vT66+/rr59+6pHjx5avHixTpw4QZC4ythP7Id9xZ4K6u9fBO98xul0KjU1VaVLl9aRI0ckSRkZGZKkW265RU8//bT27dunefPmSeIUm6vBz89P/fv3V+vWrfX000+rSpUqcjqdmj59urZv367p06frv//9rz755BNJ9ORqOXPmDPuKzRQuXFhRUVHsKzZ08uRJbdu2TSdPnnTN69mzpx577DFJ0htvvKHExER+eb1KNm7cqMqVK+vIkSPat2+f7rzzTn3//fc6fvy4/v77bw0aNEjvvvuukpOTPV1qgcJ+Yj/r169nX7GZAp1VDPKld955x/j6+prFixcbY4zJyMhwLXv33XdNsWLFTHx8vKfKK5B+/vln065dO9OuXTuza9cut2VvvPGGCQ4ONkePHvVQdQVHQkKC2/R7773HvuJhO3bsMGPGjHFN//LLL+wrNpG5P8ybN8/UrFnT/Pjjj8bpdLqNGTdunKlYsaLZuXOnJ0ossL755hvTokUL4+vra9q3b2/i4uJcywYNGmTKly9v/v77bw9WWHBk7ifz589nP7GJxMRE17/ZV+ypIGYVgnc+8M8//5hFixaZL7/80u0bR+/evU2xYsXMr7/+6jY+Ojra1K5dm19cLXT48GGzZs0aEx0dbU6ePOmav3r1avPdd9+Z9PR0Y8z/f5N57733TJ06dUxaWppH6i0o1q1bZ7y8vMy6devcvsH37duXfcVDNm7caEJCQkz58uXNv//+65q/Zs0a9hUPOnPmTJZ5jRs3NvXq1cv2F9QSJUqYiRMnXo3ScI7Zs2ebfv36meXLlxtj/n8/cTqdxtfX1/z3v//1ZHn53p9//mn+/PNPt3m33nor+4mH/fXXX6ZGjRpm6dKlrnlffvkl+4oHkVXO4lTza9wff/yhRo0a6eWXX1aPHj3UrVs3Pf7445KkDz/8UO3bt1fbtm01c+ZM7dmzRxkZGVq8eLG8vLy4uYdF/vjjD7Vq1UpRUVGKjIzUfffdp02bNkmSGjVqpA4dOqhQoUKS5OrB1q1bVblyZZ05cyZ/nVJjIxs3blSLFi00aNAg1a9f3+3r/4033lCnTp3YV66yzLvMdu7cWSdOnNAXX3zhWtawYUP2FQ/ZunWrHn/8cUVGRmrEiBH64YcfJEmLFy9WcnKyevTooS1btrjGp6SkqEqVKgoLC/NUyfnezp07NWrUKPXo0UPTp0/XX3/9JUnq1q2bnnzySTVq1EjS2f3E6XRq165dql69uqpXr+7JsvO1TZs2qWbNmlqwYIGk/z9V9ocfflBKSgr7iYds2LBBN998s7Zu3er63UuS7r33XvYVDyGrnMPTyR+5d/z4cVO3bl0zaNAgc/z4cbN//37z6quvmpo1a5pOnTq5xj311FMmJCTEXH/99aZRo0amRIkSZt26dR6sPP/avn27KV26tHnppZfM33//bf766y9TtmxZM2jQoGzH79u3z7z00ksmKCjIbN68+SpXW3D88ccfxt/f37z88suueXFxcWbjxo1uR/aefvpp9pWrZP369cbf3988//zzxhhjHnvsMXPrrbeaAwcOZDuefeXq2Lp1qwkKCjIPPPCA6dGjh4mIiDAlSpQw48aNM8acPWpRvXp1c+ONN5rXX3/dzJs3zzzzzDMmJCQky2UByBt//PGHCQ0NNV26dDG33367qVSpkhk0aJBJTk6+4GuGDRtm6tSpc8H9CVdmw4YNxt/f3zz33HPZLmc/8YzMvowdO9YMGzbMlCpVyu1Mquywr1iLrOKO4H0N27t3r6latar57bffXPNOnjxpvvzyS1O1alVz7733uuYvX77czJkzx8yaNcvs3r3bA9XmfykpKeY///mPiYqKMqmpqa5AN3XqVFOzZk1z+vRpt2u+NmzYYFq2bGkqVqxo1q9f76Gq87+TJ0+aFi1amODgYNe8u+++29SvX984HA7TsmVLM2nSJNcy9hXr/f333yYoKMgVuo0x5uuvvzaBgYGuUwPPvRSAfeXqGTx4sOnSpYtreu/evWb06NHG4XCY119/3Rhz9jT0qKgo06RJE3PDDTeYW265JV/+gmQH//zzj6lRo4bbvjJjxgxTvHjxbL8/LViwwAwePNgEBQWxr1hk+/btxuFwmJEjRxpjzu4Pc+bMMSNHjjSzZ882a9eudc1nP7l6NmzYYAoVKmSGDh1qjDn7B6vq1au7Tu0/92eKMewrVwtZxR3B+xqWkJBgKlas6DoSken06dPm448/NrVr1zZTpkzxUHUFz8mTJ02fPn3M9OnT3ebPmzfPlC5d2iQmJma52coPP/zAX78tlpKSYj799FNTuXJlc9ddd5nIyEjTqVMnM2fOHPPrr7+anj17mptuusnMmDHD06UWGLt37zYff/xxlvmdO3c2zZs3N6dPn86ybNGiRewrFnM6naZLly7mvvvuc5uflJRkxo8fbwoVKmTef/991/wTJ06YQ4cOmRMnTlztUgsEp9NpPv74Y9O1a1eze/duV3BITU01NWrUMMuWLcvymueff940bdrUbNq06SpXWzA4nU7z0UcfGYfDYT7//HNjjDEtW7Y09erVM5UrVzaVKlUyjRo1MnPmzHG9hv3EeomJiaZNmzbmxRdfdM1LT083nTp1Mrfeemu2r2FfuTrIKu4I3tew06dPm969e5t27dpl+caRnJxs7rjjDtO9e3cPVVcwHTx40PXvzCPev//+u6lVq5Zb6D7/Ziyw1qlTp8ycOXNMxYoVTZMmTcyhQ4dcy44ePWqaNm1qevbs6cEKC47zjzoYY1z7xvTp002lSpXM6tWrLzgW1powYYKpXr16lu9RCQkJZtCgQaZJkyZm3759Hqqu4Fm8eLGZMGGC27xTp06ZChUquILf+fLbzYjs5uTJk2bcuHHG4XCYMmXKmK5du5pt27YZY4xZuXKl6dGjh2nVqhWnLl9lmT0w5v9//9q4caMJDAx0+8P6ub+Lsa9Yj6ziLp9dsV6w+Pn56emnn9b69es1atQo7dq1y7UsICBALVq00Pbt25WSkuLBKguW0qVLSzr7jEJvb2/XvxMTE119ePHFFzVo0CCdOHHCY3UWNIULF1bHjh01efJkDRs2TNddd52kszfDCQkJUb169fTPP//I6XR6uNL8L7sbpWQ+07ZHjx4yxui999674FhYq1GjRipWrJhmzJih/fv3u+YXL15cHTt21ObNmxUfH+/BCguWtm3batCgQZL+/1m2fn5+Kl68uHx8fFzjPv/8c61cuVKSFBISctXrLEiKFi2qAQMGaNy4cbrhhhs0dOhQVa1aVZJ08803q1u3blqxYoXr+cSwVuZ+kdkDSa7fv8qUKaObb75ZP/30k2usw+Fw/axnX7EeWcUdv9Vcw5xOp2rVqqVvv/1W33//vZ5//nktW7bMtfyvv/5S2bJlXXcFxtVzbmBIS0vTyZMnVahQIb3yyisaO3asXnvtNQUFBXmwwoLH399fbdq0UUREhOuHcub/jxw5onr16hH0PCgjI0N+fn569tln9euvv2rt2rWeLqlAatasmXr06KHZs2dr2rRp+vvvv13Lateureuvv16pqakerLDgyvwDlcPhUJEiReTv7y9JGjp0qB599FGVLFnSk+UVKIULF1bfvn01efJk1a5dW5JcYS40NFQ33HCDAgMDPVligZG5X2SnRIkS6t27tz755BOtWrXKNZaf9VcPWcVdwdjKa5zT6ZQxxhUSMud5eXkpIyNDjRs31s8//6y+ffvq6aefVkZGhipUqKBly5YpNjZWvr6+Hqw+f7pYT87n5+enypUr66WXXtLkyZP1+++/q2HDhlez3ALjUn05f184deqURo0apdjYWLcfBMg7l7uvZC5v3ry5nnjiCS1fvpz95CrL7MvgwYN16tQpzZw5U7t27dJDDz2kypUr67333tOJEyd0ww03eLrUAi09PV1Hjx5VWlqaRo0apbfffluxsbGqVKmSp0srUAIDA1W3bl3XdOb3tLlz5yooKEjBwcEeqgzn6ty5s1q3bq0PPvhAderUUeHChT1dUr6WeVZBJrKKO4cxPAjVzv7880+9/vrrOnz4sKpUqaJOnTqpY8eOks4eIfL29nb9f9++fVq7dq2WLl2qcuXK6Y477uC5hBa4nJ6c67ffflOzZs1UvHhxxcTEqEGDBp4oO9/LaV/mzp2rOXPm6KefftL333+v+vXre6LsfC2nPck0ZswYderUSTVr1rya5RYYF/vsz/2jyMcff6x58+Zp/vz5qlmzphITEzV37lz2FQtcrCfnO3PmjFq0aKFjx45pz549io2NdT2bGHknJz2RpG3btun999/XjBkz9NNPP6lOnToWVldw5bQvkvTII48oNjZWa9asUUBAgEWVFVzJycmuP7Jf6EwPsspZBG8b27Ztmxo3bqz27durQoUKWrhwoXx8fNSsWTNNmDBB0tnTmH19fbP8hQnWyElPMu3Zs0fdunXTjBkzVKNGDU+Vnq/lti+ffvqp7rvvPlWpUsVTpedbuelJbn6hQs5s375d3333ne6//37XPSnOd+bMGddpf8nJydq9e7e8vLxUokQJhYaGXs1yC4TL6cm5P+NPnTqliIgIbd++XUuWLCHgWSCnPdm8ebPeeecdrVq1StOnT3c7Eo68k9O+ZP5MOXPmjPbv368KFSpcxWoLhj///FODBw/Wv//+q7i4OI0dO1Y9e/Z060PmH3TJKhJ3Nbcpp9NpXnjhBdOtWzfXvMTERDNq1ChTr149069fP7fx8+bNM3FxcVe7zAIlpz359ttvXXfPzu7xSMgbV9KXzDufIm/lpifx8fFXu8wCZ8eOHSYkJMQ4HA4zdOhQ8++//2YZc/4jD2Gt3Pbk448/druLM/JObnuydu1atydmIG/lti9paWlXo7wCacuWLaZEiRJm8ODBZtasWWbIkCHGx8fngs9FJ6vwODFbe+ihh0zz5s3d5iUmJppx48aZRo0amdGjRxtjjFmwYIEpW7asefHFF3n8jsVy2pMXXnjBnDlzhl9mLZabvmRkZNAXC/H9y16SkpLMww8/bB566CEzZcoU43A4zDPPPJPtL6/GGDN27FgzcuTIq1xlwZKbngwfPvwqV1mw0BN74vuX/Rw9etS0bdvWPPHEE27zW7ZsaR5//HFjjPsfQr777jt+1hseJ2ZL5n9n/zdo0EAZGRnatm2ba1mxYsX08MMPq379+vruu++Ulpamjh076uGHH9bDDz/MnRotktueREVFydvbm1NrLHIlffHy8qIvFuD7lz15eXmpYcOGateunR577DF98cUXGjdunMaOHZvlsUcJCQlau3atvv/+eyUkJHio4vwvNz1ZuHChjh496qGK8z96Yk98/7Kf9PR0HT9+XPfcc4+k/7+rf8WKFV2f+7m/Y3Xq1El9+vThZ71ncz8uZufOnaZkyZLm4YcfNidPnjTG/P9fj/bt22ccDof57rvvPFligUNP7Im+2A89sZ+kpCS36S+++MI4HA7z9NNPmyNHjhhjzl5+cezYMXP06FFz8OBBT5RZoNAT+6En9kRf7Gf79u2uf2ee0v/SSy+ZXr16uY07duzY1SzL1nicmI1VqlRJX375pdq3by9/f38NHz7c9ZxOHx8f1alTRyVKlPBwlQULPbEn+mI/9MR+ihQpIunsDYe8vLx03333yRij+++/Xw6HQ4MGDdKbb76pPXv26IsvvlBISIiHK87/6In90BN7oi/2k3ljWqfTKR8fH0lnz3qLj493jRk9erT8/Pz0xBNPFJhndV8Mn4DNtWrVSnPmzNG9996rQ4cOqVu3bqpTp45mzpyp+Ph4lStXztMlFjj0xJ7oi/3QE3vy9vaWMUZOp1Pdu3eXw+FQr169NH/+fO3atUurVq2Sn5+fp8ssUOiJ/dATe6Iv9nP+HcszTyUfNmyYRo0apfXr1xO6/4fHiV0j1q1bpyFDhmjPnj0qVKiQvL299cUXX/A8VQ+iJ/ZEX+yHnthT5o9/h8Oh1q1ba8OGDfrpp59Uu3ZtD1dWcNET+6En9kRf7CXzkWHDhw/XoUOHVKVKFb300kv67bff1KBBA0+XZxsE72tIYmKiEhISdPLkSZUuXdp12iY8h57YE32xH3piTxkZGXrmmWc0ceJEbdiwgWdC2wA9sR96Yk/0xX5ee+01vfzyywoMDNSPP/6oRo0aebokW+G4/zUkMDBQgYGBni4D56An9kRf7Iee2FfNmjW1bt06fmm1EXpiP/TEnuiLvURGRurll1/Wb7/9pho1ani6HNvhiDcAAAXYudfmwR7oif3QE3uiL/aTnJzsuhke3BG8AQAAAACwUAF+gjkAAAAAANYjeAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAABLvP3221qxYoWnywAAwOMI3gAAIM+99dZb+uabb9SgQQNPlwIAKKBiY2PVuXNnhYeHy+FwaN68eTl6/fDhw+VwOLL8l5tnlRO8AQAoIFasWCFvb2917NjR0vUsX75cn3zyib799lv5+flZui4AAC4kOTlZdevW1ZQpU3L1+qefflqHDh1y+69GjRq69957c/xeDmOMyVUVAADgmtK3b18VLVpUH374obZt26bw8HBPlwQAwFXhcDg0d+5c3XXXXa55qampevHFF/X555/r+PHjqlWrlsaMGaOWLVtm+x4bN25UvXr1FBsbq9tuuy1H6+eINwAABUBSUpJmz56tRx99VB07dtSMGTNcy3766Sc5HA4tWbJEjRo1UkBAgG699VZt27bNNWb48OGqV6+ePvnkE1WoUEFBQUHq3r27Tp486RrjdDo1evRoVaxYUf7+/qpbt66++uortzo2b96s9u3bq2jRogoNDVWvXr105MgRy7cfAIDzDRw4UCtWrNAXX3yhTZs26d5771W7du20Y8eObMd/8MEHqlq1ao5Dt0TwBgCgQPjyyy9VvXp1VatWTQ888IA++ugjnX/S24svvqi33npLa9asUaFChfTwww+7Ld+1a5fmzZunBQsWaMGCBfr555/1xhtvuJaPHj1aM2fO1NSpU7VlyxYNHjxYDzzwgH7++WdJ0vHjx3X77berfv36WrNmjRYtWqS4uDh169bN+g8AAIBz7Nu3T9OnT9ecOXN02223qVKlSnr66afVrFkzTZ8+Pcv406dPa9asWYqKisrV+gpdacEAAMD+PvzwQz3wwAOSpHbt2unEiRP6+eef3U6ne+2119SiRQtJ0vPPP6+OHTvq9OnTKly4sKSzR7RnzJihYsWKSZJ69eqlJUuW6LXXXlNqaqpef/11/fjjj2rSpIkk6YYbbtCvv/6q999/Xy1atNA777yj+vXr6/XXX3et86OPPlK5cuW0fft2Va1a9Wp8FAAA6I8//lBGRkaWnz2pqakqUaJElvFz587VyZMn1bt371ytj+ANAEA+t23bNq1atUpz586VJBUqVEj33XefPvzwQ7fgXadOHde/S5cuLUmKj4/X9ddfL0mqUKGCK3RnjomPj5ck7dy5UykpKWrTpo3butPS0lS/fn1JZ6+NW7ZsmYoWLZqlxl27dhG8AQBXTVJSkry9vbV27Vp5e3u7Lcvu59QHH3ygTp06KTQ0NFfrI3gDAJDPffjhhzpz5ozbzdSMMfLz89M777zjmufj4+P6t8PhkHT2KHd2yzPHZC5PSkqSJH3//fcqU6aM27jMO5snJSWpc+fOGjNmTJYaM4M+AABXQ/369ZWRkaH4+PhLXrO9e/duLVu2TPPnz8/1+gjeAADkY2fOnNHMmTP11ltvqW3btm7L7rrrLn3++eeqXr36Fa+nRo0a8vPz0759+1ynq5+vQYMG+vrrr1WhQgUVKsSvIAAAayUlJWnnzp2u6d27d2vDhg0KCQlR1apV1bNnTz344IN66623VL9+ff37779asmSJ6tSp4/bozY8++kilS5dW+/btc10LP/UAAMjHFixYoGPHjikqKkpBQUFuy7p27aoPP/xQb7755hWvp1ixYnr66ac1ePBgOZ1ONWvWTCdOnNDy5csVGBio3r17a8CAAfrvf/+rHj166Nlnn1VISIh27typL774Qh988EGWU/0AALgSa9asUatWrVzTQ4YMkST17t1bM2bM0PTp0zVq1Cg99dRTOnDggEqWLKlbbrlFnTp1cr0m8/4mDz300BX9nCJ4AwCQj3344YeKiIjIErqls8F77Nix2rRpU56s69VXX9V1112n0aNH6++//1ZwcLAaNGigF154QZIUHh6u5cuX67nnnlPbtm2Vmpqq8uXLq127dvLy4kErAIC81bJlyyxP8DiXj4+PRowYoREjRlxwjJeXl/75558rrsVhLlYJAAAAAAC4Ivx5GQAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsND/ARUczJAMXnQBAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "epoque = \"EPOQUE DU RECIT\"\n",
+    "\n",
+    "# Convertir toutes les valeurs en chaînes pour gérer les intervalles potentiels comme des entrées uniques\n",
+    "data[epoque] = data[epoque].astype(str)\n",
+    "all_years = visualize_year_distribution(data[epoque], 'Distribution des époques du récit')\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAJOCAYAAABBfN/cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvTUlEQVR4nO3dfXzN9f/H8ec528w2m6sZhrFYDCHKRSRXs6R0oZBEor6VLvAt5Rvlqq8opeSivknfLqTrpEuXUaKiTDRzkSyNzYiNzczO+/eH387XsWGbfXY+2x73261bPhfnfV7nvHbOznOfz3l/HMYYIwAAAAAAYAmntwsAAAAAAKAsI3gDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAADivWbNm6c033/R2GSig7OxsPf3001qyZIm3SwEAiOANACiACRMmyOFwlMh9denSRV26dHEvf/PNN3I4HPrggw9K5P7vuOMONWjQoETuqyByH/8333zjtRpmzZqlSZMmqX379l6roTR6/fXX5XA49Mcff5T4fT/22GN69dVXi9SzP/74Qw6HQ6+//nrxFwYA5RTBGwDKmdwwkPtfxYoVFR4ertjYWL344otKT08vlvtJSkrShAkTtGnTpmIZrzjZuTa7+emnn/TEE09oyZIlioqK8nY5KIDFixfrrbfe0ldffaUaNWoUy5hffPGFJkyYUCxjAUB5RPAGgHJq0qRJevPNNzV37lw98MADkqSRI0fqkksu0ebNmz32HTdunDIzMws1flJSkiZOnFjocLt06VItXbq0ULcprHPV9p///EcJCQmW3n9psnXrVn344Ycc7S5F/vjjD3355Zdq1KhRkW5fv359ZWZm6vbbb3ev++KLLzRx4sTiKhEAyh1fbxcAAPCOXr166bLLLnMvjx07VitXrtS1116rPn36KD4+XgEBAZIkX19f+fpa+ysjIyNDgYGBqlChgqX3cz5+fn5evX+7ueOOO7xdAs7h5MmTcrlcHq+bhx566ILGzD0TBgBQfDjiDQBw69atm8aPH689e/borbfecq/P7zvey5YtU6dOnVSlShVVqlRJjRs31r/+9S9Jp76XfPnll0uShg4d6j6tPfc7o126dFHz5s21ceNGde7cWYGBge7bnvkd71w5OTn617/+pVq1aikoKEh9+vTRn3/+6bFPgwYN8g2Kp495vtry+473sWPH9M9//lP16tWTv7+/GjdurGeffVbGGI/9HA6H7r//fn3yySdq3ry5/P391axZM3311Vf5P+Fn2Lt3r2644QYFBQUpLCxMo0aNUlZWVr77/vDDD7r66qtVuXJlBQYG6qqrrtLatWs99klPT9fIkSPVoEED+fv7KywsTDExMfr555/PW8tff/2lO++8UzVr1nQ/jtdee81jn9zvn7/77rvn7Y0kvf/++2rTpo0CAgIUGhqqQYMG6a+//sqzX+7zV7FiRTVv3lwff/xxnr6c7bvvZ/t+8rZt23TzzTerWrVqqlixoi677DJ9+umnHvtkZ2dr4sSJioqKUsWKFVW9enV16tRJy5YtO+/ztXXrVnXr1k0BAQGqW7eupkyZIpfLlWc/h8OR7ynbZ/vZze+xPfvss5o5c6YaNmwof39//fbbbwV+jJJ0+PBhjRo1yv1zUbduXQ0ePFipqake93P6a2L27Nnu+nP/AwAUHEe8AQAebr/9dv3rX//S0qVLddddd+W7z9atW3XttdeqRYsWmjRpkvz9/bVz50538IuOjtakSZP0xBNP6O6779aVV14pSbriiivcYxw8eFC9evXSgAEDNGjQINWsWfOcdT311FNyOBx69NFHlZKSopkzZ6pHjx7atGmT+8h8QRSkttMZY9SnTx+tWrVKw4YNU6tWrfT111/rkUce0V9//aXnn3/eY//vvvtOH330ke677z4FBwfrxRdfVN++fZWYmKjq1aufta7MzEx1795diYmJevDBBxUeHq4333xTK1euzLPvypUr1atXL7Vp00ZPPvmknE6nFixYoG7duunbb79V27ZtJUn33HOPPvjgA91///1q2rSpDh48qO+++07x8fFq3br1WWtJTk5W+/bt3X9IqFGjhr788ksNGzZMaWlpGjlypMf+BenN66+/rqFDh+ryyy/X1KlTlZycrBdeeEFr167VL7/8oipVqkg69VWDvn37qmnTppo6daoOHjyooUOHqm7dumet93y2bt2qjh07qk6dOnrssccUFBSk9957TzfccIM+/PBD3XjjjZJO/YFp6tSpGj58uNq2bau0tDRt2LBBP//8s2JiYs46/v79+9W1a1edPHnSPf4rr7xSqJ/LwliwYIGOHz+uu+++W/7+/qpWrVqBH+PRo0d15ZVXKj4+Xnfeeadat26t1NRUffrpp9q7d69CQ0Pz3N8//vEPJSUladmyZcxsDwBFZQAA5cqCBQuMJPPTTz+ddZ/KlSubSy+91L385JNPmtN/ZTz//PNGkjlw4MBZx/jpp5+MJLNgwYI826666iojycybNy/fbVdddZV7edWqVUaSqVOnjklLS3Ovf++994wk88ILL7jX1a9f3wwZMuS8Y56rtiFDhpj69eu7lz/55BMjyUyZMsVjv5tvvtk4HA6zc+dO9zpJpkKFCh7r4uLijCQza9asPPd1upkzZxpJ5r333nOvO3bsmGnUqJGRZFatWmWMMcblcpmoqCgTGxtrXC6Xe9+MjAwTGRlpYmJi3OsqV65sRowYcc77zc+wYcNM7dq1TWpqqsf6AQMGmMqVK5uMjAxjTMF7c+LECRMWFmaaN29uMjMz3ft99tlnRpJ54okn3OtatWplateubQ4fPuxet3TpUiPJoy+59537vOTavXt3nt52797dXHLJJeb48ePudS6Xy1xxxRUmKirKva5ly5amd+/ehXimThk5cqSRZH744Qf3upSUFFO5cmUjyezevdu9XpJ58skn84xxtp/d/B5bSEiISUlJ8dhW0Mf4xBNPGEnmo48+yjN+7s9Tfs/hiBEjDB8bAaDoONUcAJBHpUqVzjm7ee7RycWLF+d7Om1B+Pv7a+jQoQXef/DgwQoODnYv33zzzapdu7a++OKLIt1/QX3xxRfy8fHRgw8+6LH+n//8p4wx+vLLLz3W9+jRQw0bNnQvt2jRQiEhIfr999/Pez+1a9fWzTff7F4XGBiou+++22O/TZs2aceOHRo4cKAOHjyo1NRUpaam6tixY+revbvWrFnj7kmVKlX0ww8/KCkpqcCP1xijDz/8UNddd52MMe7xU1NTFRsbqyNHjuQ5Vf18vdmwYYNSUlJ03333eXx3uHfv3mrSpIk+//xzSdK+ffu0adMmDRkyRJUrV3bvFxMTo6ZNmxb4MZzu0KFDWrlypfr166f09HT3Yzl48KBiY2O1Y8cO9+nuVapU0datW7Vjx45C3ccXX3yh9u3bu880kKQaNWrotttuK1LN59O3b1+P2coL8xg//PBDtWzZ0n0E/HScPg4A1iF4AwDyOHr0qEeQOlP//v3VsWNHDR8+XDVr1tSAAQP03nvvFSqE16lTp1ATqZ15KSuHw6FGjRpZfo3kPXv2KDw8PM/zER0d7d5+uoiIiDxjVK1aVX///fd576dRo0Z5wk/jxo09lnND4ZAhQ1SjRg2P/1599VVlZWXpyJEjkqTp06dry5Ytqlevntq2basJEyac9w8ABw4c0OHDh/XKK6/kGT/3DyUpKSketzlfb3KfozMfiyQ1adLEvT33//ldtiy/2xbEzp07ZYzR+PHj8zyeJ5980uPxTJo0SYcPH9bFF1+sSy65RI888kieGf7zs2fPnmKt+XwiIyM9lgvzGHft2qXmzZtbUhcA4Oz4jjcAwMPevXt15MiRc16KKCAgQGvWrNGqVav0+eef66uvvtK7776rbt26aenSpfLx8Tnv/Vjx/dezHbHLyckpUE3F4Wz3Y86YiK2ocv+48cwzz6hVq1b57lOpUiVJUr9+/XTllVfq448/1tKlS/XMM89o2rRp+uijj9SrV69zjj9o0CANGTIk331atGhxgY/iwp2r16fLfTwPP/ywYmNj871N7s96586dtWvXLi1evFhLly7Vq6++queff17z5s3T8OHDi7H689d9Lme+dgrzGAEA3kHwBgB4yJ086Wwf4HM5nU51795d3bt313PPPad///vfevzxx7Vq1Sr16NGj2E9bPfP0X2OMdu7c6RECq1atqsOHD+e57Z49e3TRRRe5lwtTW/369bV8+XKlp6d7HPXetm2be3txqF+/vrZs2SJjjEd9Z15TPPc09pCQEPXo0eO849auXVv33Xef7rvvPqWkpKh169Z66qmnzhq8a9SooeDgYOXk5BRofOn8vcl9jhISEtStWzePfRMSEtzbc/+f36neZz4PVatWlaQ8/T7zDITcvvv5+RXo8VSrVk1Dhw7V0KFDdfToUXXu3FkTJkw4Z/CuX79+gWrOrfvMmk+cOKF9+/adt7azKcxjbNiwobZs2VLo++A0dAC4MJxqDgBwW7lypSZPnqzIyMhzfj/10KFDedblHn3NvfxVUFCQpLzBqKjeeOMNj++df/DBB9q3b59HgGzYsKHWr1+vEydOuNd99tlneS5tVZjarrnmGuXk5Oill17yWP/888/L4XCcNcAW1jXXXKOkpCR98MEH7nUZGRl65ZVXPPZr06aNGjZsqGeffVZHjx7NM86BAwcknTqCmnvKea6wsDCFh4ef9RJl0qkj9n379tWHH36Yb0DLHf905+vNZZddprCwMM2bN8/jvr/88kvFx8erd+/ekk79kaBVq1b673//61H7smXL3JfMylW/fn35+PhozZo1HuvnzJmT5zF36dJFL7/8cr7h9vTHc/DgQY9tlSpVUqNGjc75fEmnerd+/Xr9+OOPHuO+/fbbefZt2LBhnppfeeWVQh3xPlNhHmPfvn0VFxenjz/+OM9+5zoro7hfzwBQ3nDEGwDKqS+//FLbtm3TyZMnlZycrJUrV2rZsmWqX7++Pv30U49JsM40adIkrVmzRr1791b9+vWVkpKiOXPmqG7duurUqZOkUwGjSpUqmjdvnoKDgxUUFKR27drl+X5qQVWrVk2dOnXS0KFDlZycrJkzZ6pRo0YelzwbPny4PvjgA1199dXq16+fdu3apbfeestjsrPC1nbdddepa9euevzxx/XHH3+oZcuWWrp0qRYvXqyRI0fmGbuo7rrrLr300ksaPHiwNm7cqNq1a+vNN99UYGCgx35Op1OvvvqqevXqpWbNmmno0KGqU6eO/vrrL61atUohISFasmSJ0tPTVbduXd18881q2bKlKlWqpOXLl+unn37SjBkzzlnL008/rVWrVqldu3a666671LRpUx06dEg///yzli9fnucPL+frjZ+fn6ZNm6ahQ4fqqquu0q233uq+nFiDBg00atQo91hTp05V79691alTJ9155506dOiQZs2apWbNmnn8oaFy5cq65ZZbNGvWLDkcDjVs2FCfffZZnu+fS9Ls2bPVqVMnXXLJJbrrrrt00UUXKTk5WevWrdPevXsVFxcnSWratKm6dOmiNm3aqFq1atqwYYP7cmznMmbMGL355pu6+uqr9dBDD7kvJ1a/fv083xEfPny47rnnHvXt21cxMTGKi4vT119/ne9lvAqjoI/xkUce0QcffKBbbrlFd955p9q0aaNDhw7p008/1bx589SyZct8x2/Tpo0k6cEHH1RsbKx8fHw0YMCAC6oZAMoVb02nDgDwjtzLieX+V6FCBVOrVi0TExNjXnjhBY/LQuU683JiK1asMNdff70JDw83FSpUMOHh4ebWW28127dv97jd4sWLTdOmTY2vr6/H5Ymuuuoq06xZs3zrO9vlxN555x0zduxYExYWZgICAkzv3r3Nnj178tx+xowZpk6dOsbf39907NjRbNiwIc+Y56rtzMuJGWNMenq6GTVqlAkPDzd+fn4mKirKPPPMMx6X8zLm1KWi8rt8V0EuFWWMMXv27DF9+vQxgYGBJjQ01Dz00EPmq6++yveyWb/88ou56aabTPXq1Y2/v7+pX7++6devn1mxYoUxxpisrCzzyCOPmJYtW5rg4GATFBRkWrZsaebMmXPeOowxJjk52YwYMcLUq1fP+Pn5mVq1apnu3bubV155xb1PYXvz7rvvmksvvdT4+/ubatWqmdtuu83s3bs3z34ffvihiY6ONv7+/qZp06bmo48+yrcvBw4cMH379jWBgYGmatWq5h//+IfZsmVLvpeK27Vrlxk8eLCpVauW8fPzM3Xq1DHXXnut+eCDD9z7TJkyxbRt29ZUqVLFBAQEmCZNmpinnnrKnDhx4rzP1+bNm81VV11lKlasaOrUqWMmT55s5s+fn+dyYjk5OebRRx81oaGhJjAw0MTGxpqdO3cW6nJizzzzTL7bC/IYjTHm4MGD5v777zd16tQxFSpUMHXr1jVDhgxxXz4uv8uJnTx50jzwwAOmRo0axuFwcGkxACgkhzHFNNsLAAAoV7755ht17dpV77//vsdl0Kxwxx136JtvvrF8FnsAAKzAd7wBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDf8QYAAAAAwEIc8QYAAAAAwEIEbwAAAAAALETwBgAAAADAQr7eLsBqLpdLSUlJCg4OlsPh8HY5AAAAAIAywBij9PR0hYeHy+k89zHtMh+8k5KSVK9ePW+XAQAAAAAog/7880/VrVv3nPuU+eAdHBws6dSTERIS4uVqzi47O1tLly5Vz5495efn5+1ykA96ZH/0yP7okf3RI/ujR/ZGf+yPHtlfaelRWlqa6tWr586c51Lmg3fu6eUhISG2D96BgYEKCQmx9Q9XeUaP7I8e2R89sj96ZH/0yN7oj/3RI/srbT0qyFeamVwNAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAAL+Xq7AAAAgMJITExUamqqezk0NFQRERFerAgAgHMjeAMAgFIjMTFRTaKjlZmR4V4XEBiobfHxhG8AgG0RvAEAQKmRmpqqzIwM9ZsyV2GRUUrZvUPvjbtXqampBG8AgG0RvAEAQKkTFhmlOtEtvV0GAAAFwuRqAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFvBq8c3JyNH78eEVGRiogIEANGzbU5MmTZYxx72OM0RNPPKHatWsrICBAPXr00I4dO7xYNQAAAAAABefV4D1t2jTNnTtXL730kuLj4zVt2jRNnz5ds2bNcu8zffp0vfjii5o3b55++OEHBQUFKTY2VsePH/di5QAAAAAAFIyvN+/8+++/1/XXX6/evXtLkho0aKB33nlHP/74o6RTR7tnzpypcePG6frrr5ckvfHGG6pZs6Y++eQTDRgwwGu1AwAAAABQEF494n3FFVdoxYoV2r59uyQpLi5O3333nXr16iVJ2r17t/bv368ePXq4b1O5cmW1a9dO69at80rNAAAAAAAUhlePeD/22GNKS0tTkyZN5OPjo5ycHD311FO67bbbJEn79++XJNWsWdPjdjVr1nRvO1NWVpaysrLcy2lpaZKk7OxsZWdnW/EwikVubXausbyjR/ZHj+yPHtmf3XvkcrkUEBAgHxk5XSflI6OAgAC5XC7b1lzc7N6j8o7+2B89sr/S0qPC1Ocwp89kVsIWLVqkRx55RM8884yaNWumTZs2aeTIkXruuec0ZMgQff/99+rYsaOSkpJUu3Zt9+369esnh8Ohd999N8+YEyZM0MSJE/OsX7hwoQIDAy19PAAAAACA8iEjI0MDBw7UkSNHFBIScs59vRq869Wrp8cee0wjRoxwr5syZYreeustbdu2Tb///rsaNmyoX375Ra1atXLvc9VVV6lVq1Z64YUX8oyZ3xHvevXqKTU19bxPhjdlZ2dr2bJliomJkZ+fn7fLQT7okf3RI/ujR/Zn9x7FxcWpc+fOuvvVTxXeuLmSErboleF9tGbNGrVs2dLb5ZUIu/eovKM/9keP7K+09CgtLU2hoaEFCt5ePdU8IyNDTqfn18x9fHzkcrkkSZGRkapVq5ZWrFjhDt5paWn64YcfdO+99+Y7pr+/v/z9/fOs9/Pzs3XTcpWWOsszemR/9Mj+6JH92bVHTqdTmZmZypFDLqevcuRQZmamnE6nLeu1kl17hFPoj/3RI/uze48KU5tXg/d1112np556ShEREWrWrJl++eUXPffcc7rzzjslSQ6HQyNHjtSUKVMUFRWlyMhIjR8/XuHh4brhhhu8WToAAAAAAAXi1eA9a9YsjR8/Xvfdd59SUlIUHh6uf/zjH3riiSfc+4wZM0bHjh3T3XffrcOHD6tTp0766quvVLFiRS9WDgAAAABAwXg1eAcHB2vmzJmaOXPmWfdxOByaNGmSJk2aVHKFAQAAAABQTLx6HW8AAAAAAMo6gjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABbyavBu0KCBHA5Hnv9GjBghSTp+/LhGjBih6tWrq1KlSurbt6+Sk5O9WTIAAAAAAIXi1eD9008/ad++fe7/li1bJkm65ZZbJEmjRo3SkiVL9P7772v16tVKSkrSTTfd5M2SAQAAAAAoFF9v3nmNGjU8lp9++mk1bNhQV111lY4cOaL58+dr4cKF6tatmyRpwYIFio6O1vr169W+fXtvlAwAAAAAQKHY5jveJ06c0FtvvaU777xTDodDGzduVHZ2tnr06OHep0mTJoqIiNC6deu8WCkAAAAAAAXn1SPep/vkk090+PBh3XHHHZKk/fv3q0KFCqpSpYrHfjVr1tT+/fvPOk5WVpaysrLcy2lpaZKk7OxsZWdnF3vdxSW3NjvXWN7RI/ujR/ZHj+zP7j1yuVwKCAiQj4ycrpPykVFAQIBcLpdtay5udu9ReUd/7I8e2V9p6VFh6nMYY4yFtRRYbGysKlSooCVLlkiSFi5cqKFDh3qEaElq27atunbtqmnTpuU7zoQJEzRx4sQ86xcuXKjAwMDiLxwAAAAAUO5kZGRo4MCBOnLkiEJCQs65ry2OeO/Zs0fLly/XRx995F5Xq1YtnThxQocPH/Y46p2cnKxatWqddayxY8dq9OjR7uW0tDTVq1dPPXv2PO+T4U3Z2dlatmyZYmJi5Ofn5+1ykA96ZH/0yP7okf3ZvUdxcXHq3Lmz7n71U4U3bq6khC16ZXgfrVmzRi1btvR2eSXC7j0q7+iP/dEj+ystPco9u7ogbBG8FyxYoLCwMPXu3du9rk2bNvLz89OKFSvUt29fSVJCQoISExPVoUOHs47l7+8vf3//POv9/Pxs3bRcpaXO8owe2R89sj96ZH927ZHT6VRmZqZy5JDL6ascOZSZmSmn02nLeq1k1x7hFPpjf/TI/uzeo8LU5vXg7XK5tGDBAg0ZMkS+vv8rp3Llyho2bJhGjx6tatWqKSQkRA888IA6dOjAjOYAAAAAgFLD68F7+fLlSkxM1J133pln2/PPPy+n06m+ffsqKytLsbGxmjNnjheqBAAAAACgaLwevHv27Kmzze9WsWJFzZ49W7Nnzy7hqgAAAAAAKB62uY43AAAAAABlEcEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALCQr7cLAAAAKE6JiYlKTU2VJIWGhioiIsLLFQEAyjuCNwAAKDMSExPVJDpamRkZkqSAwEBti48nfAMAvIpTzQEAQJmRmpqqzIwM9ZsyV/2mzFVmRob76DcAAN7CEW8AAFDmhEVGebsEAADcOOINAAAAAICFCN4AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFuI43AACwlcTERKWmprqXQ0NDFRER4cWKAAC4MARvAABgG4mJiWoSHa3MjAz3uoDAQG2Ljyd8AwBKLYI3AACwjdTUVGVmZKjflLkKi4xSyu4dem/cvUpNTSV4AwBKLYI3AACwnbDIKNWJbuntMgAAKBZMrgYAAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIW4jjcAALC9+Ph4j/8DAFCaELwBAIBtpacmy+F0atCgQd4uBQCAIiN4AwAA28pMT5NxudRvylyFRUYpYe0KLZsz1dtlAQBQKHzHGwAA2F5YZJTqRLdU1fAIb5cCAEChEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALCQr7cLAAAA5VtiYqJSU1MlSfHx8V6uBgCA4kfwBgAAXpOYmKgm0dHKzMjwdikAAFjG66ea//XXXxo0aJCqV6+ugIAAXXLJJdqwYYN7uzFGTzzxhGrXrq2AgAD16NFDO3bs8GLFAACguKSmpiozI0P9pszV/W8vV8x9Y71dEgAAxc6rwfvvv/9Wx44d5efnpy+//FK//fabZsyYoapVq7r3mT59ul588UXNmzdPP/zwg4KCghQbG6vjx497sXIAAFCcwiKjVCe6paqGR3i7FAAAip1XTzWfNm2a6tWrpwULFrjXRUZGuv9tjNHMmTM1btw4XX/99ZKkN954QzVr1tQnn3yiAQMGlHjNAAAAAAAUhleD96effqrY2FjdcsstWr16terUqaP77rtPd911lyRp9+7d2r9/v3r06OG+TeXKldWuXTutW7cu3+CdlZWlrKws93JaWpokKTs7W9nZ2RY/oqLLrc3ONZZ39Mj+6JH90SP7K+keuVwuBQQEyEdGTtdJ+TodhVr2kVFAQIBcLpeys7M9xpPksa2s4HVkb/TH/uiR/ZWWHhWmPocxxlhYyzlVrFhRkjR69Gjdcsst+umnn/TQQw9p3rx5GjJkiL7//nt17NhRSUlJql27tvt2/fr1k8Ph0LvvvptnzAkTJmjixIl51i9cuFCBgYHWPRgAAAAAQLmRkZGhgQMH6siRIwoJCTnnvl4N3hUqVNBll12m77//3r3uwQcf1E8//aR169YVKXjnd8S7Xr16Sk1NPe+T4U3Z2dlatmyZYmJi5Ofn5+1ykA96ZH/0yP7okf2VdI/i4uLUuXNn3f3qpwpv3FxxSxfr48mjCryclLBFrwzvozVr1qhly5Ye40ny2FZW8DqyN/pjf/TI/kpLj9LS0hQaGlqg4O3VU81r166tpk2beqyLjo7Whx9+KEmqVauWJCk5OdkjeCcnJ6tVq1b5junv7y9/f/886/38/GzdtFylpc7yjB7ZHz2yP3pkfyXVI6fTqczMTOXIIZfTVyddplDLOXIoMzNTTqdTfn5+HuNJ8thW1vA6sjf6Y3/0yP7s3qPC1ObVWc07duyohIQEj3Xbt29X/fr1JZ2aaK1WrVpasWKFe3taWpp++OEHdejQoURrBQAAAACgKLx6xHvUqFG64oor9O9//1v9+vXTjz/+qFdeeUWvvPKKJMnhcGjkyJGaMmWKoqKiFBkZqfHjxys8PFw33HCDN0sHAAAAAKBAvBq8L7/8cn388ccaO3asJk2apMjISM2cOVO33Xabe58xY8bo2LFjuvvuu3X48GF16tRJX331lXtiNgAAAAAA7MyrwVuSrr32Wl177bVn3e5wODRp0iRNmjSpBKsCAAAAAKB4ePU73gAAAAAAlHUEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQr7eLgAAAJQ/iYmJSk1NVXx8vLdLAQDAcgRvAABQohITE9UkOlqZGRneLgUAgBLBqeYAAKBEpaamKjMjQ/2mzFXMfWO9XQ4AAJbjiDcAAPCKsMgob5cAAECJ4Ig3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIV9vFwAAAMqexMREpaamupdDQ0MVERHhxYoAAPAegjcAAChWiYmJahIdrcyMDPe6gMBAbYuPJ3wDAMolgjcAAChWqampyszIUL8pcxUWGaWU3Tv03rh7lZqaSvAGAJRLBG8AAGCJsMgo1Ylu6e0yAADwOiZXAwAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCXg3eEyZMkMPh8PivSZMm7u3Hjx/XiBEjVL16dVWqVEl9+/ZVcnKyFysGAAAAAKBwvH7Eu1mzZtq3b5/7v++++869bdSoUVqyZInef/99rV69WklJSbrpppu8WC0AAAAAAIXj6/UCfH1Vq1atPOuPHDmi+fPna+HCherWrZskacGCBYqOjtb69evVvn37ki4VAAAAAIBCu+DgvXPnTu3atUudO3dWQECAjDFyOBwFvv2OHTsUHh6uihUrqkOHDpo6daoiIiK0ceNGZWdnq0ePHu59mzRpooiICK1bt+6swTsrK0tZWVnu5bS0NElSdna2srOzi/gorZdbm51rLO/okf3RI/ujR/ZXHD1yuVwKCAiQj4ycrpPykVFAQIBcLpeys7M9tvs6HR77Fnb5XGNL8thWVvA6sjf6Y3/0yP5KS48KU5/DGGOKcicHDx5U//79tXLlSjkcDu3YsUMXXXSR7rzzTlWtWlUzZsw47xhffvmljh49qsaNG2vfvn2aOHGi/vrrL23ZskVLlizR0KFDPUK0JLVt21Zdu3bVtGnT8h1zwoQJmjhxYp71CxcuVGBgYFEeKgAAAAAAHjIyMjRw4EAdOXJEISEh59y3yEe8R40aJV9fXyUmJio6Otq9vn///ho9enSBgnevXr3c/27RooXatWun+vXr67333lNAQECR6ho7dqxGjx7tXk5LS1O9evXUs2fP8z4Z3pSdna1ly5YpJiZGfn5+3i4H+aBH9keP7I8e2V9x9CguLk6dO3fW3a9+qvDGzZWUsEWvDO+jNWvWqGXLlh7bD+zZpY8nj3LvG7d0caGWzzW2JI9tZQWvI3ujP/ZHj+yvtPQo9+zqgihy8F66dKm+/vpr1a1b12N9VFSU9uzZU6Qxq1Spoosvvlg7d+5UTEyMTpw4ocOHD6tKlSrufZKTk/P9Tnguf39/+fv751nv5+dn66blKi11lmf0yP7okf3RI/u7kB45nU5lZmYqRw65nL7KkUOZmZlyOp3y8/Pz2H7SZTz2LezyucaW5LGtrOF1ZG/0x/7okf3ZvUeFqa3Is5ofO3Ys31O3Dx06lG/wLYijR49q165dql27ttq0aSM/Pz+tWLHCvT0hIUGJiYnq0KFDUcsGAAAAAKBEFTl4X3nllXrjjTfcyw6HQy6XS9OnT1fXrl0LNMbDDz+s1atX648//tD333+vG2+8UT4+Prr11ltVuXJlDRs2TKNHj9aqVau0ceNGDR06VB06dGBGcwAAAABAqVHkU82nT5+u7t27a8OGDTpx4oTGjBmjrVu36tChQ1q7dm2Bxti7d69uvfVWHTx4UDVq1FCnTp20fv161ahRQ5L0/PPPy+l0qm/fvsrKylJsbKzmzJlT1JIBAAAAAChxRQ7ezZs31/bt2/XSSy8pODhYR48e1U033aQRI0aodu3aBRpj0aJF59xesWJFzZ49W7Nnzy5qmQAAAAAAeNUFXce7cuXKevzxx4urFgAAAAAAypwif8d7wYIFev/99/Osf//99/Xf//73gooCAAAAAKCsKHLwnjp1qkJDQ/OsDwsL07///e8LKgoAAAAAgLKiyME7MTFRkZGRedbXr19fiYmJF1QUAAAAAABlRZGDd1hYmDZv3pxnfVxcnKpXr35BRQEAAAAAUFYUOXjfeuutevDBB7Vq1Srl5OQoJydHK1eu1EMPPaQBAwYUZ40AAAAAAJRaRZ7VfPLkyfrjjz/UvXt3+fqeGsblcmnw4MF8xxsAAAAAgP9X5OBdoUIFvfvuu5o8ebLi4uIUEBCgSy65RPXr1y/O+gAAAAAAKNUu6DreknTxxRfr4osvLo5aAAAAAAAoc4ocvHNycvT6669rxYoVSklJkcvl8ti+cuXKCy4OAAAAAIDSrsjB+6GHHtLrr7+u3r17q3nz5nI4HMVZFwAAAAAAZUKRg/eiRYv03nvv6ZprrinOegAAAAAAKFOKfDmxChUqqFGjRsVZCwAAAAAAZU6Rg/c///lPvfDCCzLGFGc9AAAAAACUKUU+1fy7777TqlWr9OWXX6pZs2by8/Pz2P7RRx9dcHEAAAAAAJR2RQ7eVapU0Y033lictQAAAAAAUOYUOXgvWLCgOOsAAAAAAKBMKvJ3vCXp5MmTWr58uV5++WWlp6dLkpKSknT06NFiKQ4AAAAAgNKuyEe89+zZo6uvvlqJiYnKyspSTEyMgoODNW3aNGVlZWnevHnFWScAAAAAAKVSkY94P/TQQ7rsssv0999/KyAgwL3+xhtv1IoVK4qlOAAAAAAASrsiH/H+9ttv9f3336tChQoe6xs0aKC//vrrggsDAAAAAKAsKPIRb5fLpZycnDzr9+7dq+Dg4AsqCgAAAACAsqLIwbtnz56aOXOme9nhcOjo0aN68skndc011xRHbQAAAAAAlHpFPtV8xowZio2NVdOmTXX8+HENHDhQO3bsUGhoqN55553irBEAAAAAgFKryMG7bt26iouL06JFi7R582YdPXpUw4YN02233eYx2RoAAAAAAOVZkYO3JPn6+mrQoEHFVQsAAAAAAGVOkYP3G2+8cc7tgwcPLurQAAAAAACUGUUO3g899JDHcnZ2tjIyMlShQgUFBgYSvAEAAAAA0AXMav733397/Hf06FElJCSoU6dOTK4GAAAAAMD/K3Lwzk9UVJSefvrpPEfDAQAAAAAor4o1eEunJlxLSkoq7mEBAAAAACiVivwd708//dRj2Rijffv26aWXXlLHjh0vuDAAAAAAAMqCIgfvG264wWPZ4XCoRo0a6tatm2bMmHGhdQEAAAAAUCYUOXi7XK7irAMAAAAAgDKp2L/jDQAAAAAA/qfIR7xHjx5d4H2fe+65ot4NAAAAAAClWpGD9y+//KJffvlF2dnZaty4sSRp+/bt8vHxUevWrd37ORyOC68SAAAAAIBSqsjB+7rrrlNwcLD++9//qmrVqpKkv//+W0OHDtWVV16pf/7zn8VWJAAAAAAApVWRv+M9Y8YMTZ061R26Jalq1aqaMmUKs5oDAAAAAPD/ihy809LSdODAgTzrDxw4oPT09AsqCgAAAACAsqLIwfvGG2/U0KFD9dFHH2nv3r3au3evPvzwQw0bNkw33XRTcdYIAAAAAECpVeTveM+bN08PP/ywBg4cqOzs7FOD+fpq2LBheuaZZ4qtQAAAAAAASrMiB+/AwEDNmTNHzzzzjHbt2iVJatiwoYKCgoqtOAAAAAAASrsin2qea9++fdq3b5+ioqIUFBQkY0yRx3r66aflcDg0cuRI97rjx49rxIgRql69uipVqqS+ffsqOTn5QssGAAAAAKBEFDh4u1wuj+WDBw+qe/fuuvjii3XNNddo3759kqRhw4YV6VJiP/30k15++WW1aNHCY/2oUaO0ZMkSvf/++1q9erWSkpL4DjkAAAAAoNQocPB+7rnn9MUXX7iXR40aJT8/PyUmJiowMNC9vn///vrqq68KVcTRo0d122236T//+Y/H5cmOHDmi+fPn67nnnlO3bt3Upk0bLViwQN9//73Wr19fqPsAAAAAAMAbChy8Y2Ji9OCDD2r+/PmSpKVLl2ratGmqW7eux35RUVHas2dPoYoYMWKEevfurR49enis37hxo7Kzsz3WN2nSRBEREVq3bl2h7gMAAAAAAG8o8ORqLVu21I8//qghQ4Zo2LBhOnbsmMeR7lyHDh2Sv79/gQtYtGiRfv75Z/300095tu3fv18VKlRQlSpVPNbXrFlT+/fvz3e8rKwsZWVluZfT0tIkSdnZ2e7Z1+0otzY711je0SP7o0f2R4/srzh65HK5FBAQIB8ZOV0n5SOjgIAAuVwuZWdne2z3dTo89i3s8rnGluSxrazgdWRv9Mf+6JH9lZYeFaY+hynibGjXXHON2rRpo8mTJys4OFibN29W/fr1NWDAALlcLn3wwQfnHePPP//UZZddpmXLlrm/292lSxe1atVKM2fO1MKFCzV06FCPIC1Jbdu2VdeuXTVt2rQ8Y06YMEETJ07Ms37hwoX5/qEAAAAAAIDCysjI0MCBA3XkyBGFhIScc98iB+8tW7aoe/fuat26tVauXKk+ffpo69atOnTokNauXauGDRued4xPPvlEN954o3x8fNzrcnJy5HA45HQ69fXXX6tHjx76+++/PY56169fXyNHjtSoUaPyjJnfEe969eopNTX1vE+GN2VnZ2vZsmWKiYmRn5+ft8tBPuiR/dEj+6NH9lccPYqLi1Pnzp1196ufKrxxcyUlbNErw/tozZo1atmypcf2A3t26ePJo9z7xi1dXKjlc40tyWNbWcHryN7oj/3RI/srLT1KS0tTaGhogYJ3ka/j3bx5c23fvl0vvfSSgoODdfToUd10000aMWKEateuXaAxunfvrl9//dVj3dChQ9WkSRM9+uijqlevnvz8/LRixQr17dtXkpSQkKDExER16NAh3zH9/f3zPdXdz8/P1k3LVVrqLM/okf3RI/ujR/Z3IT1yOp3KzMxUjhxyOX2VI4cyMzPldDrl5+fnsf2ky3jsW9jlc40tyWNbWcPryN7oj/3RI/uze48KU1uRgnd2drauvvpqzZs3T48//nhRhpAkBQcHq3nz5h7rgoKCVL16dff6YcOGafTo0apWrZpCQkL0wAMPqEOHDmrfvn2R7xcAAAAAgJJSpODt5+enzZs3F3ct+Xr++efldDrVt29fZWVlKTY2VnPmzCmR+wYAoDxLTExUamqqJCk0NFQRERFerggAgNKpyKeaDxo0SPPnz9fTTz9dnPXom2++8ViuWLGiZs+erdmzZxfr/QAAgLPbu3evmjVvrsyMDElSQGCgtsXHE74BACiCIgfvkydP6rXXXtPy5cvVpk0bBQUFeWx/7rnnLrg4AADgHQcPHlRmRob6TZkrSXpv3L1KTU0leAMAUASFDt6///67GjRooC1btqh169aSpO3bt3vs43A4iqc6AADgVWGRUd4uAQCAUq/QwTsqKkr79u3TqlWrJEn9+/fXiy++qJo1axZ7cQAAAAAAlHbOwt7gzMt+f/nllzp27FixFQQAAAAAQFlS5O945zoziAMAgLIpPj7e/e+srCz5+/u7l5n1HACAsyt08HY4HHm+w813ugEAKLvSU5PlcDo1aNAg9zqH0ynjcrmXmfUcAICzK3TwNsbojjvucP+V+/jx47rnnnvyzGr+0UcfFU+FAADAqzLT02RcLvWbMldhkVFKWLtCy+ZMdS+n7N7BrOcAAJxDoYP3kCFDPJZP/+s3AAAou8Iio1QnuqVSdu/wWAYAAOdW6OC9YMECK+oAAAAAAKBMuuDJ1QAAALwtd+K30yeAAwDALgjeAACg1Mpv4jcAAOyG4A0AAEqts038BgCAnTi9XQAAAMCFyp3orWo4s6oDAOyH4A0AAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIV8vV0AAAAoG+Lj4z3+DwAATiF4AwCAC5KemiyH06lBgwZ5uxQAAGyJ4A0AAC5IZnqajMulflPmKiwySglrV2jZnKneLgsAANvgO94AAKBYhEVGqU50S1UNj/B2KQAA2ArBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAAC/l6uwAAAOAdiYmJSk1NdS+Hhoaqdu3aXqwIAICyieANAEA5lJiYqCbR0crMyHCvCwgM1NYtW7xYFQAAZRPBGwCAcig1NVWZGRnqN2WuwiKjlLJ7h94bd68OHjzo7dIAAChzCN4AAJRjYZFRqhPd0ttlAABQpjG5GgAAAAAAFiJ4AwAAAABgIU41BwCgnDh9FvP4+HgvVwMAQPlB8AYAoBzIbxZzAABQMgjeAACUA2fOYp6wdoWWzZnq7bIAACgX+I43AADlSO4s5lXDI7xdCgAA5QbBGwAAAAAAC3GqOQAAZRSTqQEAYA8EbwAAyiAmUwMAwD68eqr53Llz1aJFC4WEhCgkJEQdOnTQl19+6d5+/PhxjRgxQtWrV1elSpXUt29fJScne7FiAABKh9MnU7v/7eWKuW+st0sCAKDc8mrwrlu3rp5++mlt3LhRGzZsULdu3XT99ddr69atkqRRo0ZpyZIlev/997V69WolJSXppptu8mbJAACUKkymBgCA93n1VPPrrrvOY/mpp57S3LlztX79etWtW1fz58/XwoUL1a1bN0nSggULFB0drfXr16t9+/beKBkAAAAAgEKxzazmOTk5WrRokY4dO6YOHTpo48aNys7OVo8ePdz7NGnSRBEREVq3bp0XKwUAAAAAoOC8Prnar7/+qg4dOuj48eOqVKmSPv74YzVt2lSbNm1ShQoVVKVKFY/9a9asqf379591vKysLGVlZbmX09LSJEnZ2dnKzs625DEUh9za7FxjeUeP7I8e2R89Kn579+7VwYMHJZ36Hejv7y9JSkhIUEBAgHxk5HSdlK/Tcc5lHxkFBATI5XJJklwul3v7+W5bmLGzs7OLdexzLUvyuN+ygteRvdEf+6NH9ldaelSY+hzGGGNhLed14sQJJSYm6siRI/rggw/06quvavXq1dq0aZOGDh3qEaIlqW3bturataumTZuW73gTJkzQxIkT86xfuHChAgMDLXkMAAAAAIDyJSMjQwMHDtSRI0cUEhJyzn29HrzP1KNHDzVs2FD9+/dX9+7d9ffff3sc9a5fv75GjhypUaNG5Xv7/I5416tXT6mpqed9MrwpOztby5YtU0xMjPz8/LxdDvJBj+yPHtkfPSpecXFx6ty5s24c/7wO79urVa/O0I3jn1eN+g21Y/1qrXp1hu5+9VOFN26uuKWL9fHkUWddTkrYoleG99E333yjffv2qXbt2urSpYvufvVTHdiz65y3LejYa9asUcuWLd11F8fY51qW5HG/ZQWvI3ujP/ZHj+yvtPQoLS1NoaGhBQreXj/V/Ewul0tZWVlq06aN/Pz8tGLFCvXt21fSqdPmEhMT1aFDh7Pe3t/f332a3en8/Pxs3bRcpaXO8owe2R89sj96VDycTqcyMzNVrX4jnXQZ979rRbfUvt07lZmZqRw55HL6urefbTlHDmVmZsrpdHqMnSPHeW9bmLH9/PyKdexzLUvyuN+yhteRvdEf+6NH9mf3HhWmNq8G77Fjx6pXr16KiIhQenq6Fi5cqG+++UZff/21KleurGHDhmn06NGqVq2aQkJC9MADD6hDhw7MaA4AAAAAKDW8GrxTUlI0ePBg7du3T5UrV1aLFi309ddfKyYmRpL0/PPPy+l0qm/fvsrKylJsbKzmzJnjzZIBAAAAACgUrwbv+fPnn3N7xYoVNXv2bM2ePbuEKgIAAAAAoHjZ5jreAAAAAACURQRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxku+t4AwCAsik+Pt7j/wAAlBcEbwAAYKn01GQ5nE4NGjTI26UAAOAVBG8AAGCpzPQ0GZdL/abMVVhklBLWrtCyOVO9XRYAACWG73gDAIASERYZpTrRLVU1PMLbpQAAUKII3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AAAAAgIUI3gAAAAAAWIjgDQAAAACAhQjeAAAAAABYiOANAAAAAICFCN4AAAAAAFiI4A0AANwSEhI8/g8AAC4cwRsAACg9NVkOp1N33XWXJLn/DwAALhzBGwAAKDM9Tcbl0o3jn5ckdR3+Ty9XBABA2UHwBgAAbjXqN5QkVald18uVAABQdhC8AQAAAACwEMEbAAAAAAALEbwBAAAAALAQwRsAAAAAAAsRvAEAAAAAsBDBGwAAAAAACxG8AQAAAACwEMEbAAAAAAALEbwBAAAAALCQV4P31KlTdfnllys4OFhhYWG64YYblJCQ4LHP8ePHNWLECFWvXl2VKlVS3759lZyc7KWKAQAAAAAoHK8G79WrV2vEiBFav369li1bpuzsbPXs2VPHjh1z7zNq1CgtWbJE77//vlavXq2kpCTddNNNXqwaAAAAAICC8/XmnX/11Vcey6+//rrCwsK0ceNGde7cWUeOHNH8+fO1cOFCdevWTZK0YMECRUdHa/369Wrfvr03ygYAAAAAoMC8GrzPdOTIEUlStWrVJEkbN25Udna2evTo4d6nSZMmioiI0Lp16/IN3llZWcrKynIvp6WlSZKys7OVnZ1tZfkXJLc2O9dY3tEj+6NH9kePipfL5VJAQIB8ZOTrdLj/7XSdvKBlSR7LxTn2mctWji1JAQEBcrlcZepnjteRvdEf+6NH9ldaelSY+hzGGGNhLQXmcrnUp08fHT58WN99950kaeHChRo6dKhHkJaktm3bqmvXrpo2bVqecSZMmKCJEyfmWb9w4UIFBgZaUzwAAAAAoFzJyMjQwIEDdeTIEYWEhJxzX9sc8R4xYoS2bNniDt1FNXbsWI0ePdq9nJaWpnr16qlnz57nfTK8KTs7W8uWLVNMTIz8/Py8XQ7yQY/sjx7ZHz0qXnFxcercubPufvVTHdizSx9PHqW7X/1U4Y2bK27p4iIt3/vqYnUOytBH25L1/sSRxTp2fstWji1JrwzvozVr1qhly5Ze7lbx4XVkb/TH/uiR/ZWWHuWeXV0Qtgje999/vz777DOtWbNGdevWda+vVauWTpw4ocOHD6tKlSru9cnJyapVq1a+Y/n7+8vf3z/Pej8/P1s3LVdpqbM8o0f2R4/sjx4VD6fTqczMTOXIoZMu4/63y+l7QcuSPJaLc+wzl60cW5IyMzPldDrL5M8bryN7oz/2R4/sz+49KkxtXp3V3Bij+++/Xx9//LFWrlypyMhIj+1t2rSRn5+fVqxY4V6XkJCgxMREdejQoaTLBQAAAACg0Lx6xHvEiBFauHChFi9erODgYO3fv1+SVLlyZQUEBKhy5coaNmyYRo8erWrVqikkJEQPPPCAOnTowIzmAAAAAIBSwavBe+7cuZKkLl26eKxfsGCB7rjjDknS888/L6fTqb59+yorK0uxsbGaM2dOCVcKAAAAAEDReDV4F2RC9YoVK2r27NmaPXt2CVQEAAAAAEDx8up3vAEAAAAAKOsI3gAAAAAAWIjgDQAAAACAhWxxHW8AAACrxMfHu/+dlZUlf39/93JoaKgiIiK8URYAoBwheAMAgDIpPTVZDqdTgwYNcq9zOJ0yLpd7OSAwUNvi4wnfAABLEbwBAECZlJmeJuNyqd+UuQqLjFLC2hVaNmeqezll9w69N+5epaamErwBAJYieAMAgDItLDJKdaJbKmX3Do9lAABKCpOrAQAAAABgIYI3AAAAAAAW4lRzAAAuUGJiolJTU93LZ86Uffp2ZtEGAKD8IXgDAHABEhMT1SQ6WpkZGe51p8+UfeZ2ZtEGAKD84VRzAAAuQGpqqjIzMtRvylzd//Zy9ZsyV5kZGe4j3KdvP3MbAAAoHzjiDQBAMTjfTNlhkVElWA0AALATjngDAAAAAGAhjngDAJCP0ydEy8rKkr+/v3vb6cvx8fElVofE5GxWOL2HPL8AACsQvAEAOMOZE6I5nE4Zl8u9/czlkqpDYnK24pSemiyH06lBgwa51/H8AgCsQPAGAOAMp0+I9ndSopbNmap+U+YqLDJKCWtX5LtsdR1hkVFK2b1D7427V6mpqQTDYpCZnibjcvH8AgAsR/AGAOAsTp8QLXfytJTdO/JdtrqOc03chgvD8wsAsBqTqwEAAAAAYCGCNwAAAAAAFuJUcwAAbOT0WcytnjEdAACUDII3AAA2kd8s5gAAoPQjeAMAYBNnzmJu5YzpAACg5PAdbwAAbCZ3lu2q4VzSCgCAsoDgDQAAAACAhTjVHACAEnb6pGlZWVny9/fPsx4AAJQdBG8AAEpIemqyHE6nBg0a5F7ncDplXC4vVgUAAKxG8AYAoIRkpqfJuFx5Jk9jMjUAAMo2vuMNAEAJO3PyNCZTAwCgbCN4AwAAAABgIYI3AAAAAAAWIngDAAAAAGAhgjcAAAAAABYieAMAAAAAYCGCNwAAAAAAFiJ4AwAAAABgIV9vFwAAKD/27t0rSYqLi5PT6VRoaKgiIrh2NQAAKNs44g0AKBGJiYm67PLLJUmdO3dWmzZt1CQ6WomJiV6uDAAAwFoEbwBAiUhNTVVmRoYk6e5XP1W/KXOVmZGh1NRUL1cGAABgLU41BwCUuPDGzZUjh7fLAAAAKBEc8QYAAAAAwEIEbwAAAAAALMSp5gAA20pMTPT4DviZs6Cfvp0Z0gEAgF0RvAEAtpSYmKgm0dHuCdkkKSAwUNvi4xUREZFn++nbAAAA7MTrp5qvWbNG1113ncLDw+VwOPTJJ594bDfG6IknnlDt2rUVEBCgHj16aMeOHd4pFgBQYnJnQe83Za7uf3t5nlnQT9/ODOkAAMDOvB68jx07ppYtW2r27Nn5bp8+fbpefPFFzZs3Tz/88IOCgoIUGxur48ePl3ClAABvCIuMUp3olgqLjDrr9rNtAwAAsAOvn2req1cv9erVK99txhjNnDlT48aN0/XXXy9JeuONN1SzZk198sknGjBgQEmWCgAAAABAoXk9eJ/L7t27tX//fvXo0cO9rnLlymrXrp3WrVuXb/DOyspSVlaWezktLU2SlJ2drezsbOuLLqLc2uxcY3lHj+yPHtmby+VSQECAJMnpOikfGQUEBCg+Pl4ul0vSqfdwf39/SVJCQoICAgLkI+Oxv8vlUnZ2tns8HxlJOudYBVmuXr266tat61Grj4x8nQ6POs63fK46CztWSY59+rIkj+XiHPvMZTuNfebza1e819kb/bE/emR/paVHhanPYYwxFtZSKA6HQx9//LFuuOEGSdL333+vjh07KikpSbVr13bv169fPzkcDr377rt5xpgwYYImTpyYZ/3ChQsVGBhoWe0AAAAAgPIjIyNDAwcO1JEjRxQSEnLOfW19xLsoxo4dq9GjR7uX09LSVK9ePfXs2fO8T4Y3ZWdna9myZYqJiZGfn5+3y0E+6JH90SN7i4uLU2xsrF577TXtCG+jX5Z/ro8nj9KN459XjfoNtWP9aq16dUae5btf/VThjZsrKWGLXhneR2vWrFHLli0VFxenzp076+5XP9WBPbsKNNbZlnNvf66xc+uIW7r4nMsFqbOgY5Xk2LnL9766WJ2DMvTRtmS9P3FksY6d37Kdxj7z+bUr3uvsjf7YHz2yv9LSo9yzqwvC1sG7Vq1akqTk5GSPI97Jyclq1apVvrfx9/f3OHUwl5+fn62blqu01Fme0SP7o0f25HQ6lZmZKUlyOX110mWUmZmpavUbqVZ0S+3bvTPf5Rw55HL6KkcOZWZmyul0ys/Pzz1ejhwFHutsywUZO7eO8y0X51glOfbpy5I8lotz7DOX7TT2mc+v3fFeZ2/0x/7okf3ZvUeFqc3rs5qfS2RkpGrVqqUVK1a416WlpemHH35Qhw4dvFgZAAAAAAAF4/Uj3kePHtXOnTvdy7t379amTZtUrVo1RUREaOTIkZoyZYqioqIUGRmp8ePHKzw83P09cAAAAAAA7MzrwXvDhg3q2rWrezn3+9lDhgzR66+/rjFjxujYsWO6++67dfjwYXXq1ElfffWVKlas6K2SAaBcSUxMVGpqqns5NDRUERERXqwI8fHxHv8HAAD25vXg3aVLF51rYnWHw6FJkyZp0qRJJVgVAEA6FbqbREcrMyPDvS4gMFDb4uMJ316Qnposh9OpQYMGebsUAABQCF4P3gAA+0pNTVVmRob6TZmrsMgopezeoffG3avU1FSCtxdkpqfJuFzufiSsXaFlc6Z6uywAAHAeBG8AwHmFRUapTrR9L69U3uT2I2X3Dm+XAgAACsDWs5oDAAAAAFDaccQbAFBop0/qlZWVJX9/f/fymZOv5U7OVt4mAmMCNAAAkIvgDQAosPwm93I4nTIul3v59MnXzpycLSAgoMRrLmlMgAYAAM5E8AYAFNjZJvc62+Rrp0/O9ndSor5bMNPbD8FyTIAGAADORPAGABTamZN7nW/ytbDIqJIqzTaYAA0AAORicjUAAAAAACxE8AYAAAAAwEKcag4A8JA7C7nEjNwAAADFgeANAHA7cxZyAAAAXDiCNwDA7fRZyJmRGwAAoHjwHW8AQB65M3JXDY/wdikAAAClHsEbAAAAAAALcao5AJRCp0+AJklZWVny9/c/63JoaKgiIjh6DQAA4A0EbwAoZfKbAM3hdMq4XGddDggM1Lb4eMI3AACAFxC8AaCUOdsEaGdbTtm9Q++Nu1epqakEbwAAAC8geANAKZU7AVrK7h3nXAYAAIB3MbkaAAAAAAAWIngDAAAAAGAhTjUHALhnSY+Pjy+W8XLHKa7xysLYAACg/CJ4A0A5l98s6UWVnposh9OpQYMGFUNlZWNsAAAATjUHgHLu9FnSY+4be0FjZaanybhc6jdlru5/e/kFj1cWxgYAAOCINwBA0qlZ0ItzrNNnWC9OpXVsAABQfnHEGwAAAAAAC3HEGwDKidMnDAsNDVVERIQXqwFQGLkTIEqSy+XycjUAgMIieANAGZffxGEBgYHaFh9P+AZKgTMnQAwICNA777yjvXv3KjIy0svVAQAKguANAGXc6ROHhUVGKWX3Dr037l6lpqYSvIFS4PQJEMMio3Roz05J0sGDBwneAFBKELwBoJzInTgMQOmU+xr2kZF0zNvlAAAKgcnVAAAAAACwEEe8AXjF6RMFSUz2lZ8zn6OsrCz5+/t7TJIGAAAA+yN4AyhxZ04UJDHZ15nye44cTqcMsxkDAACUOpxqDqDEnT5R0P1vL1e/KXOVmZHhcXS3vDvzOYq5b6x7grSY+8Z6uzwAAAAUAke8AXgNk32dX+5zlLJ7h3sZAAAApQtHvAEAAAAAsBDBGwAAAAAAC3Gquc3ExcXJ6Tz195DcGYxzFWb5zBmizzY7MmMXfOyqVasK1jp9tu7T+1XQXrn+f+KxH3/8UQEBAWfdvyhjF3S5uMYuiZnLc++DWdIBT6e/Js71Or2Q9wfp3O8RBXk/SEhIOOtnBq4UAQD2QvC2ib1790qSOnfurMzMTEl5ZzAuzPLpM0QXZHZkxj7/WNWqV9dr8+cLxS89NVkOp1ODBg1yr8vtl6QC9yogIEDvvPOOesbGKuPYsbPuX5SxC7pcnGNbJb/nG0D+r41zvU6L+v5QkN9D53o/OHowRQoK0l133XXWzwxcKQIA7IXgbRMHDx6UJN04/nlVq99ICWtXaNmcqeo3Za7CIqMKtSxJ7427V6mpqYqIiPCYHbmwYzH2qeWU3Tu05KnRXvjJKB8y09PcM3bnPt+5/ZJU4F7Vjmwk6ZjHWPn1sihjF/TnpLjHLonn28r7AkqTs7028lv+OymxyO8P5/s9dLax3XUeTZcUdNbPDGfeFwDA+wjeNlOjfkPVOmMG4zNnND7f8tkUZSzGZtbtknSu57sgvQpv3Eza+8M59y/q2EX9ObnQsa1UkvcFlCaF+b1yob9HCjP2mc72mQEAYD9MrgYAAAAAgIU44l2GWTlxUnkeO3cCPCausZ6Vk36V1rEBlG5lYVLD0yeFY1K3vHLn7eHzAlA4p7+3uEpgzpuSRvAug6ycOKm8jp17e+l/E+AxcY117Pyz4K2xAZRuZeX94cxJ4ZjUzVNiYqIuu/xyvTZ/Pp8XgEI4870ld8LcvXv3KjIy0svVFY9Sc6r57Nmz1aBBA1WsWFHt2rXTjz/+6O2SbOv0yWHuf3u5Yu4by9gXOHbu7SXp7lc/Vb8pc5WZkeFxGRgUn9P7VZw/B6V5bAClm5W/40rS6ZPCxdw31uMx8bvxf8+PxOcFoDBOf2+5/+3lunH885L+NwF1WVAqjni/++67Gj16tObNm6d27dpp5syZio2NVUJCgsLCwrxdnm1ZOXFSeR47vHFz5chRjFXhbM41MV55HRtA6VZWJjXMbxI4eOLzAlB4ue8nPjKSjp13/9KkVBzxfu6553TXXXdp6NChatq0qebNm6fAwEC99tpr3i4NAAAAAIBzsn3wPnHihDZu3KgePXq41zmdTvXo0UPr1q3zYmUAAAAAAJyf7U81T01NVU5OjmrWrOmxvmbNmtq2bVue/bOyspSVleVePnLkiCTp0KFDys7OtrbYC5CWlqaMjAwl7/hDWRnH9Pefv6tixYpKTvhVJzOOFmr5cHJSkW/L2OdezsjIUOIv65Xy5x+qWLGiNm7cqLS0NDmdTo/ZF4tzuSyOvWPHDkt6ZzLSVS8os0z9zJXFsXNfR6WtbruNZdnYO7Yq4+IwHf5zd+mquxyNffjP3cpoEHLWzwwH/793ub+jivO9//T37zPrPN/9lpbfUReynPv8nO3zgl3rLm9jnzx5UhkZGfr222/l6+tr2zrL09hnfjY8/Ncfyrg4TGlpabb+nnd6erokyRhz3n0dpiB7eVFSUpLq1Kmj77//Xh06dHCvHzNmjFavXq0ffvjBY/8JEyZo4sSJJV0mAAAAAKAc+vPPP1W3bt1z7mP7I96hoaHy8fFRcnKyx/rk5GTVqlUrz/5jx47V6NGj3csul0uHDh1S9erV5XDYd4KLtLQ01atXT3/++adCQkK8XQ7yQY/sjx7ZHz2yP3pkf/TI3uiP/dEj+ystPTLGKD09XeHh4efd1/bBu0KFCmrTpo1WrFihG264QdKpML1ixQrdf//9efb39/eXv7+/x7oqVaqUQKXFIyQkxNY/XKBHpQE9sj96ZH/0yP7okb3RH/ujR/ZXGnpUuXLlAu1n++AtSaNHj9aQIUN02WWXqW3btpo5c6aOHTumoUOHers0AAAAAADOqVQE7/79++vAgQN64okntH//frVq1UpfffVVngnXAAAAAACwm1IRvCXp/vvvz/fU8rLC399fTz75ZJ7T5GEf9Mj+6JH90SP7o0f2R4/sjf7YHz2yv7LYI9vPag4AAAAAQGnm9HYBAAAAAACUZQRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAABKEHMb2x89QnEjeJcyvAnYHz2yP3pkf/TIfs7sCT2yH3pkfzk5OR7LLpfLS5XgbOiR/ZXW9zouJ2Zzhw4d0pEjR2SM0UUXXeTtcpAPemR/9Mj+6JG9JSQk6O2331ZiYqI6deqkTp06qUmTJnK5XHI6+Ru+HdAj+4uPj9esWbOUlJSk6Oho3XzzzWrTpo23y8Jp6JH9leb3OntXV85t3rxZ3bp1U9euXdWzZ09dffXVSkxM9HZZOA09sj96ZH/0yN5+++03tWvXTr/99pt27NihV199VTExMVqxYoWcTmepOdJQltEj+9u2bZvat2+vjIwM+fr6auPGjerYsaPefPNNb5eG/0eP7K/Uv9cZ2NKff/5pwsPDzWOPPWa++eYb8/7775s2bdqYiIgIs3z5cnPy5Elvl1ju0SP7o0f2R4/s7eTJk2bQoEHmtttuc6/75ZdfzLBhw4yPj4/57LPPjDHG5OTkeKvEco8elQ733XefueGGG9zLycnJZty4ccbHx8fMmTPHGGOMy+XyVnkw9MjuysJ7HcHbplauXGmaNm1qkpKS3OtOnjxpevXqZWrXrm3WrVtnjLH3D1dZR4/sjx7ZHz2ytxMnTpirrrrKPPbYYx7rU1JSzL333msqVqzo7hG8gx6VDjfddJMZNmxYnvX//ve/jcPhMJ9//rkxhmDnTfTI3srCex2nmttUamqqkpKSVK1aNUnSiRMn5OPjoy+++EJNmzbVnXfeKWOM7b/LUJbRI/ujR/ZHj+zNz89PzZs31+rVq/X333+719eoUUNjx45V7969NXnyZKWlpXmxyvKNHpUOLVq00NKlS5WUlCTpf5NBPfzww/rHP/6hhx9+WPv375fD4fBmmeUaPbK3svBexycZm8l9kffq1UuVKlXSP//5T0lShQoVdOLECUnSG2+8oaysLD377LNeq7O8On1my169eik4OJge2RCvI3vjdVS6dO7cWZmZmVqwYIHS09Pd6+vVq6frrrtOmzZt0pEjR7xYYflz4MABHThwwL3ctWtXHT9+nB7ZWGxsrOrVq6epU6cqJSVFDodDLpdLfn5+uvnmm3XkyBHt37/f22WWK0lJSdq+fbt7uVevXoqIiKBHNlbafx8RvG0iMzNTLpfL/YEzKChIY8aM0bfffqtnnnlG0qkPpC6XS9WrV1fdunV58Zew3377TU899ZSysrJkjFFAQIAefvhhrV27lh7ZBK8j++N1ZG9//PGH/vOf/2j+/Pn6+uuvJUn9+vVTp06d9PLLL+utt97SoUOH3PtffvnlCgwM9PgABGv9/PPPuuSSS5SQkOBe17dvX3Xo0EH/+c9/6JEN7Nq1S9OmTdOUKVPcE3O1b99effv21Xfffadnn31Wf/31l/tMniZNmigoKEjHjh3zZtnlyi+//KIWLVp4BO+2bdvq2muv1ffff0+PbKAs/j7y9XYBkLZs2aKRI0fq2LFjSk9P16OPPqrrrrtOgwcP1vbt27Vo0SJlZmbqiSeekNPplL+/v6pVqyY/Pz9Jp47ucdqLteLi4tS6dWv9+9//lr+/vyTJx8dHffv21fbt2/Xuu+/SIy/jdWR/vI7s7ddff1XXrl0VFRWlAwcOKDk5WTfffLNefPFFzZo1S8OHD9ecOXO0fft23X///apcubL++9//yul0qmbNmt4uv1yIi4vTVVddpWHDhqlTp04e22bPnq3Bgwdr7ty59MiLtmzZok6dOqlVq1bKyMjQ5s2btXDhQk2fPl2jR49WZmamFi9erG3btmny5MkKCgrS/PnzdeLECTVs2NDb5ZcLcXFxuvLKK3XXXXfp2muv9dj22GOP6ejRo1q+fDk98qIy+/vIG18sx//s2rXLVK1a1YwYMcLMmjXLPPDAA6ZKlSpm+PDhZufOnebQoUPm0UcfNRdddJHp0aOHefrpp82dd95pKlWqZOLj471dfrkQFxdngoKCzCOPPOKxPne25T/++MOMGTOGHnkRryP743Vkb+np6aZDhw7mgQceMMYYs2/fPvPll1+aatWqme7du5vk5GRjjDETJ040V155pXE4HKZNmzamVq1a5ueff/Zm6eXG5s2bTeXKld2voZycHPPrr7+adevWmU2bNrn3e+KJJ+iRl2RkZJjY2Fhz3333GWOMyczMNL/99ptp1KiRueKKK8z69euNMca88cYbplevXsbhcJjmzZub+vXr06MSsnXrVhMcHOx+HZ08edJ8++235osvvjArVqxw77dgwQJ65CVl+fcRwdvLnn32WdO5c2ePdW+//ba55JJLzG233Wb27Nljjh07ZpYvX2569uxpunXrZvr06WPi4uK8VHH58vvvv5uqVauagQMHGmNOfdB5+umnzfDhw80tt9xiVq1aZYwxJi0tjR55Ea8je+N1ZH+ZmZmmdevWZtGiRR7rExISTGhoqLn22mvd65KTk82XX35pvvvuO/Pnn3+WdKnlUnZ2tmnSpIkJCgoyx48fNzk5OaZPnz6mTZs2JigoyERERJhx48a5909JSaFHXtKxY0czffp0Y8ypvhljzF9//WVatGhhOnbsaFJSUowxpwLfDz/8YLZu3Wr27dvntXrLk5MnT5oePXqYkJAQEx8fb3Jyckzv3r1N69atTbVq1UxAQIC56667PPanRyWvLP8+Inh72bPPPmtatWpl0tPTPS6X8/7775tGjRqZsWPH5rnNiRMnSrLEcm3JkiWmbt265qGHHjIbNmwwXbt2NV27djW9e/c2V199tXE4HGbWrFl5bkePShavI3vjdWR/R48eNXXq1DETJ050r8t9/nPPVpgwYYK3yoM5daQuNDTUXHfddaZTp06mZ8+eZs2aNea7774zL7zwgvHx8THTpk3zdpnllsvlMpmZmeayyy4z99xzj3t9VlaWMebUUbtq1aqZe++911slwhizc+dO06ZNGxMTE2NatWplYmNjzcaNG018fLxZvHixCQoKMqNHj/Z2meVaWf59RPD2snfeeccEBAS4T43IfYM2xpi5c+eaChUqmC1btnjchusHlqy33nrLtGnTxtSuXdv07t3b7N+/3/0GMHnyZFOxYsU8p8LSo5K1aNEiXkc2t3DhQl5HNjdjxgxTt25ds2TJEve63B5NmTLFtGvXzhw8eJBrqnvR1q1bTWBgoGnVqpXZv3+/e/3x48fNyJEjTceOHc2hQ4d47XhB7nP+4YcfGn9/f/PGG2+4t2VmZhpjTp1i3qBBA/PHH3/QIy/I/WrTrl27TLNmzcwVV1xhEhMTPfZ57rnnTIMGDUxiYiI98qLnnnuuTP4+YlbzEpaRkaG///5bmZmZkqQBAwaoZ8+euv7665WSkqIKFSooKytLknTPPfcoIiJCK1eu9BiDyYWslduj3Jkrb7vtNo0ePVqXX365xo0bp5o1a7one3rggQcUHBysNWvWeIxBj0pW//79FRMTw+vIxm699VaNGjWK15FN7Nu3Tz/++KO+/vpr5eTkSJJuuukmdejQQdOnT9fSpUslyd2j0NBQpaWlqWLFilxTvYSc2aOcnBw1bdpUW7du1YMPPqhq1aq59/X391dgYKBOnDih4OBgXjslJPe143K53M95ly5d9I9//EMTJkzQO++8I0mqWLGiJKlSpUqqUKGCKlWqRI9KyOk98vHxUU5Oji666CItXbpUDz74oGrVquWxv8PhUEhIiEJDQ+lRCTl48KC2bdum9evXu9fFxMSoY8eOZe73UemqtpTbunWr+vfvr44dO2rgwIFasmSJJOmpp55SRESE2rdvr71797pn+83IyFBwcLCqVq3qzbLLldN7NGjQIH366aeSpIEDB+rpp59Wq1atJP3vOtGpqamqXbu2GjVq5K2Sy52EhASNHTtWt99+u5599ln9/PPPkqTnnntO4eHhvI5s4Mwebdy4UdKpP2JNmTKF15GXbd68WR06dNDtt9+u/v37q1mzZlq0aJHq1KmjMWPGqHLlyho3bpwWLVokScrOztbvv/+usLAw94dYWOvMHjVv3lzvvfeeUlJS1KBBAw0ePNj9ITRXamqqWrRoIZfL5aWqy5ctW7aoR48e+vPPP+V0Ot3Pe7Vq1XT33XerR48eGj16tGbNmqXjx4/r2LFj2rBhgypVqlTqwkJplV+PfHx85HK5FB4erv79++d5Hf3+++9q0qSJlyouf3799Vddc801uuGGG3T99dcrNjZWktS8eXPdddddqlq1qsaPH192fh95+5B7ebF161b3rMvz5s0zHTt2NLfeeqsx5tTpST/99JPp3LmzqVKlinn55ZfNO++8Yx577DFTvXp1s2vXLi9XXz7k16OBAwee81Sjxx9/3LRo0cIkJSWVYKXl19atW02VKlXMLbfcYu655x5Tr14906pVK/PKK68YY4z59ddfzZVXXsnryIvy61Hr1q3NSy+9dNbb8DoqOSkpKaZJkybmX//6l9m1a5f566+/TP/+/c3FF19sJk6caI4fP242bdpk7rnnHuPr62tatmxp2rdvb6pWrWp++eUXb5dfLpytR9HR0ebJJ590T86Va9++febxxx831atXN1u3bvVS1eXL7t27TaNGjYzD4TBRUVHuSZ1yJ1MzxpgdO3aYKVOmGH9/f9OoUSPTsmVLU6NGDdvPulxWnK1HZzs1+ffffzePP/64qVKlivn1119LstRya9u2bSY0NNQ89thjZt26debrr782F110kXn00Ufd+6xdu9bce++9Zeb3EcG7BGRkZJgbbrjBPPTQQ+51ixcvNjfeeKPZt2+fOX78uDHm1He0HnzwQRMdHW0aN25s2rVrxxt0CTlXj5KTk016erp7vcvlMl999ZUZMWJEqX7xlzbp6ekmNjbWjBkzxr1u7969pnr16qZGjRruSYXS09PNyJEjeR15wbl6VLNmTTNlyhSP/XkdlbytW7eaBg0amA0bNnisf/TRR02zZs3Ms88+a1wulzl69KhZt26dmTx5spk3b57ZsWOHlyouf87Vo0suucRMnz7dHDt2zBhz6kPp4MGDTXh4OK+hEpKZmWnGjRtnbrzxRrNixQrTuXNnU79+/XzDtzHGxMfHm/nz55tFixaZ3bt3e6Hi8ud8PTozfG/atMkMHDjQRERE8DoqIenp6aZfv37uS+8Zc6ovDzzwgOnTp0+efcvK7yNfbx9xLw/8/f118OBBXXrppe513377rX755RdddtllioqKUocOHfTvf/9bL7zwgv766y8FBQVJkqpUqeKlqsuXc/WodevWaty4sdq2baupU6cqOztb27Zt08aNG7V69WpdcsklXqy8/HA6nTp06JD7NOWMjAzVqVNH3bp106FDh/Txxx+rRYsWuvrqq/X8888rKSlJgYGBkngdlZTz9eiLL75Q69at1atXL6WnpyshIYHXUQnLzs7WyZMnlZGRIUnKzMxUQECAnn76aWVmZmrWrFmKiYlRixYt1L59e7Vv397LFZc/5+vR3LlzFRsbqxYtWigsLEy9evXSk08+qYsuusjLlZcPFStWVPPmzXXJJZeoW7duatiwoW6//XZ16tRJ3333nerWraucnBz3Kc1NmjTh1OUSVpAeuVwu9yn/kZGRuuOOO/TUU0+pQYMG3i2+HAkODnZ/XpBOfYbo1KmTvvnmG504cULGGPn7+ysoKKjM/D5yGPP/X7KDJVwul44ePap+/fopMDBQPXr00N69ezVz5kzNmTNHtWrV0o8//qjFixdr3LhxuvHGGz3eDGC9wvRowoQJuu6665SVlaXMzEwCXQkxxujAgQO69NJLNWrUKD388MOSpL179yo2NlaPPvqoZsyYobZt2+o///mP+zZMjFJyitKjEydOKCMjg9dRCWvbtq0qVarknnAwKyvLPSfC5ZdfrkaNGrknhYJ3nK9HDRs2dH/nkfc67zLGaPfu3Ro6dKj27NmjtWvXqk6dOjp+/Lji4+PVuHFj9x+B4R3n61F0dLR7AjyUDJfLpT///FP169eX9L/3sffee09TpkzR5s2b3fseO3bMfUCytCPdWST3C/9Op1MhISGaOHGiMjMztXbtWn300Ud66aWXdMcdd+jqq6/WP/7xD6WmpiohIcF9G1ivKD3aunWrpFNHyAkL1svtkcPhUFhYmP71r39pzJgxGjZsmMaPH6/o6Gh17NhRgwcP1vjx47V8+XIdPHjQY4ZZWOtCelShQgVeRxY7duyY0tPTlZaW5l738ssva+vWrRo4cKCkU+9nJ0+elCR17tzZfUUHlIyi9Cj3aLjE7P8lIb8eSf+bzfyiiy7Sa6+9pvr166tjx47avXu3Hn74Yd199906ceKEl6ouXy6kR8ePH/dS1eXL6T1yOp3u0H36Z7bTJyqUpH/+858aMGBA6ZxILR8kPAts375dM2fO1L59+9zr2rVrpw8++EBvvPGGqlWrpkqVKrm3VatWTY0bN1ZISIik/830C+vQI/vLr0f33nuvFixYoF9//VUbNmzQ+PHj9corr0iS9u/fr6pVq6patWr88aqE0CN7++2333TTTTfpqquuUnR0tN5++21JUnR0tF544QUtW7ZMt9xyi7Kzs939SElJUVBQkE6ePMn7XAmgR/Z3th4ZYzzexxo2bKgFCxYoMjJSDRs21Ouvv645c+bwx8USQI/sr6A9CgwMdP+R8V//+pfmzp2rxx9/XD4+Pl6pu7jxHe9itnPnTnXo0EF///23Dh48qNGjRys0NFSSFBAQoMzMTLlcLm3ZskU9e/aUr6+vpk+fri1btujll1+WxF+vrUaP7O9sPXI6nRoyZIj69+8vh8PhPvVSOnUJq4YNG7pPyaRH1qJH9vbbb7+pc+fOGjx4sC677DJt3LhRQ4cOVdOmTXXppZeqT58+CgoK0n333acWLVqoSZMmqlChgj7//HOtX79evr58PLAaPbK/s/WoWbNmHt9NzVW3bl3VqlVLVatW1bfffqumTZuWfNHlDD2yv8L06OTJk6pataoef/xxzZgxQ+vWrVPr1q29U7gVSnw6tzLs6NGj5s477zR33HGHmT17tnE4HOaRRx4xBw4c8Njv3XffNQ6Hw1x88cWmXbt2pn79+sy6XELokf0VpEenX+ItPj7ejBw50gQHB5vNmzd7o+Ryhx7Z28GDB03Pnj3Ngw8+6LG+S5cu5oEHHvBYl5aWZsaMGWOGDx9u7r//fi5HVULokf0VpEenv8/l5OSYWbNmGR8fHz4vlBB6ZH+F7VHu5++qVavmubJDWcCfS4uR0+lUmzZtVL16dfXv31+hoaEaMGCAJGnMmDHuo6r9+vVTnTp19M033yg0NFSxsbHMolhC6JH9FaRHuUdK09PTtWzZMv3yyy9as2YNM2OXEHpkb9nZ2Tp8+LBuvvlmSXJP2BkZGalDhw5JOnV6nzFGwcHBmjZtmsd+sB49sr+C9Oj0s3Zyv7MaHx+vqKgor9Rc3tAj+ytsj9q0aaNOnTpp9uzZZfPzgndzf9lz9OhRj+VFixYZh8NhHn74YffRoBMnTuQ5woqSQ4/s71w9Sk1NNcYYc/LkSZOcnGyys7PNoUOHvFFmuUaP7G379u3uf584ccIYY8y4cePM7bff7rHfkSNH3P8+/agDrEeP7K+gPUpLSyvRuvA/9Mj+Ctqj9PR0Y0zezxdlCUe8i1nudPc5OTlyOp3q37+/jDEaOHCgHA6HRo4cqWeffVZ//PGH3nzzTQUGBvI9xxJGj+yvoD3avXu3Fi5cqKpVq3q54vKHHtlb7tEcl8slPz8/SaeOoKakpLj3mTp1qvz9/fXggw/K19eX97kSRo/sryg9QsmiR/ZX0B5VqFBBI0eOLDOXDssPP30W8fHxkTFGLpdLAwYMkMPh0O23365PP/1Uu3bt0k8//VSmf7BKA3pkf+fr0Y8//qiAgABvl1mu0SN7czqdHtd5zj1N+YknntCUKVP0yy+/8EHUy+iR/dEj+6NH9leQHpWV2cvPhi8KWcjhcMjhcMgYo/79++vKK6/UgQMH9PPPP+c70yJKHj2yv3P16NJLL/V2eRA9sjvz/5ec8vX1Vb169fTss89q+vTp2rBhg1q2bOnl6iDRo9KAHtkfPbK/8t4j/vRjMYfDoZycHD3yyCNatWqVNm3aVDYnCyjF6JH90SP7o0f2lXtUwc/PT//5z38UEhKi7777rmxdoqWUo0f2R4/sjx7ZX3nvEUe8S0izZs30888/q0WLFt4uBWdBj+yPHtkfPbKv2NhYSdL333+vyy67zMvVID/0yP7okf3RI/srrz1ymNxj/rDU6d9pgD3RI/ujR/ZHj+zt2LFjzF1hc/TI/uiR/dEj+yuPPSJ4AwAAAABgIU41BwAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAUGgvvPCC1q1b5+0yAAAoFQjeAACgUGbMmKGPPvpIrVu39nYpAACUCgRvAADKgHXr1snHx0e9e/e29H7Wrl2rN998U4sXL5a/v7+l9wUAQFnhMMYYbxcBAAAuzPDhw1WpUiXNnz9fCQkJCg8P93ZJAADg/3HEGwCAUu7o0aN69913de+996p37956/fXX3du++eYbORwOrVixQpdddpkCAwN1xRVXKCEhwb3PhAkT1KpVK7355ptq0KCBKleurAEDBig9Pd29j8vl0tSpUxUZGamAgAC1bNlSH3zwgUcdW7ZsUa9evVSpUiXVrFlTt99+u1JTUy1//AAA2B3BGwCAUu69995TkyZN1LhxYw0aNEivvfaazjyh7fHHH9eMGTO0YcMG+fr66s477/TYvmvXLn3yySf67LPP9Nlnn2n16tV6+umn3dunTp2qN954Q/PmzdPWrVs1atQoDRo0SKtXr5YkHT58WN26ddOll16qDRs26KuvvlJycrL69etn/RMAAIDNcao5AAClXMeOHdWvXz899NBDOnnypGrXrq33339fXbp00TfffKOuXbtq+fLl6t69uyTpiy++UO/evZWZmamKFStqwoQJeuaZZ7R//34FBwdLksaMGaM1a9Zo/fr1ysrKUrVq1bR8+XJ16NDBfb/Dhw9XRkaGFi5cqClTpujbb7/V119/7d6+d+9e1atXTwkJCbr44otL9kkBAMBGfL1dAAAAKLqEhAT9+OOP+vjjjyVJvr6+6t+/v+bPn68uXbq492vRooX737Vr15YkpaSkKCIiQpLUoEEDd+jO3SclJUWStHPnTmVkZCgmJsbjvk+cOKFLL71UkhQXF6dVq1apUqVKeWrctWsXwRsAUK4RvAEAKMXmz5+vkydPekymZoyRv7+/XnrpJfc6Pz8/978dDoekU9/bzm977j65248ePSpJ+vzzz1WnTh2P/XJnNj969Kiuu+46TZs2LU+NuUEfAIDyiuANAEApdfLkSb3xxhuaMWOGevbs6bHthhtu0DvvvKMmTZpc8P00bdpU/v7+SkxM1FVXXZXvPq1bt9aHH36oBg0ayNeXjxcAAJyOydUAACilPvvsM/39998aNmyYmjdv7vFf3759NX/+/GK5n+DgYD388MMaNWqU/vvf/2rXrl36+eefNWvWLP33v/+VJI0YMUKHDh3Srbfeqp9++km7du3S119/raFDhyonJ6dY6gAAoLQieAMAUErNnz9fPXr0UOXKlfNs69u3rzZs2KDNmzcXy31NnjxZ48eP19SpUxUdHa2rr75an3/+uSIjIyVJ4eHhWrt2rXJyctSzZ09dcsklGjlypKpUqSKnk48bAIDyjVnNAQAAAACwEH+CBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALETwBgAAAADAQgRvAAAAAAAsRPAGAAAAAMBCBG8AAAAAACxE8AYAAAAAwEIEbwAAAAAALPR/vZN8F60wiUIAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# keep years under 2500\n",
+    "before2500 = [x for x in all_years if x < 2500]\n",
+    "df = pd.DataFrame(before2500, columns=['Année']) \n",
+    "all_years_before_2500 = visualize_year_distribution(df['Année'], 'Distribution des époques du récit')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[20302070, 22000, 19401945]"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Future dates\n",
+    "# keep years after 2500\n",
+    "[x for x in all_years if x >= 2500]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['Entre 2 et 10 tonnes', 'Entre 10 et 30 tonnes', 'Entre 0 et 2 tonnes',\n",
+       "       'Entre 30 et 80 tonnes', 'Entre 2 et 10', 'Au-delà de 80 tonnes',\n",
+       "       'Entre 10 et 100', 'Entre 0 et 2 tonnes (eq CO2)'],\n",
+       "      dtype='object', name='QUELLE EST L'EMPREINTE CARBONE ANNUELLE DU PERSONNAGE ?')"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "co2 = data[\"QUELLE EST L'EMPREINTE CARBONE ANNUELLE DU PERSONNAGE ?\"]\n",
+    "c = co2.value_counts()\n",
+    "c.index\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Construction du camembert\n",
+    "plt.figure(figsize=(8, 8))\n",
+    "plt.pie(c, autopct='%1.1f%%', startangle=140)\n",
+    "plt.title(\"Empreinte Personnelle\")\n",
+    "\n",
+    "plt.axis('equal')  # S'assure que le camembert est dessiné comme un cercle.\n",
+    "plt.title('Empreinte carbone')\n",
+    "plt.legend(c.index)\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/poetry.lock b/poetry.lock
index 7cf0f4b..7d3fdc7 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,145 +1,29 @@
 # This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand.
 
 [[package]]
-name = "anyio"
-version = "4.3.0"
-description = "High level compatibility layer for multiple asynchronous event loop implementations"
+name = "altair"
+version = "5.3.0"
+description = "Vega-Altair: A declarative statistical visualization library for Python."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "anyio-4.3.0-py3-none-any.whl", hash = "sha256:048e05d0f6caeed70d731f3db756d35dcc1f35747c8c403364a8332c630441b8"},
-    {file = "anyio-4.3.0.tar.gz", hash = "sha256:f75253795a87df48568485fd18cdd2a3fa5c4f7c5be8e5e36637733fce06fed6"},
+    {file = "altair-5.3.0-py3-none-any.whl", hash = "sha256:7084a1dab4d83c5e7e5246b92dc1b4451a6c68fd057f3716ee9d315c8980e59a"},
+    {file = "altair-5.3.0.tar.gz", hash = "sha256:5a268b1a0983b23d8f9129f819f956174aa7aea2719ed55a52eba9979b9f6675"},
 ]
 
 [package.dependencies]
-exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""}
-idna = ">=2.8"
-sniffio = ">=1.1"
-typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""}
-
-[package.extras]
-doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"]
-test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"]
-trio = ["trio (>=0.23)"]
-
-[[package]]
-name = "appnope"
-version = "0.1.4"
-description = "Disable App Nap on macOS >= 10.9"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"},
-    {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"},
-]
-
-[[package]]
-name = "argon2-cffi"
-version = "23.1.0"
-description = "Argon2 for Python"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"},
-    {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"},
-]
-
-[package.dependencies]
-argon2-cffi-bindings = "*"
-
-[package.extras]
-dev = ["argon2-cffi[tests,typing]", "tox (>4)"]
-docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"]
-tests = ["hypothesis", "pytest"]
-typing = ["mypy"]
-
-[[package]]
-name = "argon2-cffi-bindings"
-version = "21.2.0"
-description = "Low-level CFFI bindings for Argon2"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"},
-    {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"},
-    {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"},
-    {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"},
-    {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"},
-    {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"},
-    {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"},
-    {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"},
-    {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"},
-    {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"},
-    {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"},
-    {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"},
-    {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"},
-]
-
-[package.dependencies]
-cffi = ">=1.0.1"
-
-[package.extras]
-dev = ["cogapp", "pre-commit", "pytest", "wheel"]
-tests = ["pytest"]
-
-[[package]]
-name = "arrow"
-version = "1.3.0"
-description = "Better dates & times for Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"},
-    {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"},
-]
-
-[package.dependencies]
-python-dateutil = ">=2.7.0"
-types-python-dateutil = ">=2.8.10"
-
-[package.extras]
-doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"]
-test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"]
-
-[[package]]
-name = "asttokens"
-version = "2.4.1"
-description = "Annotate AST trees with source code positions"
-optional = false
-python-versions = "*"
-files = [
-    {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"},
-    {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"},
-]
-
-[package.dependencies]
-six = ">=1.12.0"
+jinja2 = "*"
+jsonschema = ">=3.0"
+numpy = "*"
+packaging = "*"
+pandas = ">=0.25"
+toolz = "*"
+typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"]
-test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"]
-
-[[package]]
-name = "async-lru"
-version = "2.0.4"
-description = "Simple LRU cache for asyncio"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"},
-    {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"},
-]
-
-[package.dependencies]
-typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""}
+all = ["altair-tiles (>=0.3.0)", "anywidget (>=0.9.0)", "pyarrow (>=11)", "vega-datasets (>=0.9.0)", "vegafusion[embed] (>=1.6.6)", "vl-convert-python (>=1.3.0)"]
+dev = ["geopandas", "hatch", "ipython", "m2r", "mypy", "pandas-stubs", "pytest", "pytest-cov", "ruff (>=0.3.0)", "types-jsonschema", "types-setuptools"]
+doc = ["docutils", "jinja2", "myst-parser", "numpydoc", "pillow (>=9,<10)", "pydata-sphinx-theme (>=0.14.1)", "scipy", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinxext-altair"]
 
 [[package]]
 name = "attrs"
@@ -160,41 +44,6 @@ tests = ["attrs[tests-no-zope]", "zope-interface"]
 tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"]
 tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"]
 
-[[package]]
-name = "babel"
-version = "2.14.0"
-description = "Internationalization utilities"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "Babel-2.14.0-py3-none-any.whl", hash = "sha256:efb1a25b7118e67ce3a259bed20545c29cb68be8ad2c784c83689981b7a57287"},
-    {file = "Babel-2.14.0.tar.gz", hash = "sha256:6919867db036398ba21eb5c7a0f6b28ab8cbc3ae7a73a44ebe34ae74a4e7d363"},
-]
-
-[package.extras]
-dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"]
-
-[[package]]
-name = "beautifulsoup4"
-version = "4.12.3"
-description = "Screen-scraping library"
-optional = false
-python-versions = ">=3.6.0"
-files = [
-    {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"},
-    {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"},
-]
-
-[package.dependencies]
-soupsieve = ">1.2"
-
-[package.extras]
-cchardet = ["cchardet"]
-chardet = ["chardet"]
-charset-normalizer = ["charset-normalizer"]
-html5lib = ["html5lib"]
-lxml = ["lxml"]
-
 [[package]]
 name = "bleach"
 version = "6.1.0"
@@ -213,6 +62,17 @@ webencodings = "*"
 [package.extras]
 css = ["tinycss2 (>=1.1.0,<1.3)"]
 
+[[package]]
+name = "blinker"
+version = "1.7.0"
+description = "Fast, simple object-to-object and broadcast signaling"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "blinker-1.7.0-py3-none-any.whl", hash = "sha256:c3f865d4d54db7abc53758a01601cf343fe55b84c1de4e3fa910e420b438d5b9"},
+    {file = "blinker-1.7.0.tar.gz", hash = "sha256:e6820ff6fa4e4d1d8e2747c2283749c3f547e4fee112b98555cdcdae32996182"},
+]
+
 [[package]]
 name = "cachetools"
 version = "5.3.3"
@@ -235,70 +95,6 @@ files = [
     {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"},
 ]
 
-[[package]]
-name = "cffi"
-version = "1.16.0"
-description = "Foreign Function Interface for Python calling C code."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"},
-    {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"},
-    {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"},
-    {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"},
-    {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"},
-    {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"},
-    {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"},
-    {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"},
-    {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"},
-    {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"},
-    {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"},
-    {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"},
-    {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"},
-    {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"},
-    {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"},
-    {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"},
-    {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"},
-    {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"},
-    {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"},
-    {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"},
-    {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"},
-    {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"},
-    {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"},
-    {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"},
-    {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"},
-    {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"},
-    {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"},
-]
-
-[package.dependencies]
-pycparser = "*"
-
 [[package]]
 name = "cfgv"
 version = "3.4.0"
@@ -420,6 +216,20 @@ files = [
     {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"},
 ]
 
+[[package]]
+name = "click"
+version = "8.1.7"
+description = "Composable command line interface toolkit"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
+    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -432,43 +242,82 @@ files = [
 ]
 
 [[package]]
-name = "comm"
-version = "0.2.1"
-description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc."
+name = "contourpy"
+version = "1.2.1"
+description = "Python library for calculating contours of 2D quadrilateral grids"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
 files = [
-    {file = "comm-0.2.1-py3-none-any.whl", hash = "sha256:87928485c0dfc0e7976fd89fc1e187023cf587e7c353e4a9b417555b44adf021"},
-    {file = "comm-0.2.1.tar.gz", hash = "sha256:0bc91edae1344d39d3661dcbc36937181fdaddb304790458f8b044dbc064b89a"},
+    {file = "contourpy-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040"},
+    {file = "contourpy-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b"},
+    {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd"},
+    {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619"},
+    {file = "contourpy-1.2.1-cp310-cp310-win32.whl", hash = "sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8"},
+    {file = "contourpy-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9"},
+    {file = "contourpy-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5"},
+    {file = "contourpy-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df"},
+    {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205"},
+    {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8"},
+    {file = "contourpy-1.2.1-cp311-cp311-win32.whl", hash = "sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec"},
+    {file = "contourpy-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922"},
+    {file = "contourpy-1.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc"},
+    {file = "contourpy-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b"},
+    {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce"},
+    {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4"},
+    {file = "contourpy-1.2.1-cp312-cp312-win32.whl", hash = "sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f"},
+    {file = "contourpy-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce"},
+    {file = "contourpy-1.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b"},
+    {file = "contourpy-1.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445"},
+    {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02"},
+    {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083"},
+    {file = "contourpy-1.2.1-cp39-cp39-win32.whl", hash = "sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba"},
+    {file = "contourpy-1.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9"},
+    {file = "contourpy-1.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609"},
+    {file = "contourpy-1.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3"},
+    {file = "contourpy-1.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f"},
+    {file = "contourpy-1.2.1.tar.gz", hash = "sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c"},
 ]
 
 [package.dependencies]
-traitlets = ">=4"
+numpy = ">=1.20"
 
 [package.extras]
-test = ["pytest"]
+bokeh = ["bokeh", "selenium"]
+docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"]
+mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.8.0)", "types-Pillow"]
+test = ["Pillow", "contourpy[test-no-images]", "matplotlib"]
+test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"]
 
 [[package]]
-name = "decorator"
-version = "5.1.1"
-description = "Decorators for Humans"
+name = "cycler"
+version = "0.12.1"
+description = "Composable style cycles"
 optional = false
-python-versions = ">=3.5"
+python-versions = ">=3.8"
 files = [
-    {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"},
-    {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"},
+    {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"},
+    {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"},
 ]
 
-[[package]]
-name = "defusedxml"
-version = "0.7.1"
-description = "XML bomb protection for Python stdlib modules"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-files = [
-    {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"},
-    {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"},
-]
+[package.extras]
+docs = ["ipython", "matplotlib", "numpydoc", "sphinx"]
+tests = ["pytest", "pytest-cov", "pytest-xdist"]
 
 [[package]]
 name = "distlib"
@@ -495,116 +344,118 @@ files = [
 [package.extras]
 test = ["pytest (>=6)"]
 
-[[package]]
-name = "executing"
-version = "2.0.1"
-description = "Get the currently executing AST node of a frame, and other information"
-optional = false
-python-versions = ">=3.5"
-files = [
-    {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"},
-    {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"},
-]
-
-[package.extras]
-tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"]
-
-[[package]]
-name = "fastjsonschema"
-version = "2.19.1"
-description = "Fastest Python implementation of JSON schema"
-optional = false
-python-versions = "*"
-files = [
-    {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"},
-    {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"},
-]
-
-[package.extras]
-devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"]
-
 [[package]]
 name = "filelock"
-version = "3.13.1"
+version = "3.13.4"
 description = "A platform independent file lock."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "filelock-3.13.1-py3-none-any.whl", hash = "sha256:57dbda9b35157b05fb3e58ee91448612eb674172fab98ee235ccb0b5bee19a1c"},
-    {file = "filelock-3.13.1.tar.gz", hash = "sha256:521f5f56c50f8426f5e03ad3b281b490a87ef15bc6c526f168290f0c7148d44e"},
+    {file = "filelock-3.13.4-py3-none-any.whl", hash = "sha256:404e5e9253aa60ad457cae1be07c0f0ca90a63931200a47d9b6a6af84fd7b45f"},
+    {file = "filelock-3.13.4.tar.gz", hash = "sha256:d13f466618bfde72bd2c18255e269f72542c6e70e7bac83a0232d6b1cc5c8cf4"},
 ]
 
 [package.extras]
-docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.24)"]
-testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"]
+docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
+testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"]
 typing = ["typing-extensions (>=4.8)"]
 
 [[package]]
-name = "fqdn"
-version = "1.5.1"
-description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers"
+name = "fonttools"
+version = "4.51.0"
+description = "Tools to manipulate font files"
 optional = false
-python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4"
+python-versions = ">=3.8"
 files = [
-    {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"},
-    {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"},
+    {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:84d7751f4468dd8cdd03ddada18b8b0857a5beec80bce9f435742abc9a851a74"},
+    {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b4850fa2ef2cfbc1d1f689bc159ef0f45d8d83298c1425838095bf53ef46308"},
+    {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5b48a1121117047d82695d276c2af2ee3a24ffe0f502ed581acc2673ecf1037"},
+    {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:180194c7fe60c989bb627d7ed5011f2bef1c4d36ecf3ec64daec8302f1ae0716"},
+    {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:96a48e137c36be55e68845fc4284533bda2980f8d6f835e26bca79d7e2006438"},
+    {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:806e7912c32a657fa39d2d6eb1d3012d35f841387c8fc6cf349ed70b7c340039"},
+    {file = "fonttools-4.51.0-cp310-cp310-win32.whl", hash = "sha256:32b17504696f605e9e960647c5f64b35704782a502cc26a37b800b4d69ff3c77"},
+    {file = "fonttools-4.51.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7e91abdfae1b5c9e3a543f48ce96013f9a08c6c9668f1e6be0beabf0a569c1b"},
+    {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a8feca65bab31479d795b0d16c9a9852902e3a3c0630678efb0b2b7941ea9c74"},
+    {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ac27f436e8af7779f0bb4d5425aa3535270494d3bc5459ed27de3f03151e4c2"},
+    {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e19bd9e9964a09cd2433a4b100ca7f34e34731e0758e13ba9a1ed6e5468cc0f"},
+    {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2b92381f37b39ba2fc98c3a45a9d6383bfc9916a87d66ccb6553f7bdd129097"},
+    {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5f6bc991d1610f5c3bbe997b0233cbc234b8e82fa99fc0b2932dc1ca5e5afec0"},
+    {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9696fe9f3f0c32e9a321d5268208a7cc9205a52f99b89479d1b035ed54c923f1"},
+    {file = "fonttools-4.51.0-cp311-cp311-win32.whl", hash = "sha256:3bee3f3bd9fa1d5ee616ccfd13b27ca605c2b4270e45715bd2883e9504735034"},
+    {file = "fonttools-4.51.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f08c901d3866a8905363619e3741c33f0a83a680d92a9f0e575985c2634fcc1"},
+    {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4060acc2bfa2d8e98117828a238889f13b6f69d59f4f2d5857eece5277b829ba"},
+    {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1250e818b5f8a679ad79660855528120a8f0288f8f30ec88b83db51515411fcc"},
+    {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76f1777d8b3386479ffb4a282e74318e730014d86ce60f016908d9801af9ca2a"},
+    {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b5ad456813d93b9c4b7ee55302208db2b45324315129d85275c01f5cb7e61a2"},
+    {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:68b3fb7775a923be73e739f92f7e8a72725fd333eab24834041365d2278c3671"},
+    {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8e2f1a4499e3b5ee82c19b5ee57f0294673125c65b0a1ff3764ea1f9db2f9ef5"},
+    {file = "fonttools-4.51.0-cp312-cp312-win32.whl", hash = "sha256:278e50f6b003c6aed19bae2242b364e575bcb16304b53f2b64f6551b9c000e15"},
+    {file = "fonttools-4.51.0-cp312-cp312-win_amd64.whl", hash = "sha256:b3c61423f22165541b9403ee39874dcae84cd57a9078b82e1dce8cb06b07fa2e"},
+    {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1621ee57da887c17312acc4b0e7ac30d3a4fb0fec6174b2e3754a74c26bbed1e"},
+    {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d9298be7a05bb4801f558522adbe2feea1b0b103d5294ebf24a92dd49b78e5"},
+    {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee1af4be1c5afe4c96ca23badd368d8dc75f611887fb0c0dac9f71ee5d6f110e"},
+    {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b49adc721a7d0b8dfe7c3130c89b8704baf599fb396396d07d4aa69b824a1"},
+    {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de7c29bdbdd35811f14493ffd2534b88f0ce1b9065316433b22d63ca1cd21f14"},
+    {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cadf4e12a608ef1d13e039864f484c8a968840afa0258b0b843a0556497ea9ed"},
+    {file = "fonttools-4.51.0-cp38-cp38-win32.whl", hash = "sha256:aefa011207ed36cd280babfaa8510b8176f1a77261833e895a9d96e57e44802f"},
+    {file = "fonttools-4.51.0-cp38-cp38-win_amd64.whl", hash = "sha256:865a58b6e60b0938874af0968cd0553bcd88e0b2cb6e588727117bd099eef836"},
+    {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:60a3409c9112aec02d5fb546f557bca6efa773dcb32ac147c6baf5f742e6258b"},
+    {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7e89853d8bea103c8e3514b9f9dc86b5b4120afb4583b57eb10dfa5afbe0936"},
+    {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56fc244f2585d6c00b9bcc59e6593e646cf095a96fe68d62cd4da53dd1287b55"},
+    {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d145976194a5242fdd22df18a1b451481a88071feadf251221af110ca8f00ce"},
+    {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c5b8cab0c137ca229433570151b5c1fc6af212680b58b15abd797dcdd9dd5051"},
+    {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:54dcf21a2f2d06ded676e3c3f9f74b2bafded3a8ff12f0983160b13e9f2fb4a7"},
+    {file = "fonttools-4.51.0-cp39-cp39-win32.whl", hash = "sha256:0118ef998a0699a96c7b28457f15546815015a2710a1b23a7bf6c1be60c01636"},
+    {file = "fonttools-4.51.0-cp39-cp39-win_amd64.whl", hash = "sha256:599bdb75e220241cedc6faebfafedd7670335d2e29620d207dd0378a4e9ccc5a"},
+    {file = "fonttools-4.51.0-py3-none-any.whl", hash = "sha256:15c94eeef6b095831067f72c825eb0e2d48bb4cea0647c1b05c981ecba2bf39f"},
+    {file = "fonttools-4.51.0.tar.gz", hash = "sha256:dc0673361331566d7a663d7ce0f6fdcbfbdc1f59c6e3ed1165ad7202ca183c68"},
 ]
 
-[[package]]
-name = "h11"
-version = "0.14.0"
-description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1"
+[package.extras]
+all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"]
+graphite = ["lz4 (>=1.7.4.2)"]
+interpolatable = ["munkres", "pycairo", "scipy"]
+lxml = ["lxml (>=4.0)"]
+pathops = ["skia-pathops (>=0.5.0)"]
+plot = ["matplotlib"]
+repacker = ["uharfbuzz (>=0.23.0)"]
+symfont = ["sympy"]
+type1 = ["xattr"]
+ufo = ["fs (>=2.2.0,<3)"]
+unicode = ["unicodedata2 (>=15.1.0)"]
+woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"]
+
+[[package]]
+name = "gitdb"
+version = "4.0.11"
+description = "Git Object Database"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"},
-    {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"},
-]
-
-[[package]]
-name = "httpcore"
-version = "1.0.4"
-description = "A minimal low-level HTTP client."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "httpcore-1.0.4-py3-none-any.whl", hash = "sha256:ac418c1db41bade2ad53ae2f3834a3a0f5ae76b56cf5aa497d2d033384fc7d73"},
-    {file = "httpcore-1.0.4.tar.gz", hash = "sha256:cb2839ccfcba0d2d3c1131d3c3e26dfc327326fbe7a5dc0dbfe9f6c9151bb022"},
+    {file = "gitdb-4.0.11-py3-none-any.whl", hash = "sha256:81a3407ddd2ee8df444cbacea00e2d038e40150acfa3001696fe0dcf1d3adfa4"},
+    {file = "gitdb-4.0.11.tar.gz", hash = "sha256:bf5421126136d6d0af55bc1e7c1af1c397a34f5b7bd79e776cd3e89785c2b04b"},
 ]
 
 [package.dependencies]
-certifi = "*"
-h11 = ">=0.13,<0.15"
-
-[package.extras]
-asyncio = ["anyio (>=4.0,<5.0)"]
-http2 = ["h2 (>=3,<5)"]
-socks = ["socksio (==1.*)"]
-trio = ["trio (>=0.22.0,<0.25.0)"]
+smmap = ">=3.0.1,<6"
 
 [[package]]
-name = "httpx"
-version = "0.27.0"
-description = "The next generation HTTP client."
+name = "gitpython"
+version = "3.1.43"
+description = "GitPython is a Python library used to interact with Git repositories"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.7"
 files = [
-    {file = "httpx-0.27.0-py3-none-any.whl", hash = "sha256:71d5465162c13681bff01ad59b2cc68dd838ea1f10e51574bac27103f00c91a5"},
-    {file = "httpx-0.27.0.tar.gz", hash = "sha256:a0cb88a46f32dc874e04ee956e4c2764aba2aa228f650b06788ba6bda2962ab5"},
+    {file = "GitPython-3.1.43-py3-none-any.whl", hash = "sha256:eec7ec56b92aad751f9912a73404bc02ba212a23adb2c7098ee668417051a1ff"},
+    {file = "GitPython-3.1.43.tar.gz", hash = "sha256:35f314a9f878467f5453cc1fee295c3e18e52f1b99f10f6cf5b1682e968a9e7c"},
 ]
 
 [package.dependencies]
-anyio = "*"
-certifi = "*"
-httpcore = "==1.*"
-idna = "*"
-sniffio = "*"
+gitdb = ">=4.0.1,<5"
 
 [package.extras]
-brotli = ["brotli", "brotlicffi"]
-cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
-http2 = ["h2 (>=3,<5)"]
-socks = ["socksio (==1.*)"]
+doc = ["sphinx (==4.3.2)", "sphinx-autodoc-typehints", "sphinx-rtd-theme", "sphinxcontrib-applehelp (>=1.0.2,<=1.0.4)", "sphinxcontrib-devhelp (==1.0.2)", "sphinxcontrib-htmlhelp (>=2.0.0,<=2.0.1)", "sphinxcontrib-qthelp (==1.0.3)", "sphinxcontrib-serializinghtml (==1.1.5)"]
+test = ["coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "typing-extensions"]
 
 [[package]]
 name = "identify"
@@ -622,13 +473,13 @@ license = ["ukkonen"]
 
 [[package]]
 name = "idna"
-version = "3.6"
+version = "3.7"
 description = "Internationalized Domain Names in Applications (IDNA)"
 optional = false
 python-versions = ">=3.5"
 files = [
-    {file = "idna-3.6-py3-none-any.whl", hash = "sha256:c05567e9c24a6b9faaa835c4821bad0590fbb9d5779e7caa6e1cc4978e7eb24f"},
-    {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"},
+    {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"},
+    {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"},
 ]
 
 [[package]]
@@ -653,129 +504,6 @@ files = [
     {file = "invoke-2.2.0.tar.gz", hash = "sha256:ee6cbb101af1a859c7fe84f2a264c059020b0cb7fe3535f9424300ab568f6bd5"},
 ]
 
-[[package]]
-name = "ipykernel"
-version = "5.5.6"
-description = "IPython Kernel for Jupyter"
-optional = false
-python-versions = ">=3.5"
-files = [
-    {file = "ipykernel-5.5.6-py3-none-any.whl", hash = "sha256:66f824af1ef4650e1e2f6c42e1423074321440ef79ca3651a6cfd06a4e25e42f"},
-    {file = "ipykernel-5.5.6.tar.gz", hash = "sha256:4ea44b90ae1f7c38987ad58ea0809562a17c2695a0499644326f334aecd369ec"},
-]
-
-[package.dependencies]
-appnope = {version = "*", markers = "platform_system == \"Darwin\""}
-ipython = ">=5.0.0"
-ipython-genutils = "*"
-jupyter-client = "*"
-tornado = ">=4.2"
-traitlets = ">=4.1.0"
-
-[package.extras]
-test = ["flaky", "jedi (<=0.17.2)", "nose", "pytest (!=5.3.4)", "pytest-cov"]
-
-[[package]]
-name = "ipython"
-version = "8.22.2"
-description = "IPython: Productive Interactive Computing"
-optional = false
-python-versions = ">=3.10"
-files = [
-    {file = "ipython-8.22.2-py3-none-any.whl", hash = "sha256:3c86f284c8f3d8f2b6c662f885c4889a91df7cd52056fd02b7d8d6195d7f56e9"},
-    {file = "ipython-8.22.2.tar.gz", hash = "sha256:2dcaad9049f9056f1fef63514f176c7d41f930daa78d05b82a176202818f2c14"},
-]
-
-[package.dependencies]
-colorama = {version = "*", markers = "sys_platform == \"win32\""}
-decorator = "*"
-exceptiongroup = {version = "*", markers = "python_version < \"3.11\""}
-jedi = ">=0.16"
-matplotlib-inline = "*"
-pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""}
-prompt-toolkit = ">=3.0.41,<3.1.0"
-pygments = ">=2.4.0"
-stack-data = "*"
-traitlets = ">=5.13.0"
-
-[package.extras]
-all = ["ipython[black,doc,kernel,nbconvert,nbformat,notebook,parallel,qtconsole,terminal]", "ipython[test,test-extra]"]
-black = ["black"]
-doc = ["docrepr", "exceptiongroup", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "stack-data", "typing-extensions"]
-kernel = ["ipykernel"]
-nbconvert = ["nbconvert"]
-nbformat = ["nbformat"]
-notebook = ["ipywidgets", "notebook"]
-parallel = ["ipyparallel"]
-qtconsole = ["qtconsole"]
-test = ["pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath"]
-test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"]
-
-[[package]]
-name = "ipython-genutils"
-version = "0.2.0"
-description = "Vestigial utilities from IPython"
-optional = false
-python-versions = "*"
-files = [
-    {file = "ipython_genutils-0.2.0-py2.py3-none-any.whl", hash = "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8"},
-    {file = "ipython_genutils-0.2.0.tar.gz", hash = "sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8"},
-]
-
-[[package]]
-name = "ipywidgets"
-version = "8.1.2"
-description = "Jupyter interactive widgets"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "ipywidgets-8.1.2-py3-none-any.whl", hash = "sha256:bbe43850d79fb5e906b14801d6c01402857996864d1e5b6fa62dd2ee35559f60"},
-    {file = "ipywidgets-8.1.2.tar.gz", hash = "sha256:d0b9b41e49bae926a866e613a39b0f0097745d2b9f1f3dd406641b4a57ec42c9"},
-]
-
-[package.dependencies]
-comm = ">=0.1.3"
-ipython = ">=6.1.0"
-jupyterlab-widgets = ">=3.0.10,<3.1.0"
-traitlets = ">=4.3.1"
-widgetsnbextension = ">=4.0.10,<4.1.0"
-
-[package.extras]
-test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"]
-
-[[package]]
-name = "isoduration"
-version = "20.11.0"
-description = "Operations with ISO 8601 durations"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"},
-    {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"},
-]
-
-[package.dependencies]
-arrow = ">=0.15.0"
-
-[[package]]
-name = "jedi"
-version = "0.19.1"
-description = "An autocompletion tool for Python that can be used for text editors."
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"},
-    {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"},
-]
-
-[package.dependencies]
-parso = ">=0.8.3,<0.9.0"
-
-[package.extras]
-docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"]
-qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"]
-testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"]
-
 [[package]]
 name = "jinja2"
 version = "3.1.3"
@@ -793,31 +521,6 @@ MarkupSafe = ">=2.0"
 [package.extras]
 i18n = ["Babel (>=2.7)"]
 
-[[package]]
-name = "json5"
-version = "0.9.20"
-description = "A Python implementation of the JSON5 data format."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "json5-0.9.20-py3-none-any.whl", hash = "sha256:f623485b37fad95783233bad9352d21526709cbd9a2ec41ddc3e950fca85b701"},
-    {file = "json5-0.9.20.tar.gz", hash = "sha256:20a255981244081d5aaa4adc90d31cdbf05bed1863993cbf300b8e2cd2b6de88"},
-]
-
-[package.extras]
-dev = ["hypothesis"]
-
-[[package]]
-name = "jsonpointer"
-version = "2.4"
-description = "Identify specific nodes in a JSON document (RFC 6901)"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*"
-files = [
-    {file = "jsonpointer-2.4-py2.py3-none-any.whl", hash = "sha256:15d51bba20eea3165644553647711d150376234112651b4f1811022aecad7d7a"},
-    {file = "jsonpointer-2.4.tar.gz", hash = "sha256:585cee82b70211fa9e6043b7bb89db6e1aa49524340dde8ad6b63206ea689d88"},
-]
-
 [[package]]
 name = "jsonschema"
 version = "4.21.1"
@@ -831,305 +534,41 @@ files = [
 
 [package.dependencies]
 attrs = ">=22.2.0"
-fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""}
-idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""}
-isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""}
-jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""}
 jsonschema-specifications = ">=2023.03.6"
 referencing = ">=0.28.4"
-rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""}
-rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""}
 rpds-py = ">=0.7.1"
-uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""}
-webcolors = {version = ">=1.11", optional = true, markers = "extra == \"format-nongpl\""}
 
 [package.extras]
 format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"]
 format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"]
 
 [[package]]
-name = "jsonschema-specifications"
-version = "2023.12.1"
-description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"},
-    {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"},
-]
-
-[package.dependencies]
-referencing = ">=0.31.0"
-
-[[package]]
-name = "jupyter"
-version = "1.0.0"
-description = "Jupyter metapackage. Install all the Jupyter components in one go."
-optional = false
-python-versions = "*"
-files = [
-    {file = "jupyter-1.0.0-py2.py3-none-any.whl", hash = "sha256:5b290f93b98ffbc21c0c7e749f054b3267782166d72fa5e3ed1ed4eaf34a2b78"},
-    {file = "jupyter-1.0.0.tar.gz", hash = "sha256:d9dc4b3318f310e34c82951ea5d6683f67bed7def4b259fafbfe4f1beb1d8e5f"},
-    {file = "jupyter-1.0.0.zip", hash = "sha256:3e1f86076bbb7c8c207829390305a2b1fe836d471ed54be66a3b8c41e7f46cc7"},
-]
-
-[package.dependencies]
-ipykernel = "*"
-ipywidgets = "*"
-jupyter-console = "*"
-nbconvert = "*"
-notebook = "*"
-qtconsole = "*"
-
-[[package]]
-name = "jupyter-client"
-version = "8.6.0"
-description = "Jupyter protocol implementation and client libraries"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyter_client-8.6.0-py3-none-any.whl", hash = "sha256:909c474dbe62582ae62b758bca86d6518c85234bdee2d908c778db6d72f39d99"},
-    {file = "jupyter_client-8.6.0.tar.gz", hash = "sha256:0642244bb83b4764ae60d07e010e15f0e2d275ec4e918a8f7b80fbbef3ca60c7"},
-]
-
-[package.dependencies]
-jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0"
-python-dateutil = ">=2.8.2"
-pyzmq = ">=23.0"
-tornado = ">=6.2"
-traitlets = ">=5.3"
-
-[package.extras]
-docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"]
-test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"]
-
-[[package]]
-name = "jupyter-console"
-version = "6.4.4"
-description = "Jupyter terminal console"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "jupyter_console-6.4.4-py3-none-any.whl", hash = "sha256:756df7f4f60c986e7bc0172e4493d3830a7e6e75c08750bbe59c0a5403ad6dee"},
-    {file = "jupyter_console-6.4.4.tar.gz", hash = "sha256:172f5335e31d600df61613a97b7f0352f2c8250bbd1092ef2d658f77249f89fb"},
-]
-
-[package.dependencies]
-ipykernel = "*"
-ipython = "*"
-jupyter-client = ">=7.0.0"
-prompt-toolkit = ">=2.0.0,<3.0.0 || >3.0.0,<3.0.1 || >3.0.1,<3.1.0"
-pygments = "*"
-
-[package.extras]
-test = ["pexpect"]
-
-[[package]]
-name = "jupyter-core"
-version = "5.7.1"
-description = "Jupyter core package. A base package on which Jupyter projects rely."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyter_core-5.7.1-py3-none-any.whl", hash = "sha256:c65c82126453a723a2804aa52409930434598fd9d35091d63dfb919d2b765bb7"},
-    {file = "jupyter_core-5.7.1.tar.gz", hash = "sha256:de61a9d7fc71240f688b2fb5ab659fbb56979458dc66a71decd098e03c79e218"},
-]
-
-[package.dependencies]
-platformdirs = ">=2.5"
-pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""}
-traitlets = ">=5.3"
-
-[package.extras]
-docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"]
-test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"]
-
-[[package]]
-name = "jupyter-events"
-version = "0.9.0"
-description = "Jupyter Event System library"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyter_events-0.9.0-py3-none-any.whl", hash = "sha256:d853b3c10273ff9bc8bb8b30076d65e2c9685579db736873de6c2232dde148bf"},
-    {file = "jupyter_events-0.9.0.tar.gz", hash = "sha256:81ad2e4bc710881ec274d31c6c50669d71bbaa5dd9d01e600b56faa85700d399"},
-]
-
-[package.dependencies]
-jsonschema = {version = ">=4.18.0", extras = ["format-nongpl"]}
-python-json-logger = ">=2.0.4"
-pyyaml = ">=5.3"
-referencing = "*"
-rfc3339-validator = "*"
-rfc3986-validator = ">=0.1.1"
-traitlets = ">=5.3"
-
-[package.extras]
-cli = ["click", "rich"]
-docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"]
-test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "rich"]
-
-[[package]]
-name = "jupyter-lsp"
-version = "2.2.3"
-description = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyter-lsp-2.2.3.tar.gz", hash = "sha256:33dbcbc5df24237ff5c8b696b04ff4689fcd316cb8d4957d620fe5504d7d2c3f"},
-    {file = "jupyter_lsp-2.2.3-py3-none-any.whl", hash = "sha256:57dd90d0a2e2530831793550846168c81c952b49e187aa339e455027a5f0fd2e"},
-]
-
-[package.dependencies]
-jupyter-server = ">=1.1.2"
-
-[[package]]
-name = "jupyter-server"
-version = "2.13.0"
-description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyter_server-2.13.0-py3-none-any.whl", hash = "sha256:77b2b49c3831fbbfbdb5048cef4350d12946191f833a24e5f83e5f8f4803e97b"},
-    {file = "jupyter_server-2.13.0.tar.gz", hash = "sha256:c80bfb049ea20053c3d9641c2add4848b38073bf79f1729cea1faed32fc1c78e"},
-]
-
-[package.dependencies]
-anyio = ">=3.1.0"
-argon2-cffi = "*"
-jinja2 = "*"
-jupyter-client = ">=7.4.4"
-jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0"
-jupyter-events = ">=0.9.0"
-jupyter-server-terminals = "*"
-nbconvert = ">=6.4.4"
-nbformat = ">=5.3.0"
-overrides = "*"
-packaging = "*"
-prometheus-client = "*"
-pywinpty = {version = "*", markers = "os_name == \"nt\""}
-pyzmq = ">=24"
-send2trash = ">=1.8.2"
-terminado = ">=0.8.3"
-tornado = ">=6.2.0"
-traitlets = ">=5.6.0"
-websocket-client = "*"
-
-[package.extras]
-docs = ["ipykernel", "jinja2", "jupyter-client", "jupyter-server", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi (>=0.8.0)", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"]
-test = ["flaky", "ipykernel", "pre-commit", "pytest (>=7.0)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.7)", "pytest-timeout", "requests"]
-
-[[package]]
-name = "jupyter-server-terminals"
-version = "0.5.2"
-description = "A Jupyter Server Extension Providing Terminals."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyter_server_terminals-0.5.2-py3-none-any.whl", hash = "sha256:1b80c12765da979513c42c90215481bbc39bd8ae7c0350b4f85bc3eb58d0fa80"},
-    {file = "jupyter_server_terminals-0.5.2.tar.gz", hash = "sha256:396b5ccc0881e550bf0ee7012c6ef1b53edbde69e67cab1d56e89711b46052e8"},
-]
-
-[package.dependencies]
-pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""}
-terminado = ">=0.8.3"
-
-[package.extras]
-docs = ["jinja2", "jupyter-server", "mistune (<4.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"]
-test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"]
-
-[[package]]
-name = "jupyterlab"
-version = "4.1.2"
-description = "JupyterLab computational environment"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyterlab-4.1.2-py3-none-any.whl", hash = "sha256:aa88193f03cf4d3555f6712f04d74112b5eb85edd7d222c588c7603a26d33c5b"},
-    {file = "jupyterlab-4.1.2.tar.gz", hash = "sha256:5d6348b3ed4085181499f621b7dfb6eb0b1f57f3586857aadfc8e3bf4c4885f9"},
-]
-
-[package.dependencies]
-async-lru = ">=1.0.0"
-httpx = ">=0.25.0"
-ipykernel = "*"
-jinja2 = ">=3.0.3"
-jupyter-core = "*"
-jupyter-lsp = ">=2.0.0"
-jupyter-server = ">=2.4.0,<3"
-jupyterlab-server = ">=2.19.0,<3"
-notebook-shim = ">=0.2"
-packaging = "*"
-tomli = {version = "*", markers = "python_version < \"3.11\""}
-tornado = ">=6.2.0"
-traitlets = "*"
-
-[package.extras]
-dev = ["build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.2.0)"]
-docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-jupyter", "sphinx (>=1.8,<7.3.0)", "sphinx-copybutton"]
-docs-screenshots = ["altair (==5.2.0)", "ipython (==8.16.1)", "ipywidgets (==8.1.1)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.0.post6)", "matplotlib (==3.8.2)", "nbconvert (>=7.0.0)", "pandas (==2.2.0)", "scipy (==1.12.0)", "vega-datasets (==0.9.0)"]
-test = ["coverage", "pytest (>=7.0)", "pytest-check-links (>=0.7)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "pytest-timeout", "pytest-tornasync", "requests", "requests-cache", "virtualenv"]
-
-[[package]]
-name = "jupyterlab-pygments"
-version = "0.3.0"
-description = "Pygments theme using JupyterLab CSS variables"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"},
-    {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"},
-]
-
-[[package]]
-name = "jupyterlab-server"
-version = "2.25.3"
-description = "A set of server components for JupyterLab and JupyterLab like applications."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jupyterlab_server-2.25.3-py3-none-any.whl", hash = "sha256:c48862519fded9b418c71645d85a49b2f0ec50d032ba8316738e9276046088c1"},
-    {file = "jupyterlab_server-2.25.3.tar.gz", hash = "sha256:846f125a8a19656611df5b03e5912c8393cea6900859baa64fa515eb64a8dc40"},
-]
-
-[package.dependencies]
-babel = ">=2.10"
-jinja2 = ">=3.0.3"
-json5 = ">=0.9.0"
-jsonschema = ">=4.18.0"
-jupyter-server = ">=1.21,<3"
-packaging = ">=21.3"
-requests = ">=2.31"
-
-[package.extras]
-docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"]
-openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"]
-test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.8.0)", "pytest (>=7.0)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"]
-
-[[package]]
-name = "jupyterlab-widgets"
-version = "3.0.10"
-description = "Jupyter interactive widgets for JupyterLab"
+name = "jsonschema-specifications"
+version = "2023.12.1"
+description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
 files = [
-    {file = "jupyterlab_widgets-3.0.10-py3-none-any.whl", hash = "sha256:dd61f3ae7a5a7f80299e14585ce6cf3d6925a96c9103c978eda293197730cb64"},
-    {file = "jupyterlab_widgets-3.0.10.tar.gz", hash = "sha256:04f2ac04976727e4f9d0fa91cdc2f1ab860f965e504c29dbd6a65c882c9d04c0"},
+    {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"},
+    {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"},
 ]
 
+[package.dependencies]
+referencing = ">=0.31.0"
+
 [[package]]
 name = "kaggle"
-version = "1.6.6"
+version = "1.6.12"
 description = "Kaggle API"
 optional = false
 python-versions = "*"
 files = [
-    {file = "kaggle-1.6.6.tar.gz", hash = "sha256:db88715cc0618af253b6afde21881ae9e8e6f64b310acfb273fd13f4a5752207"},
+    {file = "kaggle-1.6.12.tar.gz", hash = "sha256:f12a05b82d2afb10a74adc69a5f8a736c64bd9934d0b5acfb4fe4f97357530b4"},
 ]
 
 [package.dependencies]
 bleach = "*"
-certifi = "*"
+certifi = ">=2023.7.22"
 python-dateutil = "*"
 python-slugify = "*"
 requests = "*"
@@ -1137,6 +576,143 @@ six = ">=1.10"
 tqdm = "*"
 urllib3 = "*"
 
+[[package]]
+name = "kiwisolver"
+version = "1.4.5"
+description = "A fast implementation of the Cassowary constraint solver"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"},
+    {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"},
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+description = "Python port of markdown-it. Markdown parsing, done right!"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"},
+    {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"},
+]
+
+[package.dependencies]
+mdurl = ">=0.1,<1.0"
+
+[package.extras]
+benchmarking = ["psutil", "pytest", "pytest-benchmark"]
+code-style = ["pre-commit (>=3.0,<4.0)"]
+compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"]
+linkify = ["linkify-it-py (>=1,<3)"]
+plugins = ["mdit-py-plugins"]
+profiling = ["gprof2dot"]
+rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"]
+testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"]
+
 [[package]]
 name = "markupsafe"
 version = "2.1.5"
@@ -1207,110 +783,64 @@ files = [
 ]
 
 [[package]]
-name = "matplotlib-inline"
-version = "0.1.6"
-description = "Inline Matplotlib backend for Jupyter"
+name = "matplotlib"
+version = "3.8.4"
+description = "Python plotting package"
 optional = false
-python-versions = ">=3.5"
+python-versions = ">=3.9"
 files = [
-    {file = "matplotlib-inline-0.1.6.tar.gz", hash = "sha256:f887e5f10ba98e8d2b150ddcf4702c1e5f8b3a20005eb0f74bfdbd360ee6f304"},
-    {file = "matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311"},
+    {file = "matplotlib-3.8.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:abc9d838f93583650c35eca41cfcec65b2e7cb50fd486da6f0c49b5e1ed23014"},
+    {file = "matplotlib-3.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f65c9f002d281a6e904976007b2d46a1ee2bcea3a68a8c12dda24709ddc9106"},
+    {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce1edd9f5383b504dbc26eeea404ed0a00656c526638129028b758fd43fc5f10"},
+    {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecd79298550cba13a43c340581a3ec9c707bd895a6a061a78fa2524660482fc0"},
+    {file = "matplotlib-3.8.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:90df07db7b599fe7035d2f74ab7e438b656528c68ba6bb59b7dc46af39ee48ef"},
+    {file = "matplotlib-3.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:ac24233e8f2939ac4fd2919eed1e9c0871eac8057666070e94cbf0b33dd9c338"},
+    {file = "matplotlib-3.8.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:72f9322712e4562e792b2961971891b9fbbb0e525011e09ea0d1f416c4645661"},
+    {file = "matplotlib-3.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:232ce322bfd020a434caaffbd9a95333f7c2491e59cfc014041d95e38ab90d1c"},
+    {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6addbd5b488aedb7f9bc19f91cd87ea476206f45d7116fcfe3d31416702a82fa"},
+    {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc4ccdc64e3039fc303defd119658148f2349239871db72cd74e2eeaa9b80b71"},
+    {file = "matplotlib-3.8.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b7a2a253d3b36d90c8993b4620183b55665a429da8357a4f621e78cd48b2b30b"},
+    {file = "matplotlib-3.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:8080d5081a86e690d7688ffa542532e87f224c38a6ed71f8fbed34dd1d9fedae"},
+    {file = "matplotlib-3.8.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6485ac1f2e84676cff22e693eaa4fbed50ef5dc37173ce1f023daef4687df616"},
+    {file = "matplotlib-3.8.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c89ee9314ef48c72fe92ce55c4e95f2f39d70208f9f1d9db4e64079420d8d732"},
+    {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50bac6e4d77e4262c4340d7a985c30912054745ec99756ce213bfbc3cb3808eb"},
+    {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f51c4c869d4b60d769f7b4406eec39596648d9d70246428745a681c327a8ad30"},
+    {file = "matplotlib-3.8.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b12ba985837e4899b762b81f5b2845bd1a28f4fdd1a126d9ace64e9c4eb2fb25"},
+    {file = "matplotlib-3.8.4-cp312-cp312-win_amd64.whl", hash = "sha256:7a6769f58ce51791b4cb8b4d7642489df347697cd3e23d88266aaaee93b41d9a"},
+    {file = "matplotlib-3.8.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:843cbde2f0946dadd8c5c11c6d91847abd18ec76859dc319362a0964493f0ba6"},
+    {file = "matplotlib-3.8.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c13f041a7178f9780fb61cc3a2b10423d5e125480e4be51beaf62b172413b67"},
+    {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb44f53af0a62dc80bba4443d9b27f2fde6acfdac281d95bc872dc148a6509cc"},
+    {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:606e3b90897554c989b1e38a258c626d46c873523de432b1462f295db13de6f9"},
+    {file = "matplotlib-3.8.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9bb0189011785ea794ee827b68777db3ca3f93f3e339ea4d920315a0e5a78d54"},
+    {file = "matplotlib-3.8.4-cp39-cp39-win_amd64.whl", hash = "sha256:6209e5c9aaccc056e63b547a8152661324404dd92340a6e479b3a7f24b42a5d0"},
+    {file = "matplotlib-3.8.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c7064120a59ce6f64103c9cefba8ffe6fba87f2c61d67c401186423c9a20fd35"},
+    {file = "matplotlib-3.8.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0e47eda4eb2614300fc7bb4657fced3e83d6334d03da2173b09e447418d499f"},
+    {file = "matplotlib-3.8.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:493e9f6aa5819156b58fce42b296ea31969f2aab71c5b680b4ea7a3cb5c07d94"},
+    {file = "matplotlib-3.8.4.tar.gz", hash = "sha256:8aac397d5e9ec158960e31c381c5ffc52ddd52bd9a47717e2a694038167dffea"},
 ]
 
 [package.dependencies]
-traitlets = "*"
+contourpy = ">=1.0.1"
+cycler = ">=0.10"
+fonttools = ">=4.22.0"
+kiwisolver = ">=1.3.1"
+numpy = ">=1.21"
+packaging = ">=20.0"
+pillow = ">=8"
+pyparsing = ">=2.3.1"
+python-dateutil = ">=2.7"
 
 [[package]]
-name = "mistune"
-version = "3.0.2"
-description = "A sane and fast Markdown parser with useful plugins and renderers"
+name = "mdurl"
+version = "0.1.2"
+description = "Markdown URL utilities"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"},
-    {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"},
-]
-
-[[package]]
-name = "nbclient"
-version = "0.9.0"
-description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor."
-optional = false
-python-versions = ">=3.8.0"
-files = [
-    {file = "nbclient-0.9.0-py3-none-any.whl", hash = "sha256:a3a1ddfb34d4a9d17fc744d655962714a866639acd30130e9be84191cd97cd15"},
-    {file = "nbclient-0.9.0.tar.gz", hash = "sha256:4b28c207877cf33ef3a9838cdc7a54c5ceff981194a82eac59d558f05487295e"},
-]
-
-[package.dependencies]
-jupyter-client = ">=6.1.12"
-jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0"
-nbformat = ">=5.1"
-traitlets = ">=5.4"
-
-[package.extras]
-dev = ["pre-commit"]
-docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"]
-test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"]
-
-[[package]]
-name = "nbconvert"
-version = "7.16.2"
-description = "Converting Jupyter Notebooks (.ipynb files) to other formats.  Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script.  nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "nbconvert-7.16.2-py3-none-any.whl", hash = "sha256:0c01c23981a8de0220255706822c40b751438e32467d6a686e26be08ba784382"},
-    {file = "nbconvert-7.16.2.tar.gz", hash = "sha256:8310edd41e1c43947e4ecf16614c61469ebc024898eb808cce0999860fc9fb16"},
-]
-
-[package.dependencies]
-beautifulsoup4 = "*"
-bleach = "!=5.0.0"
-defusedxml = "*"
-jinja2 = ">=3.0"
-jupyter-core = ">=4.7"
-jupyterlab-pygments = "*"
-markupsafe = ">=2.0"
-mistune = ">=2.0.3,<4"
-nbclient = ">=0.5.0"
-nbformat = ">=5.7"
-packaging = "*"
-pandocfilters = ">=1.4.1"
-pygments = ">=2.4.1"
-tinycss2 = "*"
-traitlets = ">=5.1"
-
-[package.extras]
-all = ["nbconvert[docs,qtpdf,serve,test,webpdf]"]
-docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"]
-qtpdf = ["nbconvert[qtpng]"]
-qtpng = ["pyqtwebengine (>=5.15)"]
-serve = ["tornado (>=6.1)"]
-test = ["flaky", "ipykernel", "ipywidgets (>=7.5)", "pytest"]
-webpdf = ["playwright"]
-
-[[package]]
-name = "nbformat"
-version = "5.9.2"
-description = "The Jupyter Notebook format"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "nbformat-5.9.2-py3-none-any.whl", hash = "sha256:1c5172d786a41b82bcfd0c23f9e6b6f072e8fb49c39250219e4acfff1efe89e9"},
-    {file = "nbformat-5.9.2.tar.gz", hash = "sha256:5f98b5ba1997dff175e77e0c17d5c10a96eaed2cbd1de3533d1fc35d5e111192"},
+    {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"},
+    {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"},
 ]
 
-[package.dependencies]
-fastjsonschema = "*"
-jsonschema = ">=2.6"
-jupyter-core = "*"
-traitlets = ">=5.1"
-
-[package.extras]
-docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"]
-test = ["pep440", "pre-commit", "pytest", "testpath"]
-
 [[package]]
 name = "nodeenv"
 version = "1.8.0"
@@ -1325,46 +855,6 @@ files = [
 [package.dependencies]
 setuptools = "*"
 
-[[package]]
-name = "notebook"
-version = "7.1.1"
-description = "Jupyter Notebook - A web-based notebook environment for interactive computing"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "notebook-7.1.1-py3-none-any.whl", hash = "sha256:197d8e0595acabf4005851c8716e952a81b405f7aefb648067a761fbde267ce7"},
-    {file = "notebook-7.1.1.tar.gz", hash = "sha256:818e7420fa21f402e726afb9f02df7f3c10f294c02e383ed19852866c316108b"},
-]
-
-[package.dependencies]
-jupyter-server = ">=2.4.0,<3"
-jupyterlab = ">=4.1.1,<4.2"
-jupyterlab-server = ">=2.22.1,<3"
-notebook-shim = ">=0.2,<0.3"
-tornado = ">=6.2.0"
-
-[package.extras]
-dev = ["hatch", "pre-commit"]
-docs = ["myst-parser", "nbsphinx", "pydata-sphinx-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"]
-test = ["importlib-resources (>=5.0)", "ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.22.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"]
-
-[[package]]
-name = "notebook-shim"
-version = "0.2.4"
-description = "A shim layer for notebook traits and config"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"},
-    {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"},
-]
-
-[package.dependencies]
-jupyter-server = ">=1.8,<3"
-
-[package.extras]
-test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync"]
-
 [[package]]
 name = "numpy"
 version = "1.26.4"
@@ -1410,114 +900,175 @@ files = [
     {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"},
 ]
 
-[[package]]
-name = "overrides"
-version = "7.7.0"
-description = "A decorator to automatically detect mismatch when overriding a method."
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"},
-    {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"},
-]
-
 [[package]]
 name = "packaging"
-version = "23.2"
+version = "24.0"
 description = "Core utilities for Python packages"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
-    {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
+    {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"},
+    {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"},
 ]
 
 [[package]]
 name = "pandas"
-version = "1.5.3"
+version = "2.2.2"
 description = "Powerful data structures for data analysis, time series, and statistics"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
 files = [
-    {file = "pandas-1.5.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3749077d86e3a2f0ed51367f30bf5b82e131cc0f14260c4d3e499186fccc4406"},
-    {file = "pandas-1.5.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:972d8a45395f2a2d26733eb8d0f629b2f90bebe8e8eddbb8829b180c09639572"},
-    {file = "pandas-1.5.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:50869a35cbb0f2e0cd5ec04b191e7b12ed688874bd05dd777c19b28cbea90996"},
-    {file = "pandas-1.5.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3ac844a0fe00bfaeb2c9b51ab1424e5c8744f89860b138434a363b1f620f354"},
-    {file = "pandas-1.5.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a0a56cef15fd1586726dace5616db75ebcfec9179a3a55e78f72c5639fa2a23"},
-    {file = "pandas-1.5.3-cp310-cp310-win_amd64.whl", hash = "sha256:478ff646ca42b20376e4ed3fa2e8d7341e8a63105586efe54fa2508ee087f328"},
-    {file = "pandas-1.5.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6973549c01ca91ec96199e940495219c887ea815b2083722821f1d7abfa2b4dc"},
-    {file = "pandas-1.5.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c39a8da13cede5adcd3be1182883aea1c925476f4e84b2807a46e2775306305d"},
-    {file = "pandas-1.5.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f76d097d12c82a535fda9dfe5e8dd4127952b45fea9b0276cb30cca5ea313fbc"},
-    {file = "pandas-1.5.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e474390e60ed609cec869b0da796ad94f420bb057d86784191eefc62b65819ae"},
-    {file = "pandas-1.5.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f2b952406a1588ad4cad5b3f55f520e82e902388a6d5a4a91baa8d38d23c7f6"},
-    {file = "pandas-1.5.3-cp311-cp311-win_amd64.whl", hash = "sha256:bc4c368f42b551bf72fac35c5128963a171b40dce866fb066540eeaf46faa003"},
-    {file = "pandas-1.5.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:14e45300521902689a81f3f41386dc86f19b8ba8dd5ac5a3c7010ef8d2932813"},
-    {file = "pandas-1.5.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9842b6f4b8479e41968eced654487258ed81df7d1c9b7b870ceea24ed9459b31"},
-    {file = "pandas-1.5.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:26d9c71772c7afb9d5046e6e9cf42d83dd147b5cf5bcb9d97252077118543792"},
-    {file = "pandas-1.5.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5fbcb19d6fceb9e946b3e23258757c7b225ba450990d9ed63ccceeb8cae609f7"},
-    {file = "pandas-1.5.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:565fa34a5434d38e9d250af3c12ff931abaf88050551d9fbcdfafca50d62babf"},
-    {file = "pandas-1.5.3-cp38-cp38-win32.whl", hash = "sha256:87bd9c03da1ac870a6d2c8902a0e1fd4267ca00f13bc494c9e5a9020920e1d51"},
-    {file = "pandas-1.5.3-cp38-cp38-win_amd64.whl", hash = "sha256:41179ce559943d83a9b4bbacb736b04c928b095b5f25dd2b7389eda08f46f373"},
-    {file = "pandas-1.5.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c74a62747864ed568f5a82a49a23a8d7fe171d0c69038b38cedf0976831296fa"},
-    {file = "pandas-1.5.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c4c00e0b0597c8e4f59e8d461f797e5d70b4d025880516a8261b2817c47759ee"},
-    {file = "pandas-1.5.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a50d9a4336a9621cab7b8eb3fb11adb82de58f9b91d84c2cd526576b881a0c5a"},
-    {file = "pandas-1.5.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd05f7783b3274aa206a1af06f0ceed3f9b412cf665b7247eacd83be41cf7bf0"},
-    {file = "pandas-1.5.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f69c4029613de47816b1bb30ff5ac778686688751a5e9c99ad8c7031f6508e5"},
-    {file = "pandas-1.5.3-cp39-cp39-win32.whl", hash = "sha256:7cec0bee9f294e5de5bbfc14d0573f65526071029d036b753ee6507d2a21480a"},
-    {file = "pandas-1.5.3-cp39-cp39-win_amd64.whl", hash = "sha256:dfd681c5dc216037e0b0a2c821f5ed99ba9f03ebcf119c7dac0e9a7b960b9ec9"},
-    {file = "pandas-1.5.3.tar.gz", hash = "sha256:74a3fd7e5a7ec052f183273dc7b0acd3a863edf7520f5d3a1765c04ffdb3b0b1"},
+    {file = "pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce"},
+    {file = "pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238"},
+    {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4abfe0be0d7221be4f12552995e58723c7422c80a659da13ca382697de830c08"},
+    {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8635c16bf3d99040fdf3ca3db669a7250ddf49c55dc4aa8fe0ae0fa8d6dcc1f0"},
+    {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:40ae1dffb3967a52203105a077415a86044a2bea011b5f321c6aa64b379a3f51"},
+    {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8e5a0b00e1e56a842f922e7fae8ae4077aee4af0acb5ae3622bd4b4c30aedf99"},
+    {file = "pandas-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:ddf818e4e6c7c6f4f7c8a12709696d193976b591cc7dc50588d3d1a6b5dc8772"},
+    {file = "pandas-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:696039430f7a562b74fa45f540aca068ea85fa34c244d0deee539cb6d70aa288"},
+    {file = "pandas-2.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8e90497254aacacbc4ea6ae5e7a8cd75629d6ad2b30025a4a8b09aa4faf55151"},
+    {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58b84b91b0b9f4bafac2a0ac55002280c094dfc6402402332c0913a59654ab2b"},
+    {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d2123dc9ad6a814bcdea0f099885276b31b24f7edf40f6cdbc0912672e22eee"},
+    {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2925720037f06e89af896c70bca73459d7e6a4be96f9de79e2d440bd499fe0db"},
+    {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0cace394b6ea70c01ca1595f839cf193df35d1575986e484ad35c4aeae7266c1"},
+    {file = "pandas-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:873d13d177501a28b2756375d59816c365e42ed8417b41665f346289adc68d24"},
+    {file = "pandas-2.2.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9dfde2a0ddef507a631dc9dc4af6a9489d5e2e740e226ad426a05cabfbd7c8ef"},
+    {file = "pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b79011ff7a0f4b1d6da6a61aa1aa604fb312d6647de5bad20013682d1429ce"},
+    {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cb51fe389360f3b5a4d57dbd2848a5f033350336ca3b340d1c53a1fad33bcad"},
+    {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eee3a87076c0756de40b05c5e9a6069c035ba43e8dd71c379e68cab2c20f16ad"},
+    {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3e374f59e440d4ab45ca2fffde54b81ac3834cf5ae2cdfa69c90bc03bde04d76"},
+    {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:43498c0bdb43d55cb162cdc8c06fac328ccb5d2eabe3cadeb3529ae6f0517c32"},
+    {file = "pandas-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:d187d355ecec3629624fccb01d104da7d7f391db0311145817525281e2804d23"},
+    {file = "pandas-2.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0ca6377b8fca51815f382bd0b697a0814c8bda55115678cbc94c30aacbb6eff2"},
+    {file = "pandas-2.2.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9057e6aa78a584bc93a13f0a9bf7e753a5e9770a30b4d758b8d5f2a62a9433cd"},
+    {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:001910ad31abc7bf06f49dcc903755d2f7f3a9186c0c040b827e522e9cef0863"},
+    {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66b479b0bd07204e37583c191535505410daa8df638fd8e75ae1b383851fe921"},
+    {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a77e9d1c386196879aa5eb712e77461aaee433e54c68cf253053a73b7e49c33a"},
+    {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:92fd6b027924a7e178ac202cfbe25e53368db90d56872d20ffae94b96c7acc57"},
+    {file = "pandas-2.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:640cef9aa381b60e296db324337a554aeeb883ead99dc8f6c18e81a93942f5f4"},
+    {file = "pandas-2.2.2.tar.gz", hash = "sha256:9e79019aba43cb4fda9e4d983f8e88ca0373adbb697ae9c6c43093218de28b54"},
 ]
 
 [package.dependencies]
 numpy = [
-    {version = ">=1.23.2", markers = "python_version >= \"3.11\""},
-    {version = ">=1.21.0", markers = "python_version >= \"3.10\" and python_version < \"3.11\""},
+    {version = ">=1.22.4", markers = "python_version < \"3.11\""},
+    {version = ">=1.23.2", markers = "python_version == \"3.11\""},
+    {version = ">=1.26.0", markers = "python_version >= \"3.12\""},
 ]
-python-dateutil = ">=2.8.1"
+python-dateutil = ">=2.8.2"
 pytz = ">=2020.1"
+tzdata = ">=2022.7"
 
 [package.extras]
-test = ["hypothesis (>=5.5.3)", "pytest (>=6.0)", "pytest-xdist (>=1.31)"]
-
-[[package]]
-name = "pandocfilters"
-version = "1.5.1"
-description = "Utilities for writing pandoc filters in python"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
-files = [
-    {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"},
-    {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"},
-]
-
-[[package]]
-name = "parso"
-version = "0.8.3"
-description = "A Python Parser"
+all = ["PyQt5 (>=5.15.9)", "SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)", "beautifulsoup4 (>=4.11.2)", "bottleneck (>=1.3.6)", "dataframe-api-compat (>=0.1.7)", "fastparquet (>=2022.12.0)", "fsspec (>=2022.11.0)", "gcsfs (>=2022.11.0)", "html5lib (>=1.1)", "hypothesis (>=6.46.1)", "jinja2 (>=3.1.2)", "lxml (>=4.9.2)", "matplotlib (>=3.6.3)", "numba (>=0.56.4)", "numexpr (>=2.8.4)", "odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "pandas-gbq (>=0.19.0)", "psycopg2 (>=2.9.6)", "pyarrow (>=10.0.1)", "pymysql (>=1.0.2)", "pyreadstat (>=1.2.0)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "qtpy (>=2.3.0)", "s3fs (>=2022.11.0)", "scipy (>=1.10.0)", "tables (>=3.8.0)", "tabulate (>=0.9.0)", "xarray (>=2022.12.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)", "zstandard (>=0.19.0)"]
+aws = ["s3fs (>=2022.11.0)"]
+clipboard = ["PyQt5 (>=5.15.9)", "qtpy (>=2.3.0)"]
+compression = ["zstandard (>=0.19.0)"]
+computation = ["scipy (>=1.10.0)", "xarray (>=2022.12.0)"]
+consortium-standard = ["dataframe-api-compat (>=0.1.7)"]
+excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)"]
+feather = ["pyarrow (>=10.0.1)"]
+fss = ["fsspec (>=2022.11.0)"]
+gcp = ["gcsfs (>=2022.11.0)", "pandas-gbq (>=0.19.0)"]
+hdf5 = ["tables (>=3.8.0)"]
+html = ["beautifulsoup4 (>=4.11.2)", "html5lib (>=1.1)", "lxml (>=4.9.2)"]
+mysql = ["SQLAlchemy (>=2.0.0)", "pymysql (>=1.0.2)"]
+output-formatting = ["jinja2 (>=3.1.2)", "tabulate (>=0.9.0)"]
+parquet = ["pyarrow (>=10.0.1)"]
+performance = ["bottleneck (>=1.3.6)", "numba (>=0.56.4)", "numexpr (>=2.8.4)"]
+plot = ["matplotlib (>=3.6.3)"]
+postgresql = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "psycopg2 (>=2.9.6)"]
+pyarrow = ["pyarrow (>=10.0.1)"]
+spss = ["pyreadstat (>=1.2.0)"]
+sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)"]
+test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"]
+xml = ["lxml (>=4.9.2)"]
+
+[[package]]
+name = "pillow"
+version = "10.3.0"
+description = "Python Imaging Library (Fork)"
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.8"
 files = [
-    {file = "parso-0.8.3-py2.py3-none-any.whl", hash = "sha256:c001d4636cd3aecdaf33cbb40aebb59b094be2a74c556778ef5576c175e19e75"},
-    {file = "parso-0.8.3.tar.gz", hash = "sha256:8c07be290bb59f03588915921e29e8a50002acaf2cdc5fa0e0114f91709fafa0"},
+    {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"},
+    {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"},
+    {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"},
+    {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"},
+    {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"},
+    {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"},
+    {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"},
+    {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"},
+    {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"},
+    {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"},
+    {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"},
+    {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"},
+    {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"},
+    {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"},
+    {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"},
+    {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"},
+    {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"},
+    {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"},
+    {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"},
+    {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"},
+    {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"},
+    {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"},
+    {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"},
+    {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"},
+    {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"},
+    {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"},
+    {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"},
+    {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"},
+    {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"},
+    {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"},
+    {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"},
+    {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"},
+    {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"},
+    {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"},
+    {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"},
 ]
 
 [package.extras]
-qa = ["flake8 (==3.8.3)", "mypy (==0.782)"]
-testing = ["docopt", "pytest (<6.0.0)"]
-
-[[package]]
-name = "pexpect"
-version = "4.9.0"
-description = "Pexpect allows easy control of interactive console applications."
-optional = false
-python-versions = "*"
-files = [
-    {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"},
-    {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"},
-]
-
-[package.dependencies]
-ptyprocess = ">=0.5"
+docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"]
+fpx = ["olefile"]
+mic = ["olefile"]
+tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"]
+typing = ["typing-extensions"]
+xmp = ["defusedxml"]
 
 [[package]]
 name = "platformdirs"
@@ -1534,6 +1085,21 @@ files = [
 docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
 test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"]
 
+[[package]]
+name = "plotly"
+version = "5.20.0"
+description = "An open-source, interactive data visualization library for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "plotly-5.20.0-py3-none-any.whl", hash = "sha256:837a9c8aa90f2c0a2f0d747b82544d014dc2a2bdde967b5bb1da25b53932d1a9"},
+    {file = "plotly-5.20.0.tar.gz", hash = "sha256:bf901c805d22032cfa534b2ff7c5aa6b0659e037f19ec1e0cca7f585918b5c89"},
+]
+
+[package.dependencies]
+packaging = "*"
+tenacity = ">=6.2.0"
+
 [[package]]
 name = "pluggy"
 version = "1.4.0"
@@ -1568,68 +1134,91 @@ pyyaml = ">=5.1"
 virtualenv = ">=20.10.0"
 
 [[package]]
-name = "prometheus-client"
-version = "0.20.0"
-description = "Python client for the Prometheus monitoring system."
+name = "protobuf"
+version = "4.25.3"
+description = ""
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"},
-    {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"},
+    {file = "protobuf-4.25.3-cp310-abi3-win32.whl", hash = "sha256:d4198877797a83cbfe9bffa3803602bbe1625dc30d8a097365dbc762e5790faa"},
+    {file = "protobuf-4.25.3-cp310-abi3-win_amd64.whl", hash = "sha256:209ba4cc916bab46f64e56b85b090607a676f66b473e6b762e6f1d9d591eb2e8"},
+    {file = "protobuf-4.25.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f1279ab38ecbfae7e456a108c5c0681e4956d5b1090027c1de0f934dfdb4b35c"},
+    {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:e7cb0ae90dd83727f0c0718634ed56837bfeeee29a5f82a7514c03ee1364c019"},
+    {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:7c8daa26095f82482307bc717364e7c13f4f1c99659be82890dcfc215194554d"},
+    {file = "protobuf-4.25.3-cp38-cp38-win32.whl", hash = "sha256:f4f118245c4a087776e0a8408be33cf09f6c547442c00395fbfb116fac2f8ac2"},
+    {file = "protobuf-4.25.3-cp38-cp38-win_amd64.whl", hash = "sha256:c053062984e61144385022e53678fbded7aea14ebb3e0305ae3592fb219ccfa4"},
+    {file = "protobuf-4.25.3-cp39-cp39-win32.whl", hash = "sha256:19b270aeaa0099f16d3ca02628546b8baefe2955bbe23224aaf856134eccf1e4"},
+    {file = "protobuf-4.25.3-cp39-cp39-win_amd64.whl", hash = "sha256:e3c97a1555fd6388f857770ff8b9703083de6bf1f9274a002a332d65fbb56c8c"},
+    {file = "protobuf-4.25.3-py3-none-any.whl", hash = "sha256:f0700d54bcf45424477e46a9f0944155b46fb0639d69728739c0e47bab83f2b9"},
+    {file = "protobuf-4.25.3.tar.gz", hash = "sha256:25b5d0b42fd000320bd7830b349e3b696435f3b329810427a6bcce6a5492cc5c"},
 ]
 
-[package.extras]
-twisted = ["twisted"]
-
 [[package]]
-name = "prompt-toolkit"
-version = "3.0.43"
-description = "Library for building powerful interactive command lines in Python"
+name = "pyarrow"
+version = "15.0.2"
+description = "Python library for Apache Arrow"
 optional = false
-python-versions = ">=3.7.0"
+python-versions = ">=3.8"
 files = [
-    {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"},
-    {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"},
+    {file = "pyarrow-15.0.2-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:88b340f0a1d05b5ccc3d2d986279045655b1fe8e41aba6ca44ea28da0d1455d8"},
+    {file = "pyarrow-15.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eaa8f96cecf32da508e6c7f69bb8401f03745c050c1dd42ec2596f2e98deecac"},
+    {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23c6753ed4f6adb8461e7c383e418391b8d8453c5d67e17f416c3a5d5709afbd"},
+    {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f639c059035011db8c0497e541a8a45d98a58dbe34dc8fadd0ef128f2cee46e5"},
+    {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:290e36a59a0993e9a5224ed2fb3e53375770f07379a0ea03ee2fce2e6d30b423"},
+    {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:06c2bb2a98bc792f040bef31ad3e9be6a63d0cb39189227c08a7d955db96816e"},
+    {file = "pyarrow-15.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:f7a197f3670606a960ddc12adbe8075cea5f707ad7bf0dffa09637fdbb89f76c"},
+    {file = "pyarrow-15.0.2-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:5f8bc839ea36b1f99984c78e06e7a06054693dc2af8920f6fb416b5bca9944e4"},
+    {file = "pyarrow-15.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f5e81dfb4e519baa6b4c80410421528c214427e77ca0ea9461eb4097c328fa33"},
+    {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3a4f240852b302a7af4646c8bfe9950c4691a419847001178662a98915fd7ee7"},
+    {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e7d9cfb5a1e648e172428c7a42b744610956f3b70f524aa3a6c02a448ba853e"},
+    {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:2d4f905209de70c0eb5b2de6763104d5a9a37430f137678edfb9a675bac9cd98"},
+    {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:90adb99e8ce5f36fbecbbc422e7dcbcbed07d985eed6062e459e23f9e71fd197"},
+    {file = "pyarrow-15.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:b116e7fd7889294cbd24eb90cd9bdd3850be3738d61297855a71ac3b8124ee38"},
+    {file = "pyarrow-15.0.2-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:25335e6f1f07fdaa026a61c758ee7d19ce824a866b27bba744348fa73bb5a440"},
+    {file = "pyarrow-15.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90f19e976d9c3d8e73c80be84ddbe2f830b6304e4c576349d9360e335cd627fc"},
+    {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a22366249bf5fd40ddacc4f03cd3160f2d7c247692945afb1899bab8a140ddfb"},
+    {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c2a335198f886b07e4b5ea16d08ee06557e07db54a8400cc0d03c7f6a22f785f"},
+    {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3e6d459c0c22f0b9c810a3917a1de3ee704b021a5fb8b3bacf968eece6df098f"},
+    {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:033b7cad32198754d93465dcfb71d0ba7cb7cd5c9afd7052cab7214676eec38b"},
+    {file = "pyarrow-15.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:29850d050379d6e8b5a693098f4de7fd6a2bea4365bfd073d7c57c57b95041ee"},
+    {file = "pyarrow-15.0.2-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:7167107d7fb6dcadb375b4b691b7e316f4368f39f6f45405a05535d7ad5e5058"},
+    {file = "pyarrow-15.0.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e85241b44cc3d365ef950432a1b3bd44ac54626f37b2e3a0cc89c20e45dfd8bf"},
+    {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:248723e4ed3255fcd73edcecc209744d58a9ca852e4cf3d2577811b6d4b59818"},
+    {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ff3bdfe6f1b81ca5b73b70a8d482d37a766433823e0c21e22d1d7dde76ca33f"},
+    {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:f3d77463dee7e9f284ef42d341689b459a63ff2e75cee2b9302058d0d98fe142"},
+    {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:8c1faf2482fb89766e79745670cbca04e7018497d85be9242d5350cba21357e1"},
+    {file = "pyarrow-15.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:28f3016958a8e45a1069303a4a4f6a7d4910643fc08adb1e2e4a7ff056272ad3"},
+    {file = "pyarrow-15.0.2-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:89722cb64286ab3d4daf168386f6968c126057b8c7ec3ef96302e81d8cdb8ae4"},
+    {file = "pyarrow-15.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cd0ba387705044b3ac77b1b317165c0498299b08261d8122c96051024f953cd5"},
+    {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad2459bf1f22b6a5cdcc27ebfd99307d5526b62d217b984b9f5c974651398832"},
+    {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58922e4bfece8b02abf7159f1f53a8f4d9f8e08f2d988109126c17c3bb261f22"},
+    {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:adccc81d3dc0478ea0b498807b39a8d41628fa9210729b2f718b78cb997c7c91"},
+    {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:8bd2baa5fe531571847983f36a30ddbf65261ef23e496862ece83bdceb70420d"},
+    {file = "pyarrow-15.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6669799a1d4ca9da9c7e06ef48368320f5856f36f9a4dd31a11839dda3f6cc8c"},
+    {file = "pyarrow-15.0.2.tar.gz", hash = "sha256:9c9bc803cb3b7bfacc1e96ffbfd923601065d9d3f911179d81e72d99fd74a3d9"},
 ]
 
 [package.dependencies]
-wcwidth = "*"
+numpy = ">=1.16.6,<2"
 
 [[package]]
-name = "ptyprocess"
-version = "0.7.0"
-description = "Run a subprocess in a pseudo terminal"
+name = "pydeck"
+version = "0.8.0"
+description = "Widget for deck.gl maps"
 optional = false
-python-versions = "*"
+python-versions = ">=3.7"
 files = [
-    {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"},
-    {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"},
+    {file = "pydeck-0.8.0-py2.py3-none-any.whl", hash = "sha256:a8fa7757c6f24bba033af39db3147cb020eef44012ba7e60d954de187f9ed4d5"},
+    {file = "pydeck-0.8.0.tar.gz", hash = "sha256:07edde833f7cfcef6749124351195aa7dcd24663d4909fd7898dbd0b6fbc01ec"},
 ]
 
-[[package]]
-name = "pure-eval"
-version = "0.2.2"
-description = "Safely evaluate AST nodes without side effects"
-optional = false
-python-versions = "*"
-files = [
-    {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"},
-    {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"},
-]
+[package.dependencies]
+jinja2 = ">=2.10.1"
+numpy = ">=1.16.4"
 
 [package.extras]
-tests = ["pytest"]
-
-[[package]]
-name = "pycparser"
-version = "2.21"
-description = "C parser in Python"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
-files = [
-    {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"},
-    {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"},
-]
+carto = ["pydeck-carto"]
+jupyter = ["ipykernel (>=5.1.2)", "ipython (>=5.8.0)", "ipywidgets (>=7,<8)", "traitlets (>=4.3.2)"]
 
 [[package]]
 name = "pygments"
@@ -1646,6 +1235,20 @@ files = [
 plugins = ["importlib-metadata"]
 windows-terminal = ["colorama (>=0.4.6)"]
 
+[[package]]
+name = "pyparsing"
+version = "3.1.2"
+description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+optional = false
+python-versions = ">=3.6.8"
+files = [
+    {file = "pyparsing-3.1.2-py3-none-any.whl", hash = "sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742"},
+    {file = "pyparsing-3.1.2.tar.gz", hash = "sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad"},
+]
+
+[package.extras]
+diagrams = ["jinja2", "railroad-diagrams"]
+
 [[package]]
 name = "pyproject-api"
 version = "1.6.1"
@@ -1701,17 +1304,6 @@ files = [
 [package.dependencies]
 six = ">=1.5"
 
-[[package]]
-name = "python-json-logger"
-version = "2.0.7"
-description = "A python library adding a json log formatter"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"},
-    {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"},
-]
-
 [[package]]
 name = "python-slugify"
 version = "8.0.4"
@@ -1740,44 +1332,6 @@ files = [
     {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"},
 ]
 
-[[package]]
-name = "pywin32"
-version = "306"
-description = "Python for Window Extensions"
-optional = false
-python-versions = "*"
-files = [
-    {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"},
-    {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"},
-    {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"},
-    {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"},
-    {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"},
-    {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"},
-    {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"},
-    {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"},
-    {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"},
-    {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"},
-    {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"},
-    {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"},
-    {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"},
-    {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"},
-]
-
-[[package]]
-name = "pywinpty"
-version = "2.0.13"
-description = "Pseudo terminal support for Windows from Python."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pywinpty-2.0.13-cp310-none-win_amd64.whl", hash = "sha256:697bff211fb5a6508fee2dc6ff174ce03f34a9a233df9d8b5fe9c8ce4d5eaf56"},
-    {file = "pywinpty-2.0.13-cp311-none-win_amd64.whl", hash = "sha256:b96fb14698db1284db84ca38c79f15b4cfdc3172065b5137383910567591fa99"},
-    {file = "pywinpty-2.0.13-cp312-none-win_amd64.whl", hash = "sha256:2fd876b82ca750bb1333236ce98488c1be96b08f4f7647cfdf4129dfad83c2d4"},
-    {file = "pywinpty-2.0.13-cp38-none-win_amd64.whl", hash = "sha256:61d420c2116c0212808d31625611b51caf621fe67f8a6377e2e8b617ea1c1f7d"},
-    {file = "pywinpty-2.0.13-cp39-none-win_amd64.whl", hash = "sha256:71cb613a9ee24174730ac7ae439fd179ca34ccb8c5349e8d7b72ab5dea2c6f4b"},
-    {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"},
-]
-
 [[package]]
 name = "pyyaml"
 version = "6.0.1"
@@ -1827,162 +1381,15 @@ files = [
     {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"},
 ]
 
-[[package]]
-name = "pyzmq"
-version = "25.1.2"
-description = "Python bindings for 0MQ"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "pyzmq-25.1.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:e624c789359f1a16f83f35e2c705d07663ff2b4d4479bad35621178d8f0f6ea4"},
-    {file = "pyzmq-25.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:49151b0efece79f6a79d41a461d78535356136ee70084a1c22532fc6383f4ad0"},
-    {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9a5f194cf730f2b24d6af1f833c14c10f41023da46a7f736f48b6d35061e76e"},
-    {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:faf79a302f834d9e8304fafdc11d0d042266667ac45209afa57e5efc998e3872"},
-    {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f51a7b4ead28d3fca8dda53216314a553b0f7a91ee8fc46a72b402a78c3e43d"},
-    {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:0ddd6d71d4ef17ba5a87becf7ddf01b371eaba553c603477679ae817a8d84d75"},
-    {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:246747b88917e4867e2367b005fc8eefbb4a54b7db363d6c92f89d69abfff4b6"},
-    {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:00c48ae2fd81e2a50c3485de1b9d5c7c57cd85dc8ec55683eac16846e57ac979"},
-    {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:5a68d491fc20762b630e5db2191dd07ff89834086740f70e978bb2ef2668be08"},
-    {file = "pyzmq-25.1.2-cp310-cp310-win32.whl", hash = "sha256:09dfe949e83087da88c4a76767df04b22304a682d6154de2c572625c62ad6886"},
-    {file = "pyzmq-25.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:fa99973d2ed20417744fca0073390ad65ce225b546febb0580358e36aa90dba6"},
-    {file = "pyzmq-25.1.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:82544e0e2d0c1811482d37eef297020a040c32e0687c1f6fc23a75b75db8062c"},
-    {file = "pyzmq-25.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:01171fc48542348cd1a360a4b6c3e7d8f46cdcf53a8d40f84db6707a6768acc1"},
-    {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc69c96735ab501419c432110016329bf0dea8898ce16fab97c6d9106dc0b348"},
-    {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3e124e6b1dd3dfbeb695435dff0e383256655bb18082e094a8dd1f6293114642"},
-    {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7598d2ba821caa37a0f9d54c25164a4fa351ce019d64d0b44b45540950458840"},
-    {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d1299d7e964c13607efd148ca1f07dcbf27c3ab9e125d1d0ae1d580a1682399d"},
-    {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4e6f689880d5ad87918430957297c975203a082d9a036cc426648fcbedae769b"},
-    {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:cc69949484171cc961e6ecd4a8911b9ce7a0d1f738fcae717177c231bf77437b"},
-    {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9880078f683466b7f567b8624bfc16cad65077be046b6e8abb53bed4eeb82dd3"},
-    {file = "pyzmq-25.1.2-cp311-cp311-win32.whl", hash = "sha256:4e5837af3e5aaa99a091302df5ee001149baff06ad22b722d34e30df5f0d9097"},
-    {file = "pyzmq-25.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:25c2dbb97d38b5ac9fd15586e048ec5eb1e38f3d47fe7d92167b0c77bb3584e9"},
-    {file = "pyzmq-25.1.2-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:11e70516688190e9c2db14fcf93c04192b02d457b582a1f6190b154691b4c93a"},
-    {file = "pyzmq-25.1.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:313c3794d650d1fccaaab2df942af9f2c01d6217c846177cfcbc693c7410839e"},
-    {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b3cbba2f47062b85fe0ef9de5b987612140a9ba3a9c6d2543c6dec9f7c2ab27"},
-    {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fc31baa0c32a2ca660784d5af3b9487e13b61b3032cb01a115fce6588e1bed30"},
-    {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02c9087b109070c5ab0b383079fa1b5f797f8d43e9a66c07a4b8b8bdecfd88ee"},
-    {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:f8429b17cbb746c3e043cb986328da023657e79d5ed258b711c06a70c2ea7537"},
-    {file = "pyzmq-25.1.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:5074adeacede5f810b7ef39607ee59d94e948b4fd954495bdb072f8c54558181"},
-    {file = "pyzmq-25.1.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:7ae8f354b895cbd85212da245f1a5ad8159e7840e37d78b476bb4f4c3f32a9fe"},
-    {file = "pyzmq-25.1.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b264bf2cc96b5bc43ce0e852be995e400376bd87ceb363822e2cb1964fcdc737"},
-    {file = "pyzmq-25.1.2-cp312-cp312-win32.whl", hash = "sha256:02bbc1a87b76e04fd780b45e7f695471ae6de747769e540da909173d50ff8e2d"},
-    {file = "pyzmq-25.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:ced111c2e81506abd1dc142e6cd7b68dd53747b3b7ae5edbea4578c5eeff96b7"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:7b6d09a8962a91151f0976008eb7b29b433a560fde056ec7a3db9ec8f1075438"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:967668420f36878a3c9ecb5ab33c9d0ff8d054f9c0233d995a6d25b0e95e1b6b"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5edac3f57c7ddaacdb4d40f6ef2f9e299471fc38d112f4bc6d60ab9365445fb0"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0dabfb10ef897f3b7e101cacba1437bd3a5032ee667b7ead32bbcdd1a8422fe7"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:2c6441e0398c2baacfe5ba30c937d274cfc2dc5b55e82e3749e333aabffde561"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:16b726c1f6c2e7625706549f9dbe9b06004dfbec30dbed4bf50cbdfc73e5b32a"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:a86c2dd76ef71a773e70551a07318b8e52379f58dafa7ae1e0a4be78efd1ff16"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-win32.whl", hash = "sha256:359f7f74b5d3c65dae137f33eb2bcfa7ad9ebefd1cab85c935f063f1dbb245cc"},
-    {file = "pyzmq-25.1.2-cp36-cp36m-win_amd64.whl", hash = "sha256:55875492f820d0eb3417b51d96fea549cde77893ae3790fd25491c5754ea2f68"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b8c8a419dfb02e91b453615c69568442e897aaf77561ee0064d789705ff37a92"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8807c87fa893527ae8a524c15fc505d9950d5e856f03dae5921b5e9aa3b8783b"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5e319ed7d6b8f5fad9b76daa0a68497bc6f129858ad956331a5835785761e003"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:3c53687dde4d9d473c587ae80cc328e5b102b517447456184b485587ebd18b62"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:9add2e5b33d2cd765ad96d5eb734a5e795a0755f7fc49aa04f76d7ddda73fd70"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:e690145a8c0c273c28d3b89d6fb32c45e0d9605b2293c10e650265bf5c11cfec"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:00a06faa7165634f0cac1abb27e54d7a0b3b44eb9994530b8ec73cf52e15353b"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-win32.whl", hash = "sha256:0f97bc2f1f13cb16905a5f3e1fbdf100e712d841482b2237484360f8bc4cb3d7"},
-    {file = "pyzmq-25.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6cc0020b74b2e410287e5942e1e10886ff81ac77789eb20bec13f7ae681f0fdd"},
-    {file = "pyzmq-25.1.2-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:bef02cfcbded83473bdd86dd8d3729cd82b2e569b75844fb4ea08fee3c26ae41"},
-    {file = "pyzmq-25.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e10a4b5a4b1192d74853cc71a5e9fd022594573926c2a3a4802020360aa719d8"},
-    {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8c5f80e578427d4695adac6fdf4370c14a2feafdc8cb35549c219b90652536ae"},
-    {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5dde6751e857910c1339890f3524de74007958557593b9e7e8c5f01cd919f8a7"},
-    {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea1608dd169da230a0ad602d5b1ebd39807ac96cae1845c3ceed39af08a5c6df"},
-    {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0f513130c4c361201da9bc69df25a086487250e16b5571ead521b31ff6b02220"},
-    {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:019744b99da30330798bb37df33549d59d380c78e516e3bab9c9b84f87a9592f"},
-    {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2e2713ef44be5d52dd8b8e2023d706bf66cb22072e97fc71b168e01d25192755"},
-    {file = "pyzmq-25.1.2-cp38-cp38-win32.whl", hash = "sha256:07cd61a20a535524906595e09344505a9bd46f1da7a07e504b315d41cd42eb07"},
-    {file = "pyzmq-25.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb7e49a17fb8c77d3119d41a4523e432eb0c6932187c37deb6fbb00cc3028088"},
-    {file = "pyzmq-25.1.2-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:94504ff66f278ab4b7e03e4cba7e7e400cb73bfa9d3d71f58d8972a8dc67e7a6"},
-    {file = "pyzmq-25.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6dd0d50bbf9dca1d0bdea219ae6b40f713a3fb477c06ca3714f208fd69e16fd8"},
-    {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:004ff469d21e86f0ef0369717351073e0e577428e514c47c8480770d5e24a565"},
-    {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c0b5ca88a8928147b7b1e2dfa09f3b6c256bc1135a1338536cbc9ea13d3b7add"},
-    {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c9a79f1d2495b167119d02be7448bfba57fad2a4207c4f68abc0bab4b92925b"},
-    {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:518efd91c3d8ac9f9b4f7dd0e2b7b8bf1a4fe82a308009016b07eaa48681af82"},
-    {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:1ec23bd7b3a893ae676d0e54ad47d18064e6c5ae1fadc2f195143fb27373f7f6"},
-    {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:db36c27baed588a5a8346b971477b718fdc66cf5b80cbfbd914b4d6d355e44e2"},
-    {file = "pyzmq-25.1.2-cp39-cp39-win32.whl", hash = "sha256:39b1067f13aba39d794a24761e385e2eddc26295826530a8c7b6c6c341584289"},
-    {file = "pyzmq-25.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:8e9f3fabc445d0ce320ea2c59a75fe3ea591fdbdeebec5db6de530dd4b09412e"},
-    {file = "pyzmq-25.1.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a8c1d566344aee826b74e472e16edae0a02e2a044f14f7c24e123002dcff1c05"},
-    {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:759cfd391a0996345ba94b6a5110fca9c557ad4166d86a6e81ea526c376a01e8"},
-    {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c61e346ac34b74028ede1c6b4bcecf649d69b707b3ff9dc0fab453821b04d1e"},
-    {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4cb8fc1f8d69b411b8ec0b5f1ffbcaf14c1db95b6bccea21d83610987435f1a4"},
-    {file = "pyzmq-25.1.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:3c00c9b7d1ca8165c610437ca0c92e7b5607b2f9076f4eb4b095c85d6e680a1d"},
-    {file = "pyzmq-25.1.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:df0c7a16ebb94452d2909b9a7b3337940e9a87a824c4fc1c7c36bb4404cb0cde"},
-    {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:45999e7f7ed5c390f2e87ece7f6c56bf979fb213550229e711e45ecc7d42ccb8"},
-    {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ac170e9e048b40c605358667aca3d94e98f604a18c44bdb4c102e67070f3ac9b"},
-    {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1b604734bec94f05f81b360a272fc824334267426ae9905ff32dc2be433ab96"},
-    {file = "pyzmq-25.1.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:a793ac733e3d895d96f865f1806f160696422554e46d30105807fdc9841b9f7d"},
-    {file = "pyzmq-25.1.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0806175f2ae5ad4b835ecd87f5f85583316b69f17e97786f7443baaf54b9bb98"},
-    {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ef12e259e7bc317c7597d4f6ef59b97b913e162d83b421dd0db3d6410f17a244"},
-    {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ea253b368eb41116011add00f8d5726762320b1bda892f744c91997b65754d73"},
-    {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b9b1f2ad6498445a941d9a4fee096d387fee436e45cc660e72e768d3d8ee611"},
-    {file = "pyzmq-25.1.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:8b14c75979ce932c53b79976a395cb2a8cd3aaf14aef75e8c2cb55a330b9b49d"},
-    {file = "pyzmq-25.1.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:889370d5174a741a62566c003ee8ddba4b04c3f09a97b8000092b7ca83ec9c49"},
-    {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9a18fff090441a40ffda8a7f4f18f03dc56ae73f148f1832e109f9bffa85df15"},
-    {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99a6b36f95c98839ad98f8c553d8507644c880cf1e0a57fe5e3a3f3969040882"},
-    {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4345c9a27f4310afbb9c01750e9461ff33d6fb74cd2456b107525bbeebcb5be3"},
-    {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:3516e0b6224cf6e43e341d56da15fd33bdc37fa0c06af4f029f7d7dfceceabbc"},
-    {file = "pyzmq-25.1.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:146b9b1f29ead41255387fb07be56dc29639262c0f7344f570eecdcd8d683314"},
-    {file = "pyzmq-25.1.2.tar.gz", hash = "sha256:93f1aa311e8bb912e34f004cf186407a4e90eec4f0ecc0efd26056bf7eda0226"},
-]
-
-[package.dependencies]
-cffi = {version = "*", markers = "implementation_name == \"pypy\""}
-
-[[package]]
-name = "qtconsole"
-version = "5.5.1"
-description = "Jupyter Qt console"
-optional = false
-python-versions = ">= 3.8"
-files = [
-    {file = "qtconsole-5.5.1-py3-none-any.whl", hash = "sha256:8c75fa3e9b4ed884880ff7cea90a1b67451219279ec33deaee1d59e3df1a5d2b"},
-    {file = "qtconsole-5.5.1.tar.gz", hash = "sha256:a0e806c6951db9490628e4df80caec9669b65149c7ba40f9bf033c025a5b56bc"},
-]
-
-[package.dependencies]
-ipykernel = ">=4.1"
-jupyter-client = ">=4.1"
-jupyter-core = "*"
-packaging = "*"
-pygments = "*"
-pyzmq = ">=17.1"
-qtpy = ">=2.4.0"
-traitlets = "<5.2.1 || >5.2.1,<5.2.2 || >5.2.2"
-
-[package.extras]
-doc = ["Sphinx (>=1.3)"]
-test = ["flaky", "pytest", "pytest-qt"]
-
-[[package]]
-name = "qtpy"
-version = "2.4.1"
-description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)."
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"},
-    {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"},
-]
-
-[package.dependencies]
-packaging = "*"
-
-[package.extras]
-test = ["pytest (>=6,!=7.0.0,!=7.0.1)", "pytest-cov (>=3.0.0)", "pytest-qt"]
-
 [[package]]
 name = "referencing"
-version = "0.33.0"
+version = "0.34.0"
 description = "JSON Referencing + Python"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "referencing-0.33.0-py3-none-any.whl", hash = "sha256:39240f2ecc770258f28b642dd47fd74bc8b02484de54e1882b74b35ebd779bd5"},
-    {file = "referencing-0.33.0.tar.gz", hash = "sha256:c775fedf74bc0f9189c2a3be1c12fd03e8c23f4d371dce795df44e06c5b412f7"},
+    {file = "referencing-0.34.0-py3-none-any.whl", hash = "sha256:d53ae300ceddd3169f1ffa9caf2cb7b769e92657e4fafb23d34b93679116dfd4"},
+    {file = "referencing-0.34.0.tar.gz", hash = "sha256:5773bd84ef41799a5a8ca72dc34590c041eb01bf9aa02632b4a973fb0181a844"},
 ]
 
 [package.dependencies]
@@ -2011,29 +1418,22 @@ socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
 [[package]]
-name = "rfc3339-validator"
-version = "0.1.4"
-description = "A pure python RFC3339 validator"
+name = "rich"
+version = "13.7.1"
+description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal"
 optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+python-versions = ">=3.7.0"
 files = [
-    {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"},
-    {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"},
+    {file = "rich-13.7.1-py3-none-any.whl", hash = "sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222"},
+    {file = "rich-13.7.1.tar.gz", hash = "sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432"},
 ]
 
 [package.dependencies]
-six = "*"
+markdown-it-py = ">=2.2.0"
+pygments = ">=2.13.0,<3.0.0"
 
-[[package]]
-name = "rfc3986-validator"
-version = "0.1.1"
-description = "Pure python rfc3986 validator"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-files = [
-    {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"},
-    {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"},
-]
+[package.extras]
+jupyter = ["ipywidgets (>=7.5.1,<9)"]
 
 [[package]]
 name = "rpds-py"
@@ -2144,35 +1544,45 @@ files = [
 ]
 
 [[package]]
-name = "send2trash"
-version = "1.8.2"
-description = "Send file to trash natively under Mac OS X, Windows and Linux"
+name = "ruff"
+version = "0.3.7"
+description = "An extremely fast Python linter and code formatter, written in Rust."
 optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"
+python-versions = ">=3.7"
 files = [
-    {file = "Send2Trash-1.8.2-py3-none-any.whl", hash = "sha256:a384719d99c07ce1eefd6905d2decb6f8b7ed054025bb0e618919f945de4f679"},
-    {file = "Send2Trash-1.8.2.tar.gz", hash = "sha256:c132d59fa44b9ca2b1699af5c86f57ce9f4c5eb56629d5d55fbb7a35f84e2312"},
+    {file = "ruff-0.3.7-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0e8377cccb2f07abd25e84fc5b2cbe48eeb0fea9f1719cad7caedb061d70e5ce"},
+    {file = "ruff-0.3.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:15a4d1cc1e64e556fa0d67bfd388fed416b7f3b26d5d1c3e7d192c897e39ba4b"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d28bdf3d7dc71dd46929fafeec98ba89b7c3550c3f0978e36389b5631b793663"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:379b67d4f49774ba679593b232dcd90d9e10f04d96e3c8ce4a28037ae473f7bb"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c060aea8ad5ef21cdfbbe05475ab5104ce7827b639a78dd55383a6e9895b7c51"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:ebf8f615dde968272d70502c083ebf963b6781aacd3079081e03b32adfe4d58a"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d48098bd8f5c38897b03604f5428901b65e3c97d40b3952e38637b5404b739a2"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da8a4fda219bf9024692b1bc68c9cff4b80507879ada8769dc7e985755d662ea"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c44e0149f1d8b48c4d5c33d88c677a4aa22fd09b1683d6a7ff55b816b5d074f"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3050ec0af72b709a62ecc2aca941b9cd479a7bf2b36cc4562f0033d688e44fa1"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a29cc38e4c1ab00da18a3f6777f8b50099d73326981bb7d182e54a9a21bb4ff7"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:5b15cc59c19edca917f51b1956637db47e200b0fc5e6e1878233d3a938384b0b"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e491045781b1e38b72c91247cf4634f040f8d0cb3e6d3d64d38dcf43616650b4"},
+    {file = "ruff-0.3.7-py3-none-win32.whl", hash = "sha256:bc931de87593d64fad3a22e201e55ad76271f1d5bfc44e1a1887edd0903c7d9f"},
+    {file = "ruff-0.3.7-py3-none-win_amd64.whl", hash = "sha256:5ef0e501e1e39f35e03c2acb1d1238c595b8bb36cf7a170e7c1df1b73da00e74"},
+    {file = "ruff-0.3.7-py3-none-win_arm64.whl", hash = "sha256:789e144f6dc7019d1f92a812891c645274ed08af6037d11fc65fcbc183b7d59f"},
+    {file = "ruff-0.3.7.tar.gz", hash = "sha256:d5c1aebee5162c2226784800ae031f660c350e7a3402c4d1f8ea4e97e232e3ba"},
 ]
 
-[package.extras]
-nativelib = ["pyobjc-framework-Cocoa", "pywin32"]
-objc = ["pyobjc-framework-Cocoa"]
-win32 = ["pywin32"]
-
 [[package]]
 name = "setuptools"
-version = "69.1.1"
+version = "69.5.1"
 description = "Easily download, build, install, upgrade, and uninstall Python packages"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "setuptools-69.1.1-py3-none-any.whl", hash = "sha256:02fa291a0471b3a18b2b2481ed902af520c69e8ae0919c13da936542754b4c56"},
-    {file = "setuptools-69.1.1.tar.gz", hash = "sha256:5c0806c7d9af348e6dd3777b4f4dbb42c7ad85b190104837488eab9a7c945cf8"},
+    {file = "setuptools-69.5.1-py3-none-any.whl", hash = "sha256:c636ac361bc47580504644275c9ad802c50415c7522212252c033bd15f301f32"},
+    {file = "setuptools-69.5.1.tar.gz", hash = "sha256:6c1fccdac05a97e598fb0ae3bbed5904ccb317337a51139dcd51453611bbb987"},
 ]
 
 [package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"]
-testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"]
+testing = ["build[virtualenv]", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "mypy (==1.9)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6,!=8.1.1)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"]
 testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"]
 
 [[package]]
@@ -2187,66 +1597,64 @@ files = [
 ]
 
 [[package]]
-name = "sniffio"
-version = "1.3.1"
-description = "Sniff out which async library your code is running under"
+name = "smmap"
+version = "5.0.1"
+description = "A pure Python implementation of a sliding window memory map manager"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"},
-    {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"},
-]
-
-[[package]]
-name = "soupsieve"
-version = "2.5"
-description = "A modern CSS selector implementation for Beautiful Soup."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"},
-    {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"},
+    {file = "smmap-5.0.1-py3-none-any.whl", hash = "sha256:e6d8668fa5f93e706934a62d7b4db19c8d9eb8cf2adbb75ef1b675aa332b69da"},
+    {file = "smmap-5.0.1.tar.gz", hash = "sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62"},
 ]
 
 [[package]]
-name = "stack-data"
-version = "0.6.3"
-description = "Extract data from python stack frames and tracebacks for informative displays"
+name = "streamlit"
+version = "1.33.0"
+description = "A faster way to build and share data apps"
 optional = false
-python-versions = "*"
+python-versions = "!=3.9.7,>=3.8"
 files = [
-    {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"},
-    {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"},
+    {file = "streamlit-1.33.0-py2.py3-none-any.whl", hash = "sha256:bfacb5d1edefcf803c2040b051a21b4c81317a9865448e6767d0a0c6aae7edae"},
+    {file = "streamlit-1.33.0.tar.gz", hash = "sha256:a8da8ff46f5b948c56d2dc7aca7a61cf8d995f4f21744cf82258ae75e63004ba"},
 ]
 
 [package.dependencies]
-asttokens = ">=2.1.0"
-executing = ">=1.2.0"
-pure-eval = "*"
+altair = ">=4.0,<6"
+blinker = ">=1.0.0,<2"
+cachetools = ">=4.0,<6"
+click = ">=7.0,<9"
+gitpython = ">=3.0.7,<3.1.19 || >3.1.19,<4"
+numpy = ">=1.19.3,<2"
+packaging = ">=16.8,<25"
+pandas = ">=1.3.0,<3"
+pillow = ">=7.1.0,<11"
+protobuf = ">=3.20,<5"
+pyarrow = ">=7.0"
+pydeck = ">=0.8.0b4,<1"
+requests = ">=2.27,<3"
+rich = ">=10.14.0,<14"
+tenacity = ">=8.1.0,<9"
+toml = ">=0.10.1,<2"
+tornado = ">=6.0.3,<7"
+typing-extensions = ">=4.3.0,<5"
+watchdog = {version = ">=2.1.5", markers = "platform_system != \"Darwin\""}
 
 [package.extras]
-tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"]
+snowflake = ["snowflake-connector-python (>=2.8.0)", "snowflake-snowpark-python (>=0.9.0)"]
 
 [[package]]
-name = "terminado"
-version = "0.18.0"
-description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library."
+name = "tenacity"
+version = "8.2.3"
+description = "Retry code until it succeeds"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.7"
 files = [
-    {file = "terminado-0.18.0-py3-none-any.whl", hash = "sha256:87b0d96642d0fe5f5abd7783857b9cab167f221a39ff98e3b9619a788a3c0f2e"},
-    {file = "terminado-0.18.0.tar.gz", hash = "sha256:1ea08a89b835dd1b8c0c900d92848147cef2537243361b2e3f4dc15df9b6fded"},
+    {file = "tenacity-8.2.3-py3-none-any.whl", hash = "sha256:ce510e327a630c9e1beaf17d42e6ffacc88185044ad85cf74c0a8887c6a0f88c"},
+    {file = "tenacity-8.2.3.tar.gz", hash = "sha256:5398ef0d78e63f40007c1fb4c0bff96e1911394d2fa8d194f77619c05ff6cc8a"},
 ]
 
-[package.dependencies]
-ptyprocess = {version = "*", markers = "os_name != \"nt\""}
-pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""}
-tornado = ">=6.1.0"
-
 [package.extras]
-docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"]
-test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"]
-typing = ["mypy (>=1.6,<2.0)", "traitlets (>=5.11.1)"]
+doc = ["reno", "sphinx", "tornado (>=4.5)"]
 
 [[package]]
 name = "text-unidecode"
@@ -2260,23 +1668,16 @@ files = [
 ]
 
 [[package]]
-name = "tinycss2"
-version = "1.2.1"
-description = "A tiny CSS parser"
+name = "toml"
+version = "0.10.2"
+description = "Python Library for Tom's Obvious, Minimal Language"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
 files = [
-    {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"},
-    {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"},
+    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
+    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
 ]
 
-[package.dependencies]
-webencodings = ">=0.4"
-
-[package.extras]
-doc = ["sphinx", "sphinx_rtd_theme"]
-test = ["flake8", "isort", "pytest"]
-
 [[package]]
 name = "tomli"
 version = "2.0.1"
@@ -2288,6 +1689,17 @@ files = [
     {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]
 
+[[package]]
+name = "toolz"
+version = "0.12.1"
+description = "List processing tools and functional utilities"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "toolz-0.12.1-py3-none-any.whl", hash = "sha256:d22731364c07d72eea0a0ad45bafb2c2937ab6fd38a3507bf55eae8744aa7d85"},
+    {file = "toolz-0.12.1.tar.gz", hash = "sha256:ecca342664893f177a13dac0e6b41cbd8ac25a358e5f215316d43e2100224f4d"},
+]
+
 [[package]]
 name = "tornado"
 version = "6.4"
@@ -2310,13 +1722,13 @@ files = [
 
 [[package]]
 name = "tox"
-version = "4.13.0"
+version = "4.14.2"
 description = "tox is a generic virtualenv management and test command line tool"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "tox-4.13.0-py3-none-any.whl", hash = "sha256:1143c7e2489c68026a55d3d4ae84c02c449f073b28e62f80e3e440a3b72a4afa"},
-    {file = "tox-4.13.0.tar.gz", hash = "sha256:dd789a554c16c4b532924ba393c92fc8991323c4b3d466712bfecc8c9b9f24f7"},
+    {file = "tox-4.14.2-py3-none-any.whl", hash = "sha256:2900c4eb7b716af4a928a7fdc2ed248ad6575294ed7cfae2ea41203937422847"},
+    {file = "tox-4.14.2.tar.gz", hash = "sha256:0defb44f6dafd911b61788325741cc6b2e12ea71f987ac025ad4d649f1f1a104"},
 ]
 
 [package.dependencies]
@@ -2355,57 +1767,28 @@ notebook = ["ipywidgets (>=6)"]
 slack = ["slack-sdk"]
 telegram = ["requests"]
 
-[[package]]
-name = "traitlets"
-version = "5.14.1"
-description = "Traitlets Python configuration system"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "traitlets-5.14.1-py3-none-any.whl", hash = "sha256:2e5a030e6eff91737c643231bfcf04a65b0132078dad75e4936700b213652e74"},
-    {file = "traitlets-5.14.1.tar.gz", hash = "sha256:8585105b371a04b8316a43d5ce29c098575c2e477850b62b848b964f1444527e"},
-]
-
-[package.extras]
-docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"]
-test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<7.5)", "pytest-mock", "pytest-mypy-testing"]
-
-[[package]]
-name = "types-python-dateutil"
-version = "2.8.19.20240106"
-description = "Typing stubs for python-dateutil"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "types-python-dateutil-2.8.19.20240106.tar.gz", hash = "sha256:1f8db221c3b98e6ca02ea83a58371b22c374f42ae5bbdf186db9c9a76581459f"},
-    {file = "types_python_dateutil-2.8.19.20240106-py3-none-any.whl", hash = "sha256:efbbdc54590d0f16152fa103c9879c7d4a00e82078f6e2cf01769042165acaa2"},
-]
-
 [[package]]
 name = "typing-extensions"
-version = "4.10.0"
+version = "4.11.0"
 description = "Backported and Experimental Type Hints for Python 3.8+"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "typing_extensions-4.10.0-py3-none-any.whl", hash = "sha256:69b1a937c3a517342112fb4c6df7e72fc39a38e7891a5730ed4985b5214b5475"},
-    {file = "typing_extensions-4.10.0.tar.gz", hash = "sha256:b0abd7c89e8fb96f98db18d86106ff1d90ab692004eb746cf6eda2682f91b3cb"},
+    {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"},
+    {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"},
 ]
 
 [[package]]
-name = "uri-template"
-version = "1.3.0"
-description = "RFC 6570 URI Template Processor"
+name = "tzdata"
+version = "2024.1"
+description = "Provider of IANA time zone data"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=2"
 files = [
-    {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"},
-    {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"},
+    {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"},
+    {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"},
 ]
 
-[package.extras]
-dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-modern-annotations", "flake8-noqa", "flake8-pyproject", "flake8-requirements", "flake8-typechecking-import", "flake8-use-fstring", "mypy", "pep8-naming", "types-PyYAML"]
-
 [[package]]
 name = "urllib3"
 version = "2.2.1"
@@ -2444,30 +1827,45 @@ docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-
 test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
 
 [[package]]
-name = "wcwidth"
-version = "0.2.13"
-description = "Measures the displayed width of unicode strings in a terminal"
-optional = false
-python-versions = "*"
-files = [
-    {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"},
-    {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"},
-]
-
-[[package]]
-name = "webcolors"
-version = "1.13"
-description = "A library for working with the color formats defined by HTML and CSS."
+name = "watchdog"
+version = "4.0.0"
+description = "Filesystem events monitoring"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
 files = [
-    {file = "webcolors-1.13-py3-none-any.whl", hash = "sha256:29bc7e8752c0a1bd4a1f03c14d6e6a72e93d82193738fa860cbff59d0fcc11bf"},
-    {file = "webcolors-1.13.tar.gz", hash = "sha256:c225b674c83fa923be93d235330ce0300373d02885cef23238813b0d5668304a"},
+    {file = "watchdog-4.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:39cb34b1f1afbf23e9562501673e7146777efe95da24fab5707b88f7fb11649b"},
+    {file = "watchdog-4.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c522392acc5e962bcac3b22b9592493ffd06d1fc5d755954e6be9f4990de932b"},
+    {file = "watchdog-4.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6c47bdd680009b11c9ac382163e05ca43baf4127954c5f6d0250e7d772d2b80c"},
+    {file = "watchdog-4.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8350d4055505412a426b6ad8c521bc7d367d1637a762c70fdd93a3a0d595990b"},
+    {file = "watchdog-4.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c17d98799f32e3f55f181f19dd2021d762eb38fdd381b4a748b9f5a36738e935"},
+    {file = "watchdog-4.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4986db5e8880b0e6b7cd52ba36255d4793bf5cdc95bd6264806c233173b1ec0b"},
+    {file = "watchdog-4.0.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:11e12fafb13372e18ca1bbf12d50f593e7280646687463dd47730fd4f4d5d257"},
+    {file = "watchdog-4.0.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5369136a6474678e02426bd984466343924d1df8e2fd94a9b443cb7e3aa20d19"},
+    {file = "watchdog-4.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76ad8484379695f3fe46228962017a7e1337e9acadafed67eb20aabb175df98b"},
+    {file = "watchdog-4.0.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:45cc09cc4c3b43fb10b59ef4d07318d9a3ecdbff03abd2e36e77b6dd9f9a5c85"},
+    {file = "watchdog-4.0.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:eed82cdf79cd7f0232e2fdc1ad05b06a5e102a43e331f7d041e5f0e0a34a51c4"},
+    {file = "watchdog-4.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ba30a896166f0fee83183cec913298151b73164160d965af2e93a20bbd2ab605"},
+    {file = "watchdog-4.0.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:d18d7f18a47de6863cd480734613502904611730f8def45fc52a5d97503e5101"},
+    {file = "watchdog-4.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2895bf0518361a9728773083908801a376743bcc37dfa252b801af8fd281b1ca"},
+    {file = "watchdog-4.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:87e9df830022488e235dd601478c15ad73a0389628588ba0b028cb74eb72fed8"},
+    {file = "watchdog-4.0.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:6e949a8a94186bced05b6508faa61b7adacc911115664ccb1923b9ad1f1ccf7b"},
+    {file = "watchdog-4.0.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:6a4db54edea37d1058b08947c789a2354ee02972ed5d1e0dca9b0b820f4c7f92"},
+    {file = "watchdog-4.0.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d31481ccf4694a8416b681544c23bd271f5a123162ab603c7d7d2dd7dd901a07"},
+    {file = "watchdog-4.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8fec441f5adcf81dd240a5fe78e3d83767999771630b5ddfc5867827a34fa3d3"},
+    {file = "watchdog-4.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:6a9c71a0b02985b4b0b6d14b875a6c86ddea2fdbebd0c9a720a806a8bbffc69f"},
+    {file = "watchdog-4.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:557ba04c816d23ce98a06e70af6abaa0485f6d94994ec78a42b05d1c03dcbd50"},
+    {file = "watchdog-4.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:d0f9bd1fd919134d459d8abf954f63886745f4660ef66480b9d753a7c9d40927"},
+    {file = "watchdog-4.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:f9b2fdca47dc855516b2d66eef3c39f2672cbf7e7a42e7e67ad2cbfcd6ba107d"},
+    {file = "watchdog-4.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:73c7a935e62033bd5e8f0da33a4dcb763da2361921a69a5a95aaf6c93aa03a87"},
+    {file = "watchdog-4.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6a80d5cae8c265842c7419c560b9961561556c4361b297b4c431903f8c33b269"},
+    {file = "watchdog-4.0.0-py3-none-win32.whl", hash = "sha256:8f9a542c979df62098ae9c58b19e03ad3df1c9d8c6895d96c0d51da17b243b1c"},
+    {file = "watchdog-4.0.0-py3-none-win_amd64.whl", hash = "sha256:f970663fa4f7e80401a7b0cbeec00fa801bf0287d93d48368fc3e6fa32716245"},
+    {file = "watchdog-4.0.0-py3-none-win_ia64.whl", hash = "sha256:9a03e16e55465177d416699331b0f3564138f1807ecc5f2de9d55d8f188d08c7"},
+    {file = "watchdog-4.0.0.tar.gz", hash = "sha256:e3e7065cbdabe6183ab82199d7a4f6b3ba0a438c5a512a68559846ccb76a78ec"},
 ]
 
 [package.extras]
-docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"]
-tests = ["pytest", "pytest-cov"]
+watchmedo = ["PyYAML (>=3.10)"]
 
 [[package]]
 name = "webencodings"
@@ -2480,34 +1878,7 @@ files = [
     {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"},
 ]
 
-[[package]]
-name = "websocket-client"
-version = "1.7.0"
-description = "WebSocket client for Python with low level API options"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "websocket-client-1.7.0.tar.gz", hash = "sha256:10e511ea3a8c744631d3bd77e61eb17ed09304c413ad42cf6ddfa4c7787e8fe6"},
-    {file = "websocket_client-1.7.0-py3-none-any.whl", hash = "sha256:f4c3d22fec12a2461427a29957ff07d35098ee2d976d3ba244e688b8b4057588"},
-]
-
-[package.extras]
-docs = ["Sphinx (>=6.0)", "sphinx-rtd-theme (>=1.1.0)"]
-optional = ["python-socks", "wsaccel"]
-test = ["websockets"]
-
-[[package]]
-name = "widgetsnbextension"
-version = "4.0.10"
-description = "Jupyter interactive widgets for Jupyter Notebook"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "widgetsnbextension-4.0.10-py3-none-any.whl", hash = "sha256:d37c3724ec32d8c48400a435ecfa7d3e259995201fbefa37163124a9fcb393cc"},
-    {file = "widgetsnbextension-4.0.10.tar.gz", hash = "sha256:64196c5ff3b9a9183a8e699a4227fb0b7002f252c814098e66c4d1cd0644688f"},
-]
-
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.10"
-content-hash = "4f39c5e267d633fab26b42f0bffa6f1928ae0d8b3c3230112411a703c4762260"
+content-hash = "5594949892f0ae826d11b880fe1811703ad7bab12982eb2877f5c6588bab265a"
diff --git a/pyproject.toml b/pyproject.toml
index dd1755c..8cacd33 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -12,11 +12,16 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.10"
-numpy = "^1.21.1"
-pandas = "^1.1.1"
-jupyter = "^1.0.0"
-ipykernel = "^5.3.4"
+# numpy = "^1.21.1"
+# pandas = "^1.1.1"
+# jupyter = "^1.0.0"
+# ipykernel = "^5.3.4"
+pandas = "^2.2.0"
 kaggle = "^1.6.6"
+plotly = "^5.20.0"
+streamlit = "^1.33.0"
+matplotlib = "^3.8.4"
+ruff = "^0.3.7"
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = "^2.20.0"