From 6f9fc0e24fe2d0ded88b6bdb5c0d9b09055da267 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Thu, 15 Feb 2024 17:07:10 +0200
Subject: [PATCH 01/14] feat: Dynamic splitter

---
 poetry.lock                                   |  16 +-
 pyproject.toml                                |   1 +
 semantic_router/splitters/base.py             |  11 ++
 .../splitters/dynamic_cumulative.py           | 144 ++++++++++++++++++
 4 files changed, 171 insertions(+), 1 deletion(-)
 create mode 100644 semantic_router/splitters/dynamic_cumulative.py

diff --git a/poetry.lock b/poetry.lock
index ed489810..ef8400e5 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -2936,6 +2936,20 @@ files = [
 [package.dependencies]
 mpmath = ">=0.19"
 
+[[package]]
+name = "termcolor"
+version = "2.4.0"
+description = "ANSI color formatting for output in terminal"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "termcolor-2.4.0-py3-none-any.whl", hash = "sha256:9297c0df9c99445c2412e832e882a7884038a25617c60cea2ad69488d4040d63"},
+    {file = "termcolor-2.4.0.tar.gz", hash = "sha256:aab9e56047c8ac41ed798fa36d892a37aca6b3e9159f3e0c24bc64a9b3ac7b7a"},
+]
+
+[package.extras]
+tests = ["pytest", "pytest-cov"]
+
 [[package]]
 name = "tokenizers"
 version = "0.15.1"
@@ -3479,4 +3493,4 @@ pinecone = ["pinecone-client"]
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.9,<3.13"
-content-hash = "23b8995b7eee4df19bb2242d6a81de8557a855053b4346a532efa63be2ea303f"
+content-hash = "894b9692ad914e11c364d588bca8d7a99ef862cdd5b2137c00e4d5cac77a35c9"
diff --git a/pyproject.toml b/pyproject.toml
index 1889ef6e..67851a3c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -47,6 +47,7 @@ pytest-xdist = "^3.5.0"
 mypy = "^1.7.1"
 types-pyyaml = "^6.0.12.12"
 types-requests = "^2.31.0"
+termcolor = "^2.4.0"
 
 [build-system]
 requires = ["poetry-core"]
diff --git a/semantic_router/splitters/base.py b/semantic_router/splitters/base.py
index edeba73b..c4df5785 100644
--- a/semantic_router/splitters/base.py
+++ b/semantic_router/splitters/base.py
@@ -3,6 +3,8 @@
 from pydantic.v1 import BaseModel
 
 from semantic_router.encoders import BaseEncoder
+from semantic_router.schema import DocumentSplit
+from termcolor import colored
 
 
 class BaseSplitter(BaseModel):
@@ -12,3 +14,12 @@ class BaseSplitter(BaseModel):
 
     def __call__(self, docs: List[str]) -> List[List[float]]:
         raise NotImplementedError("Subclasses must implement this method")
+
+    def print_colored_splits(self, splits: List[DocumentSplit]):
+        colors = ["red", "green", "blue", "magenta", "cyan"]
+        for i, split in enumerate(splits):
+            color = colors[i % len(colors)]
+            for doc in split.docs:
+                print(colored(doc, color))  # type: ignore
+            print("Triggered score:", split.triggered_score)
+            print("\n")
diff --git a/semantic_router/splitters/dynamic_cumulative.py b/semantic_router/splitters/dynamic_cumulative.py
new file mode 100644
index 00000000..eca4383d
--- /dev/null
+++ b/semantic_router/splitters/dynamic_cumulative.py
@@ -0,0 +1,144 @@
+from typing import List
+
+import numpy as np
+
+from semantic_router.encoders import BaseEncoder
+from semantic_router.schema import DocumentSplit
+from semantic_router.splitters.base import BaseSplitter
+from semantic_router.utils.logger import logger
+
+
+class DynamicCumulativeSplitter(BaseSplitter):
+    """
+    Splits documents dynamically based on the cumulative similarity of document
+    embeddings, adjusting thresholds and window sizes based on recent similarities.
+    """
+
+    def __init__(
+        self,
+        encoder: BaseEncoder,
+        name: str = "dynamic_cumulative_similarity_splitter",
+        score_threshold: float = 0.3,
+    ):
+        super().__init__(name=name, encoder=encoder, score_threshold=score_threshold)
+        logger.info(
+            f"Initialized {self.name} with score threshold: {self.score_threshold}"
+        )
+
+    def encode_documents(self, docs: List[str]) -> np.ndarray:
+        encoded_docs = self.encoder(docs)
+        encoded_docs_array = np.array(encoded_docs)
+        logger.info(f"Encoded {len(docs)} documents")
+        return encoded_docs_array
+
+    def adjust_threshold(self, similarities):
+        if len(similarities) > 5:
+            # Calculate recent mean similarity and standard deviation
+            recent_similarities = similarities[-5:]
+            mean_similarity = np.mean(recent_similarities)
+            std_dev_similarity = np.std(recent_similarities)
+            logger.debug(
+                f"Recent mean similarity: {mean_similarity}, "
+                f"std dev: {std_dev_similarity}"
+            )
+
+            # Calculate the rate of change (delta) for mean
+            # similarity and standard deviation
+            if len(similarities) > 10:
+                previous_similarities = similarities[-10:-5]
+                previous_mean_similarity = np.mean(previous_similarities)
+                previous_std_dev_similarity = np.std(previous_similarities)
+                delta_mean = mean_similarity - previous_mean_similarity
+                delta_std_dev = std_dev_similarity - previous_std_dev_similarity
+            else:
+                delta_mean = delta_std_dev = 0
+
+            # Adjust the threshold based on the deviation from the mean similarity
+            # and the rate of change in mean similarity and standard deviation
+            adjustment_factor = (
+                std_dev_similarity + abs(delta_mean) + abs(delta_std_dev)
+            )
+            adjusted_threshold = mean_similarity - adjustment_factor
+
+            # Dynamically set the lower bound based on the rate of change
+            dynamic_lower_bound = max(0.2, 0.2 + delta_mean - delta_std_dev)
+
+            # Introduce a minimum split threshold that is higher than the
+            # dynamic lower bound
+            min_split_threshold = 0.3
+
+            # Ensure the new threshold is within a sensible range,
+            # dynamically adjusting the lower bound
+            # and considering the minimum split threshold
+            new_threshold = max(
+                np.clip(adjusted_threshold, dynamic_lower_bound, self.score_threshold),
+                min_split_threshold,
+            )
+
+            logger.debug(
+                f"Adjusted threshold to {new_threshold}, with dynamic lower "
+                f"bound {dynamic_lower_bound}"
+            )
+            return new_threshold
+        return self.score_threshold
+
+    def calculate_dynamic_context_similarity(self, encoded_docs):
+        split_indices = [0]
+        similarities = []
+        dynamic_window_size = 5  # Starting window size
+
+        norms = np.linalg.norm(encoded_docs, axis=1)
+        for idx in range(1, len(encoded_docs)):
+            # Adjust window size based on recent variability
+            if len(similarities) > 10:
+                std_dev_recent = np.std(similarities[-10:])
+                dynamic_window_size = 5 if std_dev_recent < 0.05 else 10
+
+            window_start = max(0, idx - dynamic_window_size)
+            cumulative_context = np.mean(encoded_docs[window_start:idx], axis=0)
+            cumulative_norm = np.linalg.norm(cumulative_context)
+
+            curr_sim_score = np.dot(cumulative_context, encoded_docs[idx]) / (
+                cumulative_norm * norms[idx] + 1e-10
+            )
+
+            similarities.append(curr_sim_score)
+
+            dynamic_threshold = self.adjust_threshold(similarities)
+            if curr_sim_score < dynamic_threshold:
+                split_indices.append(idx)
+
+        return split_indices, similarities
+
+    def __call__(self, docs: List[str]):
+        logger.info(f"Splitting {len(docs)} documents")
+        encoded_docs = self.encode_documents(docs)
+        split_indices, similarities = self.calculate_dynamic_context_similarity(
+            encoded_docs
+        )
+        splits = []
+
+        last_idx = 0
+        for idx in split_indices:
+            if idx == 0:
+                continue
+            splits.append(
+                DocumentSplit(
+                    docs=docs[last_idx:idx],
+                    is_triggered=(idx - last_idx > 1),
+                    triggered_score=(
+                        similarities[idx - 1] if idx - 1 < len(similarities) else None
+                    ),
+                )
+            )
+            last_idx = idx
+        splits.append(
+            DocumentSplit(
+                docs=docs[last_idx:],
+                is_triggered=(len(docs) - last_idx > 1),
+                triggered_score=similarities[-1] if similarities else None,
+            )
+        )
+        logger.info(f"Completed splitting documents into {len(splits)} splits")
+
+        return splits

From 1eb0fc70a0e4f00ce76d1107a696fbf7f2159c4c Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Thu, 15 Feb 2024 17:21:50 +0200
Subject: [PATCH 02/14] chore: Added comments

---
 .../splitters/dynamic_cumulative.py           | 111 ++++++++----------
 1 file changed, 51 insertions(+), 60 deletions(-)

diff --git a/semantic_router/splitters/dynamic_cumulative.py b/semantic_router/splitters/dynamic_cumulative.py
index eca4383d..f1b35bdf 100644
--- a/semantic_router/splitters/dynamic_cumulative.py
+++ b/semantic_router/splitters/dynamic_cumulative.py
@@ -18,99 +18,89 @@ def __init__(
         self,
         encoder: BaseEncoder,
         name: str = "dynamic_cumulative_similarity_splitter",
-        score_threshold: float = 0.3,
+        score_threshold: float = 0.9,
     ):
         super().__init__(name=name, encoder=encoder, score_threshold=score_threshold)
+        # Log the initialization details
         logger.info(
             f"Initialized {self.name} with score threshold: {self.score_threshold}"
         )
 
     def encode_documents(self, docs: List[str]) -> np.ndarray:
+        # Encode the documents using the provided encoder and return as a numpy array
         encoded_docs = self.encoder(docs)
-        encoded_docs_array = np.array(encoded_docs)
         logger.info(f"Encoded {len(docs)} documents")
-        return encoded_docs_array
+        return np.array(encoded_docs)
 
     def adjust_threshold(self, similarities):
-        if len(similarities) > 5:
-            # Calculate recent mean similarity and standard deviation
-            recent_similarities = similarities[-5:]
-            mean_similarity = np.mean(recent_similarities)
-            std_dev_similarity = np.std(recent_similarities)
-            logger.debug(
-                f"Recent mean similarity: {mean_similarity}, "
-                f"std dev: {std_dev_similarity}"
-            )
-
-            # Calculate the rate of change (delta) for mean
-            # similarity and standard deviation
-            if len(similarities) > 10:
-                previous_similarities = similarities[-10:-5]
-                previous_mean_similarity = np.mean(previous_similarities)
-                previous_std_dev_similarity = np.std(previous_similarities)
-                delta_mean = mean_similarity - previous_mean_similarity
-                delta_std_dev = std_dev_similarity - previous_std_dev_similarity
-            else:
-                delta_mean = delta_std_dev = 0
-
-            # Adjust the threshold based on the deviation from the mean similarity
-            # and the rate of change in mean similarity and standard deviation
-            adjustment_factor = (
-                std_dev_similarity + abs(delta_mean) + abs(delta_std_dev)
-            )
-            adjusted_threshold = mean_similarity - adjustment_factor
-
-            # Dynamically set the lower bound based on the rate of change
-            dynamic_lower_bound = max(0.2, 0.2 + delta_mean - delta_std_dev)
-
-            # Introduce a minimum split threshold that is higher than the
-            # dynamic lower bound
-            min_split_threshold = 0.3
-
-            # Ensure the new threshold is within a sensible range,
-            # dynamically adjusting the lower bound
-            # and considering the minimum split threshold
-            new_threshold = max(
-                np.clip(adjusted_threshold, dynamic_lower_bound, self.score_threshold),
-                min_split_threshold,
-            )
+        # Adjust the similarity threshold based on recent similarities
+        if len(similarities) <= 5:
+            # If not enough data, return the default score threshold
+            return self.score_threshold
+
+        # Calculate mean and standard deviation of the last 5 similarities
+        recent_similarities = similarities[-5:]
+        mean_similarity, std_dev_similarity = np.mean(recent_similarities), np.std(
+            recent_similarities
+        )
 
-            logger.debug(
-                f"Adjusted threshold to {new_threshold}, with dynamic lower "
-                f"bound {dynamic_lower_bound}"
-            )
-            return new_threshold
-        return self.score_threshold
+        # Calculate the change in mean and standard deviation if enough data is
+        # available
+        delta_mean = delta_std_dev = 0
+        if len(similarities) > 10:
+            previous_similarities = similarities[-10:-5]
+            delta_mean = mean_similarity - np.mean(previous_similarities)
+            delta_std_dev = std_dev_similarity - np.std(previous_similarities)
+
+        # Adjust the threshold based on the calculated metrics
+        adjustment_factor = std_dev_similarity + abs(delta_mean) + abs(delta_std_dev)
+        adjusted_threshold = mean_similarity - adjustment_factor
+        dynamic_lower_bound = max(0.2, 0.2 + delta_mean - delta_std_dev)
+        min_split_threshold = 0.3
+
+        # Ensure the new threshold is within a sensible range
+        new_threshold = max(
+            np.clip(adjusted_threshold, dynamic_lower_bound, self.score_threshold),
+            min_split_threshold,
+        )
+        logger.debug(
+            f"Adjusted threshold to {new_threshold}, with dynamic lower "
+            f"bound {dynamic_lower_bound}"
+        )
+        return new_threshold
 
     def calculate_dynamic_context_similarity(self, encoded_docs):
-        split_indices = [0]
-        similarities = []
-        dynamic_window_size = 5  # Starting window size
+        # Calculate the dynamic context similarity to determine split indices
+        split_indices, similarities = [0], []
+        dynamic_window_size = 5  # Initial window size
+        norms = np.linalg.norm(
+            encoded_docs, axis=1
+        )  # Pre-calculate norms for efficiency
 
-        norms = np.linalg.norm(encoded_docs, axis=1)
         for idx in range(1, len(encoded_docs)):
-            # Adjust window size based on recent variability
+            # Adjust window size based on the standard deviation of recent similarities
             if len(similarities) > 10:
                 std_dev_recent = np.std(similarities[-10:])
                 dynamic_window_size = 5 if std_dev_recent < 0.05 else 10
 
+            # Calculate the similarity for the current document
             window_start = max(0, idx - dynamic_window_size)
             cumulative_context = np.mean(encoded_docs[window_start:idx], axis=0)
             cumulative_norm = np.linalg.norm(cumulative_context)
-
             curr_sim_score = np.dot(cumulative_context, encoded_docs[idx]) / (
                 cumulative_norm * norms[idx] + 1e-10
             )
 
             similarities.append(curr_sim_score)
-
-            dynamic_threshold = self.adjust_threshold(similarities)
-            if curr_sim_score < dynamic_threshold:
+            # If the similarity is below the dynamically adjusted threshold,
+            # mark a new split
+            if curr_sim_score < self.adjust_threshold(similarities):
                 split_indices.append(idx)
 
         return split_indices, similarities
 
     def __call__(self, docs: List[str]):
+        # Main method to split the documents
         logger.info(f"Splitting {len(docs)} documents")
         encoded_docs = self.encode_documents(docs)
         split_indices, similarities = self.calculate_dynamic_context_similarity(
@@ -118,6 +108,7 @@ def __call__(self, docs: List[str]):
         )
         splits = []
 
+        # Create DocumentSplit objects for each identified split
         last_idx = 0
         for idx in split_indices:
             if idx == 0:

From 39266c6469cf51c20d7cf4251282411128f33e46 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 16 Feb 2024 17:06:43 +0200
Subject: [PATCH 03/14] feat: Rolling window splitter

---
 semantic_router/index/base.py                 |   8 +-
 semantic_router/index/local.py                |  12 +-
 semantic_router/index/pinecone.py             |  28 +--
 semantic_router/layer.py                      |  12 +-
 semantic_router/splitters/base.py             |  26 +-
 .../splitters/dynamic_cumulative.py           | 135 ----------
 semantic_router/splitters/rolling_window.py   | 235 ++++++++++++++++++
 tests/unit/test_layer.py                      |   7 +-
 8 files changed, 289 insertions(+), 174 deletions(-)
 delete mode 100644 semantic_router/splitters/dynamic_cumulative.py
 create mode 100644 semantic_router/splitters/rolling_window.py

diff --git a/semantic_router/index/base.py b/semantic_router/index/base.py
index 77053ef0..5271b897 100644
--- a/semantic_router/index/base.py
+++ b/semantic_router/index/base.py
@@ -1,6 +1,7 @@
-from pydantic.v1 import BaseModel
-from typing import Any, List, Tuple, Optional, Union
+from typing import Any, List, Optional, Tuple, Union
+
 import numpy as np
+from pydantic.v1 import BaseModel
 
 
 class BaseIndex(BaseModel):
@@ -36,7 +37,8 @@ def delete(self, route_name: str):
 
     def describe(self) -> dict:
         """
-        Returns a dictionary with index details such as type, dimensions, and total vector count.
+        Returns a dictionary with index details such as type, dimensions, and total
+        vector count.
         This method should be implemented by subclasses.
         """
         raise NotImplementedError("This method should be implemented by subclasses.")
diff --git a/semantic_router/index/local.py b/semantic_router/index/local.py
index 058ee2bc..0c2a7140 100644
--- a/semantic_router/index/local.py
+++ b/semantic_router/index/local.py
@@ -1,7 +1,9 @@
+from typing import List, Optional, Tuple
+
 import numpy as np
-from typing import List, Tuple, Optional
-from semantic_router.linear import similarity_matrix, top_scores
+
 from semantic_router.index.base import BaseIndex
+from semantic_router.linear import similarity_matrix, top_scores
 
 
 class LocalIndex(BaseIndex):
@@ -14,7 +16,8 @@ def __init__(
         super().__init__(index=index, routes=routes, utterances=utterances)
         self.type = "local"
 
-    class Config:  # Stop pydantic from complaining about  Optional[np.ndarray] type hints.
+    class Config:
+        # Stop pydantic from complaining about Optional[np.ndarray]type hints.
         arbitrary_types_allowed = True
 
     def add(
@@ -78,7 +81,8 @@ def delete(self, route_name: str):
             self.utterances = np.delete(self.utterances, delete_idx, axis=0)
         else:
             raise ValueError(
-                "Attempted to delete route records but either index, routes or utterances is None."
+                "Attempted to delete route records but either index, routes or "
+                "utterances is None."
             )
 
     def delete_index(self):
diff --git a/semantic_router/index/pinecone.py b/semantic_router/index/pinecone.py
index a6492226..0fa6137d 100644
--- a/semantic_router/index/pinecone.py
+++ b/semantic_router/index/pinecone.py
@@ -1,12 +1,14 @@
-from pydantic.v1 import BaseModel, Field
-import requests
-import time
 import hashlib
 import os
-from typing import Any, Dict, List, Tuple, Optional, Union
+import time
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import requests
+from pydantic.v1 import BaseModel, Field
+
 from semantic_router.index.base import BaseIndex
 from semantic_router.utils.logger import logger
-import numpy as np
 
 
 def clean_route_name(route_name: str) -> str:
@@ -21,9 +23,9 @@ class PineconeRecord(BaseModel):
 
     def __init__(self, **data):
         super().__init__(**data)
-        # generate ID based on route name and utterances to prevent duplicates
         clean_route = clean_route_name(self.route)
-        utterance_id = hashlib.md5(self.utterance.encode()).hexdigest()
+        # Use SHA-256 for a more secure hash
+        utterance_id = hashlib.sha256(self.utterance.encode()).hexdigest()
         self.id = f"{clean_route}#{utterance_id}"
 
     def to_dict(self):
@@ -48,14 +50,10 @@ class PineconeIndex(BaseIndex):
 
     def __init__(self, **data):
         super().__init__(**data)
-        self._initialize_client()
-
-        self.type = "pinecone"
-        self.client = self._initialize_client()
-        if not self.index_name.startswith(self.index_prefix):
-            self.index_name = f"{self.index_prefix}{self.index_name}"
-        # Create or connect to an existing Pinecone index
-        self.index = self._init_index()
+        clean_route = clean_route_name(self.route)
+        # Use SHA-256 for a more secure hash
+        utterance_id = hashlib.sha256(self.utterance.encode()).hexdigest()
+        self.id = f"{clean_route}#{utterance_id}"
 
     def _initialize_client(self, api_key: Optional[str] = None):
         try:
diff --git a/semantic_router/layer.py b/semantic_router/layer.py
index 1e8a8130..9573aa0a 100644
--- a/semantic_router/layer.py
+++ b/semantic_router/layer.py
@@ -1,3 +1,4 @@
+import importlib
 import json
 import os
 import random
@@ -6,19 +7,19 @@
 import numpy as np
 import yaml
 from tqdm.auto import tqdm
-import importlib
 
 from semantic_router.encoders import BaseEncoder, OpenAIEncoder
+from semantic_router.index.base import BaseIndex
+from semantic_router.index.local import LocalIndex
 from semantic_router.llms import BaseLLM, OpenAILLM
 from semantic_router.route import Route
 from semantic_router.schema import Encoder, EncoderType, RouteChoice
 from semantic_router.utils.logger import logger
-from semantic_router.index.base import BaseIndex
-from semantic_router.index.local import LocalIndex
 
 
 def is_valid(layer_config: str) -> bool:
-    """Make sure the given string is json format and contains the 3 keys: ["encoder_name", "encoder_type", "routes"]"""
+    """Make sure the given string is json format and contains the 3 keys:
+    ["encoder_name", "encoder_type", "routes"]"""
     try:
         output_json = json.loads(layer_config)
         required_keys = ["encoder_name", "encoder_type", "routes"]
@@ -209,7 +210,8 @@ def check_for_matching_routes(self, top_class: str) -> Optional[Route]:
         matching_routes = [route for route in self.routes if route.name == top_class]
         if not matching_routes:
             logger.error(
-                f"No route found with name {top_class}. Check to see if any Routes have been defined."
+                f"No route found with name {top_class}. Check to see if any Routes "
+                "have been defined."
             )
             return None
         return matching_routes[0]
diff --git a/semantic_router/splitters/base.py b/semantic_router/splitters/base.py
index c4df5785..c64d384c 100644
--- a/semantic_router/splitters/base.py
+++ b/semantic_router/splitters/base.py
@@ -1,10 +1,11 @@
+from itertools import cycle
 from typing import List
 
 from pydantic.v1 import BaseModel
+from termcolor import colored
 
 from semantic_router.encoders import BaseEncoder
 from semantic_router.schema import DocumentSplit
-from termcolor import colored
 
 
 class BaseSplitter(BaseModel):
@@ -12,14 +13,21 @@ class BaseSplitter(BaseModel):
     encoder: BaseEncoder
     score_threshold: float
 
-    def __call__(self, docs: List[str]) -> List[List[float]]:
+    def __call__(self, docs: List[str]) -> List[DocumentSplit]:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def print_colored_splits(self, splits: List[DocumentSplit]):
-        colors = ["red", "green", "blue", "magenta", "cyan"]
+    def print_splits(self, splits: list[DocumentSplit]):
+        colors = cycle(["red", "green", "blue", "magenta", "cyan"])
         for i, split in enumerate(splits):
-            color = colors[i % len(colors)]
-            for doc in split.docs:
-                print(colored(doc, color))  # type: ignore
-            print("Triggered score:", split.triggered_score)
-            print("\n")
+            triggered_text = (
+                "Triggered " + format(split.triggered_score, ".2f")
+                if split.triggered_score
+                else "Not Triggered"
+            )
+            header = f"Split {i+1} - ({triggered_text})"
+            if split.triggered_score:
+                print(colored(header, "red"))
+            else:
+                print(colored(header, "blue"))
+            print(colored(split.docs, next(colors)))  # type: ignore
+            print("\n" + "-" * 50 + "\n")
diff --git a/semantic_router/splitters/dynamic_cumulative.py b/semantic_router/splitters/dynamic_cumulative.py
deleted file mode 100644
index f1b35bdf..00000000
--- a/semantic_router/splitters/dynamic_cumulative.py
+++ /dev/null
@@ -1,135 +0,0 @@
-from typing import List
-
-import numpy as np
-
-from semantic_router.encoders import BaseEncoder
-from semantic_router.schema import DocumentSplit
-from semantic_router.splitters.base import BaseSplitter
-from semantic_router.utils.logger import logger
-
-
-class DynamicCumulativeSplitter(BaseSplitter):
-    """
-    Splits documents dynamically based on the cumulative similarity of document
-    embeddings, adjusting thresholds and window sizes based on recent similarities.
-    """
-
-    def __init__(
-        self,
-        encoder: BaseEncoder,
-        name: str = "dynamic_cumulative_similarity_splitter",
-        score_threshold: float = 0.9,
-    ):
-        super().__init__(name=name, encoder=encoder, score_threshold=score_threshold)
-        # Log the initialization details
-        logger.info(
-            f"Initialized {self.name} with score threshold: {self.score_threshold}"
-        )
-
-    def encode_documents(self, docs: List[str]) -> np.ndarray:
-        # Encode the documents using the provided encoder and return as a numpy array
-        encoded_docs = self.encoder(docs)
-        logger.info(f"Encoded {len(docs)} documents")
-        return np.array(encoded_docs)
-
-    def adjust_threshold(self, similarities):
-        # Adjust the similarity threshold based on recent similarities
-        if len(similarities) <= 5:
-            # If not enough data, return the default score threshold
-            return self.score_threshold
-
-        # Calculate mean and standard deviation of the last 5 similarities
-        recent_similarities = similarities[-5:]
-        mean_similarity, std_dev_similarity = np.mean(recent_similarities), np.std(
-            recent_similarities
-        )
-
-        # Calculate the change in mean and standard deviation if enough data is
-        # available
-        delta_mean = delta_std_dev = 0
-        if len(similarities) > 10:
-            previous_similarities = similarities[-10:-5]
-            delta_mean = mean_similarity - np.mean(previous_similarities)
-            delta_std_dev = std_dev_similarity - np.std(previous_similarities)
-
-        # Adjust the threshold based on the calculated metrics
-        adjustment_factor = std_dev_similarity + abs(delta_mean) + abs(delta_std_dev)
-        adjusted_threshold = mean_similarity - adjustment_factor
-        dynamic_lower_bound = max(0.2, 0.2 + delta_mean - delta_std_dev)
-        min_split_threshold = 0.3
-
-        # Ensure the new threshold is within a sensible range
-        new_threshold = max(
-            np.clip(adjusted_threshold, dynamic_lower_bound, self.score_threshold),
-            min_split_threshold,
-        )
-        logger.debug(
-            f"Adjusted threshold to {new_threshold}, with dynamic lower "
-            f"bound {dynamic_lower_bound}"
-        )
-        return new_threshold
-
-    def calculate_dynamic_context_similarity(self, encoded_docs):
-        # Calculate the dynamic context similarity to determine split indices
-        split_indices, similarities = [0], []
-        dynamic_window_size = 5  # Initial window size
-        norms = np.linalg.norm(
-            encoded_docs, axis=1
-        )  # Pre-calculate norms for efficiency
-
-        for idx in range(1, len(encoded_docs)):
-            # Adjust window size based on the standard deviation of recent similarities
-            if len(similarities) > 10:
-                std_dev_recent = np.std(similarities[-10:])
-                dynamic_window_size = 5 if std_dev_recent < 0.05 else 10
-
-            # Calculate the similarity for the current document
-            window_start = max(0, idx - dynamic_window_size)
-            cumulative_context = np.mean(encoded_docs[window_start:idx], axis=0)
-            cumulative_norm = np.linalg.norm(cumulative_context)
-            curr_sim_score = np.dot(cumulative_context, encoded_docs[idx]) / (
-                cumulative_norm * norms[idx] + 1e-10
-            )
-
-            similarities.append(curr_sim_score)
-            # If the similarity is below the dynamically adjusted threshold,
-            # mark a new split
-            if curr_sim_score < self.adjust_threshold(similarities):
-                split_indices.append(idx)
-
-        return split_indices, similarities
-
-    def __call__(self, docs: List[str]):
-        # Main method to split the documents
-        logger.info(f"Splitting {len(docs)} documents")
-        encoded_docs = self.encode_documents(docs)
-        split_indices, similarities = self.calculate_dynamic_context_similarity(
-            encoded_docs
-        )
-        splits = []
-
-        # Create DocumentSplit objects for each identified split
-        last_idx = 0
-        for idx in split_indices:
-            if idx == 0:
-                continue
-            splits.append(
-                DocumentSplit(
-                    docs=docs[last_idx:idx],
-                    is_triggered=(idx - last_idx > 1),
-                    triggered_score=(
-                        similarities[idx - 1] if idx - 1 < len(similarities) else None
-                    ),
-                )
-            )
-            last_idx = idx
-        splits.append(
-            DocumentSplit(
-                docs=docs[last_idx:],
-                is_triggered=(len(docs) - last_idx > 1),
-                triggered_score=similarities[-1] if similarities else None,
-            )
-        )
-        logger.info(f"Completed splitting documents into {len(splits)} splits")
-
-        return splits
diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
new file mode 100644
index 00000000..57bf4733
--- /dev/null
+++ b/semantic_router/splitters/rolling_window.py
@@ -0,0 +1,235 @@
+from typing import List
+
+import numpy as np
+from matplotlib import pyplot as plt
+from nltk.tokenize import word_tokenize
+
+from semantic_router.schema import DocumentSplit
+from semantic_router.splitters.base import BaseSplitter
+from semantic_router.utils.logger import logger
+
+
+class RollingWindowSplitter(BaseSplitter):
+    """
+    A splitter that divides documents into segments based on semantic similarity
+    using a rolling window approach.
+    It adjusts the similarity threshold dynamically.
+    Splitting is based:
+    - On the similarity threshold
+    - On the maximum token limit for a split
+
+    Attributes:
+        encoder (Callable): A function to encode documents into semantic vectors.
+        score_threshold (float): Initial threshold for similarity scores to decide
+        splits.
+        window_size (int): Size of the rolling window to calculate document context.
+        plot_splits (bool): Whether to plot the similarity scores and splits for
+        visualization.
+        min_split_tokens (int): Minimum number of tokens for a valid document split.
+        max_split_tokens (int): Maximum number of tokens a split can contain.
+        split_tokens_tolerance (int): Tolerance in token count to still consider a split
+        valid.
+        threshold_step_size (float): Step size to adjust the similarity threshold during
+        optimization.
+    """
+
+    def __init__(
+        self,
+        encoder,
+        score_threshold=0.3,
+        window_size=5,
+        plot_splits=False,
+        min_split_tokens=100,
+        max_split_tokens=300,
+        split_tokens_tolerance=10,
+        threshold_step_size=0.01,
+    ):
+        self.encoder = encoder
+        self.score_threshold = score_threshold
+        self.window_size = window_size
+        self.plot_splits = plot_splits
+        self.min_split_tokens = min_split_tokens
+        self.max_split_tokens = max_split_tokens
+        self.split_tokens_tolerance = split_tokens_tolerance
+        self.threshold_step_size = threshold_step_size
+
+    def encode_documents(self, docs: list[str]) -> np.ndarray:
+        return np.array(self.encoder(docs))
+
+    def find_optimal_threshold(self, docs: list[str], encoded_docs: np.ndarray):
+        logger.info(f"Number of documents for finding optimal threshold: {len(docs)}")
+        token_counts = [len(word_tokenize(doc)) for doc in docs]
+        low, high = 0, 1
+        while low <= high:
+            self.score_threshold = (low + high) / 2
+            similarity_scores = self.calculate_similarity_scores(encoded_docs)
+            split_indices = self.find_split_indices(similarity_scores)
+            average_tokens = np.mean(
+                [
+                    sum(token_counts[start:end])
+                    for start, end in zip(
+                        [0] + split_indices, split_indices + [len(token_counts)]
+                    )
+                ]
+            )
+            if (
+                self.min_split_tokens - self.split_tokens_tolerance
+                <= average_tokens
+                <= self.max_split_tokens + self.split_tokens_tolerance
+            ):
+                break
+            elif average_tokens < self.min_split_tokens:
+                high = self.score_threshold - self.threshold_step_size
+            else:
+                low = self.score_threshold + self.threshold_step_size
+
+    def calculate_similarity_scores(self, encoded_docs: np.ndarray) -> list[float]:
+        raw_similarities = []
+        for idx in range(1, len(encoded_docs)):
+            window_start = max(0, idx - self.window_size)
+            cumulative_context = np.mean(encoded_docs[window_start:idx], axis=0)
+            curr_sim_score = np.dot(cumulative_context, encoded_docs[idx]) / (
+                np.linalg.norm(cumulative_context) * np.linalg.norm(encoded_docs[idx])
+                + 1e-10
+            )
+            raw_similarities.append(curr_sim_score)
+        return raw_similarities
+
+    def find_split_indices(self, similarities: list[float]) -> list[int]:
+        return [
+            idx + 1
+            for idx, sim in enumerate(similarities)
+            if sim < self.score_threshold
+        ]
+
+    def split_documents(
+        self, docs: list[str], split_indices: list[int], similarities: list[float]
+    ) -> list[DocumentSplit]:
+        """
+        This method iterates through each document, appending it to the current split
+        until it either reaches a split point (determined by split_indices) or exceeds
+        the maximum token limit for a split (self.max_split_tokens).
+        When a document causes the current token count to exceed this limit,
+        or when a split point is reached and the minimum token requirement is met,
+        the current split is finalized and added to the list of splits.
+        """
+        token_counts = [len(word_tokenize(doc)) for doc in docs]
+        splits: List[DocumentSplit] = []
+        current_split: List[str] = []
+        current_tokens_count = 0
+
+        for doc_idx, doc in enumerate(docs):
+            doc_token_count = token_counts[doc_idx]
+            # Check if current document causes token count to exceed max limit
+            if (
+                current_tokens_count + doc_token_count > self.max_split_tokens
+                and current_tokens_count >= self.min_split_tokens
+            ):
+                splits.append(
+                    DocumentSplit(docs=current_split.copy(), is_triggered=True)
+                )
+                logger.info(
+                    f"Split finalized with {current_tokens_count} tokens due to "
+                    f"exceeding token limit of {self.max_split_tokens}."
+                )
+                current_split, current_tokens_count = [], 0
+
+            current_split.append(doc)
+            current_tokens_count += doc_token_count
+
+            # Check if current index is a split point based on similarity
+            if doc_idx + 1 in split_indices or doc_idx == len(docs) - 1:
+                if current_tokens_count >= self.min_split_tokens:
+                    if doc_idx < len(similarities):
+                        triggered_score = similarities[doc_idx]
+                        splits.append(
+                            DocumentSplit(
+                                docs=current_split.copy(),
+                                is_triggered=True,
+                                triggered_score=triggered_score,
+                            )
+                        )
+                        logger.info(
+                            f"Split finalized with {current_tokens_count} tokens due to"
+                            f" similarity score {triggered_score:.2f}."
+                        )
+                    else:
+                        # This case handles the end of the document list
+                        # where there's no similarity score
+                        splits.append(
+                            DocumentSplit(docs=current_split.copy(), is_triggered=False)
+                        )
+                        logger.info(
+                            f"Split finalized with {current_tokens_count} tokens "
+                            "at the end of the document list."
+                        )
+                    current_split, current_tokens_count = [], 0
+
+        # Ensure any remaining documents are included in the final token count
+        if current_split:
+            splits.append(DocumentSplit(docs=current_split.copy(), is_triggered=False))
+            logger.info(
+                f"Final split added with {current_tokens_count} tokens "
+                "due to remaining documents."
+            )
+
+        # Validation
+        original_token_count = sum(token_counts)
+        split_token_count = sum(
+            [len(word_tokenize(doc)) for split in splits for doc in split.docs]
+        )
+        logger.debug(
+            f"Original Token Count: {original_token_count}, "
+            f"Split Token Count: {split_token_count}"
+        )
+
+        if original_token_count != split_token_count:
+            logger.error(
+                f"Token count mismatch: {original_token_count} != {split_token_count}"
+            )
+            for i, split in enumerate(splits):
+                split_token_count = sum([len(word_tokenize(doc)) for doc in split.docs])
+                logger.error(f"Split {i} Token Count: {split_token_count}")
+            raise ValueError(
+                f"Token count mismatch: {original_token_count} != {split_token_count}"
+            )
+
+        return splits
+
+    # TODO: fix to plot split based on token count and final split
+    def plot_similarity_scores(
+        self, similarities: list[float], split_indices: list[int]
+    ):
+        if not self.plot_splits:
+            return
+        plt.figure(figsize=(12, 6))
+        plt.plot(similarities, label="Similarity Scores", marker="o")
+        for split_index in split_indices:
+            plt.axvline(
+                x=split_index - 1,
+                color="r",
+                linestyle="--",
+                label="Split" if split_index == split_indices[0] else "",
+            )
+        plt.axhline(
+            y=self.score_threshold,
+            color="g",
+            linestyle="-.",
+            label="Threshold Similarity Score",
+        )
+        plt.xlabel("Document Segment Index")
+        plt.ylabel("Similarity Score")
+        plt.title(f"Threshold: {self.score_threshold}", loc="right", fontsize=10)
+        plt.suptitle("Document Similarity Scores", fontsize=14)
+        plt.legend()
+        plt.show()
+
+    def __call__(self, docs: list[str]) -> list[DocumentSplit]:
+        encoded_docs = self.encode_documents(docs)
+        self.find_optimal_threshold(docs, encoded_docs)
+        similarities = self.calculate_similarity_scores(encoded_docs)
+        split_indices = self.find_split_indices(similarities=similarities)
+        splits = self.split_documents(docs, split_indices, similarities)
+
+        self.plot_similarity_scores(similarities, split_indices)
+        return splits
diff --git a/tests/unit/test_layer.py b/tests/unit/test_layer.py
index 88a4679a..113a5d4a 100644
--- a/tests/unit/test_layer.py
+++ b/tests/unit/test_layer.py
@@ -6,8 +6,8 @@
 
 from semantic_router.encoders import BaseEncoder, CohereEncoder, OpenAIEncoder
 from semantic_router.layer import LayerConfig, RouteLayer
-from semantic_router.route import Route
 from semantic_router.llms.base import BaseLLM
+from semantic_router.route import Route
 
 
 def mock_encoder_call(utterances):
@@ -399,10 +399,11 @@ def test_from_file_with_llm(self, tmp_path):
         # Load the LayerConfig from the temporary file
         layer_config = LayerConfig.from_file(str(config_path))
 
-        # Using BaseLLM because trying to create a useable Mock LLM is a nightmare.
+        # Using BaseLLM because trying to create a usable Mock LLM is a nightmare.
         assert isinstance(
             layer_config.routes[0].llm, BaseLLM
-        ), "LLM should be instantiated and associated with the route based on the config"
+        ), "LLM should be instantiated and associated with the route based on the "
+        "config"
         assert (
             layer_config.routes[0].llm.name == "fake-model-v1"
         ), "LLM instance should have the 'name' attribute set correctly"

From ab0578c68ff13bde926db9fe8cedb4fb61102dfa Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 16 Feb 2024 17:08:26 +0200
Subject: [PATCH 04/14] chore: Encoder

---
 semantic_router/splitters/rolling_window.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
index 57bf4733..ad5c568e 100644
--- a/semantic_router/splitters/rolling_window.py
+++ b/semantic_router/splitters/rolling_window.py
@@ -3,6 +3,7 @@
 import numpy as np
 from matplotlib import pyplot as plt
 from nltk.tokenize import word_tokenize
+from semantic_router.encoders.base import BaseEncoder
 
 from semantic_router.schema import DocumentSplit
 from semantic_router.splitters.base import BaseSplitter
@@ -35,7 +36,7 @@ class RollingWindowSplitter(BaseSplitter):
 
     def __init__(
         self,
-        encoder,
+        encoder: BaseEncoder,
         score_threshold=0.3,
         window_size=5,
         plot_splits=False,

From c1beddfe8b6e1b454ca6ce3ac049395a3cc013e8 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 09:52:44 +0200
Subject: [PATCH 05/14] feat: RollingWindowSplitter example

---
 docs/examples/text_semantic_split.ipynb     |  179 ++
 poetry.lock                                 | 1983 ++++++++++++++++---
 pyproject.toml                              |    5 +
 semantic_router/schema.py                   |   10 +-
 semantic_router/splitters/__init__.py       |   11 +
 semantic_router/splitters/base.py           |    4 +-
 semantic_router/splitters/rolling_window.py |  341 ++--
 semantic_router/splitters/utils.py          |   79 +
 8 files changed, 2236 insertions(+), 376 deletions(-)
 create mode 100644 docs/examples/text_semantic_split.ipynb
 create mode 100644 semantic_router/splitters/utils.py

diff --git a/docs/examples/text_semantic_split.ipynb b/docs/examples/text_semantic_split.ipynb
new file mode 100644
index 00000000..1d2af3dd
--- /dev/null
+++ b/docs/examples/text_semantic_split.ipynb
@@ -0,0 +1,179 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = '''\n",
+    "In a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\"\n",
+    "The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor.\n",
+    "One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth. While the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously.\n",
+    "Discussions on the platform draw attention to a variety of issues that those who earn money the hard way might face. For example, they are described as likely having to work overtime, forgo time off for illness or rest, and maintain an unyielding dedication to their occupation, which often results in a never-ending cycle of work without any perceived progression in their lives.\n",
+    "Another tweet that captures this sentiment reads, \"Drowning in more work and poverty despite trying harder and harder,\" pointing to a sense of despair and dissatisfaction that comes with work that is both disproportionately demanding and inadequately rewarding. Critics also note how the pursuit of hard-earned money could potentially create physical and mental health risks due to the unrelenting pressure and stress that these jobs might impose.\n",
+    "Conversely, those in favor of earning money with less difficulty contend that it's crucial to harness one's strengths and passions to create opportunities that yield financial success without the need for excessive labor. The debate revolves around the concept that people should seek out ways to work smarter, not harder, especially if it means a healthier and more fulfilling lifestyle.\n",
+    "In fact, the notion of a \"vicious cycle,\" often attributed to those chasing hard-earned money, is juxtaposed with an idealized image of someone operating in their zone of excellence. Confidently focused on their strengths, such individuals are depicted as enjoying a more relaxed and less stressful work environment, one in which they can thrive without the need for never-ending overtime or self-sacrifice.\n",
+    "Some tweets even extend this sentiment to the broader socio-economic context, observing how wealth is not merely derived from manual labor or high-paying positions requiring extraordinary work hours. The tweets emphasize the importance of cultivating an entrepreneurial spirit and a penchant for innovative thinking, especially in the modern digital age.\n",
+    "One user writes, \"Too hard-earned money isn't worth it. Learn how to make money using your brain, not your body,\" while another suggests, \"Love will flow towards those who are not lacking in love, and money will flow towards those who are not lacking in money!\"\n",
+    "While some of the discussions take a somewhat passive-aggressive view, others acknowledge that financial security and comfort might not always be possible for everyone. In a more realistic tone, a user remarks, \"If life were so easy that diligence led to wealth, then the world's richest person would be the best worker bee. But that's not the case.\" This acknowledgment underscores the complexities of the economy and the role that factors like luck, connections, and a rapidly evolving job market can play in financial success.\n",
+    "Some users are quick to criticize the notion that earning money the hard way should be avoided, with one tweet expressing, \"The person who advises you to avoid hard-earned money is likely a scammer who profits off providing emotional value in exchange for exploitation.\" Others argue that while it's essential to find enjoyment and fulfillment in one's work, it's crucial not to shun or belittle those who choose to work in physically demanding or high-paying industries.\n",
+    "Overall, the Weibo discussions offer a fascinating insight into the complexities of the modern Chinese labor market and the work-life balance that people strive to achieve. As in many countries, striking the right balance between work and play is an ongoing challenge for many Chinese citizens. However, the conversations on Weibo signal an increasing awareness of the importance of finding meaningful, fulfilling, and financially rewarding work that doesn't necessitate excessive sacrifice or sufferance.\n",
+    "In the end, as one user succinctly puts it, \"Make sure you're earning your money in a way that brings you joy and satisfaction. That's the only way to ensure that your life doesn't become a never-ending cycle of hard work without any tangible progress.\"\n",
+    "In this context, social media discussions focusing on the trials and tribulations of earning money serve not only as an outlet for venting frustrations but also as a means of promoting dialogue and shared understanding about the challenges faced by workers across all industries. These virtual conversations sparked by tweets and in-depth discussions likely resonate with a wide swath of Chinese citizens struggling to navigate the complexities of balancing a career that pays well with one that brings them joy, fulfillment, and a sense of purpose.\n",
+    "As the discussions on Weibo continue to evolve and unfold, it is evident that the discourse around work, money, and life satisfaction holds the potential to inspire meaningful change and shift societal attitudes towards a more holistic, balanced, and humane understanding of success and prosperity.\n",
+    "---\n",
+    "Note: The translated tweets and user quotes from Chinese to English were used as the foundation for the long-form news article. The author tried to maintain the integrity of the original content in the translation while adapting it to fit a journalistic format. No inaccuracies were introduced during translation, and the opinion-based nature of the original content was preserved while maintaining objectivity.\n",
+    "Heart count: 0/2\n",
+    "Note: The author did not include any Chinese characters in the final response.\n",
+    "Collapse\n",
+    "'''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from semantic_router.splitters import RollingWindowSplitter\n",
+    "from semantic_router.encoders import OpenAIEncoder\n",
+    "\n",
+    "splitter = RollingWindowSplitter(\n",
+    "    encoder=OpenAIEncoder(),\n",
+    "    min_split_tokens=50,\n",
+    "    max_split_tokens=300,\n",
+    "    window_size=5, # sentences\n",
+    "    plot_splits=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[33m2024-02-23 09:50:04 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881277932028191\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781277932028191\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.8687934834140205\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.8587934834140205\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Final optimal threshold: 0.8687934834140205\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "splits = splitter([text])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Split 1, tokens 218:\n",
+      "\u001b[31mIn a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\" The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor. One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 2, tokens 262:\n",
+      "\u001b[32mWhile the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously. Discussions on the platform draw attention to a variety of issues that those who earn money the hard way might face. For example, they are described as likely having to work overtime, forgo time off for illness or rest, and maintain an unyielding dedication to their occupation, which often results in a never-ending cycle of work without any perceived progression in their lives. Another tweet that captures this sentiment reads, \"Drowning in more work and poverty despite trying harder and harder,\" pointing to a sense of despair and dissatisfaction that comes with work that is both disproportionately demanding and inadequately rewarding. Critics also note how the pursuit of hard-earned money could potentially create physical and mental health risks due to the unrelenting pressure and stress that these jobs might impose. Conversely, those in favor of earning money with less difficulty contend that it's crucial to harness one's strengths and passions to create opportunities that yield financial success without the need for excessive labor. The debate revolves around the concept that people should seek out ways to work smarter, not harder, especially if it means a healthier and more fulfilling lifestyle.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 3, tokens 137:\n",
+      "\u001b[34mIn fact, the notion of a \"vicious cycle,\" often attributed to those chasing hard-earned money, is juxtaposed with an idealized image of someone operating in their zone of excellence. Confidently focused on their strengths, such individuals are depicted as enjoying a more relaxed and less stressful work environment, one in which they can thrive without the need for never-ending overtime or self-sacrifice. Some tweets even extend this sentiment to the broader socio-economic context, observing how wealth is not merely derived from manual labor or high-paying positions requiring extraordinary work hours. The tweets emphasize the importance of cultivating an entrepreneurial spirit and a penchant for innovative thinking, especially in the modern digital age.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 4, tokens 249:\n",
+      "\u001b[35mOne user writes, \"Too hard-earned money isn't worth it. Learn how to make money using your brain, not your body,\" while another suggests, \"Love will flow towards those who are not lacking in love, and money will flow towards those who are not lacking in money!\" While some of the discussions take a somewhat passive-aggressive view, others acknowledge that financial security and comfort might not always be possible for everyone. In a more realistic tone, a user remarks, \"If life were so easy that diligence led to wealth, then the world's richest person would be the best worker bee. But that's not the case.\" This acknowledgment underscores the complexities of the economy and the role that factors like luck, connections, and a rapidly evolving job market can play in financial success. Some users are quick to criticize the notion that earning money the hard way should be avoided, with one tweet expressing, \"The person who advises you to avoid hard-earned money is likely a scammer who profits off providing emotional value in exchange for exploitation.\" Others argue that while it's essential to find enjoyment and fulfillment in one's work, it's crucial not to shun or belittle those who choose to work in physically demanding or high-paying industries.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 5, tokens 117:\n",
+      "\u001b[31mOverall, the Weibo discussions offer a fascinating insight into the complexities of the modern Chinese labor market and the work-life balance that people strive to achieve. As in many countries, striking the right balance between work and play is an ongoing challenge for many Chinese citizens. However, the conversations on Weibo signal an increasing awareness of the importance of finding meaningful, fulfilling, and financially rewarding work that doesn't necessitate excessive sacrifice or sufferance. In the end, as one user succinctly puts it, \"Make sure you're earning your money in a way that brings you joy and satisfaction.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 6, tokens 171:\n",
+      "\u001b[32mThat's the only way to ensure that your life doesn't become a never-ending cycle of hard work without any tangible progress.\" In this context, social media discussions focusing on the trials and tribulations of earning money serve not only as an outlet for venting frustrations but also as a means of promoting dialogue and shared understanding about the challenges faced by workers across all industries. These virtual conversations sparked by tweets and in-depth discussions likely resonate with a wide swath of Chinese citizens struggling to navigate the complexities of balancing a career that pays well with one that brings them joy, fulfillment, and a sense of purpose. As the discussions on Weibo continue to evolve and unfold, it is evident that the discourse around work, money, and life satisfaction holds the potential to inspire meaningful change and shift societal attitudes towards a more holistic, balanced, and humane understanding of success and prosperity.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 7, tokens 72:\n",
+      "\u001b[34m--- Note: The translated tweets and user quotes from Chinese to English were used as the foundation for the long-form news article. The author tried to maintain the integrity of the original content in the translation while adapting it to fit a journalistic format. No inaccuracies were introduced during translation, and the opinion-based nature of the original content was preserved while maintaining objectivity.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 8, tokens 23:\n",
+      "\u001b[35mHeart count: 0/2 Note: The author did not include any Chinese characters in the final response. Collapse\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from semantic_router.splitters.utils import plot_splits\n",
+    "\n",
+    "plot_splits(splits)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/poetry.lock b/poetry.lock
index ef8400e5..c728f42f 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -213,6 +213,27 @@ files = [
     {file = "backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba"},
 ]
 
+[[package]]
+name = "beautifulsoup4"
+version = "4.12.3"
+description = "Screen-scraping library"
+optional = true
+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 = "black"
 version = "23.12.1"
@@ -334,6 +355,17 @@ files = [
 [package.dependencies]
 pycparser = "*"
 
+[[package]]
+name = "chardet"
+version = "5.2.0"
+description = "Universal encoding detector for Python 3"
+optional = true
+python-versions = ">=3.7"
+files = [
+    {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"},
+    {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"},
+]
+
 [[package]]
 name = "charset-normalizer"
 version = "3.3.2"
@@ -449,13 +481,13 @@ colorama = {version = "*", markers = "platform_system == \"Windows\""}
 
 [[package]]
 name = "cohere"
-version = "4.45"
+version = "4.47"
 description = "Python SDK for the Cohere API"
 optional = false
 python-versions = ">=3.8,<4.0"
 files = [
-    {file = "cohere-4.45-py3-none-any.whl", hash = "sha256:bdaa2e5e1c64cf3b1d55caf9d483a33fa8eafed731a999fb0934ae12c0638b75"},
-    {file = "cohere-4.45.tar.gz", hash = "sha256:63b21b2dc3abd718b18cae726a69d1b096a34eb59f3331c20469fd0df1672816"},
+    {file = "cohere-4.47-py3-none-any.whl", hash = "sha256:8b96a1ab57713eceffb4ffd58bf647055676fb741a4e5153c14296f9814c77fa"},
+    {file = "cohere-4.47.tar.gz", hash = "sha256:d689212079c1a545bd497b143cff7aa5632831fa6cf41bf7acc93b4a6effb839"},
 ]
 
 [package.dependencies]
@@ -528,6 +560,69 @@ traitlets = ">=4"
 [package.extras]
 test = ["pytest"]
 
+[[package]]
+name = "contourpy"
+version = "1.2.0"
+description = "Python library for calculating contours of 2D quadrilateral grids"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "contourpy-1.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0274c1cb63625972c0c007ab14dd9ba9e199c36ae1a231ce45d725cbcbfd10a8"},
+    {file = "contourpy-1.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ab459a1cbbf18e8698399c595a01f6dcc5c138220ca3ea9e7e6126232d102bb4"},
+    {file = "contourpy-1.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fdd887f17c2f4572ce548461e4f96396681212d858cae7bd52ba3310bc6f00f"},
+    {file = "contourpy-1.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5d16edfc3fc09968e09ddffada434b3bf989bf4911535e04eada58469873e28e"},
+    {file = "contourpy-1.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c203f617abc0dde5792beb586f827021069fb6d403d7f4d5c2b543d87edceb9"},
+    {file = "contourpy-1.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b69303ceb2e4d4f146bf82fda78891ef7bcd80c41bf16bfca3d0d7eb545448aa"},
+    {file = "contourpy-1.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:884c3f9d42d7218304bc74a8a7693d172685c84bd7ab2bab1ee567b769696df9"},
+    {file = "contourpy-1.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4a1b1208102be6e851f20066bf0e7a96b7d48a07c9b0cfe6d0d4545c2f6cadab"},
+    {file = "contourpy-1.2.0-cp310-cp310-win32.whl", hash = "sha256:34b9071c040d6fe45d9826cbbe3727d20d83f1b6110d219b83eb0e2a01d79488"},
+    {file = "contourpy-1.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:bd2f1ae63998da104f16a8b788f685e55d65760cd1929518fd94cd682bf03e41"},
+    {file = "contourpy-1.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:dd10c26b4eadae44783c45ad6655220426f971c61d9b239e6f7b16d5cdaaa727"},
+    {file = "contourpy-1.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5c6b28956b7b232ae801406e529ad7b350d3f09a4fde958dfdf3c0520cdde0dd"},
+    {file = "contourpy-1.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ebeac59e9e1eb4b84940d076d9f9a6cec0064e241818bcb6e32124cc5c3e377a"},
+    {file = "contourpy-1.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:139d8d2e1c1dd52d78682f505e980f592ba53c9f73bd6be102233e358b401063"},
+    {file = "contourpy-1.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1e9dc350fb4c58adc64df3e0703ab076f60aac06e67d48b3848c23647ae4310e"},
+    {file = "contourpy-1.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18fc2b4ed8e4a8fe849d18dce4bd3c7ea637758c6343a1f2bae1e9bd4c9f4686"},
+    {file = "contourpy-1.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:16a7380e943a6d52472096cb7ad5264ecee36ed60888e2a3d3814991a0107286"},
+    {file = "contourpy-1.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8d8faf05be5ec8e02a4d86f616fc2a0322ff4a4ce26c0f09d9f7fb5330a35c95"},
+    {file = "contourpy-1.2.0-cp311-cp311-win32.whl", hash = "sha256:67b7f17679fa62ec82b7e3e611c43a016b887bd64fb933b3ae8638583006c6d6"},
+    {file = "contourpy-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:99ad97258985328b4f207a5e777c1b44a83bfe7cf1f87b99f9c11d4ee477c4de"},
+    {file = "contourpy-1.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:575bcaf957a25d1194903a10bc9f316c136c19f24e0985a2b9b5608bdf5dbfe0"},
+    {file = "contourpy-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9e6c93b5b2dbcedad20a2f18ec22cae47da0d705d454308063421a3b290d9ea4"},
+    {file = "contourpy-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:464b423bc2a009088f19bdf1f232299e8b6917963e2b7e1d277da5041f33a779"},
+    {file = "contourpy-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:68ce4788b7d93e47f84edd3f1f95acdcd142ae60bc0e5493bfd120683d2d4316"},
+    {file = "contourpy-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d7d1f8871998cdff5d2ff6a087e5e1780139abe2838e85b0b46b7ae6cc25399"},
+    {file = "contourpy-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e739530c662a8d6d42c37c2ed52a6f0932c2d4a3e8c1f90692ad0ce1274abe0"},
+    {file = "contourpy-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:247b9d16535acaa766d03037d8e8fb20866d054d3c7fbf6fd1f993f11fc60ca0"},
+    {file = "contourpy-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:461e3ae84cd90b30f8d533f07d87c00379644205b1d33a5ea03381edc4b69431"},
+    {file = "contourpy-1.2.0-cp312-cp312-win32.whl", hash = "sha256:1c2559d6cffc94890b0529ea7eeecc20d6fadc1539273aa27faf503eb4656d8f"},
+    {file = "contourpy-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:491b1917afdd8638a05b611a56d46587d5a632cabead889a5440f7c638bc6ed9"},
+    {file = "contourpy-1.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5fd1810973a375ca0e097dee059c407913ba35723b111df75671a1976efa04bc"},
+    {file = "contourpy-1.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:999c71939aad2780f003979b25ac5b8f2df651dac7b38fb8ce6c46ba5abe6ae9"},
+    {file = "contourpy-1.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7caf9b241464c404613512d5594a6e2ff0cc9cb5615c9475cc1d9b514218ae8"},
+    {file = "contourpy-1.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:266270c6f6608340f6c9836a0fb9b367be61dde0c9a9a18d5ece97774105ff3e"},
+    {file = "contourpy-1.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dbd50d0a0539ae2e96e537553aff6d02c10ed165ef40c65b0e27e744a0f10af8"},
+    {file = "contourpy-1.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11f8d2554e52f459918f7b8e6aa20ec2a3bce35ce95c1f0ef4ba36fbda306df5"},
+    {file = "contourpy-1.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ce96dd400486e80ac7d195b2d800b03e3e6a787e2a522bfb83755938465a819e"},
+    {file = "contourpy-1.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6d3364b999c62f539cd403f8123ae426da946e142312a514162adb2addd8d808"},
+    {file = "contourpy-1.2.0-cp39-cp39-win32.whl", hash = "sha256:1c88dfb9e0c77612febebb6ac69d44a8d81e3dc60f993215425b62c1161353f4"},
+    {file = "contourpy-1.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:78e6ad33cf2e2e80c5dfaaa0beec3d61face0fb650557100ee36db808bfa6843"},
+    {file = "contourpy-1.2.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:be16975d94c320432657ad2402f6760990cb640c161ae6da1363051805fa8108"},
+    {file = "contourpy-1.2.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b95a225d4948b26a28c08307a60ac00fb8671b14f2047fc5476613252a129776"},
+    {file = "contourpy-1.2.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0d7e03c0f9a4f90dc18d4e77e9ef4ec7b7bbb437f7f675be8e530d65ae6ef956"},
+    {file = "contourpy-1.2.0.tar.gz", hash = "sha256:171f311cb758de7da13fc53af221ae47a5877be5a0843a9fe150818c51ed276a"},
+]
+
+[package.dependencies]
+numpy = ">=1.20,<2.0"
+
+[package.extras]
+bokeh = ["bokeh", "selenium"]
+docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"]
+mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.6.1)", "types-Pillow"]
+test = ["Pillow", "contourpy[test-no-images]", "matplotlib"]
+test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"]
+
 [[package]]
 name = "coverage"
 version = "7.4.1"
@@ -595,31 +690,134 @@ tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.1
 [package.extras]
 toml = ["tomli"]
 
+[[package]]
+name = "cryptography"
+version = "42.0.4"
+description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "cryptography-42.0.4-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:ffc73996c4fca3d2b6c1c8c12bfd3ad00def8621da24f547626bf06441400449"},
+    {file = "cryptography-42.0.4-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:db4b65b02f59035037fde0998974d84244a64c3265bdef32a827ab9b63d61b18"},
+    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad9c385ba8ee025bb0d856714f71d7840020fe176ae0229de618f14dae7a6e2"},
+    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69b22ab6506a3fe483d67d1ed878e1602bdd5912a134e6202c1ec672233241c1"},
+    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e09469a2cec88fb7b078e16d4adec594414397e8879a4341c6ace96013463d5b"},
+    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3e970a2119507d0b104f0a8e281521ad28fc26f2820687b3436b8c9a5fcf20d1"},
+    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e53dc41cda40b248ebc40b83b31516487f7db95ab8ceac1f042626bc43a2f992"},
+    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:c3a5cbc620e1e17009f30dd34cb0d85c987afd21c41a74352d1719be33380885"},
+    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6bfadd884e7280df24d26f2186e4e07556a05d37393b0f220a840b083dc6a824"},
+    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:01911714117642a3f1792c7f376db572aadadbafcd8d75bb527166009c9f1d1b"},
+    {file = "cryptography-42.0.4-cp37-abi3-win32.whl", hash = "sha256:fb0cef872d8193e487fc6bdb08559c3aa41b659a7d9be48b2e10747f47863925"},
+    {file = "cryptography-42.0.4-cp37-abi3-win_amd64.whl", hash = "sha256:c1f25b252d2c87088abc8bbc4f1ecbf7c919e05508a7e8628e6875c40bc70923"},
+    {file = "cryptography-42.0.4-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:15a1fb843c48b4a604663fa30af60818cd28f895572386e5f9b8a665874c26e7"},
+    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1327f280c824ff7885bdeef8578f74690e9079267c1c8bd7dc5cc5aa065ae52"},
+    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ffb03d419edcab93b4b19c22ee80c007fb2d708429cecebf1dd3258956a563a"},
+    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:1df6fcbf60560d2113b5ed90f072dc0b108d64750d4cbd46a21ec882c7aefce9"},
+    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:44a64043f743485925d3bcac548d05df0f9bb445c5fcca6681889c7c3ab12764"},
+    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:3c6048f217533d89f2f8f4f0fe3044bf0b2090453b7b73d0b77db47b80af8dff"},
+    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:6d0fbe73728c44ca3a241eff9aefe6496ab2656d6e7a4ea2459865f2e8613257"},
+    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:887623fe0d70f48ab3f5e4dbf234986b1329a64c066d719432d0698522749929"},
+    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ce8613beaffc7c14f091497346ef117c1798c202b01153a8cc7b8e2ebaaf41c0"},
+    {file = "cryptography-42.0.4-cp39-abi3-win32.whl", hash = "sha256:810bcf151caefc03e51a3d61e53335cd5c7316c0a105cc695f0959f2c638b129"},
+    {file = "cryptography-42.0.4-cp39-abi3-win_amd64.whl", hash = "sha256:a0298bdc6e98ca21382afe914c642620370ce0470a01e1bef6dd9b5354c36854"},
+    {file = "cryptography-42.0.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5f8907fcf57392cd917892ae83708761c6ff3c37a8e835d7246ff0ad251d9298"},
+    {file = "cryptography-42.0.4-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:12d341bd42cdb7d4937b0cabbdf2a94f949413ac4504904d0cdbdce4a22cbf88"},
+    {file = "cryptography-42.0.4-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1cdcdbd117681c88d717437ada72bdd5be9de117f96e3f4d50dab3f59fd9ab20"},
+    {file = "cryptography-42.0.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0e89f7b84f421c56e7ff69f11c441ebda73b8a8e6488d322ef71746224c20fce"},
+    {file = "cryptography-42.0.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f1e85a178384bf19e36779d91ff35c7617c885da487d689b05c1366f9933ad74"},
+    {file = "cryptography-42.0.4-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d2a27aca5597c8a71abbe10209184e1a8e91c1fd470b5070a2ea60cafec35bcd"},
+    {file = "cryptography-42.0.4-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4e36685cb634af55e0677d435d425043967ac2f3790ec652b2b88ad03b85c27b"},
+    {file = "cryptography-42.0.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f47be41843200f7faec0683ad751e5ef11b9a56a220d57f300376cd8aba81660"},
+    {file = "cryptography-42.0.4.tar.gz", hash = "sha256:831a4b37accef30cccd34fcb916a5d7b5be3cbbe27268a02832c3e450aea39cb"},
+]
+
+[package.dependencies]
+cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""}
+
+[package.extras]
+docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"]
+docstest = ["pyenchant (>=1.6.11)", "readme-renderer", "sphinxcontrib-spelling (>=4.0.1)"]
+nox = ["nox"]
+pep8test = ["check-sdist", "click", "mypy", "ruff"]
+sdist = ["build"]
+ssh = ["bcrypt (>=3.1.5)"]
+test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"]
+test-randomorder = ["pytest-randomly"]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+description = "Composable style cycles"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"},
+    {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"},
+]
+
+[package.extras]
+docs = ["ipython", "matplotlib", "numpydoc", "sphinx"]
+tests = ["pytest", "pytest-cov", "pytest-xdist"]
+
+[[package]]
+name = "dataclasses-json"
+version = "0.6.4"
+description = "Easily serialize dataclasses to and from JSON."
+optional = true
+python-versions = ">=3.7,<4.0"
+files = [
+    {file = "dataclasses_json-0.6.4-py3-none-any.whl", hash = "sha256:f90578b8a3177f7552f4e1a6e535e84293cd5da421fcce0642d49c0d7bdf8df2"},
+    {file = "dataclasses_json-0.6.4.tar.gz", hash = "sha256:73696ebf24936560cca79a2430cbc4f3dd23ac7bf46ed17f38e5e5e7657a6377"},
+]
+
+[package.dependencies]
+marshmallow = ">=3.18.0,<4.0.0"
+typing-inspect = ">=0.4.0,<1"
+
+[[package]]
+name = "dataclasses-json-speakeasy"
+version = "0.5.11"
+description = "Easily serialize dataclasses to and from JSON."
+optional = true
+python-versions = ">=3.7,<4.0"
+files = [
+    {file = "dataclasses_json_speakeasy-0.5.11-py3-none-any.whl", hash = "sha256:ac52a069a01e8521015d682f37849bfdf056c36fa3f81497055e201fec684104"},
+    {file = "dataclasses_json_speakeasy-0.5.11.tar.gz", hash = "sha256:418a987cea2ccf4e4be662f39faa5cc79b47b147c9d1a69d6928d6a27e0c17e8"},
+]
+
+[package.dependencies]
+marshmallow = ">=3.18.0,<4.0.0"
+typing-inspect = ">=0.4.0,<1"
+
 [[package]]
 name = "debugpy"
-version = "1.8.0"
+version = "1.8.1"
 description = "An implementation of the Debug Adapter Protocol for Python"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "debugpy-1.8.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:7fb95ca78f7ac43393cd0e0f2b6deda438ec7c5e47fa5d38553340897d2fbdfb"},
-    {file = "debugpy-1.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef9ab7df0b9a42ed9c878afd3eaaff471fce3fa73df96022e1f5c9f8f8c87ada"},
-    {file = "debugpy-1.8.0-cp310-cp310-win32.whl", hash = "sha256:a8b7a2fd27cd9f3553ac112f356ad4ca93338feadd8910277aff71ab24d8775f"},
-    {file = "debugpy-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:5d9de202f5d42e62f932507ee8b21e30d49aae7e46d5b1dd5c908db1d7068637"},
-    {file = "debugpy-1.8.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:ef54404365fae8d45cf450d0544ee40cefbcb9cb85ea7afe89a963c27028261e"},
-    {file = "debugpy-1.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60009b132c91951354f54363f8ebdf7457aeb150e84abba5ae251b8e9f29a8a6"},
-    {file = "debugpy-1.8.0-cp311-cp311-win32.whl", hash = "sha256:8cd0197141eb9e8a4566794550cfdcdb8b3db0818bdf8c49a8e8f8053e56e38b"},
-    {file = "debugpy-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:a64093656c4c64dc6a438e11d59369875d200bd5abb8f9b26c1f5f723622e153"},
-    {file = "debugpy-1.8.0-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:b05a6b503ed520ad58c8dc682749113d2fd9f41ffd45daec16e558ca884008cd"},
-    {file = "debugpy-1.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c6fb41c98ec51dd010d7ed650accfd07a87fe5e93eca9d5f584d0578f28f35f"},
-    {file = "debugpy-1.8.0-cp38-cp38-win32.whl", hash = "sha256:46ab6780159eeabb43c1495d9c84cf85d62975e48b6ec21ee10c95767c0590aa"},
-    {file = "debugpy-1.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:bdc5ef99d14b9c0fcb35351b4fbfc06ac0ee576aeab6b2511702e5a648a2e595"},
-    {file = "debugpy-1.8.0-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:61eab4a4c8b6125d41a34bad4e5fe3d2cc145caecd63c3fe953be4cc53e65bf8"},
-    {file = "debugpy-1.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:125b9a637e013f9faac0a3d6a82bd17c8b5d2c875fb6b7e2772c5aba6d082332"},
-    {file = "debugpy-1.8.0-cp39-cp39-win32.whl", hash = "sha256:57161629133113c97b387382045649a2b985a348f0c9366e22217c87b68b73c6"},
-    {file = "debugpy-1.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:e3412f9faa9ade82aa64a50b602544efcba848c91384e9f93497a458767e6926"},
-    {file = "debugpy-1.8.0-py2.py3-none-any.whl", hash = "sha256:9c9b0ac1ce2a42888199df1a1906e45e6f3c9555497643a85e0bf2406e3ffbc4"},
-    {file = "debugpy-1.8.0.zip", hash = "sha256:12af2c55b419521e33d5fb21bd022df0b5eb267c3e178f1d374a63a2a6bdccd0"},
+    {file = "debugpy-1.8.1-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:3bda0f1e943d386cc7a0e71bfa59f4137909e2ed947fb3946c506e113000f741"},
+    {file = "debugpy-1.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dda73bf69ea479c8577a0448f8c707691152e6c4de7f0c4dec5a4bc11dee516e"},
+    {file = "debugpy-1.8.1-cp310-cp310-win32.whl", hash = "sha256:3a79c6f62adef994b2dbe9fc2cc9cc3864a23575b6e387339ab739873bea53d0"},
+    {file = "debugpy-1.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:7eb7bd2b56ea3bedb009616d9e2f64aab8fc7000d481faec3cd26c98a964bcdd"},
+    {file = "debugpy-1.8.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:016a9fcfc2c6b57f939673c874310d8581d51a0fe0858e7fac4e240c5eb743cb"},
+    {file = "debugpy-1.8.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd97ed11a4c7f6d042d320ce03d83b20c3fb40da892f994bc041bbc415d7a099"},
+    {file = "debugpy-1.8.1-cp311-cp311-win32.whl", hash = "sha256:0de56aba8249c28a300bdb0672a9b94785074eb82eb672db66c8144fff673146"},
+    {file = "debugpy-1.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:1a9fe0829c2b854757b4fd0a338d93bc17249a3bf69ecf765c61d4c522bb92a8"},
+    {file = "debugpy-1.8.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3ebb70ba1a6524d19fa7bb122f44b74170c447d5746a503e36adc244a20ac539"},
+    {file = "debugpy-1.8.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2e658a9630f27534e63922ebf655a6ab60c370f4d2fc5c02a5b19baf4410ace"},
+    {file = "debugpy-1.8.1-cp312-cp312-win32.whl", hash = "sha256:caad2846e21188797a1f17fc09c31b84c7c3c23baf2516fed5b40b378515bbf0"},
+    {file = "debugpy-1.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:edcc9f58ec0fd121a25bc950d4578df47428d72e1a0d66c07403b04eb93bcf98"},
+    {file = "debugpy-1.8.1-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:7a3afa222f6fd3d9dfecd52729bc2e12c93e22a7491405a0ecbf9e1d32d45b39"},
+    {file = "debugpy-1.8.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d915a18f0597ef685e88bb35e5d7ab968964b7befefe1aaea1eb5b2640b586c7"},
+    {file = "debugpy-1.8.1-cp38-cp38-win32.whl", hash = "sha256:92116039b5500633cc8d44ecc187abe2dfa9b90f7a82bbf81d079fcdd506bae9"},
+    {file = "debugpy-1.8.1-cp38-cp38-win_amd64.whl", hash = "sha256:e38beb7992b5afd9d5244e96ad5fa9135e94993b0c551ceebf3fe1a5d9beb234"},
+    {file = "debugpy-1.8.1-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:bfb20cb57486c8e4793d41996652e5a6a885b4d9175dd369045dad59eaacea42"},
+    {file = "debugpy-1.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efd3fdd3f67a7e576dd869c184c5dd71d9aaa36ded271939da352880c012e703"},
+    {file = "debugpy-1.8.1-cp39-cp39-win32.whl", hash = "sha256:58911e8521ca0c785ac7a0539f1e77e0ce2df753f786188f382229278b4cdf23"},
+    {file = "debugpy-1.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:6df9aa9599eb05ca179fb0b810282255202a66835c6efb1d112d21ecb830ddd3"},
+    {file = "debugpy-1.8.1-py2.py3-none-any.whl", hash = "sha256:28acbe2241222b87e255260c76741e1fbf04fdc3b6d094fcf57b6c6f75ce1242"},
+    {file = "debugpy-1.8.1.zip", hash = "sha256:f696d6be15be87aef621917585f9bb94b1dc9e8aced570db1b8a6fc14e8f9b42"},
 ]
 
 [[package]]
@@ -655,6 +853,31 @@ files = [
     {file = "distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed"},
 ]
 
+[[package]]
+name = "docutils"
+version = "0.20.1"
+description = "Docutils -- Python Documentation Utilities"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"},
+    {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"},
+]
+
+[[package]]
+name = "emoji"
+version = "2.10.1"
+description = "Emoji for Python"
+optional = true
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "emoji-2.10.1-py2.py3-none-any.whl", hash = "sha256:11fb369ea79d20c14efa4362c732d67126df294a7959a2c98bfd7447c12a218e"},
+    {file = "emoji-2.10.1.tar.gz", hash = "sha256:16287283518fb7141bde00198f9ffff4e1c1cb570efb68b2f1ec50975c3a581d"},
+]
+
+[package.extras]
+dev = ["coverage", "coveralls", "pytest"]
+
 [[package]]
 name = "exceptiongroup"
 version = "1.2.0"
@@ -699,42 +922,42 @@ tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipyth
 
 [[package]]
 name = "fastavro"
-version = "1.9.3"
+version = "1.9.4"
 description = "Fast read/write of AVRO files"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "fastavro-1.9.3-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:5e9b2e1427fb84c0754bc34923d10cabcf2ed23230201208a1371ab7b6027674"},
-    {file = "fastavro-1.9.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4ef82f86ae276309abc0072598474b6be68105a0b28f8d7cc0398d1d353d7de"},
-    {file = "fastavro-1.9.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:280ef7ab7232ecb2097038d6842416ec717d0e1c314b80ff245f85201f3396a4"},
-    {file = "fastavro-1.9.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:4a36cfc0421ed7576ecb1c22de7bd1dedcce62aebbffcc597379d59171e5d76e"},
-    {file = "fastavro-1.9.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d80f2e20199140eb8c036b4393e9bc9eff325543311b958c72318999499d4279"},
-    {file = "fastavro-1.9.3-cp310-cp310-win_amd64.whl", hash = "sha256:a435f7edd7c5b52cee3f23ca950cd9373ab35cf2aa3d269b3d6aca7e2fc1372c"},
-    {file = "fastavro-1.9.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2a7053ed10194ec53754f5337b57b3273a74b48505edcd6edb79fe3c4cd259c0"},
-    {file = "fastavro-1.9.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:853e01f13534d1baa0a3d493a8573e665e93ffa35b4bf1d125e21764d343af8e"},
-    {file = "fastavro-1.9.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5a279cda25d876e6f120950cadf184a307fd8998f9a22a90bb62e6749f88d1e"},
-    {file = "fastavro-1.9.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:63d6f928840f3fb1f2e1fe20bc8b7d0e1a51ba4bb0e554ecb837a669fba31288"},
-    {file = "fastavro-1.9.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8807046edc78f50b3ea5f55f6a534c87b2a13538e7c56fec3532ef802bcae333"},
-    {file = "fastavro-1.9.3-cp311-cp311-win_amd64.whl", hash = "sha256:e502579da4a51c5630eadbd811a1b3d262d6e783bf19998cfb33d2ea0cf6f516"},
-    {file = "fastavro-1.9.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:6b665efe442061df8d9608c2fb692847df85d52ad825b776c441802f0dfa6571"},
-    {file = "fastavro-1.9.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b8c96d81f0115633489d7f1133a03832922629a61ca81c1d47b482ddcda3b94"},
-    {file = "fastavro-1.9.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:338c7ec94dd2474c4679e44d2560a1922cb6fa99acbb7b18957264baf8eadfc7"},
-    {file = "fastavro-1.9.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a509b34c9af71a109c633631ac2f6d2209830e13200d0048f7e9c057fd563f8f"},
-    {file = "fastavro-1.9.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:967edefab470987c024cd5a1fcd04744a50a91e740c7bdf325181043a47f1083"},
-    {file = "fastavro-1.9.3-cp312-cp312-win_amd64.whl", hash = "sha256:033c15e8ed02f80f01d58be1cd880b09fd444faf277263d563a727711d47a98a"},
-    {file = "fastavro-1.9.3-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:6b38723327603d77080aec56628e13a739415f8596ca0cc41a905615977c6d6b"},
-    {file = "fastavro-1.9.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:046d75c4400941fd08f0a6855a34ae63bf02ea01f366b5b749942abe10640056"},
-    {file = "fastavro-1.9.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87ab312b8baf0e61ee717878d390022ee1b713d70b244d69efbf3325680f9749"},
-    {file = "fastavro-1.9.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:c562fcf8f5091a2446aafd0c2a0da590c24e0b53527a0100d33908e32f20eea8"},
-    {file = "fastavro-1.9.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2aa0111e7ebd076d2a094862bbdf8ea175cebba148fcce6c89ff46b625e334b4"},
-    {file = "fastavro-1.9.3-cp38-cp38-win_amd64.whl", hash = "sha256:652072e0f455ca19a1ee502b527e603389783657c130d81f89df66775979d6f5"},
-    {file = "fastavro-1.9.3-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:0a57cdd4edaee36d4216faf801ebc7f53f45e4e1518bdd9832d6f6f1d6e2d88f"},
-    {file = "fastavro-1.9.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b46a18ebed61573b0823c28eda2716485d283258a83659c7fe6ad3aaeacfed4"},
-    {file = "fastavro-1.9.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f756f0723f3bd97db20437d0a8e45712839e6ccd7c82f4d82469533be48b4c7"},
-    {file = "fastavro-1.9.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d98d5a08063f5b6d7ac5016a0dfe0698b50d9987cb74686f7dfa8288b7b09e0b"},
-    {file = "fastavro-1.9.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:00698e60db58a2d52cb709df882d451fb7664ebb2f8cb37d9171697e060dc767"},
-    {file = "fastavro-1.9.3-cp39-cp39-win_amd64.whl", hash = "sha256:d021bbc135023194688e88a7431fb0b5e3ce20e27153bf258f2ce08ee1a0106b"},
-    {file = "fastavro-1.9.3.tar.gz", hash = "sha256:a30d3d2353f6d3b4f6dcd6a97ae937b3775faddd63f5856fe11ba3b0dbb1756a"},
+    {file = "fastavro-1.9.4-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:60cb38f07462a7fb4e4440ed0de67d3d400ae6b3d780f81327bebde9aa55faef"},
+    {file = "fastavro-1.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:063d01d197fc929c20adc09ca9f0ca86d33ac25ee0963ce0b438244eee8315ae"},
+    {file = "fastavro-1.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87a9053fcfbc895f2a16a4303af22077e3a8fdcf1cd5d6ed47ff2ef22cbba2f0"},
+    {file = "fastavro-1.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:02bf1276b7326397314adf41b34a4890f6ffa59cf7e0eb20b9e4ab0a143a1598"},
+    {file = "fastavro-1.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:56bed9eca435389a8861e6e2d631ec7f8f5dda5b23f93517ac710665bd34ca29"},
+    {file = "fastavro-1.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:0cd2099c8c672b853e0b20c13e9b62a69d3fbf67ee7c59c7271ba5df1680310d"},
+    {file = "fastavro-1.9.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:af8c6d8c43a02b5569c093fc5467469541ac408c79c36a5b0900d3dd0b3ba838"},
+    {file = "fastavro-1.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4a138710bd61580324d23bc5e3df01f0b82aee0a76404d5dddae73d9e4c723f"},
+    {file = "fastavro-1.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:903d97418120ca6b6a7f38a731166c1ccc2c4344ee5e0470d09eb1dc3687540a"},
+    {file = "fastavro-1.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c443eeb99899d062dbf78c525e4614dd77e041a7688fa2710c224f4033f193ae"},
+    {file = "fastavro-1.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ac26ab0774d1b2b7af6d8f4300ad20bbc4b5469e658a02931ad13ce23635152f"},
+    {file = "fastavro-1.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:cf7247874c22be856ba7d1f46a0f6e0379a6025f1a48a7da640444cbac6f570b"},
+    {file = "fastavro-1.9.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:68912f2020e1b3d70557260b27dd85fb49a4fc6bfab18d384926127452c1da4c"},
+    {file = "fastavro-1.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6925ce137cdd78e109abdb0bc33aad55de6c9f2d2d3036b65453128f2f5f5b92"},
+    {file = "fastavro-1.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b928cd294e36e35516d0deb9e104b45be922ba06940794260a4e5dbed6c192a"},
+    {file = "fastavro-1.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:90c9838bc4c991ffff5dd9d88a0cc0030f938b3fdf038cdf6babde144b920246"},
+    {file = "fastavro-1.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:eca6e54da571b06a3c5a72dbb7212073f56c92a6fbfbf847b91c347510f8a426"},
+    {file = "fastavro-1.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a4b02839ac261100cefca2e2ad04cdfedc556cb66b5ec735e0db428e74b399de"},
+    {file = "fastavro-1.9.4-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:4451ee9a305a73313a1558d471299f3130e4ecc10a88bf5742aa03fb37e042e6"},
+    {file = "fastavro-1.9.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8524fccfb379565568c045d29b2ebf71e1f2c0dd484aeda9fe784ef5febe1a8"},
+    {file = "fastavro-1.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33d0a00a6e09baa20f6f038d7a2ddcb7eef0e7a9980e947a018300cb047091b8"},
+    {file = "fastavro-1.9.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:23d7e5b29c9bf6f26e8be754b2c8b919838e506f78ef724de7d22881696712fc"},
+    {file = "fastavro-1.9.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2e6ab3ee53944326460edf1125b2ad5be2fadd80f7211b13c45fa0c503b4cf8d"},
+    {file = "fastavro-1.9.4-cp38-cp38-win_amd64.whl", hash = "sha256:64d335ec2004204c501f8697c385d0a8f6b521ac82d5b30696f789ff5bc85f3c"},
+    {file = "fastavro-1.9.4-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:7e05f44c493e89e73833bd3ff3790538726906d2856f59adc8103539f4a1b232"},
+    {file = "fastavro-1.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:253c63993250bff4ee7b11fb46cf3a4622180a783bedc82a24c6fdcd1b10ca2a"},
+    {file = "fastavro-1.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24d6942eb1db14640c2581e0ecd1bbe0afc8a83731fcd3064ae7f429d7880cb7"},
+    {file = "fastavro-1.9.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d47bb66be6091cd48cfe026adcad11c8b11d7d815a2949a1e4ccf03df981ca65"},
+    {file = "fastavro-1.9.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c293897f12f910e58a1024f9c77f565aa8e23b36aafda6ad8e7041accc57a57f"},
+    {file = "fastavro-1.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:f05d2afcb10a92e2a9e580a3891f090589b3e567fdc5641f8a46a0b084f120c3"},
+    {file = "fastavro-1.9.4.tar.gz", hash = "sha256:56b8363e360a1256c94562393dc7f8611f3baf2b3159f64fb2b9c6b87b14e876"},
 ]
 
 [package.extras]
@@ -778,6 +1001,17 @@ docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1
 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)"]
 typing = ["typing-extensions (>=4.8)"]
 
+[[package]]
+name = "filetype"
+version = "1.2.0"
+description = "Infer file type and MIME type of any file/buffer. No external dependencies."
+optional = true
+python-versions = "*"
+files = [
+    {file = "filetype-1.2.0-py2.py3-none-any.whl", hash = "sha256:7ce71b6880181241cf7ac8697a2f1eb6a8bd9b429f7ad6d27b8db9ba5f1c2d25"},
+    {file = "filetype-1.2.0.tar.gz", hash = "sha256:66b56cd6474bf41d8c54660347d37afcc3f7d1970648de365c102ef77548aadb"},
+]
+
 [[package]]
 name = "flatbuffers"
 version = "23.5.26"
@@ -789,6 +1023,71 @@ files = [
     {file = "flatbuffers-23.5.26.tar.gz", hash = "sha256:9ea1144cac05ce5d86e2859f431c6cd5e66cd9c78c558317c7955fb8d4c78d89"},
 ]
 
+[[package]]
+name = "fonttools"
+version = "4.49.0"
+description = "Tools to manipulate font files"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fonttools-4.49.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d970ecca0aac90d399e458f0b7a8a597e08f95de021f17785fb68e2dc0b99717"},
+    {file = "fonttools-4.49.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac9a745b7609f489faa65e1dc842168c18530874a5f5b742ac3dd79e26bca8bc"},
+    {file = "fonttools-4.49.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ba0e00620ca28d4ca11fc700806fd69144b463aa3275e1b36e56c7c09915559"},
+    {file = "fonttools-4.49.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdee3ab220283057e7840d5fb768ad4c2ebe65bdba6f75d5d7bf47f4e0ed7d29"},
+    {file = "fonttools-4.49.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ce7033cb61f2bb65d8849658d3786188afd80f53dad8366a7232654804529532"},
+    {file = "fonttools-4.49.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:07bc5ea02bb7bc3aa40a1eb0481ce20e8d9b9642a9536cde0218290dd6085828"},
+    {file = "fonttools-4.49.0-cp310-cp310-win32.whl", hash = "sha256:86eef6aab7fd7c6c8545f3ebd00fd1d6729ca1f63b0cb4d621bccb7d1d1c852b"},
+    {file = "fonttools-4.49.0-cp310-cp310-win_amd64.whl", hash = "sha256:1fac1b7eebfce75ea663e860e7c5b4a8831b858c17acd68263bc156125201abf"},
+    {file = "fonttools-4.49.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:edc0cce355984bb3c1d1e89d6a661934d39586bb32191ebff98c600f8957c63e"},
+    {file = "fonttools-4.49.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:83a0d9336de2cba86d886507dd6e0153df333ac787377325a39a2797ec529814"},
+    {file = "fonttools-4.49.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36c8865bdb5cfeec88f5028e7e592370a0657b676c6f1d84a2108e0564f90e22"},
+    {file = "fonttools-4.49.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33037d9e56e2562c710c8954d0f20d25b8386b397250d65581e544edc9d6b942"},
+    {file = "fonttools-4.49.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8fb022d799b96df3eaa27263e9eea306bd3d437cc9aa981820850281a02b6c9a"},
+    {file = "fonttools-4.49.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:33c584c0ef7dc54f5dd4f84082eabd8d09d1871a3d8ca2986b0c0c98165f8e86"},
+    {file = "fonttools-4.49.0-cp311-cp311-win32.whl", hash = "sha256:cbe61b158deb09cffdd8540dc4a948d6e8f4d5b4f3bf5cd7db09bd6a61fee64e"},
+    {file = "fonttools-4.49.0-cp311-cp311-win_amd64.whl", hash = "sha256:fc11e5114f3f978d0cea7e9853627935b30d451742eeb4239a81a677bdee6bf6"},
+    {file = "fonttools-4.49.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d647a0e697e5daa98c87993726da8281c7233d9d4ffe410812a4896c7c57c075"},
+    {file = "fonttools-4.49.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f3bbe672df03563d1f3a691ae531f2e31f84061724c319652039e5a70927167e"},
+    {file = "fonttools-4.49.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bebd91041dda0d511b0d303180ed36e31f4f54b106b1259b69fade68413aa7ff"},
+    {file = "fonttools-4.49.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4145f91531fd43c50f9eb893faa08399816bb0b13c425667c48475c9f3a2b9b5"},
+    {file = "fonttools-4.49.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ea329dafb9670ffbdf4dbc3b0e5c264104abcd8441d56de77f06967f032943cb"},
+    {file = "fonttools-4.49.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c076a9e548521ecc13d944b1d261ff3d7825048c338722a4bd126d22316087b7"},
+    {file = "fonttools-4.49.0-cp312-cp312-win32.whl", hash = "sha256:b607ea1e96768d13be26d2b400d10d3ebd1456343eb5eaddd2f47d1c4bd00880"},
+    {file = "fonttools-4.49.0-cp312-cp312-win_amd64.whl", hash = "sha256:a974c49a981e187381b9cc2c07c6b902d0079b88ff01aed34695ec5360767034"},
+    {file = "fonttools-4.49.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:b85ec0bdd7bdaa5c1946398cbb541e90a6dfc51df76dfa88e0aaa41b335940cb"},
+    {file = "fonttools-4.49.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:af20acbe198a8a790618ee42db192eb128afcdcc4e96d99993aca0b60d1faeb4"},
+    {file = "fonttools-4.49.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d418b1fee41a1d14931f7ab4b92dc0bc323b490e41d7a333eec82c9f1780c75"},
+    {file = "fonttools-4.49.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b44a52b8e6244b6548851b03b2b377a9702b88ddc21dcaf56a15a0393d425cb9"},
+    {file = "fonttools-4.49.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:7c7125068e04a70739dad11857a4d47626f2b0bd54de39e8622e89701836eabd"},
+    {file = "fonttools-4.49.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:29e89d0e1a7f18bc30f197cfadcbef5a13d99806447c7e245f5667579a808036"},
+    {file = "fonttools-4.49.0-cp38-cp38-win32.whl", hash = "sha256:9d95fa0d22bf4f12d2fb7b07a46070cdfc19ef5a7b1c98bc172bfab5bf0d6844"},
+    {file = "fonttools-4.49.0-cp38-cp38-win_amd64.whl", hash = "sha256:768947008b4dc552d02772e5ebd49e71430a466e2373008ce905f953afea755a"},
+    {file = "fonttools-4.49.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:08877e355d3dde1c11973bb58d4acad1981e6d1140711230a4bfb40b2b937ccc"},
+    {file = "fonttools-4.49.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fdb54b076f25d6b0f0298dc706acee5052de20c83530fa165b60d1f2e9cbe3cb"},
+    {file = "fonttools-4.49.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0af65c720520710cc01c293f9c70bd69684365c6015cc3671db2b7d807fe51f2"},
+    {file = "fonttools-4.49.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f255ce8ed7556658f6d23f6afd22a6d9bbc3edb9b96c96682124dc487e1bf42"},
+    {file = "fonttools-4.49.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d00af0884c0e65f60dfaf9340e26658836b935052fdd0439952ae42e44fdd2be"},
+    {file = "fonttools-4.49.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:263832fae27481d48dfafcc43174644b6706639661e242902ceb30553557e16c"},
+    {file = "fonttools-4.49.0-cp39-cp39-win32.whl", hash = "sha256:0404faea044577a01bb82d47a8fa4bc7a54067fa7e324785dd65d200d6dd1133"},
+    {file = "fonttools-4.49.0-cp39-cp39-win_amd64.whl", hash = "sha256:b050d362df50fc6e38ae3954d8c29bf2da52be384649ee8245fdb5186b620836"},
+    {file = "fonttools-4.49.0-py3-none-any.whl", hash = "sha256:af281525e5dd7fa0b39fb1667b8d5ca0e2a9079967e14c4bfe90fd1cd13e0f18"},
+    {file = "fonttools-4.49.0.tar.gz", hash = "sha256:ebf46e7f01b7af7861310417d7c49591a85d99146fc23a5ba82fdb28af156321"},
+]
+
+[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 = "frozenlist"
 version = "1.4.1"
@@ -923,13 +1222,13 @@ files = [
 
 [[package]]
 name = "httpcore"
-version = "1.0.2"
+version = "1.0.3"
 description = "A minimal low-level HTTP client."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "httpcore-1.0.2-py3-none-any.whl", hash = "sha256:096cc05bca73b8e459a1fc3dcf585148f63e534eae4339559c9b8a8d6399acc7"},
-    {file = "httpcore-1.0.2.tar.gz", hash = "sha256:9fc092e4799b26174648e54b74ed5f683132a464e95643b226e00c2ed2fa6535"},
+    {file = "httpcore-1.0.3-py3-none-any.whl", hash = "sha256:9a6a501c3099307d9fd76ac244e08503427679b1e81ceb1d922485e2f2462ad2"},
+    {file = "httpcore-1.0.3.tar.gz", hash = "sha256:5c0f9546ad17dac4d0772b0808856eb616eb8b48ce94f49ed819fd6982a8a544"},
 ]
 
 [package.dependencies]
@@ -940,7 +1239,7 @@ h11 = ">=0.13,<0.15"
 asyncio = ["anyio (>=4.0,<5.0)"]
 http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
-trio = ["trio (>=0.22.0,<0.23.0)"]
+trio = ["trio (>=0.22.0,<0.24.0)"]
 
 [[package]]
 name = "httpx"
@@ -1043,6 +1342,24 @@ docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.link
 perf = ["ipython"]
 testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"]
 
+[[package]]
+name = "importlib-resources"
+version = "6.1.1"
+description = "Read resources from Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "importlib_resources-6.1.1-py3-none-any.whl", hash = "sha256:e8bf90d8213b486f428c9c39714b920041cb02c184686a3dee24905aaa8105d6"},
+    {file = "importlib_resources-6.1.1.tar.gz", hash = "sha256:3893a00122eafde6894c59914446a512f728a0c1a45f9bb9b63721b6bacf0b4a"},
+]
+
+[package.dependencies]
+zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""}
+
+[package.extras]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
+testing = ["pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff", "zipp (>=3.17)"]
+
 [[package]]
 name = "iniconfig"
 version = "2.0.0"
@@ -1124,6 +1441,24 @@ qtconsole = ["qtconsole"]
 test = ["pickleshare", "pytest (<7.1)", "pytest-asyncio (<0.22)", "testpath"]
 test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.22)", "pandas", "pickleshare", "pytest (<7.1)", "pytest-asyncio (<0.22)", "testpath", "trio"]
 
+[[package]]
+name = "jaraco-classes"
+version = "3.3.1"
+description = "Utility functions for Python class constructs"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "jaraco.classes-3.3.1-py3-none-any.whl", hash = "sha256:86b534de565381f6b3c1c830d13f931d7be1a75f0081c57dff615578676e2206"},
+    {file = "jaraco.classes-3.3.1.tar.gz", hash = "sha256:cb28a5ebda8bc47d8c8015307d93163464f9f2b91ab4006e09ff0ce07e8bfb30"},
+]
+
+[package.dependencies]
+more-itertools = "*"
+
+[package.extras]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
+testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
+
 [[package]]
 name = "jedi"
 version = "0.19.1"
@@ -1143,6 +1478,21 @@ docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alab
 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 = "jeepney"
+version = "0.8.0"
+description = "Low-level, pure Python DBus protocol wrapper."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "jeepney-0.8.0-py3-none-any.whl", hash = "sha256:c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755"},
+    {file = "jeepney-0.8.0.tar.gz", hash = "sha256:5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806"},
+]
+
+[package.extras]
+test = ["async-timeout", "pytest", "pytest-asyncio (>=0.17)", "pytest-trio", "testpath", "trio"]
+trio = ["async_generator", "trio"]
+
 [[package]]
 name = "jinja2"
 version = "3.1.3"
@@ -1171,6 +1521,17 @@ files = [
     {file = "joblib-1.3.2.tar.gz", hash = "sha256:92f865e621e17784e7955080b6d042489e3b8e294949cc44c6eac304f59772b1"},
 ]
 
+[[package]]
+name = "jsonpath-python"
+version = "1.0.6"
+description = "A more powerful JSONPath implementation in modern python"
+optional = true
+python-versions = ">=3.6"
+files = [
+    {file = "jsonpath-python-1.0.6.tar.gz", hash = "sha256:dd5be4a72d8a2995c3f583cf82bf3cd1a9544cfdabf2d22595b67aff07349666"},
+    {file = "jsonpath_python-1.0.6-py3-none-any.whl", hash = "sha256:1e3b78df579f5efc23565293612decee04214609208a2335884b3ee3f786b575"},
+]
+
 [[package]]
 name = "jupyter-client"
 version = "8.6.0"
@@ -1214,14 +1575,164 @@ traitlets = ">=5.3"
 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 = "keyring"
+version = "24.3.0"
+description = "Store and access your passwords safely."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "keyring-24.3.0-py3-none-any.whl", hash = "sha256:4446d35d636e6a10b8bce7caa66913dd9eca5fd222ca03a3d42c38608ac30836"},
+    {file = "keyring-24.3.0.tar.gz", hash = "sha256:e730ecffd309658a08ee82535a3b5ec4b4c8669a9be11efb66249d8e0aeb9a25"},
+]
+
+[package.dependencies]
+importlib-metadata = {version = ">=4.11.4", markers = "python_version < \"3.12\""}
+"jaraco.classes" = "*"
+jeepney = {version = ">=0.4.2", markers = "sys_platform == \"linux\""}
+pywin32-ctypes = {version = ">=0.2.0", markers = "sys_platform == \"win32\""}
+SecretStorage = {version = ">=3.2", markers = "sys_platform == \"linux\""}
+
+[package.extras]
+completion = ["shtab (>=1.1.0)"]
+docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
+testing = ["pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff"]
+
+[[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 = "langdetect"
+version = "1.0.9"
+description = "Language detection library ported from Google's language-detection."
+optional = true
+python-versions = "*"
+files = [
+    {file = "langdetect-1.0.9-py2-none-any.whl", hash = "sha256:7cbc0746252f19e76f77c0b1690aadf01963be835ef0cd4b56dddf2a8f1dfc2a"},
+    {file = "langdetect-1.0.9.tar.gz", hash = "sha256:cbc1fef89f8d062739774bd51eda3da3274006b3661d199c2655f6b3f6d605a0"},
+]
+
+[package.dependencies]
+six = "*"
+
 [[package]]
 name = "llama-cpp-python"
-version = "0.2.39"
+version = "0.2.44"
 description = "Python bindings for the llama.cpp library"
 optional = true
 python-versions = ">=3.8"
 files = [
-    {file = "llama_cpp_python-0.2.39.tar.gz", hash = "sha256:e4fed6d0e9b925810a6463d75ef339d73288db5fa004938e5b6ce4fb40977d4f"},
+    {file = "llama_cpp_python-0.2.44.tar.gz", hash = "sha256:afe0e93548d4ba75f20bc754039907594738a6381c9f4602922bcc8a418b2039"},
 ]
 
 [package.dependencies]
@@ -1236,6 +1747,123 @@ dev = ["black (>=23.3.0)", "httpx (>=0.24.1)", "mkdocs (>=1.4.3)", "mkdocs-mater
 server = ["fastapi (>=0.100.0)", "pydantic-settings (>=2.0.1)", "sse-starlette (>=1.6.1)", "starlette-context (>=0.3.6,<0.4)", "uvicorn (>=0.22.0)"]
 test = ["httpx (>=0.24.1)", "pytest (>=7.4.0)", "scipy (>=1.10)"]
 
+[[package]]
+name = "lxml"
+version = "5.1.0"
+description = "Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API."
+optional = true
+python-versions = ">=3.6"
+files = [
+    {file = "lxml-5.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:704f5572ff473a5f897745abebc6df40f22d4133c1e0a1f124e4f2bd3330ff7e"},
+    {file = "lxml-5.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9d3c0f8567ffe7502d969c2c1b809892dc793b5d0665f602aad19895f8d508da"},
+    {file = "lxml-5.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5fcfbebdb0c5d8d18b84118842f31965d59ee3e66996ac842e21f957eb76138c"},
+    {file = "lxml-5.1.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f37c6d7106a9d6f0708d4e164b707037b7380fcd0b04c5bd9cae1fb46a856fb"},
+    {file = "lxml-5.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2befa20a13f1a75c751f47e00929fb3433d67eb9923c2c0b364de449121f447c"},
+    {file = "lxml-5.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22b7ee4c35f374e2c20337a95502057964d7e35b996b1c667b5c65c567d2252a"},
+    {file = "lxml-5.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:bf8443781533b8d37b295016a4b53c1494fa9a03573c09ca5104550c138d5c05"},
+    {file = "lxml-5.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:82bddf0e72cb2af3cbba7cec1d2fd11fda0de6be8f4492223d4a268713ef2147"},
+    {file = "lxml-5.1.0-cp310-cp310-win32.whl", hash = "sha256:b66aa6357b265670bb574f050ffceefb98549c721cf28351b748be1ef9577d93"},
+    {file = "lxml-5.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:4946e7f59b7b6a9e27bef34422f645e9a368cb2be11bf1ef3cafc39a1f6ba68d"},
+    {file = "lxml-5.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:14deca1460b4b0f6b01f1ddc9557704e8b365f55c63070463f6c18619ebf964f"},
+    {file = "lxml-5.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ed8c3d2cd329bf779b7ed38db176738f3f8be637bb395ce9629fc76f78afe3d4"},
+    {file = "lxml-5.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:436a943c2900bb98123b06437cdd30580a61340fbdb7b28aaf345a459c19046a"},
+    {file = "lxml-5.1.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:acb6b2f96f60f70e7f34efe0c3ea34ca63f19ca63ce90019c6cbca6b676e81fa"},
+    {file = "lxml-5.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:af8920ce4a55ff41167ddbc20077f5698c2e710ad3353d32a07d3264f3a2021e"},
+    {file = "lxml-5.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7cfced4a069003d8913408e10ca8ed092c49a7f6cefee9bb74b6b3e860683b45"},
+    {file = "lxml-5.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:9e5ac3437746189a9b4121db2a7b86056ac8786b12e88838696899328fc44bb2"},
+    {file = "lxml-5.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f4c9bda132ad108b387c33fabfea47866af87f4ea6ffb79418004f0521e63204"},
+    {file = "lxml-5.1.0-cp311-cp311-win32.whl", hash = "sha256:bc64d1b1dab08f679fb89c368f4c05693f58a9faf744c4d390d7ed1d8223869b"},
+    {file = "lxml-5.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:a5ab722ae5a873d8dcee1f5f45ddd93c34210aed44ff2dc643b5025981908cda"},
+    {file = "lxml-5.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:9aa543980ab1fbf1720969af1d99095a548ea42e00361e727c58a40832439114"},
+    {file = "lxml-5.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6f11b77ec0979f7e4dc5ae081325a2946f1fe424148d3945f943ceaede98adb8"},
+    {file = "lxml-5.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a36c506e5f8aeb40680491d39ed94670487ce6614b9d27cabe45d94cd5d63e1e"},
+    {file = "lxml-5.1.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f643ffd2669ffd4b5a3e9b41c909b72b2a1d5e4915da90a77e119b8d48ce867a"},
+    {file = "lxml-5.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16dd953fb719f0ffc5bc067428fc9e88f599e15723a85618c45847c96f11f431"},
+    {file = "lxml-5.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16018f7099245157564d7148165132c70adb272fb5a17c048ba70d9cc542a1a1"},
+    {file = "lxml-5.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:82cd34f1081ae4ea2ede3d52f71b7be313756e99b4b5f829f89b12da552d3aa3"},
+    {file = "lxml-5.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:19a1bc898ae9f06bccb7c3e1dfd73897ecbbd2c96afe9095a6026016e5ca97b8"},
+    {file = "lxml-5.1.0-cp312-cp312-win32.whl", hash = "sha256:13521a321a25c641b9ea127ef478b580b5ec82aa2e9fc076c86169d161798b01"},
+    {file = "lxml-5.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:1ad17c20e3666c035db502c78b86e58ff6b5991906e55bdbef94977700c72623"},
+    {file = "lxml-5.1.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:24ef5a4631c0b6cceaf2dbca21687e29725b7c4e171f33a8f8ce23c12558ded1"},
+    {file = "lxml-5.1.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8d2900b7f5318bc7ad8631d3d40190b95ef2aa8cc59473b73b294e4a55e9f30f"},
+    {file = "lxml-5.1.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:601f4a75797d7a770daed8b42b97cd1bb1ba18bd51a9382077a6a247a12aa38d"},
+    {file = "lxml-5.1.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4b68c961b5cc402cbd99cca5eb2547e46ce77260eb705f4d117fd9c3f932b95"},
+    {file = "lxml-5.1.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:afd825e30f8d1f521713a5669b63657bcfe5980a916c95855060048b88e1adb7"},
+    {file = "lxml-5.1.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:262bc5f512a66b527d026518507e78c2f9c2bd9eb5c8aeeb9f0eb43fcb69dc67"},
+    {file = "lxml-5.1.0-cp36-cp36m-win32.whl", hash = "sha256:e856c1c7255c739434489ec9c8aa9cdf5179785d10ff20add308b5d673bed5cd"},
+    {file = "lxml-5.1.0-cp36-cp36m-win_amd64.whl", hash = "sha256:c7257171bb8d4432fe9d6fdde4d55fdbe663a63636a17f7f9aaba9bcb3153ad7"},
+    {file = "lxml-5.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b9e240ae0ba96477682aa87899d94ddec1cc7926f9df29b1dd57b39e797d5ab5"},
+    {file = "lxml-5.1.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a96f02ba1bcd330807fc060ed91d1f7a20853da6dd449e5da4b09bfcc08fdcf5"},
+    {file = "lxml-5.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e3898ae2b58eeafedfe99e542a17859017d72d7f6a63de0f04f99c2cb125936"},
+    {file = "lxml-5.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61c5a7edbd7c695e54fca029ceb351fc45cd8860119a0f83e48be44e1c464862"},
+    {file = "lxml-5.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:3aeca824b38ca78d9ee2ab82bd9883083d0492d9d17df065ba3b94e88e4d7ee6"},
+    {file = "lxml-5.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8f52fe6859b9db71ee609b0c0a70fea5f1e71c3462ecf144ca800d3f434f0764"},
+    {file = "lxml-5.1.0-cp37-cp37m-win32.whl", hash = "sha256:d42e3a3fc18acc88b838efded0e6ec3edf3e328a58c68fbd36a7263a874906c8"},
+    {file = "lxml-5.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:eac68f96539b32fce2c9b47eb7c25bb2582bdaf1bbb360d25f564ee9e04c542b"},
+    {file = "lxml-5.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ae15347a88cf8af0949a9872b57a320d2605ae069bcdf047677318bc0bba45b1"},
+    {file = "lxml-5.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c26aab6ea9c54d3bed716b8851c8bfc40cb249b8e9880e250d1eddde9f709bf5"},
+    {file = "lxml-5.1.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:342e95bddec3a698ac24378d61996b3ee5ba9acfeb253986002ac53c9a5f6f84"},
+    {file = "lxml-5.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:725e171e0b99a66ec8605ac77fa12239dbe061482ac854d25720e2294652eeaa"},
+    {file = "lxml-5.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d184e0d5c918cff04cdde9dbdf9600e960161d773666958c9d7b565ccc60c45"},
+    {file = "lxml-5.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:98f3f020a2b736566c707c8e034945c02aa94e124c24f77ca097c446f81b01f1"},
+    {file = "lxml-5.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6d48fc57e7c1e3df57be5ae8614bab6d4e7b60f65c5457915c26892c41afc59e"},
+    {file = "lxml-5.1.0-cp38-cp38-win32.whl", hash = "sha256:7ec465e6549ed97e9f1e5ed51c657c9ede767bc1c11552f7f4d022c4df4a977a"},
+    {file = "lxml-5.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:b21b4031b53d25b0858d4e124f2f9131ffc1530431c6d1321805c90da78388d1"},
+    {file = "lxml-5.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:52427a7eadc98f9e62cb1368a5079ae826f94f05755d2d567d93ee1bc3ceb354"},
+    {file = "lxml-5.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6a2a2c724d97c1eb8cf966b16ca2915566a4904b9aad2ed9a09c748ffe14f969"},
+    {file = "lxml-5.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:843b9c835580d52828d8f69ea4302537337a21e6b4f1ec711a52241ba4a824f3"},
+    {file = "lxml-5.1.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9b99f564659cfa704a2dd82d0684207b1aadf7d02d33e54845f9fc78e06b7581"},
+    {file = "lxml-5.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f8b0c78e7aac24979ef09b7f50da871c2de2def043d468c4b41f512d831e912"},
+    {file = "lxml-5.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9bcf86dfc8ff3e992fed847c077bd875d9e0ba2fa25d859c3a0f0f76f07f0c8d"},
+    {file = "lxml-5.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:49a9b4af45e8b925e1cd6f3b15bbba2c81e7dba6dce170c677c9cda547411e14"},
+    {file = "lxml-5.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:280f3edf15c2a967d923bcfb1f8f15337ad36f93525828b40a0f9d6c2ad24890"},
+    {file = "lxml-5.1.0-cp39-cp39-win32.whl", hash = "sha256:ed7326563024b6e91fef6b6c7a1a2ff0a71b97793ac33dbbcf38f6005e51ff6e"},
+    {file = "lxml-5.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:8d7b4beebb178e9183138f552238f7e6613162a42164233e2bda00cb3afac58f"},
+    {file = "lxml-5.1.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:9bd0ae7cc2b85320abd5e0abad5ccee5564ed5f0cc90245d2f9a8ef330a8deae"},
+    {file = "lxml-5.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8c1d679df4361408b628f42b26a5d62bd3e9ba7f0c0e7969f925021554755aa"},
+    {file = "lxml-5.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:2ad3a8ce9e8a767131061a22cd28fdffa3cd2dc193f399ff7b81777f3520e372"},
+    {file = "lxml-5.1.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:304128394c9c22b6569eba2a6d98392b56fbdfbad58f83ea702530be80d0f9df"},
+    {file = "lxml-5.1.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d74fcaf87132ffc0447b3c685a9f862ffb5b43e70ea6beec2fb8057d5d2a1fea"},
+    {file = "lxml-5.1.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:8cf5877f7ed384dabfdcc37922c3191bf27e55b498fecece9fd5c2c7aaa34c33"},
+    {file = "lxml-5.1.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:877efb968c3d7eb2dad540b6cabf2f1d3c0fbf4b2d309a3c141f79c7e0061324"},
+    {file = "lxml-5.1.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f14a4fb1c1c402a22e6a341a24c1341b4a3def81b41cd354386dcb795f83897"},
+    {file = "lxml-5.1.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:25663d6e99659544ee8fe1b89b1a8c0aaa5e34b103fab124b17fa958c4a324a6"},
+    {file = "lxml-5.1.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:8b9f19df998761babaa7f09e6bc169294eefafd6149aaa272081cbddc7ba4ca3"},
+    {file = "lxml-5.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e53d7e6a98b64fe54775d23a7c669763451340c3d44ad5e3a3b48a1efbdc96f"},
+    {file = "lxml-5.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c3cd1fc1dc7c376c54440aeaaa0dcc803d2126732ff5c6b68ccd619f2e64be4f"},
+    {file = "lxml-5.1.0.tar.gz", hash = "sha256:3eea6ed6e6c918e468e693c41ef07f3c3acc310b70ddd9cc72d9ef84bc9564ca"},
+]
+
+[package.extras]
+cssselect = ["cssselect (>=0.7)"]
+html5 = ["html5lib"]
+htmlsoup = ["BeautifulSoup4"]
+source = ["Cython (>=3.0.7)"]
+
+[[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"
@@ -1305,6 +1933,90 @@ files = [
     {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"},
 ]
 
+[[package]]
+name = "marshmallow"
+version = "3.20.2"
+description = "A lightweight library for converting complex datatypes to and from native Python datatypes."
+optional = true
+python-versions = ">=3.8"
+files = [
+    {file = "marshmallow-3.20.2-py3-none-any.whl", hash = "sha256:c21d4b98fee747c130e6bc8f45c4b3199ea66bc00c12ee1f639f0aeca034d5e9"},
+    {file = "marshmallow-3.20.2.tar.gz", hash = "sha256:4c1daff273513dc5eb24b219a8035559dc573c8f322558ef85f5438ddd1236dd"},
+]
+
+[package.dependencies]
+packaging = ">=17.0"
+
+[package.extras]
+dev = ["pre-commit (>=2.4,<4.0)", "pytest", "pytz", "simplejson", "tox"]
+docs = ["alabaster (==0.7.15)", "autodocsumm (==0.2.12)", "sphinx (==7.2.6)", "sphinx-issues (==3.0.1)", "sphinx-version-warning (==1.1.2)"]
+lint = ["pre-commit (>=2.4,<4.0)"]
+tests = ["pytest", "pytz", "simplejson"]
+
+[[package]]
+name = "matplot"
+version = "0.1.9"
+description = ""
+optional = false
+python-versions = "*"
+files = [
+    {file = "matplot-0.1.9-py2.py3-none-any.whl", hash = "sha256:794ec24272a7672d5c89c4bbb581ceb0881c0d08c95d4f79c454a54ad4a1cdfa"},
+    {file = "matplot-0.1.9.tar.gz", hash = "sha256:89369d0974a5c5b6e5815532a9202ce09db0d70a909251bf0af0c608818c8fa4"},
+]
+
+[package.dependencies]
+matplotlib = ">=3.1.1"
+pyloco = ">=0.0.134"
+
+[[package]]
+name = "matplotlib"
+version = "3.8.3"
+description = "Python plotting package"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "matplotlib-3.8.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:cf60138ccc8004f117ab2a2bad513cc4d122e55864b4fe7adf4db20ca68a078f"},
+    {file = "matplotlib-3.8.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5f557156f7116be3340cdeef7f128fa99b0d5d287d5f41a16e169819dcf22357"},
+    {file = "matplotlib-3.8.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f386cf162b059809ecfac3bcc491a9ea17da69fa35c8ded8ad154cd4b933d5ec"},
+    {file = "matplotlib-3.8.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3c5f96f57b0369c288bf6f9b5274ba45787f7e0589a34d24bdbaf6d3344632f"},
+    {file = "matplotlib-3.8.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:83e0f72e2c116ca7e571c57aa29b0fe697d4c6425c4e87c6e994159e0c008635"},
+    {file = "matplotlib-3.8.3-cp310-cp310-win_amd64.whl", hash = "sha256:1c5c8290074ba31a41db1dc332dc2b62def469ff33766cbe325d32a3ee291aea"},
+    {file = "matplotlib-3.8.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:5184e07c7e1d6d1481862ee361905b7059f7fe065fc837f7c3dc11eeb3f2f900"},
+    {file = "matplotlib-3.8.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d7e7e0993d0758933b1a241a432b42c2db22dfa37d4108342ab4afb9557cbe3e"},
+    {file = "matplotlib-3.8.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:04b36ad07eac9740fc76c2aa16edf94e50b297d6eb4c081e3add863de4bb19a7"},
+    {file = "matplotlib-3.8.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7c42dae72a62f14982f1474f7e5c9959fc4bc70c9de11cc5244c6e766200ba65"},
+    {file = "matplotlib-3.8.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:bf5932eee0d428192c40b7eac1399d608f5d995f975cdb9d1e6b48539a5ad8d0"},
+    {file = "matplotlib-3.8.3-cp311-cp311-win_amd64.whl", hash = "sha256:40321634e3a05ed02abf7c7b47a50be50b53ef3eaa3a573847431a545585b407"},
+    {file = "matplotlib-3.8.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:09074f8057917d17ab52c242fdf4916f30e99959c1908958b1fc6032e2d0f6d4"},
+    {file = "matplotlib-3.8.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5745f6d0fb5acfabbb2790318db03809a253096e98c91b9a31969df28ee604aa"},
+    {file = "matplotlib-3.8.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b97653d869a71721b639714b42d87cda4cfee0ee74b47c569e4874c7590c55c5"},
+    {file = "matplotlib-3.8.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:242489efdb75b690c9c2e70bb5c6550727058c8a614e4c7716f363c27e10bba1"},
+    {file = "matplotlib-3.8.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:83c0653c64b73926730bd9ea14aa0f50f202ba187c307a881673bad4985967b7"},
+    {file = "matplotlib-3.8.3-cp312-cp312-win_amd64.whl", hash = "sha256:ef6c1025a570354297d6c15f7d0f296d95f88bd3850066b7f1e7b4f2f4c13a39"},
+    {file = "matplotlib-3.8.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c4af3f7317f8a1009bbb2d0bf23dfaba859eb7dd4ccbd604eba146dccaaaf0a4"},
+    {file = "matplotlib-3.8.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4c6e00a65d017d26009bac6808f637b75ceade3e1ff91a138576f6b3065eeeba"},
+    {file = "matplotlib-3.8.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e7b49ab49a3bea17802df6872f8d44f664ba8f9be0632a60c99b20b6db2165b7"},
+    {file = "matplotlib-3.8.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6728dde0a3997396b053602dbd907a9bd64ec7d5cf99e728b404083698d3ca01"},
+    {file = "matplotlib-3.8.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:813925d08fb86aba139f2d31864928d67511f64e5945ca909ad5bc09a96189bb"},
+    {file = "matplotlib-3.8.3-cp39-cp39-win_amd64.whl", hash = "sha256:cd3a0c2be76f4e7be03d34a14d49ded6acf22ef61f88da600a18a5cd8b3c5f3c"},
+    {file = "matplotlib-3.8.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:fa93695d5c08544f4a0dfd0965f378e7afc410d8672816aff1e81be1f45dbf2e"},
+    {file = "matplotlib-3.8.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9764df0e8778f06414b9d281a75235c1e85071f64bb5d71564b97c1306a2afc"},
+    {file = "matplotlib-3.8.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:5e431a09e6fab4012b01fc155db0ce6dccacdbabe8198197f523a4ef4805eb26"},
+    {file = "matplotlib-3.8.3.tar.gz", hash = "sha256:7b416239e9ae38be54b028abbf9048aff5054a9aba5416bef0bd17f9162ce161"},
+]
+
+[package.dependencies]
+contourpy = ">=1.0.1"
+cycler = ">=0.10"
+fonttools = ">=4.22.0"
+importlib-resources = {version = ">=3.2.0", markers = "python_version < \"3.10\""}
+kiwisolver = ">=1.3.1"
+numpy = ">=1.21,<2"
+packaging = ">=20.0"
+pillow = ">=8"
+pyparsing = ">=2.3.1"
+python-dateutil = ">=2.7"
+
 [[package]]
 name = "matplotlib-inline"
 version = "0.1.6"
@@ -1319,6 +2031,17 @@ files = [
 [package.dependencies]
 traitlets = "*"
 
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+description = "Markdown URL utilities"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"},
+    {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"},
+]
+
 [[package]]
 name = "mistralai"
 version = "0.0.12"
@@ -1379,6 +2102,17 @@ files = [
     {file = "mmh3-3.1.0.tar.gz", hash = "sha256:9b0f2b2ab4a915333c9d1089572e290a021ebb5b900bb7f7114dccc03995d732"},
 ]
 
+[[package]]
+name = "more-itertools"
+version = "10.2.0"
+description = "More routines for operating on iterables, beyond itertools"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "more-itertools-10.2.0.tar.gz", hash = "sha256:8fccb480c43d3e99a00087634c06dd02b0d50fbf088b380de5a41a015ec239e1"},
+    {file = "more_itertools-10.2.0-py3-none-any.whl", hash = "sha256:686b06abe565edfab151cb8fd385a05651e1fdf8f0a14191e4439283421f8684"},
+]
+
 [[package]]
 name = "mpmath"
 version = "1.3.0"
@@ -1582,6 +2316,31 @@ doc = ["nb2plots (>=0.7)", "nbconvert (<7.9)", "numpydoc (>=1.6)", "pillow (>=9.
 extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.11)", "sympy (>=1.10)"]
 test = ["pytest (>=7.2)", "pytest-cov (>=4.0)"]
 
+[[package]]
+name = "nh3"
+version = "0.2.15"
+description = "Python bindings to the ammonia HTML sanitization library."
+optional = false
+python-versions = "*"
+files = [
+    {file = "nh3-0.2.15-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:9c0d415f6b7f2338f93035bba5c0d8c1b464e538bfbb1d598acd47d7969284f0"},
+    {file = "nh3-0.2.15-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6f42f99f0cf6312e470b6c09e04da31f9abaadcd3eb591d7d1a88ea931dca7f3"},
+    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac19c0d68cd42ecd7ead91a3a032fdfff23d29302dbb1311e641a130dfefba97"},
+    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f0d77272ce6d34db6c87b4f894f037d55183d9518f948bba236fe81e2bb4e28"},
+    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:8d595df02413aa38586c24811237e95937ef18304e108b7e92c890a06793e3bf"},
+    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86e447a63ca0b16318deb62498db4f76fc60699ce0a1231262880b38b6cff911"},
+    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3277481293b868b2715907310c7be0f1b9d10491d5adf9fce11756a97e97eddf"},
+    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60684857cfa8fdbb74daa867e5cad3f0c9789415aba660614fe16cd66cbb9ec7"},
+    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3b803a5875e7234907f7d64777dfde2b93db992376f3d6d7af7f3bc347deb305"},
+    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0d02d0ff79dfd8208ed25a39c12cbda092388fff7f1662466e27d97ad011b770"},
+    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f3b53ba93bb7725acab1e030bc2ecd012a817040fd7851b332f86e2f9bb98dc6"},
+    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:b1e97221cedaf15a54f5243f2c5894bb12ca951ae4ddfd02a9d4ea9df9e1a29d"},
+    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a5167a6403d19c515217b6bcaaa9be420974a6ac30e0da9e84d4fc67a5d474c5"},
+    {file = "nh3-0.2.15-cp37-abi3-win32.whl", hash = "sha256:427fecbb1031db085eaac9931362adf4a796428ef0163070c484b5a768e71601"},
+    {file = "nh3-0.2.15-cp37-abi3-win_amd64.whl", hash = "sha256:bc2d086fb540d0fa52ce35afaded4ea526b8fc4d3339f783db55c95de40ef02e"},
+    {file = "nh3-0.2.15.tar.gz", hash = "sha256:d1e30ff2d8d58fb2a14961f7aac1bbb1c51f9bdd7da727be35c63826060b0bf3"},
+]
+
 [[package]]
 name = "nltk"
 version = "3.8.1"
@@ -1878,13 +2637,13 @@ sympy = "*"
 
 [[package]]
 name = "openai"
-version = "1.11.1"
+version = "1.12.0"
 description = "The official Python library for the openai API"
 optional = false
 python-versions = ">=3.7.1"
 files = [
-    {file = "openai-1.11.1-py3-none-any.whl", hash = "sha256:e0f388ce499f53f58079d0c1f571f356f2b168b84d0d24a412506b6abc714980"},
-    {file = "openai-1.11.1.tar.gz", hash = "sha256:f66b8fe431af43e09594147ef3cdcb79758285de72ebafd52be9700a2af41e99"},
+    {file = "openai-1.12.0-py3-none-any.whl", hash = "sha256:a54002c814e05222e413664f651b5916714e4700d041d5cf5724d3ae1a3e3481"},
+    {file = "openai-1.12.0.tar.gz", hash = "sha256:99c5d257d09ea6533d689d1cc77caa0ac679fa21efef8893d8b0832a86877f1b"},
 ]
 
 [package.dependencies]
@@ -1901,61 +2660,61 @@ datalib = ["numpy (>=1)", "pandas (>=1.2.3)", "pandas-stubs (>=1.1.0.11)"]
 
 [[package]]
 name = "orjson"
-version = "3.9.13"
+version = "3.9.14"
 description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "orjson-3.9.13-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:fa6b67f8bef277c2a4aadd548d58796854e7d760964126c3209b19bccc6a74f1"},
-    {file = "orjson-3.9.13-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b812417199eeb169c25f67815cfb66fd8de7ff098bf57d065e8c1943a7ba5c8f"},
-    {file = "orjson-3.9.13-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7ccd5bd222e5041069ad9d9868ab59e6dbc53ecde8d8c82b919954fbba43b46b"},
-    {file = "orjson-3.9.13-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eaaf80957c38e9d3f796f355a80fad945e72cd745e6b64c210e635b7043b673e"},
-    {file = "orjson-3.9.13-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:60da7316131185d0110a1848e9ad15311e6c8938ee0b5be8cbd7261e1d80ee8f"},
-    {file = "orjson-3.9.13-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5b98cd948372f0eb219bc309dee4633db1278687161e3280d9e693b6076951d2"},
-    {file = "orjson-3.9.13-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3869d65561f10071d3e7f35ae58fd377056f67d7aaed5222f318390c3ad30339"},
-    {file = "orjson-3.9.13-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:43fd6036b16bb6742d03dae62f7bdf8214d06dea47e4353cde7e2bd1358d186f"},
-    {file = "orjson-3.9.13-cp310-none-win32.whl", hash = "sha256:0d3ba9d88e20765335260d7b25547d7c571eee2b698200f97afa7d8c7cd668fc"},
-    {file = "orjson-3.9.13-cp310-none-win_amd64.whl", hash = "sha256:6e47153db080f5e87e8ba638f1a8b18995eede6b0abb93964d58cf11bcea362f"},
-    {file = "orjson-3.9.13-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:4584e8eb727bc431baaf1bf97e35a1d8a0109c924ec847395673dfd5f4ef6d6f"},
-    {file = "orjson-3.9.13-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f37f0cdd026ef777a4336e599d8194c8357fc14760c2a5ddcfdf1965d45504b"},
-    {file = "orjson-3.9.13-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d714595d81efab11b42bccd119977d94b25d12d3a806851ff6bfd286a4bce960"},
-    {file = "orjson-3.9.13-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9171e8e1a1f221953e38e84ae0abffe8759002fd8968106ee379febbb5358b33"},
-    {file = "orjson-3.9.13-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1ab9dbdec3f13f3ea6f937564ce21651844cfbf2725099f2f490426acf683c23"},
-    {file = "orjson-3.9.13-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:811ac076855e33e931549340288e0761873baf29276ad00f221709933c644330"},
-    {file = "orjson-3.9.13-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:860d0f5b42d0c0afd73fa4177709f6e1b966ba691fcd72175affa902052a81d6"},
-    {file = "orjson-3.9.13-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:838b898e8c1f26eb6b8d81b180981273f6f5110c76c22c384979aca854194f1b"},
-    {file = "orjson-3.9.13-cp311-none-win32.whl", hash = "sha256:d3222db9df629ef3c3673124f2e05fb72bc4a320c117e953fec0d69dde82e36d"},
-    {file = "orjson-3.9.13-cp311-none-win_amd64.whl", hash = "sha256:978117122ca4cc59b28af5322253017f6c5fc03dbdda78c7f4b94ae984c8dd43"},
-    {file = "orjson-3.9.13-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:031df1026c7ea8303332d78711f180231e3ae8b564271fb748a03926587c5546"},
-    {file = "orjson-3.9.13-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fd9a2101d04e85086ea6198786a3f016e45475f800712e6833e14bf9ce2832f"},
-    {file = "orjson-3.9.13-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:446d9ad04204e79229ae19502daeea56479e55cbc32634655d886f5a39e91b44"},
-    {file = "orjson-3.9.13-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b57c0954a9fdd2b05b9cec0f5a12a0bdce5bf021a5b3b09323041613972481ab"},
-    {file = "orjson-3.9.13-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:266e55c83f81248f63cc93d11c5e3a53df49a5d2598fa9e9db5f99837a802d5d"},
-    {file = "orjson-3.9.13-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31372ba3a9fe8ad118e7d22fba46bbc18e89039e3bfa89db7bc8c18ee722dca8"},
-    {file = "orjson-3.9.13-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e3b0c4da61f39899561e08e571f54472a09fa71717d9797928af558175ae5243"},
-    {file = "orjson-3.9.13-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2cc03a35bfc71c8ebf96ce49b82c2a7be6af4b3cd3ac34166fdb42ac510bbfff"},
-    {file = "orjson-3.9.13-cp312-none-win_amd64.whl", hash = "sha256:49b7e3fe861cb246361825d1a238f2584ed8ea21e714bf6bb17cebb86772e61c"},
-    {file = "orjson-3.9.13-cp38-cp38-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:62e9a99879c4d5a04926ac2518a992134bfa00d546ea5a4cae4b9be454d35a22"},
-    {file = "orjson-3.9.13-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d92a3e835a5100f1d5b566fff79217eab92223ca31900dba733902a182a35ab0"},
-    {file = "orjson-3.9.13-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:23f21faf072ed3b60b5954686f98157e073f6a8068eaa58dbde83e87212eda84"},
-    {file = "orjson-3.9.13-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:828c502bb261588f7de897e06cb23c4b122997cb039d2014cb78e7dabe92ef0c"},
-    {file = "orjson-3.9.13-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:16946d095212a3dec552572c5d9bca7afa40f3116ad49695a397be07d529f1fa"},
-    {file = "orjson-3.9.13-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3deadd8dc0e9ff844b5b656fa30a48dbee1c3b332d8278302dd9637f6b09f627"},
-    {file = "orjson-3.9.13-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:9b1b5adc5adf596c59dca57156b71ad301d73956f5bab4039b0e34dbf50b9fa0"},
-    {file = "orjson-3.9.13-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:ddc089315d030c54f0f03fb38286e2667c05009a78d659f108a8efcfbdf2e585"},
-    {file = "orjson-3.9.13-cp38-none-win32.whl", hash = "sha256:ae77275a28667d9c82d4522b681504642055efa0368d73108511647c6499b31c"},
-    {file = "orjson-3.9.13-cp38-none-win_amd64.whl", hash = "sha256:730385fdb99a21fce9bb84bb7fcbda72c88626facd74956bda712834b480729d"},
-    {file = "orjson-3.9.13-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:7e8e4a571d958910272af8d53a9cbe6599f9f5fd496a1bc51211183bb2072cbd"},
-    {file = "orjson-3.9.13-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfad553a36548262e7da0f3a7464270e13900b898800fb571a5d4b298c3f8356"},
-    {file = "orjson-3.9.13-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0d691c44604941945b00e0a13b19a7d9c1a19511abadf0080f373e98fdeb6b31"},
-    {file = "orjson-3.9.13-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a8c83718346de08d68b3cb1105c5d91e5fc39885d8610fdda16613d4e3941459"},
-    {file = "orjson-3.9.13-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ef57a53bfc2091a7cd50a640d9ae866bd7d92a5225a1bab6baa60ef62583f2"},
-    {file = "orjson-3.9.13-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9156b96afa38db71344522f5517077eaedf62fcd2c9148392ff93d801128809c"},
-    {file = "orjson-3.9.13-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:31fb66b41fb2c4c817d9610f0bc7d31345728d7b5295ac78b63603407432a2b2"},
-    {file = "orjson-3.9.13-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:8a730bf07feacb0863974e67b206b7c503a62199de1cece2eb0d4c233ec29c11"},
-    {file = "orjson-3.9.13-cp39-none-win32.whl", hash = "sha256:5ef58869f3399acbbe013518d8b374ee9558659eef14bca0984f67cb1fbd3c37"},
-    {file = "orjson-3.9.13-cp39-none-win_amd64.whl", hash = "sha256:9bcf56efdb83244cde070e82a69c0f03c47c235f0a5cb6c81d9da23af7fbaae4"},
-    {file = "orjson-3.9.13.tar.gz", hash = "sha256:fc6bc65b0cf524ee042e0bc2912b9206ef242edfba7426cf95763e4af01f527a"},
+    {file = "orjson-3.9.14-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:793f6c9448ab6eb7d4974b4dde3f230345c08ca6c7995330fbceeb43a5c8aa5e"},
+    {file = "orjson-3.9.14-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6bc7928d161840096adc956703494b5c0193ede887346f028216cac0af87500"},
+    {file = "orjson-3.9.14-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:58b36f54da759602d8e2f7dad958752d453dfe2c7122767bc7f765e17dc59959"},
+    {file = "orjson-3.9.14-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:abcda41ecdc950399c05eff761c3de91485d9a70d8227cb599ad3a66afe93bcc"},
+    {file = "orjson-3.9.14-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df76ecd17b1b3627bddfd689faaf206380a1a38cc9f6c4075bd884eaedcf46c2"},
+    {file = "orjson-3.9.14-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d450a8e0656efb5d0fcb062157b918ab02dcca73278975b4ee9ea49e2fcf5bd5"},
+    {file = "orjson-3.9.14-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:95c03137b0cf66517c8baa65770507a756d3a89489d8ecf864ea92348e1beabe"},
+    {file = "orjson-3.9.14-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:20837e10835c98973673406d6798e10f821e7744520633811a5a3d809762d8cc"},
+    {file = "orjson-3.9.14-cp310-none-win32.whl", hash = "sha256:1f7b6f3ef10ae8e3558abb729873d033dbb5843507c66b1c0767e32502ba96bb"},
+    {file = "orjson-3.9.14-cp310-none-win_amd64.whl", hash = "sha256:ea890e6dc1711aeec0a33b8520e395c2f3d59ead5b4351a788e06bf95fc7ba81"},
+    {file = "orjson-3.9.14-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:c19009ff37f033c70acd04b636380379499dac2cba27ae7dfc24f304deabbc81"},
+    {file = "orjson-3.9.14-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19cdea0664aec0b7f385be84986d4defd3334e9c3c799407686ee1c26f7b8251"},
+    {file = "orjson-3.9.14-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:135d518f73787ce323b1a5e21fb854fe22258d7a8ae562b81a49d6c7f826f2a3"},
+    {file = "orjson-3.9.14-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d2cf1d0557c61c75e18cf7d69fb689b77896e95553e212c0cc64cf2087944b84"},
+    {file = "orjson-3.9.14-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7c11667421df2d8b18b021223505dcc3ee51be518d54e4dc49161ac88ac2b87"},
+    {file = "orjson-3.9.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2eefc41ba42e75ed88bc396d8fe997beb20477f3e7efa000cd7a47eda452fbb2"},
+    {file = "orjson-3.9.14-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:917311d6a64d1c327c0dfda1e41f3966a7fb72b11ca7aa2e7a68fcccc7db35d9"},
+    {file = "orjson-3.9.14-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4dc1c132259b38d12c6587d190cd09cd76e3b5273ce71fe1372437b4cbc65f6f"},
+    {file = "orjson-3.9.14-cp311-none-win32.whl", hash = "sha256:6f39a10408478f4c05736a74da63727a1ae0e83e3533d07b19443400fe8591ca"},
+    {file = "orjson-3.9.14-cp311-none-win_amd64.whl", hash = "sha256:26280a7fcb62d8257f634c16acebc3bec626454f9ab13558bbf7883b9140760e"},
+    {file = "orjson-3.9.14-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:08e722a8d06b13b67a51f247a24938d1a94b4b3862e40e0eef3b2e98c99cd04c"},
+    {file = "orjson-3.9.14-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a2591faa0c031cf3f57e5bce1461cfbd6160f3f66b5a72609a130924917cb07d"},
+    {file = "orjson-3.9.14-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e2450d87dd7b4f277f4c5598faa8b49a0c197b91186c47a2c0b88e15531e4e3e"},
+    {file = "orjson-3.9.14-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:90903d2908158a2c9077a06f11e27545de610af690fb178fd3ba6b32492d4d1c"},
+    {file = "orjson-3.9.14-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce6f095eef0026eae76fc212f20f786011ecf482fc7df2f4c272a8ae6dd7b1ef"},
+    {file = "orjson-3.9.14-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:751250a31fef2bac05a2da2449aae7142075ea26139271f169af60456d8ad27a"},
+    {file = "orjson-3.9.14-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9a1af21160a38ee8be3f4fcf24ee4b99e6184cadc7f915d599f073f478a94d2c"},
+    {file = "orjson-3.9.14-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:449bf090b2aa4e019371d7511a6ea8a5a248139205c27d1834bb4b1e3c44d936"},
+    {file = "orjson-3.9.14-cp312-none-win_amd64.whl", hash = "sha256:a603161318ff699784943e71f53899983b7dee571b4dd07c336437c9c5a272b0"},
+    {file = "orjson-3.9.14-cp38-cp38-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:814f288c011efdf8f115c5ebcc1ab94b11da64b207722917e0ceb42f52ef30a3"},
+    {file = "orjson-3.9.14-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a88cafb100af68af3b9b29b5ccd09fdf7a48c63327916c8c923a94c336d38dd3"},
+    {file = "orjson-3.9.14-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ba3518b999f88882ade6686f1b71e207b52e23546e180499be5bbb63a2f9c6e6"},
+    {file = "orjson-3.9.14-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:978f416bbff9da8d2091e3cf011c92da68b13f2c453dcc2e8109099b2a19d234"},
+    {file = "orjson-3.9.14-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75fc593cf836f631153d0e21beaeb8d26e144445c73645889335c2247fcd71a0"},
+    {file = "orjson-3.9.14-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23d1528db3c7554f9d6eeb09df23cb80dd5177ec56eeb55cc5318826928de506"},
+    {file = "orjson-3.9.14-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:7183cc68ee2113b19b0b8714221e5e3b07b3ba10ca2bb108d78fd49cefaae101"},
+    {file = "orjson-3.9.14-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:df3266d54246cb56b8bb17fa908660d2a0f2e3f63fbc32451ffc1b1505051d07"},
+    {file = "orjson-3.9.14-cp38-none-win32.whl", hash = "sha256:7913079b029e1b3501854c9a78ad938ed40d61fe09bebab3c93e60ff1301b189"},
+    {file = "orjson-3.9.14-cp38-none-win_amd64.whl", hash = "sha256:29512eb925b620e5da2fd7585814485c67cc6ba4fe739a0a700c50467a8a8065"},
+    {file = "orjson-3.9.14-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:5bf597530544db27a8d76aced49cfc817ee9503e0a4ebf0109cd70331e7bbe0c"},
+    {file = "orjson-3.9.14-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac650d49366fa41fe702e054cb560171a8634e2865537e91f09a8d05ea5b1d37"},
+    {file = "orjson-3.9.14-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:236230433a9a4968ab895140514c308fdf9f607cb8bee178a04372b771123860"},
+    {file = "orjson-3.9.14-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3014ccbda9be0b1b5f8ea895121df7e6524496b3908f4397ff02e923bcd8f6dd"},
+    {file = "orjson-3.9.14-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ac0c7eae7ad3a223bde690565442f8a3d620056bd01196f191af8be58a5248e1"},
+    {file = "orjson-3.9.14-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fca33fdd0b38839b01912c57546d4f412ba7bfa0faf9bf7453432219aec2df07"},
+    {file = "orjson-3.9.14-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:f75823cc1674a840a151e999a7dfa0d86c911150dd6f951d0736ee9d383bf415"},
+    {file = "orjson-3.9.14-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6f52ac2eb49e99e7373f62e2a68428c6946cda52ce89aa8fe9f890c7278e2d3a"},
+    {file = "orjson-3.9.14-cp39-none-win32.whl", hash = "sha256:0572f174f50b673b7df78680fb52cd0087a8585a6d06d295a5f790568e1064c6"},
+    {file = "orjson-3.9.14-cp39-none-win_amd64.whl", hash = "sha256:ab90c02cb264250b8a58cedcc72ed78a4a257d956c8d3c8bebe9751b818dfad8"},
+    {file = "orjson-3.9.14.tar.gz", hash = "sha256:06fb40f8e49088ecaa02f1162581d39e2cf3fd9dbbfe411eb2284147c99bad79"},
 ]
 
 [[package]]
@@ -2009,15 +2768,100 @@ files = [
 [package.dependencies]
 ptyprocess = ">=0.5"
 
+[[package]]
+name = "pillow"
+version = "10.2.0"
+description = "Python Imaging Library (Fork)"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pillow-10.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:7823bdd049099efa16e4246bdf15e5a13dbb18a51b68fa06d6c1d4d8b99a796e"},
+    {file = "pillow-10.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:83b2021f2ade7d1ed556bc50a399127d7fb245e725aa0113ebd05cfe88aaf588"},
+    {file = "pillow-10.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fad5ff2f13d69b7e74ce5b4ecd12cc0ec530fcee76356cac6742785ff71c452"},
+    {file = "pillow-10.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da2b52b37dad6d9ec64e653637a096905b258d2fc2b984c41ae7d08b938a67e4"},
+    {file = "pillow-10.2.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:47c0995fc4e7f79b5cfcab1fc437ff2890b770440f7696a3ba065ee0fd496563"},
+    {file = "pillow-10.2.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:322bdf3c9b556e9ffb18f93462e5f749d3444ce081290352c6070d014c93feb2"},
+    {file = "pillow-10.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:51f1a1bffc50e2e9492e87d8e09a17c5eea8409cda8d3f277eb6edc82813c17c"},
+    {file = "pillow-10.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:69ffdd6120a4737710a9eee73e1d2e37db89b620f702754b8f6e62594471dee0"},
+    {file = "pillow-10.2.0-cp310-cp310-win32.whl", hash = "sha256:c6dafac9e0f2b3c78df97e79af707cdc5ef8e88208d686a4847bab8266870023"},
+    {file = "pillow-10.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:aebb6044806f2e16ecc07b2a2637ee1ef67a11840a66752751714a0d924adf72"},
+    {file = "pillow-10.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:7049e301399273a0136ff39b84c3678e314f2158f50f517bc50285fb5ec847ad"},
+    {file = "pillow-10.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:35bb52c37f256f662abdfa49d2dfa6ce5d93281d323a9af377a120e89a9eafb5"},
+    {file = "pillow-10.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c23f307202661071d94b5e384e1e1dc7dfb972a28a2310e4ee16103e66ddb67"},
+    {file = "pillow-10.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:773efe0603db30c281521a7c0214cad7836c03b8ccff897beae9b47c0b657d61"},
+    {file = "pillow-10.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11fa2e5984b949b0dd6d7a94d967743d87c577ff0b83392f17cb3990d0d2fd6e"},
+    {file = "pillow-10.2.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:716d30ed977be8b37d3ef185fecb9e5a1d62d110dfbdcd1e2a122ab46fddb03f"},
+    {file = "pillow-10.2.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a086c2af425c5f62a65e12fbf385f7c9fcb8f107d0849dba5839461a129cf311"},
+    {file = "pillow-10.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c8de2789052ed501dd829e9cae8d3dcce7acb4777ea4a479c14521c942d395b1"},
+    {file = "pillow-10.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:609448742444d9290fd687940ac0b57fb35e6fd92bdb65386e08e99af60bf757"},
+    {file = "pillow-10.2.0-cp311-cp311-win32.whl", hash = "sha256:823ef7a27cf86df6597fa0671066c1b596f69eba53efa3d1e1cb8b30f3533068"},
+    {file = "pillow-10.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:1da3b2703afd040cf65ec97efea81cfba59cdbed9c11d8efc5ab09df9509fc56"},
+    {file = "pillow-10.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:edca80cbfb2b68d7b56930b84a0e45ae1694aeba0541f798e908a49d66b837f1"},
+    {file = "pillow-10.2.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:1b5e1b74d1bd1b78bc3477528919414874748dd363e6272efd5abf7654e68bef"},
+    {file = "pillow-10.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0eae2073305f451d8ecacb5474997c08569fb4eb4ac231ffa4ad7d342fdc25ac"},
+    {file = "pillow-10.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7c2286c23cd350b80d2fc9d424fc797575fb16f854b831d16fd47ceec078f2c"},
+    {file = "pillow-10.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e23412b5c41e58cec602f1135c57dfcf15482013ce6e5f093a86db69646a5aa"},
+    {file = "pillow-10.2.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:52a50aa3fb3acb9cf7213573ef55d31d6eca37f5709c69e6858fe3bc04a5c2a2"},
+    {file = "pillow-10.2.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:127cee571038f252a552760076407f9cff79761c3d436a12af6000cd182a9d04"},
+    {file = "pillow-10.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:8d12251f02d69d8310b046e82572ed486685c38f02176bd08baf216746eb947f"},
+    {file = "pillow-10.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:54f1852cd531aa981bc0965b7d609f5f6cc8ce8c41b1139f6ed6b3c54ab82bfb"},
+    {file = "pillow-10.2.0-cp312-cp312-win32.whl", hash = "sha256:257d8788df5ca62c980314053197f4d46eefedf4e6175bc9412f14412ec4ea2f"},
+    {file = "pillow-10.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:154e939c5f0053a383de4fd3d3da48d9427a7e985f58af8e94d0b3c9fcfcf4f9"},
+    {file = "pillow-10.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:f379abd2f1e3dddb2b61bc67977a6b5a0a3f7485538bcc6f39ec76163891ee48"},
+    {file = "pillow-10.2.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8373c6c251f7ef8bda6675dd6d2b3a0fcc31edf1201266b5cf608b62a37407f9"},
+    {file = "pillow-10.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:870ea1ada0899fd0b79643990809323b389d4d1d46c192f97342eeb6ee0b8483"},
+    {file = "pillow-10.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4b6b1e20608493548b1f32bce8cca185bf0480983890403d3b8753e44077129"},
+    {file = "pillow-10.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3031709084b6e7852d00479fd1d310b07d0ba82765f973b543c8af5061cf990e"},
+    {file = "pillow-10.2.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:3ff074fc97dd4e80543a3e91f69d58889baf2002b6be64347ea8cf5533188213"},
+    {file = "pillow-10.2.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:cb4c38abeef13c61d6916f264d4845fab99d7b711be96c326b84df9e3e0ff62d"},
+    {file = "pillow-10.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b1b3020d90c2d8e1dae29cf3ce54f8094f7938460fb5ce8bc5c01450b01fbaf6"},
+    {file = "pillow-10.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:170aeb00224ab3dc54230c797f8404507240dd868cf52066f66a41b33169bdbe"},
+    {file = "pillow-10.2.0-cp38-cp38-win32.whl", hash = "sha256:c4225f5220f46b2fde568c74fca27ae9771536c2e29d7c04f4fb62c83275ac4e"},
+    {file = "pillow-10.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:0689b5a8c5288bc0504d9fcee48f61a6a586b9b98514d7d29b840143d6734f39"},
+    {file = "pillow-10.2.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:b792a349405fbc0163190fde0dc7b3fef3c9268292586cf5645598b48e63dc67"},
+    {file = "pillow-10.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c570f24be1e468e3f0ce7ef56a89a60f0e05b30a3669a459e419c6eac2c35364"},
+    {file = "pillow-10.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8ecd059fdaf60c1963c58ceb8997b32e9dc1b911f5da5307aab614f1ce5c2fb"},
+    {file = "pillow-10.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c365fd1703040de1ec284b176d6af5abe21b427cb3a5ff68e0759e1e313a5e7e"},
+    {file = "pillow-10.2.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:70c61d4c475835a19b3a5aa42492409878bbca7438554a1f89d20d58a7c75c01"},
+    {file = "pillow-10.2.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b6f491cdf80ae540738859d9766783e3b3c8e5bd37f5dfa0b76abdecc5081f13"},
+    {file = "pillow-10.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9d189550615b4948f45252d7f005e53c2040cea1af5b60d6f79491a6e147eef7"},
+    {file = "pillow-10.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:49d9ba1ed0ef3e061088cd1e7538a0759aab559e2e0a80a36f9fd9d8c0c21591"},
+    {file = "pillow-10.2.0-cp39-cp39-win32.whl", hash = "sha256:babf5acfede515f176833ed6028754cbcd0d206f7f614ea3447d67c33be12516"},
+    {file = "pillow-10.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:0304004f8067386b477d20a518b50f3fa658a28d44e4116970abfcd94fac34a8"},
+    {file = "pillow-10.2.0-cp39-cp39-win_arm64.whl", hash = "sha256:0fb3e7fc88a14eacd303e90481ad983fd5b69c761e9e6ef94c983f91025da869"},
+    {file = "pillow-10.2.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:322209c642aabdd6207517e9739c704dc9f9db943015535783239022002f054a"},
+    {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3eedd52442c0a5ff4f887fab0c1c0bb164d8635b32c894bc1faf4c618dd89df2"},
+    {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb28c753fd5eb3dd859b4ee95de66cc62af91bcff5db5f2571d32a520baf1f04"},
+    {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:33870dc4653c5017bf4c8873e5488d8f8d5f8935e2f1fb9a2208c47cdd66efd2"},
+    {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:3c31822339516fb3c82d03f30e22b1d038da87ef27b6a78c9549888f8ceda39a"},
+    {file = "pillow-10.2.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a2b56ba36e05f973d450582fb015594aaa78834fefe8dfb8fcd79b93e64ba4c6"},
+    {file = "pillow-10.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:d8e6aeb9201e655354b3ad049cb77d19813ad4ece0df1249d3c793de3774f8c7"},
+    {file = "pillow-10.2.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:2247178effb34a77c11c0e8ac355c7a741ceca0a732b27bf11e747bbc950722f"},
+    {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15587643b9e5eb26c48e49a7b33659790d28f190fc514a322d55da2fb5c2950e"},
+    {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753cd8f2086b2b80180d9b3010dd4ed147efc167c90d3bf593fe2af21265e5a5"},
+    {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7c8f97e8e7a9009bcacbe3766a36175056c12f9a44e6e6f2d5caad06dcfbf03b"},
+    {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d1b35bcd6c5543b9cb547dee3150c93008f8dd0f1fef78fc0cd2b141c5baf58a"},
+    {file = "pillow-10.2.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:fe4c15f6c9285dc54ce6553a3ce908ed37c8f3825b5a51a15c91442bb955b868"},
+    {file = "pillow-10.2.0.tar.gz", hash = "sha256:e87f0b2c78157e12d7686b27d63c070fd65d994e8ddae6f328e0dcf4a0cd007e"},
+]
+
+[package.extras]
+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 = "pinecone-client"
-version = "3.0.2"
+version = "3.0.3"
 description = "Pinecone client and SDK"
 optional = true
 python-versions = ">=3.8,<3.13"
 files = [
-    {file = "pinecone_client-3.0.2-py3-none-any.whl", hash = "sha256:72696c883b47c0f65808bf623aebe940c07bc396f2126b627aad63d6e3cb6c43"},
-    {file = "pinecone_client-3.0.2.tar.gz", hash = "sha256:f9a0830333eece107b4ef1119de23dad6a61bffab7f238e618416d51c46d29c8"},
+    {file = "pinecone_client-3.0.3-py3-none-any.whl", hash = "sha256:940c942aeb259145e1cd6d3f214ad977dbb4dc2e626b3528fb5015c64c3e6190"},
+    {file = "pinecone_client-3.0.3.tar.gz", hash = "sha256:2ad3ef7627edc4d9ee248d9781861c4341d6d27a15bc05f6bef53d958837d374"},
 ]
 
 [package.dependencies]
@@ -2057,6 +2901,20 @@ dense = ["openai (>=1.2.3,<2.0.0)", "sentence-transformers (>=2.0.0)", "torch (>
 openai = ["openai (>=1.2.3,<2.0.0)"]
 splade = ["sentence-transformers (>=2.0.0)", "torch (>=1.13.1)", "transformers (>=4.26.1)"]
 
+[[package]]
+name = "pkginfo"
+version = "1.9.6"
+description = "Query metadata from sdists / bdists / installed packages."
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "pkginfo-1.9.6-py3-none-any.whl", hash = "sha256:4b7a555a6d5a22169fcc9cf7bfd78d296b0361adad412a346c1226849af5e546"},
+    {file = "pkginfo-1.9.6.tar.gz", hash = "sha256:8fd5896e8718a4372f0ea9cc9d96f6417c9b986e23a4d116dda26b62cc29d046"},
+]
+
+[package.extras]
+testing = ["pytest", "pytest-cov"]
+
 [[package]]
 name = "platformdirs"
 version = "4.2.0"
@@ -2103,22 +2961,22 @@ wcwidth = "*"
 
 [[package]]
 name = "protobuf"
-version = "4.25.2"
+version = "4.25.3"
 description = ""
 optional = true
 python-versions = ">=3.8"
 files = [
-    {file = "protobuf-4.25.2-cp310-abi3-win32.whl", hash = "sha256:b50c949608682b12efb0b2717f53256f03636af5f60ac0c1d900df6213910fd6"},
-    {file = "protobuf-4.25.2-cp310-abi3-win_amd64.whl", hash = "sha256:8f62574857ee1de9f770baf04dde4165e30b15ad97ba03ceac65f760ff018ac9"},
-    {file = "protobuf-4.25.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:2db9f8fa64fbdcdc93767d3cf81e0f2aef176284071507e3ede160811502fd3d"},
-    {file = "protobuf-4.25.2-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:10894a2885b7175d3984f2be8d9850712c57d5e7587a2410720af8be56cdaf62"},
-    {file = "protobuf-4.25.2-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:fc381d1dd0516343f1440019cedf08a7405f791cd49eef4ae1ea06520bc1c020"},
-    {file = "protobuf-4.25.2-cp38-cp38-win32.whl", hash = "sha256:33a1aeef4b1927431d1be780e87b641e322b88d654203a9e9d93f218ee359e61"},
-    {file = "protobuf-4.25.2-cp38-cp38-win_amd64.whl", hash = "sha256:47f3de503fe7c1245f6f03bea7e8d3ec11c6c4a2ea9ef910e3221c8a15516d62"},
-    {file = "protobuf-4.25.2-cp39-cp39-win32.whl", hash = "sha256:5e5c933b4c30a988b52e0b7c02641760a5ba046edc5e43d3b94a74c9fc57c1b3"},
-    {file = "protobuf-4.25.2-cp39-cp39-win_amd64.whl", hash = "sha256:d66a769b8d687df9024f2985d5137a337f957a0916cf5464d1513eee96a63ff0"},
-    {file = "protobuf-4.25.2-py3-none-any.whl", hash = "sha256:a8b7a98d4ce823303145bf3c1a8bdb0f2f4642a414b196f04ad9853ed0c8f830"},
-    {file = "protobuf-4.25.2.tar.gz", hash = "sha256:fe599e175cb347efc8ee524bcd4b902d11f7262c0e569ececcb89995c15f0a5e"},
+    {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]]
@@ -2310,6 +3168,38 @@ files = [
 plugins = ["importlib-metadata"]
 windows-terminal = ["colorama (>=0.4.6)"]
 
+[[package]]
+name = "pyloco"
+version = "0.0.139"
+description = "Python Microapplication Launcher"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pyloco-0.0.139-py2.py3-none-any.whl", hash = "sha256:6aeb14954b196c7faef4efd15f92887802e90be138e35a0e64ff1312f847425b"},
+    {file = "pyloco-0.0.139.tar.gz", hash = "sha256:d39537a4006f7522bd8b8d67e5f0abe6a6d9fdc7609a967d8ac6e1cf1df2a3a8"},
+]
+
+[package.dependencies]
+SimpleWebSocketServer = "*"
+twine = "*"
+typing = "*"
+ushlex = "*"
+websocket-client = "*"
+
+[[package]]
+name = "pyparsing"
+version = "3.1.1"
+description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+optional = false
+python-versions = ">=3.6.8"
+files = [
+    {file = "pyparsing-3.1.1-py3-none-any.whl", hash = "sha256:32c7c0b711493c72ff18a981d24f28aaf9c1fb7ed5e9667c9e84e3db623bdbfb"},
+    {file = "pyparsing-3.1.1.tar.gz", hash = "sha256:ede28a1a32462f5a9705e07aea48001a08f7cf81a021585011deba701581a0db"},
+]
+
+[package.extras]
+diagrams = ["jinja2", "railroad-diagrams"]
+
 [[package]]
 name = "pyreadline3"
 version = "3.4.1"
@@ -2412,6 +3302,31 @@ files = [
 [package.dependencies]
 six = ">=1.5"
 
+[[package]]
+name = "python-iso639"
+version = "2024.2.7"
+description = "Look-up utilities for ISO 639 language codes and names"
+optional = true
+python-versions = ">=3.8"
+files = [
+    {file = "python-iso639-2024.2.7.tar.gz", hash = "sha256:c323233348c34d57c601e3e6d824088e492896bcb97a61a87f7d93401a305377"},
+    {file = "python_iso639-2024.2.7-py3-none-any.whl", hash = "sha256:7b149623ff74230f4ee3061fb01d18e57a8d07c5fee2aa72907f39b7f6d16cbc"},
+]
+
+[package.extras]
+dev = ["black (==24.1.1)", "build (==1.0.3)", "flake8 (==7.0.0)", "pytest (==8.0.0)", "twine (==4.0.2)"]
+
+[[package]]
+name = "python-magic"
+version = "0.4.27"
+description = "File type identification using libmagic"
+optional = true
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+files = [
+    {file = "python-magic-0.4.27.tar.gz", hash = "sha256:c1ba14b08e4a5f5c31a302b7721239695b2f0f058d125bd5ce1ee36b9d9d3c3b"},
+    {file = "python_magic-0.4.27-py2.py3-none-any.whl", hash = "sha256:c212960ad306f700aa0d01e5d7a325d20548ff97eb9920dcd29513174f0294d3"},
+]
+
 [[package]]
 name = "pywin32"
 version = "306"
@@ -2435,6 +3350,17 @@ files = [
     {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"},
 ]
 
+[[package]]
+name = "pywin32-ctypes"
+version = "0.2.2"
+description = "A (partial) reimplementation of pywin32 using ctypes/cffi"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "pywin32-ctypes-0.2.2.tar.gz", hash = "sha256:3426e063bdd5fd4df74a14fa3cf80a0b42845a87e1d1e81f6549f9daec593a60"},
+    {file = "pywin32_ctypes-0.2.2-py3-none-any.whl", hash = "sha256:bf490a1a709baf35d688fe0ecf980ed4de11d2b3e37b51e5442587a75d9957e7"},
+]
+
 [[package]]
 name = "pyyaml"
 version = "6.0.1"
@@ -2600,11 +3526,132 @@ files = [
 [package.dependencies]
 cffi = {version = "*", markers = "implementation_name == \"pypy\""}
 
+[[package]]
+name = "rapidfuzz"
+version = "3.6.1"
+description = "rapid fuzzy string matching"
+optional = true
+python-versions = ">=3.8"
+files = [
+    {file = "rapidfuzz-3.6.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ac434fc71edda30d45db4a92ba5e7a42c7405e1a54cb4ec01d03cc668c6dcd40"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2a791168e119cfddf4b5a40470620c872812042f0621e6a293983a2d52372db0"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5a2f3e9df346145c2be94e4d9eeffb82fab0cbfee85bd4a06810e834fe7c03fa"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23de71e7f05518b0bbeef55d67b5dbce3bcd3e2c81e7e533051a2e9401354eb0"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d056e342989248d2bdd67f1955bb7c3b0ecfa239d8f67a8dfe6477b30872c607"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01835d02acd5d95c1071e1da1bb27fe213c84a013b899aba96380ca9962364bc"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed0f712e0bb5fea327e92aec8a937afd07ba8de4c529735d82e4c4124c10d5a0"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96cd19934f76a1264e8ecfed9d9f5291fde04ecb667faef5f33bdbfd95fe2d1f"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e06c4242a1354cf9d48ee01f6f4e6e19c511d50bb1e8d7d20bcadbb83a2aea90"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:d73dcfe789d37c6c8b108bf1e203e027714a239e50ad55572ced3c004424ed3b"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:06e98ff000e2619e7cfe552d086815671ed09b6899408c2c1b5103658261f6f3"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:08b6fb47dd889c69fbc0b915d782aaed43e025df6979b6b7f92084ba55edd526"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a1788ebb5f5b655a15777e654ea433d198f593230277e74d51a2a1e29a986283"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-win32.whl", hash = "sha256:c65f92881753aa1098c77818e2b04a95048f30edbe9c3094dc3707d67df4598b"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:4243a9c35667a349788461aae6471efde8d8800175b7db5148a6ab929628047f"},
+    {file = "rapidfuzz-3.6.1-cp310-cp310-win_arm64.whl", hash = "sha256:f59d19078cc332dbdf3b7b210852ba1f5db8c0a2cd8cc4c0ed84cc00c76e6802"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fbc07e2e4ac696497c5f66ec35c21ddab3fc7a406640bffed64c26ab2f7ce6d6"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:40cced1a8852652813f30fb5d4b8f9b237112a0bbaeebb0f4cc3611502556764"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82300e5f8945d601c2daaaac139d5524d7c1fdf719aa799a9439927739917460"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edf97c321fd641fea2793abce0e48fa4f91f3c202092672f8b5b4e781960b891"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7420e801b00dee4a344ae2ee10e837d603461eb180e41d063699fb7efe08faf0"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:060bd7277dc794279fa95522af355034a29c90b42adcb7aa1da358fc839cdb11"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7e3375e4f2bfec77f907680328e4cd16cc64e137c84b1886d547ab340ba6928"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a490cd645ef9d8524090551016f05f052e416c8adb2d8b85d35c9baa9d0428ab"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2e03038bfa66d2d7cffa05d81c2f18fd6acbb25e7e3c068d52bb7469e07ff382"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:2b19795b26b979c845dba407fe79d66975d520947b74a8ab6cee1d22686f7967"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:064c1d66c40b3a0f488db1f319a6e75616b2e5fe5430a59f93a9a5e40a656d15"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:3c772d04fb0ebeece3109d91f6122b1503023086a9591a0b63d6ee7326bd73d9"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:841eafba6913c4dfd53045835545ba01a41e9644e60920c65b89c8f7e60c00a9"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-win32.whl", hash = "sha256:266dd630f12696ea7119f31d8b8e4959ef45ee2cbedae54417d71ae6f47b9848"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:d79aec8aeee02ab55d0ddb33cea3ecd7b69813a48e423c966a26d7aab025cdfe"},
+    {file = "rapidfuzz-3.6.1-cp311-cp311-win_arm64.whl", hash = "sha256:484759b5dbc5559e76fefaa9170147d1254468f555fd9649aea3bad46162a88b"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b2ef4c0fd3256e357b70591ffb9e8ed1d439fb1f481ba03016e751a55261d7c1"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:588c4b20fa2fae79d60a4e438cf7133d6773915df3cc0a7f1351da19eb90f720"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7142ee354e9c06e29a2636b9bbcb592bb00600a88f02aa5e70e4f230347b373e"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1dfc557c0454ad22382373ec1b7df530b4bbd974335efe97a04caec936f2956a"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:03f73b381bdeccb331a12c3c60f1e41943931461cdb52987f2ecf46bfc22f50d"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6b0ccc2ec1781c7e5370d96aef0573dd1f97335343e4982bdb3a44c133e27786"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da3e8c9f7e64bb17faefda085ff6862ecb3ad8b79b0f618a6cf4452028aa2222"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fde9b14302a31af7bdafbf5cfbb100201ba21519be2b9dedcf4f1048e4fbe65d"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c1a23eee225dfb21c07f25c9fcf23eb055d0056b48e740fe241cbb4b22284379"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e49b9575d16c56c696bc7b06a06bf0c3d4ef01e89137b3ddd4e2ce709af9fe06"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:0a9fc714b8c290261669f22808913aad49553b686115ad0ee999d1cb3df0cd66"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:a3ee4f8f076aa92184e80308fc1a079ac356b99c39408fa422bbd00145be9854"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f056ba42fd2f32e06b2c2ba2443594873cfccc0c90c8b6327904fc2ddf6d5799"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-win32.whl", hash = "sha256:5d82b9651e3d34b23e4e8e201ecd3477c2baa17b638979deeabbb585bcb8ba74"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:dad55a514868dae4543ca48c4e1fc0fac704ead038dafedf8f1fc0cc263746c1"},
+    {file = "rapidfuzz-3.6.1-cp312-cp312-win_arm64.whl", hash = "sha256:3c84294f4470fcabd7830795d754d808133329e0a81d62fcc2e65886164be83b"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e19d519386e9db4a5335a4b29f25b8183a1c3f78cecb4c9c3112e7f86470e37f"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:01eb03cd880a294d1bf1a583fdd00b87169b9cc9c9f52587411506658c864d73"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:be368573255f8fbb0125a78330a1a40c65e9ba3c5ad129a426ff4289099bfb41"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3e5af946f419c30f5cb98b69d40997fe8580efe78fc83c2f0f25b60d0e56efb"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f382f7ffe384ce34345e1c0b2065451267d3453cadde78946fbd99a59f0cc23c"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be156f51f3a4f369e758505ed4ae64ea88900dcb2f89d5aabb5752676d3f3d7e"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1936d134b6c513fbe934aeb668b0fee1ffd4729a3c9d8d373f3e404fbb0ce8a0"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12ff8eaf4a9399eb2bebd838f16e2d1ded0955230283b07376d68947bbc2d33d"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:ae598a172e3a95df3383634589660d6b170cc1336fe7578115c584a99e0ba64d"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:cd4ba4c18b149da11e7f1b3584813159f189dc20833709de5f3df8b1342a9759"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:0402f1629e91a4b2e4aee68043a30191e5e1b7cd2aa8dacf50b1a1bcf6b7d3ab"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:1e12319c6b304cd4c32d5db00b7a1e36bdc66179c44c5707f6faa5a889a317c0"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:0bbfae35ce4de4c574b386c43c78a0be176eeddfdae148cb2136f4605bebab89"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-win32.whl", hash = "sha256:7fec74c234d3097612ea80f2a80c60720eec34947066d33d34dc07a3092e8105"},
+    {file = "rapidfuzz-3.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:a553cc1a80d97459d587529cc43a4c7c5ecf835f572b671107692fe9eddf3e24"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:757dfd7392ec6346bd004f8826afb3bf01d18a723c97cbe9958c733ab1a51791"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2963f4a3f763870a16ee076796be31a4a0958fbae133dbc43fc55c3968564cf5"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d2f0274595cc5b2b929c80d4e71b35041104b577e118cf789b3fe0a77b37a4c5"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f211e366e026de110a4246801d43a907cd1a10948082f47e8a4e6da76fef52"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a59472b43879012b90989603aa5a6937a869a72723b1bf2ff1a0d1edee2cc8e6"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a03863714fa6936f90caa7b4b50ea59ea32bb498cc91f74dc25485b3f8fccfe9"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5dd95b6b7bfb1584f806db89e1e0c8dbb9d25a30a4683880c195cc7f197eaf0c"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7183157edf0c982c0b8592686535c8b3e107f13904b36d85219c77be5cefd0d8"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ad9d74ef7c619b5b0577e909582a1928d93e07d271af18ba43e428dc3512c2a1"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:b53137d81e770c82189e07a8f32722d9e4260f13a0aec9914029206ead38cac3"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:49b9ed2472394d306d5dc967a7de48b0aab599016aa4477127b20c2ed982dbf9"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:dec307b57ec2d5054d77d03ee4f654afcd2c18aee00c48014cb70bfed79597d6"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4381023fa1ff32fd5076f5d8321249a9aa62128eb3f21d7ee6a55373e672b261"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-win32.whl", hash = "sha256:8d7a072f10ee57c8413c8ab9593086d42aaff6ee65df4aa6663eecdb7c398dca"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:ebcfb5bfd0a733514352cfc94224faad8791e576a80ffe2fd40b2177bf0e7198"},
+    {file = "rapidfuzz-3.6.1-cp39-cp39-win_arm64.whl", hash = "sha256:1c47d592e447738744905c18dda47ed155620204714e6df20eb1941bb1ba315e"},
+    {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:eef8b346ab331bec12bbc83ac75641249e6167fab3d84d8f5ca37fd8e6c7a08c"},
+    {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:53251e256017e2b87f7000aee0353ba42392c442ae0bafd0f6b948593d3f68c6"},
+    {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6dede83a6b903e3ebcd7e8137e7ff46907ce9316e9d7e7f917d7e7cdc570ee05"},
+    {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4da90e4c2b444d0a171d7444ea10152e07e95972bb40b834a13bdd6de1110c"},
+    {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ca3dfcf74f2b6962f411c33dd95b0adf3901266e770da6281bc96bb5a8b20de9"},
+    {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bcc957c0a8bde8007f1a8a413a632a1a409890f31f73fe764ef4eac55f59ca87"},
+    {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:692c9a50bea7a8537442834f9bc6b7d29d8729a5b6379df17c31b6ab4df948c2"},
+    {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76c23ceaea27e790ddd35ef88b84cf9d721806ca366199a76fd47cfc0457a81b"},
+    {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b155e67fff215c09f130555002e42f7517d0ea72cbd58050abb83cb7c880cec"},
+    {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3028ee8ecc48250607fa8a0adce37b56275ec3b1acaccd84aee1f68487c8557b"},
+    {file = "rapidfuzz-3.6.1.tar.gz", hash = "sha256:35660bee3ce1204872574fa041c7ad7ec5175b3053a4cb6e181463fc07013de7"},
+]
+
+[package.extras]
+full = ["numpy"]
+
+[[package]]
+name = "readme-renderer"
+version = "42.0"
+description = "readme_renderer is a library for rendering readme descriptions for Warehouse"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "readme_renderer-42.0-py3-none-any.whl", hash = "sha256:13d039515c1f24de668e2c93f2e877b9dbe6c6c32328b90a40a49d8b2b85f36d"},
+    {file = "readme_renderer-42.0.tar.gz", hash = "sha256:2d55489f83be4992fe4454939d1a051c33edbab778e82761d060c9fc6b308cd1"},
+]
+
+[package.dependencies]
+docutils = ">=0.13.1"
+nh3 = ">=0.2.14"
+Pygments = ">=2.5.1"
+
+[package.extras]
+md = ["cmarkgfm (>=0.8.0)"]
+
 [[package]]
 name = "regex"
 version = "2023.12.25"
 description = "Alternative regular expression module, to replace re."
-optional = true
+optional = false
 python-versions = ">=3.7"
 files = [
     {file = "regex-2023.12.25-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0694219a1d54336fd0445ea382d49d36882415c0134ee1e8332afd1529f0baa5"},
@@ -2723,6 +3770,52 @@ urllib3 = ">=1.21.1,<3"
 socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+description = "A utility belt for advanced users of python-requests"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"},
+    {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"},
+]
+
+[package.dependencies]
+requests = ">=2.0.1,<3.0.0"
+
+[[package]]
+name = "rfc3986"
+version = "2.0.0"
+description = "Validating URI References per RFC 3986"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd"},
+    {file = "rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c"},
+]
+
+[package.extras]
+idna2008 = ["idna"]
+
+[[package]]
+name = "rich"
+version = "13.7.0"
+description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal"
+optional = false
+python-versions = ">=3.7.0"
+files = [
+    {file = "rich-13.7.0-py3-none-any.whl", hash = "sha256:6da14c108c4866ee9520bbffa71f6fe3962e193b7da68720583850cd4548e235"},
+    {file = "rich-13.7.0.tar.gz", hash = "sha256:5cb5123b5cf9ee70584244246816e9114227e0b98ad9176eede6ad54bf5403fa"},
+]
+
+[package.dependencies]
+markdown-it-py = ">=2.2.0"
+pygments = ">=2.13.0,<3.0.0"
+
+[package.extras]
+jupyter = ["ipywidgets (>=7.5.1,<9)"]
+
 [[package]]
 name = "ruff"
 version = "0.1.15"
@@ -2881,6 +3974,31 @@ tensorflow = ["safetensors[numpy]", "tensorflow (>=2.11.0)"]
 testing = ["h5py (>=3.7.0)", "huggingface_hub (>=0.12.1)", "hypothesis (>=6.70.2)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "safetensors[numpy]", "setuptools_rust (>=1.5.2)"]
 torch = ["safetensors[numpy]", "torch (>=1.10)"]
 
+[[package]]
+name = "secretstorage"
+version = "3.3.3"
+description = "Python bindings to FreeDesktop.org Secret Service API"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "SecretStorage-3.3.3-py3-none-any.whl", hash = "sha256:f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99"},
+    {file = "SecretStorage-3.3.3.tar.gz", hash = "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77"},
+]
+
+[package.dependencies]
+cryptography = ">=2.0"
+jeepney = ">=0.6"
+
+[[package]]
+name = "simplewebsocketserver"
+version = "0.1.2"
+description = "A Simple Websocket Server written in Python"
+optional = false
+python-versions = "*"
+files = [
+    {file = "SimpleWebSocketServer-0.1.2.tar.gz", hash = "sha256:48615b8769d6a01e58375a3399117c9c240ba649a15f8c7720d68b23949eff66"},
+]
+
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -2903,6 +4021,17 @@ files = [
     {file = "sniffio-1.3.0.tar.gz", hash = "sha256:e60305c5e5d314f5389259b7f22aaa33d8f7dee49763119234af3755c55b9101"},
 ]
 
+[[package]]
+name = "soupsieve"
+version = "2.5"
+description = "A modern CSS selector implementation for Beautiful Soup."
+optional = true
+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"},
+]
+
 [[package]]
 name = "stack-data"
 version = "0.6.3"
@@ -2922,6 +4051,17 @@ pure-eval = "*"
 [package.extras]
 tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"]
 
+[[package]]
+name = "style"
+version = "1.1.0"
+description = "🌈 Terminal string styling"
+optional = false
+python-versions = "*"
+files = [
+    {file = "style-1.1.0-py2.py3-none-any.whl", hash = "sha256:6485a4bcb84629341a5fd1587fe3ac4887daa4741f0c8a1d01b9c3c8a263afe7"},
+    {file = "style-1.1.0.tar.gz", hash = "sha256:8eb365fc15039b19b728bd4e6e85fb7daf24e7aeeec6a15a666f97484c564005"},
+]
+
 [[package]]
 name = "sympy"
 version = "1.12"
@@ -2936,6 +4076,20 @@ files = [
 [package.dependencies]
 mpmath = ">=0.19"
 
+[[package]]
+name = "tabulate"
+version = "0.9.0"
+description = "Pretty-print tabular data"
+optional = true
+python-versions = ">=3.7"
+files = [
+    {file = "tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f"},
+    {file = "tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c"},
+]
+
+[package.extras]
+widechars = ["wcwidth"]
+
 [[package]]
 name = "termcolor"
 version = "2.4.0"
@@ -2950,123 +4104,175 @@ files = [
 [package.extras]
 tests = ["pytest", "pytest-cov"]
 
+[[package]]
+name = "tiktoken"
+version = "0.6.0"
+description = "tiktoken is a fast BPE tokeniser for use with OpenAI's models"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "tiktoken-0.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:277de84ccd8fa12730a6b4067456e5cf72fef6300bea61d506c09e45658d41ac"},
+    {file = "tiktoken-0.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9c44433f658064463650d61387623735641dcc4b6c999ca30bc0f8ba3fccaf5c"},
+    {file = "tiktoken-0.6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afb9a2a866ae6eef1995ab656744287a5ac95acc7e0491c33fad54d053288ad3"},
+    {file = "tiktoken-0.6.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c62c05b3109fefca26fedb2820452a050074ad8e5ad9803f4652977778177d9f"},
+    {file = "tiktoken-0.6.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0ef917fad0bccda07bfbad835525bbed5f3ab97a8a3e66526e48cdc3e7beacf7"},
+    {file = "tiktoken-0.6.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e095131ab6092d0769a2fda85aa260c7c383072daec599ba9d8b149d2a3f4d8b"},
+    {file = "tiktoken-0.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:05b344c61779f815038292a19a0c6eb7098b63c8f865ff205abb9ea1b656030e"},
+    {file = "tiktoken-0.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cefb9870fb55dca9e450e54dbf61f904aab9180ff6fe568b61f4db9564e78871"},
+    {file = "tiktoken-0.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:702950d33d8cabc039845674107d2e6dcabbbb0990ef350f640661368df481bb"},
+    {file = "tiktoken-0.6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8d49d076058f23254f2aff9af603863c5c5f9ab095bc896bceed04f8f0b013a"},
+    {file = "tiktoken-0.6.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:430bc4e650a2d23a789dc2cdca3b9e5e7eb3cd3935168d97d43518cbb1f9a911"},
+    {file = "tiktoken-0.6.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:293cb8669757301a3019a12d6770bd55bec38a4d3ee9978ddbe599d68976aca7"},
+    {file = "tiktoken-0.6.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7bd1a288b7903aadc054b0e16ea78e3171f70b670e7372432298c686ebf9dd47"},
+    {file = "tiktoken-0.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac76e000183e3b749634968a45c7169b351e99936ef46f0d2353cd0d46c3118d"},
+    {file = "tiktoken-0.6.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:17cc8a4a3245ab7d935c83a2db6bb71619099d7284b884f4b2aea4c74f2f83e3"},
+    {file = "tiktoken-0.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:284aebcccffe1bba0d6571651317df6a5b376ff6cfed5aeb800c55df44c78177"},
+    {file = "tiktoken-0.6.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0c1a3a5d33846f8cd9dd3b7897c1d45722f48625a587f8e6f3d3e85080559be8"},
+    {file = "tiktoken-0.6.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6318b2bb2337f38ee954fd5efa82632c6e5ced1d52a671370fa4b2eff1355e91"},
+    {file = "tiktoken-0.6.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1f5f0f2ed67ba16373f9a6013b68da298096b27cd4e1cf276d2d3868b5c7efd1"},
+    {file = "tiktoken-0.6.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:75af4c0b16609c2ad02581f3cdcd1fb698c7565091370bf6c0cf8624ffaba6dc"},
+    {file = "tiktoken-0.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:45577faf9a9d383b8fd683e313cf6df88b6076c034f0a16da243bb1c139340c3"},
+    {file = "tiktoken-0.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7c1492ab90c21ca4d11cef3a236ee31a3e279bb21b3fc5b0e2210588c4209e68"},
+    {file = "tiktoken-0.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e2b380c5b7751272015400b26144a2bab4066ebb8daae9c3cd2a92c3b508fe5a"},
+    {file = "tiktoken-0.6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9f497598b9f58c99cbc0eb764b4a92272c14d5203fc713dd650b896a03a50ad"},
+    {file = "tiktoken-0.6.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e65e8bd6f3f279d80f1e1fbd5f588f036b9a5fa27690b7f0cc07021f1dfa0839"},
+    {file = "tiktoken-0.6.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5f1495450a54e564d236769d25bfefbf77727e232d7a8a378f97acddee08c1ae"},
+    {file = "tiktoken-0.6.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6c4e4857d99f6fb4670e928250835b21b68c59250520a1941618b5b4194e20c3"},
+    {file = "tiktoken-0.6.0-cp38-cp38-win_amd64.whl", hash = "sha256:168d718f07a39b013032741867e789971346df8e89983fe3c0ef3fbd5a0b1cb9"},
+    {file = "tiktoken-0.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:47fdcfe11bd55376785a6aea8ad1db967db7f66ea81aed5c43fad497521819a4"},
+    {file = "tiktoken-0.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fb7d2ccbf1a7784810aff6b80b4012fb42c6fc37eaa68cb3b553801a5cc2d1fc"},
+    {file = "tiktoken-0.6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ccb7a111ee76af5d876a729a347f8747d5ad548e1487eeea90eaf58894b3138"},
+    {file = "tiktoken-0.6.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2048e1086b48e3c8c6e2ceeac866561374cd57a84622fa49a6b245ffecb7744"},
+    {file = "tiktoken-0.6.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:07f229a5eb250b6403a61200199cecf0aac4aa23c3ecc1c11c1ca002cbb8f159"},
+    {file = "tiktoken-0.6.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:432aa3be8436177b0db5a2b3e7cc28fd6c693f783b2f8722539ba16a867d0c6a"},
+    {file = "tiktoken-0.6.0-cp39-cp39-win_amd64.whl", hash = "sha256:8bfe8a19c8b5c40d121ee7938cd9c6a278e5b97dc035fd61714b4f0399d2f7a1"},
+    {file = "tiktoken-0.6.0.tar.gz", hash = "sha256:ace62a4ede83c75b0374a2ddfa4b76903cf483e9cb06247f566be3bf14e6beed"},
+]
+
+[package.dependencies]
+regex = ">=2022.1.18"
+requests = ">=2.26.0"
+
+[package.extras]
+blobfile = ["blobfile (>=2)"]
+
 [[package]]
 name = "tokenizers"
-version = "0.15.1"
+version = "0.15.2"
 description = ""
 optional = true
 python-versions = ">=3.7"
 files = [
-    {file = "tokenizers-0.15.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:32c9491dd1bcb33172c26b454dbd607276af959b9e78fa766e2694cafab3103c"},
-    {file = "tokenizers-0.15.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29a1b784b870a097e7768f8c20c2dd851e2c75dad3efdae69a79d3e7f1d614d5"},
-    {file = "tokenizers-0.15.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0049fbe648af04148b08cb211994ce8365ee628ce49724b56aaefd09a3007a78"},
-    {file = "tokenizers-0.15.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e84b3c235219e75e24de6b71e6073cd2c8d740b14d88e4c6d131b90134e3a338"},
-    {file = "tokenizers-0.15.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8cc575769ea11d074308c6d71cb10b036cdaec941562c07fc7431d956c502f0e"},
-    {file = "tokenizers-0.15.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:22bf28f299c4158e6d0b5eaebddfd500c4973d947ffeaca8bcbe2e8c137dff0b"},
-    {file = "tokenizers-0.15.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:506555f98361db9c74e1323a862d77dcd7d64c2058829a368bf4159d986e339f"},
-    {file = "tokenizers-0.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7061b0a28ade15906f5b2ec8c48d3bdd6e24eca6b427979af34954fbe31d5cef"},
-    {file = "tokenizers-0.15.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7ed5e35507b7a0e2aac3285c4f5e37d4ec5cfc0e5825b862b68a0aaf2757af52"},
-    {file = "tokenizers-0.15.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1c9df9247df0de6509dd751b1c086e5f124b220133b5c883bb691cb6fb3d786f"},
-    {file = "tokenizers-0.15.1-cp310-none-win32.whl", hash = "sha256:dd999af1b4848bef1b11d289f04edaf189c269d5e6afa7a95fa1058644c3f021"},
-    {file = "tokenizers-0.15.1-cp310-none-win_amd64.whl", hash = "sha256:39d06a57f7c06940d602fad98702cf7024c4eee7f6b9fe76b9f2197d5a4cc7e2"},
-    {file = "tokenizers-0.15.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8ad034eb48bf728af06915e9294871f72fcc5254911eddec81d6df8dba1ce055"},
-    {file = "tokenizers-0.15.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ea9ede7c42f8fa90f31bfc40376fd91a7d83a4aa6ad38e6076de961d48585b26"},
-    {file = "tokenizers-0.15.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b85d6fe1a20d903877aa0ef32ef6b96e81e0e48b71c206d6046ce16094de6970"},
-    {file = "tokenizers-0.15.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a7d44f656320137c7d643b9c7dcc1814763385de737fb98fd2643880910f597"},
-    {file = "tokenizers-0.15.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd244bd0793cdacf27ee65ec3db88c21f5815460e8872bbeb32b040469d6774e"},
-    {file = "tokenizers-0.15.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f3f4a36e371b3cb1123adac8aeeeeab207ad32f15ed686d9d71686a093bb140"},
-    {file = "tokenizers-0.15.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c2921a53966afb29444da98d56a6ccbef23feb3b0c0f294b4e502370a0a64f25"},
-    {file = "tokenizers-0.15.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f49068cf51f49c231067f1a8c9fc075ff960573f6b2a956e8e1b0154fb638ea5"},
-    {file = "tokenizers-0.15.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0ab1a22f20eaaab832ab3b00a0709ca44a0eb04721e580277579411b622c741c"},
-    {file = "tokenizers-0.15.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:671268f24b607c4adc6fa2b5b580fd4211b9f84b16bd7f46d62f8e5be0aa7ba4"},
-    {file = "tokenizers-0.15.1-cp311-none-win32.whl", hash = "sha256:a4f03e33d2bf7df39c8894032aba599bf90f6f6378e683a19d28871f09bb07fc"},
-    {file = "tokenizers-0.15.1-cp311-none-win_amd64.whl", hash = "sha256:30f689537bcc7576d8bd4daeeaa2cb8f36446ba2f13f421b173e88f2d8289c4e"},
-    {file = "tokenizers-0.15.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0f3a379dd0898a82ea3125e8f9c481373f73bffce6430d4315f0b6cd5547e409"},
-    {file = "tokenizers-0.15.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d870ae58bba347d38ac3fc8b1f662f51e9c95272d776dd89f30035c83ee0a4f"},
-    {file = "tokenizers-0.15.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d6d28e0143ec2e253a8a39e94bf1d24776dbe73804fa748675dbffff4a5cd6d8"},
-    {file = "tokenizers-0.15.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:61ae9ac9f44e2da128ee35db69489883b522f7abe033733fa54eb2de30dac23d"},
-    {file = "tokenizers-0.15.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d8e322a47e29128300b3f7749a03c0ec2bce0a3dc8539ebff738d3f59e233542"},
-    {file = "tokenizers-0.15.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:760334f475443bc13907b1a8e1cb0aeaf88aae489062546f9704dce6c498bfe2"},
-    {file = "tokenizers-0.15.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1b173753d4aca1e7d0d4cb52b5e3ffecfb0ca014e070e40391b6bb4c1d6af3f2"},
-    {file = "tokenizers-0.15.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82c1f13d457c8f0ab17e32e787d03470067fe8a3b4d012e7cc57cb3264529f4a"},
-    {file = "tokenizers-0.15.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:425b46ceff4505f20191df54b50ac818055d9d55023d58ae32a5d895b6f15bb0"},
-    {file = "tokenizers-0.15.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:681ac6ba3b4fdaf868ead8971221a061f580961c386e9732ea54d46c7b72f286"},
-    {file = "tokenizers-0.15.1-cp312-none-win32.whl", hash = "sha256:f2272656063ccfba2044df2115095223960d80525d208e7a32f6c01c351a6f4a"},
-    {file = "tokenizers-0.15.1-cp312-none-win_amd64.whl", hash = "sha256:9abe103203b1c6a2435d248d5ff4cceebcf46771bfbc4957a98a74da6ed37674"},
-    {file = "tokenizers-0.15.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:2ce9ed5c8ef26b026a66110e3c7b73d93ec2d26a0b1d0ea55ddce61c0e5f446f"},
-    {file = "tokenizers-0.15.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:89b24d366137986c3647baac29ef902d2d5445003d11c30df52f1bd304689aeb"},
-    {file = "tokenizers-0.15.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0faebedd01b413ab777ca0ee85914ed8b031ea5762ab0ea60b707ce8b9be6842"},
-    {file = "tokenizers-0.15.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdbd9dfcdad4f3b95d801f768e143165165055c18e44ca79a8a26de889cd8e85"},
-    {file = "tokenizers-0.15.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:97194324c12565b07e9993ca9aa813b939541185682e859fb45bb8d7d99b3193"},
-    {file = "tokenizers-0.15.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:485e43e2cc159580e0d83fc919ec3a45ae279097f634b1ffe371869ffda5802c"},
-    {file = "tokenizers-0.15.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:191d084d60e3589d6420caeb3f9966168269315f8ec7fbc3883122dc9d99759d"},
-    {file = "tokenizers-0.15.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01c28cc8d7220634a75b14c53f4fc9d1b485f99a5a29306a999c115921de2897"},
-    {file = "tokenizers-0.15.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:325212027745d3f8d5d5006bb9e5409d674eb80a184f19873f4f83494e1fdd26"},
-    {file = "tokenizers-0.15.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3c5573603c36ce12dbe318bcfb490a94cad2d250f34deb2f06cb6937957bbb71"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-macosx_10_12_x86_64.whl", hash = "sha256:1441161adb6d71a15a630d5c1d8659d5ebe41b6b209586fbeea64738e58fcbb2"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-macosx_11_0_arm64.whl", hash = "sha256:382a8d0c31afcfb86571afbfefa37186df90865ce3f5b731842dab4460e53a38"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e76959783e3f4ec73b3f3d24d4eec5aa9225f0bee565c48e77f806ed1e048f12"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:401df223e5eb927c5961a0fc6b171818a2bba01fb36ef18c3e1b69b8cd80e591"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c52606c233c759561a16e81b2290a7738c3affac7a0b1f0a16fe58dc22e04c7d"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b72c658bbe5a05ed8bc2ac5ad782385bfd743ffa4bc87d9b5026341e709c6f44"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:25f5643a2f005c42f0737a326c6c6bdfedfdc9a994b10a1923d9c3e792e4d6a6"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c5b6f633999d6b42466bbfe21be2e26ad1760b6f106967a591a41d8cbca980e"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:ceb5c9ad11a015150b545c1a11210966a45b8c3d68a942e57cf8938c578a77ca"},
-    {file = "tokenizers-0.15.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:bedd4ce0c4872db193444c395b11c7697260ce86a635ab6d48102d76be07d324"},
-    {file = "tokenizers-0.15.1-cp37-none-win32.whl", hash = "sha256:cd6caef6c14f5ed6d35f0ddb78eab8ca6306d0cd9870330bccff72ad014a6f42"},
-    {file = "tokenizers-0.15.1-cp37-none-win_amd64.whl", hash = "sha256:d2bd7af78f58d75a55e5df61efae164ab9200c04b76025f9cc6eeb7aff3219c2"},
-    {file = "tokenizers-0.15.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:59b3ca6c02e0bd5704caee274978bd055de2dff2e2f39dadf536c21032dfd432"},
-    {file = "tokenizers-0.15.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:48fe21b67c22583bed71933a025fd66b1f5cfae1baefa423c3d40379b5a6e74e"},
-    {file = "tokenizers-0.15.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3d190254c66a20fb1efbdf035e6333c5e1f1c73b1f7bfad88f9c31908ac2c2c4"},
-    {file = "tokenizers-0.15.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fef90c8f5abf17d48d6635f5fd92ad258acd1d0c2d920935c8bf261782cfe7c8"},
-    {file = "tokenizers-0.15.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fac011ef7da3357aa7eb19efeecf3d201ede9618f37ddedddc5eb809ea0963ca"},
-    {file = "tokenizers-0.15.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:574ec5b3e71d1feda6b0ecac0e0445875729b4899806efbe2b329909ec75cb50"},
-    {file = "tokenizers-0.15.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aca16c3c0637c051a59ea99c4253f16fbb43034fac849076a7e7913b2b9afd2d"},
-    {file = "tokenizers-0.15.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a6f238fc2bbfd3e12e8529980ec1624c7e5b69d4e959edb3d902f36974f725a"},
-    {file = "tokenizers-0.15.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:587e11a26835b73c31867a728f32ca8a93c9ded4a6cd746516e68b9d51418431"},
-    {file = "tokenizers-0.15.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6456e7ad397352775e2efdf68a9ec5d6524bbc4543e926eef428d36de627aed4"},
-    {file = "tokenizers-0.15.1-cp38-none-win32.whl", hash = "sha256:614f0da7dd73293214bd143e6221cafd3f7790d06b799f33a987e29d057ca658"},
-    {file = "tokenizers-0.15.1-cp38-none-win_amd64.whl", hash = "sha256:a4fa0a20d9f69cc2bf1cfce41aa40588598e77ec1d6f56bf0eb99769969d1ede"},
-    {file = "tokenizers-0.15.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:8d3f18a45e0cf03ce193d5900460dc2430eec4e14c786e5d79bddba7ea19034f"},
-    {file = "tokenizers-0.15.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:38dbd6c38f88ad7d5dc5d70c764415d38fe3bcd99dc81638b572d093abc54170"},
-    {file = "tokenizers-0.15.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:777286b1f7e52de92aa4af49fe31046cfd32885d1bbaae918fab3bba52794c33"},
-    {file = "tokenizers-0.15.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58d4d550a3862a47dd249892d03a025e32286eb73cbd6bc887fb8fb64bc97165"},
-    {file = "tokenizers-0.15.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4eda68ce0344f35042ae89220b40a0007f721776b727806b5c95497b35714bb7"},
-    {file = "tokenizers-0.15.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cd33d15f7a3a784c3b665cfe807b8de3c6779e060349bd5005bb4ae5bdcb437"},
-    {file = "tokenizers-0.15.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0a1aa370f978ac0bfb50374c3a40daa93fd56d47c0c70f0c79607fdac2ccbb42"},
-    {file = "tokenizers-0.15.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:241482b940340fff26a2708cb9ba383a5bb8a2996d67a0ff2c4367bf4b86cc3a"},
-    {file = "tokenizers-0.15.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:68f30b05f46a4d9aba88489eadd021904afe90e10a7950e28370d6e71b9db021"},
-    {file = "tokenizers-0.15.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5a3c5d8025529670462b881b7b2527aacb6257398c9ec8e170070432c3ae3a82"},
-    {file = "tokenizers-0.15.1-cp39-none-win32.whl", hash = "sha256:74d1827830f60a9d78da8f6d49a1fbea5422ce0eea42e2617877d23380a7efbc"},
-    {file = "tokenizers-0.15.1-cp39-none-win_amd64.whl", hash = "sha256:9ff499923e4d6876d6b6a63ea84a56805eb35e91dd89b933a7aee0c56a3838c6"},
-    {file = "tokenizers-0.15.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b3aa007a0f4408f62a8471bdaa3faccad644cbf2622639f2906b4f9b5339e8b8"},
-    {file = "tokenizers-0.15.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:f3d4176fa93d8b2070db8f3c70dc21106ae6624fcaaa334be6bdd3a0251e729e"},
-    {file = "tokenizers-0.15.1-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1d0e463655ef8b2064df07bd4a445ed7f76f6da3b286b4590812587d42f80e89"},
-    {file = "tokenizers-0.15.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:089138fd0351b62215c462a501bd68b8df0e213edcf99ab9efd5dba7b4cb733e"},
-    {file = "tokenizers-0.15.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e563ac628f5175ed08e950430e2580e544b3e4b606a0995bb6b52b3a3165728"},
-    {file = "tokenizers-0.15.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:244dcc28c5fde221cb4373961b20da30097669005b122384d7f9f22752487a46"},
-    {file = "tokenizers-0.15.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:d82951d46052dddae1369e68ff799a0e6e29befa9a0b46e387ae710fd4daefb0"},
-    {file = "tokenizers-0.15.1-pp37-pypy37_pp73-macosx_10_12_x86_64.whl", hash = "sha256:7b14296bc9059849246ceb256ffbe97f8806a9b5d707e0095c22db312f4fc014"},
-    {file = "tokenizers-0.15.1-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0309357bb9b6c8d86cdf456053479d7112074b470651a997a058cd7ad1c4ea57"},
-    {file = "tokenizers-0.15.1-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:083f06e9d8d01b70b67bcbcb7751b38b6005512cce95808be6bf34803534a7e7"},
-    {file = "tokenizers-0.15.1-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85288aea86ada579789447f0dcec108ebef8da4b450037eb4813d83e4da9371e"},
-    {file = "tokenizers-0.15.1-pp37-pypy37_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:385e6fcb01e8de90c1d157ae2a5338b23368d0b1c4cc25088cdca90147e35d17"},
-    {file = "tokenizers-0.15.1-pp37-pypy37_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:60067edfcbf7d6cd448ac47af41ec6e84377efbef7be0c06f15a7c1dd069e044"},
-    {file = "tokenizers-0.15.1-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5f7e37f89acfe237d4eaf93c3b69b0f01f407a7a5d0b5a8f06ba91943ea3cf10"},
-    {file = "tokenizers-0.15.1-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:6a63a15b523d42ebc1f4028e5a568013388c2aefa4053a263e511cb10aaa02f1"},
-    {file = "tokenizers-0.15.1-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:2417d9e4958a6c2fbecc34c27269e74561c55d8823bf914b422e261a11fdd5fd"},
-    {file = "tokenizers-0.15.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8550974bace6210e41ab04231e06408cf99ea4279e0862c02b8d47e7c2b2828"},
-    {file = "tokenizers-0.15.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:194ba82129b171bcd29235a969e5859a93e491e9b0f8b2581f500f200c85cfdd"},
-    {file = "tokenizers-0.15.1-pp38-pypy38_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:1bfd95eef8b01e6c0805dbccc8eaf41d8c5a84f0cce72c0ab149fe76aae0bce6"},
-    {file = "tokenizers-0.15.1-pp38-pypy38_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b87a15dd72f8216b03c151e3dace00c75c3fe7b0ee9643c25943f31e582f1a34"},
-    {file = "tokenizers-0.15.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6ac22f358a0c2a6c685be49136ce7ea7054108986ad444f567712cf274b34cd8"},
-    {file = "tokenizers-0.15.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1e9d1f046a9b9d9a95faa103f07db5921d2c1c50f0329ebba4359350ee02b18b"},
-    {file = "tokenizers-0.15.1-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:2a0fd30a4b74485f6a7af89fffb5fb84d6d5f649b3e74f8d37f624cc9e9e97cf"},
-    {file = "tokenizers-0.15.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:80e45dc206b9447fa48795a1247c69a1732d890b53e2cc51ba42bc2fefa22407"},
-    {file = "tokenizers-0.15.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4eaff56ef3e218017fa1d72007184401f04cb3a289990d2b6a0a76ce71c95f96"},
-    {file = "tokenizers-0.15.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:b41dc107e4a4e9c95934e79b025228bbdda37d9b153d8b084160e88d5e48ad6f"},
-    {file = "tokenizers-0.15.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:1922b8582d0c33488764bcf32e80ef6054f515369e70092729c928aae2284bc2"},
-    {file = "tokenizers-0.15.1.tar.gz", hash = "sha256:c0a331d6d5a3d6e97b7f99f562cee8d56797180797bc55f12070e495e717c980"},
+    {file = "tokenizers-0.15.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:52f6130c9cbf70544287575a985bf44ae1bda2da7e8c24e97716080593638012"},
+    {file = "tokenizers-0.15.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:054c1cc9c6d68f7ffa4e810b3d5131e0ba511b6e4be34157aa08ee54c2f8d9ee"},
+    {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a9b9b070fdad06e347563b88c278995735292ded1132f8657084989a4c84a6d5"},
+    {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea621a7eef4b70e1f7a4e84dd989ae3f0eeb50fc8690254eacc08acb623e82f1"},
+    {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cf7fd9a5141634fa3aa8d6b7be362e6ae1b4cda60da81388fa533e0b552c98fd"},
+    {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44f2a832cd0825295f7179eaf173381dc45230f9227ec4b44378322d900447c9"},
+    {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8b9ec69247a23747669ec4b0ca10f8e3dfb3545d550258129bd62291aabe8605"},
+    {file = "tokenizers-0.15.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40b6a4c78da863ff26dbd5ad9a8ecc33d8a8d97b535172601cf00aee9d7ce9ce"},
+    {file = "tokenizers-0.15.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:5ab2a4d21dcf76af60e05af8063138849eb1d6553a0d059f6534357bce8ba364"},
+    {file = "tokenizers-0.15.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a47acfac7e511f6bbfcf2d3fb8c26979c780a91e06fb5b9a43831b2c0153d024"},
+    {file = "tokenizers-0.15.2-cp310-none-win32.whl", hash = "sha256:064ff87bb6acdbd693666de9a4b692add41308a2c0ec0770d6385737117215f2"},
+    {file = "tokenizers-0.15.2-cp310-none-win_amd64.whl", hash = "sha256:3b919afe4df7eb6ac7cafd2bd14fb507d3f408db7a68c43117f579c984a73843"},
+    {file = "tokenizers-0.15.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:89cd1cb93e4b12ff39bb2d626ad77e35209de9309a71e4d3d4672667b4b256e7"},
+    {file = "tokenizers-0.15.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cfed5c64e5be23d7ee0f0e98081a25c2a46b0b77ce99a4f0605b1ec43dd481fa"},
+    {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a907d76dcfda37023ba203ab4ceeb21bc5683436ebefbd895a0841fd52f6f6f2"},
+    {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20ea60479de6fc7b8ae756b4b097572372d7e4032e2521c1bbf3d90c90a99ff0"},
+    {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:48e2b9335be2bc0171df9281385c2ed06a15f5cf121c44094338306ab7b33f2c"},
+    {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:112a1dd436d2cc06e6ffdc0b06d55ac019a35a63afd26475205cb4b1bf0bfbff"},
+    {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4620cca5c2817177ee8706f860364cc3a8845bc1e291aaf661fb899e5d1c45b0"},
+    {file = "tokenizers-0.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ccd73a82751c523b3fc31ff8194702e4af4db21dc20e55b30ecc2079c5d43cb7"},
+    {file = "tokenizers-0.15.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:107089f135b4ae7817affe6264f8c7a5c5b4fd9a90f9439ed495f54fcea56fb4"},
+    {file = "tokenizers-0.15.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0ff110ecc57b7aa4a594396525a3451ad70988e517237fe91c540997c4e50e29"},
+    {file = "tokenizers-0.15.2-cp311-none-win32.whl", hash = "sha256:6d76f00f5c32da36c61f41c58346a4fa7f0a61be02f4301fd30ad59834977cc3"},
+    {file = "tokenizers-0.15.2-cp311-none-win_amd64.whl", hash = "sha256:cc90102ed17271cf0a1262babe5939e0134b3890345d11a19c3145184b706055"},
+    {file = "tokenizers-0.15.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f86593c18d2e6248e72fb91c77d413a815153b8ea4e31f7cd443bdf28e467670"},
+    {file = "tokenizers-0.15.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0774bccc6608eca23eb9d620196687c8b2360624619623cf4ba9dc9bd53e8b51"},
+    {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d0222c5b7c9b26c0b4822a82f6a7011de0a9d3060e1da176f66274b70f846b98"},
+    {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3835738be1de66624fff2f4f6f6684775da4e9c00bde053be7564cbf3545cc66"},
+    {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0143e7d9dcd811855c1ce1ab9bf5d96d29bf5e528fd6c7824d0465741e8c10fd"},
+    {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db35825f6d54215f6b6009a7ff3eedee0848c99a6271c870d2826fbbedf31a38"},
+    {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3f5e64b0389a2be47091d8cc53c87859783b837ea1a06edd9d8e04004df55a5c"},
+    {file = "tokenizers-0.15.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e0480c452217edd35eca56fafe2029fb4d368b7c0475f8dfa3c5c9c400a7456"},
+    {file = "tokenizers-0.15.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a33ab881c8fe70474980577e033d0bc9a27b7ab8272896e500708b212995d834"},
+    {file = "tokenizers-0.15.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a308a607ca9de2c64c1b9ba79ec9a403969715a1b8ba5f998a676826f1a7039d"},
+    {file = "tokenizers-0.15.2-cp312-none-win32.whl", hash = "sha256:b8fcfa81bcb9447df582c5bc96a031e6df4da2a774b8080d4f02c0c16b42be0b"},
+    {file = "tokenizers-0.15.2-cp312-none-win_amd64.whl", hash = "sha256:38d7ab43c6825abfc0b661d95f39c7f8af2449364f01d331f3b51c94dcff7221"},
+    {file = "tokenizers-0.15.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:38bfb0204ff3246ca4d5e726e8cc8403bfc931090151e6eede54d0e0cf162ef0"},
+    {file = "tokenizers-0.15.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c861d35e8286a53e06e9e28d030b5a05bcbf5ac9d7229e561e53c352a85b1fc"},
+    {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:936bf3842db5b2048eaa53dade907b1160f318e7c90c74bfab86f1e47720bdd6"},
+    {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:620beacc3373277700d0e27718aa8b25f7b383eb8001fba94ee00aeea1459d89"},
+    {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2735ecbbf37e52db4ea970e539fd2d450d213517b77745114f92867f3fc246eb"},
+    {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:473c83c5e2359bb81b0b6fde870b41b2764fcdd36d997485e07e72cc3a62264a"},
+    {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:968fa1fb3c27398b28a4eca1cbd1e19355c4d3a6007f7398d48826bbe3a0f728"},
+    {file = "tokenizers-0.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:865c60ae6eaebdde7da66191ee9b7db52e542ed8ee9d2c653b6d190a9351b980"},
+    {file = "tokenizers-0.15.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7c0d8b52664ab2d4a8d6686eb5effc68b78608a9008f086a122a7b2996befbab"},
+    {file = "tokenizers-0.15.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:f33dfbdec3784093a9aebb3680d1f91336c56d86cc70ddf88708251da1fe9064"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-macosx_10_12_x86_64.whl", hash = "sha256:d44ba80988ff9424e33e0a49445072ac7029d8c0e1601ad25a0ca5f41ed0c1d6"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-macosx_11_0_arm64.whl", hash = "sha256:dce74266919b892f82b1b86025a613956ea0ea62a4843d4c4237be2c5498ed3a"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0ef06b9707baeb98b316577acb04f4852239d856b93e9ec3a299622f6084e4be"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c73e2e74bbb07910da0d37c326869f34113137b23eadad3fc00856e6b3d9930c"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4eeb12daf02a59e29f578a865f55d87cd103ce62bd8a3a5874f8fdeaa82e336b"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9ba9f6895af58487ca4f54e8a664a322f16c26bbb442effd01087eba391a719e"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ccec77aa7150e38eec6878a493bf8c263ff1fa8a62404e16c6203c64c1f16a26"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3f40604f5042ff210ba82743dda2b6aa3e55aa12df4e9f2378ee01a17e2855e"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5645938a42d78c4885086767c70923abad047163d809c16da75d6b290cb30bbe"},
+    {file = "tokenizers-0.15.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:05a77cbfebe28a61ab5c3891f9939cc24798b63fa236d84e5f29f3a85a200c00"},
+    {file = "tokenizers-0.15.2-cp37-none-win32.whl", hash = "sha256:361abdc068e8afe9c5b818769a48624687fb6aaed49636ee39bec4e95e1a215b"},
+    {file = "tokenizers-0.15.2-cp37-none-win_amd64.whl", hash = "sha256:7ef789f83eb0f9baeb4d09a86cd639c0a5518528f9992f38b28e819df397eb06"},
+    {file = "tokenizers-0.15.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:4fe1f74a902bee74a3b25aff180fbfbf4f8b444ab37c4d496af7afd13a784ed2"},
+    {file = "tokenizers-0.15.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4c4b89038a684f40a6b15d6b09f49650ac64d951ad0f2a3ea9169687bbf2a8ba"},
+    {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d05a1b06f986d41aed5f2de464c003004b2df8aaf66f2b7628254bcbfb72a438"},
+    {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:508711a108684111ec8af89d3a9e9e08755247eda27d0ba5e3c50e9da1600f6d"},
+    {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:daa348f02d15160cb35439098ac96e3a53bacf35885072611cd9e5be7d333daa"},
+    {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:494fdbe5932d3416de2a85fc2470b797e6f3226c12845cadf054dd906afd0442"},
+    {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c2d60f5246f4da9373f75ff18d64c69cbf60c3bca597290cea01059c336d2470"},
+    {file = "tokenizers-0.15.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93268e788825f52de4c7bdcb6ebc1fcd4a5442c02e730faa9b6b08f23ead0e24"},
+    {file = "tokenizers-0.15.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6fc7083ab404019fc9acafe78662c192673c1e696bd598d16dc005bd663a5cf9"},
+    {file = "tokenizers-0.15.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:41e39b41e5531d6b2122a77532dbea60e171ef87a3820b5a3888daa847df4153"},
+    {file = "tokenizers-0.15.2-cp38-none-win32.whl", hash = "sha256:06cd0487b1cbfabefb2cc52fbd6b1f8d4c37799bd6c6e1641281adaa6b2504a7"},
+    {file = "tokenizers-0.15.2-cp38-none-win_amd64.whl", hash = "sha256:5179c271aa5de9c71712e31cb5a79e436ecd0d7532a408fa42a8dbfa4bc23fd9"},
+    {file = "tokenizers-0.15.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:82f8652a74cc107052328b87ea8b34291c0f55b96d8fb261b3880216a9f9e48e"},
+    {file = "tokenizers-0.15.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:02458bee6f5f3139f1ebbb6d042b283af712c0981f5bc50edf771d6b762d5e4f"},
+    {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c9a09cd26cca2e1c349f91aa665309ddb48d71636370749414fbf67bc83c5343"},
+    {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:158be8ea8554e5ed69acc1ce3fbb23a06060bd4bbb09029431ad6b9a466a7121"},
+    {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ddba9a2b0c8c81633eca0bb2e1aa5b3a15362b1277f1ae64176d0f6eba78ab1"},
+    {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3ef5dd1d39797044642dbe53eb2bc56435308432e9c7907728da74c69ee2adca"},
+    {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:454c203164e07a860dbeb3b1f4a733be52b0edbb4dd2e5bd75023ffa8b49403a"},
+    {file = "tokenizers-0.15.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cf6b7f1d4dc59af960e6ffdc4faffe6460bbfa8dce27a58bf75755ffdb2526d"},
+    {file = "tokenizers-0.15.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2ef09bbc16519f6c25d0c7fc0c6a33a6f62923e263c9d7cca4e58b8c61572afb"},
+    {file = "tokenizers-0.15.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c9a2ebdd2ad4ec7a68e7615086e633857c85e2f18025bd05d2a4399e6c5f7169"},
+    {file = "tokenizers-0.15.2-cp39-none-win32.whl", hash = "sha256:918fbb0eab96fe08e72a8c2b5461e9cce95585d82a58688e7f01c2bd546c79d0"},
+    {file = "tokenizers-0.15.2-cp39-none-win_amd64.whl", hash = "sha256:524e60da0135e106b254bd71f0659be9f89d83f006ea9093ce4d1fab498c6d0d"},
+    {file = "tokenizers-0.15.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6a9b648a58281c4672212fab04e60648fde574877d0139cd4b4f93fe28ca8944"},
+    {file = "tokenizers-0.15.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:7c7d18b733be6bbca8a55084027f7be428c947ddf871c500ee603e375013ffba"},
+    {file = "tokenizers-0.15.2-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:13ca3611de8d9ddfbc4dc39ef54ab1d2d4aaa114ac8727dfdc6a6ec4be017378"},
+    {file = "tokenizers-0.15.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:237d1bf3361cf2e6463e6c140628e6406766e8b27274f5fcc62c747ae3c6f094"},
+    {file = "tokenizers-0.15.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67a0fe1e49e60c664915e9fb6b0cb19bac082ab1f309188230e4b2920230edb3"},
+    {file = "tokenizers-0.15.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:4e022fe65e99230b8fd89ebdfea138c24421f91c1a4f4781a8f5016fd5cdfb4d"},
+    {file = "tokenizers-0.15.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:d857be2df69763362ac699f8b251a8cd3fac9d21893de129bc788f8baaef2693"},
+    {file = "tokenizers-0.15.2-pp37-pypy37_pp73-macosx_10_12_x86_64.whl", hash = "sha256:708bb3e4283177236309e698da5fcd0879ce8fd37457d7c266d16b550bcbbd18"},
+    {file = "tokenizers-0.15.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:64c35e09e9899b72a76e762f9854e8750213f67567787d45f37ce06daf57ca78"},
+    {file = "tokenizers-0.15.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1257f4394be0d3b00de8c9e840ca5601d0a4a8438361ce9c2b05c7d25f6057b"},
+    {file = "tokenizers-0.15.2-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02272fe48280e0293a04245ca5d919b2c94a48b408b55e858feae9618138aeda"},
+    {file = "tokenizers-0.15.2-pp37-pypy37_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:dc3ad9ebc76eabe8b1d7c04d38be884b8f9d60c0cdc09b0aa4e3bcf746de0388"},
+    {file = "tokenizers-0.15.2-pp37-pypy37_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:32e16bdeffa7c4f46bf2152172ca511808b952701d13e7c18833c0b73cb5c23f"},
+    {file = "tokenizers-0.15.2-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:fb16ba563d59003028b678d2361a27f7e4ae0ab29c7a80690efa20d829c81fdb"},
+    {file = "tokenizers-0.15.2-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:2277c36d2d6cdb7876c274547921a42425b6810d38354327dd65a8009acf870c"},
+    {file = "tokenizers-0.15.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1cf75d32e8d250781940d07f7eece253f2fe9ecdb1dc7ba6e3833fa17b82fcbc"},
+    {file = "tokenizers-0.15.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1b3b31884dc8e9b21508bb76da80ebf7308fdb947a17affce815665d5c4d028"},
+    {file = "tokenizers-0.15.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b10122d8d8e30afb43bb1fe21a3619f62c3e2574bff2699cf8af8b0b6c5dc4a3"},
+    {file = "tokenizers-0.15.2-pp38-pypy38_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d88b96ff0fe8e91f6ef01ba50b0d71db5017fa4e3b1d99681cec89a85faf7bf7"},
+    {file = "tokenizers-0.15.2-pp38-pypy38_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:37aaec5a52e959892870a7c47cef80c53797c0db9149d458460f4f31e2fb250e"},
+    {file = "tokenizers-0.15.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e2ea752f2b0fe96eb6e2f3adbbf4d72aaa1272079b0dfa1145507bd6a5d537e6"},
+    {file = "tokenizers-0.15.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:4b19a808d8799fda23504a5cd31d2f58e6f52f140380082b352f877017d6342b"},
+    {file = "tokenizers-0.15.2-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:64c86e5e068ac8b19204419ed8ca90f9d25db20578f5881e337d203b314f4104"},
+    {file = "tokenizers-0.15.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de19c4dc503c612847edf833c82e9f73cd79926a384af9d801dcf93f110cea4e"},
+    {file = "tokenizers-0.15.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea09acd2fe3324174063d61ad620dec3bcf042b495515f27f638270a7d466e8b"},
+    {file = "tokenizers-0.15.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:cf27fd43472e07b57cf420eee1e814549203d56de00b5af8659cb99885472f1f"},
+    {file = "tokenizers-0.15.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:7ca22bd897537a0080521445d91a58886c8c04084a6a19e6c78c586e0cfa92a5"},
+    {file = "tokenizers-0.15.2.tar.gz", hash = "sha256:e6e9c6e019dd5484be5beafc775ae6c925f4c69a3487040ed09b45e13df2cb91"},
 ]
 
 [package.dependencies]
@@ -3168,13 +4374,13 @@ files = [
 
 [[package]]
 name = "tqdm"
-version = "4.66.1"
+version = "4.66.2"
 description = "Fast, Extensible Progress Meter"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "tqdm-4.66.1-py3-none-any.whl", hash = "sha256:d302b3c5b53d47bce91fea46679d9c3c6508cf6332229aa1e7d8653723793386"},
-    {file = "tqdm-4.66.1.tar.gz", hash = "sha256:d88e651f9db8d8551a62556d3cff9e3034274ca5d66e93197cf2490e2dcb69c7"},
+    {file = "tqdm-4.66.2-py3-none-any.whl", hash = "sha256:1ee4f8a893eb9bef51c6e35730cebf234d5d0b6bd112b0271e10ed7c24a02bd9"},
+    {file = "tqdm-4.66.2.tar.gz", hash = "sha256:6cd52cdf0fef0e0f543299cfc96fec90d7b8a7e88745f411ec33eb44d5ed3531"},
 ]
 
 [package.dependencies]
@@ -3292,6 +4498,28 @@ build = ["cmake (>=3.20)", "lit"]
 tests = ["autopep8", "flake8", "isort", "numpy", "pytest", "scipy (>=1.7.1)", "torch"]
 tutorials = ["matplotlib", "pandas", "tabulate", "torch"]
 
+[[package]]
+name = "twine"
+version = "5.0.0"
+description = "Collection of utilities for publishing packages on PyPI"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "twine-5.0.0-py3-none-any.whl", hash = "sha256:a262933de0b484c53408f9edae2e7821c1c45a3314ff2df9bdd343aa7ab8edc0"},
+    {file = "twine-5.0.0.tar.gz", hash = "sha256:89b0cc7d370a4b66421cc6102f269aa910fe0f1861c124f573cf2ddedbc10cf4"},
+]
+
+[package.dependencies]
+importlib-metadata = ">=3.6"
+keyring = ">=15.1"
+pkginfo = ">=1.8.1"
+readme-renderer = ">=35.0"
+requests = ">=2.20"
+requests-toolbelt = ">=0.8.0,<0.9.0 || >0.9.0"
+rfc3986 = ">=1.4.0"
+rich = ">=12.0.0"
+urllib3 = ">=1.26.0"
+
 [[package]]
 name = "types-pyyaml"
 version = "6.0.12.12"
@@ -3317,6 +4545,17 @@ files = [
 [package.dependencies]
 urllib3 = ">=2"
 
+[[package]]
+name = "typing"
+version = "3.7.4.3"
+description = "Type Hints for Python"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "typing-3.7.4.3-py2-none-any.whl", hash = "sha256:283d868f5071ab9ad873e5e52268d611e851c870a2ba354193026f2dfb29d8b5"},
+    {file = "typing-3.7.4.3.tar.gz", hash = "sha256:1187fb9c82fd670d10aa07bbb6cfcfe4bdda42d6fab8d5134f04e8c4d0b71cc9"},
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.9.0"
@@ -3328,6 +4567,154 @@ files = [
     {file = "typing_extensions-4.9.0.tar.gz", hash = "sha256:23478f88c37f27d76ac8aee6c905017a143b0b1b886c3c9f66bc2fd94f9f5783"},
 ]
 
+[[package]]
+name = "typing-inspect"
+version = "0.9.0"
+description = "Runtime inspection utilities for typing module."
+optional = true
+python-versions = "*"
+files = [
+    {file = "typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f"},
+    {file = "typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78"},
+]
+
+[package.dependencies]
+mypy-extensions = ">=0.3.0"
+typing-extensions = ">=3.7.4"
+
+[[package]]
+name = "unstructured"
+version = "0.12.4"
+description = "A library that prepares raw documents for downstream ML tasks."
+optional = true
+python-versions = ">=3.9.0,<3.12"
+files = [
+    {file = "unstructured-0.12.4-py3-none-any.whl", hash = "sha256:f1aa046297a3afba3aa16895e513aca6a93802ef73b7a18080656435c4deb217"},
+    {file = "unstructured-0.12.4.tar.gz", hash = "sha256:019cf52e9e2bfa286e61ffa0d7d336e1645280f9a0f165e697583143fcfe708a"},
+]
+
+[package.dependencies]
+backoff = "*"
+beautifulsoup4 = "*"
+chardet = "*"
+dataclasses-json = "*"
+emoji = "*"
+filetype = "*"
+langdetect = "*"
+lxml = "*"
+nltk = "*"
+numpy = "*"
+python-iso639 = "*"
+python-magic = "*"
+rapidfuzz = "*"
+requests = "*"
+tabulate = "*"
+typing-extensions = "*"
+unstructured-client = ">=0.15.1"
+wrapt = "*"
+
+[package.extras]
+airtable = ["pyairtable"]
+all-docs = ["markdown", "msg-parser", "networkx", "onnx", "openpyxl", "pandas", "pdf2image", "pdfminer.six", "pikepdf", "pillow-heif", "pypandoc", "pypdf", "python-docx", "python-pptx (<=0.6.23)", "unstructured-inference (==0.7.23)", "unstructured.pytesseract (>=0.3.12)", "xlrd"]
+azure = ["adlfs", "fsspec"]
+azure-cognitive-search = ["azure-search-documents"]
+bedrock = ["boto3", "langchain-community"]
+biomed = ["bs4"]
+box = ["boxfs", "fsspec"]
+chroma = ["chromadb"]
+confluence = ["atlassian-python-api"]
+csv = ["pandas"]
+databricks-volumes = ["databricks-sdk"]
+delta-table = ["deltalake", "fsspec"]
+discord = ["discord-py"]
+doc = ["python-docx"]
+docx = ["python-docx"]
+dropbox = ["dropboxdrivefs", "fsspec"]
+elasticsearch = ["elasticsearch"]
+embed-huggingface = ["huggingface", "langchain-community", "sentence-transformers"]
+epub = ["pypandoc"]
+gcs = ["bs4", "fsspec", "gcsfs"]
+github = ["pygithub (>1.58.0)"]
+gitlab = ["python-gitlab"]
+google-drive = ["google-api-python-client"]
+hubspot = ["hubspot-api-client", "urllib3"]
+huggingface = ["langdetect", "sacremoses", "sentencepiece", "torch", "transformers"]
+image = ["onnx", "pdf2image", "pdfminer.six", "pikepdf", "pillow-heif", "pypdf", "unstructured-inference (==0.7.23)", "unstructured.pytesseract (>=0.3.12)"]
+jira = ["atlassian-python-api"]
+local-inference = ["markdown", "msg-parser", "networkx", "onnx", "openpyxl", "pandas", "pdf2image", "pdfminer.six", "pikepdf", "pillow-heif", "pypandoc", "pypdf", "python-docx", "python-pptx (<=0.6.23)", "unstructured-inference (==0.7.23)", "unstructured.pytesseract (>=0.3.12)", "xlrd"]
+md = ["markdown"]
+mongodb = ["pymongo"]
+msg = ["msg-parser"]
+notion = ["htmlBuilder", "notion-client"]
+odt = ["pypandoc", "python-docx"]
+onedrive = ["Office365-REST-Python-Client", "bs4", "msal"]
+openai = ["langchain-community", "openai", "tiktoken"]
+opensearch = ["opensearch-py"]
+org = ["pypandoc"]
+outlook = ["Office365-REST-Python-Client", "msal"]
+paddleocr = ["unstructured.paddleocr (==2.6.1.3)"]
+pdf = ["onnx", "pdf2image", "pdfminer.six", "pikepdf", "pillow-heif", "pypdf", "unstructured-inference (==0.7.23)", "unstructured.pytesseract (>=0.3.12)"]
+pinecone = ["pinecone-client (==2.2.4)"]
+postgres = ["psycopg2-binary"]
+ppt = ["python-pptx (<=0.6.23)"]
+pptx = ["python-pptx (<=0.6.23)"]
+qdrant = ["qdrant-client"]
+reddit = ["praw"]
+rst = ["pypandoc"]
+rtf = ["pypandoc"]
+s3 = ["fsspec", "s3fs"]
+salesforce = ["simple-salesforce"]
+sftp = ["fsspec", "paramiko"]
+sharepoint = ["Office365-REST-Python-Client", "msal"]
+slack = ["slack-sdk"]
+tsv = ["pandas"]
+weaviate = ["weaviate-client"]
+wikipedia = ["wikipedia"]
+xlsx = ["networkx", "openpyxl", "pandas", "xlrd"]
+
+[[package]]
+name = "unstructured-client"
+version = "0.18.0"
+description = "Python Client SDK for Unstructured API"
+optional = true
+python-versions = ">=3.8"
+files = [
+    {file = "unstructured-client-0.18.0.tar.gz", hash = "sha256:b5f1866b6a48d2e28645e37e86c9d58b1ee7df2d88e79adf873572338c027aa8"},
+    {file = "unstructured_client-0.18.0-py3-none-any.whl", hash = "sha256:36d8c5cb01b97a87e271e11d4d5a063d1c5b85fc5fd7f07819c35a9bef74821f"},
+]
+
+[package.dependencies]
+certifi = ">=2023.7.22"
+charset-normalizer = ">=3.2.0"
+dataclasses-json-speakeasy = ">=0.5.11"
+idna = ">=3.4"
+jsonpath-python = ">=1.0.6"
+marshmallow = ">=3.19.0"
+mypy-extensions = ">=1.0.0"
+packaging = ">=23.1"
+python-dateutil = ">=2.8.2"
+requests = ">=2.31.0"
+six = ">=1.16.0"
+typing-extensions = ">=4.7.1"
+typing-inspect = ">=0.9.0"
+urllib3 = ">=1.26.18"
+
+[package.extras]
+dev = ["pylint (==2.16.2)"]
+
+[[package]]
+name = "update"
+version = "0.0.1"
+description = ""
+optional = false
+python-versions = "*"
+files = [
+    {file = "update-0.0.1-py2.py3-none-any.whl", hash = "sha256:a25522b4bf60e3e3c1a3ff3ca3a4f5a328ac4b8ff400fdc9614483147e313323"},
+]
+
+[package.dependencies]
+style = "1.1.0"
+
 [[package]]
 name = "urllib3"
 version = "2.2.0"
@@ -3345,6 +4732,16 @@ h2 = ["h2 (>=4,<5)"]
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
 
+[[package]]
+name = "ushlex"
+version = "0.99.1"
+description = "Replacement for shlex (that works with unicode) for Python 2.X."
+optional = false
+python-versions = "*"
+files = [
+    {file = "ushlex-0.99.1.tar.gz", hash = "sha256:6d681561545a9781430d5254eab9a648bade78c82ffd127d56c9228ae8887d46"},
+]
+
 [[package]]
 name = "wcwidth"
 version = "0.2.13"
@@ -3356,6 +4753,22 @@ files = [
     {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"},
 ]
 
+[[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 = "wget"
 version = "3.2"
@@ -3366,6 +4779,85 @@ files = [
     {file = "wget-3.2.zip", hash = "sha256:35e630eca2aa50ce998b9b1a127bb26b30dfee573702782aa982f875e3f16061"},
 ]
 
+[[package]]
+name = "wrapt"
+version = "1.16.0"
+description = "Module for decorators, wrappers and monkey patching."
+optional = true
+python-versions = ">=3.6"
+files = [
+    {file = "wrapt-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ffa565331890b90056c01db69c0fe634a776f8019c143a5ae265f9c6bc4bd6d4"},
+    {file = "wrapt-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e4fdb9275308292e880dcbeb12546df7f3e0f96c6b41197e0cf37d2826359020"},
+    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb2dee3874a500de01c93d5c71415fcaef1d858370d405824783e7a8ef5db440"},
+    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a88e6010048489cda82b1326889ec075a8c856c2e6a256072b28eaee3ccf487"},
+    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac83a914ebaf589b69f7d0a1277602ff494e21f4c2f743313414378f8f50a4cf"},
+    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:73aa7d98215d39b8455f103de64391cb79dfcad601701a3aa0dddacf74911d72"},
+    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:807cc8543a477ab7422f1120a217054f958a66ef7314f76dd9e77d3f02cdccd0"},
+    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bf5703fdeb350e36885f2875d853ce13172ae281c56e509f4e6eca049bdfb136"},
+    {file = "wrapt-1.16.0-cp310-cp310-win32.whl", hash = "sha256:f6b2d0c6703c988d334f297aa5df18c45e97b0af3679bb75059e0e0bd8b1069d"},
+    {file = "wrapt-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:decbfa2f618fa8ed81c95ee18a387ff973143c656ef800c9f24fb7e9c16054e2"},
+    {file = "wrapt-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a5db485fe2de4403f13fafdc231b0dbae5eca4359232d2efc79025527375b09"},
+    {file = "wrapt-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:75ea7d0ee2a15733684badb16de6794894ed9c55aa5e9903260922f0482e687d"},
+    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a452f9ca3e3267cd4d0fcf2edd0d035b1934ac2bd7e0e57ac91ad6b95c0c6389"},
+    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43aa59eadec7890d9958748db829df269f0368521ba6dc68cc172d5d03ed8060"},
+    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72554a23c78a8e7aa02abbd699d129eead8b147a23c56e08d08dfc29cfdddca1"},
+    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d2efee35b4b0a347e0d99d28e884dfd82797852d62fcd7ebdeee26f3ceb72cf3"},
+    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:6dcfcffe73710be01d90cae08c3e548d90932d37b39ef83969ae135d36ef3956"},
+    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:eb6e651000a19c96f452c85132811d25e9264d836951022d6e81df2fff38337d"},
+    {file = "wrapt-1.16.0-cp311-cp311-win32.whl", hash = "sha256:66027d667efe95cc4fa945af59f92c5a02c6f5bb6012bff9e60542c74c75c362"},
+    {file = "wrapt-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:aefbc4cb0a54f91af643660a0a150ce2c090d3652cf4052a5397fb2de549cd89"},
+    {file = "wrapt-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5eb404d89131ec9b4f748fa5cfb5346802e5ee8836f57d516576e61f304f3b7b"},
+    {file = "wrapt-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9090c9e676d5236a6948330e83cb89969f433b1943a558968f659ead07cb3b36"},
+    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94265b00870aa407bd0cbcfd536f17ecde43b94fb8d228560a1e9d3041462d73"},
+    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2058f813d4f2b5e3a9eb2eb3faf8f1d99b81c3e51aeda4b168406443e8ba809"},
+    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b5e1f498a8ca1858a1cdbffb023bfd954da4e3fa2c0cb5853d40014557248b"},
+    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:14d7dc606219cdd7405133c713f2c218d4252f2a469003f8c46bb92d5d095d81"},
+    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:49aac49dc4782cb04f58986e81ea0b4768e4ff197b57324dcbd7699c5dfb40b9"},
+    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:418abb18146475c310d7a6dc71143d6f7adec5b004ac9ce08dc7a34e2babdc5c"},
+    {file = "wrapt-1.16.0-cp312-cp312-win32.whl", hash = "sha256:685f568fa5e627e93f3b52fda002c7ed2fa1800b50ce51f6ed1d572d8ab3e7fc"},
+    {file = "wrapt-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:dcdba5c86e368442528f7060039eda390cc4091bfd1dca41e8046af7c910dda8"},
+    {file = "wrapt-1.16.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:d462f28826f4657968ae51d2181a074dfe03c200d6131690b7d65d55b0f360f8"},
+    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a33a747400b94b6d6b8a165e4480264a64a78c8a4c734b62136062e9a248dd39"},
+    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3646eefa23daeba62643a58aac816945cadc0afaf21800a1421eeba5f6cfb9c"},
+    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ebf019be5c09d400cf7b024aa52b1f3aeebeff51550d007e92c3c1c4afc2a40"},
+    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:0d2691979e93d06a95a26257adb7bfd0c93818e89b1406f5a28f36e0d8c1e1fc"},
+    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:1acd723ee2a8826f3d53910255643e33673e1d11db84ce5880675954183ec47e"},
+    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:bc57efac2da352a51cc4658878a68d2b1b67dbe9d33c36cb826ca449d80a8465"},
+    {file = "wrapt-1.16.0-cp36-cp36m-win32.whl", hash = "sha256:da4813f751142436b075ed7aa012a8778aa43a99f7b36afe9b742d3ed8bdc95e"},
+    {file = "wrapt-1.16.0-cp36-cp36m-win_amd64.whl", hash = "sha256:6f6eac2360f2d543cc875a0e5efd413b6cbd483cb3ad7ebf888884a6e0d2e966"},
+    {file = "wrapt-1.16.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a0ea261ce52b5952bf669684a251a66df239ec6d441ccb59ec7afa882265d593"},
+    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bd2d7ff69a2cac767fbf7a2b206add2e9a210e57947dd7ce03e25d03d2de292"},
+    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9159485323798c8dc530a224bd3ffcf76659319ccc7bbd52e01e73bd0241a0c5"},
+    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a86373cf37cd7764f2201b76496aba58a52e76dedfaa698ef9e9688bfd9e41cf"},
+    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:73870c364c11f03ed072dda68ff7aea6d2a3a5c3fe250d917a429c7432e15228"},
+    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b935ae30c6e7400022b50f8d359c03ed233d45b725cfdd299462f41ee5ffba6f"},
+    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:db98ad84a55eb09b3c32a96c576476777e87c520a34e2519d3e59c44710c002c"},
+    {file = "wrapt-1.16.0-cp37-cp37m-win32.whl", hash = "sha256:9153ed35fc5e4fa3b2fe97bddaa7cbec0ed22412b85bcdaf54aeba92ea37428c"},
+    {file = "wrapt-1.16.0-cp37-cp37m-win_amd64.whl", hash = "sha256:66dfbaa7cfa3eb707bbfcd46dab2bc6207b005cbc9caa2199bcbc81d95071a00"},
+    {file = "wrapt-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1dd50a2696ff89f57bd8847647a1c363b687d3d796dc30d4dd4a9d1689a706f0"},
+    {file = "wrapt-1.16.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:44a2754372e32ab315734c6c73b24351d06e77ffff6ae27d2ecf14cf3d229202"},
+    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e9723528b9f787dc59168369e42ae1c3b0d3fadb2f1a71de14531d321ee05b0"},
+    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbed418ba5c3dce92619656802cc5355cb679e58d0d89b50f116e4a9d5a9603e"},
+    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:941988b89b4fd6b41c3f0bfb20e92bd23746579736b7343283297c4c8cbae68f"},
+    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6a42cd0cfa8ffc1915aef79cb4284f6383d8a3e9dcca70c445dcfdd639d51267"},
+    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1ca9b6085e4f866bd584fb135a041bfc32cab916e69f714a7d1d397f8c4891ca"},
+    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d5e49454f19ef621089e204f862388d29e6e8d8b162efce05208913dde5b9ad6"},
+    {file = "wrapt-1.16.0-cp38-cp38-win32.whl", hash = "sha256:c31f72b1b6624c9d863fc095da460802f43a7c6868c5dda140f51da24fd47d7b"},
+    {file = "wrapt-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:490b0ee15c1a55be9c1bd8609b8cecd60e325f0575fc98f50058eae366e01f41"},
+    {file = "wrapt-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9b201ae332c3637a42f02d1045e1d0cccfdc41f1f2f801dafbaa7e9b4797bfc2"},
+    {file = "wrapt-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2076fad65c6736184e77d7d4729b63a6d1ae0b70da4868adeec40989858eb3fb"},
+    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5cd603b575ebceca7da5a3a251e69561bec509e0b46e4993e1cac402b7247b8"},
+    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b47cfad9e9bbbed2339081f4e346c93ecd7ab504299403320bf85f7f85c7d46c"},
+    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8212564d49c50eb4565e502814f694e240c55551a5f1bc841d4fcaabb0a9b8a"},
+    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:5f15814a33e42b04e3de432e573aa557f9f0f56458745c2074952f564c50e664"},
+    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db2e408d983b0e61e238cf579c09ef7020560441906ca990fe8412153e3b291f"},
+    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:edfad1d29c73f9b863ebe7082ae9321374ccb10879eeabc84ba3b69f2579d537"},
+    {file = "wrapt-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed867c42c268f876097248e05b6117a65bcd1e63b779e916fe2e33cd6fd0d3c3"},
+    {file = "wrapt-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:eb1b046be06b0fce7249f1d025cd359b4b80fc1c3e24ad9eca33e0dcdb2e4a35"},
+    {file = "wrapt-1.16.0-py3-none-any.whl", hash = "sha256:6906c4100a8fcbf2fa735f6059214bb13b97f75b1a61777fcf6432121ef12ef1"},
+    {file = "wrapt-1.16.0.tar.gz", hash = "sha256:5f370f952971e7d17c7d1ead40e49f32345a7f7a5373571ef44d800d06b1899d"},
+]
+
 [[package]]
 name = "yarl"
 version = "1.9.4"
@@ -3489,8 +4981,9 @@ fastembed = ["fastembed"]
 hybrid = ["pinecone-text"]
 local = ["llama-cpp-python", "torch", "transformers"]
 pinecone = ["pinecone-client"]
+unstructured = ["unstructured"]
 
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.9,<3.13"
-content-hash = "894b9692ad914e11c364d588bca8d7a99ef862cdd5b2137c00e4d5cac77a35c9"
+content-hash = "0dd678c1d3f1136dd0244295ba1bc9b1accbcd6c3da959b70027e1187996d08c"
diff --git a/pyproject.toml b/pyproject.toml
index 67851a3c..b490ad3c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -31,6 +31,10 @@ llama-cpp-python = {version = "^0.2.28", optional = true}
 black = "^23.12.1"
 colorama = "^0.4.6"
 pinecone-client = {version="^3.0.0", optional = true}
+update = "^0.0.1"
+tiktoken = "^0.6.0"
+regex = "^2023.12.25"
+
 [tool.poetry.extras]
 hybrid = ["pinecone-text"]
 fastembed = ["fastembed"]
@@ -48,6 +52,7 @@ mypy = "^1.7.1"
 types-pyyaml = "^6.0.12.12"
 types-requests = "^2.31.0"
 termcolor = "^2.4.0"
+matplot = "^0.1.9"
 
 [build-system]
 requires = ["poetry-core"]
diff --git a/semantic_router/schema.py b/semantic_router/schema.py
index 6a5a0637..066aa691 100644
--- a/semantic_router/schema.py
+++ b/semantic_router/schema.py
@@ -77,6 +77,12 @@ def __str__(self):
 
 
 class DocumentSplit(BaseModel):
-    docs: List[str]
+    docs: list[str]
     is_triggered: bool = False
-    triggered_score: Optional[float] = None
+    triggered_score: float | None = None
+    token_count: int | None = None
+    metadata: dict | None = None
+
+    @property
+    def content(self) -> str:
+        return " ".join(self.docs)
diff --git a/semantic_router/splitters/__init__.py b/semantic_router/splitters/__init__.py
index e69de29b..44acb9e3 100644
--- a/semantic_router/splitters/__init__.py
+++ b/semantic_router/splitters/__init__.py
@@ -0,0 +1,11 @@
+from semantic_router.splitters.base import BaseSplitter
+from semantic_router.splitters.consecutive_sim import ConsecutiveSimSplitter
+from semantic_router.splitters.cumulative_sim import CumulativeSimSplitter
+from semantic_router.splitters.rolling_window import RollingWindowSplitter
+
+__all__ = [
+    "BaseSplitter",
+    "ConsecutiveSimSplitter",
+    "CumulativeSimSplitter",
+    "RollingWindowSplitter",
+]
diff --git a/semantic_router/splitters/base.py b/semantic_router/splitters/base.py
index c64d384c..87daedd1 100644
--- a/semantic_router/splitters/base.py
+++ b/semantic_router/splitters/base.py
@@ -1,5 +1,5 @@
 from itertools import cycle
-from typing import List
+from typing import List, Optional
 
 from pydantic.v1 import BaseModel
 from termcolor import colored
@@ -12,6 +12,8 @@ class BaseSplitter(BaseModel):
     name: str
     encoder: BaseEncoder
     score_threshold: float
+    min_split_tokens: Optional[int] = None
+    max_split_tokens: Optional[int] = None
 
     def __call__(self, docs: List[str]) -> List[DocumentSplit]:
         raise NotImplementedError("Subclasses must implement this method")
diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
index ad5c568e..030719de 100644
--- a/semantic_router/splitters/rolling_window.py
+++ b/semantic_router/splitters/rolling_window.py
@@ -1,88 +1,38 @@
-from typing import List
-
 import numpy as np
-from matplotlib import pyplot as plt
-from nltk.tokenize import word_tokenize
-from semantic_router.encoders.base import BaseEncoder
 
+from semantic_router.encoders.base import BaseEncoder
 from semantic_router.schema import DocumentSplit
-from semantic_router.splitters.base import BaseSplitter
+from semantic_router.splitters.utils import split_to_sentences, tiktoken_length
 from semantic_router.utils.logger import logger
 
 
-class RollingWindowSplitter(BaseSplitter):
-    """
-    A splitter that divides documents into segments based on semantic similarity
-    using a rolling window approach.
-    It adjusts the similarity threshold dynamically.
-    Splitting is based:
-    - On the similarity threshold
-    - On the maximum token limit for a split
-
-    Attributes:
-        encoder (Callable): A function to encode documents into semantic vectors.
-        score_threshold (float): Initial threshold for similarity scores to decide
-        splits.
-        window_size (int): Size of the rolling window to calculate document context.
-        plot_splits (bool): Whether to plot the similarity scores and splits for
-        visualization.
-        min_split_tokens (int): Minimum number of tokens for a valid document split.
-        max_split_tokens (int): Maximum number of tokens a split can contain.
-        split_tokens_tolerance (int): Tolerance in token count to still consider a split
-        valid.
-        threshold_step_size (float): Step size to adjust the similarity threshold during
-        optimization.
-    """
-
+class RollingWindowSplitter:
     def __init__(
         self,
         encoder: BaseEncoder,
-        score_threshold=0.3,
+        threshold_adjustment: float = 0.01,
         window_size=5,
-        plot_splits=False,
         min_split_tokens=100,
         max_split_tokens=300,
         split_tokens_tolerance=10,
-        threshold_step_size=0.01,
+        plot_splits=False,
     ):
+        self.calculated_threshold: float
         self.encoder = encoder
-        self.score_threshold = score_threshold
+        self.threshold_adjustment = threshold_adjustment
         self.window_size = window_size
         self.plot_splits = plot_splits
         self.min_split_tokens = min_split_tokens
         self.max_split_tokens = max_split_tokens
         self.split_tokens_tolerance = split_tokens_tolerance
-        self.threshold_step_size = threshold_step_size
 
     def encode_documents(self, docs: list[str]) -> np.ndarray:
-        return np.array(self.encoder(docs))
-
-    def find_optimal_threshold(self, docs: list[str], encoded_docs: np.ndarray):
-        logger.info(f"Number of documents for finding optimal threshold: {len(docs)}")
-        token_counts = [len(word_tokenize(doc)) for doc in docs]
-        low, high = 0, 1
-        while low <= high:
-            self.score_threshold = (low + high) / 2
-            similarity_scores = self.calculate_similarity_scores(encoded_docs)
-            split_indices = self.find_split_indices(similarity_scores)
-            average_tokens = np.mean(
-                [
-                    sum(token_counts[start:end])
-                    for start, end in zip(
-                        [0] + split_indices, split_indices + [len(token_counts)]
-                    )
-                ]
-            )
-            if (
-                self.min_split_tokens - self.split_tokens_tolerance
-                <= average_tokens
-                <= self.max_split_tokens + self.split_tokens_tolerance
-            ):
-                break
-            elif average_tokens < self.min_split_tokens:
-                high = self.score_threshold - self.threshold_step_size
-            else:
-                low = self.score_threshold + self.threshold_step_size
+        try:
+            embeddings = self.encoder(docs)
+            return np.array(embeddings)
+        except Exception as e:
+            logger.error(f"Error encoding documents {docs}: {e}")
+            raise
 
     def calculate_similarity_scores(self, encoded_docs: np.ndarray) -> list[float]:
         raw_similarities = []
@@ -97,11 +47,68 @@ def calculate_similarity_scores(self, encoded_docs: np.ndarray) -> list[float]:
         return raw_similarities
 
     def find_split_indices(self, similarities: list[float]) -> list[int]:
-        return [
-            idx + 1
-            for idx, sim in enumerate(similarities)
-            if sim < self.score_threshold
-        ]
+        split_indices = []
+        for idx in range(1, len(similarities)):
+            if similarities[idx] < self.calculated_threshold:
+                split_indices.append(idx + 1)
+        return split_indices
+
+    def find_optimal_threshold(self, docs: list[str], encoded_docs: np.ndarray):
+        token_counts = [tiktoken_length(doc) for doc in docs]
+        cumulative_token_counts = np.cumsum([0] + token_counts)
+        similarity_scores = self.calculate_similarity_scores(encoded_docs)
+
+        # Analyze the distribution of similarity scores to set initial bounds
+        median_score = np.median(similarity_scores)
+        std_dev = np.std(similarity_scores)
+
+        # Set initial bounds based on median and standard deviation
+        low = max(0.0, float(median_score - std_dev))
+        high = min(1.0, float(median_score + std_dev))
+
+        iteration = 0
+        while low <= high:
+            self.calculated_threshold = (low + high) / 2
+            logger.info(
+                f"Iteration {iteration}: Trying threshold: {self.calculated_threshold}"
+            )
+            split_indices = self.find_split_indices(similarity_scores)
+
+            # Calculate the token counts for each split using the cumulative sums
+            split_token_counts = [
+                cumulative_token_counts[end] - cumulative_token_counts[start]
+                for start, end in zip(
+                    [0] + split_indices, split_indices + [len(token_counts)]
+                )
+            ]
+
+            # Calculate the median token count for the splits
+            median_tokens = np.median(split_token_counts)
+            logger.info(
+                f"Iteration {iteration}: Median tokens per split: {median_tokens}"
+            )
+            if (
+                self.min_split_tokens - self.split_tokens_tolerance
+                <= median_tokens
+                <= self.max_split_tokens + self.split_tokens_tolerance
+            ):
+                logger.info(
+                    f"Iteration {iteration}: "
+                    f"Optimal threshold {self.calculated_threshold} found "
+                    f"with median tokens ({median_tokens}) in target range "
+                    f" {self.min_split_tokens}-{self.max_split_tokens}."
+                )
+                break
+            elif median_tokens < self.min_split_tokens:
+                high = self.calculated_threshold - self.threshold_adjustment
+                logger.info(f"Iteration {iteration}: Adjusting high to {high}")
+            else:
+                low = self.calculated_threshold + self.threshold_adjustment
+                logger.info(f"Iteration {iteration}: Adjusting low to {low}")
+            iteration += 1
+
+        logger.info(f"Final optimal threshold: {self.calculated_threshold}")
+        return self.calculated_threshold
 
     def split_documents(
         self, docs: list[str], split_indices: list[int], similarities: list[float]
@@ -114,93 +121,98 @@ def split_documents(
         or when a split point is reached and the minimum token requirement is met,
         the current split is finalized and added to the list of splits.
         """
-        token_counts = [len(word_tokenize(doc)) for doc in docs]
-        splits: List[DocumentSplit] = []
-        current_split: List[str] = []
+        token_counts = [tiktoken_length(doc) for doc in docs]
+        splits, current_split = [], []
         current_tokens_count = 0
 
         for doc_idx, doc in enumerate(docs):
             doc_token_count = token_counts[doc_idx]
-            # Check if current document causes token count to exceed max limit
-            if (
-                current_tokens_count + doc_token_count > self.max_split_tokens
-                and current_tokens_count >= self.min_split_tokens
-            ):
-                splits.append(
-                    DocumentSplit(docs=current_split.copy(), is_triggered=True)
-                )
-                logger.info(
-                    f"Split finalized with {current_tokens_count} tokens due to "
-                    f"exceeding token limit of {self.max_split_tokens}."
-                )
-                current_split, current_tokens_count = [], 0
-
-            current_split.append(doc)
-            current_tokens_count += doc_token_count
 
             # Check if current index is a split point based on similarity
-            if doc_idx + 1 in split_indices or doc_idx == len(docs) - 1:
-                if current_tokens_count >= self.min_split_tokens:
-                    if doc_idx < len(similarities):
-                        triggered_score = similarities[doc_idx]
-                        splits.append(
-                            DocumentSplit(
-                                docs=current_split.copy(),
-                                is_triggered=True,
-                                triggered_score=triggered_score,
-                            )
-                        )
-                        logger.info(
-                            f"Split finalized with {current_tokens_count} tokens due to"
-                            f" similarity score {triggered_score:.2f}."
-                        )
-                    else:
-                        # This case handles the end of the document list
-                        # where there's no similarity score
-                        splits.append(
-                            DocumentSplit(docs=current_split.copy(), is_triggered=False)
+            if doc_idx + 1 in split_indices:
+                if current_tokens_count + doc_token_count >= self.min_split_tokens:
+                    # Include the current document before splitting
+                    # if it doesn't exceed the max limit
+                    current_split.append(doc)
+                    current_tokens_count += doc_token_count
+
+                    triggered_score = (
+                        similarities[doc_idx] if doc_idx < len(similarities) else None
+                    )
+                    splits.append(
+                        DocumentSplit(
+                            docs=current_split.copy(),
+                            is_triggered=True,
+                            triggered_score=triggered_score,
+                            token_count=current_tokens_count,
                         )
-                        logger.info(
-                            f"Split finalized with {current_tokens_count} tokens "
-                            "at the end of the document list."
+                    )
+                    logger.info(
+                        f"Split finalized with {current_tokens_count} tokens due to "
+                        f"threshold {self.calculated_threshold}."
+                    )
+                    current_split, current_tokens_count = [], 0
+                    continue  # Move to the next document after splitting
+
+            # Check if adding the current document exceeds the max token limit
+            if current_tokens_count + doc_token_count > self.max_split_tokens:
+                if current_tokens_count >= self.min_split_tokens:
+                    splits.append(
+                        DocumentSplit(
+                            docs=current_split.copy(),
+                            is_triggered=False,
+                            triggered_score=None,
+                            token_count=current_tokens_count,
                         )
+                    )
+                    logger.info(
+                        f"Split finalized with {current_tokens_count} tokens due to "
+                        f"exceeding token limit of {self.max_split_tokens}."
+                    )
                     current_split, current_tokens_count = [], 0
 
-        # Ensure any remaining documents are included in the final token count
+            current_split.append(doc)
+            current_tokens_count += doc_token_count
+
+        # Handle the last split
         if current_split:
-            splits.append(DocumentSplit(docs=current_split.copy(), is_triggered=False))
+            splits.append(
+                DocumentSplit(
+                    docs=current_split.copy(),
+                    is_triggered=False,
+                    triggered_score=None,
+                    token_count=current_tokens_count,
+                )
+            )
             logger.info(
-                f"Final split added with {current_tokens_count} tokens "
-                "due to remaining documents."
+                f"Final split added with {current_tokens_count} "
+                "tokens due to remaining documents."
             )
 
-        # Validation
+        # Validation to ensure no tokens are lost during the split
         original_token_count = sum(token_counts)
         split_token_count = sum(
-            [len(word_tokenize(doc)) for split in splits for doc in split.docs]
+            [tiktoken_length(doc) for split in splits for doc in split.docs]
         )
-        logger.debug(
-            f"Original Token Count: {original_token_count}, "
-            f"Split Token Count: {split_token_count}"
-        )
-
         if original_token_count != split_token_count:
             logger.error(
                 f"Token count mismatch: {original_token_count} != {split_token_count}"
             )
-            for i, split in enumerate(splits):
-                split_token_count = sum([len(word_tokenize(doc)) for doc in split.docs])
-                logger.error(f"Split {i} Token Count: {split_token_count}")
             raise ValueError(
                 f"Token count mismatch: {original_token_count} != {split_token_count}"
             )
 
         return splits
 
-    # TODO: fix to plot split based on token count and final split
     def plot_similarity_scores(
         self, similarities: list[float], split_indices: list[int]
     ):
+        try:
+            from matplotlib import pyplot as plt
+        except ImportError:
+            logger.warning("Plotting is disabled. Please `pip install matplotlib`.")
+            return
+
         if not self.plot_splits:
             return
         plt.figure(figsize=(12, 6))
@@ -213,24 +225,97 @@ def plot_similarity_scores(
                 label="Split" if split_index == split_indices[0] else "",
             )
         plt.axhline(
-            y=self.score_threshold,
+            y=self.calculated_threshold,
             color="g",
             linestyle="-.",
             label="Threshold Similarity Score",
         )
+
+        # Annotating each similarity score
+        for i, score in enumerate(similarities):
+            plt.annotate(
+                f"{score:.2f}",  # Formatting to two decimal places
+                (i, score),
+                textcoords="offset points",
+                xytext=(0, 10),  # Positioning the text above the point
+                ha="center",
+            )  # Center-align the text
+
         plt.xlabel("Document Segment Index")
         plt.ylabel("Similarity Score")
-        plt.title(f"Threshold: {self.score_threshold}", loc="right", fontsize=10)
+        plt.title(
+            f"Threshold: {self.calculated_threshold} |"
+            " Window Size: {self.window_size}",
+            loc="right",
+            fontsize=10,
+        )
         plt.suptitle("Document Similarity Scores", fontsize=14)
         plt.legend()
         plt.show()
 
+    def plot_sentence_similarity_scores(
+        self, docs: list[str], threshold: float, window_size: int
+    ):
+        try:
+            from matplotlib import pyplot as plt
+        except ImportError:
+            logger.warning("Plotting is disabled. Please `pip install matplotlib`.")
+            return
+        """
+        Computes similarity scores between the average of the last
+        'window_size' sentences and the next one,
+        plots a graph of these similarity scores, and prints the first
+        sentence after a similarity score below
+        a specified threshold.
+        """
+        sentences = [sentence for doc in docs for sentence in split_to_sentences(doc)]
+        encoded_sentences = self.encode_documents(sentences)
+        similarity_scores = []
+
+        for i in range(window_size, len(encoded_sentences)):
+            window_avg_encoding = np.mean(
+                encoded_sentences[i - window_size : i], axis=0
+            )
+            sim_score = np.dot(window_avg_encoding, encoded_sentences[i]) / (
+                np.linalg.norm(window_avg_encoding)
+                * np.linalg.norm(encoded_sentences[i])
+                + 1e-10
+            )
+            similarity_scores.append(sim_score)
+
+        plt.figure(figsize=(10, 8))
+        plt.plot(similarity_scores, marker="o", linestyle="-", color="b")
+        plt.title("Sliding Window Sentence Similarity Scores")
+        plt.xlabel("Sentence Index")
+        plt.ylabel("Similarity Score")
+        plt.grid(True)
+        plt.axhline(y=threshold, color="r", linestyle="--", label="Threshold")
+        plt.show()
+
+        for i, score in enumerate(similarity_scores):
+            if score < threshold:
+                print(
+                    f"First sentence after similarity score "
+                    f"below {threshold}: {sentences[i + window_size]}"
+                )
+
     def __call__(self, docs: list[str]) -> list[DocumentSplit]:
+        if not docs:
+            raise ValueError("At least one document is required for splitting.")
+
+        if len(docs) == 1:
+            token_count = tiktoken_length(docs[0])
+            if token_count > self.max_split_tokens:
+                logger.warning(
+                    f"Single document exceeds the maximum token limit "
+                    f"of {self.max_split_tokens}. "
+                    "Splitting to sentences before semantically splitting."
+                )
+            docs = split_to_sentences(docs[0])
         encoded_docs = self.encode_documents(docs)
         self.find_optimal_threshold(docs, encoded_docs)
         similarities = self.calculate_similarity_scores(encoded_docs)
         split_indices = self.find_split_indices(similarities=similarities)
         splits = self.split_documents(docs, split_indices, similarities)
-
         self.plot_similarity_scores(similarities, split_indices)
         return splits
diff --git a/semantic_router/splitters/utils.py b/semantic_router/splitters/utils.py
new file mode 100644
index 00000000..04e3c8b5
--- /dev/null
+++ b/semantic_router/splitters/utils.py
@@ -0,0 +1,79 @@
+from typing import List
+
+import regex
+import tiktoken
+from colorama import Fore, Style
+
+from semantic_router.schema import DocumentSplit
+
+
+def split_to_sentences(text: str) -> list[str]:
+    """
+    Enhanced regex pattern to split a given text into sentences more accurately.
+
+    The enhanced regex pattern includes handling for:
+    - Direct speech and quotations.
+    - Abbreviations, initials, and acronyms.
+    - Decimal numbers and dates.
+    - Ellipses and other punctuation marks used in informal text.
+    - Removing control characters and format characters.
+
+    Args:
+        text (str): The text to split into sentences.
+
+    Returns:
+        list: A list of sentences extracted from the text.
+    """
+    regex_pattern = r"""
+        # Negative lookbehind for word boundary, word char, dot, word char
+        (?<!\b\w\.\w.)
+        # Negative lookbehind for single uppercase initials like "A."
+        (?<!\b[A-Z][a-z]\.)
+        # Negative lookbehind for abbreviations like "U.S."
+        (?<!\b[A-Z]\.)
+        # Negative lookbehind for abbreviations with uppercase letters and dots
+        (?<!\b\p{Lu}\.\p{Lu}.)
+        # Negative lookbehind for numbers, to avoid splitting decimals
+        (?<!\b\p{N}\.)
+        # Positive lookbehind for punctuation followed by whitespace
+        (?<=\.|\?|!|:|\.\.\.)\s+
+        # Positive lookahead for uppercase letter or opening quote at word boundary
+        (?="?(?=[A-Z])|"\b)
+        # OR
+        |
+        # Splits after punctuation that follows closing punctuation, followed by
+        # whitespace
+        (?<=[\"\'\]\)\}][\.!?])\s+(?=[\"\'\(A-Z])
+        # OR
+        |
+        # Splits after punctuation if not preceded by a period
+        (?<=[^\.][\.!?])\s+(?=[A-Z])
+        # OR
+        |
+        # Handles splitting after ellipses
+        (?<=\.\.\.)\s+(?=[A-Z])
+        # OR
+        |
+        # Matches and removes control characters and format characters
+        [\p{Cc}\p{Cf}]+
+    """
+    sentences = regex.split(regex_pattern, text, flags=regex.VERBOSE)
+    sentences = [sentence.strip() for sentence in sentences if sentence.strip()]
+    return sentences
+
+
+def tiktoken_length(text: str) -> int:
+    tokenizer = tiktoken.get_encoding("cl100k_base")
+    tokens = tokenizer.encode(text, disallowed_special=())
+    return len(tokens)
+
+
+def plot_splits(document_splits: List[DocumentSplit]) -> None:
+    colors = [Fore.RED, Fore.GREEN, Fore.BLUE, Fore.MAGENTA]
+    for i, split in enumerate(document_splits):
+        color = colors[i % len(colors)]
+        colored_content = f"{color}{split.content}{Style.RESET_ALL}"
+        print(f"Split {i + 1}, tokens {split.token_count}:")
+        print(colored_content)
+        print("-" * 88)
+        print("\n")

From f8f0a2cc06316d1de21fda1469f44bedf21a6056 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 10:18:06 +0200
Subject: [PATCH 06/14] fix: Minor fixes

---
 docs/examples/text_semantic_split.ipynb     | 74 +++++++++++----------
 semantic_router/splitters/rolling_window.py |  2 +-
 semantic_router/splitters/utils.py          | 12 +++-
 3 files changed, 50 insertions(+), 38 deletions(-)

diff --git a/docs/examples/text_semantic_split.ipynb b/docs/examples/text_semantic_split.ipynb
index 1d2af3dd..c7ef2f7c 100644
--- a/docs/examples/text_semantic_split.ipynb
+++ b/docs/examples/text_semantic_split.ipynb
@@ -32,9 +32,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/jakit/customers/aurelio/semantic-router/.venv/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
    "source": [
     "from semantic_router.splitters import RollingWindowSplitter\n",
     "from semantic_router.encoders import OpenAIEncoder\n",
@@ -49,34 +58,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "\u001b[33m2024-02-23 09:50:04 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881277932028191\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781277932028191\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.8687934834140205\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.8587934834140205\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Final optimal threshold: 0.8687934834140205\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
-      "\u001b[32m2024-02-23 09:50:05 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
+      "\u001b[33m2024-02-23 10:17:52 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881252553216503\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781252553216503\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.8687915616817252\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.8587915616817252\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Final optimal threshold: 0.8687915616817252\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAJJCAYAAAAJGAw6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxU1fsH8M/MsAw7IouAKIsL4gKuhJpLoRBlaptlpVJZ+hW/lt8yLRK1xRY1zUzNcglzKdefWZipaO7KoiKCG4oiu7LDADPn98dwL4wM68ydBZ/368VLuHPnzLmXOzLPPc95jogxxkAIIYQQQgghhBCjINZ3BwghhBBCCCGEENJ8FMgTQgghhBBCCCFGhAJ5QgghhBBCCCHEiFAgTwghhBBCCCGEGBEK5AkhhBBCCCGEECNCgTwhhBBCCCGEEGJEKJAnhBBCCCGEEEKMCAXyhBBCCCGEEEKIEaFAnhBCCCGEEEIIMSIUyBNCCCFtmKenJzw9PQVrf8GCBRCJRIiNjVXZLhKJMGLECMFet7HXJoQQQto6CuQJIeQRd+vWLYhEIpUvS0tLuLm54cknn8T8+fNx48YNfXezTYmNjYVIJMKCBQta/Nz8/HzMnTsXPXv2hKWlJSwtLdG5c2c8+eSTWLhwIbKzs7XfYSPCXc9TpkwR/LVOnDiBF198Ee7u7jAzM0O7du3g6+uLiRMnYtOmTYK/PiGEkEeXib47QAghxDD4+PjgtddeAwDIZDLk5OTg7Nmz+PTTT/HFF19gzpw5+PzzzyESifTc00fX3bt3MXjwYNy5cwcBAQEIDw+Hvb09MjMzcfLkSSxYsABDhgyBi4sL/5xDhw4J2qeIiAi8/PLL6NSpk6CvY2ivvXHjRrzxxhswMTFBWFgYunbtCpFIhNTUVPz55584duwYJk+erPN+EUIIeTRQIE8IIQQA0KVLF7UjxMePH8frr7+OxYsXQyKR4NNPP9V95wgAICoqCnfu3MGiRYvwySef1Hv80qVLsLe3V9nm4+MjaJ8cHR3h6Ogo6GsY2muXlZXhv//9L2xsbHDy5En07NlT5fGqqipK9yeEECIoSq0nhBDSqKFDhyImJgbm5ub4+uuvcefOHZXHq6ursWzZMvj7+8PCwgJ2dnYYOXIk9u3b12Cbe/fuxejRo9G+fXtIpVJ4enri9ddfR1JSEr/PiBEjGhz9nzJlCkQiEW7dusVv27hxI0QiETZu3Ih9+/YhMDAQlpaWcHd3xyeffAKFQgEA2LRpE9/XTp064ZtvvlH7GowxrF+/HkOGDIGtrS0sLS0xYMAArF+/vt6+dedqb9myBQEBAbCwsICrqytmzZqF8vJylX1HjhwJAFi4cKHKlIa6x6POqVOnAAAzZ85U+3jv3r3h4eGhsk3dHPm6/d2wYQN69+4NCwsLeHl54bvvvuOPf+nSpejevTukUim6du2KX375pdFjb8rVq1cxZ84c9OvXj//dd+vWDXPnzkVJSUm9/blroKKiApGRkfDx8YGpqSl/w+nh1964cSO8vLwAKH/Pdc9tbGwsIiMjIRKJ8Ntvv6nt3/r16yESibB48eJGjyMpKQnFxcUYOXJkvSAeAExNTTFq1Ci1z23OtQ8AeXl5ePfdd+Hl5QVzc3M4OzvjpZdeqrcfUPt+uHnzJpYuXQo/Pz+Ym5urTC/IycnBe++9hy5dusDc3ByOjo54/vnn1bZ37do1hIeH86/t4OAAf39/vPvuu2CMNXpuCCGE6AaNyBNCCGlS9+7d8dJLLyE6Ohp79uzhA0nGGF544QXs3bsX3bp1w4wZM1BaWort27fj2WefxbJly/Dee++ptPW///0Py5Ytg4ODA8aNGwdnZ2fcuXMH//zzD/r3749evXpp1Nfdu3fj77//xrhx4zBkyBDs378fn332GRhjsLOzw2effYaxY8dixIgR2LlzJ+bMmQMXFxdMmjSJb4MxhldffRVbt25F165dMXHiRJiZmeHgwYN48803kZycjCVLltR77e+//x4xMTEYO3YsnnjiCcTExOC7775DXl4efv31VwDK4PTWrVvYtGkThg8frlIQ7uHR9Ie1b98egDIgHjRokEbnCQCWL1+O2NhYvr87d+7ErFmzYGlpiYSEBOzcuRPPPPMMnnzySWzbtg2TJ0+Gp6cnhg0b1qrX27VrF37++WeMHDkSI0aMgEKhwOnTp/HVV1/h6NGjOHbsGExNTes97/nnn8eFCxcQGhoKe3t7Plh/WEBAAGbNmoUVK1bA398f48aN4x/z9PTE1KlTsXjxYvz000946aWX6j1/3bp1MDExQXh4eKPHwf0ebt68CblcDolE0qzjb+61n5ubi6CgINy4cQMjRozAyy+/jLS0NOzYsQP79+/HgQMHMHTo0Hrtz5w5E6dPn8bTTz+NMWPGwNnZGQD4du7evYvRo0dj3LhxyMnJwc6dO3HgwAEcOnQIgYGBAIB79+5h0KBBKC0txdNPP40JEyagtLQU165dww8//IAlS5bAxIQ+PhJCiN4xQgghj7S0tDQGgIWEhDS6388//8wAsNdff53ftmnTJgaADR8+nMlkMn777du3maOjIzMxMWE3btzgt+/bt48BYL1792Z5eXkq7VdVVbGsrCz+5+HDh7OG/kxNnjyZAWBpaWn8tg0bNjAAzNTUlJ09e5bfXlRUxJydnZmlpSXr0KGDSn/S09OZmZkZ6927t0r7P/74IwPAwsPDWWVlJb9dJpOxMWPGMADs/Pnz/PaoqCgGgNnZ2bGUlBR+e1lZGevWrRsTi8UsIyOD337kyBEGgEVFRak9voZ89913DABzdnZm8+fPZ0eOHGGFhYWNPqdz586sc+fOKtu4/jo4OKg9H3Z2dqxbt24sJyeHf+z06dMMABszZozato4cOaKynbsu6rp7967KdcJZuHAhA8A2b96ssp27BgICAlh+fn6956l7be56njx5spqzwdhTTz3FRCKRyrXDGGNJSUkMABs3bpza59WlUChY//79GQA2dOhQtm7dOnbp0iVWXV3d4HNacu2Hh4czAGzevHkq++3fv58BYF26dGFyuZzfzr0fOnbsyG7fvl3vtQcPHswkEgmLiYlR2Z6amspsbGxUrn/uGlu+fHm9dtT9DgghhOgHpdYTQghpFjc3NwDKlF8OV5n766+/hpmZGb+9U6dOeO+991BdXc2PRAPADz/8AABYsWIFP6rJMTExUSnS1lqvvfYaBg4cyP9sY2ODZ555BmVlZZg+fTq8vb35xzw8PDB06FAkJyejurqa3/7999/DysoKq1atUhkhNjMzw+effw4A2Lp1a73XnjVrFrp3787/bGFhgVdeeQUKhQJxcXEaH1tERAQ++OADFBQUYNGiRRg5ciTs7e3Rs2dPzJ07F5mZmS1qb9asWWrPR2FhIT7++GM4OTnxjwUGBsLb2xsXLlxodf+56u7qjgsA/vnnH7XPW7hwIRwcHFr9unVNmzYNjDH8/PPPKtt/+uknAMDUqVObbEMkEmHHjh0YMmQIjh8/jqlTp6J3796wtbVFcHAwNm7cCLlcrvKc5l77lZWV2Lp1K9q3b4/IyEiV/cLCwjBq1Chcv34dJ06cqNevDz74oF7hv4SEBJw8eRKTJ09GSEiIymPdunXD1KlTcenSpXop9hYWFvXa19bvgBBCiOYoN4oQQkirJSQkwNLSUm2aNzcPPDExkd929uxZmJubY/jw4YL1KSAgoN42V1fXRh+Ty+XIzs6Gu7s7ysrKcOnSJbi5ueGrr76qt39VVRUAICUlpd5j/fv3r7etY8eOAICCgoIWHIV6IpEIX3/9NebMmYM///wTp0+fxvnz5xEXF4fk5GSsXbsWMTExfJp0U1pzrs6cOdPq/jPGsGHDBmzcuBFJSUkoLCzkaxcAyrRudbQxjYDz9NNPw93dHRs2bMCCBQsgkUhQWVmJ6OhoeHh4IDQ0tFnteHp64vjx40hMTMQ///yD8+fP48SJEzh06BAOHTqEX375BX/99RfMzc0BNP/aT0lJQUVFBUaOHAlLS8t6j48cORIHDx5EYmIiHn/8cZXH1J2n06dPAwCys7PVFrPkruOUlBT06tULY8aMwbx58zBjxgwcOnQIoaGhGD58uMoNH0IIIfpHgTwhhJBm4YKsuqO0RUVF9YqrcbiAsKioiN9WWFgId3d3iMXCJYTZ2trW28bN6W3sMS5Af/DgARhjyMjIwMKFCxt8ndLS0ha99sMjtJpwdHTEpEmT+Hn9WVlZiIiIwM6dO/H22283e9S8NeeqbuZCS/33v//F999/Dw8PDzz77LNwdXXlA92FCxdCJpOpfZ42MjU4EokEb731FhYuXIi//voLzzzzDHbv3o38/HxERES0+NoMCAhQuekRGxuL1157DUeOHMEPP/zA14ho7rXPvV8aOmZ17yuOuufcv38fALB//37s37+/wdflrmdPT0+cPn0aCxYswJ9//skXBvT19cWiRYvw4osvNtp/QgghukGp9YQQQpqFqwxeN23d1tYWOTk5avfPysri9+HY29sjKytLZRS2IVzAoy5wLCwsbHa/W4rrb//+/cEYa/DryJEjgvWhpTp06IDo6GiYm5vj4sWLyM/P13eX6snJycGqVavQp08fpKSkYOPGjVi8eDEWLFiAadOmNfrchlYvaK233noLEokE69atA6BMqxeLxXjjjTc0bnvEiBH8Eo2HDx/mtzf32ueuv+zsbLWPq3tfcdSdJ26/lStXNno9113zvlevXtixYwfu37+PU6dOYf78+cjKysKECRPUpvQTQgjRPQrkCSGENOnq1av47bffYG5ujvHjx/Pb+/bti7KyMpw9e7bec7jAv+5o5aBBgyCTyXD06NEmX7Ndu3YAgIyMDJXtCoVCo3naTbGxsUGPHj1w5coVraTDq8NVOdfmKL25ubnaiu+G4ubNm2CMITg4uF7K+L///qu112nOue3YsSOefvpp/Pnnnzh58iQOHTqEkJCQevPLW8va2rretuZe+76+vpBKpTh37hzKysrqPa7ufdUYbpoFt3RhS5iamuKxxx7DwoUL8d1334Exhj/++KPF7RBCCNE+CuQJIYQ06sSJEwgJCYFMJsPcuXPh7u7OP8aN4s2bN49PTQeAO3fuYNmyZTAxMcGrr77Kb58xYwYAZZE1LuWXU11drTIKyY38b9y4UWW/ZcuWIS0tTTsH14D//ve/KCsrw9SpU9Wm0KelpTW55ntjuKJhd+7cadHzli5dqnZuPqAs0FdSUgJfX996xdQMQefOnQEAJ0+eVBmVvnv3LubNm6e112nXrh1EIlGT5/add95BdXU1XnzxRTDGmlXkjpOWlobvv/8excXF9R4rKyvDihUrAEBlibjmXvtmZmZ45ZVXkJeXV289+5iYGBw4cABdunTBkCFDmtXXQYMGITAwEFu3bsX27dvrPa5QKFRuLsTFxalN2+f6J5VKm/W6hBBChEVz5AkhhAAArl+/zhfDqqysRE5ODs6ePYtLly5BIpEgMjISUVFRKs95/fXXsWvXLuzduxd9+vTBM888w68jf//+fSxdulSlSFZYWBjef/99LFmyBF27dsX48ePh7OyMjIwMHDp0CO+//z7effddAEB4eDi+/vprLFiwAImJifDx8cH58+eRlJSE4cOHN2tUv7XeeecdnD59Gps2bcKJEycQHBwMNzc3ZGdnIyUlBWfOnMGWLVvg6enZqvZ9fX3h5uaGbdu2wdzcHB07doRIJMLMmTNhZ2fX4POio6Px/vvvo3fv3ggMDISzszMKCgpw+vRpxMfHw8LCAqtXr27lUQvL1dUVzz//PHbu3IkBAwbgySefRHZ2Nv744w88+eSTuHHjhlZex9raGgMHDsSxY8fw+uuvo2vXrhCLxXj99df5mwkAEBoais6dO+P27dvo0KEDxowZ0+zXKCwsxMyZM/HBBx9g6NCh6NWrFywsLJCRkYH9+/cjPz8f/fv3x8yZM/nntOTa/+qrr3D06FF89tlnOHnyJAIDA3Hr1i38/vvvsLS0xIYNG1o0l3/r1q0YOXIkXn75ZSxfvhz9+vWDhYUF0tPTcerUKeTm5qKiogKA8hpbu3Ythg0bBh8fH9ja2iI5ORl//vknHBwcEB4e3uzXJYQQIhwK5AkhhAAAbty4wRd3s7CwgL29PXx9ffHJJ59g8uTJ8PHxqfccbhmuFStWYNOmTVi5ciXMzMzQr18/zJ49G88++2y953zzzTcICgrC999/jx07dqCiogKurq544oknMGrUKH4/FxcXHDlyBP/73//w999/w8TEBCNHjsTp06fx2WefCRrIi0QibNy4EWFhYVi3bh3++OMPlJSUwNnZGV27dsWSJUsQHBzc6vYlEgl27dqFDz/8EFu3buVHdl977bVGA/kNGzZg3759OHz4MA4cOIDs7GxIJBJ07twZ06dPx3vvvYeuXbu2ul9C27hxIzw9PbFz506sXLkSnTp1wuzZs/Hhhx9ix44dWnud6OhovPfee/jjjz9QWFgIxhiGDh2qEshzwf1nn32GKVOm8EX+mqNHjx7YuXMnDhw4gDNnzmDz5s148OABbG1t0bNnTzz33HOYPn16vdHr5l77Tk5OOHPmDD799FPs3bsX//77L+zs7DBu3DhERUWhV69eLTofXl5eSEhIwLJly7Bnzx5s2LABEokErq6uGDZsGF544QV+31deeQUVFRU4ceIEzp49C5lMho4dO2L69Olql7cjhBCiHyLGGNN3JwghhBBCdO2ZZ57Bn3/+iatXr6JLly767g4hhBDSbDRHnhBCCCGPHC5dfNSoURTEE0IIMTqUWk8IIYSQR8aWLVuQmpqKX375BQDq1X0ghBBCjAEF8oQQQgh5ZPz444/4999/0blzZ/z8888YPHiwvrtECCGEtBjNkSeEEEIIIYQQQowIzZEnhBBCCCGEEEKMCAXyhBBCCCGEEEKIEaFAnhBCCCGEEEIIMSIUyBNCCCGEEEIIIUaEAnlCCCGEEEIIIcSIUCBPCCGEEEIIIYQYEQrkCSGEEEIIIYQQI0KBPCGEEEIIIYQQYkQokCeEEEIIIYQQQowIBfKEEEIIIYQQQogRoUCeEEIIIYQQQggxIhTIE0IIIYQQQgghRoQCeUIIIYQQQgghxIhQIE8IIYQQQgghhBgRCuQJIYQQQgghhBAjQoE8IYQQQgghhBBiRCiQJ4QQQgghhBBCjAgF8oQQQgghhBBCiBGhQJ4QQgghhBBCCDEiFMgTQgghhBBCCCFGhAJ5QgghhBBCCCHEiFAgTwghhBBCWi02NhYikQgFBQU6fd2NGzfC3t5eozZu3boFkUiExMTEBvfR1/ER0hrcNS1Uu429V5pjwYIFCAgI0EqftGXKlCkYN26cvrvRYhTIE0IIIYQQtUQiUaNfCxYs0HcXDdbFixfx+OOPQyqVwsPDA19//XWTzzl37hyefPJJ2Nvbo127dggJCcGFCxdU9mGMYcmSJejWrRvMzc3h7u6Ozz//XGWfX3/9Ff7+/rC0tISrqyveeOMN5Ofn84+PGDFC7e/z6aef5vfJzs7GlClT4ObmBktLS4SGhuLatWsqr/Pjjz9ixIgRsLW1bfBmh6enZ73X+fLLL1t0TJmZmZg4cSK6desGsViMd999V+35KygowIwZM+Dq6gpzc3N069YNf/75J/+4XC7HJ598Ai8vL1hYWMDHxweffvopGGP8Prt27cLo0aPRvn17tYErF9Cq+/r9998BABcuXMArr7wCDw8PWFhYoEePHlixYoVKO9wNooe/srKy+H0WL16MgQMHwsbGBs7Ozhg3bhxSU1PVHntzxcTE1HsdAHB1dYWnp6faYz106BA8PDyQmZmJXr16afT6+rBu3Tr4+/vD2toa9vb26Nu3LxYvXsw/vmLFCmzcuFGnfZoyZUq9331oaGiL2jARqG+EEEIIIcTIZWZm8t9v374d8+fPVwkkrK2tcf78+Ra3W1lZCTMzM6300RAVFRVh9OjRCA4Oxpo1a3Dp0iW88cYbsLe3x9tvv632OSUlJQgNDcWzzz6LH374AdXV1YiKikJISAju3LkDU1NTAMCsWbPw999/Y8mSJejduzfu37+P+/fv8+2cOHECkyZNwrfffosxY8YgIyMD06ZNw9SpU7Fr1y4AymC1srKSf05+fj78/f3x4osvAlAG1uPGjYOpqSn27t0LW1tbLFu2DMHBwUhOToaVlRUAoKysDKGhoQgNDcW8efMaPB+LFi3C1KlT+Z9tbGxUHm/qmGQyGZycnBAZGYlvv/1W7WtUVlZi1KhRcHZ2xo4dO+Du7o7bt2+rZG189dVXWL16NTZt2oSePXvi/PnzCA8Ph52dHf773/8CAEpLSzF06FC89NJLKn3mcAFtXT/++CO++eYbPPXUUwCAuLg4ODs7Y/PmzfDw8MDJkyfx9ttvQyKRICIiQuW5qampsLW15X92dnbmvz969ChmzJiBgQMHorq6Gh999BFGjx6t8jtoqaFDh8LExASxsbF4+eWXAQBXrlxBeXk5ysrKcOvWLT6gP3LkCMzNzTFkyBBIJBJ06NChVa+pT+vXr8e7776L7777DsOHD4dMJsPFixeRlJTE72NnZ6eXvoWGhmLDhg38z+bm5i1rgBFCCCGEENKEDRs2MDs7u3rbjxw5wgCwf/75h/Xv359ZWFiwoKAglpKSwu8TFRXF/P392bp165inpycTiUSMMcYePHjA3nzzTebo6MhsbGzYyJEjWWJiIv+8xMRENmLECGZtbc1sbGxYv3792Llz51T6ExMTw3x9fZmVlRULCQlh9+7d458vl8vZwoULmbu7OzMzM2P+/v7sr7/+4h9PS0tjAFhCQgK/bf/+/axr165MKpWyESNGsA0bNjAA7MGDB80+Vz/88ANr164dk8lk/LYPP/yQde/evcHnnDt3jgFg6enp/LaLFy8yAOzatWuMMcaSk5OZiYmJyrl92DfffMO8vb1Vtn333XfM3d29wed8++23zMbGhpWUlDDGGEtNTWUAWFJSEr+PXC5nTk5ObN26dfWez10D6s5R586d2bffftvgazfnmOoaPnw4mzVrVr3tq1evZt7e3qyysrLB5z799NPsjTfeUNn23HPPsVdffbXevuqujYYEBATUa/dh//nPf9jIkSP5nxs7Zw3JyclhANjRo0cb3Ifrd2OCgoLYO++8w//8ww8/sKeffpo99dRTbMOGDfz2SZMmseHDh6u0y52P5rzvGWNs8eLFzNnZmVlbW7M33niDffjhh8zf359/vKn36PPPP89mzJjB/zxr1iwGgF25coUxxphMJmOWlpbs4MGDao917NixbMqUKY2ej8mTJ7OxY8eqHOfDX9x5YIyxf//9lw0dOpRJpVLWsWNHNnPmTP6901x1X7O1KLWeEEIIIYRo7OOPP8bSpUtx/vx5mJiY4I033lB5/Pr169i5cyd27drFpyu/+OKLyMnJwV9//YW4uDj069cPTz75JD8a++qrr6Jjx444d+4c4uLiMHfuXH5kGlCOCC9ZsgTR0dE4duwY0tPT8f777/OPr1ixAkuXLsWSJUtw8eJFhISE4Nlnn62XIs65c+cOnnvuOYwZMwaJiYl46623MHfu3Hr7iUSiRlNxT506hWHDhqlkHYSEhCA1NRUPHjxQ+5zu3bujffv2+Pnnn1FZWYny8nL8/PPP6NGjBz9Cum/fPnh7e+OPP/6Al5cXPD098dZbb6mMXgcFBeHOnTv4888/wRhDdnY2duzYgbCwsAb7+/PPP+Pll1/mR3llMhkAQCqV8vuIxWKYm5vj+PHjDbbTkC+//BLt27dH37598c0336C6upp/rDnH1Bz/93//h6CgIMyYMQMuLi7o1asXvvjiC8jlcn6fwYMH49ChQ7h69SoAZQr88ePH+ZH01oiLi0NiYiLefPPNRvcrLCyEg4NDve0BAQFwdXXFqFGjcOLEiSbbAKC2nZYYOXIkjhw5wv985MgRjBgxAsOHD1fZHhsbi5EjRzbaVmPv+99++w0LFizAF198gfPnz8PV1RU//PCDyvObeo8OHz4csbGx/P5Hjx6Fo6Mjv+3cuXOoqqrC4MGD1favQ4cOOH36NG7fvt2sc8NlXHBfCQkJaN++PYYNGwYAuHHjBkJDQ/H888/j4sWL2L59O44fP66SabFgwYJ60xTUiY2NhbOzM7p3747p06erTH9pFo1uAxBCCCGEkEdCc0bkOfv372cAWHl5OWNMOSJvamrKcnJy+H3+/fdfZmtryyoqKlTa8/HxYWvXrmWMMWZjY8M2btzYYH8AsOvXr/PbVq1axVxcXPif3dzc2Oeff67yvIEDB7L//Oc/jLH6o4zz5s1jfn5+Kvt/+OGH9UZOu3fvznbt2qW2X4wxNmrUKPb222+rbLt8+TIDwJKTkxt83qVLl5iPjw8Ti8VMLBaz7t27s1u3bvGPv/POO8zc3JwFBgayY8eOsSNHjrCAgACVkV7GGPvtt9+YtbU1MzExYQDYmDFjGhypPnPmDAPAzpw5w2+rrKxknTp1Yi+++CK7f/8+k8lk7Msvv2QA2OjRo+u10djo8tKlS9mRI0fYhQsX2OrVq5m9vT177733WnxMnIZG5Lt3787Mzc3ZG2+8wc6fP8+2bdvGHBwc2IIFC/h95HI5+/DDD5lIJGImJiZMJBKxL774Qu3rNHdEfvr06axHjx6N7nPixAlmYmLCDhw4wG9LSUlha9asYefPn2cnTpxg4eHhzMTEhMXFxaltQy6Xs6effpoNGTKk0ddqzoj8wYMHGQA+e8XZ2ZmdPXuWnTx5knXu3JkxxtiNGzdURv8bG5HnPPy+DwoK4t9rnMDAQJUR+abeoxcvXmQikYjl5OSw+/fvMzMzM/bpp5+yCRMmMMYY++yzz9jgwYMbPNZ79+6xxx57jAFg3bp1Y5MnT2bbt29ncrmc36eh0fHy8nIWGBjInnnmGX7/N998s957+99//2VisZg/7pUrV7InnniiwT4xxtjWrVvZ3r172cWLF9nu3btZjx492MCBA1l1dXWjz6uL5sgTQgghhBCN9enTh//e1dUVAJCTk4NOnToBADp37gwnJyd+nwsXLqCkpATt27dXaae8vBw3btwAAMyePRtvvfUWoqOjERwcjBdffBE+Pj78vpaWlio/u7q6IicnB4Bynvq9e/cwZMgQlfaHDBlSr4Ac58qVKwgMDFTZFhQUVG+/lJSUBs5C65WXl+PNN9/EkCFDsHXrVsjlcixZsgRPP/00zp07BwsLCygUCshkMvzyyy/o1q0bAOVoev/+/ZGamoru3bsjOTkZs2bNwvz58xESEoLMzEx88MEHmDZtGn7++ed6r/vzzz+jd+/eGDRoEL/N1NQUu3btwptvvgkHBwdIJBIEBwfjqaeeUikM1xyzZ8/mv+/Tpw/MzMzwzjvvYPHixTA3N2/WMTWHQqGAs7MzfvzxR0gkEvTv3x8ZGRn45ptvEBUVBUA5Qvzrr79iy5Yt6NmzJxITE/Huu+/Czc0NkydPbtFxAcrf2ZYtW/DJJ580uE9SUhLGjh2LqKgojB49mt/evXt3lWMbPHgwbty4gW+//RbR0dH12pkxYwaSkpJalRHxsMGDB8PMzAyxsbHw9/dHeXk5+vXrB4VCgdzcXKSlpSE2NhYWFhZ47LHHGm2rsff9lStXMG3aNJX9g4KC+FH/5rxHe/XqBQcHBxw9ehRmZmbo27cvnnnmGaxatQqAcoR+xIgRDfbP1dUVp06dQlJSEo4dO4aTJ09i8uTJ+OmnnxATEwOxuOEE9TfeeAPFxcU4ePAgv9+FCxdw8eJF/Prrr/x+jDEoFAqkpaWhR48eiIiIqFcL4WFcfQIA6N27N/r06QMfHx/ExsbiySefbPS5HArkCSGEEEKIxuqmvHPLXykUCn7bw8W5SkpK4OrqqpI2y+EKlC1YsAATJ07E/v378ddffyEqKgrbtm3D+PHj670m97otDTSF0KFDB2RnZ6ts435uqGDYli1bcOvWLZw6dYoPGrZs2YJ27dph7969ePnll+Hq6goTExM+4AWAHj16AADS09PRvXt3LF68GEOGDMEHH3wAQBloWVlZ4fHHH8dnn33GB1uAsrDbtm3bsGjRonr96d+/PxITE1FYWIjKyko4OTkhMDAQAwYM0ODMAIGBgaiursatW7fQvXv3Zh1Tc7i6usLU1BQSiUSlnaysLL644gcffIC5c+fyQVTv3r1x+/ZtLF68uFWB/I4dO1BWVoZJkyapfTw5ORlPPvkk3n77bURGRjbZ3qBBg9QG6hEREfjjjz9w7NgxdOzYscX9fJilpSUGDRqEI0eO4P79+xg6dCgkEgkkEgkGDx6MI0eO4MiRIxgyZEiTRSmbet9rSiQSYdiwYYiNjYW5uTlGjBiBPn36QCaTISkpCSdPnlSZTtOQXr16oVevXvjPf/6DadOm4fHHH8fRo0cbnDrw2Wef4cCBAzh79qxKccaSkhK88847fHHEuriblq3h7e0NR0dHXL9+vdmBPM2RJ4QQQgghOtevXz9kZWXBxMQEXbp0UflydHTk9+vWrRvee+89/P3333juuedUqjw3xtbWFm5ubvXmHZ84cQJ+fn5qn9OjRw+cPXtWZdvp06dbeGTKUcdjx46hqqqK33bw4EF0794d7dq1U/ucsrIyiMVilTXAuZ+5wGjIkCGorq7mMxYA8PO9O3furNJOXVxw+/BNjt9//x0ymQyvvfZag8diZ2cHJycnXLt2DefPn8fYsWObPP7GJCYmQiwW89XZm3NMzTFkyBBcv35dJYi8evUqXF1d+WC0oXPT2sDz559/xrPPPquSacK5fPkyRo4cicmTJ9dbHrAhiYmJKjdaGGOIiIjA7t27cfjwYXh5ebWqn+qMHDkSsbGxiI2NVRnR5oLmxoLc5urRowfOnDmjsq3u+6m571FunjzXV7FYjGHDhuGbb76BTCarN6LfFK7t0tJStY/v3LkTixYtwm+//aaS8QMo/99KTk6u939Wly5dNFqJ4+7du8jPz1f5/Tep2Un4hBBCCCHkkdXUHPm686MTEhIYAJaWlsYYq61aX5dCoWBDhw5l/v7+7MCBAywtLY2dOHGCffTRR+zcuXOsrKyMzZgxgx05coTdunWLHT9+nPn4+LA5c+Y02J/du3erzA/+9ttvma2tLdu2bRtLSUlhH374ITM1NWVXr15ljNWf93v79m1mZmbG3n//fZaSksJ+/fVX1qFDhxbPkS8oKGAuLi7s9ddfZ0lJSWzbtm3M0tKSn/vPGGO7du1SqWJ/5coVZm5uzqZPn86Sk5NZUlISe+2115idnR0/l1kul7N+/fqxYcOGsfj4eHb+/HkWGBjIRo0apfJ7MjExYT/88AO7ceMGO378OBswYAAbNGhQvX4OHTqUn2v8sN9++40dOXKE3bhxg+3Zs4d17tyZPffccyr7ZGZmsoSEBLZu3ToGgB07dowlJCSw/Px8xhhjJ0+eZN9++y1LTExkN27cYJs3b2ZOTk5s0qRJfBvNOSbGlNdUQkIC69+/P5s4cSJLSEhgly9f5h9PT09nNjY2LCIigqWmprI//viDOTs7s88++4zfZ/Lkyczd3Z398ccfLC0tje3atYs5Ojry1xRjjOXn57OEhAR+vve2bdtYQkICy8zMVOnPtWvXmEgkUqmwzrl06RJzcnJir732GsvMzOS/6taI+Pbbb9mePXvYtWvX2KVLl9isWbOYWCxWmXM+ffp0Zmdnx2JjY1XaKSsrU/s7Y6x5c+QZY+zw4cMMALOxsWGnT5/mtx89epTZ2NgwAOzkyZP12n14jnxj7/tt27YxqVTK1q9fz1JTU9n8+fOZjY2Nyv8FTb1HGVOuXiESiZi5uTkrLi7mnyeRSNhjjz3W6HFOmzaNLVq0iB0/fpzdunWLnTp1ij399NPMycmJ5eXlMcZU58hfunSJWVpassjISJVzzl3TFy5cYBYWFmzGjBksISGBXb16le3Zs0elsn5Tc+SLi4vZ+++/z06dOsXS0tLYP//8w/r168e6du1ar2ZIYyiQJ4QQQgghTdJ2IM8YY0VFRWzmzJnMzc2NmZqaMg8PD/bqq6+y9PR0JpPJ2Msvv8w8PDyYmZkZc3NzYxEREXxBqeYE8nK5nC1YsIC5u7szU1PTZi0/t2/fPtalSxdmbm7OHn/8cbZ+/fp6xwdAZZkudS5cuMCGDh3KzM3Nmbu7O/vyyy/rnc+HA66///6bDRkyhNnZ2bF27dqxJ554gp06dUpln4yMDPbcc88xa2tr5uLiwqZMmcIHGZzvvvuO+fn5MQsLC+bq6speffVVdvfuXZV9UlJSGAD2999/q+3/ihUrWMeOHZmpqSnr1KkTi4yMVFlOjzHl7xVqlurizk1cXBwLDAxkdnZ2TCqVsh49erAvvviiXrDSnGNS9zpcYTbOyZMnWWBgIDM3N2fe3t7s888/VykeVlRUxGbNmsU6derEpFIp8/b2Zh9//LHKcXG/l4e/oqKiVF5r3rx5zMPDQ6VoWlPnpW5/v/rqK+bj48OkUilzcHBgI0aMYIcPH27ymJu69pobyJeXlzNzc3NmbW3Nqqqq+O0VFRVMKpXW296aQJ4xxj7//HPm6OjIrK2t2eTJk9mcOXPqLT/X2HuU26ddu3YsMDCw3mvNnTu30ePcsWMHCwsLY66urvz/I88//zy7ePEiv0/dQL6h33/d5efOnj3LRo0axaytrZmVlRXr06ePSsG+qKioetdmXWVlZWz06NHMycmJmZqass6dO7OpU6eyrKysRo/lYSLGDGAiESGEEEIIIYQQjdy6dQteXl4GUSuCCIvmyBNCCCGEEEIIIUaEAnlCCCGEEEIIIcSIUCBPCCGEEEIIIW2Avb09oqKi9N0NogM0R54QQgghhBBCCDEiNCJPCCGEEEKIgVm1ahU8PT0hlUoRGBhYb337uqqqqrBo0SL4+PhAKpXC398fMTExKvusXr0affr0ga2tLWxtbREUFIS//vpL6MMghAiEAnlCCCGEEEIMyPbt2zF79mxERUUhPj4e/v7+CAkJQU5Ojtr9IyMjsXbtWqxcuRLJycmYNm0axo8fj4SEBH6fjh074ssvv0RcXBzOnz+PJ554AmPHjsXly5d1dViEEC2i1Ho1FAoF7t27BxsbG4hEIn13hxBCCCGEPEKeeOIJ9OvXD0uWLAGg/Gzq5+eHt99+G7Nnz663f/fu3fH+++9j6tSp/LbXXnsNFhYWWLduXYOv07lzZ3z66aeYNGmS9g+CENJijDEUFxfDzc0NYnHjY+4UyKtx9+5deHh46LsbhBBCCCGEEEIeMXfu3EHHjh0b3cdER30xKjY2NgCUJ9DW1lbPvSFtUlUVsGGD8vvwcMDUVL/9IYS0Hr2fiTp0XQivjZ7jzMxM+Pr64uDBgxg0aBC//ZNPPsGJEydw+PDhes958803kZSUhC1btsDLywuxsbGYOHEi5HI5cnNz+f0uX76MUaNGoaKiAtbW1vjpp58wevTohjsj1Dk2tnaFblsIxtZfwDivCy0rKiqCh4cHH482hkbk1SgqKoKdnR0KCwspkCfCKC0FrK2V35eUAFZW+u0PIaT16P1M1KHrQnht9Bzfu3cP7u7uOHnyJIKCgvjtc+bMwdGjR3HmzJl6z8nNzcXUqVOxb98+iEQi+Pj4IDg4GOvXr0d5eTm/X2VlJdLT01FYWIgdO3bgp59+wtGjR+Hn56e+M0KdY2NrV+i2hWBs/QWM87rQspbEoVTsjhBCCCGEEAPh6OgIiUSC7Oxsle3Z2dno0KGD2uc4OTlhz549KC0txe3bt5GSkgJra2t4e3ur7GdmZoYuXbqgf//+WLx4Mfz9/bFixQrBjoUQIhwK5AkhhBBCCDEQZmZm6N+/Pw4dOsRvUygUOHTokMoIvTpSqRTu7u6orq7Gzp07MXbs2Eb3VygUkMlkWuk3IUS3aI48IYQQQgghBmT27NmYPHkyBgwYgEGDBmH58uUoLS1FeHg4AGDSpElwd3fH4sWLAQBnzpxBRkYGAgICkJGRgQULFkChUGDOnDl8m/PmzcNTTz2FTp06obi4GFu2bEFsbCwOHDigl2MkhGiGAnlCCCGEEEIMyIQJE5Cbm4v58+cjKysLAQEBiImJgYuLCwAgPT1dZWmqiooKREZG4ubNm7C2tkZYWBiio6Nhb2/P75OTk4NJkyYhMzMTdnZ26NOnDw4cOIBRo0bp+vAIIVpAxe7UoGJ3RHBGVHSDENIEej8Tdei6EB6dY+EZW/ExKnZXy9j6CxjndaFlVOyOEEIIIYQQQghpoyi1nhB9MDcH/vij9ntCiPGi9zNRh64L4dE5Fp5Q59jY2hW6bSEYW38B47wu9IhS69Wg1HpCCCGEEEIIIbpEqfWEEEIIIYQQQkgbRan1hOhDVRXw66/K7199FTA11W9/CCGtR+9nog5dF8Kjcyw8oc6xsbUrdNtCMLb+AsZ5XegRpdarQan1RHBGVD2TENIEej8Tdei6EB6dY+EZWxVxqlpfy9j6CxjndaFllFpPCCGEEEIIIYS0URTIE0IIIYS0UatWrYKnpyekUikCAwNx9uzZBvetqqrCokWL4OPjA6lUCn9/f8TExKjss3r1avTp0we2trawtbVFUFAQ/vrrL6EPgxBCyEMokCeEEEIIaYO2b9+O2bNnIyoqCvHx8fD390dISAhycnLU7h8ZGYm1a9di5cqVSE5OxrRp0zB+/HgkJCTw+3Ts2BFffvkl4uLicP78eTzxxBMYO3YsLl++rKvDImrIFQynbuRjb2IGTt3Ih1xBM2cJaetojrwaNEeeCM6I5uoQQppA72eijgFcF4GBgRg4cCC+//57AIBCoYCHhwdmzpyJuXPn1tvfzc0NH3/8MWbMmMFve/7552FhYYHNmzc3+DoODg745ptv8Oabb2r/IBpjAOfYEMQkZWLhvmRkFlbw21ztpIga44fQXq6aNW5sc5ZpjnwtY+svYJzXhZbRHHlCCCGEkEdYZWUl4uLiEBwczG8Ti8UIDg7GqVOn1D5HJpNBKpWqbLOwsMDx48fV7i+Xy7Ft2zaUlpYiKChIe50nzRaTlInpm+NVgngAyCqswPTN8YhJytRTzwghQqNAnhBCCCGkjcnLy4NcLoeLi4vKdhcXF2RlZal9TkhICJYtW4Zr165BoVDg4MGD2LVrFzIzVYPBS5cuwdraGubm5pg2bRp2794NPz8/wY6FqCdXMCzclwx1qbXctoX7kinNnpA2itaRJ0QfzM2B336r/Z4QYrzo/UzUMcLrYsWKFZg6dSp8fX0hEong4+OD8PBwrF+/XmW/7t27IzExEYWFhdixYwcmT56Mo0eP6j6YN8JzrE1n0+7XG4mviwHILKzA2bT7CPJp37oXEeocG1u7QrctBGPrL2Cc14Ue0Rx5NWiOPCGEEEKMWWVlJSwtLbFjxw6MGzeO3z558mQUFBRg7969DT63oqIC+fn5cHNzw9y5c/HHH380WswuODgYPj4+WLt2rTYPgTRhb2IGZm1LbHK/FS8HYGyAu/AdIoRojObIE0IIIYQ8wszMzNC/f38cOnSI36ZQKHDo0KEm57NLpVK4u7ujuroaO3fuxNixYxvdX6FQQCaTaaXfpPmcbaRN79SC/QghxoVS6wnRh+pqYPdu5ffjxwMm9FYkxGjR+5moYwDXxezZszF58mQMGDAAgwYNwvLly1FaWorw8HAAwKRJk+Du7o7FixcDAM6cOYOMjAwEBAQgIyMDCxYsgEKhwJw5c/g2582bh6eeegqdOnVCcXExtmzZgtjYWBw4cEDnx2cI51ifBnk5oIOtObKK1N9EEQHoYCfFIC+H1r+IUOfY2NoVum0hGFt/AeO8LvSobRwFIcZGJgNeekn5fUlJm/kPhZBHEr2fiToGcF1MmDABubm5mD9/PrKyshAQEICYmBi+AF56ejrE4trkzIqKCkRGRuLmzZuwtrZGWFgYoqOjYW9vz++Tk5ODSZMmITMzE3Z2dujTpw8OHDiAUaNG6frwDOIc65NELMITvs7YcvZOvcdENf9GjfGDRCyq93izCXWOja1dodsWgrH1FzDO60KPKLWePHJWrVoFT09PSKVSBAYG4uzZsw3uW1VVhUWLFsHHxwdSqRT+/v6IiYlR2Wfx4sUYOHAgbGxs4OzsjHHjxiE1NVXowyCEEEKaFBERgdu3b0Mmk+HMmTMIDAzkH4uNjcXGjRv5n4cPH47k5GRUVFQgLy8Pv/zyC9zc3FTa+/nnn3Hr1i3IZDLk5OTgn3/+0U8QT1BZrcDRq3kAACszicpjHeykWP1aP83XkSeEGCwK5MkjZfv27Zg9ezaioqIQHx8Pf39/hISEICcnR+3+kZGRWLt2LVauXInk5GRMmzYN48ePR0JCAr/P0aNHMWPGDJw+fRoHDx5EVVUVRo8ejdLSUl0dFiGEEEIeMTvj7yKjoBxONuaI/WAkv31j+EAc//AJCuIJaeMokCePlGXLlmHq1KkIDw+Hn58f1qxZA0tLy3pL63Cio6Px0UcfISwsDN7e3pg+fTrCwsKwdOlSfp+YmBhMmTIFPXv2hL+/PzZu3Ij09HTExcXp6rAIIYQQ8gipkiuw6sh1AMA7w7zhaG0Gk5oUet8Otpql0xNCjAIF8uSRUVlZibi4OAQHB/PbxGIxgoODcerUKbXPkclkkEpVq71aWFjg+PHjDb5OYWEhAMDBQYPiMoQQQgghDdgVfxd3H5TD0docrwZ2hkgkgq2FKQCgqKJKz70jhOgCBfLkkZGXlwe5XM4X+eG4uLggKytL7XNCQkKwbNkyXLt2DQqFAgcPHsSuXbuQmZmpdn+FQoF3330XQ4YMQa9evbR+DIQQQgh5tFXJFfi+ZjR+2nBvWNTMj7eVKgt4FZVTIE/Io4ACeUIasWLFCnTt2hW+vr4wMzNDREQEwsPDVar81jVjxgwkJSVh27ZtOu4pIYQQQh4FuxMycOd+ORytzfBqYGd+O43IE/JoaRu19wlpBkdHR0gkEmRnZ6tsz87ORocOHdQ+x8nJCXv27EFFRQXy8/Ph5uaGuXPnwtvbu96+ERER+OOPP3Ds2DF07Nix8c6YmQEbNtR+TwgxXvR+JurQdSG8R/AcV9eZG//2sNrReACwldYE8uXV2ntBoc6xsbUrdNtCMLb+AsZ5XeiRiDHG9N0JQ1NUVAQ7OzsUFhbC1tZW390hWhQYGIhBgwZh5cqVAJSp8J06dUJERATmzp3b5POrqqrQo0cPvPTSS/jiiy8AAIwxzJw5E7t370ZsbCy6du0q6DEQQggh5NG0I+4u3v/9AtpbmeHfD0fC0qx2TO4/v8bhz0tZWDS2JyYFeeqvk4SQVmtJHEoj8uSRMnv2bEyePBkDBgzAoEGDsHz5cpSWliI8PBwAMGnSJLi7u2Px4sUAgDNnziAjIwMBAQHIyMjAggULoFAoMGfOHL7NGTNmYMuWLdi7dy9sbGz4+fZ2dnawsLDQ/UESQgghpM2pliuw8vA1AMDUYd4qQTxQd0SeUusJeRRQIE8eKRMmTEBubi7mz5+PrKwsBAQEICYmhi+Al56erjL/vaKiApGRkbh58yasra0RFhaG6Oho2Nvb8/usXr0aADBixAiV19qwYQOmTJmiviPV1cCBA8rvQ0IAE3orEmK06P1M1DGy60KuYDibdh85xRVwtpFikJeD4S9hZmTnWFN7E+/hdn4ZHKzM8Ppjnes9XjtHXoup9UKdY2NrV+i2hWBs/QWM87rQI0qtV4NS64ngSksBa2vl9yUlgJWVfvtDCGk9ej8TdYzouohJysTCfcnILKzgt7naSRE1xg+hvVz12LMmGNE51lS1XIFR3x5DWl4p5oR2x39GdKm3z/eHr2HJ31fx8kAPfPl8H+28sFDn2NjaFbptIRhbfwHjvC60rCVxKFWtJ4QQQgh5RMUkZWL65niVIB4AsgorMH1zPGKS1C+3SnRr38V7SMsrhb2laYPz36lqPSGPFgrkCSGEEEIeQXIFw8J9yVCXmsltW7gvGXIFJW/qk1zBsPKwslL91Me9YW2uPi1YkKr1hBCDRYE8IYQQQsgj6Gza/Xoj8XUxAJmFFTibdl93nSL1/HHxHm7mlsLOwhSTgurPjefYWigDfBqRJ+TRQIE8IYQQQsgjKKe44SC+NfsR7ZMrGL47pKxU/9ZQL9jUjLqrQ1XrCXm0UCBPCCGEEPIIcraRanU/on37L2XiRm4pbKUmmDzEs9F9BalaTwgxWBTIE0IIIYQ8ggZ5OcDVToqGFpkTQVm9fpCXgy67RWooFAwra0bj3xzqzY+4N8RGWpNaX14FWpSKkLavbSyiR4ixMTMDvv++9ntCiPGi9zNRxwiuC4lYhKgxfpi+Ob7eY1xwHzXGz3DXkzeQc7xq1Sp88803yMrKgr+/P1auXIlBgwap3beqqgqLFy/Gpk2bkJGRge7du+Orr75CaGgov8/ixYuxa9cuXE6+AhlMYOXhhyGv/NhkP7hAv1rBUF4lh6WZFj7mC3WOja1dodsWgrH1FzDO60KPaB15NWgdeUIIIYQ8KmKSMvG/3y6gtFLOb3OyNsen43oa9jryBmD79u2YNGkS1qxZg8DAQCxfvhy///47UlNT4ezsXG//Dz/8EJs3b8a6devg6+uLAwcOYPbs2Th58iT69u0LAAgNDcVLL03AT6ki3Mothv3lnSjNSkNycjKsGln/mjGGLh//BbmC4fS8J9HBjqZEEGJsaB15QrRArmA4dSMfexMzcOpGPi2/QwghpE0K7eWKgZ7tVLYtGONHQXwzLFu2DFOnTkV4eDj8/PywZs0aWFpaYv369Wr3j46OxkcffYSwsDB4e3tj+vTpCAsLw9KlS/l9YmJi0GFgKO6JnNC+Uzfs+30L0tPTERcX12hfRCIRbKVUuZ6QRwWl1hOiRkxSJhbuS1ZZlsfVTooobX2wkcuBf/9Vfv/444BEonmbhBD9oPczUcfIrour2SUAgI7tLHD3QTlu3S/Tc4+aQc/nuLKyEnFxcZg3bx6/TSwWIzg4GKdOnVL7HJlMBqlUdaTcwsICx48f539W1KlUHz7EC6xS+btwcGi6VoGthSkelFVpr3K9UOfY2NoVum0hGFt/AeO8LvSIRuSJRlatWgVPT09IpVIEBgbi7NmzDe5bVVWFRYsWwcfHB1KpFP7+/oiJiVHZZ/HixRg4cCBsbGzg7OyMcePGITU1VejDUBGTlInpm+Prra2bVViB6ZvjEZOUqfmLVFQAI0cqvypoWR9CjBq9n4k6RnRdFJZX4V7N37zQnh0AALfySvXZpebR8znOy8uDXC6Hi4uLynYXFxdkZWWpfU5ISAiWLVuGa9euQaFQ4ODBg9i1axcyM2s/W/ydnIWUrGLYmJsgPKgz3n33XQwZMgS9evVqsk/8EnTaGpEX6hwbW7tCty0EY+svYJzXhR5RIE9abfv27Zg9ezaioqIQHx8Pf39/hISEICcnR+3+kZGRWLt2LVauXInk5GRMmzYN48ePR0JCAr/P0aNHMWPGDJw+fRoHDx5EVVUVRo8ejdJS3XygkCsYFu5Lhrokem7bwn3JlGZPCCGkzbiaXQxAmXnm72EPAEgzhkDeCK1YsQJdu3aFr68vzMzMEBERgfDwcIjFyo/kCgXDikPXAQBThnjiow/eRVJSErZt29as9m0tuMr1tAQdIW0dBfKk1YSaFzZlyhT07NkT/v7+2LhxY7PmhWnL2bT79Ubi62IAMgsrcDbtvk76QwghhAgtNUsZyHfvYAMvR2UxNQrkm+bo6AiJRILs7GyV7dnZ2ejQoYPa5zg5OWHPnj0oLS3F7du3kZKSAmtra3h7ewMA/k7OxpXMIlibmyBl13L88ccfOHLkCDp27NisPml9RJ4QYrAokCetws0LCw4O5rdpY17YwwoLCwE0b16YNuQUNy/dprn7EUIIIYZOXSCfX1qJQm3Ns26jzMzM0L9/fxw6dIjfplAocOjQIQQFBTX6XKlUCnd3d1RXV2Pnzp0YO3YsGFPOjWeMwS7hF/y57/9w+PBheHl5NbtPfCBPvztC2jwK5EmrCDUvrC6FQtGieWHa4GzTvKVamrsfIYQQYui4QN63gw2szE3gbGMOwEjmyevZ7NmzsW7dOmzatAlXrlzB9OnTUVpaivDwcADApEmTVIrhnTlzBrt27cLNmzfx77//IjQ0FAqFAnPmzMHB5GwkZxah+NAaJB3bjy1btsDGxgZZWVnIyspCeXl5k/3hU+srKLWekLaOAnmiM03NC3vYjBkzWjQvTBsGeTnA1U4KUQOPi6CcQzjISzcZAoQQQoiQGGNIySoCAHR3Ua5ZTOn1zTdhwgQsWbIE8+fPR0BAABITExETE8MPdKSnp6sMWFRUVCAyMhJ+fn4YP3483N3dcfz4cdjZ2WFFTaX6B3H7UVRYiBEjRsDV1ZX/2r59e5P9oRF5Qh4dFMiTVhFiXlhdERERLZ4Xpg0SsQhRY/zUPsYF91Fj/CARNxTqEyG1xVUSCCFEn7KKKlBUUQ2JWAQfZ2UA7+2k/PcmBfLNEhERgdu3b0Mmk+HMmTMIDAzkH4uNjcXGjRv5n4cPH47k5GRUVFQgLy8Pv/zyC9zc3HDoSg4u3yuCpZkE+SUyMMbqfU2ZMqXJvtha0Bx5Qh4VtI48aZW688LGjRsHoHZeWERERKPP5eaFVVVVYefOnXjppZf4xxhjmDlzJnbv3o3Y2NgWzQvTltBerlj9Wj/M3JqAKnltdfoO2lxH3tQU+Prr2u9Jk7hVEtasWYPAwEAsX74cISEhSE1NhbOzc739IyMjsXnzZqxbtw6+vr44cOAAxo8fj5MnT6Jv374AaldJGDhwIKqrq/HRRx9h9OjRSE5OhpWVla4PkRgrej8TdYzkukipSav3crSCuYmE/x4wghF5IznHTWGM8aPxrwd1hoOVWavb0nrVeqHOsbG1K3TbQjC2/gLGeV3okYgxRutoPaSoqAh2dnYoLCyEra2tvrtjsLZv347Jkydj7dq1GDRoEJYvX47ffvsNKSkpcHFxwaRJk+Du7o7FixcDUM4Ly8jIQEBAADIyMrBgwQKkpaUhPj4e9vb2AID//Oc/2LJlC/bu3Yvu3bvzr2VnZwcLCwudHVtFlRw958egThyPK4tCYWEm0VkfiKrAwEAMHDgQ33//PQDljSMPDw/MnDkTc+fOrbe/m5sbPv74Y8yYMYPf9vzzz8PCwgKbN29W+xq5ublwdnbG0aNHMWzYMGEOhBBCDMiaozfw5V8peLqPK1ZN7AcA+PtyFt6OjkNvdzvsmzlUzz1s+w6nZOONjedhYSrB8Q9Hor21eavbOnQlG29uOg//jnbYG0G/O0KMTUviUBqRJ602YcIE5ObmYv78+cjKykJAQEC9eWF1579z88Ju3rwJa2trhIWFITo6mg/iAWD16tUAgBEjRqi81oYNG5qVUqYtF+4UQM4AZxtz3C+tRLWCoaC8EhZmuruZQGpxqyTULRjUFlZJIIQQfeML3bnY8Nu41Pq0vFIwxiAS0XQyoTDGsOKf2tF4TYJ4oG5qPRW7I6Sto0CeaCQiIqLBVPrY2FiVn7l5YY0xlASRuPQHAIABnu0Qf7sAWUUVyC2WwdVOS4G8XA7Exyu/79cPkNBIf2MaWyUhJSVF7XO4VRKGDRsGHx8fHDp0CLt27YJcLle7vz5WSSBtBL2fiTpGcl3UXXqO4+FgCbEIKJFVI7dEZrgrtRjJOW5M7NVcXLhbCKmpGFMfr18zqKW0XuxOqHNsbO0K3bYQjK2/gHFeF3pEgTwhasTfVgby/Tq1w5375cgqqkBeiUx7L1BRAQwapPy+pASg+dhat2LFCkydOhW+vr4QiUTw8fFBeHg41q9fr3Z/bpWExkbsCVGL3s9EHSO4LqrlClzPLQEA+HaoTeE0N5GgYztLpN8vQ1puqeEG8kZwjhtTdzT+tcDOcLLRbDQeqLv8XJV2simEOsfG1q7QbQvB2PoLGOd1oUcGUbWeKlETQ8IYQ1xNIN+/czs4WiuLzuQWazGQJy3SVldJIIQQfbqVX4rKagUszSTo2E4148yzpuDdrXwDL3hnxI5dy0PinQKYm4jx9nDNR+OB2hH5KjlDRZVCK20SQgyT3gN5rhJ1VFQU4uPj4e/vj5CQEOTk5KjdPzIyEmvXrsXKlSuRnJyMadOmYfz48UhISOD34SpRnz59GgcPHkRVVRVGjx6N0lL6Y0SadjOvFA/KqmBuIkZPNzv+DjkF8vpTd5UEDrdKQlBQUKPP5VZJqK6uxs6dOzF27Fj+McYYIiIisHv3bhw+fFgvqyQQQoi+cBXru7nYQPzQsqrejrQEnZCUo/FXAQCvPdZZa1kPlmYSfolcWoKOkLZN74H8smXLMHXqVISHh8PPzw9r1qyBpaVlg+mv0dHR+OijjxAWFgZvb29Mnz4dYWFhWLp0Kb9PTEwMpkyZgp49e8Lf3x8bN25Eeno64uLidHVYxIhxo/H+He1hZiKGY03hmbySSn1265E3e/ZsrFu3Dps2bcKVK1cwffp0lJaWIjw8HAAwadIklWJ4Z86cwa5du3Dz5k38+++/CA0NhUKhwJw5c/h9ZsyYgc2bN2PLli2wsbFBVlYWsrKyUF5ervPjI4QQXeML3dWZH8/hl6DLpUBeCMev5yE+XTka/46WRuMBQCQSwVbKLUFHgTwhbZle58gbSiVqmUwGmax2tLWoqKjZx0DanrhbNfPjO7cDABqRNxBteZUEQgjRhxQ1he44RrOWvBGRKxjOpt1HTlEFVsVeBwBMDOyk9RoEthameFBWRSPyhLRxeg3kDaUS9eLFi7Fw4ULNDoa0GXzF+ocDeW0WuyOt0lZXSSCEEH3gK9a7NBzI375fBrmC8enapHVikjKxcF8yMgsrVLarO/eaqq1cT0vQEdKW6T21vqVWrFiBrl27wtfXF2ZmZoiIiEB4eLjKSFxdXCXqbdu2NdjmvHnzUFhYyH/duXNHqO4TA1dQVonrOcoKvtyIPJ9aTyPyhBBC2ohSWTXS75cBUD8i72ZvATOJGJXVCtwroOlGmohJysT0zfH1gngAmLfrEmKSMrX6enUr1xNC2i69jshrUom6oqIC+fn5cHNzw9y5cxutRH3s2LFGK1Gbm5vD3FzzJT+I8UtILwCgLPLjYKWsVi9Iar2pKRAVVfs90atVq1bhm2++QVZWFvz9/bFy5UoM4pYpeUhVVRUWL16MTZs2ISMjA927d8dXX32F0NBQfp9jx47hm2++QVxcHDIzM7F7926MGzdOR0dDdI7ez0QdA78urmYrR+Mdrc3R3rr+ZyCJWITO7S1xLacEaXml8HCw1HUXm2bg5xhQptMv3JeMxvK/Fu5Lxii/DlrLetDqWvJCnWNja1fotoVgbP0FjPO60CO9BvJ1K1FzH3K5StQNpc9yuErUVVVV2LlzJ1566SX+McYYZs6cid27dyM2NpYqURsIfm5YcQWcbaQY5OVgcKl652/fB6Bcdo7DBfLFsmpUVMkhNZVo/kJmZsCCBZq3QzTGrZyxZs0aBAYGYvny5QgJCUFqaiqcnZ3r7R8ZGYnNmzdj3bp18PX1xYEDBzB+/HicPHkSffv2BQCUlpbC398fb7zxBp577jldHxLRNXo/E3UM/LrgAnl1he44Xo5WfCA/rJuTrrrWfAZ+jgHgbNp9tSPxHAYgs7ACZ9PuI8invVZekw/kK7SQWi/UOTa2doVuWwjG1l/AOK8LPdJrIA8oK1FPnjwZAwYMwKBBg7B8+fJ6lajd3d2xePFiAMpK1BkZGQgICEBGRgYWLFigthL1li1bsHfvXr4SNQDY2dnBwsKifieI4NTNDXO1kyJqjB9Ce7nqsWeq6q4fz7ExN4GZiTK9MLdYZpijEqTV6q6cAQBr1qzB/v37sX79esydO7fe/tHR0fj4448RFhYGAJg+fTr++ecfLF26FJs3bwYAPPXUU3jqqad0dxCEENJCjRW641DBO83lFDccxLdmv+bgU+upaj0hbZre58hPmDABS5Yswfz58xEQEIDExMR6lagzM2vnDnGVqP38/DB+/Hi4u7vj+PHj9SpRFxYWYsSIEXB1deW/tm/fruvDI2h4blhWYQWmb47X+tyw1qqSK3DhjnKFg7qBvEgkgpO1lgveKRTA5cvKL4VCO22SFuNWzggODua3CbFyBmnj6P1M1DHw6yK1LQTyBn6OATS7Ir02K9fXjshrIZAX6hwbW7tCty0EY+svYJzXhR7pfUQeoErUbVljc8MYABG0Pzesta5kFqG8Sg5bqQl8nKxVHnO0MUdGQbn2Ct6VlwPcKgolJYCVlXbaJS2ii5UzyCOA3s9EHQO/LhpbQ55j8IG8gZ9jABjk5QBXOymyCivUfhYSAehgp5xuqC22FlqsWi/UOTa2doVuWwjG1l/AOK8LPdL7iDxp21oyN0zf6qbVix+6qaD1EXlitFq6cgYhhBia3GIZ8ksrIRIBXZ0bCeSdlB927z4oQ2V12xnF0iWJWISoMX5qH+M+aUSN8dPqYAZVrSfk0UCfPImg9DE3rLXUzY/ncAXv8oorddonIixNVs4oLS3F7du3kZKSAmtra7UrZxBCiCHiRuM7O1jCwqzhAq5O1uawMpNAwcAvVUdaLrSXK1a/1g8mDwXrHeykWP1aP63XCtJq1XpCiMGiQJ4ISh9zw1qLC+T7qQvkrZVL0eWW6P+GA2keuYLh1I187E3MwKkb+ZAr6ic11l05g8OtnBEUFNRo+9zKGdXV1di5cyfGjh2r9WMghBAhpGQVAWh8fjygrBHDjcobbHq9kXi8qxP/d2jhs37YOvUxHP/wCUEK/vKp9dqoWk8IMVgGMUeetF36mBvWGvcKypFZWAGJWIQAD/t6jwuyljwRTEtWSRBi5YySkhJcv36d/zktLQ2JiYlwcHBAp06dhDx0QghpUm2hO9sm9/VytEZSRhHS8koAuDS5P1Ev8U4BGAB3ewtMHizsssg0Ik/Io4ECeSIobm7Y9M3xDe6j7blhrcGNxvu52sLSrP7bgk+tL6HUekPHrZLw8I0jbpWEh9MYJ0yYgNzcXMyfPx9ZWVkICAiot3JG3fnv3MoZN2/ehLW1NcLCwhAdHa2ycsb58+cxcuRI/ufZs2cDACZPnoyNGzdq/ZgJIaQlUpuxhjzH4AveGYnGpu9pW9058owxiET6/YxFCBEGBfJEcKG9XPHl873x4c5LKtvtLUzx5fO9DWId+ab+wDpa04i8MWjtKgnaXjljxIgRtHoGIcQgKRQMV7ObXnqO4+VoCYACeU3pNJCvGZGvkjNUVCkarYNACDFeFMgTneBGtN3tpejlZocDydkY7NPeIIJ4oOk/sFpPrTc1Bd5/v/Z7ohUtWSUhyKe97jpG2jZ6PxN1DPS6SL9fhooqBcxNxPBs3/QSTF6OyuVYDTKQN9Bz/DCFgiE+XXeBvKWZBBKxCHIFQ1FFlWaBvFDn2NjaFbptIRhbfwHjvC70iAJ5ohOX7ioL6wR6tcfrQZ1xIDkb/17LQ5VcAVOJfmsullVWIzlT2b+mRuTLq+QolVXDylzDt46ZGfDNN5q1QeoxplUSSBtC72eijoFeFyk18+O7ulg3a1qbV02wn10k087fP20y0HP8sOu5JSiuqIaFqaRZ0xk0JRKJYCs1wYOyKhSVV8HFVoOCwkKdY2NrV+i2hWBs/QWM87rQI6paT3TiUkYBAKB3Rzv06WgPByszFMuq+ZFwfUq8UwC5gsHVTgo3ewu1+1iZm8Cy5o42pdcbruauflAqo0q+hJBHE1/ozqXpQncAYGdpCgcr5cotBjkqbwTO31J+1gnwsIeJjgYvaivXU8E7QtoqCuSJTly8WwgA6NPRDhKxCCO6OQEAjqTk6LNbAID4Zs5b49PrS7QQyCsUwK1byi+FQvP2CIDaVRKaGmP6aHcSpm+Ow7WaeaKEaITez0QdA70uUrOVGWgtGRnmCt7dyjewQN5Az/HDdDk/nlNbuV7DG9dCnWNja1fotoVgbP0FjPO60CMK5IngsosqkFMsg1gE+LnaAQBG+DoDAI6k6j+Qb+4fWC69Pk8bI/Ll5YCXl/KrvFzz9giA2lUSGlrqEAAGeraDSAT8lZSF0cuP4b3tibhtaB9OiXGh9zNRx0CvCy61vlsrAvm0XAP7v9JAz/HD+PnxnjoM5OtUrteIUOfY2NoVum0hGFt/AeO8LvSIAnkiuEs1o/FdnW34givDuzpBIhbhanYJ7j4o01vfFArW7EDeyVqLI/JEMKG9XPmMj7o62Emx5rV++H3aYMTMGobQnh3AGLA7IQNPLD2Kebsu4l5B2/nPnRBCHlZRJcetmvT41ozIU2p9y+WXyPjz1s9DHyPylFpPSFtlQBVLSFt1MUMZyPdyt+O32Vmaon+ndjh76z6OpOTg9SBPvfTtRm4JimoK0PRwbXy+IL+WPM2RN3gZNQH5e8Fd4eloBWcbKQZ5OfCFnbp3sMGa1/vj0t1CLPk7FUev5mLr2TvYGZeBVx/rhP+M6ML/vgkhpK24nlMCBQPsLU3h3IL/47hA/iYF8i0Wn14AAOjqbA07S91Vy+YD+QqqCUNIW0Uj8kRwSRm18+PrGuFbM08+NVfnfeJwo/H+HnZNVs93pBF5o5BTXIFrOSUQiYBJQZ4YG+COIJ/2aqsz9+5oh01vDMLv04IQ6OWASrkCG07cwrCvj+CrmBQUlFXWe45cwXDqRj72Jmbg1I18yBW0XjwhxDjUFrqzgUjUdMV6jsHOkTcC52/fB6Db+fFAndR6GpEnpM2iEXkiKMYYX+iu90OB/BO+zvg6JhUnb+ShokoOqakG65y2UksK0Gh9LXkiiNM3lR+aenSwRbuaSstNGejpgG1vP4YT1/Pxzd+puHCnAKtjb2Dzqdt463FvvDHUEzZSU8QkZWLhvmSVtepd7aSIGuOH0F6ughwPIYRoS2pNgc+WLoHGrTdfUFaFB6WVzf6/ldQW1O2n60BeSlXrCWnraESeCCqrqAJ5JTJIxCL4PZS63t3FBq52UlRUKXDqZr5e+teqQL6k/iitkFatWgVPT09IpVIEBgbi7NmzDe5bVVWFRYsWwcfHB1KpFP7+/oiJiVHZ59ixYxgzZgzc3NwgEomwZ88egY9At07dyAMADPZp36LniUQiDO3qiD3/GYx1kwbAt4MNimXV+Pafqxj29RHM3p6I6ZvjVYJ4AMgqrMD0zfGIScrU2jEQQogQuEJ33Ts0b+k5joWZBG52yuU9Kb2++SqrFbhQM5gxQOcj8lqqWk8IMVgUyBNB1Ra6s6434i4SiTCSq16vh2Xo7pdW8h9I+nVq+g+so7VyBEKXc+S3b9+O2bNnIyoqCvHx8fD390dISAhyctSfr8jISKxduxYrV65EcnIypk2bhvHjxyMhIYHfp7S0FP7+/li1apWuDkOnTt5Q3hQa3KVlgTxHJBJhlJ8L/vzv41j5Sl94O1nhQVkVdiVkqK2Gz21buC+Z0uwJIQYtNUu59Fz3Fo7IA4AnFbxrscv3ClFZrUA7S1N+eoKuaK1qPSHEYFEgTwR1qYH58ZyR3ZWB/OGUHDCm2yCIS3fr4mwNe8um0wTrptZr3FcTE+A//1F+mTQ8w2XZsmWYOnUqwsPD4efnhzVr1sDS0hLr169Xu390dDQ++ugjhIWFwdvbG9OnT0dYWBiWLl3K7/PUU0/hs88+w/jx4zU7BgOUUVCO2/llkIhFGOjpoFFbYrEIY/zd8Pe7wzBtmHej+zIAmYUVOJt2X6PXJEaqme9nojvazmRqaZsADO66KCirRHaR8kZ0awJ5fp68IQXyBnaOH1Y3668lNQm0QWtV64U6x8bWrtBtC8HY+gsY53WhR23nSIhB4ufHu6sP5Id0aQ8ziRh3H5TjRm4Juji3/MNFa53n/sA2YzQeqC12VylXoKiiGnYWGlSfNTcHmhgRr6ysRFxcHObNm8dvE4vFCA4OxqlTp9Q+RyaTQSqVqmyzsLDA8ePHW99XI3KqZjS+t7sdbKTaqQ5sIhGjh1vz0lBziiua3om0Pc14PxPd4TKZ1qxZg8DAQCxfvhwhISFITU2Fs7Nzvf0jIyOxefNmrFu3Dr6+vjhw4ADGjx+PkydPom/fvq1qE4DBXRdcWn3HdhawNm/5xz+DXILOwM7xw+L0ND8eqJNar2nVeqHOsbG1K3TbQjC2/gLGeV3oEY3IE8EwxviK9b072qvdx9LMBIHeypHTIym6rV7Pjcj392zeH1ipqQQ2UuWHH10UvMvLy4NcLoeLi4vKdhcXF2RlZal9TkhICJYtW4Zr165BoVDg4MGD2LVrFzIzH43521wg39L58U1xtpE2vVML9iOECEeITKaWtmmI6lasbw1vJ1qCriUYYy0eMNAmWkeekLaPAnkimHuFFcgvrYSJWNRohdwnfGvT63VFWYCmAEDLloTh15LXdAk6xoDcXOWXFqcUrFixAl27doWvry/MzMwQERGB8PBwiMVt/63OGOML3QVpOZAf5OUAVzspGkqMFEFZvX6Ql2bp/MRICfR+Ji3HZTIFBwfz2zTNZGpNmwAM7rqoLXTXukCeq1x/K69U51PhGmRg57iuuw/KkVssg4lYBH8Pe52/ft058hr9voQ6x8bWrtBtC8HY+gsY53WhR23/0z3Rm0s1gXI3F5tGl5bj5smfu3VfZ0VZLt8rhKymAI13CwrQ8GvJazoiX1YGODsrv8rK1L+WoyMkEgmys7NVtmdnZ6NDhw5qn+Pk5IQ9e/agtLQUt2/fRkpKCqytreHt3fgc77bgdn4Z7hVWwFQiwoDO2g2oJWIRosb4AUCDwXzUGD+1a9WTR0Az3s9EN4TIZGpNmwAM7rrQpNAdAHg4WEIiFqG8Ss7Ptdc7AzvHdcWnK0fje7rb6WV5XW5EvkrOUFGlaH1DQp1jY2tX6LaFYGz9BYzzutAjCuSJYJoqdMfxdLSCt6MVqhUMJ67l6aJrrS5Ao8u15M3MzNC/f38cOnSI36ZQKHDo0CEEBQU1+lypVAp3d3dUV1dj586dGDt2rNDd1TtuCcO+Hu1gYab9D02hvVyx+rV+6GCnOnJnZS7B6tf60TryhBipRyGTiTGGq9klAADfFi49xzGViNHJwRIAcDOvRGt9a6vi9JhWDwCWZhL+5jJVriekbWo7f6WIweEL3TURyAPgl6HTVXo9d6e8pQVonKy1lFrfTLNnz8a6deuwadMmXLlyBdOnT0dpaSnCw8MBAJMmTVIphnfmzBns2rULN2/exL///ovQ0FAoFArMmTOH36ekpASJiYlITEwEAKSlpSExMRHp6ek6OSahcMvOaTutvq7QXq44/uET2Dr1Mbw51AsAYGEqQXAPlyaeqX0GUZWbEAMjRCZTa9o0NBkF5SiRVcNUIuLnureGQRa8M1Dnb9UOGOiDSCSCbU1dH5onT0jbRIE8EQRjjB+Rb6hifV1cen3s1VwoBF6LmzFW+we2hXfKdTkiDwATJkzAkiVLMH/+fAQEBCAxMRExMTF8imd6erpKIbuKigpERkbCz88P48ePh7u7O44fPw57e3t+n/Pnz6Nv3758NebZs2ejb9++mD9/vk6OSQjK+fHCFLp7mEQsQpBPe3wY6gsHKzPklVTi2DXdFmrkKmhHRUUhPj4e/v7+CAkJQU6O+hthkZGRWLt2LVauXInk5GRMmzYN48ePR0JCQqvbJMQQCZHJpEmbhoIrdOfjZA1TSes/+nHz5NNyKZBvTImsGik1Uxn0FcgDdSvXUyBPSFtEgTwRxN0H5Sgoq4KpRNSs+XgDvdrBykyC3GIZLt8rErxvOa0sQMONyOfqaEQeACIiInD79m3IZDKcOXMGgYGB/GOxsbHYuHEj//Pw4cORnJyMiooK5OXl4ZdffoGbm5tKeyNGjABjrN5X3XaMzfWcEuSVyGBuIkZAJ3udvKaZiRjjAtwBADvi7urkNTlUlZuQhgmRydRUm4ZO00J3HK+a0fxb+RTIN+bCnQIoGOBub1FvOpYu1Vau13AJOkKIQaJAngiCG4337WALc5Om5yubm0gwpIsjAOBIqrAjgJoUoHG0MQOgu9R60jxcWv1AT4dmXW/a8kL/jgCAf5Jz8KC0UievaVBVuQkxQEJkMjXVpqFL1VIgzxWHpSXoGle3Do8+1a1cT0hTaMqe8aFAngiCmx/fqxlp9RxdLUPX2rR6AHCyVgZDukqtJ81zSgfz49Xxc7NFTzdbVMoV+L8L93TymgZVlZsQA6XtTKam2jR0XCDf2FKwzcHNkU/PL0O1XINK6G2cwQTytJY8aSaasmecTPTdAdI2JTWzYn1dXMG7C3cLkF8iQ/uaNHZt0+QPLDdHPr+kEgoFg7i1y42ZmACTJ9d+T1pNoWB8xXpdB/KAclT+8r1k/B53B5MHe+r89ZtjxYoVmDp1Knx9fSESieDj44Pw8HBKm9cWej8TdQzkuqisVuBGrrLKfDcXzQL5DrZSmJuIIatW4O6Dcni2YPlWQRjIOa5LoWB85p/BBPIVGqTWC3WOja1dodsWQgv6W3d6HQCsWbMG+/fvx/r16zF37tx6+0dHR+Pjjz9GWFgYAGD69On4559/sHTpUmzevLlVbba0zy1ibL+7Zmo7R0IMBmMMF2vWkG9OoTuOi60Ufq62SM4swtGruXiuX0et961uAZoBni3/A9veWplaX61gKCivgoOVWes6Ym4OGPGcdEOSnFmEwvIqWJuboE8LrjdtGRvgji/+vIKkjCJcySxCD9fWLe3UXJpU5a6oqEB+fj7c3Nwwd+7cNlWVW6/o/UzUMZDr4mZeCaoVDDbmJnC3t9CoLbFYBC9HK6RkFSMtv1T/gbyBnOO6ruWUoLiiGpZmEo0zIDTFp9ZrMiIv1Dk2tnaFblsIzewvN72ubu0QbU3Za0mbLelzixnb766ZKLWeaF36/TIUVVTDTCJu8d1/odPrE9NrC9C42La8AI2pRIx2lso73JRebxhO3+Tmx7eDiQbVmFvLwcoMT/oqU9J1UfSOqnITQlqCS6vv1sEGIlErs8jq4Jego8r1anFZfwEe9nr5m1RX7Yg8pdaThtGUPeNFgTzROq7QXQ9XG5iZtOwSG+nrBAA4djVXkPl32pi3xqXXa1TwjjGgtFT5xYRdbq+tO8kvO+eotz68OECZPbInIQNVOpg3SlW5DQy9n4k6BnJdaKvQHceg1pI3kHNcl6HMjwfqLD+nSdV6oc6xsbUrdNtCELC/K1asQNeuXeHr6wszMzNEREQgPDwcYrGGoaUxXhd6RKn1ROsu1RS6692C+fGcAI92sLc0RUFZFeLTCzDIy0GrfYurmbfWmrR6jqO1Oa5ml2g2Il9WBlhbK78vKQGs9JyeaKSq5QqcTbsPQD/z4znDuznB0doceSUyHEnJweiewqajT5gwAbm5uZg/fz6ysrIQEBBQryp33T+mXFXumzdvwtraGmFhYYiOjq5XlbuxNkkj6P1M1DGQ60Jbhe44noYUyBvIOa6Lmx/fzyACeS1UrRfqHBtbu0K3LYRm9tegpuwZ43WhRzQiT7SOq1jfkvnxHIlYhOHdlKPy2l6GTqFgSKi5U96vFRXrOdyIvCGm1ssVDKdu5GNvYgZO3ciHXNF27jqqcymjECWyathZmAo+N70xJhIxnuun2zXlqSo3IaQ5+DXkNSx0x/E2pEDewOSVyPjz0s/DAAJ5qlpPmoGm7BkvGpEnWqVQMCTd4wJ5+1a18YSvM/Ym3sORlBx8GOqrtb5dzSlGsUzzAjRO1lpIrRdATFImFu5LRmZhBb/N1U6KqDF+CO3lqseeCYdLq3/M2wGS1q4goCUv9O+IH4/dxOGUHOSVyOAo0KoLhBDSXMUVVcgoKAcA+HbQzs1OLrX+XmE5KqrkkJpKtNJuWxBfM1jQ1dkadjX1dPSJT63XpGo9eSTMnj0bkydPxoABAzBo0CAsX7683pQ9d3d3LF68GIByyl5GRgYCAgKQkZGBBQsWqJ2y11ibRHMUyBOtun2/DMUV1TA3EaOri3Wr2hjW1QlikXIU4V5BOdw0rLLL4eat9e2kWQEaRwMckY9JysT0zfF4ePw9q7AC0zfHY/Vr/dpkMM8Vugvy1l9aPaebiw38O9rhwt1C7E28hzeHeum7S4SQR9zVbOVofAdbqdYCSwcrM9hKTVBUUY3b+WVam3vfFsQZyLJzHBqRJ81FU/aME6XWE63ilp3r4WoL01YGy+2szNC3JvVdm+n1fAEaDdLqgdoR+VwDGZGXKxgW7kuuF8QD4Lct3Jfc5tLsZdVynLulnB8/uIv+Ct3V9UJ/ZdG738/fATPSYiqrVq2Cp6cnpFIpAgMDcfbs2Qb3raqqwqJFi+Dj4wOpVAp/f3/ExMRo1CYhutaWpySlaLnQHQCIRKI6Be9KtNZuWxBvQIXuANU58sb6N4noDk3ZMz4UyBOtSqqpWN+nFYXu6uKWoTuixWXouEBe0wI0hjYifzbtvko6/cMYgMzCCr4oXFuRmF6AiioFHK3N0NW5ddkf2vasvzvMJGKkZBXj8r0ifXenxbZv347Zs2cjKioK8fHx8Pf3R0hICHJy1L8PIyMjsXbtWqxcuRLJycmYNm0axo8fj4SEhFa3SYguxSRlYuhXh/HKutOYtS0Rr6w7jaFfHUZMUqa+u6YV2q5Yz6kN5Mu02q4xq6xW4EJNjSCDCeRrRuSr5AwVVcKvqEII0S0K5IlWaVLorq4R3ZUF705cz0dFlVzjfuUWy3A7vwwiEfjR/tYytDnyOcUNB/Gt2c9YnLrJzY9vr5W1kbXBztIUo3rqbk15bVu2bBmmTp2K8PBw+Pn5Yc2aNbC0tMT69evV7h8dHY2PPvoIYWFh8Pb2xvTp0xEWFoalS5e2uk1CdIWbkvTwjVBuSlJbCOa1XeiO4+WovHlKI/K1ku4VorJagXaWpvyNDn2zNJPw9WNoLXlC2h4K5InWKBSMH4VszdJzdfm52sLF1hzlVXKc0cJIMrccTDdnG9hZaDZPkKtaf7+0svUpmBIJ8MILyi+JZoWCnG2kWt3PWBjC+vHqvFiTXr8nMQOyas1vQulKZWUl4uLiEBwczG8Ti8UIDg7GqVOn1D5HJpNBKlW9riwsLHD8+PFWt2mUtPh+NlRtbcqFTqYk6fm6YIzxc+S1PiLvZCCV6w3ovVc3rd5Qbi6LRCLYSmvS61s7T16oc2xs7QrdthCMrb+AcV4XekSBPNGatPxSlMiqITUVo4uTZqnOIpEII7trL71eW2n1gLLQj1gEKBiQX9rKUXmpFPj9d+WXVLMAe5CXA1ztpGjsY4OrnRSDvBw0eh1DUl4pR2J6AQD9rh+vzuNdneBia46CsiocvmI86eN5eXmQy+X1itC4uLggKytL7XNCQkKwbNkyXLt2DQqFAgcPHsSuXbuQmZlZr826QdvBgwdx/fr1BvtiDIGgCi2+nw1RW5xyoZMpSXq+LnKKZSgoq4JELEIXLU8/8mpvIIG8Ab33tPk5Q5tqK9e3MpAX6hwbW7tCty0EY+svYJzXhR5RIE+05lJNWn1PNzuNqsJzRnLz5FNzNC7Swv2BHaCFP7ASsQgOVoYzT14iFiFqjF+j+3zytJ/el2fTprjbD1ApV8DVTgrP9pb67o4KiViE5/rVFL0zwvT6llixYgW6du0KX19fmJmZISIiAuHh4SqVbQHgn3/+UQnanJyckJqaatSB4KOkLU65eBSmJHFp9Z7tLbW+RJyno/L/3bySSkrZhjL74Tz/OcOwbprb8CPytAQdIW0NBfJEa7Q1P54ztIsjTCUi3M4v0+iuv6xazt9k0FYBGi69Pq+kUivtaSq0lytWv9YPUhP1b+k7D9pWQaKTN/IAKEfjDSWFsS6uev3Rq7nIKdJvINDcityOjo6QSCTIzs5W2Z6dnY0OHTqofY6TkxP27NmD0tJS3L59GykpKbC2toa3t7dKm9HR0SpBm7+/P0xNTY06EHxUtNUpF4/ClKTULOVUN22tH1+XjdSU/zt4S9+j8gbg7oNy5BbLYCIWaVzsV9v4JejohgshbQ4F8kRruIr12grkrcxNEOilTJs+rEF6fVJGISrlCrS3MkNnLY3eOlqbAdBgRL60FBCJlF+l2vkQFNrLFV1dlOmTbw71wtapj+Hz8b0AAN8cSOXrBLQFpwxo/Xh1fJys0a+TPeQKht0JGXrrR0sqcpuZmaF///44dOgQv02hUODQoUMICgpq9HWkUinc3d1RXV2NnTt3YuzYsXybffv2xfXr1/mgTaFQ4PDhw+jRo4dRB4IqBHg/Gwqhp1w0t01tG+TlAGtzkwYfF0ELU5L0fF0IsfRcXQaRXm8g7z0u66+nu53Wsx80pfFa8kKdY2NrV+i2hWBs/QWM87rQIwrkiVbIFQxJ97Sz9FxdXHp9bGpuq9uoO29NW6O3Tga2BB3nXoFy9Pe5fu4I8mmPiYM64Zk+rqhWMMzckoDCMuO/I19cUcVnfxja/Pi6XujvAUBZvV4f6/e2piL37NmzsW7dOmzatAlXrlzB9OnTUVpaivDwcADApEmTMG/ePH7/M2fOYNeuXbh58yb+/fdfhIaGQqFQYM6cOfw+b7zxBhhjiIuLU2kzKCjIqANB0rDmTrnQp5SsIpRVqk815v5KRI0x7ilJQi09x+Eqs9/MbTsfiluL+5zRX8NVcYRQu5Y8pdYT7Whuph8RnuH8VSVG7WZuCcoq5bA0k8Bbw0J3dY2sWYbuTFo+SmSt+yOkzfnxHENbgg5QFoDLL1Wm+ne0V2YeiEQiLH6uNzq3t0RGQTk+3HlRJag0xkrU527dh1zB0MnBEh3bGdb8+Lqe8XeF1FSMazkl/NrCutLaitwTJkzAkiVLMH/+fAQEBCAxMRExMTF8wJyens4H0wBQUVGByMhI+Pn5Yfz48XB3d8fx48dhb2/P78ONzq9bt06lTSurhpdnMoZA8FEh5JSLlrSpTZXVCvzvtwtQMKCvhz062Klmf3Swk2L1a/0Q2stV8L4IpVquwLUc5dJwvkIF8jWV62/lUyAfV6divaHReESekDpakulHhEefiohWXMrgCt3ZanUEw9vJGp7tLVElZzh+La/Fz2eMCfIH1hBH5DMKlPPgrc1N+DvwgHIu48pX+sJUIkLM5SxEn74NwHgrUZ/il50z3NF4QPnhKbSnMijZEXdHp6+tSUXuiIgI3L59GzKZDGfOnEFgYCD/WGxsLDZu3Mj/PHz4cCQnJ6OiogJ5eXn45Zdf4ObmptIeF7StWbNGpU1jDgQfJUJNuWhtm9rw/ZHrSMkqhoOVGdZNHoATHz6Bsf7K6za4hzOOf/iEUQfxAHArvwyV1QpYmErgIdANT25EXu+V6/WsRFaNlJp6BAM8DTCQ17RqPSE1WpPpR4RFgTzRitpCd/Zab3tEdy69vuXBYPr9MuSVVMJMIkYvLc3dB+oWuzOcQP7ug3IAgLu9Rb0pBH062mPeUz0AAJ/9cQWX7xUabSVqbv14Q06r53Dp9f+XeA8VVbpbU96QKnK3xUDwUSPElIum2hRKUkYhfjiiXPpw0diecLQ2h0QswuPdlNlfZZVyo06n53Bp9d1crCEW6Hj4QD63VC/ThwzFhTsFUDDl314XW8MrjmhLVeuJFrQ2048IiwJ5ohXciHzvjtqvjvuEBsvQcaPxvdxttVqAxtHaEEfkawL5dhZqHw8f4ongHi6olCsw45ezRlmJuqCsEsmZypEPQy10V9dgn/Zws5OiqKIaB5Ozm36CljS30vbexHu4Xyr8ygttKRB8FAkx5aKpNoVQWa3A+79fQLWCIax3BzzTpzZ7xNupbc33Ts0Wdn48AHRysIRIBBTLqg1mBRd9OH/LcNPqARqRJ9qhSaYfEQ4F8kRj1XIFku8pgyshRuQDvR1gYSpBdpGMD+Ka67xA89b41HoDGpHPqBmR79hAIC8SifDNC33gaifF9TuZkMvlcHZ2VtnH0CtRn755H4wBXZyt4WyAIx8PE4tFeL6/7teUH+TlAOeaa7Qxh1Ny8MTSWGw+fVvQu+htJRA0dC2tT7F8+XJ0794dFhYW8PDwwHvvvYeKitoPasXFxXj33XfRuXNnfPDBB/zvQRtTLoDGp3EI4fvD1/iU+kVje6k85uOorO2SVVSB0lbWYzEk3NJz3QVYeo4jNZXA3V759+ZRnicfl27ggTzNkSdaYEiZfqQWBfJEYzdyS1FeJYeVmQTejg0XsGotcxMJhnRxBAAcaeEydPFCBfI1I/IFZVWorFa0vAGJBAgLU35JtJMpwI/I26sP5AGgnZUZvnulL5862pLzaQgFyE5x68cbwWg8h1tT/vi1XGQ1cjdbm8QioEMDNzpENV//G9UNvh1sUFBWhcg9SRi76jifwSIEbc+9b6pNnRLg/dxSLa1PsWXLFsydOxdRUVG4cuUKfv75Z2zfvh0fffQRv89bb72FgwcPIjo6GpcuXcLo0aMRHByMjAztLako5M0HCwsLDB48GOfOnUNSRiFWxd4AAHw6thefVcWxszRFeyvlsqJam/Otx+uCS60XqtAdp256vV7o+b2nUDAkGHChO6DuiHwrb1AJdY6NrV2h2xaCFvvb3Ey/5u7XIGO8LvSIAnmisYt3CwAo108Vai5ebXp985ehK6qo4tML+2n5D6ydhSlMao41v7QVo/JSKbB/v/JLqp2RZX6OfAMj8pyBng6YPaY/IBJjdUw8rucU848ZegEybv14Qy90V1fn9lYY5OkABQN2xutmVH7zmXRczCiEiVgER2szlce4itwzn+yKP2YOxcJne8JGaoKkjCI8v/ok3v/9gkHVfjAKAryfW6ql9SlOnjyJIUOGYOLEifD09MTo0aPxyiuv8IF0eXk5du7cia+//hrDhg1Dly5dsGDBAnTp0gWrV6/WSp91efMhYt0/kCsYnu7tiqf7qC9kxwWlN3JLtHJ8+rouyiqrcfu+svipkKn1QJ0l6PRV8E7P771rOSUollXD0kwi+E2T1uKXn2vtiLxQ59jY2hW6bSFosb+DvBzgaidFQ5/yRQBc7aQY5OWg0esY5XWhRwYRyBvjElikVlLN/Pg+Wiwm97ARNcvQJaQ/wINmzulNTC8AY8p5fBrfIXyIWCwyuHnyGQ+aHpHnzAzugfaevii6kYAZvyagokpu8AXIcotluJqt/ID9mBGNyAPACwOUo/I7dbCm/NXsYnz2RzIAYF5YD5z5KBhbpz6GFS8HYOvUx1QqcptIxJg82BNH3h+Bl2r6uCPuLkYuicWGE2molrci24ToXGvqUwwePBhxcXH838abN2/izz//RFhYGACguroacrm80boYmtLVzQcb545I+Pt3OFiZYeHYng32h5snb+xV2K9ll4AxwNHarF7mgbbVVq7X0s0PI8NlMQV42MNEYhAfqevhUuuLK6of6aKERDMSsQhRY/wAoF4wz/0cNcavTRQLNSZ6/1/HWJfAIrUu8oXuhAvk3ewt4NvBBgoGHLvWvFF5oebHcxxtlCOdhjB6WVmtQHbNvKSmRuQB5Y2IxfPnoeTiAcT9swczV/9h8AXITteMxvdwtUU7K7Mm9jYsYb1dYWEqwc28UsSnC5e+XlElx3+3JkBWrcDwbk4IH+wJiViEIJ/2GBvgjiCf9mr/yDpam+PrF/yx6z+D0cvdFsUV1Vi4LxnPrDyOMzXnnRiu1tSnmDhxIhYtWoShQ4fC1NQUPj4+GDFiBD+6bWNjg6CgIHz66ae4d+8e5HI5Nm/ejFOnTqnUM2gtXd18uHS3EHkVgOzuZbUp9XV5OynnyRt7wTsurV7o0XigNpC/lVcm+GsZovO3lYW9DDWtHqhNra+UKyBrzVRAQmqE9nLF6tf6oYOd6g3edlZmWP1aP6NfttMY6T2QN9YlsIiSaqE77QbyD2dVdBEpP5AebmBe98NzJ9d9HQVWXcn/gW1o7mRrOWkyIl9aClhZKb9KNf/QmFVYAcYAcxMx36+mTJ3yGmbNW4SC45vx0+wXEHvynEEXIDtpJOvHP2zVqlXo1b0Lrn01Fpm/zMZ32/5qdP/WzgEGgC//SkFKVjEcrc2w5EX/Fk916depHfbOGIrPx/eCvaUpUrKKMeHH03h3WwKyi6iATYO0/H7WhdjYWHzxxRf44YcfEB8fj127dmH//v349NNP+X2io6PBGIO7uzvMzc3x3Xff4ZVXXtFKXQxd3Hwok1Vi4offQJaRAouq4gZT6jnefJq4lkaX9XRdpHCBvItwhe443jVFAtPyS6HQx7JTen7vcXV4tD19T5uszCTg/hS0Kr1eqHNsbO0K3bYQBOhvaC9XHPrfcJVtbw710l4Qb4zXhR6Z6PPFuTvydUf9tLUEVkvblMlqg7GiopZVRn+UXcspgaxaARtzE3i2116hOy6rYs2aNQgMDMTy5cvxy/y3YTdpFY5eNYVcwVRGFrm5k+vXr8fgwYNxJSUVz744ERYF5ej/vycBKOdOJiUlITo6Gm5ubti8eTOCg4ORnJwMd3f3Fvexdi35Vi67U6a9EYy7D5RtqVtDvjHfLpoL9yHj8f2R6zA1N0GHLrWVnGNjY1X25QqQNSUiIgIRERHN7kNzcYXujCmQr3sdm7t2xztzF2HzgmlY9OoT6Nyx/h+9h6/jq1evYsqUKRCJRFi2bBmAhq/jH//vKDaeVBYhW/KiP399tpRELMKrgZ0R1ssV3/ydiq1n07En8R4OJmdjVnBXhA/xgmlNCqlcwXA27T5yiivgbKOcG/fIptVp8f3cUq2pT/HJJ5/g9ddfx1tvvQUA6N27N0pLS/H222/j448/hlgsho+PD44ePYrS0lIUFRXB1dUVEyZM4Oti6Frdmw+BgYG4fv06Zs2ahU8//RSffPIJAOXNhzfeeAPu7u4QiyUwcfFGu94j4FjRdIE+bkSeWxe9Jf+XNkgP10VqNlex3lrw13Kzl8JUIkJltQL3CsvRsZ2l4K9Zj57ee3klMtzKV752Pw/DDeRFIhFsLUxRUFaFooqq1q34ItQ5NrZ2hW5bCAL0t+ShlT1auqJUk4zxutATvY7It+aOvBBLYC1evBh2dnb8l4eHhxaO7tFw6a4yrb6nu61WC92py6qwsbZC9ZXDKCirQuId1fTkh+dOdurzGCx6DIM8+xq6udgIUrjJkObI321iDfnGvBvcFQM926FEVo2ZWxNaV4VfYPcKynErvwxiETBQ00IqOlT3On55dBD8X34fIhMzRH79ndr9WzsH2NPLB7Pmfw0AeGOIF0Z0d1bbfku0szLDF+N74/9mDEWAhz1KK+X44s8UPLXiX5y4noeYpEwM/eowXll3GrO2JeKVdacx9KvDiEnSPO2atExr6lOUlZXVG1mX1FTyfXgerZWVFVxdXfHgwQMcOHCAr4uhCU1vPvTu3Rvjx4/HF198gcWLF0OhUP6/xd18OJV6Fx1nbITrpG/Ry9UKXbv4NNmnTg6WkIhFKK2UI8cA/l9vrdQsZUaBkEvPcUwkYnRyUAbvxl5boKW40fiuztawszTVc28ax82TLyw3/qUVif49nNlxuWaKLdE9vafWt5QQS2DNmzcPhYWF/NedO3e02OO27WJGAQCgT0d7rbXZ2NxJiwLl8kEPp9c/PHcy5uQFlN84j24DhkEiFglSuIlfS94APvC1pNDdw0wkYqx4uS/sLU1x8W4hvopJ0Xb3NHaqJq2+d0d7/gOJoXv4OhaLRXhhQCdIPQNw5NgJtc9pzRxghYIhs1SOgrRL6OFqiw+f6q7V4+jd0Q67pg/G1y/0QXsrM1zPKcGrP53BtM3xyHxoOb2swgpM3xxPwbweNFWf4uGaF2PGjMHq1auxbds2pKWl4eDBg/jkk08wZswYPqA/cOAAYmJi+MdHjhwJX1/fRmteyBUMp27kY29iBk7dyIe8gXRrIW8+yKrliNp/AyLLdnjSxwoXTx9r1s0HMxMxPGpuhmqtcr2O5ZfIkFcig0gEdHMRfkQeALxq0utvPWKBPLd+/ABPwx2N5/CV6ytoLXmiuYIy5XVkV1N/4VZ+GV1beqLX1PrW3JHnlsCqqKhAfn4+3NzcMHfuXI2WwDI3N4e5ubCVXduqSxnanx/fWFaFSfxFVAI4kpKLD0J8+ccmTpyIvLw8DB06FIwxVFdXwzrgKUz+z3sAVOdO9ujRAy4uLti6dStOnTqFLl26tKqffCBvAMXuuDXkO7ZiRB5QFhNc8oI/3vrlPH4+noYg7/YI9tN8Xru2cPPjjWn9eHXX8fP9OiLK0h65d5Jw90FZvTRUddfxtGnT1M4B5q7jt6NWIPdGEkzbuWLlKwEwN9H++qhisQgvDfBASM8OWPp3Kn45dVvtfgzK6rUL9yVjlF+HRzfNXg8mTJiA3NxczJ8/H1lZWQgICKhX86JuEBwZGQmRSITIyEhkZGTAyckJY8aMweeff87vU1hYiHnz5uHu3btwcHDA888/j88//xympupvpsUkZWLhvmSVGzyudlJEjfFTO39y9uzZmDx5MgYMGIBBgwZh+fLl9W4+uLu7Y/HixQCUNx+WLVuGvn378qn16m4+/H7+DpLuiGBZnouzf25t8uZDXd5O1riVX4abuaUY7OPYrOcYEq7QXScHS1ia6eYjnreTFXBFj0vQ6UncrZr58Z2MIJCvuQHe6iXoCKmDC+Q921sir6QSGQXlSL5XZHQrCrUFeh2R12S5Kn0tgUVqVVYrcCVTmEJ3DbGRmkIkUs7HyarzYfHhwk2+ry1E+Y3zSPqjtsChtgs3can1eYY0It/KQB4Agv1c8OZQLwDA+zsu4F7NzQF9Y4zxFeuNaX68Oh4OlnCryZrYFV9/zm5rCpD9un4trHoMg5ONFF2cha1SbWdhiqeaKGjDAGQWVmB3wt1WL1/X3FFdoioiIgK3b9+GTCbDmTNnEBgYyD8WGxuLjRs38j+bmJggKioK169fR3l5OdLT07Fq1SqV4pUvvfQSbty4AZlMhszMTHz//fews1P/f31MUiamtzBLo6nimA8X3IyMjMT//vc/vujmm2++iZCQEKxdu5bf5+LNe9i05BPc+2ka8v/8FsOHPY4DBw40ePPhYXzBOyOtXF9b6E53a5pz9XEepdR6WbWcX7HHkCvWc/hAvoJS64nmCmtuCNlamKKXu3IKTxKl1+uFXkfkgZbfkT9z5gwyMjIQEBCAjIwMLFiwQO0SWI21SbTjanYxKqsVsJGaoHN77RW4aSyroqObKzp52CMhvQCxqTl4eVAnAKpzJ7OLKlDu3h8Owydhy4/f4cdlXwhSuMmQUuvvFnDF7jT7PXwY6otzt+7j4t1C/HdrAra9/Zje18ZNv1+GjIJymEpERpHCyGnoOu5gKsNtq3bYEXcXESO7qNSWaEkBstwHhRj37T/IqJRCcmQ5fD21m1LfkJzi5lWvf//3i/h4dxK6udigh6sNerjaKr862DY6n7Slo7pE/+QKhoX7kqHudktTWRqNFcd8uOAmd/MhKipK7f6yajkOVnjD/Z2f8EwfV3w/sV+Lj4Vfgs5I10XnRuR9dbD0HKd2LflHJ5C/fK8IldUKtLM05Y/fkPGp9TQiT7SgoOY6src0Qzdnaxy4nI3L96hQuD7oPZBvaTogtwTWzZs3YW1tjbCwMERHR9dbAquxNol2cHff+nS000513xp1syrGjRsHoDarIiIiApbdnZGQXoDDKbWBfN25k1wBGtd2VrgG9YWbrKys+MJNX3/9dav6yQXyxbJqVFTJITVtQUqzWAwMH177vQbkCobMguavId8YMxMxVr7SF898dxznbz/A8n+u4f0Q3QSIDeHmxwd42OssVVQbGrqOryaegk330Ui/X4Zzt+4jsE4qWksKkC09fBsZlVI4mlbhWuo5jH2zdddxSznbNK/isbmJGLJqBS5lFOLSQ3fq3eyktYG9qy18XW3g2d4KB5OzMH1zfL2AkBvVNdh1arX4fjZGZ9Pu1xuJr4vL0jibdh9BAmbVfHfoGq5ml8DR2gyLxvZq+glqaDUo1cN1kZLNrSEvfKE7jreT8pzdfVCOymoFzEx0+B7Q03uP+5zRv3M7rX7+EUrtiHwrAnmhzrGxtSt020IQqL+FZcrVmuwtTNGrJiNXayPyxnhd6JFBfCpuyR15fS+BRWpxaWW9BEirbyyrIrdaio9mvYNd/zph5cQtMDeRqMydPFvigPK0BBQd21Bv7iRjDN27d8f169fxwQcftGju5MNszE1gZiJGZbUCucUyeDi0YDTcwgJ46NpurZziClTXLMfn0solx+rq3N4Ki5/vjYgtCVgVex2PebfH0K76myvKz483wvmq6q7jstJSvPrK6/jjehneCJ+CZwf3avEc4DM38xF9oRzygkwUXtyGHhpcxy01yMsBrnZSZBVWqB2BFQHoYCfFsQ9G4m5BOVIyi3AlswjJmcW4klmEjIJy3CuswL3CChyqU7RSaiKGnLFWjerqnRbfz8aouVkazd2vNS7eLcCaozcBAJ+N6wUHK7NWteNTE5TeuV8GWbVcs5oTOr4uFAqGa3wgr7sReWcbc1iaSVBWKcedB2XwcdJNkT0AenvvxfGBvHGsomJrwc2Rb0VqvVDn2NjaFbptIQjUXy613s7CFD1rUutv5JagrLJa8wEXY7wu9MggAnlinLil5/q422u97cayKpwUDKLSfFSIxDiX9gBDuzqqFG5KS78DkdQOo0Kfwtq1K/g2W1q4qSkikQhO1ubIKChHbkkLA3kt4ubHu9pJtZYG/0wfN5y4no+tZ9Px7vZE7Js5BLfyynS+XjhjzCgL3XEauo7FLl3xx/VTuHX7Nu7UKZTUnAJkafdy8fnHc1BZlAsbW3u8MHGCRtdxS0nEIkSN8cP0zfEQASqBN3dFRI3xg6mJGF6OVvBytMJTvWtH0QvLq5CapQzqua/U7GJUVDU+n15Xo7qkZZLvFeG3c81b6cWiJVlLLSCrluP93y9ArmAY4++mUdaGk405rM1NUCKrRnp+GbrqcK65pu48KENZpRxmJmJ4anG6W1NEIhE821shObMIabmlug3k9YAxhvN1RuSNga2UqtYT7alNrTeFs40UzjbmyCmW4UpmkdHc3GorKJAnrSKrliMlSzkfpk9HYQrdNZRVIRaLMP2bX/Db+bs4nJKDoV0d+bmTH34Uid4LDqBKzvDjnJGwrzNn/KWXXsJLL72k1T462igDeX0WvLurwdJzjYka44f42w+Qml2M4V/HorJO4TJdzVm+kVuCvBIZzE3E6NvJXtDXEoq665gxpvyg/fJijH2hD7+9qTnAcgXDYZkPXN9eB38Pe+yYFgRTPdQwCO3litWv9as3l71DM64LOwtTDPJywCCv2j/2cgXD+uNp+PzPK02+tpCjuqR5GFMWI1xz7CaOXc1t9vPe256Itx73xluPe8FGi8tIrvinNqV+4bM9NWpLJBLB28kKF+8W4kZuqVEF8lyhuy5O1jqvbeLlVBPIPwLz5O8+KEdusQwmYpFgn3+0rXZEngJ5ormHl5/r5W6Hwyk5SMqgQF7X2s4kAaJTV7NKUCVnsLMwbfWSZ5p4wtcZABCbqrqe/MW7haiSMzjZmOukX07WrVyCrrQUcHJSfpVq9sGHW3pO0/nxD5OaSvDyIA8AUAniAd2tF86Nxg/wbNeyGgQGTiQS4YX+HQEAO+LuNvt5Pxy5jrO37sPKTILvXg7QSxDPCe3liuMfPoGtUx/DipcDsHXqYzj+4ROturkjEYuaPUWnuXP0dUqL72dDJlcw7L+YibGrTmDiT2dw7GouxCJgjL8bPnrKFyLUZmVwuJ892lmgtFKOFYeu4fGvj2Dt0Rsor5Rr3KcLdwqw5ugNAMBn43q3OqW+Lr5yvaYF73R8XVzVQ6E7DnfO0vJ1fP3r4b3HpdX3dLczmr9LGlWtF+ocG1u7QrctBIH6Wze1HgB6uWmxcr0xXhd6RCPypFUuZhQA0H6hu+Ya0sURphIRbuaV4lZeKTxrPkTw89Y66aYADVfwLq+4suVPzsvTSh+4EfmOWh6RlysYfjx2U+1jupqzfPK68abVN+W5fh2x9OBVnEm7j/T8MnRqIhU27vYDLD90DQDw6bhe6Nxe/5WSJWKR1tLcmzv3vu5IvkHR0vvZEFVUyfF73F2sO3YT6feVK2RITcV4aYAHpj7uzU8r6tTessEsjdF+HRBzOQtL/07FjdxSLP4rBT8fT8PMJ7pgwsBOrSqQVlGlTKlXMOBZfzeE9uqgleP1clSmhqdpYwk6HV4XKXqYH8/hiwTqY9k+Hb/36n7OMBbciHxxa0fkhTrHxtau0G0LQYD+FtapWg8ob2oBQJK2Ktcb43WhJxTIk1bh7rrpav34h9lITTHQ0wEnb+TjSGoOwh2V659zf2B1tUyZk7XyP7HcEv2l+3Ij8h3baXdOpL4rUSsUDKfTjLfQXVPc7C0wtIsj/r2Whx3xdzF7VLcG9y2qqMKsbQmQKxjGBrhhfF93HfZUNxqbe8+JGuNneIXu2rCCskpEn7qNjSdvIb9UebOynaUpJgV5YlJQZ7S3Vi2uGdrLFaP8OuBs2n219TTCertitJ8L9iTew7cHryKjoByf7L2Mtcdu4r3gbhjX171Fv98Vh67hWo4ypX6Bhin1dXFV2G8aWZo4t/ScPgJ5z0doCTpdf87QBn75OZojT7SggKtaX7OULBcLXMsubvkqTkQjlFpPWuXiXf0G8gAwsrsyvf5wTeVrxhji05V/YPvpqACNIawln/GgZg15LafW67sS9ZWsIhSUVcHSTGI08xBbikuv3xl3FwqFutBVeV1H7k7C3Qfl8HCwwKfjehnFcketwc2972Cnmj4vNREb7tJzRkquUM5z35uYgVM38iGvc/3dfVCGhfsuY/CXh7H04FXkl1aiYzsLLHy2J07MfQLvjepWL4jncFkaYwPcEeTTvl5gbiIR44X+HXH4/eFYNLYnnGzMcfdBOf73+wWELD+Gvy5l1ltqUZ3EOwVYq+WUeg4fyOcaz1rysmo5H0T76nDpOQ6XWp9VVIGyylakbxuJElk1Xx/IWArdAXVS68urm/X+IqQhCgWrl1rvaieFg5UZqhUMV2syg4hu0Ig8abGKKjl/57+3HgOskb7O+PzPKzhz8z7KKquRVViB+6WVMDMRo6ebbj7I8Kn1Ja1IrdcCxljtHHktp9Y3dy6yUHOWufXjB3k56HUuuJBCenaAjdQEGQXlOH0zH4O71M882J2Qgf+7cA8SsQjLJ/TlP5C1VXVHdRPvPMBXMamoVijwWBucXqEvMUmZ9VLgXe2keHOoF5IyCrHvYiYf2Pu52uKd4d54urerVguomZtIMCnIEy/298CmU7ew5ugNXM8pwfRf49Hb3Q7vh3THsK6O/E0ruYLxI/32lqZYtC9Z6yn1HC5N/EFZFR6UVqKdFm8SCOV6TgnkCmXdGhdbzZchbSl7SzO0szTFg7Iq3Morg5+O/gbrWmJ6ARRM+ffWxdYA63U0gEutr5QrIKtW0IgpabWSympw9325QF4kEqGnmy3+vZaHpIwi9Olor78OPmLa5qdjIqjUrGJUKxgcrMy0Hjy2hI+TFTwcLFApV+DE9Xw+3c2/o51ma/+2gKO1fkfk80sr+WW7XO21+6GCm7Pc2NivawNzlletWgVPT09IpVIEBgbi7Nmzjb7W8uXL0b17d1hYWMDDwwPvvfce/k25BwAY7NMexcXFePfdd9G5c2dYWFhg8ODBOHfunCaHZxCkphKM8XcDAPyupujd7fxSfLInCQDw7pNdjWoESBPcqO70EV3Qw9UW1Qpg/yVhCys+KmKSMjF9c3y9aTOZhRX4bP8V7Em8B7mCYWgXR0S/OQj7/zsUYwPcBauCbmEmwbThPjg2ZyT++2RXWJlJcCmjEJPXn8WEH0/j3K37iEnKxNCvDuOVdacxa1siJq8/hxu5pbCRmmhcpV4dSzMTuNZkhWhc8E5H6qbV6ytjx+sRSK+PM7Jl5zhWZhJwyTFUuZ5oorCmYr3UVKxyQ4grWHtJGwXvSLNRIE9a7GLNm7SXu34K3XFEIhGeqEmvP5Kao/O0ekD/qfXcGvLONuZav3nBzVkG6lei5gzt4lgvdXb79u2YPXs2oqKiEB8fD39/f4SEhCAnJ0dtG1u2bMHcuXMRFRWFK1eu4Oeff8b27dux/+dlAIAgb0e89dZbOHjwIKKjo3Hp0iWMHj0awcHByMjI0Nrx6guXXv9XUiaK68xfrJIr8N9tiSitlGOQpwP+M7KLvrqoV+P7Km907I43/t+1vskVDAv3JautP8CRmoqxd8YQbH4rEI93ddLZ//G2UlPMHtUNx+aMxFtDvWBmIsbZtPt4cc0pTFNz4wEAiiuqcaamjoa21abXG0dQmqrHivWc2nnyhnvzQ9ObzGu+ng9WXckH8sZyk1kkEtUuQUfz5IkGHk6r5/RyUwbyl+9RIK9LFMiTFrt0twAA0EeP8+M5I2uWoYtJysSRmrnyfXWY0sONyJdXyVEqa8G8QLEYGDBA+SVu/duwttCdMJkRDc1ZtpEqZ+XsiL+LA5ezVB5btmwZpk6divDwcPj5+WHNmjWwtLTE+vXr1b7GyZMnMWTIEEycOBGenp4YPXo0nnzmOZTcTYWt1ARe7Uyxc+dOfP311xg2bBi6dOmCBQsWoEuXLli9erUgx61LfT3s4eNkhYoqBfZfrB11/vbgVVy4UwBbqQm+fTngkS3yNjbAHWIRcP72A6Tnl+m7O+pp6f0stKYKWAJARZUCZVpYFq612lubI/IZPxz9YAS//GVDuJUz5A3Ul9CEd03leo0K3unwukjRY6E7Tu2yfTq8+dGCc6zpTeZ1637C9VN/48HRTXwgb0w3mblpWYXlLaxhINR1bGztCt22EAToL7eGvL2F6pSjXu7K6TQpmcWoemjJ4hYxxutCj9rOkRCduZShLPSiz/nxHC5F7H5pFbKKlKPi8//vsuDrm3OszE1gaaYcCW/RqLyFBXDunPLLovVBODci767livV1qVsvPOGTUZgY2AmMAbO2JSDxTgEAoLKyEnFxcQgODuafLxaLERwcjFOnTqltf/DgwYiLi+NHRm7evImDB/6Chc8ABHq3B1PIIZfLIZWq3kywsLDA8ePHhTloHVKuKa8MWNafSMPexAz89O9N/BCrLOT15fN99DqFRd9cbKUYUlM7YE+i4X04BqC197PQ9F3AsiVc7Sww1r/x1RnqrpyhbVopeNfC60KT0eJts5/B/UPr4GlfO0qm69Fibtm+W7oM5FtwjjW9yewZEASLHsNQnX0Nvh1sUF5eblQ3mVtduV6o/9+MrV2h2xaCAP0tKFfWhLKzVB2R7+RgCRupCSrlClzL1t3/m3pvV88okCctUlEl5ytS6rNiPaAchZ+1LbHe9txiGaZvjtdZMF9b8E736fV3uYr1Agd6D1eiNpGIsejZnhjZ3QkVVQq8ufEc0vPLkJeXB7lcDhcXF5Xnu7i4ICsrS23bEydOxKJFizB06FCYmprCx8cHtl7+sAt6CYN92sPGxgZBQUH49NNPce/ePcjlcmzevBmnTp1CZmbbmDfdruYP4tXsEszalojP9l8BAAzxaY+w3lSpfVyAMqDbnZBBFZc1oO8Cli2lzxsP3k41I/I6Sq3XZLT4TPxF2IfMRFnKv9i66mt+H12PFhvyHHlt3GT+6+QFlN84j679H4eJRIzq6mqjuslcW7meUutJ6zWUWs8VvAOAJEqv1xkK5EmLJGcWQa5gcLQ244sB6UNjcz25bUKlXD5MnwXv+Ir1AqXWN8ZEIsb3E/uhp5st8ksrMWXjWRSWt7x6f2xsLL744gv88MMPiI+Px2+/70BawnEUnNiKwTXrx0dHR4MxBnd3d5ibm+O7777DK6+8AnEbSI+KScrEvF2X1D528ka+zm5IGbLQXh1gYSpBWl4pLtylDwitxRWwbIgIDRew1Ad93njg0sRv55fp5O+IJqPFFdL2sPDqB+eAJ5AYfx4A9DJa7OmozAzjqv0bEm3cZJ79/DBIO/XGpOnvAYDR3WTmA/mKtrs8IBFebWp9/RV0uAG+y1TwTmeM/1Mw0amkjNr14/VZ6K6puZ5Cplw+zIkL5FsyIl9WBnh6Kr/KWj/v9+4DYefIN8XK3ATrpwyEm50UN3NL8UlMOiQSCbKzs1X2y87ORocO6peI+uSTT/D666/jrbfeQu/evdG5/0jYDZuEojM70MVJ+cHQx8cHR48eRUlJCe7cuYOzZ8+iqqoK3t7egh+jkJpTfExXN6QMmZW5CUb3VH4A3x1fv7q/3mnp/Sy0ugUsH8b9bx41xs9g6jE0tXKGkDce3OwtYGYiRqVcwU9harFmXheajhanZhWhqiALZTfOIywsDAD0MlpsaWaCDjVLsqXl62hUXsD33sM3mXtOWojyG+dxef8Gfh9jusnMp9a3dEReqHNsbO0K3bYQBOgvNyJvb1k/kOcq1yfdK2r9CxjjdaFHhvc/DTFoF+/WBvL6ZEhzPfnU+paMyDMG3L6t/NIgVZgvdqfHOdQutlKsDx8IG3MTnL9TDEfPHvjnn3/4xxUKBQ4dOoSgoCC1zy8rK1P50HPqRj5EIjEkaj69W1lZwdXVFQ8ePMCBAwcwduxYrR+PLhnSDSlDN76vMr1+38VMzQrpCEFL72ddCO3lCn819U062Emx+rV+CO1lOFM5Gls5Q+gbDxKxCF7tlaPyN1pbhb2Z14Wmo8VTHu+Ke2vfgm/fQHz00UcA9DdazKXX62yefDPPsaOjo0Y3mV29uqHEtf//s3fm8VHU9/9/zV7Z3IFsLiCQcAWScIWQyKEcIpdGwYoWUAERW4Wq0NqCAhFREOsvjW0R1K8oLVpRiyeWVpCgyKUJh9yEhARy38cmm80evz9mZ5Ilm2RnM7NH8n4+Hvt4JJvZTz47+5nZec/7/X69EDT5UXz0zl9hMrHnIE+6ydySkRcYyEt1fvO0caUeWwokmC9nP3draT0AxFmU6y8U1jqegPDEdeFCKJAnBPELF8g7URneFu7U66lxJCMvAjWNzaizlMi5orS+NcPCA7D94bFQyBgY4+bgrbffwa5du3Dx4kU8+eST0Gq1WLp0KQDg0Ucfxdq1a/nXpqSkYPv27fjoo4+Qm5uLvV99g+ofdmPs7dMhl7NCgv/973+xf/9+5Obm4ttvv8XUqVMxbNgwfkxPxZ1uSLk7kwZroPHzQqVWj++vlLl6Oh4Lq3PCBqZb7o/nBSyP/GmaWwXxHO05ZzjjxoM7W9C1zhZPW7MTIfOex7WsH7Bp0yZ+G1dki6PctE9epVJh7NixOHjwIP+ckJvMWRb/+IggtkrsVq0OT7jJzNvPCVWtJ4hWtIjdqdr8LVrjCx+VHI3Nxq4JhRJ2o3D1BAjPoVFvxNVSVuhupIsV67mSy+Ianc2yZAbshZ4zej1d5SXPlXv28lHCR+X6Q3nSEA023z8CfzSZYWyowR/WvIDayjKMHj0a+/fv57NN+fn5VheS69atA8MwWLduHQoKCmBQ+UM9KAk7duzgt6mpqcHatWtx8+ZN9O7dG7/61a/wyiuvQKlse0fYk3CnG1LujkIuw72j+mDnj7nYe6oAdw4P6/xFRBuOXC1HY7MRfYO88etx/V3aImUvs+IjcFdsOE7mVqK0TodQf/bcLnULgCjK9XbQlWzxsmXL8MbG/8FnaG88NS0KL/7xGbzwwguQyWR8tlir1aK2thYRERF46KGHJM0Wu8SCzk5Wr16NxYsXIzExEUlJSUhPT29zk7lv377YsmULAPYmc1paGsaMGYPMhmA05p5CzffvIyUlxeoms9lsRkxMDLKzs/Hcc8+57U3mALWDqvUE0YqOeuTlMgaxEQH4Oa8K5wprMCTMdXaYPQXXX/0THsOFohqYzGzgGhbg2sCCK7l8cncWGMAqmHd2r6fGj70rWVbvXHEfVwrdtceDiZG4WdmAvyIF8nH34tMl4zB5aIjVNhkZGVa/KxQKpKamIjU1FT9ml2PR/51AeIAaowa1WE89+OCDePDBB53xFpyKO92Q8gTuT+iLnT/m4tsLJajVNfOlooT9HLjIBot3xYZ5RBDPwTlnOBPOTk3qjHzrbPHcuXMBtGSLV65cafM1XLa4sEaHOp0BChnTYbbY19eXzxa/9tprtoYUBV653g2rGB566CGUlZVhw4YNKC4uFnSTOTf/Bhh1IO6cORtvvfUGv40n3WRuychTIE84Tnuq9RzxfQPZQL6gFvPGOHNmPRMK5Am74crqR7q4P56DK7nc+NUFqz7j8EA1UlNinVYm6lCPvAgUWKzn+gVJ5yHvCKvuGoqbVY3Ye6oAT+3OxCe/nYBYiyVJZxy9Vg4AGD8o2KOCDEdxpxtSnkBcnwAMCfXD1dJ67P+lGA+Oi3T1lDwKk8mMAxdZO7PpVNHQKVxG3hll4o5mi5WhA9FcrYAG1dj44naXZ4ujLfvseoUWZrPZ7c7jK1eubPfmSHs3mde8sA4jXvwf9AYTtv9+MoKC/PhtPOkmM6nWE2LQkdgdgBYLOlKudwoUyBN2c5ZTrHdxWX1rXFVy2ZrWpfXOvHBxx4w8wHqJvvqrkSiq0eFYTgUee/8nfLZiAiICO5/nsWsVAOD0zJsrcZcbUp4AwzCYO6Yv/vzfy9h76iYF8gI5daMa5fVN8FcrkDyQqjw6Y5AlI19cq4O2yQBfL+kumRzNFm9L24zy0mLUBvbGow/dj1deeYXfxhXZ4shePpAxQIPeiNK6JpdX74nB+cJa6A0m9PZV8RUHngiXka+jjDzRBVpK69v2yAMtyvUXCmthMpkho0SEpFAgT9jNL26iWH8rrii5bA0ndqc3mlCrM7RbbmQFwwCxsS0/OwBnPdfXhYr17aFSyLDj4bH41Y6jyC6tx9L3fsInvx0P/w5KoeubDLxH+IQeFMgD7nFDylPgAvnjOZUoqG50j/UvwvHsDL69wJbVT40JhVJOWredEeijRLCvChVaPXLLtfwFqt0IXBeOZIurYu7F56cL8dzMGKyYOthqG1dki1UKGSJ7+yCvogE5ZVrpA3knHHuc0F1C/15uV2EgBN5+TmiPvFT72NPGlXpsKRB5vk0GIxqbjQDaL60fEuoHL4UMdU0G5Fc28AKYduOJ68KFUCBP2IW2yYBrFsEfdwvkXY1aKYe/WoE6nQFldU32BfI+PsD58136v+6akecI9FHivSXjMO/No7hUXIcVH57Cu4sT2w0gfsqthNFkRmRvb/Tr5V7tAs7A1TekPIW+Qd5Iju6NE7mV+OJ0AZ6aMrjzF0mNCMezM/j2AmtldlcsldXby8AQX1Ro9bhWVi88kHfCurhUzArQxriRqFS0xhd5FQ3ILddKf05zwj7++TobyI8d0EvS/yM1fGl9o0FY9aBU+9jTxpV6bCkQeb5cWT3DAP5q2yGkQi7DsIgAnLlRjXOFNcIDeU9cFy6EbskTdnGhqBYmMxAeoEZoNyiVExu+T96JFnScan0/Nw3kASCytw92LkmEt1KO76+UYf3n59oIMXEcy2HL6icM1DhzioQHcn8CK4T4WVZBu+uJsCanrB7XyrRQyhlMjgnp/AUEgBbxNne0oGs2mvgb7DHh7hXIA2yfvKdjNpuRmd9NAnlLkkFvNKHJYHLxbAhPpLWHfEcl8/F8n3ytU+bVk6FAnrCLs5aSZ8EZiR4C7yXvJMG7Rr0RFVpWJd/dxO5uZWS/IPxtwRjIGOCjn27gzYxrNrdrLXRHEB0xe0QEVAoZrpbW43whXSjYA6dWf9vAYFL7F8DAELZP3t180QF2Ts1GM/y8FG51Q9edb34I5WZVI8rqmqCQMS633e0qvio5uNiLlOsJR+hMsZ6DixVI8E56KJDvIWzbtg1RUVFQq9VITk7GyZMnO9w+PT0dMTEx8Pb2RmRkJLZtXg+zQc9/kRmNRqxfvx7R0dHw9vbGoEGDsGnTph6bHRPsJd/QAMTFsY+GBsH/r6CafY2fl4Lve3NnpseG4cV74wAAf/7vZXxxusDq79UNej4go0Ce6IwAtRJ3WVTXPztV0MnWTqCLx7Mz4PrjqaxeGC2+6A54yUu8Lriy+qFhfm7Vu81b0Dmyz4Qi8T7OtPTHx/UNhFopF318Z8IwTIsFnZA+ean2saeNK/XYUiDyfDvykG9NfB9LIF9YIzwu8MR14ULcPwIgusyePXuwevVq7NixA8nJyUhPT8fMmTNx+fJlhIaGttn+ww8/xJo1a7Bz505MmDABV65cQcr8hfAqq8eI5W8DALZu3Yrt27dj165diIuLw88//4ylS5ciMDAQTz/9tLPfossJ8RNYWm82AxcutPwskNZCd+50AdcRj46PQn5FA/7vSC6e++QswgPUSB7IBu0ncithNgODQny7hcoxIT3zxvTFvl+K8MXpQqydPQwKV4q3dfF4lpqK+iY+ICHbOWHwGfkyB+zUJF4Xl4vZm58x4fbZezoLLpDPr2yAwWiS9tiUeB9zx02ih5fVcwSolahuaEZNowALOqn2saeNK/XYUiDyfKu5jLyPbcV6jqHhflDIGFQ3NKOgulGY7pEnrgsXQhn5HkBaWhqWL1+OpUuXIjY2Fjt27ICPjw927txpc/ujR49i4sSJWLhwIaKiojBh8jSoY26HvugqL3R39OhR3Hfffbj77rsRFRWFBx54ADNmzOg0099dEZyR7yLuLnTXHs/PGY7Z8eHQG0144p+ZuFxch2PXKvDB8TwAIEsswm4mx4Sgl48S5fVN+NFiW0jY5rtLpTCZWX/fPu6g8u9B9O/tA7mMgVZvREmt8zRQ7OGyJSM/zI364wGgT6A3VAoZmo1mFFbrOn+BG2I0mXHsWgUOXioFAIyJDHLthETCYeV6goD9pfVeCjmGWgQ4qU9eWiiQ7+bo9XpkZmZi+vTp/HMymQzTp0/HsWPHbL5mwoQJyMzM5IPy/x07g4ZrPyM07ja+F3zChAk4ePAgrly5AgA4c+YMjhw5gtmzZ0v8jtwTLiNf5iSxO08QurOFTMbgLw+Nxpj+QahpbMacN77HgneO4/urbH/8N78UY/+5IhfPkvAElHIZUkb1AQB8lnXTxbNxb6is3nFUChkiLefZnDInlIoLgFesd7NAXiZjEBXMZuAcaklwMfvPFWHS1u+w4J3jKLTcNH/p6wvd4rupRbmeAnlCODUNrDZTZ6X1ABDfl60UOl9IffJSQoF8N6e8vBxGoxFhYdYXcGFhYSguLrb5moULF+Kll17CpEmToFQq8aupiVD3H4FZi57kt1mzZg1+/etfY9iwYVAqlRgzZgyeffZZLFq0SNL3465o/NkyI2ep1vMZeQ/MrqmVcixM6g8AMN5S3VTT0Iwnd2d1iwsmQnrmjWHV6/97vgTaJgGloj0IXbMRP1hulFEg7xhceX2OmwjeGU1mfHeplG+xGmyZnzvR0ifvHvvMXvafK8KTu7NQVGNdSVBW19Qtvpv4QF5H50up6ao21apVq6DTtaxDd9Cm4krrg3w6D+RHkOCdU6BAnmhDRkYGNm/ejDfffBNZWVmYs+p1NF77GYWHdvPbfPzxx/jggw/w4YcfIisrC7t27cLrr7+OXbt2uXDmriPEj+3rdlZpPd8j72EZeYC9CE379orNv3FfRxu/ugCjqfv0MBHSMDoyCNEaXzQ2G/Hf87ZvTPZ0jlwtR2OzEX2DvBEb4V691J7CQDdSYeeyxY+9/xP/XMrfj7hdgBmtcV+1//YwmszY+NUF2Prm6S7fTXxpPWXkJYXTpkpNTUVWVhZGjRqFmTNnorS01Ob2nDZVamoqLl68iHfffRd79uzB888/z2/DaVP9/e9/x8WLF7F161a89tpr+Nvf/uast2V3aT3ACkQCwDlylpEUCuS7ORqNBnK5HCUlJVbPl5SUIDw83OZr1q9fj0ceeQSPP/44RowYgcY+YxE0+VEc+OhtmEys9+hzzz3HZ+VHjBiBRx55BKtWrcKWLVskf0/uCNcjX1Gvh8kJX/IFVZ6bkT+ZW9km29EaM4CiGh1O5lY6b1KER8IwDOaOtnjKu4N6vRvC2c5NHx7qMcKY7kZLRt61ZeLtZYuLa3Ruly0e6IEZ+Z7w3dSSkadAXkq6qk01Y8YMLFiwwCqL7w7aVNUN9gfyw8MDIGPYBFdprWdqZXgCFMh3c1QqFcaOHYuDBw/yz5lMJhw8eBDjx4+3+ZqGhgbIZOzSqNU1I6dcC4aRQcaAL+FpvQ2HXC7nA/2eRrAfW1pvMJn50qMOYRhgwAD2IfDiWm8woaSOPSkKUgJ1E0rr7Duh27sd0bPhyut/zC5HiasuFrpwPEuJyWTGgYtsBuiuWNs3bonOGRjiYEZexHXhadniKGcF8iLu457w3cTbzwlRrZfq/OZp49o5thjaVDk5Ofjmm28wZ84cq20Ea1OJvC9aSus7Vq0HAG+VHIND2Zugvwgpr/fEdeFCyH6uB7B69WosXrwYiYmJSEpKQnp6OrRaLZYuXQoAePTRR9G3b18+m56SkoK0tDSMGTMGivAhaMw9hfofP8C9KSmQy+X8Nq+88gr69++PuLg4nDp1CmlpaXjsscdc9j5diVIuQy8fJaoamlFW14Tevp2c5Hx8gOvXHfpfxTU6mM2Al0IGjV/nJ1N3I9TfPns5e7cjejb9g30wdkAvZOZV4cvThVh+x0DnT6ILx7OUnLpRjfL6JvirFeQI0QW47PLNqgY0GYzwUtjpJy7iuhCSLR4/KFiU/9kVuB75gupG6JqN0nmwi7iPe8J3U4DaAdV6qc5vnjaunWN3pE116dIlm69ZuHAhysvLMWnSJJjNZhgMBvz2t7+1Kq1fs2YNamtrMWzYMMjlchiNRrzyyisda1OJvC9qBZTWA6yf/JWSepwrqMWd9lqfeuK6cCEUyPcAHnroIZSVlWHDhg0oLi7G6NGjsX//fv4kk5+fb5VdX7duHRiGwbp165B/4yZMXgEYljQFb731Fr/N3/72N6xfvx5PPfUUSktL0adPH/zmN7/Bhg0bnP7+3IUQfy9UNTSjvL4JMZBORfhmdQMAz/KQb01SdG9EBKrZGxI2/s4ACA9UIymaAg/CPuaN6YvMvCrsPVXgmkDeTeHU6qfGhEIppZd3NyfE3wt+XgrUNxmQX9GAIWHOV4n3tGyxxk8Ffy8F6poMyK9s4K2o3Jme8N3UkpGn0np3orU2VXJyMrKzs/HMM89g06ZNWL9+PQBrbaq4uDicPn0azz77LPr06YPFixc7ZZ7VnGq9HWJ3ANsnv/dUAc6Rcr1k0Dd7D2HlypXIy8tDU1MTTpw4geTkZP5vGRkZeP/99/nfFQoFUlNTkZ2djSfeO4p+T72HJ1/YjKCgIH4bf39/pKenIy8vD42Njbh27RpefvllqFSelyEWC86aT2rBO08WugMAuYxBakosAPbCqDXc76kpsZDLPO8mBeEa7hkZAaWcwcWiWlwqJmEdDr4/ntTquwTDMHx5/TUXCd65Y7a4I1VuhmEQHWJdXu/uqtzcd1N7QTzg+d9NpFovPWJoU82bNw+bN2/Gli1b3EabymQy82J39tjPAUB8H4sFHSnXSwYF8kSHcH0tI/sFungm7g8neGdXIN/YCIwbxz4aGwX9H08WuuOYFR+B7Q8nIDzQ+qIzPFCN7Q8nYFZ8hItmRngiQT4qTI0JBeAi0bsuHM9SkVuuRXZpPZRyBlNiQlw9HY+HV64XIngn4rrgssXthZAMgAgnZovtUeWOCm4J5CVT5Rb52JsVH4EHEvq2eb67fDdxGfk6IRl5qc5vnjaunWN3VZuKg2tl7ZI2lYj7ol5vACfBEWBnIB9rCeQLa3SosNee2RPXhQuh0nqiXWoampFXwZZxc36QRPtwGXm7vORNJuDnn1t+FgDnId/PQzPyHLPiI3BXbDhO5laitE6HUH/2ItSTsx2E67g/oS/+d6EEX5wqxB9nDnPuOurC8SwV315g7fhuGxjMZ+EIx+GV64Vk5EVcF1y2+MndWW3+5opscWtVbgDYsWMH9u3bh507d2LNmjUAWnnJl2mhbaXKDQBRUVFYsGABTpw4wY/ZWpWb2+Zf//pXx6rcEhx7F4rqAACPTYzCqMigbvXdxNvPCemRl+r85mnjChi7K9pUXGn9+vXrkdJVbSoR90WNRbFerZTZrXnhr1ZioMYXOeVanC+sxR1D7bip7InrwoVQIE+0C9fTEtnb2y6Fyp6OoIx8Fyjw8NL61shljFsIMxGez9RhoQhQK1Bcq8OJnApMGKxx9ZRcCtcffxeV1YtCtBvYqc2Kj8CbixKw4sMstBanDw9UIzUl1mnZYk6Ve+3atfxztlS5B7YqrZ87YQJ2796NkydPIikpiVflfuSRR/jtJ0yYgLfffhtXrlzB0KFDeVXutLQ0p7wvALhcXIcLRbVQyhn8btoQ9OpMuNbD4EvrGw0wm80eqbPjCXRFm6qgoAAhISF84M7ham0qznouyFvYMRHXNxA55VqcK6yxL5AnBEGBPNEuZ29ayur7Brl2Ih5CCNcjb2/5kIO0iN15nvUcQUiFl0KOu0f2wb9O5mPvqYIeHchX1DchM68KAOxXCiY6pMWCzrVe8kPC/GAyA0o5g633j0REkLfTs8X2qnLzNz8qtFj4W4lUuUWGa82ZEhPa7YJ4oKUkWm80oclgks5NgMDKlSuxcuVKm3/LyMiw+p3TpkpNTW13PE6bKj09XcRZ2k+NQMV6jvg+AfjqTCHOF5B+jRRQjzzRLucs/fEjqD/eLjROyMgbTWYUVbPiQN0hI08QYsCJbqUtGIeif6zG3v8eRqPe2O727i661VW+u1QKkxmI6xPg0Voa7gQXlFY1NKNKq3fZPI7nVAIAxkX1xv1j+2H8oGC3LfnmvOTL6prwzf8O8KrcWVlZ2Lt3L/bt24dNmzbx27dW5c7KysKuXbvw+uuvY9euXU6Zr8lkxhen2UD+/jFt++S7A74qObjlQsr1hBCqG9nzXqCdivUc8ZbWXEFe8oTdUEaeaJezBdUAqD/eXkKE9Mg7SGmdDgaTGQoZgzDLjQOC6Mlwols7duzAuHFJmL7sT8jb/Tw+WTQFj04d2WZ7TnRr586dmDBhAq5cuYIlS5aAYRi+hJcT3dq1axfi4uLw888/Y+nSpQgMDMTTTz/t7LcoGCqrFx8flQJ9AtUorNEhp7weY31dY0F2MpcN5F1pgWavKneAWgmNnwrl9XqsW7eBV+UGgBEjRkCr1eKJJ57ACy+8AJlMZqXKzW2Tl5eHLVu2OMVe63huBYpqdPBXKzB1WKjk/88VMAyDAG8lqhuaUatrRmiA81wOCM+mpbReWCAfZxG8y69sQE1Ds+AbAUTHUEaesEmVVo8blWwvdnwfCuTtgeuRr9TqYTRJk7nj+uPDA9VQkC80QViJbsXHx+H3G/8MRumFN7a9ZXP7o61Et6KiojBjxgwsWLDASlCrtehWVFQUHnjgAcyYMaNj0S03QddsxA9XywFQIC82nOCdqyzozGYzTuRWAACSo12nLSJElZurZKipr5dGlVtEPstis/H3jIzo1iXnXJ98TSNZ0BH242hpfZCPihdnPl9EWXmxoUiAsAkndBcV7EN3z+ykt68KMgYwmYEKrR1ZeY2GfQiAU6ynclmCaBHdmj59Ov/c/WMjoY4ajUtnM21Wx0yYMAGZmZl8UM6Jbs2ZM8dqm4MHD+LKlSsAwItuzZ49u/3JOHA8S8GP2eVobDaib5A3YiMCXD2dboVDgncirov8ygaU1DZBJZdhTP8gUcZ0lNWrV+Odd97Brl27cPHiRTz55JNtVLnXrl3L77MhiZOxfft2fPTRR8jNzcW3337brir3vn37cP36dXz22WdIS0vDvHnzOp6MCPtY12zEf86xTg9zR3fPsnoOh5TrpTq/edq4Uo8tBSLNl/eQdyAm4BKCdvfJe+K6cBFUWk+0wWgy4+uzRQDYzK/RZHbbHjx3Qi5j0NvXC+X1TSira0Kofwcla76+QFmZ4P9xsxsp1hNEV7ElujUoxA/hYWG4cSETX50pxNKJ0VavWbhQAtEtB49nKeDK6qcPDyVFapERLHgn8ro4YemPHxUZ6PKMsb2q3EmWQH7ozEcxfpBGfFVukfbxtxdKUN9kQN8gb4yLcl3bgjNoUa63M5CX6vzmaeNKPbYUiDjf6ga2R94RF6v4vgHYf76YTxJ2iCeuCxdCgTxhxf5zRdj41QUU1bDCT8dzKjFp63dOtbbxZEL82UC+vF4aMSQukO9HGXmCaJehYf64cYFVoL41kM/IyOBFtzi/3meeeQabNm3C+vXrAViLbsXFxeH06dN49tln0adPH6f06jqKyWTGgYulAIC7YsM72ZoQikNe8iJy3FJW78r++NbYo8q9/xybFMirasJf3ViV+3OLWv28MX0h6+aJCz6Q11FpPWE/XEY+QGBpPdAieHeOBO9EhwJ5gmf/uSI8uTsLt3Z3F9fo8OTuLGx/OIGC+U7Q+LF3KqVSrudK6/v1Ius5gmhPdCvArIXCrxfO3qxBdmk9Bof68X9bv36924tuOcqpG9Uor2+Cv1qB5IHuEex1JwZasst5FQ0uqVTjhO5c2R8vlGiN5eZHudZtfcsr6ptw+AqbqZvbTdXqW8OX1pNqPSEAR8XuACDOUlqfU66FtskAXy8KP8XCoR55g8GAAwcO4K233kJdXR0AoLCwEPX1rvVXJRzHaDJj41cX2gTxAPjnNn51QTIRt+5CiL0WdI2NwJQp7KOx0e7xC6osHvJUWk8Q7YpuHfk+A8NHJQJoybRxtCeoBXRBdMvB41lsDlxkb2hMiQmFksQwRadPkDdUChn0RhNuWs7FHSLiuiiobsTNqkbIZQzGDujVpbGcyYBgHzAMUKczoFIK2z4R9vHXZ4tgMJkxsl+g1U2/7kpLRt7OQF6q85unjSv12FIg4ny70iMf4u+F8AA1zGbgYlEnffKeuC5ciOBbInl5eZg1axby8/PR1NSEu+66C/7+/ti6dSuampqwY8cOKeZJSMzJ3Eq+nN4WZgBFNTqczK3E+EGekw1wNnZb0JlMwOHDLT/bgdlsJrE7griF1atXY/HixUhMTERSUhLS09Oh1Wrx9JPLseF/N/Ha2t+h/FACXn31VQCsoFZaWhrGjBnDl9a3J7rVv39/xMXF4dSpU0hLS8Njjz1mexIOHM9SQLZz0iKXMYgO9sXlkjrklGsxINi34xeIuC5OWsrq4/sGelQ2S62Uo0+gNwqqG5FbrkWwn8i2qSLs472Wm33dXeSOw5/vkbeztF6q85unjSvh2EaTGSdzK1Fap0OovxpJ0b3FqfgRcb6OqtZzxPcNQHGtDucKapDYkQ6FJ64LFyL42+CZZ55BYmIizpw5g+DgloBu3rx5WL58uaiTI5xHaV37Qbwj2/VU7M7IO0CFVg9dM3vyiQgi71eCANoX3RqVEI/XDhejuLwI57Lz+O3XrVsHhmHEF91yMbnlWmSX1kMpZzAlJsTV0+m2DAyxBPJlWkyNcd7/5YTubnOT/nghRGt8UVDdiJxybccX8C7gWlk9ztyohlzGIGVUH1dPxyk4pFpPSMat2lQAEBGodjttqpbSeuFidwBbXn/gYil+sVe5nrALwYH8Dz/8gKNHj0Klsv4go6KiUFBQ0M6rCHenQ4V1B7brqXCBfKcZeQfgPOTDArzgpei+HrcEIZT2RLdmx4fjk4WvYkRSJP+cQqFAqhuLbjnKtxdY66zbBgbzpbOE+AhWrhcJrj/eXYTuhBCt8cWR7HJhtn1O4gtLNv72IRr++7u7I1i1npAMT9GmajIY0dhsBACHLak5wbvz9ijXE3YjuInOZDLBaDS2ef7mzZvw9/cXZVKE80mK7o2wDr7EGLB3CD3xIsKZaPyky8hTWT1BCGNeAlsq+/XZIuia235vdScOXGDV6qcPp7J6KRmocb5yfWmtDjnlWjAM3C6jbQ9RFpHA624WyJvNZnx2ukWtvqfAqY6Tar1r8SRtKq6snmEAfwdbe+L7BgAArpbWd/vvY2ciOJCfMWOGVZaCYRjU19cjNTUVc+bMEXNuhBORyxgMCbN9I4br0klNiSU/+U7gS+slzMj3JcV6grCL26KDERGoRp3OgEOXSl09Hcmo1Orxcx6bsZ1O/fGSEs1l5Mudl5E/YcnGDw8PcLg/1ZVwav/ulpHPzKvCjcpG+KrkmNGD7BoD1GwgVkcZeZciRJvK1dQ0tPTHO2rPGB6gRrCvCkaTGZeK68ScXo9GcCD/+uuv48cff0RsbCx0Oh0WLlzIl9Vv3bpV8AS2bduGqKgoqNVqJCcn4+TJkx1un56ejpiYGHh7eyMyMhKrVq2CTtdyIBiNRqxfvx7R0dHw9vbGoEGDsGnTJl6NmLDN2ZvV+PFaOQCgt69120R4oNptynvcHU7srrqhGXqDuGIanEoyZeQJwj5kMgb3WQSs9p7qvq1fBy+WwGQG4voE0PlBYgZZMvIltU3QNjkno8nbznmopWC0JZC/VlqPz08V4Ni1CrfIMnLnhFnxEfBW9Zx2tZaMPAXyrsSTtKmqGx23nuNgGIb85CVAcH1EZGQkzpw5gz179uDMmTOor6/HsmXLsGjRInh7C7uA2LNnD1avXo0dO3YgOTkZ6enpmDlzJi5fvozQ0NA223/44YdYs2YNdu7ciQkTJuDKlStYsmQJGIZBWloaAGDr1q3Yvn07du3ahbi4OPz8889YunQpAgMD8fTTTwt9uz0Ck8mMDV+ch9kMzB3dB//vwdHSqGf2AAK9lVDIGBhMZlRomxAR2MEx4SMss86X1pP1HEHYzf0JfbHj8DVkXC5FlVaPXr6OCfV0isDjWUxIrd55BPooEeyrQoVWj9xyLX9h2i4irIsTFsX6ZA9tbeN6YptNZjy75zQAkcW8HNjHTQYj9p0tAsCeI3oSfCDfaIDZbAbD2HF9J9X5zdPGFXFsp2lTiTDf1hn5rhDfNwCHr5R13ifvievCRQgK5JubmzFs2DB8/fXXWLRoERYtWtSlf56Wlobly5dj6dKlAIAdO3Zg37592LlzJ9asWdNm+6NHj2LixIlYuHAhAFZgb8GCBThx4oTVNvfddx/uvvtufpt//etfnWb6ezKfZt7E6RvV8FXJsXbOcMhlDFnMOYhMxkDj54XiWh3K6joI5H19Aa2wMsObltL6fhTIE4TdDA3zR2xEAC4U1eLrX4rwyG0DxP8nDhzPYqFrNuKHq2w1FfXHO4eBIb6o0Opxray+40BehHVRqdXjSglbxp8U7Xnfy/vPFWHlh6faPC+amJeD+/jQpTLUNDYjLMALtw30vP3aFbjSer3RhCaDCWplJ9UIUp3fPG1ckcdOiu6NiEA1imt0NvvkGbAVsV3SphJpvlxGPtCnazfC4/twGfkOlOs9cV24EEGl9Uql0qqMvSvo9XpkZmZi+vTpLZORyTB9+nQcO3bM5msmTJiAzMxMPijPycnBN998Y9WbP2HCBBw8eBBXrlwBAJw5cwZHjhzB7Nmz251LU1MTamtrrR49hZqGZry6/xIA4NnpQxEWQKr0XUXjz57oxFau5zLy/ah0liAEwWXcPu+G5fU/ZpejsdmIvkHeiOsT4Orp9AicKXjHldUPDfNr0/bm7rizmNdnp24CYL3je1rFoa9KAe4tk3K965DLGKSmxLYbxAPuo01V3aAH0LXSeqBFuf5ycZ3o7ac9FcE98itWrMDWrVthMHStN6y8vBxGoxFhYdYZhLCwMBQXF9t8zcKFC/HSSy9h0qRJUCqVGDRoEKZMmYLnn3+e32bNmjX49a9/jWHDhkGpVGLMmDF49tlnO6we2LJlCwIDA/lHZGRku9t2N9K+vYxKrR6DQ/2wZGKUq6fTLQiRQLm+prEZdRaFWSqtJwhh3DuqD2QMK26VV9G97shzZfXTh4faVyJLdJkWwTvnBfKe6BjjrmJe1Q16HLpUBgCY24PU6jlkMgb+alKudwdmxUcgZWTbihR306bibvh0tbS+Xy9vBKgV0BtNuFJCgndiIDiQ/+mnn7B37170798fM2fOxP3332/1kJKMjAxs3rwZb775JrKysrB3717s27cPmzZt4rf5+OOP8cEHH+DDDz9EVlYWdu3ahddffx27du1qd9y1a9eipqaGf9y4cUPS9+EunC+swT+P5wEANt4bB6Vc8HIgbNDiJa9vfyOdDrj7bvZhR5ULp1jfy0cJH5Vj1h8E0VMJDVBj4mANAOCvB6/ii9MiC24JPJ7FwmQy48BFVo3/rh6kuu1qWlTYO1GuF2FdtPTHe175t1PEvBzYx/t+KYLeaMKwcH8Mj+iZVSwB3ux1hF2Cd1Kd3zxtXInG5m52cYn3xyZG4cifpokTxIs0X17szkEPeY7Wgnft9sl74rpwIYIjgqCgIPzqV7/q8j/WaDSQy+UoKSmxer6kpATh4bYvSNavX49HHnkEjz/+OABgxIgR0Gq1eOKJJ/DCCy9AJpPhueee47Py3DZ5eXnYsmULFi9ebHNcLy8veHm176HeHTGbzUj94jxMZuDuERH8RS7RdezykjcagW++afm5E/iyerKeIwiHGBzqix+uluPfWQX4dxZbYi+a4JbA43nbtm3485//jOLiYowaNQp/+9vfkJSU1O726enp2L59O/Lz86HRaPDAAw9gy5YtOF/SiPL6JhTueAy3b21rr/fUU09h27ZtDr8twjYDQ9jS+twybcdiYQLXxa3U6ppxoYht9fNEoTuniHk5sI+5Fpue5B1/KwFqJYBG+0rru7iOu824Eoxd09iMUzeqAQB3DA1BxuUy+KuV4pXTizTfapHE7gC2vP7otQqcK6jFQ+NsbOCJ68KFCA7k33vvPVH+sUqlwtixY3Hw4EHMnTsXAGAymXDw4EGsXLnS5msaGhogk1lnjeVyVqSDs5drbxuTiXoxWvPZqQL8nFcFb6UcL9w93NXT6VbwXvIiltYXkPUcQTjM/nNFeP/HvDbPiya4JQAx3VrCZjwBAHh067/w8n2x/GvOnTuHu+66C/Pnz3fKe+pp9O/tA7mMgVZvREltE8IDpdGW+fl6Jcxm1r4t1AP1a5wi5iWQG5UN+Ol6FRgGvDVlTySASuvdgqPZ5TCazBgU4ouR/YKQcblMdH0lMagRqbQeAK/lcq4z5XrCLhyupS4rK8ORI0dw5MgRlJWVOTTG6tWr8c4772DXrl24ePEinnzySWi1Wl7F/tFHH8XatWv57VNSUrB9+3Z89NFHyM3Nxbfffov169cjJSWFD+hTUlLwyiuvYN++fbh+/To+++wzpKWlYd68eY6+1W5Hra4Zm79hBe5+d+dg9KHgUFT4QF7EkzFZzxGEY7ib4FZrt5bY2Fjs2LEDPj4+2Llzp83tW7u1REVFYcaMGViwYAFOnjzJ98ffe9swhIeH84+vv/4agwYNwuTJk53ynnoaKoUM/Xuz1VE5ZZ2U13eBEzmW/vgoz8vGAy1iXkCLeNetOFvMi8vGTxykkewGjCfAl9aT2J1LOXyFjZ/uGBqCED9WzLKio7ZMF9FSWt91wU2utP5iUS0MRkqydhXBgbxWq8Vjjz2GiIgI3HHHHbjjjjvQp08fLFu2DA0NDYLGeuihh/D6669jw4YNGD16NE6fPo39+/fzAnj5+fkoKirit1+3bh1+//vfY926dYiNjcWyZcswc+ZMvPXWW/w2f/vb3/DAAw/gqaeewvDhw/GHP/wBv/nNb6z66Hs6bxy4ivL6JkRrfLFsUrSrp9Pt4Erry0XMyHPWc5SRJwhhuJPglphuLbdNno7s0nooZAwmDw2x+h+7d+/GY489RuJ3EhJt6ZO/JqHg3QnLmkwe6JmBPMCKeW1/OMFm0PzQuEininmZzWZ8Zgnke6LIXWtaMvIUyLsKs9mM7y2B/OShIQi2XDtWaN0wI8+p1nexRx4AooN94auSQ9dscopgaHdHcCC/evVqHD58GF999RWqq6tRXV2NL774AocPH8bvf/97wRNYuXIl8vLy0NTUhBMnTiA5OZn/W0ZGBt5//33+d4VCgdTUVGRnZ6OxsRH5+fnYtm0bgoKC+G38/f2Rnp6OvLw8NDY24tq1a3j55ZehUnmGbcu2bdsQFRUFtVqN5ORk/uKtPdLT0xETEwNvb29ERkZi1apVVhaBUVFRYBjG6rEhJQ4V/9uOF++Ng5eiE/9QQjCSlNZTRp4gHMIpglt2IqZby9CZjwAAbhsYbFXu+Pnnn6O6uhpLliyR7H0QrQTvJLKg0zYZ8EsBW3qa7OE+57PiI3DkT9Pwr+W34Y1fj8ZSi0POvrNFKKl1nujUmZs1yCnXQq2UYVZ8zxaHDLCcM2obqbTeVVwrq0dhjQ4qhQzJ0cEI9nXfjLyYpfUyGYM43k+eyuu7iuBA/t///jfeffddzJ49GwEBAQgICMCcOXPwzjvv4NNPP5Vijj0GrncyNTUVWVlZGDVqFGbOnInS0rYiRkBL72RqaiouXryId999F3v27LGy4/vpp59QVFSEoqIiFBYWYvKzbwAAJs9MscriEOLBZeTrmgzQNYsjqMGp1vejQJ4gBOEUwS0Jac+t5a+vbwUA3BVrfVOA+37u06ePK6bbY+AE73I6U653kKz8KhhNZvQN8u4WlVhyGYPxg4Jx3+i+WHd3LEZHBqGuyYCNX5132hy4svoZseHw8+rZ7i+UkXc9GZfZbHxydG94q+R8Rt7deuRNJjMfyHfVR54jrq+lT76gVpTxejKCA/mGhoY22QQACA0NFVxaT1gjZu8kR0hICN83+VOpGVk/HISyVwTe/MPDznpbPY4AtQIqBXtoiZGVb9QbUaFl79D2CyLVeoIQAie41V6ROQNWvd4ZgltddWsZMWIE5s2bh+dTX8KF//wDZrMJ01sF8nl5eThw4ADv7EJIx0DOS16ijDzXH+/JZfXtIZcx2DxvBOQyBt/8UoyDF0s6f1EXaTaa8NWZQgDAvISeXVYPUI+8O/D91XIA4JNqGkuPfK3OgCaD+6iq1zUZwEnIBIgUyMdTRl40BAfy48ePR2pqqlX5dmNjIzZu3Ijx48eLOrmehJi9k3PmzGmzrbbJgE1fnIH2QgZmzP01+gf7SvNGCDAMg5DO7qz6+gJmM/vw7fiz4Mrq/bwU/JcvQRD20ZHgFvd7lwW37DyeW7u1cHBuLe19f9pyYrlYzGaBY8P9rbK17733HkJDQ3H33Xc7/l4Iu+AC+ZtVDe1fdAs4z98Kp9ngibZz9hDbJwCPWzR6NnxxHtomB0u87dzHP1wtQ4VWD42fCreT3a4w1fourONuNa6IY+uajTiRUwGAFboD2M9EYfkeqtSKVF4vwny5mz1qpQxqpTjtuK295E23Cs164rpwIYID+TfeeAM//vgj+vXrhzvvvBN33nknIiMjcfToUbzxxhtSzLFHIGbvZOvSeo6/fncV1zMPw9RUj7+mrpLkPRAtaETsk7/ZynqOxKsIQjjtCW5p/L2caj0HiOPW8v5ft8J7cBJmxLeUz5tMJrz33ntYvHgxFAq64Sc1IX5e8PNSwGQG8irErUbUNRtx2uItnRzt2f3xHfHM9CHo18sbBdWNSD9wRdL/tTeLLatPGdUHCrnDhk3dhpYeecrIu4ITuZVoMpgQEajGkFC2TUcmYxDshsr1nId8kLd4WmODQnzhpZBBqzfiegUJ3nUFwd/28fHxuHr1Kj744ANcusRamC1YsACLFi2Ct7fn93F5Eq17J5OTk5GdnY1nnnkGmzZtwvr16/ntskvrsfNILurP/g+33X4nBg6IdOGsewZcRl4MCzouI0/98QThOLPiI3BXbDhO5lZi3ee/4FqZFqumD3FqEA+wbi1lZWXYsGEDiouLMXr06DZuLa0z8OvWrQPDMFi3bh0KCgqgCQmBLHI0gic9bNUff+DAAeTn5+Oxxx5z6vvpqTAMg4Ehvjh7swY5ZVoMDfMXbexT+dXQG00I9ffCgODu207lo1Jg09x4LH3vJ+z88TruG92Xz9SJSZ2umbdqnNfD1eo5AtSW0nrqkXcJnFr9HUNCrBI0wb5eKKltcqs++epG8RTrORRyGYZHBOD0jWqcK6zlNUcI4Th0297HxwfLly8Xey49mq72TgLAiBEjoNVq8cQTT+CFF16ATCaD2WzGxq/Oo7GyBE15Z7Amfa/k74VoUa4vr2vnrqpOBzzCqk7jn/8E1O0LbXFCd6RYTxBdgxPcmhUfjm2HruFUfjUWJg/o+sACjmeAdWtZuXKlzb9lZGRY/c65taSmpgIADl4swbJdP6NPoBpxfQL47WbMmAGz+ZYSRUJSBmosgXx7gncC1wUHX1Y/MLjbV2FNjQnFPSMj8PXZIjz/2S/47KmJwtpc7NjH/zlXjCaDCYNCfDFCghsFnogg1XoH13G3G1fEsVv7x7dG9Iy8CPPlhO7E6o/niO/LBvLnC2pw76hW4qyeuC5ciOD6oi1bttgUX9u5cye2bt0qyqR6ImL1TsrlbP8Kd0H33/PF+OFqORrPHYAmJIR6J51EiOVkXFbfjrWO0Qh8+in7MHYsasJbz3UD5WKCcAfGDugFAMjMrxJnQAHHc1fhMovTY8O6fZDn7vDK9e0J3jm4Lk7ksr2z3bU//lY2pMTCX63A2Zs1+Mex68JseI1GpH/6KWI+/RTevXrZtOFdOisJeVvvwXd/mAqZTMZb8a5YscIJ78494QN5ezLyUp3fBI5r97qwjJv+6aeIGTlSkD1zp+tChH1RWN2I7NJ6yBhg0i16DRqxveRFmG9Lab24gTx3U+1c4S2Cd26y3jwFwYH8W2+9hWHDhrV5Pi4uDjt27BBlUj0VMXon169fj5SUFMjlcjTqjdj09UWYzSaYrmTgsaVLqHfSSYjpJX+TMvIEISoJ/dlAPqdMK56okBMwmcw4cJG1I73Vdo5wPi3K9eJZ0OkNJmRZbjD1lEA+1F+NNbPZ68r1aW8Ls+H9+GOsAZAK4GJmZhsb3sLqRgQv+n/ot+Kf+PnCNRQVFeHbb78FAMyfP98Zb88t4Urr9QaTaDa5UiLYnhlg18XatXbZMztzXXBl9aMjgxB4S7k65yVf7kY98rz1nIil9QBaecnXUjVZFxAc1RUXFyMiom1PYUhICIqKikSZVE+lq72TISEhSElJwSuvvAIAeDMjGwXVjfAru4j80kLqnXQifGm9CCdjvrSeMvIEIQpBPioMDvVDdmk9svKqrCzc3JnTN6tRXt8Efy9FtxZB8xSiNZZAvlw8saZfCqqhazahty+7RnsKC8b1x78zb2LfP/Zi8O338QmMHTt2YN++fdi5cyfWrFnT5nVHjx/HRAALAWDAAETFxmLBggU4ceIEAOCL04WQeQciKbo3xg4fCAB49dVXMWjQIEyePNlJ78798FUpIGMAk5nNyoulRi4Vre2ZATvWBcCuiwcfBHx9ERUVZbUuADZuaY2z1kV7ZfVAi1CyO/XIc4F8oMgZ+aFh/lDKGdQ0NuNmVSMie3dfPRApEZyRj4yMxI8//tjm+R9//BF9+vSx8QpCCCtXrkReXh6amppw4sQJJCcn83/LyMjA+++/z//O9U5mZ2ejsbER+fn52LZtG4KCgnC9XIu3DucAAP7f6kdgNpsxdOhQZ7+dHgtXHtXVjLzeYEJJHVsK1q8XneQIQizG9he5vN4JcGX1U4aFQqUg5W1XwwXy1Q3NqBKpsuOEpT8+Kap3j2qdkMkYbLxnGPTF2SgLGIr/ni+2PN+JDe9ttyETAFdk3dqG12w247NTNwG0iNzp9Xrs3r0bjz32WI/av7cikzHwVwvok3chDtkzA+y6+PlnAB3bM3P/wxnrwmA04Ui2tX98a7iMvHup1nNid+Kp1gOASiFDTDgrEkp+8o4j+Epg+fLlePbZZ/Hee+8hLy8PeXl52LlzJ1atWkUCeG4CJ3CnN5pw+xANZsbZFssjpEOs0vriGh3MZsBLIYPGT9yTKEH0ZPg++eueF8hPHx7q4pkQAKu63sdiadiu4J1ATuRwQnc9o6y+NcGKJsBsgtw3CC9+eR71Fm/5Dm14H3wQLwGYBEAZFGRlw3uhqBZXSuqhksswZwRbSfr555+juroaS5Yscc6bcmMCvD1Dud4he2aAXRd33dWpPTPgvHVx+kY16nQGBPkoMbJfUJu/i94jLwJcj7zYGXkAiO/TTp88YTeCA/nnnnsOy5Ytw1NPPYWBAwdi4MCB+N3vfoenn37aqn+bcB0HL5bi0OUyKOUMXrw3rkffdXYV3Mm4sdkIbZPjd7tvVpOHPEFIwdgoNpA/c7MaeoPJxbPpnNxyLbJL66GQMZgSQ4G8u8AJ3l1rT/BOAAajCZl57I2lpB7SH2+LsAA1imp0+H//u9zpthnff4/NAN4EkHXkCPbu3Yt9+/Zh06ZN+PwU6x1/5/BQPgh59913MXv2bKogBRCg7r5e8hkAuy7+8hdkZWVZrQtbOGtdcP3xkwZrbLozuKOPvFSl9QAQ17elT55wDME98gzDYOvWrVi/fj0uXrwIb29vDBkyBF5eXlLMjxCIrtmIjV+fBwAsmzQQg8ib0SX4eingo5KjQW9EWV0TfL0cExkkoTuCkIaBGl/08lGiqqEZF4pqMToyyNVT6pADlmz8bQODJbmgIhxjYIgvjmSXt69cL4ALRbWobzIgQK3AsPCAzl/QzeBseOfH+eOdfGDX0euYN6Zvxza8mzbhEQCPA0B8PEYkJ/M2vHFr2dZErqw+Ly8PBw4cwN69ZMMLtArkde5dWu+QPTPAroslSwBfX5v2zBzOXBeHr7Jl9bb64wEgmMvI1+thNpvdIoEjldgdAMRbLFTPFdS4zfv1NBxusvPz88O4cePg7++Pa9euwWRy/4xGT+Ctwzm4UdmI8AA1fjdtsKun06MJ6Ui0xMcHqK9nHz7t976T0B1BSAPDMHx5/c/XK7s2mJ3Hc1fgyupJrd694AXvbCnXC1wXXFn9uKjewrzUuwmcDW/xxZ9x3+g+MJmBNZ+e6diGt6kJslWrrPaxXC6HyQyU1ukQ5KPkK1jee+89hIaGkg2vBb60vrOMvFTnNzvHFWzP7OODhtGj2XXRatxb7Zk5BK2LLuyLSq0eZ29WAwDuGNJOIG/pkdcbTeLcYBHhs2uxn3O8vbM968DhEQGQyxhUaPUoqW3i55y+dStihgyBt0YjnnWgE76nXYHdgfzOnTuRlpZm9dwTTzyBgQMHYsSIEYiPj8eNGzdEnyBhPzcqG/BmRjYA4IW7hzucBSbEoUPBO4YBfH3ZRwd3IDkP+X6UkScI0UmwBPJZXRW8s/N4dgSjyYz/nS/GT5abDVNibF8AEq6BK63PtaVcL3BdcEJ3PbE/noOz4R1Skwmv+iL88P6rqKqp69iG9//+Dx999RVyr1/nbXgHjL4djEyOe0ZGQKWQwWQy4b333sPixYvJhtdCS0a+k0BeqvObgHEF2TMzDFLuu49dF3v22LRn5hC8LrqwL45kl8NsBoaF+yPcoq1xK2qlHP6Wa/cKMZTrRfjsulpa35F1oFopxxCLOwcnePfhv/6FNRs2IPXFF8W1DpTwe9qV2H02e/vtt/Gb3/yG/33//v1477338I9//APDhw/HypUrsXHjRvzf//2fJBMlOmfT1xfQZDBh/MBg3DOyrUUg4VxCuEC+CyfjAiqtJwjJ4JXr86rcsqxv/7kibPzqAopqWjIRv377OFJTYjErns7x7sBAS0Y+r6IBRpPZ4Uy6yWTmb9b0ZGtBzob3z5s3obCoGDJNFPo8uBEGL7YE1x4b3tlz7kZGwJ0AgHlj+gEADhw4gPz8fLLhbUWAt2eo1gPi2zNzOHNdfN+B7Vxrgv1UqGsyoEKrx0AX37fVNRvR2GwEgDae9/bSmXVgXJ9AXCquw7nCGkyPDcPRo0cxceJELFy4EADcyjrQHbE7I3/16lUkJibyv3/xxRe47777sGjRIiQkJGDz5s1WZS+Ec8m4XIr/XSiBXMZg430kcOcO8KX1tjLyTU3AkiXso6n9QJ/LyPcN6j5lQAThLoyKDIJCxqCktonXo3AIO49nIew/V4Qnd2dZBfEA62Tx5O4s7D9XJMr/IbpG3yBveClk0BtNuFnVYP1HAevickkdahqb4auSI65Pz+uPbw1vw6vT4b4N78McMgQbPj8Hs9nc1obXaERqbi6yJ01CY3U18vPzMfs369Ak88aAYB8k9A8CAMyYMYNseG/B7oy8BOc3R8a12565qQmKxx9n18X5823smVsjeF04uC/MZnNLIN9OWT1HS5+8CPu6i58d13YhY8BXCgjBHuvA+L5cnzwreDdh3Dhk/vADTt59N9DUJJ51oFTr2MXYHcg3NjYiIKDly+Xo0aO44447+N8HDhzYrg0EIT5GkxnHrlXgi9MF+P5KKV78khW4WzIhCkPD/F08OwJoVVpv62RsMAC7drEPg+274UaTGYXVlJEnCKlQK+W8am6XyuvtOJ6FYDSZsfGrCzDb+Bv33MavLsBosrUF4UxkMqZVn/wt5fUC1sWJnAoAwNio3lDIHZYv6lbIZAxemRcPpZzBwUul2H/OxjWmjX2816JWP3d0X0pqdIDdPfIin988dtwujH2puA6ldU3wVsqRaHFMaQ+uT75cDOX6Lu4Lrqw+wFsJmQPVRvZYB8bzyvVsaf3CBx7AS83NmPTNN1D6+YlnHSjlunAhdn9bDBgwAJmZmQDYD+b8+fOYOHEi//fi4mIEBgaKP0OiDfvPFWHS1u+w4J3jeOaj03h050+4XtEAf7UCz04f4urpERa66iVfWqeDwWSGQsYgzJ9cIQhCClqX17sLJ3Mr22TiW2MGUFSjw8ncLor0EaLABfLXbAne2clJvqy+5/bH22JImD9+O3kQACD1y/OdZo9L63Q4cpXNfM61qNUTtvEU1fruwGFLNv62gb2hVso73JbLyNsUSnYy1ZxivYROKcMjAsAwQHGtDmV1TR1aStqip1tK2h3IL168GCtWrMCmTZswf/58DBs2DGPHjuX/fvToUcTHx0sySaKF9sotAaBOZ8CP2eUumBVhC43FD7TMwbuqXH98eKCaMjQEIRFcduTn6+4TyJfWtR/EO7IdIS0DQ9hA3qbgnR2YzWb+pgwF8m1ZMXUwooJ9UFrXhNf/27G3/JenC2EyA2P6B/E3WAjbtPTIdz8feXeDK6uf3El/PACEuJGXPKdYH+jjmGK9PdaBfl4K/lg9X1hjZSk5Ij4e8+bNw+bNm7Fly5Y2DmmcdeDjjz/u0Py6A3ZHB3/84x+xfPly7N27F2q1Gp988onV33/88UcsWLBA9AkSLXRUbgkADKjc0p3osEfeDlr646msniCkgrOgu1TMeni7A6H+thWNHd2OkJaBGlZ12VEv+WtlWpTX6+GlkGFEP6psvBW1Uo5X5o0AAPzzeB5OddAG85mlrH4eZeM7JUBtKa3vrEee6BLaJgN/o7gzoTugVY+81vUZ+a4q1ttrHRjfhz3vnS+sRUNjY5vgVBTrwG6K3YG8TCbDSy+9hFOnTuE///kPhg8fbvX3Tz75BMuWLRN9gkQLVG7pWfCl9fVNbU4+9nCTFOsJQnLCAtToG+QNkxk4nV/t6ukAAJKieyOiHXsigL1pGxGoRhJlb90CLiOfU+5Yaf2JXLY/PqF/L3gpOi677alMHKzB/Ql9YTYDa/f+gmajqc02V0vqcL6wFgoZg3tG9swyWyF4kmq9J3M8pwJ6own9ennbVSUS7Cdij3wXqW5g59CV0np7rAOv7nsLANsnnzJ7NrYD+AiwspTssnVgN4XqdT0IKrf0LDixO73B5FAPGhfI96OMPEFIClde7y598nIZg9SUWJt/4+SGUlNiHbY6I8SFy8iX1DY5VNVxIof84+3hhTnD0ctHiUvFddh5JLfN3786WwgAmBITit6+jpUC9yT4QJ4y8pLSuqzeHvHFYF8RVeu7CJeRD3LQeg5grQNff/11bNiwAaNHj8bp06fbWAcyjdUAgHOFNVj3pz/h9wDWAYhNTMSyZcswc+ZMvPXWW1bjkqUkCwXyHgSVW3oWaqUc/pbSNUcE77jS+n69yHqOIKSEK6/P7IpyvcjMio/A8Ii2DiThgWpsfziBfOTdiEAfJa80fV1gn3zr/niqsOiYYD8vPD+HrQb9y4EruFFpbff39Rk2kKeyevvgSuv1BhN0Fq9wQnwO2+kfz8HpK1VoXZ+R72ppPUdn1oH/2v1PAMCNykZo9WakAsgG0FheLp51YDel59YieCBcuWVxjc5mnzwD9iKPLgbchxB/L9TpDCivb8LgUL+WP/j4AKWlLT/boMDiSUyl9QQhLQkW5fpTeVUwmszCM912HM9CadAbcK2UDQpfnz8KSjmDUH/2/E6ZePdjYIgvKrR6XCur5+2U7FkX+ZUNKK7VQSln+HVItM8DY/vh31k3cTynEuu/OIf3FieCKS3FT7mVyPn3VfirFbhzeKirp+kR+KoUkDGAycxm5dtVU5fg/OaR4zowdn5FA65XNEAhYzBhULBd/4Lrka9uaEaz0QRlV8SOu7gveLE7CVXrufH79/ZBfmUDzlc3Y4KnrQsXQhl5D6J1ueWtl3FUbume8F7yt2bkGQYICWEfNkqtzGYzid0RhJMYFu4PX5UcdU0GXC2tEz5AJ8ezIxy71tJX+auEvrhvdF+MHxRM53c3xabgnR3r4oQlGz+qX1CntlQEwDAMXpk3Aiq5DBmXy/DV2SIcq5Xh/52qBBgGs+LDaT/aiUzGwF9tR5+8BOc3Kcc1moFjtTJ8UaDHsZxKcQWgBc75sMUKMWFAL35fd0aQt5I/z1d2NSvfxX3M2885qFovhPi+AQCAXwprPWq9uRrBgfyhQ4ekmAdhJ7PiI7D94QSE3yKEROWW7omjXvIVWj10zayYT0QQtUoQhJQo5DKM7h8EwH365DMusxeAU2Ls66skXEuL4J2w0nrqjxfOoBA/PDWV9ZZ/ds9pLHjnOI5bbogcvFSK/eeKXDk9jyLAu3sp1+8/V4RJW7/DgneO45mP2LUxaet3LlsThy/bbzvHIZMxvMaDq73kxSqtt4c4i3L9ucJayf9Xd0Jwaf2sWbPQr18/LF26FIsXL0ZkZKQU83ILtHot5Hr77+x6KbygkLG71GAyoMnQBBkjg7eyJaOq1Qu3p1HJVVDK2YPIaDLi9qEB+N/q23Dupg6ldTqE+qsR308NGSNsfKVcCZWcPVmYzCY0NrMZYF9Vi6pmY3MjTOa26rAdoZAp4KVgA1iz2YyG5oY24+oMOhhNwnqy5DI51IqWoJZ7rz5KH/5Ct8nQBINJmNhQe5+Rt9IbMoa916U36tFsFPZFxzAMQiwZ+fL6JjQ0N8BsNkOtUEPebABWr0YzjNC/uhnw8rJ6bXZpNUzQIdRfBYNJB8MtN2VtfUa21p9QbH1Gt64/nUG4mKKtz6i99ScEW59Re+tPCGqFGnIZe+w3G5uhN+rbXX9CcNY5QmfQgWEY+Chbyse49SeEnnSOiO/rhR+ydTieU4i5YzRWf+v0HNHUBP3qZ9AME/Dqq22O5/Zo7zPyknsh4wpbAjhpcC+H1gSdI1icdY6ICGJghh45ZS3K9dq6SmDNGvaXdtbFsdybMEGHEZFqaPVaOkdY6OwcMSjEF2boIWtuwtrD7wMAtk5eggqtEr/ZfRRv/Ho07ooNbzOuJ15H2PqMbH1HCcVX5YsAtRJAI8rqaqHVq2yfI5qaOl3Ht47L0eE5QuC4nZ0jvvmlAE9+cBxKQzNeaLUmCmt0Ha4JQecIAXOWQYVj18oBABMGB7ExhZ3XEYE+RpTU6XCzugpRGutQTdA5QsB8bX1GlVo2qObE7qQ8RwwKU8AEHS5cvwHtiu2dzlnwdYSd+8IdzhFCzvGMWeAnUl5ejn/+85/YtWsXzp8/j2nTpmHZsmWYO3cuVKruoRJaW1uLwMBAYA0AAcnQjx/4GPPj5gMAPjn/CR789EFMHjAZGUsy+G1C/hyC8oZyQfP5++y/Y0XSCgBAxvUMTN01FbEhsTj/1Hl+m7g343Ch7IKgcVMnp+LFKS8CAM6Xnkf89nhofDQoe66M32bK+1NwOO+woHGfSnwK2+7eBgAo05Yh9HW2X82c2rLU5n8yH59e+FTQuA/EPoBP5n/C/85sZA+o0j+UIsSXvdu5Yt8KvPnzm4LGbe8zOvfkOcSFxgEAXsx4ERsPbxQ0bmxILJ4a/gX+/N/LmD+2H74pW4gLZRdwaPEhTAkZB/j5Yds4YKVA+8v2PiNb608otj4jW+tPKLY+I1vrTyi2PqP21p8QDi0+hClRUwAA205uw8r/rGx3/QmBzhEs3e4codXixXv8sHGKoGHb/Yx23/cNXvjIBJVchifvuYrV/3tG0Lh0jmjBmecIH+NEDMA6nN84EwzD0DnCgtjnCKPJjElbv8PZxlQ0yH8UNK4nXkfY+oxsrT8hcJ/RgreP41hOBfz7vYJzFcc89hxhNJmRsGUnzhoeFzyuVOeIbXd9jte+VCDYV4WlMy7jd/t/53HXEV7oj/DGN/HtqjswJMzfY84RHB51HYFW5wgdgFeBmpoaBAQEdDiu4NJ6jUaDVatW4fTp0zhx4gSGDh2Kp556Cn369MHTTz+NM2fOCB2SILotrTPyBEEQ9nD6RjUAVuBUJad+X0+BAdCgN6Kkls73UnIytxJFNWSzKwZcab3BJKxiwt04mVuJMje7zjp9swYAcPsQjce2R3HLwhml9YRjCM7I30phYSHefvttvPrqq1AoFNDpdBg/fjx27NiBuLg4sebpVLiMfGFZYad3QlpDJXEs7lg22xFSlsQdv1aHx97/GfF9A/Dxb8e2lMQ16gA/PzTLAH15CeDra/Xal78+jw9O3sDjk6Lx+xkxbcamslkWKq1noXMES1fPEff+/Qiultbjr78eg7tiw/jnOz1HaLXQB7LHM0raHs/t0d5n9MQ/zuDH7Cqsu3s4Fk+IdLhsloPOEc45R8x+40fkVzTjw8eTMWGwBtqqUsDilWxrXWz48hd88nMBHpsYhedmDgNA5wiOjs4RX5wuwDMfnYYZeqj1Dcj6+8MAgISVu9Goajn+//zASNwzso/VuJ54HSFlaf1zn5zBJ5k38exdA7D89mjb5wittsN1bGtcjg7PEQLH7egc8cXpAjz9URbM0MNbrxO0JgSdIwTMef72n3ChSIu/PDQK94wME3QdseWbi/jH8TwsmxSFP8wYZvU3QecIAfO99TMqqavDbVsOQgY1Lm2aBbVSLvk5YsWHWTh2Np///Dqas+DrCDv3hTucI2pra9EnpI9dGXmH7Oeam5vxxRdfYOfOnfj222+RmJiIv//971iwYAHKysqwbt06zJ8/HxcuCCu/cDd8Vb5WC0IICpkCClXb3evoeBxymdzmGK1P9I4gY2Q2x2296ByBYRib47Y+SBzF1rheCi94wb7+VCHjquQq/kQkhBA/9ku7rK7J5mekNAFKlS9wy/8sq2MggxrRmuBO14ytz6i99ScEW59Re+tPCLY+o/bWnxBsfUbtrT8hKOVK/sutNV0dl84RLO50jkiO7oNrpfm4UNiEuaPb/xxsniOM7AM2jmd78VH6oFFvxE/X2UzO5KEh7a4/IdA5gkXqc8SQkF7IryjFtXItJgzWsONycZuNdXHqug4yqHH74H4250DnCJZbP6NQf3bdMVBBBhN8LftYBjVkrfoh+/fq3em+8oTriNbYvI7owjkiwJJp1ekVbebMr79mdLiOO6LDc0QXxr31Mwr1V4OBDAzUkAEOr4lOzxF2zrmsrgkXithA7fYh7Z/H25tLn6AgyFCCusa2n0trOj1HOLiP5TI5DAYVZFDDWynnnSCkPkeM6ReOE2dL+c/P3jnbdR3h4L5wxTnCqLI/iSG4tP53v/sdIiIi8Jvf/AZDhw7FqVOncOzYMTz++OPw9fVFVFQUXn/9dVy6dEno0ATR7eBU6yvq9TAJsEC5WcXesexHHvIE4TTGWny8XalcfyynHHqDCX2DvDE41M9l8yCEE61hL8xaC961R2mdDjnlWjAMkBhFivVCSIrujYhAdRsbXg4GQESgGknRtF87I4Czn/Nw1frO1gTg3DXxg8V2Lq5PAG9DLASNL3ft6Lp2AWcq1nNwFnQcJ3IqxLUP7IYIDuQvXLiAv/3tbygsLER6ejri49uKz2g0GrKpIwgAwX7snV2Dycz7cdoD5yHfjzzkCcJpjB3ABvK/3KyBrllYWb9YcLZzk8l2zuMYGMLeeMm1w4LupMUubXh4APWfCkQuY5CaEgsAbQI37vfUlFjei5toH95+TsD1iTvSek20hzPXxPdXLOdxAbZzreGuHSu66iPfBaob2f/NKdY7g1utmpe895NL7QM9AcGBfGpqKubPnw+vW2T7DQYDvv/+ewCAQqHA5MmTxZkhQXgwSrkMvSwnQXu95Gsam1GnY3tv+lJGniCcxoBgH2j8VNAbTThfWOP0/282m1v84x28ACRcB+8lX2Z/IE9ZY8eYFR+B7Q8nICzQ+lo0PFCN7Q8nYFZ8hItm5lm0ZOSF9fu6I7PiI7AgqX+7f/dSOkc41GQy4/urrGL8HQ4H8i3VnK6iusG5Gfn954qwdu8vbZ4vrtHhyd1ZFMy3g+AGualTp6KoqAihodZWDDU1NZg6dSqMRtdkMQjCXQnx90JVQzPK65sQA3/2SW9vIDe35edWFFjK6nv5KOHTxR5WgiDsh2EYJPTvhf9dKEFmXhXGDrAzyOrgeBZCbrkW+ZUNUMoZTBis6fwFhFvBBfI3qxrQZDDCq4N1cSKHDeRvG0iBvKPMio/AXcNmI2tKFsq1Tdg5ZBCSBmkoEy8Arke+w4y8SOc3Z4ybXVYPnVKFrdu/wZj+vbBzyCAcuFyKd49cx8tfX8CkwRoo5YJzmILmfL6wFpVaPfy8FEiwtGsJJdiXzciX1TfBbDY7Xp3VhX3szNJ6o8mMjV9dgBmATqnCpN++C1h+NoOttNn41QXcFRvu+PEt1Tp2MYKjhPYWVEVFBXztVOoliJ6Exs8LV0rqrTPyMhkQFWVze76svlfXREUIghBOYhQbyP98vQpP3GHnizo4noXAZePHRfWGnxfdxPM0Qvy84O+lQF2TAXkVDRga5m9zXVRp9bhcUgeA/awJx5Er5EiYPMbV0/BYAtSW0vqOeuRFOr9JPW5BdSNO5laCkcnwyK+noI+lNTG2XxA+O1WIa2VafHA8D0smRjv+T+yY8+ErpQCA8YOCoVI4dtOA66vXG0yobzLAX+1gMN2FfcwF8s4orW9tKWlmZLgZGGb1dzOAohodTuZWYvygYMf+iVTr2MXYfaVw//33A2AzFkuWLLEqrTcajTh79iwmTJgg/gwJwsPhBO/sLa0vqGItNPpSfzxBOB2uTz4rv6prmRAHyLD0VU6JobJ6T4RhGESH+OLszRrklNWzgbwNTl5ns/FDQv34ElqCcAUtGXnPL63/8nQhACApqjcfxANsRvn3M4bihc/O4S8HruK+0X3Ry7dr7gEd8f2VrpXVA4C3Sg5flRxavREV9XrHA/kuUN3A9chLt684Suvssyy1d7uehN23igIDAxEYGAiz2Qx/f3/+98DAQISHh+OJJ57A7t27pZwrQXgk3J3V8tbqo3o98Nxz7ENv3QPFZeSpP54gnE9cn0Co5DKU1+uRV2Gnv3gHx7O9NOqNOJ5TAQCYEhPaydaEq9i2bRuioqKgVquRnJyMkydPWv19IKdcX64F9HqkT5uGmN694e3tjcjISKxatQpHLrG9nsmWsvqCggI8/PDDCA4Ohre3N0aMGIGff/7ZuW/MUxHh2OvJ8IF8Rxl5qfaxyON+cboAAHB/fEibcR9KjMSwcH/UNDbjjYNXJZtzra4ZWfms68nkIV27Icv3yWu7oFzfhX3szNJ6zlISAJTGZqw9tBNrD+2E0tjc7naC6abnCrsz8u+99x4AICoqCn/4wx+ojJ4g7MRmRr65GXj9dfbnF18EVC13PPlAnjLyBOF01Eo5RvQLRGZeFTLzqhClseO7roPj2V6O51RAbzChT6AaQ8h2zi3Zs2cPVq9ejR07diA5ORnp6emYOXMmLl++zOsGccr1OWVafPjBB1hz6BB2Aphw/jyu3LyJJUuWQH26EEh+FEnRwaiqqsLEiRMxdepU/Oc//0FISAiuXr2KXr0c663tcYhw7PVkuNJ6vcEEXbOR9wu3Qqp9LOK4l4prcam4Diq5DLOGatqMq5DLsOGeWCz8vxP45/E8LErujyHtVMx0Zc5HsytgMJkRrfFF/+CutUcG+6mQX9mA8q4I3nVhHztT7I6zDyyu0UFhNOI3J/cCANInLkSzXAkGrJBll8RBu+m5wiHVegriCcJ+Qix3Vcvs9APlPOQpI08QroErr8/Md56ffMZltq9yckwo2c65KWlpaVi+fDmWLl2K2NhY7NixAz4+Pti5cye/TYtyfT2OHj+OiQAWAogaMAAzZszAr+Y/hMLscwCA5Oje2Lp1KyIjI/Hee+8hKSkJ0dHRmDFjBgYNGuSCd0j0NHxVCnDaYZ7sJf/5KbasfkpMCALb6emeMFiDu2LDYDSZ8fK+i5LM43uLf/wdQ7ouVhrs61rl+mon9siTpaTj2BXIJyQkoKqKvaAZM2YMEhIS2n0QBGGNRnCPPCd2R4E8QbgCTmk487oTA3nqj3dr9Ho9MjMzMX36dP45mUyG6dOn49ixY/xzAzWWjHy5FhNuuw2ZALji+5ycHHz59T54D0xEVLAPwgLU+PLLL5GYmIj58+cjNDQUY8aMwTvvvOPEd0b0ZGQyhu+/9tQ+eZPJjC8tZfVzx/TtcNsX5gyHUs7g8JUyHLLcPBULs9nc4h8vwnlcY/GSL7czCSQ2tU4srQfat5QMDfAiS8kOsKu0/r777uPF7ebOnSvlfAii2xFiq0e+HRr1RlRo2buv/YJItZ4gXAGXkb9SWoeaxmbJL2Ryy7XIq2Bt5yaS7ZxbUl5eDqPRiLAwazXlsLAwXLp0if89SsOet6sbmjHr7rl4CY9hEgBzUBAMBgOS5jwEZsSDSI5mlZdzcnKwfft2rF69Gs8//zx++uknPP3001CpVFi8eLHT3h/RcwnwVqCmsdljM/I/Xa9EYY0O/l4KTBsWCujbF0SL0vhi6cRovP19jjh2dK3IKdfiZlUjVHIZbhvooLJ6KzS8l7xrAnmutD7I23kl6LPiI3DXgCnAiy3P/WnmMAriO8CuQD41NRUAq04/depUjBw5EkFBQVLOiyC6DVyPfKVWD6PJ3GFpENcf7+elQIA32U8RhCsI8ffCgGAf5FU04PSNakzugvqwPRy2ZIYSB5DtnKfjo1KgT6AahTU6/Ps/32IzgDcBJB85guzCQixa9luoahVImv8qAMBkMiExMRGbN28GwFY9njt3Djt27KBAnnAKAWolgMaOveTdmM8tavWz4sPZHv9OKtFXThuMf2fexLUyLXYfz8PSrtjRtYLLxo+L7gUfVdfP48FcRl7rqtJ6TrXeuYr5t14jZ1wpw/1j+zl1Dp6EoNtQcrkcM2bM4MvsCYLonN6+KsgYwGTuXH30ZivrOeqTJQjXMZYvr6+U/H9RWb37o9FoIJfLUVJSYvV8SUkJwsPDrZ7jBO/S0l7DIwAeBzAiPh4z706B/6RHUHv8U4yLCgIAREREIDY21ur1w4cPR35+vlRvhSCsCOBK63WeV1qvN5jwzS+sC0RnZfUcAWolfj8jBgCQfuAqqkQKlA9f4frjxTmPB7swI69rNkLXbALQ4mzgKg5fKYPBaHLpHNwZwfUk8fHxyMnJkWIuBNEtkcsY9Pa1r0+ey8hTfzxBuJaxUc4RvNM1G3HsGtnOuTsqlQpjx47FwYMH+edMJhMOHjyI8ePHW23LCd7V1WutLrIy86pgggwM0+JKMnHiRFy+fNnq9VeuXMGAAQOkeSMEcQtc9Z8nZuQzLpeiprEZof5egsrZHxrXYke3aPXGDi0lbyUdQAwAb42Gt5SsrtPy9qF3DA0RxVJSY/G6d4XYHbcWZAzg78IqsUAfJWoam3HqRrXL5uDuCP50Xn75ZfzhD3/Apk2bMHbs2DYK9gEBAaJNjiC6Cxo/Fcrrm1psRLy9gXPnWn62UECK9QThFnB98qfzq2EwmqDoqI+ynePZHo7nVKDJYEJEoBpDw8h2zp1ZvXo1Fi9ejMTERCQlJSE9PR1arRZLly4FADz66KPo27cvYu55AgAQNmIStpfcwJjUVCQXF2P3p4dR/cNuDB47GXI5a/O1atUqTJgwAZs3b8aDDz6IkydP4u2338bbb7/tsvfpUXTh2CNYWjLy7QTyUu1jEcb9wlJWf++oPi0l2XaMK5cx2JASi/tW/xn/2ZeGza//FffNmGzTUrI1H372GdaoVNi5aRMmPPAArmRnY8mSJSis1kEXdg9C/b0Q5mVAQkLXLSVbfOS7EMg7uI+rWwndyZytFN9qzred0eHzs8X47lIpxkV1wXrulnG707lCcCA/Z84cAMC9995rVfprNpvBMAyMRqN4syOIbkKIvxcuFde1ZORlMiAurs125CFPEO7BkFB/+HspUNdkwKXiOsT3DWx/43aOZ3vIuNxSVk/tNO7NQw89hLKyMmzYsAHFxcUYPXo09u/fzwvg5efnQyaTYZaltD5w4q/x+zH9sO6tt1CwYQMY70CooxPxp1e28GOOGzcOn332GdauXYuXXnoJ0dHRSE9Px6JFi1zyHj2OLhx7BAtXOt2uar1U+7iL49bpmnHgItvqYlVWb+e4EwZpwJzbB/9RM3HBPwFrhg/Hjh07sG/fPuzcuRNr1qxp85qjx49j4qRJWPjHPwIAogYOxIIFC/Dp/kNgUu7BHUND8Nprr/GWkhzR0cL78Lke+aoGfec3k9vDwX1c42TFeitazXlqcwEbyF8sxZ9mDRNt3O6E4ED+0KFDUsyDILo1nOBdZ8r1lJEnCPdALmMwZkAvfH+lDFn5VR0H8l2A66ucPJTK6j2BlStXYuXKlTb/lpGRAQC4UclqndyobsK6TRuQmpoKXbMRI1/8H/RGE6aOHGj1unvuuQf33HOPpPMmiPboNCPvpuw/V4wmgwmDQnwR10d4NbBer0dl3iWEjpmHH66W49DlUkwbFtbGUrI1EyZMwO7du3Hy5EkkJSUhJycH33zzDVQDJ6EZbFn9mtQvMXPmTMyfPx+HDx9G37598dRTT2H58uWC5tfLp0VfqbJBj1B/teD36CicYn2gj/MU620xeWgIZAxwuaQOBdWNlOSygeBAfvLkyVLMgyC6NZwFHZ+R1+sBi0oxnn8eULEny5tVlJEnCHdhbH82kM/Mq8Kj46Pa37Cd47kz8iq0yC3XQiFjMHFw1+2KCPegb5A3vBQymJqaULfmBQT5qHDm17+B3mhCqL8XooLJWlQ0HDz2iBY67ZGXah93cVyurH7u6L7W1Ux2jstZSt43IRb/KQVe/voibh8S0sZSsjULH3gA5f/8JyaNHw+zTAaDwYBHH3sch0PmgmGA2wdrRLOUZPWVVCiv16Oi3sFA3sF9XN1gUax3RUa+1ZyDnn8eCf174ee8Knx3qRSP3NYF7ZBueq5wWMGgoaEB+fn50OutezdGjhzZ5UkRRHeDy8jzgXxzM7BxI/vzc88BKhX0BhNK6lj/03696EKPIFwN1yf/8/VOBO9sHM/2wJXVJ0b1gr/atcrAhHjIZAyiNb7Iy29A0F/YMvrMxHkAgKTo3tRCISYOHntEC52q1ku1j7swbmmtDkevlQMA7ht9i1q9wHF/ldAPPx3RIadci38cy+tw24yDB7F5/37WUvLoUWQXFmL5kythGNKIyb9+Er18VaJaSgb7evGBvEM4uI9dWlp/y5ynDQ/Fz3lVONTVQL6bnisEN1yUlZXhnnvugb+/P+Li4jBmzBirB0EQbbGntL64RgezGfBSyKDx6x4nGILwZEb3D4KMYbUrimt0oo+fYfGPJ7X67genXM/xcx5rY5gsQFmbIJxBS4+855TWf3mmECYzkNA/CP0drHDhLCXrqyt4O7o3DlxBfkFRG0tJjvWbNllZSs6bNw+j738Stcc/xe2WqioxLSW5PvnOrIvFhgvkne0hb4tpw9jvx6PXyqFrJh22WxEcyD/77LOorq7GiRMn4O3tjf3792PXrl0YMmQIvvzySynmSBAej+bW0nob3KwmD3mCcCf8vBQYFs72XmbmiWtDp2s24lgOZztH/vHdjWiNdSB/Kr8aAJAc3UXlZYIQmQC1pbTeg3rk+bJ6O73jbdHaUvLBxEgMjwhATaMe3/z3f20sJTkaGhutAiejyYwrpVoAwB1D2EBeTEvJYDuuHaWA65F3SWn9LcSE+aNPoBq6ZhNv1Uq0IDiQ/+6775CWlobExETIZDIMGDAADz/8MF577TVs2bKl8wFuYdu2bcL8G9PTERMTA29vb96/UaezzpSI4d9IEGLCl9Z3kJEnoTuCcD+48nqxA/kTuZXQNZsQHqBGTJi/qGMTrmegxtpKUNdsQm9fFYaEksUg4V5wbT3tqta7GdfK6vFLQQ3kMgZ3j4jo0lirV6/GO++8g93//AceHaZA5X/fhLZei9vvng+AtZRcu3Ytv33K7NnYDuAjALnXr+Otf32GooO74B+TjIQBbCC/atUqHD9+HJs3b0Z2djY+/PBDvP3221ixYoXg+Wn4jLxzveS5jHyAGwTyDMNgqiUrf/BSiYtn434I7pHXarW8t2KvXr1QVlaGoUOHYsSIEcjKyhI01p49e7B69Wrs2LEDycnJnfs3fvgh1qxZg507d2LChAm4cuUKlixZAoZhkJaWBgCoqqrCxIld928kCDHhxO6qG5qhN5hgq3CeE7rrR4E8QbgNiVG98M/jecjMFzeQbymrJ9u57sitpfUAkBRF/fGE+8GL3XlIRv6LUwUAgDuGaPiMtaPcaikZ1G8I/B58CTtOlmNC/EDeUpJj3Z/+BGbLFqwDUJCYCLV/L6ijE/DAb//A28OJaSnJVXNWdOJ4JDbVfGm9e7R5ThsWig9O5OPQpTLe7pxgERzIx8TE4PLly4iKisKoUaPw1ltvISoqCjt27EBEhLA7Y2lpaVi+fDmWLl0KAJ37Nx49iokTJ2LhwoUAgKioKCxYsAAnTpzgt9m6daso/o0EISaB3kooZAwMJjMqtE2IsHHkkYc8QbgfCf3Zm8DnC2rQqDfCWyUXZdzDrfzjie7HwJC2mfckKqsn3BAu66o3mKBrNkKtFOccJwVmsxmfi1BW35rWlpL5FQ2YnnYYP1wtx3eXSnlLSQ6FQoFUAKkAUF6OebtO41R+Ne4aLY2lZLCvJSPvqNidg9S4UrXeBhMGaeClkKGguhFXSuoRE05VbByCS+ufeeYZFBUVAQBSU1Pxn//8B/3798df//pXXqHRHvR6PTIzMzF9+vSWychknfo3ZmZm8uX3nH/jnDlz+G2+/PJLJCYmYv78+QgNDcWYMWPwzjvvdDiXpqYm1NbWWj0IQkxkMoa/s1peZ/uETKX1BOF+9OvljbAALxhMZpy9WS3KmPkVDcjhbec0ooxJuBeB3kr09rW+CE6MospAwv3wUynAJTjdPSt/6kY18isb4KOS467YMNHH7x/sg8cmscm/V/ZdhN5ganfb6gY9ztyoBsD6x0sBV3FQ7qLS+kA3ELsDAG+VHBMGsa0L310qdfFs3AvBGfmHH36Y/3ns2LHIy8vDpUuX0L9/f2g09l+QcP6NYWHWB2KH/o0LF6K8vByTJk2C2WyGwWDAb3/7Wzz//PP8No74N27ZsgUbOUsCgpAIjb8KxbU6lNXrgAgNwOlBqFlv0JaMPFnPEYS7wDAMxg7ohW9+KUZmfpVt1XG1us3x3BEZV9gLkbEDyHauu7L/XBHKDQzufZRt+2tSKPHEPzLx4r2xmBXftb5eohUCjz2iLTIZA38vBWp1BtQ2GhB6a7JTqn3swLhcWf3MuHD4qNoJYbo43xVTB+HTzJsWO7rrePz2Vtn2VmMfuVkPkxkYEuqHPhJVUvKq9Y6W1ju4L/jSeldk5NuZ87RhoTh0uQyHLpXiySmDRBvX0xGckb8VHx8fJCQkCAriHSUjIwObN2/Gm2++iaysLOzduxf79u3Dpk2b+G1MJhMSEhKwefNmjBkzBk888QSWL1+OHTt2tDvu2rVrUVNTwz9u3Lgh+Xsheh4hrdVH5XJg3Dj2IZfDaDKjsJoy8gThjnDl9Znt+cnfcjx3RgZfVk+2c92R/eeK8OTuLDSZZTgbMRRnI4bCJJOjpFaHJ3dnYf+5IldPsfsg8NgjbMNb0NnKyEu1jwWO22w04euz7LFz3+g+oo17K/5qJZ6bORQA8MbBq6hsnQ1vNfb311hLSamy8QCg8W2xLjabzcIHcGBfmExm3orQJRn5dubMCd5l5lehpsGBypFueq6wKyO/evVquwfkROc6g/NvLCmxViAsKSlp379x/Xo88sgjePzxxwEAI0aMgFarxRNPPIEXXngBMpmsXf/Gf//73+3OxcvLC15eXRPMIIjOaPGSb1siVVqng8FkhkLGIMyf1iJBuBOJUWxvc2Z+VZeFdnTNRhy9Vg6A+uO7I0aTGRu/ugBbl9xmAAyAjV9dwF2x4ZDLSLCJcA8C1EoAjajTua9y/ZHsclRo9dD4qTBJ4pakB8ZGYtfRPFwoqkXat5fx8twRVn83m834/gp7Hpc0kPdnM/K6ZhMa9Eb4egkupBZMXZMBJssJLNBNeuQBoF8vHwwN88OVknocvlqGe0d1cDOnB2HXijh16pRdgwm5uGnt3zh37lwAbDb94MGDvOjErTQ0NFipRwKA3HJXhbtTJaZ/I0GIiZWXvF4PvPEG+4dnnuH748MD1bzyKUEQ7kFsRAC8FDJUNzQjp1yLQbcKmd1yPEPVvtLvyVa2c8NIsKfbcTK3EkU1rCWu0tiMpT9/CQB4L/FeNMuVMAMoqtHhZG4lxg+y0aZBCEPAsUe0D69c32gj0ynVPhY47ueWsvp7Rvbp+DpJhPnKZQw2pMTi128fx4cn8vHIbVGswJpl7LK6JlQ0xsPLywvJEopY+qgU8FbK0dhsREW9Xngg78C+4LLd3ko5vBQuyFx3MOepw0JxpaQe310sER7Id9NzhV0r4tChQ5L889WrV2Px4sVITExEUlIS0tPTodVqeRX7Rx99FH379uX96VNSUpCWloYxY8YgOTkZ2dnZWL9+PVJSUviAftWqVZgwYQI2b96MBx98ECdPnsTbb7+Nt99+W5L3QBD2wnvJ1zUBzc3AH//I/uGpp0ixniDcGJVChlH9gnDyeiUyr1e1DeRvOZ47ukDgyuonDyXbue5IaZ2O/1lhNOL5DNZB559j7kazXGlzO6ILCDj2iPYJUHdQWi/VPhYwrrbJgP+dZyt4OyyrFzhuR9w2MBiz48Pxn3PF2PT1BfxzWRIYy9ihABSrPsW4gcGSq/wH+6lws6oR5dom9A8WqKHkwL6o4a3nXJSN72DO02JC8dbhHBy+UgajySysqqmbniukr9HogFv9G0ePHo39+/fzAnht/BvXrQPDMFi3bh0KCgoQEhKClJQUvPLKK/w2Yvo3EoSY8IG8DdGSm6RYTxBuzdioXmwgn1eFB8dFOjwOJ3RHZfXdk1B/+0SU7N2OIJwB3yPf6J6l9d9eKEFjsxEDgn0wOjLIaf/3+TnDcfBiKY5kl+PgxVJMH2B9E3eyhGX1HMF+XrhZ1eg0C7rqRvb/uFNZPcfYAb0QoFagqqEZp29UYewAsvS0K5C///778f777yMgIAD3339/h9vu3btX0ARa+zfeik3/xtRUpKamdjimWP6NBCEmLfZz7Qfy/XqRYj1BuCNjOcG7/HYE7+zgRmUDcsostnNDyHauO5IU3RsRgWoU19jOuDNgW6jI2aO6AgAAd+9JREFUU55wJzrMyLsBn59my+rvG93XqZVMkb19sOz2aGzPuIZXvrmIO5aPRes87uSh0p/HNb5dVK4XSLWltN4dA3mFXIbJMaH46kwhvrtUSoE87FStDwwM5A+cwMDADh8EQdjGqrT+FrjS+n5UWk8QbknCADaQzy6tR3WDY5mRjMul/FgBZDvXLZHLGKSmsIK7t4Yb3O+pKbEkdEe4FR32yLuY8vom/HCVFZab21lZvQSsmDoYGj8v5JZrsfv4df753r5KRAX7Sv7/OQu6cicF8i4vre+EacPYKojvLpW5eCbugV0Z+ffee8/mzwRB2A+Xka9rMkDXbETrwsqCqgYAVFpPEO5Kb18VBob4IqdMi6z8KkwbFiZ4jBbbOSqr787Mio/A9ocTsPXfmVbPhweqkZpCPvKE+9GSkXe/0vp9Z4tgNJkxsl8gBt6qT+IE/LwU+OPMGPzx32fx+n+v4DHL85XaZtz+2iHJj2m+mtNJpfVcIO+OGXkAmDw0FAwDXCyqRVFNIyICe/Z1M8ljE4STCFAroFKwh1zr8nqz2UxidwThAfDl9XnCy+tZ27kKAMCUoeQf392ZFR+BA6un8L+/v3QcjvxpGgXxhFvS0iPvfhn51mX1rsLPohZ/q61kcY0OT+7Owv5zRZL972BLIF+hdVKPvKXiLMjHPcXgevuqMMaik3CIsvLCA/mKigqsWLECsbGx0Gg06N27t9WDIAjbMAyDEP6E3BLIV2j10DWbAAARQSSARBDuylhLef3P14UH8j9dr0RjsxFhAV4YHkG2cz2B1uXzyQODqZyecFsC1JbSejfrkc+r0OJUfjVkDJAyyjU3wYwmMzbtu2Dzb1xgv/GrCzCabg3zxUHj59weeXfPyAPAtGHszfDvLpW4eCauR7Bq/SOPPILs7GwsW7YMYWFhZJ9DEALQ+HuhoLoRJXoGsNg6FjSyJ/+wAC/XeHYSBGEXiVFsIH/mZjWajSYoOS9jtZo/nqG2fTOObOd6IHasC6KL0D4WhQ4z8lLtYzvG/eJ0IQBg4mCN/U4PIs/3ZG4liizilU0KJX69YDP/M8AG80U1OpzMrcT4QcFd/n+3EuxrSQA5UlrvwL5wudidHXOeOiwUr//vCn7MrmBbVe2xAOym5wrBgfwPP/yAI0eOYNSoUVLMhyC6NVxGvqzRAEyZAgAo+IUtyaKyeoJwbwZq/BDorURNYzMuFNZiFGeDJJfzx3N7cEJ3U2KorL7HYMe6ILoI7WNR6LBHXuA+3rZtG/785z+juLgYo0aNwt/+9jckJSW1O256ejq2/+Y3yM/Ph0ajwQMPPIAtW7bAy8sLn58uQPWRD7B767+w+/GWl8bExODSpUu2JyDymiita3GgMMnkON5/ZKfbiUmXxO4c2BfVrha7s2POsREBCA9Qo7hWh+M5FfZ9r3bTc4Xg0vphw4ahsbFRirkQRLeHU64vr2u5s1rAe8iT9RxBuDMyGYOE/kEAhPXJ36hswLUyLeQyBhMHk+0cQRDuhViq9Xv27MHq1auRmpqKrKwsjBo1CjNnzkRpaanN7T/88EOsWbMGqampuHjxIt59913s2bMHzz//PM4V1CLHct4cHhuLoqIi/nHkyJEuzVMI9lYC2F0xIBBO7K6yQS9Z+X5ruDUQ5O2ePfIA26o61VJef+iS7bXVUxAcyL/55pt44YUXcPjwYVRUVKC2ttbqQRA9lW3btiEqKgpqtRrJyck4efJkm21CuF6n6jqkP/AAYsLC8NRdsbj55hKc+jgdOl3LHd0XX3wRDMNYPYYNG+a090MQRFsSo1gtGCs/+eZmYNs29tHc9kI44wpbVj+2fy+37jskRKaTdUGIAO1jUeBK65sMJuiajdZ/FLCP09LSsHz5cixduhSxsbHYsWMHfHx8sHPnzrYbNzfj6FtvYeKAAVg4fz6ioqIwY8YMLFiwACdPnuRF7gaG+EGlVCI8PJx/aDQd3BAVeU0kRfdGRKAaDACF0YBHsr7GI1lfQ2FkqxcYABGBaiRFS6MT1stHCYYBzGagSqj1qQP7wuWl9XbOme+Tv1wKs9mOGxzd9FwhOJAPCgpCbW0tpk2bhtDQUPTq1Qu9evVCUFAQevXqJcUcCcLtsfcuNJeRP/7fz7Hm3/9GamkpHkrdheDZT+P8kf14/vnnrbaPi4tz2V1ogiDaksAp11+varl40OuBlSvZh77thdZhS1n9ZLKd61l0si4IEaB9LAp+KgU46Y66W8vr7dzHer0emZmZmD59Ov+cTCbD9OnTcezYMVsvwITvv0fmlSs4efQoACAnJwfffPMNZs2eja/OsP3xw8L9cfXqVfTp0wcDBw7EokWLkJ+f3/6bEXlNyGUMUlNiAQAqowGbvt2BTd/ugNJoAKd2kpoSK5mYpUIuQy8fTvBO4PtxYF9UN3Kq9S4K5O2c88TBwVApZLhR2YhrZfWijetpCA7kFy1aBKVSiQ8//BAHDx7Ed999h++++w6HDh3Cd999J8UcCcLtsfcuNFcidf3SWUwEsBBAnTwI3tEJuOue+9tk8RUKhf13oQmCEBVbVTajIgMhlzEortWhsMa6JzIdQMyYMfD29kZkZCRWrVqFmnotbzt3/uv/oyobgiDcDpmMgb9X15Try8vLYTQaERYWZvV8WFgYiouLbb5mIYCXAEy66y4olUoMGjQIU6ZMwZQHf4PSuiYE+Sgxf/ZUvP/++9i/fz+2b9+O3Nxc3H777airq3Nono4wKz4C2x9OQFigl9Xz4YFqbH84QXJbyWBf5yjX65qNvItSoKsCeTvxUSlw20BWXPC7HlxeL1js7ty5czh16hRiYmKkmA9BeBzcXei1a9fyz7V3F5rLyHuFD0UmgJNg1U6bq8uR+eN3WLZksdX23F1otVqN8ePHY8uWLejfv7/Ub4kgejxclc2OHTuQnJyM9PR0zJw5E5cvX0ZcnwCcvVmDzLwqXqTyQwBrAOxcuxYTpk7FlStXsGTJEhRW69AQdg9C/b0QovdCXFwcDhw4wP8fhULw1zBBEIToBHgrUaszONVLPgPAZgBv/uUvSL7jDmRnZ+OZZ57B2UoZED0Hc0ZE4N57RvDbjxw5EsnJyRgwYAA+/vhjLFu2zGlznRUfgbsGTAFeZH9/f+k4JMZFOsVWMthPhaulQLnEXvLcZy9j2CoNd2daTAi+v1KGgxdL8cQdg1w9HZcgOCOfmJiIGzduSDEXgvBIhNyF5gJ51aAJ7F1oAD9t/RUK33oc06ZMsSqtT05OdvldaILoqXRUZdNSXl/Jb38UYKtsHnzQqtfz+IkTAFps56jKhiAId6RD5Xo70Gg0kMvlKCmx9vYuKSlBeHi4zdesB/AIgMeXLMGIESMwb948bHzpZRzb+y7MZhPmju7b5jVBQUEYOnQosrOzHZpnV2gdtCcPDHZKEA8AwX6cULK0GfnqVh7yMie9t64wbRh73f1zXhVqnHgDyp0QHMj/7ne/wzPPPIP3338fmZmZOHv2rNWDIIj24Urry66dYe9CA4ha9Bqifr0B/93/H2zatInfdvbs2Zg/fz5GjhyJmTNn4ptvvkF1dTU+/vhj10yeIHoInfV6jh1gCeRbCd5NANgqm59/BtDS66mMGgugxXZOUK8nQRCEk+iqcr1KpcLYsWNx8OBB/jmTyYSDBw9i/PjxNl/TgLaByMUStt+5b6AaiQPaam/V19fj2rVriIiQtpzdneCsiyu00gbyNbz1nPsq1remf7APBof6wWgy44erZa6ejksQXDfx0EMPAQAee+wx/jmGYWA2m8EwDIxGY3svJYhuiZC70L5eCvio5Lh+9COsAPA4gP+nGYDB0WF46O4heOKJJ/DCCy9AJmt7j82Vd6EJoifRUZXNpUuXkBjFXlxeLKqDtskAX7C9nuVgez3NZjMMBgMeXvo4fgidC7mMwaQhGsgsVTYxMTEoKirCxo0bcfvtt+PcuXPw9/d3+vskCILgaMnIO57ZXL16NRYvXozExEQkJSUhPT0dWq0WS5cuBQA8+uij6Nu3L7Zs2QIASAGQBmDMJ58gefJkZGdn4620LfAenIT7EiIhkzH4wx/+gJSUFAwYMACFhYVITU2FXC7HggULuvqWPYaWHnlpS+s5xfoAD3JXmTYsFNml9fjuUinuGdnH1dNxOoID+dzcXCnmQRAeS+u70HPnzgXQchd65cqVbbYP8fdCjkFvdRe6b5A35HI5ALRro8HdhX7kkUfEfgsEQQggItAbfQLVKKzR4cyNakyI8LbZ67n8yZUwDGnEXYueQqC3ErNnz+bHcGWvJ0EQxK1wwVtto2Ol9QCb7CsrK8OGDRtQXFyM0aNHY//+/fxN0fz8fKtExTqw9m3rNm1CwZNPIlgTAqbfKATf/ghfVn/z5k0sWLAAFRUVCAkJwaRJk3D8+HGEhPQcFxC+tF7yQN6iWO9BgfzUmFC8/X0ODl8ug8lk9oiWADERHMgPGDBAinkQhEcj5C60xs8L3oOTsK22ELq7F0JbX4nG61VYv+tVpKSk8AE93YUmCNdgT5XN2KjeKDxTiMy8KkyICsL62Fg8MmwYHv/NbwCFAiNGjMAb+3/B9zs3444XN9j8P1Rl083x8gK+/rrlZ0J8aB+LRrsZeYH7eOXKlTaTGACQkZFhNa7i66+RCiB15kxAocCHJ/Lx/Ge/YFi4P2LC2Sqljz76SNgbkXJNuGi9BftZMvJCS+sFzreltN6FgbzAOSdG9YK/WoEKrR5nblZjTP92rNC76bnCrkD+yy+/xOzZs6FUKvHll192uO29994rysQIwpMQchc6xM8LARMXIGF4ON7/6lPUVe7G172D8esH5uGVV17hx6S70AThGuypshnbPwhfnSlk++QVQ9CgVkM2eDBgUaFvMhhxtawBAHDHENuCdlRl081RKIC773b1LLo3tI9Fo90eean2sY1xPz9dAACYO6atyF1XxhUNF603jZ+DpfUC51vTSuzOZQics1Iuwx1DQrDvlyJ8d6m0/UC+m54r7Ark586di+LiYoSGhvIXNbagHnmiJ2PvXegQfy8wMjluf/C3MI7+Fc7erMHbj4zFjDjrfnrBd6EJghCNzqps/v2XtagqMCJL/ThMJjNSUlKQlpaGMWPGIDk5GV8czkTpoX8gaNhtGBnJXlhQlQ1BEO5KV1Xru0pBdSNO5laCYYB7R/W8XueOCPblSuslVq239Mh7Umk9AEwdFsoH8r+f0bPs0e0K5E0mk82fCYIQjsbPCwqjAZFffoyEwlpcGDQJfXt5u3paBEG0orMqm9qyYqCB9V3OLqzCushIMNOmYd26dSgoKICXfxDU0WOx8Ok/gWHYnj2qsulhNDcDH3zA/rxoEaD0rItjj4D2sWi09MjfkpGXah/fMu6XpwsBAElRvdEnqAvXRFKuCRetN43FurhBb0SD3gAfez3eBc6Xz8i7UrXegX08JSYEDAOcL6xFSa0OYQFqUcb1BBhze8paPZja2loEBgaipqYGAQEBrp4O0c348EQ+Nu35CRf/8gAAYPiqT3H85XsR6MqeJIIgBLPg7eM4llOB12YPwoNThrNP1tcDvr64K+0wrpbW4+8Lx/RIJV0CgFYL+PmxP1vWBSEytI9F43/ni/HEPzMxpn8QPntqYssfpNrHt4w7651MXCquw5b7R2BBUn/RxhV1TbhovZnNZgxbvx9NBhN++ONURPb2se+FAuf76M6T+P5KGV6fPwoPjO3XxVk7iIP7eO62H3H6RjVevX8Efm1r/XjQuUJIHGq3j/yxY8fwNScSYOEf//gHoqOjERoaiieeeAJNTdKWfBBEd4DrdeLw81LwvWkEQXgOnJ/8qbxqq+cLqhtxtbQeMga4fTBl2wmCcH/azcg7gUvFtbhUXAeVXIY58T3HH95eGIaBhveSl065vsYDVes5pg0LBQB8d6nUxTNxLnYH8i+99BLOnz/P//7LL79g2bJlmD59OtasWYOvvvqK94UkCKJ9Qvyt1TIjAtV86S1BEJ7DWIuf/OmbVVbPZ1xmLyQS+veiShuCIDwCV/bIf32WLaufOiyEzpntwCvXS9gn7xaq9Q7CBfJHssvRZOg5em12B/KnT5/GnXfeyf/+0UcfITk5Ge+88w5Wr16Nv/71r/j4448lmSRBdCduDeSpP54gPJMEi4jd9fIGq+czLpcBYPv2CIIgPIF2VeudwDdniwCA944n2hLsywbyUgreVbuDar2DxPUJQKi/Fxr0RpzMrXT1dJyG3YF8VVUVL/IDAIcPH8bs2bP538eNG4cbN26IOzuC6IZw5VEcfYJsiHIQBOH2BPooMSTUz+o5vcGEo9nlAIApMaGumBZBEIRguNL6JoMJumbpM5pGU4tEV1FNE/y85Jg6jM6Z7cFdO5YLtaCzE5PJ3ErszvMCeYZhMNXynXvwYs8pr7c7kA8LC0Nubi4AQK/XIysrC7fddhv/97q6Oii7iQIgQUiJWimHv7qlJ75PIGXkCcJTSYyy9qzNyquEVm+Exs8LsREklkoQhGfgp1KA6/Krk7i8fv+5IkxPy7B6zmhqaUsi2hLM9chLFMjXNRnAyZ97YkYeAKYNZwP5Q5dL0VO03O0O5OfMmYM1a9bghx9+wNq1a+Hj44Pbb7+d//vZs2cxaNAgSSZJEN2N1oJ3XbJZIQjCpST0tw7kf7Bk4ycPDYFMRtoXBEF4BjIZA38vS3m9Trry+v3nivDk7iwU11iXiDc2G/Hk7izsP1ck2f/2ZLjrxgqtNKX1NRYPeW+lHF4KuST/Q2y2bduGqKgoqNVqJCcnQ12VA5VchryKBuSUa9tsnw4gBoC3RoPIyEisWrUKOp3O5tivvvoqGIbBs88+K+Vb6DJ2S2Vv2rQJ999/PyZPngw/Pz/s2rULKlVLMLJz507MmDFDkkkSRHfDP9AXT923BgAwoZktMZPTRT9BeBxjB/SCXqHE0/evxf+bPwoHc6oBUH88AcDLC+C0g7y8Ot6WcAzax6IS4K1Erc5g3Scv4j42mszY+NUFmAHoFUr+OkivaMkAb/zqAu6KDXf8mkjKNeHC9dYidicgIy9gvtWNFsV6V5fV2znnPXv2YPXq1dixYweSk5ORnp6OuSl3Y/qGD/FTCXDoUikGhbS0vn24dy/WKJXY+eSTmPC73+FKTg6WLFkChmGQlpZmNfZPP/2Et956CyNHjpTkLYqJ3YG8RqPB999/j5qaGvj5+UEut75b88knn8DPz6+dVxMEwbH/XBHOFGuhGzYJAPDNvsvYdiQPqSmxmEW2KwThUURrfBHo740vh0zEzNgEXDqdxdrODdG4emqEq1EogPnzXT2L7g3tY1FhlesbrZXrRdzHJ3MrUVTDZkCNMjm+sVwHcZgBFNXocDK3EuMHBTv2T6RcEy5cb8G+XI+8gIy8gPnWuIvQnZ1zTktLw/Lly7F06VIAwI4dO7Bv3z6YLx8Cgibju0ulePz2gfz2R0+cwMTbb8fCN94AAEQNHowFCxbgxIkTVuPW19dj0aJFeOedd/Dyyy+L+Makwe7Seo7AwMA2QTwA9O7d2ypDTxBEW7iSMl2zyer54hodlZQRhAfCMAzGRAYBADZ9zVq0juoXiCAf+j4kCMKzkFq5vrTOdhmzo9v1JLiMvFRid9UNbhLI24Fer0dmZiamT5/OPyeTyTB9+nTU5F0AwN40qmvVIjJhwgRkZmbi5MmTAICcnBx88803mDNnjtXYK1aswN133201tjsjOJAnCMIxWpeUyU1GzLl0BHMuHYHcZAQnybHxqwtWSq4EQbg3+88VIfNaGeZcOoKEkwchNxlxtVRLN+UIwGAAPvmEfRic783dI6B9LCotXvKtAnkR93Gof4tLz63XQe1tJxgp14QL11uIReyuUtsEk73XiQLmW+0uHvJ2zLm8vBxGo9HKTQ1ghdlrK8swUOMLg8mMI1fL+b8tfPBBvDRvHiZNmAClUolBgwZhypQpeP755/ltPvroI2RlZWHLli3SvDcJsLu0niCIrtG6pExlaMabX7wKABi+6lM0quTilJQRBOE0uAobtV5ndTzXN8nx5O4sbH84gdplejJNTcCDD7I/19ezJaOEuNA+FhXOgq62sVUAJeI+TorujYhANYprdDavgxgA4YFqJEX3dvh/SLomXLjeell85E1mNuju7WtH1ZeA+XJVGEHeLq4mE2EfTxsWipwjuTh4qRSzR7DfwRnffovN77+PNwEkHz+O7MJCPPPMM9i0aRPWr1+PGzdu4JlnnsG3334LtdpzbKEpI08QToJKygii+9C6wqY9qMKGIAhPwmZGXkTkMgapKbE2/8ZJ26WmxJL4rw2UchmfLa8Q0idvJ9UNbMm+J3jIazQayOVylJSUWD1fUlKC8PBwTBvG2tBlXC7lqxfWb9qERwA8DmBEfDzmzZuHzZs3Y8uWLTCZTMjMzERpaSkSEhKgUCigUChw+PBh/PWvf4VCoYDRaIQ7QoE8QTgJe0vFulRSRhCEU2hdYWOL1hU2BEEQnoDUPfIAMCs+An9fOAa3hurhgWqqYuqEYF/p+uQ9qUdepVJh7NixOHjwIP+cyWTCwYMHMX78eCRG9YaflwLl9Xr8UlADAGhobGwT9HKab2azGXfeeSd++eUXnD59mn8kJiZi0aJFOH36tE19OHeAapAIwkm0LimzhSglZQRBOAWqsCEIorvRkpGXtv+7by8fq2qm95eOQ2JcJGXiOyHYzwvXyrSSeMnXuEuPvJ2sXr0aixcvRmJiIpKSkpCeng6tVoulS5dCpZCh+eBfUWX0wXd3DsGoyCCkzJ6NtNOnMQZA8vXryC4sxPr165GSkgK5XA5/f3/Ex8db/Q9fX18EBwe3ed6doIw8QTiJ1iVlt35VUUkZQXgWVGFDEER3o6VHXrqMPAAcz6mw+j15YDBd+9iBhlOur5OgtN5d7Ofs5KGHHsLrr7+ODRs2YPTo0Th9+jT279/PC+ApGithrK/CoculAIB1f/oTfg9gHYDYxEQsW7YMM2fOxFtvveW6NyEClJEnCCcyKz4C2x9OwNZ/Z1o9Hx6oJh95gvAgqMKGIIjuRoDaUlovUY88x4lbAnnCPjQW5foKrfil9TUNbiJ2J4CVK1di5cqVNv92KOMQkl45iLM3a1Bap0OoQoFUAKkAUF4O+Pp2On5GRoaY05UEysgThJOZFR+BA6un8L+/v3QcjvxpGgXxBOFBUIUNQRDdDWdk5A1GE366XiXZ+N2ZYF82kJeiR97TSus7I9RfjZH9AgEAGZfLXDwb6aCMPEG4ALnaC3jvPQBA8rAIgC72CcLj4CpsXv78LP4w51kAQLNcQRU2BItKxZ/nofKcLJdHQftYVGz2yIu8jy8U1aK+yYDevmqY3t0JmYwR97OTck24eL0FW0rr7VatFzDf6kaLar2rS+tF3MfThoXi7M0afHexFA+OCu+W5woK5AnCFSiVwJIlrp4FQRBdZFZ8BO6KDcfJ3ESU1unwK3+2nJ4y8QSd550A7WNRsalaL/I+5vrjEwaHQrb4btHG5ZFyTbh4vXE98naX1ts5X12zEbpmEwA3sJ8TcR9PGxaK9ANXcSS7HHpGDlU3PFdQIE8QBEEQXUAuYzB+ULCrp0EQBNEluNL6JoMJumYj1ErxLbdO5LCWnLcNpHOmUIK5HnmRfeS5GzdyGQN/r+4TGsb3CYTGzwvl9U346XolJg7WuHpKokM98gThCgwGYN8+9mGQ1uaFIAiJoeOZsAWtC+mhfSwqfioFGEsxUR1XXi/iPjaazDiZywbyyZGB0nx2Uq4JF683TuzO7h55O+fLKdYHqBVgGBdXk4m4j2UyBlNjQgAAh84XdstzRfe57UIQnkRTE3DPPezP9fWAgg5FgvBY6HgmbEHrQnpoH4uKzJKRrdUZUKtrRoi/l6j7+GJRLeqaDPD3UiA22Euaz07KNeHi9cb1yNc3GeyrmLBzvtWcYr2PG/SOi7yPpw0LxSeZN3H0fAHwQvc7V1BGniAIgiAIgiAISZXruf74caQj4hD+Xgqo5GzoJqYFXY2HecgLYdIQDZRyBrnlDa6eiiRQIE8QBEEQBEEQhG3lepE4zvfH9xZ97J4AwzDClevtoLrBTRTrJcBfrURSdPddbxTIEwRBEARBEARhW7leBNj+eDYjnxxNQneO0hLIi5+R7y4e8rcyNSbU6vcTORUwmswumo24UCBPEARBEARBEESrjLy4gfyl4lrU6gzw81Igrk+AqGP3JIJ9WcG7MhEz8nwg3w0z8gCgkFu3cSx57ydM2vod9p8rctGMxIMCeYIgCIIgCIIgWvXIi1taz5XVJ0b1gkJO4YejaHgLOvEy8pzYXXcsrd9/rggbv7zQ5vniGh2e3J3l8cE8HUkEQRAEQRAEQUiWkT9hEboj//iuoZGiR54Tu3MH1XoRMZrM2PjVBdgqouee2/jVBY8us+8e2vsE4WmoVMDf/97yM0EQngsdz4QtaF1ID+1j0WnTIy/CPjaZzDh53eIfzwmPSfXZSbkm3GC98T3y9qjW2zlftyqtF3Efn8ytRFGNDgDQLFdg/V2/5X8G2GC+qEaHk7mVGD/IM28wUSBPEK5AqQRWrHD1LAiCEAM6nglb0LqQHtrHotNGtV6EfXy5pA7VDc3wVckR3zdQtHFtIuWacIP1xvXIl9uTkbdzvjXupFov4j4urdPxPxvkCvwz4Z5Ot/M0qLSeIAiCIAiCIAhJfOQ5//ixUb2hpP74LiGFan11N1WtD/VXi7qdO0IZeYJwBUYj8MMP7M+33w7I5a6dD0EQjkPHM2ELWhfSQ/tYdALUltJ6rkdehH18wpZ/vFSfnZRrwg3WGyd2Z1dG3s75upX9nIj7OCm6NyIC1Siu0YExGZF08zwA4GS/OJhkcjAAwgPVHu0z7xa3xbZt24aoqCio1WokJyfj5MmTHW6fnp6OmJgYeHt7IzIyEqtWrYJOZ7ss4tVXXwXDMHj22WclmDlBOIhOB0ydyj7aWbsEQXgIdDwTtqB1IT20j0WnTUa+i/vYZDLjhC3/eKk+OynXhBusNy6Qr9TqYepMpM2O+ZpMZj6QD3CH0noR97FcxiA1JRYAoDY046N/PY+P/vU8vAzN4AzpUlNiIZcx7Q/i5rg8kN+zZw9Wr16N1NRUZGVlYdSoUZg5cyZKS0ttbv/hhx9izZo1SE1NxcWLF/Huu+9iz549eP7559ts+9NPP+Gtt97CyJEjpX4bBEEQBEEQBOHRtOmR7yJXS+tR1dAMb6UcI/sFijJmT6a3L1tabzCZRXEWqNMZYLbcD3CLHnmRmRUfge0PJyAs0Mvq+fBANbY/nIBZ8REumpk4uDyQT0tLw/Lly7F06VLExsZix44d8PHxwc6dO21uf/ToUUycOBELFy5EVFQUZsyYgQULFrTJ4tfX12PRokV455130KtXL2e8FYIgCIIgCILwWNqo1ncRrj8+MaoX9ceLgEoh49sfykXok+ey8T4qObwU3bM1ZVZ8BA6snsL//v7ScTjyp2keH8QDLg7k9Xo9MjMzMX36dP45mUyG6dOn49ixYzZfM2HCBGRmZvKBe05ODr755hvMmTPHarsVK1bg7rvvthq7PZqamlBbW2v1IAiCIAiCIIieBFde3WQwQdds7PJ4XFk9+ceLB1deL4aXfHWjGynWS0jr8vnkgcEeXU7fGpeK3ZWXl8NoNCIsLMzq+bCwMFy6dMnmaxYuXIjy8nJMmjQJZrMZBoMBv/3tb61K6z/66CNkZWXhp59+smseW7ZswcaNGx1/IwRBEARBEATh4fipFGAYwGxmy67VXUj5mc1mXugu2YMFxdyNYD8Vcsq19nnJd0J1A5uR7+6BfHfF42pcMjIysHnzZrz55pvIysrC3r17sW/fPmzatAkAcOPGDTzzzDP44IMPoFbbZyewdu1a1NTU8I8bN25I+RYIgiAIgiAIwu2QyRj4ed2iXO8g2aX1qNDqoVbKMLJfkAizIwCByvWd4FaK9YRgXJqR12g0kMvlKCkpsXq+pKQE4eHhNl+zfv16PPLII3j88ccBACNGjIBWq8UTTzyBF154AZmZmSgtLUVCQgL/GqPRiO+//x5///vf0dTUBPktVgZeXl7w8rIWQSAIgiAIgiCInkaAWok6nYHtk/dROTwO7x8/oBdUCo/LHbotnJe8GD3ynIc8ZeQ9E5cG8iqVCmPHjsXBgwcxd+5cAIDJZMLBgwexcuVKm69paGiATGZ9MuACc7PZjDvvvBO//PKL1d+XLl2KYcOG4U9/+lObIJ4gXIJSCbz2WsvPBEF4LnQ8E7agdSE9tI8lIcBbiYLqRla5Xunr8D4+nmvxj4+20R8v1Wcn5Zpwk/UW7Gtnj7wd861pYG8GBHk7fsNGVDxxXbgQlwbyALB69WosXrwYiYmJSEpKQnp6OrRaLZYuXQoAePTRR9G3b19s2bIFAJCSkoK0tDSMGTMGycnJyM7Oxvr165GSkgK5XA5/f3/Ex8db/Q9fX18EBwe3eZ4gXIZKBTz3nKtnQRCEGNDxTNiC1oX00D6WBE4Vvbax2eF9zPbHW/zjbQndSfXZSbkm3GS9aSwZ+YrOMvJ2zNftSus9cV24EJcH8g899BDKysqwYcMGFBcXY/To0di/fz8vgJefn2+VgV+3bh0YhsG6detQUFCAkJAQpKSk4JVXXnHVWyAIgiAIgiCIbgGnXN+VHvlrZVqU1+vhpZBhVCT5x4tJMKdarxVBtd4idhdApfUeicsDeQBYuXJlu6X0GRkZVr8rFAqkpqYiNTXV7vFvHYMgXI7RCGRlsT8nJADU8kEQngsdz4QtaF1ID+1jSQhQs0Fdnc7g8D7m+uMT+vey7U8u1Wcn5Zpwk/UW7Gtnj7wd8612t4y8J64LF+IWgTxB9Dh0OiApif25vh7w9XXtfAiCcBw6nglb0LqQHtrHkhDg3aq03sF9fILrj2/PP16qz07KNeEm603jb6dqvR3z5Uvr3aVH3hPXhQshCUmCIAiCIAiCIAC0ZOQdLa03m818Rj55IPnHi43GInZXpzOgyWDs0lg15CPv0VAgTxAEQRAEQRAEgFY98o0Gh16fW65FWV0TVAoZRkcGiTgzAmArJhQyBgBQqe2aBV11o0W13l1K6wlBUCBPEARBEARBEASAVqr1Dmbkj+ewZfVjIoOgVnaPXmR3gmEY3ku+U+X6TqghH3mPhgJ5giAIgiAIgiAAtM7IOxbIn8hly+rb7Y8nugznJd9pn3wH6JqN0DWbAACBlJH3SCiQJwiCIAiCIAgCQOseeeGl9dQf7xy4jHynyvUdwGXj5TIG/l6kf+6JUCBPEARBEARBEASAW1TrBZJX0YCS2iao5DIk9O8l9tQICyGcl3wXMvKty+oZhhFlXoRzodsvBOEKlEogNbXlZ4IgPBc6nglb0LqQHtrHkmClWi9wH3PZ+NGd9cdL9dlJuSbcaL3xPfIdid11Mt9qd1Ss98R14UIYs9lsdvUk3I3a2loEBgaipqYGAQEBrp4OQRAEQRAEQTiFmsZmjNr4PwDA5ZdnwUthv2Ddqj2n8dmpAjw9bTBWz4iRaoo9nh2Hr+HV/1zC/Ql9kfbgaIfG+N/5Yjzxz0yMjgzC5ysmijtBwmGExKFUWk8QBEEQBEEQBADA30sBrtK6TkCfvHV/PAndSUmwb9dV67nSerKe81yotJ4gXIHJBFy8yP48fDggo3tqBOGx0PFM2ILWhfTQPpYEmYyBn5cCdToDarVN0ORls3/oZB/fqGxEUY0OSjnTeX+8VJ+dlGvCjdabhuuR13bQI9/JfN3Ses4T14ULoUCeIFxBYyMQH8/+XF8P+Pq6dj4EQTgOHc+ELWhdSA/tY8kIUCtRpzOgvrrO7n3MZeNH9QuCt6qTcnypPjsp14QbrTcukC+v6yAj38l8uR75IHcK5D1xXbiQ7nE7giAIgiAIgiAIUXDES/54LtnOOYsWsbsmOCp3xmfkfVSizYtwLhTIEwRBEARBEATBE6Bmi3aF9MifyKkEANxG/fGS09vSI99sNKNWwGfUmmp3LK0nBEGBPEEQBEEQBEEQPHxG3s4g8UZlAwqqG6GQMRg7gPzjpUatlMPfi73Z4qiXfHUDW5bvVqX1hCAokCcIgiAIgiAIgofzkq/T2Vdaz/XHj+wXCB8VSXA5A7u85DugllTrPR4K5AmCIAiCIAiC4Anw5krr7QvkT+SyZfVkO+c8gnnBOwcz8lRa7/FQIE8QBEEQBEEQBA+Xka8VmJGn/njnobFk5MsdzMjzqvWUkfdYqPaFIFyBUgn84Q8tPxME4bnQ8UzYgtaF9NA+lgyuR766mel0H9+sasDNqkbIhfTHS/XZSbkm3Gy9cRn5dnvkO5ivyWTmb9IEeruRar0nrgsXQoE8QbgClQr4859dPQuCIMSAjmfCFrQupIf2sWRwqvVVBnS6jzm1+hF9A+HnZWdoIdVnJ+WacLP1prEo11fUt5OR72C+dToDONc6tyqt98R14UKotJ4gCIIgCIIgCB4hPvJcWT35xzsXPiOvFd4jX93IBv8+KjlUCgoHPRXKyBOEKzCZgPx89uf+/QEZnUQJwmOh45mwBa0L6aF9LBm8an2DHrh+nX2ynX3MCd0J6o+X6rOTck242XrjVOvL28vIdzDfGk6x3p2y8YBnrgsXQoE8QbiCxkYgOpr9ub4e8PV17XwIgnAcOp4JW9C6kB7ax5LBqdY31dV3uI8LqxuRX9kAGQMkCvGPl+qzk3JNuNl6C/a1qNa31yPfwXw5obsAdwvkPXFduJDucTuCIAiCIAiCIAhRaPGRN3S43Ylctqx+RN9A+KvdLCjs5oT4d9Ij3wHV5CHfLaBAniAIgiAIgiAIHi5Tq2s2dbjd8WvkH+8quIx8TWMz9IaOP6dbaSmtdyPFekIwFMgTBEEQBEEQBMHj76UAw3S+HZeRv42E7pxOoLcSchn7IVU1CMvK11i2dyvFekIwFMgTBEEQBEEQBMEjkzGdWskV1+hwvcLSHx9FgbyzkckY9PblBO+EKddzPfJUWu/ZUCBPEARBEARBEIQVAZ30vHPZ+Lg+gZ1uS0hDcGde8u3AldYHUiDv0VAgTxAEQRAEQRCEFZ0pmvP+8dGUjXcVIf6dKNe3Ayd2R6X1ng3ZzxGEK1AogKeeavmZIAjPhY5nwha0LqSH9rGkBKgVMMrkuP7QYkQF+7bZxydyHPCP55Dqs5NyTbjheuswI9/BfGsa3FTszhPXhQvpPu+EIDwJLy9g2zZXz4IgCDGg45mwBa0L6aF9LCkB3kroFUocXfUSopL7W/2ttFaHnHItGAYY50hGXqrPTso14YbrLdjPkpHX2sjIdzDfGne1n/PEdeFCqLSeIAiCIAiCIHoI27ZtQ1RUFNRqNZKTk3Hy5Emb23F975/9823ExMTA29sbkZGRWLVqFb6/VAgAiI0IwJvpr2PcuHHw9/dHaGgo5s6di8uXLzvt/fRkgv0c65GvbiTV+u4ABfIE4QrMZqCsjH2Yza6eDUEQXYGOZ8IWtC6kh/axYPbs2YPVq1cjNTUVWVlZGDVqFGbOnInS0tI22wZ4K6A9fwifv/1npK5ahYsXLuDdd9/Fnj178NrLLwIAkqODcfjwYaxYsQLHjx/Ht99+i+bmZsyYMQNarbb9iUj12Um5JtxwvWksXvIVtnrkO5gvp1rvdoG8J64LF0KBPEG4goYGIDSUfTQ0uHo2BEF0BTqeCVvQupAe2seCSUtLw/Lly7F06VLExsZix44d8PHxwc6dO9tsG6BWwnDjPO5o1mPhk08iKjQUM2bMwIIFC3Dll1MAWP/4/fv3Y8mSJYiLi8OoUaPw/vvvIz8/H5mZme1PRKrPTso14YbrjcvIl9vKyLczX12zEU0GEwA3LK33xHXhQiiQJwiCIAiCIIhujl6vR2ZmJqZPn84/J5PJMH36dBw7dqzN9gHeSnj3iUEmAK74PicnB199vQ9M/wQwDJBkoz++pqYGANC7N6nZS43Gr4OMfDtw/fFyGQM/L5JL82QokCcIgiAIgiCIbk55eTmMRiPCwsKsng8LC0NxcXGb7QPUCgQOux0vAZgEQBkUhEGDBmHwqCQEjn8Qw8IDEORjrXpuMpnw7LPPYuLEiYiPj5fw3RBAq4y8Vg+znSXjrcvqGYaRbG6E9NBtGIIgCIIgCIIgrAjwVkJ74xw2A3gTQPKRI8guLMSSJ54CU2RC8nNr27xmxYoVOHfuHI4cOeL0+fZEgi098nqDCfVNBvirOy+V5xXr3a0/nhAMZeQJgiAIgiAIopuj0Wggl8tRUlJi9XxJSQnCw8PbbB+gVqL86Ed4BMDjAEbEx2PevHmInPEYao9/iqSoXlbbr1y5El9//TUOHTqEfv36SfhOCA5vlRy+KjkA+5XrqxvY7QIokPd4KJAnCIIgCIIgiG6OSqXC2LFjcfDgQf45k8mEgwcPYvz48W22D/BWwPT/27vzsKiq/w/g7wEcYFhlEXBBEAUhFReE1FRUFK0vaWqaWooJasnX1Cy3EM2MNDOyTHsyga+GWuaWW/WjUHMJxXBJREXckkUpQEAWZ87vD5zRERBQxuHi+/U88zzDnTNnPnPuudZnznLvlGolCzcLSpB1q3xEt+vdRF4IgbCwMGzduhW//vorXF1ddfo9SJv6XvI5ld1LvhK59fUe8lRrnFpPRERERPQUmDFjBsaNGwcfHx/4+voiKioKhYWFGD9+PABg7NixaNasGSIjI2Fp0gjmrbpgVfZFdALgd+kS4g6eQu6B9XBo1x32lqYAyqfTx8XFYfv27bCwsNCst7eysoKpqam+vupTw85cjiv/FOHGrZqNyOdzan2DwUSeSB+MjIBx4+49JyLp4vVMlWG/0D22ca2NHDkSN27cwPz585GZmYmOHTti7969mg3wrly5AgOD8jF4S9NGaNxtJDpfPIb3bt/E3z4+kJtbw8S1C8a+PVdT56pVqwAA/v7+Wp8VHR2N4ODgygPR1bnTZZ+op/2tyhH5KuKtt/eQB6TZL/RIJmq6xeFTJD8/H1ZWVsjLy4OlpaW+wyEiIiIieqJUKgG3ebshBHDsvQDYmRsj8NP9SM26hVVjOmNQeyd9h0gA5mw5iQ2JVzGjvzum9mtTbfn3tp3C+iNXMLVfG8zo7/4EIqTaqE0e2nB+kiAiIiIiojphcPc+47eK7yD/dhkMZDKkZt0CUPn940k/1DvX1/Re8nm37wDg1PqGgIk8kT4IARQVlT9XKADex5NIung9U2XYL3SPbaxzlsZGuJNfgIJ/8nAus7x93R3MNdO5H5muzp0u+0Q97W/330teSxXxqnetr5dT66XYL/SIu9YT6UNREWBuXv5Q/8NCRNLE65kqw36he2xjnbM3VCLl0+Ho0LY5klL+BgD4udo+fsW6One67BP1tL9p1sg/OCJfRbx59XnXein2Cz1iIk9ERERERBVYmtybvJuY/g8A4NlWdZDIU52xU4/I1/A+8vU6kadaYSJPREREREQVWNw3/fpcVgEAro+vb+yqGpGvQr3etZ5qhYk8ERERERFVYGmsney1bmIOe4vHXB9PdcrWrHxE/t+iMtxRqh5aVqUSyC9WJ/JyncdGusVEnoiIiIiIKrAwNdT624+j8fWOtUIOg7t7t/1T9PDp9beK70B943GOyEsfE3kiIiIiIqrA4oERea6Pr38MDWSwuTsqn1PNOvnc2+WvK+SGkBsxDZQ6nkEiIiIiIqrA3ET7TtU+Lo31FAk9jPpe8jerWSevXh/Pe8g3DLyPPJE+GBoCw4ffe05E0sXrmSrDfqF7bGOd2ns6A1/uv4QmHj0AACoDAwz98hAigrwwsJ3T41Wuq3Onyz5Rj/ubnYUcqVkPjMhXEq96x3orRT1dHy/FfqFHMiHUKyX0Z+XKlfj444+RmZkJb29vfP755/D19a2yfFRUFFatWoUrV67Azs4Ow4cPR2RkJExMTAAAkZGR2LJlC86ePQtTU1N0794dS5YsgYeHR43iyc/Ph5WVFfLy8mBpaVkn35GIiIiISAr2ns7AG+uP48Ek4e5SbKx6tfPjJ/NUZ6Zu+BM7TlzHey94IqRnqyrL7ThxHVM3/IlnW9lg48RuTzBCqqna5KF6n1q/adMmzJgxAxERETh+/Di8vb0RGBiI7OzsSsvHxcVh9uzZiIiIQEpKCr755hts2rQJc+fO1ZTZt28fpkyZgiNHjuCXX35BWVkZBgwYgMLCwif1tYiIiIiIJEepElj445kKSTwAzbGFP56BUqX3sUC6y/buveRzCh++Rj7v7mZ41tyxvkHQ+9T65cuXIzQ0FOPHjwcArF69Grt27cLatWsxe/bsCuUPHTqEHj16YPTo0QAAFxcXjBo1Cn/88YemzN69e7XeExMTgyZNmiApKQm9evXS4bchIiIiIpKuxPR/kJFXXOXrAkBGXjES0/9BNzduflcf1PRe8uqp9dYKrpFvCPQ6Il9aWoqkpCQEBARojhkYGCAgIACHDx+u9D3du3dHUlISEhMTAQAXL17E7t278fzzz1f5OXl5eQAAG5vKb5lRUlKC/Px8rQeRThUWAjJZ+YMzRYikjdczVYb9QvfYxjqRfeteEm9aWoxLS/6DS0v+A9PS4irL1Zquzp0u+0Q97m+2le1aX0m86s3u6u2t56TYL/RIryPyN2/ehFKphIODg9ZxBwcHnD17ttL3jB49Gjdv3sRzzz0HIQTu3LmDyZMna02tv59KpcK0adPQo0cPtGvXrtIykZGRWLhw4eN9GSIiIiIiiWtiYVKn5Uj31CPy1e5ar9nsrp4m8lQrel8jX1sJCQn48MMP8eWXX+L48ePYsmULdu3ahUWLFlVafsqUKTh9+jQ2btxYZZ1z5sxBXl6e5nH16lVdhU9EREREVG/5utrAycpEs7Hdg2QAnKxM4Ota+UxXevLUa+RvVnMfec3Ueq6RbxD0OiJvZ2cHQ0NDZGVlaR3PysqCo6Njpe8JDw/Ha6+9hpCQEABA+/btUVhYiIkTJ2LevHkwMLj320RYWBh27tyJ/fv3o3nz5lXGYWxsDGNj4zr4RkRERERE0mVoIENEkBfeWH+8QjKv/jsiyAuGBlWl+vSkadbIF5ZACAGZrPJzk1ffp9ZTreh1RF4ul6NLly6Ij4/XHFOpVIiPj0e3bpXfEqGoqEgrWQcAw7v3A1TfSU8IgbCwMGzduhW//vorXF1ddfQNiIiIiIgaloHtnLDq1c5wsNIe6HK0MuGt5+oh9Yh8cZkKRaXKKsvl3r67az2n1jcIet+1fsaMGRg3bhx8fHzg6+uLqKgoFBYWanaxHzt2LJo1a4bIyEgAQFBQEJYvX45OnTrBz88PFy5cQHh4OIKCgjQJ/ZQpUxAXF4ft27fDwsICmZmZAAArKyuYmprq54sSEREREUnEwHZO6N/SH1hQ/nfM+K7weaYFR+LrIYXcCKaNDHG7TImcglKYGVee4qmn1nNEvmHQeyI/cuRI3LhxA/Pnz0dmZiY6duyIvXv3ajbAu3LlitYI/HvvvQeZTIb33nsPf//9N+zt7REUFITFixdryqxatQoA4O/vr/VZ0dHRCA4O1vl3IiIiIiKSuvuTdr9WtgCT+HrL1lyOa//exs3CEjjbKiotU+93rada0XsiD5SvZQ8LC6v0tYSEBK2/jYyMEBERgYiIiCrrU0+xJ6q3DA0B9S0T784kISKJ4vVMlWG/0D22se7pqo2lVq+u664DdubG5Yn8rbs71z8Qb3GZEiV3VADq8dR6KfYLPZIJZr0V5Ofnw8rKCnl5ebC0tNR3OERERERERFUKiT2K/0vJRuTQ9hjl61zh9az8Yvh9GA9DAxkuLB5U5YZ4pF+1yUMld/s5IiIiIiIiusfW7O7O9VXcS/7+afVM4huGejG1XqqUSiXKysr0HQYRAWjUqJFmw0siIiKip0l195LPLbq7Yz3XxzcYTOQfgRACmZmZyM3N1XcoJFUqFXDtWvnz5s0BA06OqQvW1tZwdHTkL830ZBUWAk2alD/PzgbMzPQbD9UP7Be6xzbWPV21sdTq1XXddcBWcy/5u4n8A/Fqdqyvr+vjAWn2Cz1iIv8I1El8kyZNoFAomDRQ7SmVwO3b5c9dXBrUxhv6IIRAUVERsrOzAQBOTry/LT1hRUX6joDqI/YL3WMb656u2lhq9eq67sdkd3dEXmtq/X3x5krl1nNS7Bd6wkS+lpRKpSaJt7W11Xc4JFVK5b3nJiZM5OuAqakpACA7OxtNmjThNHsiIiJ6atjdHZG/WcUa+by7a+Q5tb7h4HzeWlKviVcoKr8/IxHpj/q65N4VRERE9DSx1YzIV75GXj213lohf2IxkW4xkX9EnE5PVP/wuiQiIqKnkXrX+n+KSqFUVby7eO7t8gTfkiPyDQYTeSIiIiIiIglrrGgEmQwQAvi3qOKofC6n1jc4TOT1SKkSOJyWg+3Jf+NwWk6lv549aTKZDNu2bXusOoKDgzFkyBDN3/7+/pg2bdpj1QkACxYsQMeOHR+7HiIiIiKihsTI0ACNFVVPr783tZ6JfEPBze70ZO/pDCz88Qwy8oo1x5ysTBAR5IWB7XSz4/aNGzcwf/587Nq1C1lZWWjcuDG8vb0xf/589OjRAwCQkZGBxo0bP9bnfPbZZxCi7n+UmDlzJv773/9q/g4ODkZubu5j//CgVCrx8ccfIyYmBpcvX4apqSnatGmD0NBQhISEPGbUVZDJAAuLe8+JSLoMDIDeve89JwLYL54EtrHu6aqNpVavruuuI3bmcvxTWIqbBSXwsDLTijdPCrvWS7Ff6BETeT3YezoDb6w/jgdT3cy8Yryx/jhWvdpZJ8n8sGHDUFpaitjYWLRq1QpZWVmIj49HTk6Opoyjo+Njf46VldVj13E/IQSUSiXMzc1hbm5ep3UDwMKFC/HVV1/hiy++gI+PD/Lz83Hs2DH8+++/df5ZaqV37kDu4aGz+onoCTI1BRIS9B0F1TfsF7rHNtY9XbWx1OrVdd11pHydfEH5zvWmdlrxaqbW1+cReSn2Cz1qOD9J6JEQAkWld2r0uFVchogdf1VI4gFoji3YcQa3isuqras2o965ubk4cOAAlixZgj59+qBly5bw9fXFnDlz8OKLL2rK3T+1/tKlS5DJZPjuu+/Qs2dPmJqaomvXrjh37hyOHj0KHx8fmJubY9CgQbhx44amjgen1j9o3bp18PHxgYWFBRwdHTF69GjN/b8BICEhATKZDHv27EGXLl1gbGyM33//XWtq/YIFCxAbG4vt27dDJpNBJpMhISEBffv2RVhYmNbn3bhxA3K5HPHx8ZXGs2PHDrz55pt4+eWX4erqCm9vb0yYMAEzZ87UlFGpVFi6dClat24NY2NjODs7Y/HixZrXT506hb59+8LU1BS2traYOHEiCgoKKrTJ4sWL0bRpU3jcTeKvXr2KESNGwNraGjY2Nhg8eDAuXbqk1Ra+vr4wMzODtbU1evTogcuXL1fZtkRERET0dHrYzvWSGJGnWuGIfB24XaaE1/yf6qQuASAzvxjtF/xcbdkz7wdCIa/ZKVSPZm/btg3PPvssjI2NaxxTREQEoqKi4OzsjNdffx2jR4+GhYUFPvvsMygUCowYMQLz58/HqlWralRfWVkZFi1aBA8PD2RnZ2PGjBkIDg7G7t27tcrNnj0by5YtQ6tWrdC4cWMk3PdL2syZM5GSkoL8/HxER0cDAGxsbBASEoKwsDB88sknmu+4fv16NGvWDH379q00HkdHR/z666948803YW9vX2mZOXPm4Ouvv8ann36K5557DhkZGTh79iwAoLCwEIGBgejWrRuOHj2K7OxsTRwxMTGaOuLj42FpaYlffvlF0w7q9x04cABGRkb44IMPMHDgQJw8eRIGBgYYMmQIQkNDsWHDBpSWliIxMZE7sxMRERFRBep7yecUat9LXqkSyC9WJ/K8/VxDwUT+KWFkZISYmBiEhoZi9erV6Ny5M3r37o1XXnkFHTp0eOh7Z86cicDAQADAW2+9hVGjRiE+Pl6zrn7ChAlaCWt1Xn/9dc3zVq1aYcWKFejatSsKCgq0ps6///776N+/f6V1mJubw9TUFCUlJVrLAYYOHYqwsDBs374dI0aMAADExMQgODi4ygR4+fLlGD58OBwdHfHMM8+ge/fuGDx4MAYNGgQAuHXrFj777DN88cUXGDduHADAzc0Nzz33HAAgLi4OxcXF+N///gczMzMAwBdffIGgoCAsWbIEDg4OAAAzMzOsWbMGcrkcUCqx/qOPoLp9G2u++goyo/JLMTo6GtbW1khISICPjw/y8vLwn//8B25ubgAAT0/PGrczET0hhYWAi0v580uXgLv/DtBTjv1C99jGuqerNpZavbquu47Ymt03In9fvLfOnIN6Im+9HpGXYr/QIybydcC0kSHOvB9Yo7KJ6f8gOPpoteVixneFr6tNtZ9bG8OGDcMLL7yAAwcO4MiRI9izZw+WLl2KNWvWIDg4uMr33Z/oq5PS9u3bax27f2p8dZKSkrBgwQKcOHEC//77L1QqFQDgypUr8PLy0pTz8fGpcZ1qJiYmeO2117B27VqMGDECx48fx+nTp7Fjx44q3+Pl5YXTp08jKSkJBw8exP79+xEUFITg4GCsWbMGKSkpKCkpQb9+/Sp9f0pKCry9vTVJPAD06NEDKpUKqampWm0ml9/7FfTE2bO4cPUqLKytteorLi5GWloaBgwYgODgYAQGBqJ///4ICAjAiBEj4OSkm80Qiegx3Lyp7wioPmK/0D22se7pqo2lVq+u664DtndH5G+qp9bfjTf/7rR6hdwQcqN6vrJaiv1CT+r5mZQGmUwGhdyoRo+ebezhZGWCqiZHy1C+e33PNvbV1vUoU6xNTEzQv39/hIeH49ChQwgODkZERMRD39Oo0b1f7tSf+eAxdTJeHfU0dEtLS3z77bc4evQotm7dCgAoLdVez2P2iL+WhYSE4JdffsG1a9cQHR2Nvn37omXLlg99j4GBAbp27Ypp06Zhy5YtiImJwTfffIP09HSYmpo+UhwPevD7FNy+jS5t2yI5KQnJycmax7lz5zB69GgA5SP0hw8fRvfu3bFp0ya4u7vjyJEjdRIPERERETUcdnfXyN8s0J5ar7n1XH0ejadaYyL/hBkayBARVD7q/GAarv47IsgLhgZPZh20l5cXCgsLn8hnAcDZs2eRk5ODjz76CD179kTbtm1rNZp/P7lcDqVSWeF4+/bt4ePjg6+//hpxcXFaU/lrSj0zoLCwEG3atIGpqWmVm+V5enrixIkTWu148OBBGBgYaDa1q0xnDw+cv3oVTZo0QevWrbUe9+/836lTJ8yZMweHDh1Cu3btEBcXV+vvQ0REREQNm20Va+Rz1RvdKbg+viFhIq8HA9s5YdWrneFoZaJ13NHKRGe3nsvJyUHfvn2xfv16nDx5Eunp6fj++++xdOlSDB48uM4/ryrOzs6Qy+X4/PPPcfHiRezYsQOLFi16pLpcXFxw8uRJpKam4ubNmygrK9O8FhISgo8++ghCCLz00ksPrWf48OH49NNP8ccff+Dy5ctISEjAlClT4O7ujrZt28LExASzZs3Cu+++i//9739IS0vDkSNH8M033wAAxowZAxMTE4wbNw6nT5/Gb7/9hv/+97947bXXNNPqKzNm0CDYWVtj8Esv4cCBA0hPT0dCQgKmTp2Ka9euIT09HXPmzMHhw4dx+fJl/Pzzzzh//jzXyRMRERFRBXZV7FqfX3wHAGBlylXVDQnPpp4MbOeE/l6OSEz/B9m3itHEwgS+rjY6G4k3NzeHn58fPv30U6SlpaGsrAwtWrRAaGgo5s6dq5PPrIy9vT1iYmIwd+5crFixAp07d8ayZcu0boFXU6GhoZpN4QoKCvDbb7/B398fADBq1ChMmzYNo0aNgomJyUPrCQwMxIYNGxAZGYm8vDw4Ojqib9++WLBgAYzubkIXHh4OIyMjzJ8/H9evX4eTkxMmT54MAFAoFPjpp5/w1ltvoWvXrlAoFBg2bBiWL1/+0M9VmJhg/1dfYVZcHIYOHYpbt26hWbNm6NevHywtLXH79m2cPXsWsbGxyMnJgZOTE6ZMmYJJkybVuq2IiIiIqGFTj8gXlSpRVHoHirvH84vKE3tr7ljfoMhEbW5G/pTIz8+HlZUV8vLyYGlpqfVacXEx0tPT4erqWm2CSPpz6dIluLm54ejRo+jcubO+w6lIqQT+/LP8eadOgGHtNi6kyvH6JL0oLATUd9woKGgwu+HSY2K/0D22se7pqo2lVq+u664jQgi0Dd+Lkjsq/D7FF82dmwAAVv2YjCW/X8MrXVvgo2EPv1uVXkmxX9Sxh+WhD+KIPDUoZWVlyMnJwXvvvYdnn322fibxACCTAQrFvedEJF0GBoD6LhsGXLFGd7Ff6B7bWPd01cZSq1fXddcRmUwGO3Nj/J17GznFd9D8brx5JeV7StXrW88B0uwXesREnhqUgwcPok+fPnB3d8fmzZv1HU7VDAyA+261R0QSZmoKHK3+tqL0lGG/0D22se7pqo2lVq+u665DduZy/J17GzfKDDTx3vz+BADASlHPE3kp9gs9YiJPDYq/vz+4WoSIiIiInkaV7VyfW6S+/RzXyDckDWduARERERER0VPM1kx9L/l7O9fnq28/V9+n1lOtMJEn0gelEjh5svyhVOo7GiJ6HEVFgItL+aOoSN/RUH3BfqF7bGPd01UbS61eXdddh9Qj8nk5eZp4b+flAwCs6/vUein2Cz3i1HoifSktrb4MEdV/QgCXL997TgSwXzwJbGPd01UbS61eXdddh9T3kv+3oEQTb15RKQCD+j8iL8V+oUcckSciIiIiImoA7CpZI59/+w4ATq1vaJjIExERERERNQC2d0fkc+5bI19yRwVAAlPrqVaYyBMRERERETUAtmbqEXntJZyGBjKYG3NVdUPCRJ5q7NKlS5DJZEhOTgYAJCQkQCaTITc3V69xERERERHRfWvkH0jkrUwbQSaT6SMk0hEm8k+RGzdu4I033oCzszOMjY3h6OiIwMBAHDx48JHq6969OzIyMmBlZQUAiImJgbW1dR1GTERERERENdX47u3nVA/s6WbN9fENDhP5p8iwYcPw559/IjY2FufOncOOHTvg7++PnJycR6pPLpfD0dGRv+49KhOT8gcRSZtMBnh5lT/47yGpsV/oHttY93TVxlKrV9d118LKlSvh4uICExMT+Pn5ITExUev1RoYGsFY0gpABJe5tscTWHmkxU7FvbiBatGiB6dOno7i4uFZ1PjFS7Bd6xIUSdamwsOrXDA21k7aHlTUwAExNH17WzKxWoeXm5uLAgQNISEhA7969AQAtW7aEr6+vpoxMJsOXX36JHTt2ICEhAU5OTli6dCmGDx9eaZ0JCQno06cP/v33XyQnJ2P8+PGaegAgIiICCxYsqFWcTw1DQ6BdO31HQUR1QaEA/vpL31FQfcN+oXtsY93TVRtLrV5d111DmzZtwowZM7B69Wr4+fkhKioKgYGBSE1NRZMmTTTl7MyNcaGoDJGTp+HD2W/BKvC/6N2zByZ6KxAcHAyZTIbly5fXqs4nQor9Qo84Il+XzM2rfgwbpl22SZOqyw4apF3WxaVimVqHZg5zc3Ns27YNJSUlVZYLDw/HsGHDcOLECYwZMwavvPIKUlJSqq2/e/fuiIqKgqWlJTIyMpCRkYGZM2fWOk4iIiIiIqpo+fLlCA0Nxfjx4+Hl5YXVq1dDoVBg7dq1WuVs706vP/rHEbi16wwzL380b9ESAwYMwKhRo7RG3GtaJ9U/TOSfEkZGRoiJiUFsbCysra3Ro0cPzJ07FydPntQq9/LLLyMkJATu7u5YtGgRfHx88Pnnn1dbv1wuh5WVFWQyGRwdHeHo6AjzR/jBgYiIiIiItJWWliIpKQkBAQGaYwYGBggICMDhw4e1yqrvJd/cwxuXUk+j5HoqrBVyXLx4Ebt378bzzz9f6zqp/mEiX5cKCqp+/PCDdtns7KrL7tmjXfbSpYplHsGwYcNw/fp17NixAwMHDkRCQgI6d+6MmJgYTZlu3bppvadbt241GpGnWlIqgdOnyx9Kpb6jIaLHUVQEPPNM+aOoSN/RUH3BfqF7bGPd01UbS61eXdddAzdv3oRSqYSDg4PWcQcHB2RmZmodszWXw6SsGItjVuK9RnJkfjsLi4Z2hJubG/z9/TF37txa1/lESLFf6BHXyNel2qxb11XZapiYmKB///7o378/wsPDERISgoiICAQHB9fZZ1ANPbDRCBFJlBDAmTP3nhMB7BdPAttY93TVxlKrV9d11zFbM2PIBHD6ygV8DsAxYDLeePVFtLcsxltvvYVFixYhPDxc32FWJMV+oUcckX/KeXl5ofC+zfSOHDmi9fqRI0fg6elZo7rkcjmUHF0mIiIiIqpTdnZ2MDQ0RFZWltbxrKwsODo6ah2zvXsv+XAArwGwbh+Adu3b46WXXsKHH36IyMhIqFSqWtVJ9Q8T+adETk4O+vbti/Xr1+PkyZNIT0/H999/j6VLl2Lw4MGact9//z3Wrl2Lc+fOISIiAomJiQgLC6vRZ7i4uKCgoADx8fG4efMmihrQ1BUiIiIiIn2Ry+Xo0qUL4uPjNcdUKhXi4+MrLI1Vr5Evwr1kz+rufeQNDQ0BAEKIWtVJ9Q+n1j8lzM3N4efnh08//RRpaWkoKytDixYtEBoaqlknAwALFy7Exo0b8eabb8LJyQkbNmyAl5dXjT6je/fumDx5MkaOHImcnBzefo6IiIiIqI7MmDED48aNg4+PD3x9fREVFYXCwkLNLaDHjh2LZs2aYdikdwAAQQCWA7BI/R2FOa3wyy8nER4ejqCgIE1CX12dVH8xkX9KGBsbIzIyEpGRkQ8t17RpU/z888+Vvubi4gJx37oSf39/rb8BYNWqVVi1atXjB0xERERERBojR47EjRs3MH/+fGRmZqJjx47Yu3evZrO6K1euwMDAALZ3R+TfAyADsPjgRozovxpN7O0RFBSExYsX17hOqr+YyBMREREREUlAWFhYlcteExISAAD5xWUAyhO9CAAbX/8C+xf+B/YWxrWuk+ovJvJE+iKX6zsCIqoLMhnQsuW950QA+8WTwDbWPV21sdTq1XXddczC2AiNjAxwzbIJAEDI7q2Rr9ek2C/0iIk8aTw4TZ50yNAQ6NBB31EQUV1QKIBLl/QdBdU37Be6xzbWPV21sdTq1XXddUwmk8G8sSWee2MtAMBMbgi5kQT2OJdiv9AjCZxRIiIiIiIiqin1OnlAIqPxVGtM5ImIiIiIiBoQ9b3kAcBKweWcDRETeSJ9UKmAM2fKHyqVvqMhosdx+zbQtWv54/ZtfUdD9QX7he6xjXVPV20stXp1XbcOODQS2B47Hdtjp8PeUKnvcGpGiv1Cj7hGnkgfhACKiu49JyLpUqmAY8fuPScC2C+eBLax7umqjaVWr67r1gF7hRG8M88DAKxNJJLySbFf6BFH5ImIiIiIiBoQG7P7ptabSiSRp1phIk9ERERERNSAaG12p+Bmdw0RE3nSSEhIgEwmQ25u7hP93JiYGFhbWz9WHZcuXYJMJkNycnKVZeri+9VVG7m4uSEqLk7zt0wmw7Zt2x6rTgDw9/fHtGnTHrseIiIiIpIu6/t2qs8rKoNSxaWcDQ0T+aeETCZ76GPBggX6DrFeOHHiBF588UU0adIEJiYmcHFxwciRI5GdnQ0A6N69OzIyMmBlZfVYn3P0yBFMHDq0LkLWsmXLFixatEjzt4uLC6Kioh673hs3buCNN96As7MzjI2N4ejoiMDAQBw8ePCx6yYiIiKiurP3dAbmbTul+Xtz0t94bsmv2Hs6Q49RUV2rF4n8ypUr4eLiAhMTE/j5+SExMfGh5aOiouDh4QFTU1O0aNEC06dPR3Fx8WPV2dBlZGRoHlFRUbC0tNQ6NnPmzEeqt7S0tI4j1Z8bN26gX79+sLGxwU8//YSUlBRER0ejadOmKCwsBADI5XI4OjpCJpM91mfZ29tDYWJSF2EDuHcebGxsYGFhUWf1qg0bNgx//vknYmNjce7cOezYsQP+/v7Iycmp889Sa0h9i4iIiOhJ2Hs6A2+sP46cgjKt45l5xXhj/XEm8w2I3hP5TZs2YcaMGYiIiMDx48fh7e2NwMBAzQjog+Li4jB79mxEREQgJSUF33zzDTZt2oS5c+c+cp11pbC0sNaPO6o7mvffUd1BYWkhbpfdrrbe2nJ0dNQ8rKysIJPJtI6Zm5tryiYlJcHHxwcKhQLdu3dHamqq5rUFCxagY8eOWLNmDVxdXWFyNxnNzc1FSEgI7O3tYWlpib59++LEiROa9504cQJ9+vSBhYUFLC0t0aVLFxxT7x55108//QRPT0+Ym5tj4MCByMi49w+NSqXC+++/j+bNm8PY2BgdO3bE3r17H/qdd+/eDXd3d5iamqJPnz64dOnSQ8sfPHgQeXl5WLNmDTp16gRXV1f06dMHn376KVxdXQFUnFqvXhawc+dOeHh4QKFQYPjw4SgqKkJsbCxcXFzQuHFjTJ06FUrlvVt/uLi5IWrTJsCo8s1HZs2aBXd3dygUCrRq1Qrh4eEoK7v3D3JV5+H+qfX+/v64fPkypk+frpl5UVhYCEtLS2zevFnr87Zt2wYzMzPcunWrQiy5ubk4cOAAlixZgj59+qBly5bw9fXFnDlz8OKLL2qVmzRpEhwcHGBiYoJ27dph586dmtd/+OEHPPPMMzA2NoaLiws++eQTrc9xcXHBokWLMHbsWFhaWmLixIkAgN9//x09e/bU/HA3depUzQ8rRPWGnV35g+h+7Be6xzbWPV21sdTq1XXddUCpElj44xmoJ9HnmFoix9QSADTHFv54pn5Ps5div9ATvW9huHz5coSGhmL8+PEAgNWrV2PXrl1Yu3YtZs+eXaH8oUOH0KNHD4wePRpA+f/8jxo1Cn/88ccj11lXzCPNqy/0gO+Gf4eXn3kZALA1ZStGbB6B3i17IyE4QVPG5TMX3Cy6qfU+EaG7C3DevHn45JNPYG9vj8mTJ+P111/XmkJ94cIF/PDDD9iyZQsMDQ0BAC+//DJMTU2xZ88eWFlZ4auvvkK/fv1w7tw52NjYYMyYMejUqRNWrVoFQ0NDJCcno1Gje2t3ioqKsGzZMqxbtw4GBgZ49dVXMXPmTHz77bcAgM8++wyffPIJvvrqK3Tq1Alr167Fiy++iL/++gtt2rSp8B2uXr2KoUOHYsqUKZg4cSKOHTuGt99++6Hf29HREXfu3MHWrVsxfPjwGo+6FxUVYcWKFdi4cSNu3bqFoUOH4qWXXoK1tTV2796NixcvYtiwYejRowdGjhx5743NmgEdO1Zap4WFBWJiYtC0aVOcOnUKoaGhsLCwwLvvvvvQ83C/LVu2wNvbGxMnTkRoaCgAwMzMDK+88gqio6MxfPhwTVn135WN5pubm8Pc3Bzbtm3Ds88+C2Nj4wplVCoVBg0ahFu3bmH9+vVwc3PDmTNnNHElJSVhxIgRWLBgAUaOHIlDhw7hzTffhK2tLYKDgzX1LFu2DPPnz0dERAQAIC0tDQMHDsQHH3yAtWvX4saNGwgLC0NYWBiio6OrPilET5KZGXDjhr6joPqG/UL32Ma6p6s2llq9uq67jiSm/4OMvPJZyrflJugyNU7rdQEgI68Yien/oJubrR4irIYU+4Ue6TWRLy0tRVJSEubMmaM5ZmBggICAABw+fLjS93Tv3h3r169HYmIifH19cfHiRezevRuvvfbaI9dZUlKCkpISzd/5+fl18fUka/HixejduzcAYPbs2XjhhRdQXFysGfUtLS3F//73P9jb2wMoHzFNTExEdna2JslbtmwZtm3bhs2bN2PixIm4cuUK3nnnHbRt2xYAKiTfZWVlWL16Ndzc3AAAYWFheP/99zWvL1u2DLNmzcIrr7wCAFiyZAl+++03REVFYeXKlRW+w6pVq+Dm5qYZ9fXw8MCpU6ewZMmSKr/3s88+i7lz52L06NGYPHkyfH190bdvX4wdOxYODg5Vvq+srEzzeQAwfPhwrFu3DllZWTA3N4eXlxf69OmD3377TTuRf4j33ntP89zFxQUzZ87Exo0btRL5B8/Dg2xsbGBoaAgLCws4OjpqjoeEhGjW+js5OSE7Oxu7d+/G//3f/1Vaj5GREWJiYhAaGorVq1ejc+fO6N27N1555RV06NABAPB///d/SExMREpKCtzd3QEArVq10tSxfPly9OvXD+Hh4QAAd3d3nDlzBh9//LFWIt+3b1+tH1xCQkIwZswYzSyDNm3aYMWKFejduzdWrVql6ZNERERET7vsW8XVF6pFOarf9JrI37x5E0qlskKS5ODggLNnz1b6ntGjR+PmzZt47rnnIITAnTt3MHnyZM3U+kepMzIyEgsXLnzs71Mwp6DW7zE2uje6+ZLnSyiYUwADmfaKh0tvXXrc0GpFnZwBgJOTEwAgOzsbzs7OAICWLVtqJY8nTpxAQUEBbG21f9m7ffs20tLSAAAzZsxASEgI1q1bh4CAALz88suaxBcAFAqF1t/qBBMo/2Hl+vXr6NGjh1b9PXr00Jq+f7+UlBT4+flpHevWrVu1333x4sWYMWMGfv31V/zxxx9YvXo1PvzwQ+zfvx/t27ev9D0Pxu7g4AAXFxet5QoODg61WtqxadMmrFixAmlpaSgoKMCdO3dgaWmpVebB81BTvr6+eOaZZxAbG4vZs2dj/fr1aNmyJXr16lXle4YNG4YXXngBBw4cwJEjR7Bnzx4sXboUa9asQXBwMJKTk9G8eXNNEv+glJQUDB48WOtYjx49EBUVBaVSqRm59/Hx0Spz4sQJnDx5UjMzAwCEEFCpVEhPT4enp2etvz8RERFRQ9TEomYDHDUtR/Wb3tfI11ZCQgI+/PBDfPnllzh+/Di2bNmCXbt2ae3UXVtz5sxBXl6e5nH16tVHqsdMblbrh5HBvd9SjAyMYCY3g2kj02rr1aX7p7yrp5erVKp78Zhpf35BQQGcnJyQnJys9UhNTcU777wDoHxN919//YUXXngBv/76K7y8vLB169ZKP1P9uULoZ/2Ora0tXn75ZSxbtgwpKSlo2rQpli1bVmX5ymKv7Nj9bQgAyM4GUlOBB44fPnwYY8aMwfPPP4+dO3fizz//xLx58yps/vbgeaiNkJAQxMTEACifVj9+/PhqlxKYmJigf//+CA8Px6FDhxAcHKyZAm9qavrQ99ZUZX1r0qRJWv3qxIkTOH/+vNaPJ0R6dfs24O9f/rh9u7rS9LRgv9A9trHu6aqNpVavruuuI76uNnCyMoEMgHFZCTbGzcbGuNkwLiufeSwD4GRlAl9XG73GWSUp9gs90uuIvJ2dHQwNDZGVlaV1PCsrS2sq8P3Cw8Px2muvISQkBADQvn17FBYWYuLEiZg3b94j1WlsbFzpul+qmc6dOyMzMxNGRkZwcXGpspy7uzvc3d0xffp0jBo1CtHR0XjppZeqrd/S0hJNmzbFwYMHNVP+gfLN6Xx9fSt9j6enJ3bs2KF17MiRIzX7QveRy+Vwc3PTzeZqxcXArVvAAz9YHDp0CC1btsS8efM0xy5fvvxIHyGXy7U22VN79dVX8e6772LFihU4c+YMxo0bV+u6vby8sG3bNgDlsziuXbuGc+fOVToq7+npWeFWdQcPHoS7u3ul6/vVOnfujDNnzqB169a1jo/oiVGpgH377j0nAtgvngS2se7pqo2lVq+u664jhgYyRAR54Y31x2EoBJ69ehoAYCAE1MM1EUFeMDR4vLsv6YwU+4Ue6XVEXi6Xo0uXLoiPj9ccU6lUiI+Pr3IadFFREQwMtMNWJwJCiEeqkx5PQEAAunXrhiFDhuDnn3/GpUuXcOjQIcybNw/Hjh3D7du3ERYWhoSEBFy+fBkHDx7E0aNHazUt+p133sGSJUuwadMmpKamYvbs2UhOTsZbb71VafnJkyfj/PnzeOedd5Camoq4uDjNCHRVdu7ciVdffRU7d+7EuXPnkJqaimXLlmH37t0VpoXrUps2bXDlyhVs3LgRaWlpWLFihdbshdpwcXHB/v378ffff+PmzXsbJjZu3BhDhw7FO++8gwEDBqB58+ZV1pGTk4O+ffti/fr1OHnyJNLT0/H9999j6dKlmnbp3bs3evXqhWHDhuGXX35Beno69uzZo7mzwNtvv434+HgsWrQI586dQ2xsLL744otqb3s4a9YsHDp0CGFhYUhOTsb58+exfft2hIWFPVJ7EBERETVkA9s5YdWrneFgpT1I6WhlglWvdsbAdk56iozqmt53rZ8xYwbGjRsHHx8f+Pr6IioqCoWFhZod58eOHYtmzZohMjISABAUFITly5ejU6dO8PPzw4ULFxAeHo6goCBNQl9dnVS3ZDIZdu/ejXnz5mH8+PG4ceMGHB0d0atXLzg4OMDQ0BA5OTkYO3YssrKyYGdnh6FDh9ZqX4KpU6ciLy8Pb7/9NrKzs+Hl5YUdO3ZUumM9ADg7O+OHH37A9OnT8fnnn8PX1xcffvghXn/99So/w8vLCwqFAm+//TauXr0KY2NjtGnTBmvWrNFspvgkvPjii5g+fTrCwsJQUlKCF154AeHh4ViwYEGt63r//fcxadIkuLm5oaSkRGu5woQJExAXF/fQNgHKd6338/PDp59+irS0NJSVlaFFixYIDQ3Vuu3jDz/8gJkzZ2LUqFEoLCxE69at8dFHHwEoH1n/7rvvMH/+fCxatAhOTk54//33tTa6q0yHDh2wb98+zJs3Dz179oQQAm5ubjXeNJCIiIjoaTOwnRP6t/QHFpT/HTO+K3yeaVF/R+LpkciEvhYi3+eLL77Axx9/jMzMTHTs2BErVqzQbFTm7+8PFxcXzWjqnTt3sHjxYqxbtw5///037O3tERQUhMWLF8Pa2rpGdVYnPz8fVlZWyMvLq7DBWHFxMdLT07Xu3U1Ua0ol8Oef5c87dQIeMr1cV9atW4fp06fj+vXrkMvlT/zzdYHXJ+lFYSGg3tyyoKD8NjdE7Be6xzbWPV21sdTq1XXduiC1eAFp9os69rA89EH1IpGvb5jIk87pMZEvKipCRkYGXnzxRQwZMgSLFy9+Yp+ta7w+SS8k9D8I9ASxX+ge21j3pJZYMZG/R2rxAtLsF3WsNom85HatJ6LHs3TpUrRt2xaOjo6YM2eOvsMhIiIiIqJa0vsaeaKnloF+fkdbsGDBI623J6KHUCj0HQHVR+wXusc21j1dtbHU6tV13bogtXgBafYLPWEiT6QPhoZA5876joKI6oKZWfm0PaL7sV/oHttY93TVxlKrV9d164LU4gWk2S/0iFPrHxG3FiCqf3hdEhEREdHTgIl8LTVq1AhA+YZhRFS/qK9L9XVKRERERNQQcWp9LRkaGsLa2hrZ2dkAAIVCAZmM92SkWlKpgCtXyp87O+ttvXxDIYRAUVERsrOzYW1tDUM93M6PnmLFxcCwYeXPf/gB4B0TCGC/eBLYxrqnqzaWWr26rlsXpBYvIM1+oUe8/Vwlqtv2XwiBzMxM5ObmPvngqGFQqYCrV8uft2jBRL6OWFtbw9HRkT+u0ZMlodva0BPEfqF7bGPdk9rtwHj7uXukFi8gzX5Rx2pz+zmOyD8CmUwGJycnNGnSBGVlZfoOh6SoqAh44YXy58ePN8idNJ+0Ro0acSSeiIiIiJ4KTOQfg6GhIRMHejRKJXD5cvlzY+MGM8WHiIiIiIh0j/N5iYiIiIiIiCSEiTwRERERERGRhDCRJyIiIiIiIpIQrpGvhHoj//z8fD1HQg1WYeG95/n55WvmiUiaeD1TZdgvdI9trHu6amOp1avrunVBavEC0uwXdUydf9bkxnK8/Vwlrl27hhYtWug7DCIiIiIiInrKXL16Fc2bN39oGSbylVCpVLh+/TosLCzq9f2o8/Pz0aJFC1y9erXa+wxS/cPzJ108d9LFcyddPHfSxvMnXTx30sVzJz1CCNy6dQtNmzaFgcHDV8Fzan0lDAwMqv0FpD6xtLTkxSlhPH/SxXMnXTx30sVzJ208f9LFcyddPHfSYmVlVaNy3OyOiIiIiIiISEKYyBMRERERERFJCBN5CTM2NkZERASMjY31HQo9Ap4/6eK5ky6eO+niuZM2nj/p4rmTLp67ho2b3RERERERERFJCEfkiYiIiIiIiCSEiTwRERERERGRhDCRJyIiIiIiIpIQJvJEREREREREEsJEXsJWrlwJFxcXmJiYwM/PD4mJifoOiaqxYMECyGQyrUfbtm31HRZVYf/+/QgKCkLTpk0hk8mwbds2rdeFEJg/fz6cnJxgamqKgIAAnD9/Xj/Bkpbqzl1wcHCFa3HgwIH6CZa0REZGomvXrrCwsECTJk0wZMgQpKamapUpLi7GlClTYGtrC3NzcwwbNgxZWVl6ipjUanLu/P39K1x7kydP1lPEpLZq1Sp06NABlpaWsLS0RLdu3bBnzx7N67zm6q/qzh2vuYaLibxEbdq0CTNmzEBERASOHz8Ob29vBAYGIjs7W9+hUTWeeeYZZGRkaB6///67vkOiKhQWFsLb2xsrV66s9PWlS5dixYoVWL16Nf744w+YmZkhMDAQxcXFTzhSelB15w4ABg4cqHUtbtiw4QlGSFXZt28fpkyZgiNHjuCXX35BWVkZBgwYgMLCQk2Z6dOn48cff8T333+Pffv24fr16xg6dKgeoyagZucOAEJDQ7WuvaVLl+opYlJr3rw5PvroIyQlJeHYsWPo27cvBg8ejL/++gsAr7n6rLpzB/Caa7AESZKvr6+YMmWK5m+lUimaNm0qIiMj9RgVVSciIkJ4e3vrOwx6BADE1q1bNX+rVCrh6OgoPv74Y82x3NxcYWxsLDZs2KCHCKkqD547IYQYN26cGDx4sF7iodrJzs4WAMS+ffuEEOXXWaNGjcT333+vKZOSkiIAiMOHD+srTKrEg+dOCCF69+4t3nrrLf0FRTXWuHFjsWbNGl5zEqQ+d0LwmmvIOCIvQaWlpUhKSkJAQIDmmIGBAQICAnD48GE9RkY1cf78eTRt2hStWrXCmDFjcOXKFX2HRI8gPT0dmZmZWtehlZUV/Pz8eB1KREJCApo0aQIPDw+88cYbyMnJ0XdIVIm8vDwAgI2NDQAgKSkJZWVlWtde27Zt4ezszGuvnnnw3Kl9++23sLOzQ7t27TBnzhwUFRXpIzyqglKpxMaNG1FYWIhu3brxmpOQB8+dGq+5hslI3wFQ7d28eRNKpRIODg5axx0cHHD27Fk9RUU14efnh5iYGHh4eCAjIwMLFy5Ez549cfr0aVhYWOg7PKqFzMxMAKj0OlS/RvXXwIEDMXToULi6uiItLQ1z587FoEGDcPjwYRgaGuo7PLpLpVJh2rRp6NGjB9q1aweg/NqTy+WwtrbWKstrr36p7NwBwOjRo9GyZUs0bdoUJ0+exKxZs5CamootW7boMVoCgFOnTqFbt24oLi6Gubk5tm7dCi8vLyQnJ/Oaq+eqOncAr7mGjIk80RM0aNAgzfMOHTrAz88PLVu2xHfffYcJEyboMTKip8srr7yied6+fXt06NABbm5uSEhIQL9+/fQYGd1vypQpOH36NPcSkaCqzt3EiRM1z9u3bw8nJyf069cPaWlpcHNze9Jh0n08PDyQnJyMvLw8bN68GePGjcO+ffv0HRbVQFXnzsvLi9dcA8ap9RJkZ2cHQ0PDCruFZmVlwdHRUU9R0aOwtraGu7s7Lly4oO9QqJbU1xqvw4ahVatWsLOz47VYj4SFhWHnzp347bff0Lx5c81xR0dHlJaWIjc3V6s8r736o6pzVxk/Pz8A4LVXD8jlcrRu3RpdunRBZGQkvL298dlnn/Gak4Cqzl1leM01HEzkJUgul6NLly6Ij4/XHFOpVIiPj9daD0P1X0FBAdLS0uDk5KTvUKiWXF1d4ejoqHUd5ufn448//uB1KEHXrl1DTk4Or8V6QAiBsLAwbN26Fb/++itcXV21Xu/SpQsaNWqkde2lpqbiypUrvPb0rLpzV5nk5GQA4LVXD6lUKpSUlPCakyD1uasMr7mGg1PrJWrGjBkYN24cfHx84Ovri6ioKBQWFmL8+PH6Do0eYubMmQgKCkLLli1x/fp1REREwNDQEKNGjdJ3aFSJgoICrV+s09PTkZycDBsbGzg7O2PatGn44IMP0KZNG7i6uiI8PBxNmzbFkCFD9Bc0AXj4ubOxscHChQsxbNgwODo6Ii0tDe+++y5at26NwMBAPUZNQPmU7Li4OGzfvh0WFhaaNbhWVlYwNTWFlZUVJkyYgBkzZsDGxgaWlpb473//i27duuHZZ5/Vc/RPt+rOXVpaGuLi4vD888/D1tYWJ0+exPTp09GrVy906NBBz9E/3ebMmYNBgwbB2dkZt27dQlxcHBISEvDTTz/xmqvnHnbueM01cPreNp8e3eeffy6cnZ2FXC4Xvr6+4siRI/oOiaoxcuRI4eTkJORyuWjWrJkYOXKkuHDhgr7Doir89ttvAkCFx7hx44QQ5begCw8PFw4ODsLY2Fj069dPpKam6jdoEkI8/NwVFRWJAQMGCHt7e9GoUSPRsmVLERoaKjIzM/UdNglR6XkDIKKjozVlbt++Ld58803RuHFjoVAoxEsvvSQyMjL0FzQJIao/d1euXBG9evUSNjY2wtjYWLRu3Vq88847Ii8vT7+Bk3j99ddFy5YthVwuF/b29qJfv37i559/1rzOa67+eti54zXXsMmEEOJJ/nBARERERERERI+Oa+SJiIiIiIiIJISJPBEREREREZGEMJEnIiIiIiIikhAm8kREREREREQSwkSeiIiIiIiISEKYyBMRERERERFJCBN5IiIiIiIiIglhIk9ERET0BMlkMmzbtk3fYRARkYQxkScioqdKcHAwZDIZZDIZGjVqBAcHB/Tv3x9r166FSqXSd3hPTExMDKytrastp1Qq8dFHH6Ft27YwNTWFjY0N/Pz8sGbNGt0H+YQEBwdjyJAhdVaOiIhI14z0HQAREdGTNnDgQERHR0OpVCIrKwt79+7FW2+9hc2bN2PHjh0wMuJ/HtUWLlyIr776Cl988QV8fHyQn5+PY8eO4d9//9V3aERERE8tjsgTEdFTx9jYGI6OjmjWrBk6d+6MuXPnYvv27dizZw9iYmI05a5cuYLBgwfD3NwclpaWGDFiBLKysrTq+vHHH9G1a1eYmJjAzs4OL730kua1yqZQW1tbaz7j0qVLkMlk+O6779CzZ0+Ympqia9euOHfuHI4ePQofHx+Ym5tj0KBBuHHjhlY9a9asgaenJ0xMTNC2bVt8+eWXmtfU9W7ZsgV9+vSBQqGAt7c3Dh8+DABISEjA+PHjkZeXp5mdsGDBgkrbaseOHXjzzTfx8ssvw9XVFd7e3pgwYQJmzpypKaNSqRAZGQlXV1eYmprC29sbmzdvrlBPmzZtYGJigj59+iA2NhYymQy5ubkA7s0Q2LlzJzw8PKBQKDB8+HAUFRUhNjYWLi4uaNy4MaZOnQqlUqmpt6SkBDNnzkSzZs1gZmYGPz8/JCQkaF5X1/vTTz/B09MT5ubmGDhwIDIyMgAACxYsQGxsLLZv365pi/vf/zD+/v6YOnUq3n33XdjY2MDR0bFCO54/fx69evWCiYkJvLy88Msvv1So5+rVqxgxYgSsra1hY2ODwYMH49KlSwCAs2fPQqFQIC4uTlP+u+++g6mpKc6cOVOjOImIqAESRERET5Fx48aJwYMHV/qat7e3GDRokBBCCKVSKTp27Ciee+45cezYMXHkyBHRpUsX0bt3b035nTt3CkNDQzF//nxx5swZkZycLD788EPN6wDE1q1btT7DyspKREdHCyGESE9PFwBE27Ztxd69e8WZM2fEs88+K7p06SL8/f3F77//Lo4fPy5at24tJk+erKlj/fr1wsnJSfzwww/i4sWL4ocffhA2NjYiJiamQr07d+4UqampYvjw4aJly5airKxMlJSUiKioKGFpaSkyMjJERkaGuHXrVqVtEhgYKHr16iWys7OrbNMPPvhA8x3S0tJEdHS0MDY2FgkJCUIIIS5evCgaNWokZs6cKc6ePSs2bNggmjVrJgCIf//9VwghRHR0tGjUqJHo37+/OH78uNi3b5+wtbUVAwYMECNGjBB//fWX+PHHH4VcLhcbN27UfHZISIjo3r272L9/v7hw4YL4+OOPhbGxsTh37pxWvQEBAeLo0aMiKSlJeHp6itGjRwshhLh165YYMWKEGDhwoKYtSkpKKv2eD/ad3r17C0tLS7FgwQJx7tw5ERsbK2Qymfj555+FEOV9qF27dqJfv34iOTlZ7Nu3T3Tq1EmrX5SWlgpPT0/x+uuvi5MnT4ozZ86I0aNHCw8PD00cK1euFFZWVuLy5cvi6tWronHjxuKzzz6r8nwQEVHDx0SeiIieKg9L5EeOHCk8PT2FEEL8/PPPwtDQUFy5ckXz+l9//SUAiMTERCGEEN26dRNjxoyp8rNqmsivWbNG8/qGDRsEABEfH685FhkZKTw8PDR/u7m5ibi4OK16Fy1aJLp161ZlverYU1JShBDlCa6VlVWVsd//Pk9PT2FgYCDat28vJk2aJHbv3q15vbi4WCgUCnHo0CGt902YMEGMGjVKCCHErFmzRLt27bRenzdvXoVEHoC4cOGCpsykSZOEQqHQ+pEhMDBQTJo0SQghxOXLl4WhoaH4+++/teru16+fmDNnTpX1rly5Ujg4OGj+flifuF9lifxzzz2nVaZr165i1qxZQgghfvrpJ2FkZKQV3549e7T6xbp164SHh4dQqVSaMiUlJcLU1FT89NNPmmMvvPCC6Nmzp+jXr58YMGCAVnkiInr6cBEgERHRXUIIyGQyAEBKSgpatGiBFi1aaF738vKCtbU1UlJS0LVrVyQnJyM0NPSxP7dDhw6a5w4ODgCA9u3bax3Lzs4GABQWFiItLQ0TJkzQ+uw7d+7AysqqynqdnJwAANnZ2Wjbtm2NY/Py8sLp06eRlJSEgwcPYv/+/QgKCkJwcDDWrFmDCxcuoKioCP3799d6X2lpKTp16gQASE1NRdeuXbVe9/X1rfBZCoUCbm5uWt/bxcUF5ubmlbbFqVOnoFQq4e7urlVPSUkJbG1tq6zXyclJU8fjur+NH6xb3YeaNm2qeb1bt25a5U+cOIELFy7AwsJC63hxcTHS0tI0f69duxbu7u4wMDDAX3/9pemnRET0dGIiT0REdFdKSgpcXV1rXN7U1PShr8tkMgghtI6VlZVVKNeoUSOt91R2TL2jfkFBAQDg66+/hp+fn1Y9hoaG1db7KDvzGxgYoGvXrujatSumTZuG9evX47XXXsO8efM08ezatQvNmjXTep+xsXGtPuf+eNUxV3bs/rYwNDREUlJShe9+f/JfWR0PnpdH9bD4aqKgoABdunTBt99+W+E1e3t7zfMTJ06gsLAQBgYGyMjI0PwwQ0RETycm8kRERAB+/fVXnDp1CtOnTwcAeHp64urVq7h69apmVP7MmTPIzc2Fl5cXgPLR2Pj4eIwfP77SOu3t7TWbqgHlG58VFRU9VpwODg5o2rQpLl68iDFjxjxyPXK5XGvTuNpQf//CwkJ4eXnB2NgYV65cQe/evSst7+Hhgd27d2sdO3r06CN99v06deoEpVKJ7Oxs9OzZ85HreZy2eBh1H7o/8T5y5IhWmc6dO2PTpk1o0qQJLC0tK63nn3/+QXBwMObNm4eMjAyMGTMGx48fr/aHJCIiari4az0RET11SkpKkJmZib///hvHjx/Hhx9+iMGDB+M///kPxo4dCwAICAhA+/btNUlTYmIixo4di969e8PHxwcAEBERgQ0bNiAiIgIpKSk4deoUlixZovmcvn374osvvsCff/6JY8eOYfLkyRVGcB/FwoULERkZiRUrVuDcuXM4deoUoqOjsXz58hrX4eLigoKCAsTHx+PmzZtV/sAwfPhwfPrpp/jjjz9w+fJlJCQkYMqUKXB3d0fbtm1hYWGBmTNnYvr06YiNjUVaWhqOHz+Ozz//HLGxsQCASZMm4ezZs5g1axbOnTuH7777TrNz/+NMEXd3d8eYMWMwduxYbNmyBenp6UhMTERkZCR27dpVq7Y4efIkUlNTcfPmzUpnTTyKgIAAuLu7Y9y4cThx4gQOHDiAefPmaZUZM2YM7OzsMHjwYBw4cADp6elISEjA1KlTce3aNQDA5MmT0aJFC7z33ntYvnw5lEql1l0DiIjo6cNEnoiInjp79+6Fk5MTXFxcMHDgQPz2229YsWIFtm/frpmiLZPJsH37djRu3Bi9evVCQEAAWrVqhU2bNmnq8ff3x/fff48dO3agY8eO6Nu3LxITEzWvf/LJJ2jRogV69uyJ0aNHY+bMmVAoFI8df0hICNasWYPo6Gi0b98evXv3RkxMTK2WBXTv3h2TJ0/GyJEjYW9vj6VLl1ZaLjAwED/++COCgoI0SWnbtm3x888/w8iofGLfokWLEB4ejsjISHh6emLgwIHYtWuXJh5XV1ds3rwZW7ZsQYcOHbBq1SpNQlvb6fcPio6OxtixY/H222/Dw8MDQ4YMwdGjR+Hs7FzjOkJDQ+Hh4QEfHx/Y29vj4MGDjxWTmoGBAbZu3Yrbt2/D19cXISEhWLx4sVYZhUKB/fv3w9nZGUOHDoWnpycmTJiA4uJiWFpa4n//+x92796NdevWwcjICGZmZli/fj2+/vpr7Nmzp07iJCIi6ZGJulokRkRERFRDixcvxurVq3H16lV9h0JERCQ5XCNPREREOvfll1+ia9eusLW1xcGDB/Hxxx8jLCxM32ERERFJEhN5IiIi0rnz58/jgw8+wD///ANnZ2e8/fbbmDNnjr7DIiIikiROrSciIiIiIiKSEG52R0RERERERCQhTOSJiIiIiIiIJISJPBEREREREZGEMJEnIiIiIiIikhAm8kREREREREQSwkSeiIiIiIiISEKYyBMRERERERFJCBN5IiIiIiIiIglhIk9EREREREQkIf8PN79Ii6tLK5kAAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -91,49 +100,49 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Split 1, tokens 218:\n",
+      "Split 1, tokens 218, triggered by: 0.85\n",
       "\u001b[31mIn a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\" The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor. One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth.\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
       "\n",
-      "Split 2, tokens 262:\n",
+      "Split 2, tokens 262, triggered by: token limit\n",
       "\u001b[32mWhile the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously. Discussions on the platform draw attention to a variety of issues that those who earn money the hard way might face. For example, they are described as likely having to work overtime, forgo time off for illness or rest, and maintain an unyielding dedication to their occupation, which often results in a never-ending cycle of work without any perceived progression in their lives. Another tweet that captures this sentiment reads, \"Drowning in more work and poverty despite trying harder and harder,\" pointing to a sense of despair and dissatisfaction that comes with work that is both disproportionately demanding and inadequately rewarding. Critics also note how the pursuit of hard-earned money could potentially create physical and mental health risks due to the unrelenting pressure and stress that these jobs might impose. Conversely, those in favor of earning money with less difficulty contend that it's crucial to harness one's strengths and passions to create opportunities that yield financial success without the need for excessive labor. The debate revolves around the concept that people should seek out ways to work smarter, not harder, especially if it means a healthier and more fulfilling lifestyle.\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
       "\n",
-      "Split 3, tokens 137:\n",
+      "Split 3, tokens 137, triggered by: 0.85\n",
       "\u001b[34mIn fact, the notion of a \"vicious cycle,\" often attributed to those chasing hard-earned money, is juxtaposed with an idealized image of someone operating in their zone of excellence. Confidently focused on their strengths, such individuals are depicted as enjoying a more relaxed and less stressful work environment, one in which they can thrive without the need for never-ending overtime or self-sacrifice. Some tweets even extend this sentiment to the broader socio-economic context, observing how wealth is not merely derived from manual labor or high-paying positions requiring extraordinary work hours. The tweets emphasize the importance of cultivating an entrepreneurial spirit and a penchant for innovative thinking, especially in the modern digital age.\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
       "\n",
-      "Split 4, tokens 249:\n",
+      "Split 4, tokens 249, triggered by: 0.86\n",
       "\u001b[35mOne user writes, \"Too hard-earned money isn't worth it. Learn how to make money using your brain, not your body,\" while another suggests, \"Love will flow towards those who are not lacking in love, and money will flow towards those who are not lacking in money!\" While some of the discussions take a somewhat passive-aggressive view, others acknowledge that financial security and comfort might not always be possible for everyone. In a more realistic tone, a user remarks, \"If life were so easy that diligence led to wealth, then the world's richest person would be the best worker bee. But that's not the case.\" This acknowledgment underscores the complexities of the economy and the role that factors like luck, connections, and a rapidly evolving job market can play in financial success. Some users are quick to criticize the notion that earning money the hard way should be avoided, with one tweet expressing, \"The person who advises you to avoid hard-earned money is likely a scammer who profits off providing emotional value in exchange for exploitation.\" Others argue that while it's essential to find enjoyment and fulfillment in one's work, it's crucial not to shun or belittle those who choose to work in physically demanding or high-paying industries.\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
       "\n",
-      "Split 5, tokens 117:\n",
+      "Split 5, tokens 117, triggered by: 0.87\n",
       "\u001b[31mOverall, the Weibo discussions offer a fascinating insight into the complexities of the modern Chinese labor market and the work-life balance that people strive to achieve. As in many countries, striking the right balance between work and play is an ongoing challenge for many Chinese citizens. However, the conversations on Weibo signal an increasing awareness of the importance of finding meaningful, fulfilling, and financially rewarding work that doesn't necessitate excessive sacrifice or sufferance. In the end, as one user succinctly puts it, \"Make sure you're earning your money in a way that brings you joy and satisfaction.\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
       "\n",
-      "Split 6, tokens 171:\n",
+      "Split 6, tokens 171, triggered by: 0.82\n",
       "\u001b[32mThat's the only way to ensure that your life doesn't become a never-ending cycle of hard work without any tangible progress.\" In this context, social media discussions focusing on the trials and tribulations of earning money serve not only as an outlet for venting frustrations but also as a means of promoting dialogue and shared understanding about the challenges faced by workers across all industries. These virtual conversations sparked by tweets and in-depth discussions likely resonate with a wide swath of Chinese citizens struggling to navigate the complexities of balancing a career that pays well with one that brings them joy, fulfillment, and a sense of purpose. As the discussions on Weibo continue to evolve and unfold, it is evident that the discourse around work, money, and life satisfaction holds the potential to inspire meaningful change and shift societal attitudes towards a more holistic, balanced, and humane understanding of success and prosperity.\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
       "\n",
-      "Split 7, tokens 72:\n",
+      "Split 7, tokens 72, triggered by: 0.80\n",
       "\u001b[34m--- Note: The translated tweets and user quotes from Chinese to English were used as the foundation for the long-form news article. The author tried to maintain the integrity of the original content in the translation while adapting it to fit a journalistic format. No inaccuracies were introduced during translation, and the opinion-based nature of the original content was preserved while maintaining objectivity.\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
       "\n",
-      "Split 8, tokens 23:\n",
+      "Split 8, tokens 23, triggered by: final split\n",
       "\u001b[35mHeart count: 0/2 Note: The author did not include any Chinese characters in the final response. Collapse\u001b[0m\n",
       "----------------------------------------------------------------------------------------\n",
       "\n",
@@ -146,13 +155,6 @@
     "\n",
     "plot_splits(splits)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
index 030719de..f9137ae9 100644
--- a/semantic_router/splitters/rolling_window.py
+++ b/semantic_router/splitters/rolling_window.py
@@ -245,7 +245,7 @@ def plot_similarity_scores(
         plt.ylabel("Similarity Score")
         plt.title(
             f"Threshold: {self.calculated_threshold} |"
-            " Window Size: {self.window_size}",
+            f" Window Size: {self.window_size}",
             loc="right",
             fontsize=10,
         )
diff --git a/semantic_router/splitters/utils.py b/semantic_router/splitters/utils.py
index 04e3c8b5..43e7b68e 100644
--- a/semantic_router/splitters/utils.py
+++ b/semantic_router/splitters/utils.py
@@ -73,7 +73,17 @@ def plot_splits(document_splits: List[DocumentSplit]) -> None:
     for i, split in enumerate(document_splits):
         color = colors[i % len(colors)]
         colored_content = f"{color}{split.content}{Style.RESET_ALL}"
-        print(f"Split {i + 1}, tokens {split.token_count}:")
+        if split.is_triggered:
+            triggered = f"{split.triggered_score:.2f}"
+        elif i == len(document_splits) - 1:
+            triggered = "final split"
+        else:
+            triggered = "token limit"
+        print(
+            f"Split {i + 1}, "
+            f"tokens {split.token_count}, "
+            f"triggered by: {triggered}"
+        )
         print(colored_content)
         print("-" * 88)
         print("\n")

From 022335fc36421f4fe2cc98696783112124ca6a3a Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 10:26:06 +0200
Subject: [PATCH 07/14] chore: Merge main

---
 docs/examples/text_semantic_split.ipynb | 38 ++++++++++++-------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/docs/examples/text_semantic_split.ipynb b/docs/examples/text_semantic_split.ipynb
index c7ef2f7c..cc514e02 100644
--- a/docs/examples/text_semantic_split.ipynb
+++ b/docs/examples/text_semantic_split.ipynb
@@ -39,7 +39,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/jakit/customers/aurelio/semantic-router/.venv/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "/Users/jakit/customers/aurelio/semantic-router/.venv/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
       "  from .autonotebook import tqdm as notebook_tqdm\n"
      ]
     }
@@ -65,27 +65,27 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "\u001b[33m2024-02-23 10:17:52 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881252553216503\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781252553216503\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.8687915616817252\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.8587915616817252\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Final optimal threshold: 0.8687915616817252\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.8687915616817252.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:17:53 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
+      "\u001b[33m2024-02-23 10:25:30 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881252553216499\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781252553216499\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.8687907643329578\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.8587907643329578\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Final optimal threshold: 0.8687907643329578\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
+      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -173,7 +173,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,

From a063d42b1792c3118e4d69e668c36a01f2086c53 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 10:32:56 +0200
Subject: [PATCH 08/14] chore: lint + removed test coverage threshold

---
 Makefile                                    | 2 +-
 semantic_router/llms/ollama.py              | 1 +
 semantic_router/schema.py                   | 2 +-
 semantic_router/splitters/rolling_window.py | 1 +
 tests/unit/llms/test_llm_ollama.py          | 1 +
 5 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index adf4eb0c..3891e912 100644
--- a/Makefile
+++ b/Makefile
@@ -12,4 +12,4 @@ lint lint_diff:
 	poetry run mypy $(PYTHON_FILES)
 
 test:
-	poetry run pytest -vv -n 20 --cov=semantic_router --cov-report=term-missing --cov-report=xml --cov-fail-under=80
+	poetry run pytest -vv -n 20 --cov=semantic_router --cov-report=term-missing --cov-report=xml
diff --git a/semantic_router/llms/ollama.py b/semantic_router/llms/ollama.py
index 1c5dfed5..df35ac06 100644
--- a/semantic_router/llms/ollama.py
+++ b/semantic_router/llms/ollama.py
@@ -1,4 +1,5 @@
 from typing import List, Optional
+
 import requests
 
 from semantic_router.llms import BaseLLM
diff --git a/semantic_router/schema.py b/semantic_router/schema.py
index b8ab498c..88419021 100644
--- a/semantic_router/schema.py
+++ b/semantic_router/schema.py
@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Any, List, Optional
+from typing import List, Optional
 
 from pydantic.v1 import BaseModel
 from pydantic.v1.dataclasses import dataclass
diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
index 6d8b6751..1f84f597 100644
--- a/semantic_router/splitters/rolling_window.py
+++ b/semantic_router/splitters/rolling_window.py
@@ -1,4 +1,5 @@
 from typing import List
+
 import numpy as np
 
 from semantic_router.encoders.base import BaseEncoder
diff --git a/tests/unit/llms/test_llm_ollama.py b/tests/unit/llms/test_llm_ollama.py
index 29998982..369e5f44 100644
--- a/tests/unit/llms/test_llm_ollama.py
+++ b/tests/unit/llms/test_llm_ollama.py
@@ -1,4 +1,5 @@
 import pytest
+
 from semantic_router.llms.ollama import OllamaLLM
 from semantic_router.schema import Message
 

From 8e2626af54fba6afe75a88277b4278701678e219 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 11:01:18 +0200
Subject: [PATCH 09/14] fix: Fix inheritance with BaseSplitter

---
 docs/examples/text_semantic_split.ipynb     | 38 +++++++++---------
 semantic_router/splitters/base.py           | 44 +++++++++++----------
 semantic_router/splitters/rolling_window.py |  8 +++-
 semantic_router/splitters/utils.py          | 20 ----------
 4 files changed, 48 insertions(+), 62 deletions(-)

diff --git a/docs/examples/text_semantic_split.ipynb b/docs/examples/text_semantic_split.ipynb
index cc514e02..35f618a4 100644
--- a/docs/examples/text_semantic_split.ipynb
+++ b/docs/examples/text_semantic_split.ipynb
@@ -65,27 +65,27 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "\u001b[33m2024-02-23 10:25:30 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881252553216499\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781252553216499\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.8687907643329578\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.8587907643329578\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Final optimal threshold: 0.8687907643329578\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.8687907643329578.\u001b[0m\n",
-      "\u001b[32m2024-02-23 10:25:31 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
+      "\u001b[33m2024-02-23 11:00:31 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881277932028191\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781277932028191\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.868791983949652\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.858791983949652\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Final optimal threshold: 0.868791983949652\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.868791983949652.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.868791983949652.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.868791983949652.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.868791983949652.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.868791983949652.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.868791983949652.\u001b[0m\n",
+      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -151,9 +151,7 @@
     }
    ],
    "source": [
-    "from semantic_router.splitters.utils import plot_splits\n",
-    "\n",
-    "plot_splits(splits)"
+    "splitter.print(splits)"
    ]
   }
  ],
diff --git a/semantic_router/splitters/base.py b/semantic_router/splitters/base.py
index 87daedd1..8e68cd04 100644
--- a/semantic_router/splitters/base.py
+++ b/semantic_router/splitters/base.py
@@ -1,8 +1,7 @@
-from itertools import cycle
 from typing import List, Optional
 
-from pydantic.v1 import BaseModel
-from termcolor import colored
+from colorama import Fore, Style
+from pydantic.v1 import BaseModel, Extra
 
 from semantic_router.encoders import BaseEncoder
 from semantic_router.schema import DocumentSplit
@@ -11,25 +10,30 @@
 class BaseSplitter(BaseModel):
     name: str
     encoder: BaseEncoder
-    score_threshold: float
-    min_split_tokens: Optional[int] = None
-    max_split_tokens: Optional[int] = None
+    score_threshold: Optional[float]
+
+    class Config:
+        extra = Extra.allow
 
     def __call__(self, docs: List[str]) -> List[DocumentSplit]:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def print_splits(self, splits: list[DocumentSplit]):
-        colors = cycle(["red", "green", "blue", "magenta", "cyan"])
-        for i, split in enumerate(splits):
-            triggered_text = (
-                "Triggered " + format(split.triggered_score, ".2f")
-                if split.triggered_score
-                else "Not Triggered"
-            )
-            header = f"Split {i+1} - ({triggered_text})"
-            if split.triggered_score:
-                print(colored(header, "red"))
+    def print(self, document_splits: List[DocumentSplit]) -> None:
+        colors = [Fore.RED, Fore.GREEN, Fore.BLUE, Fore.MAGENTA]
+        for i, split in enumerate(document_splits):
+            color = colors[i % len(colors)]
+            colored_content = f"{color}{split.content}{Style.RESET_ALL}"
+            if split.is_triggered:
+                triggered = f"{split.triggered_score:.2f}"
+            elif i == len(document_splits) - 1:
+                triggered = "final split"
             else:
-                print(colored(header, "blue"))
-            print(colored(split.docs, next(colors)))  # type: ignore
-            print("\n" + "-" * 50 + "\n")
+                triggered = "token limit"
+            print(
+                f"Split {i + 1}, "
+                f"tokens {split.token_count}, "
+                f"triggered by: {triggered}"
+            )
+            print(colored_content)
+            print("-" * 88)
+            print("\n")
diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
index 1f84f597..4a746f7c 100644
--- a/semantic_router/splitters/rolling_window.py
+++ b/semantic_router/splitters/rolling_window.py
@@ -4,21 +4,25 @@
 
 from semantic_router.encoders.base import BaseEncoder
 from semantic_router.schema import DocumentSplit
+from semantic_router.splitters.base import BaseSplitter
 from semantic_router.splitters.utils import split_to_sentences, tiktoken_length
 from semantic_router.utils.logger import logger
 
 
-class RollingWindowSplitter:
+
+class RollingWindowSplitter(BaseSplitter):
     def __init__(
         self,
         encoder: BaseEncoder,
-        threshold_adjustment: float = 0.01,
+        threshold_adjustment=0.01,
         window_size=5,
         min_split_tokens=100,
         max_split_tokens=300,
         split_tokens_tolerance=10,
         plot_splits=False,
+        name = "rolling_window_splitter",
     ):
+        super().__init__(name=name, encoder=encoder)
         self.calculated_threshold: float
         self.encoder = encoder
         self.threshold_adjustment = threshold_adjustment
diff --git a/semantic_router/splitters/utils.py b/semantic_router/splitters/utils.py
index 43e7b68e..296df2ad 100644
--- a/semantic_router/splitters/utils.py
+++ b/semantic_router/splitters/utils.py
@@ -67,23 +67,3 @@ def tiktoken_length(text: str) -> int:
     tokens = tokenizer.encode(text, disallowed_special=())
     return len(tokens)
 
-
-def plot_splits(document_splits: List[DocumentSplit]) -> None:
-    colors = [Fore.RED, Fore.GREEN, Fore.BLUE, Fore.MAGENTA]
-    for i, split in enumerate(document_splits):
-        color = colors[i % len(colors)]
-        colored_content = f"{color}{split.content}{Style.RESET_ALL}"
-        if split.is_triggered:
-            triggered = f"{split.triggered_score:.2f}"
-        elif i == len(document_splits) - 1:
-            triggered = "final split"
-        else:
-            triggered = "token limit"
-        print(
-            f"Split {i + 1}, "
-            f"tokens {split.token_count}, "
-            f"triggered by: {triggered}"
-        )
-        print(colored_content)
-        print("-" * 88)
-        print("\n")

From ff2ed5f94090e66b606e516c5bb63cb96ae71178 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 11:10:19 +0200
Subject: [PATCH 10/14] chore: lint

---
 Makefile                                     |  4 ++--
 semantic_router/splitters/base.py            |  3 +--
 semantic_router/splitters/consecutive_sim.py |  3 ++-
 semantic_router/splitters/cumulative_sim.py  | 16 ++++++++++------
 semantic_router/splitters/rolling_window.py  |  3 +--
 semantic_router/splitters/utils.py           |  6 ------
 6 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/Makefile b/Makefile
index 3891e912..a7c69643 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
 format:
-	poetry run black --target-version py39 .
+	poetry run black --target-version py39 -l 88 .
 	poetry run ruff --select I --fix .
 
 PYTHON_FILES=.
@@ -7,7 +7,7 @@ lint: PYTHON_FILES=.
 lint_diff: PYTHON_FILES=$(shell git diff --name-only --diff-filter=d main | grep -E '\.py$$')
 
 lint lint_diff:
-	poetry run black --target-version py39 $(PYTHON_FILES) --check
+	poetry run black --target-version py39 -l 88 $(PYTHON_FILES) --check
 	poetry run ruff .
 	poetry run mypy $(PYTHON_FILES)
 
diff --git a/semantic_router/splitters/base.py b/semantic_router/splitters/base.py
index 8e68cd04..0514e014 100644
--- a/semantic_router/splitters/base.py
+++ b/semantic_router/splitters/base.py
@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List
 
 from colorama import Fore, Style
 from pydantic.v1 import BaseModel, Extra
@@ -10,7 +10,6 @@
 class BaseSplitter(BaseModel):
     name: str
     encoder: BaseEncoder
-    score_threshold: Optional[float]
 
     class Config:
         extra = Extra.allow
diff --git a/semantic_router/splitters/consecutive_sim.py b/semantic_router/splitters/consecutive_sim.py
index f30bbc75..4a2e1106 100644
--- a/semantic_router/splitters/consecutive_sim.py
+++ b/semantic_router/splitters/consecutive_sim.py
@@ -19,8 +19,9 @@ def __init__(
         name: str = "consecutive_similarity_splitter",
         score_threshold: float = 0.45,
     ):
-        super().__init__(name=name, score_threshold=score_threshold, encoder=encoder)
+        super().__init__(name=name, encoder=encoder)
         encoder.score_threshold = score_threshold
+        self.score_threshold = score_threshold
 
     def __call__(self, docs: List[Any]):
         # Check if there's only a single document
diff --git a/semantic_router/splitters/cumulative_sim.py b/semantic_router/splitters/cumulative_sim.py
index f7a6475a..e9dd8deb 100644
--- a/semantic_router/splitters/cumulative_sim.py
+++ b/semantic_router/splitters/cumulative_sim.py
@@ -8,9 +8,9 @@
 
 
 class CumulativeSimSplitter(BaseSplitter):
-
     """
-    Called "cumulative sim" because we check the similarities of the embeddings of cumulative concatenated documents with the next document.
+    Called "cumulative sim" because we check the similarities of the
+    embeddings of cumulative concatenated documents with the next document.
     """
 
     def __init__(
@@ -19,15 +19,17 @@ def __init__(
         name: str = "cumulative_similarity_splitter",
         score_threshold: float = 0.45,
     ):
-        super().__init__(name=name, score_threshold=score_threshold, encoder=encoder)
+        super().__init__(name=name, encoder=encoder)
         encoder.score_threshold = score_threshold
+        self.score_threshold = score_threshold
 
     def __call__(self, docs: List[str]):
         total_docs = len(docs)
         # Check if there's only a single document
         if total_docs == 1:
             raise ValueError(
-                "There is only one document provided; at least two are required to determine topics based on similarity."
+                "There is only one document provided; at least two are required "
+                "to determine topics based on similarity."
             )
         splits = []
         curr_split_start_idx = 0
@@ -35,10 +37,12 @@ def __call__(self, docs: List[str]):
         for idx in range(0, total_docs):
             if idx + 1 < total_docs:  # Ensure there is a next document to compare with.
                 if idx == 0:
-                    # On the first iteration, compare the first document directly to the second.
+                    # On the first iteration, compare the
+                    # first document directly to the second.
                     curr_split_docs = docs[idx]
                 else:
-                    # For subsequent iterations, compare cumulative documents up to the current one with the next.
+                    # For subsequent iterations, compare cumulative
+                    # documents up to the current one with the next.
                     curr_split_docs = "\n".join(docs[curr_split_start_idx : idx + 1])
                 next_doc = docs[idx + 1]
 
diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
index 4a746f7c..0369c746 100644
--- a/semantic_router/splitters/rolling_window.py
+++ b/semantic_router/splitters/rolling_window.py
@@ -9,7 +9,6 @@
 from semantic_router.utils.logger import logger
 
 
-
 class RollingWindowSplitter(BaseSplitter):
     def __init__(
         self,
@@ -20,7 +19,7 @@ def __init__(
         max_split_tokens=300,
         split_tokens_tolerance=10,
         plot_splits=False,
-        name = "rolling_window_splitter",
+        name="rolling_window_splitter",
     ):
         super().__init__(name=name, encoder=encoder)
         self.calculated_threshold: float
diff --git a/semantic_router/splitters/utils.py b/semantic_router/splitters/utils.py
index 296df2ad..349c3eaa 100644
--- a/semantic_router/splitters/utils.py
+++ b/semantic_router/splitters/utils.py
@@ -1,10 +1,5 @@
-from typing import List
-
 import regex
 import tiktoken
-from colorama import Fore, Style
-
-from semantic_router.schema import DocumentSplit
 
 
 def split_to_sentences(text: str) -> list[str]:
@@ -66,4 +61,3 @@ def tiktoken_length(text: str) -> int:
     tokenizer = tiktoken.get_encoding("cl100k_base")
     tokens = tokenizer.encode(text, disallowed_special=())
     return len(tokens)
-

From fef3ae8db9d20b7afea406d76dd59f5c0af07bc5 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 14:43:20 +0200
Subject: [PATCH 11/14] fix: Address PR comments

---
 pyproject.toml                    | 1 -
 semantic_router/index/pinecone.py | 7 +++----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 477f7d45..2b55043e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -53,7 +53,6 @@ pytest-xdist = "^3.5.0"
 mypy = "^1.7.1"
 types-pyyaml = "^6.0.12.12"
 types-requests = "^2.31.0"
-termcolor = "^2.4.0"
 matplot = "^0.1.9"
 
 [build-system]
diff --git a/semantic_router/index/pinecone.py b/semantic_router/index/pinecone.py
index 5913a6ad..886cd806 100644
--- a/semantic_router/index/pinecone.py
+++ b/semantic_router/index/pinecone.py
@@ -50,10 +50,9 @@ class PineconeIndex(BaseIndex):
 
     def __init__(self, **data):
         super().__init__(**data)
-        clean_route = clean_route_name(self.route)
-        # Use SHA-256 for a more secure hash
-        utterance_id = hashlib.sha256(self.utterance.encode()).hexdigest()
-        self.id = f"{clean_route}#{utterance_id}"
+        self._initialize_client()
+        self.type = "pinecone"
+        self.client = self._initialize_client()
 
     def _initialize_client(self, api_key: Optional[str] = None):
         try:

From afc97d93d95aa3295636f9c01d512f382fda25d5 Mon Sep 17 00:00:00 2001
From: Simonas <20096648+simjak@users.noreply.github.com>
Date: Fri, 23 Feb 2024 14:44:27 +0200
Subject: [PATCH 12/14] chore: Removed termcolor

---
 poetry.lock | 20 +++-----------------
 1 file changed, 3 insertions(+), 17 deletions(-)

diff --git a/poetry.lock b/poetry.lock
index 94f87978..760f53ce 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1615,12 +1615,12 @@ files = [
 
 [[package]]
 name = "llama-cpp-python"
-version = "0.2.47"
+version = "0.2.48"
 description = "Python bindings for the llama.cpp library"
 optional = true
 python-versions = ">=3.8"
 files = [
-    {file = "llama_cpp_python-0.2.47.tar.gz", hash = "sha256:cd1a46a70ec2d4be4c3b063e6824f8481790bd5081e934c9a85f534738d3cf62"},
+    {file = "llama_cpp_python-0.2.48.tar.gz", hash = "sha256:37294f14c3b8157334beb8c9b6d92087f2c9d82730d733e6fc4fc15034271dd8"},
 ]
 
 [package.dependencies]
@@ -3702,20 +3702,6 @@ files = [
 [package.dependencies]
 mpmath = ">=0.19"
 
-[[package]]
-name = "termcolor"
-version = "2.4.0"
-description = "ANSI color formatting for output in terminal"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "termcolor-2.4.0-py3-none-any.whl", hash = "sha256:9297c0df9c99445c2412e832e882a7884038a25617c60cea2ad69488d4040d63"},
-    {file = "termcolor-2.4.0.tar.gz", hash = "sha256:aab9e56047c8ac41ed798fa36d892a37aca6b3e9159f3e0c24bc64a9b3ac7b7a"},
-]
-
-[package.extras]
-tests = ["pytest", "pytest-cov"]
-
 [[package]]
 name = "tiktoken"
 version = "0.6.0"
@@ -4406,4 +4392,4 @@ vision = ["pillow", "torch", "torchvision", "transformers"]
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.9,<3.13"
-content-hash = "13824ce7626ac01d8ef8217219a4670f666458edb0a05f0606906af5f3e94b57"
+content-hash = "5808af6bf85a4aaaecb2c70178b38dfe134791073b7641a1eb488bfda6155963"

From 57f024c9c774930cd4d0e795b700e8fbece9a3b2 Mon Sep 17 00:00:00 2001
From: James Briggs <35938317+jamescalam@users.noreply.github.com>
Date: Fri, 23 Feb 2024 08:49:07 -0500
Subject: [PATCH 13/14] tweaks

---
 docs/examples/rolling-window-splitter.ipynb | 191 +++++++++
 docs/examples/text_semantic_split.ipynb     | 179 ---------
 poetry.lock                                 | 418 +-------------------
 pyproject.toml                              |   3 +-
 semantic_router/splitters/rolling_window.py |   5 +-
 5 files changed, 207 insertions(+), 589 deletions(-)
 create mode 100644 docs/examples/rolling-window-splitter.ipynb
 delete mode 100644 docs/examples/text_semantic_split.ipynb

diff --git a/docs/examples/rolling-window-splitter.ipynb b/docs/examples/rolling-window-splitter.ipynb
new file mode 100644
index 00000000..3e59347a
--- /dev/null
+++ b/docs/examples/rolling-window-splitter.ipynb
@@ -0,0 +1,191 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = '''\n",
+    "In a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\"\n",
+    "The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor.\n",
+    "One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth. While the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously.\n",
+    "Discussions on the platform draw attention to a variety of issues that those who earn money the hard way might face. For example, they are described as likely having to work overtime, forgo time off for illness or rest, and maintain an unyielding dedication to their occupation, which often results in a never-ending cycle of work without any perceived progression in their lives.\n",
+    "Another tweet that captures this sentiment reads, \"Drowning in more work and poverty despite trying harder and harder,\" pointing to a sense of despair and dissatisfaction that comes with work that is both disproportionately demanding and inadequately rewarding. Critics also note how the pursuit of hard-earned money could potentially create physical and mental health risks due to the unrelenting pressure and stress that these jobs might impose.\n",
+    "Conversely, those in favor of earning money with less difficulty contend that it's crucial to harness one's strengths and passions to create opportunities that yield financial success without the need for excessive labor. The debate revolves around the concept that people should seek out ways to work smarter, not harder, especially if it means a healthier and more fulfilling lifestyle.\n",
+    "In fact, the notion of a \"vicious cycle,\" often attributed to those chasing hard-earned money, is juxtaposed with an idealized image of someone operating in their zone of excellence. Confidently focused on their strengths, such individuals are depicted as enjoying a more relaxed and less stressful work environment, one in which they can thrive without the need for never-ending overtime or self-sacrifice.\n",
+    "Some tweets even extend this sentiment to the broader socio-economic context, observing how wealth is not merely derived from manual labor or high-paying positions requiring extraordinary work hours. The tweets emphasize the importance of cultivating an entrepreneurial spirit and a penchant for innovative thinking, especially in the modern digital age.\n",
+    "One user writes, \"Too hard-earned money isn't worth it. Learn how to make money using your brain, not your body,\" while another suggests, \"Love will flow towards those who are not lacking in love, and money will flow towards those who are not lacking in money!\"\n",
+    "While some of the discussions take a somewhat passive-aggressive view, others acknowledge that financial security and comfort might not always be possible for everyone. In a more realistic tone, a user remarks, \"If life were so easy that diligence led to wealth, then the world's richest person would be the best worker bee. But that's not the case.\" This acknowledgment underscores the complexities of the economy and the role that factors like luck, connections, and a rapidly evolving job market can play in financial success.\n",
+    "Some users are quick to criticize the notion that earning money the hard way should be avoided, with one tweet expressing, \"The person who advises you to avoid hard-earned money is likely a scammer who profits off providing emotional value in exchange for exploitation.\" Others argue that while it's essential to find enjoyment and fulfillment in one's work, it's crucial not to shun or belittle those who choose to work in physically demanding or high-paying industries.\n",
+    "Overall, the Weibo discussions offer a fascinating insight into the complexities of the modern Chinese labor market and the work-life balance that people strive to achieve. As in many countries, striking the right balance between work and play is an ongoing challenge for many Chinese citizens. However, the conversations on Weibo signal an increasing awareness of the importance of finding meaningful, fulfilling, and financially rewarding work that doesn't necessitate excessive sacrifice or sufferance.\n",
+    "In the end, as one user succinctly puts it, \"Make sure you're earning your money in a way that brings you joy and satisfaction. That's the only way to ensure that your life doesn't become a never-ending cycle of hard work without any tangible progress.\"\n",
+    "In this context, social media discussions focusing on the trials and tribulations of earning money serve not only as an outlet for venting frustrations but also as a means of promoting dialogue and shared understanding about the challenges faced by workers across all industries. These virtual conversations sparked by tweets and in-depth discussions likely resonate with a wide swath of Chinese citizens struggling to navigate the complexities of balancing a career that pays well with one that brings them joy, fulfillment, and a sense of purpose.\n",
+    "As the discussions on Weibo continue to evolve and unfold, it is evident that the discourse around work, money, and life satisfaction holds the potential to inspire meaningful change and shift societal attitudes towards a more holistic, balanced, and humane understanding of success and prosperity.\n",
+    "---\n",
+    "Note: The translated tweets and user quotes from Chinese to English were used as the foundation for the long-form news article. The author tried to maintain the integrity of the original content in the translation while adapting it to fit a journalistic format. No inaccuracies were introduced during translation, and the opinion-based nature of the original content was preserved while maintaining objectivity.\n",
+    "Heart count: 0/2\n",
+    "Note: The author did not include any Chinese characters in the final response.\n",
+    "Collapse\n",
+    "'''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/jamesbriggs/opt/anaconda3/envs/decision-layer/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "from getpass import getpass\n",
+    "from semantic_router.splitters import RollingWindowSplitter\n",
+    "from semantic_router.encoders import OpenAIEncoder\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = os.getenv(\"OPENAI_API_KEY\") or getpass(\"Enter your OpenAI API key: \")\n",
+    "\n",
+    "splitter = RollingWindowSplitter(\n",
+    "    encoder=OpenAIEncoder(),\n",
+    "    min_split_tokens=50,\n",
+    "    max_split_tokens=300,\n",
+    "    window_size=5, # sentences\n",
+    "    plot_splits=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[33m2024-02-23 08:44:26 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:26 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881277932028191\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:26 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:26 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781277932028191\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:26 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.8687934834140205\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:26 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:26 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.8587934834140205\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:26 INFO semantic_router.utils.logger Final optimal threshold: 0.8687934834140205\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.8687934834140205.\u001b[0m\n",
+      "\u001b[32m2024-02-23 08:44:27 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "splits = splitter([text])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Split 1, tokens 218, triggered by: 0.85\n",
+      "\u001b[31mIn a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\" The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor. One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 2, tokens 262, triggered by: token limit\n",
+      "\u001b[32mWhile the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously. Discussions on the platform draw attention to a variety of issues that those who earn money the hard way might face. For example, they are described as likely having to work overtime, forgo time off for illness or rest, and maintain an unyielding dedication to their occupation, which often results in a never-ending cycle of work without any perceived progression in their lives. Another tweet that captures this sentiment reads, \"Drowning in more work and poverty despite trying harder and harder,\" pointing to a sense of despair and dissatisfaction that comes with work that is both disproportionately demanding and inadequately rewarding. Critics also note how the pursuit of hard-earned money could potentially create physical and mental health risks due to the unrelenting pressure and stress that these jobs might impose. Conversely, those in favor of earning money with less difficulty contend that it's crucial to harness one's strengths and passions to create opportunities that yield financial success without the need for excessive labor. The debate revolves around the concept that people should seek out ways to work smarter, not harder, especially if it means a healthier and more fulfilling lifestyle.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 3, tokens 137, triggered by: 0.85\n",
+      "\u001b[34mIn fact, the notion of a \"vicious cycle,\" often attributed to those chasing hard-earned money, is juxtaposed with an idealized image of someone operating in their zone of excellence. Confidently focused on their strengths, such individuals are depicted as enjoying a more relaxed and less stressful work environment, one in which they can thrive without the need for never-ending overtime or self-sacrifice. Some tweets even extend this sentiment to the broader socio-economic context, observing how wealth is not merely derived from manual labor or high-paying positions requiring extraordinary work hours. The tweets emphasize the importance of cultivating an entrepreneurial spirit and a penchant for innovative thinking, especially in the modern digital age.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 4, tokens 249, triggered by: 0.86\n",
+      "\u001b[35mOne user writes, \"Too hard-earned money isn't worth it. Learn how to make money using your brain, not your body,\" while another suggests, \"Love will flow towards those who are not lacking in love, and money will flow towards those who are not lacking in money!\" While some of the discussions take a somewhat passive-aggressive view, others acknowledge that financial security and comfort might not always be possible for everyone. In a more realistic tone, a user remarks, \"If life were so easy that diligence led to wealth, then the world's richest person would be the best worker bee. But that's not the case.\" This acknowledgment underscores the complexities of the economy and the role that factors like luck, connections, and a rapidly evolving job market can play in financial success. Some users are quick to criticize the notion that earning money the hard way should be avoided, with one tweet expressing, \"The person who advises you to avoid hard-earned money is likely a scammer who profits off providing emotional value in exchange for exploitation.\" Others argue that while it's essential to find enjoyment and fulfillment in one's work, it's crucial not to shun or belittle those who choose to work in physically demanding or high-paying industries.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 5, tokens 117, triggered by: 0.87\n",
+      "\u001b[31mOverall, the Weibo discussions offer a fascinating insight into the complexities of the modern Chinese labor market and the work-life balance that people strive to achieve. As in many countries, striking the right balance between work and play is an ongoing challenge for many Chinese citizens. However, the conversations on Weibo signal an increasing awareness of the importance of finding meaningful, fulfilling, and financially rewarding work that doesn't necessitate excessive sacrifice or sufferance. In the end, as one user succinctly puts it, \"Make sure you're earning your money in a way that brings you joy and satisfaction.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 6, tokens 171, triggered by: 0.82\n",
+      "\u001b[32mThat's the only way to ensure that your life doesn't become a never-ending cycle of hard work without any tangible progress.\" In this context, social media discussions focusing on the trials and tribulations of earning money serve not only as an outlet for venting frustrations but also as a means of promoting dialogue and shared understanding about the challenges faced by workers across all industries. These virtual conversations sparked by tweets and in-depth discussions likely resonate with a wide swath of Chinese citizens struggling to navigate the complexities of balancing a career that pays well with one that brings them joy, fulfillment, and a sense of purpose. As the discussions on Weibo continue to evolve and unfold, it is evident that the discourse around work, money, and life satisfaction holds the potential to inspire meaningful change and shift societal attitudes towards a more holistic, balanced, and humane understanding of success and prosperity.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 7, tokens 72, triggered by: 0.80\n",
+      "\u001b[34m--- Note: The translated tweets and user quotes from Chinese to English were used as the foundation for the long-form news article. The author tried to maintain the integrity of the original content in the translation while adapting it to fit a journalistic format. No inaccuracies were introduced during translation, and the opinion-based nature of the original content was preserved while maintaining objectivity.\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n",
+      "Split 8, tokens 23, triggered by: final split\n",
+      "\u001b[35mHeart count: 0/2 Note: The author did not include any Chinese characters in the final response. Collapse\u001b[0m\n",
+      "----------------------------------------------------------------------------------------\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "splitter.print(splits)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/examples/text_semantic_split.ipynb b/docs/examples/text_semantic_split.ipynb
deleted file mode 100644
index 35f618a4..00000000
--- a/docs/examples/text_semantic_split.ipynb
+++ /dev/null
@@ -1,179 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "text = '''\n",
-    "In a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\"\n",
-    "The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor.\n",
-    "One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth. While the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously.\n",
-    "Discussions on the platform draw attention to a variety of issues that those who earn money the hard way might face. For example, they are described as likely having to work overtime, forgo time off for illness or rest, and maintain an unyielding dedication to their occupation, which often results in a never-ending cycle of work without any perceived progression in their lives.\n",
-    "Another tweet that captures this sentiment reads, \"Drowning in more work and poverty despite trying harder and harder,\" pointing to a sense of despair and dissatisfaction that comes with work that is both disproportionately demanding and inadequately rewarding. Critics also note how the pursuit of hard-earned money could potentially create physical and mental health risks due to the unrelenting pressure and stress that these jobs might impose.\n",
-    "Conversely, those in favor of earning money with less difficulty contend that it's crucial to harness one's strengths and passions to create opportunities that yield financial success without the need for excessive labor. The debate revolves around the concept that people should seek out ways to work smarter, not harder, especially if it means a healthier and more fulfilling lifestyle.\n",
-    "In fact, the notion of a \"vicious cycle,\" often attributed to those chasing hard-earned money, is juxtaposed with an idealized image of someone operating in their zone of excellence. Confidently focused on their strengths, such individuals are depicted as enjoying a more relaxed and less stressful work environment, one in which they can thrive without the need for never-ending overtime or self-sacrifice.\n",
-    "Some tweets even extend this sentiment to the broader socio-economic context, observing how wealth is not merely derived from manual labor or high-paying positions requiring extraordinary work hours. The tweets emphasize the importance of cultivating an entrepreneurial spirit and a penchant for innovative thinking, especially in the modern digital age.\n",
-    "One user writes, \"Too hard-earned money isn't worth it. Learn how to make money using your brain, not your body,\" while another suggests, \"Love will flow towards those who are not lacking in love, and money will flow towards those who are not lacking in money!\"\n",
-    "While some of the discussions take a somewhat passive-aggressive view, others acknowledge that financial security and comfort might not always be possible for everyone. In a more realistic tone, a user remarks, \"If life were so easy that diligence led to wealth, then the world's richest person would be the best worker bee. But that's not the case.\" This acknowledgment underscores the complexities of the economy and the role that factors like luck, connections, and a rapidly evolving job market can play in financial success.\n",
-    "Some users are quick to criticize the notion that earning money the hard way should be avoided, with one tweet expressing, \"The person who advises you to avoid hard-earned money is likely a scammer who profits off providing emotional value in exchange for exploitation.\" Others argue that while it's essential to find enjoyment and fulfillment in one's work, it's crucial not to shun or belittle those who choose to work in physically demanding or high-paying industries.\n",
-    "Overall, the Weibo discussions offer a fascinating insight into the complexities of the modern Chinese labor market and the work-life balance that people strive to achieve. As in many countries, striking the right balance between work and play is an ongoing challenge for many Chinese citizens. However, the conversations on Weibo signal an increasing awareness of the importance of finding meaningful, fulfilling, and financially rewarding work that doesn't necessitate excessive sacrifice or sufferance.\n",
-    "In the end, as one user succinctly puts it, \"Make sure you're earning your money in a way that brings you joy and satisfaction. That's the only way to ensure that your life doesn't become a never-ending cycle of hard work without any tangible progress.\"\n",
-    "In this context, social media discussions focusing on the trials and tribulations of earning money serve not only as an outlet for venting frustrations but also as a means of promoting dialogue and shared understanding about the challenges faced by workers across all industries. These virtual conversations sparked by tweets and in-depth discussions likely resonate with a wide swath of Chinese citizens struggling to navigate the complexities of balancing a career that pays well with one that brings them joy, fulfillment, and a sense of purpose.\n",
-    "As the discussions on Weibo continue to evolve and unfold, it is evident that the discourse around work, money, and life satisfaction holds the potential to inspire meaningful change and shift societal attitudes towards a more holistic, balanced, and humane understanding of success and prosperity.\n",
-    "---\n",
-    "Note: The translated tweets and user quotes from Chinese to English were used as the foundation for the long-form news article. The author tried to maintain the integrity of the original content in the translation while adapting it to fit a journalistic format. No inaccuracies were introduced during translation, and the opinion-based nature of the original content was preserved while maintaining objectivity.\n",
-    "Heart count: 0/2\n",
-    "Note: The author did not include any Chinese characters in the final response.\n",
-    "Collapse\n",
-    "'''"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/jakit/customers/aurelio/semantic-router/.venv/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
-   "source": [
-    "from semantic_router.splitters import RollingWindowSplitter\n",
-    "from semantic_router.encoders import OpenAIEncoder\n",
-    "\n",
-    "splitter = RollingWindowSplitter(\n",
-    "    encoder=OpenAIEncoder(),\n",
-    "    min_split_tokens=50,\n",
-    "    max_split_tokens=300,\n",
-    "    window_size=5, # sentences\n",
-    "    plot_splits=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[33m2024-02-23 11:00:31 WARNING semantic_router.utils.logger Single document exceeds the maximum token limit of 300. Splitting to sentences before semantically splitting.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 0: Trying threshold: 0.8881277932028191\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 0: Median tokens per split: 24.0\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 0: Adjusting high to 0.8781277932028191\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 1: Trying threshold: 0.868791983949652\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 1: Median tokens per split: 34.5\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Iteration 1: Adjusting high to 0.858791983949652\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Final optimal threshold: 0.868791983949652\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 218 tokens due to threshold 0.868791983949652.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 262 tokens due to exceeding token limit of 300.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 137 tokens due to threshold 0.868791983949652.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 249 tokens due to threshold 0.868791983949652.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 117 tokens due to threshold 0.868791983949652.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 171 tokens due to threshold 0.868791983949652.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Split finalized with 72 tokens due to threshold 0.868791983949652.\u001b[0m\n",
-      "\u001b[32m2024-02-23 11:00:32 INFO semantic_router.utils.logger Final split added with 23 tokens due to remaining documents.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "splits = splitter([text])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Split 1, tokens 218, triggered by: 0.85\n",
-      "\u001b[31mIn a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\" The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor. One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth.\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "Split 2, tokens 262, triggered by: token limit\n",
-      "\u001b[32mWhile the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously. Discussions on the platform draw attention to a variety of issues that those who earn money the hard way might face. For example, they are described as likely having to work overtime, forgo time off for illness or rest, and maintain an unyielding dedication to their occupation, which often results in a never-ending cycle of work without any perceived progression in their lives. Another tweet that captures this sentiment reads, \"Drowning in more work and poverty despite trying harder and harder,\" pointing to a sense of despair and dissatisfaction that comes with work that is both disproportionately demanding and inadequately rewarding. Critics also note how the pursuit of hard-earned money could potentially create physical and mental health risks due to the unrelenting pressure and stress that these jobs might impose. Conversely, those in favor of earning money with less difficulty contend that it's crucial to harness one's strengths and passions to create opportunities that yield financial success without the need for excessive labor. The debate revolves around the concept that people should seek out ways to work smarter, not harder, especially if it means a healthier and more fulfilling lifestyle.\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "Split 3, tokens 137, triggered by: 0.85\n",
-      "\u001b[34mIn fact, the notion of a \"vicious cycle,\" often attributed to those chasing hard-earned money, is juxtaposed with an idealized image of someone operating in their zone of excellence. Confidently focused on their strengths, such individuals are depicted as enjoying a more relaxed and less stressful work environment, one in which they can thrive without the need for never-ending overtime or self-sacrifice. Some tweets even extend this sentiment to the broader socio-economic context, observing how wealth is not merely derived from manual labor or high-paying positions requiring extraordinary work hours. The tweets emphasize the importance of cultivating an entrepreneurial spirit and a penchant for innovative thinking, especially in the modern digital age.\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "Split 4, tokens 249, triggered by: 0.86\n",
-      "\u001b[35mOne user writes, \"Too hard-earned money isn't worth it. Learn how to make money using your brain, not your body,\" while another suggests, \"Love will flow towards those who are not lacking in love, and money will flow towards those who are not lacking in money!\" While some of the discussions take a somewhat passive-aggressive view, others acknowledge that financial security and comfort might not always be possible for everyone. In a more realistic tone, a user remarks, \"If life were so easy that diligence led to wealth, then the world's richest person would be the best worker bee. But that's not the case.\" This acknowledgment underscores the complexities of the economy and the role that factors like luck, connections, and a rapidly evolving job market can play in financial success. Some users are quick to criticize the notion that earning money the hard way should be avoided, with one tweet expressing, \"The person who advises you to avoid hard-earned money is likely a scammer who profits off providing emotional value in exchange for exploitation.\" Others argue that while it's essential to find enjoyment and fulfillment in one's work, it's crucial not to shun or belittle those who choose to work in physically demanding or high-paying industries.\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "Split 5, tokens 117, triggered by: 0.87\n",
-      "\u001b[31mOverall, the Weibo discussions offer a fascinating insight into the complexities of the modern Chinese labor market and the work-life balance that people strive to achieve. As in many countries, striking the right balance between work and play is an ongoing challenge for many Chinese citizens. However, the conversations on Weibo signal an increasing awareness of the importance of finding meaningful, fulfilling, and financially rewarding work that doesn't necessitate excessive sacrifice or sufferance. In the end, as one user succinctly puts it, \"Make sure you're earning your money in a way that brings you joy and satisfaction.\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "Split 6, tokens 171, triggered by: 0.82\n",
-      "\u001b[32mThat's the only way to ensure that your life doesn't become a never-ending cycle of hard work without any tangible progress.\" In this context, social media discussions focusing on the trials and tribulations of earning money serve not only as an outlet for venting frustrations but also as a means of promoting dialogue and shared understanding about the challenges faced by workers across all industries. These virtual conversations sparked by tweets and in-depth discussions likely resonate with a wide swath of Chinese citizens struggling to navigate the complexities of balancing a career that pays well with one that brings them joy, fulfillment, and a sense of purpose. As the discussions on Weibo continue to evolve and unfold, it is evident that the discourse around work, money, and life satisfaction holds the potential to inspire meaningful change and shift societal attitudes towards a more holistic, balanced, and humane understanding of success and prosperity.\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "Split 7, tokens 72, triggered by: 0.80\n",
-      "\u001b[34m--- Note: The translated tweets and user quotes from Chinese to English were used as the foundation for the long-form news article. The author tried to maintain the integrity of the original content in the translation while adapting it to fit a journalistic format. No inaccuracies were introduced during translation, and the opinion-based nature of the original content was preserved while maintaining objectivity.\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n",
-      "Split 8, tokens 23, triggered by: final split\n",
-      "\u001b[35mHeart count: 0/2 Note: The author did not include any Chinese characters in the final response. Collapse\u001b[0m\n",
-      "----------------------------------------------------------------------------------------\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "splitter.print(splits)"
-   ]
-  }
- ],
- "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.9.18"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/poetry.lock b/poetry.lock
index 760f53ce..fff4911a 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -532,7 +532,7 @@ test = ["pytest"]
 name = "contourpy"
 version = "1.2.0"
 description = "Python library for calculating contours of 2D quadrilateral grids"
-optional = false
+optional = true
 python-versions = ">=3.9"
 files = [
     {file = "contourpy-1.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0274c1cb63625972c0c007ab14dd9ba9e199c36ae1a231ce45d725cbcbfd10a8"},
@@ -658,65 +658,11 @@ tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.1
 [package.extras]
 toml = ["tomli"]
 
-[[package]]
-name = "cryptography"
-version = "42.0.4"
-description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers."
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "cryptography-42.0.4-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:ffc73996c4fca3d2b6c1c8c12bfd3ad00def8621da24f547626bf06441400449"},
-    {file = "cryptography-42.0.4-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:db4b65b02f59035037fde0998974d84244a64c3265bdef32a827ab9b63d61b18"},
-    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad9c385ba8ee025bb0d856714f71d7840020fe176ae0229de618f14dae7a6e2"},
-    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69b22ab6506a3fe483d67d1ed878e1602bdd5912a134e6202c1ec672233241c1"},
-    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e09469a2cec88fb7b078e16d4adec594414397e8879a4341c6ace96013463d5b"},
-    {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3e970a2119507d0b104f0a8e281521ad28fc26f2820687b3436b8c9a5fcf20d1"},
-    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e53dc41cda40b248ebc40b83b31516487f7db95ab8ceac1f042626bc43a2f992"},
-    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:c3a5cbc620e1e17009f30dd34cb0d85c987afd21c41a74352d1719be33380885"},
-    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6bfadd884e7280df24d26f2186e4e07556a05d37393b0f220a840b083dc6a824"},
-    {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:01911714117642a3f1792c7f376db572aadadbafcd8d75bb527166009c9f1d1b"},
-    {file = "cryptography-42.0.4-cp37-abi3-win32.whl", hash = "sha256:fb0cef872d8193e487fc6bdb08559c3aa41b659a7d9be48b2e10747f47863925"},
-    {file = "cryptography-42.0.4-cp37-abi3-win_amd64.whl", hash = "sha256:c1f25b252d2c87088abc8bbc4f1ecbf7c919e05508a7e8628e6875c40bc70923"},
-    {file = "cryptography-42.0.4-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:15a1fb843c48b4a604663fa30af60818cd28f895572386e5f9b8a665874c26e7"},
-    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1327f280c824ff7885bdeef8578f74690e9079267c1c8bd7dc5cc5aa065ae52"},
-    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ffb03d419edcab93b4b19c22ee80c007fb2d708429cecebf1dd3258956a563a"},
-    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:1df6fcbf60560d2113b5ed90f072dc0b108d64750d4cbd46a21ec882c7aefce9"},
-    {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:44a64043f743485925d3bcac548d05df0f9bb445c5fcca6681889c7c3ab12764"},
-    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:3c6048f217533d89f2f8f4f0fe3044bf0b2090453b7b73d0b77db47b80af8dff"},
-    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:6d0fbe73728c44ca3a241eff9aefe6496ab2656d6e7a4ea2459865f2e8613257"},
-    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:887623fe0d70f48ab3f5e4dbf234986b1329a64c066d719432d0698522749929"},
-    {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ce8613beaffc7c14f091497346ef117c1798c202b01153a8cc7b8e2ebaaf41c0"},
-    {file = "cryptography-42.0.4-cp39-abi3-win32.whl", hash = "sha256:810bcf151caefc03e51a3d61e53335cd5c7316c0a105cc695f0959f2c638b129"},
-    {file = "cryptography-42.0.4-cp39-abi3-win_amd64.whl", hash = "sha256:a0298bdc6e98ca21382afe914c642620370ce0470a01e1bef6dd9b5354c36854"},
-    {file = "cryptography-42.0.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5f8907fcf57392cd917892ae83708761c6ff3c37a8e835d7246ff0ad251d9298"},
-    {file = "cryptography-42.0.4-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:12d341bd42cdb7d4937b0cabbdf2a94f949413ac4504904d0cdbdce4a22cbf88"},
-    {file = "cryptography-42.0.4-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1cdcdbd117681c88d717437ada72bdd5be9de117f96e3f4d50dab3f59fd9ab20"},
-    {file = "cryptography-42.0.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0e89f7b84f421c56e7ff69f11c441ebda73b8a8e6488d322ef71746224c20fce"},
-    {file = "cryptography-42.0.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f1e85a178384bf19e36779d91ff35c7617c885da487d689b05c1366f9933ad74"},
-    {file = "cryptography-42.0.4-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d2a27aca5597c8a71abbe10209184e1a8e91c1fd470b5070a2ea60cafec35bcd"},
-    {file = "cryptography-42.0.4-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4e36685cb634af55e0677d435d425043967ac2f3790ec652b2b88ad03b85c27b"},
-    {file = "cryptography-42.0.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f47be41843200f7faec0683ad751e5ef11b9a56a220d57f300376cd8aba81660"},
-    {file = "cryptography-42.0.4.tar.gz", hash = "sha256:831a4b37accef30cccd34fcb916a5d7b5be3cbbe27268a02832c3e450aea39cb"},
-]
-
-[package.dependencies]
-cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""}
-
-[package.extras]
-docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"]
-docstest = ["pyenchant (>=1.6.11)", "readme-renderer", "sphinxcontrib-spelling (>=4.0.1)"]
-nox = ["nox"]
-pep8test = ["check-sdist", "click", "mypy", "ruff"]
-sdist = ["build"]
-ssh = ["bcrypt (>=3.1.5)"]
-test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"]
-test-randomorder = ["pytest-randomly"]
-
 [[package]]
 name = "cycler"
 version = "0.12.1"
 description = "Composable style cycles"
-optional = false
+optional = true
 python-versions = ">=3.8"
 files = [
     {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"},
@@ -791,17 +737,6 @@ files = [
     {file = "distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed"},
 ]
 
-[[package]]
-name = "docutils"
-version = "0.20.1"
-description = "Docutils -- Python Documentation Utilities"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"},
-    {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"},
-]
-
 [[package]]
 name = "exceptiongroup"
 version = "1.2.0"
@@ -940,7 +875,7 @@ files = [
 name = "fonttools"
 version = "4.49.0"
 description = "Tools to manipulate font files"
-optional = false
+optional = true
 python-versions = ">=3.8"
 files = [
     {file = "fonttools-4.49.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d970ecca0aac90d399e458f0b7a8a597e08f95de021f17785fb68e2dc0b99717"},
@@ -1259,7 +1194,7 @@ testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs
 name = "importlib-resources"
 version = "6.1.1"
 description = "Read resources from Python packages"
-optional = false
+optional = true
 python-versions = ">=3.8"
 files = [
     {file = "importlib_resources-6.1.1-py3-none-any.whl", hash = "sha256:e8bf90d8213b486f428c9c39714b920041cb02c184686a3dee24905aaa8105d6"},
@@ -1354,24 +1289,6 @@ qtconsole = ["qtconsole"]
 test = ["pickleshare", "pytest (<7.1)", "pytest-asyncio (<0.22)", "testpath"]
 test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.22)", "pandas", "pickleshare", "pytest (<7.1)", "pytest-asyncio (<0.22)", "testpath", "trio"]
 
-[[package]]
-name = "jaraco-classes"
-version = "3.3.1"
-description = "Utility functions for Python class constructs"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "jaraco.classes-3.3.1-py3-none-any.whl", hash = "sha256:86b534de565381f6b3c1c830d13f931d7be1a75f0081c57dff615578676e2206"},
-    {file = "jaraco.classes-3.3.1.tar.gz", hash = "sha256:cb28a5ebda8bc47d8c8015307d93163464f9f2b91ab4006e09ff0ce07e8bfb30"},
-]
-
-[package.dependencies]
-more-itertools = "*"
-
-[package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
-testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
-
 [[package]]
 name = "jedi"
 version = "0.19.1"
@@ -1391,21 +1308,6 @@ docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alab
 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 = "jeepney"
-version = "0.8.0"
-description = "Low-level, pure Python DBus protocol wrapper."
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "jeepney-0.8.0-py3-none-any.whl", hash = "sha256:c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755"},
-    {file = "jeepney-0.8.0.tar.gz", hash = "sha256:5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806"},
-]
-
-[package.extras]
-test = ["async-timeout", "pytest", "pytest-asyncio (>=0.17)", "pytest-trio", "testpath", "trio"]
-trio = ["async_generator", "trio"]
-
 [[package]]
 name = "jinja2"
 version = "3.1.3"
@@ -1477,34 +1379,11 @@ traitlets = ">=5.3"
 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 = "keyring"
-version = "24.3.0"
-description = "Store and access your passwords safely."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "keyring-24.3.0-py3-none-any.whl", hash = "sha256:4446d35d636e6a10b8bce7caa66913dd9eca5fd222ca03a3d42c38608ac30836"},
-    {file = "keyring-24.3.0.tar.gz", hash = "sha256:e730ecffd309658a08ee82535a3b5ec4b4c8669a9be11efb66249d8e0aeb9a25"},
-]
-
-[package.dependencies]
-importlib-metadata = {version = ">=4.11.4", markers = "python_version < \"3.12\""}
-"jaraco.classes" = "*"
-jeepney = {version = ">=0.4.2", markers = "sys_platform == \"linux\""}
-pywin32-ctypes = {version = ">=0.2.0", markers = "sys_platform == \"win32\""}
-SecretStorage = {version = ">=3.2", markers = "sys_platform == \"linux\""}
-
-[package.extras]
-completion = ["shtab (>=1.1.0)"]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
-testing = ["pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff"]
-
 [[package]]
 name = "kiwisolver"
 version = "1.4.5"
 description = "A fast implementation of the Cassowary constraint solver"
-optional = false
+optional = true
 python-versions = ">=3.7"
 files = [
     {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"},
@@ -1635,30 +1514,6 @@ dev = ["black (>=23.3.0)", "httpx (>=0.24.1)", "mkdocs (>=1.4.3)", "mkdocs-mater
 server = ["fastapi (>=0.100.0)", "pydantic-settings (>=2.0.1)", "sse-starlette (>=1.6.1)", "starlette-context (>=0.3.6,<0.4)", "uvicorn (>=0.22.0)"]
 test = ["httpx (>=0.24.1)", "pytest (>=7.4.0)", "scipy (>=1.10)"]
 
-[[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"
@@ -1728,26 +1583,11 @@ files = [
     {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"},
 ]
 
-[[package]]
-name = "matplot"
-version = "0.1.9"
-description = ""
-optional = false
-python-versions = "*"
-files = [
-    {file = "matplot-0.1.9-py2.py3-none-any.whl", hash = "sha256:794ec24272a7672d5c89c4bbb581ceb0881c0d08c95d4f79c454a54ad4a1cdfa"},
-    {file = "matplot-0.1.9.tar.gz", hash = "sha256:89369d0974a5c5b6e5815532a9202ce09db0d70a909251bf0af0c608818c8fa4"},
-]
-
-[package.dependencies]
-matplotlib = ">=3.1.1"
-pyloco = ">=0.0.134"
-
 [[package]]
 name = "matplotlib"
 version = "3.8.3"
 description = "Python plotting package"
-optional = false
+optional = true
 python-versions = ">=3.9"
 files = [
     {file = "matplotlib-3.8.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:cf60138ccc8004f117ab2a2bad513cc4d122e55864b4fe7adf4db20ca68a078f"},
@@ -1806,17 +1646,6 @@ files = [
 [package.dependencies]
 traitlets = "*"
 
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-description = "Markdown URL utilities"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"},
-    {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"},
-]
-
 [[package]]
 name = "mistralai"
 version = "0.0.12"
@@ -1877,17 +1706,6 @@ files = [
     {file = "mmh3-3.1.0.tar.gz", hash = "sha256:9b0f2b2ab4a915333c9d1089572e290a021ebb5b900bb7f7114dccc03995d732"},
 ]
 
-[[package]]
-name = "more-itertools"
-version = "10.2.0"
-description = "More routines for operating on iterables, beyond itertools"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "more-itertools-10.2.0.tar.gz", hash = "sha256:8fccb480c43d3e99a00087634c06dd02b0d50fbf088b380de5a41a015ec239e1"},
-    {file = "more_itertools-10.2.0-py3-none-any.whl", hash = "sha256:686b06abe565edfab151cb8fd385a05651e1fdf8f0a14191e4439283421f8684"},
-]
-
 [[package]]
 name = "mpmath"
 version = "1.3.0"
@@ -2091,31 +1909,6 @@ doc = ["nb2plots (>=0.7)", "nbconvert (<7.9)", "numpydoc (>=1.6)", "pillow (>=9.
 extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.11)", "sympy (>=1.10)"]
 test = ["pytest (>=7.2)", "pytest-cov (>=4.0)"]
 
-[[package]]
-name = "nh3"
-version = "0.2.15"
-description = "Python bindings to the ammonia HTML sanitization library."
-optional = false
-python-versions = "*"
-files = [
-    {file = "nh3-0.2.15-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:9c0d415f6b7f2338f93035bba5c0d8c1b464e538bfbb1d598acd47d7969284f0"},
-    {file = "nh3-0.2.15-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6f42f99f0cf6312e470b6c09e04da31f9abaadcd3eb591d7d1a88ea931dca7f3"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac19c0d68cd42ecd7ead91a3a032fdfff23d29302dbb1311e641a130dfefba97"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f0d77272ce6d34db6c87b4f894f037d55183d9518f948bba236fe81e2bb4e28"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:8d595df02413aa38586c24811237e95937ef18304e108b7e92c890a06793e3bf"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86e447a63ca0b16318deb62498db4f76fc60699ce0a1231262880b38b6cff911"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3277481293b868b2715907310c7be0f1b9d10491d5adf9fce11756a97e97eddf"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60684857cfa8fdbb74daa867e5cad3f0c9789415aba660614fe16cd66cbb9ec7"},
-    {file = "nh3-0.2.15-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3b803a5875e7234907f7d64777dfde2b93db992376f3d6d7af7f3bc347deb305"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0d02d0ff79dfd8208ed25a39c12cbda092388fff7f1662466e27d97ad011b770"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f3b53ba93bb7725acab1e030bc2ecd012a817040fd7851b332f86e2f9bb98dc6"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:b1e97221cedaf15a54f5243f2c5894bb12ca951ae4ddfd02a9d4ea9df9e1a29d"},
-    {file = "nh3-0.2.15-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a5167a6403d19c515217b6bcaaa9be420974a6ac30e0da9e84d4fc67a5d474c5"},
-    {file = "nh3-0.2.15-cp37-abi3-win32.whl", hash = "sha256:427fecbb1031db085eaac9931362adf4a796428ef0163070c484b5a768e71601"},
-    {file = "nh3-0.2.15-cp37-abi3-win_amd64.whl", hash = "sha256:bc2d086fb540d0fa52ce35afaded4ea526b8fc4d3339f783db55c95de40ef02e"},
-    {file = "nh3-0.2.15.tar.gz", hash = "sha256:d1e30ff2d8d58fb2a14961f7aac1bbb1c51f9bdd7da727be35c63826060b0bf3"},
-]
-
 [[package]]
 name = "nltk"
 version = "3.8.1"
@@ -2547,7 +2340,7 @@ ptyprocess = ">=0.5"
 name = "pillow"
 version = "10.2.0"
 description = "Python Imaging Library (Fork)"
-optional = false
+optional = true
 python-versions = ">=3.8"
 files = [
     {file = "pillow-10.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:7823bdd049099efa16e4246bdf15e5a13dbb18a51b68fa06d6c1d4d8b99a796e"},
@@ -2676,20 +2469,6 @@ dense = ["openai (>=1.2.3,<2.0.0)", "sentence-transformers (>=2.0.0)", "torch (>
 openai = ["openai (>=1.2.3,<2.0.0)"]
 splade = ["sentence-transformers (>=2.0.0)", "torch (>=1.13.1)", "transformers (>=4.26.1)"]
 
-[[package]]
-name = "pkginfo"
-version = "1.9.6"
-description = "Query metadata from sdists / bdists / installed packages."
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "pkginfo-1.9.6-py3-none-any.whl", hash = "sha256:4b7a555a6d5a22169fcc9cf7bfd78d296b0361adad412a346c1226849af5e546"},
-    {file = "pkginfo-1.9.6.tar.gz", hash = "sha256:8fd5896e8718a4372f0ea9cc9d96f6417c9b986e23a4d116dda26b62cc29d046"},
-]
-
-[package.extras]
-testing = ["pytest", "pytest-cov"]
-
 [[package]]
 name = "platformdirs"
 version = "4.2.0"
@@ -2943,29 +2722,11 @@ files = [
 plugins = ["importlib-metadata"]
 windows-terminal = ["colorama (>=0.4.6)"]
 
-[[package]]
-name = "pyloco"
-version = "0.0.139"
-description = "Python Microapplication Launcher"
-optional = false
-python-versions = "*"
-files = [
-    {file = "pyloco-0.0.139-py2.py3-none-any.whl", hash = "sha256:6aeb14954b196c7faef4efd15f92887802e90be138e35a0e64ff1312f847425b"},
-    {file = "pyloco-0.0.139.tar.gz", hash = "sha256:d39537a4006f7522bd8b8d67e5f0abe6a6d9fdc7609a967d8ac6e1cf1df2a3a8"},
-]
-
-[package.dependencies]
-SimpleWebSocketServer = "*"
-twine = "*"
-typing = "*"
-ushlex = "*"
-websocket-client = "*"
-
 [[package]]
 name = "pyparsing"
 version = "3.1.1"
 description = "pyparsing module - Classes and methods to define and execute parsing grammars"
-optional = false
+optional = true
 python-versions = ">=3.6.8"
 files = [
     {file = "pyparsing-3.1.1-py3-none-any.whl", hash = "sha256:32c7c0b711493c72ff18a981d24f28aaf9c1fb7ed5e9667c9e84e3db623bdbfb"},
@@ -3100,17 +2861,6 @@ files = [
     {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"},
 ]
 
-[[package]]
-name = "pywin32-ctypes"
-version = "0.2.2"
-description = "A (partial) reimplementation of pywin32 using ctypes/cffi"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "pywin32-ctypes-0.2.2.tar.gz", hash = "sha256:3426e063bdd5fd4df74a14fa3cf80a0b42845a87e1d1e81f6549f9daec593a60"},
-    {file = "pywin32_ctypes-0.2.2-py3-none-any.whl", hash = "sha256:bf490a1a709baf35d688fe0ecf980ed4de11d2b3e37b51e5442587a75d9957e7"},
-]
-
 [[package]]
 name = "pyyaml"
 version = "6.0.1"
@@ -3276,25 +3026,6 @@ files = [
 [package.dependencies]
 cffi = {version = "*", markers = "implementation_name == \"pypy\""}
 
-[[package]]
-name = "readme-renderer"
-version = "42.0"
-description = "readme_renderer is a library for rendering readme descriptions for Warehouse"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "readme_renderer-42.0-py3-none-any.whl", hash = "sha256:13d039515c1f24de668e2c93f2e877b9dbe6c6c32328b90a40a49d8b2b85f36d"},
-    {file = "readme_renderer-42.0.tar.gz", hash = "sha256:2d55489f83be4992fe4454939d1a051c33edbab778e82761d060c9fc6b308cd1"},
-]
-
-[package.dependencies]
-docutils = ">=0.13.1"
-nh3 = ">=0.2.14"
-Pygments = ">=2.5.1"
-
-[package.extras]
-md = ["cmarkgfm (>=0.8.0)"]
-
 [[package]]
 name = "regex"
 version = "2023.12.25"
@@ -3418,52 +3149,6 @@ urllib3 = ">=1.21.1,<3"
 socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
-[[package]]
-name = "requests-toolbelt"
-version = "1.0.0"
-description = "A utility belt for advanced users of python-requests"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
-files = [
-    {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"},
-    {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"},
-]
-
-[package.dependencies]
-requests = ">=2.0.1,<3.0.0"
-
-[[package]]
-name = "rfc3986"
-version = "2.0.0"
-description = "Validating URI References per RFC 3986"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd"},
-    {file = "rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c"},
-]
-
-[package.extras]
-idna2008 = ["idna"]
-
-[[package]]
-name = "rich"
-version = "13.7.0"
-description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal"
-optional = false
-python-versions = ">=3.7.0"
-files = [
-    {file = "rich-13.7.0-py3-none-any.whl", hash = "sha256:6da14c108c4866ee9520bbffa71f6fe3962e193b7da68720583850cd4548e235"},
-    {file = "rich-13.7.0.tar.gz", hash = "sha256:5cb5123b5cf9ee70584244246816e9114227e0b98ad9176eede6ad54bf5403fa"},
-]
-
-[package.dependencies]
-markdown-it-py = ">=2.2.0"
-pygments = ">=2.13.0,<3.0.0"
-
-[package.extras]
-jupyter = ["ipywidgets (>=7.5.1,<9)"]
-
 [[package]]
 name = "ruff"
 version = "0.1.15"
@@ -3622,31 +3307,6 @@ tensorflow = ["safetensors[numpy]", "tensorflow (>=2.11.0)"]
 testing = ["h5py (>=3.7.0)", "huggingface_hub (>=0.12.1)", "hypothesis (>=6.70.2)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "safetensors[numpy]", "setuptools_rust (>=1.5.2)"]
 torch = ["safetensors[numpy]", "torch (>=1.10)"]
 
-[[package]]
-name = "secretstorage"
-version = "3.3.3"
-description = "Python bindings to FreeDesktop.org Secret Service API"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "SecretStorage-3.3.3-py3-none-any.whl", hash = "sha256:f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99"},
-    {file = "SecretStorage-3.3.3.tar.gz", hash = "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77"},
-]
-
-[package.dependencies]
-cryptography = ">=2.0"
-jeepney = ">=0.6"
-
-[[package]]
-name = "simplewebsocketserver"
-version = "0.1.2"
-description = "A Simple Websocket Server written in Python"
-optional = false
-python-versions = "*"
-files = [
-    {file = "SimpleWebSocketServer-0.1.2.tar.gz", hash = "sha256:48615b8769d6a01e58375a3399117c9c240ba649a15f8c7720d68b23949eff66"},
-]
-
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -4131,28 +3791,6 @@ build = ["cmake (>=3.18)", "lit"]
 tests = ["autopep8", "flake8", "isort", "numpy", "pytest", "scipy (>=1.7.1)"]
 tutorials = ["matplotlib", "pandas", "tabulate"]
 
-[[package]]
-name = "twine"
-version = "5.0.0"
-description = "Collection of utilities for publishing packages on PyPI"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "twine-5.0.0-py3-none-any.whl", hash = "sha256:a262933de0b484c53408f9edae2e7821c1c45a3314ff2df9bdd343aa7ab8edc0"},
-    {file = "twine-5.0.0.tar.gz", hash = "sha256:89b0cc7d370a4b66421cc6102f269aa910fe0f1861c124f573cf2ddedbc10cf4"},
-]
-
-[package.dependencies]
-importlib-metadata = ">=3.6"
-keyring = ">=15.1"
-pkginfo = ">=1.8.1"
-readme-renderer = ">=35.0"
-requests = ">=2.20"
-requests-toolbelt = ">=0.8.0,<0.9.0 || >0.9.0"
-rfc3986 = ">=1.4.0"
-rich = ">=12.0.0"
-urllib3 = ">=1.26.0"
-
 [[package]]
 name = "types-pyyaml"
 version = "6.0.12.12"
@@ -4178,17 +3816,6 @@ files = [
 [package.dependencies]
 urllib3 = ">=2"
 
-[[package]]
-name = "typing"
-version = "3.7.4.3"
-description = "Type Hints for Python"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
-files = [
-    {file = "typing-3.7.4.3-py2-none-any.whl", hash = "sha256:283d868f5071ab9ad873e5e52268d611e851c870a2ba354193026f2dfb29d8b5"},
-    {file = "typing-3.7.4.3.tar.gz", hash = "sha256:1187fb9c82fd670d10aa07bbb6cfcfe4bdda42d6fab8d5134f04e8c4d0b71cc9"},
-]
-
 [[package]]
 name = "typing-extensions"
 version = "4.9.0"
@@ -4217,16 +3844,6 @@ h2 = ["h2 (>=4,<5)"]
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
 
-[[package]]
-name = "ushlex"
-version = "0.99.1"
-description = "Replacement for shlex (that works with unicode) for Python 2.X."
-optional = false
-python-versions = "*"
-files = [
-    {file = "ushlex-0.99.1.tar.gz", hash = "sha256:6d681561545a9781430d5254eab9a648bade78c82ffd127d56c9228ae8887d46"},
-]
-
 [[package]]
 name = "wcwidth"
 version = "0.2.13"
@@ -4238,22 +3855,6 @@ files = [
     {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"},
 ]
 
-[[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 = "wget"
 version = "3.2"
@@ -4387,9 +3988,10 @@ fastembed = ["fastembed"]
 hybrid = ["pinecone-text"]
 local = ["llama-cpp-python", "torch", "transformers"]
 pinecone = ["pinecone-client"]
+processing = ["matplotlib"]
 vision = ["pillow", "torch", "torchvision", "transformers"]
 
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.9,<3.13"
-content-hash = "5808af6bf85a4aaaecb2c70178b38dfe134791073b7641a1eb488bfda6155963"
+content-hash = "067185d9d8b058fbcf9bd00e3c9a0b5b3ada33cbfa7f77e81d164692d98ae22b"
diff --git a/pyproject.toml b/pyproject.toml
index 2b55043e..1db92298 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,6 +35,7 @@ regex = "^2023.12.25"
 torchvision = { version = "^0.16.2", optional = true}
 pillow = { version= "^10.2.0", optional = true}
 tiktoken = "^0.6.0"
+matplotlib = { version="^3.8.3", optional = true}
 
 [tool.poetry.extras]
 hybrid = ["pinecone-text"]
@@ -42,6 +43,7 @@ fastembed = ["fastembed"]
 local = ["torch", "transformers", "llama-cpp-python"]
 pinecone = ["pinecone-client"]
 vision = ["torch", "torchvision", "transformers", "pillow"]
+processing = ["matplotlib"]
 
 [tool.poetry.group.dev.dependencies]
 ipykernel = "^6.25.0"
@@ -53,7 +55,6 @@ pytest-xdist = "^3.5.0"
 mypy = "^1.7.1"
 types-pyyaml = "^6.0.12.12"
 types-requests = "^2.31.0"
-matplot = "^0.1.9"
 
 [build-system]
 requires = ["poetry-core"]
diff --git a/semantic_router/splitters/rolling_window.py b/semantic_router/splitters/rolling_window.py
index 0369c746..ca9eed95 100644
--- a/semantic_router/splitters/rolling_window.py
+++ b/semantic_router/splitters/rolling_window.py
@@ -215,7 +215,10 @@ def plot_similarity_scores(
         try:
             from matplotlib import pyplot as plt
         except ImportError:
-            logger.warning("Plotting is disabled. Please `pip install matplotlib`.")
+            logger.warning(
+                "Plotting is disabled. Please `pip install "
+                "semantic-router[processing]`."
+            )
             return
 
         if not self.plot_splits:

From a75c2ce895b180039653aed6021f66be2edcc166 Mon Sep 17 00:00:00 2001
From: James Briggs <35938317+jamescalam@users.noreply.github.com>
Date: Fri, 23 Feb 2024 08:51:04 -0500
Subject: [PATCH 14/14] lint

---
 docs/07-ollama-local-execution.ipynb        | 23 +++++++++++----------
 docs/examples/rolling-window-splitter.ipynb | 12 ++++++-----
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/docs/07-ollama-local-execution.ipynb b/docs/07-ollama-local-execution.ipynb
index 91a011cb..cf26b77e 100644
--- a/docs/07-ollama-local-execution.ipynb
+++ b/docs/07-ollama-local-execution.ipynb
@@ -211,8 +211,10 @@
     "from semantic_router.llms.ollama import OllamaLLM\n",
     "\n",
     "\n",
-    "llm = OllamaLLM(llm_name=\"openhermes\") # Change llm_name if you want to use a different LLM with dynamic routes.\n",
-    "rl = RouteLayer(encoder = encoder, routes=routes, llm=llm)"
+    "llm = OllamaLLM(\n",
+    "    llm_name=\"openhermes\"\n",
+    ")  # Change llm_name if you want to use a different LLM with dynamic routes.\n",
+    "rl = RouteLayer(encoder=encoder, routes=routes, llm=llm)"
    ]
   },
   {
@@ -303,15 +305,15 @@
     "\n",
     "def get_time(timezone: str) -> str:\n",
     "    \"\"\"\n",
-    "Finds the current time in a specific timezone.\n",
+    "    Finds the current time in a specific timezone.\n",
     "\n",
-    ":param timezone: The timezone to find the current time in, should\n",
-    "    be a valid timezone from the IANA Time Zone Database like\n",
-    "    \"America/New_York\" or \"Europe/London\". Do NOT put the place\n",
-    "    name itself like \"rome\", or \"new york\", you must provide\n",
-    "    the IANA format.\n",
-    ":type timezone: str\n",
-    ":return: The current time in the specified timezone.\n",
+    "    :param timezone: The timezone to find the current time in, should\n",
+    "        be a valid timezone from the IANA Time Zone Database like\n",
+    "        \"America/New_York\" or \"Europe/London\". Do NOT put the place\n",
+    "        name itself like \"rome\", or \"new york\", you must provide\n",
+    "        the IANA format.\n",
+    "    :type timezone: str\n",
+    "    :return: The current time in the specified timezone.\n",
     "    \"\"\"\n",
     "    now = datetime.now(ZoneInfo(timezone))\n",
     "    return now.strftime(\"%H:%M\")"
@@ -449,7 +451,6 @@
     }
    ],
    "source": [
-    "\n",
     "get_time(**out.function_call)"
    ]
   },
diff --git a/docs/examples/rolling-window-splitter.ipynb b/docs/examples/rolling-window-splitter.ipynb
index 3e59347a..b94d3a56 100644
--- a/docs/examples/rolling-window-splitter.ipynb
+++ b/docs/examples/rolling-window-splitter.ipynb
@@ -6,7 +6,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "text = '''\n",
+    "text = \"\"\"\n",
     "In a recent surge of social media discussions on Weibo, Chinese netizens have been engaging in conversations about the struggles and challenges of earning money. The online debate sparked a wave of opinions and perspectives on the relationship between hard work, high pay, and finding contentment. Among the tweets, several users pontificated that one should avoid earning \"too much hard-earned money.\"\n",
     "The tweets and discussions revolve around the idea that working too hard for one's income can have a detrimental effect on one's life, both physically and mentally. Some users advocate for finding opportunities that align with one's strengths and passions, rather than simply focusing on high-paying jobs that may require excessive hours and intense labor.\n",
     "One Weibo user pontificates, \"Don't earn that much hard-earned money,\" a sentiment echoed by others with tweets such as, \"Why is it that when earning money, that process always has to be so tough?\" This question is followed by a comparison between two types of people - those who are used to earning money the hard way and those who seem to effortlessly obtain wealth. While the former group is depicted as having been taught to suffer from a young age, the latter is shown as being able to focus solely on their natural talents and thriving in their niche advantageously.\n",
@@ -27,7 +27,7 @@
     "Heart count: 0/2\n",
     "Note: The author did not include any Chinese characters in the final response.\n",
     "Collapse\n",
-    "'''"
+    "\"\"\""
    ]
   },
   {
@@ -50,14 +50,16 @@
     "from semantic_router.splitters import RollingWindowSplitter\n",
     "from semantic_router.encoders import OpenAIEncoder\n",
     "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = os.getenv(\"OPENAI_API_KEY\") or getpass(\"Enter your OpenAI API key: \")\n",
+    "os.environ[\"OPENAI_API_KEY\"] = os.getenv(\"OPENAI_API_KEY\") or getpass(\n",
+    "    \"Enter your OpenAI API key: \"\n",
+    ")\n",
     "\n",
     "splitter = RollingWindowSplitter(\n",
     "    encoder=OpenAIEncoder(),\n",
     "    min_split_tokens=50,\n",
     "    max_split_tokens=300,\n",
-    "    window_size=5, # sentences\n",
-    "    plot_splits=True\n",
+    "    window_size=5,  # sentences\n",
+    "    plot_splits=True,\n",
     ")"
    ]
   },