From 4aa1c4b66bdcd63a384d0968b1fb4079b736bfcd Mon Sep 17 00:00:00 2001
From: shafayetShafee <sshafee@isrt.ac.bd>
Date: Tue, 13 Aug 2024 02:42:42 +0600
Subject: [PATCH 1/6] feat: added support for ATT and ATC

---
 src/skmiscpy/cbs.py | 130 ++++++++++++++++++++++++++++++++++++++++----
 tests/test_smd.py   |  39 ++++++-------
 2 files changed, 138 insertions(+), 31 deletions(-)

diff --git a/src/skmiscpy/cbs.py b/src/skmiscpy/cbs.py
index a3975af..77b64a6 100644
--- a/src/skmiscpy/cbs.py
+++ b/src/skmiscpy/cbs.py
@@ -135,7 +135,9 @@ def _calc_smd_covar(
     wt_var : str, optional
         The column name of the weights. If None, only the unadjusted SMD is calculated. Defaults to None.
     estimand : str, optional
-        The causal estimand to use. Supports only "ATE" (Average Treatment Effect) currently. Defaults to "ATE".
+        The causal estimand to use. Defaults to "ATE" (Average Treatment Effect). Currently supported
+        options are "ATT" (Average Treatment Effect among the Treated) and 
+        "ATC" (Average Treatment Effect among the Control group).
 
     Returns
     -------
@@ -372,20 +374,128 @@ def _calc_smd_cont_covar_ate(m1: float, m0: float, s2_1: float, s2_0: float) ->
     return smd
 
 
-def _calc_smd_bin_covar_att(*args, **kwargs):
-    raise NotImplementedError("SMD for ATT estimand is not yet implemented.")
+def _calc_smd_bin_covar_att(
+    m1: float, m0: float, wt_m1: float = None, wt_m0: float = None
+) -> float:
+    """
+    Calculate the standardized mean difference (SMD) for binary covariates
+    when estimand is the Average Treatment Effect among the Treated group (ATT).
 
+    Parameters
+    ----------
+    m1 : float
+        The mean of the covariate for the treatment group. Must be between 0 and 1.
+    m0 : float
+        The mean of the covariate for the control group. Must be between 0 and 1.
+    wt_m1 : float, optional
+        The weighted mean of the covariate for the treatment group. 
+        If not provided, `m1` is used. Must be between 0 and 1.
+    wt_m0 : float, optional
+        The weighted mean of the covariate for the control group. I
+        f not provided, `m0` is used. Must be between 0 and 1.
 
-def _calc_smd_bin_covar_atc(*args, **kwargs):
-    raise NotImplementedError("SMD for ATC estimand is not yet implemented.")
+    Returns
+    -------
+    float
+        The Standardized Mean Difference (SMD).
+    """
+    wt_m1 = m1 if wt_m1 is None else wt_m1
+    wt_m0 = m0 if wt_m0 is None else wt_m0
+    
+    std_factor = np.sqrt(m1 * (1 - m1))
+
+    smd = _calc_raw_smd(a=wt_m1, b=wt_m0, std_factor=std_factor)
+    return smd
 
 
-def _calc_smd_cont_covar_att(*args, **kwargs):
-    raise NotImplementedError("SMD for ATT estimand is not yet implemented.")
+def _calc_smd_bin_covar_atc(
+    m1: float, m0: float, wt_m1: float = None, wt_m0: float = None
+) -> float:
+    """
+    Calculate the standardized mean difference (SMD) for binary covariates
+    when estimand is the Average Treatment Effect among the Control group (ATC).
+
+    Parameters
+    ----------
+    m1 : float
+        The mean of the covariate for the treatment group. Must be between 0 and 1.
+    m0 : float
+        The mean of the covariate for the control group. Must be between 0 and 1.
+    wt_m1 : float, optional
+        The weighted mean of the covariate for the treatment group. 
+        If not provided, `m1` is used. Must be between 0 and 1.
+    wt_m0 : float, optional
+        The weighted mean of the covariate for the control group. I
+        f not provided, `m0` is used. Must be between 0 and 1.
+
+    Returns
+    -------
+    float
+        The Standardized Mean Difference (SMD).
+    """
+    wt_m1 = m1 if wt_m1 is None else wt_m1
+    wt_m0 = m0 if wt_m0 is None else wt_m0
 
+    std_factor = np.sqrt(m0 * (1 - m0))
 
-def _calc_smd_cont_covar_atc(*args, **kwargs):
-    raise NotImplementedError("SMD for ATC estimand is not yet implemented.")
+    smd = _calc_raw_smd(a=wt_m1, b=wt_m0, std_factor=std_factor)
+    return smd
+
+
+def _calc_smd_cont_covar_att(m1: float, m0: float, s2_1: float, s2_0: float) -> float:
+    """
+    Calculate the standardized mean difference (SMD) for continuous covariates
+    when estimand is the Average Treatment Effect among the Treated group (ATT).
+
+    Parameters
+    ----------
+    m1 : float
+        The mean of the covariate for treated group (group 1).
+    m0 : float
+        The mean of the covariate for control group (group 0).
+    s2_1 : float
+        The variance of the covariate for treated group (group 1). 
+        Must be strictly positive.
+    s2_0 : float
+        The variance of the covariate for control group (group 0). 
+        Must be strictly positive.
+
+    Returns
+    -------
+    float
+        The standardized mean difference (SMD).
+    """
+    std_factor = np.sqrt(s2_1)
+    smd = _calc_raw_smd(a=m1, b=m0, std_factor=std_factor)
+    return smd
+
+
+def _calc_smd_cont_covar_atc(m1: float, m0: float, s2_1: float, s2_0: float) -> float:
+    """
+    Calculate the standardized mean difference (SMD) for continuous covariates
+    when estimand is the Average Treatment Effect among the Control group (ATC).
+
+    Parameters
+    ----------
+    m1 : float
+        The mean of the covariate for treated group (group 1).
+    m0 : float
+        The mean of the covariate for control group (group 0).
+    s2_1 : float
+        The variance of the covariate for treated group (group 1). 
+        Must be strictly positive.
+    s2_0 : float
+        The variance of the covariate for control group (group 0). 
+        Must be strictly positive.
+
+    Returns
+    -------
+    float
+        The standardized mean difference (SMD).
+    """
+    std_factor = np.sqrt(s2_0)
+    smd = _calc_raw_smd(a=m1, b=m0, std_factor=std_factor)
+    return smd
 
 
 def _calc_raw_smd(a: float, b: float, std_factor: float) -> float:
@@ -412,4 +522,4 @@ def _calc_raw_smd(a: float, b: float, std_factor: float) -> float:
     The raw SMD is calculated as the absolute difference between `a` and `b` divided by `std_factor`.
     """
     raw_smd = abs(a - b) / std_factor
-    return raw_smd
+    return raw_smd
\ No newline at end of file
diff --git a/tests/test_smd.py b/tests/test_smd.py
index 19cef92..f185983 100644
--- a/tests/test_smd.py
+++ b/tests/test_smd.py
@@ -316,25 +316,22 @@ def test_compute_smd_invalid_estimand(sample_data):
         )
 
 
-def test_compute_smd_not_implemented_error(sample_data):
-    with pytest.raises(
-        NotImplementedError, match="SMD for ATC estimand is not yet implemented"
-    ):
-        compute_smd(
-            data=sample_data,
-            group="group",
-            vars="binary_var",
-            wt_var="weights",
-            estimand="ATC",
-        )
+def test_compute_smd_att_atc(sample_data):
+    att_smd = _calc_smd_covar(
+        data=sample_data,
+        group="group",
+        covar="cont_var",
+        wt_var="weights",
+        estimand="ATT",
+    )
+    assert isinstance(att_smd, float), "ATT SMD should return a float value"
+
+    atc_smd = _calc_smd_covar(
+        data=sample_data,
+        group="group",
+        covar="binary_var",
+        wt_var="weights",
+        estimand="ATC",
+    )
+    assert isinstance(atc_smd, float), "ATC SMD should return a float value"
 
-    with pytest.raises(
-        NotImplementedError, match="SMD for ATT estimand is not yet implemented"
-    ):
-        compute_smd(
-            data=sample_data,
-            group="group",
-            vars="cont_var",
-            wt_var="weights",
-            estimand="ATT",
-        )

From 9a4e4ff7d421d9cbd02c2b958088972d4cf3937f Mon Sep 17 00:00:00 2001
From: shafayetShafee <sshafee@isrt.ac.bd>
Date: Tue, 13 Aug 2024 03:41:57 +0600
Subject: [PATCH 2/6] doc: extended the tutorial for ATT

---
 docs/example.ipynb | 336 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 326 insertions(+), 10 deletions(-)

diff --git a/docs/example.ipynb b/docs/example.ipynb
index f368806..189e997 100644
--- a/docs/example.ipynb
+++ b/docs/example.ipynb
@@ -34,21 +34,19 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 13,
+            "execution_count": 1,
             "metadata": {},
             "outputs": [],
             "source": [
                 "import pandas as pd\n",
                 "import statsmodels.formula.api as smf\n",
-                "\n",
-                "from skmiscpy import here\n",
                 "from skmiscpy import compute_smd, plot_smd\n",
                 "from skmiscpy import plot_mirror_histogram"
             ]
         },
         {
             "cell_type": "code",
-            "execution_count": 15,
+            "execution_count": 2,
             "metadata": {},
             "outputs": [
                 {
@@ -133,7 +131,7 @@
                             "4   5     543      51    0          42.5"
                         ]
                     },
-                    "execution_count": 15,
+                    "execution_count": 2,
                     "metadata": {},
                     "output_type": "execute_result"
                 }
@@ -160,7 +158,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 16,
+            "execution_count": 3,
             "metadata": {},
             "outputs": [
                 {
@@ -233,7 +231,7 @@
                             "4    0          42.5  0.622325"
                         ]
                     },
-                    "execution_count": 16,
+                    "execution_count": 3,
                     "metadata": {},
                     "output_type": "execute_result"
                 }
@@ -265,7 +263,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 17,
+            "execution_count": 4,
             "metadata": {},
             "outputs": [
                 {
@@ -583,7 +581,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 10,
+            "execution_count": 8,
             "metadata": {},
             "outputs": [
                 {
@@ -622,7 +620,325 @@
             "cell_type": "markdown",
             "metadata": {},
             "source": [
-                "So we can say, using a mosquito net reduces the risk of malaria by 14.7 points, on average across all people in the country."
+                "So we can say, using a mosquito net reduces the risk of malaria by 14.7 points, on average across all people in the country. And this is the estimate of ATE."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now the ATE shows the effect of the net program for everyone, even people who have no need for a net. If we’re interested in making this a universal program, the ATE is useful. But what if we’re interested in what the program is currently doing for the people using it! Then we’d need to find the ATT instead."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "### ATT (Average Treatment Effect among the Treated)\n",
+                "\n",
+                "The generic procedure is as same as above. At first we need to calculate the weights, then check the covariate balance from the data using these weights. If satisfying covariate balance is achieved, proceed to ATT estimation. \n",
+                "\n",
+                "The formula to calculate the weights in case of ATT is,\n",
+                "\n",
+                "$$\n",
+                "w_{ATT} = T_i + \\dfrac{(1- T_i) \\times p_i}{1 - p_i}\n",
+                "$$"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 10,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/html": [
+                            "<div>\n",
+                            "<style scoped>\n",
+                            "    .dataframe tbody tr th:only-of-type {\n",
+                            "        vertical-align: middle;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe tbody tr th {\n",
+                            "        vertical-align: top;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe thead th {\n",
+                            "        text-align: right;\n",
+                            "    }\n",
+                            "</style>\n",
+                            "<table border=\"1\" class=\"dataframe\">\n",
+                            "  <thead>\n",
+                            "    <tr style=\"text-align: right;\">\n",
+                            "      <th></th>\n",
+                            "      <th>id</th>\n",
+                            "      <th>income</th>\n",
+                            "      <th>health</th>\n",
+                            "      <th>net</th>\n",
+                            "      <th>malaria_risk</th>\n",
+                            "      <th>ps</th>\n",
+                            "      <th>wts_att</th>\n",
+                            "    </tr>\n",
+                            "  </thead>\n",
+                            "  <tbody>\n",
+                            "    <tr>\n",
+                            "      <th>0</th>\n",
+                            "      <td>1</td>\n",
+                            "      <td>379</td>\n",
+                            "      <td>56</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>50.1</td>\n",
+                            "      <td>0.393401</td>\n",
+                            "      <td>0.648534</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>1</th>\n",
+                            "      <td>2</td>\n",
+                            "      <td>528</td>\n",
+                            "      <td>39</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>59.4</td>\n",
+                            "      <td>0.427308</td>\n",
+                            "      <td>0.746139</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>2</th>\n",
+                            "      <td>3</td>\n",
+                            "      <td>608</td>\n",
+                            "      <td>54</td>\n",
+                            "      <td>1</td>\n",
+                            "      <td>34.9</td>\n",
+                            "      <td>0.759827</td>\n",
+                            "      <td>1.000000</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>3</th>\n",
+                            "      <td>4</td>\n",
+                            "      <td>265</td>\n",
+                            "      <td>21</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>82.8</td>\n",
+                            "      <td>0.036798</td>\n",
+                            "      <td>0.038204</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>4</th>\n",
+                            "      <td>5</td>\n",
+                            "      <td>543</td>\n",
+                            "      <td>51</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>42.5</td>\n",
+                            "      <td>0.622325</td>\n",
+                            "      <td>1.647782</td>\n",
+                            "    </tr>\n",
+                            "  </tbody>\n",
+                            "</table>\n",
+                            "</div>"
+                        ],
+                        "text/plain": [
+                            "   id  income  health  net  malaria_risk        ps   wts_att\n",
+                            "0   1     379      56    0          50.1  0.393401  0.648534\n",
+                            "1   2     528      39    0          59.4  0.427308  0.746139\n",
+                            "2   3     608      54    1          34.9  0.759827  1.000000\n",
+                            "3   4     265      21    0          82.8  0.036798  0.038204\n",
+                            "4   5     543      51    0          42.5  0.622325  1.647782"
+                        ]
+                    },
+                    "execution_count": 10,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "data_wt_att = (\n",
+                "    data_ps\n",
+                "      .assign(\n",
+                "        wts_att = data_ps['net'] + (1 - data_ps['net']) * data_ps['ps'] / (1 - data_ps['ps'])\n",
+                "    )\n",
+                ")\n",
+                "\n",
+                "data_wt_att.head()\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 11,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAP3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMS5wb3N0MSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8kixA/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABe4ElEQVR4nO3deVxU1f8/8NewzAz7JqsKgigiihamEu6iaH5c6aNpJZp+WkRDUSuyT24laq6poJaCmWZZapmmJrl8XFNT09x3S0AzAUEZEM7vD3/cryMDzAwDMwOv5+Mxj5pzz733PWfGmTfnnHuuTAghQERERGSGLIwdABEREZG+mMgQERGR2WIiQ0RERGaLiQwRERGZLSYyREREZLaYyBAREZHZYiJDREREZouJDBEREZktJjJERERktpjIaGHKlCmQyWTVcq5OnTqhU6dO0vPdu3dDJpPh22+/rZbzDxs2DA0aNKiWc+krNzcXI0eOhJeXF2QyGcaOHWvskExeamoqZDIZrl27ZuxQzEp1ttuwYcNgb29f5eepLk9/l+m6b7NmzQwbkI6q83u/qslkMkyZMsWgx6zM+2totS6RKfliKnkolUr4+PggKioKn376Ke7fv2+Q89y6dQtTpkzBiRMnDHI8QzLl2LQxY8YMpKam4q233sLq1avx6quvllm3QYMGau+3h4cH2rdvj40bN1ZjxKYpKSkJqampBj/unTt3EBcXhyZNmsDGxgYeHh5o3bo13n33XeTm5hr8fObkwYMHmDJlCnbv3m2U88+ePRsymQzHjx9XKxdCwMXFBTKZDFevXlXblp+fD4VCgSFDhlRnqFoxhe+yYcOGqX3HODo6okWLFpg7dy5UKpXR4jKEM2fOYMqUKab/B5CoZVJSUgQAMW3aNLF69WqxcuVKMWPGDNG9e3chk8mEn5+fOHnypNo+hYWF4uHDhzqd58iRIwKASElJ0Wk/lUolVCqV9HzXrl0CgFi/fr1Ox9E3toKCApGfn2+wc1WFNm3aiIiICK3q+vn5iZYtW4rVq1eL1atXi1mzZomAgAABQCQnJ1dxpKbj0aNH4uHDh6K4uFgqCwkJER07djToee7evSt8fX2Fs7OziI+PF8uXLxeJiYli8ODBwsHBQVy9etWg56tqmtqtMu7cuSMAiMmTJ5faFhMTI+zs7AxynrLs379fABCffvqpWvmpU6cEAGFlZSVWr16ttm3v3r0CgFiyZIlO53r6u0wXHTt2FCEhIRXW0/d7VhuTJ08W2vxExsTECIVCIX3HLFq0SHTq1EkAEIMGDTJ4XPoo6zNXkfXr1wsAYteuXaW2Veb9NTQrYyRPpqBnz55o1aqV9DwhIQG//PIL/vWvf6FPnz44e/YsbGxsAABWVlawsqrapnrw4AFsbW0hl8ur9DwVsba2Nur5tXH79m00bdpU6/p169bFK6+8Ij0fOnQoAgMDMX/+fLz55psa93n06BGKi4uN/n4YiqWlJSwtLav8PCtWrMCNGzewf/9+PP/882rbcnJyqrU98/LyYGdnV6ljVFe7VZdWrVpBqVRi3759GDNmjFS+f/9+uLm5oVWrVti3b5/av5d9+/YBANq1a6fTuWrKvx1tWFlZqbXZqFGj0KZNG3z99deYN28efHx8jBhd1TCl97fWDS2Vp0uXLvjvf/+L69ev48svv5TKNY2V/vzzz2jXrh2cnZ1hb2+PoKAgvP/++wAez2t57rnnAADDhw+XuhxLuvFLxn+PHTuGDh06wNbWVtq3rHHHoqIivP/++/Dy8oKdnR369OmDmzdvqtVp0KABhg0bVmrfJ49ZUWya5sjk5eVh/PjxqF+/PhQKBYKCgjBnzhyIp26cLpPJMHr0aGzatAnNmjWDQqFASEgItm3bprnBn3L79m2MGDECnp6eUCqVaNGiBVatWiVtL5kvdPXqVWzZskWKXdduTy8vLwQHB0td6NeuXYNMJsOcOXOwYMECNGzYEAqFAmfOnAEA/PLLL2jfvj3s7Ozg7OyMvn374uzZs2rHLPmMnDt3DgMHDoSjoyPc3NwQFxeH/Pz8UjF8+eWXCAsLg42NDVxdXfHSSy+Vej9LPidnzpxB586dYWtri7p162L27Nmljrdo0SKEhITA1tYWLi4uaNWqFdauXSttf3quR4MGDfDHH39gz549Ujt26tQJV65cgUwmw/z580ud48CBA5DJZPjqq6/KbNvLly/D0tISbdu2LbXN0dERSqVSrezw4cN44YUX4OLiAjs7O4SGhmLhwoVqdXRp/zNnzmDIkCFwcXFR++HVpr010TRHpkGDBvjXv/6Fffv2oXXr1lAqlQgICMAXX3xR7rGuXbsGd3d3AMDUqVOldn967sJff/2Ffv36wd7eHu7u7pgwYQKKiorU6hQXF2PBggUICQmBUqmEp6cn3njjDdy7d6/cGORyOZ577jns379frXz//v0IDw9HRESExm3Ozs7SnBVtz63pu+z69evo06cP7Ozs4OHhgXHjxmH79u2QyWQah9vK++xX9F0GPP589ejRA05OTrC1tUXHjh1LvT7gcbL23HPPQalUomHDhli2bFm57VgRCwsL6bWXfHYq+n4rqVvyXTR//nz4+fnBxsYGHTt2xOnTp9XqlvVboc08x+vXr2PUqFEICgqCjY0N3Nzc8O9//1vtc56amop///vfAIDOnTtL7VvyPmk6v66vcfny5dL37XPPPYcjR46UG3eZjN0lVN1KhpaOHDmicfvNmzcFAPHiiy9KZU93MZ4+fVrI5XLRqlUrsXDhQrF06VIxYcIE0aFDByGEEBkZGWLatGkCgHj99delLsfLly8LIR53m3p5eQl3d3cxZswYsWzZMrFp0yZp25Pd/SVDS82bNxehoaFi3rx54r333hNKpVI0btxYPHjwQKrr5+cnYmJiSr2mJ49ZUWwxMTHCz89P2re4uFh06dJFyGQyMXLkSLF48WLRu3dvAUCMHTtW7TwARIsWLYS3t7eYPn26WLBggQgICBC2trbi77//Lvd9efDggQgODhbW1tZi3Lhx4tNPPxXt27cXAMSCBQuk2FevXi3q1KmjNlyUm5tb5nH9/PxEr1691MoKCgqEp6en8PLyEkIIcfXqVQFANG3aVAQEBIiZM2eK+fPni+vXr4uff/5ZWFlZicaNG4vZs2eLqVOnijp16ggXFxe1YZKSz0jz5s1F7969xeLFi8Urr7wiAIhXX31V7fwfffSRkMlkYtCgQSIpKUk6ZoMGDcS9e/fU3jcfHx9Rv359ERcXJ5KSkkSXLl0EALF161ap3vLly6XP7LJly8TChQvFiBEjxNtvvy3VKfncl8S8ceNGUa9ePdGkSROpHXfs2CGEECIiIkKEhYWVastRo0YJBwcHkZeXV2Z7z5gxQwAQqampZdYpsWPHDiGXy4Wfn5+YPHmySE5OFm+//baIjIyU6uja/k2bNhV9+/YVSUlJ0lCItu2tydPtJsTjz1RQUJDw9PQU77//vli8eLF49tlnhUwmE6dPny7zWLm5uSI5OVkAEP3795favWQoOyYmRiiVShESEiJee+01kZycLKKjowUAkZSUpHaskSNHCisrK/Gf//xHLF26VLz77rvCzs5OPPfcc6KgoKDc15SQkFDqNQUEBIgZM2aInTt3CplMJrVLcXGxcHFxET179tT53E9/l+Xm5oqAgABhY2Mj3nvvPbFgwQLRunVr0aJFi1LDF9p89iv6LktLSxNyuVyEh4eLuXPnivnz54vQ0FAhl8vF4cOHpXP9/vvvwsbGRvj6+orExEQxffp04enpKUJDQ7UeWtI0JNi/f38BQJw7d06r7zch/u+7qHnz5qJBgwZi1qxZYurUqcLV1VW4u7uLjIyMMtv3yXie/A4XovTQ0vr160WLFi3Ehx9+KJYvXy7ef/994eLiIvz8/KR/35cvXxZvv/22ACDef/99qX1LYnj6/Lq+xmeeeUYEBgaKWbNmidmzZ4s6deqIevXqVfj51YSJjAZOTk7imWeekZ4/ncjMnz9fABB37twp8xjljd127NhRABBLly7VuE1TIlO3bl2Rk5MjlX/zzTcCgFi4cKFUpk0iU1FsT/8j2LRpkwAgPvroI7V6L774opDJZOLSpUtSGQAhl8vVyk6ePCkAiEWLFpU615MWLFggAIgvv/xSKisoKBDh4eHC3t5e7bVrSk7K4ufnJ7p37y7u3Lkj7ty5I06ePCleeuklAUCMGTNGCPF//7AcHR3F7du31fZv2bKl8PDwEHfv3lV7TRYWFmLo0KFSWclnpE+fPmr7jxo1SgCQfqyuXbsmLC0txccff6xW79SpU8LKykqtvORz8sUXX0hlKpVKeHl5iejoaKmsb9++Fc4n0PSDXNYcmWXLlgkA4uzZs1JZQUGBqFOnjsbP15MyMjKEu7u7ACCaNGki3nzzTbF27VqRlZWlVu/Ro0fC399f+Pn5lUomnpyPomv7Dx48WO1YurS3JmUlMgDE3r17pbLbt28LhUIhxo8fX+7xKpojg/8/f+9JzzzzjFpi+b///U8AEGvWrFGrt23bNo3lT9uyZYsAIM2FSU9PFwDEnj17xP3794WlpaXYsmWLEOLxH20ApHbS5dxPf+/MnTtXAJD+aBNCiIcPH4omTZpoTGS0+eyX9V1WXFwsGjVqJKKiotQ+Tw8ePBD+/v6iW7duUlm/fv2EUqkU169fl8rOnDkjLC0tdUpkSr5jLl26JGbMmCFkMpkIDQ0VQmj//VbyXWRjYyP+/PNPqe7hw4cFADFu3Lgy2/fJeCpKZJ78A7jEwYMHS7V5eXNknj6/rq/Rzc1N/PPPP1Ld77//XgAQmzdvLnWuinBoSQN7e/tyr15ydnYGAHz//fcoLi7W6xwKhQLDhw/Xuv7QoUPh4OAgPX/xxRfh7e2NrVu36nV+bW3duhWWlpZ4++231crHjx8PIQR++ukntfLIyEg0bNhQeh4aGgpHR0dcuXKlwvN4eXlh8ODBUpm1tTXefvtt5ObmYs+ePXq/hh07dsDd3R3u7u5o0aIF1q9fj1dffRWzZs1SqxcdHS11/QNAeno6Tpw4gWHDhsHV1VXtNXXr1k1j28fGxqo9L5mHUFJ3w4YNKC4uxsCBA/H3339LDy8vLzRq1Ai7du1S29/e3l5t7F0ul6N169Zq7ens7Iw///xT/27ZpwwcOBBKpRJr1qyRyrZv346///5bLRZNPD09cfLkSbz55pu4d+8eli5diiFDhsDDwwPTp0+XhiOPHz+Oq1evYuzYsdK/pxIlw7j6tP/Tc550bW9tNW3aFO3bt5eeu7u7IygoqMLPuTaefg3t27dXO+769evh5OSEbt26qb2msLAw2NvbV/iann/+eVhYWEhzX/bv3w9ra2s899xzsLe3R2hoqDT8UvLfkmG6ypx727ZtqFu3Lvr06SOVKZVK/Oc//9FYX5vPfllOnDiBixcvYsiQIbh7964UZ15eHrp27Yq9e/eiuLgYRUVF2L59O/r16wdfX19p/+DgYERFRVV4nhJ5eXnSd0xgYCDef/99hIeHS1dH6vr91q9fP9StW1d63rp1a7Rp08Zg3/cl8z8BoLCwEHfv3kVgYCCcnZ3x22+/6XVMXV/joEGD4OLiIj0v+fekz7+hWjvZtzy5ubnw8PAoc/ugQYPw+eefY+TIkXjvvffQtWtXDBgwAC+++CIsLLTLDevWravTZKlGjRqpPZfJZAgMDKzyy+KuX78OHx8ftSQKePwPvWT7k578Mijh4uJS4dj99evX0ahRo1LtV9Z5dNGmTRt89NFHkMlksLW1RXBwcKkfTwDw9/cvFRMABAUFlaobHByM7du3l5pQ+vT71LBhQ1hYWEjv08WLFyGEKFWvxNOTrevVq1dqfpaLiwt+//136fm7776LnTt3onXr1ggMDET37t0xZMgQREREaDxHRZydndG7d2+sXbsW06dPBwCsWbMGdevWRZcuXSrc39vbG8nJyUhKSsLFixexfft2zJo1Cx9++CG8vb0xcuRIXL58GQDKXStEn/Z/+j3Utb21pe/nvCJKpVItmdZ03IsXLyI7O7vM76jbt2+Xew5nZ2eEhISoJSvPPPOM9OP2/PPPq20rSSAqe+7r16+jYcOGpT7PgYGBGutr89kvy8WLFwEAMTExZdbJzs6GSqXCw4cPNX4+goKCtE4clEolNm/eDODxH6n+/v6oV6+etF3X7zdN8TRu3BjffPONVvFU5OHDh0hMTERKSgr++usvtfmO2dnZeh1T19f49L+hkqRGn39DTGSe8ueffyI7O7vMf1zA42x279692LVrF7Zs2YJt27bh66+/RpcuXbBjxw6trnJ4MiM2lLIWbyoqKqq2Ky/KOs+T/1CqW506dRAZGVlhvep4T4qLiyGTyfDTTz9pbKunF0TTpj2Dg4Nx/vx5/Pjjj9i2bRu+++47JCUl4cMPP8TUqVP1invo0KFYv349Dhw4gObNm+OHH37AqFGjtE7UgcevvXHjxmjcuDF69eqFRo0aYc2aNRg5cqReMWnj6fdQ1/bWVlV9zrX5d1pcXAwPDw+1HrMnPZ0IadKuXTssXboUWVlZpa4we/7557Fy5UoUFhZi3759CAsLkyZpG+Lc2qpMG5f0lH/yySdo2bKlxjr29vYGW+fF0tJSq+8YQ5LJZBrb4umJ4ZqMGTMGKSkpGDt2LMLDw+Hk5ASZTIaXXnpJ71EGXRny3xATmaesXr0aACrsVrSwsEDXrl3RtWtXzJs3DzNmzMCkSZOwa9cuREZGGnxFyJK/MEoIIXDp0iWEhoZKZS4uLsjKyiq17/Xr1xEQECA91yU2Pz8/7Ny5E/fv31frlTl37py03RD8/Pzw+++/o7i4WO3H0tDn0TUmADh//nypbefOnUOdOnVKXd578eJFtV6BS5cuobi4WLqKoGHDhhBCwN/fH40bNzZYrHZ2dhg0aBAGDRqEgoICDBgwAB9//DESEhJKXSlUorzPQY8ePeDu7o41a9agTZs2ePDgQbkLD1YkICAALi4uSE9PBwBp+PH06dNl/gDo0/5Pq6r21pchvhcaNmyInTt3IiIiQu/ku127dkhOTsbOnTtx/PhxTJw4Udr2/PPP4+HDh9iyZQuuXLmC6Ohog5zbz88PZ86cgRBCrR0uXbqk12sAym7Pks+Xo6NjuQmGu7s7bGxsSn2/Apo/d/rS9ftNUzwXLlxQuxrJxcVF4zCMNr3X3377LWJiYjB37lypLD8/v9Tvh66/Fcb6DuccmSf88ssvmD59Ovz9/fHyyy+XWe+ff/4pVVaS9Zdk+CVfsJoSC3188cUXavN2vv32W6Snp6Nnz55SWcOGDXHo0CEUFBRIZT/++GOpy0x1ie2FF15AUVERFi9erFY+f/58yGQytfNXxgsvvICMjAx8/fXXUtmjR4+waNEi2Nvbo2PHjgY5jy68vb3RsmVLrFq1Sq2tTp8+jR07duCFF14otc+SJUvUni9atAgApHYaMGAALC0tMXXq1FJ/eQghcPfuXZ3jfHofuVyOpk2bQgiBwsLCMvezs7Mr8zNgZWWFwYMH45tvvkFqaiqaN2+uljSX5fDhw8jLyytV/uuvv+Lu3bvSMNGzzz4Lf39/LFiwoFQMJe2iT/s/rSrauzJsbW0BVO57YeDAgSgqKpKG/Z706NEjrY5dMudl3rx5KCwsVOuRadCgAby9vaVLnZ+8jL0y546KisJff/2FH374QSrLz8/HZ599VmG8ZSnruywsLAwNGzbEnDlzNK4mfefOHQCPewWioqKwadMm3LhxQ9p+9uxZbN++Xe+4nqbr99umTZvw119/Sc9//fVXHD58uNT3/blz56TXAgAnT57UeHn50ywtLUv9e1i0aFGp3hxdfyuM9R1ea3tkfvrpJ5w7dw6PHj1CZmYmfvnlF/z888/w8/PDDz/8UOZfsQAwbdo07N27F7169YKfnx9u376NpKQk1KtXT/pH37BhQzg7O2Pp0qVwcHCAnZ0d2rRpU2oMX1uurq5o164dhg8fjszMTCxYsACBgYFqE+VGjhyJb7/9Fj169MDAgQNx+fJlfPnll2qTb3WNrXfv3ujcuTMmTZqEa9euoUWLFtixYwe+//57jB07ttSx9fX6669j2bJlGDZsGI4dO4YGDRrg22+/xf79+7FgwYJSc3SqyyeffIKePXsiPDwcI0aMwMOHD7Fo0SI4OTlpvHfJ1atX0adPH/To0QMHDx7El19+iSFDhqBFixYAHrf9Rx99hISEBFy7dg39+vWDg4MDrl69io0bN+L111/HhAkTdIqxe/fu8PLyQkREBDw9PXH27FksXrwYvXr1KrfdwsLCkJycjI8++giBgYHw8PBQmwMzdOhQfPrpp9i1a1epidFlWb16NdasWYP+/fsjLCwMcrkcZ8+excqVK6FUKqX1kiwsLJCcnIzevXujZcuWGD58OLy9vXHu3Dn88ccf0o+Iru3/tKpo78qwsbFB06ZN8fXXX6Nx48ZwdXVFs2bNdLqvUMeOHfHGG28gMTERJ06cQPfu3WFtbY2LFy9i/fr1WLhwIV588cVyj+Hr64v69evj4MGDaNCgQakF255//nl89913kMlkanOtKnPuN954A4sXL8bgwYMRFxcHb29vrFmzRvqu1ae3qrzvss8//xw9e/ZESEgIhg8fjrp16+Kvv/7Crl274OjoKM1pmTp1KrZt24b27dtj1KhR0o9vSEiIVvNxtKHr91tgYCDatWuHt956CyqVCgsWLICbmxveeecdqc5rr72GefPmISoqCiNGjMDt27exdOlShISEICcnp9x4/vWvf2H16tVwcnJC06ZNcfDgQezcuRNubm5q9Vq2bAlLS0vMmjUL2dnZUCgU6NKli8Y5Ukb9Dtf5OiczV3I5ZclDLpcLLy8v0a1bN7Fw4UK1y3xLPH35dVpamujbt6/w8fERcrlc+Pj4iMGDB4sLFy6o7ff999+Lpk2bCisrK7VLBMtbfrusy6+/+uorkZCQIDw8PISNjY3o1auX2uWCJebOnSvq1q0rFAqFiIiIEEePHtV4mV5ZsWm6dO/+/fti3LhxwsfHR1hbW4tGjRqJTz75pNSy7QBEbGxsqZjKuiz8aZmZmWL48OGiTp06Qi6Xi+bNm2u8RFzXy68rqltyOeAnn3yicfvOnTtFRESEsLGxEY6OjqJ3797izJkzanVKPiNnzpwRL774onBwcBAuLi5i9OjRGm9v8d1334l27doJOzs7YWdnJ5o0aSJiY2PF+fPnpTplfU6efo+WLVsmOnToINzc3IRCoRANGzYUEydOFNnZ2VIdTZcRZ2RkiF69egkHBwcBQOOlnCEhIcLCwkLtUtDy/P7772LixIni2WefFa6ursLKykp4e3uLf//73+K3334rVX/fvn2iW7duwsHBQdjZ2YnQ0NBSl+rr0v5lLYmgTXtrUtbl15o+U2VdDvu0AwcOiLCwMCGXy9Uuiy1rPZKylspfvny5CAsLEzY2NsLBwUE0b95cvPPOO+LWrVsVxiCEEIMHDxYAxJAhQ0ptmzdvngAggoODNe6rzbk1tceVK1dEr169hI2NjXB3dxfjx48X3333nQAgDh06pLavNp99Icr+LhNCiOPHj4sBAwZI/zb8/PzEwIEDRVpamtox9uzZI70nAQEBYunSpTrdokCbW0to8/325HfR3LlzRf369YVCoRDt27cvdescIYT48ssvRUBAgJDL5aJly5Zi+/btWl1+fe/ePSkWe3t7ERUVJc6dO6fxu/qzzz4TAQEB0uXoJZdia3p/dX2NT3s6Tm3J/v/ORFQJU6ZMwdSpU3Hnzh3UqVPH2OEYzDPPPANXV1ekpaUZOxSqoRYsWIBx48bhzz//VLvkuDa6du0a/P398cknn1RrT6G54xwZItLo6NGjOHHiBIYOHWrsUKiGePjwodrz/Px8LFu2DI0aNar1SQzpr9bOkSEizU6fPo1jx45h7ty58Pb2xqBBg4wdEtUQAwYMgK+vL1q2bIns7Gx8+eWXOHfuXJmXcxNpg4kMEan59ttvMW3aNAQFBeGrr74qd+I7kS6ioqLw+eefY82aNSgqKkLTpk2xbt06JstUKUadI1Myr+BJQUFB0nXn+fn5GD9+PNatWweVSoWoqCgkJSXB09PTGOESERGRiTH6HJmQkBCkp6dLj5L7fwDAuHHjsHnzZqxfvx579uzBrVu3MGDAACNGS0RERKbE6ENLVlZW8PLyKlWenZ2NFStWYO3atdLaFikpKQgODsahQ4fQtm3b6g6ViIiITIzRE5mLFy/Cx8cHSqUS4eHhSExMhK+vL44dO4bCwkK15aWbNGkCX19fHDx4sMxERqVSqd0/o7i4GP/88w/c3NwMftsAIiIiqhpCCNy/fx8+Pj7l3ufNqIlMmzZtkJqaiqCgIKSnp2Pq1Klo3749Tp8+jYyMDMjl8lJ3Kfb09ERGRkaZx0xMTNT7RnlERERkWm7evKl2N/GnGTWRefK+EaGhoWjTpg38/PzwzTff6H0ztISEBMTHx0vPs7Oz4evri5s3b8LR0bHSMRMREVHVy8nJQf369Su8vYHRh5ae5OzsjMaNG+PSpUvo1q0bCgoKkJWVpdYrk5mZqXFOTQmFQgGFQlGq3NHRkYkMERGRmaloWojRr1p6Um5uLi5fvgxvb2+EhYXB2tpabWn08+fP48aNGwgPDzdilERERGQqjNojM2HCBPTu3Rt+fn64desWJk+eDEtLSwwePBhOTk4YMWIE4uPj4erqCkdHR4wZMwbh4eG8YomIiIgAGDmR+fPPPzF48GDcvXsX7u7uaNeuHQ4dOgR3d3cAwPz582FhYYHo6Gi1BfGIiIiIACOv7FsdcnJy4OTkhOzs7HLnyBQVFaGwsLAaIyNtyOXyci+7IyKimknb32+TmuxrDEIIZGRkICsry9ihkAYWFhbw9/eHXC43dihERGSCan0iU5LEeHh4wNbWlovmmZDi4mLcunUL6enp8PX15XtDRESl1OpEpqioSEpi3NzcjB0OaeDu7o5bt27h0aNHsLa2NnY4RERkYmr15IOSOTG2trZGjoTKUjKkVFRUZORIiIjIFNXqRKYEhyxMF98bIiIqDxMZIiIiMltMZIiIiMhsMZHR4EFBUbU/dJWRkYG4uDgEBgZCqVTC09MTERERSE5OxoMHD6qgVQwjPz8fsbGxcHNzg729PaKjo5GZmWnssIiIyEzV6quWytPr88PVdq4tI9voVP/KlSuIiIiAs7MzZsyYgebNm0OhUODUqVNYvnw56tatiz59+mjct7Cw0KhX/4wbNw5btmzB+vXr4eTkhNGjR2PAgAHYv3+/0WIiIiLzxR4ZMzRq1ChYWVnh6NGjGDhwIIKDgxEQEIC+fftiy5Yt6N27t1RXJpMhOTkZffr0gZ2dHT7++GMAQHJyMho2bAi5XI6goCCsXr1a2ufatWuQyWQ4ceKEVJaVlQWZTIbdu3cDAHbv3g2ZTIYtW7YgNDQUSqUSbdu2xenTp8uMOzs7GytWrMC8efPQpUsXhIWFISUlBQcOHMChQ4cM20hERFQrMJExM3fv3sWOHTsQGxsLOzs7jXWevtJnypQp6N+/P06dOoXXXnsNGzduRFxcHMaPH4/Tp0/jjTfewPDhw7Fr1y6d45k4cSLmzp2LI0eOwN3dHb179y7zVg/Hjh1DYWEhIiMjpbImTZrA19cXBw8e1PncRERETGTMzKVLlyCEQFBQkFp5nTp1YG9vD3t7e7z77rtq24YMGYLhw4cjICAAvr6+mDNnDoYNG4ZRo0ahcePGiI+Px4ABAzBnzhyd45k8eTK6deuG5s2bY9WqVcjMzMTGjRs11s3IyIBcLoezs7NauaenJzIyMnQ+NxEREROZGuLXX3/FiRMnEBISApVKpbatVatWas/Pnj2LiIgItbKIiAicPXtW5/OGh4dL/+/q6oqgoCC9jkNERKQPTvY1M4GBgZDJZDh//rxaeUBAAADAxsam1D5lDUGVpeRu00/eGN0Qdwb38vJCQUEBsrKy1HplMjMz4eXlVenjExFR7cMeGTPj5uaGbt26YfHixcjLy9PrGMHBwaWuEtq/fz+aNm0K4PH9jQAgPT1d2v7kxN8nPTlJ9969e7hw4QKCg4M11g0LC4O1tTXS0tKksvPnz+PGjRtqPTtERETaYo+MGUpKSkJERARatWqFKVOmIDQ0FBYWFjhy5AjOnTuHsLCwcvefOHEiBg4ciGeeeQaRkZHYvHkzNmzYgJ07dwJ43KvTtm1bzJw5E/7+/rh9+zY++OADjceaNm0a3Nzc4OnpiUmTJqFOnTro16+fxrpOTk4YMWIE4uPj4erqCkdHR4wZMwbh4eFo27ZtpdqEiIhqJyYyZqhhw4Y4fvw4ZsyYgYSEBPz5559QKBRo2rQpJkyYgFGjRpW7f79+/bBw4ULMmTMHcXFx8Pf3R0pKCjp16iTVWblyJUaMGIGwsDAEBQVh9uzZ6N69e6ljzZw5E3Fxcbh48SJatmyJzZs3Szd61GT+/PmwsLBAdHQ0VCoVoqKikJSUpHdbEBFR7SYTT06EqIFycnLg5OSE7OxsODo6qm3Lz8/H1atX4e/vD6VSKZXrs9JuZdnKLav9nJWxe/dudO7cGffu3St1FZIhlfUeERFRzVbe7/eT2COjgbklFURERLUVJ/sSERGR2WKPDOmlU6dOqOGjkkREZAbYI0NERERmi4kMERERmS0mMkRERGS2mMgQERGR2WIiQ0RERGaLiQwRERGZLSYyREREZLaYyGggiqv3FgX6nC8jIwNxcXEIDAyEUqmEp6cnIiIikJycjAcPHlRBlIaxfPlydOrUCY6OjpDJZMjKyjJ2SEREZMa4IJ4GMgtL/Ln0ZRTcOlvl55L7BKPem2t02ufKlSuIiIiAs7MzZsyYgebNm0OhUODUqVNYvnw56tatiz59+mjct7CwENbW1oYIXS8PHjxAjx490KNHDyQkJBgtDiIiqhlMpkdm5syZkMlkGDt2rFSWn5+P2NhYuLm5wd7eHtHR0cjMzKyWeApunUX+9eNV/tAnWRo1ahSsrKxw9OhRDBw4EMHBwQgICEDfvn2xZcsW9O7dW6ork8mQnJyMPn36wM7ODh9//DEAIDk5GQ0bNoRcLkdQUBBWr14t7XPt2jXIZDKcOHFCKsvKyoJMJsPu3bsBPL5ppEwmw5YtWxAaGgqlUom2bdvi9OnT5cY+duxYvPfee2jbtq3Or5uIiOhpJpHIHDlyBMuWLUNoaKha+bhx47B582asX78ee/bswa1btzBgwAAjRWka7t69ix07diA2NhZ2dnYa68hkMrXnU6ZMQf/+/XHq1Cm89tpr2LhxI+Li4jB+/HicPn0ab7zxBoYPH45du3bpHM/EiRMxd+5cHDlyBO7u7ujduzcKCwv1em1ERES6Mnoik5ubi5dffhmfffYZXFxcpPLs7GysWLEC8+bNQ5cuXRAWFoaUlBQcOHAAhw4dMmLExnXp0iUIIRAUFKRWXqdOHdjb28Pe3h7vvvuu2rYhQ4Zg+PDhCAgIgK+vL+bMmYNhw4Zh1KhRaNy4MeLj4zFgwADMmTNH53gmT56Mbt26oXnz5li1ahUyMzOxcePGSr1GIiIibRk9kYmNjUWvXr0QGRmpVn7s2DEUFhaqlTdp0gS+vr44ePBgmcdTqVTIyclRe9QGv/76K06cOIGQkBCoVCq1ba1atVJ7fvbsWURERKiVRURE4OxZ3Ye5wsPDpf93dXVFUFCQXschIiLSh1En+65btw6//fYbjhw5UmpbRkYG5HI5nJ2d1co9PT2RkZFR5jETExMxdepUQ4dqMgIDAyGTyXD+/Hm18oCAAACAjY1NqX3KGoIqi4XF4/z2ybtbc7iIiIhMkdF6ZG7evIm4uDisWbMGSqXSYMdNSEhAdna29Lh586bBjm0K3Nzc0K1bNyxevBh5eXl6HSM4OBj79+9XK9u/fz+aNm0KAHB3dwcApKenS9ufnPj7pCeH+e7du4cLFy4gODhYr7iIiEizBwVFWj1qI6P1yBw7dgy3b9/Gs88+K5UVFRVh7969WLx4MbZv346CggJkZWWp9cpkZmbCy8urzOMqFAooFIqqDN3okpKSEBERgVatWmHKlCkIDQ2FhYUFjhw5gnPnziEsLKzc/SdOnIiBAwfimWeeQWRkJDZv3owNGzZg586dAB736rRt2xYzZ86Ev78/bt++jQ8++EDjsaZNmwY3Nzd4enpi0qRJqFOnDvr161fmuTMyMpCRkYFLly4BAE6dOgUHBwf4+vrC1dVVvwYhIqoFen1+uNztW0a2qaZITIvREpmuXbvi1KlTamXDhw9HkyZN8O6776J+/fqwtrZGWloaoqOjAQDnz5/HjRs31OZlVBW5T/X0KuhznoYNG+L48eOYMWMGEhIS8Oeff0KhUKBp06aYMGECRo0aVe7+/fr1w8KFCzFnzhzExcXB398fKSkp6NSpk1Rn5cqVGDFiBMLCwhAUFITZs2eje/fupY41c+ZMxMXF4eLFi2jZsiU2b94MuVxe5rmXLl2qNvTXoUMHAEBKSgqGDRumW0MQEVGtJxNPToQwsk6dOqFly5ZYsGABAOCtt97C1q1bkZqaCkdHR4wZMwYAcODAAa2PmZOTAycnJ2RnZ8PR0VFtW35+Pq5evQp/f3+14S1RXASZhWXlX5CWqvt8hrB792507twZ9+7dKzWPyZDKeo+IiGqTBwVFWvXI2MrN67ekPOX9fj/JpFf2nT9/PiwsLBAdHQ2VSoWoqCgkJSVV+XmrO6kwtySGiIjIVJhUIlOyamwJpVKJJUuWYMmSJcYJiIiIiEyaSSUyZD46deoEExqVJCKiWsroC+IRERER6YuJDMCeBRPG94aIiMpTqxMZa2trAMCDBw+MHAmVpaCgAABgackJ0UREVFqtniNjaWkJZ2dn3L59GwBga2tb6s7RZDzFxcW4c+cObG1tYWVVqz+qRERUhlr/61CySnBJMkOmxcLCAr6+vkwwiYhIo1qfyMhkMnh7e8PDw4M3RjRBcrlcuoklERHR02p9IlPC0tKS8zCIiIjMDP/UJSIiIrPFRIaIiIjMFhMZIiIiMltMZIiIiMhsMZEhIiIis8VEhoiIiMwWExkiIiIyW0xkiIiIyGxxQTwiIqp1HhQUaVXPVs6FUk0dExkiIqqVen1+uNztW0a2qaZIqDI4tERERERmi4kMERERmS0mMkRERGS2mMgQERGR2WIiQ0RERGaLiQwRERGZLSYyREREZLaYyBAREZHZ4oJ4REQmSpvVZ7nyLNV2TGSIiExYeavPcuVZIg4tERERkRljIkNERERmy6iJTHJyMkJDQ+Ho6AhHR0eEh4fjp59+krbn5+cjNjYWbm5usLe3R3R0NDIzM40YMREREZkSoyYy9erVw8yZM3Hs2DEcPXoUXbp0Qd++ffHHH38AAMaNG4fNmzdj/fr12LNnD27duoUBAwYYM2QiIiIyIUad7Nu7d2+15x9//DGSk5Nx6NAh1KtXDytWrMDatWvRpUsXAEBKSgqCg4Nx6NAhtG3b1hghExERkQkxmTkyRUVFWLduHfLy8hAeHo5jx46hsLAQkZGRUp0mTZrA19cXBw8eLPM4KpUKOTk5ag8iIiKqmYyeyJw6dQr29vZQKBR48803sXHjRjRt2hQZGRmQy+VwdnZWq+/p6YmMjIwyj5eYmAgnJyfpUb9+/Sp+BURERGQsRk9kgoKCcOLECRw+fBhvvfUWYmJicObMGb2Pl5CQgOzsbOlx8+ZNA0ZLREREpsToC+LJ5XIEBgYCAMLCwnDkyBEsXLgQgwYNQkFBAbKystR6ZTIzM+Hl5VXm8RQKBRQKRVWHTURERCbA6D0yTysuLoZKpUJYWBisra2RlpYmbTt//jxu3LiB8PBwI0ZIREREpsKoPTIJCQno2bMnfH19cf/+faxduxa7d+/G9u3b4eTkhBEjRiA+Ph6urq5wdHTEmDFjEB4eziuWiIiICICRE5nbt29j6NChSE9Ph5OTE0JDQ7F9+3Z069YNADB//nxYWFggOjoaKpUKUVFRSEpKMmbIREREZEKMmsisWLGi3O1KpRJLlizBkiVLqikiIiIiMicmN0eGiIiISFtGv2qJiIhIFw8KiiqsYyu3rIZIyBQwkSEiIrPT6/PDZW7bMrJNNUZCxsahJSIiIjJb7JEhIqIapViICoefBEQ1RUNVjYkMERHVKDJZ+UNPAPDjyNbVFA1VNQ4tERERkdliIkNERERmi4kMERERmS0mMkRERGS2ONmXiEgH2izGBnBBNqLqwkSGiEhHFV0RwwXZiKoPExkioidw/REi88JEhohqBEMO+ZTX48L1R/THYTmqCkxkiKjG4JCP6eN7RIbGRIaIqhT/CieiqsREhoiqHP8KJ6KqwnVkiIiIyGwxkSEiIiKzxaElIqJajvOYyJwxkSEiIs5jIrPFoSUiIiIyW0xkiIiIyGwxkSEiIiKzxUSGiIiIzBYTGSIiIjJbvGqJiIioFqipl9kzkSEiMlPFQmj142RuP0xUdWriZfZMZIiIzJRMVvEP0+YRrStMdgSEIcOqFG2SM1OKl4yPiQwRUQ2mTbLz48jW1RRNxcwtXjI+o072TUxMxHPPPQcHBwd4eHigX79+OH/+vFqd/Px8xMbGws3NDfb29oiOjkZmZqaRIiYiqp1KekrKexAZg1F7ZPbs2YPY2Fg899xzePToEd5//310794dZ86cgZ2dHQBg3Lhx2LJlC9avXw8nJyeMHj0aAwYMwP79+40ZOhFRrVJRT4k5zq2gmsGoicy2bdvUnqempsLDwwPHjh1Dhw4dkJ2djRUrVmDt2rXo0qULACAlJQXBwcE4dOgQ2rZta4ywiYiIyESY1Doy2dnZAABXV1cAwLFjx1BYWIjIyEipTpMmTeDr64uDBw9qPIZKpUJOTo7ag4iIiGomk0lkiouLMXbsWERERKBZs2YAgIyMDMjlcjg7O6vV9fT0REZGhsbjJCYmwsnJSXrUr1+/qkMnIiIiIzGZRCY2NhanT5/GunXrKnWchIQEZGdnS4+bN28aKEIiIiIyNSZx+fXo0aPx448/Yu/evahXr55U7uXlhYKCAmRlZan1ymRmZsLLy0vjsRQKBRQKRVWHTERERCbAqD0yQgiMHj0aGzduxC+//AJ/f3+17WFhYbC2tkZaWppUdv78edy4cQPh4eHVHS4RERGZGKP2yMTGxmLt2rX4/vvv4eDgIM17cXJygo2NDZycnDBixAjEx8fD1dUVjo6OGDNmDMLDw3nFEhHpjKvGEtU8Rk1kkpOTAQCdOnVSK09JScGwYcMAAPPnz4eFhQWio6OhUqkQFRWFpKSkao6UiGoCrhpLVPMYNZERouK/fJRKJZYsWYIlS5ZUQ0RERNVDm5Vw2TtEVDGTmOxLRFQbsXeIqPJM5vJrIiIiIl0xkSEiIiKzxUSGiIiIzBYTGSIiIjJbTGSIiIjIbDGRISIiIrPFRIaIiIjMFhMZIiIiMltMZIiIiMhscWVfIjI6bW7maCu3rKZoiMicMJEhIqOr6GaOW0a2qcZoKo932SaqPkxkiIgMjHfZrhm0SUgB9hYaGxMZIiIiDbRJSM2tt7AmYiJDVANp81ckwL8kicj8MZEhqqH4lyQR1Qa8/JqIiIjMFntkiIiIqgiHeaseExkiIqIqxGHeqsWhJSIiIjJb7JEhqkZck0I/XGCOiMrCRIaomtWkFWyrCxeYI6Ky6DW0dOXKFUPHQURERKQzvRKZwMBAdO7cGV9++SXy8/MNHRMRERGRVvRKZH777TeEhoYiPj4eXl5eeOONN/Drr78aOjYiIiKicumVyLRs2RILFy7ErVu3sHLlSqSnp6Ndu3Zo1qwZ5s2bhzt37hg6TiIiIqJSKnX5tZWVFQYMGID169dj1qxZuHTpEiZMmID69etj6NChSE9PN1ScRERERKVUKpE5evQoRo0aBW9vb8ybNw8TJkzA5cuX8fPPP+PWrVvo27evoeIkIiIyOSVLA5T14LIAVU+vy6/nzZuHlJQUnD9/Hi+88AK++OILvPDCC7CweJwX+fv7IzU1FQ0aNDBkrERERCaloqUBuCxA1dMrkUlOTsZrr72GYcOGwdvbW2MdDw8PrFixolLBEZkTbRa7419nRESGpVcic/HixQrryOVyxMTElFtn7969+OSTT3Ds2DGkp6dj48aN6Nevn7RdCIHJkyfjs88+Q1ZWFiIiIpCcnIxGjRrpEzZRleOibURE1UuvOTIpKSlYv359qfL169dj1apVWh8nLy8PLVq0wJIlSzRunz17Nj799FMsXboUhw8fhp2dHaKiorh2DVE1KG/c/8kHEZEx6dUjk5iYiGXLlpUq9/DwwOuvv15hT0yJnj17omfPnhq3CSGwYMECfPDBB9Kk4S+++AKenp7YtGkTXnrpJX1CJyId8K69pC3eD4uMRa9E5saNG/D39y9V7ufnhxs3blQ6KAC4evUqMjIyEBkZKZU5OTmhTZs2OHjwYJmJjEqlgkqlkp7n5OQYJB4iIiob74dFxqJXIuPh4YHff/+91FVJJ0+ehJubmyHiQkZGBgDA09NTrdzT01PapkliYiKmTp1qkBiIqps2f9UWCwELmazcOvzLl4hqC70SmcGDB+Ptt9+Gg4MDOnToAADYs2cP4uLijD7kk5CQgPj4eOl5Tk4O6tevb8SIiLSn7V+1/MuXiOgxvRKZ6dOn49q1a+jatSusrB4fori4GEOHDsWMGTMMEpiXlxcAIDMzU+0S78zMTLRs2bLM/RQKBRQKhUFiICIiItOm11VLcrkcX3/9Nc6dO4c1a9Zgw4YNuHz5MlauXAm5XG6QwPz9/eHl5YW0tDSpLCcnB4cPH0Z4eLhBzkFERETmTa8emRKNGzdG48aN9d4/NzcXly5dkp5fvXoVJ06cgKurK3x9fTF27Fh89NFHaNSoEfz9/fHf//4XPj4+amvNEFXEEHNOAMBWbmmokExCRfNxOM+GiMyBXolMUVERUlNTkZaWhtu3b6O4uFht+y+//KLVcY4ePYrOnTtLz0vmtsTExCA1NRXvvPMO8vLy8PrrryMrKwvt2rXDtm3boFQq9QmbarGKlhCvjZcZc2l1IqoJ9Epk4uLikJqail69eqFZs2aQafHXrCadOnWCEGX/1SeTyTBt2jRMmzZNr+MTERFRzaZXIrNu3Tp88803eOGFFwwdDxEREZHW9J7sGxgYaOhYiIiIiHSiVyIzfvx4LFy4sNxhISIiIqKqptfQ0r59+7Br1y789NNPCAkJgbW1tdr2DRs2GCQ4IjJtvL8OERmbXomMs7Mz+vfvb+hYiMjM8P46RGRseiUyKSkpho6DiIiISGd6zZEBgEePHmHnzp1YtmwZ7t+/DwC4desWcnNzDRYcERERUXn06pG5fv06evTogRs3bkClUqFbt25wcHDArFmzoFKpsHTpUkPHSURERFSKXj0ycXFxaNWqFe7duwcbGxupvH///mr3RiIiIiKqSnr1yPzvf//DgQMHSt0gskGDBvjrr78MEhgRERFRRfTqkSkuLkZRUelLLv/88084ODhUOigiIiIibeiVyHTv3h0LFiyQnstkMuTm5mLy5Mm8bQFVqwcFRRU+uI4JEVHNpdfQ0ty5cxEVFYWmTZsiPz8fQ4YMwcWLF1GnTh189dVXho6RaqCKFlErYSu3rLAO1zEhIqq99Epk6tWrh5MnT2LdunX4/fffkZubixEjRuDll19Wm/xLVJ6KEpAtI9tUUyRERGSu9EpkAMDKygqvvPKKIWOhGkKb3hYO9xARkSHolch88cUX5W4fOnSoXsFQzWGI4R7ex4eIiCqiVyITFxen9rywsBAPHjyAXC6Hra0tExkyCN7Hh4iIKqJXInPv3r1SZRcvXsRbb72FiRMnVjooIlPD3iEiItOk9xyZpzVq1AgzZ87EK6+8gnPnzhnqsEQmgb1DRESmSe+bRmpiZWWFW7duGfKQRERERGXSq0fmhx9+UHsuhEB6ejoWL16MiIgIgwRGpotDLEREZCr0SmT69eun9lwmk8Hd3R1dunTB3LlzDREXmbjyhlk4xEJERNVFr0SmuLjY0HEQERER6cygc2SIiIiIqpNePTLx8fFa1503b54+p6AqYMj7GxEREZkCvRKZ48eP4/jx4ygsLERQUBAA4MKFC7C0tMSzzz4r1ZPJZIaJkgyG9zciIqKaRK9Epnfv3nBwcMCqVavg4uIC4PEiecOHD0f79u0xfvx4gwZJ1YcLvxERkTnRK5GZO3cuduzYISUxAODi4oKPPvoI3bt3ZyJjxrjwGxERmRO9EpmcnBzcuXOnVPmdO3dw//79SgdFuuMdp4mIqDbSK5Hp378/hg8fjrlz56J168d/nR8+fBgTJ07EgAEDDBogaY89KUREVNvodfn10qVL0bNnTwwZMgR+fn7w8/PDkCFD0KNHDyQlJRk6RixZsgQNGjSAUqlEmzZt8Ouvvxr8HKbuQUFRuQ/2thARUW2kV4+Mra0tkpKS8Mknn+Dy5csAgIYNG8LOzs6gwQHA119/jfj4eCxduhRt2rTBggULEBUVhfPnz8PDw8Pg5zNlXE2XiIhIXaUWxEtPT0d6ejoaNWoEOzs7CGH4XoF58+bhP//5D4YPH46mTZti6dKlsLW1xcqVKw1+rqpQUU/Kg4Ii5KoesceFiIhID3r1yNy9excDBw7Erl27IJPJcPHiRQQEBGDEiBFwcXEx2P2WCgoKcOzYMSQkJEhlFhYWiIyMxMGDBzXuo1KpoFKppOc5OTkGiaUyen1+GB72cjgprTVuX9g/BHEbT0MmA8rKBRf2D0GjOnZl1rGQAY3q2MHKUoZHRZoPUl11SrYDqLAO49U/FkPVMaVYyqpjqrEYO15dY6nKeKsiFn3jNVYsmuo8vV1THW2WXJNpEUtFx3n6GPrGYmpkQo9ulKFDh+L27dv4/PPPERwcjJMnTyIgIADbt29HfHw8/vjjD4MEd+vWLdStWxcHDhxAeHi4VP7OO+9gz549OHy49FDLlClTMHXq1FLl2dnZcHR0NEhcunhQUAQZAKUVILMof8VcIYohk5XfSSaKi8o9TkXbTa2OKcWiTR1TisVQdUwpFm3qmFIs2tQxpVi0qWNKsWhTx5RiMVQdU4pFmzraHEMfOTk5cHJyqvD3W68emR07dmD79u2oV6+eWnmjRo1w/fp1fQ5pMAkJCWq3UMjJyUH9+vWNFs+Ty/3/ufRlFNw6q7Ge3CcY9d5cU+HxZBaWZR7HLrQnPF/8uNzzmFIdU4qlJsZbE1+TKcXCeI1fx5Riqa2vSdvfrqqkVyKTl5cHW1vbUuX//PMPFApFpYMqUadOHVhaWiIzM1OtPDMzE15eXhr3USgUBo3BkApunUX+9eNVdhy5d5MKz2NKdUwplpoYb018TaYUC+M1fh1TiqU2vyZj02uyb/v27fHFF19Iz2UyGYqLizF79mx07tzZYMHJ5XKEhYUhLS1NKisuLkZaWpraUBMRERHVTnr1yMyePRtdu3bF0aNHUVBQgHfeeQd//PEH/vnnH+zfv9+gAcbHxyMmJgatWrVC69atsWDBAuTl5WH48OEGPQ8RERGZH70SmWbNmuHChQtYvHgxHBwckJubiwEDBiA2Nhbe3t4GDXDQoEG4c+cOPvzwQ2RkZKBly5bYtm0bPD09DXoeIiIiMj86JzKFhYXo0aMHli5dikmTJlVFTKWMHj0ao0ePrpZzERERkfnQeY6MtbU1fv/996qIhYiIiEgneg0tvfLKK1ixYgVmzpxp6HhqNLlPsF7btK1r7e5f4bFK6hAREdUEeiUyjx49wsqVK7Fz506EhYWVusfSvHnzDBJcTSKKiyq81l7bhYnKO4425yEiIqopdEpkrly5ggYNGuD06dN49tlnAQAXLlxQqyMzx/WNq4E2qx4aok5VrK5IRERkqnRKZBo1aoT09HTs2rULwOMrij799FNeQURERERGodNk36dvy/TTTz8hLy/PoAERERERaUuvlX1L6HG/SSIiIiKD0SmRkclkpebAcE4MERERGYtOc2SEEBg2bJh0U8b8/Hy8+eabpa5a2rBhg+EiJCIiIiqDTolMTEyM2vNXXnnFoMFQ9eFaM0REVBPolMikpKRUVRxUjbjWDBER1RSVmuxL5olrzRARUU3BRIaIiIjMll63KCDSRUX3hiIiItIXExmqMkUPsjgfh4iIqhSHlqjKFGVncD4OERFVKSYyREREZLY4tESkI67BQ0RkOpjIEGmJc36IiEwPh5aItMQ5P0REpoeJDBEREZktDi1RpZQ3X6S8bdrWM/ScE85vISKqWZjIkF60nS8iiovKHY6prjknnN9CRFQzcWiJ9KLtfJGK6lTXnBPObyEiqpmYyBAREZHZ4tASlckQ81/MUVmvzdCvmfN1iIgqj4kMaWSI+S/mqKLXbYjXzPk6RESGw6El0sgQ81/MUXXM6eF8HSIiw2EiQ0RERGaLQ0tkFrSZT8I5PaVxrk352HZE5s+oiczevXvxySef4NixY0hPT8fGjRvRr18/absQApMnT8Znn32GrKwsREREIDk5GY0aNTJe0FTttJ2vU9vm9HCujf7YdkQ1h1GHlvLy8tCiRQssWbJE4/bZs2fj008/xdKlS3H48GHY2dkhKioK+fn51RwpGZOh5uvUpCQG4FybymDbEdUcRu2R6dmzJ3r27KlxmxACCxYswAcffIC+ffsCAL744gt4enpi06ZNeOmll6ozVCIiIjJBJjvZ9+rVq8jIyEBkZKRU5uTkhDZt2uDgwYNGjIyIiIhMhclO9s3IyAAAeHp6qpV7enpK2zRRqVRQqVTS85ycnKoJkMiMlDWplRNaicjcmWwio6/ExERMnTrV2GEQmQxOaiWimsxkh5a8vLwAAJmZmWrlmZmZ0jZNEhISkJ2dLT1u3rxZpXESmTpOaiWimsxkExl/f394eXkhLS1NKsvJycHhw4cRHh5e5n4KhQKOjo5qDyIiIqqZjDq0lJubi0uXLknPr169ihMnTsDV1RW+vr4YO3YsPvroIzRq1Aj+/v7473//Cx8fH7W1ZojIdFTXAnNcIJGIShg1kTl69Cg6d+4sPY+PjwcAxMTEIDU1Fe+88w7y8vLw+uuvIysrC+3atcO2bdugVCqNFTIRaVBdC8xpe57auEAiUW1l1ESmU6dOEEKUuV0mk2HatGmYNm1aNUZFRLqqrgXmtD1PbVwgkai2Mtk5MkREREQVqXGXXxOZAs7PqDl4Y0ki08ZEhsjAOD+j5uAaPESmj0NLRAbG+Rk1B98nItPHRIaIiIjMFoeWiEyYKc21qc5Yyjoe5xcZBu+9RTUJExkiE2Uqc210WbulsrFocy7OL9Jfda33Q1SdOLREZKJMZa6NIdduMcS5mMTor7rW+yGqTkxkiIiIyGwxkSEiIiKzxUSGiIiIzBYTGSIiIjJbTGSIiIjIbPHyayKiSuK6LETGw0SGiKgSuC4LkXFxaImIqBK4LguRcTGRISIiIrPFoSUiqlamdP8oItKOKd//jIkMEVUbU7l/FBFpxxzuf8ahJSKqNqZy/ygi0o453P+MiQwRERGZLQ4tERHnrRCR2WIiQ1TLcd4KEZkzDi0R1XKct0JE5oyJDBEREZktDi0REZGa8uZF8f5RZGqYyBARkYT3jiJzw6ElIiKScD4UmRsmMkRERGS2OLRERGQCauu8lNr6uslwjJrIJCYmYsOGDTh37hxsbGzw/PPPY9asWQgKCpLq5OfnY/z48Vi3bh1UKhWioqKQlJQET09PI0ZORGQY2tzLpiaqra+bDM+oQ0t79uxBbGwsDh06hJ9//hmFhYXo3r078vLypDrjxo3D5s2bsX79euzZswe3bt3CgAEDjBg1EZHhaHMvm5qotr5uMjyj9shs27ZN7Xlqaio8PDxw7NgxdOjQAdnZ2VixYgXWrl2LLl26AABSUlIQHByMQ4cOoW3btsYIm4iIiEyESU32zc7OBgC4uroCAI4dO4bCwkJERkZKdZo0aQJfX18cPHjQKDESERGR6TCZyb7FxcUYO3YsIiIi0KxZMwBARkYG5HI5nJ2d1ep6enoiIyND43FUKhVUKpX0PCcnp8piJiIyNbwBKNU2JpPIxMbG4vTp09i3b1+ljpOYmIipU6caKCoiIvOg7eRZ3gCUahqTGFoaPXo0fvzxR+zatQv16tWTyr28vFBQUICsrCy1+pmZmfDy8tJ4rISEBGRnZ0uPmzdvVmXoREQmQdvJs0xiqKYxaiIjhMDo0aOxceNG/PLLL/D3V18zICwsDNbW1khLS5PKzp8/jxs3biA8PFzjMRUKBRwdHdUeREREVDMZdWgpNjYWa9euxffffw8HBwdp3ouTkxNsbGzg5OSEESNGID4+Hq6urnB0dMSYMWMQHh7OK5aIiIjIuIlMcnIyAKBTp05q5SkpKRg2bBgAYP78+bCwsEB0dLTagnhERERERk1khBAV1lEqlViyZAmWLFlSDRERERGROTGJyb5ERERE+jCZy6+JiIjIsGrDTTmZyBAREdUwtemmnBxaIiIiqmFq0005mcgQERGR2eLQEhERUS1m7vfnYiJDRERUS9WE+3NxaImIiKiWqgn352IiQ0RERGaLQ0tERFXMUHMQzH0uQ1WpDWulUNmYyBARVSFDzUGoCXMZDK02rZVCZePQEhFRFTLUHISaMJfB0GrTWilUNiYyREREZLaYyBAREZHZYiJDREREZouJDBEREZktJjJERERktpjIEBERkdliIkNERERmi4kMERERmS0mMkRERGS2eIsCIiIiA+K9n6oXExkiIiID4L2fjINDS0RERAbAez8ZBxMZIiIiMltMZIiIiMhsMZEhIiIis8VEhoiIiMwWExkiIiIyW0xkiIiIyGwZdR2Z5ORkJCcn49q1awCAkJAQfPjhh+jZsycAID8/H+PHj8e6deugUqkQFRWFpKQkeHp6GjFqIiIyN4ZapK6845S3Tdu6XDBPd0ZNZOrVq4eZM2eiUaNGEEJg1apV6Nu3L44fP46QkBCMGzcOW7Zswfr16+Hk5ITRo0djwIAB2L9/vzHDJiIiM2KIReq0XexOFBdVuJYMF80zLKMmMr1791Z7/vHHHyM5ORmHDh1CvXr1sGLFCqxduxZdunQBAKSkpCA4OBiHDh1C27ZtjREyERGZGUMsUqftYneGqkPaM5k5MkVFRVi3bh3y8vIQHh6OY8eOobCwEJGRkVKdJk2awNfXFwcPHjRipERERGQqjH6vpVOnTiE8PBz5+fmwt7fHxo0b0bRpU5w4cQJyuRzOzs5q9T09PZGRkVHm8VQqFVQqlfQ8JyenqkInIqJqUNZ8El3mpFTmPFVxLjIcoycyQUFBOHHiBLKzs/Htt98iJiYGe/bs0ft4iYmJmDp1qgEjJCIiY6loPok2c1IMcR5DnosMy+hDS3K5HIGBgQgLC0NiYiJatGiBhQsXwsvLCwUFBcjKylKrn5mZCS8vrzKPl5CQgOzsbOlx8+bNKn4FRERUVSpKHAyVWHBui/kyeiLztOLiYqhUKoSFhcHa2hppaWnStvPnz+PGjRsIDw8vc3+FQgFHR0e1BxEREdVMRh1aSkhIQM+ePeHr64v79+9j7dq12L17N7Zv3w4nJyeMGDEC8fHxcHV1haOjI8aMGYPw8HBesUREREQAjJzI3L59G0OHDkV6ejqcnJwQGhqK7du3o1u3bgCA+fPnw8LCAtHR0WoL4hEREREBRk5kVqxYUe52pVKJJUuWYMmSJdUUEREREZkTk5sjQ0RERKQto19+TURENRPXZaHqwESGiIgMypD3JSKqCIeWiIjIoAx5XyKiijCRISIiIrPFoSUiItIZ57+QqWAiQ0REOuH8FzIlHFoiIiKdcP4LmRImMkRERGS2OLRERERkYsqbZ2Tt7l9hndo0T0kmhBDGDqIq5eTkwMnJCdnZ2bwTNhERmTxt5hcZqo4p0/b3m0NLREREJsRQc5DMOYnRBRMZIiIiMltMZIiIiMhsMZEhIiIis8VEhoiIiMwWExkiIiIyW0xkiIiIyGwxkSEiIiKzxUSGiIiIzBYTGSIiIjJbTGSIiIjIbDGRISIiIrPFRIaIiIjMFhMZIiIiMltMZIiIiMhsMZEhIiIis8VEhoiIiMwWExkiIiIyW0xkiIiIyGyZTCIzc+ZMyGQyjB07VirLz89HbGws3NzcYG9vj+joaGRmZhovSCIiIjIpJpHIHDlyBMuWLUNoaKha+bhx47B582asX78ee/bswa1btzBgwAAjRUlERESmxuiJTG5uLl5++WV89tlncHFxkcqzs7OxYsUKzJs3D126dEFYWBhSUlJw4MABHDp0yIgRExERkakweiITGxuLXr16ITIyUq382LFjKCwsVCtv0qQJfH19cfDgweoOk4iIiEyQlTFPvm7dOvz22284cuRIqW0ZGRmQy+VwdnZWK/f09ERGRkaZx1SpVFCpVNLz7OxsAEBOTo5hgiYiIqIqV/K7LYQot57REpmbN28iLi4OP//8M5RKpcGOm5iYiKlTp5Yqr1+/vsHOQURERNXj/v37cHJyKnO7TFSU6lSRTZs2oX///rC0tJTKioqKIJPJYGFhge3btyMyMhL37t1T65Xx8/PD2LFjMW7cOI3HfbpHpri4GP/88w/c3Nwgk8kqHXdOTg7q16+PmzdvwtHRsdLHo/KxvasX27t6sb2rF9u7elW2vYUQuH//Pnx8fGBhUfZMGKP1yHTt2hWnTp1SKxs+fDiaNGmCd999F/Xr14e1tTXS0tIQHR0NADh//jxu3LiB8PDwMo+rUCigUCjUyp4enjIER0dH/kOoRmzv6sX2rl5s7+rF9q5elWnv8npiShgtkXFwcECzZs3Uyuzs7ODm5iaVjxgxAvHx8XB1dYWjoyPGjBmD8PBwtG3b1hghExERkYkx6mTfisyfPx8WFhaIjo6GSqVCVFQUkpKSjB0WERERmQiTSmR2796t9lypVGLJkiVYsmSJcQLSQKFQYPLkyaWGr6hqsL2rF9u7erG9qxfbu3pVV3sbbbIvERERUWUZfUE8IiIiIn0xkSEiIiKzxUSGiIiIzBYTGSIiIjJbTGQ0WLJkCRo0aAClUok2bdrg119/Lbf++vXr0aRJEyiVSjRv3hxbt26tpkhrBl3a+7PPPkP79u3h4uICFxcXREZGVvj+kDpdP98l1q1bB5lMhn79+lVtgDWMru2dlZWF2NhYeHt7Q6FQoHHjxvxO0YGu7b1gwQIEBQXBxsYG9evXx7hx45Cfn19N0Zq3vXv3onfv3vDx8YFMJsOmTZsq3Gf37t149tlnoVAoEBgYiNTU1MoHIkjNunXrhFwuFytXrhR//PGH+M9//iOcnZ1FZmamxvr79+8XlpaWYvbs2eLMmTPigw8+ENbW1uLUqVPVHLl50rW9hwwZIpYsWSKOHz8uzp49K4YNGyacnJzEn3/+Wc2Rmydd27vE1atXRd26dUX79u1F3759qyfYGkDX9lapVKJVq1bihRdeEPv27RNXr14Vu3fvFidOnKjmyM2Tru29Zs0aoVAoxJo1a8TVq1fF9u3bhbe3txg3blw1R26etm7dKiZNmiQ2bNggAIiNGzeWW//KlSvC1tZWxMfHizNnzohFixYJS0tLsW3btkrFwUTmKa1btxaxsbHS86KiIuHj4yMSExM11h84cKDo1auXWlmbNm3EG2+8UaVx1hS6tvfTHj16JBwcHMSqVauqKsQaRZ/2fvTokXj++efF559/LmJiYpjI6EDX9k5OThYBAQGioKCgukKsUXRt79jYWNGlSxe1svj4eBEREVGlcdZE2iQy77zzjggJCVErGzRokIiKiqrUuTm09ISCggIcO3YMkZGRUpmFhQUiIyNx8OBBjfscPHhQrT4AREVFlVmf/o8+7f20Bw8eoLCwEK6urlUVZo2hb3tPmzYNHh4eGDFiRHWEWWPo094//PADwsPDERsbC09PTzRr1gwzZsxAUVFRdYVttvRp7+effx7Hjh2Thp+uXLmCrVu34oUXXqiWmGubqvq9NKmVfY3t77//RlFRETw9PdXKPT09ce7cOY37ZGRkaKyfkZFRZXHWFPq099Peffdd+Pj4lPrHQaXp09779u3DihUrcOLEiWqIsGbRp72vXLmCX375BS+//DK2bt2KS5cuYdSoUSgsLMTkyZOrI2yzpU97DxkyBH///TfatWsHIQQePXqEN998E++//351hFzrlPV7mZOTg4cPH8LGxkav47JHhszWzJkzsW7dOmzcuBFKpdLY4dQ49+/fx6uvvorPPvsMderUMXY4tUJxcTE8PDywfPlyhIWFYdCgQZg0aRKWLl1q7NBqpN27d2PGjBlISkrCb7/9hg0bNmDLli2YPn26sUMjHbBH5gl16tSBpaUlMjMz1cozMzPh5eWlcR8vLy+d6tP/0ae9S8yZMwczZ87Ezp07ERoaWpVh1hi6tvfly5dx7do19O7dWyorLi4GAFhZWeH8+fNo2LBh1QZtxvT5fHt7e8Pa2hqWlpZSWXBwMDIyMlBQUAC5XF6lMZszfdr7v//9L1599VWMHDkSANC8eXPk5eXh9ddfx6RJk2Bhwb/1Dams30tHR0e9e2MA9siokcvlCAsLQ1pamlRWXFyMtLQ0hIeHa9wnPDxcrT4A/Pzzz2XWp/+jT3sDwOzZszF9+nRs27YNrVq1qo5QawRd27tJkyY4deoUTpw4IT369OmDzp0748SJE6hfv351hm929Pl8R0RE4NKlS1LCCAAXLlyAt7c3k5gK6NPeDx48KJWslCSRgrchNLgq+72s1FThGmjdunVCoVCI1NRUcebMGfH6668LZ2dnkZGRIYQQ4tVXXxXvvfeeVH///v3CyspKzJkzR5w9e1ZMnjyZl1/rQNf2njlzppDL5eLbb78V6enp0uP+/fvGeglmRdf2fhqvWtKNru1948YN4eDgIEaPHi3Onz8vfvzxR+Hh4SE++ugjY70Es6Jre0+ePFk4ODiIr776Sly5ckXs2LFDNGzYUAwcONBYL8Gs3L9/Xxw/flwcP35cABDz5s0Tx48fF9evXxdCCPHee++JV199Vapfcvn1xIkTxdmzZ8WSJUt4+XVVWbRokfD19RVyuVy0bt1aHDp0SNrWsWNHERMTo1b/m2++EY0bNxZyuVyEhISILVu2VHPE5k2X9vbz8xMASj0mT55c/YGbKV0/309iIqM7Xdv7wIEDok2bNkKhUIiAgADx8ccfi0ePHlVz1OZLl/YuLCwUU6ZMEQ0bNhRKpVLUr19fjBo1Sty7d6/6AzdDu3bt0vh9XNLGMTExomPHjqX2admypZDL5SIgIECkpKRUOg6ZEOw/IyIiIvPEOTJERERktpjIEBERkdliIkNERERmi4kMERERmS0mMkRERGS2mMgQERGR2WIiQ0RERGaLiQwRmaXU1FQ4OzsbOwwiMjImMkQ12LBhwyCTySCTySCXyxEYGIhp06bh0aNHxg6t0gYNGoQLFy5Iz6dMmYKWLVsa5NifffYZWrRoAXt7ezg7O+OZZ55BYmKiQY5NRIbFu18T1XA9evRASkoKVCoVtm7ditjYWFhbWyMhIaFUXXO6w7KNjU2l7phblpUrV2Ls2LH49NNP0bFjR6hUKvz+++84ffq0wc9VwpzancjUsEeGqIZTKBTw8vKCn58f3nrrLURGRuKHH34A8LjHpl+/fvj444/h4+ODoKAgAMCpU6fQpUsX2NjYwM3NDa+//jpyc3OlY5bsN3XqVLi7u8PR0RFvvvkmCgoKpDrFxcVITEyEv78/bGxs0KJFC3z77bfS9t27d0MmkyEtLQ2tWrWCra0tnn/+eZw/f16qc/LkSXTu3BkODg5wdHREWFgYjh49CkB9aCk1NRVTp07FyZMnpR6o1NRUvPbaa/jXv/6l1h6FhYXw8PDAihUrNLbXDz/8gIEDB2LEiBEIDAxESEgIBg8ejI8//lit3sqVKxESEgKFQgFvb2+MHj1a2nbjxg307dsX9vb2cHR0xMCBA5GZmSltL+k9+vzzz+Hv7w+lUgkAyMrKwsiRI6U27dKlC06ePFnBO0xUu7FHhqiWsbGxwd27d6XnaWlpcHR0xM8//wwAyMvLQ1RUFMLDw3HkyBHcvn0bI0eOxOjRo5Gamqq2n1KpxO7du3Ht2jUMHz4cbm5u0g9+YmIivvzySyxduhSNGjXC3r178corr8Dd3R0dO3aUjjNp0iTMnTsX7u7uePPNN/Haa69h//79AICXX34ZzzzzDJKTk2FpaYkTJ07A2tq61GsaNGgQTp8+jW3btmHnzp0AACcnJzRu3BgdOnRAeno6vL29AQA//vgjHjx4gEGDBmlsHy8vL+zZswfXr1+Hn5+fxjrJycmIj4/HzJkz0bNnT2RnZ0sxFxcXS0nMnj178OjRI8TGxmLQoEHYvXu3dIxLly7hu+++w4YNG2BpaQkA+Pe//w0bGxv89NNPcHJywrJly9C1a1dcuHABrq6uZb+pRLVZpW87SUQm68m7VRcXF4uff/5ZKBQKMWHCBGm7p6enUKlU0j7Lly8XLi4uIjc3VyrbsmWLsLCwEBkZGdJ+rq6uIi8vT6qTnJws7O3tRVFRkcjPzxe2trbiwIEDavGMGDFCDB48WAjxf3fO3blzp9p5AIiHDx8KIYRwcHAQqampGl9bSkqKcHJykp5PnjxZtGjRolS9pk2bilmzZknPe/fuLYYNG1Zmm926dUu0bdtWABCNGzcWMTEx4uuvvxZFRUVSHR8fHzFp0iSN++/YsUNYWlqKGzduSGV//PGHACB+/fVXKVZra2tx+/Ztqc7//vc/4ejoKPLz89WO17BhQ7Fs2bIy4yWq7Ti0RFTD/fjjj7C3t4dSqUTPnj0xaNAgTJkyRdrevHlztfkZZ8+eRYsWLWBnZyeVRUREoLi4WG3Yp0WLFrC1tZWeh4eHIzc3Fzdv3sSlS5fw4MEDdOvWDfb29tLjiy++wOXLl9XiCw0Nlf6/pNfk9u3bAID4+HiMHDkSkZGRmDlzZql9tTFy5EikpKQAADIzM/HTTz/htddeK7O+t7c3Dh48iFOnTiEuLg6PHj1CTEwMevTogeLiYty+fRu3bt1C165dNe5/9uxZ1K9fH/Xr15fKmjZtCmdnZ5w9e1Yq8/Pzg7u7u/T85MmTyM3NhZubm1qbXb16Va/XTVRbcGiJqIbr3LkzkpOTIZfL4ePjAysr9X/2TyYshlIyn2bLli2oW7eu2jaFQqH2/MmhIplMBuDx8AzweC7JkCFDsGXLFvz000+YPHky1q1bh/79+2sdy9ChQ/Hee+/h4MGDOHDgAPz9/dG+ffsK92vWrBmaNWuGUaNG4c0330T79u2xZ88etGrVSutzl+fpds/NzYW3t7fa8FMJXmZOVDYmMkQ1nJ2dHQIDA7WuHxwcjNTUVOTl5Uk/tvv374eFhYU0GRh43IPw8OFD6cqhQ4cOwd7eHvXr14erqysUCgVu3LihNh9GH40bN0bjxo0xbtw4DB48GCkpKRoTGblcjqKiolLlbm5u6NevH1JSUnDw4EEMHz5c5xiaNm0K4PH8IQcHBzRo0ABpaWno3LlzqbrBwcG4efMmbt68KfXKnDlzBllZWdJxNHn22WeRkZEBKysrNGjQQOcYiWorDi0RkZqXX34ZSqUSMTExOH36NHbt2oUxY8bg1Vdfhaenp1SvoKAAI0aMwJkzZ7B161ZMnjwZo0ePhoWFBRwcHDBhwgSMGzcOq1atwuXLl/Hbb79h0aJFWLVqlVZxPHz4EKNHj8bu3btx/fp17N+/H0eOHEFwcLDG+g0aNMDVq1dx4sQJ/P3331CpVNK2kSNHYtWqVTh79ixiYmLKPe9bb72F6dOnY//+/bh+/ToOHTqEoUOHwt3dHeHh4QAe9xTNnTsXn376KS5evCi9NgCIjIxE8+bN8fLLL+O3337Dr7/+iqFDh6Jjx47l9uZERkYiPDwc/fr1w44dO3Dt2jUcOHAAkyZNkq7UIqLS2CNDRGpsbW2xfft2xMXF4bnnnoOtrS2io6Mxb948tXpdu3ZFo0aN0KFDB6hUKgwePFht7s306dPh7u6OxMREXLlyBc7Oznj22Wfx/vvvaxWHpaUl7t69i6FDhyIzMxN16tTBgAEDMHXqVI31o6OjsWHDBnTu3BlZWVlISUnBsGHDADxOEry9vRESEgIfH59yzxsZGYmVK1ciOTkZd+/eRZ06dRAeHo60tDS4ubkBAGJiYpCfn4/58+djwoQJqFOnDl588UUAj4fHvv/+e4wZMwYdOnSAhYUFevToISU6ZZHJZNi6dSsmTZqE4cOH486dO/Dy8kKHDh3UEkgiUicTQghjB0FE5mXYsGHIysrCpk2bjB2KVnJzc1G3bl2kpKRgwIABxg6HiAyIPTJEVGMVFxfj77//xty5c+Hs7Iw+ffoYOyQiMjAmMkRUY924cQP+/v6oV68eUlNTS12xRUTmj0NLREREZLZ41RIRERGZLSYyREREZLaYyBAREZHZYiJDREREZouJDBEREZktJjJERERktpjIEBERkdliIkNERERmi4kMERERma3/B23K0tSMXNrLAAAAAElFTkSuQmCC",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "plot_mirror_histogram(\n",
+                "    data = data_wt_att,\n",
+                "    var = 'ps',\n",
+                "    group = 'net',\n",
+                "    weights = 'wts_att',\n",
+                "    title = \"Distribution of Propensity Score in the Weighted Population\",\n",
+                "    xlabel = \"Propensity Score\"\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "#### Checking Covariate Balancing"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 12,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/html": [
+                            "<div>\n",
+                            "<style scoped>\n",
+                            "    .dataframe tbody tr th:only-of-type {\n",
+                            "        vertical-align: middle;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe tbody tr th {\n",
+                            "        vertical-align: top;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe thead th {\n",
+                            "        text-align: right;\n",
+                            "    }\n",
+                            "</style>\n",
+                            "<table border=\"1\" class=\"dataframe\">\n",
+                            "  <thead>\n",
+                            "    <tr style=\"text-align: right;\">\n",
+                            "      <th></th>\n",
+                            "      <th>variables</th>\n",
+                            "      <th>unadjusted_smd</th>\n",
+                            "      <th>adjusted_smd</th>\n",
+                            "    </tr>\n",
+                            "  </thead>\n",
+                            "  <tbody>\n",
+                            "    <tr>\n",
+                            "      <th>0</th>\n",
+                            "      <td>health</td>\n",
+                            "      <td>1.064252</td>\n",
+                            "      <td>0.184724</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>1</th>\n",
+                            "      <td>income</td>\n",
+                            "      <td>1.027642</td>\n",
+                            "      <td>0.194283</td>\n",
+                            "    </tr>\n",
+                            "  </tbody>\n",
+                            "</table>\n",
+                            "</div>"
+                        ],
+                        "text/plain": [
+                            "  variables  unadjusted_smd  adjusted_smd\n",
+                            "0    health        1.064252      0.184724\n",
+                            "1    income        1.027642      0.194283"
+                        ]
+                    },
+                    "execution_count": 12,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "smd_df_att = compute_smd(\n",
+                "    data = data_wt_att,\n",
+                "    vars = ['health', 'income'],\n",
+                "    group = 'net',\n",
+                "    wt_var = 'wts_att',\n",
+                "    estimand = 'ATT'\n",
+                ")\n",
+                "\n",
+                "smd_df_att"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 14,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 1000x600 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "plot_smd(smd_df_att, add_ref_line=True)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "#### Estimating ATT"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 23,
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "-17.563307778917196\n"
+                    ]
+                }
+            ],
+            "source": [
+                "outcome_model_att = (\n",
+                "    smf.wls(\n",
+                "        \"malaria_risk ~ net\",\n",
+                "        data = data_wt_att,\n",
+                "        weights = data_wt_att['wts_att']\n",
+                "    )\n",
+                "    .fit()\n",
+                ")\n",
+                "\n",
+                "\n",
+                "treated = nets.loc[nets.net == 1]\n",
+                "\n",
+                "# Predict outcomes when net = 1 for treated people\n",
+                "pred_1 = (\n",
+                "    outcome_model_att\n",
+                "        .predict(treated.assign(net = 1))\n",
+                ")\n",
+                "\n",
+                "# Predict outcomes when net = 0 for treated people\n",
+                "pred_0 = (\n",
+                "    outcome_model_att\n",
+                "        .predict(treated.assign(net = 0))\n",
+                ")\n",
+                "\n",
+                "mean_difference = (pred_1 - pred_0).mean()\n",
+                "print(mean_difference)\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "So that means, People who currently use mosquito nets see a malaria risk reduction of 17.6 points, on average. This ATT estimate is helpful for understanding the effect of net usage on people who actually use them; this shows what would happen if we withheld the program or took away everyone's nets"
             ]
         }
     ],

From 9b320799bb8ed2c01993c4d5e0f162243130dd73 Mon Sep 17 00:00:00 2001
From: shafayetShafee <sshafee@isrt.ac.bd>
Date: Tue, 13 Aug 2024 14:51:17 +0600
Subject: [PATCH 3/6] doc: extended the tutorial for ATC

---
 docs/example.ipynb | 348 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 338 insertions(+), 10 deletions(-)

diff --git a/docs/example.ipynb b/docs/example.ipynb
index 189e997..6ab849c 100644
--- a/docs/example.ipynb
+++ b/docs/example.ipynb
@@ -6,7 +6,7 @@
             "source": [
                 "# Causal Analysis Workflow & Estimating ATE Using `skmiscpy`\n",
                 "\n",
-                "Here we will show how we can do a very basic causal analysis using the python package `skmiscpy`. The following example content and the data used in this example are taken from (Heiss, 2024). It is highly recommended to read the post,\n",
+                "Here we will show how we can do a very basic causal analysis using the python package `skmiscpy`. The following contents and the data used in this example are taken from (Heiss, 2024). It is highly recommended to read the post,\n",
                 "\n",
                 "> Heiss, Andrew. 2024. \"Demystifying Causal Inference Estimands: ATE, ATT, and ATU.\" March 21, 2024. https://doi.org/10.59350/c9z3a-rcq16.\n",
                 "\n",
@@ -552,7 +552,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 9,
+            "execution_count": 8,
             "metadata": {},
             "outputs": [
                 {
@@ -581,7 +581,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 8,
+            "execution_count": 9,
             "metadata": {},
             "outputs": [
                 {
@@ -603,13 +603,11 @@
                 ")\n",
                 "\n",
                 "# Predict outcomes when net = 1\n",
-                "nets_1 = nets.copy()\n",
-                "nets_1['net'] = 1\n",
+                "nets_1 = nets.assign(net = 1)\n",
                 "pred_1 = outcome_model.predict(nets_1)\n",
                 "\n",
                 "# Predict outcomes when net = 0\n",
-                "nets_0 = nets.copy()\n",
-                "nets_0['net'] = 0\n",
+                "nets_0 = nets.assign(net = 0)\n",
                 "pred_0 = outcome_model.predict(nets_0)\n",
                 "\n",
                 "mean_difference = (pred_1 - pred_0).mean()\n",
@@ -867,7 +865,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 14,
+            "execution_count": 13,
             "metadata": {},
             "outputs": [
                 {
@@ -894,7 +892,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 23,
+            "execution_count": 22,
             "metadata": {},
             "outputs": [
                 {
@@ -916,7 +914,7 @@
                 ")\n",
                 "\n",
                 "\n",
-                "treated = nets.loc[nets.net == 1]\n",
+                "treated = data_wt_att.loc[nets.net == 1]\n",
                 "\n",
                 "# Predict outcomes when net = 1 for treated people\n",
                 "pred_1 = (\n",
@@ -940,6 +938,336 @@
             "source": [
                 "So that means, People who currently use mosquito nets see a malaria risk reduction of 17.6 points, on average. This ATT estimate is helpful for understanding the effect of net usage on people who actually use them; this shows what would happen if we withheld the program or took away everyone's nets"
             ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now what if, we’re interested in what would happen if we expanded the program to people not using it? For this, we need to estimate the \"Average Treatment Effect among the Control group\" (ATC)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "### ATC (Average Treatment Effect among the Control group)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "The formula to calculate the weights in case of ATC is,\n",
+                "\n",
+                "$$\n",
+                "w_{ATC} = \\dfrac{(1- p_i) \\times T_i}{p_i} + (1- T_i)\n",
+                "$$"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 14,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/html": [
+                            "<div>\n",
+                            "<style scoped>\n",
+                            "    .dataframe tbody tr th:only-of-type {\n",
+                            "        vertical-align: middle;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe tbody tr th {\n",
+                            "        vertical-align: top;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe thead th {\n",
+                            "        text-align: right;\n",
+                            "    }\n",
+                            "</style>\n",
+                            "<table border=\"1\" class=\"dataframe\">\n",
+                            "  <thead>\n",
+                            "    <tr style=\"text-align: right;\">\n",
+                            "      <th></th>\n",
+                            "      <th>id</th>\n",
+                            "      <th>income</th>\n",
+                            "      <th>health</th>\n",
+                            "      <th>net</th>\n",
+                            "      <th>malaria_risk</th>\n",
+                            "      <th>ps</th>\n",
+                            "      <th>wts_atc</th>\n",
+                            "    </tr>\n",
+                            "  </thead>\n",
+                            "  <tbody>\n",
+                            "    <tr>\n",
+                            "      <th>0</th>\n",
+                            "      <td>1</td>\n",
+                            "      <td>379</td>\n",
+                            "      <td>56</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>50.1</td>\n",
+                            "      <td>0.393401</td>\n",
+                            "      <td>1.000000</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>1</th>\n",
+                            "      <td>2</td>\n",
+                            "      <td>528</td>\n",
+                            "      <td>39</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>59.4</td>\n",
+                            "      <td>0.427308</td>\n",
+                            "      <td>1.000000</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>2</th>\n",
+                            "      <td>3</td>\n",
+                            "      <td>608</td>\n",
+                            "      <td>54</td>\n",
+                            "      <td>1</td>\n",
+                            "      <td>34.9</td>\n",
+                            "      <td>0.759827</td>\n",
+                            "      <td>0.316089</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>3</th>\n",
+                            "      <td>4</td>\n",
+                            "      <td>265</td>\n",
+                            "      <td>21</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>82.8</td>\n",
+                            "      <td>0.036798</td>\n",
+                            "      <td>1.000000</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>4</th>\n",
+                            "      <td>5</td>\n",
+                            "      <td>543</td>\n",
+                            "      <td>51</td>\n",
+                            "      <td>0</td>\n",
+                            "      <td>42.5</td>\n",
+                            "      <td>0.622325</td>\n",
+                            "      <td>1.000000</td>\n",
+                            "    </tr>\n",
+                            "  </tbody>\n",
+                            "</table>\n",
+                            "</div>"
+                        ],
+                        "text/plain": [
+                            "   id  income  health  net  malaria_risk        ps   wts_atc\n",
+                            "0   1     379      56    0          50.1  0.393401  1.000000\n",
+                            "1   2     528      39    0          59.4  0.427308  1.000000\n",
+                            "2   3     608      54    1          34.9  0.759827  0.316089\n",
+                            "3   4     265      21    0          82.8  0.036798  1.000000\n",
+                            "4   5     543      51    0          42.5  0.622325  1.000000"
+                        ]
+                    },
+                    "execution_count": 14,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "data_wt_atc = (\n",
+                "    data_ps\n",
+                "      .assign(\n",
+                "          wts_atc = (1 - data_ps['ps']) * data_ps['net'] / data_ps['ps'] + (1 - data_ps['net'])\n",
+                "      )\n",
+                ")\n",
+                "\n",
+                "data_wt_atc.head()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 15,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "plot_mirror_histogram(\n",
+                "    data = data_wt_atc,\n",
+                "    var = 'ps',\n",
+                "    group = 'net',\n",
+                "    weights = 'wts_atc'\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "#### Checking Covariate Balance"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 16,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/html": [
+                            "<div>\n",
+                            "<style scoped>\n",
+                            "    .dataframe tbody tr th:only-of-type {\n",
+                            "        vertical-align: middle;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe tbody tr th {\n",
+                            "        vertical-align: top;\n",
+                            "    }\n",
+                            "\n",
+                            "    .dataframe thead th {\n",
+                            "        text-align: right;\n",
+                            "    }\n",
+                            "</style>\n",
+                            "<table border=\"1\" class=\"dataframe\">\n",
+                            "  <thead>\n",
+                            "    <tr style=\"text-align: right;\">\n",
+                            "      <th></th>\n",
+                            "      <th>variables</th>\n",
+                            "      <th>unadjusted_smd</th>\n",
+                            "      <th>adjusted_smd</th>\n",
+                            "    </tr>\n",
+                            "  </thead>\n",
+                            "  <tbody>\n",
+                            "    <tr>\n",
+                            "      <th>0</th>\n",
+                            "      <td>income</td>\n",
+                            "      <td>1.098326</td>\n",
+                            "      <td>0.128953</td>\n",
+                            "    </tr>\n",
+                            "    <tr>\n",
+                            "      <th>1</th>\n",
+                            "      <td>health</td>\n",
+                            "      <td>1.147354</td>\n",
+                            "      <td>0.176100</td>\n",
+                            "    </tr>\n",
+                            "  </tbody>\n",
+                            "</table>\n",
+                            "</div>"
+                        ],
+                        "text/plain": [
+                            "  variables  unadjusted_smd  adjusted_smd\n",
+                            "0    income        1.098326      0.128953\n",
+                            "1    health        1.147354      0.176100"
+                        ]
+                    },
+                    "execution_count": 16,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "smd_df_atc = compute_smd(\n",
+                "    data = data_wt_atc,\n",
+                "    vars = ['income', 'health'],\n",
+                "    group = 'net',\n",
+                "    wt_var = 'wts_atc',\n",
+                "    estimand = 'ATC'\n",
+                ")\n",
+                "\n",
+                "smd_df_atc"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 20,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 1000x600 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "plot_smd(smd_df_atc, add_ref_line = True)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "#### Estimating ATC"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 21,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "outcome_model_atc = (\n",
+                "    smf.wls(\n",
+                "        \"malaria_risk ~ net\",\n",
+                "        data = data_wt_atc,\n",
+                "        weights = data_wt_atc['wts_atc']\n",
+                "    )\n",
+                "    .fit()\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 29,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "np.float64(-11.719789670723687)"
+                        ]
+                    },
+                    "execution_count": 29,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "untreated = data_wt_atc.loc[nets.net == 0]\n",
+                "\n",
+                "pred_1 = (\n",
+                "    outcome_model_atc\n",
+                "      .predict(\n",
+                "          untreated.assign(net = 1)\n",
+                "      )\n",
+                ")\n",
+                "\n",
+                "pred_0 = (\n",
+                "    outcome_model_atc\n",
+                "      .predict(\n",
+                "          untreated.assign(net = 0)\n",
+                "      )\n",
+                ")\n",
+                "\n",
+                "(pred_1 - pred_0).mean()\n",
+                "\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "So People who don't currently use mosquito nets would see a malaria risk reduction of 11.7 points, on average. This ATC estimate is helpful for understanding the effect of net usage on people who don't use them right now; this shows what would happen if we expanded the program or gave nets to people without them"
+            ]
         }
     ],
     "metadata": {

From b90fddbc38f9d5547cd4f813b30673a4861c3e7b Mon Sep 17 00:00:00 2001
From: shafayetShafee <sshafee@isrt.ac.bd>
Date: Tue, 13 Aug 2024 14:58:32 +0600
Subject: [PATCH 4/6] build: version 0.3.0

---
 CHANGELOG.md   | 4 ++++
 pyproject.toml | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c589029..b773b54 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## v0.3.0 (13/08/2024)
+
+- Added support for computing SMD for ATC and ATT causal estimand in case of binary treatment.
+
 ## v0.2.0 (12/08/2024)
 
 - Changed the modules structure.
diff --git a/pyproject.toml b/pyproject.toml
index ee19c25..7cfda57 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "skmiscpy"
-version = "0.2.0"
+version = "0.3.0"
 description = "Contains a few functions useful for data-analysis, causal inference etc."
 authors = ["Shafayet Khan Shafee"]
 license = "MIT"

From 2fad549afa38ae66ba4e8ff3784be2d3c0fff193 Mon Sep 17 00:00:00 2001
From: shafayetShafee <sshafee@isrt.ac.bd>
Date: Tue, 13 Aug 2024 17:47:57 +0600
Subject: [PATCH 5/6] build: add PSR as dev deps

---
 poetry.lock    | 180 ++++++++++++++++++++++++++++++++++++++++++++++++-
 pyproject.toml |   4 ++
 2 files changed, 183 insertions(+), 1 deletion(-)

diff --git a/poetry.lock b/poetry.lock
index 7c2ed3f..0bac872 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -509,6 +509,25 @@ files = [
 [package.dependencies]
 colorama = {version = "*", markers = "platform_system == \"Windows\""}
 
+[[package]]
+name = "click-option-group"
+version = "0.5.6"
+description = "Option groups missing in Click"
+optional = false
+python-versions = ">=3.6,<4"
+files = [
+    {file = "click-option-group-0.5.6.tar.gz", hash = "sha256:97d06703873518cc5038509443742b25069a3c7562d1ea72ff08bfadde1ce777"},
+    {file = "click_option_group-0.5.6-py3-none-any.whl", hash = "sha256:38a26d963ee3ad93332ddf782f9259c5bdfe405e73408d943ef5e7d0c3767ec7"},
+]
+
+[package.dependencies]
+Click = ">=7.0,<9"
+
+[package.extras]
+docs = ["Pallets-Sphinx-Themes", "m2r2", "sphinx"]
+tests = ["pytest"]
+tests-cov = ["coverage", "coveralls", "pytest", "pytest-cov"]
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -766,6 +785,17 @@ files = [
     {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"},
 ]
 
+[[package]]
+name = "dotty-dict"
+version = "1.3.1"
+description = "Dictionary wrapper for quick access to deeply nested keys."
+optional = false
+python-versions = ">=3.5,<4.0"
+files = [
+    {file = "dotty_dict-1.3.1-py3-none-any.whl", hash = "sha256:5022d234d9922f13aa711b4950372a06a6d64cb6d6db9ba43d0ba133ebfce31f"},
+    {file = "dotty_dict-1.3.1.tar.gz", hash = "sha256:4b016e03b8ae265539757a53eba24b9bfda506fb94fbce0bee843c6f05541a15"},
+]
+
 [[package]]
 name = "exceptiongroup"
 version = "1.2.2"
@@ -884,6 +914,38 @@ files = [
     {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"},
 ]
 
+[[package]]
+name = "gitdb"
+version = "4.0.11"
+description = "Git Object Database"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "gitdb-4.0.11-py3-none-any.whl", hash = "sha256:81a3407ddd2ee8df444cbacea00e2d038e40150acfa3001696fe0dcf1d3adfa4"},
+    {file = "gitdb-4.0.11.tar.gz", hash = "sha256:bf5421126136d6d0af55bc1e7c1af1c397a34f5b7bd79e776cd3e89785c2b04b"},
+]
+
+[package.dependencies]
+smmap = ">=3.0.1,<6"
+
+[[package]]
+name = "gitpython"
+version = "3.1.43"
+description = "GitPython is a Python library used to interact with Git repositories"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "GitPython-3.1.43-py3-none-any.whl", hash = "sha256:eec7ec56b92aad751f9912a73404bc02ba212a23adb2c7098ee668417051a1ff"},
+    {file = "GitPython-3.1.43.tar.gz", hash = "sha256:35f314a9f878467f5453cc1fee295c3e18e52f1b99f10f6cf5b1682e968a9e7c"},
+]
+
+[package.dependencies]
+gitdb = ">=4.0.1,<5"
+
+[package.extras]
+doc = ["sphinx (==4.3.2)", "sphinx-autodoc-typehints", "sphinx-rtd-theme", "sphinxcontrib-applehelp (>=1.0.2,<=1.0.4)", "sphinxcontrib-devhelp (==1.0.2)", "sphinxcontrib-htmlhelp (>=2.0.0,<=2.0.1)", "sphinxcontrib-qthelp (==1.0.3)", "sphinxcontrib-serializinghtml (==1.1.5)"]
+test = ["coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "typing-extensions"]
+
 [[package]]
 name = "greenlet"
 version = "3.0.3"
@@ -2776,6 +2838,25 @@ files = [
 [package.dependencies]
 six = ">=1.5"
 
+[[package]]
+name = "python-gitlab"
+version = "4.9.0"
+description = "A python wrapper for the GitLab API"
+optional = false
+python-versions = ">=3.8.0"
+files = [
+    {file = "python_gitlab-4.9.0-py3-none-any.whl", hash = "sha256:0c8b7220055072bc44a344ea944237f1251f8dcdd9eae88c4b2fb5c1af2085fa"},
+    {file = "python_gitlab-4.9.0.tar.gz", hash = "sha256:df44dbb6e9c941e7ebfb9244e7ed4aa4db90f5c16498cb2d135b8e6e7f089a1a"},
+]
+
+[package.dependencies]
+requests = ">=2.32.0"
+requests-toolbelt = ">=1.0.0"
+
+[package.extras]
+autocompletion = ["argcomplete (>=1.10.0,<3)"]
+yaml = ["PyYaml (>=6.0.1)"]
+
 [[package]]
 name = "python-json-logger"
 version = "2.0.7"
@@ -2787,6 +2868,38 @@ files = [
     {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"},
 ]
 
+[[package]]
+name = "python-semantic-release"
+version = "9.8.6"
+description = "Automatic Semantic Versioning for Python projects"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "python_semantic_release-9.8.6-py3-none-any.whl", hash = "sha256:018729c09edbb1d4ad8b08af81bc2a42d002d54e37f87ed4b706fa283636ce3f"},
+    {file = "python_semantic_release-9.8.6.tar.gz", hash = "sha256:6e2e4626112bdbf43e86aac4535557e8c0a9274a4ea5352f14623cbabbfe498a"},
+]
+
+[package.dependencies]
+click = ">=8.0,<9.0"
+click-option-group = ">=0.5,<1.0"
+dotty-dict = ">=1.3,<2.0"
+gitpython = ">=3.0,<4.0"
+importlib-resources = ">=6.0,<7.0"
+jinja2 = ">=3.1,<4.0"
+pydantic = ">=2.0,<3.0"
+python-gitlab = ">=4.0,<5.0"
+requests = ">=2.25,<3.0"
+rich = ">=13.0,<14.0"
+shellingham = ">=1.5,<2.0"
+tomlkit = ">=0.11,<1.0"
+
+[package.extras]
+build = ["build (>=1.2,<2.0)"]
+dev = ["pre-commit (>=3.5,<4.0)", "ruff (==0.5.0)", "tox (>=4.11,<5.0)"]
+docs = ["Sphinx (>=6.0,<7.0)", "furo (>=2024.1,<2025.0)", "sphinx-autobuild (==2024.2.4)", "sphinxcontrib-apidoc (==0.5.0)"]
+mypy = ["mypy (==1.10.1)", "types-requests (>=2.32.0,<2.33.0)"]
+test = ["coverage[toml] (>=7.0,<8.0)", "pytest (>=7.0,<8.0)", "pytest-clarity (>=1.0,<2.0)", "pytest-cov (>=5.0,<6.0)", "pytest-env (>=1.0,<2.0)", "pytest-lazy-fixture (>=0.6.3,<0.7.0)", "pytest-mock (>=3.0,<4.0)", "pytest-pretty (>=1.2,<2.0)", "pytest-xdist (>=3.0,<4.0)", "requests-mock (>=1.10,<2.0)", "responses (>=0.25.0,<0.26.0)", "types-pytest-lazy-fixture (>=0.6.3,<0.7.0)"]
+
 [[package]]
 name = "pytz"
 version = "2024.1"
@@ -3097,6 +3210,20 @@ urllib3 = ">=1.21.1,<3"
 socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+description = "A utility belt for advanced users of python-requests"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"},
+    {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"},
+]
+
+[package.dependencies]
+requests = ">=2.0.1,<3.0.0"
+
 [[package]]
 name = "rfc3339-validator"
 version = "0.1.4"
@@ -3122,6 +3249,24 @@ files = [
     {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"},
 ]
 
+[[package]]
+name = "rich"
+version = "13.7.1"
+description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal"
+optional = false
+python-versions = ">=3.7.0"
+files = [
+    {file = "rich-13.7.1-py3-none-any.whl", hash = "sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222"},
+    {file = "rich-13.7.1.tar.gz", hash = "sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432"},
+]
+
+[package.dependencies]
+markdown-it-py = ">=2.2.0"
+pygments = ">=2.13.0,<3.0.0"
+
+[package.extras]
+jupyter = ["ipywidgets (>=7.5.1,<9)"]
+
 [[package]]
 name = "rpds-py"
 version = "0.20.0"
@@ -3329,6 +3474,17 @@ core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.te
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"]
 test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test", "mypy (==1.11.*)", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (<0.4)", "pytest-ruff (>=0.2.1)", "pytest-ruff (>=0.3.2)", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"]
 
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+description = "Tool to Detect Surrounding Shell"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"},
+    {file = "shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de"},
+]
+
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -3340,6 +3496,17 @@ files = [
     {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
 ]
 
+[[package]]
+name = "smmap"
+version = "5.0.1"
+description = "A pure Python implementation of a sliding window memory map manager"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "smmap-5.0.1-py3-none-any.whl", hash = "sha256:e6d8668fa5f93e706934a62d7b4db19c8d9eb8cf2adbb75ef1b675aa332b69da"},
+    {file = "smmap-5.0.1.tar.gz", hash = "sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62"},
+]
+
 [[package]]
 name = "sniffio"
 version = "1.3.1"
@@ -3802,6 +3969,17 @@ files = [
     {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]
 
+[[package]]
+name = "tomlkit"
+version = "0.13.0"
+description = "Style preserving TOML library"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "tomlkit-0.13.0-py3-none-any.whl", hash = "sha256:7075d3042d03b80f603482d69bf0c8f345c2b30e41699fd8883227f89972b264"},
+    {file = "tomlkit-0.13.0.tar.gz", hash = "sha256:08ad192699734149f5b97b45f1f18dad7eb1b6d16bc72ad0c2335772650d7b72"},
+]
+
 [[package]]
 name = "tornado"
 version = "6.4.1"
@@ -3997,4 +4175,4 @@ test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools",
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.9"
-content-hash = "7b26d536e88913b6fdbf03f2ada888d1bea5d42f2ad3581179e4de53511bc89a"
+content-hash = "f947e402146e4e6cb63c1cf0c079dd35670197636b5ae573d8484415f7471187"
diff --git a/pyproject.toml b/pyproject.toml
index 7cfda57..d691369 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -26,7 +26,11 @@ sphinx-autoapi = "^3.2.1"
 sphinx-rtd-theme = "^2.0.0"
 linkify-it-py = "^2.0.3"
 sphinx-immaterial = "^0.12.2"
+python-semantic-release = "^9.8.6"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.semantic_release]
+version_variable = "pyproject.toml:version"
\ No newline at end of file

From 3c55a2cfe65da29aba10fc03343a677b7fd90b1d Mon Sep 17 00:00:00 2001
From: shafayetShafee <sshafee@isrt.ac.bd>
Date: Tue, 13 Aug 2024 18:04:15 +0600
Subject: [PATCH 6/6] build: added CI workflow

---
 .github/workflows/ci-cd.yml | 60 ++++++++++++++++++++++++++++++++++++-
 pyproject.toml              |  7 ++++-
 2 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
index 17d529c..0c76391 100644
--- a/.github/workflows/ci-cd.yml
+++ b/.github/workflows/ci-cd.yml
@@ -31,4 +31,62 @@ jobs:
         token: ${{ secrets.CODECOV_TOKEN }}
 
     - name: Build documentation
-      run: poetry run make html --directory docs/
\ No newline at end of file
+      run: poetry run make html --directory docs/
+
+  
+  cd:
+    permissions:
+      id-token: write
+      contents: write
+    # Only run this job if the "ci" job passes
+    needs: ci
+
+    # Only run this job if new work is pushed to "main"
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+
+    # Set up operating system
+    runs-on: ubuntu-latest
+
+    # Define job steps
+    steps:
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.9"
+
+      - name: Check-out repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Use Python Semantic Release to prepare release
+        id: release
+        uses: python-semantic-release/python-semantic-release@v8.3.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        if: steps.release.outputs.released == 'true'
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+
+      - name: Test install from TestPyPI
+        run: |
+            pip install \
+            --index-url https://test.pypi.org/simple/ \
+            --extra-index-url https://pypi.org/simple \
+            skmiscpy
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        if: steps.release.outputs.released == 'true'
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+
+      - name: Publish package distributions to GitHub Releases
+        uses: python-semantic-release/upload-to-gh-release@main
+        if: steps.release.outputs.released == 'true'
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index d691369..eac6716 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -33,4 +33,9 @@ requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.semantic_release]
-version_variable = "pyproject.toml:version"
\ No newline at end of file
+version_toml = [
+    "pyproject.toml:tool.poetry.version",
+]                                                     # version location
+branch = "main"                                       # branch to make releases of
+changelog_file = "CHANGELOG.md"                       # changelog file
+build_command = "pip install poetry && poetry build"  # build dists                                           
\ No newline at end of file