From 6227571fa773964835310aa1102ab8e055ef2b9b Mon Sep 17 00:00:00 2001
From: Mahesh Vashishtha <mahesh.vashishtha@snowflake.com>
Date: Tue, 27 Aug 2024 16:00:43 -0700
Subject: [PATCH 01/11] SNOW-1637101: Support binary operations between two
 timedeltas. (#2169)

SNOW-1637101

---------
Signed-off-by: sfc-gh-mvashishtha <mahesh.vashishtha@snowflake.com>
---
 CHANGELOG.md                                  |   4 +-
 .../modin/plugin/_internal/binary_op_utils.py | 113 +++-
 .../compiler/snowflake_query_compiler.py      |  77 ++-
 tests/integ/modin/binary/test_timedelta.py    | 554 +++++++++++++++++-
 tests/integ/modin/frame/test_compare.py       |  83 ++-
 tests/integ/modin/frame/test_equals.py        |   8 +
 tests/integ/modin/series/test_equals.py       |   8 +
 tests/integ/modin/test_timedelta_ops.py       |  80 +--
 .../notebooks/modin/MIMICHealthcareDemo.ipynb | 163 ++++--
 9 files changed, 900 insertions(+), 190 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a4c9b8d5ee..99ac288a7a9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,13 +45,13 @@
 
 #### New Features
 
-- Added limited support for the `Timedelta` type, including
+- Added limited support for the `Timedelta` type, including the following features. Snowpark pandas will raise `NotImplementedError` for unsupported `Timedelta` use cases.
   - supporting tracking the Timedelta type through `copy`, `cache_result`, `shift`, `sort_index`.
   - converting non-timedelta to timedelta via `astype`. 
-  - `NotImplementedError` will be raised for the rest of methods that do not support `Timedelta`.
   - support for subtracting two timestamps to get a Timedelta.
   - support indexing with Timedelta data columns. 
   - support for adding or subtracting timestamps and `Timedelta`.
+  - support for binary arithmetic between two `Timedelta` values.
 - Added support for index's arithmetic and comparison operators.
 - Added support for `Series.dt.round`.
 - Added documentation pages for `DatetimeIndex`.
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py b/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py
index 7d03940b7e0..a0ca357c59b 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py
@@ -6,6 +6,7 @@
 from dataclasses import dataclass
 from types import MappingProxyType
 
+import numpy as np
 import pandas as native_pd
 from pandas._typing import Callable, Scalar
 
@@ -236,10 +237,34 @@ def _compute_subtraction_between_snowpark_timestamp_columns(
         "rmul": "mul",
         "rsub": "sub",
         "rmod": "mod",
+        "__rand__": "__and__",
+        "__ror__": "__or__",
     }
 )
 
 
+def _op_is_between_two_timedeltas_or_timedelta_and_null(
+    first_datatype: DataType, second_datatype: DataType
+) -> bool:
+    """
+    Whether the binary operation is between two timedeltas, or between timedelta and null.
+
+    Args:
+        first_datatype: First datatype
+        second_datatype: Second datatype
+
+    Returns:
+        bool: Whether op is between two timedeltas or between timedelta and null.
+    """
+    return (
+        isinstance(first_datatype, TimedeltaType)
+        and isinstance(second_datatype, (TimedeltaType, NullType))
+    ) or (
+        isinstance(first_datatype, (TimedeltaType, NullType))
+        and isinstance(second_datatype, TimedeltaType)
+    )
+
+
 def compute_binary_op_between_snowpark_columns(
     op: str,
     first_operand: SnowparkColumn,
@@ -274,6 +299,7 @@ def compute_binary_op_between_snowpark_columns(
         )
 
     binary_op_result_column = None
+    snowpark_pandas_type = None
 
     # some operators and the data types have to be handled specially to align with pandas
     # However, it is difficult to fail early if the arithmetic operator is not compatible
@@ -290,7 +316,18 @@ def compute_binary_op_between_snowpark_columns(
         and isinstance(second_datatype(), TimestampType)
     ):
         binary_op_result_column = dateadd("ns", first_operand, second_operand)
-    elif op == "add" and (
+    elif op in (
+        "add",
+        "sub",
+        "eq",
+        "ne",
+        "gt",
+        "ge",
+        "lt",
+        "le",
+        "floordiv",
+        "truediv",
+    ) and (
         (
             isinstance(first_datatype(), TimedeltaType)
             and isinstance(second_datatype(), NullType)
@@ -315,16 +352,66 @@ def compute_binary_op_between_snowpark_columns(
         # Timedelta - Timestamp doesn't make sense. Raise the same error
         # message as pandas.
         raise TypeError("bad operand type for unary -: 'DatetimeArray'")
-    elif isinstance(first_datatype(), TimedeltaType) or isinstance(
-        second_datatype(), TimedeltaType
+    elif op == "mod" and _op_is_between_two_timedeltas_or_timedelta_and_null(
+        first_datatype(), second_datatype()
+    ):
+        binary_op_result_column = compute_modulo_between_snowpark_columns(
+            first_operand, first_datatype(), second_operand, second_datatype()
+        )
+        snowpark_pandas_type = TimedeltaType()
+    elif op == "pow" and _op_is_between_two_timedeltas_or_timedelta_and_null(
+        first_datatype(), second_datatype()
+    ):
+        raise TypeError("unsupported operand type for **: Timedelta")
+    elif op == "__or__" and _op_is_between_two_timedeltas_or_timedelta_and_null(
+        first_datatype(), second_datatype()
+    ):
+        raise TypeError("unsupported operand type for |: Timedelta")
+    elif op == "__and__" and _op_is_between_two_timedeltas_or_timedelta_and_null(
+        first_datatype(), second_datatype()
+    ):
+        raise TypeError("unsupported operand type for &: Timedelta")
+    elif (
+        op in ("add", "sub")
+        and isinstance(first_datatype(), TimedeltaType)
+        and isinstance(second_datatype(), TimedeltaType)
+    ):
+        snowpark_pandas_type = TimedeltaType()
+    elif op == "mul" and _op_is_between_two_timedeltas_or_timedelta_and_null(
+        first_datatype(), second_datatype()
+    ):
+        raise np.core._exceptions._UFuncBinaryResolutionError(  # type: ignore[attr-defined]
+            np.multiply, (np.dtype("timedelta64[ns]"), np.dtype("timedelta64[ns]"))
+        )
+    elif _op_is_between_two_timedeltas_or_timedelta_and_null(
+        first_datatype(), second_datatype()
+    ) and op in ("eq", "ne", "gt", "ge", "lt", "le", "truediv"):
+        # These operations, when done between timedeltas, work without any
+        # extra handling in `snowpark_pandas_type` or `binary_op_result_column`.
+        # They produce outputs that are not timedeltas (e.g. numbers for floordiv
+        # and truediv, and bools for the comparisons).
+        pass
+    elif (
+        # equal_null and floordiv for timedelta also work without special
+        # handling, but we need to exclude them from the above case so we catch
+        # them in an `elif` clause further down.
+        op not in ("equal_null", "floordiv")
+        and (
+            (
+                isinstance(first_datatype(), TimedeltaType)
+                and not isinstance(second_datatype(), TimedeltaType)
+            )
+            or (
+                not isinstance(first_datatype(), TimedeltaType)
+                and isinstance(second_datatype(), TimedeltaType)
+            )
+        )
     ):
         # We don't support these cases yet.
-        # TODO(SNOW-1637101, SNOW-1637102): Support these cases.
+        # TODO(SNOW-1637102): Support this case.
         ErrorMessage.not_implemented(
-            f"Snowpark pandas does not yet support the binary operation {op} with timedelta types."
+            f"Snowpark pandas does not yet support the binary operation {op} with a Timedelta column and a non-Timedelta column."
         )
-    elif op == "truediv":
-        binary_op_result_column = first_operand / second_operand
     elif op == "floordiv":
         binary_op_result_column = floor(first_operand / second_operand)
     elif op == "mod":
@@ -335,9 +422,9 @@ def compute_binary_op_between_snowpark_columns(
         binary_op_result_column = compute_power_between_snowpark_columns(
             first_operand, second_operand
         )
-    elif op in ["__or__", "__ror__"]:
+    elif op == "__or__":
         binary_op_result_column = first_operand | second_operand
-    elif op in ["__and__", "__rand__"]:
+    elif op == "__and__":
         binary_op_result_column = first_operand & second_operand
     elif (
         op == "add"
@@ -370,6 +457,8 @@ def compute_binary_op_between_snowpark_columns(
             pandas_lit(""),
         )
     elif op == "equal_null":
+        # TODO(SNOW-1641716): In Snowpark pandas, generally use this equal_null
+        # with type checking intead of snowflake.snowpark.functions.equal_null.
         if not are_equal_types(first_datatype(), second_datatype()):
             binary_op_result_column = pandas_lit(False)
         else:
@@ -409,7 +498,7 @@ def compute_binary_op_between_snowpark_columns(
 
     return SnowparkPandasColumn(
         snowpark_column=binary_op_result_column,
-        snowpark_pandas_type=None,
+        snowpark_pandas_type=snowpark_pandas_type,
     )
 
 
@@ -423,6 +512,10 @@ def are_equal_types(type1: DataType, type2: DataType) -> bool:
     Returns:
         True if given types are equal, False otherwise.
     """
+    if isinstance(type1, TimedeltaType) and not isinstance(type2, TimedeltaType):
+        return False
+    if isinstance(type2, TimedeltaType) and not isinstance(type1, TimedeltaType):
+        return False
     if isinstance(type1, _IntegralType) and isinstance(type2, _IntegralType):
         return True
     if isinstance(type1, _FractionalType) and isinstance(type2, _FractionalType):
diff --git a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
index 31904a58b65..380ed7db05d 100644
--- a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
+++ b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
@@ -17257,17 +17257,27 @@ def compare(
             other._modin_frame.data_column_snowflake_quoted_identifiers,
             self._modin_frame.data_column_pandas_labels,
         ):
+            left_identiifer = result_column_mapper.left_quoted_identifiers_map[
+                left_identifier
+            ]
+            right_identifier = result_column_mapper.right_quoted_identifiers_map[
+                right_identifier
+            ]
+            op_result = compute_binary_op_between_snowpark_columns(
+                op="equal_null",
+                first_operand=col(left_identifier),
+                first_datatype=functools.partial(
+                    lambda col: result_frame.get_snowflake_type(col), left_identiifer
+                ),
+                second_operand=col(right_identifier),
+                second_datatype=functools.partial(
+                    lambda col: result_frame.get_snowflake_type(col), right_identifier
+                ),
+            )
             binary_op_result = binary_op_result.append_column(
                 str(left_pandas_label) + "_comparison_result",
-                col(
-                    result_column_mapper.left_quoted_identifiers_map[left_identifier]
-                ).equal_null(
-                    col(
-                        result_column_mapper.right_quoted_identifiers_map[
-                            right_identifier
-                        ]
-                    )
-                ),
+                op_result.snowpark_column,
+                op_result.snowpark_pandas_type,
             )
         """
         >>> SnowflakeQueryCompiler(binary_op_result).to_pandas()
@@ -17345,28 +17355,48 @@ def compare(
         new_pandas_labels = []
         new_values = []
         column_index_tuples = []
+        column_types = []
         for (
             pandas_column_value,
             pandas_label,
             left_identifier,
             right_identifier,
             column_only_contains_matches,
+            left_type,
+            right_type,
         ) in zip(
             self.columns,
             filtered_binary_op_result.data_column_pandas_labels,
             self._modin_frame.data_column_snowflake_quoted_identifiers,
             other._modin_frame.data_column_snowflake_quoted_identifiers,
             all_rows_match_frame.iloc[:, 0].values,
+            self._modin_frame.cached_data_column_snowpark_pandas_types,
+            other._modin_frame.cached_data_column_snowpark_pandas_types,
         ):
             # Drop columns that only contain matches.
             if column_only_contains_matches:
                 continue
 
-            cols_equal = col(
-                result_column_mapper.left_quoted_identifiers_map[left_identifier]
-            ).equal_null(
-                col(result_column_mapper.right_quoted_identifiers_map[right_identifier])
-            )
+            left_mappped_identifier = result_column_mapper.left_quoted_identifiers_map[
+                left_identifier
+            ]
+            right_mapped_identifier = result_column_mapper.right_quoted_identifiers_map[
+                right_identifier
+            ]
+
+            cols_equal = compute_binary_op_between_snowpark_columns(
+                op="equal_null",
+                first_operand=col(left_mappped_identifier),
+                first_datatype=functools.partial(
+                    lambda col: result_frame.get_snowflake_type(col),
+                    left_mappped_identifier,
+                ),
+                second_operand=col(right_mapped_identifier),
+                second_datatype=functools.partial(
+                    lambda col: result_frame.get_snowflake_type(col),
+                    right_mapped_identifier,
+                ),
+            ).snowpark_column
 
             # Add a column containing the values from `self`, but replace
             # matching values with null.
@@ -17375,11 +17405,7 @@ def compare(
                 iff(
                     condition=cols_equal,
                     expr1=pandas_lit(np.nan),
-                    expr2=col(
-                        result_column_mapper.left_quoted_identifiers_map[
-                            left_identifier
-                        ]
-                    ),
+                    expr2=col(left_mappped_identifier),
                 )
             )
 
@@ -17390,11 +17416,7 @@ def compare(
                 iff(
                     condition=cols_equal,
                     expr1=pandas_lit(np.nan),
-                    expr2=col(
-                        result_column_mapper.right_quoted_identifiers_map[
-                            right_identifier
-                        ]
-                    ),
+                    expr2=col(right_mapped_identifier),
                 )
             )
 
@@ -17408,8 +17430,13 @@ def compare(
                 column_index_tuples.append((pandas_column_value, "self"))
                 column_index_tuples.append((pandas_column_value, "other"))
 
+            column_types.append(left_type)
+            column_types.append(right_type)
+
         result = SnowflakeQueryCompiler(
-            filtered_binary_op_result.project_columns(new_pandas_labels, new_values)
+            filtered_binary_op_result.project_columns(
+                new_pandas_labels, new_values, column_types
+            )
         ).set_columns(
             # TODO(SNOW-1510921): fix the levels and inferred_type of the
             # result's MultiIndex once we can pass the levels correctly through
diff --git a/tests/integ/modin/binary/test_timedelta.py b/tests/integ/modin/binary/test_timedelta.py
index 632243664d7..d9fa20b1a40 100644
--- a/tests/integ/modin/binary/test_timedelta.py
+++ b/tests/integ/modin/binary/test_timedelta.py
@@ -11,8 +11,10 @@
 import pytest
 
 import snowflake.snowpark.modin.plugin  # noqa: F401
+from snowflake.snowpark.exceptions import SnowparkSQLException
 from tests.integ.modin.sql_counter import sql_count_checker
 from tests.integ.modin.utils import (
+    assert_series_equal,
     assert_snowpark_pandas_equals_to_pandas_without_dtypecheck,
     create_test_dfs,
     create_test_series,
@@ -109,12 +111,37 @@ def timestamp_scalar(request):
     return request.param
 
 
+@pytest.fixture(
+    params=[
+        pd.Timedelta("10 days 23:59:59.123456789"),
+        datetime.timedelta(microseconds=1),
+        datetime.timedelta(microseconds=2),
+        pd.Timedelta(nanoseconds=1),
+        pd.Timedelta(nanoseconds=2),
+        pd.Timedelta(nanoseconds=3),
+        pd.Timedelta(days=1),
+        pd.Timedelta(days=1, hours=1),
+        pd.Timedelta(days=10),
+    ]
+)
+def timedelta_scalar_positive(request):
+    return request.param
+
+
 @pytest.fixture(
     params=[
         pd.Timedelta("10 days 23:59:59.123456789"),
         pd.Timedelta("-10 days 23:59:59.123456789"),
         datetime.timedelta(days=-10, hours=23),
         datetime.timedelta(microseconds=1),
+        datetime.timedelta(microseconds=2),
+        pd.Timedelta(nanoseconds=1),
+        pd.Timedelta(nanoseconds=2),
+        pd.Timedelta(nanoseconds=3),
+        pd.Timedelta(days=1),
+        pd.Timedelta(days=1, hours=1),
+        pd.Timedelta(days=10),
+        pd.Timedelta(days=-1),
     ]
 )
 def timedelta_scalar(request):
@@ -134,6 +161,36 @@ def timedelta_dataframes_1() -> tuple[pd.DataFrame, native_pd.DataFrame]:
     )
 
 
+@pytest.fixture
+def timedelta_dataframes_postive_no_nulls_1_2x2() -> tuple[
+    pd.DataFrame, native_pd.DataFrame
+]:
+    return create_test_dfs(
+        [
+            [pd.Timedelta(days=1), pd.Timedelta(days=4)],
+            [
+                pd.Timedelta(days=2),
+                pd.Timedelta(days=3),
+            ],
+        ]
+    )
+
+
+@pytest.fixture
+def timedelta_dataframes_with_negatives_no_nulls_1_2x2() -> tuple[
+    pd.DataFrame, native_pd.DataFrame
+]:
+    return create_test_dfs(
+        [
+            [pd.Timedelta(days=1), pd.Timedelta(days=4)],
+            [
+                pd.Timedelta(days=2),
+                pd.Timedelta(days=-3),
+            ],
+        ]
+    )
+
+
 @pytest.fixture
 def timedelta_series_1() -> tuple[pd.Series, native_pd.Series]:
     return create_test_series(
@@ -148,10 +205,332 @@ def timedelta_series_1() -> tuple[pd.Series, native_pd.Series]:
     )
 
 
+@pytest.fixture
+def timedelta_series_positive_no_nulls_1_length_6() -> tuple[
+    pd.Series, native_pd.Series
+]:
+    return create_test_series(
+        [
+            pd.Timedelta(days=1),
+            pd.Timedelta(days=2),
+            pd.Timedelta(days=3),
+            pd.Timedelta(days=4),
+            pd.Timedelta(days=5),
+            pd.Timedelta(days=6),
+        ]
+    )
+
+
+@pytest.fixture
+def timedelta_series_no_nulls_2_length_6() -> tuple[pd.Series, native_pd.Series]:
+    return create_test_series(
+        [
+            pd.Timedelta(microseconds=7),
+            pd.Timedelta(hours=6, minutes=5),
+            pd.Timedelta(hours=4, minutes=3),
+            pd.Timedelta(hours=2, minutes=1),
+            pd.Timedelta(hours=8, minutes=9),
+            pd.Timedelta(hours=9, minutes=8),
+        ]
+    )
+
+
+@pytest.fixture
+def timedelta_series_no_nulls_3_length_2() -> tuple[pd.Series, native_pd.Series]:
+    return create_test_series(
+        [
+            pd.Timedelta(microseconds=7),
+            pd.Timedelta(hours=6, minutes=5),
+        ]
+    )
+
+
+@pytest.fixture(
+    params=[
+        "sub",
+        "rsub",
+        "add",
+        "radd",
+        "div",
+        "rdiv",
+        "truediv",
+        "rtruediv",
+        "floordiv",
+        "rfloordiv",
+        "mod",
+        "rmod",
+        "eq",
+        "ne",
+        "gt",
+        "lt",
+        "ge",
+        "le",
+    ]
+)
+def op_between_timedeltas(request) -> list[str]:
+    """Valid operations between timedeltas."""
+    return request.param
+
+
+class TestInvalid:
+    """
+    Test invalid binary operations, e.g. subtracting a timestamp from a timedelta.
+
+    For simplicity, check these cases for operations between dataframes and
+    scalars only.
+    """
+
+    @sql_count_checker(query_count=0)
+    def test_timedelta_scalar_minus_timestamp_dataframe(self):
+        eval_snowpark_pandas_result(
+            *create_test_dfs([datetime.datetime(year=2024, month=8, day=21)]),
+            lambda df: pd.Timedelta(1) - df,
+            expect_exception=True,
+            expect_exception_type=TypeError,
+            expect_exception_match=re.escape(
+                "bad operand type for unary -: 'DatetimeArray"
+            ),
+        )
+
+    @sql_count_checker(query_count=0)
+    @pytest.mark.parametrize(
+        "operation,error_symbol",
+        [("__or__", "|"), ("__ror__", "|"), ("__and__", "&"), ("__rand__", "&")],
+    )
+    def test_timedelta_dataframe_bitwise_operation_with_timedelta_scalar(
+        self, operation, timedelta_dataframes_1, error_symbol
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_dataframes_1,
+            lambda df: getattr(df, operation)(pd.Timedelta(2)),
+            expect_exception=True,
+            # pandas exception depends on the input types and is something like
+            # "unsupported operand type(s) for &: 'Timedelta' and 'TimedeltaArray'",
+            # but Snowpwark pandas always gives the same exception.
+            assert_exception_equal=False,
+            expect_exception_type=TypeError,
+            expect_exception_match=re.escape(
+                f"unsupported operand type for {error_symbol}: Timedelta"
+            ),
+        )
+
+    @sql_count_checker(query_count=0)
+    @pytest.mark.parametrize("operation", ["pow", "rpow"])
+    def test_timedelta_dataframe_exponentiation_with_timedelta_scalar(
+        self, operation, timedelta_dataframes_1
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_dataframes_1,
+            lambda df: getattr(df, operation)(pd.Timedelta(2)),
+            expect_exception=True,
+            # pandas exception depends on the input types and is something
+            # like "cannot perform __rpow__ with this index type:
+            # TimedeltaArray", but Snowpwark pandas always gives the same
+            # exception.
+            assert_exception_equal=False,
+            expect_exception_type=TypeError,
+            expect_exception_match=re.escape(
+                "unsupported operand type for **: Timedelta"
+            ),
+        )
+
+    @sql_count_checker(query_count=0)
+    @pytest.mark.parametrize("operation", ["mul", "rmul"])
+    def test_timedelta_dataframe_multiplied_by_timedelta_scalar_invalid(
+        self, operation, timedelta_dataframes_1
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_dataframes_1,
+            lambda df: getattr(df, operation)(pd.Timedelta(2)),
+            expect_exception=True,
+            expect_exception_type=np.core._exceptions._UFuncBinaryResolutionError,
+            expect_exception_match=re.escape(
+                "ufunc 'multiply' cannot use operands with types dtype('<m8[ns]') and dtype('<m8[ns]')"
+            ),
+        )
+
+
+class TestNumericEdgeCases:
+    """
+    Test numeric edge cases, e.g. arithmetic with zero and mod by a negative number.
+    """
+
+    @sql_count_checker(query_count=1)
+    @pytest.mark.parametrize(
+        "lhs,rhs,expected_pandas,expected_snow",
+        [(3, -2, -1, 1), (-3, -2, -1, -1), (-3, 2, 1, -1)],
+    )
+    def test_timedelta_mod_with_negative(
+        self, lhs, rhs, expected_pandas, expected_snow
+    ):
+        """Snowflake sometimes has different behavior for mod with negative numbers."""
+        snow_series, pandas_series = create_test_series(pd.Timedelta(lhs))
+        assert_series_equal(
+            pandas_series % pd.Timedelta(rhs),
+            native_pd.Series(pd.Timedelta(expected_pandas)),
+        )
+        assert_snowpark_pandas_equals_to_pandas_without_dtypecheck(
+            snow_series % pd.Timedelta(rhs),
+            native_pd.Series(pd.Timedelta(expected_snow)),
+        )
+
+    @sql_count_checker(query_count=0)
+    def test_divide_timedelta_by_zero_timedelta(self):
+        snow_series, pandas_series = create_test_series(pd.Timedelta(1))
+        assert_series_equal(pandas_series / pd.Timedelta(0), native_pd.Series(np.inf))
+        with pytest.raises(SnowparkSQLException, match=re.escape("Division by zero")):
+            (snow_series / pd.Timedelta(0)).to_pandas()
+
+    @sql_count_checker(query_count=0)
+    def test_floordiv_timedelta_by_zero_timedelta(self):
+        snow_series, pandas_series = create_test_series(pd.Timedelta(1))
+        assert_series_equal(pandas_series // pd.Timedelta(0), native_pd.Series(0))
+        with pytest.raises(SnowparkSQLException, match=re.escape("Division by zero")):
+            (snow_series // pd.Timedelta(0)).to_pandas()
+
+    @sql_count_checker(query_count=1)
+    def test_mod_timedelta_by_zero_timedelta(self):
+        snow_series, pandas_series = create_test_series(pd.Timedelta(1))
+        assert_series_equal(
+            pandas_series % pd.Timedelta(0),
+            native_pd.Series(1, dtype="timedelta64[ns]"),
+        )
+        assert_snowpark_pandas_equals_to_pandas_without_dtypecheck(
+            snow_series % pd.Timedelta(0),
+            native_pd.Series(pd.NaT, dtype="timedelta64[ns]"),
+        )
+
+    @sql_count_checker(query_count=1)
+    @pytest.mark.parametrize("op", ["add", "radd", "sub", "rsub"])
+    def test_timedelta_plus_or_minus_zero_timedelta(self, timedelta_dataframes_1, op):
+        eval_snowpark_pandas_result(
+            *timedelta_dataframes_1, lambda df: getattr(df, op)(pd.Timedelta(0))
+        )
+
+
+class TestNullsInTimedeltaComparisons:
+    """
+    Test comparisons (e.g. <=) between timedeltas where some operands are null.
+
+    Snowpark pandas returns null for comparsions where either operand is null,
+    whereas pandas considers null values to be equal to each other, and not
+    less than, greater than, or equal to any other values.
+
+    We test these cases separately because we can't use pandas to validate
+    Snowpark pandas results.
+    """
+
+    @sql_count_checker(query_count=1)
+    @pytest.mark.parametrize("op", ["eq", "ne", "lt", "le", "gt", "ge"])
+    def test_comparison_with_null(self, timedelta_dataframes_1, op):
+        snow_df = timedelta_dataframes_1[0]
+        assert_snowpark_pandas_equals_to_pandas_without_dtypecheck(
+            getattr(snow_df, op)(pd.NaT),
+            native_pd.DataFrame([[None, None], [None, None]]),
+        )
+
+    @sql_count_checker(query_count=1)
+    def test_eq_non_null(self, timedelta_dataframes_1):
+        snow_df = timedelta_dataframes_1[0]
+        assert_snowpark_pandas_equals_to_pandas_without_dtypecheck(
+            snow_df == pd.Timedelta(days=1),
+            native_pd.DataFrame([[True, None], [False, False]]),
+        )
+
+    @sql_count_checker(query_count=1)
+    def test_neq_non_null(self, timedelta_dataframes_1):
+        snow_df = timedelta_dataframes_1[0]
+        assert_snowpark_pandas_equals_to_pandas_without_dtypecheck(
+            snow_df != pd.Timedelta(days=1),
+            native_pd.DataFrame([[False, None], [True, True]]),
+        )
+
+
+@sql_count_checker(query_count=1)
+@pytest.mark.parametrize(
+    "op",
+    [
+        "sub",
+        "rsub",
+        "add",
+        "radd",
+    ],
+)
+def test_timedelta_timedelta_null_arithmetic_valid_in_pandas(
+    op, timedelta_dataframes_1
+):
+    """These timedelta arithmetic operations with null are valid in Snowpark pandas and pandas."""
+    eval_snowpark_pandas_result(
+        *timedelta_dataframes_1, lambda df: getattr(df, op)(pd.NaT)
+    )
+
+
+@sql_count_checker(query_count=1)
+@pytest.mark.parametrize("op", ["div", "rdiv", "mod", "rmod", "floordiv", "rfloordiv"])
+def test_timedelta_timedelta_null_arithmetic_invalid_in_pandas(
+    op, timedelta_dataframes_1
+):
+    """It is not valid in pandas to divide (div, rdiv, mod, rmod, floordiv, rfloordiv) timedelta with null scalar."""
+    snow_df, pandas_df = timedelta_dataframes_1
+
+    def op_with_null(df):
+        return getattr(df, op)(pd.NaT)
+
+    with pytest.raises(TypeError):
+        op_with_null(pandas_df)
+    assert_snowpark_pandas_equals_to_pandas_without_dtypecheck(
+        op_with_null(snow_df), native_pd.DataFrame([[pd.NaT, pd.NaT], [pd.NaT, pd.NaT]])
+    )
+
+
+@sql_count_checker(query_count=1)
+@sql_count_checker(query_count=1)
+@pytest.mark.parametrize(
+    "op",
+    [
+        "sub",
+        "rsub",
+        "add",
+        "radd",
+        "div",
+        "rdiv",
+        "truediv",
+        "rtruediv",
+        "floordiv",
+        "rfloordiv",
+    ],
+)
+def test_valid_arithmetic_between_possibly_negative_timedeltas(
+    timedelta_dataframes_with_negatives_no_nulls_1_2x2, op, timedelta_scalar
+):
+    """
+    Test that all valid arithmetic (except mod) between Timedeltas works with negative operands.
+
+    Test just dataframe left operand and scalar right operand in this test case.
+    """
+    if op == "rfloordiv" and timedelta_scalar in (
+        datetime.timedelta(microseconds=1),
+        datetime.timedelta(microseconds=2),
+        pd.Timedelta(nanoseconds=1),
+        pd.Timedelta(nanoseconds=2),
+        pd.Timedelta(nanoseconds=3),
+    ):
+        # snowflake returns 0 for dividing tiny timedeltas by large (~days)
+        # timedelta dataframes, so floordiv gives 0 in Snowflake but -1 in
+        # pandas. e.g.  pd.Timedelta('0 days 00:00:00.000000003') / pd.DataFrame([pd.Timedelta('-3 days')])
+        # translates to  pd.session.sql('SELECT 3.0 / -259200000000000.0').to_pandas(),
+        # which gives 0
+        pytest.xfail("precision difference in snowflake")
+    eval_snowpark_pandas_result(
+        *timedelta_dataframes_with_negatives_no_nulls_1_2x2,
+        lambda df: getattr(df, op)(timedelta_scalar),
+    )
+
+
 class TestDataFrameAndScalar:
     @pytest.mark.parametrize("operation", ["sub", "rsub"])
     @sql_count_checker(query_count=1)
-    def test_timestamp_col_minus_timestamp_scalar(
+    def test_timestamp_minus_timestamp(
         self,
         timestamp_scalar,
         operation,
@@ -194,18 +573,6 @@ def test_timestamp_dataframe_plus_or_minus_timedelta_scalar(
             lambda df: getattr(df, operation)(timedelta_scalar),
         )
 
-    @sql_count_checker(query_count=0)
-    def test_timedelta_scalar_minus_timestamp_dataframe_negative(self):
-        eval_snowpark_pandas_result(
-            *create_test_dfs([datetime.datetime(year=2024, month=8, day=21)]),
-            lambda df: pd.Timedelta(1) - df,
-            expect_exception=True,
-            expect_exception_type=TypeError,
-            expect_exception_match=re.escape(
-                "bad operand type for unary -: 'DatetimeArray"
-            ),
-        )
-
     @sql_count_checker(query_count=1)
     @pytest.mark.parametrize("operation", ["add", "radd"])
     def test_timedelta_dataframe_plus_timestamp_scalar(
@@ -215,13 +582,30 @@ def test_timedelta_dataframe_plus_timestamp_scalar(
             *timedelta_dataframes_1, lambda df: getattr(df, operation)(timestamp_scalar)
         )
 
-    @pytest.mark.parametrize("operation", ["sub", "rsub", "add", "radd"])
-    @pytest.mark.xfail(strict=True, raises=NotImplementedError, reason="SNOW-1637101")
-    def test_timedelta_dataframe_plus_or_minus_timedelta_scalar(
-        self, timedelta_dataframes_1, timedelta_scalar, operation
+    @sql_count_checker(query_count=1)
+    def test_timedelta_dataframe_with_timedelta_scalar(
+        self,
+        timedelta_dataframes_postive_no_nulls_1_2x2,
+        timedelta_scalar_positive,
+        op_between_timedeltas,
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_dataframes_postive_no_nulls_1_2x2,
+            lambda df: getattr(df, op_between_timedeltas)(timedelta_scalar_positive),
+        )
+
+    @pytest.mark.xfail(
+        strict=True,
+        raises=NotImplementedError,
+        match="does not yet support the binary operation .* with a Timedelta column and a non-Timedelta column",
+        reason="SNOW-1637102",
+    )
+    @pytest.mark.parametrize("op", ["mul", "rmul"])
+    def test_timedelta_dataframe_with_integer_scalar(
+        self, timedelta_dataframes_postive_no_nulls_1_2x2, op
     ):
         eval_snowpark_pandas_result(
-            *timedelta_dataframes_1, lambda df: getattr(df, operation)(timedelta_scalar)
+            *timedelta_dataframes_postive_no_nulls_1_2x2, lambda df: getattr(df, op)(3)
         )
 
 
@@ -268,6 +652,20 @@ def test_timedelta_series_plus_timestamp_scalar(
             lambda series: getattr(series, operation)(timestamp_scalar),
         )
 
+    @sql_count_checker(query_count=1)
+    def test_timedelta_series_with_timedelta_scalar(
+        self,
+        timedelta_scalar_positive,
+        timedelta_series_positive_no_nulls_1_length_6,
+        op_between_timedeltas,
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_series_positive_no_nulls_1_length_6,
+            lambda series: getattr(series, op_between_timedeltas)(
+                timedelta_scalar_positive
+            ),
+        )
+
 
 class TestDataFrameAndListLikeAxis1:
     @pytest.mark.parametrize("op", ["sub", "rsub"])
@@ -317,6 +715,20 @@ def test_timedelta_dataframe_plus_timestamp_list_like(
             ),
         )
 
+    @sql_count_checker(query_count=1)
+    def test_timedelta_dataframe_with_timedelta_list_like(
+        self, op_between_timedeltas, timedelta_dataframes_postive_no_nulls_1_2x2
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_dataframes_postive_no_nulls_1_2x2,
+            lambda df: getattr(df, op_between_timedeltas)(
+                [
+                    pd.Timedelta(days=2, milliseconds=140),
+                    pd.Timedelta(days=1, milliseconds=770),
+                ]
+            ),
+        )
+
 
 class TestSeriesAndListLike:
     @sql_count_checker(query_count=1, join_count=1)
@@ -368,6 +780,24 @@ def test_timedelta_series_plus_timestamp_list_like(self, op, timedelta_series_1)
             ),
         )
 
+    @sql_count_checker(query_count=1, join_count=1)
+    def test_timedelta_series_and_timedelta_list_like(
+        self, op_between_timedeltas, timedelta_series_positive_no_nulls_1_length_6
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_series_positive_no_nulls_1_length_6,
+            lambda series: getattr(series, op_between_timedeltas)(
+                [
+                    pd.Timedelta(days=6, minutes=6),
+                    pd.Timedelta(days=5, minutes=5),
+                    pd.Timedelta(days=4, minutes=4),
+                    pd.Timedelta(days=3, minutes=3),
+                    pd.Timedelta(days=2, minutes=2),
+                    pd.Timedelta(nanoseconds=2),
+                ]
+            ),
+        )
+
 
 class TestDataFrameAndListLikeAxis0:
     @sql_count_checker(query_count=1, join_count=1)
@@ -420,6 +850,21 @@ def test_timedelta_dataframe_plus_timestamp_list_like(
             ),
         )
 
+    @sql_count_checker(query_count=1, join_count=1)
+    def test_timedelta_dataframe_and_timedelta_list_like(
+        self, op_between_timedeltas, timedelta_dataframes_postive_no_nulls_1_2x2
+    ):
+        eval_snowpark_pandas_result(
+            *timedelta_dataframes_postive_no_nulls_1_2x2,
+            lambda df: getattr(df, op_between_timedeltas)(
+                [
+                    pd.Timedelta(nanoseconds=1),
+                    pd.Timedelta(microseconds=2),
+                ],
+                axis=0,
+            ),
+        )
+
 
 class TestSeriesAndSeries:
     @pytest.mark.parametrize(
@@ -514,6 +959,21 @@ def test_timedelta_plus_timestamp(self, op, timedelta_series_1):
             lambda inputs: getattr(inputs[0], op)(inputs[1]),
         )
 
+    @sql_count_checker(query_count=1, join_count=1)
+    def test_timedelta_and_timedleta(
+        self,
+        op_between_timedeltas,
+        timedelta_series_positive_no_nulls_1_length_6,
+        timedelta_series_no_nulls_2_length_6,
+    ):
+        snow_lhs, pandas_lhs = timedelta_series_positive_no_nulls_1_length_6
+        snow_rhs, pandas_rhs = timedelta_series_no_nulls_2_length_6
+        eval_snowpark_pandas_result(
+            (snow_lhs, snow_rhs),
+            (pandas_lhs, pandas_rhs),
+            lambda inputs: getattr(inputs[0], op_between_timedeltas)(inputs[1]),
+        )
+
 
 class TestDataFrameAndSeriesAxis0:
     @pytest.mark.parametrize("op", ["sub", "rsub"])
@@ -579,6 +1039,21 @@ def test_timedelta_dataframe_plus_timestamp_series(
             lambda t: getattr(t[0], op)(t[1], axis=0),
         )
 
+    @sql_count_checker(query_count=1, join_count=1)
+    def test_timedelta_dataframe_and_timedelta_series(
+        self,
+        op_between_timedeltas,
+        timedelta_dataframes_postive_no_nulls_1_2x2,
+        timedelta_series_no_nulls_3_length_2,
+    ):
+        snow_df, pandas_df = timedelta_dataframes_postive_no_nulls_1_2x2
+        snow_series, pandas_series = timedelta_series_no_nulls_3_length_2
+        eval_snowpark_pandas_result(
+            (snow_df, snow_series),
+            (pandas_df, pandas_series),
+            lambda t: getattr(t[0], op_between_timedeltas)(t[1], axis=0),
+        )
+
 
 class TestDataFrameAndSeriesAxis1:
     @sql_count_checker(
@@ -669,7 +1144,7 @@ def test_timestamp_series_minus_timestamp_dataframe(
         )
 
     @sql_count_checker(
-        # One query to materialize the series for the subtraction, and another
+        # One query to materialize the series for the operation, and another
         # query to materialize the result.
         query_count=2
     )
@@ -767,7 +1242,7 @@ def test_timestamp_dataframe_minus_timedelta_series(
         )
 
     @sql_count_checker(
-        # One query to materialize the series for the subtraction, and another
+        # One query to materialize the series for the operation, and another
         # query to materialize the result.
         query_count=2
     )
@@ -811,6 +1286,25 @@ def test_timedelta_dataframe_plus_timestamp_series(
             ),
         )
 
+    @sql_count_checker(
+        # One query to materialize the series for the subtraction, and another
+        # query to materialize the result.
+        query_count=2
+    )
+    def test_timedelta_dataframe_with_timedelta_series(
+        self,
+        timedelta_dataframes_postive_no_nulls_1_2x2,
+        timedelta_series_no_nulls_3_length_2,
+        op_between_timedeltas,
+    ):
+        snow_df, pandas_df = timedelta_dataframes_postive_no_nulls_1_2x2
+        snow_series, pandas_series = timedelta_series_no_nulls_3_length_2
+        eval_snowpark_pandas_result(
+            (snow_df, snow_series),
+            (pandas_df, pandas_series),
+            lambda t: getattr(t[0], op_between_timedeltas)(t[1]),
+        )
+
 
 class TestDataFrameAndDataFrameAxis1:
     @pytest.mark.parametrize(
@@ -891,3 +1385,23 @@ def test_timedelta_dataframe_plus_timestamp_dataframe(self, op):
             (pandas_lhs, pandas_rhs),
             lambda t: getattr(t[0], op)(t[1]),
         )
+
+    @sql_count_checker(query_count=1, join_count=1)
+    def test_two_timedelta_datfaframes(
+        self, timedelta_dataframes_postive_no_nulls_1_2x2, op_between_timedeltas
+    ):
+        snow_lhs, pandas_lhs = timedelta_dataframes_postive_no_nulls_1_2x2
+        snow_rhs, pandas_rhs = create_test_dfs(
+            [
+                [
+                    pd.Timedelta(nanoseconds=1),
+                    pd.Timedelta(microseconds=1),
+                ],
+                [pd.Timedelta(days=2), pd.Timedelta(days=1)],
+            ]
+        )
+        eval_snowpark_pandas_result(
+            (snow_lhs, snow_rhs),
+            (pandas_lhs, pandas_rhs),
+            lambda t: getattr(t[0], op_between_timedeltas)(t[1]),
+        )
diff --git a/tests/integ/modin/frame/test_compare.py b/tests/integ/modin/frame/test_compare.py
index 761422f158d..9a0f7caf88d 100644
--- a/tests/integ/modin/frame/test_compare.py
+++ b/tests/integ/modin/frame/test_compare.py
@@ -10,15 +10,25 @@
 from tests.integ.modin.sql_counter import sql_count_checker
 from tests.integ.modin.utils import create_test_dfs, eval_snowpark_pandas_result
 
-# (+1 query, +0 join) materialize first frame's index for comparison if multi-index
-# (+1 query, +0 join) materialize second frame's index for comparison if multi-index
+# (+1 query, +0 join) materialize first frame's index for comparison
+# (+1 query, +0 join) materialize second frame's index for comparison
 # (+1 query, +1 join) row count query for joining the two frames and checking
 #                     for columns where all rows match.
 # (+1 query, +1 join) materialize query that joins the two frames and checks
 #                     for columns where all rows match.
 # (+1 query, +1 join) convert final comparison result with join to pandas
-QUERY_COUNT = 5
-JOIN_COUNT = 3
+QUERY_COUNT_MULTI_LEVEL_INDEX = 5
+JOIN_COUNT_MULTI_LEVEL_INDEX = 3
+
+
+# (+1 query, +1 join) execute a query to compare two frames' lazy indexes.
+# (+1 query, +1 join) row count query for joining the two frames and checking
+#                     for columns where all rows match.
+# (+1 query, +1 join) materialize query that joins the two frames and checks
+#                     for columns where all rows match.
+# (+1 query, +1 join) convert final comparison result with join to pandas
+QUERY_COUNT_SINGLE_LEVEL_INDEX = 4
+JOIN_COUNT_SINGLE_LEVEL_INDEX = 4
 
 
 @pytest.fixture
@@ -61,7 +71,10 @@ def base_df() -> native_pd.DataFrame:
 
 
 class TestDefaultParameters:
-    @sql_count_checker(query_count=QUERY_COUNT, join_count=JOIN_COUNT)
+    @sql_count_checker(
+        query_count=QUERY_COUNT_MULTI_LEVEL_INDEX,
+        join_count=JOIN_COUNT_MULTI_LEVEL_INDEX,
+    )
     def test_no_diff(self, base_df):
         other_df = base_df.copy()
         eval_snowpark_pandas_result(
@@ -72,6 +85,56 @@ def test_no_diff(self, base_df):
             # In snowpark pandas, the column index of the empty resulting frame
             # has the correct values and names, but the incorrect inferred_type
             # for some of its levels. Ignore that bug for now.
+            # TODO(SNOW-1510921): fix the bug.
+            check_index_type=False,
+            check_column_type=False,
+        )
+
+    @sql_count_checker(
+        # no joins because we can skip the joins when comparing df to df.copy()
+        query_count=QUERY_COUNT_SINGLE_LEVEL_INDEX,
+        join_count=0,
+    )
+    def test_no_diff_timedelta(self):
+        eval_snowpark_pandas_result(
+            *create_test_dfs([pd.Timedelta(1)]),
+            lambda df: df.compare(df.copy()),
+            check_index_type=False,
+            check_column_type=False,
+        )
+
+    @sql_count_checker(
+        query_count=QUERY_COUNT_SINGLE_LEVEL_INDEX,
+        join_count=JOIN_COUNT_SINGLE_LEVEL_INDEX,
+    )
+    def test_one_diff_timedelta(self):
+        base_snow_df, base_pandas_df = create_test_dfs(
+            [[pd.Timedelta(1), pd.Timedelta(2)]]
+        )
+        other_snow_df, other_pandas_df = create_test_dfs(
+            [[pd.Timedelta(1), pd.Timedelta(3)]]
+        )
+        eval_snowpark_pandas_result(
+            (base_snow_df, other_snow_df),
+            (base_pandas_df, other_pandas_df),
+            lambda t: t[0].compare(t[1]),
+            check_index_type=False,
+            check_column_type=False,
+        )
+
+    @sql_count_checker(
+        query_count=QUERY_COUNT_SINGLE_LEVEL_INDEX,
+        join_count=JOIN_COUNT_SINGLE_LEVEL_INDEX,
+    )
+    def test_timedelta_compared_with_int(self):
+        base_snow_df, base_pandas_df = create_test_dfs([[pd.Timedelta(1), 2]])
+        other_snow_df, other_pandas_df = create_test_dfs(
+            [[pd.Timedelta(1), pd.Timedelta(2)]]
+        )
+        eval_snowpark_pandas_result(
+            (base_snow_df, other_snow_df),
+            (base_pandas_df, other_pandas_df),
+            lambda t: t[0].compare(t[1]),
             check_index_type=False,
             check_column_type=False,
         )
@@ -86,7 +149,10 @@ def test_no_diff(self, base_df):
             ((3, 4), [201]),
         ],
     )
-    @sql_count_checker(query_count=QUERY_COUNT, join_count=JOIN_COUNT)
+    @sql_count_checker(
+        query_count=QUERY_COUNT_MULTI_LEVEL_INDEX,
+        join_count=JOIN_COUNT_MULTI_LEVEL_INDEX,
+    )
     def test_single_value_diff(self, base_df, position, new_value):
         # check that we are changing a value, so the test case is meaningful.
         assert not (
@@ -122,7 +188,10 @@ def test_default_index_on_both_axes(self, base_df):
             ),
         )
 
-    @sql_count_checker(query_count=QUERY_COUNT, join_count=JOIN_COUNT)
+    @sql_count_checker(
+        query_count=QUERY_COUNT_MULTI_LEVEL_INDEX,
+        join_count=JOIN_COUNT_MULTI_LEVEL_INDEX,
+    )
     def test_different_value_in_every_column_and_row(self, base_df):
         other_df = base_df.copy()
         other_df.iloc[0, 0] = "c"
diff --git a/tests/integ/modin/frame/test_equals.py b/tests/integ/modin/frame/test_equals.py
index e57c4180231..95b6b8ffd6f 100644
--- a/tests/integ/modin/frame/test_equals.py
+++ b/tests/integ/modin/frame/test_equals.py
@@ -15,6 +15,12 @@
     "lhs, rhs, expected",
     [
         ([1, 2, 3], [1, 2, 3], True),
+        pytest.param(
+            [pd.Timedelta(1), pd.Timedelta(2), pd.Timedelta(3)],
+            [pd.Timedelta(1), pd.Timedelta(2), pd.Timedelta(3)],
+            True,
+            id="timedelta",
+        ),
         ([1, 2, 3], [1, 2, 4], False),  # different values
         ([1, 2, None], [1, 2, None], True),  # nulls are considered equal
         ([1, 2, 3], [1.0, 2.0, 3.0], False),  # float and integer types are not equal
@@ -58,6 +64,8 @@ def test_equals_column_labels(lhs, rhs, expected):
         (np.float64, np.float32, True),
         (np.int16, "object", False),
         (np.int16, np.float16, False),
+        ("timedelta64[ns]", int, False),
+        ("timedelta64[ns]", float, False),
     ],
 )
 @sql_count_checker(query_count=2, join_count=2)
diff --git a/tests/integ/modin/series/test_equals.py b/tests/integ/modin/series/test_equals.py
index b0f7af34b19..912726ff2f9 100644
--- a/tests/integ/modin/series/test_equals.py
+++ b/tests/integ/modin/series/test_equals.py
@@ -15,6 +15,12 @@
     "lhs, rhs, expected",
     [
         ([1, 2, 3], [1, 2, 3], True),
+        pytest.param(
+            [pd.Timedelta(1), pd.Timedelta(2), pd.Timedelta(3)],
+            [pd.Timedelta(1), pd.Timedelta(2), pd.Timedelta(3)],
+            True,
+            id="timedelta",
+        ),
         ([1, 2, None], [1, 2, None], True),  # nulls are considered equal
         ([1, 2, 3], [1.0, 2.0, 3.0], False),  # float and integer types are not equal
         ([1, 2, 3], ["1", "2", "3"], False),  # integer and string types are not equal
@@ -37,6 +43,8 @@ def test_equals_series(lhs, rhs, expected):
         (np.float64, np.float32, True),
         (np.int16, "object", False),
         (np.int16, np.float16, False),
+        ("timedelta64[ns]", int, False),
+        ("timedelta64[ns]", float, False),
     ],
 )
 @sql_count_checker(query_count=2, join_count=2)
diff --git a/tests/integ/modin/test_timedelta_ops.py b/tests/integ/modin/test_timedelta_ops.py
index 2d38c1e372f..c60b91b3273 100644
--- a/tests/integ/modin/test_timedelta_ops.py
+++ b/tests/integ/modin/test_timedelta_ops.py
@@ -26,8 +26,8 @@
 }
 
 
-@sql_count_checker(query_count=0)
-def test_td_case1_negative():
+@sql_count_checker(query_count=1)
+def test_insert_datetime_difference_in_days():
     data = TIME_DATA1
     snow_df = pd.DataFrame(data)
     native_df = native_pd.DataFrame(data)
@@ -41,80 +41,20 @@ def test_td_case1_negative():
         )
         / np.timedelta64(1, "D")
     ).round()
-    # TODO SNOW-1635620: remove Exception raised when TimeDelta is implemented
-    with pytest.raises(NotImplementedError):
-        snow_df["month_lag"] = (
-            (
-                pd.to_datetime(snow_df["CREATED_AT"], format="%Y-%m-%d %H:%M:%S")
-                - pd.to_datetime(
-                    snow_df["REPORTING_DATE"], format="%Y-%m-%d", errors="coerce"
-                )
-            )
-            / np.timedelta64(1, "D")
-        ).round()
-        assert_series_equal(snow_df["month_lag"], native_df["open_lag"])
-
-
-@sql_count_checker(query_count=0)
-def test_td_case2_negative():
-    data = TIME_DATA1
-    snow_df = pd.DataFrame(data)
-    native_df = native_pd.DataFrame(data)
-    native_df["open_lag"] = (
-        (
-            native_pd.to_datetime(native_df["CREATED_AT"], format="%Y-%m-%d %H:%M:%S")
-            - native_pd.to_datetime(
-                native_df["OPEN_DATE"], format="%Y-%m-%d", errors="coerce"
-            )
-        )
-        / np.timedelta64(1, "D")
-    ).round()
-    # TODO SNOW-1635620: remove Exception raised when TimeDelta is implemented
-    with pytest.raises(NotImplementedError):
-        snow_df["open_lag"] = (
-            (
-                pd.to_datetime(snow_df["CREATED_AT"], format="%Y-%m-%d %H:%M:%S")
-                - pd.to_datetime(
-                    snow_df["OPEN_DATE"], format="%Y-%m-%d", errors="coerce"
-                )
-            )
-            / np.timedelta64(1, "D")
-        ).round()
-        assert_series_equal(snow_df["open_lag"], native_df["open_lag"])
-
-
-@sql_count_checker(query_count=0)
-def test_td_case3_negative():
-    data = TIME_DATA1
-    snow_df = pd.DataFrame(data)
-    native_df = native_pd.DataFrame(data)
-
-    native_df["close_lag"] = (
+    snow_df["month_lag"] = (
         (
-            native_pd.to_datetime(native_df["CREATED_AT"], format="%Y-%m-%d %H:%M:%S")
-            - native_pd.to_datetime(
-                native_df["CLOSED_DATE"], format="%Y-%m-%d", errors="coerce"
+            pd.to_datetime(snow_df["CREATED_AT"], format="%Y-%m-%d %H:%M:%S")
+            - pd.to_datetime(
+                snow_df["REPORTING_DATE"], format="%Y-%m-%d", errors="coerce"
             )
         )
         / np.timedelta64(1, "D")
     ).round()
-    # TODO SNOW-1635620: remove Exception raised when TimeDelta is implemented
-    with pytest.raises(NotImplementedError):
-        snow_df["close_lag"] = (
-            (
-                pd.to_datetime(snow_df["CREATED_AT"], format="%Y-%m-%d %H:%M:%S")
-                - pd.to_datetime(
-                    snow_df["CLOSED_DATE"], format="%Y-%m-%d", errors="coerce"
-                )
-            )
-            / np.timedelta64(1, "D")
-        ).round()
-
-        assert_series_equal(snow_df["close_lag"], native_df["close_lag"])
+    assert_series_equal(snow_df["month_lag"], native_df["month_lag"])
 
 
 @sql_count_checker(query_count=1)
-def test_td_case4():
+def test_insert_datetime_difference():
     data = {
         "bl_start_ts": [Timestamp("2017-03-01T12")],
         "green_light_ts": [Timestamp("2017-01-07T12")],
@@ -131,7 +71,7 @@ def test_td_case4():
 
 
 @sql_count_checker(query_count=0)
-def test_td_case5_negative():
+def test_diff_timestamp_column_to_get_timedelta_negative():
     data = {
         "Country": ["A", "B", "C", "D", "E"],
         "Agreement Signing Date": [
@@ -144,7 +84,7 @@ def test_td_case5_negative():
     }
     snow_df = pd.DataFrame(data)
     native_df = native_pd.DataFrame(data)
-    # TODO SNOW-1635620: remove Exception raised when TimeDelta is implemented
+    # TODO SNOW-1641729: remove Exception raised when TimeDelta is implemented
     with pytest.raises(SnowparkSQLException):
         eval_snowpark_pandas_result(
             snow_df,
diff --git a/tests/notebooks/modin/MIMICHealthcareDemo.ipynb b/tests/notebooks/modin/MIMICHealthcareDemo.ipynb
index 40e82c78d6b..3f1849e52cd 100644
--- a/tests/notebooks/modin/MIMICHealthcareDemo.ipynb
+++ b/tests/notebooks/modin/MIMICHealthcareDemo.ipynb
@@ -392,10 +392,17 @@
    "metadata": {
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:snowflake.snowpark.modin.plugin.utils.warning_message:Snowpark pandas support for Timedelta is not currently available.\n"
+     ]
+    }
+   ],
    "source": [
-    "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
-    "# df[\"length_of_stay\"] = (df[\"outtime\"]-df[\"intime\"])/pd.Timedelta('1 hour')"
+    "df[\"length_of_stay\"] = (df[\"outtime\"]-df[\"intime\"])/pd.Timedelta('1 hour')"
    ]
   },
   {
@@ -405,8 +412,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
-    "# df[\"age\"] = df[\"intime\"].dt.year-df[\"dob\"].dt.year"
+    "df[\"age\"] = df[\"intime\"].dt.year-df[\"dob\"].dt.year"
    ]
   },
   {
@@ -426,8 +432,7 @@
    },
    "outputs": [],
    "source": [
-    "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
-    "# df = df[df[\"age\"]<100]"
+    "df = df[df[\"age\"]<100]"
    ]
   },
   {
@@ -447,10 +452,37 @@
    "metadata": {
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:snowflake.snowpark.modin.plugin.utils.warning_message:DataFrame.plot materializes data to the local machine for plotting.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='age', ylabel='length_of_stay'>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
-    "# df.plot(\"age\",\"length_of_stay\",kind=\"scatter\")"
+    "df.plot(\"age\",\"length_of_stay\",kind=\"scatter\")"
    ]
   },
   {
@@ -518,8 +550,8 @@
    },
    "outputs": [],
    "source": [
-    "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
-    "# df[\"pre_icu_length_of_stay\"]= (df[\"intime\"]-df[\"admittime\"])/pd.Timedelta('1 day')"
+    "df[\"admittime\"] = pd.to_datetime(df[\"admittime\"])\n",
+    "df[\"pre_icu_length_of_stay\"]= (df[\"intime\"]-df[\"admittime\"])/pd.Timedelta('1 day')"
    ]
   },
   {
@@ -541,7 +573,7 @@
    },
    "outputs": [],
    "source": [
-    "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
+    "# TODO(https://snowflakecomputing.atlassian.net/browse/SNOW-1640617): Implement Series.hist\n",
     "# df[\"pre_icu_length_of_stay\"].hist()"
    ]
   },
@@ -552,11 +584,18 @@
    "metadata": {
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Percentage of ICU admissions within 1 day:         81.10%\n"
+     ]
+    }
+   ],
    "source": [
-    "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
-    "# print(f\"Percentage of ICU admissions within 1 day: \\\n",
-    "#         {len(df[df['pre_icu_length_of_stay']<1])/len(df)*100:.2f}%\")"
+    "print(f\"Percentage of ICU admissions within 1 day: \\\n",
+    "        {len(df[df['pre_icu_length_of_stay']<1])/len(df)*100:.2f}%\")"
    ]
   },
   {
@@ -592,12 +631,12 @@
        "3                                       HUMERAL FRACTURE\n",
        "4                                    ALCOHOLIC HEPATITIS\n",
        "                             ...                        \n",
-       "131                                 PERICARDIAL EFFUSION\n",
-       "132                                ALTERED MENTAL STATUS\n",
-       "133    ACUTE RESPIRATORY DISTRESS SYNDROME;ACUTE RENA...\n",
-       "134                                          BRADYCARDIA\n",
-       "135                                          CHOLANGITIS\n",
-       "Name: diagnosis, Length: 136, dtype: object"
+       "122                                  SHORTNESS OF BREATH\n",
+       "123                                 PERICARDIAL EFFUSION\n",
+       "124    ACUTE RESPIRATORY DISTRESS SYNDROME;ACUTE RENA...\n",
+       "125                                          BRADYCARDIA\n",
+       "126                                          CHOLANGITIS\n",
+       "Name: diagnosis, Length: 127, dtype: object"
       ]
      },
      "execution_count": 16,
@@ -636,12 +675,12 @@
        "3                                       HUMERAL FRACTURE\n",
        "4                                    ALCOHOLIC HEPATITIS\n",
        "                             ...                        \n",
-       "131                                 PERICARDIAL EFFUSION\n",
-       "132                                ALTERED MENTAL STATUS\n",
-       "133    ACUTE RESPIRATORY DISTRESS SYNDROME ACUTE RENA...\n",
-       "134                                          BRADYCARDIA\n",
-       "135                                          CHOLANGITIS\n",
-       "Name: diagnosis, Length: 136, dtype: object"
+       "122                                  SHORTNESS OF BREATH\n",
+       "123                                 PERICARDIAL EFFUSION\n",
+       "124    ACUTE RESPIRATORY DISTRESS SYNDROME ACUTE RENA...\n",
+       "125                                          BRADYCARDIA\n",
+       "126                                          CHOLANGITIS\n",
+       "Name: diagnosis, Length: 127, dtype: object"
       ]
      },
      "execution_count": 17,
@@ -669,8 +708,8 @@
     {
      "data": {
       "text/plain": [
-       "[('SEPSIS', 10),\n",
-       " ('PNEUMONIA', 8),\n",
+       "[('SEPSIS', 9),\n",
+       " ('PNEUMONIA', 7),\n",
        " ('CONGESTIVE HEART FAILURE', 5),\n",
        " ('FEVER', 4),\n",
        " ('SHORTNESS OF BREATH', 4)]"
@@ -769,8 +808,8 @@
      "data": {
       "text/plain": [
        "hospital_expire_flag\n",
-       "0    90\n",
-       "1    46\n",
+       "0    85\n",
+       "1    42\n",
        "Name: count, dtype: int64"
       ]
      },
@@ -892,15 +931,15 @@
        "      <td>...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>131</th>\n",
-       "      <td>0</td>\n",
+       "      <th>122</th>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
+       "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>132</th>\n",
+       "      <th>123</th>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
@@ -908,7 +947,7 @@
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>133</th>\n",
+       "      <th>124</th>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
@@ -916,7 +955,7 @@
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>134</th>\n",
+       "      <th>125</th>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
@@ -924,7 +963,7 @@
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>135</th>\n",
+       "      <th>126</th>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
@@ -933,7 +972,7 @@
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "<p>136 rows × 5 columns</p>\n",
+       "<p>127 rows × 5 columns</p>\n",
        "</div>"
       ],
       "text/plain": [
@@ -944,13 +983,13 @@
        "3         0          0                         0      0                    0\n",
        "4         0          0                         0      0                    0\n",
        "..      ...        ...                       ...    ...                  ...\n",
-       "131       0          0                         0      0                    0\n",
-       "132       0          0                         0      0                    0\n",
-       "133       0          0                         0      0                    0\n",
-       "134       0          0                         0      0                    0\n",
-       "135       0          0                         0      0                    0\n",
+       "122       0          0                         0      0                    1\n",
+       "123       0          0                         0      0                    0\n",
+       "124       0          0                         0      0                    0\n",
+       "125       0          0                         0      0                    0\n",
+       "126       0          0                         0      0                    0\n",
        "\n",
-       "[136 rows x 5 columns]"
+       "[127 rows x 5 columns]"
       ]
      },
      "execution_count": 23,
@@ -979,12 +1018,12 @@
        "3      0\n",
        "4      1\n",
        "      ..\n",
-       "131    0\n",
-       "132    1\n",
-       "133    0\n",
-       "134    0\n",
-       "135    0\n",
-       "Name: hospital_expire_flag, Length: 136, dtype: int8"
+       "122    0\n",
+       "123    0\n",
+       "124    0\n",
+       "125    0\n",
+       "126    0\n",
+       "Name: hospital_expire_flag, Length: 127, dtype: int8"
       ]
      },
      "execution_count": 24,
@@ -1460,7 +1499,7 @@
        "  /* fitted */\n",
        "  background-color: var(--sklearn-color-fitted-level-3);\n",
        "}\n",
-       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GaussianNB()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;GaussianNB<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.5/modules/generated/sklearn.naive_bayes.GaussianNB.html\">?<span>Documentation for GaussianNB</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>GaussianNB()</pre></div> </div></div></div></div>"
+       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GaussianNB()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;GaussianNB<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.4/modules/generated/sklearn.naive_bayes.GaussianNB.html\">?<span>Documentation for GaussianNB</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>GaussianNB()</pre></div> </div></div></div></div>"
       ],
       "text/plain": [
        "GaussianNB()"
@@ -1508,7 +1547,7 @@
     {
      "data": {
       "text/plain": [
-       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x1327de680>"
+       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x17da7e430>"
       ]
      },
      "execution_count": 29,
@@ -1517,7 +1556,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1546,7 +1585,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Accuracy of the binary classifier = 0.64\n"
+      "Accuracy of the binary classifier = 0.62\n"
      ]
     }
    ],
@@ -1586,6 +1625,18 @@
     "\n",
     "Snowpark pandas lets you seamlessly move between feature engineering, visualization, and machine learning — all within the Python data ecosystem, while operating directly on the data in your data warehouse. \n"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e78a2bc",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698086ae",
+   "metadata": {},
+   "source": []
   }
  ],
  "metadata": {

From 380ed37d7b87eb7b6dcd8072544ecae76ee2fb01 Mon Sep 17 00:00:00 2001
From: Jonathan Shi <149419494+sfc-gh-joshi@users.noreply.github.com>
Date: Tue, 27 Aug 2024 17:59:41 -0700
Subject: [PATCH 02/11] Fix error message in python 3.8 to_snowpark_pandas
 daily test (#2173)

<!---
Please answer these questions before creating your pull request. Thanks!
--->

1. Which Jira issue is this PR addressing? Make sure that there is an
accompanying issue to your PR.

   <!---
   In this section, please add a Snowflake Jira issue number.

Note that if a corresponding GitHub issue exists, you should still
include
   the Snowflake Jira issue number. For example, for GitHub issue
https://github.com/snowflakedb/snowpark-python/issues/1400, you should
   add "SNOW-1335071" here.
    --->

   Fixes SNOW-NNNNNNN

2. Fill out the following pre-review checklist:

- [ ] I am adding a new automated test(s) to verify correctness of my
new code
- [ ] If this test skips Local Testing mode, I'm requesting review from
@snowflakedb/local-testing
   - [ ] I am adding new logging messages
   - [ ] I am adding a new telemetry message
   - [ ] I am adding new credentials
   - [ ] I am adding a new dependency
- [ ] If this is a new feature/behavior, I'm adding the Local Testing
parity changes.

3. Please describe how your code solves the related issue.

Updates the error message to check if we're on python 3.8 before
checking the pandas version.
---
 tests/integ/test_df_to_snowpark_pandas.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/integ/test_df_to_snowpark_pandas.py b/tests/integ/test_df_to_snowpark_pandas.py
index 05d51b1b38a..ede9b10e85c 100644
--- a/tests/integ/test_df_to_snowpark_pandas.py
+++ b/tests/integ/test_df_to_snowpark_pandas.py
@@ -5,6 +5,8 @@
 
 # Tests behavior of to_snowpark_pandas() without explicitly initializing Snowpark pandas.
 
+import sys
+
 import pytest
 
 from snowflake.snowpark._internal.utils import TempObjectType
@@ -47,9 +49,14 @@ def test_to_snowpark_pandas_no_modin(session, tmp_table_basic):
         # TODO: SNOW-1552497: after upgrading to modin 0.30.1, Snowpark pandas will support
         # all pandas 2.2.x, and this function call will raise a ModuleNotFoundError since
         # modin is not installed.
+        match = (
+            "Snowpark pandas does not support Python 3.8. Please update to Python 3.9 or later"
+            if sys.version_info.major == 3 and sys.version_info.minor == 8
+            else "does not match the supported pandas version in Snowpark pandas"
+        )
         with pytest.raises(
             RuntimeError,
-            match="does not match the supported pandas version in Snowpark pandas",
+            match=match,
         ):
             snowpark_df.to_snowpark_pandas()
     else:

From a7c6820124518bedc4ba82538b11fa404888e53b Mon Sep 17 00:00:00 2001
From: Yun Zou <yun.zou@snowflake.com>
Date: Wed, 28 Aug 2024 09:04:12 -0700
Subject: [PATCH 03/11] Fix query_generator for new compilation stage after
 optimization applied (#2172)

<!---
Please answer these questions before creating your pull request. Thanks!
--->

1. Which Jira issue is this PR addressing? Make sure that there is an
accompanying issue to your PR.
SNOW-1641324

2. Fill out the following pre-review checklist:

- [ ] I am adding a new automated test(s) to verify correctness of my
new code
- [ ] If this test skips Local Testing mode, I'm requesting review from
@snowflakedb/local-testing
   - [ ] I am adding new logging messages
   - [ ] I am adding a new telemetry message
   - [ ] I am adding new credentials
   - [ ] I am adding a new dependency
- [ ] If this is a new feature/behavior, I'm adding the Local Testing
parity changes.

3. Please describe how your code solves the related issue.
The test Enable CTE Optimization merge gate is currently failing because
1) the _projection_in_str for select statement is reset properly after
updating, which causes the expr_alias is updated properly during query
generation
2) query parameter is not propogated properly during query generation
which causes variable binding query fail
---
 .../_internal/analyzer/snowflake_plan.py      |  3 +
 .../_internal/compiler/query_generator.py     |  4 +-
 .../snowpark/_internal/compiler/utils.py      | 25 +++++-
 .../integ/scala/test_snowflake_plan_suite.py  |  5 +-
 tests/integ/test_cte.py                       | 85 ++++++++++++++++---
 5 files changed, 103 insertions(+), 19 deletions(-)

diff --git a/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py b/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py
index 83c0eebb9c7..aad369a8b83 100644
--- a/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py
+++ b/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py
@@ -1608,6 +1608,9 @@ def with_query_block(
 
         new_query = project_statement([], name)
 
+        # note we do not propagate the query parameter of the child here,
+        # the query parameter will be propagate along with the definition during
+        # query generation stage.
         queries = child.queries[:-1] + [Query(sql=new_query)]
         # propagate the cte table
         referenced_ctes = {name}.union(child.referenced_ctes)
diff --git a/src/snowflake/snowpark/_internal/compiler/query_generator.py b/src/snowflake/snowpark/_internal/compiler/query_generator.py
index fdf8af9d4dd..d9220424097 100644
--- a/src/snowflake/snowpark/_internal/compiler/query_generator.py
+++ b/src/snowflake/snowpark/_internal/compiler/query_generator.py
@@ -64,7 +64,7 @@ def __init__(
         # NOTE: the dict used here is an ordered dict, all with query block definition is recorded in the
         # order of when the with query block is visited. The order is important to make sure the dependency
         # between the CTE definition is satisfied.
-        self.resolved_with_query_block: Dict[str, str] = {}
+        self.resolved_with_query_block: Dict[str, Query] = {}
 
     def generate_queries(
         self, logical_plans: List[LogicalPlan]
@@ -209,7 +209,7 @@ def do_resolve_with_resolved_children(
             if logical_plan.name not in self.resolved_with_query_block:
                 self.resolved_with_query_block[
                     logical_plan.name
-                ] = resolved_child.queries[-1].sql
+                ] = resolved_child.queries[-1]
 
             resolved_plan = self.plan_builder.with_query_block(
                 logical_plan.name,
diff --git a/src/snowflake/snowpark/_internal/compiler/utils.py b/src/snowflake/snowpark/_internal/compiler/utils.py
index 579c3b8e5d6..273ebe0440a 100644
--- a/src/snowflake/snowpark/_internal/compiler/utils.py
+++ b/src/snowflake/snowpark/_internal/compiler/utils.py
@@ -227,6 +227,9 @@ def update_resolvable_node(
         # re-calculation of the sql query and snowflake plan
         node._sql_query = None
         node._snowflake_plan = None
+        # make sure we also clean up the cached _projection_in_str, so that
+        # the projection expression can be re-analyzed during code generation
+        node._projection_in_str = None
         node.analyzer = query_generator
 
         # update the pre_actions and post_actions for the select statement
@@ -267,12 +270,26 @@ def update_resolvable_node(
         update_resolvable_node(node.snowflake_plan, query_generator)
         node.analyzer = query_generator
 
+        node.pre_actions = node._snowflake_plan.queries[:-1]
+        node.post_actions = node._snowflake_plan.post_actions
+        node._api_calls = node._snowflake_plan.api_calls
+
+        if isinstance(node, SelectSnowflakePlan):
+            node.expr_to_alias.update(node._snowflake_plan.expr_to_alias)
+            node.df_aliased_col_name_to_real_col_name.update(
+                node._snowflake_plan.df_aliased_col_name_to_real_col_name
+            )
+            node._query_params = []
+            for query in node._snowflake_plan.queries:
+                if query.params:
+                    node._query_params.extend(query.params)
+
     elif isinstance(node, Selectable):
         node.analyzer = query_generator
 
 
 def get_snowflake_plan_queries(
-    plan: SnowflakePlan, resolved_with_query_blocks: Dict[str, str]
+    plan: SnowflakePlan, resolved_with_query_blocks: Dict[str, Query]
 ) -> Dict[PlanQueryType, List[Query]]:
 
     from snowflake.snowpark._internal.analyzer.analyzer_utils import cte_statement
@@ -286,12 +303,16 @@ def get_snowflake_plan_queries(
         post_action_queries = copy.deepcopy(plan.post_actions)
         table_names = []
         definition_queries = []
+        final_query_params = []
         for name, definition_query in resolved_with_query_blocks.items():
             if name in plan.referenced_ctes:
                 table_names.append(name)
-                definition_queries.append(definition_query)
+                definition_queries.append(definition_query.sql)
+                final_query_params.extend(definition_query.params)
         with_query = cte_statement(definition_queries, table_names)
         plan_queries[-1].sql = with_query + plan_queries[-1].sql
+        final_query_params.extend(plan_queries[-1].params)
+        plan_queries[-1].params = final_query_params
 
     return {
         PlanQueryType.QUERIES: plan_queries,
diff --git a/tests/integ/scala/test_snowflake_plan_suite.py b/tests/integ/scala/test_snowflake_plan_suite.py
index 4b2f538ea40..3d9f2e22b24 100644
--- a/tests/integ/scala/test_snowflake_plan_suite.py
+++ b/tests/integ/scala/test_snowflake_plan_suite.py
@@ -175,9 +175,8 @@ def check_plan_queries(
             # the cte optimization is not kicking in when sql simplifier disabled, because
             # the cte_optimization_enabled is set to False when constructing the plan for df2,
             # and place_holder is not propogated.
-            # TODO (SNOW-1541096): revisit this test once the cte optimization is switched to the
-            #   new compilation infra.
-            cte_applied=session.sql_simplifier_enabled,
+            cte_applied=session.sql_simplifier_enabled
+            or session._query_compilation_stage_enabled,
             exec_queries=df2._plan.execution_queries,
         )
 
diff --git a/tests/integ/test_cte.py b/tests/integ/test_cte.py
index 6aa115afcc2..87a91deab0e 100644
--- a/tests/integ/test_cte.py
+++ b/tests/integ/test_cte.py
@@ -10,6 +10,7 @@
 from snowflake.connector.options import installed_pandas
 from snowflake.snowpark import Window
 from snowflake.snowpark._internal.analyzer import analyzer
+from snowflake.snowpark._internal.analyzer.snowflake_plan import PlanQueryType
 from snowflake.snowpark._internal.utils import (
     TEMP_OBJECT_NAME_PREFIX,
     TempObjectType,
@@ -35,6 +36,16 @@
     )
 ]
 
+binary_operations = [
+    lambda x, y: x.union_all(y),
+    lambda x, y: x.select("a").union(y.select("a")),
+    lambda x, y: x.except_(y),
+    lambda x, y: x.select("a").intersect(y.select("a")),
+    lambda x, y: x.join(y.select("a", "b"), rsuffix="_y"),
+    lambda x, y: x.select("a").join(y, how="outer", rsuffix="_y"),
+    lambda x, y: x.join(y.select("a"), how="left", rsuffix="_y"),
+]
+
 
 WITH = "WITH"
 
@@ -104,18 +115,7 @@ def test_unary(session, action):
     check_result(session, df_action.union_all(df_action), expect_cte_optimized=True)
 
 
-@pytest.mark.parametrize(
-    "action",
-    [
-        lambda x, y: x.union_all(y),
-        lambda x, y: x.select("a").union(y.select("a")),
-        lambda x, y: x.except_(y),
-        lambda x, y: x.select("a").intersect(y.select("a")),
-        lambda x, y: x.join(y.select("a", "b"), rsuffix="_y"),
-        lambda x, y: x.select("a").join(y, how="outer", rsuffix="_y"),
-        lambda x, y: x.join(y.select("a"), how="left", rsuffix="_y"),
-    ],
-)
+@pytest.mark.parametrize("action", binary_operations)
 def test_binary(session, action):
     df = session.create_dataframe([[1, 2], [3, 4]], schema=["a", "b"])
     check_result(session, action(df, df), expect_cte_optimized=True)
@@ -138,6 +138,67 @@ def test_binary(session, action):
     assert len(plan_queries["post_actions"]) == 1
 
 
+@pytest.mark.parametrize("action", binary_operations)
+def test_variable_binding_binary(session, action):
+    df1 = session.sql(
+        "select $1 as a, $2 as b from values (?, ?), (?, ?)", params=[1, "a", 2, "b"]
+    )
+    df2 = session.sql(
+        "select $1 as a, $2 as b from values (?, ?), (?, ?)", params=[1, "c", 3, "d"]
+    )
+    df3 = session.sql(
+        "select $1 as a, $2 as b from values (?, ?), (?, ?)", params=[1, "a", 2, "b"]
+    )
+
+    check_result(session, action(df1, df3), expect_cte_optimized=True)
+    check_result(session, action(df1, df2), expect_cte_optimized=False)
+
+
+def test_variable_binding_multiple(session):
+    if not session._query_compilation_stage_enabled:
+        pytest.skip(
+            "CTE query generation without the new query generation doesn't work correctly"
+        )
+
+    df1 = session.sql(
+        "select $1 as a, $2 as b from values (?, ?), (?, ?)", params=[1, "a", 2, "b"]
+    )
+    df2 = session.sql(
+        "select $1 as a, $2 as b from values (?, ?), (?, ?)", params=[1, "c", 3, "d"]
+    )
+
+    df_res = df1.union(df1).union(df2)
+    check_result(session, df_res, expect_cte_optimized=True)
+    plan_queries = df_res._plan.execution_queries
+
+    assert plan_queries[PlanQueryType.QUERIES][-1].params == [
+        1,
+        "a",
+        2,
+        "b",
+        1,
+        "c",
+        3,
+        "d",
+    ]
+
+    df_res = df2.union(df1).union(df2).union(df1)
+    check_result(session, df_res, expect_cte_optimized=True)
+    plan_queries = df_res._plan.execution_queries
+
+    assert plan_queries[PlanQueryType.QUERIES][-1].params == [
+        1,
+        "a",
+        2,
+        "b",
+        1,
+        "c",
+        3,
+        "d",
+    ]
+    assert plan_queries[PlanQueryType.QUERIES][-1].sql.count(WITH) == 1
+
+
 @pytest.mark.parametrize(
     "action",
     [

From 997373e02b7e114c2637f087aeda61f91179aac6 Mon Sep 17 00:00:00 2001
From: sfc-gh-lninobrijaldo <luis.nino@snowflake.com>
Date: Wed, 28 Aug 2024 11:42:50 -0500
Subject: [PATCH 04/11] Add method array_remove. (#2105)

---
 CHANGELOG.md                             | 12 ++++--
 docs/source/snowpark/functions.rst       |  1 +
 src/snowflake/snowpark/functions.py      | 50 ++++++++++++++++++++++++
 tests/integ/scala/test_function_suite.py | 29 ++++++++++++++
 4 files changed, 89 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99ac288a7a9..8f5a3daf78e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,9 +4,14 @@
 
 ### Snowpark Python API Updates
 
+### New Features
+
+- Added following new functions in `snowflake.snowpark.functions`:
+  - `array_remove`
+  - `ln`
+
 #### Improvements
 
-- Added support for function `functions.ln`
 - Added support for specifying the following to `DataFrameWriter.save_as_table`:
   - `enable_schema_evolution`
   - `data_retention_time`
@@ -47,9 +52,10 @@
 
 - Added limited support for the `Timedelta` type, including the following features. Snowpark pandas will raise `NotImplementedError` for unsupported `Timedelta` use cases.
   - supporting tracking the Timedelta type through `copy`, `cache_result`, `shift`, `sort_index`.
-  - converting non-timedelta to timedelta via `astype`. 
+  - converting non-timedelta to timedelta via `astype`.
+  - `NotImplementedError` will be raised for the rest of methods that do not support `Timedelta`.
   - support for subtracting two timestamps to get a Timedelta.
-  - support indexing with Timedelta data columns. 
+  - support indexing with Timedelta data columns.
   - support for adding or subtracting timestamps and `Timedelta`.
   - support for binary arithmetic between two `Timedelta` values.
 - Added support for index's arithmetic and comparison operators.
diff --git a/docs/source/snowpark/functions.rst b/docs/source/snowpark/functions.rst
index 100cb5470fc..9a381e5046a 100644
--- a/docs/source/snowpark/functions.rst
+++ b/docs/source/snowpark/functions.rst
@@ -43,6 +43,7 @@ Functions
     array_min
     array_position
     array_prepend
+    array_remove
     array_size
     array_slice
     array_sort
diff --git a/src/snowflake/snowpark/functions.py b/src/snowflake/snowpark/functions.py
index 8f8b156132c..58c2ab8518c 100644
--- a/src/snowflake/snowpark/functions.py
+++ b/src/snowflake/snowpark/functions.py
@@ -5333,6 +5333,56 @@ def array_append(array: ColumnOrName, element: ColumnOrName) -> Column:
     return builtin("array_append")(a, e)
 
 
+def array_remove(array: ColumnOrName, element: ColumnOrLiteral) -> Column:
+    """Given a source ARRAY, returns an ARRAY with elements of the specified value removed.
+
+    Args:
+        array: name of column containing array.
+        element: element to be removed from the array. If the element is a VARCHAR, it needs
+            to be casted into VARIANT data type.
+
+    Examples::
+        >>> from snowflake.snowpark.types import VariantType
+        >>> df = session.create_dataframe([([1, '2', 3.1, 1, 1],)], ['data'])
+        >>> df.select(array_remove(df.data, 1).alias("objects")).show()
+        -------------
+        |"OBJECTS"  |
+        -------------
+        |[          |
+        |  "2",     |
+        |  3.1      |
+        |]          |
+        -------------
+        <BLANKLINE>
+
+        >>> df.select(array_remove(df.data, lit('2').cast(VariantType())).alias("objects")).show()
+        -------------
+        |"OBJECTS"  |
+        -------------
+        |[          |
+        |  1,       |
+        |  3.1,     |
+        |  1,       |
+        |  1        |
+        |]          |
+        -------------
+        <BLANKLINE>
+
+        >>> df.select(array_remove(df.data, None).alias("objects")).show()
+        -------------
+        |"OBJECTS"  |
+        -------------
+        |NULL       |
+        -------------
+        <BLANKLINE>
+
+    See Also:
+        - `ARRAY <https://docs.snowflake.com/en/sql-reference/data-types-semistructured#label-data-type-array>`_ for more details on semi-structured arrays.
+    """
+    a = _to_col_if_str(array, "array_remove")
+    return builtin("array_remove")(a, element)
+
+
 def array_cat(array1: ColumnOrName, array2: ColumnOrName) -> Column:
     """Returns the concatenation of two ARRAYs.
 
diff --git a/tests/integ/scala/test_function_suite.py b/tests/integ/scala/test_function_suite.py
index a322c7d34b8..98b2bdbfeef 100644
--- a/tests/integ/scala/test_function_suite.py
+++ b/tests/integ/scala/test_function_suite.py
@@ -36,6 +36,7 @@
     array_intersection,
     array_position,
     array_prepend,
+    array_remove,
     array_size,
     array_slice,
     array_to_string,
@@ -2823,6 +2824,34 @@ def test_array_append(session):
     )
 
 
+@pytest.mark.skipif(
+    "config.getoption('local_testing_mode', default=False)",
+    reason="array_remove is not yet supported in local testing mode.",
+)
+def test_array_remove(session):
+    Utils.check_answer(
+        [
+            Row("[\n  2,\n  3\n]"),
+            Row("[\n  6,\n  7\n]"),
+        ],
+        TestData.array1(session).select(
+            array_remove(array_remove(col("arr1"), lit(1)), lit(8))
+        ),
+        sort=False,
+    )
+
+    Utils.check_answer(
+        [
+            Row("[\n  2,\n  3\n]"),
+            Row("[\n  6,\n  7\n]"),
+        ],
+        TestData.array1(session).select(
+            array_remove(array_remove(col("arr1"), 1), lit(8))
+        ),
+        sort=False,
+    )
+
+
 @pytest.mark.skipif(
     "config.getoption('local_testing_mode', default=False)",
     reason="array_cat is not yet supported in local testing mode.",

From 9876b4cec1a579150fe4cc4be9a251928875df74 Mon Sep 17 00:00:00 2001
From: Naresh Kumar <113932371+sfc-gh-nkumar@users.noreply.github.com>
Date: Wed, 28 Aug 2024 10:41:19 -0700
Subject: [PATCH 05/11] SNOW-1559348: Add Snowpark pandas TimedeltaIndex class
 (#2160)

Fixes SNOW-1559348

- Add TimedeltaIndex class to provide lazy implementation.
- Add documentation pages.
- Only supports construction and raises not implemented error for
timedelta index specific methods and attributes.
- Also include type propagation fixes to query compiler methods
`set_index_from_series`, `set_index_from_columns` and `drop`.
---
 CHANGELOG.md                                  |   1 +
 docs/source/modin/indexing.rst                |  40 ++
 docs/source/modin/supported/index.rst         |   1 +
 .../supported/timedelta_index_supported.rst   |  48 +++
 .../snowpark/modin/pandas/__init__.py         |   2 +-
 .../modin/plugin/_internal/type_utils.py      |   2 +
 .../compiler/snowflake_query_compiler.py      |  38 +-
 .../snowpark/modin/plugin/extensions/index.py |  26 +-
 .../modin/plugin/extensions/pd_overrides.py   |   4 +
 .../plugin/extensions/timedelta_index.py      | 388 ++++++++++++++++++
 .../modin/plugin/utils/error_message.py       |   4 +
 tests/integ/modin/index/conftest.py           |   6 +
 .../index/test_timedelta_index_methods.py     |  65 +++
 tests/unit/modin/test_class.py                |   1 -
 14 files changed, 609 insertions(+), 17 deletions(-)
 create mode 100644 docs/source/modin/supported/timedelta_index_supported.rst
 create mode 100644 src/snowflake/snowpark/modin/plugin/extensions/timedelta_index.py
 create mode 100644 tests/integ/modin/index/test_timedelta_index_methods.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8f5a3daf78e..1cf5845439c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -58,6 +58,7 @@
   - support indexing with Timedelta data columns.
   - support for adding or subtracting timestamps and `Timedelta`.
   - support for binary arithmetic between two `Timedelta` values.
+  - support for lazy `TimedeltaIndex`.
 - Added support for index's arithmetic and comparison operators.
 - Added support for `Series.dt.round`.
 - Added documentation pages for `DatetimeIndex`.
diff --git a/docs/source/modin/indexing.rst b/docs/source/modin/indexing.rst
index fa4f0538890..80ceba61bec 100644
--- a/docs/source/modin/indexing.rst
+++ b/docs/source/modin/indexing.rst
@@ -220,3 +220,43 @@ DatetimeIndex
 
     DatetimeIndex.mean
     DatetimeIndex.std
+
+.. _api.timedeltaindex:
+
+TimedeltaIndex
+--------------
+
+.. autosummary::
+   :toctree: pandas_api/
+
+   TimedeltaIndex
+
+.. rubric:: `TimedeltaIndex` Components
+
+.. autosummary::
+    :toctree: pandas_api/
+
+    TimedeltaIndex.days
+    TimedeltaIndex.seconds
+    TimedeltaIndex.microseconds
+    TimedeltaIndex.nanoseconds
+    TimedeltaIndex.components
+    TimedeltaIndex.inferred_freq
+
+.. rubric:: `TimedeltaIndex` Conversion
+
+.. autosummary::
+    :toctree: pandas_api/
+
+    TimedeltaIndex.as_unit
+    TimedeltaIndex.to_pytimedelta
+    TimedeltaIndex.round
+    TimedeltaIndex.floor
+    TimedeltaIndex.ceil
+
+.. rubric:: `TimedeltaIndex` Methods
+
+.. autosummary::
+    :toctree: pandas_api/
+
+    TimedeltaIndex.mean
diff --git a/docs/source/modin/supported/index.rst b/docs/source/modin/supported/index.rst
index 97202d69290..2d7999c4954 100644
--- a/docs/source/modin/supported/index.rst
+++ b/docs/source/modin/supported/index.rst
@@ -16,6 +16,7 @@ To view the docs for the most recent release, check that you’re viewing the st
    dataframe_supported
    index_supported
    datetime_index_supported
+   timedelta_index_supported
    window_supported
    groupby_supported
    resampling_supported
diff --git a/docs/source/modin/supported/timedelta_index_supported.rst b/docs/source/modin/supported/timedelta_index_supported.rst
new file mode 100644
index 00000000000..73abe530fd7
--- /dev/null
+++ b/docs/source/modin/supported/timedelta_index_supported.rst
@@ -0,0 +1,48 @@
+``pd.TimedeltaIndex`` supported APIs
+====================================
+
+The following table is structured as follows: The first column contains the method name.
+The second column is a flag for whether or not there is an implementation in Snowpark for
+the method in the left column.
+
+.. note::
+    ``Y`` stands for yes, i.e., supports distributed implementation, ``N`` stands for no and API simply errors out,
+    ``P`` stands for partial (meaning some parameters may not be supported yet), and ``D`` stands for defaults to single
+    node pandas execution via UDF/Sproc.
+
+Attributes
+
++-----------------------------+---------------------------------+----------------------------------------------------+
+| TimedeltaIndex attribute    | Snowpark implemented? (Y/N/P/D) | Notes for current implementation                   |
++-----------------------------+---------------------------------+----------------------------------------------------+
+| ``days``                    | N                               |                                                    |
++-----------------------------+---------------------------------+----------------------------------------------------+
+| ``seconds``                 | N                               |                                                    |
++-----------------------------+---------------------------------+----------------------------------------------------+
+| ``microseconds``            | N                               |                                                    |
++-----------------------------+---------------------------------+----------------------------------------------------+
+| ``nanoseconds``             | N                               |                                                    |
++-----------------------------+---------------------------------+----------------------------------------------------+
+| ``components``              | N                               |                                                    |
++-----------------------------+---------------------------------+----------------------------------------------------+
+| ``inferred_freq``           | N                               |                                                    |
++-----------------------------+---------------------------------+----------------------------------------------------+
+
+
+Methods
+
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
+| DataFrame method            | Snowpark implemented? (Y/N/P/D) | Missing parameters               | Notes for current implementation          |
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
+| ``as_unit``                 | N                               |                                  |                                           |
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
+| ``to_pytimedelta``          | N                               |                                  |                                           |
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
+| ``round``                   | N                               |                                  |                                           |
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
+| ``floor``                   | N                               |                                  |                                           |
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
+| ``ceil``                    | N                               |                                  |                                           |
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
+| ``mean``                    | N                               |                                  |                                           |
++-----------------------------+---------------------------------+----------------------------------+-------------------------------------------+
diff --git a/src/snowflake/snowpark/modin/pandas/__init__.py b/src/snowflake/snowpark/modin/pandas/__init__.py
index 975289684cf..c4eb07d9589 100644
--- a/src/snowflake/snowpark/modin/pandas/__init__.py
+++ b/src/snowflake/snowpark/modin/pandas/__init__.py
@@ -63,7 +63,6 @@
         SparseDtype,
         StringDtype,
         Timedelta,
-        TimedeltaIndex,
         Timestamp,
         UInt8Dtype,
         UInt16Dtype,
@@ -156,6 +155,7 @@
 from snowflake.snowpark.modin.plugin.extensions.pd_overrides import (  # isort: skip  # noqa: E402,F401
     Index,
     DatetimeIndex,
+    TimedeltaIndex,
 )
 import snowflake.snowpark.modin.plugin.extensions.base_overrides  # isort: skip  # noqa: E402,F401
 import snowflake.snowpark.modin.plugin.extensions.dataframe_extensions  # isort: skip  # noqa: E402,F401
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py b/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py
index 1fd252bf7e0..ed0c81bc4af 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py
@@ -267,6 +267,8 @@ def to_pandas(cls, s: DataType) -> Union[np.dtype, ExtensionDtype]:
             return np.dtype("int64") if s.scale == 0 else np.dtype("float64")
         if isinstance(s, TimestampType):
             return np.dtype("datetime64[ns]")
+        if isinstance(s, TimedeltaType):
+            return np.dtype("timedelta64[ns]")
         # We also need to treat parameterized types correctly
         if isinstance(s, (StringType, ArrayType, MapType, GeographyType)):
             return np.dtype(np.object_)
diff --git a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
index 380ed7db05d..b24cb083723 100644
--- a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
+++ b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
@@ -1730,7 +1730,6 @@ def set_index_from_series(
         Returns:
             The new SnowflakeQueryCompiler after the set_index operation
         """
-        self._raise_not_implemented_error_for_timedelta()
 
         assert (
             len(key._modin_frame.data_column_pandas_labels) == 1
@@ -1761,6 +1760,7 @@ def set_index_from_series(
         new_index_ids = result_column_mapper.map_right_quoted_identifiers(
             other_frame.data_column_snowflake_quoted_identifiers
         )
+        new_index_snowpark_types = other_frame.cached_data_column_snowpark_pandas_types
         if append:
             new_index_labels = (
                 new_internal_frame.index_column_pandas_labels + new_index_labels
@@ -1769,6 +1769,10 @@ def set_index_from_series(
                 new_internal_frame.index_column_snowflake_quoted_identifiers
                 + new_index_ids
             )
+            new_index_snowpark_types = (
+                self_frame.cached_index_column_snowpark_pandas_types
+                + new_index_snowpark_types
+            )
         new_internal_frame = InternalFrame.create(
             ordered_dataframe=new_internal_frame.ordered_dataframe,
             data_column_pandas_labels=self_frame.data_column_pandas_labels,
@@ -1778,8 +1782,8 @@ def set_index_from_series(
             ),
             index_column_pandas_labels=new_index_labels,
             index_column_snowflake_quoted_identifiers=new_index_ids,
-            data_column_types=None,
-            index_column_types=None,
+            data_column_types=self_frame.cached_data_column_snowpark_pandas_types,
+            index_column_types=new_index_snowpark_types,
         )
         return SnowflakeQueryCompiler(new_internal_frame)
 
@@ -5882,7 +5886,6 @@ def set_index_from_columns(
         Returns:
             A new QueryCompiler instance with updated index.
         """
-        self._raise_not_implemented_error_for_timedelta()
 
         index_column_pandas_labels = keys
         index_column_snowflake_quoted_identifiers = []
@@ -5910,6 +5913,16 @@ def set_index_from_columns(
                 self._modin_frame.data_column_snowflake_quoted_identifiers
             )
 
+        id_to_type = (
+            self._modin_frame.snowflake_quoted_identifier_to_snowpark_pandas_type
+        )
+        index_column_snowpark_pandas_types = [
+            id_to_type.get(id) for id in index_column_snowflake_quoted_identifiers
+        ]
+        data_column_snowpark_pandas_types = [
+            id_to_type.get(id) for id in data_column_snowflake_quoted_identifiers
+        ]
+
         # Generate aliases for new index columns if
         # 1. 'keys' are also kept as data columns, or
         # 2. 'keys' have duplicates.
@@ -5944,6 +5957,10 @@ def set_index_from_columns(
                 self._modin_frame.index_column_snowflake_quoted_identifiers
                 + index_column_snowflake_quoted_identifiers
             )
+            index_column_snowpark_pandas_types = (
+                self._modin_frame.cached_index_column_snowpark_pandas_types
+                + index_column_snowpark_pandas_types
+            )
 
         frame = InternalFrame.create(
             ordered_dataframe=ordered_dataframe,
@@ -5952,8 +5969,8 @@ def set_index_from_columns(
             data_column_pandas_index_names=self._modin_frame.data_column_pandas_index_names,
             data_column_pandas_labels=data_column_pandas_labels,
             data_column_snowflake_quoted_identifiers=data_column_snowflake_quoted_identifiers,
-            data_column_types=None,
-            index_column_types=None,
+            data_column_types=data_column_snowpark_pandas_types,
+            index_column_types=index_column_snowpark_pandas_types,
         )
         return SnowflakeQueryCompiler(frame)
 
@@ -10255,13 +10272,16 @@ def drop(
 
             data_column_labels = []
             data_column_identifiers = []
-            for label, identifiers in zip(
+            data_column_snowpark_pandas_types = []
+            for label, identifiers, type in zip(
                 frame.data_column_pandas_labels,
                 frame.data_column_snowflake_quoted_identifiers,
+                frame.cached_data_column_snowpark_pandas_types,
             ):
                 if label not in data_column_labels_to_drop:
                     data_column_labels.append(label)
                     data_column_identifiers.append(identifiers)
+                    data_column_snowpark_pandas_types.append(type)
 
             frame = InternalFrame.create(
                 ordered_dataframe=frame.ordered_dataframe,
@@ -10270,8 +10290,8 @@ def drop(
                 data_column_pandas_labels=data_column_labels,
                 data_column_snowflake_quoted_identifiers=data_column_identifiers,
                 data_column_pandas_index_names=frame.data_column_pandas_index_names,
-                data_column_types=None,
-                index_column_types=None,
+                data_column_types=data_column_snowpark_pandas_types,
+                index_column_types=frame.cached_index_column_snowpark_pandas_types,
             )
             frame = frame.select_active_columns()
 
diff --git a/src/snowflake/snowpark/modin/plugin/extensions/index.py b/src/snowflake/snowpark/modin/plugin/extensions/index.py
index 21692a228ec..bbd415536af 100644
--- a/src/snowflake/snowpark/modin/plugin/extensions/index.py
+++ b/src/snowflake/snowpark/modin/plugin/extensions/index.py
@@ -42,6 +42,7 @@
     is_integer_dtype,
     is_numeric_dtype,
     is_object_dtype,
+    is_timedelta64_dtype,
     pandas_dtype,
 )
 from pandas.core.dtypes.inference import is_hashable
@@ -112,21 +113,30 @@ def __new__(
         from snowflake.snowpark.modin.plugin.extensions.datetime_index import (
             DatetimeIndex,
         )
+        from snowflake.snowpark.modin.plugin.extensions.timedelta_index import (
+            TimedeltaIndex,
+        )
 
         if query_compiler:
             dtype = query_compiler.index_dtypes[0]
-            if dtype == np.dtype("datetime64[ns]"):
+            if is_datetime64_any_dtype(dtype):
                 return DatetimeIndex(query_compiler=query_compiler)
+            if is_timedelta64_dtype(dtype):
+                return TimedeltaIndex(query_compiler=query_compiler)
         elif isinstance(data, BasePandasDataset):
             if data.ndim != 1:
                 raise ValueError("Index data must be 1 - dimensional")
             dtype = data.dtype
-            if dtype == np.dtype("datetime64[ns]"):
-                return DatetimeIndex(data, dtype, copy, name, tupleize_cols)
+            if is_datetime64_any_dtype(dtype):
+                return DatetimeIndex(data, dtype=dtype, copy=copy, name=name)
+            if is_timedelta64_dtype(dtype):
+                return TimedeltaIndex(data, dtype=dtype, copy=copy, name=name)
         else:
             index = native_pd.Index(data, dtype, copy, name, tupleize_cols)
             if isinstance(index, native_pd.DatetimeIndex):
                 return DatetimeIndex(data)
+            if isinstance(index, native_pd.TimedeltaIndex):
+                return TimedeltaIndex(data)
         return object.__new__(cls)
 
     def __init__(
@@ -252,9 +262,13 @@ def __getattr__(self, key: str) -> Any:
     def _binary_ops(self, method: str, other: Any) -> Index:
         if isinstance(other, Index):
             other = other.to_series().reset_index(drop=True)
-        return self.__constructor__(
-            self.to_series().reset_index(drop=True).__getattr__(method)(other)
-        )
+        series = self.to_series().reset_index(drop=True).__getattr__(method)(other)
+        qc = series._query_compiler
+        qc = qc.set_index_from_columns(qc.columns, include_index=False)
+        # Use base constructor to ensure that the correct type is returned.
+        idx = Index(query_compiler=qc)
+        idx.name = series.name
+        return idx
 
     def _unary_ops(self, method: str) -> Index:
         return self.__constructor__(
diff --git a/src/snowflake/snowpark/modin/plugin/extensions/pd_overrides.py b/src/snowflake/snowpark/modin/plugin/extensions/pd_overrides.py
index 3515baaee3a..5d61bc95694 100644
--- a/src/snowflake/snowpark/modin/plugin/extensions/pd_overrides.py
+++ b/src/snowflake/snowpark/modin/plugin/extensions/pd_overrides.py
@@ -44,9 +44,13 @@
     DatetimeIndex,
 )
 from snowflake.snowpark.modin.plugin.extensions.index import Index  # noqa: F401
+from snowflake.snowpark.modin.plugin.extensions.timedelta_index import (  # noqa: F401
+    TimedeltaIndex,
+)
 
 register_pd_accessor("Index")(Index)
 register_pd_accessor("DatetimeIndex")(DatetimeIndex)
+register_pd_accessor("TimedeltaIndex")(TimedeltaIndex)
 
 
 @_inherit_docstrings(native_pd.read_csv, apilink="pandas.read_csv")
diff --git a/src/snowflake/snowpark/modin/plugin/extensions/timedelta_index.py b/src/snowflake/snowpark/modin/plugin/extensions/timedelta_index.py
new file mode 100644
index 00000000000..7facf4acefd
--- /dev/null
+++ b/src/snowflake/snowpark/modin/plugin/extensions/timedelta_index.py
@@ -0,0 +1,388 @@
+#
+# Copyright (c) 2012-2024 Snowflake Computing Inc. All rights reserved.
+#
+
+# Licensed to Modin Development Team under one or more contributor license agreements.
+# See the NOTICE file distributed with this work for additional information regarding
+# copyright ownership.  The Modin Development Team licenses this file to you under the
+# Apache License, Version 2.0 (the "License"); you may not use this file except in
+# compliance with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under
+# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific language
+# governing permissions and limitations under the License.
+
+# Code in this file may constitute partial or total reimplementation, or modification of
+# existing code originally distributed by the Modin project, under the Apache License,
+# Version 2.0.
+
+"""
+Module houses ``TimedeltaIndex`` class, that is distributed version of
+``pandas.TimedeltaIndex``.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as native_pd
+from pandas._libs import lib
+from pandas._typing import ArrayLike, AxisInt, Dtype, Frequency, Hashable
+from pandas.core.dtypes.common import is_timedelta64_dtype
+
+from snowflake.snowpark.modin.pandas import DataFrame, Series
+from snowflake.snowpark.modin.plugin.compiler.snowflake_query_compiler import (
+    SnowflakeQueryCompiler,
+)
+from snowflake.snowpark.modin.plugin.extensions.index import Index
+from snowflake.snowpark.modin.plugin.utils.error_message import (
+    timedelta_index_not_implemented,
+)
+
+_CONSTRUCTOR_DEFAULTS = {
+    "unit": lib.no_default,
+    "freq": lib.no_default,
+    "dtype": None,
+    "copy": False,
+    "name": None,
+}
+
+
+class TimedeltaIndex(Index):
+
+    # Equivalent index type in native pandas
+    _NATIVE_INDEX_TYPE = native_pd.TimedeltaIndex
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Create new instance of TimedeltaIndex. This overrides behavior of Index.__new__.
+        Args:
+            *args: arguments.
+            **kwargs: keyword arguments.
+
+        Returns:
+            New instance of TimedeltaIndex.
+        """
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        data: ArrayLike | native_pd.Index | Series | None = None,
+        unit: str | lib.NoDefault = _CONSTRUCTOR_DEFAULTS["unit"],
+        freq: Frequency | lib.NoDefault = _CONSTRUCTOR_DEFAULTS["freq"],
+        dtype: Dtype | None = _CONSTRUCTOR_DEFAULTS["dtype"],
+        copy: bool = _CONSTRUCTOR_DEFAULTS["copy"],
+        name: Hashable | None = _CONSTRUCTOR_DEFAULTS["name"],
+        query_compiler: SnowflakeQueryCompiler = None,
+    ) -> None:
+        """
+        Immutable Index of timedelta64 data.
+
+        Represented internally as int64, and scalars returned Timedelta objects.
+
+        Parameters
+        ----------
+        data : array-like (1-dimensional), optional
+            Optional timedelta-like data to construct index with.
+        unit : {'D', 'h', 'm', 's', 'ms', 'us', 'ns'}, optional
+            The unit of ``data``.
+
+            .. deprecated:: 2.2.0
+             Use ``pd.to_timedelta`` instead.
+
+        freq : str or pandas offset object, optional
+            One of pandas date offset strings or corresponding objects. The string
+            ``'infer'`` can be passed in order to set the frequency of the index as
+            the inferred frequency upon creation.
+        dtype : numpy.dtype or str, default None
+            Valid ``numpy`` dtypes are ``timedelta64[ns]``, ``timedelta64[us]``,
+            ``timedelta64[ms]``, and ``timedelta64[s]``.
+        copy : bool
+            Make a copy of input array.
+        name : object
+            Name to be stored in the index.
+
+        Examples
+        --------
+        >>> pd.TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'])
+        TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]')
+
+        We can also let pandas infer the frequency when possible.
+
+        >>> pd.TimedeltaIndex(np.arange(5) * 24 * 3600 * 1e9, freq='infer')
+        TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]')
+        """
+        if query_compiler:
+            # Raise error if underlying type is not a Timedelta type.
+            current_dtype = query_compiler.index_dtypes[0]
+            if not is_timedelta64_dtype(current_dtype):
+                raise ValueError(
+                    f"TimedeltaIndex can only be created from a query compiler with TimedeltaType, found {current_dtype}"
+                )
+        kwargs = {
+            "unit": unit,
+            "freq": freq,
+            "dtype": dtype,
+            "copy": copy,
+            "name": name,
+        }
+        self._init_index(data, _CONSTRUCTOR_DEFAULTS, query_compiler, **kwargs)
+
+    @timedelta_index_not_implemented()
+    @property
+    def days(self) -> Index:
+        """
+        Number of days for each element.
+
+        Returns
+        -------
+        An Index with the days component of the timedelta.
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta(["0 days", "10 days", "20 days"])  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['0 days', '10 days', '20 days'],
+                        dtype='timedelta64[ns]', freq=None)
+        >>> idx.days  # doctest: +SKIP
+        Index([0, 10, 20], dtype='int64')
+        """
+
+    @timedelta_index_not_implemented()
+    @property
+    def seconds(self) -> Index:
+        """
+        Number of seconds (>= 0 and less than 1 day) for each element.
+
+        Returns
+        -------
+        An Index with seconds component of the timedelta.
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta([1, 2, 3], unit='s')  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['0 days 00:00:01', '0 days 00:00:02', '0 days 00:00:03'],
+                       dtype='timedelta64[ns]', freq=None)
+        >>> idx.seconds  # doctest: +SKIP
+        Index([1, 2, 3], dtype='int32')
+        """
+
+    @timedelta_index_not_implemented()
+    @property
+    def microseconds(self) -> Index:
+        """
+        Number of microseconds (>= 0 and less than 1 second) for each element.
+
+        Returns
+        -------
+        An Index with microseconds component of the timedelta.
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta([1, 2, 3], unit='us')  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['0 days 00:00:00.000001', '0 days 00:00:00.000002',
+                        '0 days 00:00:00.000003'],
+                       dtype='timedelta64[ns]', freq=None)
+        >>> idx.microseconds  # doctest: +SKIP
+        Index([1, 2, 3], dtype='int32')
+        """
+
+    @timedelta_index_not_implemented()
+    @property
+    def nanoseconds(self) -> Index:
+        """
+        Number of nonoseconds (>= 0 and less than 1 microsecond) for each element.
+
+        Returns
+        -------
+        An Index with nanoseconds compnent of the timedelta.
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta([1, 2, 3], unit='ns')  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['0 days 00:00:00.000000001', '0 days 00:00:00.000000002',
+                        '0 days 00:00:00.000000003'],
+                       dtype='timedelta64[ns]', freq=None)
+        >>> idx.nanoseconds  # doctest: +SKIP
+        Index([1, 2, 3], dtype='int32')
+        """
+
+    @timedelta_index_not_implemented()
+    @property
+    def components(self) -> DataFrame:
+        """
+        Return a DataFrame of the individual resolution components of the Timedeltas.
+
+        The components (days, hours, minutes seconds, milliseconds, microseconds,
+        nanoseconds) are returned as columns in a DataFrame.
+
+        Returns
+        -------
+        A DataFrame
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta(['1 day 3 min 2 us 42 ns'])  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['1 days 00:03:00.000002042'],
+                       dtype='timedelta64[ns]', freq=None)
+        >>> idx.components  # doctest: +SKIP
+           days  hours  minutes  seconds  milliseconds  microseconds  nanoseconds
+        0     1      0        3        0             0             2           42
+        """
+
+    @timedelta_index_not_implemented()
+    @property
+    def inferred_freq(self) -> str | None:
+        """
+        Tries to return a string representing a frequency generated by infer_freq.
+
+        Returns None if it can't autodetect the frequency.
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta(["0 days", "10 days", "20 days"])  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['0 days', '10 days', '20 days'],
+                       dtype='timedelta64[ns]', freq=None)
+        >>> idx.inferred_freq  # doctest: +SKIP
+        '10D'
+        """
+
+    @timedelta_index_not_implemented()
+    def round(self, freq: Frequency) -> TimedeltaIndex:
+        """
+        Perform round operation on the data to the specified `freq`.
+
+        Parameters
+        ----------
+        freq : str or Offset
+            The frequency level to round the index to. Must be a fixed
+            frequency like 'S' (second) not 'ME' (month end). See
+            frequency aliases for a list of possible `freq` values.
+
+        Returns
+        -------
+        TimedeltaIndex with round values.
+
+        Raises
+        ------
+        ValueError if the `freq` cannot be converted.
+        """
+
+    @timedelta_index_not_implemented()
+    def floor(self, freq: Frequency) -> TimedeltaIndex:
+        """
+        Perform floor operation on the data to the specified `freq`.
+
+        Parameters
+        ----------
+        freq : str or Offset
+            The frequency level to floor the index to. Must be a fixed
+            frequency like 'S' (second) not 'ME' (month end). See
+            frequency aliases for a list of possible `freq` values.
+
+        Returns
+        -------
+        TimedeltaIndex with floor values.
+
+        Raises
+        ------
+        ValueError if the `freq` cannot be converted.
+        """
+
+    @timedelta_index_not_implemented()
+    def ceil(self, freq: Frequency) -> TimedeltaIndex:
+        """
+        Perform ceil operation on the data to the specified `freq`.
+
+        Parameters
+        ----------
+        freq : str or Offset
+            The frequency level to ceil the index to. Must be a fixed
+            frequency like 'S' (second) not 'ME' (month end). See
+            frequency aliases for a list of possible `freq` values.
+
+        Returns
+        -------
+        TimedeltaIndex with ceil values.
+
+        Raises
+        ------
+        ValueError if the `freq` cannot be converted.
+        """
+
+    @timedelta_index_not_implemented()
+    def to_pytimedelta(self) -> np.ndarray:
+        """
+        Return an ndarray of datetime.timedelta objects.
+
+        Returns
+        -------
+        numpy.ndarray
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta([1, 2, 3], unit='D')  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['1 days', '2 days', '3 days'],
+                        dtype='timedelta64[ns]', freq=None)
+        >>> idx.to_pytimedelta()  # doctest: +SKIP
+        array([datetime.timedelta(days=1), datetime.timedelta(days=2),
+               datetime.timedelta(days=3)], dtype=object)
+        """
+
+    @timedelta_index_not_implemented()
+    def mean(
+        self, *, skipna: bool = True, axis: AxisInt | None = 0
+    ) -> native_pd.Timestamp:
+        """
+        Return the mean value of the Array.
+
+        Parameters
+        ----------
+        skipna : bool, default True
+            Whether to ignore any NaT elements.
+        axis : int, optional, default 0
+
+        Returns
+        -------
+            scalar Timestamp
+
+        See Also
+        --------
+        numpy.ndarray.mean : Returns the average of array elements along a given axis.
+        Series.mean : Return the mean value in a Series.
+
+        Notes
+        -----
+        mean is only defined for Datetime and Timedelta dtypes, not for Period.
+        """
+
+    @timedelta_index_not_implemented()
+    def as_unit(self, unit: str) -> TimedeltaIndex:
+        """
+        Convert to a dtype with the given unit resolution.
+
+        Parameters
+        ----------
+        unit : {'s', 'ms', 'us', 'ns'}
+
+        Returns
+        -------
+        DatetimeIndex
+
+        Examples
+        --------
+        >>> idx = pd.to_timedelta(['1 day 3 min 2 us 42 ns'])  # doctest: +SKIP
+        >>> idx  # doctest: +SKIP
+        TimedeltaIndex(['1 days 00:03:00.000002042'],
+                        dtype='timedelta64[ns]', freq=None)
+        >>> idx.as_unit('s')  # doctest: +SKIP
+        TimedeltaIndex(['1 days 00:03:00'], dtype='timedelta64[s]', freq=None)
+        """
diff --git a/src/snowflake/snowpark/modin/plugin/utils/error_message.py b/src/snowflake/snowpark/modin/plugin/utils/error_message.py
index 1e832450579..7fc86152c63 100644
--- a/src/snowflake/snowpark/modin/plugin/utils/error_message.py
+++ b/src/snowflake/snowpark/modin/plugin/utils/error_message.py
@@ -143,6 +143,10 @@ def raise_not_implemented_method_error(
     decorating_functions=False, attribute_prefix="DatetimeIndex"
 )
 
+timedelta_index_not_implemented = _make_not_implemented_decorator(
+    decorating_functions=False, attribute_prefix="TimedeltaIndex"
+)
+
 pandas_module_level_function_not_implemented = _make_not_implemented_decorator(
     decorating_functions=True, attribute_prefix="pd"
 )
diff --git a/tests/integ/modin/index/conftest.py b/tests/integ/modin/index/conftest.py
index bc26872380e..3c6362dd83c 100644
--- a/tests/integ/modin/index/conftest.py
+++ b/tests/integ/modin/index/conftest.py
@@ -16,6 +16,10 @@
         data={"col1": [1, 2, 3], "col2": [3, 4, 5]},
         index=native_pd.DatetimeIndex(["2024-01-01", "2024-02-01", "2024-03-01"]),
     ),
+    native_pd.DataFrame(
+        data={"col1": [1, 2, 3], "col2": [3, 4, 5]},
+        index=native_pd.TimedeltaIndex(["0 days", "1 days", "3 days"]),
+    ),
 ]
 
 NATIVE_INDEX_TEST_DATA = [
@@ -36,6 +40,8 @@
         tz="America/Los_Angeles",
     ),
     native_pd.DatetimeIndex([1262347200000000000, 1262347400000000000]),
+    native_pd.TimedeltaIndex(["0 days", "1 days", "3 days"]),
+    native_pd.TimedeltaIndex([100, 200, 300]),
 ]
 
 NATIVE_INDEX_UNIQUE_TEST_DATA = [
diff --git a/tests/integ/modin/index/test_timedelta_index_methods.py b/tests/integ/modin/index/test_timedelta_index_methods.py
new file mode 100644
index 00000000000..1baafed24d2
--- /dev/null
+++ b/tests/integ/modin/index/test_timedelta_index_methods.py
@@ -0,0 +1,65 @@
+#
+# Copyright (c) 2012-2024 Snowflake Computing Inc. All rights reserved.
+#
+
+import modin.pandas as pd
+import pandas as native_pd
+import pytest
+
+import snowflake.snowpark.modin.plugin  # noqa: F401
+from tests.integ.modin.sql_counter import sql_count_checker
+
+
+@sql_count_checker(query_count=3)
+def test_timedelta_index_construction():
+    # create from native pandas timedelta index.
+    index = native_pd.TimedeltaIndex(["1 days", "2 days", "3 days"])
+    snow_index = pd.Index(index)
+    assert isinstance(snow_index, pd.TimedeltaIndex)
+
+    # create from query compiler with timedelta type.
+    df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=index)
+    snow_index = df.index
+    assert isinstance(snow_index, pd.TimedeltaIndex)
+
+    # create from snowpark pandas timedelta index.
+    snow_index = pd.Index(pd.TimedeltaIndex([123]))
+    assert isinstance(snow_index, pd.TimedeltaIndex)
+
+    # create by subtracting datetime index from another.
+    date_range1 = pd.date_range("2000-01-01", periods=10, freq="h")
+    date_range2 = pd.date_range("2001-05-01", periods=10, freq="h")
+    snow_index = date_range2 - date_range1
+    assert isinstance(snow_index, pd.TimedeltaIndex)
+
+
+@sql_count_checker(query_count=0)
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"unit": "ns"},
+        {"freq": "M"},
+        {"dtype": "int"},
+        {"copy": True},
+        {"name": "abc"},
+    ],
+)
+def test_non_default_args(kwargs):
+    idx = pd.TimedeltaIndex(["1 days"])
+
+    name = list(kwargs.keys())[0]
+    value = list(kwargs.values())[0]
+    msg = f"Non-default argument '{name}={value}' when constructing Index with query compiler"
+    with pytest.raises(AssertionError, match=msg):
+        pd.TimedeltaIndex(query_compiler=idx._query_compiler, **kwargs)
+
+
+@pytest.mark.parametrize(
+    "property", ["days", "seconds", "microseconds", "nanoseconds", "inferred_freq"]
+)
+@sql_count_checker(query_count=0)
+def test_property_not_implemented(property):
+    snow_index = pd.TimedeltaIndex(["1 days", "2 days"])
+    msg = f"Snowpark pandas does not yet support the property TimedeltaIndex.{property}"
+    with pytest.raises(NotImplementedError, match=msg):
+        getattr(snow_index, property)
diff --git a/tests/unit/modin/test_class.py b/tests/unit/modin/test_class.py
index 1d4b3881b7b..29aa1037d47 100644
--- a/tests/unit/modin/test_class.py
+++ b/tests/unit/modin/test_class.py
@@ -49,7 +49,6 @@ def test_class_equivalence():
     assert pd.SparseDtype is native_pd.SparseDtype
     assert pd.StringDtype is native_pd.StringDtype
     assert pd.Timedelta is native_pd.Timedelta
-    assert pd.TimedeltaIndex is native_pd.TimedeltaIndex
     assert pd.Timestamp is native_pd.Timestamp
     assert pd.UInt8Dtype is native_pd.UInt8Dtype
     assert pd.UInt16Dtype is native_pd.UInt16Dtype

From c187e188c2e3951926152e8162a837a3c3314524 Mon Sep 17 00:00:00 2001
From: Naren Krishna <naren.krishna@snowflake.com>
Date: Wed, 28 Aug 2024 10:47:15 -0700
Subject: [PATCH 06/11] FIX: Return NotImplementedError when converting string
 to timedelta (#2177)

<!---
Please answer these questions before creating your pull request. Thanks!
--->

1. Which Jira issue is this PR addressing? Make sure that there is an
accompanying issue to your PR.

   <!---
   In this section, please add a Snowflake Jira issue number.

Note that if a corresponding GitHub issue exists, you should still
include
   the Snowflake Jira issue number. For example, for GitHub issue
https://github.com/snowflakedb/snowpark-python/issues/1400, you should
   add "SNOW-1335071" here.
    --->

   Fixes SNOW-NNNNNNN

2. Fill out the following pre-review checklist:

- [ ] I am adding a new automated test(s) to verify correctness of my
new code
- [ ] If this test skips Local Testing mode, I'm requesting review from
@snowflakedb/local-testing
   - [ ] I am adding new logging messages
   - [ ] I am adding a new telemetry message
   - [ ] I am adding new credentials
   - [ ] I am adding a new dependency
- [ ] If this is a new feature/behavior, I'm adding the Local Testing
parity changes.

3. Please describe how your code solves the related issue.

Please write a short description of how your code change solves the
related issue.

---------

Signed-off-by: Naren Krishna <naren.krishna@snowflake.com>
---
 .../modin/supported/dataframe_supported.rst   |  4 ++--
 .../modin/supported/series_supported.rst      |  4 ++--
 .../modin/plugin/_internal/type_utils.py      |  4 ++--
 .../compiler/snowflake_query_compiler.py      | 10 ++++++++-
 tests/integ/modin/frame/test_astype.py        | 19 ++++++++++-------
 tests/integ/modin/series/test_astype.py       | 21 ++++++++++++-------
 6 files changed, 41 insertions(+), 21 deletions(-)

diff --git a/docs/source/modin/supported/dataframe_supported.rst b/docs/source/modin/supported/dataframe_supported.rst
index 1855eb314b3..6bb214e3bd6 100644
--- a/docs/source/modin/supported/dataframe_supported.rst
+++ b/docs/source/modin/supported/dataframe_supported.rst
@@ -98,8 +98,8 @@ Methods
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
 | ``assign``                  | Y                               |                                  |                                                    |
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
-| ``astype``                  | P                               |                                  | ``N``: from string to datetime or ``errors ==      |
-|                             |                                 |                                  | "ignore"``                                         |
+| ``astype``                  | P                               |                                  | ``N`` if from string to datetime/timedelta or      |
+|                             |                                 |                                  | ``errors == "ignore"``                             |
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
 | ``at_time``                 | N                               |                                  |                                                    |
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
diff --git a/docs/source/modin/supported/series_supported.rst b/docs/source/modin/supported/series_supported.rst
index ea78a3a0e68..331be4d0298 100644
--- a/docs/source/modin/supported/series_supported.rst
+++ b/docs/source/modin/supported/series_supported.rst
@@ -105,8 +105,8 @@ Methods
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
 | ``asof``                    | N                               |                                  |                                                    |
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
-| ``astype``                  | P                               |                                  | ``N``: from string to datetime or ``errors ==      |
-|                             |                                 |                                  | "ignore"``                                         |
+| ``astype``                  | P                               |                                  | ``N`` if from string to datetime/timedelta or      |
+|                             |                                 |                                  | ``errors == "ignore"``                             |
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
 | ``at_time``                 | N                               |                                  |                                                    |
 +-----------------------------+---------------------------------+----------------------------------+----------------------------------------------------+
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py b/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py
index ed0c81bc4af..261903be0f7 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/type_utils.py
@@ -318,12 +318,12 @@ def column_astype(
         isinstance(from_sf_type, TimestampType)
         and from_sf_type.tz == TimestampTimeZone.LTZ
     ):
-        # treat TIMESTAMPT_LTZ columns as same as TIMESTAMPT_TZ
+        # treat TIMESTAMP_LTZ columns as same as TIMESTAMP_TZ
         curr_col = builtin("to_timestamp_tz")(curr_col)
 
     if isinstance(to_sf_type, TimestampType):
         assert to_sf_type.tz != TimestampTimeZone.LTZ, (
-            "Cast to TIMESTAMPT_LTZ is not supported in astype since "
+            "Cast to TIMESTAMP_LTZ is not supported in astype since "
             "Snowpark pandas API maps tz aware datetime to TIMESTAMP_TZ"
         )
         # convert to timestamp
diff --git a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
index b24cb083723..7e6336c397e 100644
--- a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
+++ b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
@@ -8795,7 +8795,15 @@ def astype(
                 to_sf_type = TypeMapper.to_snowflake(to_dtype)
                 from_dtype = col_dtypes_curr[label]
                 from_sf_type = self._modin_frame.get_snowflake_type(id)
-                if is_astype_type_error(from_sf_type, to_sf_type):
+                if isinstance(from_sf_type, StringType) and isinstance(
+                    to_sf_type, TimedeltaType
+                ):
+                    # Raise NotImplementedError as there is no Snowflake SQL function converting
+                    # string (e.g. 1 day, 3 hours, 2 minutes) to Timedelta
+                    ErrorMessage.not_implemented(
+                        f"dtype {pandas_dtype(from_dtype)} cannot be converted to {pandas_dtype(to_dtype)}"
+                    )
+                elif is_astype_type_error(from_sf_type, to_sf_type):
                     raise TypeError(
                         f"dtype {pandas_dtype(from_dtype)} cannot be converted to {pandas_dtype(to_dtype)}"
                     )
diff --git a/tests/integ/modin/frame/test_astype.py b/tests/integ/modin/frame/test_astype.py
index 89049daee61..0c1d1faa31c 100644
--- a/tests/integ/modin/frame/test_astype.py
+++ b/tests/integ/modin/frame/test_astype.py
@@ -109,7 +109,6 @@ def test_astype_from_timestamp_ltz(session, to_dtype):
             "float_col": "timedelta64[ns]",
             "boolean_col": bool,
             "object_col": "timedelta64[ns]",
-            "string_col": str,
         },
     ],
 )
@@ -121,7 +120,6 @@ def test_astype_to_timedelta(dtype):
             "float_col": [12345678, 2.3],
             "boolean_col": [True, False],
             "object_col": [1, "2"],
-            "string_col": ["6", "8"],
         },
     )
     snow_df = pd.DataFrame(native_df)
@@ -129,21 +127,28 @@ def test_astype_to_timedelta(dtype):
 
 
 @sql_count_checker(query_count=2)
-def test_astype_datetime_to_timedelta_negative():
-    native_df = native_pd.DataFrame(
+def test_astype_to_timedelta_negative():
+    native_datetime_df = native_pd.DataFrame(
         data={"col1": [pd.to_datetime("2000-01-01"), pd.to_datetime("2001-01-01")]}
     )
-    snow_df = pd.DataFrame(native_df)
+    snow_datetime_df = pd.DataFrame(native_datetime_df)
     with SqlCounter(query_count=0):
         with pytest.raises(
             TypeError,
             match=re.escape("Cannot cast DatetimeArray to dtype timedelta64[ns]"),
         ):
-            native_df.astype("timedelta64[ns]")
+            native_datetime_df.astype("timedelta64[ns]")
         with pytest.raises(
             TypeError,
             match=re.escape(
                 "dtype datetime64[ns] cannot be converted to timedelta64[ns]"
             ),
         ):
-            snow_df.astype("timedelta64[ns]")
+            snow_datetime_df.astype("timedelta64[ns]")
+    with SqlCounter(query_count=0):
+        snow_string_df = pd.DataFrame(data=["2 days, 3 minutes", "4 days, 1 hour"])
+        with pytest.raises(
+            NotImplementedError,
+            match=re.escape("dtype object cannot be converted to timedelta64[ns]"),
+        ):
+            snow_string_df.astype("timedelta64[ns]")
diff --git a/tests/integ/modin/series/test_astype.py b/tests/integ/modin/series/test_astype.py
index ff65c677c05..9c00e9a675d 100644
--- a/tests/integ/modin/series/test_astype.py
+++ b/tests/integ/modin/series/test_astype.py
@@ -407,8 +407,8 @@ def test_python_datetime_astype_DatetimeTZDtype(seed):
 @sql_count_checker(query_count=1)
 @pytest.mark.parametrize(
     "data",
-    [[12345678, 9], [12345678, 2.6], [True, False], [1, "2"], ["1", "2"]],
-    ids=["int", "float", "boolean", "object", "string"],
+    [[12345678, 9], [12345678, 2.6], [True, False], [1, "2"]],
+    ids=["int", "float", "boolean", "object"],
 )
 def test_astype_to_timedelta(data):
     native_series = native_pd.Series(data)
@@ -419,24 +419,31 @@ def test_astype_to_timedelta(data):
 
 
 @sql_count_checker(query_count=2)
-def test_astype_datetime_to_timedelta_negative():
-    native_series = native_pd.Series(
+def test_astype_to_timedelta_negative():
+    native_datetime_series = native_pd.Series(
         data=[pd.to_datetime("2000-01-01"), pd.to_datetime("2001-01-01")]
     )
-    snow_series = pd.Series(native_series)
+    snow_datetime_series = pd.Series(native_datetime_series)
     with SqlCounter(query_count=0):
         with pytest.raises(
             TypeError,
             match=re.escape("Cannot cast DatetimeArray to dtype timedelta64[ns]"),
         ):
-            native_series.astype("timedelta64[ns]")
+            native_datetime_series.astype("timedelta64[ns]")
         with pytest.raises(
             TypeError,
             match=re.escape(
                 "dtype datetime64[ns] cannot be converted to timedelta64[ns]"
             ),
         ):
-            snow_series.astype("timedelta64[ns]")
+            snow_datetime_series.astype("timedelta64[ns]")
+    with SqlCounter(query_count=0):
+        snow_string_series = pd.Series(data=["2 days, 3 minutes"])
+        with pytest.raises(
+            NotImplementedError,
+            match=re.escape("dtype object cannot be converted to timedelta64[ns]"),
+        ):
+            snow_string_series.astype("timedelta64[ns]")
 
 
 @sql_count_checker(query_count=0)

From e83e7003dd18153c79782a16f9897119db1a8b8d Mon Sep 17 00:00:00 2001
From: Andong Zhan <andong.zhan@snowflake.com>
Date: Wed, 28 Aug 2024 13:12:51 -0700
Subject: [PATCH 07/11] SNOW-1643374 remove azure from CI during investigation
 (#2181)

SNOW-1643374 remove azure from CI during investigation
---
 .github/workflows/precommit.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/precommit.yml b/.github/workflows/precommit.yml
index 20a2d5274a2..0d8ca77dac3 100644
--- a/.github/workflows/precommit.yml
+++ b/.github/workflows/precommit.yml
@@ -85,7 +85,7 @@ jobs:
       matrix:
         os: [macos-latest, windows-latest-64-cores, ubuntu-latest-64-cores]
         python-version: ["3.9", "3.10", "3.11"]
-        cloud-provider: [aws, azure, gcp]
+        cloud-provider: [aws, gcp] # TODO: SNOW-1643374 add azure back
         exclude:
           # only run macos with aws py3.9 for doctest
           - os: macos-latest
@@ -309,7 +309,7 @@ jobs:
       matrix:
         os: [macos-latest, windows-latest-64-cores, ubuntu-latest-64-cores]
         python-version: [ "3.9", "3.10", "3.11" ]
-        cloud-provider: [aws, azure, gcp]
+        cloud-provider: [aws, gcp] # TODO: SNOW-1643374 add azure back
         exclude:
           # only run macos with aws py3.9 for doctest
           - os: macos-latest

From f11f6ee57951ab655a3a97205821d7d2380b6f2b Mon Sep 17 00:00:00 2001
From: Afroz Alam <afroz.alam@snowflake.com>
Date: Wed, 28 Aug 2024 21:26:22 +0000
Subject: [PATCH 08/11] SNOW-1418500: Add side effect to _resolve_packages
 (#2174)

---
 src/snowflake/snowpark/_internal/udf_utils.py |  4 ++--
 src/snowflake/snowpark/session.py             | 21 ++++++++++---------
 tests/integ/test_packaging.py                 |  2 +-
 tests/unit/test_session.py                    | 14 +++++++++----
 4 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/src/snowflake/snowpark/_internal/udf_utils.py b/src/snowflake/snowpark/_internal/udf_utils.py
index 5a92dcb95cd..b79fcdcf9c9 100644
--- a/src/snowflake/snowpark/_internal/udf_utils.py
+++ b/src/snowflake/snowpark/_internal/udf_utils.py
@@ -1062,7 +1062,7 @@ def resolve_imports_and_packages(
                 packages,
                 include_pandas=is_pandas_udf,
                 statement_params=statement_params,
-            )[0]
+            )
             if packages is not None
             else session._resolve_packages(
                 [],
@@ -1070,7 +1070,7 @@ def resolve_imports_and_packages(
                 validate_package=False,
                 include_pandas=is_pandas_udf,
                 statement_params=statement_params,
-            )[0]
+            )
         )
 
     if session is not None:
diff --git a/src/snowflake/snowpark/session.py b/src/snowflake/snowpark/session.py
index 5414d9a089d..b718364dc83 100644
--- a/src/snowflake/snowpark/session.py
+++ b/src/snowflake/snowpark/session.py
@@ -1117,11 +1117,10 @@ def add_packages(
             to ensure the consistent experience of a UDF between your local environment
             and the Snowflake server.
         """
-        _, resolved_result_dict = self._resolve_packages(
+        self._resolve_packages(
             parse_positional_args_to_list(*packages),
             self._packages,
         )
-        self._packages.update(resolved_result_dict)
 
     def remove_package(self, package: str) -> None:
         """
@@ -1482,12 +1481,13 @@ def _resolve_packages(
         validate_package: bool = True,
         include_pandas: bool = False,
         statement_params: Optional[Dict[str, str]] = None,
-    ) -> Tuple[List[str], Dict[str, str]]:
+    ) -> List[str]:
         """
         Given a list of packages to add, this method will
         1. Check if the packages are supported by Snowflake
         2. Check if the package version if provided is supported by Snowflake
         3. Check if the package is already added
+        4. Update existing packages dictionary with the new packages (*this is required for python sp to work*)
 
         When auto package upload is enabled, this method will also try to upload the packages
         unavailable in Snowflake to the stage.
@@ -1496,7 +1496,6 @@ def _resolve_packages(
 
         Returns:
             List[str]: List of package specifiers
-            Dict[str, str]: Dictionary of package name -> package specifier
         """
         # Extract package names, whether they are local, and their associated Requirement objects
         package_dict = self._parse_packages(packages)
@@ -1518,7 +1517,9 @@ def _resolve_packages(
                 raise errors[0]
             elif len(errors) > 0:
                 raise RuntimeError(errors)
-            return list(result_dict.values()), result_dict
+
+            self._packages.update(result_dict)
+            return list(result_dict.values())
 
         package_table = "information_schema.packages"
         if not self.get_current_database():
@@ -1531,7 +1532,7 @@ def _resolve_packages(
         #  'scikit-learn': 'scikit-learn==1.2.2',
         #  'python-dateutil': 'python-dateutil==2.8.2'}
         # Add to packages dictionary. Make a copy of existing packages
-        # dictionary to avoid modifying it.
+        # dictionary to avoid modifying it during intermediate steps.
         result_dict = (
             existing_packages_dict.copy() if existing_packages_dict is not None else {}
         )
@@ -1567,10 +1568,10 @@ def _resolve_packages(
         if include_pandas:
             extra_modules.append("pandas")
 
-        return (
-            list(result_dict.values())
-            + self._get_req_identifiers_list(extra_modules, result_dict),
-            result_dict,
+        if existing_packages_dict is not None:
+            existing_packages_dict.update(result_dict)
+        return list(result_dict.values()) + self._get_req_identifiers_list(
+            extra_modules, result_dict
         )
 
     def _upload_unsupported_packages(
diff --git a/tests/integ/test_packaging.py b/tests/integ/test_packaging.py
index 3deac4e80f3..eaf99534e2b 100644
--- a/tests/integ/test_packaging.py
+++ b/tests/integ/test_packaging.py
@@ -262,7 +262,7 @@ def is_yaml_available() -> bool:
     # add module objects
     # but we can't register a udf with these versions
     # because the server might not have them
-    resolved_packages, _ = session._resolve_packages(
+    resolved_packages = session._resolve_packages(
         [numpy, pandas, dateutil], validate_package=False
     )
     assert f"numpy=={numpy.__version__}" in resolved_packages
diff --git a/tests/unit/test_session.py b/tests/unit/test_session.py
index 86c8d54f7bb..262c9e82c44 100644
--- a/tests/unit/test_session.py
+++ b/tests/unit/test_session.py
@@ -245,7 +245,9 @@ def run_query(sql: str):
         )
 
 
-def test_resolve_packages_no_side_effect():
+def test_resolve_packages_side_effect():
+    """Python stored procedure depends on this behavior to add packages to the session."""
+
     def mock_get_information_schema_packages(table_name: str):
         result = MagicMock()
         result.filter().group_by().agg()._internal_collect_with_tag.return_value = [
@@ -261,15 +263,19 @@ def mock_get_information_schema_packages(table_name: str):
 
     existing_packages = {}
 
-    resolved_packages, _ = session._resolve_packages(
+    resolved_packages = session._resolve_packages(
         ["random_package_name"],
         existing_packages_dict=existing_packages,
         validate_package=True,
         include_pandas=False,
     )
 
-    assert len(resolved_packages) == 2  # random_package_name and cloudpickle
-    assert len(existing_packages) == 0
+    assert (
+        len(resolved_packages) == 2
+    ), resolved_packages  # random_package_name and cloudpickle
+    assert (
+        len(existing_packages) == 1
+    ), existing_packages  # {"random_package_name": "random_package_name"}
 
 
 @pytest.mark.skipif(not is_pandas_available, reason="requires pandas for write_pandas")

From bbc8781bb92b80c40dd8d3b0d8219eaddca0118f Mon Sep 17 00:00:00 2001
From: Andong Zhan <andong.zhan@snowflake.com>
Date: Wed, 28 Aug 2024 14:33:58 -0700
Subject: [PATCH 09/11] SNOW-1628820 remove timedelta warning message (#2178)

SNOW-1628820 remove timedelta warning message and update notebooks
---
 .../plugin/_internal/snowpark_pandas_types.py |   8 -
 tests/integ/modin/types/test_timedelta.py     |  10 +-
 .../notebooks/modin/MIMICHealthcareDemo.ipynb | 206 +++++-
 .../modin/SnowflakeChainTesting.ipynb         | 658 ++++++++++++++----
 .../modin/SnowparkPandasAPIDemo.ipynb         | 257 ++++---
 tests/notebooks/modin/TimeSeriesTesting.ipynb | 444 ++++++++++--
 .../modin/VisualizingTaxiTripData.ipynb       | 166 ++++-
 7 files changed, 1382 insertions(+), 367 deletions(-)

diff --git a/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py b/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py
index 20f5d8b61de..4ba43a94c4d 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py
@@ -12,13 +12,8 @@
 import pandas as native_pd
 
 from snowflake.snowpark.column import Column
-from snowflake.snowpark.modin.plugin.utils.warning_message import WarningMessage
 from snowflake.snowpark.types import DataType, LongType
 
-TIMEDELTA_WARNING_MESSAGE = (
-    "Snowpark pandas support for Timedelta is not currently available."
-)
-
 """Map Python type to its from_pandas method"""
 _python_type_to_from_pandas: dict[type, Callable[[Any], Any]] = {}
 
@@ -128,9 +123,6 @@ class TimedeltaType(SnowparkPandasType, LongType):
     )
 
     def __init__(self) -> None:
-        # TODO(SNOW-1620452): Remove this warning message before releasing
-        # Timedelta support.
-        WarningMessage.single_warning(TIMEDELTA_WARNING_MESSAGE)
         super().__init__()
 
     @staticmethod
diff --git a/tests/integ/modin/types/test_timedelta.py b/tests/integ/modin/types/test_timedelta.py
index f0d8440009f..bcae016cbf0 100644
--- a/tests/integ/modin/types/test_timedelta.py
+++ b/tests/integ/modin/types/test_timedelta.py
@@ -2,15 +2,11 @@
 # Copyright (c) 2012-2024 Snowflake Computing Inc. All rights reserved.
 #
 import datetime
-import logging
 
 import modin.pandas as pd
 import pandas as native_pd
 import pytest
 
-from snowflake.snowpark.modin.plugin._internal.snowpark_pandas_types import (
-    TIMEDELTA_WARNING_MESSAGE,
-)
 from tests.integ.modin.sql_counter import sql_count_checker
 from tests.integ.modin.utils import (
     assert_series_equal,
@@ -21,13 +17,11 @@
 
 
 @sql_count_checker(query_count=1)
-def test_create_timedelta_column_from_pandas_timedelta(caplog):
+def test_create_timedelta_column_from_pandas_timedelta():
     pandas_df = native_pd.DataFrame(
         {"timedelta_column": [native_pd.Timedelta(nanoseconds=1)], "int_column": [3]}
     )
-    with caplog.at_level(logging.DEBUG):
-        snow_df = pd.DataFrame(pandas_df)
-    assert TIMEDELTA_WARNING_MESSAGE in caplog.text
+    snow_df = pd.DataFrame(pandas_df)
     eval_snowpark_pandas_result(snow_df, pandas_df, lambda df: df)
 
 
diff --git a/tests/notebooks/modin/MIMICHealthcareDemo.ipynb b/tests/notebooks/modin/MIMICHealthcareDemo.ipynb
index 3f1849e52cd..95a75e3c858 100644
--- a/tests/notebooks/modin/MIMICHealthcareDemo.ipynb
+++ b/tests/notebooks/modin/MIMICHealthcareDemo.ipynb
@@ -33,6 +33,12 @@
    "execution_count": 1,
    "id": "90243e71-4cf0-4971-a95e-3f29e12449fc",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:35.536214Z",
+     "iopub.status.busy": "2024-08-28T17:27:35.535897Z",
+     "iopub.status.idle": "2024-08-28T17:27:36.977905Z",
+     "shell.execute_reply": "2024-08-28T17:27:36.977472Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -63,6 +69,12 @@
    "execution_count": 2,
    "id": "c309356f-14f8-469a-9257-b944b8951410",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:36.980268Z",
+     "iopub.status.busy": "2024-08-28T17:27:36.980102Z",
+     "iopub.status.idle": "2024-08-28T17:27:45.691050Z",
+     "shell.execute_reply": "2024-08-28T17:27:45.690724Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -84,6 +96,12 @@
    "execution_count": 3,
    "id": "68823bb5-fcd1-4f92-b767-e5ac83dc3df7",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:45.693385Z",
+     "iopub.status.busy": "2024-08-28T17:27:45.693251Z",
+     "iopub.status.idle": "2024-08-28T17:27:46.018818Z",
+     "shell.execute_reply": "2024-08-28T17:27:46.018231Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -126,6 +144,12 @@
    "execution_count": 4,
    "id": "9a7fc3b9-50db-49da-a18a-8865a3356f31",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:46.022960Z",
+     "iopub.status.busy": "2024-08-28T17:27:46.022736Z",
+     "iopub.status.idle": "2024-08-28T17:27:49.916885Z",
+     "shell.execute_reply": "2024-08-28T17:27:49.916624Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -306,6 +330,12 @@
    "execution_count": 5,
    "id": "7692a0af-de2f-42d1-9110-15ce104c2c5c",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:49.918782Z",
+     "iopub.status.busy": "2024-08-28T17:27:49.918678Z",
+     "iopub.status.idle": "2024-08-28T17:27:50.561066Z",
+     "shell.execute_reply": "2024-08-28T17:27:50.560658Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -358,7 +388,14 @@
    "cell_type": "code",
    "execution_count": 6,
    "id": "5344da61-915d-43cf-894a-484876450748",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:50.563582Z",
+     "iopub.status.busy": "2024-08-28T17:27:50.563395Z",
+     "iopub.status.idle": "2024-08-28T17:27:50.768782Z",
+     "shell.execute_reply": "2024-08-28T17:27:50.768309Z"
+    }
+   },
    "outputs": [
     {
      "name": "stderr",
@@ -390,17 +427,15 @@
    "execution_count": 7,
    "id": "5f72ca6b-ae9a-4a68-a391-83b065785004",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:50.770869Z",
+     "iopub.status.busy": "2024-08-28T17:27:50.770722Z",
+     "iopub.status.idle": "2024-08-28T17:27:50.888703Z",
+     "shell.execute_reply": "2024-08-28T17:27:50.888387Z"
+    },
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:snowflake.snowpark.modin.plugin.utils.warning_message:Snowpark pandas support for Timedelta is not currently available.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "df[\"length_of_stay\"] = (df[\"outtime\"]-df[\"intime\"])/pd.Timedelta('1 hour')"
    ]
@@ -409,7 +444,14 @@
    "cell_type": "code",
    "execution_count": 8,
    "id": "ecc19928-1d3a-49b8-bc0d-4270e53bfc4c",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:50.890752Z",
+     "iopub.status.busy": "2024-08-28T17:27:50.890619Z",
+     "iopub.status.idle": "2024-08-28T17:27:51.188395Z",
+     "shell.execute_reply": "2024-08-28T17:27:51.188083Z"
+    }
+   },
    "outputs": [],
    "source": [
     "df[\"age\"] = df[\"intime\"].dt.year-df[\"dob\"].dt.year"
@@ -428,6 +470,12 @@
    "execution_count": 9,
    "id": "50c62f3f-a804-4efd-89bb-cf689a870055",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:51.190704Z",
+     "iopub.status.busy": "2024-08-28T17:27:51.190570Z",
+     "iopub.status.idle": "2024-08-28T17:27:51.563926Z",
+     "shell.execute_reply": "2024-08-28T17:27:51.563299Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -450,6 +498,12 @@
    "execution_count": 10,
    "id": "66ac1e04-4581-4292-8b7a-b88faa76edf5",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:51.567168Z",
+     "iopub.status.busy": "2024-08-28T17:27:51.566843Z",
+     "iopub.status.idle": "2024-08-28T17:27:52.325449Z",
+     "shell.execute_reply": "2024-08-28T17:27:52.325162Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -472,7 +526,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -514,6 +568,12 @@
    "execution_count": 11,
    "id": "17b76fe7-4d6d-4eb4-bebe-55cc643b69f3",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:52.327478Z",
+     "iopub.status.busy": "2024-08-28T17:27:52.327310Z",
+     "iopub.status.idle": "2024-08-28T17:27:55.549227Z",
+     "shell.execute_reply": "2024-08-28T17:27:55.548770Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -534,6 +594,12 @@
    "execution_count": 12,
    "id": "8514feca-f6b3-4186-bd32-ef07ba8efed4",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:55.552055Z",
+     "iopub.status.busy": "2024-08-28T17:27:55.551878Z",
+     "iopub.status.idle": "2024-08-28T17:27:55.941773Z",
+     "shell.execute_reply": "2024-08-28T17:27:55.941284Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -546,6 +612,12 @@
    "execution_count": 13,
    "id": "bf8025c3-8657-41a7-8feb-6afab251ccfd",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:55.944225Z",
+     "iopub.status.busy": "2024-08-28T17:27:55.944051Z",
+     "iopub.status.idle": "2024-08-28T17:27:56.081283Z",
+     "shell.execute_reply": "2024-08-28T17:27:56.080891Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -569,6 +641,12 @@
    "execution_count": 14,
    "id": "60ba61f7-fa60-4a6d-8b06-1282d2f64382",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:56.083562Z",
+     "iopub.status.busy": "2024-08-28T17:27:56.083425Z",
+     "iopub.status.idle": "2024-08-28T17:27:56.085148Z",
+     "shell.execute_reply": "2024-08-28T17:27:56.084867Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -582,6 +660,12 @@
    "execution_count": 15,
    "id": "5cdeb9af-660a-4daa-98c5-f9e86699e9bd",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:56.086699Z",
+     "iopub.status.busy": "2024-08-28T17:27:56.086595Z",
+     "iopub.status.idle": "2024-08-28T17:27:57.259523Z",
+     "shell.execute_reply": "2024-08-28T17:27:57.259142Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -619,6 +703,12 @@
    "execution_count": 16,
    "id": "2b704957-4b20-41a9-abbb-1d963a0ea0d2",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:57.261881Z",
+     "iopub.status.busy": "2024-08-28T17:27:57.261730Z",
+     "iopub.status.idle": "2024-08-28T17:27:57.985080Z",
+     "shell.execute_reply": "2024-08-28T17:27:57.984756Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -663,6 +753,12 @@
    "execution_count": 17,
    "id": "1748639f-04b5-45e6-b836-2433b66fa29d",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:57.986888Z",
+     "iopub.status.busy": "2024-08-28T17:27:57.986758Z",
+     "iopub.status.idle": "2024-08-28T17:27:59.498296Z",
+     "shell.execute_reply": "2024-08-28T17:27:59.498013Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -702,6 +798,12 @@
    "execution_count": 18,
    "id": "24a34764-f442-4cc1-8b87-ed96ace34651",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:59.500159Z",
+     "iopub.status.busy": "2024-08-28T17:27:59.500025Z",
+     "iopub.status.idle": "2024-08-28T17:28:00.076867Z",
+     "shell.execute_reply": "2024-08-28T17:28:00.076522Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -731,6 +833,12 @@
    "execution_count": 19,
    "id": "96753257-acd4-4ba9-b81b-19dc0a2af53c",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:00.079097Z",
+     "iopub.status.busy": "2024-08-28T17:28:00.078936Z",
+     "iopub.status.idle": "2024-08-28T17:28:00.081233Z",
+     "shell.execute_reply": "2024-08-28T17:28:00.080958Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -762,6 +870,12 @@
    "execution_count": 20,
    "id": "2d26eee2-671a-4ff8-ac22-62612c1a1ced",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:00.083739Z",
+     "iopub.status.busy": "2024-08-28T17:28:00.083616Z",
+     "iopub.status.idle": "2024-08-28T17:28:00.944153Z",
+     "shell.execute_reply": "2024-08-28T17:28:00.943809Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -801,6 +915,12 @@
    "execution_count": 21,
    "id": "21aef8ae-47d8-4c77-8e04-270304c41d4e",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:00.946550Z",
+     "iopub.status.busy": "2024-08-28T17:28:00.946409Z",
+     "iopub.status.idle": "2024-08-28T17:28:02.622587Z",
+     "shell.execute_reply": "2024-08-28T17:28:02.622199Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -837,6 +957,12 @@
    "execution_count": 22,
    "id": "2d11b951-5b4c-4a98-ae4c-883fbccd56a7",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:02.624633Z",
+     "iopub.status.busy": "2024-08-28T17:28:02.624483Z",
+     "iopub.status.idle": "2024-08-28T17:28:02.933061Z",
+     "shell.execute_reply": "2024-08-28T17:28:02.932626Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -850,6 +976,12 @@
    "execution_count": 23,
    "id": "35155531-c8ff-4ed1-9a3e-e457176f9f20",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:02.935312Z",
+     "iopub.status.busy": "2024-08-28T17:28:02.935204Z",
+     "iopub.status.idle": "2024-08-28T17:28:04.421197Z",
+     "shell.execute_reply": "2024-08-28T17:28:04.420876Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -1006,6 +1138,12 @@
    "execution_count": 24,
    "id": "b8c41494-755a-485b-8119-9dfff98213df",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:04.423275Z",
+     "iopub.status.busy": "2024-08-28T17:28:04.423133Z",
+     "iopub.status.idle": "2024-08-28T17:28:05.150707Z",
+     "shell.execute_reply": "2024-08-28T17:28:05.150379Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -1053,6 +1191,12 @@
    "id": "62d79c9b9a1e3fca",
    "metadata": {
     "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:05.152844Z",
+     "iopub.status.busy": "2024-08-28T17:28:05.152694Z",
+     "iopub.status.idle": "2024-08-28T17:28:07.249455Z",
+     "shell.execute_reply": "2024-08-28T17:28:07.248760Z"
+    },
     "jupyter": {
      "outputs_hidden": false
     }
@@ -1067,6 +1211,12 @@
    "execution_count": 26,
    "id": "719049a4-0a5b-45da-bbd5-8ff073c95a93",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:07.253088Z",
+     "iopub.status.busy": "2024-08-28T17:28:07.252690Z",
+     "iopub.status.idle": "2024-08-28T17:28:07.972094Z",
+     "shell.execute_reply": "2024-08-28T17:28:07.971764Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -1089,6 +1239,12 @@
    "execution_count": 27,
    "id": "9e1f2052-7405-496c-b4de-76e031978cb5",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:07.974120Z",
+     "iopub.status.busy": "2024-08-28T17:28:07.973931Z",
+     "iopub.status.idle": "2024-08-28T17:28:07.979210Z",
+     "shell.execute_reply": "2024-08-28T17:28:07.978966Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -1499,7 +1655,7 @@
        "  /* fitted */\n",
        "  background-color: var(--sklearn-color-fitted-level-3);\n",
        "}\n",
-       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GaussianNB()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;GaussianNB<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.4/modules/generated/sklearn.naive_bayes.GaussianNB.html\">?<span>Documentation for GaussianNB</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>GaussianNB()</pre></div> </div></div></div></div>"
+       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GaussianNB()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;GaussianNB<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.5/modules/generated/sklearn.naive_bayes.GaussianNB.html\">?<span>Documentation for GaussianNB</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>GaussianNB()</pre></div> </div></div></div></div>"
       ],
       "text/plain": [
        "GaussianNB()"
@@ -1521,6 +1677,12 @@
    "execution_count": 28,
    "id": "dcb50a0d-3f66-4376-a383-597789f83fa0",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:07.980853Z",
+     "iopub.status.busy": "2024-08-28T17:28:07.980748Z",
+     "iopub.status.idle": "2024-08-28T17:28:07.983038Z",
+     "shell.execute_reply": "2024-08-28T17:28:07.982709Z"
+    },
     "tags": []
    },
    "outputs": [],
@@ -1541,13 +1703,19 @@
    "execution_count": 29,
    "id": "4993b18c-7d2a-49b6-96f5-b4a7c6a38cc2",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:07.984580Z",
+     "iopub.status.busy": "2024-08-28T17:28:07.984481Z",
+     "iopub.status.idle": "2024-08-28T17:28:08.048040Z",
+     "shell.execute_reply": "2024-08-28T17:28:08.047710Z"
+    },
     "tags": []
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x17da7e430>"
+       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x313e3fe80>"
       ]
      },
      "execution_count": 29,
@@ -1556,7 +1724,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1578,6 +1746,12 @@
    "execution_count": 30,
    "id": "0c6fde6b-1126-4625-9c6e-7223eb97c30b",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:08.049898Z",
+     "iopub.status.busy": "2024-08-28T17:28:08.049780Z",
+     "iopub.status.idle": "2024-08-28T17:28:08.052183Z",
+     "shell.execute_reply": "2024-08-28T17:28:08.051914Z"
+    },
     "tags": []
    },
    "outputs": [
@@ -1655,7 +1829,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
diff --git a/tests/notebooks/modin/SnowflakeChainTesting.ipynb b/tests/notebooks/modin/SnowflakeChainTesting.ipynb
index 0d52f936e12..385437a72a7 100644
--- a/tests/notebooks/modin/SnowflakeChainTesting.ipynb
+++ b/tests/notebooks/modin/SnowflakeChainTesting.ipynb
@@ -8,17 +8,15 @@
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:36.473541Z",
      "start_time": "2024-03-07T18:28:35.266455Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:12.334742Z",
+     "iopub.status.busy": "2024-08-28T17:52:12.334629Z",
+     "iopub.status.idle": "2024-08-28T17:52:13.600342Z",
+     "shell.execute_reply": "2024-08-28T17:52:13.599816Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "UserWarning: Snowpark pandas is currently in Private Preview. See https://docs.snowflake.com/LIMITEDACCESS/snowpark-pandas for details.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pathlib import Path\n",
     "import sys\n",
@@ -41,6 +39,12 @@
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:41.717889Z",
      "start_time": "2024-03-07T18:28:36.475455Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:13.604060Z",
+     "iopub.status.busy": "2024-08-28T17:52:13.603731Z",
+     "iopub.status.idle": "2024-08-28T17:52:17.597094Z",
+     "shell.execute_reply": "2024-08-28T17:52:17.596200Z"
     }
    },
    "outputs": [],
@@ -56,6 +60,12 @@
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:42.579467Z",
      "start_time": "2024-03-07T18:28:41.720668Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:17.601819Z",
+     "iopub.status.busy": "2024-08-28T17:52:17.601431Z",
+     "iopub.status.idle": "2024-08-28T17:52:18.520682Z",
+     "shell.execute_reply": "2024-08-28T17:52:18.520391Z"
     }
    },
    "outputs": [
@@ -95,34 +105,346 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 4,
    "id": "5d9f5d2b",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:57.276309Z",
      "start_time": "2024-03-07T18:28:42.577226Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:18.523427Z",
+     "iopub.status.busy": "2024-08-28T17:52:18.523060Z",
+     "iopub.status.idle": "2024-08-28T17:52:18.941964Z",
+     "shell.execute_reply": "2024-08-28T17:52:18.941577Z"
     }
    },
    "outputs": [
     {
-     "ename": "NotImplementedError",
-     "evalue": "Snowpark pandas dropna API doesn't yet support axis == 1",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[9], line 8\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mchained_one\u001b[39m(df):\n\u001b[1;32m      2\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m (df\n\u001b[1;32m      3\u001b[0m                 \u001b[38;5;241m.\u001b[39mdrop(columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPULOCATIONID\u001b[39m\u001b[38;5;124m'\u001b[39m,\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDOLOCATIONID\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m      4\u001b[0m                 \u001b[38;5;66;03m# dropna(axis=1)\u001b[39;00m\n\u001b[1;32m      5\u001b[0m                 \u001b[38;5;241m.\u001b[39mdropna(axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcolumns\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      6\u001b[0m                )\n\u001b[0;32m----> 8\u001b[0m df_one \u001b[38;5;241m=\u001b[39m \u001b[43mchained_one\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      9\u001b[0m df_one\n",
-      "Cell \u001b[0;32mIn[9], line 2\u001b[0m, in \u001b[0;36mchained_one\u001b[0;34m(df)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mchained_one\u001b[39m(df):\n\u001b[0;32m----> 2\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m (\u001b[43mdf\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[43m                \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdrop\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mPULOCATIONID\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mDOLOCATIONID\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      4\u001b[0m \u001b[43m                \u001b[49m\u001b[38;5;66;43;03m# dropna(axis=1)\u001b[39;49;00m\n\u001b[1;32m      5\u001b[0m \u001b[43m                \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdropna\u001b[49m\u001b[43m(\u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mcolumns\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      6\u001b[0m                )\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/telemetry.py:382\u001b[0m, in \u001b[0;36msnowpark_pandas_telemetry_method_decorator.<locals>.wrap\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    380\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m    381\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrap\u001b[39m(\u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Callable:\n\u001b[0;32m--> 382\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_telemetry_helper\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    383\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    384\u001b[0m \u001b[43m        \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    385\u001b[0m \u001b[43m        \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    386\u001b[0m \u001b[43m        \u001b[49m\u001b[43mis_standalone_function\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    387\u001b[0m \u001b[43m        \u001b[49m\u001b[43mproperty_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproperty_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    388\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/telemetry.py:316\u001b[0m, in \u001b[0;36m_telemetry_helper\u001b[0;34m(func, args, kwargs, is_standalone_function, property_name)\u001b[0m\n\u001b[1;32m    307\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    308\u001b[0m     \u001b[38;5;66;03m# Send Telemetry and Raise Error\u001b[39;00m\n\u001b[1;32m    309\u001b[0m     _send_snowpark_pandas_telemetry_helper(\n\u001b[1;32m    310\u001b[0m         session\u001b[38;5;241m=\u001b[39msession,\n\u001b[1;32m    311\u001b[0m         telemetry_type\u001b[38;5;241m=\u001b[39merror_to_telemetry_type(e),\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    314\u001b[0m         api_calls\u001b[38;5;241m=\u001b[39mexisting_api_calls \u001b[38;5;241m+\u001b[39m [curr_api_call],\n\u001b[1;32m    315\u001b[0m     )\n\u001b[0;32m--> 316\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m e\n\u001b[1;32m    318\u001b[0m \u001b[38;5;66;03m# Not inplace lazy APIs: add curr_api_call to the result\u001b[39;00m\n\u001b[1;32m    319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_snowpark_pandas_dataframe_or_series_type(result):\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/telemetry.py:306\u001b[0m, in \u001b[0;36m_telemetry_helper\u001b[0;34m(func, args, kwargs, is_standalone_function, property_name)\u001b[0m\n\u001b[1;32m    300\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m    301\u001b[0m     \u001b[38;5;66;03m# query_history is a QueryHistory instance which is a Context Managers\u001b[39;00m\n\u001b[1;32m    302\u001b[0m     \u001b[38;5;66;03m# See example in https://github.com/snowflakedb/snowpark-python/blob/main/src/snowflake/snowpark/session.py#L2052\u001b[39;00m\n\u001b[1;32m    303\u001b[0m     \u001b[38;5;66;03m# Use `nullcontext` to handle `session` lacking `query_history` attribute without raising an exception.\u001b[39;00m\n\u001b[1;32m    304\u001b[0m     \u001b[38;5;66;03m# This prevents telemetry from interfering with regular API calls.\u001b[39;00m\n\u001b[1;32m    305\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(session, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mquery_history\u001b[39m\u001b[38;5;124m\"\u001b[39m, nullcontext)() \u001b[38;5;28;01mas\u001b[39;00m query_history:\n\u001b[0;32m--> 306\u001b[0m         result \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    307\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    308\u001b[0m     \u001b[38;5;66;03m# Send Telemetry and Raise Error\u001b[39;00m\n\u001b[1;32m    309\u001b[0m     _send_snowpark_pandas_telemetry_helper(\n\u001b[1;32m    310\u001b[0m         session\u001b[38;5;241m=\u001b[39msession,\n\u001b[1;32m    311\u001b[0m         telemetry_type\u001b[38;5;241m=\u001b[39merror_to_telemetry_type(e),\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    314\u001b[0m         api_calls\u001b[38;5;241m=\u001b[39mexisting_api_calls \u001b[38;5;241m+\u001b[39m [curr_api_call],\n\u001b[1;32m    315\u001b[0m     )\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/pandas/dataframe.py:362\u001b[0m, in \u001b[0;36mDataFrame.dropna\u001b[0;34m(self, axis, how, thresh, subset, inplace)\u001b[0m\n\u001b[1;32m    353\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdropna\u001b[39m(\n\u001b[1;32m    354\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    355\u001b[0m     \u001b[38;5;241m*\u001b[39m,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    360\u001b[0m     inplace: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    361\u001b[0m ):  \u001b[38;5;66;03m# TODO: SNOW-1063346: Modin upgrade - modin.pandas.DataFrame functions\u001b[39;00m\n\u001b[0;32m--> 362\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_dropna\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    363\u001b[0m \u001b[43m        \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhow\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mthresh\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthresh\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msubset\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msubset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minplace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minplace\u001b[49m\n\u001b[1;32m    364\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/pandas/base.py:1481\u001b[0m, in \u001b[0;36mBasePandasDataset._dropna\u001b[0;34m(self, axis, how, thresh, subset, inplace)\u001b[0m\n\u001b[1;32m   1478\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m check\u001b[38;5;241m.\u001b[39many():\n\u001b[1;32m   1479\u001b[0m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[38;5;28mlist\u001b[39m(np\u001b[38;5;241m.\u001b[39mcompress(check, subset)))\n\u001b[0;32m-> 1481\u001b[0m new_query_compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_query_compiler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdropna\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1482\u001b[0m \u001b[43m    \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1483\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhow\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhow\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1484\u001b[0m \u001b[43m    \u001b[49m\u001b[43mthresh\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthresh\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1485\u001b[0m \u001b[43m    \u001b[49m\u001b[43msubset\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msubset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1486\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1487\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_create_or_update_from_compiler(new_query_compiler, inplace)\n",
-      "File \u001b[0;32m~/anaconda3/envs/snowpark-modin-1.15/lib/python3.9/site-packages/modin/logging/logger_decorator.py:125\u001b[0m, in \u001b[0;36menable_logging.<locals>.decorator.<locals>.run_and_log\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    110\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    111\u001b[0m \u001b[38;5;124;03mCompute function with logging if Modin logging is enabled.\u001b[39;00m\n\u001b[1;32m    112\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    122\u001b[0m \u001b[38;5;124;03mAny\u001b[39;00m\n\u001b[1;32m    123\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m LogMode\u001b[38;5;241m.\u001b[39mget() \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisable\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mobj\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    127\u001b[0m logger \u001b[38;5;241m=\u001b[39m get_logger()\n\u001b[1;32m    128\u001b[0m logger\u001b[38;5;241m.\u001b[39mlog(log_level, start_line)\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py:7957\u001b[0m, in \u001b[0;36mSnowflakeQueryCompiler.dropna\u001b[0;34m(self, axis, how, thresh, subset)\u001b[0m\n\u001b[1;32m   7944\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   7945\u001b[0m \u001b[38;5;124;03mRemove missing values. If 'thresh' is specified then the 'how' parameter is ignored.\u001b[39;00m\n\u001b[1;32m   7946\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   7954\u001b[0m \u001b[38;5;124;03mNew QueryCompiler with null values dropped along given axis.\u001b[39;00m\n\u001b[1;32m   7955\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   7956\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m axis \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m-> 7957\u001b[0m     \u001b[43mErrorMessage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnot_implemented\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   7958\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mSnowpark pandas dropna API doesn\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mt yet support axis == 1\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m   7959\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   7961\u001b[0m \u001b[38;5;66;03m# reuse Snowpark Dataframe's dropna API and make sure to define subset correctly, i.e., only contain data\u001b[39;00m\n\u001b[1;32m   7962\u001b[0m \u001b[38;5;66;03m# columns\u001b[39;00m\n\u001b[1;32m   7963\u001b[0m subset_data_col_ids \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m   7964\u001b[0m     \u001b[38;5;28mid\u001b[39m\n\u001b[1;32m   7965\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m label, \u001b[38;5;28mid\u001b[39m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   7969\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m subset \u001b[38;5;129;01mor\u001b[39;00m label \u001b[38;5;129;01min\u001b[39;00m subset\n\u001b[1;32m   7970\u001b[0m ]\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/utils/error_message.py:151\u001b[0m, in \u001b[0;36mErrorMessage.not_implemented\u001b[0;34m(cls, message)\u001b[0m\n\u001b[1;32m    148\u001b[0m \u001b[38;5;129m@classmethod\u001b[39m\n\u001b[1;32m    149\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mnot_implemented\u001b[39m(\u001b[38;5;28mcls\u001b[39m, message: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m NoReturn:  \u001b[38;5;66;03m# pragma: no cover\u001b[39;00m\n\u001b[1;32m    150\u001b[0m     logger\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNotImplementedError: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmessage\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 151\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(message)\n",
-      "\u001b[0;31mNotImplementedError\u001b[0m: Snowpark pandas dropna API doesn't yet support axis == 1"
-     ]
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>VENDORID</th>\n",
+       "      <th>TPEP_PICKUP_DATETIME</th>\n",
+       "      <th>TPEP_DROPOFF_DATETIME</th>\n",
+       "      <th>PASSENGER_COUNT</th>\n",
+       "      <th>TRIP_DISTANCE</th>\n",
+       "      <th>RATECODEID</th>\n",
+       "      <th>STORE_AND_FWD_FLAG</th>\n",
+       "      <th>PAYMENT_TYPE</th>\n",
+       "      <th>FARE_AMOUNT</th>\n",
+       "      <th>EXTRA</th>\n",
+       "      <th>MTA_TAX</th>\n",
+       "      <th>TIP_AMOUNT</th>\n",
+       "      <th>TOLLS_AMOUNT</th>\n",
+       "      <th>IMPROVEMENT_SURCHARGE</th>\n",
+       "      <th>TOTAL_AMOUNT</th>\n",
+       "      <th>CONGESTION_SURCHARGE</th>\n",
+       "      <th>AIRPORT_FEE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 09:39:08</td>\n",
+       "      <td>2015-01-01 09:59:49</td>\n",
+       "      <td>1</td>\n",
+       "      <td>11.89</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>1</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>7.87</td>\n",
+       "      <td>5.33</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>48.00</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 04:01:36</td>\n",
+       "      <td>2015-01-01 04:31:36</td>\n",
+       "      <td>1</td>\n",
+       "      <td>12.58</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>1</td>\n",
+       "      <td>38.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>7.80</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>47.60</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 13:52:20</td>\n",
+       "      <td>2015-01-01 13:58:50</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>1.62</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>8.92</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 12:43:33</td>\n",
+       "      <td>2015-01-01 12:51:45</td>\n",
+       "      <td>5</td>\n",
+       "      <td>2.27</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>1</td>\n",
+       "      <td>9.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>1.90</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>12.20</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 03:36:36</td>\n",
+       "      <td>2015-01-01 03:44:48</td>\n",
+       "      <td>5</td>\n",
+       "      <td>1.76</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>2</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>9.30</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14995</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 11:51:58</td>\n",
+       "      <td>2015-01-01 11:54:39</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>5.30</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14996</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 08:52:40</td>\n",
+       "      <td>2015-01-01 09:01:14</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1.89</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>2</td>\n",
+       "      <td>8.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>9.30</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14997</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2015-01-01 03:25:03</td>\n",
+       "      <td>2015-01-01 03:44:56</td>\n",
+       "      <td>1</td>\n",
+       "      <td>7.50</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>2</td>\n",
+       "      <td>23.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>24.80</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14998</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2015-01-01 03:03:53</td>\n",
+       "      <td>2015-01-01 03:21:27</td>\n",
+       "      <td>2</td>\n",
+       "      <td>7.36</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>1</td>\n",
+       "      <td>22.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>4.60</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>28.40</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14999</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2015-01-01 02:04:06</td>\n",
+       "      <td>2015-01-01 02:14:59</td>\n",
+       "      <td>2</td>\n",
+       "      <td>3.00</td>\n",
+       "      <td>1</td>\n",
+       "      <td>N</td>\n",
+       "      <td>1</td>\n",
+       "      <td>11.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>13.80</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>15000 rows × 17 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       VENDORID TPEP_PICKUP_DATETIME TPEP_DROPOFF_DATETIME  PASSENGER_COUNT  \\\n",
+       "0             2  2015-01-01 09:39:08   2015-01-01 09:59:49                1   \n",
+       "1             2  2015-01-01 04:01:36   2015-01-01 04:31:36                1   \n",
+       "2             2  2015-01-01 13:52:20   2015-01-01 13:58:50                1   \n",
+       "3             2  2015-01-01 12:43:33   2015-01-01 12:51:45                5   \n",
+       "4             2  2015-01-01 03:36:36   2015-01-01 03:44:48                5   \n",
+       "...         ...                  ...                   ...              ...   \n",
+       "14995         2  2015-01-01 11:51:58   2015-01-01 11:54:39                2   \n",
+       "14996         2  2015-01-01 08:52:40   2015-01-01 09:01:14                2   \n",
+       "14997         1  2015-01-01 03:25:03   2015-01-01 03:44:56                1   \n",
+       "14998         2  2015-01-01 03:03:53   2015-01-01 03:21:27                2   \n",
+       "14999         1  2015-01-01 02:04:06   2015-01-01 02:14:59                2   \n",
+       "\n",
+       "       TRIP_DISTANCE  RATECODEID STORE_AND_FWD_FLAG  PAYMENT_TYPE  \\\n",
+       "0              11.89           1                  N             1   \n",
+       "1              12.58           1                  N             1   \n",
+       "2               1.01           1                  N             1   \n",
+       "3               2.27           1                  N             1   \n",
+       "4               1.76           1                  N             2   \n",
+       "...              ...         ...                ...           ...   \n",
+       "14995           0.66           1                  N             1   \n",
+       "14996           1.89           1                  N             2   \n",
+       "14997           7.50           1                  N             2   \n",
+       "14998           7.36           1                  N             1   \n",
+       "14999           3.00           1                  N             1   \n",
+       "\n",
+       "       FARE_AMOUNT  EXTRA  MTA_TAX  TIP_AMOUNT  TOLLS_AMOUNT  \\\n",
+       "0             34.0    0.0      0.5        7.87          5.33   \n",
+       "1             38.5    0.5      0.5        7.80          0.00   \n",
+       "2              6.5    0.0      0.5        1.62          0.00   \n",
+       "3              9.5    0.0      0.5        1.90          0.00   \n",
+       "4              8.0    0.5      0.5        0.00          0.00   \n",
+       "...            ...    ...      ...         ...           ...   \n",
+       "14995          4.5    0.0      0.5        0.00          0.00   \n",
+       "14996          8.5    0.0      0.5        0.00          0.00   \n",
+       "14997         23.5    0.5      0.5        0.00          0.00   \n",
+       "14998         22.5    0.5      0.5        4.60          0.00   \n",
+       "14999         11.5    0.5      0.5        1.00          0.00   \n",
+       "\n",
+       "       IMPROVEMENT_SURCHARGE  TOTAL_AMOUNT  CONGESTION_SURCHARGE  AIRPORT_FEE  \n",
+       "0                        0.3         48.00                   NaN          NaN  \n",
+       "1                        0.3         47.60                   NaN          NaN  \n",
+       "2                        0.3          8.92                   NaN          NaN  \n",
+       "3                        0.3         12.20                   NaN          NaN  \n",
+       "4                        0.3          9.30                   NaN          NaN  \n",
+       "...                      ...           ...                   ...          ...  \n",
+       "14995                    0.3          5.30                   NaN          NaN  \n",
+       "14996                    0.3          9.30                   NaN          NaN  \n",
+       "14997                    0.0         24.80                   NaN          NaN  \n",
+       "14998                    0.3         28.40                   NaN          NaN  \n",
+       "14999                    0.0         13.80                   NaN          NaN  \n",
+       "\n",
+       "[15000 rows x 17 columns]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -139,15 +461,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "07955149",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:57.678995Z",
      "start_time": "2024-03-07T18:28:57.276560Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:18.946285Z",
+     "iopub.status.busy": "2024-08-28T17:52:18.946120Z",
+     "iopub.status.idle": "2024-08-28T17:52:19.544569Z",
+     "shell.execute_reply": "2024-08-28T17:52:19.544031Z"
     }
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:snowflake.snowpark.modin.plugin.utils.warning_message:`to_datetime` implementation has mismatches with pandas:\n",
+      "Snowpark pandas to_datetime uses Snowflake's automatic format detection to convert string to datetime when a format is not provided. In this case Snowflake's auto format may yield different result values compared to pandas..\n"
+     ]
+    },
     {
      "name": "stderr",
      "output_type": "stream",
@@ -204,7 +540,7 @@
        "      <td>1</td>\n",
        "      <td>0.24</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>3.0</td>\n",
        "      <td>0.5</td>\n",
@@ -213,8 +549,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.3</td>\n",
        "      <td>4.30</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>822</th>\n",
@@ -224,7 +560,7 @@
        "      <td>1</td>\n",
        "      <td>0.80</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>7.5</td>\n",
        "      <td>0.5</td>\n",
@@ -233,8 +569,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>8.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>10330</th>\n",
@@ -244,7 +580,7 @@
        "      <td>2</td>\n",
        "      <td>3.65</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>14.0</td>\n",
        "      <td>0.5</td>\n",
@@ -253,8 +589,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.3</td>\n",
        "      <td>18.92</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2282</th>\n",
@@ -264,7 +600,7 @@
        "      <td>2</td>\n",
        "      <td>1.10</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>7.5</td>\n",
        "      <td>0.5</td>\n",
@@ -273,8 +609,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>9.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>11184</th>\n",
@@ -284,7 +620,7 @@
        "      <td>4</td>\n",
        "      <td>0.90</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>5.0</td>\n",
        "      <td>0.5</td>\n",
@@ -293,8 +629,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>7.55</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
@@ -324,7 +660,7 @@
        "      <td>1</td>\n",
        "      <td>1.50</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>8.0</td>\n",
        "      <td>0.0</td>\n",
@@ -333,8 +669,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>8.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>331</th>\n",
@@ -344,7 +680,7 @@
        "      <td>1</td>\n",
        "      <td>1.10</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>6.5</td>\n",
        "      <td>0.0</td>\n",
@@ -353,8 +689,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>8.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>10685</th>\n",
@@ -364,7 +700,7 @@
        "      <td>3</td>\n",
        "      <td>2.90</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>11.0</td>\n",
        "      <td>0.0</td>\n",
@@ -373,8 +709,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>11.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>12300</th>\n",
@@ -384,7 +720,7 @@
        "      <td>2</td>\n",
        "      <td>3.38</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>12.0</td>\n",
        "      <td>0.0</td>\n",
@@ -393,8 +729,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.3</td>\n",
        "      <td>14.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9211</th>\n",
@@ -404,7 +740,7 @@
        "      <td>1</td>\n",
        "      <td>1.40</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>6.5</td>\n",
        "      <td>0.0</td>\n",
@@ -413,8 +749,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>7.30</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -435,18 +771,18 @@
        "12300         2  2015-01-01 14:59:48   2015-01-01 15:09:37                2   \n",
        "9211          1  2015-01-01 14:59:55   2015-01-01 15:06:01                1   \n",
        "\n",
-       "       TRIP_DISTANCE  RATECODEID  STORE_AND_FWD_FLAG  PAYMENT_TYPE  \\\n",
-       "10799           0.24           1               False             2   \n",
-       "822             0.80           1               False             2   \n",
-       "10330           3.65           1               False             1   \n",
-       "2282            1.10           1               False             1   \n",
-       "11184           0.90           1               False             1   \n",
-       "...              ...         ...                 ...           ...   \n",
-       "9483            1.50           1               False             2   \n",
-       "331             1.10           1               False             1   \n",
-       "10685           2.90           1               False             2   \n",
-       "12300           3.38           1               False             1   \n",
-       "9211            1.40           1               False             2   \n",
+       "       TRIP_DISTANCE  RATECODEID STORE_AND_FWD_FLAG  PAYMENT_TYPE  \\\n",
+       "10799           0.24           1                  N             2   \n",
+       "822             0.80           1                  N             2   \n",
+       "10330           3.65           1                  N             1   \n",
+       "2282            1.10           1                  N             1   \n",
+       "11184           0.90           1                  N             1   \n",
+       "...              ...         ...                ...           ...   \n",
+       "9483            1.50           1                  N             2   \n",
+       "331             1.10           1                  N             1   \n",
+       "10685           2.90           1                  N             2   \n",
+       "12300           3.38           1                  N             1   \n",
+       "9211            1.40           1                  N             2   \n",
        "\n",
        "       FARE_AMOUNT  EXTRA  MTA_TAX  TIP_AMOUNT  TOLLS_AMOUNT  \\\n",
        "10799          3.0    0.5      0.5        0.00           0.0   \n",
@@ -461,23 +797,23 @@
        "12300         12.0    0.0      0.5        2.00           0.0   \n",
        "9211           6.5    0.0      0.5        0.00           0.0   \n",
        "\n",
-       "       IMPROVEMENT_SURCHARGE  TOTAL_AMOUNT CONGESTION_SURCHARGE AIRPORT_FEE  \n",
-       "10799                    0.3          4.30                 None        None  \n",
-       "822                      0.0          8.80                 None        None  \n",
-       "10330                    0.3         18.92                 None        None  \n",
-       "2282                     0.0          9.80                 None        None  \n",
-       "11184                    0.0          7.55                 None        None  \n",
-       "...                      ...           ...                  ...         ...  \n",
-       "9483                     0.0          8.80                 None        None  \n",
-       "331                      0.0          8.80                 None        None  \n",
-       "10685                    0.0         11.80                 None        None  \n",
-       "12300                    0.3         14.80                 None        None  \n",
-       "9211                     0.0          7.30                 None        None  \n",
+       "       IMPROVEMENT_SURCHARGE  TOTAL_AMOUNT  CONGESTION_SURCHARGE  AIRPORT_FEE  \n",
+       "10799                    0.3          4.30                   NaN          NaN  \n",
+       "822                      0.0          8.80                   NaN          NaN  \n",
+       "10330                    0.3         18.92                   NaN          NaN  \n",
+       "2282                     0.0          9.80                   NaN          NaN  \n",
+       "11184                    0.0          7.55                   NaN          NaN  \n",
+       "...                      ...           ...                   ...          ...  \n",
+       "9483                     0.0          8.80                   NaN          NaN  \n",
+       "331                      0.0          8.80                   NaN          NaN  \n",
+       "10685                    0.0         11.80                   NaN          NaN  \n",
+       "12300                    0.3         14.80                   NaN          NaN  \n",
+       "9211                     0.0          7.30                   NaN          NaN  \n",
        "\n",
        "[15000 rows x 17 columns]"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -490,12 +826,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "fe08e4c0",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:57.906565Z",
      "start_time": "2024-03-07T18:28:57.681687Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:19.551182Z",
+     "iopub.status.busy": "2024-08-28T17:52:19.550955Z",
+     "iopub.status.idle": "2024-08-28T17:52:20.055900Z",
+     "shell.execute_reply": "2024-08-28T17:52:20.055329Z"
     }
    },
    "outputs": [
@@ -555,7 +897,7 @@
        "      <td>1</td>\n",
        "      <td>0.24</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>3.0</td>\n",
        "      <td>0.5</td>\n",
@@ -564,8 +906,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.3</td>\n",
        "      <td>4.30</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>822</th>\n",
@@ -575,7 +917,7 @@
        "      <td>1</td>\n",
        "      <td>0.80</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>7.5</td>\n",
        "      <td>0.5</td>\n",
@@ -584,8 +926,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>8.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>10330</th>\n",
@@ -595,7 +937,7 @@
        "      <td>2</td>\n",
        "      <td>3.65</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>14.0</td>\n",
        "      <td>0.5</td>\n",
@@ -604,8 +946,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.3</td>\n",
        "      <td>18.92</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2282</th>\n",
@@ -615,7 +957,7 @@
        "      <td>2</td>\n",
        "      <td>1.10</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>7.5</td>\n",
        "      <td>0.5</td>\n",
@@ -624,8 +966,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>9.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>11184</th>\n",
@@ -635,7 +977,7 @@
        "      <td>4</td>\n",
        "      <td>0.90</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>5.0</td>\n",
        "      <td>0.5</td>\n",
@@ -644,8 +986,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>7.55</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
@@ -675,7 +1017,7 @@
        "      <td>1</td>\n",
        "      <td>1.50</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>8.0</td>\n",
        "      <td>0.0</td>\n",
@@ -684,8 +1026,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>8.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>331</th>\n",
@@ -695,7 +1037,7 @@
        "      <td>1</td>\n",
        "      <td>1.10</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>6.5</td>\n",
        "      <td>0.0</td>\n",
@@ -704,8 +1046,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>8.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>10685</th>\n",
@@ -715,7 +1057,7 @@
        "      <td>3</td>\n",
        "      <td>2.90</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>11.0</td>\n",
        "      <td>0.0</td>\n",
@@ -724,8 +1066,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>11.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>12300</th>\n",
@@ -735,7 +1077,7 @@
        "      <td>2</td>\n",
        "      <td>3.38</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>1</td>\n",
        "      <td>12.0</td>\n",
        "      <td>0.0</td>\n",
@@ -744,8 +1086,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.3</td>\n",
        "      <td>14.80</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9211</th>\n",
@@ -755,7 +1097,7 @@
        "      <td>1</td>\n",
        "      <td>1.40</td>\n",
        "      <td>1</td>\n",
-       "      <td>False</td>\n",
+       "      <td>N</td>\n",
        "      <td>2</td>\n",
        "      <td>6.5</td>\n",
        "      <td>0.0</td>\n",
@@ -764,8 +1106,8 @@
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "      <td>7.30</td>\n",
-       "      <td>None</td>\n",
-       "      <td>None</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -786,18 +1128,18 @@
        "12300         2  2015-01-01 14:59:48   2015-01-01 15:09:37                2   \n",
        "9211          1  2015-01-01 14:59:55   2015-01-01 15:06:01                1   \n",
        "\n",
-       "       TRIP_DISTANCE  RATECODEID  STORE_AND_FWD_FLAG  PAYMENT_TYPE  \\\n",
-       "10799           0.24           1               False             2   \n",
-       "822             0.80           1               False             2   \n",
-       "10330           3.65           1               False             1   \n",
-       "2282            1.10           1               False             1   \n",
-       "11184           0.90           1               False             1   \n",
-       "...              ...         ...                 ...           ...   \n",
-       "9483            1.50           1               False             2   \n",
-       "331             1.10           1               False             1   \n",
-       "10685           2.90           1               False             2   \n",
-       "12300           3.38           1               False             1   \n",
-       "9211            1.40           1               False             2   \n",
+       "       TRIP_DISTANCE  RATECODEID STORE_AND_FWD_FLAG  PAYMENT_TYPE  \\\n",
+       "10799           0.24           1                  N             2   \n",
+       "822             0.80           1                  N             2   \n",
+       "10330           3.65           1                  N             1   \n",
+       "2282            1.10           1                  N             1   \n",
+       "11184           0.90           1                  N             1   \n",
+       "...              ...         ...                ...           ...   \n",
+       "9483            1.50           1                  N             2   \n",
+       "331             1.10           1                  N             1   \n",
+       "10685           2.90           1                  N             2   \n",
+       "12300           3.38           1                  N             1   \n",
+       "9211            1.40           1                  N             2   \n",
        "\n",
        "       FARE_AMOUNT  EXTRA  MTA_TAX  TIP_AMOUNT  TOLLS_AMOUNT  \\\n",
        "10799          3.0    0.5      0.5        0.00           0.0   \n",
@@ -812,23 +1154,23 @@
        "12300         12.0    0.0      0.5        2.00           0.0   \n",
        "9211           6.5    0.0      0.5        0.00           0.0   \n",
        "\n",
-       "       IMPROVEMENT_SURCHARGE  TOTAL_AMOUNT CONGESTION_SURCHARGE AIRPORT_FEE  \n",
-       "10799                    0.3          4.30                 None        None  \n",
-       "822                      0.0          8.80                 None        None  \n",
-       "10330                    0.3         18.92                 None        None  \n",
-       "2282                     0.0          9.80                 None        None  \n",
-       "11184                    0.0          7.55                 None        None  \n",
-       "...                      ...           ...                  ...         ...  \n",
-       "9483                     0.0          8.80                 None        None  \n",
-       "331                      0.0          8.80                 None        None  \n",
-       "10685                    0.0         11.80                 None        None  \n",
-       "12300                    0.3         14.80                 None        None  \n",
-       "9211                     0.0          7.30                 None        None  \n",
+       "       IMPROVEMENT_SURCHARGE  TOTAL_AMOUNT  CONGESTION_SURCHARGE  AIRPORT_FEE  \n",
+       "10799                    0.3          4.30                   NaN          NaN  \n",
+       "822                      0.0          8.80                   NaN          NaN  \n",
+       "10330                    0.3         18.92                   NaN          NaN  \n",
+       "2282                     0.0          9.80                   NaN          NaN  \n",
+       "11184                    0.0          7.55                   NaN          NaN  \n",
+       "...                      ...           ...                   ...          ...  \n",
+       "9483                     0.0          8.80                   NaN          NaN  \n",
+       "331                      0.0          8.80                   NaN          NaN  \n",
+       "10685                    0.0         11.80                   NaN          NaN  \n",
+       "12300                    0.3         14.80                   NaN          NaN  \n",
+       "9211                     0.0          7.30                   NaN          NaN  \n",
        "\n",
        "[15000 rows x 17 columns]"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -845,12 +1187,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "id": "afef5a5c",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:58.433517Z",
      "start_time": "2024-03-07T18:28:57.910033Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:20.062655Z",
+     "iopub.status.busy": "2024-08-28T17:52:20.062443Z",
+     "iopub.status.idle": "2024-08-28T17:52:20.696390Z",
+     "shell.execute_reply": "2024-08-28T17:52:20.695770Z"
     }
    },
    "outputs": [
@@ -987,7 +1335,7 @@
        "6    1.462722      0.186825     15.231608  "
       ]
      },
-     "execution_count": 8,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1008,12 +1356,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "bf04ee9b",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:58.441220Z",
      "start_time": "2024-03-07T18:28:58.432402Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:20.700371Z",
+     "iopub.status.busy": "2024-08-28T17:52:20.700144Z",
+     "iopub.status.idle": "2024-08-28T17:52:20.702635Z",
+     "shell.execute_reply": "2024-08-28T17:52:20.702103Z"
     }
    },
    "outputs": [],
@@ -1026,12 +1380,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "7ca17eab",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:58.441415Z",
      "start_time": "2024-03-07T18:28:58.436132Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:20.705816Z",
+     "iopub.status.busy": "2024-08-28T17:52:20.705608Z",
+     "iopub.status.idle": "2024-08-28T17:52:20.707897Z",
+     "shell.execute_reply": "2024-08-28T17:52:20.707518Z"
     }
    },
    "outputs": [],
@@ -1042,12 +1402,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "44f84dc4",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-03-07T18:28:58.442175Z",
      "start_time": "2024-03-07T18:28:58.439190Z"
+    },
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:52:20.710120Z",
+     "iopub.status.busy": "2024-08-28T17:52:20.709950Z",
+     "iopub.status.idle": "2024-08-28T17:52:20.711901Z",
+     "shell.execute_reply": "2024-08-28T17:52:20.711557Z"
     }
    },
    "outputs": [],
@@ -1072,7 +1438,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.19"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
diff --git a/tests/notebooks/modin/SnowparkPandasAPIDemo.ipynb b/tests/notebooks/modin/SnowparkPandasAPIDemo.ipynb
index 9ed6a5d4eb4..4a3506e0b79 100644
--- a/tests/notebooks/modin/SnowparkPandasAPIDemo.ipynb
+++ b/tests/notebooks/modin/SnowparkPandasAPIDemo.ipynb
@@ -18,16 +18,15 @@
    "cell_type": "code",
    "execution_count": 1,
    "id": "d9388c10-9876-47a2-82a6-da35d120ff77",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "UserWarning: Snowpark pandas is currently in Private Preview. See https://docs.snowflake.com/LIMITEDACCESS/snowpark-pandas for details.\n"
-     ]
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:35:29.956189Z",
+     "iopub.status.busy": "2024-08-28T17:35:29.956006Z",
+     "iopub.status.idle": "2024-08-28T17:35:31.117161Z",
+     "shell.execute_reply": "2024-08-28T17:35:31.116614Z"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "import modin.pandas as spd\n",
     "import snowflake.snowpark.modin.plugin\n",
@@ -57,13 +56,27 @@
    "cell_type": "code",
    "execution_count": 2,
    "id": "03298234-aabe-4548-99b1-bfdb609bdafb",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:35:31.121238Z",
+     "iopub.status.busy": "2024-08-28T17:35:31.120973Z",
+     "iopub.status.idle": "2024-08-28T17:35:37.029284Z",
+     "shell.execute_reply": "2024-08-28T17:35:37.028960Z"
+    }
+   },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Data from source table/view 'FINANCIAL__ECONOMIC_ESSENTIALS.CYBERSYN.STOCK_PRICE_TIMESERIES' is being copied into a new temporary table 'SNOWPARK_TEMP_TABLE_515SJ7V1X4'. DataFrame creation might take some time.\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Took 9.748766167000001 seconds to read a table with 66061030 rows into Snowpark pandas!\n"
+      "Took 5.6064697500000005 seconds to read a table with 69641010 rows into Snowpark pandas!\n"
      ]
     }
    ],
@@ -80,12 +93,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "b69ac2fd-c636-4bb5-a27d-58a5e4cbea7e",
    "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:35:37.031526Z",
+     "iopub.status.busy": "2024-08-28T17:35:37.031368Z",
+     "iopub.status.idle": "2024-08-28T17:42:00.344511Z",
+     "shell.execute_reply": "2024-08-28T17:42:00.344196Z"
+    },
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Native pandas took 383.31552045800004 seconds to read the data!\n"
+     ]
+    }
+   ],
    "source": [
     "# Read data into a local native pandas df - recommended to kill this cell after waiting a few minutes!\n",
     "\n",
@@ -124,9 +151,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 4,
    "id": "1a623bed-aed9-4cdb-a3c8-33e9e7da52af",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:00.346273Z",
+     "iopub.status.busy": "2024-08-28T17:42:00.346155Z",
+     "iopub.status.idle": "2024-08-28T17:42:02.046901Z",
+     "shell.execute_reply": "2024-08-28T17:42:02.046061Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -162,58 +196,58 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>INDF</td>\n",
-       "      <td>ETF-Index Fund Shares</td>\n",
-       "      <td>PSE</td>\n",
-       "      <td>NYSE ARCA</td>\n",
+       "      <td>LNG</td>\n",
+       "      <td>Equity</td>\n",
+       "      <td>NYS</td>\n",
+       "      <td>NEW YORK STOCK EXCHANGE</td>\n",
        "      <td>pre-market_open</td>\n",
        "      <td>Pre-Market Open</td>\n",
-       "      <td>2024-05-08</td>\n",
-       "      <td>35.965</td>\n",
+       "      <td>2021-03-15</td>\n",
+       "      <td>75.15</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>ATLC</td>\n",
+       "      <td>PNC</td>\n",
        "      <td>Equity</td>\n",
-       "      <td>NAS</td>\n",
-       "      <td>NASDAQ CAPITAL MARKET</td>\n",
-       "      <td>pre-market_open</td>\n",
-       "      <td>Pre-Market Open</td>\n",
-       "      <td>2024-05-08</td>\n",
-       "      <td>27.670</td>\n",
+       "      <td>NYS</td>\n",
+       "      <td>NEW YORK STOCK EXCHANGE</td>\n",
+       "      <td>nasdaq_volume</td>\n",
+       "      <td>Nasdaq Volume</td>\n",
+       "      <td>2018-07-19</td>\n",
+       "      <td>369981.00</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>AAPR</td>\n",
+       "      <td>VNQI</td>\n",
        "      <td>ETF-Index Fund Shares</td>\n",
-       "      <td>BAT</td>\n",
-       "      <td>BATS Z-EXCHANGE</td>\n",
-       "      <td>pre-market_open</td>\n",
-       "      <td>Pre-Market Open</td>\n",
-       "      <td>2024-05-08</td>\n",
-       "      <td>24.650</td>\n",
+       "      <td>NAS</td>\n",
+       "      <td>NASDAQ CAPITAL MARKET</td>\n",
+       "      <td>all-day_high</td>\n",
+       "      <td>All-Day High</td>\n",
+       "      <td>2022-02-02</td>\n",
+       "      <td>53.19</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>TEL</td>\n",
+       "      <td>FLNG</td>\n",
        "      <td>Equity</td>\n",
        "      <td>NYS</td>\n",
        "      <td>NEW YORK STOCK EXCHANGE</td>\n",
-       "      <td>pre-market_open</td>\n",
-       "      <td>Pre-Market Open</td>\n",
-       "      <td>2024-05-08</td>\n",
-       "      <td>142.600</td>\n",
+       "      <td>nasdaq_volume</td>\n",
+       "      <td>Nasdaq Volume</td>\n",
+       "      <td>2021-08-12</td>\n",
+       "      <td>1068.00</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>CYTH</td>\n",
+       "      <td>AGX</td>\n",
        "      <td>Equity</td>\n",
-       "      <td>NAS</td>\n",
-       "      <td>NASDAQ CAPITAL MARKET</td>\n",
-       "      <td>pre-market_open</td>\n",
-       "      <td>Pre-Market Open</td>\n",
-       "      <td>2024-05-08</td>\n",
-       "      <td>1.530</td>\n",
+       "      <td>NYS</td>\n",
+       "      <td>NEW YORK STOCK EXCHANGE</td>\n",
+       "      <td>nasdaq_volume</td>\n",
+       "      <td>Nasdaq Volume</td>\n",
+       "      <td>2021-04-29</td>\n",
+       "      <td>8047.00</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -221,28 +255,28 @@
       ],
       "text/plain": [
        "  TICKER            ASSET_CLASS PRIMARY_EXCHANGE_CODE  \\\n",
-       "0   INDF  ETF-Index Fund Shares                   PSE   \n",
-       "1   ATLC                 Equity                   NAS   \n",
-       "2   AAPR  ETF-Index Fund Shares                   BAT   \n",
-       "3    TEL                 Equity                   NYS   \n",
-       "4   CYTH                 Equity                   NAS   \n",
+       "0    LNG                 Equity                   NYS   \n",
+       "1    PNC                 Equity                   NYS   \n",
+       "2   VNQI  ETF-Index Fund Shares                   NAS   \n",
+       "3   FLNG                 Equity                   NYS   \n",
+       "4    AGX                 Equity                   NYS   \n",
        "\n",
        "     PRIMARY_EXCHANGE_NAME         VARIABLE    VARIABLE_NAME        DATE  \\\n",
-       "0                NYSE ARCA  pre-market_open  Pre-Market Open  2024-05-08   \n",
-       "1    NASDAQ CAPITAL MARKET  pre-market_open  Pre-Market Open  2024-05-08   \n",
-       "2          BATS Z-EXCHANGE  pre-market_open  Pre-Market Open  2024-05-08   \n",
-       "3  NEW YORK STOCK EXCHANGE  pre-market_open  Pre-Market Open  2024-05-08   \n",
-       "4    NASDAQ CAPITAL MARKET  pre-market_open  Pre-Market Open  2024-05-08   \n",
+       "0  NEW YORK STOCK EXCHANGE  pre-market_open  Pre-Market Open  2021-03-15   \n",
+       "1  NEW YORK STOCK EXCHANGE    nasdaq_volume    Nasdaq Volume  2018-07-19   \n",
+       "2    NASDAQ CAPITAL MARKET     all-day_high     All-Day High  2022-02-02   \n",
+       "3  NEW YORK STOCK EXCHANGE    nasdaq_volume    Nasdaq Volume  2021-08-12   \n",
+       "4  NEW YORK STOCK EXCHANGE    nasdaq_volume    Nasdaq Volume  2021-04-29   \n",
        "\n",
-       "     VALUE  \n",
-       "0   35.965  \n",
-       "1   27.670  \n",
-       "2   24.650  \n",
-       "3  142.600  \n",
-       "4    1.530  "
+       "       VALUE  \n",
+       "0      75.15  \n",
+       "1  369981.00  \n",
+       "2      53.19  \n",
+       "3    1068.00  \n",
+       "4    8047.00  "
       ]
      },
-     "execution_count": 14,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -264,13 +298,20 @@
    "cell_type": "code",
    "execution_count": 5,
    "id": "4218fceb-68f1-41be-8c08-3f6ad51424d5",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:02.052365Z",
+     "iopub.status.busy": "2024-08-28T17:42:02.052087Z",
+     "iopub.status.idle": "2024-08-28T17:42:03.213745Z",
+     "shell.execute_reply": "2024-08-28T17:42:03.213064Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Filtering for stocks belonging to the NYSE took 1.480584958999998 seconds in Snowpark pandas\n"
+      "Filtering for stocks belonging to the NYSE took 1.1570580000000064 seconds in Snowpark pandas\n"
      ]
     }
    ],
@@ -297,13 +338,20 @@
    "cell_type": "code",
    "execution_count": 6,
    "id": "5d456c29-7689-4599-bcd6-02c646ef8f58",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:03.218253Z",
+     "iopub.status.busy": "2024-08-28T17:42:03.217966Z",
+     "iopub.status.idle": "2024-08-28T17:42:04.219058Z",
+     "shell.execute_reply": "2024-08-28T17:42:04.218450Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Filtering for the Pre-Market Open price for the above stocks took 1.0095136250000678 seconds in Snowpark pandas\n"
+      "Filtering for the Pre-Market Open price for the above stocks took 0.9963804170000117 seconds in Snowpark pandas\n"
      ]
     }
    ],
@@ -328,13 +376,20 @@
    "cell_type": "code",
    "execution_count": 7,
    "id": "2f8f893a-c7dc-4e08-bace-3c93ada282cf",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:04.221691Z",
+     "iopub.status.busy": "2024-08-28T17:42:04.221503Z",
+     "iopub.status.idle": "2024-08-28T17:42:08.104300Z",
+     "shell.execute_reply": "2024-08-28T17:42:08.103522Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pivoting the DataFrame took 4.195186291000027 seconds in Snowpark pandas\n"
+      "Pivoting the DataFrame took 3.878563791999966 seconds in Snowpark pandas\n"
      ]
     }
    ],
@@ -350,7 +405,14 @@
    "cell_type": "code",
    "execution_count": 8,
    "id": "65c0b9d1-a3be-4d05-9481-f54628f3b793",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:08.108598Z",
+     "iopub.status.busy": "2024-08-28T17:42:08.108313Z",
+     "iopub.status.idle": "2024-08-28T17:42:11.589114Z",
+     "shell.execute_reply": "2024-08-28T17:42:11.588214Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -476,13 +538,20 @@
    "cell_type": "code",
    "execution_count": 9,
    "id": "5b06f23b-12dc-4387-bb87-bc4cbcff6a85",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:11.594268Z",
+     "iopub.status.busy": "2024-08-28T17:42:11.593913Z",
+     "iopub.status.idle": "2024-08-28T17:42:13.693659Z",
+     "shell.execute_reply": "2024-08-28T17:42:13.692959Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Resampling the DataFrame took 2.099826750000034 seconds in Snowpark pandas\n"
+      "Resampling the DataFrame took 2.095007124999995 seconds in Snowpark pandas\n"
      ]
     }
    ],
@@ -498,7 +567,14 @@
    "cell_type": "code",
    "execution_count": 10,
    "id": "8978f55a-c28a-4b7f-9f20-4a2952d2a857",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:13.698712Z",
+     "iopub.status.busy": "2024-08-28T17:42:13.698431Z",
+     "iopub.status.idle": "2024-08-28T17:42:14.012750Z",
+     "shell.execute_reply": "2024-08-28T17:42:14.011861Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -529,6 +605,7 @@
        "2023-10-24     121.47\n",
        "2024-01-23     131.54\n",
        "2024-04-23     152.77\n",
+       "2024-07-23     156.60\n",
        "Freq: None, Name: All-Day Low, dtype: float64"
       ]
      },
@@ -553,13 +630,20 @@
    "cell_type": "code",
    "execution_count": 11,
    "id": "fb467dd6-cc74-423f-b17b-46541f5bbff8",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:14.018887Z",
+     "iopub.status.busy": "2024-08-28T17:42:14.018476Z",
+     "iopub.status.idle": "2024-08-28T17:42:14.867704Z",
+     "shell.execute_reply": "2024-08-28T17:42:14.866925Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Diffing the resampled data took 0.6961409589999903 seconds in Snowpark pandas\n"
+      "Diffing the resampled data took 0.8439803329999904 seconds in Snowpark pandas\n"
      ]
     }
    ],
@@ -575,7 +659,14 @@
    "cell_type": "code",
    "execution_count": 12,
    "id": "866628d5-5bf9-4212-bba2-bf5e816a70e1",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:14.872878Z",
+     "iopub.status.busy": "2024-08-28T17:42:14.872544Z",
+     "iopub.status.idle": "2024-08-28T17:42:15.255755Z",
+     "shell.execute_reply": "2024-08-28T17:42:15.254822Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -606,6 +697,7 @@
        "2023-10-24      -0.07\n",
        "2024-01-23      10.07\n",
        "2024-04-23      21.23\n",
+       "2024-07-23       3.83\n",
        "Freq: None, Name: All-Day Low, dtype: float64"
       ]
      },
@@ -622,7 +714,14 @@
    "cell_type": "code",
    "execution_count": 13,
    "id": "a7593697-feb5-40a7-9d6c-7c011ad35186",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:42:15.261056Z",
+     "iopub.status.busy": "2024-08-28T17:42:15.260483Z",
+     "iopub.status.idle": "2024-08-28T17:42:15.265793Z",
+     "shell.execute_reply": "2024-08-28T17:42:15.265216Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -668,7 +767,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.19"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
diff --git a/tests/notebooks/modin/TimeSeriesTesting.ipynb b/tests/notebooks/modin/TimeSeriesTesting.ipynb
index 0460b46a370..b21dc046b66 100644
--- a/tests/notebooks/modin/TimeSeriesTesting.ipynb
+++ b/tests/notebooks/modin/TimeSeriesTesting.ipynb
@@ -10,9 +10,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 1,
    "id": "5ece8277-dc52-40f3-913f-1a3145df6bdc",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:35.535408Z",
+     "iopub.status.busy": "2024-08-28T17:27:35.535052Z",
+     "iopub.status.idle": "2024-08-28T17:27:36.951326Z",
+     "shell.execute_reply": "2024-08-28T17:27:36.950877Z"
+    }
+   },
    "outputs": [],
    "source": [
     "from pathlib import Path\n",
@@ -30,9 +37,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 2,
    "id": "c127fb50-c570-46fb-a074-6e8eb3ede058",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:36.953723Z",
+     "iopub.status.busy": "2024-08-28T17:27:36.953532Z",
+     "iopub.status.idle": "2024-08-28T17:27:36.955730Z",
+     "shell.execute_reply": "2024-08-28T17:27:36.955323Z"
+    }
+   },
    "outputs": [],
    "source": [
     "import datetime\n",
@@ -49,17 +63,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 3,
    "id": "8d5f4a0a-fe5c-4a94-94ba-f16d258f92a6",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:36.958090Z",
+     "iopub.status.busy": "2024-08-28T17:27:36.957962Z",
+     "iopub.status.idle": "2024-08-28T17:27:37.441073Z",
+     "shell.execute_reply": "2024-08-28T17:27:37.440761Z"
+    }
+   },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`to_datetime` implementation has mismatches with pandas:\n",
+      "Snowpark pandas to_datetime uses Snowflake's automatic format detection to convert string to datetime when a format is not provided. In this case Snowflake's auto format may yield different result values compared to pandas..\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
        "DatetimeIndex(['2018-01-01', '2018-01-01', '2018-01-01'], dtype='datetime64[ns]', freq=None)"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -81,31 +110,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "28d01637-1093-43ea-a791-bc167243530e",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:37.443821Z",
+     "iopub.status.busy": "2024-08-28T17:27:37.443686Z",
+     "iopub.status.idle": "2024-08-28T17:27:37.973506Z",
+     "shell.execute_reply": "2024-08-28T17:27:37.973040Z"
+    }
+   },
    "outputs": [
     {
-     "ename": "SnowparkSessionException",
-     "evalue": "(1409): More than one active session is detected. When you call function 'udf' or use decorator '@udf', you must specify the 'session' parameter if you created multiple sessions.Alternatively, you can use 'session.udf.register' to register UDFs",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mSnowparkSessionException\u001b[0m                  Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[16], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m dti \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdate_range\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m2018-01-01\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mh\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      2\u001b[0m dti\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/telemetry.py:454\u001b[0m, in \u001b[0;36msnowpark_pandas_telemetry_standalone_function_decorator.<locals>.wrap\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    447\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m    448\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrap\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):  \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[1;32m    449\u001b[0m     \u001b[38;5;66;03m# add a `type: ignore` for this function definition because the\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    452\u001b[0m     \u001b[38;5;66;03m# hints in-line here. We'll fix up the type with a `cast` before\u001b[39;00m\n\u001b[1;32m    453\u001b[0m     \u001b[38;5;66;03m# returning the function.\u001b[39;00m\n\u001b[0;32m--> 454\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_telemetry_helper\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    455\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    456\u001b[0m \u001b[43m        \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    457\u001b[0m \u001b[43m        \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    458\u001b[0m \u001b[43m        \u001b[49m\u001b[43mis_standalone_function\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    459\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/telemetry.py:283\u001b[0m, in \u001b[0;36m_telemetry_helper\u001b[0;34m(func, args, kwargs, is_standalone_function, property_name, property_method_type)\u001b[0m\n\u001b[1;32m    281\u001b[0m         session \u001b[38;5;241m=\u001b[39m snowflake\u001b[38;5;241m.\u001b[39msnowpark\u001b[38;5;241m.\u001b[39msession\u001b[38;5;241m.\u001b[39m_get_active_session()\n\u001b[1;32m    282\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m SnowparkSessionException:\n\u001b[0;32m--> 283\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_run_func_helper\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    284\u001b[0m     class_prefix \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m    285\u001b[0m         func\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__module__\u001b[39m\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m)[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m    286\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m is_standalone_function\n\u001b[1;32m    287\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m args[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\n\u001b[1;32m    288\u001b[0m     )\n\u001b[1;32m    289\u001b[0m \u001b[38;5;66;03m# Else the decorated func is an instance method:\u001b[39;00m\n\u001b[1;32m    290\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/telemetry.py:182\u001b[0m, in \u001b[0;36m_run_func_helper\u001b[0;34m(func, args, kwargs)\u001b[0m\n\u001b[1;32m    177\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    178\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    179\u001b[0m     \u001b[38;5;66;03m# Raise error caused by func, i.e. the api call\u001b[39;00m\n\u001b[1;32m    180\u001b[0m     \u001b[38;5;66;03m# while suppressing Telemetry caused exceptions like SnowparkSessionException from telemetry in the stack trace.\u001b[39;00m\n\u001b[1;32m    181\u001b[0m     \u001b[38;5;66;03m# This prevents from adding telemetry error messages to regular API calls error messages.\u001b[39;00m\n\u001b[0;32m--> 182\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m e \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/telemetry.py:177\u001b[0m, in \u001b[0;36m_run_func_helper\u001b[0;34m(func, args, kwargs)\u001b[0m\n\u001b[1;32m    165\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    166\u001b[0m \u001b[38;5;124;03mThe helper function that run func, suppressing the possible previous telemetry exception context.\u001b[39;00m\n\u001b[1;32m    167\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    174\u001b[0m \u001b[38;5;124;03m    The return value of the function\u001b[39;00m\n\u001b[1;32m    175\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 177\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    178\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    179\u001b[0m     \u001b[38;5;66;03m# Raise error caused by func, i.e. the api call\u001b[39;00m\n\u001b[1;32m    180\u001b[0m     \u001b[38;5;66;03m# while suppressing Telemetry caused exceptions like SnowparkSessionException from telemetry in the stack trace.\u001b[39;00m\n\u001b[1;32m    181\u001b[0m     \u001b[38;5;66;03m# This prevents from adding telemetry error messages to regular API calls error messages.\u001b[39;00m\n\u001b[1;32m    182\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m e \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/pandas/general.py:2159\u001b[0m, in \u001b[0;36mdate_range\u001b[0;34m(start, end, periods, freq, tz, normalize, name, inclusive, **kwargs)\u001b[0m\n\u001b[1;32m   2155\u001b[0m \u001b[38;5;66;03m# If a timezone is not explicitly given via `tz`, see if one can be inferred from the `start` and `end` endpoints.\u001b[39;00m\n\u001b[1;32m   2156\u001b[0m \u001b[38;5;66;03m# If more than one of these inputs provides a timezone, require that they all agree.\u001b[39;00m\n\u001b[1;32m   2157\u001b[0m tz \u001b[38;5;241m=\u001b[39m _infer_tz_from_endpoints(start, end, tz)\n\u001b[0;32m-> 2159\u001b[0m qc \u001b[38;5;241m=\u001b[39m \u001b[43mSnowflakeQueryCompiler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_date_range\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2160\u001b[0m \u001b[43m    \u001b[49m\u001b[43mstart\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2161\u001b[0m \u001b[43m    \u001b[49m\u001b[43mend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2162\u001b[0m \u001b[43m    \u001b[49m\u001b[43mperiods\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2163\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfreq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2164\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtz\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtz\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2165\u001b[0m \u001b[43m    \u001b[49m\u001b[43mleft_inclusive\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mleft_inclusive\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2166\u001b[0m \u001b[43m    \u001b[49m\u001b[43mright_inclusive\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mright_inclusive\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2167\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2168\u001b[0m \u001b[38;5;66;03m# Set date range as index column.\u001b[39;00m\n\u001b[1;32m   2169\u001b[0m qc \u001b[38;5;241m=\u001b[39m qc\u001b[38;5;241m.\u001b[39mset_index_from_columns(qc\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mtolist(), include_index\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/venv/lib/python3.10/site-packages/modin/logging/logger_decorator.py:125\u001b[0m, in \u001b[0;36menable_logging.<locals>.decorator.<locals>.run_and_log\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    110\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    111\u001b[0m \u001b[38;5;124;03mCompute function with logging if Modin logging is enabled.\u001b[39;00m\n\u001b[1;32m    112\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    122\u001b[0m \u001b[38;5;124;03mAny\u001b[39;00m\n\u001b[1;32m    123\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m LogMode\u001b[38;5;241m.\u001b[39mget() \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdisable\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mobj\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    127\u001b[0m logger \u001b[38;5;241m=\u001b[39m get_logger()\n\u001b[1;32m    128\u001b[0m logger\u001b[38;5;241m.\u001b[39mlog(log_level, start_line)\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py:668\u001b[0m, in \u001b[0;36mSnowflakeQueryCompiler.from_date_range\u001b[0;34m(cls, start, end, periods, freq, tz, left_inclusive, right_inclusive)\u001b[0m\n\u001b[1;32m    665\u001b[0m         end \u001b[38;5;241m=\u001b[39m end\u001b[38;5;241m.\u001b[39mtz_localize(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m    666\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(freq, Tick):\n\u001b[1;32m    667\u001b[0m     \u001b[38;5;66;03m# generate nanosecond values\u001b[39;00m\n\u001b[0;32m--> 668\u001b[0m     ns_values \u001b[38;5;241m=\u001b[39m \u001b[43mgenerator_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate_regular_range\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    669\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperiods\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\n\u001b[1;32m    670\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    671\u001b[0m     dt_values \u001b[38;5;241m=\u001b[39m ns_values\u001b[38;5;241m.\u001b[39mseries_to_datetime()\n\u001b[1;32m    672\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/generator_utils.py:71\u001b[0m, in \u001b[0;36mgenerate_regular_range\u001b[0;34m(start, end, periods, freq)\u001b[0m\n\u001b[1;32m     67\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     68\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(  \u001b[38;5;66;03m# pragma: no cover\u001b[39;00m\n\u001b[1;32m     69\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mat least \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mstart\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m or \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mend\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m should be specified if a \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mperiod\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m is given.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     70\u001b[0m     )\n\u001b[0;32m---> 71\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgenerate_range\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43me\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstride\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/modin/plugin/_internal/generator_utils.py:127\u001b[0m, in \u001b[0;36mgenerate_range\u001b[0;34m(start, end, step)\u001b[0m\n\u001b[1;32m    110\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mgenerate_range\u001b[39m(\n\u001b[1;32m    111\u001b[0m     start: \u001b[38;5;28mint\u001b[39m,\n\u001b[1;32m    112\u001b[0m     end: Optional[\u001b[38;5;28mint\u001b[39m],\n\u001b[1;32m    113\u001b[0m     step: \u001b[38;5;28mint\u001b[39m,\n\u001b[1;32m    114\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msnowflake_query_compiler.SnowflakeQueryCompiler\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    115\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    116\u001b[0m \u001b[38;5;124;03m    Use `session.range` to generate values in range and represent in a query compiler\u001b[39;00m\n\u001b[1;32m    117\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;124;03m        The query compiler containing int values\u001b[39;00m\n\u001b[1;32m    125\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m    126\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _create_qc_from_snowpark_dataframe(\n\u001b[0;32m--> 127\u001b[0m         \u001b[43mget_active_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mrange(start, end, step)\n\u001b[1;32m    128\u001b[0m     )\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/context.py:32\u001b[0m, in \u001b[0;36mget_active_session\u001b[0;34m()\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_active_session\u001b[39m() \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msnowflake.snowpark.Session\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m     25\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Returns the current active Snowpark session.\u001b[39;00m\n\u001b[1;32m     26\u001b[0m \n\u001b[1;32m     27\u001b[0m \u001b[38;5;124;03m    Raises: SnowparkSessionException: If there is more than one active session or no active sessions.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[38;5;124;03m        A :class:`Session` object for the current session.\u001b[39;00m\n\u001b[1;32m     31\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m---> 32\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msnowflake\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msnowpark\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msession\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_active_session\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/Desktop/snowpark-python/src/snowflake/snowpark/session.py:217\u001b[0m, in \u001b[0;36m_get_active_session\u001b[0;34m()\u001b[0m\n\u001b[1;32m    215\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mnext\u001b[39m(\u001b[38;5;28miter\u001b[39m(_active_sessions))\n\u001b[1;32m    216\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(_active_sessions) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 217\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m SnowparkClientExceptionMessages\u001b[38;5;241m.\u001b[39mMORE_THAN_ONE_ACTIVE_SESSIONS()\n\u001b[1;32m    218\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    219\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m SnowparkClientExceptionMessages\u001b[38;5;241m.\u001b[39mSERVER_NO_DEFAULT_SESSION()\n",
-      "\u001b[0;31mSnowparkSessionException\u001b[0m: (1409): More than one active session is detected. When you call function 'udf' or use decorator '@udf', you must specify the 'session' parameter if you created multiple sessions.Alternatively, you can use 'session.udf.register' to register UDFs"
-     ]
+     "data": {
+      "text/plain": [
+       "DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 01:00:00',\n",
+       "               '2018-01-01 02:00:00'],\n",
+       "              dtype='datetime64[ns]', freq=None)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -123,9 +149,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "1f2c79bc-2a9e-41f0-ab36-44fcc20d119a",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:37.976832Z",
+     "iopub.status.busy": "2024-08-28T17:27:37.976629Z",
+     "iopub.status.idle": "2024-08-28T17:27:37.978940Z",
+     "shell.execute_reply": "2024-08-28T17:27:37.978566Z"
+    }
+   },
    "outputs": [],
    "source": [
     "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
@@ -134,9 +167,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "d7916dfa-9716-47e4-92a8-c3c852a3d802",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:37.981235Z",
+     "iopub.status.busy": "2024-08-28T17:27:37.981056Z",
+     "iopub.status.idle": "2024-08-28T17:27:37.983005Z",
+     "shell.execute_reply": "2024-08-28T17:27:37.982681Z"
+    }
+   },
    "outputs": [],
    "source": [
     "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
@@ -153,10 +193,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "5aa8cd79-521b-42ee-a3a6-66be36603bcb",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:37.985074Z",
+     "iopub.status.busy": "2024-08-28T17:27:37.984931Z",
+     "iopub.status.idle": "2024-08-28T17:27:39.127895Z",
+     "shell.execute_reply": "2024-08-28T17:27:39.127293Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2018-01-01 00:00:00    0\n",
+       "2018-01-01 01:00:00    1\n",
+       "2018-01-01 02:00:00    2\n",
+       "2018-01-01 03:00:00    3\n",
+       "2018-01-01 04:00:00    4\n",
+       "Freq: None, dtype: int64"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "idx = pd.date_range(\"2018-01-01\", periods=5, freq=\"h\")\n",
     "ts = pd.Series(range(len(idx)), index=idx)\n",
@@ -165,10 +228,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "796c954c-7f60-441b-b85e-1098824fae4b",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:39.131539Z",
+     "iopub.status.busy": "2024-08-28T17:27:39.131194Z",
+     "iopub.status.idle": "2024-08-28T17:27:39.966782Z",
+     "shell.execute_reply": "2024-08-28T17:27:39.966293Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2018-01-01 00:00:00    0.5\n",
+       "2018-01-01 02:00:00    2.5\n",
+       "2018-01-01 04:00:00    4.0\n",
+       "Freq: None, dtype: float64"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "ts.resample(\"2h\").mean()"
    ]
@@ -183,10 +267,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "e7272da8-eae8-4e31-8a61-2f442a6780e0",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:39.969410Z",
+     "iopub.status.busy": "2024-08-28T17:27:39.969229Z",
+     "iopub.status.idle": "2024-08-28T17:27:39.972019Z",
+     "shell.execute_reply": "2024-08-28T17:27:39.971689Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Friday'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "friday = pd.Timestamp(\"2018-01-05\")\n",
     "friday.day_name()"
@@ -194,10 +296,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "b69cb16a-9fc7-46fe-a6f6-a6a1ce635dc5",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:39.974318Z",
+     "iopub.status.busy": "2024-08-28T17:27:39.974172Z",
+     "iopub.status.idle": "2024-08-28T17:27:39.976711Z",
+     "shell.execute_reply": "2024-08-28T17:27:39.976411Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Saturday'"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "saturday = friday + pd.Timedelta(\"1 day\")\n",
     "saturday.day_name()"
@@ -205,10 +325,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "064f4271-9485-497d-b176-b39d4f75248c",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:39.979219Z",
+     "iopub.status.busy": "2024-08-28T17:27:39.979068Z",
+     "iopub.status.idle": "2024-08-28T17:27:39.981624Z",
+     "shell.execute_reply": "2024-08-28T17:27:39.981354Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Monday'"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "monday = friday + pd.offsets.BDay()\n",
     "monday.day_name()"
@@ -216,10 +354,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "86bf9469-b7d3-44fc-900e-cfd67a065842",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:39.983587Z",
+     "iopub.status.busy": "2024-08-28T17:27:39.983443Z",
+     "iopub.status.idle": "2024-08-28T17:27:40.913877Z",
+     "shell.execute_reply": "2024-08-28T17:27:40.913560Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2012-01-01    NaN\n",
+       "2012-01-02    0.0\n",
+       "2012-01-03    1.0\n",
+       "Freq: None, dtype: float64"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "rng = pd.date_range(\"2012-01-01\", \"2012-01-03\")\n",
     "ts = pd.Series(range(len(rng)), index=rng)\n",
@@ -245,10 +404,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "id": "0e4e6063-a60f-4a70-adca-2cb9b3b101f8",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:40.916090Z",
+     "iopub.status.busy": "2024-08-28T17:27:40.915940Z",
+     "iopub.status.idle": "2024-08-28T17:27:41.359184Z",
+     "shell.execute_reply": "2024-08-28T17:27:41.358781Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DatetimeIndex(['2012-10-08 18:15:05', '2012-10-09 18:15:05',\n",
+       "               '2012-10-10 18:15:05', '2012-10-11 18:15:05'],\n",
+       "              dtype='datetime64[ns]', freq=None)"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "stamps = pd.date_range(\"2012-10-08 18:15:05\", periods=4, freq=\"D\")\n",
     "stamps"
@@ -256,9 +435,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "f4a38e8b-abcb-49c6-839d-01e4215d7d7a",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:41.361646Z",
+     "iopub.status.busy": "2024-08-28T17:27:41.361457Z",
+     "iopub.status.idle": "2024-08-28T17:27:41.363485Z",
+     "shell.execute_reply": "2024-08-28T17:27:41.363091Z"
+    }
+   },
    "outputs": [],
    "source": [
     "# TODO SNOW-1635620: uncomment when TimeDelta is implemented\n",
@@ -275,10 +461,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "1febbd6a-1b57-4e6a-a48a-3eac565ad61d",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:41.365775Z",
+     "iopub.status.busy": "2024-08-28T17:27:41.365599Z",
+     "iopub.status.idle": "2024-08-28T17:27:41.413954Z",
+     "shell.execute_reply": "2024-08-28T17:27:41.413683Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Timestamp('2016-10-30 23:00:00+0200', tz='Europe/Helsinki')"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "ts = pd.Timestamp(\"2016-10-30 00:00:00\", tz=\"Europe/Helsinki\")\n",
     "\n",
@@ -287,10 +491,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "id": "b8d03fb0-826f-4698-a6d0-f2b63f7d38dc",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:41.415634Z",
+     "iopub.status.busy": "2024-08-28T17:27:41.415523Z",
+     "iopub.status.idle": "2024-08-28T17:27:41.417793Z",
+     "shell.execute_reply": "2024-08-28T17:27:41.417561Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Timestamp('2016-10-31 00:00:00+0200', tz='Europe/Helsinki')"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "ts + pd.DateOffset(days=1)"
    ]
@@ -305,40 +527,112 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "id": "dd818a8d-97c1-46f3-b29f-499ba92f22ae",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:41.419736Z",
+     "iopub.status.busy": "2024-08-28T17:27:41.419620Z",
+     "iopub.status.idle": "2024-08-28T17:27:42.097520Z",
+     "shell.execute_reply": "2024-08-28T17:27:42.097100Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Timedelta('396 days 03:00:00')"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "pd.to_datetime('2018-10-26 12:00:00') - pd.to_datetime('2017-09-25 09:00:00')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "id": "7c9a87d2-7883-46a6-8433-dfa5900ca9b0",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:42.099835Z",
+     "iopub.status.busy": "2024-08-28T17:27:42.099657Z",
+     "iopub.status.idle": "2024-08-28T17:27:42.102502Z",
+     "shell.execute_reply": "2024-08-28T17:27:42.102144Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Timedelta('6 days 07:00:00')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "pd.Timestamp(\"2014-08-01 10:00\") - pd.Timestamp(\"2014-07-26 03:00\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "id": "e78454b1-0d4c-42bc-a127-b21a4a7f09cf",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:42.104922Z",
+     "iopub.status.busy": "2024-08-28T17:27:42.104781Z",
+     "iopub.status.idle": "2024-08-28T17:27:42.107600Z",
+     "shell.execute_reply": "2024-08-28T17:27:42.107293Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Timedelta('682 days 03:00:00')"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "pd.Timestamp(year=2017, month=1, day=1, hour=12) - pd.Timestamp(year=2015, month=2, day=19, hour=9)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "id": "2534d141-1862-4901-ba70-7ed73ab9abdd",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:42.109761Z",
+     "iopub.status.busy": "2024-08-28T17:27:42.109628Z",
+     "iopub.status.idle": "2024-08-28T17:27:42.763799Z",
+     "shell.execute_reply": "2024-08-28T17:27:42.763158Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Timedelta('-31 days +03:09:02')"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "(pd.to_datetime(\"2018-8-26 15:09:02\") - pd.to_datetime('2018-09-26 12:00:00'))"
    ]
@@ -368,7 +662,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
diff --git a/tests/notebooks/modin/VisualizingTaxiTripData.ipynb b/tests/notebooks/modin/VisualizingTaxiTripData.ipynb
index 6bed3588807..7da0b8c4901 100644
--- a/tests/notebooks/modin/VisualizingTaxiTripData.ipynb
+++ b/tests/notebooks/modin/VisualizingTaxiTripData.ipynb
@@ -19,14 +19,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
    "id": "a48f71cf5ca0ead",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-04-26T14:29:18.451575Z",
      "start_time": "2024-04-26T14:29:18.439220Z"
     },
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:35.535431Z",
+     "iopub.status.busy": "2024-08-28T17:27:35.535097Z",
+     "iopub.status.idle": "2024-08-28T17:27:37.129341Z",
+     "shell.execute_reply": "2024-08-28T17:27:37.128903Z"
+    }
    },
    "outputs": [],
    "source": [
@@ -48,10 +54,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "id": "691d582a439c5a80",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:37.131387Z",
+     "iopub.status.busy": "2024-08-28T17:27:37.131228Z",
+     "iopub.status.idle": "2024-08-28T17:27:41.984160Z",
+     "shell.execute_reply": "2024-08-28T17:27:41.983698Z"
+    }
    },
    "outputs": [],
    "source": [
@@ -60,10 +72,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "id": "d80067becc67183e",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:41.986666Z",
+     "iopub.status.busy": "2024-08-28T17:27:41.986440Z",
+     "iopub.status.idle": "2024-08-28T17:27:42.229686Z",
+     "shell.execute_reply": "2024-08-28T17:27:42.229248Z"
+    }
    },
    "outputs": [],
    "source": [
@@ -83,15 +101,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 4,
    "id": "6fb5a3f01b2b0f26",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:42.232608Z",
+     "iopub.status.busy": "2024-08-28T17:27:42.232433Z",
+     "iopub.status.idle": "2024-08-28T17:27:43.149053Z",
+     "shell.execute_reply": "2024-08-28T17:27:43.148761Z"
+    }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -135,10 +159,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "id": "f71c3e100b98fbf2",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:43.152387Z",
+     "iopub.status.busy": "2024-08-28T17:27:43.152260Z",
+     "iopub.status.idle": "2024-08-28T17:27:43.849823Z",
+     "shell.execute_reply": "2024-08-28T17:27:43.849504Z"
+    }
    },
    "outputs": [
     {
@@ -356,7 +386,7 @@
        "6                       485           485                    485           485  "
       ]
      },
-     "execution_count": 9,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -367,10 +397,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 6,
    "id": "8bc9d6db83a8deab",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:43.851746Z",
+     "iopub.status.busy": "2024-08-28T17:27:43.851616Z",
+     "iopub.status.idle": "2024-08-28T17:27:44.313330Z",
+     "shell.execute_reply": "2024-08-28T17:27:44.313030Z"
+    }
    },
    "outputs": [
     {
@@ -386,7 +422,7 @@
        "Name: VENDORID, dtype: int64"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -398,15 +434,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 7,
    "id": "5e87fd5eee32716b",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:44.315144Z",
+     "iopub.status.busy": "2024-08-28T17:27:44.315017Z",
+     "iopub.status.idle": "2024-08-28T17:27:45.402962Z",
+     "shell.execute_reply": "2024-08-28T17:27:45.402634Z"
+    }
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:snowflake.snowpark.modin.plugin.utils.warning_message:Calling __array__ on a modin object materializes all data into local memory.\n",
+      "Since this can be called by 3rd party libraries silently, it can lead to \n",
+      "unexpected delays or high memory usage. Use to_pandas() or to_numpy() to do \n",
+      "this once explicitly.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -441,12 +493,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 8,
    "id": "c3b3cbdfec3a8c7",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:45.404941Z",
+     "iopub.status.busy": "2024-08-28T17:27:45.404803Z",
+     "iopub.status.idle": "2024-08-28T17:27:50.361662Z",
+     "shell.execute_reply": "2024-08-28T17:27:50.361336Z"
+    }
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:snowflake.snowpark.modin.plugin.utils.warning_message:`to_datetime` implementation has mismatches with pandas:\n",
+      "Snowpark pandas to_datetime uses Snowflake's automatic format detection to convert string to datetime when a format is not provided. In this case Snowflake's auto format may yield different result values compared to pandas..\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
@@ -458,7 +524,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAHQCAYAAACIk59EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABpA0lEQVR4nO3dd3xUZfY/8M+kB0ghgRQghFAMRJoUqSpVBMGC6w8VFRBREaxfFd3FVdAVd1VUFFFRKWvBZcWCBTZAABWkKTUQJZRQUiCQhCSkzvn9Ee9lZjKTzCR35t5JPu/XKy/NnXbuTMg9eZ7znMckIgIiIiIiqhcfvQMgIiIiagiYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpwE/PF583bx5WrVqFQ4cOITg4GAMHDsQ///lPJCYmqvcZMmQINm3aZPW4+++/H++++676fUZGBqZPn46UlBQ0a9YMkyZNwrx58+Dn59zpmc1mnD59GiEhITCZTNqcHBEREbmViODChQto1aoVfHz0HyfSNanatGkTZsyYgb59+6KiogJ//etfce211yI1NRVNmzZV7zdt2jTMnTtX/b5Jkybq/1dWVuL6669HTEwMtmzZgszMTNx9993w9/fHSy+95FQcp0+fRlxcnHYnRkRERB5z4sQJtGnTRu8wYDLShspnzpxBVFQUNm3ahKuvvhpA1UhVz5498cYbb9h9zA8//ICxY8fi9OnTiI6OBgC8++67mDVrFs6cOYOAgIBaXzc/Px/h4eE4ceIEQkNDNTsfIiIicp+CggLExcUhLy8PYWFheoej70iVrfz8fABARESE1fFPPvkEH3/8MWJiYjBu3Dg8++yz6mjV1q1b0a1bNzWhAoBRo0Zh+vTpOHDgAK644opqr1NaWorS0lL1+wsXLgAAQkNDmVQRERF5GaOU7hgmqTKbzXj00UcxaNAgdO3aVT1+xx13ID4+Hq1atcLevXsxa9YspKWlYdWqVQCArKwsq4QKgPp9VlaW3deaN28e5syZ46YzISIiosbIMEnVjBkzsH//fvz0009Wx++77z71/7t164bY2FgMHz4c6enp6NChQ51e65lnnsHjjz+ufq8MHxIRERHVlf6l8gBmzpyJb7/9FikpKbUWmvXr1w8AcPjwYQBATEwMsrOzre6jfB8TE2P3OQIDA9WpPk75ERERkRZ0TapEBDNnzsSXX36JDRs2ICEhodbH7N69GwAQGxsLABgwYAD27duHnJwc9T7JyckIDQ1FUlKSW+ImIiIisqXr9N+MGTPw6aef4uuvv0ZISIhaAxUWFobg4GCkp6fj008/xZgxYxAZGYm9e/fisccew9VXX43u3bsDAK699lokJSXhrrvuwr/+9S9kZWVh9uzZmDFjBgIDA/U8PSIiImpEdG2p4Khaf8mSJZg8eTJOnDiBO++8E/v370dRURHi4uJw8803Y/bs2VZTdsePH8f06dOxceNGNG3aFJMmTcLLL7/sdPPPgoIChIWFIT8/n1OBREREXsJo129D9anSi9E+FCIiIqqd0a7fhihUJyIiIvJ2TKqIiIiINMCkioiIiEgDTKqIiIiINMCkioiIiEgDhtmmhuonOTUbW9NzMaBDJEYmRdf+ACIiItIUR6oagOTUbExbvhPLthzDtOU7kZyaXfuDiIiISFNMqhqArem58DWZUCkCX5MJvxzJ1TskIiKiRodJVQMwoEOkmlBViqB/+0i9QyIiImp0WFPVAIxMisbiu/vglyO56N+eNVVERER6YFLVQIxMimYyRUREpCNO/xERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQZ0TarmzZuHvn37IiQkBFFRUbjpppuQlpZmdZ+SkhLMmDEDkZGRaNasGW655RZkZ2db3ScjIwPXX389mjRpgqioKDz55JOoqKjw5KkQERFRI6drUrVp0ybMmDEDv/zyC5KTk1FeXo5rr70WRUVF6n0ee+wxrF69GitXrsSmTZtw+vRpjB8/Xr29srIS119/PcrKyrBlyxYsW7YMS5cuxd///nc9TomIiIgaKZOIiN5BKM6cOYOoqChs2rQJV199NfLz89GyZUt8+umn+Mtf/gIAOHToELp06YKtW7eif//++OGHHzB27FicPn0a0dHRAIB3330Xs2bNwpkzZxAQEFDr6xYUFCAsLAz5+fkIDQ116zkSERGRNox2/TZUTVV+fj4AICIiAgCwa9culJeXY8SIEep9OnfujLZt22Lr1q0AgK1bt6Jbt25qQgUAo0aNQkFBAQ4cOGD3dUpLS1FQUGD1RURERFQfhkmqzGYzHn30UQwaNAhdu3YFAGRlZSEgIADh4eFW942OjkZWVpZ6H8uESrlduc2eefPmISwsTP2Ki4vT+GyIiIiosTFMUjVjxgzs378fK1ascPtrPfPMM8jPz1e/Tpw44fbXJCIioobNT+8AAGDmzJn49ttvsXnzZrRp00Y9HhMTg7KyMuTl5VmNVmVnZyMmJka9z/bt262eT1kdqNzHVmBgIAIDAzU+CyIiImrMdB2pEhHMnDkTX375JTZs2ICEhASr23v37g1/f3+sX79ePZaWloaMjAwMGDAAADBgwADs27cPOTk56n2Sk5MRGhqKpKQkz5wIERERNXq6jlTNmDEDn376Kb7++muEhISoNVBhYWEIDg5GWFgYpk6discffxwREREIDQ3FQw89hAEDBqB///4AgGuvvRZJSUm466678K9//QtZWVmYPXs2ZsyYwdEoIiIi8hhdWyqYTCa7x5csWYLJkycDqGr++X//93/47LPPUFpailGjRuGdd96xmto7fvw4pk+fjo0bN6Jp06aYNGkSXn75Zfj5OZczGm1JJhEREdXOaNdvQ/Wp0ovRPhQiIiKqndGu34ZZ/UdERETkzZhUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWnAT+8AqHbJqdnYmp6LAR0iMTIpWu9wiIiIyA6OVBlccmo2pi3fiWVbjmHa8p1ITs3WOyQiIiKyg0mVwW1Nz4WvyYRKEfiaTPjlSK7eIREREZEdTKoMbkCHSDWhqhRB//aReodEREREdrCmyuBGJkVj8d198MuRXPRvz5oqIiIio2JS5QVGJkUzmSIiIjI4Tv8RERERaYAjVV6ErRWIiIiMiyNVXoKtFYiIiIyNSZWXYGsFIiIiY2NS5SXYWoGIiMjYWFPlJdhagYiIyNiYVHkRtlYgIiIyLk7/EREREWmAI1UGw7YJRERE3okjVQbCtglERETei0mVgbBtAhERkfdiUmUgbJtARETkvVhTZSBsm0BEROS9mFQZDNsmEBEReSdO/xERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpQNekavPmzRg3bhxatWoFk8mEr776yur2yZMnw2QyWX1dd911Vvc5d+4cJk6ciNDQUISHh2Pq1KkoLCz04FkQERER6ZxUFRUVoUePHli4cKHD+1x33XXIzMxUvz777DOr2ydOnIgDBw4gOTkZ3377LTZv3oz77rvP3aETERERWfHT88VHjx6N0aNH13ifwMBAxMTE2L3t4MGDWLNmDXbs2IE+ffoAAN566y2MGTMGr776Klq1aqV5zERERET2GL6mauPGjYiKikJiYiKmT5+O3Nxc9batW7ciPDxcTagAYMSIEfDx8cG2bdscPmdpaSkKCgqsvoiIiIjqw9BJ1XXXXYfly5dj/fr1+Oc//4lNmzZh9OjRqKysBABkZWUhKirK6jF+fn6IiIhAVlaWw+edN28ewsLC1K+4uDi3ngcRERE1fLpO/9XmtttuU/+/W7du6N69Ozp06ICNGzdi+PDhdX7eZ555Bo8//rj6fUFBARMrIiIiqhdDj1TZat++PVq0aIHDhw8DAGJiYpCTk2N1n4qKCpw7d85hHRZQVacVGhpq9UVERERUHy4nVe3bt7eqa1Lk5eWhffv2mgTlyMmTJ5Gbm4vY2FgAwIABA5CXl4ddu3ap99mwYQPMZjP69evn1liIiIiILLk8/Xfs2DG1pslSaWkpTp065dJzFRYWqqNOAHD06FHs3r0bERERiIiIwJw5c3DLLbcgJiYG6enpeOqpp9CxY0eMGjUKANClSxdcd911mDZtGt59912Ul5dj5syZuO2227jyj4iIiDzK6aTqm2++Uf9/7dq1CAsLU7+vrKzE+vXr0a5dO5defOfOnRg6dKj6vVLnNGnSJCxatAh79+7FsmXLkJeXh1atWuHaa6/FCy+8gMDAQPUxn3zyCWbOnInhw4fDx8cHt9xyCxYsWOBSHERERET1ZRIRceaOPj5VM4Umkwm2D/H390e7du3w2muvYezYsdpH6WYFBQUICwtDfn4+66uIiIi8hNGu306PVJnNZgBAQkICduzYgRYtWrgtKCIiIiJv43JN1dGjR90RBxEREZFXq1OfqvXr12P9+vXIyclRR7AUH330kSaBEREREXkTl5OqOXPmYO7cuejTpw9iY2NhMpncERcRERGRV3E5qXr33XexdOlS3HXXXe6Ih4iIiMgrudz8s6ysDAMHDnRHLERERERey+Wk6t5778Wnn37qjliIiIiIvJbL038lJSV4//33sW7dOnTv3h3+/v5Wt8+fP1+z4IiIiIi8hctJ1d69e9GzZ08AwP79+61uY9E6ERERNVYuJ1UpKSnuiIOIiIjIq7lcU0VERERE1bk8UjV06NAap/k2bNhQr4CIiIiIvJHLSZVST6UoLy/H7t27sX//fkyaNEmruIiIiIi8istJ1euvv273+PPPP4/CwsJ6B0RERETkjTSrqbrzzju57x8RERE1WpolVVu3bkVQUJBWT0dERETkVVye/hs/frzV9yKCzMxM7Ny5E88++6xmgRERERF5E5eTqrCwMKvvfXx8kJiYiLlz5+Laa6/VLDAiIiIib+JyUrVkyRJ3xEFERETk1VxOqhS7du3CwYMHAQCXX345rrjiCs2CIiIiIvI2LidVOTk5uO2227Bx40aEh4cDAPLy8jB06FCsWLECLVu21DpGIiIiIsNzefXfQw89hAsXLuDAgQM4d+4czp07h/3796OgoAAPP/ywO2IkIiIiMjyTiIgrDwgLC8O6devQt29fq+Pbt2/Htddei7y8PC3j84iCggKEhYUhPz8foaGheodDRERETjDa9dvlkSqz2Qx/f/9qx/39/WE2mzUJioiIiMjbuJxUDRs2DI888ghOnz6tHjt16hQee+wxDB8+XNPgiIiIiLyFy0nV22+/jYKCArRr1w4dOnRAhw4dkJCQgIKCArz11lvuiJGIiIjI8Fxe/RcXF4dff/0V69atw6FDhwAAXbp0wYgRIzQPjoiIiMhbuFyo3hAZrdCNiIiIame063edmn/u2LEDKSkpyMnJqVacPn/+fE0CIyIiIvImLidVL730EmbPno3ExERER0fDZDKpt1n+PxEREVFj4nJS9eabb+Kjjz7C5MmT3RAOERERkXdyefWfj48PBg0a5I5YiIiIiLyWy0nVY489hoULF7ojFvJiyanZmLs6Fcmp2XqHQkREpAuXV/+ZzWZcf/31+P3335GUlFStu/qqVas0DdATjLZ6wNskp2Zj2vKd8DWZUCmCxXf3wcikaL3DIiKiBs5o12+XR6oefvhhpKSk4LLLLkNkZCTCwsKsvqjx2ZqeqyZUviYTfjmSq3dIREREHudyofqyZcvwxRdf4Prrr3dHPOSFBnSIxEc/H1UTq/7tI/UOiYiIyONcTqoiIiLQoUMHd8RCXmpkUjQW390HvxzJRf/2kZz6IyKiRsnlmqolS5ZgzZo1WLJkCZo0aeKuuDzKaHOyREREVDujXb9dHqlasGAB0tPTER0djXbt2lUrVP/11181C46IiIjIW7icVN10001uCIOIiIjIu2m6oXJlZSV8fX21ejqPMdrwIREREdXOaNdvl1sq2PP7779j1qxZaNOmjRZPR0REROR16pxUFRcXY8mSJbjqqquQlJSETZs24fHHH9cyNiIiIiKv4XJN1S+//IIPPvgAK1euRNu2bXHw4EGkpKTgqquuckd8RERERF7B6ZGq1157DZdffjn+8pe/oHnz5ti8eTP27dsHk8mEyEg2eyQiIqLGzemRqlmzZmHWrFmYO3euVxajExEREbmT0yNVL7zwAlauXImEhATMmjUL+/fvd2dcRERERF7F6aTqmWeewe+//45///vfyMrKQr9+/dCjRw+ICM6fP+/OGImIiIgMz+XVf9dccw2WLVuGrKwsPPjgg+jduzeuueYaDBw4EPPnz3dHjERERESGp0nzz3379uHDDz/Ep59+ipycHC3i8iijNQ8jIiKi2hnt+q1pR/Xy8vJqewF6A6N9KERERFQ7o12/NemorvDGhIqIiIhIC5omVURERESNFZMqIiIiIg0wqSIiIiLSQJ2SqvT0dMyePRu33367utrvhx9+wIEDBzQNjoiIiMhbuJxUbdq0Cd26dcO2bduwatUqFBYWAgD27NmD5557TvMAiYiIiLyBy0nV008/jRdffBHJyckICAhQjw8bNgy//PKLS8+1efNmjBs3Dq1atYLJZMJXX31ldbuI4O9//ztiY2MRHByMESNG4I8//rC6z7lz5zBx4kSEhoYiPDwcU6dOVRM9IiIiIk9xOanat28fbr755mrHo6KicPbsWZeeq6ioCD169MDChQvt3v6vf/0LCxYswLvvvott27ahadOmGDVqFEpKStT7TJw4EQcOHEBycjK+/fZbbN68Gffdd59rJ0VERERUT36uPiA8PByZmZlISEiwOv7bb7+hdevWLj3X6NGjMXr0aLu3iQjeeOMNzJ49GzfeeCMAYPny5YiOjsZXX32F2267DQcPHsSaNWuwY8cO9OnTBwDw1ltvYcyYMXj11VfRqlUrV09Pd8mp2dianosBHSIxMinakDEYIcaaGD0+LTSGcyQi8jYuj1TddtttmDVrFrKysmAymWA2m/Hzzz/jiSeewN13361ZYEePHkVWVhZGjBihHgsLC0O/fv2wdetWAMDWrVsRHh6uJlQAMGLECPj4+GDbtm0On7u0tBQFBQVWX0aQnJqNact3YtmWY5i2fCeSU7MNF4MRYqyJ0ePTQmM4RyIib+RyUvXSSy+hc+fOiIuLQ2FhIZKSknD11Vdj4MCBmD17tmaBZWVlAQCio63/Co+OjlZvy8rKQlRUlNXtfn5+iIiIUO9jz7x58xAWFqZ+xcXFaRZ3fWxNz4WvyYRKEfiaTPjlSK7hYjBCjDUxenxaaAznSETkjVxKqkQEWVlZWLBgAY4cOYJvv/0WH3/8MQ4dOoR///vf8PX1dVecmnrmmWeQn5+vfp04cULvkAAAAzpEqhfKShH0bx9puBiMEGNNjB6fFhrDORIReSOXaqpEBB07dsSBAwfQqVMnt47wxMTEAACys7MRGxurHs/OzkbPnj3V+yh9shQVFRU4d+6c+nh7AgMDERgYqH3Q9TQyKRqL7+6DX47kon97fWplaovBCDHWxOjxaaExnCMRkTdyKany8fFBp06dkJubi06dOrkrJgBAQkICYmJisH79ejWJKigowLZt2zB9+nQAwIABA5CXl4ddu3ahd+/eAIANGzbAbDajX79+bo3PXUYmRet+kawtBiPEWBOjx6eFxnCORETexuWaqpdffhlPPvkk9u/fX+8XLywsxO7du7F7924AVcXpu3fvRkZGBkwmEx599FG8+OKL+Oabb7Bv3z7cfffdaNWqFW666SYAQJcuXXDddddh2rRp2L59O37++WfMnDkTt912m1eu/CMiIiLvZRIRceUBzZs3R3FxMSoqKhAQEIDg4GCr28+dO+f0c23cuBFDhw6tdnzSpElYunQpRATPPfcc3n//feTl5WHw4MF45513cNlll1m93syZM7F69Wr4+PjglltuwYIFC9CsWTOn4ygoKEBYWBjy8/MRGhrq9OO8BZffExFRQ2S067fLSdWyZctqvH3SpEn1CkgPRvtQtKQsv1eKmhff3YeJFRERNQhGu3673PzTG5Omxsze8nsmVURERNpzuabKUklJiSGbaNIlXH5PRETkGS6PVBUVFWHWrFn4z3/+g9zc6k0HKysrNQmMtMHl90RERJ7h8kjVU089hQ0bNmDRokUIDAzEBx98gDlz5qBVq1ZYvny5O2KkehqZFI1nxyYxoSIiInIjl0eqVq9ejeXLl2PIkCGYMmUKrrrqKnTs2BHx8fH45JNPMHHiRHfESURERGRoLo9UnTt3Du3btwcAhIaGqi0UBg8ejM2bN2sbHVlJTs3G3NWp3ECX6oQ/P0RE7uVyUtW+fXscPXoUANC5c2f85z//AVA1ghUeHq5pcHSJ0hph2ZZjmLZ8Jy+M5BL+/BARuZ/LSdWUKVOwZ88eAMDTTz+NhQsXIigoCI899hiefPJJzQOkKvZaI9QFRysaJ61+foiIyDGna6qOHDmChIQEPPbYY+qxESNG4NChQ9i1axc6duyI7t27uyVIqmqN8NHPR+vVGsGyEehHPx9lI9BGRIufHyIiqpnTSVWnTp2QmZmJqKgoAMCECROwYMECxMfHIz4+3m0BUhUtWiOwEWjjxdYaRETu5/T0n+1uNt9//z2Kioo0D4gcq29rBD0agXK60TjYWoOIyL1cbqlA3svToxWcbiQiosbE6aTKZDLBZDJVO0bGl5yaja3puRjQoSqRsk1sbG/XSn2nG90VFxERkTs4nVSJCCZPnozAwEAAVfv+PfDAA2jatKnV/VatWqVthFQvtY0WuXM0qT7F0RzlIiIib+N0UjVp0iSr7++8807NgyHt1TZa5M7i9fpMN7KonoiIvI3TSdWSJUvcGQe5SW2jRe5eam9vutEZbAFARETexiS2y/oaoYKCAoSFhSE/Px+hoaF6h6O55NTsGkeLartdL0aNi4iIjMFo128mVTDeh0JERES1M9r1my0VvIiyGi44wBcXyyp1XxXn6uo8ruYzNn4+RET1w5EqGC/TtUdZDedjAsxS1bXVDOi2Ks5ydV6lSK1xuHp/8ix+PkTkjYx2/XZ5Q2XSh7IazvxnCmwGdN0Y19UNermhr7Hx8yEiqj8mVV5C2WLG589+qz6AU6vi3LVNjKtb3uixRY5WGsNWO7V9Po3hPSAiqi9O/8F4w4eOKKvhgvx9UVJeWeuqOHdP6bi6Os8bV/M1pmkxR59PY3oPiMi7GO36zUJ1L+Jqzyd3N9B0NZ669qzSU2NqQuro82lM7wERUX1w+q8B02rKzShTP3rE4c3Tllrhe0BE5BxO/8F4w4d14Wg5fH2n3PSc+rE8JwC6xuFt05Za43tAREZktOs3kyoY70NxlTsTn7mrU7FsyzF1pGLyoHZ4dmySJs9dE9tzGtElCimHzng8DiIiMi6jXb85/dcAuHM5vF5TP7bnBIBTUPVklGlcIqKGioXqDYA7Nx8emRSNxXf38fjUj+05TejbFhP6tvXqKSg9O5Zbjvx99PNRruAjInIDTv/BeMOHddEQa14a0jnp3ZZAr2lcIiJ3Mtr1myNVDYQ3tiuoTUM6J73bErhzNJOIiKowqSLyAL2TGr2mcYmIGhNO/8F4w4eO2KvJUY4FB/jiYlmlS/U69anxsW13oFetkDexN52pZZ2VnjVbRER6MNr1m0kVjPeh2GOvJgeo6t3kYwLMUrWU0ww4Va9Tnxof28cC4BYmdaBlnZXeNVtERHow2vWbLRW8hL2aHOWY+c+02Aw43VKhPm0YLB9rAmAC3NLOwRvUtU1Bcmo23kj+HT4mbd4728/z8x0ZbJ9ARORhTKq8hL1+Ucoxn6o2TvABnK7Xqa3/VE3JguVjBYAAjbIAWhkdWrblGKYt3+lUApOcmo17l+3AtOU7cTCzoGqE0eT85+aI7ee57mCOS3EREVH9cfoPxhs+dMRRTc4vR3IR5O+LkvJKl4qQHbUscGYqyfKxANxWAG3kOiFX2xQo76sJVYkoUJUId2kVikdHXKZJTdUvR3JxPLeI3eeJqFEw2vWbq/+8iL0WA862HbCXnDh6rDPL/20f646ExzIJqalhpV6Jl6sr+izfV6Bq2tQMaJJQAZc+k+TUbKw7mFOn0UMjJ7FEREbH6b9GwNVpKr22prH1+fYMAJdGdT7fkVHtPnWZgtOK0qZg8qB2ThWGW76vADC8S5RbCspdjUuh53tJRNQQcKTKiySnZlclGiZgQt+2dqfk7I0yVC9iPlHjaIQzPY20asdQ42NNtR7QvammKw1KXe0VVZ/3uKa4bJ9X+T7jXJGu7yURkbdjTRWMNydrjzKKYMlyFKKmOqiaWiDMGNqxxv5WjnpjadWOoabH2tYgOart8lQrAU9OjbnjvJSkfN2hHKvPf2HKYbbHICKvZLTrN0eqvMTW9FyrAmcTYDWSUNOIjeUIyfGzRUhJqypi9gHUC6q9miVHm/DWZ3TIlcc6M7IzMikaM4Z2xMa0HAxJjAJQVUCudeLjyobEjpKv2pIyy5FICDQdNbJMUAGon/9n2zPUVaO+JhOGdm6J+Mim7LpORFQHTKq8hFIUrRDAqtaptqJpqyJmi5EK2z5JNU0bKrfXZ8sVVx9b2/Racmq2mhgeOF0AAE4lPq5yNhl0lHzVlpTZG4lUzkV5n+ozUmZbJA9UFcmfLyqD4FI7DnvTykRE5BwmVV5CGbWpKtY2YULfuGoXvxGdowCT/dtsn0dpw7Aw5bCaWAX5+1rd11ECVJ995OrzWHtJhW0jUsBxklgfziaDjpKv2pIyeyORw7tEIz6yifpazo6UORN/XEQTnDpfrPbJ6hJb1dYBcM9IHxFRY8Ckyos4GrWxrb+Z0Deu1ucBqi7kY7rF4vt9mepUYM+4cLvThrYJkCsF2s6eR00cjfTYJguAexqROpsMOkq+akvK7I1EWibHc1en1ms60DZ+AFY/M0pCVZ/EjYiosWNSZWDOTve4WuNkm4Qpewbae2x9kictOTpHe8mCuxqROvNeOEq+akvKahuJrM+Uq6P4beNxlLixdxURkXO4+g/GWz0A1L6az3ZJvGU9TlRIAP5xc3eHo1pvJP9etUUKUG0z5h5twjBzWCeX2ii8sjYN3+w5hYjgAAy+rCUullUiOMC3xlWFrrwPW9NzERzga7VKzdlRFCMmBK7GZPkeOOqar8V51rRpN1cEEpERGe36zaQKxvtQAMdboDhKtm5ZtAW7jp+3eg5HxdC2iZQyBVjTY19Zm1ZVf/XnY5TbleOWlNog5XXqeiG2PdcZQzu6tBWPJ9stOMvVmJzdMkir87TdusjVrXiIiDzJaNdvdlQ3KEddze1NgwHA0bNF1Z5DuU2hPFYtTm4VisV390FMaJBVW02TzWOVFXZAVULlY3H7xkM51V5XydLNAqsY7alp42bbcy0pr8SzY5Pq1b5Bb45icvQ+OHMOWp7nyKRoq/fYKN31iYi8AZMqg1JqbCy3GklOzUbGuSK7Fzl7Fzt7xdDKY81yac+5AR0iYTlcaduuYWt6Lnwssi6zxe1DOkdVe13lrsqqQkcX4lfWpmHa8p1YuuVotW1RajpXZxkxIbAXU03bwzhzDsEBvlbtMdxRoO/qljdERI0Rp/9gvOFDe2yneEZ0iarWU+jBT37Fj7/nILJZIP52vf0RHdvpHcvjjoqkbacNZwztiCdHJaq3v7I2Dav3nEbzJv4Y3KklSsorEeTvuP7H8jkVPiZgyqAEu1Oc9s7VlffNXYXrdeXqFFtN56B+NqhKdpXPxoi1ZEREWjPa9Zur/7yE7RRPfGTTahfLdyb2AnCpaBlAtfs4WsFW08q22lauPTkq0SrJcvZ8lEQAqErWHE1x2jtXZxlh9aJtgmMbk7ONW+09n70pUle6vxMRkXY4/eclnJ3KqmlKrT5sa21cZVszNKBDpFqfBVSNsDTEOh4lwVnys+PPw5UpNtupQmXqz/K9crVui4iItMGRKi/hTPNJq4LyP4vRtewqXleORk5qaizqbNd1o09zVU2pXire/3zHCZdHCi3ZG5my917Zjnxx9IqIyP2YVHmRmi68Sv8py61OLKfUPK2mKSrLxp01TTnWdtE3WqJgN8GrVrFYvxJG26nC47lF6N8+0qoGy15SWt+O7EREVDtO/zUASnJxMLMAgkur7yyn1Czv6+4pIGemqFx9vrq2G/DUlJejFXyJsdaFkxP6tq3X6ygJ09DOLQEAKYfO2J1WZGsEIiLP4+o/eH71QHJqNj7fngGYgMSY0Bo7j1uOfgB/TicJMOHKS6vh5q5OxZKfj6pjIJe3ClXbJdg+l22TyN0n8rDxUA6GdI6yWjWmdESvqTO6o6m3e5fuwPpDOWo8LZoFoFmgHwpLK9A6LBgzh3dSz+VMQSlgAlo2C0RibNV7kVVQguNni1BSUYnsghIUllZWa2z5yto0/HvrMRSUVKivGxbkh+LySvj5mBAS6AczgLOFZeronZ+PCU0CfBHk7wOzGSg3m1FcWgmBQARoGuiHwZ1aIiY0CMEBvvjp9zM4d7EMAb4+yC4oha8PUFZuhpiAYZ2jkdCiKT7fnoG8i+WoNIvNZshROF9cbtWQNSY0EMVllbhYVonmTf3RvU24mmS9veEPnCsqww09W2PN/kykn7nUdyzY3xetwoOQXVACswh8TD5o0SwQx3OLqo17+fmYICII8PVBSLA/LpZXAgJENgvA+eIyFJZUwNfXBAhQVilWrxEdGoiwYH+0bBaICVe2VX824ls0xanzxTh1/iLKzWaUVpgRExKEv9Wjxo6ISAtGW/1n6KTq+eefx5w5c6yOJSYm4tChQwCAkpIS/N///R9WrFiB0tJSjBo1Cu+88w6io137Re/JD8W2lQCAal3Kbe9ruVmwJeX+D37yq1VH9DHdYtWVgJZsl+53bR2KPSfzrR6nbK5shkVndDvxOWp7AKDa+WlFaTcQ5O9brYs76UPvKVciatyMllQZfvrv8ssvR2Zmpvr1008/qbc99thjWL16NVauXIlNmzbh9OnTGD9+vI7R1m5req5V93LAejNj2/s6SqiAS13Nj9t0Uz+ee+l7y+kv2ymg9DOFVo/bduTPjut/fq/WZtmJzza29QdzMG35Tny+IwO+Jtsz1IYybWWvizvpwwhd6omIjMLwSZWfnx9iYmLUrxYtWgAA8vPz8eGHH2L+/PkYNmwYevfujSVLlmDLli345ZdfdI7aMdvu5UDVh2CvzsUyCbInyN8XQPWu5kMSq763rfMBquqsWjUPAgAUlVZaPa5di6Z2EziTnfiU2JTIBFDjdJQE1pdSI2avi7uRuCupNCLWZhERXWL41X9//PEHWrVqhaCgIAwYMADz5s1D27ZtsWvXLpSXl2PEiBHqfTt37oy2bdti69at6N+/v8PnLC0tRWlpqfp9QUGBW8/BklJorHQvT4wJcdh53HIVl+2UlwnAwpTD6BkXrjbe3JiWgyGJUer3toXcn+/IwLqDOVaJkKVdx88jKiQQORdKrY4n2anRsjyPdQdz1NeZ0LctJvRti7c3/GE1tWhpxtCO6BkXjs93nMCZCyUAgJYhgUiMCUVJeSUy80twPLcIJ88VI//PmimlfQAA9fw+35GBotIK+Pn6ILJpIIrLynG+uLyqpirID0H+fhjXoxWOni1CysFslFaaYbY46QBfEwSAyKWaqk7RIdh1/Lw69Rka5GdVtxXga4KPj+lSTdWODOQVl0NE0LNtczxwTQd11d2Xv53C5t9z4OtjQmiwP6JCgvBH9gVcLK9E8yb+6N6mOSb0jQPwZ01VcRlu6OG4piqnoOTPz9IHkTXUVEEE/n4+CAmqqqkqKa9EuUX9lNIZ31ZYsB/yL1ZUO96hZVNUmoFjudYjovYWQhARNWaGrqn64YcfUFhYiMTERGRmZmLOnDk4deoU9u/fj9WrV2PKlClWyREAXHnllRg6dCj++c9/Onxee7VaAAwzJ+tIcmo23lj3Ow5mFqibFdtuaWJ7f8u6p7iIYJw6d1Gd3nOWMw0pbfsk2RbPA8CILtHVtsBx9HxKsfzClMPVitQt7+NKfyp7hfrObOVj1K1unDkXe/cd0TkKKWln1P0Cu8RWJc1AVT2cklC2jQhG19bhiAkNsl4oYWcrIyIiPRitpsrQSZWtvLw8xMfHY/78+QgODq5zUmVvpCouLs4wH0pN7F0gLVcC2ru/MppkO0LRNiIYJ85ddNg5qVmgL16fcEWd99yzLVgf0SUaH0zq49TjlPObMbRjtZE8VxIKe89vtASprlw5l0t7O1atOLWXrM5dnYqlW46qjWOHdY7GuoPZdXqfiYg8wWhJleGn/yyFh4fjsssuw+HDhzFy5EiUlZUhLy8P4eHh6n2ys7MRExNT4/MEBgYiMDDQzdHWn73RmEvTbiew7mA2UtLOYN2hHPWCZ2+fOUcF7+N6tMbClMNqstU7vrlVC4BJAxPsPqczRiZFo0ebMKspQGWqryb2OobbjsQ5aibqbFwNJTFw9VyUadp1B3PsJqvBAb5q0m0W4ExBCRuGEhG5wPCF6pYKCwuRnp6O2NhY9O7dG/7+/li/fr16e1paGjIyMjBgwAAdo9SGo2aSQNXFtG1Ek2oXPHuPSU7NRkZukVVROXCpRmnx3X0wZVACFt/dB19MH4gZQzvi8lahmDG0o9q3ynIvwVfWpjl9DjOHdbL6fs/J/FqbcDrTpNIdjSwb+r54jpJVyyTpYlml+gvBB0DL0CA2DCUicoGhR6qeeOIJjBs3DvHx8Th9+jSee+45+Pr64vbbb0dYWBimTp2Kxx9/HBEREQgNDcVDDz2EAQMG1Fik7i1qG42x3a6kf/vIqoaiuLT6TikWV1ajdf9z5MhyNZ/taMeToxLVQnAlDstpQ6U43pkRi5FJ0RjRJQrrD+aoqwOV87A3+qUcszeKYvu8ltuwAFU1XHXd/8/Z7W6Mvs9gTez9vNR2nwl94zChb1yDmS4lInI3QydVJ0+exO23347c3Fy0bNkSgwcPxi+//IKWLau26Hj99dfh4+ODW265xar5Z0NQ20XQXmKxzqZ/kzL1poxStQwJApCv1lDtPpFXa5d0JQ6FDxxv0mz72OTUbEAutVuoaXNfAC7VSSnJoPJcJqDO+//VlsBa1qUZZZ9BV9W0SbXl52bvPt50nkREevKqQnV3MVqhm8KyEBlAjaMk9y7dUS2pstUuogkyzhVbrf6z1yVdWf1l27Hd8rhtPPYKzBemHL60kqx5MMb1bI0nRyVW6+w+eVA7iKDaMaWWynbrHMv3wPa8R3SJwgeT+jr13lpu/+MoobN9T4DaV126m5YjZvUp+ici0pvRrt+GHqlq7GxHY5RREmVLGKuLnxP9Js1/fil8TMDnO06oF2hl+lBJHpTVYt/vy1SnAGcM7QgA1UaaLEd7TBaPVZ4r4/xFderQ0SicvWPKuVtOQVqNFFU779rfCHsjZY5GcWyL/O01QnWGvVG8uiRGr6xNUxcX2Bsxc/V561P0T0RE1phUeQF7W8KsO2i94u9wTmEtzwJ0bR2Grq3D1FEns0BdMv/Rz0fRo02Y1f3PXCjF3NUHgD/v62syIS2rABsP5ahd4AHgsc9/w9WXRanfC6o2MrZVlWydwAeT+qgrGPHnYxxNTzlaufj5jgyMTIrGhL5t1YamAqjNNJ19P5VEwrZoW2GbAA63l9DWwjaJaxfZBMdyix0mRjU9j9IAVml7YJkEOVsbZu/8fExVn6fSpZ+IiFzHpMoLKBc+JXFQNjl+Y93v2H0iz+7mwr4+QKVNl899p/Jw4txFdYPkFk0DkFtUVtUEElVdzYFLGynbdkSvFLFKYBSFpZX4fl+mw47cCkFVEqessFMSOsuWELZJgG1N1yVVI1I11Qo54kzRtqIuz2/LNjE8llsMwH5iZI8y+pSRW6R+dsrjg/x91SL9uow6jUyKVjfStuzSX5/RNCKixoo1VTDenKw9Vk08UXVhdbTdCFC955Qzesc3R/Ngf8BUtdXJ+kM5DhuDOkMZkbHkA6BLq1DEhgapXb2d6Qyv9OWyrfeqq/o0AU1Oza6aKjXBqVEre3VZllzphg5A/fyVZMhRHZsz75Ftk1YfEzBlUAL6t49krRURGZ7Rrt8cqTIoe8XZH0zqW22rGkdcTaiUxygX5DHdYuuVUAFAx6hmOHHuotXUnRnAwcwCHDhdtd+io82kLVnWlmm1vL+uTUBtkxDLadiaXsuyYaul2vbPsx19Gto5CvGRTdC/fWS1Oraf/jjj8vlsTc+1O/r1RvLv6mfDWisiIucwqdKZvQLmz7dnYN0h6xEp2xoZ29GLmtQ0omVLudv3+zIxY2hH/PTHGYcbIwNVG/hW2HlyZdNky+nCkCA/FJVWWMWijLgAwI1v/YRzF6s2FVYaj9p2h3e1f5SzU1jOPsfW9FyrEScTap++e2VtGjYeykF8i6YY0SUKZy6UomVIICb0bQug5h5bwQG+6vSs0jsKgJpwW9ax7TmZr37WziZCak0VLn0Wapd9OJf0EhFRFU7/Qb/hw9raEFiy12bglyO5CPL3tVtTVV8mAPcMvjQNpIgKCUDOhepF6JbGdItFWUUlIMD5i+V1GjWzndqqqSGno2kqdaUcqhKEujyHo8/IUk0jVUoMCtu2FDVNsdmufFQSVcupxB6tw7D3VL7Vz4uz+0Javo4yArg1PVdtbWG52TJHqYjIiDj9RyrbqZ2NaTl2R5+UlVlK48y3N/yBU3kX0TosGDOHd8KILlFYd7DmHlW18fc1obzy0usKgJ1Hz+F4bpFVkldbQmVC1SiXI20jgiEATpy7WOPz/HIkVz3vmoq5Ld9DH1NV8b5CXSmHmpuW1lTgbW97l6qpvAwAJkzoG1djwrHRpneYZWd5EVR7XeU17RWel5RX4u0Nf6jPAwAwVU/Au7YOxZ6T+bXuCwnYH6GzLOJnQkVE5DwmVR5meRGzXNVXKYIhiVE4cLrg0khDl2gkxoSoW7YAsBo1OltYhmnLd6J3fPN6x2WZUCn2nMoHTrn2PLUNe47r0VodbalJQoum2HW8KoFT6nzssWwJYBbg4OkCTFu+EyO6RFlNe5oBh1NY9lYDWta02e5/50o9VnyLpjiQWWB1zFFvriB/X6uWCDOGdrR67Z1Hz1V9JhZahgRW2wqowix2k7Wauthb9j+r72pHIqLGikmVB9n2EVIaaSp6xoWroyBnLpQCIugZFw6gqi9TWtYFu8979GyRu0N3SlxEMCKaBFSrwRrTLRbHc4swJDFKrZWypExrvb3hD5wvLse4Hq1wsawSvx0/rxZQ25677dYqb6z7HQdPF8AMqHsdKi0LlKmzmuqxLPcbBFBtyq+mvQhrEhMaZDXSd3mrUAxJjLK7LYzjUbGqAve9p6rXtil1WcoWOpbJuWWjUtu2Dm9v+AO94yOs+o2t+7P/2YyhHZX2YTV2syciImtMqjyopuk+ZepqSKL1VF5tW88AVaM654pqnpbzhBPnLuL0+RIAQLvIpqgUM274c2Rqa3rupQTxz87tirSsAjw5KrFaPZFlfyqlv5W9DvOL7+6DR0dcZpUITejbFhP6tq1xxMXRtjxzV6dWS27quiWN7SjYkMQoLEw5fGl0yKbuyXLkUon78x0ZduvsxnSLVR9nuw+kozgUe07mw8/XBzatzNReVUp8wKXE1Ad131+RiKgxYFLlQfYusAdOF1hNXSmtBpzVolkAKmy7fKL2FX8tmgXY7XpeV0H+PigtN6sJ4rHcIviaTGpdk9W0kxNby4xMisaIzlFqryzLWidHHdHtdWmv6eJvb1sey02k7W2Z42ozzEvtFKpeKy2zwGrEaN2hHKw7lKOO1tlKTs22Wy9nAnA8twivrE1TR5CUxO/eZTvUJMzy/YlrHowT5y/Vstkb4VQayyptGgDrKVSl6axybkREdAmTKg+y1527Z1y41dSVK+0PgKq6KnvJka/JBHMNCzuLShx3Pq+LkvJLiZ1ZLu2Rp1ASoKqkp+pYbVvLTLiyLdYdyqmW3NgmPUpX8eAAX7td2h2yyeWqtuVJrTYt52h0rKaGnZabNSstMmpqgbEw5TDimgerKxWr3qsMZOaVWPWRUgiAAxZJuGWdlGUSprw/yanZKC2vtHqO/u0jqy0qsF11CVz6mTThUp8xpW7N1S17iIgaMrZUgP5LMu0t27ftD9UusilyC0txoVTbZMhSbdvMuMpRB3HlPNs2D8a4nlU9qRxROskD1t3LbVtKqNOouJSUKC0oHI0w2bY7sIzNNmmauzoVS34+qp5PjzZh6B0fUe057XVAd/Q+OMOVJHtEl2gA4tRK0N7xzfHANR2sFgzMGNoRT45KrOqrlZaDIYlR6BkXrr7PG9NyrJrOatXdnoiorvS+ftviSJUB2BvBSsuyngY8luu+YvSQID9ENg3A6bya2xy4wgdA86YBOFdUVi2hUJKNE+cvYmHKYRw9W4R9J/MQ0TQAM4d1skqcLEd5LLuX7z6Rh69/O4XC0gp1VMyy8aXlKj6rFW4WNUwXyyqtRoGU57FcMadsR3O+uNzqPPaczMe+U/lWo1bJqdlWnciVgbD6/NXiyqglIDhTUOrUPY/nFlXFavGelZRXqps2+5pMOHC6AIvv7qNOK9r2yLKdliUiauyYVBlEtfofD44fXiipwAWNpwPNANq1aIrcGgroBdZ9rU6cv4hpy3daLfdXEhPLZMfeJtImXFrlZ7lSz7LoHADW/1nDtPjuPtWmEZUkwbK9QY3n+OeU2Oc7TqjxKp3ILUenlOfUuo7N1vni8motFxyxnTZWzrmmnl2W9WGWqw3ZbZ2IqAqTKoNRprvOXHBuxMHInOmkbi93/HxHBtpGNLWa+rJcETd39YFqj2kW6Iv5E66oNmJi2QtMGV1RGoEqxe2Wq+Ys2xs4M20nqFqZmJZVoCZ2ynFlFCwuogkqzWZEhQbVO6lqF9kEGeeK7Y5gHTidX6+pxoUphxEVEmi1LY5twuSOfRjJGOqyEIOIrDGpMhDbzXoB7VfpeYMzF0qRGBNqlTi0DAlE9zZhAABfH59qj7lQWondJ/Kq1TcpPagsa9TMsG4mqlQV2o4WWrYgsGSv9sxyVZ1CmVZUpm7t3cdVx3KLHd5muVjAlr1id3ty/kzmzaiqGwPsX2zruiE1GZMrCzGIyDEmVR7maKuQz7dnYPeJvGr3b2wJFVBVr9QyJNBme5xStTllu4gmdh+3MOUwesaFW63WU/fI+zNBAKqKv5X6IUf1ViOTotWVcLa0LOZX9I5vjpLyShSVVODYOceJU130aBOGliGBSMu+gFPnLjqVXAHA3pP5apKv9KhSitmpYalp2peInMekyoPs/TUIoNbancbG589CKkfTWOeK7SealnsEKisGleewXElpFtjtMr7eomfUxbJK7DuZp8HZOGfX8fNu+3lo3bwJvt+XWW1qsLbVnkrNm+DSKJdl4koNh6PebETkmurzKOQ2tn8Nvr3hDzz06a96h2U4ZqmaAnS0p2GBnaJ6pf7q+Nmiqm1wnCgsGtAh0qpvlFIHtTDlMJZtOabJdJ2t6m1Oq1gmhCO6RGn2WiFBfupom+1b0i6yqZrAmgCEBFb/G8v2MUqc1LAoixAmD2rHqT+iemBS5UHKRVxJrPaczEdJhbOTMY3LnpP5ThW6K7q1rpreW38oB9OW78TRWlpQfL4jA1vTczGmW6zVceXTUD6ndpH2pxrrylGuZ7lptLKfnxavVdOqzvQzhWo7BQFw98B2AC7tnegoTo5iNEwjk6Lx7NgkJlRE9cDpPw+y7Ef19e5TDa5eys8H0CNH9DWZUPFnVbuStKSfqTmpWncwR53aclTEXSmCQjc2W7WlbBptr7bOHQpLqzqst2oejBt6tFJrpb7ZcwonzlUfpTMBGN6FBeqNhTOrAblikMgaO6pDn46sN771k9M9hbxVWLAfKs0CswiKy9ybbfWOb+7SyJZR6XkeM4Z2rNb/S6FMr3JqqHGw3RnA3ufuzH3q+tpM1MhZRuuozuk/ncwc3knvENyutNyMwtJKtydUgHM9sbyBnuexbIv9FhJjusViyqAEJlSNiL3VgHW5j6uURG3ZlmOYtnxnVX0kkRdhUqWjEV2iMKJLFGYM7ah3KG7RkOvF4iKCG9znpkwHKtpGNMHiu/vg5itag+PZjYtt/ae9Ojpn7uMqdyRqRJ7E6T94fvhQ+WtMqeWZMbQjesaF4+0Nf+BU3sUGV2tlNB1aNq215qo2yqjNjW//ZNWuoSFRenvtOZmvTv+xT1Xj4UzXfK0767trSpEaLqNN/zGpguc/lLmrU7H056NWxdHKxWru6lSHnbwbutr6JlnyMQEBvj51Gg2rT5f6Fs0CMG98dwBVf1UHB/g6rENy9Pii0kpcLK+s/c4GZdkklQjQtg6KWyCRK4yWVHH1nw6URnuWlKaKWQUlOkWlP3sJlaPCbbMApXWcXqzPSKDS7sBypNGV4vLW4cGGHNlqGuCDIidr3yw3peZFj7Te4oZbIJE3Y02VDpQtUGz947tUu9uiNGYlNYzoKB2/PWlhymF8vj3Dqg3DruPnnY7jXHGZVR+oFs0C0KJpgNV9mgT4VDvmbs4mVEDV+856F1KwDoroEiZVOokJDap2Ia5ps9zGynLjY3vcNXdtuVegJR8TAJOpWl8rZ+M4e6EMlSLqP7yzhWU4W2Q9clZcZq52TG+WP6vcyoQsaVGwnpyajbmrU7naj7wep/90sudkntsSgoaktmm1qJAA5FzQNgFpF9nEYW2XWYDzxWUI8PVBWaXr049KLVVEPeq69KD8rIYE+aFfQgQm9GVNFVWxbGpclzooracPifTEkSodPPjJrw2mr5LetE6oACC3qAzHatjmZtfx83VKqCwVXCyv1+P1cqGkAusO5ugdBhlMfba44fQhNSRMqjwsOTUba1g3VW/+Pu6rpqppvzytlFV69zglL3ykFXf0uyLSC6f/PEgZ5qb6Kzd7d1Li7XjhI63Ud/qQyEiYVHlIcmo23kj+Xe8wiOpF6dPFCx9piW0UjI97MjqHSZUHKCNUnl7+T6Q1FqgTNT5cTOA81lR5gFKIyQkr8nY//XFG7xCIyMO4mMB5TKo8QCnE5EgVebs9J/Pxyto0vcMgD2H/KAK4mMAV3PsPntk76JW1aS7tEUdkVJe3CsV3D1+ldxjkZtzcuGGqa22UUfdk5N5/jVRaZgFMcF8HcCJPGZIYpXcI5AH2pnyMdDEl19WnNoqLCZzD6T8PSE7NxrpDOUyoyOu1i2yCJ0cl6h0GeUBtUz6cGvQ+rI1yPyZVHrA1PZf1VNQgHMst5kW0kVD6R00e1K7aiIYy4rFsyzFMW76TPxNegrVR7sfpPw8Y0CESH/18VO8wiOrNxwROAzUijqZ8ODXondho1f2YVHnAyKRohAX5Id8D258QuZNZ2E3dSPRqyKj8ocgRD+/D2ij3YlLlAa+sTWNCRQ1Cu8im/IVsEHo2ZOSIB5F9TKo84Js9p/QOgUgTHaOa6h0C/Wlrei58TECliC7TshzxIG5dUx0L1T2gtKxS7xCINJEYE8oVXwYRHOALZV9xswBB/r76BkSNChcr2MekygMCA/jLjhqGhSmH+UvUIC6WVaq/wH0AlJTzjzfyHLZnsI9JlQcE+PJtpoaBv0SNY0CHSJhR9ZmYYcwFBOxl1XC50p6hMf0ccJsauLfNPbenoYaG25YYh1G3DgG4zU1j4MzPn7t/DrhNTSPz+fYMvUMg0gxXfBmLvWJxoxQPO9PLyiixUt04s1ihsfU0Y1LlZgUl5XqHQKQZrvgyNj3bLNiqrZeVvVgBaJpkNeakzSjn3th6mjGpcqNX1qahrLLRz65SA+HDvZYMzxOjAs5erGvrZWUb6+c7MrDuYI5mCaGREkxPM9K5N7aeZqygdqONh3L0DoFIM+/d1UfvEKgW7t7bzdVl9COTovHs2CS7F1LbWAHXFkLUVvzcmFenGe3ca/o5aGiYVLlREFspUAPSGH4heruaNkHWgpYXa9tYJ/Rt69JqstqSu8a8eXBjPne9cfrPTZJTs7Hr+Hm9wyDSBLuCuEbPehZ31r1pXR9jG6uz00TOTHM2tmknS4353PXWYJKqhQsX4pVXXkFWVhZ69OiBt956C1deeaVu8ShbSJhZUkUNwKjLY/UOwWsYqZ5Fa+6+WDubEDqb3DXmhRWN+dz11CD+/vz888/x+OOP47nnnsOvv/6KHj16YNSoUcjJ0a+maUCHSJgFYG2vscSEBlY7Fhrkhx5twtA2ogliQgPh6wME+JoQFVL9vs4I8DV53eceGuSHAF9TtWJ0E4Ax3WLxzsReusTljYxWz6I1I9THuHuak6iuGkTzz379+qFv3754++23AQBmsxlxcXF46KGH8PTTT9f6eHc1D1MaowX5+yItqwBnLpQCAFqGBCLAzxff78vU7LW0EBbsh/yLFW57/h5twjBzWCfsPpHnloaoNY0MKq89Mim6WkPWGUM74slRiXYfZ9ncDoD6ef70xxmcLy5D19bh+H5fpvraynMpoxU+AMyoSkxOnS/GnpP56nO3i2yCv11fdXF68JNfHf48BPv74LLoELRu3sTqPj3ahKnHlNfp0SYMLUMCcb64HL9nXUBwgC9y/vy5s/dejegShQl921pdlIzcUNIbsOklkecYrfmn1ydVZWVlaNKkCf773//ipptuUo9PmjQJeXl5+Prrr6s9prS0FKWlly40BQUFiIuLc/uHYvvLdsbQjurFeVyP1ugZF47Pd2TgcE4RjuUWqY/rHd8czZv4Y/eJPJwtLANQdVHsEhuK+Mim2H8qHyXlFQjy98O4Hq0AoNakpXd8czxwTQd8viMDgAkT+sYBAKYt3wkTAAEwoks0Avx8rC7kSsyn8i6idXgwBndqafVaY7rFoqyiUj0H5bmU/yoXmFfWpuGbPacQ0SQAgzu1RFrWBQCCCX3bAqhKXjLzS3A8twhB/r4oKa9EkL8vdh0/rz6XpTHdYhEbFmSV/CiPH5IYVS1pemVtGjam5di9zVWOkhB7x2t6Xcsk/Lu9p5FbWIqrLouyGiWy95y1JUHJqdnqcnXLz3ZC3zhe7N2EiSmRZxgtqfL6mqqzZ8+isrIS0dHWv7iio6Nx6NAhu4+ZN28e5syZ44nwrNhOC5SUV+LrmYOt7jMyKRpzV6di2ZZj6v16xoXj2bFJ1ZKyR0dcZvcX9tzVqXYTD4XynLZz7nNXp1rFFx/ZBCKoMWbbx8SGBeHZsUlW54A/Y7EsKH1yVGKNyYyj89qdkYdKEXV6TXle5XVreryl2l7fFY5qF+wdr+l1Le/vzH1qe33L221/9uIjm/Bi70asZyFqnBpETZWrnnnmGeTn56tfJ06c8MjrOrvM1dH9nK0jGNAhslpCpSQhPiY4fG17r1tbzI5uV44rNTo+cPy6zrJ8LcGlhIpLhmvHJdZERO7XKKf/bHly+NDZaQFX7mdv6XbVlM8JAILEmFB1+qykvLLWzS/rMr1U0/SXM6/r7PnZq3Gq7xSLUbZzcBfl/IID6v45EBEZkdGm/7w+qQKqCtWvvPJKvPXWWwCqCtXbtm2LmTNn6lqo7m7OFsR6a9LgiYLfhl5U3NDPj4gaN6NdvxvE9N/jjz+OxYsXY9myZTh48CCmT5+OoqIiTJkyRe/Q3MqZpduubithJJ5Ymq7Va9S2ZYZeGvryfiIiI2kQSdWECRPw6quv4u9//zt69uyJ3bt3Y82aNdWK1xsaZ+pkvPmi6ok6IC1ew8iJK2upiIg8p0FM/9WX0YYPXeFMvZM3T/94Yml6fV/DdrXm5EHtrFYi6o3L+4mooTLa9ZtJFYz3oWiNF1X38vbElYjIWxnt+s2kCsb7UBoyby2arw0TVyIizzPa9ZtJFYz3oTRUHNEhIiItGe363SAK1ck7eHPRPBERUW2YVJHHcCUaERE1ZF6/9x95D2WbHdYeERFRQ8SkijyKG80SEVFDxek/IiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg1w7z8AIgIAKCgo0DkSIiIicpZy3Vau43pjUgXgwoULAIC4uDidIyEiIiJXXbhwAWFhYXqHAZMYJb3TkdlsxunTpxESEgKTyaTZ8xYUFCAuLg4nTpxAaGioZs/rCYxdH94au7fGDTB2vTB2fTS02EUEFy5cQKtWreDjo39FE0eqAPj4+KBNmzZue/7Q0FCv++FVMHZ9eGvs3ho3wNj1wtj10ZBiN8IIlUL/tI6IiIioAWBSRURERKQBJlVuFBgYiOeeew6BgYF6h+Iyxq4Pb43dW+MGGLteGLs+GLt7sVCdiIiISAMcqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIjIArhvzfkyqvIzZbEZlZaXeYdRJaWkpdu/eDQBedw7l5eU4efKk+r03/fIzm80wm816h+GykpISLFiwABs2bNA7FJd5879Tb/rZtlVWVobff/8dALzuZ76iogLnzp3TO4w68eafmZKSEnz44Yf47bffNHk+JlVeZP78+Rg2bBjuuOMOfPnll8jPzwfgHb88jh49imbNmuGmm25CXl4efH19vSJuoOp979GjB26++WbcdNNN2L9/P0wmk1fEv2DBAtxwww2YOHEi/vOf/6g/M0b3zjvvICoqCt988w3y8/NRUlKid0hO8+Z/p2+88QZuuOEGPPjgg9i2bRvKysr0Dslp+/btQ3h4OKZPn44LFy7Ax8fHay728+fPR58+fTBu3Dg89NBDOHLkCADvSFYWLlyI22+/HTNnzsSPP/7oVT8zb7/9NqKiovD555/jzJkzmsTOpMoLlJeXY/LkyXjzzTdx0003obCwEH/729/w0EMPAYAhNpGszaFDh5CQkID4+Hi8/PLLAKDp5tXucOHCBdx2221YtGgR5s6di3vuuQf5+fl45plnABj7fd+3bx8GDhyIhQsXYujQocjLy8OLL76It956S+/QarV27VosXrwYixYtwrp163DzzTcjKCjI8BcYb/53WlRUhFtuuQVvvvkmrrjiCuzcuRN33XUXXnjhBb1Dc9r27dsRGhqKgIAALF26VO9wnHL27FmMGzcOixYtwlNPPYWRI0di586deOONNwAY+3fkb7/9hr59++Ktt95Cp06dsG3bNtx///1YuXKl3qE5ZcWKFXjvvffw/vvv43//+x+uvfZaBAQE1P+JhQwvLS1NOnfuLGvXrlWPLVu2TMLDw+Wdd94REZHKykq9wquR2WwWEZFPP/1Uxo0bJ88//7x06dJF9uzZIyLGjVtE5Oeff5bOnTvL3r171WNPPPGETJ48WUSqzk05PyPJy8uTRx99VO688045e/asenzq1Klyxx13SHFxsY7ROab8LDzwwANy1113iYhIRkaGLFq0SNavXy9HjhwRETHkey7i3f9Ot2/fLp06dZJff/1VPfb3v/9dOnToIJ999pmOkdVO+XlYtGiRTJkyRSZNmiQjRoyQw4cPi4hx33MRke+//14uv/xyOX78uHps/Pjx8uSTT4qIcX/WMzMzZcqUKTJt2jTJy8tTj1911VXyyCOPiIhxY6+oqBARkVtvvVV9n0+ePCmffPKJ7NixQ7KyskSk7j83xv3TidTpgvLychw5cgTt27dXbxs/fjwefPBBPP300yguLjbcX8Hy56iC8pfW9u3bMWLECNx1111o2bIl/vnPfwIw5l/vyvteWFiIjIwM+Pv7q7ft378fbdq0wYEDB2AymQz1l6Tlex4REYEHH3wQkZGRKC8vBwB06tQJO3fuRHBwsJ5hVqPE7ePjg4qKCmzZsgXjxo3Dl19+ie7du+Ozzz7D5MmTMXz4cBw6dMhQ7zng3f9Oldjz8vKQm5uLli1bqrfde++9GDJkCJ599lm9wquR7e+Y5ORkjBo1Cvfeey8uXLiAjz76CICxf8ecPHkShYWFVqOwhYWFaNeuHU6dOmW4n3UlzoCAADRr1gwPPPAAwsLCUFpaCgDo06cPduzYAcC4o2y+vr4oKyvDtm3bMHbsWHzyySfo3r073nnnHYwbNw7jxo2r179V4/20NXJffPEF3nvvPezdu1etI8nLy8Pll1+OlJQU9X7NmjXD1KlT0aJFCzz//PMA9K/ZsBe7MkfdpEkTXLhwAQkJCZg8eTJ2796Ne+65B1OnTsXZs2f1DBuA/dgjIiLQt29fjBo1Ck888QQiIiJw9OhRpKSk4Prrr8e0adN0jrrKtm3bAECt8woNDcWsWbMwYMAAAICfnx8AIDs7Wz1mBJZxA1U/v35+fkhKSsJ7772HlStX4sMPP8SaNWuwefNmxMfH47777kNeXp6OUVdZu3YtVq9ejSNHjqCiogIAkJ+f7xX/TlevXo0vvvgCGRkZajF9fn4+WrdujYMHD6r3i4uLw8SJE+Hj44PXXntNr3CtKLEfP35cjV25oLdo0QKVlZUYOHAghg0bhp9//hkzZszAE088oWfIKnuxx8TEIDo6Grfeeiuee+45REREID09HYsWLcKIESMwe/ZsAPr/zOzbtw/Apd8xEREReOWVV9CrVy8AUPfiO3HiBK666ird4rRHiV0hIqioqED37t3x/vvvY8WKFVi6dCm+++47rFy5EsXFxbj77rsB1PF9r+dIGmkkPT1d+vTpI23atJErrrhC2rRpo06BlJaWypAhQ2TKlCly6tQp9TEXL16UZ599Vnr16iX5+fl6hW439kmTJlndZ+DAgfLNN9+IiMjHH38s4eHh4uPjIwsWLBAR/YaKa3rfRUROnDghq1atkiuvvFKee+45KS8vl7y8PElJSRGTySS7du3SLf69e/fKwIEDxWQyyX/+8x8RuTS0bS+m0aNHy5tvvmn3Nk+qKW6z2Swvv/yytG7dWjp27CjZ2dlqrOnp6WIymWTr1q26xb59+3bp1q2bdOzYUZKSkqRjx47y0ksviYhISUmJXHPNNXLPPfcY8t/poUOHpGfPntKmTRvp3LmzdOzYUf7617+KiEhxcbG0bdtWnn76aSkqKlIfc/bsWZk8ebKMHz9e12lje7HPnj3b6j5du3aVn376SUSqpgJDQ0PF399f998xNb3vFRUVsnPnTlm8eLF06dJFXn75ZSkpKZGTJ0/KkiVLxGQyWU0Netru3bulX79+0qpVK1m3bp0as8LyPTWbzTJw4ED137Teaoq9oqJCHnjgAYmNjZWBAwdKaWmp+rj169eLyWSSo0eP1ul1OVJlEP/9738RGBiIgwcP4n//+x/efPNNfPHFF3j22WcREBCAe++9Fxs2bEBycrL6mKCgIDRv3lz3JfP2Yl+5ciXmzJmDixcvAgA6duyIwsJC3HjjjZg6dSr69euHzp07q6MoesXv6H1//vnnUVpaijZt2qBt27Y4fvw47r33Xvj5+SEsLAxdu3ZF69at1eX+nh7q3rlzJ2bOnInIyEiMGzcO77zzDioqKuDr61ttWgSoKojdsmULevfurd6Wk5Pj0Zhri7uiogImkwnDhw9HdHQ0ioqKEBUVBZPJhIqKCrRo0QIJCQlqWw5PW7t2LaZOnYrRo0djx44dWL16NW699VZ88cUX2L9/PwIDAzFp0iSkpKQY8t/pkiVLEBUVhQMHDmDt2rV44IEH8MYbb+D9999HcHAwHn74YSxatAg7d+5UHxMZGYmIiAjk5OToOm1sG/v999+P+fPnY8mSJQCAgoICJCYmQkQwbtw4PProo+jatSu6d++O1q1bA9BvJZ292N944w18+OGH8PX1Re/evdGhQwcUFRXh3nvvRWBgIFq3bo3evXujVatW+Omnn3SJ+8cff8S0adMQFhaGyy67DB9//DEqKysd/o45fPgw9u3bh65du6rHzp8/7/G4gZpjV37f3HLLLaioqEBeXp5VgbryO3/Pnj11e/F6pYKkiYqKCunVq5fMmjXL6vh7770nAQEBsnnzZhERufHGG2X48OGSnJys3ufFF1+UwYMHS0lJiUdjVtQUe2BgoGzcuFFEROLj48VkMsnYsWMlNTVVcnNz5aGHHpI2bdpIZmamHqHXGHtQUJCkpKSIiEhycrIMGDBAduzYod4nOTlZunTpYlXE7knnz5+XmTNnyoEDB2TlypXSo0cP+ec//yki9gssV6xYIR06dBCRqtGHe+65R7p27Wo1oqJ33JZ/AS9cuFCCgoKsRiN+/PFH6d69u1qA7EkVFRWyePFimTlzppw9e1b9C33dunXSoUMH2b9/v3rfG264QUaMGGGof6fFxcXSpk0bef3119VjpaWlMnv2bAkLC1NHQ7p16yY33XSTupBEROThhx+WcePGSXl5uafDFpGaY2/evLk6ohASEiImk0lGjx4taWlpcuLECRk/frxcffXVkpuba8jY09PTRUTkww8/lJEjR1qNSn355ZeSlJRU5xGT+srIyJD77rtPDh8+LK+88or069dPli9fLiLVR6hERBYsWCA9e/YUEZHc3FyZMmWKXH/99XLmzBlDxW75e+app56SFi1ayNtvv60e++6776RHjx5qwbqrmFTpTLkAXnfddXLrrbdaHRMR6dOnj4wdO1ZERPbs2SPjx4+XiIgI+etf/yrPPPOMNG/eXBYuXOj5wMW12Ddv3ixfffWV1S/m77//XmbNmiXnzp3z+NC8M7HfeOONIlI1jHzVVVdJv379ZPHixTJ37lyJiYmRmTNnSnFxscdjV15PmaY5f/68PProo9KtWzfJyMgQEetfHCIic+bMkalTp8r8+fMlJCRE+vfvL7///rvh4laG4c+fPy+vvPKK+Pr6yrBhw+T++++XqKgomTlzply8eFGXqZwDBw7I+fPnrY5lZGRIdHS0pKWlqcf27t1ryH+nAwcOlEcffVRELn0W+fn50qlTJ5k2bZqIiGzatEkGDBggnTt3ljfffFOef/55iYiIkE8++cSwsT/wwAMiIvKf//xHvvnmG6uf/UWLFslTTz0lBQUFHo7ctdg3btwoHTt2lPHjx8sXX3whL730ksTExMhTTz0lpaWluk1dXrhwQURETp8+LX/5y19k7Nixkp2dLSLV/3ibMWOGzJ49W9544w0JCQmRvn376vIHkKKm2JXfMxkZGfLQQw+JyWSS22+/XR555BGJioqSp59+WsrKyur0vjOpMoDKykp59dVXpUePHrJv3z4RufShJycni4+Pj/rXSm5urjz33HNy++23W9Up6cWV2BXKD6reS26diV1Zxr9mzRq5+eab1eRq9erVusVtSfnFlpKSIoMGDZLp06dXu09ZWZlcccUVYjKZJD4+XlatWuXpMKtxJm4RkVWrVsnzzz8vt912m3z77beeDNEhy1YaH330kSQlJUlZWZnVReb8+fOG+ndaUlIiDz74oIwZM0b9mVbi/eCDDyQoKEjOnTsnIiKpqakyffp0GT16tFxxxRW6/6zXFntwcLDVsn6RS79bbP+48DRX3vfFixfL0KFDpU+fPtKrVy/d33eF8h5+/PHH0r9/f5k3b161+5w/f15at24tJpNJ2rRpI19++aWHo7TPmdhFRN5//3155JFH5Prrr6/3+86kyoPsTcso//hTUlLkqquukocfftjq9ry8PElMTLQanhTx/C+L+sSu11/oivrE/tZbb1kdr+uQcF052yultLRUXnrpJUlMTFSLdZVRwQsXLsiUKVPk/fffd1uctuobt54JtzOxK/FNnjxZ7r//fof389S/05piVmJdsWKF9OrVS+bPn291+759+6Rz587Vkm3lL3130yL2r776yq0xOqJF7F988YXVcU9N9zn7b1Q5j+LiYpk2bZoMGTJELXtQfr7PnDkjw4cPl/fee889wdrQInZ3TWezUN3NPvjgA7z33nsA7PdLUQr9hgwZgquvvho//vgjvvjiC/X2s2fP4vz584iLiwNwqdjS19fX3aFrFnubNm3cHqstrWJv27YtgEuF9NHR0e4OvdbYbYkIAgICMHbsWFx22WV47bXXkJGRgbvuugvfffcdmjVrhg8++MDtLSC0jHvt2rVujdWWq7Er9u/fj0GDBgGo6i/0zDPP4PDhw+rtnvh3On/+fEycOBEzZ87Etm3b1L5kYlNMPGHCBCQmJuL777/Hxo0b1ceXlZXhxIkTiImJsXpcs2bNvCb2qKgot8fqrthjY2MBXPod065dO91jt6S0UQgODsZtt90GEcHSpUtx/PhxTJw4EXv37kWLFi2wZs0a3HfffV4T+5133onU1FTtA3RLqkaye/duGTZsmJhMJhk6dGiNS++VrPv333+Xe+65RyIjI+X777+XI0eOyGuvvSbdunXzaP0LYzd+7I4sWLBAgoKCxM/PT9q3b++R+L01bpH6xX7kyBFJSEiQI0eOyIcffijh4eFy+eWXy7Fjx9wdtoiIbN26Vbp37y7dunWTZ599Vrp16yY9evSQlStXVruv8rO+bds2uf766yUpKUl27dolWVlZ8uKLL8rAgQPl9OnTHombsXtH7I488cQTEh4eLoGBgdKuXTs5fPiwR0aWvSV2JlVuUFlZKS+99JLceuut8v7778uVV14pf/vb39Thxpo+xDNnzsiECROkffv20q5dO4mNjZWvv/7aU6Ezdi+MXaRqKPvbb7+V2NhYadeuncdi99a4Reof+4IFC8TPz0/i4+OlefPm8vHHH3sibBGp6p82ceJEmTlzphQWFqrH+/btq/ZAchT/7t27Zfjw4RIXF6f+rH///fceiVuEsXtj7CJVtZlffvmlxMbGSkJCgkfrprwpdiZVGlM+2AMHDsiPP/4oIiL/93//J4MHD5YffvjB6j41yc7OVtsReApj997YL168KNddd50888wz7g3WgrfGLaJN7HPnzpUmTZrICy+84N5g7Th16pTMnDlTXWChtGq45557ZNSoUXYfY3k+paWl8scff3j0oq5g7N4Tu6WioiLp3LmzPPXUU26N0x5vit0kYvCt373AihUrcOHCBQwcOBAdO3ZEYGCg2mgMAI4ePYo777wT3bp1wz/+8Q9ERkZCRBw2jKzpNsbO2G2ZzWb4+PigvLzcap9Cxu2+2IGqeqr4+HiEhIR4NPb27dsjODgYFy9erNaQc8yYMRg0aBD+9re/uT0mZzF2fWgZu/LvpLS0VN2Sxp28OXaOVNVDamqqdO3aVdq1ayfdunWTtm3bqn1HFMrqiNdff1369OkjS5cu1SPUahi7Prw1dm+NW6Rhx247CtKrVy91pE1vjF0fjF1fTKrq4e9//7sMGzZMLl68KFlZWfLZZ5+Jv7+/vPLKK2pdhvLLuri4WEaPHi233nqr2hDtwIEDIqJPvybGztgbQ9yNIXalGPq3336T0NBQtR+SiOjWSVyEseuFseuLSVUdXbx4UTp37qxupqp49dVXJSQkxGrTV+UX9hdffCF9+/aVxx57TMaOHSuRkZEe73skwtgZe+OIW6TxxC5StRXOoEGDREQkMzNT7rjjDhk/fny1xpiewNgZu6u8OXZLTKrqQMmUBw8eLFOnThUR6yZ/Xbp0kTvvvLNag7KzZ89K27ZtxWQyyZgxYzy29NoSY2fsrvDWuEUaX+xTpkyRl156SV5++WVp0qSJXHXVVXLixAnPBi6MnbG7zptjt8Wkqo7Ky8tl7ty50qtXL3WaQNni5IsvvhB/f3+rjSQ3btwoJpNJLr/8cnW1kV4Yuz68NXZvjVuk8cSemZkp4eHhYjKZJCEhQdasWaNb3CKMXS+MXX/sqF4H5eXl8PPzQ+/evREUFIT3338fABAQEAAAuOqqq9C6dWt8//336mP69OmDBQsWYP/+/Rg8eLAucQOMXS/eGru3xg00jti/++479TE9e/bE0qVLceTIEYwaNUqXuAHGrhfGbhB6Z3VGpGzcaluYam8fr1mzZskVV1xhtQJh79690qJFC1m3bp3Dx7kLY2fsrvDWuEUYu2Xs9p7LXRg7Y3eVN8fuKiZVFlJSUqRTp05iMpnUnartbdy4YsUKad26tWzcuFF+//13ueOOOyQ2Nlb+97//ydGjR+WFF16QXr16yfHjxxk7Yzdk7N4aN2Nn7IydsRsZk6o/7dy5U2644Qa599575dZbb5XLLrvM6naz2Sy5ubly3XXXSVRUlMyfP1/KyspEpGp+94YbbpAOHTpI27ZtpU2bNvK///2PsTN2Q8burXEzdsbO2Bm70TGp+tOJEyfktddek0OHDklqaqo0b95c/vWvf4nIpcz64sWLsnDhQsnMzKz2+IqKCsnKypJNmzZ5NG4Rxs7YG0fcIoydsbuOsTN2T2q0SdWWLVuq7Q6uZMlms1lefPFFadasmdpMTGk85oi9IU13YeyXMPbaeWvcIozdEmN3DmO/hLF7XqNLqtatWycJCQkSHx8vbdq0kWnTpklaWpqIVH3wSvHbqVOnpEuXLjJ58mT1Nr0xdn14a+zeGrcIY9cLY9cHY284GlVSlZGRIf3795dnn31WDh8+LCtXrpT27dvL+PHj1QZ/ltnzp59+KiaTSX799VcRqcq6CwsLGTtjN3zs3ho3Y2fsjJ2xe7NGlVT973//k+DgYLWxmEhVU7Grr75a7r//fvWYkkEXFBTI6NGj5ZprrpG9e/fK6NGj5d133/Xo0mvGztgbU9yMnbEzdsbuzRpVUrVixQrp1auXOjQpUlUM949//EOSkpJk48aN6jHFqlWrxGQyiclkkqFDh8q5c+c8HrcIY2fsjSNuEcbO2F3H2Bm7UTSqpGrfvn0SFBQkX3/9tdXx3377TUaNGiWPPfaYeqysrEyWLVsmgYGB0rdvX9mxY4enw7XC2PXhrbF7a9wijF0vjF0fjL1haVTb1HTt2hVDhw7F/PnzUVhYqB7v2bMnoqKicOTIEZjNZgBAUVER9u/fjzfeeAPbt29Hnz599AobAGPXi7fG7q1xA4xdL4xdH4y9gdE7q/O03bt3i5+fnyxatEjdrFFE5G9/+5t07NhRx8hqx9j14a2xe2vcIoxdL4xdH4y94fDTO6nztB49emDWrFl44YUX4O/vj9tuuw1msxk7d+7EnXfeqXd4NWLs+vDW2L01boCx64Wx64OxNyB6Z3V6efDBByU2Nlb69esn8fHxkpSUJAcOHNA7LKcwdn14a+zeGrcIY9cLY9cHY/d+JhERvRM7PZSUlODgwYP49ddfERgY6FUZNWPXh7fG7q1xA4xdL4xdH4zd+zXapIqIiIhIS41q9R8RERGRuzCpIiIiItIAkyoiIiIiDTCpIiIiItIAkyoiIiIiDTCpIiIiItIAkyoiIiIiDTCpIiIiItIAkyoiarCef/55REdHw2Qy4auvvnJ4zBXHjh2DyWTC7t27NY2ViLwfO6oTkUsmT56MZcuWAQD8/PwQERGB7t274/bbb8fkyZPh42OMv9UOHjyIpKQkfPnll+jfvz+aN2+OI0eOVDsWGBioPub555/HnDlzanzeiooKnDlzBi1atICfX6Pbk56IamCM335E5FWuu+46ZGZm4tixY/jhhx8wdOhQPPLIIxg7diwqKiocPq68vNxjMaanpwMAbrzxRsTExCAwMNDuMUtPPPEEMjMz1a82bdpg7ty5Vsd8fX0RExPDhIqIqmFSRUQuCwwMRExMDFq3bo1evXrhr3/9K77++mv88MMPWLp0qXo/k8mERYsW4YYbbkDTpk3xj3/8AwCwaNEidOjQAQEBAUhMTMS///1vq+dXHjd69GgEBwejffv2+O9//2t1n3379mHYsGEIDg5GZGQk7rvvPhQWFgKoGnEaN24cAMDHxwcmk8nuMVvNmjVDTEyM+uXr64uQkBCrY7bTfxs3boTJZMLatWtxxRVXIDg4GMOGDUNOTg5++OEHdOnSBaGhobjjjjtQXFysvpbZbMa8efOQkJCA4OBg9OjRo9o5EpGXESIiF0yaNEluvPFGu7f16NFDRo8erX4PQKKiouSjjz6S9PR0OX78uKxatUr8/f1l4cKFkpaWJq+99pr4+vrKhg0brB4XGRkpixcvlrS0NJk9e7b4+vpKamqqiIgUFhZKbGysjB8/Xvbt2yfr16+XhIQEmTRpkoiIXLhwQZYsWSIAJDMzUzIzM+0eq018fLy8/vrrVseOHj0qAOS3334TEZGUlBQBIP3795effvpJfv31V+nYsaNcc801cu2118qvv/4qmzdvlsjISHn55ZfV53nxxRelc+fOsmbNGklPT5clS5ZIYGCgbNy40YlPgYiMiEkVEbmkpqRqwoQJ0qVLF/V7APLoo49a3WfgwIEybdo0q2O33nqrjBkzxupxDzzwgNV9+vXrJ9OnTxcRkffff1+aN28uhYWF6u3fffed+Pj4SFZWloiIfPnll2L7d6O9YzVxJalat26dep958+YJAElPT1eP3X///TJq1CgRESkpKZEmTZrIli1brJ576tSpcvvttzsdHxEZC6f/iEgzIlJtWq1Pnz5W3x88eBCDBg2yOjZo0CAcPHjQ6tiAAQOqfa/c5+DBg+jRoweaNm1q9RxmsxlpaWn1Po+66N69u/r/0dHRaNKkCdq3b291LCcnBwBw+PBhFBcXY+TIkWjWrJn6tXz5crXui4i8DystiUgzBw8eREJCgtUxy8SnIfP391f/32QyWX2vHDObzQCg1n599913aN26tdX9bIvnich7cKSKiDSxYcMG7Nu3D7fcckuN9+vSpQt+/vlnq2M///wzkpKSrI798ssv1b7v0qWL+hx79uxBUVGR1XP4+PggMTGxPqfhEUlJSQgMDERGRgY6duxo9RUXF6d3eERURxypIiKXlZaWIisrC5WVlcjOzsaaNWswb948jB07FnfffXeNj33yySfx//7f/8MVV1yBESNGYPXq1Vi1ahXWrVtndb+VK1eiT58+GDx4MD755BNs374dH374IQBg4sSJeO655zBp0iQ8//zzOHPmDB566CHcddddiI6Odtt5ayUkJARPPPEEHnvsMZjNZgwePBj5+fn4+eefERoaikmTJukdIhHVAZMqInLZmjVrEBsbCz8/PzRv3hw9evTAggULMGnSpFqbf950001488038eqrr+KRRx5BQkIClixZgiFDhljdb86cOVixYgUefPBBxMbG4rPPPlNHs5o0aYK1a9fikUceQd++fdGkSRPccsstmD9/vrtOWXMvvPACWrZsiXnz5uHIkSMIDw9X21MQkXdiR3UiMhyTyYQvv/wSN910k96hEBE5jTVVRERERBpgUkVERESkAdZUEZHhsCqBiLwRR6qIiIiINMCkioiIiEgDTKqIiIiINMCkioiIiEgDTKqIiIiINMCkioiIiEgDTKqIiIiINMCkioiIiEgDTKqIiIiINPD/Ac/cgJZN/ynwAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -494,10 +560,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 9,
    "id": "8349334c3a180ee9",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:50.364258Z",
+     "iopub.status.busy": "2024-08-28T17:27:50.364103Z",
+     "iopub.status.idle": "2024-08-28T17:27:55.090457Z",
+     "shell.execute_reply": "2024-08-28T17:27:55.090158Z"
+    }
    },
    "outputs": [
     {
@@ -511,7 +583,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAHQCAYAAACIk59EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABpgElEQVR4nO3deXxU5dUH8N9kD5CFBLIAIayGRFkFWVU2RTZLsb6oKKAWFcG6VKW2qIi+okXRUhHrCrQqlleoxQUadisgm6yBKGEJSzYCSUjIPuf9I9zLzGRmMpPcmbk3+X0/Hz6aWc+dmcw9eZ7znMckIgIiIiIiahA/XwdARERE1BgwqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSQIAvn3z+/PlYtWoVjh49itDQUAwaNAivv/46kpKS1NsMHToUW7Zssbrfww8/jPfee0/9OTMzEzNmzMCmTZvQokULTJ06FfPnz0dAgGuHZzabce7cOYSFhcFkMmlzcERERORRIoJLly6hTZs28PPz/TiRT5OqLVu2YObMmejXrx+qqqrwxz/+EbfeeivS0tLQvHlz9XbTp0/HvHnz1J+bNWum/n91dTXGjh2LuLg4bNu2DVlZWZgyZQoCAwPx6quvuhTHuXPnkJCQoN2BERERkdecPn0a7dq183UYMOlpQ+W8vDzExMRgy5YtuOmmmwDUjFT16tULb7/9tt37fPfddxg3bhzOnTuH2NhYAMB7772H2bNnIy8vD0FBQXU+b2FhISIjI3H69GmEh4drdjxERETkOUVFRUhISEBBQQEiIiJ8HY5vR6psFRYWAgCioqKsLv/000/xj3/8A3FxcRg/fjyef/55dbRq+/bt6N69u5pQAcCoUaMwY8YMHD58GL179671POXl5SgvL1d/vnTpEgAgPDycSRUREZHB6KV0RzdJldlsxhNPPIHBgwfjuuuuUy+/5557kJiYiDZt2uDAgQOYPXs20tPTsWrVKgBAdna2VUIFQP05Ozvb7nPNnz8fL730koeOhIiIiJoi3SRVM2fOxKFDh/Df//7X6vKHHnpI/f/u3bsjPj4eI0aMQEZGBjp37lyv53ruuefw1FNPqT8rw4dERERE9eX7UnkAs2bNwtdff41NmzbVWWjWv39/AMCxY8cAAHFxccjJybG6jfJzXFyc3ccIDg5Wp/o45UdERERa8GlSJSKYNWsWVq9ejY0bN6Jjx4513mffvn0AgPj4eADAwIEDcfDgQeTm5qq3SU1NRXh4OFJSUjwSNxEREZEtn07/zZw5E5999hm++uorhIWFqTVQERERCA0NRUZGBj777DOMGTMG0dHROHDgAJ588kncdNNN6NGjBwDg1ltvRUpKCu677z78+c9/RnZ2NubMmYOZM2ciODjYl4dHRERETYhPWyo4qtb/5JNPMG3aNJw+fRr33nsvDh06hJKSEiQkJODXv/415syZYzVld+rUKcyYMQObN29G8+bNMXXqVLz22msuN/8sKipCREQECgsLORVIRERkEHo7f+uqT5Wv6O1NISIiorrp7fyti0J1IiIiIqNjUkVERESkASZVRERERBpgUkVERESkASZVRERERBrQzTY11DCpaTnYnpGPgZ2jcUtKbN13ICIiIk1xpKoRSE3LwfTlu7Fs20lMX74bqWk5dd+JiIiINMWkqhHYnpEPf5MJ1SLwN5mw43i+r0MiIiJqcphUNQIDO0erCVW1CAZ0ivZ1SERERE0Oa6oagVtSYvHBlL7YcTwfAzqxpoqIiMgXmFQ1ErekxDKZIiIi8iFO/xERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQaYVBERERFpgEkVERERkQZ8mlTNnz8f/fr1Q1hYGGJiYjBhwgSkp6db3aasrAwzZ85EdHQ0WrRogTvuuAM5OTlWt8nMzMTYsWPRrFkzxMTE4JlnnkFVVZU3D4WIiIiaOJ8mVVu2bMHMmTOxY8cOpKamorKyErfeeitKSkrU2zz55JNYs2YNVq5ciS1btuDcuXOYOHGien11dTXGjh2LiooKbNu2DcuWLcPSpUvxwgsv+OKQiIiIqIkyiYj4OghFXl4eYmJisGXLFtx0000oLCxE69at8dlnn+E3v/kNAODo0aNITk7G9u3bMWDAAHz33XcYN24czp07h9jYWADAe++9h9mzZyMvLw9BQUF1Pm9RUREiIiJQWFiI8PBwjx4jERERaUNv529d1VQVFhYCAKKiogAAe/bsQWVlJUaOHKneplu3bmjfvj22b98OANi+fTu6d++uJlQAMGrUKBQVFeHw4cN2n6e8vBxFRUVW/4iIiIgaQjdJldlsxhNPPIHBgwfjuuuuAwBkZ2cjKCgIkZGRVreNjY1Fdna2ehvLhEq5XrnOnvnz5yMiIkL9l5CQoPHREBERUVOjm6Rq5syZOHToEFasWOHx53ruuedQWFio/jt9+rTHn5OIiIgatwBfBwAAs2bNwtdff42tW7eiXbt26uVxcXGoqKhAQUGB1WhVTk4O4uLi1Nvs3LnT6vGU1YHKbWwFBwcjODhY46MgIiKipsynI1UiglmzZmH16tXYuHEjOnbsaHX99ddfj8DAQGzYsEG9LD09HZmZmRg4cCAAYODAgTh48CByc3PV26SmpiI8PBwpKSneORAiIiJq8nw6UjVz5kx89tln+OqrrxAWFqbWQEVERCA0NBQRERF48MEH8dRTTyEqKgrh4eF47LHHMHDgQAwYMAAAcOuttyIlJQX33Xcf/vznPyM7Oxtz5szBzJkzORpFREREXuPTlgomk8nu5Z988gmmTZsGoKb55+9//3t8/vnnKC8vx6hRo/Duu+9aTe2dOnUKM2bMwObNm9G8eXNMnToVr732GgICXMsZ9bYkk4iIiOqmt/O3rvpU+Yre3hQiIiKqm97O37pZ/UdERERkZEyqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIA0yqiIiIiDTApIqIiIhIAwG+DoDqlpqWg+0Z+RjYORq3pMT6OhwiIiKygyNVOpealoPpy3dj2baTmL58N1LTcnwdEhEREdnBpErntmfkw99kQrUI/E0m7Die7+uQiIiIyA4mVTo3sHO0mlBVi2BAp2hfh0RERER2sKZK525JicUHU/pix/F8DOjEmioiIiK9YlJlALekxDKZIiIi0jlO/xERERFpgCNVBsLWCkRERPrFkSqDYGsFIiIifWNSZRBsrUBERKRvTKoMgq0ViIiI9I01VQbB1gpERET6xqTKQNhagYiISL84/UdERESkAY5U6QzbJhARERkTR6p0hG0TiIiIjItJlY6wbQIREZFxManSEbZNICIiMi7WVOkI2yYQEREZF5MqnWHbBCIiImPi9B8RERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWmASRURERGRBphUEREREWnAp0nV1q1bMX78eLRp0wYmkwn/+te/rK6fNm0aTCaT1b/bbrvN6jYXLlzA5MmTER4ejsjISDz44IMoLi724lEQERER+TipKikpQc+ePbF48WKHt7ntttuQlZWl/vv888+trp88eTIOHz6M1NRUfP3119i6dSseeughT4dOREREZCXAl08+evRojB492ultgoODERcXZ/e6I0eOYO3atdi1axf69u0LAPjrX/+KMWPG4I033kCbNm00j5mIiIjIHt3XVG3evBkxMTFISkrCjBkzkJ+fr163fft2REZGqgkVAIwcORJ+fn748ccfHT5meXk5ioqKrP4RERERNYTbSVWnTp2sEhtFQUEBOnXqpElQittuuw3Lly/Hhg0b8Prrr2PLli0YPXo0qqurAQDZ2dmIiYmxuk9AQACioqKQnZ3t8HHnz5+PiIgI9V9CQoKmcRMREVHT4/b038mTJ9WkxlJ5eTnOnj2rSVCKu+66S/3/7t27o0ePHujcuTM2b96MESNG1Ptxn3vuOTz11FPqz0VFRUysiIiIqEFcTqr+/e9/q/+/bt06REREqD9XV1djw4YN6NChg6bB2erUqRNatWqFY8eOYcSIEYiLi0Nubq7VbaqqqnDhwgWHdVhATZ1WcHCwR2MlIiKipsXlpGrChAkAAJPJhKlTp1pdFxgYiA4dOuDNN9/UNDhbZ86cQX5+PuLj4wEAAwcOREFBAfbs2YPrr78eALBx40aYzWb079/fo7EQERERWXI5qTKbzQCAjh07YteuXWjVqlWDn7y4uBjHjh1Tfz5x4gT27duHqKgoREVF4aWXXsIdd9yBuLg4ZGRk4Nlnn0WXLl0watQoAEBycjJuu+02TJ8+He+99x4qKysxa9Ys3HXXXVz5R0RERF5lEhHx1ZNv3rwZw4YNq3X51KlTsWTJEkyYMAE//fQTCgoK0KZNG9x66614+eWXERsbq972woULmDVrFtasWQM/Pz/ccccdWLRoEVq0aOFyHEVFRYiIiEBhYSHCw8M1OTYiIiLyLL2dv+uVVG3YsAEbNmxAbm6uOoKl+PjjjzULzlv09qYQERFR3fR2/nZ79d9LL72EefPmoW/fvoiPj4fJZPJEXERERESG4nZS9d5772Hp0qW47777PBEPERERkSG53fyzoqICgwYN8kQsRERERIbldlL129/+Fp999pknYiEiIiIyLLen/8rKyvD+++9j/fr16NGjBwIDA62uX7hwoWbBERERERmF20nVgQMH0KtXLwDAoUOHrK5j0ToRERE1VW4nVZs2bfJEHERERESG5nZNFRERERHV5vZI1bBhw5xO823cuLFBAREREREZkdtJlVJPpaisrMS+fftw6NChWhstExERETUVbidVb731lt3L586di+Li4gYHRERERGREmtVU3XvvvYbc94+IiIhIC5olVdu3b0dISIhWD0dERERkKG5P/02cONHqZxFBVlYWdu/ejeeff16zwIiIiIiMxO2kKiIiwupnPz8/JCUlYd68ebj11ls1C4yIiIjISNxOqj755BNPxEFERERkaG4nVYo9e/bgyJEjAIBrr70WvXv31iwoIiIiIqNxO6nKzc3FXXfdhc2bNyMyMhIAUFBQgGHDhmHFihVo3bq11jESERER6Z7bq/8ee+wxXLp0CYcPH8aFCxdw4cIFHDp0CEVFRfjd737niRiJiIiIdM8kIuLOHSIiIrB+/Xr069fP6vKdO3fi1ltvRUFBgZbxeUVRUREiIiJQWFiI8PBwX4dDRERELtDb+dvtkSqz2YzAwMBalwcGBsJsNmsSFBEREZHRuJ1UDR8+HI8//jjOnTunXnb27Fk8+eSTGDFihKbBERERERmF20nVO++8g6KiInTo0AGdO3dG586d0bFjRxQVFeGvf/2rJ2IkIiIi0j23V/8lJCRg7969WL9+PY4ePQoASE5OxsiRIzUPjoiIiMgo3C5Ub4z0VuhGREREddPb+btezT937dqFTZs2ITc3t1Zx+sKFCzUJjIiIiMhI3E6qXn31VcyZMwdJSUmIjY2FyWRSr7P8fyIiIqKmxO2k6i9/+Qs+/vhjTJs2zQPhEBERERmT26v//Pz8MHjwYE/EQkRERGRYbidVTz75JBYvXuyJWIiIiIgMy+3pv6effhpjx45F586dkZKSUqu7+qpVqzQLjoiIiMgo3E6qfve732HTpk0YNmwYoqOjWZxOREREhHokVcuWLcOXX36JsWPHeiIeIiIiIkNyO6mKiopC586dPRELGVhqWg62Z+RjYOdo3JIS6+twiIiIvM7tQvW5c+fixRdfxOXLlz0RDxlQaloOpi/fjWXbTmL68t1ITcvxdUhERERe5/ZI1aJFi5CRkYHY2Fh06NChVqH63r17NQuOjGF7Rj78TSZUi8DfZMKO4/kcrSIioibH7aRqwoQJHgiDjGxg52h8/MMJNbEa0Cna1yERERF5naYbKldXV8Pf31+rh/MavW3IaESpaTnYcTwfAzqxpoqIiLxDb+fvem2obOvnn3/GRx99hOXLlyMrK0uLhySDuSUllskUERE1aW4XqisuX76MTz75BDfeeCNSUlKwZcsWPPXUU1rGRkRERGQYbo9U7dixAx9++CFWrlyJ9u3b48iRI9i0aRNuvPFGT8RHREREZAguj1S9+eabuPbaa/Gb3/wGLVu2xNatW3Hw4EGYTCZER7MwmYiIiJo2l0eqZs+ejdmzZ2PevHmGLEYnIiIi8iSXR6pefvllrFy5Eh07dsTs2bNx6NAhT8ZFREREZCguJ1XPPfccfv75Z/z9739HdnY2+vfvj549e0JEcPHiRU/GSERERKR7bq/+u/nmm7Fs2TJkZ2fj0UcfxfXXX4+bb74ZgwYNwsKFCz0RIxEREZHuadL88+DBg/joo4/w2WefITc3V4u4vEpvzcOIiIiobno7f2vaUb2ysrLWXoBGoLc3hYiIiOqmt/N3vZt/2mPEhIqIiIhIC5omVURERERNFZMqIiIiIg0wqSIiIiLSQL2SqoyMDMyZMwd33323utrvu+++w+HDhzUNjoiIiMgo3E6qtmzZgu7du+PHH3/EqlWrUFxcDADYv38/XnzxRc0DJCIiIjICt5OqP/zhD3jllVeQmpqKoKAg9fLhw4djx44dmgZHREREZBRuJ1UHDx7Er3/961qXx8TE4Pz585oERURERGQ0bidVkZGRyMrKqnX5Tz/9hLZt22oSFBEREZHRuJ1U3XXXXZg9ezays7NhMplgNpvxww8/4Omnn8aUKVM8ESMRERGR7rmdVL366qvo1q0bEhISUFxcjJSUFNx0000YNGgQ5syZ44kYiYiIiHTPraRKRJCdnY1Fixbh+PHj+Prrr/GPf/wDR48exd///nf4+/u79eRbt27F+PHj0aZNG5hMJvzrX/+q9XwvvPAC4uPjERoaipEjR+KXX36xus2FCxcwefJkhIeHIzIyEg8++KC6IpGIiIjIW9xOqrp06YIzZ84gISEBY8aMwf/8z/+ga9eu9XrykpIS9OzZE4sXL7Z7/Z///GcsWrQI7733Hn788Uc0b94co0aNQllZmXqbyZMn4/Dhw0hNTcXXX3+NrVu34qGHHqpXPERERET1ZRIRcecO1157LT766CMMGDBA20BMJqxevRoTJkwAUJPAtWnTBr///e/x9NNPAwAKCwsRGxuLpUuX4q677sKRI0eQkpKCXbt2oW/fvgCAtWvXYsyYMThz5gzatGnj0nPraZfr1LQcbM/Ix8DO0bglJVaXMeghRmf0Hp8WmsIxEhHVRU/nb6AeNVWvvfYannnmGRw6dMgT8ahOnDiB7OxsjBw5Ur0sIiIC/fv3x/bt2wEA27dvR2RkpJpQAcDIkSPh5+eHH3/80eFjl5eXo6ioyOqfHqSm5WD68t1Ytu0kpi/fjdS0HN3FoIcYndF7fFpoCsdIRGREbidVU6ZMwc6dO9GzZ0+EhoYiKirK6p9WsrOzAQCxsdZ/hcfGxqrXZWdnIyYmxur6gIAAREVFqbexZ/78+YiIiFD/JSQkaBZ3Q2zPyIe/yYRqEfibTNhxPF93MeghRmf0Hp8WmsIxEhEZUYC7d3j77bc9EIZ3Pffcc3jqqafUn4uKinSRWA3sHI2PfzihnjAHdIrWXQx6iNEZvcenhaZwjERERuR2UjV16lRPxFFLXFwcACAnJwfx8fHq5Tk5OejVq5d6G2VDZ0VVVRUuXLig3t+e4OBgBAcHax90A92SEosPpvTFjuP5GNDJN7UydcWghxid0Xt8WmgKx0hEZERuJ1WWysrKUFFRYXWZVoViHTt2RFxcHDZs2KAmUUVFRfjxxx8xY8YMAMDAgQNRUFCAPXv24PrrrwcAbNy4EWazGf3799ckDm+7JSXW5yfJumLQQ4zO6D0+LTSFYyQiMhq3k6qSkhLMnj0b//znP5GfX7uWo7q62uXHKi4uxrFjx9SfT5w4gX379iEqKgrt27fHE088gVdeeQVdu3ZFx44d8fzzz6NNmzbqCsHk5GTcdtttmD59Ot577z1UVlZi1qxZuOuuu1xe+UdERESkBbcL1Z999lls3LgRS5YsQXBwMD788EO89NJLaNOmDZYvX+7WY+3evRu9e/dG7969AQBPPfUUevfujRdeeEF9rsceewwPPfQQ+vXrh+LiYqxduxYhISHqY3z66afo1q0bRowYgTFjxmDIkCF4//333T2sRi01LQfz1qRxlRgREZEHud2nqn379li+fDmGDh2K8PBw7N27F126dMHf//53fP755/j22289FavH6K3PhZaU5fdKUfMHU/py2oiIiBoFvZ2/3R6punDhAjp16gSgpn7qwoULAIAhQ4Zg69at2kZHDcbl90RERN7hdlLVqVMnnDhxAgDQrVs3/POf/wQArFmzBpGRkZoGRw03sHO0mlBx+T0REZHnuF2ofv/992P//v24+eab8Yc//AHjx4/HO++8g8rKSixcuNATMVIDcPk9ERGRd7hcU3X8+HF07NgRJpPJ6vJTp05hz5496NKlC3r06OGRID1Nb3OyREREVDe9nb9dnv7r2rUr8vLy1J8nTZqEnJwcJCYmYuLEiYZNqIiIiIi04HJSZTug9e2336KkpETzgMgxtkaghuDnh4jIs9wuVCffUFojLNt2EtOX7+aJkdzCzw8Rkee5nFSZTKZa9VS2P5PnaNUagaMVTRNbaxAReZ7Lq/9EBNOmTVM3Ii4rK8MjjzyC5s2bW91u1apV2kZIAGpaI3z8w4kGtUawbAT68Q8n2Ai0CdHi80NERM65nFRNnTrV6ud7771X82DIMS1aI9gbrWBS1TSwtQYRkee5vU1NY6S3JZme4osta1LTcrA9Ix8DO/NETkRE2tLb+ZtJFfT3pnhSalqO10YruO8gERF5kt7O3253VCfjsR0tsk1sPDWa1NDpRo5yERGRkbClQiNX11J6Ty61b8i+g2wBQERERsOkqpGraym9J5faK8XR0wZ3cHvqjy0AiIjIaJhUNXJ1jRY1ZDTJFbekxOL5cSluT995Oi4iIiKtsVAd+it001pdxeneLF53h17jIiIifdDb+ZtJFfT3phAREVHd9Hb+5vQfERERkQbYUsFAlBYDoUH+KK2o9nmrAXdbHrBFgr7x/SEiahhO/0F/w4f2KC0G/EyAWWqGGM2AzxpqutvYk41A9Y3vDxEZkd7O35z+MwilxYD5SgpsBlxqNZCaloN5a9I07/PkbssDI7dI8NRrqCd1vT9N4TUgImooJlUGobQY8DPV/OwH1NlqQE+NPY3aIqGpNCF19v40ldeAiKihWFNlEEojzR3H8xES6I+yyuo6Ww00dJsYV+NxpeWBu7fXC0++hnri7P1pKq8BEVFDMakyEHv79jkzsHM0Pv7hRINHhxwVMLsbj7u3dzUOT9LqNTQCR+9PU3oNiIgagoXq0F+hm5Ya2kBTLwXMvoyDTUj5GhCRPunt/M2RqkZCq9EkW76c+rE8Jl/G0dDXsDHga0BEVDcWqjcCeipI14rtMYUG+Ruy0J2IiJoOjlQ1AnoqSNeK7TGVVVYbstDdkq+ba/r6+YmIGjsmVY2ApwuJfTH1Y++YjDwFZVkT9vEPJ7xem+br5yciagqYVDUCRm1X4ExjOyZftyXw9fMTETUFTKoaCSOP4jjSmI7J120JfP38RERNAVsqQH9LMqlx8nVbAl8/PxGR1vR2/mZSBf29KY7YKzRWLgsN8kdpRbVbRcgNKVy2vC8AFkDXk5bF4yxEJ6KmRm/nbyZV0N+bYo+95pcAMH35bviZALPU9McwAy4VITekmabtfQH4vDmoEWnZ0FQvTVqJiLxJb+dv1lQZhL1CYxFYJTZmwOUi5IYULlve98r+zk22ANrd0SHLkcXNR3PhZ9LmtbN9P7/YlclRKyIiL2PzT4Ow14RTuczvSmbjB7hchFxXU8/UtBzMW5Nmt5Go5X0FgABNsgDa3aaryu2XbjuBxZuOIS2rqGaE0eT6++aI7fu5/kiuR5rBEhGRYxypMghHLQaUy0IC/VFWWe1yEbKzlgV19TSyvS8AjxVA67lOyN3RPsvbAzXJqB+A5PhwPDHymgYdn+V7ciq/BJuO5jXZ0UMiIl9hUmUg9loMuNp2wF5y4ui+riQLtvf1xElbSe5MgNOGlb5KvNxtU6Dc3rYGrqEJlUJ5T1LTcrD+SG69Rg/1nMQSEekdC9Whv0I3rblbxKyXouffLt2F9Udz1Z9HJsfgw6n9rG7j61jdbVOg3N7dkUVPx6XcRw/vOxGRq/R2/uZIlYGkpuXgi52ZgAmY1K99rROeo1GG2kXMp52ORrjSzVyrdgxO72uq8wKfdwp3t0GpO7dvyGvs7HlsH1f5OfNCCbuuExE1AEeqoL9M1x5lFMGS5UiCs1EGZy0QZg7r4rS/laPeWFq1Y3B2X8vpP4H9VhHeHF3x5tSYJ45LScrXH821ev8XbzrG9hhEZEh6O39zpMogtmfkq8kFUDNmYzmS4GzExqqI+XwJNqXXFDH7AeoJ1V7NkqOCda3aMdR1X1dGzG5JicXMYV2wOT0XQ5NiAADz1qRpnvi4syGxo+SrrqTMciQSFu0ytBg1skxQAajv/+c7M9VVo/4mE4Z1a43E6Obsuk5EVA9MqgxCKXJWCGBVgFxX0bRVEbPFSIWzPkmOEqCG7CPn7n3rmi5LTctRE8PD54oAwKXEx12uJoOOkq+6kjJ7I5HKsSivU0NGymxXHgI1RfIXSyrUVYjVInanlYmIyDVMqgxCGbX5YlcmABMm9Utw2ubAldGfkEB/LN50TE2sQgL9rW7rKAFy9bnqen4tRkO81YjU1WTQUfJVV1JmbyRyRHIsEqObqc/l6kiZK/EnRDXD2YuX1T5ZSlsHwDMjfURETQGTKgNxp/i4rscBak7kY7rH49uDWepUYK+ESLvThrYJkLsF2q4ehzP2jtE2WQA804jU1WTQUfJVV1JmbyTSMnGetyatQdOB9nqLWdZsKQlVQxI3IqKmjoXq0F+hm8LVRKmhLROUfkn+JhOmDe6A58elaH8wDVRXIb43GpG6E6ujpqp1rah0NBLpqcJ1y3jmrUnDsm0n1cRN+SywdxUR6ZXezt9MqqC/NwWoO4mwPMlZngwBICwkAAv/p5fDE/fbqT/jSFYRzECtRpQ920Vg1vCubrVRWLAuHf/efxZRoUEYck1rlFZUIzTI3+mqQndeh+0Z+cjMv1pg707yp8eEoCH7BTrqbaXFcTrbtJsrAolIj/R2/mZSBf29KQCcjho4OvHZclQMbZtIKVOAzu67YF16Tf3Vlfso1yuXW1Jqg5Tnqe+J2FkrCFceU4/NLD3RiFXL43R19IqISA/0dv7mhso65WjDY0cFzy2C/Ws9xo7j+VY/K/dVi5PbhOODKX0RFx5i1VbTZHNfZYUdUJNQ+Vlcv9mi47lCydLNV9oC2MZhydnGzbbHOjI5FtMGd3A5abD3Wvmao5gcvQ6uHIOWx3lLSiyeH5diVbPmbONtIiK6ikmVTimFxZZJRGpaDjIvlNg9yd10TUytx7BXDK3c1yxX95wb2DkalsOVtu0atmfkw88i6zJbXD+0W+3nVW6qrCp0dCJesC4d05fvxtJtJzB9+W6rhMLesU7ql2B1wq+LHhMCezEpI03Ltp2s9Tq4cgyhQf5W7TE8UaDvTjJLRNRUcfoP+hs+tMd2imdkckytnkKPfroX3/+ci+gWwfjTWPvJh7Mi6rqKpJXpvJnDuuCZUUnq9QvWpWPN/nNo2SwQQ7q2RllldZ1729n2ZfIzAfcP7mh3itPesbrzuvm6cN2Wu1Nszo5BfW9Qk+wq740ea8mIiLSmt/M3WyoYhO0UT2J081ony3cn9wFwtWgZQK3bOGpn4KzNQV3tBJ4ZlWSVZLl6PEoiANQka46mOO0dq6sa0vpBK7YJjm1MrjZutfd4tq9VWWW1W93fiYhIO5z+MwhXp7KcTak1hG2tTUMN7Byt1mcBNSMsjbGOx9nUnsKdKTbbx1Om/ixfKz3WkhERNQUcqTIIV5pPWhWUXylG17KreEPYG61x1ljU1a7rep/mUurRlJonR++HqyNq9kam7L1W9ka+9P5aEREZHZMqA6nrxOtsSs3bLE/ggP1O3XVNObrTMkGv01yhQf4wX6laNAtqbQXkLntThbavlb2k1AivFRGR0TGpaiRS03KQmV+iTqkpRcueaBLpSiyWJ/CRyTEN2mLFUcyubHLszdEZe8+VnlWkXu8HoKyyukHPYZkwhQT6u1w75+qG0EREVH9MqhoByyQGAIYnx9ZawWd7O0+OVtiewAE4rJGqK+lxFnNdBd6ePt66RuMAYL1FHy/LVhQNoRyDvWNz9Hq6uiE0ERHVH1sqwPtLMlPTcvDFzkzABCTFhTvdzsXyJLnvdIG6HcysEVe3kpm3Jg2f/HACgpoeUQ8M6Wi367W9pfshgf7YfDQXQ7vFWC3FV7aZcbbdjLNtayy7rMeEBQEwoaisEnFhIfjTldje2fgL9p8pVDuwj+kej7jwEGQXleHU+RKUVVXjzMVSlFfVTGhathtYsC4dX+zKRFFpJQRAy2ZBgAgullYiwM+EsOAAXK6sRkl5tdqDy88EtAgOQEigH8xmoNJsxuXyaggEIkDz4AAM6doaFVXVyLtUjsLLlaiGoLLKjPySCgT6myBmQEzAtW0isOfURbvvrwnAiOQYHMstxsn8y+rlEaEBEAFKK6rRsnkgerSLxKR+7dXX4kJJBW7v1RZrD2UhI69EvV9ooD/aRIYgp6gMZhH4mfzQqkUwTuWXwNkvb0RoQM3UowDRLYJw8XIFisuq4O9vAgSoqL5679BAf8SGBwMwodpsRkx4CE7llwAC3NApGmcvXsbxvBKUV9WMtLWJCMWfNFy4QERUH3prqaDrpGru3Ll46aWXrC5LSkrC0aNHAQBlZWX4/e9/jxUrVqC8vByjRo3Cu+++i9hY977ovfmm2PZnAlBr6xfb21pu02JJuf2jn+612mZmTPf4Wu0VbEdTqkVqbU+j/KzEo243Yyc+R72klOdQ7qu1D6b0xb7TBbW2xiHfYG0WEfmS3pIq3bdUuPbaa5GVlaX+++9//6te9+STT2LNmjVYuXIltmzZgnPnzmHixIk+jLZu2zPyrbaEAWoSFntL3y2n0exRbn/qfInV5afya362XX4PQF26P3NYl1rP9+PxK9vYXPlZ3W7GTny2sW04kovpy3fji12Z8DeZPJJQKTVi9rbGId9guwYioqt0n1QFBAQgLi5O/deqVSsAQGFhIT766CMsXLgQw4cPx/XXX49PPvkE27Ztw44dO3wctWO2W8IANW+CvToXy35N9igryWy3ihmaVPOzo35Fp86XYPGmY7hYUmF1vw6tmttN4Ex24lNiUyITwKp+yn7EDaMUedvbGkdPHL1fjRFrs4iIrtJ9ofovv/yCNm3aICQkBAMHDsT8+fPRvn177NmzB5WVlRg5cqR6227duqF9+/bYvn07BgwY4PAxy8vLUV5erv5cVFTk8LZaU1ZvKVvCJMWFOdzOxXZp/L7TBfhiVybOF1fAzwQs3nQMvRIi1W7mm9NzMTQpRv3Ztjg5JNBfnZoDak/POaoRSmkTru4TaO841h/Jtdifrz0m9WuPL3adxvoj1o0uw0MC0LFVc8wa3hUA8MWu0wAESXHhVlvbZBWW4VR+CfKLy5FddPV9Uk7gyvF9sSsTJeVVCPD3Q3TzYFyuqMTFy1dqqkICEBIYgPE92+DE+RJsOpKDSrMZVear8TQL8kNltUDEtqbKjLxLZSgsrYRZgIqq6qs1VVLzug3vFotf926Ldzb+giNZRag2C3q1b4lHbu6svl+rfzqLrT/nwt/PhPDQQMSEheCXnEsoraxGy2aB6NGuJSb1SwBwpabqcgVu7+m4piq3qOxKguyHa+LC7L5fQf4m+PuZEODvh9BAf5RWVqOq2ozSyqsHHuAHq9dBEREagMLSKqv3KyjADzd0rKmp+jnnktXj2FtdSkTUlOm6puq7775DcXExkpKSkJWVhZdeeglnz57FoUOHsGbNGtx///1WyREA3HDDDRg2bBhef/11h49rr1YLgG7mZJ2xLDb3MwHJ8bUTHkvKvnFKQXpaVpHbU3OudPm2bT5pWTyveNBBAb29x7OsA3O0V2F9WiXocS/A+nLnWK7u7QhAgE3pebU+Q9sz8rF02wm1cez9gzuqHdqV17kxvX5EZHx6q6nSdVJlq6CgAImJiVi4cCFCQ0PrnVTZG6lKSEjQzZuisJc42G5u7KjI3fZx7BWPt2oRhPziCodJVqsWQZg/sUe9NzK2Lci33YjZ2f2UkS97x+XKbciavUUPtq+f7apNZeECX2ci0iu9JVW6r6myFBkZiWuuuQbHjh1DXFwcKioqUFBQYHWbnJwcxMXFOX2c4OBghIeHW/3TG0d7xinTbsnx4WpCZVkvlZqWg3lr0qz2mFNqqyyTJz8T0CuhZc3qvivzgWO6xwOAOj2oJFT2HrMut6TEYmSyde1Tenbd06yu7FvHve3cZ/uajUyOrbXXYGlFtfqF4IeaBQ98nYmIXGeopKq4uBgZGRmIj4/H9ddfj8DAQGzYsEG9Pj09HZmZmRg4cKAPo9SGs8ThlpRYPDHyGjWhUorI7SViSqf1ahGrN9sswKR+CfhgSl/cP7gjPpjSF+9O7oMPpvTFA0M6WjWTtNygecG6dJePQWmxoFh/JNdpYmYZq7MmlbYbLocE+rud9Nl77roeoz7JpV7YvmaT+iXU2iBb2eRaWQE6NCmm0WxsTUTkDbqe/nv66acxfvx4JCYm4ty5c3jxxRexb98+pKWloXXr1pgxYwa+/fZbLF26FOHh4XjssccAANu2bXPrefQ2fAi4Pg1mWd/y26W7rDp492wXgf1nCtXHUH5WpgFdmc6ZtyZNrbNRuDMN9Ntlu7DhSK66OlBp3mk7tVm775X9rvC2xx4S6I/Fm441aIqqqUw5ulIPZXsb1lARkZ7p7fyt69V/Z86cwd133438/Hy0bt0aQ4YMwY4dO9C6dWsAwFtvvQU/Pz/ccccdVs0/GwN7m+Lau41lrdV6m/5N+88UArja4qDKfHXUwYSa1XO2j7tgXbpVh3VlBaHCD3C4b5y9RAlytd2C7Yia5RYrtiNzidHNrI7NtrZMOfZ5a9LUlhTOYnMWa1374qWm5eDt1J/V5zHq3nmONqm2fX1tV3ka7TiJiHxF10nVihUrnF4fEhKCxYsXY/HixV6KyLtskyZnq92+2Jnp9LEENX2tlCJlwdXpOOXxLAuVD1/ZCLhXQqTV4yj71zkbafr4hxOYOawLFm86ptZntY0MwfhebdVEyDaJcbQ3Xa3NmbvFYNIN7dWYQ4P81WalZlzt3eWMvVid7U2oLgyA455i7mrIRs9abhLtrf0giYiaAl0nVVSjVmJxZUsYy5NfXnG5k0eoUVZZrU4BAjWjR1/sOq2eoG07la/Zfxabj+ZabVszIrn2Zr4jk2MAQa1RMODqasPMi6VqXy0lgfIzQa2JcjQyZ9u5ff3RXKw/mque/Esrqq+uhDRdbRDqjO3IVFlltcNRQcvbutLCwhHbPRwXbzoGPxPcTmSUxNfRfd1NuOoapSMiItcZqlC9qXK0JYxSMJ2aloOzBaV1Pk5IoL+aUAE1Cc36IzlqYXtiq+ZWt8+8UIq0rCKrfQCT4sKspsKAmhGv9UdzrUbBzhdbd2vHlcf4Ytdp3JISi5nDuqgtIRZvOqaOmNkrnrbX5V1J2gZ2job5SkJnFtc6fNsWbSuJlO1z297WLKh3QmW5gEAZDVQSQVdX1aWm5Ti9r6MVo84ox2eZ4BIRUf1wpMoAlJEdJbFRNjl+e/3PDjcXDg3wQ6lN2+wT50vUUScAaBEcgJLyKrUeKT4iBDOHdcHm9FwE+Jlw8GyhWqAuADq3bq5O6dlb3RAa6GfVcdtWzZRjzYrE0opql0ZIlBGsl78+jMwLlomjyep6d4qp3blPfR7flrM9HF1JBJXRp8x86/fPLFBXPrpSG+bo+JR+VCZc7dKvTOlqNc1IRNQU6Hr1n7fobfWAPUpH7PVHrk7HKdNe9ignSndcn9gSPdtFqp3MbZt3uqtDdDOczL9sdZkfgOQ24RiaFOPWqj3bBqa+rP1JTcupqWEzodY0rKPb22u+CtTdENVe007l/bdtzmlZx+bqa2TbpNWyk7rRVzsSUeOnt/M3R6p0ShklCA3yR2lFNQZ2jsaHU/vVrERb/zOOZBU5TKgA1JlQ2TvB7zl1EXtPXVSLt5WTdH11iWmB0xdKrUZozACOZBXh8Lki9GwXgdZhwS4lJlqMGGnBNglZfyS3zoTj6j6JNfshKsmwKx3mbUefhnWLQWJ0M3X7GMs6tv/+kuf28WzPyLc7+tUYVjsSEXkbkyofs7eK7oudmVh/1HpEyrYo2Xb0whnbES1H03ewuHzxpmP4YErfOhOrIH8/VFTXnvKbOawLeiVEYv2RXPX5wkJqphuVWJT6rqS4mr8u3tnwCy6U1mwq/MyoJLtL/V1pCeDqdfV5jO0Z+Vavnwl1t3FQ2lQktmqudplXEsm64gsN8lenZ5WmnQDUhNuyjm3/mUL1vXY1EVIXDeDq6JdSCK/lakcioqaA03/w3fCh7dSO7fSNJcvGmcp9LZtfas0E4IEhV6eBFDFhQci9VLsI3dKY7vGoqKoGBLhYWok9py66/fyu7jvnrCmnulIOzvdHdPYYjt4jS85Gqmz307OcmgPgdIrNdp9HJVG1nErs2TYCB84WWn1e1AaqNu0nHLFs8Lk9I9+tDbuJiHyJ03+ksp3a2Zyea3f0SVmZpfSHemfjLzhbUIq2EaGYNaIrRibHYP2RXAfP4ppAfxMqq68+rwDYfeICTuWXWCV5dSVUJjifemwfFQoBcNqq6Ly2Hcfz1eNWVrnZO7Hbtjx4e/3P6nXqSjk4b1rqrMDbUfuFmtWHJqdd3wHUalOhNELdcTwfYtGGwnIrIkdNScsqq/HOxl/UxwEAmGon4Ne1Dcf+M4XYlJ5n1X7C0QbdtpdZ9gtjQkVE5DomVV5meRKzXNVXLYKhSTE4fK7IaquWpLgwlFVWq9MvlqNG54srMH35blyf2LLBcVkmVIr9ZwuBs+49Tl3DnuN7tlVHW5zp2Ko59pyqSeCUOh97LHtemQU4cq4I05fvxsjkGKtpT6VpqbPHsO36bjnFZtt+wdVEI7FVc7WRqsJyOs3yeUMC/Z02Jd194kLNe2KhdVgwRibHWG0FZNk53zJZs23yaXuZ0v9MD7VrRERGxKTKi+x18rbUKyFSPaGFBNYUqFsub3879We7j3vifIk3wq9TQlQoopoFWfXCAmqm8k7ll2BoUoxaK2VJmdZ6Z+MvuHi5EuN7tkFpRTV+OnVRHWWybeppmZx+MKVvTfH+uSJ1Q2Dgai8nZerMUYJgWwQPoNaUn5LYuptkxIWHWI30XXtl5aNl7JZTb/ZHxWoK3A/YJFTA1U2r1x+5Osppm5zbe2zbkTLlMdYfycXMYV3AogAiIvcxqfIiZ9N9ytTVEyOvUeuk/FAzkmHZR8ieAZ2i3W6foIXI0AAUlFapScPpC6U4d7EMANAhujmqxYzbr4xMbc/IV7e8sd1SJz27CM+MSqpVT2Q5AmU5UmVva5UnRl5jlQhN6tcek/q1r3PExXKvQ6VezXYbnbLKavU6d9mOglm2krC37Y7lyKUS9xe7Mh22Y1DuZ290aXN6LoYmxdh97KzCMvy6d1urfR0BqL2qLBP/0opqq1WoHL0iIrKPSZUX2TvBHj5XVGvqSqF0MlcSJnuDBx2im9l9riB/EyrsTOkpWrUIstv13B0FpVVqXDFhwci7VK4miCfzS+BvMql1TVbTTrWyw9rpotJ1XUkuLZtS2ht1eX5cijqqowyz1DVNZ2+vQ8tNpO3tQ+huM8yr7RRqEsn0rCLr0aEr2+4oo3W2UtNyHNbLpWcXYcG6dDXZURI/y61sDp8rUl83y95ljpJwpbGssuJQXQl4pfu9o22SiIiISZVX2eu11Csh0mrqynZEQuxcZulk/uVaDTYBoMpJQgUAJWVV9TsIB3IvXd170CxQR0QUSgJUk/TUXKYcl9ImwJajruu2SY/SVTw0yB/rj+TA32SyKtB2pPZeh+fUBMX2fXJn42HL5AuA2iLDWQuMxZuOIaFlqLpSsea1ykRWQZlVHylLynQdAKs6KcutbICarYEAYOMR62nXHcfza322bFdd2talATXbJK0/ksvkiojIBlsqwPdLMu11zbY92TlLrPTKUczKcbZvGYrxvdo6bICpthRAzQndslmmbUsJNQnA1aREaUHhaITp0U/31hqxcdTeYN6aNHzywwn1eHq2i8D1iVG1HtOV99Idzrrm2xqZHAtAXF4Jen1iS6t2F2O6x+PdyX1qpkTTc5EY3RzfHsxyGIMeutsTUdPm6/O3LY5U6YC9Qul5Xx+2ajvgyYQqNLBmX+2ySrNmz+MHoGXzIFwoqaj1mEqycfpiKRZvOoYT50tw8EwBopoHYdbwrlYn6J5tI7D/bE1TS8spwH2nC/DVT2dRXF6ljopZNr60XMVntcLNoobJtohceRzLFXPKdjQXL1daHcf+M4U4eLbQatRKWUygTJ8pk5oNeU1dTaiUZ8orKq/7ZgBCA/1RVlGtHr+fqWbvR2XTZn+TCYfPFalF+iGB/kjPLrJq5mrZHoJJFRERkyrdsK3/+WJnZp29nLTibBPk+jID6NCqOfJLHNdtKVObymjR6YulmL58t9VyfyUxsewSbm8TaROurvKzXKlnWXQOABuu1DB9MKVvrWlEJUmwbG/g9BivTHMq02tqo05Yj04pj6lFHZszFy9X1mq54EhpZbVVqwdlMYC9FYiWRfqWe1Da1pwRETV1TKp0Rjlp5V1ybcRBzxx1Ug8LCcClsqtF7ra+2JWJ9lHNa02hKSfweWsO17pPVPMgvHZHj1ojJpa9wJTRFaURqFLcbjlCaNnewJVpOwGw/kgO0rOLaqYe5erlylTksG4xat2YZaJmb8PpuvRsF4FDZ4vs1mb9nF3UoKnGxZuO1eqNZZswKcm/ZRd2jlIREdVgUqUjtpv1Atqs0tObS3UUyeddKsekfu2tlvsnRjdDl5gWAGoSqNMXrUfxwkICaz2OUks1c1gX/PeXPLV/lhnWLRqU/MR2tNC23QBQM1UaGx6C/JIKq+OwjUd5HhOAfacvIj27CDHhIVbXn8y/7FYS1D4qFEO6tq7VB0xxqbza7uXA1QSvZ7sInC0odfiZ+mJXJnq2iwBQ01gUsL/q0Z0GqGQM9VndSkTWWKgO3xe6KV9mmfkl2HA013AF6Z7gbCNn2wJrS5b1TZYF4yO7xWBjeq7aEPT+wVf3NXS0V569QnZP8APQvV0EqsyCkrIqnLzg3uiV1WPZKSrv2S4Cra+0vLDcdNmVuMw2/2+5WIAaD2f7XxLpma/P37Y4UuVltn8NKl9mRlzd5ylKY1RHr8lhB3VDJlzd3297hvXegXnF5VdbAwhqdRkHrtZbKQ0vD54p8MTh1WIGMKRra7XbfF21XE4fy84L1rZlM6vkULlNaIAfSqsc19NZ1oYpt7JcLECNh7P9L4nIdX6+DqApUU6Yy7adxPTlu/Hop3vx2Gd7ATChslQtgpLyaoevSZmDREBwdX+/0CB/qyTK3pTZwM7RtVbpKQ0vl207aXdKz1MWbzqG1LQctempFvxMNXVbjkbb2rQMrfMxbN8DZXNralyU3wUuPiBqGI5UeZHlX4OWq96otpP5ru1nGBrgh2viwtA6LARJcWF4Z8MvmPf1YXX/P0eUYnjLeisTro7IKCeY69qG48LlCuQXl+NyhfarJK1jOo1bUmJRWuG4NsodZoHTQvgzF0vVkSgTgGg79Xu2LSeUUT5qXOw1JiYi9zGp8iLbJfyNTfMgP5R4OPGwVVplxv4zhZg5rLXDGix7LFsCAPYbdKr9tLzU2iLvUs2+idlFZV55vnKLET8BMH9iDwBQWyYol1vextnG1GRs9Vl8wOJ2Imuc/vMi5a/BaYM7oEOU/T37jMw2oQoKMCHQ34RmQX7wcz5w1CBKDZarAv1Mar2VwlGK62ilnT1hIQEI8nftQO3dav+ZQixYl+7zEcysgjK78Sl9q6hpSE3Lwbw1aUhNy3F4vWU5g6PbETUlHKnyMuWvQWXlWWMWGx6C23u2VTtxe0q1iFsn+0r32pS7rK5WEQpnm13/fftJDSNynQnAy18fRqbFqJy9Bqac+msaXNnr0lPF7Rz9IiNjUuUjljUMp/JLaiUdoYF+Hul07k2nL5S6NSXXEBl5rtVgaSUs2B/RLYLdbt4JwGFCBQBFGm907SoBrBIqAEiICsXz464FANbaNDGuJEy25QxaJNzubFxOpEec/vOR1LQcfLEzE6fyS5AUV7u3htETKk8I9DchLjwYwQF+iGkRZHeKylv6d4rGn8am1H1DA7tcUY0vdmVi3+kCnMovwRc7MznF00S4shrQspxBq+THXjJHZCRs/gnvNw+z14toTPd4nL142Wm3a6rR0J5ekaEBKCht2IiQchLxVoNQPeHoQdPgzlZEWk3ZsQkpuUtvzT+ZVMH7b8q8NWn45IcTtRKDD6b0xTsbfnF5U9zGJsAEVNm8KB2imtntMG4C0DzYH8VOtmbxhFYtgq6uktuZCZiAoAB/7DyRj8LLlXXWa9XVcNMIrm0TjidGXsOTHQHQPhHivpLkDr0lVZz+84GBnaPtjrT87zdpTTahAmonVACQ0jbC7m0F8HpCBQDniyuw73QBpi/fjfVHc7H+SC6+PZiF88UVLrXJuCYurNYvXavmQZ4J1kOOnCviai9SaT1ld0tKLJ4fl8KEigyJSZUP3JISi5HJMbUur0/Rc2NmAnDKxSag7ooMdb5GIyTQ/q+G5RY6tiwHqZy1kDDD+hfvfIlxpnuVBqmsdyEFu7ETXcXVfz4SFODv6xB0TwAcySqq9/2V2qsgPxMqbKblnNVU9WxXMzpmr0dVtQgSo5vj8DnncUU1D0JllRmFNqv5Dp4txPWJLdGyWaBH20x4irKVD0+epNCiGzvbKFBjwZoqeH9OdsG6dK+1GmjsOkQ3Q3ZhmcP9AOtT1H59YkvsOXWxwbE5ExMWjNxL5R59Dk+aOawLnhmV5OswqBFgcTo1BGuqmrjUtBws23bC12E0GifzLztMqID6rRI85IW6tjwDJ1QA2FmdNMM2CtSYMKnyIuUvMl8UWDc2LYI9N3Nd7oXVeXobHg4N9HOr7xen/kgrrMmixoQ1VV60PYN/gWmluNw3nccbK3vNZgP9Tai00/2dmyqTlrSoySLPY92ba5hUeUlqWg72nLrg6zCIXGYy1a5IYy0VeYKyJyrpE7cPch2n/7xA+UAesLOazFKgvy83XiGyVmFnGrRXQqT3AyEin2Ldm+uYVHmB8oGsq47G3lQLkZ68s/EXX4dARF7GujfXManyAuUD6awhJJER7D9TiAXr0n0dBnlJaloO5q1JY/f8Js4Tm2c3VuxTBe/0uVB6UzV0M2AiX7u2TTi++d2Nvg6DPIz9oxqnxlZwzj5VTVR6VhETKmoUhibV3mKJGh/W0TQ+SqK8bNtJ7t/pIUyqvCA1LQfrj+YyoaJGgcXqTUNddTScGjQeJsqex6TKC7Zn5LvVWJFIr/xM4BdxE+GsjoYjHsbEgnPPY58qLxjYORof/8Ctacj4zMJu6k2Jo/5R9kY8GkN9TmPHRquex6TKC25JiUVESAAKy9gFnIytZ7sIfhHriK+KjpU/FDniYTxstOpZTKq8YMG6dCZURKQpX3a55ogHkX1Mqrzg3/vP+joEIk20Dgv2dQh0xfaMfPiZoPbA8/YUHEc8qLG1Z9ACC9W9oLyi2tchEGkiKS6cK750IjTIH+YrS4rNAoQE+vs2IGpSuFjBPiZVXhAcxC87ahwWbzrGL1GdKK2oVr/A/QCUVfKPN/Ietmewj0mVFwT582WmxoFfovoxsHM0zKh5T8zQ56pM9rJqvNxpz9CUPgfcpgaebXOvbE9D1Fhw2xL9SE3L0W2xOLe5afxc+fx5+nOgt21qWKjuYZuP5vo6BCLNcMWXvtgrFtdL8bArvaz0EivVjyuLFZpaTzMmVR6WX1Lu6xCINMMVX/rmyzYLturqZWUvVgCaJllNOWnTy7E3tZ5mTKo8KDUtB9lFTKqIyDu8MSrg6sm6rl5WtrF+sSsT64/kapYQ6inB9DY9HXtT62nGCmoP+mJXpq9DINLM9YktfR0C1cHTe7u5u4z+lpRYPD8uxe6J1DZWQNuFEE15dZrejt3Z56CxYVLlQXmXOEpFjceXMwb5OgSqg7NNkLWg5cnaNtZJ/dq7lRDWtaKsKW8e3JSP3de4+g+eWT2g/EVH1BgE+AHHXh3r6zAMQy/1LFrz9EouV1czuhqHnldHelpTOXau/msitmfkwwSgyWes1ChENgvydQiGoad6Fq15uj7G1YUQrtaONeWFFU352H2p0Uz/LV68GB06dEBISAj69++PnTt3+jSegZ2jmVAZRGhgo/k1qLcgf5PT6yf1a++lSIxPb/UsWtNDfQynt0ivGsVI1RdffIGnnnoK7733Hvr374+3334bo0aNQnp6OmJiYnwSk/IX3Re7TiPvUhkKSytRXF6FFsEB6BLTAhcvV2LPqYs+ic1XQgP8YPIzobLajMpq76acMWHB6NEuAhcvV+LAmQKr539gSCf0SohU//oGYPX/NQsOTEiKC0N6dhGO5ZYgp6gUVWZBsyB/FJZWqaOSY7rHIz4iBPtOF1i9v6GBfggK8ENhaZV6WZC/CQlRzVBwuRLVZjMKLK6zZQJgMkHd6w0A/Gx+Vh4TACqrxWlSr8QbFhKAKQM74JlRSUhNy1E/r1mFpbh4uRKhgf6478r15JqmtoTcF5raijIyjkZRU9W/f3/069cP77zzDgDAbDYjISEBjz32GP7whz/UeX9vzsla1lrsO12grhBURgL+vf8s/E1+iAgNQFZhGS5XVCEpLhwtmwVi3+kCnC+uAFBzQk2OD0didHPsPJGvXg4AM4d1wX9/ycPZglJUVptRXmVGeEgAmgUF4GT+ZfV2HaKbISI0EK3DQjCpXwIA4J2Nv+BiSQWuaxeJ+IgQZBWW4duDWXYfu21kKGYN74p9pwuwZv9ZtGwWhCFdWyM9u6hWkX7rsGBM6tde/fJbsC4d/95/FlHqfS4BEPV12HE8H1mFZTiVX4KQQH+UVVYjMbo5KqqqkXepvFaSmhQXjrLKaqukSLn/0KSYWknBgnXp2Jyea/e6+ryn9r7c7V3u7HmV24cE+uObA+eQX1yOG6+JwbuT+zh9zLpqJ5TrldcjMbo54iNCeDLyoKZSz0Lka3qrqTJ8UlVRUYFmzZrh//7v/zBhwgT18qlTp6KgoABfffVVrfuUl5ejvPzqSb+oqAgJCQkef1PcKa60dztn97f8EgdQq0heGZlQ/jtzWBe7J3Xbx1ceS7mfbcx1xaqMpvgBMNu5f0NeP4BbpriKW4YQUWOkt6TK8MUk58+fR3V1NWJjrU8QsbGxyM7Otnuf+fPnIyIiQv2XkJDgjVBdrrVwdDtny6Ut6xyUInlLYvFff5PJ7o729p5XuUy5n23MjmJVLlemp8wO7u8Oy+cyoSZBbKx1K1pr7HU+RER6YPikqj6ee+45FBYWqv9Onz7tled1tbjS2e1cKRK1VySvJFl+Jjh8bnvPW1fMjq5XLve78sR+cPy8rrJ8LsHVBJF1K3VjYS8Rkec1yek/W96uqXK1D0tDajKUomNA1HojpTaprh3F61uz46imyJXndee47BWUcyqrbqzzIaLGRm/Tf4ZPqoCaQvUbbrgBf/3rXwHUFKq3b98es2bN0l2hOhEREWlDb+fvRtFS4amnnsLUqVPRt29f3HDDDXj77bdRUlKC+++/39ehERERURPRKJKqSZMmIS8vDy+88AKys7PRq1cvrF27tlbxOhEREZGnNIrpv4bS2/AhERER1U1v5+8mufqPiIiISGtMqoiIiIg0wKSKiIiISANMqoiIiIg0wKSKiIiISANMqoiIiIg0wKSKiIiISANMqoiIiIg00Cg6qjeU0v+0qKjIx5EQERGRq5Tztl76mDOpAnDp0iUAQEJCgo8jISIiInddunQJERERvg6D29QAgNlsxrlz5xAWFgaTyaTZ4xYVFSEhIQGnT5/WRft8dzB23zBq7EaNG2DsvsLYfaOxxS4iuHTpEtq0aQM/P99XNHGkCoCfnx/atWvnsccPDw833IdXwdh9w6ixGzVugLH7CmP3jcYUux5GqBS+T+uIiIiIGgEmVUREREQaYFLlQcHBwXjxxRcRHBzs61Dcxth9w6ixGzVugLH7CmP3DcbuWSxUJyIiItIAR6qIiIiINMCkioiIiEgDTKqIiIiINMCkioiIiEgDTKqIiIiINMCkioiIVEZeEF5RUYGff/4ZQM32Y0Zj5NeeajCpMhiz2Yzq6mpfh1Ev5eXl2LdvHwAY7hgqKytx5swZ9WcjffmZzWZDnmDKysqwaNEibNy40dehuM2ov6dvv/02br/9djz66KP48ccfUVFR4euQXHbw4EFERkZixowZuHTpEvz8/Az1e1pVVYULFy74Oox6MdLrbKusrAwfffQRfvrpJ00ej0mVgSxcuBDDhw/HPffcg9WrV6OwsBCAMf4iO3HiBFq0aIEJEyagoKAA/v7+hogbqHnde/bsiV//+teYMGECDh06BJPJZIj4Fy1ahNtvvx2TJ0/GP//5T/Uzo3fvvvsuYmJi8O9//xuFhYUoKyvzdUguM+LvaUlJCe644w785S9/Qe/evbF7927cd999ePnll30dmst27tyJ8PBwBAUFYenSpb4Oxy0LFy5E3759MX78eDz22GM4fvw4AGMkK4sXL8bdd9+NWbNm4fvvvzdUIv7OO+8gJiYGX3zxBfLy8rSJXUj3KioqZOrUqdK+fXt56623ZMyYMZKcnCz33Xefr0Nz2bfffitdu3aVm266SWbPni0iImaz2cdROVdUVCSTJk2SLl26yMqVK+Xdd9+VoUOHyrhx43wdWp0OHDggAwcOlGuuuUbeeOMNue2226R79+7y8ssv+zq0Oq1du1Z69eol//jHP6wu1/vnxci/pzt37pSuXbvK3r171cteeOEF6dy5s3z++ec+jKxuyudiyZIlcv/998vUqVNl5MiRcuzYMRERqa6u9mV4TuXl5cm4ceOkS5cu8umnn8oLL7wgAwYMkMcee8zXodVp79690rdvX0lKSpI5c+ZI3759JTk5udbvrV59/vnnct1112n++WZSZQDp6enSrVs3WbdunXrZsmXLJDIyUt59910R0e8Xh/KF99lnn8n48eNl7ty5kpycLPv37xcR/cYtIvLDDz9It27d5MCBA+plTz/9tEybNk1Eao5Njyf6goICeeKJJ+Tee++V8+fPq5c/+OCDcs8998jly5d9GJ1jymfhkUceURORzMxMWbJkiWzYsEGOHz8uIvpNroz4e6rE85///EeioqLk9OnT6nWZmZny4IMPSpcuXXwVnlO2n4OJEyfKihUr5Pvvv5f+/fvLH//4Rx9F5rpvv/1Wrr32Wjl16pR62cSJE+WZZ54REf1+1rOysuT++++X6dOnS0FBgXr5jTfeKI8//riI6Df2qqoqERG588471df5zJkz8umnn8quXbskOztbROr/u8rpPx1TpgsqKytx/PhxdOrUSb1u4sSJePTRR/GHP/wBly9fhp+fvt5KuTJsbTKZANQMzY8cORL33XcfWrdujddffx0AdBc3cPV1Ly4uRmZmJgIDA9XrDh06hHbt2uHw4cMwmUzq8emB5WseFRWFRx99FNHR0aisrAQAdO3aFbt370ZoaKgvw6xFidvPzw9VVVXYtm0bxo8fj9WrV6NHjx74/PPPMW3aNIwYMQJHjx7V1WsOGO/3dM2aNfjyyy+RmZmp1n0VFhaibdu2OHLkiHq7hIQETJ48GX5+fnjzzTd9Fa4VJfZTp06psZeXlwMAWrVqherqagwaNAjDhw/HDz/8gJkzZ+Lpp5/2Zch2KZ+ZM2fOoLi42Gqar7i4GB06dMDZs2d191lX4gwKCkKLFi3wyCOPICIiQn0P+vbti127dgGA7mJX+Pv7o6KiAj/++CPGjRuHTz/9FD169MC7776L8ePHY/z48Q36XfX9bzhZ+fLLL/G3v/0NBw4cUOtICgoKcO2112LTpk3q7Vq0aIEHH3wQrVq1wty5cwH4vmbDXuzKHHWzZs1w6dIldOzYEdOmTcO+ffvwwAMP4MEHH8T58+d9GTYA+7FHRUWhX79+GDVqFJ5++mlERUXhxIkT2LRpE8aOHYvp06f7OOoaP/74IwCodV7h4eGYPXs2Bg4cCAAICAgAAOTk5KiX6YFl3EDN5zcgIAApKSn429/+hpUrV+Kjjz7C2rVrsXXrViQmJuKhhx5CQUGBD6OusW7dOqxZswbHjx9HVVUVgJrERM+/p+np6ejduzceffRRzJkzByNGjFBjGjt2LAoLC7Fx40ZcvnxZvU+PHj0waNAgbNu2DaWlpT6JG6gd+8iRI/HSSy8BgLq57rZt25CYmAg/Pz+0b98eP/30Ez744AMkJiYC8H19kr2EMC4uDrGxsbjzzjvx4osvIioqChkZGViyZAlGjhyJOXPmAPD9d/vBgwcBXP2OiYqKwoIFC9CnTx8AV9+D06dP48Ybb/RZnPYosStEBFVVVejRowfef/99rFixAkuXLsU333yDlStX4vLly5gyZQqAer7uDRxJI41kZGRI3759pV27dtK7d29p166dOgVSXl4uQ4cOlfvvv1/Onj2r3qe0tFSef/556dOnjxQWFvoqdLuxT5061eo2gwYNkn//+98iIvKPf/xDIiMjxc/PTxYtWiQivhsqdva6i4icPn1aVq1aJTfccIO8+OKLUllZKQUFBbJp0yYxmUyyZ88en8V/4MABGTRokJhMJvnnP/8pIleHtu3FNHr0aPnLX/5i9zpvcha32WyW1157Tdq2bStdunSRnJwcNdaMjAwxmUyyfft2n8W+c+dO6d69u3Tp0kVSUlKkS5cu8uqrr4qISFlZmdx8883ywAMP6PL3dPbs2XLrrbdKYWGhnDp1St544w1p1qyZ/O1vfxMRkTfeeEMiIiJky5YtVvd76qmnZMiQIb4IWWUb+4IFC6RZs2by8ccfi4hIYWGh3HHHHfL999/LuHHjJDg4WAYNGiTXX3+9fPnllyLiu6nXo0ePSq9evaRdu3bSrVs36dKlizo1WVVVJbt375YPPvhAkpOT5bXXXpOysjI5c+aMfPLJJ2IymaymBr1t37590r9/f2nTpo2sX79ejVlh+T1iNptl0KBB6u+0rzmLvaqqSh555BGJj4+XQYMGSXl5uXq/DRs2iMlkkhMnTtTreZlU6cTrr78ugwcPlkuXLkleXp58+eWX0qxZM5kzZ46I1CQiiYmJsnTpUqv7LVy4UHr16iUXL170QdQ1HMU+d+5ctX5nypQp8tlnn8ntt98uwcHBMmrUKElJSVFrTSx/UfUQ+4svvihlZWUiIrJ7926JjY21qjfJy8uTdu3ayYIFC3wS965du+Smm26S8ePHy+233y5Dhw6VyspKEbGfMOXl5UlERIT897//VS/LycnxWrwKZ3Er/921a5f06dNH4uPj1ftVVlZKYWGhdOrUSZYsWeL1uEVqCui7d+8uzz77rFy8eFEyMjLkueeek+uvv14OHjwoIiIff/yxdOzYUXe/p5cvX5Z27drJW2+9pV5WXl4uc+bMkYiICPXE3b17d5kwYYJa8ygi8rvf/U7Gjx+vvj/e5iz2li1bqie/sLAwMZlMMnr0aElPT5fTp0/LxIkT5aabbpL8/HyfxC7iOCH88MMP1dts3LhR2rdvb1UDeeDAAWnbtq18+umnvghbtm7dKv369ZNbb71Vhg4dKtOmTbP648fWzz//LGFhYZKWlqZeduHCBa/Fa8lZ7MrnODU1VVq3bi0pKSlW901PT5fExET517/+Va/nZlKlA1VVVdKnTx91VZzib3/7mwQFBcnWrVtFRORXv/qVjBgxQlJTU9XbvPLKKzJkyBA1AfA2Z7EHBwfL5s2bRUQkMTFRTCaTjBs3TtLS0iQ/P18ee+wxadeunWRlZfkidKexh4SEyKZNm0Sk5pdv4MCBsmvXLvU2qampkpycbFXE7k0XL16UWbNmyeHDh2XlypXSs2dPef3110XE/l/kK1askM6dO4uIyPnz5+WBBx6Q6667zmpExddxWybWixcvlpCQEPWPChGR77//Xnr06KGu6vKmqqoq+eCDD2TWrFly/vx59aSyfv166dy5sxw6dEi97e233y4jR47Uze+p8nkYNGiQPPHEEyJy9aRYWFgoXbt2lenTp4uIyJYtW2TgwIHSrVs3+ctf/iJz586VqKgon53YXYn9kUceERGRf/7zn/Lvf//b6nO0ZMkSefbZZ6WoqMjLkdeoKyHMyMgQEZGPPvpIbrnlFqtRqdWrV0tKSkq9R0waKjMzUx566CE5duyYLFiwQPr37y/Lly8XkdojVCIiixYtkl69eomISH5+vtx///0yduxYycvL01Xslp+PZ599Vlq1aiXvvPOOetk333wjPXv2VAvW3cWkyseUL43bbrtN7rzzTqvLRET69u2rLuHfv3+/TJw4UaKiouSPf/yjPPfcc9KyZUtZvHix9wMX92LfunWr/Otf/7L6a/fbb7+V2bNny4ULF7w+HeVK7L/61a9EpGYY+cYbb5T+/fvLBx98IPPmzZO4uDiZNWuWXL582euxK89XUlIiIjWJyhNPPCHdu3eXzMxMEak98vfSSy/Jgw8+KAsXLpSwsDAZMGCA/Pzzz7qLWxmGv3jxoixYsED8/f1l+PDh8vDDD0tMTIzMmjVLSktLfTJ9efjw4VojTZmZmRIbGyvp6enqZQcOHNDV76lIzdTko48+KmPGjFFXUSqf9w8//FBCQkLUUYW0tDSZMWOGjB49Wnr37i1r1qzxWdwidcceGhpqtQJN5OpnzVcj4CLuJYSbN2+WLl26yMSJE+XLL7+UV199VeLi4uTZZ5+V8vJyn03XX7p0SUREzp07J7/5zW9k3Lhx6gi37R9vM2fOlDlz5sjbb78tYWFh0q9fP5/8AaRwFrvyPZOZmSmPPfaYmEwmufvuu+Xxxx+XmJgY+cMf/iAVFRX1et2ZVOlAdXW1vPHGG9KzZ091GkF501NTU8XPz0/9ayU/P19efPFFufvuu63qlHzFndgVygfV10tuXYld+RJfu3at/PrXv1aTK1+faBTKF9umTZtk8ODBMmPGjFq3qaiokN69e4vJZJLExERZtWqVt8OsxZW4RURWrVolc+fOlbvuuku+/vprb4bokGUrjY8//lhSUlKkoqLC6iRz8eJFr/6eOqsXUmJdsWKF9OnTRxYuXGh1/cGDB6Vbt261PhfKScnTtIi9vlM1nuZOMvvBBx/IsGHDpG/fvtKnTx/dfMcoiek//vEPGTBggMyfP7/WbS5evCht27YVk8kk7dq1k9WrV3s5SvtciV1E5P3335fHH39cxo4d2+DXnUmVF9n78lC+NDZt2iQ33nij/O53v7O6vqCgQJKSkqyGJ0W8/xdYQ2L35V/oIg2L/a9//avV5fUdEq4vV4try8vL5dVXX5WkpCS1bkoZFbx06ZLcf//98v7773ssTlsNjduXCbcrsSvxTZs2TR5++GGHt/PG7+mbb74pd911l8ycOVN27NghFRUVVjFauvvuu2XkyJHq1LaIyJ49e6R58+aybds2h/fzFK1j9zYtEkKlkF7hrek+V39HleO4fPmyTJ8+XYYOHaqWPSif77y8PBkxYoS66MHTtIjdUzWCbKngYR9++CH+9re/AbDfk0lZTj506FDcdNNN+P777/Hll1+q158/fx4XL15EQkICgKvLgv39/T0dumaxt2vXzuOx2tIq9vbt2wO4urQ2NjbW06HXGbstEUFQUBDGjRuHa665Bm+++SYyMzNx33334ZtvvkGLFi3w4YcferwFhJZxr1u3zqOx2nI3dsWhQ4cwePBgADX9hZ577jkcO3ZMvd6Tv6c7duxAz549sXTpUnTt2hVbt27Fww8/jK+++gqAdZ8g5fP7xBNPIDg4GDNnzsTevXuRk5OD7777Dj179kSHDh1q3c9osXvTwoULMXnyZMyaNQs//vij2g9ObHr0TZo0CUlJSfj222+xefNm9f4VFRU4ffo04uPjAVw9Tm8cS12xW1LaKISGhuKuu+6CiGDp0qU4deoUJk+ejAMHDqBVq1ZYu3YtHnroIcPEfu+99yItLU37AD2SqpHs27dPhg8fLiaTSYYNG+Z06b2Sdf/888/ywAMPSHR0tHz77bdy/PhxefPNN6V79+5erX9h7PqP3ZFFixZJSEiIBAQESKdOnbwSv1HjFmlY7MePH5eOHTvK8ePH5aOPPpLIyEi59tpr5eTJk54OW06fPi2TJ0+WWbNmSXFxsXp5v3791OX6jo5h3759MmLECElISJAOHTpIfHy8fPvttx6PWWHk2EVEtm/fLj169JDu3bvL888/L927d5eePXvKypUra91W+Y758ccfZezYsZKSkiJ79uyR7OxseeWVV2TQoEFy7tw5XcbuyNNPPy2RkZESHBwsHTp0kGPHjnlldNMosTOp8oDq6mp59dVX5c4775T3339fbrjhBvnTn/7kdMm7Ii8vTyZNmiSdOnVSvzS++uorb4XO2A0Yu0jNUPbXX38t8fHx0qFDB6/FbtS4RRoe+6JFiyQgIEASExOlZcuWXt3z7OzZszJr1iy1FlBZVfjAAw/IqFGj7N7H8njKy8vll19+8XpCImLs2I2cEDYkdpGa2szVq1dLfHy8dOzY0at1U0aKnUmVxpQ39vDhw/L999+LiMjvf/97GTJkiHz33XdWt3EmJydHbUfgLYzduLGXlpbKbbfdJs8995xng7Vg1LhFtIl93rx50qxZM69sUv3555/L+++/L4cOHVJ7v9nbw3H06NHyyiuveDwedxg5dltGTgjrE7ulkpIS6datmzz77LMejdMeI8XOpEoDll8aypttWaB6/PhxGTRokDz88MNqczdnX9jeLBRl7FcZNXZlikEp8vUko8Ytov3n5eDBgx7vf5SWlibXXXeddOjQQbp37y7t27dXl+HbxldeXi59+vRRk0JfM3LsCiMnhFrGrvyeeKvPmpFjZ1LVAHV9aYhcfUPfeust6du3b61Oy77C2H3DqLEbNW4RY8f+wgsvyPDhw6W0tFSys7Pl888/l8DAQFmwYIE6Takkpz/99JOEh4erS/dFxKedxI0cu5ETQsbuW0yqGsCVLw3ly/ry5csyevRoufPOO9WGaIcPHxYR3/RrYuyMvSnEbeTYS0tLpVu3buregoo33nhDwsLCau2B+Morr8jgwYNFRCQrK0vuuecemThxYq3GmN5g5NhFjJ0QMnbfYlJVT+58aShf2F9++aX069dPnnzySRk3bpxER0d7ve+RCGNn7E0jbhHjxq6cOIYMGSIPPvigVXwiIsnJyXLvvfda9eu5//775dVXX5XXXntNmjVrJjfeeKPVfpXeYuTYRYydEDJ23yXiCiZV9VCfLw2Rmj3X2rdvLyaTScaMGeOVpde2GDtjd4dR4xYxduwiNSsj582bJ3369FFHzZSO/19++aUEBgaq+6plZWVJZGSkmEwm6dixo6xdu9YnMSuMGruRE0LG7rtE3BKTqnpy50tDpGZvJ5PJJNdee6262shXGLtvGDV2o8YtYtzYleL9b775RgYNGlRr1VJubq506NBBrf3KysqSoUOHyrJly7weqy0jxy5i3IRQhLHrAZOqenD1S8PyS6K4uLjWlie+wNh9w6ixGzVuEX3HruxjaFunZW9bm9mzZ0vv3r2tCnIPHDggrVq1kvXr16uXeavmy8ix18XICSFj1wcmVXZo/aXhzX36GDtjd4dR4xYxZuybNm2Srl27islkUjdutbeP2YoVK6Rt27ayefNm+fnnn+Wee+6R+Ph4+c9//iMnTpyQl19+Wfr06SOnTp3yeMyNIXaFkRNCxq7PRNwWkyoLRv7SYOyMvSnEbeTYd+/eLbfffrv89re/lTvvvFOuueYaq+vNZrPk5+fLbbfdJjExMbJw4UL1L/isrCy5/fbbpXPnztK+fXtp166d/Oc///FK3EaPXcS4nxnG7vtE3F1Mqq4w8pcGY2fsTSFuo8d++vRpefPNN+Xo0aOSlpYmLVu2lD//+c8icvVEU1paKosXL5asrKxa96+qqpLs7GzZsmWL12JWGDl2I39mGLvvEvH6YlJ1hZG/NBg7Y28KcYsYK/Zt27bV2ixXOWmYzWZ55ZVXpEWLFmpvHaUPjyP2/sL3FCPHbstInxlbjN03sTdEk02qjPylwdivYux1M2rcIsaMff369dKxY0dJTEyUdu3ayfTp0yU9PV2NWakFOXv2rCQnJ8u0adPU63zNyLErjPiZUTD2q3yZiDdEk0uqjPylwdh9w6ixGzVuEePGnpmZKQMGDJDnn39ejh07JitXrpROnTrJxIkT1X5XlieTzz77TEwmk+zdu1dEak5CxcXFjL0ejPqZEWHsjUmTSqqM/KXB2Bl7U4jb6LH/5z//kdDQULXPjkhNj52bbrpJHn74YfUy5YRSVFQko0ePlptvvlkOHDggo0ePlvfee8+rqygbQ+xG/swwdt8l4p7QpJIqI39pMHbG3hTiNnrsK1askD59+qh/qYvU1Ib87//+r6SkpMjmzZvVyxSrVq0Sk8kkJpNJhg0bJhcuXPB63CLGjt3InxnG7pvYPaVJJVVG/tJg7Iy9KcQtYuzYDx48KCEhIfLVV19ZXf7TTz/JqFGj5Mknn1Qvq6iokGXLlklwcLD069dPdu3a5e1wrRg5diN/Zhi7b2L3lCaVVBn5S4Ox+4ZRYzdq3CLGjl1E1L/EL126ZHX5fffdJ7/61a/UAtyLFy/KM888I0uWLPFFmHYZNXYjf2YYe+PSpJIqEeN+aYgwdl8xauxGjVvE2LHv27dPAgICZMmSJereZSIif/rTn6RLly4+jKxuRo7dyJ8Zxt54NLmkyshfGozdN4wau1HjFjF27CI1cbZp00Y+/PBDKS4ulqKiIhk1apTMnTvX16HVyaixG/kzw9gbjyaXVIkY90tDhLH7ilFjN2rcIsaOXUTk0Ucflfj4eOnfv78kJiZKSkqKHD582NdhucSosRv5M8PYGweTiAiaoJkzZ2L16tVo3749srOz0bx5c6xcuRIpKSm+Dq1OjN03jBq7UeMGjB17WVkZjhw5gr179yI4OBj33nuvr0NymZFjN/JnhrEbX5NNqoz8pcHYfcOosRs1bsDYsZNvGPkzw9iNr8kmVURERERa8vN1AERERESNAZMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSIiIiLSAJMqIiIiIg0wqSKiRmvu3LmIjY2FyWTCv/71L4eXuePkyZMwmUzYt2+fprESkfGxozoRuWXatGlYtmwZACAgIABRUVHo0aMH7r77bkybNg1+fvr4W+3IkSNISUnB6tWrMWDAALRs2RLHjx+vdVlwcLB6n7lz5+Kll15y+rhVVVXIy8tDq1atEBAQ4OnDICID0ce3HxEZym233YasrCycPHkS3333HYYNG4bHH38c48aNQ1VVlcP7VVZWei3GjIwMAMCvfvUrxMXFITg42O5llp5++mlkZWWp/9q1a4d58+ZZXebv74+4uDgmVERUC5MqInJbcHAw4uLi0LZtW/Tp0wd//OMf8dVXX+G7777D0qVL1duZTCYsWbIEt99+O5o3b47//d//BQAsWbIEnTt3RlBQEJKSkvD3v//d6vGV+40ePRqhoaHo1KkT/u///s/qNgcPHsTw4cMRGhqK6OhoPPTQQyguLgZQM+I0fvx4AICfnx9MJpPdy2y1aNECcXFx6j9/f3+EhYVZXWY7/bd582aYTCasW7cOvXv3RmhoKIYPH47c3Fx89913SE5ORnh4OO655x5cvnxZfS6z2Yz58+ejY8eOCA0NRc+ePWsdIxEZjBARuWHq1Knyq1/9yu51PXv2lNGjR6s/A5CYmBj5+OOPJSMjQ06dOiWrVq2SwMBAWbx4saSnp8ubb74p/v7+snHjRqv7RUdHywcffCDp6ekyZ84c8ff3l7S0NBERKS4ulvj4eJk4caIcPHhQNmzYIB07dpSpU6eKiMilS5fkk08+EQCSlZUlWVlZdi+rS2Jiorz11ltWl504cUIAyE8//SQiIps2bRIAMmDAAPnvf/8re/fulS5dusjNN98st956q+zdu1e2bt0q0dHR8tprr6mP88orr0i3bt1k7dq1kpGRIZ988okEBwfL5s2bXXgXiEiPmFQRkVucJVWTJk2S5ORk9WcA8sQTT1jdZtCgQTJ9+nSry+68804ZM2aM1f0eeeQRq9v0799fZsyYISIi77//vrRs2VKKi4vV67/55hvx8/OT7OxsERFZvXq12P7daO8yZ9xJqtavX6/eZv78+QJAMjIy1MsefvhhGTVqlIiIlJWVSbNmzWTbtm1Wj/3ggw/K3Xff7XJ8RKQvnP4jIs2ISK1ptb59+1r9fOTIEQwePNjqssGDB+PIkSNWlw0cOLDWz8ptjhw5gp49e6J58+ZWj2E2m5Gent7g46iPHj16qP8fGxuLZs2aoVOnTlaX5ebmAgCOHTuGy5cv45ZbbkGLFi3Uf8uXL1frvojIeFhpSUSaOXLkCDp27Gh1mWXi05gFBgaq/28ymax+Vi4zm80AoNZ+ffPNN2jbtq3V7WyL54nIODhSRUSa2LhxIw4ePIg77rjD6e2Sk5Pxww8/WF32ww8/ICUlxeqyHTt21Po5OTlZfYz9+/ejpKTE6jH8/PyQlJTUkMPwipSUFAQHByMzMxNdunSx+peQkODr8IionjhSRURuKy8vR3Z2Nqqrq5GTk4O1a9di/vz5GDduHKZMmeL0vs888wz+53/+B71798bIkSOxZs0arFq1CuvXr7e63cqVK9G3b18MGTIEn376KXbu3ImPPvoIADB58mS8+OKLmDp1KubOnYu8vDw89thjuO+++xAbG+ux49ZKWFgYnn76aTz55JMwm80YMmQICgsL8cMPPyA8PBxTp071dYhEVA9MqojIbWvXrkV8fDwCAgLQsmVL9OzZE4sWLcLUqVPrbP45YcIE/OUvf8Ebb7yBxx9/HB07dsQnn3yCoUOHWt3upZdewooVK/Doo48iPj4en3/+uTqa1axZM6xbtw6PP/44+vXrh2bNmuGOO+7AwoULPXXImnv55ZfRunVrzJ8/H8ePH0dkZKTanoKIjIkd1YlId0wmE1avXo0JEyb4OhQiIpexpoqIiIhIA0yqiIiIiDTAmioi0h1WJRCREXGkioiIiEgDTKqIiIiINMCkioiIiEgDTKqIiIiINMCkioiIiEgDTKqIiIiINMCkioiIiEgDTKqIiIiINPD/3T/GU4WAmV4AAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -551,10 +623,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 10,
    "id": "1c06746a382ca255",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:55.092288Z",
+     "iopub.status.busy": "2024-08-28T17:27:55.092162Z",
+     "iopub.status.idle": "2024-08-28T17:27:55.295492Z",
+     "shell.execute_reply": "2024-08-28T17:27:55.295063Z"
+    }
    },
    "outputs": [],
    "source": [
@@ -563,15 +641,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 11,
    "id": "e9decc93d86484b8",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:27:55.298084Z",
+     "iopub.status.busy": "2024-08-28T17:27:55.297856Z",
+     "iopub.status.idle": "2024-08-28T17:28:02.704856Z",
+     "shell.execute_reply": "2024-08-28T17:28:02.704559Z"
+    }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -623,10 +707,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 12,
    "id": "324ce2b2a505896b",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:02.706815Z",
+     "iopub.status.busy": "2024-08-28T17:28:02.706678Z",
+     "iopub.status.idle": "2024-08-28T17:28:02.827733Z",
+     "shell.execute_reply": "2024-08-28T17:28:02.827310Z"
+    }
    },
    "outputs": [],
    "source": [
@@ -638,15 +728,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 13,
    "id": "b8bcfad9f2595785",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "execution": {
+     "iopub.execute_input": "2024-08-28T17:28:02.829840Z",
+     "iopub.status.busy": "2024-08-28T17:28:02.829693Z",
+     "iopub.status.idle": "2024-08-28T17:28:07.543554Z",
+     "shell.execute_reply": "2024-08-28T17:28:07.542916Z"
+    }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAikAAAHHCAYAAAB6NchxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACi7UlEQVR4nOy9eZwU1dX//7m3ep2lZ18YYAAVZRcDCuP2GEWRoMZIYjCouPzCVwIqEBV5HhFwQ3kSd+MWhPgo0WjUJBhRREVRUIJiUIxBRcHIMAjMDDMwM91d9/dHdVVXdS09vcx093Devlqm69a9daqXup8+59xTTAghQBAEQRAEkWXwTBtAEARBEARhBYkUgiAIgiCyEhIpBEEQBEFkJSRSCIIgCILISkikEARBEASRlZBIIQiCIAgiKyGRQhAEQRBEVkIihSAIgiCIrIRECkEQBEEQWQmJFII4jLnssstQUFDQqX0ZY1i4cGGX2rN8+XIwxvD111936XEIgsgNSKQQOY86sf3jH/+wbD/ttNMwbNiwbraKIAiCSBVXpg0gCCI3OHToEFyurr1kXHLJJZg8eTK8Xm+XHocgiNyARApBEJ3C5/N1+TEkSYIkSV1+HIIgcgMK9xCHLU899RRGjRoFv9+P0tJSTJ48GTt37tTaly1bBsYYnnjiCUO/O+64A4wx/P3vf9e2/eY3v8GJJ56IsrIy+P1+jBo1Cs8//7zpmIcOHcI111yD8vJyFBYW4rzzzsN//vMfy3yPjz76CBMmTEAgEEBBQQHOOOMMbNiwwbCPGup69913MWfOHFRUVCA/Px8/+clPsGfPnk6/Fl999RXGjx+P/Px81NTU4JZbbkHsDdJjbVy4cCEYY/jiiy9w2WWXobi4GEVFRbj88stx8OBBU9+ZM2fipZdewrBhw+D1ejF06FCsWrXK8nz0OSn9+/fHOeecg3Xr1uGEE06Az+fDEUccgSeffNJ0Hv/85z/xX//1X/D7/ejTpw9uu+027X2kPBeCyD1IpBA9hqamJnz//femRzAYNO17++2349JLL8XAgQNx9913Y9asWVizZg1OPfVUNDY2AgAuv/xynHPOOZgzZ44mXrZs2YJFixbhyiuvxI9+9CNtvPvuuw/HHXccbrnlFtxxxx1wuVz42c9+hpdfftlw3MsuuwwPPPAAfvSjH+Guu+6C3+/HxIkTTfZ9+umnOOWUU/Dxxx/jhhtuwPz587F9+3acdtppeP/99037X3311fj444+xYMECTJ8+HX/7298wc+bMTr1u4XAYZ599NqqqqrBkyRKMGjUKCxYswIIFCzrV/8ILL8SBAwewePFiXHjhhVi+fDkWLVpk2m/dunX41a9+hcmTJ2PJkiVoa2vDpEmTsHfv3rjH+OKLL/DTn/4UZ555Jn7729+ipKQEl112GT799FNtn//85z/44Q9/iE8//RTz5s3D7Nmz8fTTT+O+++7r1HkQBJGFCILIcZYtWyYAOD6GDh2q7f/1118LSZLE7bffbhhny5YtwuVyGbbv2rVLlJaWijPPPFO0t7eL4447TtTW1oqmpiZD34MHDxqed3R0iGHDhonTTz9d27Zp0yYBQMyaNcuw72WXXSYAiAULFmjbzj//fOHxeMSXX36pbfvuu+9EYWGhOPXUU03nPm7cOCHLsrZ99uzZQpIk0djY6PjaTZ06VQAQV199tbZNlmUxceJE4fF4xJ49e7TtsTYuWLBAABBXXHGFYcyf/OQnoqyszLANgPB4POKLL77Qtn388ccCgHjggQdM57N9+3ZtW79+/QQA8fbbb2vbGhoahNfrFb/+9a+1bVdffbVgjImPPvpI27Z3715RWlpqGpMgiNyAPClEj+Ghhx7C6tWrTY8RI0YY9nvhhRcgyzIuvPBCg8eluroaAwcOxJtvvqntW11drY17yimnYPPmzXjiiScQCAQMY/r9fu3v/fv3o6mpCaeccgo+/PBDbbsa2vjVr35l6Hv11VcbnofDYbz22ms4//zzccQRR2jbe/XqhV/84hdYt24dmpubDX2mTZsGxpj2/JRTTkE4HMY333zTqddO73VRQzMdHR14/fXX4/a96qqrDM9POeUU7N2712TjuHHjcOSRR2rPR4wYgUAggK+++iruMYYMGYJTTjlFe15RUYFjjjnG0HfVqlWoq6vDyJEjtW2lpaWYMmVK3PEJgshOKHGW6DGccMIJGD16tGl7SUkJvv/+e+35tm3bIITAwIEDLcdxu92G55MnT8ZTTz2Fl19+GdOmTcMZZ5xh6rNy5Urcdttt2Lx5M9rb27XteuHwzTffgHOOAQMGGPoeddRRhud79uzBwYMHccwxx5iOM3jwYMiyjJ07d2Lo0KHa9traWtM5A4pgigfn3CCGAODoo48GgE7lcTgdWy/mYvdT9+2MjZ3p+80336Curs60X+zrSxBE7kAihTjskGUZjDG88sorlitJYoub7d27V6vBsnXrVsiyDM6jTsh33nkH5513Hk499VT87ne/Q69eveB2u7Fs2TKsWLGia08mgt2KGBGT/JrJY6diYybPjyCIzEEihTjsOPLIIyGEwIABAzSPgRMzZszQEkPnzZuHe++9F3PmzNHa//znP8Pn8+HVV1811PdYtmyZYZx+/fpBlmVs377d4MX54osvDPtVVFQgLy8Pn3/+ucmWf/3rX+Cco2/fvp0+33jIsoyvvvrK8Fr8+9//BqCsrMkV+vXrZ3otAfPrSxBE7kA5KcRhxwUXXABJkrBo0SLTL3EhhGG1yfPPP49nn30Wd955J2688UZMnjwZN910kzaJA8qvfMYYwuGwtu3rr7/GSy+9ZBh7/PjxAIDf/e53hu0PPPCA4bkkSTjrrLPwl7/8xRBu2b17N1asWIGTTz7ZlBOTKg8++KD2txACDz74INxut2VoK1sZP3481q9fj82bN2vb9u3bh6effjpzRhEEkRLkSSEOO4488kjcdtttmDdvHr7++mucf/75KCwsxPbt2/Hiiy9i2rRpuO6669DQ0IDp06fjhz/8oZZY+uCDD+LNN9/EZZddhnXr1oFzjokTJ+Luu+/G2WefjV/84hdoaGjAQw89hKOOOgr//Oc/teOOGjUKkyZNwr333ou9e/di7NixWLt2rSZ49Pkrt912G1avXo2TTz4Zv/rVr+ByufDoo4+ivb0dS5YsSevr4fP5sGrVKkydOhVjxozBK6+8gpdffhn//d//jYqKirQeqyu54YYb8NRTT+HMM8/E1Vdfjfz8fPz+979HbW0t9u3bZ3h9CYLIDciTQhyW3Hjjjfjzn/8MzjkWLVqE6667Dn/9619x1lln4bzzzgMATJ8+He3t7VoxMAAoKyvDY489hvXr1+M3v/kNAOD000/H0qVLUV9fj1mzZuGPf/wj7rrrLvzkJz8xHffJJ5/EjBkz8PLLL2Pu3Lno6OjAs88+C8BY0XXo0KF45513MGzYMCxevBiLFi1Cv3798Oabb2LMmDFpfS0kScKqVatQX1+P66+/Hhs3bsSCBQtw6623pvU4XU3fvn3x5ptvYvDgwbjjjjtw7733YurUqbjiiisAdE/FXIIg0gsTlHlGEBll8+bNOO644/DUU0/RctkuYNasWXj00UfR0tJCJfcJIscgTwpBdCOHDh0ybbv33nvBOcepp56aAYt6FrGv7969e/F///d/OPnkk0mgEEQOQjkpBNGNLFmyBJs2bcIPf/hDuFwuvPLKK3jllVcwbdq0tK7YOVypq6vDaaedhsGDB2P37t1YunQpmpubMX/+/EybRhBEElC4hyC6kdWrV2PRokXYunUrWlpaUFtbi0suuQT/8z//A5eLfjOkyn//93/j+eefx7fffgvGGH7wgx9gwYIFGDduXKZNIwgiCTIuUv7zn/9g7ty5eOWVV3Dw4EEcddRRWLZsmWXlUIIgCIIgDh8y+tNt//79OOmkk/DDH/4Qr7zyCioqKrBt2zatrDZBEARBEIcvGfWk3HjjjXj33XfxzjvvZMoEgiAIgiCylIyKlCFDhmD8+PH49ttvsXbtWvTu3Ru/+tWv8Mtf/tJy//b2dsPN22RZxr59+1BWVkaFmgiCIAhHhBA4cOAAampqDPffSjdtbW3o6OhIeRyPx0P1fUQG8Xq9wuv1innz5okPP/xQPProo8Ln84nly5db7r9gwQIBgB70oAc96EGPpB87d+7ssnnt0KFDorq6KC12VldXi0OHDnWZrblARj0pHo8Ho0ePxnvvvadtu+aaa7Bx40asX7/etH+sJ6WpqSlyC3cOgDwpncPqdUrkIxDbP9GPTyr9rX75yLpxE/0MqNcCAJAs+uvbrYgem8FtMXrYob9+bDcYM9bwUL6W6i8xq8+30B3fY/IkChEGEIY9erucPhMSGDOmrim2BXV9nV532Wa7869YFmkXtv3Vsc2vL4MLAINAyOb4qs12Y6vnY/fexWsnshfle9PY2IiioqIuOUJzczOKiorw9c77EAj4UxjnEPr3vRZNTU1pv1dXLpHRxNlevXphyJAhhm2DBw/Gn//8Z8v9vV6v4S6zUZKZoA5PmMXrlJhEiZkMu+3YzDKkJwRzbHciKs8ZGEvc9SsEByDAINkc28keBiGUSZIxburPGIOQo+eG2PGFOj4Ds3Rbc9hPwojRKBZ2qu3MfG6MMe3c43/37Nqc3ysGBgFh+ZmBEIrNwm4MAcZ45P0176O0Ccs24/GdbaNrTu7SHekBBQVeFBRYzVedQ5adBPrhQ0ZFykknnWS6Hf2///1v9OvXL0MWEU5YTRjRC3amYEj2F60y2abD9mQveKqQcJrIhbWI0Cbproqrq69rvHOzFwqpIOJ6seyPISAiCtSmXQjl5XMY3ukzndnPO5ErCBGCEKGU+hMZFimzZ8/GiSeeiDvuuAMXXnghPvjgAzz22GN47LHHMmlWj8XyV2lOEM9LkrgXJYpTqXRnAcQYA4QrhWMzMOZ16K96K+y6m0NM+rGdD82iHgm7/sztYFu8c051Io/TXziFsuQ4YSLhKFAIIh0IEY6EXZPvT2T43j3HH388XnzxRfzxj3/EsGHDcOutt+Lee++lm6x1AakKlFT6s8h/Sfd3EAGMpSJQ0tPfoTW1YzOLME8i/eMR59jxzy1XRS9BELlCxutwn3POOTjnnHMybQZBEARBpA1ZhCCnELJJpW9PIuMihSAIgiB6GpSTkh4yGu4hCIIgCIKwgzwpBEEQBJFmlMTZVDwplDgLkEghCIIgiLQj5BCEnIJISaFvT4LCPQRBEARBZCXkSSEIgiCIdCNCyiOV/gSJFIIgCIJIN7S6Jz1QuIcgCIIgiKyEPCkEQRAEkW7kECAH4+/n1J8gkUIQBEEQ6UYJ9zjdGyx+f4JECkEQBEGkHzkEyMmLFPKkKFBOCkEQBEEQWQl5UgiCIAgi3ZAnJS2QSCEIgiCItBNOsdYJlcUHKNxDEARBEESWQiKFIAiCINIMk0MpPxIhHA5j/vz5GDBgAPx+P4488kjceuutEEJo+wghcPPNN6NXr17w+/0YN24ctm3bZhhn3759mDJlCgKBAIqLi3HllVeipaUlLa9JMpBIIQiCIIh0I4dSfyTAXXfdhYcffhgPPvggPvvsM9x1111YsmQJHnjgAW2fJUuW4P7778cjjzyC999/H/n5+Rg/fjza2tq0faZMmYJPP/0Uq1evxsqVK/H2229j2rRpaXtZEoUJvczKMZqbm1FUVARAAsAybU5WwxxeH4H4H4FU+qd8bNaVWjre2LJjK3NI6xKQ4/TnYMyhvwgDDq+Pc18BIIVCUinaFu91S+n3kRCO43fmM0UcrggAYTQ1NSEQCHTJEdR56dttUxEo9CQ/zoEO9Bn4h07bes4556CqqgpLly7Vtk2aNAl+vx9PPfUUhBCoqanBr3/9a1x33XUAgKamJlRVVWH58uWYPHkyPvvsMwwZMgQbN27E6NGjAQCrVq3Cj370I3z77beoqalJ+nyShTwpBEEQBJFu0uRJaW5uNjza29stD3fiiSdizZo1+Pe//w0A+Pjjj7Fu3TpMmDABALB9+3bU19dj3LhxWp+ioiKMGTMG69evBwCsX78excXFmkABgHHjxoFzjvfff79LXqZ40OoegiAIgkgzTITARPJ+ABZZGdS3b1/D9gULFmDhwoWm/W+88UY0Nzdj0KBBkCQJ4XAYt99+O6ZMmQIAqK+vBwBUVVUZ+lVVVWlt9fX1qKysNLS7XC6UlpZq+3Q3JFIIgiAIIkvZuXOnIdzj9Xot9/vTn/6Ep59+GitWrMDQoUOxefNmzJo1CzU1NZg6dWp3mZt2SKQQBEEQRLqRZUBOodaJrORdBQKBTuWkXH/99bjxxhsxefJkAMDw4cPxzTffYPHixZg6dSqqq6sBALt370avXr20frt378bIkSMBANXV1WhoaDCMGwqFsG/fPq1/d0M5KQRBEASRZrp7CfLBgwfBuXFKlyQJckTsDBgwANXV1VizZo3W3tzcjPfffx91dXUAgLq6OjQ2NmLTpk3aPm+88QZkWcaYMWOSfSlSgjwpBEEQBJFu5DAgp+AHSNALc+655+L2229HbW0thg4dio8++gh33303rrjiCgAAYwyzZs3CbbfdhoEDB2LAgAGYP38+ampqcP755wMABg8ejLPPPhu//OUv8cgjjyAYDGLmzJmYPHlyRlb2ACRSCIIgCCLneeCBBzB//nz86le/QkNDA2pqavD//t//w80336ztc8MNN6C1tRXTpk1DY2MjTj75ZKxatQo+n0/b5+mnn8bMmTNxxhlngHOOSZMm4f7778/EKQGgOimHDVQnxQ6qk9IVtlGdFCI76b46Kd9t/hEChe7kxzkQRM3Iv3eprbkAeVIIgiAIIs0wOQyWQriHpZJ024OgxFmCIAiCILIS8qQQBEEQRLoRKSbOCvKkACRSCIIgCCLtMFlOKWTD5Hh5XYcHFO4hCIIgCCIrIU8KQRAEQaQbOQzIKaw6pcRZACRSCIIgCCLtKKt7khcptLpHgcI9BEEQBEFkJeRJIdKA+mvBroiWBKX4ll27C4DTfSokAHa/KjgYc0OIdgfbGOyLfznbzpgXQgQd+jvBwJgPQrQl0dfeps7DEa+YnF27UgwuBEACYxa/BtWCanaF9tQakVZ9AUDIAJhlu3JsAeX1s2iH2u5cKJAgMgqFe9JCj/Ok5OpFi0X+y9jxHau6OtvFmAuMSQ47uAHb6qUMnHtgr5clMOa2tYEzLySe52CjK9Lf5ujMBUUE2Ryd54Ezj11v+0kaAGNuSNzvMH6qX784lX6Zy+EYLNJu97rJECLkcIyI6EymYLUmQuJVrM1M5dhUv4u5eg0i0osS7kntQfQwT0q8i4Panq1lszNnVzwREmm3m5AE7H8xg0f6c8vuLDKBM2bTrokADitviiqOGCQIC2+M0t/p/BgYsz61qG0um/mS6f417xDtL0XKyMfa5nC7gE5N/vb9o2PbeUv07VYXQxHzbwLobRfC4bNhN3a8Y2fn95cgDJAnJS30OE9KLtNVv8Diijemn2yTGJ05/fLk2n7W3XnEBuuPYtRDY/dRjehsW0+OfjJO1LbImA5eoIiRlq2cuyJ7OXiZkqZz75WdEGLa6+48jhBmgRMNxwApCwZLMZb8mNnyA4S8KQSRHnqUJyW3UWLwmYQx1slf8IZeur/Nv9qj4kPNDRGW7ULYnTvT9jObxrVJlsEFgdi8FL0wsRqfxfwdY5vqCQGD87lZI4TipeHcDTl8yOLYTu93vPehs58V59fVqt34GUhGRKRLKAgIIQxCyiiQsg8SJ4QKk0VKBdmYnL2f8+7ksBEp2X/xyHb7AOu4CNP9xUzTR3QiF7AMLQgWyZ9kECJWCEQncutQUNRDwbnLwjvKdftyU8jFKDLMtqmeEPVYsV4Fx0iGTkAp52WyHs7CNF6+SSKfF6twVGe9Z7JJKCSXRGyH8TVIVIQIiBz4bhOHJXI4ta8KhXsA9KBwD4uZLDu7bzaQiO3dT7xQEbf8WyXqIbFKMtWv7lBFjB792GbPAzNobHPuiVmExBI7foxt+naTnrdeeRIdT4K2AoUxmJNn43lS0onVuTk9jyVGNMR6WhLxviXsqYvdv2t/XWb3d5EgDj8OG09KrtDtMfU4v8gT+8UeCzf0N4dsOKK/pJmp3SgyzJ4Yxo0fX3PybGw4Jxb79tg8EsZdMY4Wq4lef3KSto/iiTAmzzqFijrnTej8+6K8rvqfdFZiUH9y8YSBg21Wtju7nBI8FrnAiRxBpOhJoRsMAiCRknUoIZP0XYgT/zVovVLFft/Y5/r+ehECJbRj2N3o/VAmchieG8eOnUz17UJJcBUh3f6x9unDSRZeHcNT1ROibrfyhOifGkNhnEu6JgYmXBDoQHpI5j3VPWPm504ODiFk7b2wFlCp5FOJGBGT+0mzKun+LhO5BRMymG2uXef6Ez0o3EOkh8RzHaKImMnKtPw3JmQTW1vFPFE6h2+MAoxZiJpY4oV/Ym2Ldf07h7b0xCYCc4PXp7uSZu32t39unTgdL5HWbt90IDSbKGmWIA4/DgtPCl080ojBYxAbIlEmX63VtCw4JmQT8wPcmDxrNZHrRYT5o8uZS+ddNYsIvcfAWoxFbeMWS5oZc0EI1Rvi9JkyV2k1Js92Z9Js7DHVv2PbnNAnz3bFrzvltbAXIc6emmxJns0WO4gsgRJn00IPESnmC0M8V2u2uGKtLmrZYlu8ycvKm6BfRWNORYgkz4pw5O/Y8VURI8MUKtJQ2q1rj6ieG2Hj6XD2pERFDLNuh6QVYzcTfb+UY8d6ldTk2ci5d/tkpgowu+PGC/NFzsfO06K92fHyVVKh+5Jm9ds6+10kgUIYkOUUi7lRuAegcE9W0m0CpRuTZqNj6ouzmZfFMkNxN/tk19ik2WirZNjPqm+8drvia9Fj2vXV56+YBZhWHbcbk2a1HoYKtFbol4pb0Ynibc6JLfZtna4wmw3CnSCI7qSHeFJ6FunypCT/y64zybNOv8hVT4SFJ0SLOFiLEDV51v5eQBGPgJAsuqvJs04eg07co8iUNKsOH6f6bSQUpk+a1Y+tFJxLNXk2lffUXnh2JnnWWlhqe6RgG6xXBRnGjtM9SwVM9nhFiW6HPClpgUQKYaJzlWed8imYvSeEMUDEJrnqegv1X2bp6FHCSdZeGoCBMxfCwkkIxHMe8kg+ipWAUsSXvYdJTfC0tl0pONfdSbOx/ezFpfN73hkPT9dNxopIyt7JnkI9RCxMlsFS0BmpVKvtSfRokUIXji4iIjRsGpX/bD0hkbwTmx/eikAyJ54axre9l47qgXG6M3E8kRJvfKevjLOIUZJnM5E0q7fPyQPmhAzEXRKZyvLheCKk+/NRCCIlZDnFxFkSKUCGc1IWLlyo1JDQPQYNGpRJk7qV7L4wJp+v4nzn4UjyrKM3Ilqt1XoEJ6HA4wgRZ09G/LsmO39lokmzVm1qGCwVT0oqpPp1d7poZq+XgyCI3CXjnpShQ4fi9ddf1567XBk3qdvI7SWLDktCbcIdUexW7ijjxhMK9l6aSOJp5H5ANr2dDNPlndj1Nt+fyIh1qCgyeCeSZuORWjJzanSlEMlcKIkgugTypKSFjCsCl8uF6urqTJuREbJZoDiHFTrjZXEKacTLy4j3ujgJiURKsFscmccp0hY3HOMkoJIyST+6xc3+0kO2F0ojiJyDREpayPgS5G3btqGmpgZHHHEEpkyZgh07dmTapMODLpjodIPD2ROSytJn5xv7iRSLjbG4X4l4IsWpf6o5Hc7nHo+uEDeEM7SyhyBSI6OelDFjxmD58uU45phjsGvXLixatAinnHIKPvnkExQWFpr2b29vR3t7u/a8ubm5O83NKbrWSxNn7C6cDOOKiJTdFU5hrHjehnhemNRESteKDPrVlizZ7BElMogIA3IK1yO6dw+ADIuUCRMmaH+PGDECY8aMQb9+/fCnP/0JV155pWn/xYsXY9GiRd1pIpEUuXvRJm8DQRDpgJYgp4eMh3v0FBcX4+ijj8YXX3xh2T5v3jw0NTVpj507d3azhQRBEARBdBcZT5zV09LSgi+//BKXXHKJZbvX64XX6+1mqwiCIAgiQShxNi1k1JNy3XXXYe3atfj666/x3nvv4Sc/+QkkScJFF12USbMIgiAIIjVkOfVHAvTv399Ud4wxhhkzZgAA2traMGPGDJSVlaGgoACTJk3C7t27DWPs2LEDEydORF5eHiorK3H99dcjFAql7SVJhox6Ur799ltcdNFF2Lt3LyoqKnDyySdjw4YNqKioyKRZBEEQBJFTbNy4EeFwWHv+ySef4Mwzz8TPfvYzAMDs2bPx8ssv47nnnkNRURFmzpyJCy64AO+++y4AIBwOY+LEiaiursZ7772HXbt24dJLL4Xb7cYdd9yRkXMCACY6V0EqK2lubkZRUREAV1IZ9pleHuhkc6q2xX09Ur3DsZMTzrF0fGowSODcY9suy0EIJK/8Je6DXeKvEAKyOOjQm0PifnvbRBDC4b5CQoThWGnX5p5C6UCIMIQIOu7TlatYcvm72JXfYyLdCABhNDU1IRAIdMkR1Hlp31MlCOQl/51pPihQevH+pG2dNWsWVq5ciW3btqG5uRkVFRVYsWIFfvrTnwIA/vWvf2Hw4MFYv349xo4di1deeQXnnHMOvvvuO1RVVQEAHnnkEcydOxd79uyBx2N/3e1KsipxliAIgiB6BLJI/QFF9Ogf+jIcdnR0dOCpp57CFVdcAcYYNm3ahGAwiHHjxmn7DBo0CLW1tVi/fj0AYP369Rg+fLgmUABg/PjxaG5uxqeffprmF6fzkEghCIIgiHSTppyUvn37oqioSHssXrw47qFfeuklNDY24rLLLgMA1NfXw+PxoLi42LBfVVUV6uvrtX30AkVtV9syRVat7iEIgiAIIsrOnTsN4Z7OrHBdunQpJkyYgJqamq40rVsgkUIQBEEQ6UaWATmFPK5IuCcQCCSUk/LNN9/g9ddfxwsvvKBtq66uRkdHBxobGw3elN27d2v3zquursYHH3xgGEtd/ZPJ++tRuIcgCIIg0k2aclISZdmyZaisrMTEiRO1baNGjYLb7caaNWu0bZ9//jl27NiBuro6AEBdXR22bNmChoYGbZ/Vq1cjEAhgyJAhSb4IqUOeFIIgCILoAciyjGXLlmHq1KlwuaLTe1FREa688krMmTMHpaWlCAQCuPrqq1FXV4exY8cCAM466ywMGTIEl1xyCZYsWYL6+nrcdNNNmDFjRkaLqJJIIQiCIIh0I2RApBDuSaI6yOuvv44dO3bgiiuuMLXdc8894Jxj0qRJaG9vx/jx4/G73/1Oa5ckCStXrsT06dNRV1eH/Px8TJ06Fbfcckvy55AGqE5KBqE6KYlDdVKoTkpXQHVSDhe6sU7KYz4E/CnUSTkkUDqtrUttzQUoJ4UgCIIgiKyEwj0EQRAEkW5kkeINBskLB5BIIQiCIIj0QyIlLVC4hyAIgiCIrIQ8KQRBEASRZoSsPFLpT5BIIQiCIIj0Q+GetEAihSAIgiDSjYwURUq6DMltKCeFIAiCIIishDwpBEEQBJFuyJOSFkikEARBEES6EXAqIN25/gSFewiCIAiCyE7Ik0IQBEEQaUbIDEJO/t49tARZgUQKQRAEQaQbyklJCxTuIQiCIAgiKyFPCkEQBEGkG8GAFMI9lDirQCKFIAiCINIM5aSkBwr3EARBEASRlZAnhSAIgiDSjZxiuIc8KQBIpBAEQRBE+hFMeSTdP32m5DIkUgiCIAgizVBOSnqgnBSCIAiCILIS8qQQBEEQRLqReYo5KRTvAUikEARBEET6ocTZtEDhHqILyN1fALlrOUEQRM+DPCk9FAEBhhRUfEoHFwDrmmOLeDKCsRRvjy4DTEq2s2MrA4u7h9MYQgiwLnpdkanPSg8go981ImsRgkGksLpH0C8mACRSDl8EUpiXMvntkR0nawaemkaBsH1ZGGOA4LD3w4o4QiJZ8RMdP5U3ztk2mmS7AkWY0mxzWEI5KWmBwj09ljhfjpR+kcf78sRrj3ds53Znb0KKk23cdX/xvjJh25b4L3m8HZwFihCqiEmcznhoaLIlCKK7IU9KzuIcGojfLgEIxWm3n3AdiRMuYXBBIGjfziQIYW+b4i2xFhOMMTAhQSRpu924ne4vwmDM7mvFHENhjLGI0HAWIvaCQsBZRMkQgtv0V49LQoQg0oGQkWKdFPouAuRJyVrix7id3zoWr912IlX7ux36SmC2QoSBw+14fIl7HI/Nmf2xleM7286ZB3YTPQOP+9rYT9TxLxpCOIsjZxEk4gSiRRxvjL0nRQgBIeQ44Z6uuyiSF4Y47FDvgpzsI5VqtT2IHi1SROS/nogiFJzevnjeDCcR4gJ38gZAchhfwMV9EaFgYxn3ONouMa9tG8AcbAM4c0HibthPuAxOngpncdiZidxJhMjO7fEy5SJCw2EH2xZFnMi2+4hOZOk5vTad+a5l83cxm20jiMOZHi1SejbcOXOcceVh1cRcjp4QBsnBWyEi7fYfHc494NxeBHHmdhBJDJzb2ycxt6NIYeDOnhiH10UdwU4IdC7nw34fWYQc+yvHdfakwHEf2UHECDjZ1mWLhgjiMEVd3ZPKg6CclC6lazP7GRjjNuEFJe/APh4qKbkbzGWR+yHA4IKTflUEjINIYR57P0bEAyRxN+Rwu0VfRWAoeSvmc2PMHbGdW07IyvjOIgaIJzUcJnJHDSEi/1jlpQjda22XdyKi4zjmnTj0tV0BpNomWwrMeGEqwhm7ZcjkoTmMkbnySLp/+kzJZciTkpOoyY92b19ku4MnRcHaW6F4WhiYrUdCgl3YhDMXGLP3ZvCILrZtZy7Dv6Z2rooYa9s5UwSYvTfFPtzDwCKvq50nJKztaU1UpFgeN7Ld3tsR2e7o1rDLW9GLFIvJMnJM62OLToV77C1KbSKmiZzoiag3GEzlkSj/+c9/cPHFF6OsrAx+vx/Dhw/HP/7xj6hNQuDmm29Gr1694Pf7MW7cOGzbts0wxr59+zBlyhQEAgEUFxfjyiuvREtLS8qvR7L0EJGS+EUu0xfGzhR/st+Hx/wb04/Fa3dFxrcL+Ui27YypXhgrkcTAIvkknEmWCaqqyLATESyeSGFqfzvbua6/8fVjEXHHGLO0TTg8i4Za4mPnlYh6hpxEBmyOo2u3+FhERYZ1SCcqTqyOrearJEe8z3Kmv2upkMu2E4cX+/fvx0knnQS3241XXnkFW7duxW9/+1uUlJRo+yxZsgT3338/HnnkEbz//vvIz8/H+PHj0dbWpu0zZcoUfPrpp1i9ejVWrlyJt99+G9OmTcvEKQHoweEe/cUlExUhu/J4qghRlqxaFRdTJ2BnkcOYyzRnqV4UpbfVx0PS7SvFTMgCki5hljMPwqINerRwDuMW/aPixDpkExUXVjkrXGe7cpxDpv7Wf0dHt4c5r8wxeCKs9tPnkjiJiPjjKyGb2POPJzKcwkHxc23iJc3q/463b7ZWZ81m24jcI/WKs4n1veuuu9C3b18sW7ZM2zZgwADdeAL33nsvbrrpJvz4xz8GADz55JOoqqrCSy+9hMmTJ+Ozzz7DqlWrsHHjRowePRoA8MADD+BHP/oRfvOb36Cmpibp80mWHuJJOdzQv21WH+SIyLDwduhFiNXbzwwixCwU9MLFUijolhdzi6XGeg8KjxFBiqcjKsBix+fMoxNQFl4e3TZLT40+/GUZCou+lrGiwZg0a/GaM+dJX5ZDMe0xGEROZzwtFp4ebahYwRJrj31fInnI60IYUHNSUnkAaG5uNjza2825fADw17/+FaNHj8bPfvYzVFZW4rjjjsPjjz+utW/fvh319fUYN26ctq2oqAhjxozB+vXrAQDr169HcXGxJlAAYNy4ceCc4/333++KVykuJFK6mPT/MjPmVJiTIGOLdcUeXy8ymEmIGL0n3NTfKBwswjkGT4pRKMQum44VMda2RI+vDwFZiRj9c2uBxS3/tsY44cRd/RKT02FMSBYQpsJ5sRNajLCIUy/F7AmJbbcXJWYBRhl6XQGJFiId9O3bF0VFRdpj8eLFlvt99dVXePjhhzFw4EC8+uqrmD59Oq655hr84Q9/AADU19cDAKqqqgz9qqqqtLb6+npUVlYa2l0uF0pLS7V9upseG+7pubAYESIBhuqtMZMv41rCJmDl/TBWnmUmIeCCEMGY/dV2VcQoF2PO3AYRIsWIFB6z7Dg278TquSyivxpilzUrlWfDuv31tinJs7LBdifxFvu6xnhCTHkmsQm2ZiHAmCommOE9iLbr3wtT3A32iJgVQFYixckrJBuGz6RIoYmc6Kkkm/yq7w8AO3fuRCAQ0LZ7vdZ1pGRZxujRo3HHHXcAAI477jh88skneOSRRzB16tSk7cg0PcaTksjFLtMXxkS8K7H7mkVGbLvZs2Jsd/KcALErfmLDO+aKpdH8l9gCbrGVaWNFhtnTEk+0OIkc86odZX819GX0MKnLmJ2JrNZJIGlW6ynCBnucPSlW4R/Zud0gMpw9KdbhH6fnqRGbo5Kr5LLtROZJV52UQCBgeNiJlF69emHIkCGGbYMHD8aOHTsAANXV1QCA3bt3G/bZvXu31lZdXY2GhgZDeygUwr59+7R9upseI1L0WF1cuvOC07XJd7GiI3ayNa+4ce5vDJHEihCjKLJe7aMgwLn5y6P3nphFCTeKmFgBpffqgJtW9BhtNwso5Xhq7RGLj7rQh3+cq9Cak2adwi2A8b5Hzqt1Ekmate7T2aRZ/XPn1UB6Ops021myefJPl23ZfI5Ez+Skk07C559/btj273//G/369QOgJNFWV1djzZo1WntzczPef/991NXVAQDq6urQ2NiITZs2afu88cYbkGUZY8aM6YazMEPhnpzDqhCXfoVPrMiIrgCyEiEw5GnESZS1ameSNodalcLn3INwuC3Sbu7PmRthEY4IFisBpqwAskqE1eeVcAsBZTieVfiEMd38bF1bhDEpMuE4TTp2tVWUsIssW91MUURvFuhY9yT2b3WTDOgEop3t9iJEDQnRZJpO1BVCXVvIkcgJurmY2+zZs3HiiSfijjvuwIUXXogPPvgAjz32GB577DEAyvV01qxZuO222zBw4EAMGDAA8+fPR01NDc4//3wAiufl7LPPxi9/+Us88sgjCAaDmDlzJiZPnpyRlT0AiZRuIX0XrNi8ichWxiPznN0dbtVtViKDRaq7hmyWHEfzTqxL1euEgoWQkJgbQZiTZvV9wmizObayAiiMsGWZfb2IsbIt1hNjageP866IyH52e0UmeZskV1kOgXM37O7IHH2rbK5GcSvP6v9NrF2tPNuV+SiH8yR9OJ87oZCunJTOcvzxx+PFF1/EvHnzcMstt2DAgAG49957MWXKFG2fG264Aa2trZg2bRoaGxtx8sknY9WqVfD5fNo+Tz/9NGbOnIkzzjgDnHNMmjQJ999/f9LnkSpMpFJqMsM0NzejqKgIagVU1S3tdIHojl848cpjJxoOivbl4NxnbhcyhGgD4LJc9itECBBBcF5g2R6WD0KIdrh4keWqmFC4CQIhSLzYUgSFw61gTEKex6y0hZBxMLgLEvfB6yq2GLsdHeH9cPE8uKQ8i/ZDCMmt8LpKIFmEk4LhQ5BFBzxSoaUIOtSxBwJhcOYz2S6EgCzsvTwAwJgbsgjFJA+rA8gRnWIz0TM3JO5DKNwMWAoVJWdHyNZLCrVl0rbje6CIkNh8F9V2D4QIWdz6AFA+Sx7Icgfi/WRLptx7Z76L2UqqtpMXJZsRAMJoamoyJKOmE3Ve2nFVLQLe5D0pze0yah/Z0aW25gJZk5Ny5513au6oZMmFO7Emk6+i9HG6J41SD8W+3QXAZdvOmQfKDf/syuR7wOCx8dIALp4HNy+w6cshMR9cFuJKObYbjFmLKwDg3AvO3LYVaiXmNi1VNo0PqzAXItusq8+qCBF2vq+Ng8YXIhhZXWTTX8jxx3b8DWF/V2UhRBzb1ZsRdo0nJZfvQJ6q7bl63kR6oRsMpoesCPds3LgRjz76KEaMGJFpU1IiXvJlKiiTuM09ZxgDY9YiQG2XJHslzpgLLod2JSHWOqMcANyugOOdh73uYkfbrDws2rGZBJ+7zME2Fzzc/mPMuSeSIGs9cSgeFPtJRRYdtm3K++E0ycuQZad7XshxVg3Fm+ycbwpo6f0xtDudW1cngBNED0ekmJNCWhdAFnhSWlpaMGXKFDz++OOGewwQBEEQRK6SiRsM9kQyLlJmzJiBiRMnGkr12tHe3m4qEUwQBEEQRM8ko+GeZ555Bh9++CE2btzYqf0XL16MRYsWdbFVBEEQBJEaSkpZKjcYTKMxOUzGPCk7d+7Etddei6efftqw/MmJefPmoampSXvs3Lmzi60kCIIgiCRINdRD4R4AGfSkbNq0CQ0NDfjBD36gbQuHw3j77bfx4IMPor29HZJkXG3i9XptSwITBEEQBNGzyJhIOeOMM7BlyxbDtssvvxyDBg3C3LlzTQKFIAiCIHIFIXik2ney/SneA2RQpBQWFmLYsGGGbfn5+SgrKzNtJwiCIIicItWQDYV7AGTB6h6CIAiCIAgrsqKYm8pbb72VaRMIgiAIImVSrRpLFWcVskqkEARBEERPoLtvMNhToXAPQRAEQRBZCXlSCIIgCCLN0Oqe9EAihSAIgiDSDIV70gOJFIIgCIJIM5Q4mx4oJ4UgCIIgiKyEPCkEQRAEkWbIk5IekhIpO3bswDfffIODBw+ioqICQ4cOpXvqEARBEEQEIVLMSSGRAiABkfL111/j4YcfxjPPPINvv/3WkHns8XhwyimnYNq0aZg0aRI4pygSQRAEQRCp0Sk1cc011+DYY4/F9u3bcdttt2Hr1q1oampCR0cH6uvr8fe//x0nn3wybr75ZowYMQIbN27sarsJgiAIImtRlyCn8iA66UnJz8/HV199hbKyMlNbZWUlTj/9dJx++ulYsGABVq1ahZ07d+L4449Pu7EEQRAEkQvQEuT00CmRsnjx4k4PePbZZydtDEEQBEEQhAqt7iEIgiCINEOre9JDQkGvzz77DB999JH2vKWlBRdffDH69euHSZMmYffu3Wk3kCAIgiByDVWkpPIgEhQps2fPxttvv609v/XWW/HBBx/g+uuvx3fffYdZs2al2z6CIAiCyDmEHM1LSe6R6TPIDhISKVu3bsXYsWO158899xzuuecezJw5E8uXL8eaNWvSbiBBEARBEIcnncpJufzyywEAu3fvxm9+8xsUFBSgpaUFO3bswLPPPos///nPEEJg3759uOKKKwAATzzxRNdZTRAEQRBZDOWkpIdOiZRly5YBAN577z389Kc/xc9//nP8/ve/xzfffIMnn3wSAFBfX4+VK1eSOCEIgiAOe1KtdUJ1UhQSWt1z0UUX4corr8QTTzyBdevW4cEHH9Ta3nnnHYwcOTLd9hEEQRAEcZiSkEhZuHAh+vbti82bN+Pyyy/H5MmTtbbvvvsOc+bMSbuBBEEQBJFryIJBTiFkk0rfnkTCdVKuvPJKy+3XXnttysYQBEEQRI8gxYqzoIqzADq5ukd/M0GCIAiCILKLhQsXgjFmeAwaNEhrb2trw4wZM1BWVoaCggLL2mY7duzAxIkTkZeXh8rKSlx//fUIhULdfSoGOiVShg4dimeeeQYdHR2O+23btg3Tp0/HnXfemRbjCIIgCCIXyUQxt6FDh2LXrl3aY926dVrb7Nmz8be//Q3PPfcc1q5di++++w4XXHCB1h4OhzFx4kR0dHTgvffewx/+8AcsX74cN998c1pej2TpVLjngQcewNy5c/GrX/0KZ555JkaPHo2amhr4fD7s378fW7duxbp16/Dpp59i5syZmD59elfbTRAEQRBZSyaWILtcLlRXV5u2NzU1YenSpVixYgVOP/10AMqq3cGDB2PDhg0YO3YsXnvtNWzduhWvv/46qqqqMHLkSNx6662YO3cuFi5cCI/Hk/S5pEKnRMoZZ5yBf/zjH1i3bh2effZZPP300/jmm29w6NAhlJeX47jjjsOll16KKVOmoKSkpKttJgiCIIjDgubmZsNzr9cLr9drue+2bds0B0JdXR0WL16M2tpabNq0CcFgEOPGjdP2HTRoEGpra7F+/XqMHTsW69evx/Dhw1FVVaXtM378eEyfPh2ffvopjjvuuK45wTgklDh78skn4+STT+4qWwiCIAiiR5AuT0rfvn0N2xcsWICFCxea9h8zZgyWL1+OY445Brt27cKiRYtwyimn4JNPPkF9fT08Hg+Ki4sNfaqqqlBfXw9AqXWmFyhqu9qWKRJe3fPkk0/i5z//uUnJdXR04JlnnsGll16aNuMIgiAIIheRBYecQkE2te/OnTsRCAS07XZelAkTJmh/jxgxAmPGjEG/fv3wpz/9CX6/P2k7Mk3Cr+Dll1+OpqYm0/YDBw5o5fNzF2fVy5jHdh8GF1xSsW1fznxwSfahsDx3DfI9vW3bCz194LUdn6HG9wN4ecCy1cV86OseBQnWMcV8VoIjXCfA7twKpWpUuI+2ta2I90IBL7dtdzEfuI0eFkJAiLDtCjIhBELhNtv2kNyGQ8E9tu1h+SDCcqutbWH5EGRhnRCu2NYOIcLW7RAQCEHAbvWb86o4Efkv6XYhO6y8S31FXrzjEwRhjxCp3Fww6oUJBAKGh51IiaW4uBhHH300vvjiC1RXV6OjowONjY2GfXbv3q3lsFRXV5tW+6jPrfJcuouERYoQAoyZJ7Nvv/0WRUVFaTEqWVjkv6T7MwZ7ocLBGIfdS8a5B4y5wGwmY859kLjXdnyvqwReV6ntsd28EB6pwLLVw/Ph5QXIk6z75/ESeLgffm79/hTyCvh5Ibws37I9XypDPi+zfW39vBh+Zi2QAIAzFxiTbFpFzL+xhKFMl9a3BA3LbRAiCAFrISGLDqXdYjJXtoUghN0SOxF52N2OVNbtlzzxhIBVu4j7umV3jYVUvqcEQcSnpaUFX375JXr16oVRo0bB7XYbbgL8+eefY8eOHairqwMA1NXVYcuWLWhoaND2Wb16NQKBAIYMGdLt9qt0Otxz3HHHaWuvzzjjDLhc0a7hcBjbt2/H2Wef3SVGdhYBkfLFjzFmOaEpAkVtt+gHd6TdZTnpceaJtLshYn65M0gRAaN4ZASM/V3cD8YYXDzP0mYvL4z8ay0UfJHtXlaAFuwxtedFxIufFaJdtJjHZwVgjMHN8tER0y7BA4m5FPEKZppQWUTUcSYhbDWfMhGZZ+09Kcq/MmAhdNTXUhZBcOYy9Y2+FzKA2P6y9q+1+JZj/jUdPeZfu/bEScSDYffDoatIl3fF6vNCED2F7l7dc9111+Hcc89Fv3798N1332HBggWQJAkXXXQRioqKcOWVV2LOnDkoLS1FIBDA1Vdfjbq6OowdOxYAcNZZZ2HIkCG45JJLsGTJEtTX1+Omm27CjBkzOu296Qo6LVLOP/98AMDmzZsxfvx4FBREf9V7PB70798fkyZNSruBiZCaQIkX6lFFimQpQhh3RdpdFnMT1/pz5kY4RqS4eDRe6JLyEAw3x7TnRfpK4HBBjhExXl5g+DcWPy8GAPikQlg5HHxQRI6fBdCIXcZjMy94RBx4eT46wkaR4uWK94UxBhd8COKQoV0VKczGA9XpQoHCLBSEEJAj74UsBwFujLvKIqjbN2zy5hjfR7OIiYZ5hI0QSEGEdHmBRJr8CSKTdLdI+fbbb3HRRRdh7969qKiowMknn4wNGzagoqICAHDPPfeAc45Jkyahvb0d48ePx+9+9zutvyRJWLlyJaZPn466ujrk5+dj6tSpuOWWW5I+h3TQaZGyYMECAED//v3x85//HD6fr8uMygTxf4kq7dZzC496DLgb4Zj5VP8LnzHzS+6S8pVJiymCxCRSpDwokw6DxH2QZaNQ8EU8IZy54GI+hESbwW5PJIzjgTmc40W+JkLyeJFJxHiYKnwEvKwAB2CMWXp4gfZr2M18CIoYkcKi4oRBsgjLRF/QWCGgTOQRT4qFt0MvQqzySvTbrMJB+m0CMpitp0W1M9a2aLgn1ouXeQ8BAwkVgjh8eOaZZxzbfT4fHnroITz00EO2+/Tr1w9///vf021aSiS8umfq1KkAlNU8DQ0NkGXjjFxbW5sey1IgNTeyZUwC6gSlhHuME4BeeCi3145td0Od5Dj3mISAi+dpk6+b58X4IgC3VKCN6eJ+BHUihYHDxaIeBC8vRCgcFSlKqCYacnEzv0FI+HUhIi/yTa+dl+drE7BPCiDGiQMvL9QmZw/z4WDMyxcVKQIM3CgMdCLEmtg2o1AwipSgWcTIHYi+F1Y5K7ptIgwwt8E2o7CRkVgKV3cKBCsBlb7jpyOMqofyUYjDAbrBYHpIWKRs27YNV1xxBd577z3DdnWCCIetExi7mvRd+NRxhMU2dTuHfoJTPCXKRMEYi3gMQrr26Kog5de6UcS4paiHwxWTHMvAwbVVOQxuyY9DOqHg4fnaxCwg4OEFaA1H8058PGCYvL2s0ChSWECbhBjj8LICtIkDWruXF2ivrQu+iNCIClMf04X9eJ4pfSP6vjBwJhmERTwREtuu2BlF8ZSor6UiKvSJyzI6tDHUFUTaa2XIVwHAYsNJVrbpsdo/kc+g1bnZ99e3Z95Lkz4oL4XoqWSi4mxPJGGRctlll8HlcmHlypXo1atXtybsdRexybP6kIUqRPRhH8VTEhU3SnJsKKbduL+a8MkgaUm1gCJ4OHNrk7mk87IAynJePR5eqE2+mrdDpwO8PAC1u4iEbFoQzd7O40XRyU8I+FmhQaR4dCt+GGPwsDwtudYFryGUJcFtEDGxeSiMSYa52bxiJ2biFrHPjcmzQgQNfWS5A1xyaX0VT4oefd6J8dhCyIoQ0ARfrNiOtTVRUdN5kpm0uyt5lgQFQRBO7Ny5E4wx9OnTBwDwwQcfYMWKFRgyZAimTZuW8HgJi5TNmzdj06ZNhrsr5j7OCZFGkWJOnjXmmbCY5Fke018YkmeVfBMjLp6HjrBSi8bN8wwTEGOSQcR4eQH0c5OHGT0xfqkYUS8Og9+QPMvgjSTNRp7CxwIAvlPsYD4tXwVQJkIvL0B7JHnWw805Lm7mQ4c4GLE15nWLeZ2FRTKsM9H9hZC1pFmtNU6Oij551nrZsU7EmGyLTZ6NN1k71TehpFmC6Okcrp6UX/ziF5g2bRouueQS1NfX48wzz8TQoUPx9NNPo76+PuEbFiZcJ2XIkCH4/vvvE+2W1Zh/gTo/N84x3OQx4DzqOeExXhRFxES3uXie4depgDAsNXZJeSb79N4Un1RksE/NO1GOxOGBUQTpk2e9LB/ckNjKtOXIarvBcqYkymrtuqRZ1XY3orZZregxJ6caiS45NudV6IuXxQoUZVsckWJIlLVKpNULEysBpbfNQsRoSb4kEgjicEfNSUnlkYt88sknOOGEEwAAf/rTnzBs2DC89957ePrpp7F8+fKEx0tYpNx111244YYb8NZbb2Hv3r1obm42PLKF9OaoGMfSF32zWq2jvKxqu5o0q2vl0fCOi+cbbGVgBu+K21TATcDFfZF9OVwwr7LyROqmeHRJs1HbOTxMGd/PAqZf9V7kaeLCEyNCAAYfj3pe9Emzqu1unYCKPbaaPAskkzRr3G69midatC2aNKtHL0wsPCmRJcfmpFntCJ2yLVlPRmriRi+g0k86a6MQBNFzCQaDWl2V119/Heeddx4A5YaGu3btcupqScLhHvUuimeccYZhe2YTZ7viwqcmZFqNHU2eNXtKIr2ZC0IEI+0xIgdq5VrZkDSr4lJrj8Tkq6i9XZIfCCkiItbLIqCEZFrDDaakWSASsmGF6BAHlSqxMaenJM/mo00cgE+XNKvZpkue9TJzXRYP92tzuXlC0ifPOhVIs18+qybPKmPE7qeUqWdwR0RMrCcmrPPUJCNCOlthNtV2u14900NDybNET0SI1EI2XR4V7iKGDh2KRx55BBMnTsTq1atx6623AgC+++47lJWVJTxewiLlzTffTPggXU+iKyvi91eTZ83eAACRlTBKjoPVSyigVI4NmpJmVThzQQjZUuSoybMSs65Foy459uqSZnWWacmzPl3SbPS8lDDNAXk38nVJs5rlQsDPAmgTB+C2KJOvJM/mI4wOQ76Kipo8a4eaPBvvfjf29/JRkmdjk2ZVZDkIxmNXERn2sOynHFl28KJEbYtfgTZ5UpmsuzrXhYQEQXSewzUn5a677sJPfvIT/O///i+mTp2KY489FgDw17/+VQsDJULCIuW//uu/Ej5I15NqpVk7b4lVyALadqX+mpUIUZNnY5Nmo2Mz5obE7fMzXDwPEvdZrtpgjIMztylpVkVNntUnzept80XCNF6YPSGMKWGgFrbPkK+iWR5Jno2tmqvHzXwIwbqdRV5vpwnVORQkWybNqqPLIggm7F9XxYPiNNnKFkmzWu84tql5KZQ0SxCHOyLFvJJcFSmnnXYavv/+ezQ3N6OkJHpT3WnTpiE/3/r+cE4kLFLefvttx/ZTTz01YSMyif2yTadwj+qK47b9OXdDCGsvihL2cMPFfTb1MQRcPB8S99qO7+J+U9KsNjrj8LACuGF9rx8P8uBlhbZeojxeBI+w/jCpnpiQ6LC0XU2elZndTfvUcJf9yh5nASM7CCQRESn2nhzFS+Jw7DjtSptTe6ZFQvZWmqV8FILo+Zx++ul44YUXDAIFAEpLS3H++efjjTfeSGi8hEXKaaedZtqmn0gzVczNis7Fup1CRXZeFkTqktiJEEARMNFKs+b+Hrhjkmb1x3VL+ZC43a0HBNwsz1QzRU++VGErcBjjKGRltrU1PMiL3AfIynbFExMSHZa2MzC4mBftOGhrW/w51HkH+1BOJKFWViyxHsdJhLCIp8XpMxxv2XQmBUJ2ihOCOBw5XMM9b731Fjo6zD8k29ra8M477yQ8XsIiZf/+/YbnwWAQH330EebPn4/bb789YQO6ks7F0J0+CNyhSJawzTfReusqzZqOyjhcFkmzKhLPs8z5iPSGV7K+47Fqm58X29ouhEAeL7E9dcaYklRrs4OL+cAdBJoLHudfzXF/7McTKfahJgCQ5XbbMZT6KE75MPFEdqoihYQEQRwOHG4i5Z///Kf299atW1FfX689D4fDWLVqFXr37p3wuAmLlKKiItO2M888Ex6PB3PmzMGmTZsSNiKz2HtSGLMP58TWO7Ea16mdgRuqtcZiL1AUPCzfQUAx23wVQAnZ+FihrZCQhWy4M3Oi9gkmO87F8Yu4Je9JUUJFXenNy97EVoIgiEwxcuRIJcLAGE4//XRTu9/vxwMPPJDwuAmLFDuqqqrw+eefp2u4bsI+nBNtd2p1EhLMsUy53dJlPU73c3Ext60IAQDJwYsDweByClUx5xLr8e4zE4rj6bBe/ts5FIGTaKVagiCI7uVwu8Hg9u3bIYTAEUccgQ8++AAVFRVam8fjQWVlJSTJ+ce3FQmLFL1LB1B+He7atQt33nknRo4cmbAB2Y1zKMj5XinOHzCJe+Lcb8VZCEgw11/RdXXsy+IIqDBkx1QdJVpjb18Q7bZjA4BsVUgtQjxvg/3y4OgeqbUTBEGkzuEW7unXrx8AQJbT+yMyYZGiunRiJ5OxY8fiiSeeSJth3UG8G7KlIkIUHEJJ4I6ekLheHJul0dHeziLFCaGonCRHT4eQcOgZN2RCIiQboZU9BHH4sG3bNrz55ptoaGgwiZZE792TsEjZvn274TnnHBUVFfD57FeaHL7EuzD30As3Y6QVCII4rDncwj0qjz/+OKZPn47y8nJUV1cbi40y1vUiRXXpEARBEARhjQCL3MQj+f65yG233Ybbb78dc+fOTct4Cd9gEADWrl2Lc889F0cddRSOOuoonHfeeUmtfyYIgiAIouewf/9+/OxnP0vbeAmLlKeeegrjxo1DXl4errnmGlxzzTXw+/0444wzsGLFioTGevjhhzFixAgEAgEEAgHU1dXhlVdeSdQkgiAIgsgq1MTZVB65yM9+9jO89tpraRsv4XDP7bffjiVLlmD27NnatmuuuQZ33303br31VvziF7/o9Fh9+vTBnXfeiYEDB0IIgT/84Q/48Y9/jI8++ghDhw5N1DSCIAiCyAoO15yUo446CvPnz8eGDRswfPhwuN3GchfXXHNNQuMxkWCFKa/Xi08//RRHHXWUYfsXX3yBYcOGoa2tLSEDYiktLcX//u//4sorr4y7b3Nzc6S4nMty9UC8irNxV8gwj0OrBBe3vjdOpLdjwTOvVASPQ8XZeBSycvsVEwJww2vblwsOr0N7BzoQ5PYF0+KxX3yHsEPBtUOhvbZtzjfwA8JyB8Ki1aF/J24gmCHinVtPplMrygiiy1GKPTY1NSEQcKranTzqvPSXUT9Gvit+PSw7WkNB/HjTX7rU1q5gwIABtm2MMXz11VcJjZewJ6Vv375Ys2aNSaS8/vrr6Nu3b6LDaYTDYTz33HNobW1FXV2d5T7t7e1ob4/W4Ghubk76eARBEARBpJfYFcCpkrBI+fWvf41rrrkGmzdvxoknnggAePfdd7F8+XLcd999CRuwZcsW1NXVoa2tDQUFBXjxxRcxZMgQy30XL16MRYsWJXwMgiAIguhOZKQY7snR1T3pJmGRMn36dFRXV+O3v/0t/vSnPwEABg8ejGeffRY//vGPEzbgmGOOwebNm9HU1ITnn38eU6dOxdq1ay2Fyrx58zBnzhzteXNzc0reG4IgCILoCg63irMqV1xxhWN7okVfk7p3z09+8hP85Cc/SaarCY/Ho4WORo0ahY0bN+K+++7Do48+atrX6/XC67XPpSAIgiAIInPs37/f8DwYDOKTTz5BY2Oj5Y0H45HSDQZbWlpMJW9TTfCRZdmQd0IQBEEQuYYMllLIJlfDPS+++KJpmyzLmD59Oo488siEx0uqLP7MmTPx1ltvGVbyqDfLC4c7f4fbefPmYcKECaitrcWBAwewYsUKvPXWW3j11VcTNYsgCIIgsodUa53kaLjHCs455syZg9NOOw033HBDQn0TFikXX3wxhBB44oknUFVVFfcmfU40NDTg0ksvxa5du1BUVIQRI0bg1VdfxZlnnpn0mARBEARBZBdffvklQqFQwv0SFikff/wxNm3ahGOOOSbhg8WydOnSlMcgCIIgiGzjcC3mpl/cAihRll27duHll1/G1KlTEx4vYZFy/PHHY+fOnWkRKQRBEATREzlcV/d89NFHhuecc1RUVOC3v/1t3JU/ViQsUn7/+9/jqquuwn/+8x8MGzbMVPJ2xIgRCRtBEARBEETu8+abb6Z1vIRvMLhnzx58+eWXuPzyy3H88cdj5MiROO6447R/CYIgCOJwR07DIxXuvPNOMMYwa9YsbVtbWxtmzJiBsrIyFBQUYNKkSdi9e7eh344dOzBx4kTk5eWhsrIS119/fVK5JHv27MG6deuwbt067NmzJ+nzSNiTcsUVV+C4447DH//4x5QTZwmCIAiiJ5LJcM/GjRvx6KOPmiIbs2fPxssvv4znnnsORUVFmDlzJi644AK8++67AJTb00ycOBHV1dV47733sGvXLlx66aVwu9244447OnXs1tZWXH311XjyySe1EiWSJOHSSy/FAw88gLw8p3vemUnYk/LNN9/grrvuwpgxY9C/f3/069fP8CAIgiCIwx1ZRJNnk3skd9yWlhZMmTIFjz/+OEpKSrTtTU1NWLp0Ke6++26cfvrpGDVqFJYtW4b33nsPGzZsAAC89tpr2Lp1K5566imMHDkSEyZMwK233oqHHnoIHR0dnTr+nDlzsHbtWvztb39DY2MjGhsb8Ze//AVr167Fr3/964TPJ2GRcvrpp+Pjjz9O+EAEQRAEQSRGc3Oz4RGv2OmMGTMwceJEjBs3zrB906ZNCAaDhu2DBg1CbW0t1q9fDwBYv349hg8fjqqqKm2f8ePHo7m5GZ9++mmn7P3zn/+MpUuXYsKECQgEAggEAvjRj36Exx9/HM8//3xnT1sj4XDPueeei9mzZ2PLli0YPny4KXH2vPPOS9gIgiAIguhJCDCIFKrGqn1j70+3YMECLFy40LLPM888gw8//BAbN240tdXX18Pj8aC4uNiwvaqqCvX19do+eoGitqttneHgwYOmMQCgsrISBw8e7NQYehIWKVdddRUA4JZbbjG1JVpxliAIgiB6Iumqk7Jz507D7Wbs7l+3c+dOXHvttVi9ejV8Pl/Sx02Vuro6LFiwAE8++aRmx6FDh7Bo0SLU1dUlPF7CIiX2Xj0EQRAEQXQNasgkHps2bUJDQwN+8IMfaNvC4TDefvttPPjgg3j11VfR0dGBxsZGgzdl9+7dqK6uBgBUV1fjgw8+MIyrrv5R94nHvffei7PPPht9+vTBscceC0ApAuv1evHaa691agw9Ceek2NHY2IgHH3wwXcMRBEEQRM6iJM6m9kiEM844A1u2bMHmzZu1x+jRozFlyhTtb7fbjTVr1mh9Pv/8c+zYsUPzcNTV1WHLli1oaGjQ9lm9ejUCgQCGDBnSKTuGDx+Obdu2YfHixRg5ciRGjhyJO++8E1988QWGDh2a2EkhxbsgA8CaNWuwdOlSvPjii8jLy8PMmTNTHZIgCIIgcpp05aR0lsLCQgwbNsywLT8/H2VlZdr2K6+8EnPmzEFpaSkCgQCuvvpq1NXVYezYsQCAs846C0OGDMEll1yCJUuWoL6+HjfddBNmzJhhG2aKZfHixaiqqsIvf/lLw/YnnngCe/bswdy5cxM6r6Q8KTt37sQtt9yCAQMG4KyzzgJjDC+++GKnE2sIgiAIguhe7rnnHpxzzjmYNGkSTj31VFRXV+OFF17Q2iVJwsqVKyFJEurq6nDxxRfj0ksvtcxBtePRRx/FoEGDTNuHDh2KRx55JGGbmRCiU06lYDCIl156Cb///e/xzjvv4Oyzz8YvfvELXHTRRfj444877QpKJ83NzSgqKgLgArNQnQLOp8aYs0ZjzOPQKsHFnYrSMHAm2bZ6pSJ4pHzH4ztRyMotzxkAIAA37FUvFxxeh/YOdCDIg0nbtl98h7Cw738otNe2Tfk42r9vYbkDYdHq0D/s2D/1Oo7JE+/cejK2n9UI8b6rBJEeBIAwmpqaOpXnkQzqvPT7Ib9AnuQ0hzhzMNyB/2/rii61tSvw+Xz47LPPMGDAAMP2r776CkOGDEFbW1tC43U63NO7d28MGjQIF198MZ555hmtSMxFF12U0AEJgiAIoqcjhPJIpX8u0rdvX7z77rsmkfLuu++ipqYm4fE6LVJCoRAYY2CMQZLsPQQEQRAEQRye/PKXv8SsWbMQDAZx+umnA1ByV2+44YakKs52WqR89913WiW5a6+9FhMmTMDFF19M9+4hCIIgiBgEGORuTJzNFq6//nrs3bsXv/rVr7RS+j6fD3PnzsW8efMSHq/TibM+nw9TpkzBG2+8gS1btmDw4MG45pprEAqFcPvtt2P16tVUyI0gCIIgEL3BYCqPXIQxhrvuugt79uzBhg0b8PHHH2Pfvn24+eabkxovqdU9Rx55JG677TZ88803ePnll9He3o5zzjnHshQuQRAEQRxupHZzwdSq1WYDBQUFOP744zFs2LBOL1+2IqU6KZxzTJgwARMmTMCePXvwf//3f6kMRxAEQRAEoZFyMTeViooKzJkzJ13DEQRBEETOkmrBgRxd3JN20iZSCIIgCIJQSNcNBg930nbvHoIgCIIgiHRCnhSCIAiCSDMyUqtvnbna2NlFSiJFraifq7VShBAp2N6ZiKEAHNe6x2t36iqALnrdGVhKpnVlMJWxrh2fIAgiHaS6jDhXlyCnm6TCPUuXLsWwYcPg8/ng8/kwbNgw/P73v0+3bRnH+bZG8XSu8ywvEHJsR5zWMJxr0jjdCyXuPY3AHA8uIv/ZIcEdZ/zko4wM8aodZ/aL3clbYR120L15CIJIhoQ9KTfffDPuvvtu7RbPALB+/XrMnj0bO3bsSOhuidkOgzJh211gOeylCo9z88KQ3AFvnPnW6bIeRhBuuK33YREvkc2ELSAgQwa3EQt226PDOwsBN/OiXW619VJx5kJYdFiPzRiEkGEvNuIJnHgihVwxBEF0PZQ4mx4SFikPP/wwHn/8ccONBc877zyMGDECV199dU6JlHiTrZ/loQ3Wd2zkjKNI8qMx3GYpYmQho1DyoVW2noxlEUxpuozX1/HMmEBYBMFt7oTMwSGLsONdnJ2QhDtOGI05htqc2nI0sghAFWAkkAjicICWIKeHhP3uwWAQo0ePNm0fNWoUQqFQWozqLiTms21j4Cji5bZeFFnI6OUpgdNHqY+nGNxusgVDiWR//ALmBbeRGgwMPjjfApwJp7eWoQMdji74DnHQtk0WYYSE/e22ZQQdJ2NZhOwFCgSECDv0jxMi63IVEy/HiC4tBEEQ6SJhkXLJJZfg4YcfNm1/7LHHMGXKlLQYlS6cPSUMEs+3zXEQkFEuOd9W+khfte2UJIFjgK/cdrKtcBeil7vQUohwMFS6ClEi5dnYJpAPv+P5xQvZdKDNtn8YIbSLFlsR0yFa0BZuhvWELNAuH4jk3Fi0CgFZtNu+LgzMUcQoY8TLB+pKoeL8meq6sQmCyCUO97L46SKp1T1Lly7Fa6+9hrFjxwIA3n//fezYsQOXXnqpoers3XffnR4ruwQBt5QPgQ4E5QOWe5RLveEN5aHdwqvgZhKO9vUG8KFl316eIvTxlFhO45xx1LhLUOnKw6dWoSIIlEr5cEPC/vBByBb75KMAIRzEIbRbHl+CBNkmY0aGjA7WZvujv120oEMctBQxAgJt4WaE0YF8UWEKvwgBtMsHEGJheCRzAi1jDGG5DZLkBywEohACAiHbkI9AGEomkLOnyN6jkaqnQ0I8j0nyq8bUZGvyxhBErkNLkNNDwiLlk08+wQ9+8AMAwJdffgkAKC8vR3l5OT755BNtv+xZlmx/0XdxP8KizVKkuOCBnxWgmJWjQew0eRV6ecrhlzwoduWjMdRqaJMYQx9PCardAcujK6GiYlS68m2tLuOKSJGD1rbnIw/tIoQ21m4an4GBQwJDGMLiox5GEDILK3knMUJBQOCQaEFQHLI8LgNDuziAsOiwfI8ZY2iXDwBMguD5pn2EEEpf2QWJW3ixWORsmAwrESPLQc1Se89Dd4R87IWE7Wc/bj5KZr8zTkniBEEkBi1BTg8Ji5Q333yzK+zodhhzgXM3XMJv2V4sVYAxhmKpHA3yTkMbB0cfTzkAoI+nFM3hg5B1E1BYCPT2lMDDXSh3F2BPsMU0fi93McpcfnAwS09JiZQHt03iqhdeSJDghcfaUyOkyL8M4VhPBwRCUCb6DrTDB2NIiYGhTbRARhhhBC2XE7fLBxAWQUuPgSxkBMVBSPBaTtYyOgAIyCIEbtVfDkX+DVuIGAEhMpn3xCLJr/YJv+q/tom/OSwEctl2giByk55dFt/Bm+PiijiRuDl5lYGjmFcAAIp4menCLENGTUSk9HKXWOZX9PYWAwD6ekpMybMcDBXuACTGUeYyi6Qi7oeLSQhwvylnhYEhH4oHxi55VhIu7TzM58YQjoiUIGu3nHTaoIiqdrnV1KYmzQqEEbJY+dQhlL5h0WHxugiEwoqHRljknahJs8rfVnVglHwVpX88T0ZX/AphMf/GImL+TeIIDp/ZeKvRshkn20n4ED0RgWjIJ5kHfSsUOuVJueCCC7B8+XIEAgFccMEFjvu+8MILaTEsMexd/3bLPl1c8SBw5gZjLsMvdAEZRTqRYkWNR9neyyLvxMU4yl2Fkf2K8WGr0RNTGREoAFDtysfe8CHNE8PBUC4VRGxjKJXy8X046olRkmYV291wWf66VUM4dsmz4UhSaxAdpskjjBBCUJZNd4iD8KPIsE+7iIbG2sLNcLt8UF97AYF2uVlnaQhM54kRAghHVgUJhE0eBwYWFSkWybFKvoo+3JMoqX7t44mUFEfvRIiUvBkEkRsIpBjuyeEfJemkUyKlqKhIu4AWFRV1qUHdhcSjHgwX8yMojHkpRVzxlLiZF36Wj0Mi6lXwMBdKIiKk2l1sGruXbulxjdv4enHGUeMp0Z5XuvKxpW2P9lyGQJkUzVUplwqwL9xqCAnlRTwp6lLk2ORZyaEqqwwZgikCIGiRdNumex2C4pBBoAgItIebteft8gEUiErNYcUQyUeJEJLbDMmzjDGEZJ33hYWh/wgqIkT1oMgQiClIx/TCpTP5HWZPTmoooi8a8nEaL5X7CmRf8mwue3EIgshdOiVSli1bhltuuQXXXXcdli1b1tU2dQHmi77qSQEUwaJPnnUzL3wsKhSKeQXawge1X7C9veWaaPNwF0pdBdgXUrwdnDH01YmQKk/A8OtXFjJ66YRNpducPFuqEyllUr4pZyUPUYHlE15D8iwD1yYUJYGWG1b5qF4SAJCZjLAIa6JGTZpV6YhJno0VIe3igOnXv749LHdA8Ki3RFl+rDu+HILEdR9BFjsxG5Nno0mzKtmbPGs6fg4kzar/kqeGIFJHFsojlf5EAjkpixYtQkuLOQE0F+HMBc6ik6OL6/NCGIp5pWHyVfJSIn3B0dtTYRivt6dU85zIQhg8JW4modJdYNi/l6dY+7tUMuadMAAlOgFVyo0ixhdJmo0+NybP8pgibkwYPSFhGCf6oC6vRE2aje4fRhjGirntehEjtxhCabIIG1YFhUW74XWUhdFzI4uQsb9sTIqV5WheisiSpFn9cz2xIUXHnJkc9krksu0E0Z2INDyIBERKzpXz1uc6xEwuEjOuaNGHfhigJc2qKKGfiCcEspaPolLjKTGs7umtEyEA0EeXPCshmq8CKJ6XClfUniIpT8tXAYAA90FSwwxgyIdR8MQmz6pJs9Hz4bq/mZaPotLBjJVn1aRZFX3yrCxChkqzAjJCiIqSDmHsKxuSZwVCstEzo0+eFcIsQvTJs0qRt2BM/+5Mno0dK/Z5+kJLlku7c1gcUNIsQRDJktDqnuypfWKm8xc7AVdMJVfFs+LWxlHzUVQCvNTwXF3Zo9LLbfSclLmMQqK3p1gTMZWegOnmg1XufPBIoKacG/syxrQcFX3SrIoLksETE5uPEps8a/aktGuTSBhBU3uHOKS9tu3CXE9GrTyrFnmLRdbGYwjJRk+KmjyrnqeaNKu1656rRd6MJDLBpScfJUp6BVAi361cFiwEcbhAFWfTQ0J1Uo4++ui4F9N9+/alZFDXEc0hMIZ3FCTm136pF8V4UtzMgzxWiIPiAHzcgyLJGIKpchdpo/e2uF9PjSeaPNtbJ2hUKl35kNEAAIakWZUyqQANYUUg5FnUNfHBi4NQKsjGFmfTT2gywhAxeR9BLZwjcMhChKiVZ+1EiJI8W6UUcbPoH5bbIUluAExb2ROzBwBXRITErugR0eRZZlV/MZHk2XSt7Ik8S2vyrNV+3Zc8G0/0kCgiiMShirPpISGRsmjRoh6xukeyECku7kdQboaH+eHj5nvmFPMKHAwfQG9PuUmoubkLZe5CfB88gD4eCxHiDmhF23rFhIIAoMplTJSNRb8tVqQAgE94cJC1gTNuyEFRUZNnQ4hNPAUEkxEWIUhwGfJRVILikLZUuN2iMm+7HE2etWoPy+2AVAghZEPSrNYugnAxl40IASBkgEmQbe4m7UyWJM9medJsLJQ8SxBEtpCQSJk8eTIqKyu7ypZugTO3IWlWRRUusfkoKkW8DN+Fv0LvmFCPSm93Kb4PHkBvC5HiYhyV7gDqg02WS5aLJR8kMAgohdxiUUWKDz7L2idqXopaaTYWJhjAzKEelXYcQh4KLUWKgIww2uGCz5A0q9IhWjUviNWdkcMRYRIW1vcYUvNQYpNmVWQRgsQkrYibxQhwrpFj0y0h7MIx0XwaS8uo8ixBHLZQWfz00OmclGzORzFhc08ZBgmShZcEiC9Sylxq8Tbr4m6qOKmx8JQAQB9PMVxMQpkuaVaFR/JOirjfkDSrUsCUFT0FsL7Xj0co+TR2IkWdUGKTZlXaodxAsQ3mCrMA0BYpg28lNARkBEWrpRcFUJNnZYRlq1BPNO8kNh/F3G5/V+X4pDfU0/nx05M8m8vhFjvbReQ/guippFJtNtVQUU+i056UXFjdEy8DIM/Ty1AfRQ9nEo7znI4yV41le4VUifNKT8RAfx/L9uF5feHnEkptbho4tuAoHOGrNuWrqIzx1yIo23sEBrIBcAlzCX9AqTzrlf1wWdxnB1CExEE0G2qk6GlBIw7JTbaelsbQf3AAuyzbAGBPcJtlhViV1uAuJexjaVsYofBB08odFVl0IBgOWyTNRkeITyqfXQlOWt7pvCM7xBk/saRZXa9umeRzWSARRCYRohNf/zj9iQREiizniK5zul+PlA+JeW3be7mOsHfPM4YfFBxt29fL3TiuoNa2vcSVj0DMqh895a4CW5ECACWsCDY3RAYAuG3u4wMoE00Hs76rMaAk1B4UjbbtIdGGDot8EpVoKXyb/hb3ADIc30agRNutvTDdAWMcXVUwTkkIzty9epzGT8exSeAQBJEqPfsGgwRBEASRAWSwlB+J8PDDD2PEiBEIBAIIBAKoq6vDK6+8orW3tbVhxowZKCsrQ0FBASZNmoTdu3cbxtixYwcmTpyIvLw8VFZW4vrrr0colMkimiRSCIIgCCLtqGXxU3kkQp8+fXDnnXdi06ZN+Mc//oHTTz8dP/7xj/Hpp58CAGbPno2//e1veO6557B27Vp89913hhsGh8NhTJw4ER0dHXjvvffwhz/8AcuXL8fNN9+czpclYRJa3UMQBEEQRPZx7rnnGp7ffvvtePjhh7Fhwwb06dMHS5cuxYoVK3D66acDUO7JN3jwYGzYsAFjx47Fa6+9hq1bt+L1119HVVUVRo4ciVtvvRVz587FwoUL4fHYpxR0JeRJIQiCIIh0I6LJs8k81Lz45uZmw6O93XoRgp5wOIxnnnkGra2tqKurw6ZNmxAMBjFu3Dhtn0GDBqG2thbr168HAKxfvx7Dhw9HVVWVts/48ePR3NyseWMyAYkUgiAIgkgz6cpJ6du3L4qKirTH4sWLbY+5ZcsWFBQUwOv14qqrrsKLL76IIUOGoL6+Hh6PB8XFxYb9q6qqUF9fDwCor683CBS1XW3LFBkN9yxevBgvvPAC/vWvf8Hv9+PEE0/EXXfdhWOOOSaTZhEEQRBEVrBz504EAgHtuddrv0L1mGOOwebNm9HU1ITnn38eU6dOxdq1a7vDzC4jo56UtWvXYsaMGdiwYQNWr16NYDCIs846C62tzktWCYIgCCKbSSXUo6+xoq7WUR9OIsXj8eCoo47CqFGjsHjxYhx77LG47777UF1djY6ODjQ2Nhr23717N6qrqwEA1dXVptU+6nN1n0yQUZGyatUqXHbZZRg6dCiOPfZYLF++HDt27MCmTZsyaRZBEARBpEQ2VJyVZRnt7e0YNWoU3G431qxZo7V9/vnn2LFjB+rq6gAAdXV12LJlCxoaGrR9Vq9ejUAggCFDhqTBmuTIqtU9TU1NAIDS0tIMW0IQBEEQucO8efMwYcIE1NbW4sCBA1ixYgXeeustvPrqqygqKsKVV16JOXPmoLS0FIFAAFdffTXq6uowduxYAMBZZ52FIUOG4JJLLsGSJUtQX1+Pm266CTNmzHD03nQ1WSNSZFnGrFmzcNJJJ2HYsGGW+7S3txsym5ubnSudEgRBEEQmSKbWSWz/RGhoaMCll16KXbt2oaioCCNGjMCrr76KM888EwBwzz33gHOOSZMmob29HePHj8fvfvc7rb8kSVi5ciWmT5+Ouro65OfnY+rUqbjllluSP4k0kDUiZcaMGfjkk0+wbt06230WL16MRYsWdaNVBEEQBJE4ulXESfdPhKVLlzq2+3w+PPTQQ3jooYds9+nXrx/+/ve/J3jkriUrliDPnDkTK1euxJtvvok+faxv4Aco7qympibtsXPnzm60kiAIgiA6h+JJYSk8Mn0G2UFGPSlCCFx99dV48cUX8dZbb2HAgAGO+3u93ozGxgiCIAiC6D4yKlJmzJiBFStW4C9/+QsKCwu1gjFFRUXw+/2ZNI0gCIIgkka/jDjZ/kSGwz0PP/wwmpqacNppp6FXr17a49lnn82kWQRBEASREtmwBLknkPFwD0EQBEEQhBVZs7qHIAiCIHoKFO5JDyRSCIIgCCLNpBqyoXCPQlYsQSYIgiAIgoiFPCkEQRAEkWZEihVnKdyjQCKFIAiCINJMd1ec7alQuIcgCIIgiKyEPCkEQRAEkWa6+waDPRUSKQRBEASRZmgJcnogkUIQBEEQaYaWIKcHykkhCIIgCCIrIU8KQRAEQaQZyklJDyRSCIIgCCLN0BLk9EDhHoIgCIIgshLypBAEQRBEmqFwT3ogkUIQBEEQaYaWIKcHCvcQBEEQBJGVkCeFIAiCINIM1UlJDyRSCIIgCCLNyEgxJyVtluQ2FO4hCIIgCCIrOaxEih9+uB2cRyWeMDizl75uJsNu9boQQEvI/tgdskBzKGzb3iq3o1Vut20/KA4iJIK27W3iAISw1t5CCATDB237CiEgC3vjhXBe8S+EbHvsziBEOHIMm2PHyyBzao/XP067cm7J/xwS8aodZDA7TkT+S7QtkfEJ4nBFpOFB9DCRwpgLjNmLkNHuYzFQ6m/Z5mYMP+pzCEcXWguBApeMSl8HvNx6Mt7fAWxt4uiwmav/dfAQ1u4/YDvhrTv4JdYd2mZr+0ehj7BDfG3Z1iE68E3oIzSJ3Zbth0QT9rd/YStUgvIBhMIt9kIBDuoLgCzaIAtrgaWMySIP63aBdgB2Ak4AkONM5k5CIwWnqRCACNna1lnxks1CJR5dITRIvBCHA0JElyEn88jiy0K30sNECocQ1pOhGx7k83wU8yLL9r5eHyQGlPusJ6QCl/KJcXPrT05rWJmIW23m8++DYXQIgYOyedIUQqAh3IK9NkKhVW5DBzrQLJosx26Bsr1NPmDZ3hHZHpStRYosByN2OIsRKxR7lRQx+0nb+j2JjBD5v52YkA37JY2VbZ29Cth6ibrwKhLHtlyZ6HPFToJIN6qTNpUH0cNECsDAmPWv9mKpHACQBx8ki9Pu5/UDACpsREqJR5moPDaelIMh5ZitIfOxZSGwP6iMq/6rp1luR1CEEYaMZvmQqf37ULMyNlogW0yYB0QjAKAN1iLlkKyImJDF2AAQjnhBhIXHICpC7NCLCKtvlbrNTqjIMf/a9beGOQighMI0SV0RDs+rCAkPgiC6ix4kUvSnYp64SqUKpYUxFLICU3ttRKQUuAQ8Ft6SUq+yzUqkCAG0Reb3FguRciAsa9P//pDZW9EQatX+3htuNbV/H1ZEioDAQZi9IQfkRgBAu2i1FDEHxX4AQFCY+wohIyw6AACysBAptmEYtV1/PIvXJu6EprabPTHKc+fjm8eJty0ZhKXgYQ75S7kMiRCCSB05DQ+iR4kUZvO3QolUoSUDBixEypH+fO3vUo9xYuRMaOEeiQE85iLeFo5Oh60h84/yvTrvyT4LT0pDsAUcDBwMe+UWU/ueiEgBgBbRbGpvjnhSAKBdGPuHRQeCQvGghOV2kxAxeFesRIrFNuMO0fa4+5rGjvW+xE6OMW0JezvS+TU3jiWESChZOJsn/my2jSByFSW3RKTwyPQZZAc9RqQwxi3/Vil3VWuhgViR4mUc5S43AOWDVeY1TrZFbgGu0z3uGG/KQd3uYcFMybP7gmGt//5QyPSrvD7UChkCMgS+DxtFhhACDSElXMPA0BIT0mkXbehANGm1LUakqKEelZDcZnwuos8FzKt04goPFt0/Nq/ELEKcclMAs6hIUGTEipgUVhyZBVG85ymSxQHodIoYEkQEQSRCjxQpsXiYF3lcESYMDMU8YGjv6/VFclkAxswipdgjtDlEAKZw0KGQcfqNTZ79PhjWVHFYAC1h3cQuBBpCUWGxL9wCWTdhtYo2dEQSWgUEDsDoSTmgS6ZlYGgTRhFzUDRCb10oJnlW8aRE22NFiVO4x+xNsF9KrFpoJEbUmEROrMgwju2Uj2KJ3rZERYFp/y50xvaQpFmVXLOXINKB3bLiRB5EDxIp5nBP9HlJJB9Fxc98kCBpz/v5/JowYAAqfMYJqMQjQ100xGDlSWGG9FBlpY+CPmlWpVFXL6Up3IagbjKWIdCkExJ7QkZRcjAm7+SAaNQmawFhSp49JDfqXgmGYEzyrCJSol8HvShRRIiTJ8VqonYK3zjtazVePCEQL2k2VSFib0sqtVNyGRIcBNE5Ull+nMwdlBcvXozjjz8ehYWFqKysxPnnn4/PP//csE9bWxtmzJiBsrIyFBQUYNKkSdi921i6YseOHZg4cSLy8vJQWVmJ66+/HiGLXMruooeIlNjTEIgVKbEJpfqQTz+vX3GhRMhzCUM9lFKPMBxBnzwrC6AtrJ/kjSt8mkKyYXpjAPYHo2/47pA5UXafLnn2+3AzuN7TAYGDiLYfkBsNE0eHOGjIOzko9O3C4EmRRRjhmAJxshy1LbGkWW0Eg63OmEWKOvknljRrNV76J1OjMOmZaW0kQggiN1m7di1mzJiBDRs2YPXq1QgGgzjrrLPQ2hqdL2bPno2//e1veO6557B27Vp89913uOCCC7T2cDiMiRMnoqOjA++99x7+8Ic/YPny5bj55pszcUoAesy9e2JFitGTUipVaOEcAFry7P5IqOQIf55phFKvjF2HOCRd0qyKmjwrg0VW9Rh/0avJs4yZE2UFgH06T0pDqBUcDHJkcuBg2BtuwZGoBKB4UuSYieOAaEYBK4QQwpA0q9IuWuBnRQiJdkPOCaAk0soiDM4kU35KZI+orQkkzer7OBXUi+7ntGSZ2bepL2xcukJEyACk5Lw0UD53CYeouolsto0gcpFUqzYn2nfVqlWG58uXL0dlZSU2bdqEU089FU1NTVi6dClWrFiB008/HQCwbNkyDB48GBs2bMDYsWPx2muvYevWrXj99ddRVVWFkSNH4tZbb8XcuXOxcOFCeDyepM8nWXqIJ8V8cdXnqJRJ1aYLsOpJ8XOOMpfxhdcnzxa5heWcqHpTDlnM4/rk2X2hsCHpFgAag9Hk2fpQi0GEyBD4PlJ8TQiBPWFj4qs+ebYDbQiiw3R8NXk2NmlWRV3RY1U3RSCaZxK/uJu9J8V+Iu9s8mySoR4teSidSbOx27vI29CJEFKmPB3pOC55aYjDiXSFe5qbmw2P9nb726foaWpSrv+lpaUAgE2bNiEYDGLcuHHaPoMGDUJtbS3Wr18PAFi/fj2GDx+OqqoqbZ/x48ejubkZn376aTpeloTpESLFKmlWvd57mQ9+nmfcX5c8q9ZHMY4XFSklHtm8aATRvJTYpFkVNXlWnzSrEoZSO0UWAnuC5nDP/vBByELGAfkQgqZE1mjyrFUFWn3y7KGYpFkVtfKs4kkxt6selLhJs5Z1UTqbPGtznyFN5DgXd0v6N39KpRzVfplLms1VSKAQRHL07dsXRUVF2mPx4sVx+8iyjFmzZuGkk07CsGHDAAD19fXweDwoLi427FtVVYX6+nptH71AUdvVtkzQQ8I9Vp4UBiGYKWlWxce8cEFCrVdJmuU6d4k+ebbYI0zDM0RX+OiTZvXtrSGGYo+MRou6KADQGAohBBkhiwlPhkCjfAiNYesKsgdFK8IijAOykjSrnwD0ybMHI0XeYtE8KcKYNBsdIwwhXHHqgDi1dWZCst6HpepJQZJJs9HODo1yJJn48JxwSWgQROdJtSCb2nfnzp0IBKIrUr1eb9y+M2bMwCeffIJ169alYEF20ENEih0MpZGkWW7hbQmwAlPSrIpfEvBJMsq8wnI69HDFE2KVkyIAtIQZGmOSZlU4U8rjt8LsRVHZG27BvlCzIV9Fz0G04IAhKTZKhzgEWYRwSG6E1WQdlJXkWtnmrsqyCMXNK7G/147qgYnnpLOe8ARkCFlG4kmz+nG7ejKlpFmCIJxRvM0p5KREfgwFAgGDSInHzJkzsXLlSrz99tvo06ePtr26uhodHR1obGw0eFN2796N6upqbZ8PPvjAMJ66+kfdp7vpEeEeexhKpUpD0qyKkjxbaJk0q1LhDSNPsv6QcYZI3on1L/rWILC3w3qilQWwLxRSkmYtbFOTZ/eEmywFCgA0y82WSbMqLfI+hGAdu5RFEMGwubKtihDh+PkoTkm1Qna+pWBcT0ccL01cT0bXTbZKKKz7kuEIgshNurssvhACM2fOxIsvvog33ngDAwYMMLSPGjUKbrcba9as0bZ9/vnn2LFjB+rq6gAAdXV12LJlCxoaGrR9Vq9ejUAggCFDhiRoUXro0Z4UxjhKXVW2qxYqXAUocVm/BLIAevllx4Uk7WH7CUcGw55IpVmr9e6NwTA6cMBQuC3aV2BPuBl7Q9bhHgaGJuxHCNaeEAA4IO+xNxxAh0X5/SgCchyR4uRJUc4glck4nhclTkZKKkmzccmcyCCBQxCEHTNmzMCKFSvwl7/8BYWFhVoOSVFREfx+P4qKinDllVdizpw5KC0tRSAQwNVXX426ujqMHTsWAHDWWWdhyJAhuOSSS7BkyRLU19fjpptuwowZMzoVZuoKerRI8bE8+Jg5MRZQJvr+3jzAYnUMoESASj0yhOCWQkUgkjTL7H/Yfx8M2RbkCUNgT8h8wz+V/eFWhGwmawGB5shNAy1tB8MheT/sl/ICwfAhx3an5cfx7oysLM52It5km6rI6MrJvGeGegiCSC/pCvd0locffhgAcNpppxm2L1u2DJdddhkA4J577gHnHJMmTUJ7ezvGjx+P3/3ud9q+kiRh5cqVmD59Ourq6pCfn4+pU6filltuSfo8UqVHi5QSqdyxvcrLTUmzKgxKUTe7KYkBOBBiDqtVhaH8fSwhdNiGcgBY3s1YT7s4ZEqa1Y4NgXZxEPaTNYNsI870o9gTb6KOF0WM1z/VpNmuhLwZBEHEx/mnXOf6J7R/J659Pp8PDz30EB566CHbffr164e///3vCR696+jROSklUrnjZF/sCcUpDMZtp8OQDBwK2/dtF2HHD1kQVoXUogiEHYtrCRG2VelCCMgOoaBUJ9p4lWjjLxB2OH4nvmhWOUadGjsLoIJpBEEQnadHe1KKeanjhFbiCduqNCEA63U9Ci0hY1XbWNrjTOQdaHcItih1Qpxchc45IfESU1OcKOPmfCS3sqdzpCCAUoRyQgiC6CyyEI7e8s70J3q4SJGY5PjLNbYSbCLIIk7WRdw72cpwyglxVDBZjrOngyAIoufT3WXxeyo9OtwTD5pKCYIgCCJ76dGeFIIgCILIBOmqOHu4QyKFIAiCINKMjBRzUijcA+AwD/cQBEEQBJG9kCeFIAiCINIMre5JDyRSCIIgCCLN0Oqe9EAihSAIgiDSDOWkpAfKSSEIgiAIIishTwpBEARBpBnypKQHEikEQRAEkWYoJyU9ZDTc8/bbb+Pcc89FTU0NGGN46aWXMmkOQRAEQRBZREZFSmtrK4499ljH20YTBEEQRK4hIuGeZB/kSVHIaLhnwoQJmDBhQiZNIAiCIIi0IzMZjCVf3F6mwvgAciwnpb29He3t7drz5ubmDFpDEARBEERXklNLkBcvXoyioiLt0bdv30ybRBAEQRAmUgn1pLoyqCeRUyJl3rx5aGpq0h47d+7MtEkEQRAEYSJ1iULhHiDHwj1erxderzfTZhAEQRAE0Q3klEghCIIgiFxABsBSKuZGABkWKS0tLfjiiy+059u3b8fmzZtRWlqK2traDFpGEARBEMlDq3vSQ0ZFyj/+8Q/88Ic/1J7PmTMHADB16lQsX748Q1YRBEEQRGrIkMFSEBokUhQyKlJOO+00CEEZzARBEARBmKGcFIIgCIJIM+RJSQ8kUgiCIAgizaS6jJiWICvkVJ0UgiAIgiAOH8iTQhAEQRBphlb3pAcSKQRBEASRZgTklIQGhXsUKNxDEARBEERWQp4UgiAIgkgzAmGIFPwAAuE0WpO7kEghCIIgiDSjhHooJyVVKNxDEARBED2At99+G+eeey5qamrAGMNLL71kaBdC4Oabb0avXr3g9/sxbtw4bNu2zbDPvn37MGXKFAQCARQXF+PKK69ES0tLN56FERIpBEEQBJFmZC11Ntn/Eq/G3traimOPPRYPPfSQZfuSJUtw//3345FHHsH777+P/Px8jB8/Hm1tbdo+U6ZMwaefforVq1dj5cqVePvttzFt2rSkX4dUoXAPQRAEQaQZJSeFpdQ/USZMmIAJEyZYjycE7r33Xtx000348Y9/DAB48sknUVVVhZdeegmTJ0/GZ599hlWrVmHjxo0YPXo0AOCBBx7Aj370I/zmN79BTU1N0ueTLORJIQiCIIg0k5oXJbp8ubm52fBob29Pyp7t27ejvr4e48aN07YVFRVhzJgxWL9+PQBg/fr1KC4u1gQKAIwbNw6cc7z//vspvBrJQyKFIAiCILKUvn37oqioSHssXrw4qXHq6+sBAFVVVYbtVVVVWlt9fT0qKysN7S6XC6Wlpdo+3Q2FewiCIAgizaTr3j07d+5EIBDQtnu93pRtyyVIpBAEQRBEmpERBlLISZEjOSmBQMAgUpKluroaALB792706tVL2757926MHDlS26ehocHQLxQKYd++fVr/7obCPQRBEATRwxkwYACqq6uxZs0abVtzczPef/991NXVAQDq6urQ2NiITZs2afu88cYbkGUZY8aM6XabgR7uSQmKIAQEmI2aDcoMXslpmZeAnRJ2ceflYZw5K2gOHhnf7tDxFDhz6B+vb+JL2xIaXwggzvkTBEH0ZNIV7kmElpYWfPHFF9rz7du3Y/PmzSgtLUVtbS1mzZqF2267DQMHDsSAAQMwf/581NTU4PzzzwcADB48GGeffTZ++ctf4pFHHkEwGMTMmTMxefLkjKzsAXq4SNkf/h593P1t2/d1SCjwhC0FAWMAi0gcKwpcwrHdyyRH27zMB6fyOIxxcBG2/ZgycABhS7nBGIOziEkNxjiEk76CDA4JwlFEJWubcz8GnoYbc1nbxyLvOEEQRDxkkWK4RyS+BPkf//gHfvjDH2rP58yZAwCYOnUqli9fjhtuuAGtra2YNm0aGhsbcfLJJ2PVqlXw+Xxan6effhozZ87EGWecAc45Jk2ahPvvvz/p80gVJoTTdJPdNDc3o6ioCIzlRyZmI5VSL/xXvvWacQA4srANx5YesvVahNwetHcwiJDFS8SADw64sLfZbdmXsTC+Cu1HSLaOqIXQgd1su61tYRFCSLZfaibkDsgiaFvwh4t2tMvtlpMqZwwe5kWHCNmO74QQYcjikMMeHIx5HAYIQxFY1mJCEi6EEbRsY+BgzG3bV/k4J3denUMRMPZihcO+FDaLePWS+8qlLpDUz3lXiMdMkqt2E92PABBGU1NTWvI8rFDnpfK848FZ8n4AWYTw/cGNXWprLtCjc1Iaw/sc21leh31YhQOBI/IgwtYXP8YEavsdgmQTLhJCQm1Zq+2xJbjhd9lfWL3M+a0p9/jtBQpjqHQX2/YVQqDUVegYkspn+Q5H57YhNABwwVq4qfhZwFZkMHD4WMB2fAEZXlYIu18ojDFISD77nTvaziAxv6OHSOI+W9sAAYn5bNqiFiQLi2M7Yy44TeYMEpx++bEudbw6nzdzvNgLAM6ey1R+0canM6HZVNqJXEQN96TyIHqISLGb0ApceeB2GoQL9BqwF2D2F+3K4wK213QhMxw19ADCDh65kQO+h4tbf9Dy3WEcW2H/i//IPC8KXdZvj8QYBvqLbfvKQqCft9x2MhUA+noq4OREq3JVRvJmzHi5HwW81KYnQymvgGQzaTAwFPEqyzbFNhmFUqWj16CAl9m2AQx+qdT2M+Hm+XBzOwHG4OZOv1gEPFKhY7sytr3tSn+7SYnBxf22fSXmBbMNIzK4eJ6jbTyOQFK8X/a2OwswFkdIuBz6xhNYAGPO7TxOu7OIYXC+FKYqMuJdZlMRWCxOezxSnQIyKQ6zG0VohFN4kEgBeohIsbqscsZR5aqAy+Y7IgTQ/8i9KCg9aL2DDNScWg4m2X/Jho5thN2XsCCvDSOPaLAN9wyqaMWxFSFY6RCJAcfke3BMvs9y9LAQGOgvQpHLPqQyOK+3bRsADPT1tp2OCng+Kt0VlnfhZGAoRBkKWUUkLya2HShxVaJIshYSAgJFrBqSw6RUyvvatjFwFPJesJtMvbwAfqnEUuQwMPh4Mby82EbECHhdhXA7TPZeqQROF16PVORguxRpt7bdxf2QbI/NwJkXHHbvuYBbynecrBWRYQ/n9p8nxiRI3A872xlzOXpaOHM5ihilzf515czZO+YUXmSMgzl6JrnjsRmTOtHfCeeJnDm2cwdhqh7bSQjEa09NRDi/LqkKqMNX4BBReoRIsbpwykJGpbscbpszFILhiP77UNZ3P5jNSp3yEUUoPtJ60vAXBzFgaCtcbouJnAkc1acBQ/rut+wrcYHBFQcwrDyEkIVYDgvgyDw3jsnz2XqCar0FOMJXZBmy4WCo9ZaixGXtMShzBdDHU2HZxsBQLpWjzFZkAAW8BIW83FLpCwgUSxUo4eWWIgYACqVSFPJyyzYOCQWsEi6bkI2fFyNfsvbiqCLEx4ttbBfw8iL4eJGtp8bNC+DmhbaeGI+rAG7J+nVlzBVpsz5vj1QAt1Rg2aaEivwOnhQBzj3g3H6yliR/REhY2y5xr62IYUwCt53oIwLJ4disEyLEaTLm3O3YnzOP7eeJMZeDOGOA4I7Hji9iGITDajtFRCQnYhQBFM/L43Rs1gmh4NSaioiJ39fuPYs/dmfIbhEjhAw5hYcQ5EkBeoxIsabCVW7pqQAUIdGvdj+KezfB6rOQ19sPd6EbFccGwGLcMYwD5QMPQpKAfkeaPTGMCRzZpwF9y1rg85hDOmGZ4ZjyFgwvtw/3HJXnwcB8L6xSYlyModrjR39fAFbLbCo9hXAxCbXeCpOI4Yyjj6cCbu5Cmcsc2hAQKHeVoViy9zYUcHuRAQDFvBzFvMxSxEhww4t8FDJrEZPPy8A5RwEvR+xFiIEjn5fDxbxwM/NkrooQL7f3ZnilIngdvB1uqQBuqdAm4dgDztxw8wLL18bN88AYg1uyEhoMLl6ghGwsJ0wBifsdvR2cxREpzBsJ+VjZ7o5Mxh5L2xncYIzZJPoJSNwXEQI2uUDohEhxDAdxW0+MYjsDLIUIixzbzuMglC9sXBERz5vhLBTsJ0wJnDscX6gCyS7HqjO2JxuOYnFsR5zzjuOBSsm2eO3M0bZsgHJS0kOPEClui1g7B0OZq8Q23NOr+gC83jBKappgmgw5Q9mxykRWNqzQYnWPQNkAZXXLkUNaIMUkwMoyxxG994BzYHCf/bCaNI6paEFNgYyAx/xB9HKGXl4JA/OsJ6w+3nxIjKG/L2D6GHPG0MddouznKTXlnchCRi+P4iXp7SkHt/gVViaVQWISiqViy+MXsBLksSJwiwu7l/ng5/kotvHEFPIyMMZQYOGJYeAoYIr4KeDlpsuTgAx/JBcmj1nnnfh4ABJz24ZsPDwAj03eiYv7wJkLbm7l7WDadjcvsBQxak6I8q/Zeo9UAMYYPDbeFIn7Ih4FqwmTgTE3JBtvh8R9YIxHPClWfZV+nHusQ2GqgLARIpx5lKRkm5CQ0t/ucqLkfNiJFBYRIdbt0e3W3hKhtduJHAYpjsfBaTJVJ0Onvk5hD2bYz9zMndvjCgkn2zrTF7Zew84ICOfXNdVQklN/9TOcvUJFiHDKD6KHiJR8VmL6opW6SiAxCZwpOR56JElg4FF7AADF1c2ITZ4VQqBkSESkDDUnSgqZofQIxYNyxNGtCIfMX5QBvb8HAAzruw9STDip0BNCZX4HGANGVIRMX7Oj8tzgjKHU40KxyzhhSYyhv1eZ5Pr5zJOtLAR6exTbe3vLLIMaNW5FQPRyl0K2cCOVuhQhUCGZRYyX5cHNPGCMm5JnGRhKJOXmVPmsEFLMpMHAUMiUPlbJrwIy8iPb83mZ5WSap4oUXmKZdaKs/AF8Fp8JDy8AZxI4k+CJESIMDG6u9HXbiAw1VGMtYmJFitk6tZ+LF1iMz7Vwi1VeCueeyIRgDg8wMK2Py9ITI7R8E7uQjioAuM0KICniwVFyQ8y2K54MZpngqnhR1MnUyosjaftZ2c4MtplR2+09NZHPsLC63KkTrd1ky2L+jT0271S73UQePXf7hGi78aOveXK5HyzOuZltiEU5J+dQmL1tUduTIXvFCZFeeoRI8fNiw2WVM44qd/ROjrHeFFkGBvRXlidLbhmF5TFLhQVQMlQRAMVH5YNbuGNKI56UAUeblxkH8g+huFBpH9R7P8K65FkGYFBFi1aQdURFCFwnkiQGDMyLXugHxSTPhoVAP6+SE5EvuVHiMk9KNZ5iAEBvjzl3g4Gh0qN4WnpZtBfyArgjF/0yl1HEMDAUsGgfq+TZYq687owxlMR4UwSE1t+LfLgskkALWFSkmG2X4IuIkDxegtjJ1MsLtcnAJxUbRA4Dg1eXqxKbPCsgNBHBGLf0xERFhnXehysS5rFaZaPkTSjnq+StGG13cb92wTYLDWYQF7FJpAJC68OYZJkAq/a3z0mJeCNsRYYyiSrhJqPt+vCVVShL9XDYeUuix7YRMZoIsbHdQeQwfajGUihEtwkLERMVGXYei3gTfXxPiWqnVV/VdiuRYxQHVsdX+9oJhc6KFCuYo23GcExy4ytj564YkdPwH9FTRAorhv7CKQsZFa5ozkRsXooQDEcMiNZQMSXPMqB4kDIZSh6O4qONiZJ5ZUF485UPUK++bXDrQjaMCQzsu1t7Hps8y5nAoIoD2vPh5SGEdRebsFDyUVSOtljhU+uL/pI/0hcA1+3BwVDpVmz3cjfK3EZPULm7CO7IxbzSbZyoGRgqXNGE2tjkWQGgkJVoz2OTZwUESqTo615skTyrel8YYyjkxuRdDhe8TDk3D/Obwnh5vES7IPp5iaFNTZpViU2eFRCGXBSvZE6e1Se1WiXPqgmzViEbrkvetEry9PAC7YJr9sQwQy6KOWQjHEVKbB8XM4sotT9j3CRU9KtXrEIm+uNJFsdmPNrHSYTYjW9otxQaqggxJ7hGvTR24R79DwQLAaUbz9mTEvu3cXxrEaMXB9YepOgknPix9RN4fNutiAoByzwlR4HQOYGk/JXM69o5slnEiEjyayoPooeIlDyL1RyVrugEG7vCh3MZfftExUNJTPJsQd88uPKiFzx98izjQPlRUe8Jl4D+A6PPGQSO6LNHe967tBV53mj11LBgOKYiWhB/WLk57niUzpMyMN9r0NNuxlHljk5o/f0Bw2Rb7QlA0l2waj3lWvKskjRbrhvLhXJ3NGQkIAzCpFgqjqmVIgwhnkILb0exTngUS8bkWRc88CA6mRawcsPFsYCXGy46BaxCa2fgyNMdz8U88LCox0JAwKfLNfFZJM/qE2qtkmv14sEjGfNOlJUxrph9oxOQS1d7hTEGl6T3pjDD2Ep+h35CFQaRYZVXYhAKJk8JMxSJi10qrCWeavZ5DLbra5QoybNGESPpknWZRc6KXhxYixTJod04uce2m2yPWbpuPLZF8qzhubMnJV67WQjEhitiJ0y9t8FKxMSOHfO6ss7bFv9SHvueGW23u72HYod1qMlubGWLc3tiJCqgiJ5EjxApLuY2TFgcHCWuEl27cf/eNc3w6Lwf+uRZJjGUHmucwMqGRpNnhRAoO8JYEv7Iwa1a8qwslKRZFcZUb0p00jhGF16qypNR4o3a4ucMVZ7ohfWoPOMv11pvvmHFTj9fQBuZM4Y+HqOHoY+3TEuelYWMXm7jqpzebmPeSZkrKkI44yiJSZ4tYNHn/pjkWR/Lg1c3wRYbRAzTkmZVCnV5J0ooySh6Cng0p0ZA1vJRVGKTZ/XChDMXPIaibQxeHvUqKX9H+7q4H1w3obl5oaGvixm9H4roiFoXG+IxJs8Kg5eGMWbKidELE3NNEWOYJDavREmaNZ6Lsa9xfyUcFLXdFAKKqVmiF0hK8qzxM2m0NXayjRUhMfk0Ok+IsndMHpPJ6xPneUzROGY4ttWSWKfJNL4IMdriNLb5uTkPxcoTo+5rFbLpnECyao8VJWZPSufzVOy9SMmTmAjJTsGSWiE35UH0EJECGCescnepwZvAWDR5VpJkHHXk94a+gaoDYJHKsEKOJs2qlA/TTViCaSt7VI44xpg8qybNqgzVJc8GvEGU53UYbDu2MqTlqAzM9xi+oMVuF0rdyoVbWdFjnNxqvVHvgZI0W2xo7+MxJs/WeIxCoJfHmHdSElODpNxVrnlTvCwfLt2Ep4RsFNHDwFDCKw1981iBViKfAYZ8FgCRZcYKAsKUh6I8j1pvEim8xCByPDFCwsejybNKuEX/iz6aPKtPmlWJFRmx4Z3Yeiex9U1ik2djQzz65FkGcwhG0oVs1KRZve1RYWCuUmv0xAiTqIgVOVbeC73t5v765FljCCY27yRWhMSKGLMocX5uDlVZ7W/IUIMRo/fC+LrGTraJipLY9lhBlqhocTq+2fZEJvZURIl6fKd28+sarz0RslOUxCKESDHcQ/ejAnqQSMmPTFgcSqXZWNS8lHCY4YgBew1tkktGoDLi3dAlzaoUHZEH7ol+MUr7G0WKPnm2pLAVgfw2Q/uQPkryLIPAkMpo0qzKiPIQOIQpaVZlcL4XDErSbK03Jj9GcqHcHZ2UatxGgdXLU6KfTlARc0+fXu6oMAhIAS1fRaVMKoMMGfqVOXoKdXknJZLxdVeSZxUhIiBM/b0sD25d0bbYFT960cIhaSt3VPR5KV4eME0CPq4kz8bmq+jb1Tsbm1b7MAaPrmhbbAE3ifkMv8qN4R2jaOHMZQrR6JNnJclvulArSbgi0t+cBxIVGsIUHlKWInst9rV+bvZO6L02LtPrqk+edUqUjR1LeR4rYqwmcr2QiCNKENtfH7qyqG+iO571qhT78E6iIiaeJ8UcgjGGb2JtjxdicUqkNQuFREWKcd9EbUt0fOPYuSFKiK6hx4iUvMiEJcOYNKvi1j7nTFvZo6dUzVHhQNHRxsmQuzhKj1EmsYKKDrjzjAlNVb3b4PUprrmjdEmzKoMjYwswQ9KsyrBI8qySNGsWKUfn+7Tfhv285mqnR/gUYeICR7nbONl6eDTvpMJdDFfMpFDhLtISbysk8+tWFsntsRIZAFDIyiOFh5RKs7EU67wlVvf7UZNnJXjggfHc3MynhfHyeKnpYpWnEyl2IkS13aqAmz551qoSrN674oq5349StE3pw5nbtDxWSZ6VTONEx44eT7IoTGcM/5hX6+gTWK2q1OrHNE/0TFsBZPZ0GEWG1f1+9LVaGLdaDaRf7ZN8oqzye98sYtTxWUy+iul4Vqt1HHNMYrfFS/h0EjF2E7m6TbKYfPXn6jzRx7c9Mc9IrIjpfNKshW0Wr1v8HJXkhUiyS7C7Girmlh56jkjR5UpUus2TrepJkSQZffs0mdpLejcCAAr75cPlN/86rDhWmejLdUmyKpxHvSlH6pJmVaqLD6LAp4R4jold7gxFpKhYiZSB+cpE4WUc5W7zpNHfp0yC1Z4iQ5hLpdarCAGrUvguJmneFatS+EU8oIV7CmJW1AAwVJ4tthA5alE3N7zwWEzGasinICZfRWuPFHfLs0jSlZgbnsjdmq0TZQO6v50Taa1uOqgKCSlS5M2u3XrJcTR51koASdyjjWmVKKtf7WO5pFjzlDDH1T6xoSKtf2T5t7WIiCbPWh1bnzxrvWImngiJhqqsLkGq8IlNmo32V0OI1rZrIsmy9kgiyagWx2b2IsTYx+7Sqq6ishIZ0cnWerVOvIm+s8mz8Wy3aIlrm5OXxnnszhFPQGVfaISKuaWHHiNSJOZGHi+ABAnFFr+aXQxgTKBP7ya4XGaFqiTPAmXHFluOXzpUmWhik2ZVjhyo9I/NRwEAxoChNY0AgKPLW0ztFXkCpR4gX2Iod5svrGrybK2vwPJePWpRtz4x+Sgqar2UXh7zRA8A1RFvSZnL3M4ZR5GkiJN8nRBU8UWKtvlZPjwWv7pLIuKikFkfW02WVcVILGrIJzYfRUXd7rWoIqskzyq5Hx4Lb4Ynkjzr4nkW+QCAW1KLu9kVb8uP/Gtd3VbdHr+/1WoeNXmWWU7GqnfFFZM0Gx07IlJsbkgYLZBmVzdF2R6bj6K0RUWMdQE11WNgXSAtWhfF7MUBosLHvkKty7Fd9UjYCwF1u9NkG28it5504xZv09qTKd7GHNtTtT1+u32V13i2JZQvQ+EdQkePESkAUO3qhV7uKstS74wBtX0aMWzoLsu+gcoWeIrdKB9t9hYAQOVQDi7JqDzG7AkBgMFH74HXHcSA3mZPCgD8oO9+9C06hLK8oGX7cSUSRhR4Lb+ghS4JvT1+HOO3Lufe11sIL3Ohv9daCPT3VoGDo6+n0rK9xlMFN3ObVvKolPEqFLASuCwLfTGUSb1QIVnfddnH8uBFPop4lWV7IS8Hh4SAXbtUCfWePVbk8TIlVMSshYCflysJtDbucQ8PwGtz3i7mB2dueCTr110VQHY3DfRIhQC4bbtbKoh4C6wnW4n5wJm1CGGMQ2K+SAKuGTW51e5eP1q4x6bMvdLP2ksTHd/67sBq5Vnb4muRvBP79og4s6mOG1dgaaLOyZthfT+eqIix6+vkTdAfM7n2qHixm6jj2R6f5Mvgx7HdUDPG4fiOticWpspmqE5KemAih1OIm5ubUVRUhOP8F0FiHgzwelDqcZuSP1XmzHsFNb0b4XJZn3LojLsg5Vu7x0XbPrRt+iPcfpsPzt5GtG/5D/xeaxFyqKEQB/cG4JOsj/3Ftr5oaSqC2+a2x180BgDhgmRlmwC+aXXDw6zi3EqBuKZgGF6L/AEAOBAU2NMha5VmY9nT3oGmcAhW9+oBAD8X8ETKzVv27zgIBnMhLkDJF2kX7ZBsji1DRhvabNs7RAc62CHbkukhEYTMZFvb2kSzkhhsM+mERAeYzaQghIwO0Wo7NoMEDpdte1BuQ0i02R47GD4EWYRsL/ou7gOzzG1QVha0h5tg96taCBlhud1xsnVxr71toUMIi3Zb29TLSrLtdp8Xta8QYdv2sByEEEHbseWIG93etnjt8c4tzkobh3bFNjnpY8tyCMqtBGyOLwDbzwQEhMPnTQhY5gFp7bLz6yYLZ9tS+cwobZ2dykJoampCIGD94yNV1HnJ4+rl8P2KjxAyOkK7utTWXMDptqQ5B2cSXA53WnW7ZVuBAkAp4OZwcbEVKBHsBAoASBzwuWTA5j4XHs5sBQoAeLmEkOzU7vxW2gkUQPnS2wkUQAn5SEyyuuEyAEBiLkvvlb7d6fJhJ0A6066EHpzuvsstQ2TRdsnxt5mdwEhHu3Xdjth2J9t53HYnnNoVb0gqtiX+a7qztsVrj5dImbptXdfePbYnN368Zc6Zfl3joa7k6y5S9YSQJ0WhR4V7CIIgCILoOfQoTwpBEARBZAOpLiGmJcgKJFIIgiAIIs0ouU3Jh5co3KNA4R6CIAiCILIS8qQQBEEQRNoRQEohm5xdeJtWSKQQBEEQRJpRwjXJr0jK4eogaYXCPQRBEARBZCXkSSEIgiCINKOszknBk0LhHgAkUgiCIAiiC0hNpFBOigKFewiCIAiCyErIk0IQBEEQ6SbFxFnb+5AcZpBIIQiCIIg0Qzkp6SErwj0PPfQQ+vfvD5/PhzFjxuCDDz7ItEkEQRAEkQJyGh6J09Pm04yLlGeffRZz5szBggUL8OGHH+LYY4/F+PHj0dDQkGnTCIIgCCJn6InzacZFyt13341f/vKXuPzyyzFkyBA88sgjyMvLwxNPPJFp0wiCIAgiSYSSV5LsI4lwT0+cTzMqUjo6OrBp0yaMGzdO28Y5x7hx47B+/foMWkYQBEEQqSBS+i9RkdJT59OMJs5+//33CIfDqKqqMmyvqqrCv/71L9P+7e3taG9v1543NTUBAMIiCAAICgkdsrBNVTpwSEb+QYc4X/MhgFvrNtF2COGWkH3f1jD4IfsPVUebjGC7DAhr61qCIbSGgrb9D4Y7EJZtbBNAmyzZ9g0LoN2mLwC0y0CHbJ/gFRRhhETYNtk8KCQ46d2Q6LD9ugkIhBxirzJkhBG2bQ8jhDDsXzelr/37IiME2WF8pzYhZMd2BgEZ9u+LLEKRO6XajR92vBOq011WhRBx+spx7rLK4tgWr39qON2mXsT5lanY5tAe9+KfasJi8uMnMzkZ+if5C7zzx3Zoj7MaJdVzcyb+2EL//25bOZP6cZqbmw3PvV4vvF6vab9E59NcIadW9yxevBiLFi0ybf9n2/MAgI8OOfd/7NfxjnBVcoZ1in2Rhx3fdOGxCSJx2uPvQiRBJtdspCy/REda7Mg0Bw4cQFFRUZeM7fF4UF1djfr6+pTHKigoQN++fQ3bFixYgIULF6Y8dq6QUZFSXl4OSZKwe/duw/bdu3ejurratP+8efMwZ84c7XljYyP69euHHTt2dNkHrrtpbm5G3759sXPnTgQCgUybkxbonHIDOqfcoKedU3eejxACBw4cQE1NTZcdw+fzYfv27ejoSF3QCSHAmNHLbeVFARKfT3OFjIoUj8eDUaNGYc2aNTj//PMBALIsY82aNZg5c6Zpfzs3V1FRUY/4suoJBAJ0TjkAnVNuQOeU/XTX+XTHD1qfzwefz9flx9GT6HyaK2Q83DNnzhxMnToVo0ePxgknnIB7770Xra2tuPzyyzNtGkEQBEHkDD1xPs24SPn5z3+OPXv24Oabb0Z9fT1GjhyJVatWmZJ/CIIgCIKwpyfOpxkXKQAwc+bMpNxRXq8XCxYssI3R5SJ0TrkBnVNuQOeU/fS088k0yc6n2QoT3bcWiyAIgiAIotNkvOIsQRAEQRCEFSRSCIIgCILISkikEARBEASRlZBIIQiCIAgiK8lpkfLQQw+hf//+8Pl8GDNmDD744INMm5Q0ixcvxvHHH4/CwkJUVlbi/PPPx+eff55ps9LGnXfeCcYYZs2alWlTUuI///kPLr74YpSVlcHv92P48OH4xz/+kWmzkiYcDmP+/PkYMGAA/H4/jjzySNx6663deG+T1Hn77bdx7rnnoqamBowxvPTSS4Z2IQRuvvlm9OrVC36/H+PGjcO2bdsyY2wncTqnYDCIuXPnYvjw4cjPz0dNTQ0uvfRSfPfdd5kzuBPEe5/0XHXVVWCM4d577+02+4jsJGdFyrPPPos5c+ZgwYIF+PDDD3Hsscdi/PjxaGhoyLRpSbF27VrMmDEDGzZswOrVqxEMBnHWWWehtbU106alzMaNG/Hoo49ixIgRmTYlJfbv34+TTjoJbrcbr7zyCrZu3Yrf/va3KCkpybRpSXPXXXfh4YcfxoMPPojPPvsMd911F5YsWYIHHngg06Z1mtbWVhx77LF46KGHLNuXLFmC+++/H4888gjef/995OfnY/z48Whra+tmSzuP0zkdPHgQH374IebPn48PP/wQL7zwAj7//HOcd955GbC088R7n1RefPFFbNiwoUtL1xM5hMhRTjjhBDFjxgzteTgcFjU1NWLx4sUZtCp9NDQ0CABi7dq1mTYlJQ4cOCAGDhwoVq9eLf7rv/5LXHvttZk2KWnmzp0rTj755EybkVYmTpworrjiCsO2Cy64QEyZMiVDFqUGAPHiiy9qz2VZFtXV1eJ///d/tW2NjY3C6/WKP/7xjxmwMHFiz8mKDz74QAAQ33zzTfcYlSJ25/Ttt9+K3r17i08++UT069dP3HPPPd1uG5Fd5KQnpaOjA5s2bcK4ceO0bZxzjBs3DuvXr8+gZemjqakJAFBaWpphS1JjxowZmDhxouG9ylX++te/YvTo0fjZz36GyspKHHfccXj88cczbVZKnHjiiVizZg3+/e9/AwA+/vhjrFu3DhMmTMiwZelh+/btqK+vN3z+ioqKMGbMmB5zrQCU6wVjDMXFxZk2JWlkWcYll1yC66+/HkOHDs20OUSWkBUVZxPl+++/RzgcNpX6raqqwr/+9a8MWZU+ZFnGrFmzcNJJJ2HYsGGZNidpnnnmGXz44YfYuHFjpk1JC1999RUefvhhzJkzB//93/+NjRs34pprroHH48HUqVMzbV5S3HjjjWhubsagQYMgSRLC4TBuv/12TJkyJdOmpYX6+noAsLxWqG25TltbG+bOnYuLLroop284eNddd8HlcuGaa67JtClEFpGTIqWnM2PGDHzyySdYt25dpk1Jmp07d+Laa6/F6tWru/1uoF2FLMsYPXo07rjjDgDAcccdh08++QSPPPJIzoqUP/3pT3j66aexYsUKDB06FJs3b8asWbNQU1OTs+d0OBEMBnHhhRdCCIGHH3440+YkzaZNm3Dffffhww8/BGMs0+YQWUROhnvKy8shSRJ2795t2L57925UV1dnyKr0MHPmTKxcuRJvvvkm+vTpk2lzkmbTpk1oaGjAD37wA7hcLrhcLqxduxb3338/XC4XwuFwpk1MmF69emHIkCGGbYMHD8aOHTsyZFHqXH/99bjxxhsxefJkDB8+HJdccglmz56NxYsXZ9q0tKBeD3ritUIVKN988w1Wr16d016Ud955Bw0NDaitrdWuF9988w1+/etfo3///pk2j8ggOSlSPB4PRo0ahTVr1mjbZFnGmjVrUFdXl0HLkkcIgZkzZ+LFF1/EG2+8gQEDBmTapJQ444wzsGXLFmzevFl7jB49GlOmTMHmzZshSVKmTUyYk046ybQs/N///jf69euXIYtS5+DBg+DceBmQJAmyLGfIovQyYMAAVFdXG64Vzc3NeP/993P2WgFEBcq2bdvw+uuvo6ysLNMmpcQll1yCf/7zn4brRU1NDa6//nq8+uqrmTaPyCA5G+6ZM2cOpk6ditGjR+OEE07Avffei9bWVlx++eWZNi0pZsyYgRUrVuAvf/kLCgsLtXh5UVER/H5/hq1LnMLCQlM+TX5+PsrKynI2z2b27Nk48cQTcccdd+DCCy/EBx98gMceewyPPfZYpk1LmnPPPRe33347amtrMXToUHz00Ue4++67ccUVV2TatE7T0tKCL774Qnu+fft2bN68GaWlpaitrcWsWbNw2223YeDAgRgwYADmz5+PmpoanH/++ZkzOg5O59SrVy/89Kc/xYcffoiVK1ciHA5r14vS0lJ4PJ5Mme1IvPcpVmi53W5UV1fjmGOO6W5TiWwi08uLUuGBBx4QtbW1wuPxiBNOOEFs2LAh0yYlDQDLx7JlyzJtWtrI9SXIQgjxt7/9TQwbNkx4vV4xaNAg8dhjj2XapJRobm4W1157raitrRU+n08cccQR4n/+539Ee3t7pk3rNG+++abld2fq1KlCCGUZ8vz580VVVZXwer3ijDPOEJ9//nlmjY6D0zlt377d9nrx5ptvZtp0W+K9T7HQEmRCCCGYEDlUWpIgCIIgiMOGnMxJIQiCIAii50MihSAIgiCIrIRECkEQBEEQWQmJFIIgCIIgshISKQRBEARBZCUkUgiCIAiCyEpIpBAEQRAEkZWQSCGILmDhwoUYOXJktx3vsssuy+oKqgRBEMlAxdwIIg7x7sq6YMECLFy40LCtpaUF7e3tKd1T5a233sIPf/hDzYbCwkIcccQROPPMMzF79mz06tVL27epqQlCCBQXF8cd97LLLkNjYyNeeumlpG0jCILoDnL23j0E0V3s2rVL+/vZZ5/FzTffbLjRYEFBgfa3EALhcBgFBQWG7anw+eefIxAIoLm5GR9++CGWLFmCpUuX4q233sLw4cMBKPd4IgiC6GlQuIcg4lBdXa09ioqKwBjTnv/rX/9CYWEhXnnlFYwaNQperxfr1q0zhXvUcMyiRYtQUVGBQCCAq666Ch0dHXGPX1lZierqahx99NGYPHky3n33XVRUVGD69Omm8VWef/55DB8+HH6/H2VlZRg3bhxaW1uxcOFC/OEPf8Bf/vIXMMbAGMNbb70FAJg7dy6OPvpo5OXl4YgjjsD8+fMRDAa1MdVz+r//+z/0798fRUVFmDx5Mg4cOKDtI8sylixZgqOOOgperxe1tbW4/fbbtfadO3fiwgsvRHFxMUpLS/HjH/8YX3/9deJvCkEQhwUkUggiDdx4442488478dlnn2HEiBGW+6xZswafffYZ3nrrLfzxj3/ECy+8gEWLFiV8LL/fj6uuugrvvvsuGhoaTO27du3CRRddhCuuuEI73gUXXAAhBK677jpceOGFOPvss7Fr1y7s2rULJ554IgDlztXLly/H1q1bcd999+Hxxx/HPffcYxj7yy+/xEsvvYSVK1di5cqVWLt2Le68806tfd68ebjzzjsxf/58bN26FStWrEBVVRUAIBgMYvz48SgsLMQ777yDd999FwUFBTj77LM7JdYIgjj8oHAPQaSBW265BWeeeabjPh6PB0888QTy8vIwdOhQ3HLLLbj++utx6623gvPEfi8MGjQIAPD111+jsrLS0LZr1y6EQiFccMEF6NevHwBoYSFAETnt7e2orq429Lvpppu0v/v374/rrrsOzzzzDG644QZtuyzLWL58OQoLCwEAl1xyCdasWYPbb78dBw4cwH333YcHH/z/27mfkGS2MAzgj/SHMpGCCiTCqAYpCKHchOFmwKigINqUixYRtJCgFrkQizbtgrALQRRBK9vUJmoRkRiUQWC2SMoGySKiXNWA2R+5C/nkevN+JXzEcHt+MIuDxzMzrh7O+3r+wuDgIACgrq4ObW1tAFKlsmQyiaWlpXSfz8rKCkpLS+H1emG1WnP6DYjo/48hhegPMJlMn84xGo1Qq9XpcWtrK2RZxvX1dTpMfNWvfvdsTb1GoxGiKKKpqQnt7e2wWq3o6+tDWVnZb9dcW1uD2+2GJEmQZRlvb2/QarUZc2pqatIBBQB0Ol16NycUCiGRSEAUxazrB4NBXF5eZnwfAJ6fnyFJ0ucvTUQ/Dss9RH9ASUnJt94vFAoBSIWGf8vLy8POzg62t7fR2NiI+fl5GAwGRCKR/1zv8PAQNpsNnZ2d2NzcRCAQgNPp/FCGKSgoyBirVCokk0kAqR2a35FlGS0tLTg5Ocm4Li4uMDAw8JXXJqIfhiGF6JsEg0HE4/H02O/3Q6PRoLq6Oqd14vE4FhcXYbFYUFFRkXWOSqWC2WzG9PQ0AoEACgsLsbGxASBVdnp/f8+Yf3BwAL1eD6fTCZPJBEEQcHV1ldNzCYKA4uJi7O7uZv28ubkZ4XAYlZWVqK+vz7j47yQiyoYhheibvLy8YGhoCGdnZ9ja2sLU1BTsdvun/Sj39/e4u7tDOByGx+OB2WxGLBbDwsJC1vlHR0eYmZnB8fExotEo1tfX8fDwgIaGBgCp3ZfT01Ocn58jFovh9fUVgiAgGo3C4/FAkiS43e50qPmqoqIiOBwOTExMYHV1FZIkwe/3Y3l5GQBgs9lQXl6Onp4e7O/vIxKJwOv1YnR0FDc3Nzndi4h+BvakEH0TURQhCAIsFgsSiQT6+/s/HAKXjcFggEqlgkajQW1tLaxWK8bHxz80vv6i1Wrh8/kwNzeHx8dH6PV6zM7OoqOjAwAwPDwMr9cLk8kEWZaxt7eH7u5ujI2NwW63I5FIoKurCy6X60vP908ulwv5+fmYnJzE7e0tdDodRkZGAABqtRo+nw8OhwO9vb14enpCVVUVRFH80PtCRATwxFmib8FTXomIcsdyDxERESkSQwoREREpEss9REREpEjcSSEiIiJFYkghIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRWJIISIiIkX6G12uK9DBfPjXAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -706,7 +802,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.19"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,

From 639724b342f98ee4a8a073db2b8ffcd29afcd85c Mon Sep 17 00:00:00 2001
From: Andong Zhan <andong.zhan@snowflake.com>
Date: Wed, 28 Aug 2024 14:34:23 -0700
Subject: [PATCH 10/11] SNOW-1625379 Test coverage for timedelta under
 modin/integ/frame part 1 (#2171)

<!---
Please answer these questions before creating your pull request. Thanks!
--->

1. Which Jira issue is this PR addressing? Make sure that there is an
accompanying issue to your PR.

   <!---
   In this section, please add a Snowflake Jira issue number.

Note that if a corresponding GitHub issue exists, you should still
include
   the Snowflake Jira issue number. For example, for GitHub issue
https://github.com/snowflakedb/snowpark-python/issues/1400, you should
   add "SNOW-1335071" here.
    --->

Fixes SNOW-1625379 Test coverage for timedelta under modin/integ/frame
part 1

2. Fill out the following pre-review checklist:

- [ ] I am adding a new automated test(s) to verify correctness of my
new code
- [ ] If this test skips Local Testing mode, I'm requesting review from
@snowflakedb/local-testing
   - [ ] I am adding new logging messages
   - [ ] I am adding a new telemetry message
   - [ ] I am adding new credentials
   - [ ] I am adding a new dependency
- [ ] If this is a new feature/behavior, I'm adding the Local Testing
parity changes.

3. Please describe how your code solves the related issue.

Please write a short description of how your code change solves the
related issue.

This pull request includes several changes to enhance support for the
`Timedelta` type, improve type handling, and add new test cases. The
most important changes include adding support for various `Timedelta`
operations, enhancing type checking and handling, and introducing new
test cases to ensure the robustness of these features.

### Enhancements to `Timedelta` Support:

* Added support for `Timedelta` type in various operations like
`fillna`, `diff`, `duplicated`, `empty`, `insert`, `isin`, `isna`,
`items`, `iterrows`, `join`, `len`, `melt`, `nlargest`, and `nsmallest`
in the `CHANGELOG.md` file.
* Removed `NotImplementedError` for `Timedelta` in methods such as
`insert`, `melt`, and `merge` in `snowflake_query_compiler.py`.
[[1]](diffhunk://#diff-834ee069919510e7e410c503a8afa455154c40e65389769c08d35b0ec3f8ec03L5756-L5757)
[[2]](diffhunk://#diff-834ee069919510e7e410c503a8afa455154c40e65389769c08d35b0ec3f8ec03L6631-L6632)
[[3]](diffhunk://#diff-834ee069919510e7e410c503a8afa455154c40e65389769c08d35b0ec3f8ec03L6735-L6736)

### Improvements in Type Handling:

* Introduced `type_match` method in `SnowparkPandasType` class to check
type compatibility.
* Enhanced the `_simple_unpivot` function to handle `SnowparkPandasType`
correctly and added type information for unpivoted columns.
[[1]](diffhunk://#diff-7cb97f6cd7fe8ccd13a0e4f482622edaf6d3e20a4289cef11c394cae56054198R738-R747)
[[2]](diffhunk://#diff-7cb97f6cd7fe8ccd13a0e4f482622edaf6d3e20a4289cef11c394cae56054198R759-R763)
[[3]](diffhunk://#diff-7cb97f6cd7fe8ccd13a0e4f482622edaf6d3e20a4289cef11c394cae56054198L790-R796)
[[4]](diffhunk://#diff-7cb97f6cd7fe8ccd13a0e4f482622edaf6d3e20a4289cef11c394cae56054198R879-R885)
[[5]](diffhunk://#diff-7cb97f6cd7fe8ccd13a0e4f482622edaf6d3e20a4289cef11c394cae56054198L884-R898)
* Updated `fillna` and `diff` methods to maintain `SnowparkPandasType`
consistency after operations.
[[1]](diffhunk://#diff-834ee069919510e7e410c503a8afa455154c40e65389769c08d35b0ec3f8ec03R9789-R9792)
[[2]](diffhunk://#diff-834ee069919510e7e410c503a8afa455154c40e65389769c08d35b0ec3f8ec03L10195-R10205)

### New Test Cases:

* Added test cases for `Timedelta` type in `assign`, `ffill`, `bfill`,
and `diff` methods to ensure proper functionality.
[[1]](diffhunk://#diff-ca5c04609726549052929ac53289f47c80b13355949ba45d714221b5e820b90bR241-R261)
[[2]](diffhunk://#diff-adee223f3478e814786eb931d777565482438add6f27928a38cd03a570c1f847L17-R17)
[[3]](diffhunk://#diff-adee223f3478e814786eb931d777565482438add6f27928a38cd03a570c1f847R34-R54)
[[4]](diffhunk://#diff-61d2953e049081cd075fa2952a7910995e67980403a66f2806e4580f7b1c7defR143-R156)
* Introduced a new test case for `Timedelta` type in `test_compare.py`
to validate comparison operations.
[[1]](diffhunk://#diff-8d1c8c7ca2b331b0e3f36453255ba307ffd88e02a583d4cf2edeef39204ed3e0L28-R31)
[[2]](diffhunk://#diff-8d1c8c7ca2b331b0e3f36453255ba307ffd88e02a583d4cf2edeef39204ed3e0R51)

These changes collectively improve the handling and support of the
`Timedelta` type, ensuring more robust and comprehensive functionality
across various operations.
---
 CHANGELOG.md                                  |  2 +-
 .../modin/plugin/_internal/binary_op_utils.py |  6 +-
 .../modin/plugin/_internal/isin_utils.py      | 10 ++++
 .../modin/plugin/_internal/join_utils.py      | 24 ++++++++
 .../plugin/_internal/snowpark_pandas_types.py | 13 ++++
 .../modin/plugin/_internal/unpivot_utils.py   | 21 +++++--
 .../compiler/snowflake_query_compiler.py      | 32 ++++++----
 tests/integ/modin/data.py                     | 12 +++-
 tests/integ/modin/frame/test_assign.py        | 21 +++++++
 tests/integ/modin/frame/test_bfill_ffill.py   | 23 +++++++-
 tests/integ/modin/frame/test_compare.py       | 15 ++---
 tests/integ/modin/frame/test_diff.py          | 14 +++++
 tests/integ/modin/frame/test_drop.py          | 12 ++++
 tests/integ/modin/frame/test_dropna.py        |  1 +
 tests/integ/modin/frame/test_duplicated.py    | 15 ++++-
 tests/integ/modin/frame/test_empty.py         |  9 ++-
 tests/integ/modin/frame/test_equals.py        |  5 ++
 tests/integ/modin/frame/test_fillna.py        | 17 ++++++
 tests/integ/modin/frame/test_idxmax_idxmin.py | 20 +++++++
 tests/integ/modin/frame/test_insert.py        | 31 ++++++++++
 tests/integ/modin/frame/test_isin.py          | 21 +++++++
 tests/integ/modin/frame/test_items.py         |  1 +
 tests/integ/modin/frame/test_iterrows.py      |  1 +
 tests/integ/modin/frame/test_itertuples.py    |  1 +
 tests/integ/modin/frame/test_join.py          | 20 +++++++
 tests/integ/modin/frame/test_len.py           |  1 +
 tests/integ/modin/frame/test_mask.py          |  9 +++
 tests/integ/modin/frame/test_melt.py          | 16 +++++
 tests/integ/modin/frame/test_merge.py         | 59 +++++++++++++++++++
 .../modin/frame/test_nlargest_nsmallest.py    | 18 ++++++
 tests/integ/modin/series/test_shift.py        |  6 +-
 .../unit/modin/test_snowpark_pandas_types.py  |  7 +++
 32 files changed, 424 insertions(+), 39 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1cf5845439c..ad1c8e9cb95 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -51,7 +51,7 @@
 #### New Features
 
 - Added limited support for the `Timedelta` type, including the following features. Snowpark pandas will raise `NotImplementedError` for unsupported `Timedelta` use cases.
-  - supporting tracking the Timedelta type through `copy`, `cache_result`, `shift`, `sort_index`.
+  - supporting tracking the Timedelta type through `copy`, `cache_result`, `shift`, `sort_index`, `assign`, `bfill`, `ffill`, `fillna`, `compare`, `diff`, `drop`, `dropna`, `duplicated`, `empty`, `equals`, `insert`, `isin`, `isna`, `items`, `iterrows`, `join`, `len`, `mask`, `melt`, `merge`, `nlargest`, `nsmallest`.
   - converting non-timedelta to timedelta via `astype`.
   - `NotImplementedError` will be raised for the rest of methods that do not support `Timedelta`.
   - support for subtracting two timestamps to get a Timedelta.
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py b/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py
index a0ca357c59b..6d79de24ffb 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/binary_op_utils.py
@@ -512,10 +512,8 @@ def are_equal_types(type1: DataType, type2: DataType) -> bool:
     Returns:
         True if given types are equal, False otherwise.
     """
-    if isinstance(type1, TimedeltaType) and not isinstance(type2, TimedeltaType):
-        return False
-    if isinstance(type2, TimedeltaType) and not isinstance(type1, TimedeltaType):
-        return False
+    if isinstance(type1, TimedeltaType) or isinstance(type2, TimedeltaType):
+        return type1 == type2
     if isinstance(type1, _IntegralType) and isinstance(type2, _IntegralType):
         return True
     if isinstance(type1, _FractionalType) and isinstance(type2, _FractionalType):
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/isin_utils.py b/src/snowflake/snowpark/modin/plugin/_internal/isin_utils.py
index 26d50a8d53c..48edba416c6 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/isin_utils.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/isin_utils.py
@@ -14,6 +14,9 @@
 )
 from snowflake.snowpark.modin.plugin._internal.frame import InternalFrame
 from snowflake.snowpark.modin.plugin._internal.indexing_utils import set_frame_2d_labels
+from snowflake.snowpark.modin.plugin._internal.snowpark_pandas_types import (
+    SnowparkPandasType,
+)
 from snowflake.snowpark.modin.plugin._internal.type_utils import infer_series_type
 from snowflake.snowpark.modin.plugin._internal.utils import (
     append_columns,
@@ -100,6 +103,13 @@ def scalar_isin_expression(
             for literal_expr in values
         ]
 
+    # Case 4: If column's and values' data type differs and any of the type is SnowparkPandasType
+    elif values_dtype != column_dtype and (
+        isinstance(values_dtype, SnowparkPandasType)
+        or isinstance(column_dtype, SnowparkPandasType)
+    ):
+        return pandas_lit(False)
+
     values = array_construct(*values)
 
     # to_variant is a requirement for array_contains, else an error is produced.
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/join_utils.py b/src/snowflake/snowpark/modin/plugin/_internal/join_utils.py
index 331901f1a67..846f3c64079 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/join_utils.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/join_utils.py
@@ -172,6 +172,30 @@ def join(
         JoinTypeLit
     ), f"Invalid join type: {how}. Allowed values are {get_args(JoinTypeLit)}"
 
+    def assert_snowpark_pandas_types_match() -> None:
+        """If Snowpark pandas types do not match, then a ValueError will be raised."""
+        left_types = [
+            left.snowflake_quoted_identifier_to_snowpark_pandas_type.get(id, None)
+            for id in left_on
+        ]
+        right_types = [
+            right.snowflake_quoted_identifier_to_snowpark_pandas_type.get(id, None)
+            for id in right_on
+        ]
+        for i, (lt, rt) in enumerate(zip(left_types, right_types)):
+            if lt != rt:
+                left_on_id = left_on[i]
+                idx = left.data_column_snowflake_quoted_identifiers.index(left_on_id)
+                key = left.data_column_pandas_labels[idx]
+                lt = lt if lt is not None else left.get_snowflake_type(left_on_id)
+                rt = rt if rt is not None else right.get_snowflake_type(right_on[i])
+                raise ValueError(
+                    f"You are trying to merge on {type(lt).__name__} and {type(rt).__name__} columns for key '{key}'. "
+                    f"If you wish to proceed you should use pd.concat"
+                )
+
+    assert_snowpark_pandas_types_match()
+
     # Re-project the active columns to make sure all active columns of the internal frame participate
     # in the join operation, and unnecessary columns are dropped from the projected columns.
     left = left.select_active_columns()
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py b/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py
index 4ba43a94c4d..0efa51d0a38 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/snowpark_pandas_types.py
@@ -96,6 +96,13 @@ def get_snowpark_pandas_type_for_pandas_type(
             return _type_to_snowpark_pandas_type[pandas_type]()
         return None
 
+    def type_match(self, value: Any) -> bool:
+        """Return True if the value's type matches self."""
+        val_type = SnowparkPandasType.get_snowpark_pandas_type_for_pandas_type(
+            type(value)
+        )
+        return self == val_type
+
 
 class SnowparkPandasColumn(NamedTuple):
     """A Snowpark Column that has an optional SnowparkPandasType."""
@@ -125,6 +132,12 @@ class TimedeltaType(SnowparkPandasType, LongType):
     def __init__(self) -> None:
         super().__init__()
 
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+    def __ne__(self, other: Any) -> bool:
+        return not self.__eq__(other)
+
     @staticmethod
     def to_pandas(value: int) -> native_pd.Timedelta:
         """
diff --git a/src/snowflake/snowpark/modin/plugin/_internal/unpivot_utils.py b/src/snowflake/snowpark/modin/plugin/_internal/unpivot_utils.py
index 905f2b23c91..9f1ca22180a 100644
--- a/src/snowflake/snowpark/modin/plugin/_internal/unpivot_utils.py
+++ b/src/snowflake/snowpark/modin/plugin/_internal/unpivot_utils.py
@@ -735,12 +735,16 @@ def _simple_unpivot(
     # create the initial set of columns to be retained as identifiers and those
     # which will be unpivoted. Collect data type information.
     unpivot_quoted_columns = []
+    unpivot_quoted_column_types = []
+
     ordering_decode_conditions = []
     id_col_names = []
     id_col_quoted_identifiers = []
-    for (pandas_label, snowflake_quoted_identifier) in zip(
+    id_col_types = []
+    for (pandas_label, snowflake_quoted_identifier, sp_pandas_type) in zip(
         frame.data_column_pandas_labels,
         frame.data_column_snowflake_quoted_identifiers,
+        frame.cached_data_column_snowpark_pandas_types,
     ):
         is_id_col = pandas_label in pandas_id_columns
         is_var_col = pandas_label in pandas_value_columns
@@ -752,9 +756,11 @@ def _simple_unpivot(
                 col(var_quoted) == pandas_lit(pandas_label)
             )
             unpivot_quoted_columns.append(snowflake_quoted_identifier)
+            unpivot_quoted_column_types.append(sp_pandas_type)
         if is_id_col:
             id_col_names.append(pandas_label)
             id_col_quoted_identifiers.append(snowflake_quoted_identifier)
+            id_col_types.append(sp_pandas_type)
 
     # create the case expressions used for the final result set ordering based
     # on the column position. This clause will be appled after the unpivot
@@ -787,7 +793,7 @@ def _simple_unpivot(
                 pandas_labels=[unquoted_col_name],
             )[0]
         )
-        # coalese the values to unpivot and preserve null values This code
+        # coalesce the values to unpivot and preserve null values This code
         # can be removed when UNPIVOT_INCLUDE_NULLS is enabled
         unpivot_columns_normalized_types.append(
             coalesce(to_variant(c), to_variant(pandas_lit(null_replace_value))).alias(
@@ -870,6 +876,13 @@ def _simple_unpivot(
         var_quoted,
         corrected_value_column_name,
     ]
+    corrected_value_column_type = None
+    if len(set(unpivot_quoted_column_types)) == 1:
+        corrected_value_column_type = unpivot_quoted_column_types[0]
+    final_snowflake_quoted_col_types = id_col_types + [
+        None,
+        corrected_value_column_type,
+    ]
 
     # Create the new frame and compiler
     return InternalFrame.create(
@@ -881,8 +894,8 @@ def _simple_unpivot(
         index_column_snowflake_quoted_identifiers=[
             ordered_dataframe.row_position_snowflake_quoted_identifier
         ],
-        data_column_types=None,
-        index_column_types=None,
+        data_column_types=final_snowflake_quoted_col_types,
+        index_column_types=[None],
     )
 
 
diff --git a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
index 7e6336c397e..e13c77f8ec3 100644
--- a/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
+++ b/src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py
@@ -1499,7 +1499,7 @@ def _shift_values_axis_0(
         row_position_quoted_identifier = frame.row_position_snowflake_quoted_identifier
 
         fill_value_dtype = infer_object_type(fill_value)
-        fill_value = pandas_lit(fill_value) if fill_value is not None else None
+        fill_value = None if pd.isna(fill_value) else pandas_lit(fill_value)
 
         def shift_expression_and_type(
             quoted_identifier: str, dtype: DataType
@@ -5757,8 +5757,6 @@ def insert(
         Returns:
             A new SnowflakeQueryCompiler instance with new column.
         """
-        self._raise_not_implemented_error_for_timedelta()
-
         if not isinstance(value, SnowflakeQueryCompiler):
             # Scalar value
             new_internal_frame = self._modin_frame.append_column(
@@ -5848,7 +5846,9 @@ def move_last_element(arr: list, index: int) -> None:
         data_column_snowflake_quoted_identifiers = (
             new_internal_frame.data_column_snowflake_quoted_identifiers
         )
+        data_column_types = new_internal_frame.cached_data_column_snowpark_pandas_types
         move_last_element(data_column_snowflake_quoted_identifiers, loc)
+        move_last_element(data_column_types, loc)
 
         new_internal_frame = InternalFrame.create(
             ordered_dataframe=new_internal_frame.ordered_dataframe,
@@ -5857,8 +5857,8 @@ def move_last_element(arr: list, index: int) -> None:
             data_column_pandas_index_names=new_internal_frame.data_column_pandas_index_names,
             index_column_pandas_labels=new_internal_frame.index_column_pandas_labels,
             index_column_snowflake_quoted_identifiers=new_internal_frame.index_column_snowflake_quoted_identifiers,
-            data_column_types=None,
-            index_column_types=None,
+            data_column_types=data_column_types,
+            index_column_types=new_internal_frame.cached_index_column_snowpark_pandas_types,
         )
         return SnowflakeQueryCompiler(new_internal_frame)
 
@@ -6645,8 +6645,6 @@ def melt(
         Notes:
             melt does not yet handle multiindex or ignore index
         """
-        self._raise_not_implemented_error_for_timedelta()
-
         if col_level is not None:
             raise NotImplementedError(
                 "Snowpark Pandas doesn't support 'col_level' argument in melt API"
@@ -6749,8 +6747,6 @@ def merge(
         Returns:
             SnowflakeQueryCompiler instance with merged result.
         """
-        self._raise_not_implemented_error_for_timedelta()
-
         if validate:
             ErrorMessage.not_implemented(
                 "Snowpark pandas merge API doesn't yet support 'validate' parameter"
@@ -9815,6 +9811,10 @@ def _fillna_with_masking(
 
         # case 2: fillna with a method
         if method is not None:
+            # no Snowpark pandas type change in this case
+            data_column_snowpark_pandas_types = (
+                self._modin_frame.cached_data_column_snowpark_pandas_types
+            )
             method = FillNAMethod.get_enum_for_string_method(method)
             method_is_ffill = method is FillNAMethod.FFILL_METHOD
             if axis == 0:
@@ -9921,6 +9921,7 @@ def fillna_expr(snowflake_quoted_id: str) -> SnowparkColumn:
                 include_index=False,
             )
             fillna_column_map = {}
+            data_column_snowpark_pandas_types = []
             if columns_mask is not None:
                 columns_to_ignore = itertools.compress(
                     self._modin_frame.data_column_pandas_labels,
@@ -9940,10 +9941,18 @@ def fillna_expr(snowflake_quoted_id: str) -> SnowparkColumn:
                                 col(id),
                                 coalesce(id, pandas_lit(val)),
                             )
+                        col_type = self._modin_frame.get_snowflake_type(id)
+                        col_pandas_type = (
+                            col_type
+                            if isinstance(col_type, SnowparkPandasType)
+                            and col_type.type_match(val)
+                            else None
+                        )
+                        data_column_snowpark_pandas_types.append(col_pandas_type)
 
         return SnowflakeQueryCompiler(
             self._modin_frame.update_snowflake_quoted_identifiers_with_expressions(
-                fillna_column_map
+                fillna_column_map, data_column_snowpark_pandas_types
             ).frame
         )
 
@@ -10217,7 +10226,8 @@ def diff(self, periods: int, axis: int) -> "SnowflakeQueryCompiler":
         }
         return SnowflakeQueryCompiler(
             self._modin_frame.update_snowflake_quoted_identifiers_with_expressions(
-                diff_label_to_value_map
+                diff_label_to_value_map,
+                self._modin_frame.cached_data_column_snowpark_pandas_types,
             ).frame
         )
 
diff --git a/tests/integ/modin/data.py b/tests/integ/modin/data.py
index 653e0037e09..35c4d321787 100644
--- a/tests/integ/modin/data.py
+++ b/tests/integ/modin/data.py
@@ -1,6 +1,7 @@
 #
 # Copyright (c) 2012-2024 Snowflake Computing Inc. All rights reserved.
 #
+import pandas as native_pd
 
 RAW_NA_DF_DATA_TEST_CASES = [
     ({"A": [1, 2, 3], "B": [4, 5, 6]}, "numeric-no"),
@@ -16,9 +17,18 @@
     ({"A": [True, 1, "X"], "B": ["Y", 3.14, False]}, "mixed"),
     ({"A": [True, None, "X"], "B": [None, 3.14, None]}, "mixed-mixed-1"),
     ({"A": [None, 1, None], "B": ["Y", None, False]}, "mixed-mixed-2"),
+    (
+        {
+            "A": [None, native_pd.Timedelta(2), None],
+            "B": [native_pd.Timedelta(4), None, native_pd.Timedelta(6)],
+        },
+        "timedelta-mixed-1",
+    ),
 ]
 
 RAW_NA_DF_SERIES_TEST_CASES = [
     (list(df_data.values()), test_case)
-    for (df_data, test_case) in RAW_NA_DF_DATA_TEST_CASES
+    for (df_data, test_case) in RAW_NA_DF_DATA_TEST_CASES[
+        :1
+    ]  # "timedelta-mixed-1" is not json serializable
 ]
diff --git a/tests/integ/modin/frame/test_assign.py b/tests/integ/modin/frame/test_assign.py
index b0da2a110bf..b1677deda8f 100644
--- a/tests/integ/modin/frame/test_assign.py
+++ b/tests/integ/modin/frame/test_assign.py
@@ -238,3 +238,24 @@ def test_overwrite_columns_via_assign():
     eval_snowpark_pandas_result(
         snow_df, native_df, lambda df: df.assign(a=df["b"], last_col=[10, 11, 12])
     )
+
+
+@sql_count_checker(query_count=2, join_count=1)
+def test_assign_basic_timedelta_series():
+    snow_df, native_df = create_test_dfs(
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+        columns=native_pd.Index(list("abc"), name="columns"),
+        index=native_pd.Index([0, 1, 2], name="index"),
+    )
+    native_df.columns.names = ["columns"]
+    native_df.index.names = ["index"]
+
+    native_td = native_pd.timedelta_range("1 day", periods=3)
+
+    def assign_func(df):
+        if isinstance(df, pd.DataFrame):
+            return df.assign(new_col=pd.Series(native_td))
+        else:
+            return df.assign(new_col=native_pd.Series(native_td))
+
+    eval_snowpark_pandas_result(snow_df, native_df, assign_func)
diff --git a/tests/integ/modin/frame/test_bfill_ffill.py b/tests/integ/modin/frame/test_bfill_ffill.py
index 7938fe4059f..504261b80fe 100644
--- a/tests/integ/modin/frame/test_bfill_ffill.py
+++ b/tests/integ/modin/frame/test_bfill_ffill.py
@@ -14,7 +14,7 @@
 
 @pytest.mark.parametrize("func", ["backfill", "bfill", "ffill", "pad"])
 @sql_count_checker(query_count=1)
-def test_df_func(func):
+def test_df_fill(func):
     native_df = native_pd.DataFrame(
         [
             [np.nan, 2, np.nan, 0],
@@ -31,3 +31,24 @@ def test_df_func(func):
         native_df,
         lambda df: getattr(df, func)(),
     )
+
+
+@pytest.mark.parametrize("func", ["backfill", "bfill", "ffill", "pad"])
+@sql_count_checker(query_count=1)
+def test_df_timedelta_fill(func):
+    native_df = native_pd.DataFrame(
+        [
+            [np.nan, 2, np.nan, 0],
+            [3, 4, np.nan, 1],
+            [np.nan, np.nan, np.nan, np.nan],
+            [np.nan, 3, np.nan, 4],
+            [3, np.nan, 4, np.nan],
+        ],
+        columns=list("ABCD"),
+    ).astype("timedelta64[ns]")
+    snow_df = pd.DataFrame(native_df)
+    eval_snowpark_pandas_result(
+        snow_df,
+        native_df,
+        lambda df: getattr(df, func)(),
+    )
diff --git a/tests/integ/modin/frame/test_compare.py b/tests/integ/modin/frame/test_compare.py
index 9a0f7caf88d..c7f0c6f81d4 100644
--- a/tests/integ/modin/frame/test_compare.py
+++ b/tests/integ/modin/frame/test_compare.py
@@ -35,16 +35,10 @@
 def base_df() -> native_pd.DataFrame:
     return native_pd.DataFrame(
         [
-            [None, None, 3.1, pd.Timestamp("2024-01-01"), [130]],
-            [
-                "a",
-                1,
-                4.2,
-                pd.Timestamp("2024-02-01"),
-                [131],
-            ],
-            ["b", 2, 5.3, pd.Timestamp("2024-03-01"), [132]],
-            [None, 3, 6.4, pd.Timestamp("2024-04-01"), [133]],
+            [None, None, 3.1, pd.Timestamp("2024-01-01"), [130], pd.Timedelta(1)],
+            ["a", 1, 4.2, pd.Timestamp("2024-02-01"), [131], pd.Timedelta(11)],
+            ["b", 2, 5.3, pd.Timestamp("2024-03-01"), [132], pd.Timedelta(21)],
+            [None, 3, 6.4, pd.Timestamp("2024-04-01"), [133], pd.Timedelta(13)],
         ],
         index=pd.MultiIndex.from_tuples(
             [
@@ -64,6 +58,7 @@ def base_df() -> native_pd.DataFrame:
                 ("group_2", "float_col"),
                 ("group_2", "timestamp_col"),
                 ("group_2", "list_col"),
+                ("group_2", "timedelta_col"),
             ],
             names=["column_level1", "column_level2"],
         ),
diff --git a/tests/integ/modin/frame/test_diff.py b/tests/integ/modin/frame/test_diff.py
index 26aa5b74c85..185b2eab89e 100644
--- a/tests/integ/modin/frame/test_diff.py
+++ b/tests/integ/modin/frame/test_diff.py
@@ -140,6 +140,20 @@ def test_df_diff_bool_df(periods):
     eval_snowpark_pandas_result(snow_df, native_df, lambda df: df.diff(periods=periods))
 
 
+@sql_count_checker(query_count=1)
+@pytest.mark.parametrize("periods", [0, 1])
+def test_df_diff_timedelta_df(periods):
+    native_df = native_pd.DataFrame(
+        np.arange(NUM_ROWS_TALL_DF * NUM_COLS_TALL_DF).reshape(
+            (NUM_ROWS_TALL_DF, NUM_COLS_TALL_DF)
+        ),
+        columns=["A", "B", "C", "D"],
+    )
+    native_df = native_df.astype({"A": "timedelta64[ns]", "C": "timedelta64[ns]"})
+    snow_df = pd.DataFrame(native_df)
+    eval_snowpark_pandas_result(snow_df, native_df, lambda df: df.diff(periods=periods))
+
+
 @sql_count_checker(query_count=1)
 @pytest.mark.parametrize("periods", [0, 1])
 def test_df_diff_int_and_bool_df(periods):
diff --git a/tests/integ/modin/frame/test_drop.py b/tests/integ/modin/frame/test_drop.py
index e71999dd28d..cc1a1a203d3 100644
--- a/tests/integ/modin/frame/test_drop.py
+++ b/tests/integ/modin/frame/test_drop.py
@@ -70,6 +70,18 @@ def test_drop_list_like(native_df, labels):
     eval_snowpark_pandas_result(snow_df, native_df, lambda df: df.drop(labels, axis=1))
 
 
+@pytest.mark.parametrize(
+    "labels", [Index(["red", "green"]), np.array(["red", "green"])]
+)
+@sql_count_checker(query_count=1)
+def test_drop_timedelta(native_df, labels):
+    native_df_dt = native_df.astype({"red": "timedelta64[ns]"})
+    snow_df = pd.DataFrame(native_df_dt)
+    eval_snowpark_pandas_result(
+        snow_df, native_df_dt, lambda df: df.drop(labels, axis=1)
+    )
+
+
 @pytest.mark.parametrize(
     "labels, axis, expected_query_count",
     [
diff --git a/tests/integ/modin/frame/test_dropna.py b/tests/integ/modin/frame/test_dropna.py
index e5fb2085417..d77c65d055e 100644
--- a/tests/integ/modin/frame/test_dropna.py
+++ b/tests/integ/modin/frame/test_dropna.py
@@ -19,6 +19,7 @@ def test_dropna_df():
             "name": ["Alfred", "Batman", "Catwoman"],
             "toy": [np.nan, "Batmobile", "Bullwhip"],
             "born": [pd.NaT, pd.Timestamp("1940-04-25"), pd.NaT],
+            "dt": [pd.NaT, pd.Timedelta(1), pd.NaT],
         }
     )
 
diff --git a/tests/integ/modin/frame/test_duplicated.py b/tests/integ/modin/frame/test_duplicated.py
index e4c5d594ecc..0eade6af114 100644
--- a/tests/integ/modin/frame/test_duplicated.py
+++ b/tests/integ/modin/frame/test_duplicated.py
@@ -53,11 +53,24 @@ def test_duplicated_with_misspelled_column_name_or_empty_subset(subset):
         (["A"], native_pd.Series([False, False, True, False, True])),
         (["B"], native_pd.Series([False, False, False, True, True])),
         (["A", "B"], native_pd.Series([False, False, False, False, True])),
+        ("C", native_pd.Series([False, False, True, False, True])),
     ],
 )
 @sql_count_checker(query_count=1, join_count=1)
 def test_duplicated_subset(subset, expected):
-    df = pd.DataFrame({"A": [0, 1, 1, 2, 0], "B": ["a", "b", "c", "b", "a"]})
+    df = pd.DataFrame(
+        {
+            "A": [0, 1, 1, 2, 0],
+            "B": ["a", "b", "c", "b", "a"],
+            "C": [
+                pd.Timedelta(1),
+                pd.Timedelta(10),
+                pd.Timedelta(1),
+                pd.Timedelta(0),
+                pd.Timedelta(10),
+            ],
+        }
+    )
 
     result = df.duplicated(subset=subset)
     assert_snowpark_pandas_equal_to_pandas(result, expected)
diff --git a/tests/integ/modin/frame/test_empty.py b/tests/integ/modin/frame/test_empty.py
index 0ed4d2c9fa9..b39a77eae91 100644
--- a/tests/integ/modin/frame/test_empty.py
+++ b/tests/integ/modin/frame/test_empty.py
@@ -16,7 +16,14 @@
 @pytest.mark.parametrize(
     "dataframe_input, test_case_name",
     [
-        ({"A": [1, 2, 3], "B": [4, 5, 6]}, "simple non-empty"),
+        (
+            {
+                "A": [1, 2, 3],
+                "B": [4, 5, 6],
+                "C": native_pd.timedelta_range(1, periods=3),
+            },
+            "simple non-empty",
+        ),
         ({"A": [], "B": []}, "empty column"),
         ({"A": [np.nan]}, "np nan column"),
     ],
diff --git a/tests/integ/modin/frame/test_equals.py b/tests/integ/modin/frame/test_equals.py
index 95b6b8ffd6f..2e2dc2fa129 100644
--- a/tests/integ/modin/frame/test_equals.py
+++ b/tests/integ/modin/frame/test_equals.py
@@ -25,6 +25,11 @@
         ([1, 2, None], [1, 2, None], True),  # nulls are considered equal
         ([1, 2, 3], [1.0, 2.0, 3.0], False),  # float and integer types are not equal
         ([1, 2, 3], ["1", "2", "3"], False),  # integer and string types are not equal
+        (
+            [1, 2, 3],
+            pandas.timedelta_range(1, periods=3),
+            False,  # timedelta and integer types are not equal
+        ),
     ],
 )
 @sql_count_checker(query_count=2, join_count=2)
diff --git a/tests/integ/modin/frame/test_fillna.py b/tests/integ/modin/frame/test_fillna.py
index 189e757c8b2..677c8d3ddc5 100644
--- a/tests/integ/modin/frame/test_fillna.py
+++ b/tests/integ/modin/frame/test_fillna.py
@@ -150,6 +150,23 @@ def test_value_scalar(test_fillna_df):
     )
 
 
+@sql_count_checker(query_count=2)
+def test_timedelta_value_scalar(test_fillna_df):
+    timedelta_df = test_fillna_df.astype("timedelta64[ns]")
+    eval_snowpark_pandas_result(
+        pd.DataFrame(timedelta_df),
+        timedelta_df,
+        lambda df: df.fillna(pd.Timedelta(1)),  # dtype keeps to be timedelta64[ns]
+    )
+
+    # Snowpark pandas dtype will be changed to int in this case
+    eval_snowpark_pandas_result(
+        pd.DataFrame(timedelta_df),
+        test_fillna_df,
+        lambda df: df.fillna(1),
+    )
+
+
 @sql_count_checker(query_count=1)
 def test_value_scalar_none_index(test_fillna_df_none_index):
     # note: none in index should not be filled
diff --git a/tests/integ/modin/frame/test_idxmax_idxmin.py b/tests/integ/modin/frame/test_idxmax_idxmin.py
index f5a8a6d4b85..72fe88968bc 100644
--- a/tests/integ/modin/frame/test_idxmax_idxmin.py
+++ b/tests/integ/modin/frame/test_idxmax_idxmin.py
@@ -194,6 +194,26 @@ def test_idxmax_idxmin_with_dates(func, axis):
     )
 
 
+@sql_count_checker(query_count=1)
+@pytest.mark.parametrize("func", ["idxmax", "idxmin"])
+@pytest.mark.parametrize("axis", [0, 1])
+@pytest.mark.xfail(reason="SNOW-1625380 TODO")
+def test_idxmax_idxmin_with_timedelta(func, axis):
+    native_df = native_pd.DataFrame(
+        data={
+            "date_1": native_pd.timedelta_range(1, periods=3),
+            "date_2": [pd.Timedelta(1), pd.Timedelta(-1), pd.Timedelta(0)],
+        },
+        index=[10, 17, 12],
+    )
+    snow_df = pd.DataFrame(native_df)
+    eval_snowpark_pandas_result(
+        snow_df,
+        native_df,
+        lambda df: getattr(df, func)(axis=axis),
+    )
+
+
 @sql_count_checker(query_count=1)
 @pytest.mark.parametrize("func", ["idxmax", "idxmin"])
 @pytest.mark.parametrize("axis", [0, 1])
diff --git a/tests/integ/modin/frame/test_insert.py b/tests/integ/modin/frame/test_insert.py
index 258d4d2e641..86f5bd8082c 100644
--- a/tests/integ/modin/frame/test_insert.py
+++ b/tests/integ/modin/frame/test_insert.py
@@ -1,6 +1,8 @@
 #
 # Copyright (c) 2012-2024 Snowflake Computing Inc. All rights reserved.
 #
+import functools
+
 import modin.pandas as pd
 import numpy as np
 import pandas as native_pd
@@ -768,3 +770,32 @@ def insert_op(df):
         expected_res = native_df1.join(native_df2["bar"], how="left", sort=False)
         expected_res = expected_res[["bar", "foo"]]
         assert_frame_equal(snow_res, expected_res, check_dtype=False)
+
+
+@sql_count_checker(query_count=4, join_count=6)
+def test_insert_timedelta():
+    native_df = native_pd.DataFrame({"col1": [1, 2], "col2": [3, 4]})
+    snow_df = pd.DataFrame(native_df)
+
+    def insert(column, vals, df):
+        if isinstance(df, pd.DataFrame) and isinstance(vals, native_pd.Series):
+            values = pd.Series(vals)
+        else:
+            values = vals
+        df.insert(1, column, values)
+        return df
+
+    vals = native_pd.timedelta_range(1, periods=2)
+    eval_snowpark_pandas_result(
+        snow_df, native_df, functools.partial(insert, "td", vals)
+    )
+
+    vals = native_pd.Series(native_pd.timedelta_range(1, periods=2))
+    eval_snowpark_pandas_result(
+        snow_df, native_df, functools.partial(insert, "td2", vals)
+    )
+
+    vals = native_pd.Series(native_pd.timedelta_range(1, periods=2), index=[0, 2])
+    eval_snowpark_pandas_result(
+        snow_df, native_df, functools.partial(insert, "td3", vals)
+    )
diff --git a/tests/integ/modin/frame/test_isin.py b/tests/integ/modin/frame/test_isin.py
index c0f0a3ce37b..cd560a5715a 100644
--- a/tests/integ/modin/frame/test_isin.py
+++ b/tests/integ/modin/frame/test_isin.py
@@ -248,3 +248,24 @@ def test_isin_dataframe_values_type_negative():
     ):
         df = pd.DataFrame([1, 2, 3])
         df.isin(values="abcdef")
+
+
+@sql_count_checker(query_count=3)
+@pytest.mark.parametrize(
+    "values",
+    [
+        pytest.param([2, 3], id="integers"),
+        pytest.param([pd.Timedelta(2), pd.Timedelta(3)], id="timedeltas"),
+    ],
+)
+def test_isin_timedelta(values):
+    native_df = native_pd.DataFrame({"a": [1, 2, 3], "b": [None, 4, 2]}).astype(
+        {"b": "timedelta64[ns]"}
+    )
+    snow_df = pd.DataFrame(native_df)
+
+    eval_snowpark_pandas_result(
+        snow_df,
+        native_df,
+        lambda df: _test_isin_with_snowflake_logic(df, values, query_count=1),
+    )
diff --git a/tests/integ/modin/frame/test_items.py b/tests/integ/modin/frame/test_items.py
index d409a0f326a..9cbd4945ee6 100644
--- a/tests/integ/modin/frame/test_items.py
+++ b/tests/integ/modin/frame/test_items.py
@@ -51,6 +51,7 @@ def assert_items_results_equal(snow_result, pandas_result) -> None:
         ),
         native_pd.DataFrame(index=["a"]),
         native_pd.DataFrame(columns=["a"]),
+        native_pd.DataFrame({"ts": native_pd.timedelta_range(10, periods=10)}),
     ],
 )
 def test_items(dataframe):
diff --git a/tests/integ/modin/frame/test_iterrows.py b/tests/integ/modin/frame/test_iterrows.py
index 700d1b4ec27..fc415b2daf5 100644
--- a/tests/integ/modin/frame/test_iterrows.py
+++ b/tests/integ/modin/frame/test_iterrows.py
@@ -53,6 +53,7 @@ def assert_iterators_equal(snowpark_iterator, native_iterator):
         ),
         # empty df
         native_pd.DataFrame([]),
+        native_pd.DataFrame({"ts": native_pd.timedelta_range(10, periods=4)}),
     ],
 )
 def test_df_iterrows(native_df):
diff --git a/tests/integ/modin/frame/test_itertuples.py b/tests/integ/modin/frame/test_itertuples.py
index c3687a939c7..eed33f9e1a4 100644
--- a/tests/integ/modin/frame/test_itertuples.py
+++ b/tests/integ/modin/frame/test_itertuples.py
@@ -37,6 +37,7 @@
     native_pd.DataFrame([[1, 1.5], [2, 2.5], [3, 7.8]], columns=["i nt", "flo at"]),
     # empty df
     native_pd.DataFrame([]),
+    native_pd.DataFrame({"ts": native_pd.timedelta_range(10, periods=10)}),
 ]
 
 
diff --git a/tests/integ/modin/frame/test_join.py b/tests/integ/modin/frame/test_join.py
index 91500189d12..964b6f5426b 100644
--- a/tests/integ/modin/frame/test_join.py
+++ b/tests/integ/modin/frame/test_join.py
@@ -259,3 +259,23 @@ def test_join_validate_negative(lvalues, rvalues, validate):
     msg = "Snowpark pandas merge API doesn't yet support 'validate' parameter"
     with pytest.raises(NotImplementedError, match=msg):
         left.join(right, validate=validate)
+
+
+@sql_count_checker(query_count=6, join_count=2)
+def test_join_timedelta(left, right):
+    right = right.astype("timedelta64[ns]")
+    eval_snowpark_pandas_result(
+        left,
+        left.to_pandas(),
+        lambda df: df.join(
+            right if isinstance(df, pd.DataFrame) else right.to_pandas()
+        ),
+    )
+    left = left.astype("timedelta64[ns]")
+    eval_snowpark_pandas_result(
+        left,
+        left.to_pandas(),
+        lambda df: df.join(
+            right if isinstance(df, pd.DataFrame) else right.to_pandas()
+        ),
+    )
diff --git a/tests/integ/modin/frame/test_len.py b/tests/integ/modin/frame/test_len.py
index 1adeec50caa..d52df4bf567 100644
--- a/tests/integ/modin/frame/test_len.py
+++ b/tests/integ/modin/frame/test_len.py
@@ -16,6 +16,7 @@
         ({"a": []}, 0),
         ({"a": [1, 2]}, 2),
         ({"a": [1, 2], "b": [1, 2], "c": [1, 2]}, 2),
+        ({"td": native_pd.timedelta_range(1, periods=20)}, 20),
     ],
 )
 @sql_count_checker(query_count=1)
diff --git a/tests/integ/modin/frame/test_mask.py b/tests/integ/modin/frame/test_mask.py
index 684d8ba4342..e490f34e905 100644
--- a/tests/integ/modin/frame/test_mask.py
+++ b/tests/integ/modin/frame/test_mask.py
@@ -954,3 +954,12 @@ def perform_mask(df):
         native_df,
         perform_mask,
     )
+
+
+@sql_count_checker(query_count=1)
+def test_mask_timedelta(test_data):
+    native_df = native_pd.DataFrame(test_data, dtype="timedelta64[ns]")
+    snow_df = pd.DataFrame(native_df)
+    eval_snowpark_pandas_result(
+        snow_df, native_df, lambda df: df.mask(df > pd.Timedelta(1))
+    )
diff --git a/tests/integ/modin/frame/test_melt.py b/tests/integ/modin/frame/test_melt.py
index 68d25b1e482..0812bb2c60c 100644
--- a/tests/integ/modin/frame/test_melt.py
+++ b/tests/integ/modin/frame/test_melt.py
@@ -303,3 +303,19 @@ def test_everything():
             value_name="dependent",
         ),
     )
+
+
+@sql_count_checker(query_count=1)
+@pytest.mark.parametrize("value_vars", [["B"], ["B", "C"]])
+def test_melt_timedelta(value_vars):
+    native_df = npd.DataFrame(
+        {
+            "A": {0: "a", 1: "b", 2: "c"},
+            "B": {0: 1, 1: 3, 2: 5},
+            "C": {0: 2, 1: 4, 2: 6},
+        }
+    ).astype({"B": "timedelta64[ns]", "C": "timedelta64[ns]"})
+    snow_df = pd.DataFrame(native_df)
+    eval_snowpark_pandas_result(
+        snow_df, native_df, lambda df: df.melt(id_vars=["A"], value_vars=value_vars)
+    )
diff --git a/tests/integ/modin/frame/test_merge.py b/tests/integ/modin/frame/test_merge.py
index 7ac88042e7f..c1ced99fc67 100644
--- a/tests/integ/modin/frame/test_merge.py
+++ b/tests/integ/modin/frame/test_merge.py
@@ -1156,3 +1156,62 @@ def test_merge_validate_negative(lvalues, rvalues, validate):
     msg = "Snowpark pandas merge API doesn't yet support 'validate' parameter"
     with pytest.raises(NotImplementedError, match=msg):
         left.merge(right, left_on="A", right_on="B", validate=validate)
+
+
+@sql_count_checker(query_count=1, join_count=1)
+def test_merge_timedelta_on():
+    left_df = native_pd.DataFrame(
+        {"lkey": ["foo", "bar", "baz", "foo"], "value": [1, 2, 3, 5]}
+    ).astype({"value": "timedelta64[ns]"})
+    right_df = native_pd.DataFrame(
+        {"rkey": ["foo", "bar", "baz", "foo"], "value": [5, 6, 7, 8]}
+    ).astype({"value": "timedelta64[ns]"})
+    eval_snowpark_pandas_result(
+        pd.DataFrame(left_df),
+        left_df,
+        lambda df: df.merge(
+            pd.DataFrame(right_df) if isinstance(df, pd.DataFrame) else right_df,
+            left_on="lkey",
+            right_on="rkey",
+        ),
+    )
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"how": "inner", "on": "a"},
+        {"how": "right", "on": "a"},
+        {"how": "right", "on": "b"},
+        {"how": "left", "on": "c"},
+        {"how": "cross"},
+    ],
+)
+def test_merge_timedelta_how(kwargs):
+    left_df = native_pd.DataFrame(
+        {"a": ["foo", "bar"], "b": [1, 2], "c": [3, 5]}
+    ).astype({"b": "timedelta64[ns]"})
+    right_df = native_pd.DataFrame(
+        {"a": ["foo", "baz"], "b": [1, 3], "c": [3, 4]}
+    ).astype({"b": "timedelta64[ns]", "c": "timedelta64[ns]"})
+    count = 1
+    expect_exception = False
+    if "c" == kwargs.get("on", None):  # merge timedelta with int exception
+        expect_exception = True
+        count = 0
+
+    with SqlCounter(query_count=count, join_count=count):
+        eval_snowpark_pandas_result(
+            pd.DataFrame(left_df),
+            left_df,
+            lambda df: df.merge(
+                pd.DataFrame(right_df) if isinstance(df, pd.DataFrame) else right_df,
+                **kwargs,
+            ),
+            expect_exception=expect_exception,
+            expect_exception_match="You are trying to merge on LongType and TimedeltaType columns for key 'c'. If you "
+            "wish to proceed you should use pd.concat",
+            expect_exception_type=ValueError,
+            assert_exception_equal=False,  # pandas exception: You are trying to merge on int64 and timedelta64[ns]
+            # columns for key 'c'. If you wish to proceed you should use pd.concat
+        )
diff --git a/tests/integ/modin/frame/test_nlargest_nsmallest.py b/tests/integ/modin/frame/test_nlargest_nsmallest.py
index c32fb64a80e..c528c99d1b0 100644
--- a/tests/integ/modin/frame/test_nlargest_nsmallest.py
+++ b/tests/integ/modin/frame/test_nlargest_nsmallest.py
@@ -2,6 +2,7 @@
 # Copyright (c) 2012-2024 Snowflake Computing Inc. All rights reserved.
 #
 import modin.pandas as pd
+import pandas as native_pd
 import pytest
 
 import snowflake.snowpark.modin.plugin  # noqa: F401
@@ -124,3 +125,20 @@ def test_nlargest_nsmallest_non_numeric_types(method, data):
     n = 2
     expected_df = snow_df.sort_values("A", ascending=(method == "nsmallest")).head(n)
     assert_frame_equal(getattr(snow_df, method)(n, "A"), expected_df)
+
+
+@pytest.mark.parametrize("n", [1, 2, 4])
+@pytest.mark.parametrize("columns", ["A", "B", ["A", "B"], ["B", "A"]])
+@pytest.mark.parametrize("keep", ["first", "last"])
+@sql_count_checker(query_count=1)
+def test_time_delta_nlargest_nsmallest(method, n, columns, keep):
+    native_df = native_pd.DataFrame(
+        {"A": [3, 2, 1, 4, 4], "B": [1, 2, 3, 4, 5]}
+    ).astype("timedelta64[ns]")
+    snow_df = pd.DataFrame(native_df)
+
+    eval_snowpark_pandas_result(
+        snow_df,
+        native_df,
+        lambda df: getattr(df, method)(n, columns=columns, keep=keep),
+    )
diff --git a/tests/integ/modin/series/test_shift.py b/tests/integ/modin/series/test_shift.py
index 7f27c4d313b..f5d4169026e 100644
--- a/tests/integ/modin/series/test_shift.py
+++ b/tests/integ/modin/series/test_shift.py
@@ -46,11 +46,7 @@ def test_series_with_values_shift(series, periods, fill_value):
         lambda s: s.shift(
             periods=periods,
             fill_value=pd.Timedelta(fill_value)
-            if isinstance(
-                s, native_pd.Series
-            )  # pandas does not support fill int to timedelta
-            and s.dtype == "timedelta64[ns]"
-            and fill_value is not no_default
+            if s.dtype == "timedelta64[ns]" and fill_value is not no_default
             else fill_value,
         ),
     )
diff --git a/tests/unit/modin/test_snowpark_pandas_types.py b/tests/unit/modin/test_snowpark_pandas_types.py
index 36d64d164c8..754f031c1a6 100644
--- a/tests/unit/modin/test_snowpark_pandas_types.py
+++ b/tests/unit/modin/test_snowpark_pandas_types.py
@@ -14,6 +14,7 @@
     SnowparkPandasType,
     TimedeltaType,
 )
+from snowflake.snowpark.types import LongType
 
 
 def test_timedelta_type_is_immutable():
@@ -68,3 +69,9 @@ def test_get_snowpark_pandas_type_for_pandas_type(pandas_obj, snowpark_pandas_ty
 )
 def test_TimedeltaType_from_pandas(timedelta, snowpark_pandas_value):
     assert TimedeltaType.from_pandas(timedelta) == snowpark_pandas_value
+
+
+def test_equals():
+    assert TimedeltaType() == TimedeltaType()
+    assert TimedeltaType() != LongType()
+    assert LongType() != TimedeltaType()

From 572d01d4ef576b034514f2f09461cec236b54083 Mon Sep 17 00:00:00 2001
From: Yuyang Wang <yuyang.wang@snowflake.com>
Date: Wed, 28 Aug 2024 15:02:43 -0700
Subject: [PATCH 11/11] SNOW-1549041: Add doc and fix description of function
 ln (#2170)

---
 CHANGELOG.md                        | 1 +
 docs/source/snowpark/functions.rst  | 1 +
 src/snowflake/snowpark/functions.py | 3 ++-
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ad1c8e9cb95..d9bacaafa6f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@
 
 #### Improvements
 
+- Added support for `ln` in `snowflake.snowpark.functions`
 - Added support for specifying the following to `DataFrameWriter.save_as_table`:
   - `enable_schema_evolution`
   - `data_retention_time`
diff --git a/docs/source/snowpark/functions.rst b/docs/source/snowpark/functions.rst
index 9a381e5046a..877b884e7b4 100644
--- a/docs/source/snowpark/functions.rst
+++ b/docs/source/snowpark/functions.rst
@@ -196,6 +196,7 @@ Functions
     length
     listagg
     lit
+    ln
     locate
     log
     lower
diff --git a/src/snowflake/snowpark/functions.py b/src/snowflake/snowpark/functions.py
index 58c2ab8518c..89b2d3aa336 100644
--- a/src/snowflake/snowpark/functions.py
+++ b/src/snowflake/snowpark/functions.py
@@ -5982,7 +5982,8 @@ def vector_inner_product(v1: ColumnOrName, v2: ColumnOrName) -> Column:
 
 
 def ln(c: ColumnOrLiteral) -> Column:
-    """Returns the natrual log product of given column expression
+    """Returns the natrual logarithm of given column expression.
+
     Example::
         >>> from snowflake.snowpark.functions import ln
         >>> from math import e