From 4ab3ad6e7215a0a9307aff5e615e13ed29845953 Mon Sep 17 00:00:00 2001
From: Jackson North <jackson.north@utah.edu>
Date: Thu, 12 Feb 2026 17:01:58 -0700
Subject: [PATCH 1/2] Continue working on Task 4

---
 Pandas/4.DataManipulation.ipynb |   2 +-
 Pandas/PandasExercise1.ipynb    | 610 ++++++++++++++++++++++++++++++--
 2 files changed, 580 insertions(+), 32 deletions(-)

diff --git a/Pandas/4.DataManipulation.ipynb b/Pandas/4.DataManipulation.ipynb
index fa8ffff..922034f 100644
--- a/Pandas/4.DataManipulation.ipynb
+++ b/Pandas/4.DataManipulation.ipynb
@@ -1903,7 +1903,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "p310env",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
diff --git a/Pandas/PandasExercise1.ipynb b/Pandas/PandasExercise1.ipynb
index b13c275..01a1949 100644
--- a/Pandas/PandasExercise1.ipynb
+++ b/Pandas/PandasExercise1.ipynb
@@ -19,11 +19,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "2e231547",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(         Date            Precip_in\n",
+       " 0  2024-01-01  0.14028030062619642\n",
+       " 1  2024-01-02   0.6590180328421851\n",
+       " 2  2024-01-03                  0.0\n",
+       " 3  2024-01-04                  0.0\n",
+       " 4  2024-01-05   0.3757291395473922,\n",
+       "               Date Precip_in\n",
+       " count           61        58\n",
+       " unique          60        32\n",
+       " top     2024-01-16       0.0\n",
+       " freq             2        27)"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "# Load rainfall CSV\n",
+    "rain_raw = pd.read_csv(\"data/snotel_rainfall_data.csv\")\n",
+    "\n",
+    "rain_raw.head(), rain_raw.describe(include=\"all\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -42,11 +70,92 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "9c41bef2",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "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>Precip_in</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>56.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>-8.467089</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>150.395286</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>-999.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25%</th>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>0.050563</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75%</th>\n",
+       "      <td>0.682890</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>500.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        Precip_in\n",
+       "count   56.000000\n",
+       "mean    -8.467089\n",
+       "std    150.395286\n",
+       "min   -999.000000\n",
+       "25%      0.000000\n",
+       "50%      0.050563\n",
+       "75%      0.682890\n",
+       "max    500.000000"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rain_raw['Precip_in']= pd.to_numeric(rain_raw['Precip_in'], errors='coerce')\n",
+    "rain_raw.describe()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -64,11 +173,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "4817f0f6",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(         Date Streamflow_cfs\n",
+       " 0  2024-01-01          10.25\n",
+       " 1  2024-01-02           10.7\n",
+       " 2  2024-01-03           13.3\n",
+       " 3  2024-01-04           10.1\n",
+       " 4  2024-01-05           10.0,\n",
+       "               Date Streamflow_cfs\n",
+       " count           60             55\n",
+       " unique          60             37\n",
+       " top     2024-01-01           10.0\n",
+       " freq             1              8)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "stream_raw = pd.read_csv(\"data/streamflow_data.csv\")\n",
+    "\n",
+    "stream_raw.head(), stream_raw.describe(include=\"all\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -88,11 +222,151 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 54,
    "id": "fb7eee2c",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/scratch/local/u1257442/849844/ipykernel_713953/1581712565.py:35: FutureWarning: Downcasting object dtype arrays on .fillna, .ffill, .bfill is deprecated and will change in a future version. Call result.infer_objects(copy=False) instead. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n",
+      "  rain_mean[\"Precip_in\"] = rain_mean[\"Precip_in\"].fillna(r_mean)\n",
+      "/scratch/local/u1257442/849844/ipykernel_713953/1581712565.py:38: FutureWarning: Series.interpolate with object dtype is deprecated and will raise in a future version. Call obj.infer_objects(copy=False) before interpolating instead.\n",
+      "  rain_interp[\"Precip_in\"] = rain_interp[\"Precip_in\"].interpolate(method=\"time\")\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(            Streamflow_cfs\n",
+       " Date                      \n",
+       " 2024-01-01           10.25\n",
+       " 2024-01-02           10.70\n",
+       " 2024-01-03           13.30\n",
+       " 2024-01-04           10.10\n",
+       " 2024-01-05           10.00,\n",
+       "             Streamflow_cfs\n",
+       " Date                      \n",
+       " 2024-01-01           10.25\n",
+       " 2024-01-02           10.70\n",
+       " 2024-01-03           13.30\n",
+       " 2024-01-04           10.10\n",
+       " 2024-01-05           10.00,\n",
+       "             Streamflow_cfs\n",
+       " Date                      \n",
+       " 2024-01-01           10.25\n",
+       " 2024-01-02           10.70\n",
+       " 2024-01-03           13.30\n",
+       " 2024-01-04           10.10\n",
+       " 2024-01-05           10.00,\n",
+       "             Streamflow_cfs\n",
+       " Date                      \n",
+       " 2024-01-01           10.25\n",
+       " 2024-01-02           10.70\n",
+       " 2024-01-03           13.30\n",
+       " 2024-01-04           10.10\n",
+       " 2024-01-05           10.00,\n",
+       "            Precip_in\n",
+       " Date                \n",
+       " 2024-01-01   0.14028\n",
+       " 2024-01-02  0.659018\n",
+       " 2024-01-03       0.0\n",
+       " 2024-01-04       0.0\n",
+       " 2024-01-05  0.375729,\n",
+       "            Precip_in\n",
+       " Date                \n",
+       " 2024-01-01   0.14028\n",
+       " 2024-01-02  0.659018\n",
+       " 2024-01-03       0.0\n",
+       " 2024-01-04       0.0\n",
+       " 2024-01-05  0.375729,\n",
+       "             Precip_in\n",
+       " Date                 \n",
+       " 2024-01-01   0.140280\n",
+       " 2024-01-02   0.659018\n",
+       " 2024-01-03   0.000000\n",
+       " 2024-01-04   0.000000\n",
+       " 2024-01-05   0.375729,\n",
+       "            Precip_in\n",
+       " Date                \n",
+       " 2024-01-01   0.14028\n",
+       " 2024-01-02  0.659018\n",
+       " 2024-01-03       0.0\n",
+       " 2024-01-04       0.0\n",
+       " 2024-01-05  0.375729)"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# convert Date columns if necessary\n",
+    "if \"Date\" in stream_raw.columns:\n",
+    "    stream_raw[\"Date\"] = pd.to_datetime(stream_raw[\"Date\"])\n",
+    "    stream_raw = stream_raw.set_index(\"Date\").sort_index()\n",
+    "\n",
+    "# replace the sentinel value -999 with NaN so pandas methods work\n",
+    "stream_raw[\"Streamflow_cfs\"] = stream_raw[\"Streamflow_cfs\"].replace(-999, pd.NA)\n",
+    "\n",
+    "# create several cleaned versions to compare\n",
+    "stream_drop = stream_raw.dropna(subset=[\"Streamflow_cfs\"])\n",
+    "\n",
+    "# overall mean\n",
+    "m = stream_raw[\"Streamflow_cfs\"].mean()\n",
+    "stream_mean = stream_raw.copy()\n",
+    "stream_mean[\"Streamflow_cfs\"] = stream_mean[\"Streamflow_cfs\"].fillna(m)\n",
+    "\n",
+    "stream_interp = stream_raw.copy()\n",
+    "stream_interp[\"Streamflow_cfs\"] = stream_interp[\"Streamflow_cfs\"].interpolate(method=\"time\")\n",
+    "\n",
+    "# do the same for rainfall data\n",
+    "if \"Date\" in rain_raw.columns:\n",
+    "    rain_raw[\"Date\"] = pd.to_datetime(rain_raw[\"Date\"])\n",
+    "    rain_raw = rain_raw.set_index(\"Date\").sort_index()\n",
+    "\n",
+    "# convert precip to numeric already done, replace -999 if present\n",
+    "rain_raw[\"Precip_in\"] = rain_raw[\"Precip_in\"].replace(-999, pd.NA)\n",
+    "\n",
+    "rain_drop = rain_raw.dropna(subset=[\"Precip_in\"])\n",
+    "\n",
+    "# remove outliers\n",
+    "rain_drop = rain_drop[rain_drop[\"Precip_in\"] < 10]\n",
+    "\n",
+    "r_mean = rain_drop[\"Precip_in\"].mean()\n",
+    "rain_mean = rain_drop.copy()\n",
+    "rain_mean[\"Precip_in\"] = rain_mean[\"Precip_in\"].fillna(r_mean)\n",
+    "\n",
+    "rain_interp = rain_raw.copy()\n",
+    "rain_interp[\"Precip_in\"] = rain_interp[\"Precip_in\"].interpolate(method=\"time\")\n",
+    "\n",
+    "# show summaries\n",
+    "stream_raw.head(), stream_drop.head(), stream_mean.head(), stream_interp.head(),\\\n",
+    "rain_raw.head(), rain_drop.head(), rain_mean.head(), rain_interp.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "d9b76623",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.float64(0.4600556588999218)"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r_mean\n"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -108,11 +382,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 41,
    "id": "bd2fa519",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "rainfall_methods = {\"raw\": rain_raw, \"drop\": rain_drop, \"mean\": rain_mean, \"interpolate\": rain_interp}\n",
+    "streamflow_methods = {\"raw\": stream_raw, \"drop\": stream_drop, \"mean\": stream_mean, \"interpolate\": stream_interp}\n",
+    "\n",
+    "dataframe_dict = {\"rainfall\": rainfall_methods, \"streamflow\": streamflow_methods}"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -126,11 +405,49 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 42,
    "id": "9c76bf67",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# visualize streamflow methods\n",
+    "def plot_methods(df_dict, column, title):\n",
+    "    fig, ax = plt.subplots()\n",
+    "    for name, df in df_dict.items():\n",
+    "        series = pd.to_numeric(df[column], errors='coerce')  # convert and force NA->nan\n",
+    "        ax.plot(df.index, series, label=name)\n",
+    "    ax.set_title(title)\n",
+    "    ax.legend()\n",
+    "    ax.set_xlabel('Date')\n",
+    "    ax.set_ylabel(column)\n",
+    "    plt.show()\n",
+    "\n",
+    "plot_methods(streamflow_methods, 'Streamflow_cfs', 'Streamflow gap‑filling methods')\n",
+    "plot_methods(rainfall_methods, 'Precip_in', 'Rainfall gap‑filling methods')"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -144,11 +461,95 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 37,
    "id": "1e688b18",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "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>Precip_in</th>\n",
+       "      <th>Streamflow_cfs</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Date</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2024-01-01</th>\n",
+       "      <td>0.14028</td>\n",
+       "      <td>10.25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-02</th>\n",
+       "      <td>0.659018</td>\n",
+       "      <td>10.7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-03</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>13.3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-04</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>10.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-05</th>\n",
+       "      <td>0.375729</td>\n",
+       "      <td>10.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           Precip_in Streamflow_cfs\n",
+       "Date                               \n",
+       "2024-01-01   0.14028          10.25\n",
+       "2024-01-02  0.659018           10.7\n",
+       "2024-01-03       0.0           13.3\n",
+       "2024-01-04       0.0           10.1\n",
+       "2024-01-05  0.375729           10.0"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# choose interpolated series for both variables and merge into one frame\n",
+    "rain_flow_df = pd.DataFrame({\n",
+    "    'Precip_in': rain_interp['Precip_in'],\n",
+    "    'Streamflow_cfs': stream_interp['Streamflow_cfs']\n",
+    "})\n",
+    "\n",
+    "rain_flow_df.head()\n",
+    "# display a preview"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -162,11 +563,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 36,
    "id": "d481b613",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/scratch/local/u1257442/849844/ipykernel_713953/2372665443.py:1: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.\n",
+      "  monthly_stream = stream_raw.resample('M').mean()\n",
+      "/scratch/local/u1257442/849844/ipykernel_713953/2372665443.py:2: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.\n",
+      "  monthly_rain = rain_raw.resample('M').mean()\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(            Streamflow_cfs\n",
+       " Date                      \n",
+       " 2024-01-31       12.112500\n",
+       " 2024-02-29       99.015517,\n",
+       "            Precip_in\n",
+       " Date                \n",
+       " 2024-01-31  0.437921\n",
+       " 2024-02-29  18.98449)"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "monthly_stream = stream_raw.resample('M').mean()\n",
+    "monthly_rain = rain_raw.resample('M').mean()\n",
+    "monthly_stream.head(), monthly_rain.head()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -175,16 +608,107 @@
    "source": [
     "## Task 9: Data Corrections\n",
     "\n",
-    "We want to put the data into a streamflow model, but it requires precipitation to be in mm and streamflow to be in CMS (cubic meters per second). Create a new dataframe called rain_flow_SI_df that converts the previous dataframe to SI units."
+    "We want to put the data into a streamflow model, but it requires precipitation to be in mm and streamflow to be in CMS (cubic meters per second). Create a new dataframe called rain_flow_SI_df that converts the previous dataframe to SI units.\n",
+    "\n",
+    "(The code below assumes `rain_flow_df` was defined in Task 7.)\n",
+    "\n",
+    "The conversion factors used are:\n",
+    "\n",
+    "* inches → millimetres: ×25.4* cubic feet‑per‑second → cubic metres‑per‑second: ×0.0283168"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 38,
    "id": "6d73bc7f",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "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>Precip_mm</th>\n",
+       "      <th>Streamflow_cms</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Date</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2024-01-01</th>\n",
+       "      <td>3.56312</td>\n",
+       "      <td>0.290247</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-02</th>\n",
+       "      <td>16.739058</td>\n",
+       "      <td>0.30299</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-03</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.376613</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-04</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.286</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-01-05</th>\n",
+       "      <td>9.54352</td>\n",
+       "      <td>0.283168</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            Precip_mm Streamflow_cms\n",
+       "Date                                \n",
+       "2024-01-01    3.56312       0.290247\n",
+       "2024-01-02  16.739058        0.30299\n",
+       "2024-01-03        0.0       0.376613\n",
+       "2024-01-04        0.0          0.286\n",
+       "2024-01-05    9.54352       0.283168"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# convert to SI units using previously merged rain_flow_df\n",
+    "rain_flow_SI_df = rain_flow_df.copy()\n",
+    "rain_flow_SI_df['Precip_mm'] = rain_flow_SI_df['Precip_in'] * 25.4\n",
+    "rain_flow_SI_df['Streamflow_cms'] = rain_flow_SI_df['Streamflow_cfs'] * 0.0283168\n",
+    "\n",
+    "# drop original imperial columns if you like\n",
+    "rain_flow_SI_df = rain_flow_SI_df.drop(columns=['Precip_in','Streamflow_cfs'])\n",
+    "\n",
+    "rain_flow_SI_df.head()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -200,11 +724,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 46,
    "id": "2c9b3495",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "boolean value of NA is ambiguous",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[46], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m columns \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDry\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mLight Rain\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mModerate Rain\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mHeavy Rain\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m----> 2\u001b[0m rain_flow_SI_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRain_Category\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcut\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrain_flow_SI_df\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mPrecip_mm\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[43mbins\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2.5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m7.6\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      5\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolumns\u001b[49m\n\u001b[1;32m      6\u001b[0m \u001b[43m)\u001b[49m                                         \n",
+      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/reshape/tile.py:257\u001b[0m, in \u001b[0;36mcut\u001b[0;34m(x, bins, right, labels, retbins, precision, include_lowest, duplicates, ordered)\u001b[0m\n\u001b[1;32m    254\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m bins\u001b[38;5;241m.\u001b[39mis_monotonic_increasing:\n\u001b[1;32m    255\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbins must increase monotonically.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 257\u001b[0m fac, bins \u001b[38;5;241m=\u001b[39m \u001b[43m_bins_to_cuts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    258\u001b[0m \u001b[43m    \u001b[49m\u001b[43mx_idx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    259\u001b[0m \u001b[43m    \u001b[49m\u001b[43mbins\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    260\u001b[0m \u001b[43m    \u001b[49m\u001b[43mright\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mright\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    261\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlabels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    262\u001b[0m \u001b[43m    \u001b[49m\u001b[43mprecision\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprecision\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    263\u001b[0m \u001b[43m    \u001b[49m\u001b[43minclude_lowest\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minclude_lowest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    264\u001b[0m \u001b[43m    \u001b[49m\u001b[43mduplicates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mduplicates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    265\u001b[0m \u001b[43m    \u001b[49m\u001b[43mordered\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mordered\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    266\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    268\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _postprocess_for_cut(fac, bins, retbins, original)\n",
+      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/reshape/tile.py:452\u001b[0m, in \u001b[0;36m_bins_to_cuts\u001b[0;34m(x_idx, bins, right, labels, precision, include_lowest, duplicates, ordered)\u001b[0m\n\u001b[1;32m    449\u001b[0m side: Literal[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mleft\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mright\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mleft\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m right \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mright\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    451\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 452\u001b[0m     ids \u001b[38;5;241m=\u001b[39m \u001b[43mbins\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msearchsorted\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mside\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    453\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[1;32m    454\u001b[0m     \u001b[38;5;66;03m# e.g. test_datetime_nan_error if bins are DatetimeArray and x_idx\u001b[39;00m\n\u001b[1;32m    455\u001b[0m     \u001b[38;5;66;03m#  is integers\u001b[39;00m\n\u001b[1;32m    456\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m x_idx\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39mkind \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mm\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n",
+      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/base.py:1361\u001b[0m, in \u001b[0;36mIndexOpsMixin.searchsorted\u001b[0;34m(self, value, side, sorter)\u001b[0m\n\u001b[1;32m   1357\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(values, np\u001b[38;5;241m.\u001b[39mndarray):\n\u001b[1;32m   1358\u001b[0m     \u001b[38;5;66;03m# Going through EA.searchsorted directly improves performance GH#38083\u001b[39;00m\n\u001b[1;32m   1359\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m values\u001b[38;5;241m.\u001b[39msearchsorted(value, side\u001b[38;5;241m=\u001b[39mside, sorter\u001b[38;5;241m=\u001b[39msorter)\n\u001b[0;32m-> 1361\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43malgorithms\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msearchsorted\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1362\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1363\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1364\u001b[0m \u001b[43m    \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mside\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1365\u001b[0m \u001b[43m    \u001b[49m\u001b[43msorter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msorter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1366\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/algorithms.py:1329\u001b[0m, in \u001b[0;36msearchsorted\u001b[0;34m(arr, value, side, sorter)\u001b[0m\n\u001b[1;32m   1325\u001b[0m     arr \u001b[38;5;241m=\u001b[39m ensure_wrapped_if_datetimelike(arr)\n\u001b[1;32m   1327\u001b[0m \u001b[38;5;66;03m# Argument 1 to \"searchsorted\" of \"ndarray\" has incompatible type\u001b[39;00m\n\u001b[1;32m   1328\u001b[0m \u001b[38;5;66;03m# \"Union[NumpyValueArrayLike, ExtensionArray]\"; expected \"NumpyValueArrayLike\"\u001b[39;00m\n\u001b[0;32m-> 1329\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43marr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msearchsorted\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mside\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msorter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msorter\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32mpandas/_libs/missing.pyx:392\u001b[0m, in \u001b[0;36mpandas._libs.missing.NAType.__bool__\u001b[0;34m()\u001b[0m\n",
+      "\u001b[0;31mTypeError\u001b[0m: boolean value of NA is ambiguous"
+     ]
+    }
+   ],
+   "source": [
+    "columns = ['Dry', 'Light Rain', 'Moderate Rain', 'Heavy Rain']\n",
+    "rain_flow_SI_df['Rain_Category'] = pd.cut(\n",
+    "    rain_flow_SI_df['Precip_mm'],\n",
+    "    bins=[-float('inf'), 0.1, 2.5, 7.6, float('inf')],\n",
+    "    labels=columns\n",
+    ")                                         "
+   ]
   },
   {
    "cell_type": "markdown",
@@ -239,7 +787,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "p310env",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },

From 7e9b15702dd29a5c64952327f85e5952792af6e5 Mon Sep 17 00:00:00 2001
From: Jackson North <jackson.north@utah.edu>
Date: Fri, 13 Feb 2026 09:13:11 -0700
Subject: [PATCH 2/2] Update exercise answers

---
 Pandas/PandasExercise1.ipynb | 613 +++++++++++++++++------------------
 1 file changed, 299 insertions(+), 314 deletions(-)

diff --git a/Pandas/PandasExercise1.ipynb b/Pandas/PandasExercise1.ipynb
index 01a1949..74bea38 100644
--- a/Pandas/PandasExercise1.ipynb
+++ b/Pandas/PandasExercise1.ipynb
@@ -46,6 +46,7 @@
    ],
    "source": [
     "import pandas as pd\n",
+    "import numpy as np\n",
     "\n",
     "# Load rainfall CSV\n",
     "rain_raw = pd.read_csv(\"data/snotel_rainfall_data.csv\")\n",
@@ -76,75 +77,23 @@
    "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>Precip_in</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>count</th>\n",
-       "      <td>56.000000</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>mean</th>\n",
-       "      <td>-8.467089</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>std</th>\n",
-       "      <td>150.395286</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>min</th>\n",
-       "      <td>-999.000000</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>25%</th>\n",
-       "      <td>0.000000</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>50%</th>\n",
-       "      <td>0.050563</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>75%</th>\n",
-       "      <td>0.682890</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>max</th>\n",
-       "      <td>500.000000</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
       "text/plain": [
-       "        Precip_in\n",
-       "count   56.000000\n",
-       "mean    -8.467089\n",
-       "std    150.395286\n",
-       "min   -999.000000\n",
-       "25%      0.000000\n",
-       "50%      0.050563\n",
-       "75%      0.682890\n",
-       "max    500.000000"
+       "(             rain_mm\n",
+       " Date                \n",
+       " 2024-01-01  0.140280\n",
+       " 2024-01-02  0.659018\n",
+       " 2024-01-03  0.000000\n",
+       " 2024-01-04  0.000000\n",
+       " 2024-01-05  0.375729,\n",
+       "           rain_mm\n",
+       " count   56.000000\n",
+       " mean    -8.467089\n",
+       " std    150.395286\n",
+       " min   -999.000000\n",
+       " 25%      0.000000\n",
+       " 50%      0.050563\n",
+       " 75%      0.682890\n",
+       " max    500.000000)"
       ]
      },
      "execution_count": 2,
@@ -153,8 +102,24 @@
     }
    ],
    "source": [
-    "rain_raw['Precip_in']= pd.to_numeric(rain_raw['Precip_in'], errors='coerce')\n",
-    "rain_raw.describe()"
+    "# Try to identify likely columns\n",
+    "rain_raw.columns\n",
+    "\n",
+    "# Heuristic: pick the first column that looks like a date, and the first non-date numeric-ish column\n",
+    "date_col = rain_raw.columns[0]\n",
+    "value_col = rain_raw.columns[1] if len(rain_raw.columns) > 1 else rain_raw.columns[0]\n",
+    "\n",
+    "# Parse date\n",
+    "rain_raw[date_col] = pd.to_datetime(rain_raw[date_col], errors=\"coerce\")\n",
+    "\n",
+    "# Coerce rainfall values to numeric\n",
+    "rain_raw[value_col] = pd.to_numeric(rain_raw[value_col], errors=\"coerce\")\n",
+    "\n",
+    "# Build the requested DataFrame name: Rainfall_mm\n",
+    "Rainfall_mm = rain_raw[[date_col, value_col]].dropna(subset=[date_col]).set_index(date_col).sort_index()\n",
+    "Rainfall_mm.columns = [\"rain_mm\"]\n",
+    "\n",
+    "Rainfall_mm.head(), Rainfall_mm.describe()"
    ]
   },
   {
@@ -180,17 +145,35 @@
     {
      "data": {
       "text/plain": [
-       "(         Date Streamflow_cfs\n",
-       " 0  2024-01-01          10.25\n",
-       " 1  2024-01-02           10.7\n",
-       " 2  2024-01-03           13.3\n",
-       " 3  2024-01-04           10.1\n",
-       " 4  2024-01-05           10.0,\n",
-       "               Date Streamflow_cfs\n",
-       " count           60             55\n",
-       " unique          60             37\n",
-       " top     2024-01-01           10.0\n",
-       " freq             1              8)"
+       "(            flow_cfs\n",
+       " Date                \n",
+       " 2024-01-01     10.25\n",
+       " 2024-01-02     10.70\n",
+       " 2024-01-03     13.30\n",
+       " 2024-01-04     10.10\n",
+       " 2024-01-05     10.00,\n",
+       "           flow_cfs\n",
+       " count    54.000000\n",
+       " mean     40.058333\n",
+       " std     369.096212\n",
+       " min    -999.000000\n",
+       " 25%      10.100000\n",
+       " 50%      10.600000\n",
+       " 75%      13.900000\n",
+       " max    2510.000000,\n",
+       " count       54.000000\n",
+       " mean        40.058333\n",
+       " median      10.600000\n",
+       " min       -999.000000\n",
+       " max       2510.000000\n",
+       " std        369.096212\n",
+       " Name: flow_cfs, dtype: float64,\n",
+       " 0.05    10.0000\n",
+       " 0.25    10.1000\n",
+       " 0.50    10.6000\n",
+       " 0.75    13.9000\n",
+       " 0.95    21.3525\n",
+       " Name: flow_cfs, dtype: float64)"
       ]
      },
      "execution_count": 3,
@@ -199,9 +182,25 @@
     }
    ],
    "source": [
-    "stream_raw = pd.read_csv(\"data/streamflow_data.csv\")\n",
+    "flow_raw = pd.read_csv(\"data/streamflow_data.csv\")\n",
+    "\n",
+    "flow_raw.head(), flow_raw.describe(include=\"all\")\n",
+    "\n",
+    "# Identify columns similarly\n",
+    "flow_date_col = flow_raw.columns[0]\n",
+    "flow_value_col = flow_raw.columns[1] if len(flow_raw.columns) > 1 else flow_raw.columns[0]\n",
     "\n",
-    "stream_raw.head(), stream_raw.describe(include=\"all\")"
+    "flow_raw[flow_date_col] = pd.to_datetime(flow_raw[flow_date_col], errors=\"coerce\")\n",
+    "flow_raw[flow_value_col] = pd.to_numeric(flow_raw[flow_value_col], errors=\"coerce\")\n",
+    "\n",
+    "streamflow_cfs = flow_raw[[flow_date_col, flow_value_col]].dropna(subset=[flow_date_col]).set_index(flow_date_col).sort_index()\n",
+    "streamflow_cfs.columns = [\"flow_cfs\"]\n",
+    "\n",
+    "# More useful stats:\n",
+    "stats = streamflow_cfs[\"flow_cfs\"].agg([\"count\",\"mean\",\"median\",\"min\",\"max\",\"std\"])\n",
+    "quantiles = streamflow_cfs[\"flow_cfs\"].quantile([0.05, 0.25, 0.5, 0.75, 0.95])\n",
+    "\n",
+    "streamflow_cfs.head(), streamflow_cfs.describe(), stats, quantiles"
    ]
   },
   {
@@ -222,150 +221,57 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": 10,
    "id": "fb7eee2c",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/scratch/local/u1257442/849844/ipykernel_713953/1581712565.py:35: FutureWarning: Downcasting object dtype arrays on .fillna, .ffill, .bfill is deprecated and will change in a future version. Call result.infer_objects(copy=False) instead. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n",
-      "  rain_mean[\"Precip_in\"] = rain_mean[\"Precip_in\"].fillna(r_mean)\n",
-      "/scratch/local/u1257442/849844/ipykernel_713953/1581712565.py:38: FutureWarning: Series.interpolate with object dtype is deprecated and will raise in a future version. Call obj.infer_objects(copy=False) before interpolating instead.\n",
-      "  rain_interp[\"Precip_in\"] = rain_interp[\"Precip_in\"].interpolate(method=\"time\")\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "(            Streamflow_cfs\n",
-       " Date                      \n",
-       " 2024-01-01           10.25\n",
-       " 2024-01-02           10.70\n",
-       " 2024-01-03           13.30\n",
-       " 2024-01-04           10.10\n",
-       " 2024-01-05           10.00,\n",
-       "             Streamflow_cfs\n",
-       " Date                      \n",
-       " 2024-01-01           10.25\n",
-       " 2024-01-02           10.70\n",
-       " 2024-01-03           13.30\n",
-       " 2024-01-04           10.10\n",
-       " 2024-01-05           10.00,\n",
-       "             Streamflow_cfs\n",
-       " Date                      \n",
-       " 2024-01-01           10.25\n",
-       " 2024-01-02           10.70\n",
-       " 2024-01-03           13.30\n",
-       " 2024-01-04           10.10\n",
-       " 2024-01-05           10.00,\n",
-       "             Streamflow_cfs\n",
-       " Date                      \n",
-       " 2024-01-01           10.25\n",
-       " 2024-01-02           10.70\n",
-       " 2024-01-03           13.30\n",
-       " 2024-01-04           10.10\n",
-       " 2024-01-05           10.00,\n",
-       "            Precip_in\n",
-       " Date                \n",
-       " 2024-01-01   0.14028\n",
-       " 2024-01-02  0.659018\n",
-       " 2024-01-03       0.0\n",
-       " 2024-01-04       0.0\n",
-       " 2024-01-05  0.375729,\n",
-       "            Precip_in\n",
-       " Date                \n",
-       " 2024-01-01   0.14028\n",
-       " 2024-01-02  0.659018\n",
-       " 2024-01-03       0.0\n",
-       " 2024-01-04       0.0\n",
-       " 2024-01-05  0.375729,\n",
-       "             Precip_in\n",
-       " Date                 \n",
-       " 2024-01-01   0.140280\n",
-       " 2024-01-02   0.659018\n",
-       " 2024-01-03   0.000000\n",
-       " 2024-01-04   0.000000\n",
-       " 2024-01-05   0.375729,\n",
-       "            Precip_in\n",
-       " Date                \n",
-       " 2024-01-01   0.14028\n",
-       " 2024-01-02  0.659018\n",
-       " 2024-01-03       0.0\n",
-       " 2024-01-04       0.0\n",
-       " 2024-01-05  0.375729)"
+       "(rain_mm    6\n",
+       " dtype: int64,\n",
+       " flow_cfs    7\n",
+       " dtype: int64)"
       ]
      },
-     "execution_count": 54,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# convert Date columns if necessary\n",
-    "if \"Date\" in stream_raw.columns:\n",
-    "    stream_raw[\"Date\"] = pd.to_datetime(stream_raw[\"Date\"])\n",
-    "    stream_raw = stream_raw.set_index(\"Date\").sort_index()\n",
-    "\n",
-    "# replace the sentinel value -999 with NaN so pandas methods work\n",
-    "stream_raw[\"Streamflow_cfs\"] = stream_raw[\"Streamflow_cfs\"].replace(-999, pd.NA)\n",
-    "\n",
-    "# create several cleaned versions to compare\n",
-    "stream_drop = stream_raw.dropna(subset=[\"Streamflow_cfs\"])\n",
-    "\n",
-    "# overall mean\n",
-    "m = stream_raw[\"Streamflow_cfs\"].mean()\n",
-    "stream_mean = stream_raw.copy()\n",
-    "stream_mean[\"Streamflow_cfs\"] = stream_mean[\"Streamflow_cfs\"].fillna(m)\n",
-    "\n",
-    "stream_interp = stream_raw.copy()\n",
-    "stream_interp[\"Streamflow_cfs\"] = stream_interp[\"Streamflow_cfs\"].interpolate(method=\"time\")\n",
-    "\n",
-    "# do the same for rainfall data\n",
-    "if \"Date\" in rain_raw.columns:\n",
-    "    rain_raw[\"Date\"] = pd.to_datetime(rain_raw[\"Date\"])\n",
-    "    rain_raw = rain_raw.set_index(\"Date\").sort_index()\n",
-    "\n",
-    "# convert precip to numeric already done, replace -999 if present\n",
-    "rain_raw[\"Precip_in\"] = rain_raw[\"Precip_in\"].replace(-999, pd.NA)\n",
-    "\n",
-    "rain_drop = rain_raw.dropna(subset=[\"Precip_in\"])\n",
-    "\n",
-    "# remove outliers\n",
-    "rain_drop = rain_drop[rain_drop[\"Precip_in\"] < 10]\n",
-    "\n",
-    "r_mean = rain_drop[\"Precip_in\"].mean()\n",
-    "rain_mean = rain_drop.copy()\n",
-    "rain_mean[\"Precip_in\"] = rain_mean[\"Precip_in\"].fillna(r_mean)\n",
-    "\n",
-    "rain_interp = rain_raw.copy()\n",
-    "rain_interp[\"Precip_in\"] = rain_interp[\"Precip_in\"].interpolate(method=\"time\")\n",
-    "\n",
-    "# show summaries\n",
-    "stream_raw.head(), stream_drop.head(), stream_mean.head(), stream_interp.head(),\\\n",
-    "rain_raw.head(), rain_drop.head(), rain_mean.head(), rain_interp.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "id": "d9b76623",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "np.float64(0.4600556588999218)"
-      ]
-     },
-     "execution_count": 53,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "r_mean\n"
+    "# Replace common bad flags (-999) with NaN, and remove other obvious junk (negative rainfall/flow)\n",
+    "rain_clean0 = Rainfall_mm.copy()\n",
+    "flow_clean0 = streamflow_cfs.copy()\n",
+    "\n",
+    "rain_clean0[\"rain_mm\"] = rain_clean0[\"rain_mm\"].replace(-999, np.nan)\n",
+    "flow_clean0[\"flow_cfs\"] = flow_clean0[\"flow_cfs\"].replace(-999, np.nan)\n",
+    "\n",
+    "# Remove values that don't make physical sense (optional but usually correct)\n",
+    "rain_clean0.loc[rain_clean0[\"rain_mm\"] < 0, \"rain_mm\"] = np.nan\n",
+    "flow_clean0.loc[flow_clean0[\"flow_cfs\"] < 0, \"flow_cfs\"] = np.nan\n",
+    "\n",
+    "# drop any duplicate timestamps – they cause reindex/concat errors later\n",
+    "rain_clean0 = rain_clean0[~rain_clean0.index.duplicated(keep='first')]\n",
+    "flow_clean0 = flow_clean0[~flow_clean0.index.duplicated(keep='first')]\n",
+    "\n",
+    "# Method 1: drop gaps\n",
+    "rain_drop = rain_clean0.dropna()\n",
+    "flow_drop = flow_clean0.dropna()\n",
+    "\n",
+    "# Method 2: fill with mean\n",
+    "rain_meanfill = rain_clean0.copy()\n",
+    "flow_meanfill = flow_clean0.copy()\n",
+    "rain_meanfill[\"rain_mm\"] = rain_meanfill[\"rain_mm\"].fillna(rain_meanfill[\"rain_mm\"].mean())\n",
+    "flow_meanfill[\"flow_cfs\"] = flow_meanfill[\"flow_cfs\"].fillna(flow_meanfill[\"flow_cfs\"].mean())\n",
+    "\n",
+    "# Method 3: interpolate (time-based works well for time series)\n",
+    "rain_interp = rain_clean0.copy()\n",
+    "flow_interp = flow_clean0.copy()\n",
+    "rain_interp[\"rain_mm\"] = rain_interp[\"rain_mm\"].interpolate(method=\"time\")\n",
+    "flow_interp[\"flow_cfs\"] = flow_interp[\"flow_cfs\"].interpolate(method=\"time\")\n",
+    "\n",
+    "(rain_clean0.isna().sum(), flow_clean0.isna().sum())"
    ]
   },
   {
@@ -382,15 +288,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 11,
    "id": "bd2fa519",
    "metadata": {},
    "outputs": [],
    "source": [
-    "rainfall_methods = {\"raw\": rain_raw, \"drop\": rain_drop, \"mean\": rain_mean, \"interpolate\": rain_interp}\n",
-    "streamflow_methods = {\"raw\": stream_raw, \"drop\": stream_drop, \"mean\": stream_mean, \"interpolate\": stream_interp}\n",
-    "\n",
-    "dataframe_dict = {\"rainfall\": rainfall_methods, \"streamflow\": streamflow_methods}"
+    "# The original cleaned frames already share the same index (duplicates\n",
+    "# are allowed).  Rather than reindexing (which fails when the index\n",
+    "# contains duplicate labels) just concat the three series together.  The\n",
+    "# result will align on their indexes and keep duplicates intact.\n",
+    "\n",
+    "rainfall_methods = pd.concat([\n",
+    "    rain_drop[\"rain_mm\"],\n",
+    "    rain_meanfill[\"rain_mm\"],\n",
+    "    rain_interp[\"rain_mm\"]\n",
+    "], axis=1)\n",
+    "rainfall_methods.columns = [\"dropna\", \"mean_fill\", \"interpolate\"]\n",
+    "\n",
+    "streamflow_methods = pd.concat([\n",
+    "    flow_drop[\"flow_cfs\"],\n",
+    "    flow_meanfill[\"flow_cfs\"],\n",
+    "    flow_interp[\"flow_cfs\"]\n",
+    "], axis=1)\n",
+    "streamflow_methods.columns = [\"dropna\", \"mean_fill\", \"interpolate\"]"
    ]
   },
   {
@@ -405,13 +325,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 12,
    "id": "9c76bf67",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -421,7 +341,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -433,20 +353,38 @@
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
-    "# visualize streamflow methods\n",
-    "def plot_methods(df_dict, column, title):\n",
+    "# visualize gap‑filling methods for a DataFrame of series\n",
+    "def plot_methods(df, title):\n",
     "    fig, ax = plt.subplots()\n",
-    "    for name, df in df_dict.items():\n",
-    "        series = pd.to_numeric(df[column], errors='coerce')  # convert and force NA->nan\n",
+    "    for name in df.columns:\n",
+    "        series = pd.to_numeric(df[name], errors='coerce')  # ensure numeric\n",
     "        ax.plot(df.index, series, label=name)\n",
     "    ax.set_title(title)\n",
     "    ax.legend()\n",
     "    ax.set_xlabel('Date')\n",
-    "    ax.set_ylabel(column)\n",
+    "    ax.set_ylabel('value')\n",
     "    plt.show()\n",
     "\n",
-    "plot_methods(streamflow_methods, 'Streamflow_cfs', 'Streamflow gap‑filling methods')\n",
-    "plot_methods(rainfall_methods, 'Precip_in', 'Rainfall gap‑filling methods')"
+    "# if the helper frames don't yet exist (e.g. after restarting the kernel),\n",
+    "# rebuild them from the cleaned series so plotting always works.\n",
+    "if 'streamflow_methods' not in globals():\n",
+    "    streamflow_methods = pd.concat([\n",
+    "        flow_drop[\"flow_cfs\"],\n",
+    "        flow_meanfill[\"flow_cfs\"],\n",
+    "        flow_interp[\"flow_cfs\"]\n",
+    "    ], axis=1)\n",
+    "    streamflow_methods.columns = [\"dropna\", \"mean_fill\", \"interpolate\"]\n",
+    "\n",
+    "if 'rainfall_methods' not in globals():\n",
+    "    rainfall_methods = pd.concat([\n",
+    "        rain_drop[\"rain_mm\"],\n",
+    "        rain_meanfill[\"rain_mm\"],\n",
+    "        rain_interp[\"rain_mm\"]\n",
+    "    ], axis=1)\n",
+    "    rainfall_methods.columns = [\"dropna\", \"mean_fill\", \"interpolate\"]\n",
+    "\n",
+    "plot_methods(streamflow_methods, 'Streamflow gap‑filling methods')\n",
+    "plot_methods(rainfall_methods, 'Rainfall gap‑filling methods')"
    ]
   },
   {
@@ -461,7 +399,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 14,
    "id": "1e688b18",
    "metadata": {},
    "outputs": [
@@ -486,8 +424,8 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
-       "      <th>Precip_in</th>\n",
-       "      <th>Streamflow_cfs</th>\n",
+       "      <th>rain_mm</th>\n",
+       "      <th>flow_cfs</th>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Date</th>\n",
@@ -498,57 +436,57 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>2024-01-01</th>\n",
-       "      <td>0.14028</td>\n",
+       "      <td>0.140280</td>\n",
        "      <td>10.25</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-02</th>\n",
        "      <td>0.659018</td>\n",
-       "      <td>10.7</td>\n",
+       "      <td>10.70</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-03</th>\n",
-       "      <td>0.0</td>\n",
-       "      <td>13.3</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>13.30</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-04</th>\n",
-       "      <td>0.0</td>\n",
-       "      <td>10.1</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>10.10</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-05</th>\n",
        "      <td>0.375729</td>\n",
-       "      <td>10.0</td>\n",
+       "      <td>10.00</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "           Precip_in Streamflow_cfs\n",
-       "Date                               \n",
-       "2024-01-01   0.14028          10.25\n",
-       "2024-01-02  0.659018           10.7\n",
-       "2024-01-03       0.0           13.3\n",
-       "2024-01-04       0.0           10.1\n",
-       "2024-01-05  0.375729           10.0"
+       "             rain_mm  flow_cfs\n",
+       "Date                          \n",
+       "2024-01-01  0.140280     10.25\n",
+       "2024-01-02  0.659018     10.70\n",
+       "2024-01-03  0.000000     13.30\n",
+       "2024-01-04  0.000000     10.10\n",
+       "2024-01-05  0.375729     10.00"
       ]
      },
-     "execution_count": 37,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# choose interpolated series for both variables and merge into one frame\n",
+    "# choose the interpolated series for both variables and merge into one frame\n",
+    "# use the cleaned column names from earlier\n",
     "rain_flow_df = pd.DataFrame({\n",
-    "    'Precip_in': rain_interp['Precip_in'],\n",
-    "    'Streamflow_cfs': stream_interp['Streamflow_cfs']\n",
+    "    'rain_mm': rain_interp['rain_mm'],\n",
+    "    'flow_cfs': flow_interp['flow_cfs']\n",
     "})\n",
     "\n",
-    "rain_flow_df.head()\n",
-    "# display a preview"
+    "rain_flow_df.head()  # display a preview"
    ]
   },
   {
@@ -563,7 +501,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 16,
    "id": "d481b613",
    "metadata": {},
    "outputs": [
@@ -571,33 +509,48 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/scratch/local/u1257442/849844/ipykernel_713953/2372665443.py:1: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.\n",
-      "  monthly_stream = stream_raw.resample('M').mean()\n",
-      "/scratch/local/u1257442/849844/ipykernel_713953/2372665443.py:2: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.\n",
-      "  monthly_rain = rain_raw.resample('M').mean()\n"
+      "/scratch/local/u1257442/850202/ipykernel_457187/160883511.py:12: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.\n",
+      "  monthly_stream = stream_raw.resample('M', on=stream_raw.columns[0]).mean()\n",
+      "/uufs/chpc.utah.edu/common/home/u1257442/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/groupby/grouper.py:381: FutureWarning: Dtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.\n",
+      "  ax = Index(obj[key], name=key)\n",
+      "/scratch/local/u1257442/850202/ipykernel_457187/160883511.py:13: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.\n",
+      "  monthly_rain = rain_raw.resample('M', on=rain_raw.columns[0]).mean()\n",
+      "/uufs/chpc.utah.edu/common/home/u1257442/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/groupby/grouper.py:381: FutureWarning: Dtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.\n",
+      "  ax = Index(obj[key], name=key)\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "(            Streamflow_cfs\n",
-       " Date                      \n",
-       " 2024-01-31       12.112500\n",
-       " 2024-02-29       99.015517,\n",
-       "            Precip_in\n",
-       " Date                \n",
-       " 2024-01-31  0.437921\n",
-       " 2024-02-29  18.98449)"
+       "(           Streamflow_cfs\n",
+       " Date                     \n",
+       " 2024-01-31        -28.332\n",
+       " 2024-02-29      99.015517,\n",
+       "             Precip_in\n",
+       " Date                 \n",
+       " 2024-01-31 -34.025456\n",
+       " 2024-02-29   18.98449)"
       ]
      },
-     "execution_count": 36,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "monthly_stream = stream_raw.resample('M').mean()\n",
-    "monthly_rain = rain_raw.resample('M').mean()\n",
+    "# make sure the raw frames exist (they were created back in Task 3)\n",
+    "if 'stream_raw' not in globals() or 'rain_raw' not in globals():\n",
+    "    # reload if necessary\n",
+    "    stream_raw = pd.read_csv(\"data/streamflow_data.csv\")\n",
+    "    rain_raw = pd.read_csv(\"data/snotel_rainfall_data.csv\")\n",
+    "    # apply the same parsing as before\n",
+    "    stream_raw.iloc[:,0] = pd.to_datetime(stream_raw.iloc[:,0], errors='coerce')\n",
+    "    stream_raw.iloc[:,1] = pd.to_numeric(stream_raw.iloc[:,1], errors='coerce')\n",
+    "    rain_raw.iloc[:,0] = pd.to_datetime(rain_raw.iloc[:,0], errors='coerce')\n",
+    "    rain_raw.iloc[:,1] = pd.to_numeric(rain_raw.iloc[:,1], errors='coerce')\n",
+    "\n",
+    "monthly_stream = stream_raw.resample('M', on=stream_raw.columns[0]).mean()\n",
+    "monthly_rain = rain_raw.resample('M', on=rain_raw.columns[0]).mean()\n",
     "monthly_stream.head(), monthly_rain.head()"
    ]
   },
@@ -619,7 +572,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 20,
    "id": "6d73bc7f",
    "metadata": {},
    "outputs": [
@@ -644,39 +597,53 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
-       "      <th>Precip_mm</th>\n",
-       "      <th>Streamflow_cms</th>\n",
+       "      <th>rain_mm</th>\n",
+       "      <th>flow_cfs</th>\n",
+       "      <th>rain_mm_SI</th>\n",
+       "      <th>flow_cms</th>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Date</th>\n",
        "      <th></th>\n",
        "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>2024-01-01</th>\n",
-       "      <td>3.56312</td>\n",
+       "      <td>0.140280</td>\n",
+       "      <td>10.25</td>\n",
+       "      <td>0.140280</td>\n",
        "      <td>0.290247</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-02</th>\n",
-       "      <td>16.739058</td>\n",
-       "      <td>0.30299</td>\n",
+       "      <td>0.659018</td>\n",
+       "      <td>10.70</td>\n",
+       "      <td>0.659018</td>\n",
+       "      <td>0.302990</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-03</th>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>13.30</td>\n",
+       "      <td>0.000000</td>\n",
        "      <td>0.376613</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-04</th>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.286</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>10.10</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.286000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2024-01-05</th>\n",
-       "      <td>9.54352</td>\n",
+       "      <td>0.375729</td>\n",
+       "      <td>10.00</td>\n",
+       "      <td>0.375729</td>\n",
        "      <td>0.283168</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -684,29 +651,40 @@
        "</div>"
       ],
       "text/plain": [
-       "            Precip_mm Streamflow_cms\n",
-       "Date                                \n",
-       "2024-01-01    3.56312       0.290247\n",
-       "2024-01-02  16.739058        0.30299\n",
-       "2024-01-03        0.0       0.376613\n",
-       "2024-01-04        0.0          0.286\n",
-       "2024-01-05    9.54352       0.283168"
+       "             rain_mm  flow_cfs  rain_mm_SI  flow_cms\n",
+       "Date                                                \n",
+       "2024-01-01  0.140280     10.25    0.140280  0.290247\n",
+       "2024-01-02  0.659018     10.70    0.659018  0.302990\n",
+       "2024-01-03  0.000000     13.30    0.000000  0.376613\n",
+       "2024-01-04  0.000000     10.10    0.000000  0.286000\n",
+       "2024-01-05  0.375729     10.00    0.375729  0.283168"
       ]
      },
-     "execution_count": 38,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "# convert to SI units using previously merged rain_flow_df\n",
+    "# ensure the source dataframe exists and has expected names\n",
+    "if 'rain_flow_df' not in globals():\n",
+    "    raise NameError(\"rain_flow_df not defined – run earlier cells\")\n",
+    "\n",
     "rain_flow_SI_df = rain_flow_df.copy()\n",
-    "rain_flow_SI_df['Precip_mm'] = rain_flow_SI_df['Precip_in'] * 25.4\n",
-    "rain_flow_SI_df['Streamflow_cms'] = rain_flow_SI_df['Streamflow_cfs'] * 0.0283168\n",
     "\n",
-    "# drop original imperial columns if you like\n",
-    "rain_flow_SI_df = rain_flow_SI_df.drop(columns=['Precip_in','Streamflow_cfs'])\n",
+    "# the joined frame used 'rain_mm' and 'flow_cfs'\n",
+    "if 'rain_mm' in rain_flow_SI_df.columns:\n",
+    "    rain_flow_SI_df['rain_mm_SI'] = rain_flow_SI_df['rain_mm']  # already mm\n",
+    "else:\n",
+    "    raise KeyError(\"expected column 'rain_mm' in rain_flow_df\")\n",
     "\n",
+    "if 'flow_cfs' in rain_flow_SI_df.columns:\n",
+    "    rain_flow_SI_df['flow_cms'] = rain_flow_SI_df['flow_cfs'] * 0.0283168\n",
+    "else:\n",
+    "    raise KeyError(\"expected column 'flow_cfs' in rain_flow_df\")\n",
+    "\n",
+    "# nothing to drop, the original dataframe already used metric names\n",
     "rain_flow_SI_df.head()"
    ]
   },
@@ -724,34 +702,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 25,
    "id": "2c9b3495",
    "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "boolean value of NA is ambiguous",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[46], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m columns \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDry\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mLight Rain\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mModerate Rain\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mHeavy Rain\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m----> 2\u001b[0m rain_flow_SI_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRain_Category\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcut\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrain_flow_SI_df\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mPrecip_mm\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[43mbins\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2.5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m7.6\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      5\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolumns\u001b[49m\n\u001b[1;32m      6\u001b[0m \u001b[43m)\u001b[49m                                         \n",
-      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/reshape/tile.py:257\u001b[0m, in \u001b[0;36mcut\u001b[0;34m(x, bins, right, labels, retbins, precision, include_lowest, duplicates, ordered)\u001b[0m\n\u001b[1;32m    254\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m bins\u001b[38;5;241m.\u001b[39mis_monotonic_increasing:\n\u001b[1;32m    255\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbins must increase monotonically.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 257\u001b[0m fac, bins \u001b[38;5;241m=\u001b[39m \u001b[43m_bins_to_cuts\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    258\u001b[0m \u001b[43m    \u001b[49m\u001b[43mx_idx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    259\u001b[0m \u001b[43m    \u001b[49m\u001b[43mbins\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    260\u001b[0m \u001b[43m    \u001b[49m\u001b[43mright\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mright\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    261\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlabels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    262\u001b[0m \u001b[43m    \u001b[49m\u001b[43mprecision\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprecision\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    263\u001b[0m \u001b[43m    \u001b[49m\u001b[43minclude_lowest\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minclude_lowest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    264\u001b[0m \u001b[43m    \u001b[49m\u001b[43mduplicates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mduplicates\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    265\u001b[0m \u001b[43m    \u001b[49m\u001b[43mordered\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mordered\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    266\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    268\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _postprocess_for_cut(fac, bins, retbins, original)\n",
-      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/reshape/tile.py:452\u001b[0m, in \u001b[0;36m_bins_to_cuts\u001b[0;34m(x_idx, bins, right, labels, precision, include_lowest, duplicates, ordered)\u001b[0m\n\u001b[1;32m    449\u001b[0m side: Literal[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mleft\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mright\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mleft\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m right \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mright\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    451\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 452\u001b[0m     ids \u001b[38;5;241m=\u001b[39m \u001b[43mbins\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msearchsorted\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mside\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    453\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[1;32m    454\u001b[0m     \u001b[38;5;66;03m# e.g. test_datetime_nan_error if bins are DatetimeArray and x_idx\u001b[39;00m\n\u001b[1;32m    455\u001b[0m     \u001b[38;5;66;03m#  is integers\u001b[39;00m\n\u001b[1;32m    456\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m x_idx\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39mkind \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mm\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n",
-      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/base.py:1361\u001b[0m, in \u001b[0;36mIndexOpsMixin.searchsorted\u001b[0;34m(self, value, side, sorter)\u001b[0m\n\u001b[1;32m   1357\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(values, np\u001b[38;5;241m.\u001b[39mndarray):\n\u001b[1;32m   1358\u001b[0m     \u001b[38;5;66;03m# Going through EA.searchsorted directly improves performance GH#38083\u001b[39;00m\n\u001b[1;32m   1359\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m values\u001b[38;5;241m.\u001b[39msearchsorted(value, side\u001b[38;5;241m=\u001b[39mside, sorter\u001b[38;5;241m=\u001b[39msorter)\n\u001b[0;32m-> 1361\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43malgorithms\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msearchsorted\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1362\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1363\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1364\u001b[0m \u001b[43m    \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mside\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1365\u001b[0m \u001b[43m    \u001b[49m\u001b[43msorter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msorter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1366\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/algorithms.py:1329\u001b[0m, in \u001b[0;36msearchsorted\u001b[0;34m(arr, value, side, sorter)\u001b[0m\n\u001b[1;32m   1325\u001b[0m     arr \u001b[38;5;241m=\u001b[39m ensure_wrapped_if_datetimelike(arr)\n\u001b[1;32m   1327\u001b[0m \u001b[38;5;66;03m# Argument 1 to \"searchsorted\" of \"ndarray\" has incompatible type\u001b[39;00m\n\u001b[1;32m   1328\u001b[0m \u001b[38;5;66;03m# \"Union[NumpyValueArrayLike, ExtensionArray]\"; expected \"NumpyValueArrayLike\"\u001b[39;00m\n\u001b[0;32m-> 1329\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43marr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msearchsorted\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mside\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mside\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msorter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msorter\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32mpandas/_libs/missing.pyx:392\u001b[0m, in \u001b[0;36mpandas._libs.missing.NAType.__bool__\u001b[0;34m()\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: boolean value of NA is ambiguous"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "columns = ['Dry', 'Light Rain', 'Moderate Rain', 'Heavy Rain']\n",
+    "# use the SI precipitation column produced earlier\n",
+    "precip_col = 'rain_mm_SI' if 'rain_mm_SI' in rain_flow_SI_df.columns else 'rain_mm'\n",
+    "if precip_col not in rain_flow_SI_df.columns:\n",
+    "    raise KeyError(f\"no precipitation column found in {list(rain_flow_SI_df.columns)}\")\n",
+    "\n",
     "rain_flow_SI_df['Rain_Category'] = pd.cut(\n",
-    "    rain_flow_SI_df['Precip_mm'],\n",
+    "    rain_flow_SI_df[precip_col],\n",
     "    bins=[-float('inf'), 0.1, 2.5, 7.6, float('inf')],\n",
     "    labels=columns\n",
-    ")                                         "
+    ")"
    ]
   },
   {
@@ -766,11 +732,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "id": "2798ee78",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVtdJREFUeJzt3Xlcjen/P/DXaTvRKlEhKtn3ZZgkIqms2XdZB4NB1ixj19h3WcaUzwyDIbvBZBsRkbGvGYyhUpZStJ7r94df99dRjJLO6e71fDzOY9z3fd33eZ9z7jnn1XXf93UrhBACRERERFTg6Wi6ACIiIiLKGwx2RERERDLBYEdEREQkEwx2RERERDLBYEdEREQkEwx2RERERDLBYEdEREQkEwx2RERERDLBYEdEREQkEwx2RAQAUCgUmDFjRq7WTU9Px4QJE2BrawsdHR14e3vnaH07Ozv069dPmj5x4gQUCgVOnDiRq3qIiAorBjuiAiYoKAgKhUJ66OnpoXTp0ujXrx8eP36skZp++uknLFy4EJ07d8amTZswZsyYfH3+e/fuYciQIXBwcIChoSFMTU3h7OyM5cuX482bNzne3po1axAUFJT3hWqxvH4Pv4TC+LkQ5ZSepgsgotyZNWsW7O3tkZycjLNnzyIoKAihoaG4du0aDA0Nc7y9N2/eQE8vd18Jx44dQ+nSpbF06dJcrf85Dhw4gC5dukCpVKJv376oXr06UlNTERoaivHjx+P69etYv359jra5Zs0aWFpaqvUiytmXeA+/hML2uRDlBoMdUQHl5eWF+vXrAwAGDRoES0tLzJ8/H3v37kXXrl1zvL3chMFMT58+hbm5ea7Xz6379++je/fuKFeuHI4dOwYbGxtp2fDhwxEZGYkDBw7ke135JSkpCUZGRp+1jcL+HhLJDQ/FEsmEi4sLgLeH1DKlpqbi+++/R7169WBmZgYjIyO4uLjg+PHjWdZ//xy7GTNmQKFQIDIyEv369YO5uTnMzMzQv39/vH79GgDw4MEDKBQKHD9+HNevX5cOD2eeG7do0SI0atQIxYsXR5EiRVCvXj3s2LEjz17zggULkJiYiI0bN6oFkkyOjo4YNWqUNB0YGIjmzZujZMmSUCqVqFq1KgICAtTWsbOzw/Xr13Hy5Enp9bi6ukrLX758idGjR8PW1hZKpRKOjo6YP38+VCqV2naePXuGPn36wNTUFObm5vDx8cHly5ehUCiyHE48duwYXFxcYGRkBHNzc7Rv3x43b95Ua5P5edy4cQM9e/ZEsWLF0LhxYwQGBkKhUOCvv/7K8vrnzZsHXV3djx6iz+l7mJ6ejtmzZ6N8+fJQKpWws7PD5MmTkZKSorbeh87ZfP98ysxTC06fPg1fX1+UKFECRkZG6NChA2JjY9XW+9DnkpaWhpkzZ6JChQowNDRE8eLF0bhxY/zxxx8ffN1EcsUeOyKZePDgAQCgWLFi0ryEhAT8+OOP6NGjBwYPHoxXr15h48aN8PDwQHh4OGrXrv2f2+3atSvs7e3h7++Pixcv4scff0TJkiUxf/58lChRAj///DPmzp2LxMRE+Pv7AwCqVKkCAFi+fDnatWuHXr16ITU1FVu3bkWXLl2wf/9+tG7d+rNf8759++Dg4IBGjRp9UvuAgABUq1YN7dq1g56eHvbt24dvv/0WKpUKw4cPBwAsW7YMI0eOhLGxMaZMmQIAsLKyAgC8fv0aTZs2xePHjzFkyBCULVsWZ86cgZ+fH6KiorBs2TIAgEqlQtu2bREeHo5hw4ahcuXK2LNnD3x8fLLUFBISAi8vLzg4OGDGjBl48+YNVq5cCWdnZ1y8eBF2dnZq7bt06YIKFSpg3rx5EEKgc+fOGD58ODZv3ow6deqotd28eTNcXV1RunTpPHsPBw0ahE2bNqFz584YO3Yszp07B39/f9y8eRO7du36pG1kZ+TIkShWrBimT5+OBw8eYNmyZRgxYgS2bdsG4OOfy4wZM+Dv749BgwahQYMGSEhIwIULF3Dx4kW4u7vnuiaiAkkQUYESGBgoAIiQkBARGxsrHj16JHbs2CFKlCghlEqlePTokdQ2PT1dpKSkqK3/4sULYWVlJQYMGKA2H4CYPn26ND19+nQBIEu7Dh06iOLFi6vNa9q0qahWrVqWWl+/fq02nZqaKqpXry6aN2+uNr9cuXLCx8dHmj5+/LgAII4fP/7B9yE+Pl4AEO3bt/9gm/+qRwghPDw8hIODg9q8atWqiaZNm2ZpO3v2bGFkZCTu3LmjNn/SpElCV1dX/PPPP0IIIXbu3CkAiGXLlkltMjIyRPPmzQUAERgYKM2vXbu2KFmypHj27Jk07/Lly0JHR0f07dtXmpf5efTo0SNLXT169BClSpUSGRkZ0ryLFy9mea735fQ9vHTpkgAgBg0apDZ/3LhxAoA4duyYNO/9/SnT+5915v7cokULoVKppPljxowRurq64uXLl9K8D30utWrVEq1bt/6k10AkdzwUS1RAtWjRAiVKlICtrS06d+4MIyMj7N27F2XKlJHa6OrqwsDAAMDbXqTnz58jPT0d9evXx8WLFz/peYYOHao27eLigmfPniEhIeE/1y1SpIj07xcvXiA+Ph4uLi6f/Nwfk/n8JiYmn7zOu/XEx8cjLi4OTZs2xd9//434+Pj/XP+3336Di4sLihUrhri4OOnRokULZGRk4M8//wQAHDp0CPr6+hg8eLC0ro6OjtQrmCkqKgqXLl1Cv379YGFhIc2vWbMm3N3dcfDgwSw1vP95AEDfvn3x5MkTtUPsmzdvRpEiRdCpU6cPvp6cvoeZ9fj6+qrNHzt2LAB81rl433zzDRQKhTTt4uKCjIwMPHz48D/XNTc3x/Xr13H37t1cPz+RXPBQLFEBtXr1alSsWBHx8fH46aef8Oeff0KpVGZpt2nTJixevBi3bt1CWlqaNN/e3v6Tnqds2bJq05mHel+8eAFTU9OPrrt//37MmTMHly5dUjsH690f8NzKfO5Xr1598jqnT5/G9OnTERYWJp0nmCk+Ph5mZmYfXf/u3bu4cuUKSpQoke3yp0+fAgAePnwIGxsbFC1aVG25o6Oj2nRmaKlUqVKWbVWpUgWHDx/OcoFEdp+bu7s7bGxssHnzZri5uUGlUuHXX39F+/btPxracvoePnz4EDo6Olleh7W1NczNzT8phH3Ix/az/zJr1iy0b98eFStWRPXq1eHp6Yk+ffqgZs2aua6HqKBisCMqoBo0aCBdFevt7Y3GjRujZ8+euH37NoyNjQEAv/zyC/r16wdvb2+MHz8eJUuWhK6uLvz9/dUusvgYXV3dbOcLIT663qlTp9CuXTs0adIEa9asgY2NDfT19REYGIgtW7bk4JVmz9TUFKVKlcK1a9c+qf29e/fg5uaGypUrY8mSJbC1tYWBgQEOHjyIpUuXZrn4ITsqlQru7u6YMGFCtssrVqyYo9eQG+/2OmbS1dVFz549sWHDBqxZswanT5/GkydP0Lt3749uK6fvYabPCeYZGRnZzs/tfgYATZo0wb1797Bnzx4cOXIEP/74I5YuXYq1a9di0KBBua6VqCBisCOSgcyw1qxZM6xatQqTJk0CAOzYsQMODg4IDg5W+zGePn36F69p586dMDQ0xOHDh9V6EgMDA/PsOdq0aYP169cjLCwMTk5OH227b98+pKSkYO/evWq9Qx+6Qjg75cuXR2JiIlq0aPHR5ypXrhyOHz+O169fq/XaRUZGZmkHALdv386yjVu3bsHS0vKThzPp27cvFi9ejH379uH3339HiRIl4OHh8Z/r5eQ9LFeuHFQqFe7evStdIAMAMTExePnypfR6gLc9bi9fvlRbPzU1FVFRUZ/0erLzsUBpYWGB/v37o3///khMTESTJk0wY8YMBjsqdHiOHZFMuLq6okGDBli2bBmSk5MB/F8vyLu9HufOnUNYWNgXr0dXVxcKhUKth+bBgwfYvXt3nj3HhAkTYGRkhEGDBiEmJibL8nv37mH58uVSPYD6exEfH59t0DQyMsoSSoC3VwiHhYXh8OHDWZa9fPkS6enpAAAPDw+kpaVhw4YN0nKVSoXVq1errWNjY4PatWtj06ZNas937do1HDlyBK1atfrIq1dXs2ZN1KxZEz/++CN27tyJ7t27f9KA0zl5DzPrybz6N9OSJUsAQO1K5/Lly0vnHGZav379B3vsPsWHPpdnz56pTRsbG8PR0THLECxEhQF77IhkZPz48ejSpQuCgoIwdOhQtGnTBsHBwejQoQNat26N+/fvY+3atahatSoSExO/aC2tW7fGkiVL4OnpiZ49e+Lp06dYvXo1HB0dceXKlTx5jvLly2PLli3o1q0bqlSponbXhDNnzuC3336Txkxr2bIlDAwM0LZtWwwZMgSJiYnYsGEDSpYsmaUXqV69eggICMCcOXPg6OiIkiVLonnz5hg/fjz27t2LNm3aoF+/fqhXrx6SkpJw9epV7NixAw8ePIClpSW8vb3RoEEDjB07FpGRkahcuTL27t2L58+fA1DveVq4cCG8vLzg5OSEgQMHSsOdmJmZ5fjevX379sW4ceMA4D8Pw+bmPaxVqxZ8fHywfv16vHz5Ek2bNkV4eDg2bdoEb29vNGvWTNruoEGDMHToUHTq1Anu7u64fPkyDh8+DEtLyxy9pnd96HOpWrUqXF1dUa9ePVhYWODChQvYsWMHRowYkevnIiqwNHtRLhHlVObwEOfPn8+yLCMjQ5QvX16UL19epKenC5VKJebNmyfKlSsnlEqlqFOnjti/f7/w8fER5cqVU1sXHxjuJDY2Ntvnv3//vjTvQ8OdbNy4UVSoUEEolUpRuXJlERgYKG33XbkZ7uRdd+7cEYMHDxZ2dnbCwMBAmJiYCGdnZ7Fy5UqRnJwstdu7d6+oWbOmMDQ0FHZ2dmL+/Pnip59+yvJ6oqOjRevWrYWJiYkAoDbExqtXr4Sfn59wdHQUBgYGwtLSUjRq1EgsWrRIpKamSu1iY2NFz549hYmJiTAzMxP9+vUTp0+fFgDE1q1b1eoPCQkRzs7OokiRIsLU1FS0bdtW3LhxQ63Nhz6Pd0VFRQldXV1RsWLFT3rfcvMepqWliZkzZwp7e3uhr68vbG1thZ+fn1obId7uixMnThSWlpaiaNGiwsPDQ0RGRn5wuJP39+fs9oEPfS5z5swRDRo0EObm5qJIkSKicuXKYu7cuWqfB1FhoRDiE85MJSKiz7Z792506NABoaGhcHZ2zvPtx8XFwcbGBt9//z2mTZuW59snIu3Hc+yIiL6AN2/eqE1nZGRg5cqVMDU1Rd26db/IcwYFBSEjIwN9+vT5ItsnIu3Hc+yIiL6AkSNH4s2bN3ByckJKSgqCg4Nx5swZzJs3L9shSz7HsWPHcOPGDcydOxfe3t5ZbkNGRIUHD8USEX0BW7ZsweLFixEZGYnk5GQ4Ojpi2LBhX+SEfldXV5w5cwbOzs745ZdfPnpvWCKSNwY7IiIiIpngOXZEREREMsFgR0RERCQTsr94QqVS4cmTJzAxMcmTG48TERER5SchBF69eoVSpUpBR+fjfXKyD3ZPnjyBra2tpssgIiIi+iyPHj1CmTJlPtpG9sHOxMQEwNs3w9TUVMPVEBEREeVMQkICbG1tpUzzMbIPdpmHX01NTRnsiIiIqMD6lFPKePEEERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJhEaDXUBAAGrWrCkNHuzk5ITff/9dWp6cnIzhw4ejePHiMDY2RqdOnRATE6PBiomIiIi0l0aDXZkyZfDDDz8gIiICFy5cQPPmzdG+fXtcv34dADBmzBjs27cPv/32G06ePIknT56gY8eOmiyZiIiISGsphBBC00W8y8LCAgsXLkTnzp1RokQJbNmyBZ07dwYA3Lp1C1WqVEFYWBi+/vrrT9peQkICzMzMEB8fz1uKERERUYGTkyyjNefYZWRkYOvWrUhKSoKTkxMiIiKQlpaGFi1aSG0qV66MsmXLIiws7IPbSUlJQUJCgtqDiIiIqDDQ03QBV69ehZOTE5KTk2FsbIxdu3ahatWquHTpEgwMDGBubq7W3srKCtHR0R/cnr+/P2bOnPmFq849u0kHNF2CVnrwQ2tNl0BERFTgabzHrlKlSrh06RLOnTuHYcOGwcfHBzdu3Mj19vz8/BAfHy89Hj16lIfVEhEREWkvjffYGRgYwNHREQBQr149nD9/HsuXL0e3bt2QmpqKly9fqvXaxcTEwNra+oPbUyqVUCqVX7psIiIiIq2j8R6796lUKqSkpKBevXrQ19fH0aNHpWW3b9/GP//8AycnJw1WSERERKSdNNpj5+fnBy8vL5QtWxavXr3Cli1bcOLECRw+fBhmZmYYOHAgfH19YWFhAVNTU4wcORJOTk6ffEUsERERUWGi0WD39OlT9O3bF1FRUTAzM0PNmjVx+PBhuLu7AwCWLl0KHR0ddOrUCSkpKfDw8MCaNWs0WTIRERGR1tK6cezymraNY8erYrPHq2KJiIiyVyDHsSMiIiKiz8NgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTepougIg+zm7SAU2XoJUe/NBa0yUQEWkd9tgRERERyQSDHREREZFMMNgRERERyQSDHREREZFMMNgRERERyQSDHREREZFMMNgRERERyQSDHREREZFMMNgRERERyQSDHREREZFMMNgRERERyQSDHREREZFMMNgRERERyQSDHREREZFMaDTY+fv746uvvoKJiQlKliwJb29v3L59W62Nq6srFAqF2mPo0KEaqpiIiIhIe2k02J08eRLDhw/H2bNn8ccffyAtLQ0tW7ZEUlKSWrvBgwcjKipKeixYsEBDFRMRERFpLz1NPvmhQ4fUpoOCglCyZElERESgSZMm0vyiRYvC2to6v8sjIiIiKlC06hy7+Ph4AICFhYXa/M2bN8PS0hLVq1eHn58fXr9+rYnyiIiIiLSaRnvs3qVSqTB69Gg4OzujevXq0vyePXuiXLlyKFWqFK5cuYKJEyfi9u3bCA4OznY7KSkpSElJkaYTEhK+eO1ERERE2kBrgt3w4cNx7do1hIaGqs3/5ptvpH/XqFEDNjY2cHNzw71791C+fPks2/H398fMmTO/eL1ERERE2kYrDsWOGDEC+/fvx/Hjx1GmTJmPtm3YsCEAIDIyMtvlfn5+iI+Plx6PHj3K83qJiIiItJFGe+yEEBg5ciR27dqFEydOwN7e/j/XuXTpEgDAxsYm2+VKpRJKpTIvyyQiIiIqEDQa7IYPH44tW7Zgz549MDExQXR0NADAzMwMRYoUwb1797Blyxa0atUKxYsXx5UrVzBmzBg0adIENWvW1GTpRERERFpHo8EuICAAwNtBiN8VGBiIfv36wcDAACEhIVi2bBmSkpJga2uLTp06YerUqRqoloiIiEi7afxQ7MfY2tri5MmT+VQNERERUcGmFRdPEBEREdHnY7AjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgkGOyIiIiKZYLAjIiIikgmNBjt/f3989dVXMDExQcmSJeHt7Y3bt2+rtUlOTsbw4cNRvHhxGBsbo1OnToiJidFQxURERETaS6PB7uTJkxg+fDjOnj2LP/74A2lpaWjZsiWSkpKkNmPGjMG+ffvw22+/4eTJk3jy5Ak6duyowaqJiIiItJOeJp/80KFDatNBQUEoWbIkIiIi0KRJE8THx2Pjxo3YsmULmjdvDgAIDAxElSpVcPbsWXz99deaKJuIiIhIK2nVOXbx8fEAAAsLCwBAREQE0tLS0KJFC6lN5cqVUbZsWYSFhWW7jZSUFCQkJKg9iIiIiAoDrQl2KpUKo0ePhrOzM6pXrw4AiI6OhoGBAczNzdXaWllZITo6Otvt+Pv7w8zMTHrY2tp+6dKJiIiItILWBLvhw4fj2rVr2Lp162dtx8/PD/Hx8dLj0aNHeVQhERERkXbT6Dl2mUaMGIH9+/fjzz//RJkyZaT51tbWSE1NxcuXL9V67WJiYmBtbZ3ttpRKJZRK5ZcumYiIiEjraLTHTgiBESNGYNeuXTh27Bjs7e3VlterVw/6+vo4evSoNO/27dv4559/4OTklN/lEhEREWk1jfbYDR8+HFu2bMGePXtgYmIinTdnZmaGIkWKwMzMDAMHDoSvry8sLCxgamqKkSNHwsnJiVfEEhEREb1Ho8EuICAAAODq6qo2PzAwEP369QMALF26FDo6OujUqRNSUlLg4eGBNWvW5HOlRERERNpPo8FOCPGfbQwNDbF69WqsXr06HyoiIiIiKri05qpYIiIiIvo8DHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTDHZEREREMsFgR0RERCQTuQp2Dg4OePbsWZb5L1++hIODw2cXRUREREQ5l6tg9+DBA2RkZGSZn5KSgsePH392UURERESUc3o5abx3717p34cPH4aZmZk0nZGRgaNHj8LOzi7PiiMiIiKiT5ejYOft7Q0AUCgU8PHxUVumr68POzs7LF68OM+KIyIiIqJPl6Ngp1KpAAD29vY4f/48LC0tv0hRRERERJRzOQp2me7fv5/XdRARERHRZ8pVsAOAo0eP4ujRo3j69KnUk5fpp59++uzCiIiIiChnchXsZs6ciVmzZqF+/fqwsbGBQqHI67qIiIiIKIdyFezWrl2LoKAg9OnTJ6/rISIiIqJcytU4dqmpqWjUqFFe10JEREREnyFXwW7QoEHYsmVLXtdCRERERJ8hV4dik5OTsX79eoSEhKBmzZrQ19dXW75kyZI8KY6IiIiIPl2ugt2VK1dQu3ZtAMC1a9fUlvFCCiIiIiLNyFWwO378eF7XQURERESfKVfn2BERERGR9slVj12zZs0+esj12LFjuS6IiIiIiHInV8Eu8/y6TGlpabh06RKuXbsGHx+fvKiLiIiIiHIoV8Fu6dKl2c6fMWMGEhMTP6sgIiIiIsqdPD3Hrnfv3rxPLBEREZGG5GmwCwsLg6GhYV5ukoiIiIg+Ua4OxXbs2FFtWgiBqKgoXLhwAdOmTcuTwoiIiIgoZ3IV7MzMzNSmdXR0UKlSJcyaNQstW7bMk8KIiIiIKGdyFewCAwPz5Mn//PNPLFy4EBEREYiKisKuXbvg7e0tLe/Xrx82bdqkto6HhwcOHTqUJ89PREREJCe5CnaZIiIicPPmTQBAtWrVUKdOnRytn5SUhFq1amHAgAFZDu9m8vT0VAuSSqUy9wUTERERyViugt3Tp0/RvXt3nDhxAubm5gCAly9folmzZti6dStKlCjxSdvx8vKCl5fXR9solUpYW1vnpkwiIiKiQiVXV8WOHDkSr169wvXr1/H8+XM8f/4c165dQ0JCAr777rs8LfDEiRMoWbIkKlWqhGHDhuHZs2cfbZ+SkoKEhAS1BxEREVFhkKseu0OHDiEkJARVqlSR5lWtWhWrV6/O04snPD090bFjR9jb2+PevXuYPHkyvLy8EBYWBl1d3WzX8ff3x8yZM/OsBiIiIqKCIlfBTqVSQV9fP8t8fX19qFSqzy4qU/fu3aV/16hRAzVr1kT58uVx4sQJuLm5ZbuOn58ffH19pemEhATY2trmWU1ERERE2ipXh2KbN2+OUaNG4cmTJ9K8x48fY8yYMR8MXHnBwcEBlpaWiIyM/GAbpVIJU1NTtQcRERFRYZCrYLdq1SokJCTAzs4O5cuXR/ny5WFvb4+EhASsXLkyr2uU/Pvvv3j27BlsbGy+2HMQERERFVS5OhRra2uLixcvIiQkBLdu3QIAVKlSBS1atMjRdhITE9V63+7fv49Lly7BwsICFhYWmDlzJjp16gRra2vcu3cPEyZMgKOjIzw8PHJTNhEREZGs5ajH7tixY6hatSoSEhKgUCjg7u6OkSNHYuTIkfjqq69QrVo1nDp16pO3d+HCBdSpU0ca/87X1xd16tTB999/D11dXVy5cgXt2rVDxYoVMXDgQNSrVw+nTp3iWHZERERE2chRj92yZcswePDgbM9bMzMzw5AhQ7BkyRK4uLh80vZcXV0hhPjg8sOHD+ekPCIiIqJCLUc9dpcvX4anp+cHl7ds2RIRERGfXRQRERER5VyOgl1MTEy2w5xk0tPTQ2xs7GcXRUREREQ5l6NgV7p0aVy7du2Dy69cucIrVomIiIg0JEfBrlWrVpg2bRqSk5OzLHvz5g2mT5+ONm3a5FlxRERERPTpcnTxxNSpUxEcHIyKFStixIgRqFSpEgDg1q1bWL16NTIyMjBlypQvUigRERERfVyOgp2VlRXOnDmDYcOGwc/PT7qiVaFQwMPDA6tXr4aVldUXKZSIiIiIPi7HAxSXK1cOBw8exIsXLxAZGQkhBCpUqIBixYp9ifqIiIiI6BPl6s4TAFCsWDF89dVXeVkLEREREX2GXN0rloiIiIi0D4MdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJBIMdERERkUww2BERERHJhEaD3Z9//om2bduiVKlSUCgU2L17t9pyIQS+//572NjYoEiRImjRogXu3r2rmWKJiIiItJxGg11SUhJq1aqF1atXZ7t8wYIFWLFiBdauXYtz587ByMgIHh4eSE5OzudKiYiIiLSfniaf3MvLC15eXtkuE0Jg2bJlmDp1Ktq3bw8A+N///gcrKyvs3r0b3bt3z89SiYiIiLSe1p5jd//+fURHR6NFixbSPDMzMzRs2BBhYWEarIyIiIhIO2m0x+5joqOjAQBWVlZq862srKRl2UlJSUFKSoo0nZCQ8GUKJCIiItIyWttjl1v+/v4wMzOTHra2tpouiYiIiChfaG2ws7a2BgDExMSozY+JiZGWZcfPzw/x8fHS49GjR1+0TiIiIiJtobXBzt7eHtbW1jh69Kg0LyEhAefOnYOTk9MH11MqlTA1NVV7EBERERUGGj3HLjExEZGRkdL0/fv3cenSJVhYWKBs2bIYPXo05syZgwoVKsDe3h7Tpk1DqVKl4O3trbmiiYiIiLSURoPdhQsX0KxZM2na19cXAODj44OgoCBMmDABSUlJ+Oabb/Dy5Us0btwYhw4dgqGhoaZKJiIiItJaGg12rq6uEEJ8cLlCocCsWbMwa9asfKyKiIiIqGDS2nPsiIiIiChnGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmGOyIiIiIZILBjoiIiEgmtDrYzZgxAwqFQu1RuXJlTZdFREREpJX0NF3Af6lWrRpCQkKkaT09rS+ZiIiISCO0PiXp6enB2tpa02UQERERaT2tPhQLAHfv3kWpUqXg4OCAXr164Z9//tF0SURERERaSat77Bo2bIigoCBUqlQJUVFRmDlzJlxcXHDt2jWYmJhku05KSgpSUlKk6YSEhPwql4iIiEijtDrYeXl5Sf+uWbMmGjZsiHLlymH79u0YOHBgtuv4+/tj5syZ+VUiERERkdbQ+kOx7zI3N0fFihURGRn5wTZ+fn6Ij4+XHo8ePcrHComIiIg0p0AFu8TERNy7dw82NjYfbKNUKmFqaqr2ICIiIioMtDrYjRs3DidPnsSDBw9w5swZdOjQAbq6uujRo4emSyMiIiLSOlp9jt2///6LHj164NmzZyhRogQaN26Ms2fPokSJEpoujYiIiEjraHWw27p1q6ZLICIiIiowtPpQLBERERF9OgY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIpnQ03QBRESUt+wmHdB0CVrpwQ+tNV0C0RfHHjsiIiIimWCwIyIiIpIJBjsiIiIimWCwIyIiIpIJBjsiIiIimWCwIyIiIpIJBjsiIiIimWCwIyIiIpIJBjsiIiIimeCdJ4iIiAox3qnkwwri3UrYY0dEREQkEwx2RERERDLBYEdEREQkEwx2RERERDLBYEdEREQkEwUi2K1evRp2dnYwNDREw4YNER4erumSiIiIiLSO1ge7bdu2wdfXF9OnT8fFixdRq1YteHh44OnTp5oujYiIiEiraH2wW7JkCQYPHoz+/fujatWqWLt2LYoWLYqffvpJ06URERERaRWtHqA4NTUVERER8PPzk+bp6OigRYsWCAsLy3adlJQUpKSkSNPx8fEAgISEhC9b7CdSpbzWdAlaSVs+H23EfSZ73Gc+jPtM9rjPZI/7y4dpyz6TWYcQ4j/banWwi4uLQ0ZGBqysrNTmW1lZ4datW9mu4+/vj5kzZ2aZb2tr+0VqpLxhtkzTFVBBw32Gcor7DOWUtu0zr169gpmZ2UfbaHWwyw0/Pz/4+vpK0yqVCs+fP0fx4sWhUCg0WJl2SUhIgK2tLR49egRTU1NNl0MFAPcZyinuM5RT3GeyJ4TAq1evUKpUqf9sq9XBztLSErq6uoiJiVGbHxMTA2tr62zXUSqVUCqVavPMzc2/VIkFnqmpKf/noRzhPkM5xX2Gcor7TFb/1VOXSasvnjAwMEC9evVw9OhRaZ5KpcLRo0fh5OSkwcqIiIiItI9W99gBgK+vL3x8fFC/fn00aNAAy5YtQ1JSEvr376/p0oiIiIi0itYHu27duiE2Nhbff/89oqOjUbt2bRw6dCjLBRWUM0qlEtOnT89y2JroQ7jPUE5xn6Gc4j7z+RTiU66dJSIiIiKtp9Xn2BERERHRp2OwIyIiIpIJBjsiIiIimWCwIyIiIpIJBjsiIiIimWCwIwCfdmNhorzAfY3yG/c5KkwY7AgApPvovnnzBgC/COnLUKlU0r727NkzDVdDcpT53RUdHY24uDikpqZCoVBApVJpuDLSlML22TPYkWTlypXw8PAA8H9Bjygv6ei8/cqZO3cuvL294ezsjMDAQMTFxWm4MpILhUKBXbt2wdnZGc2aNYOLiwv+/fdfad+jwkUIIX32wcHBCAoKwsGDBzVc1ZfFPZ0kNWrUQGxsLP78809Nl0Iy8+5fzOvWrcPixYvRrVs3mJubY/Xq1Zg7dy5iYmI0WCEVZEIIqafu1q1bGDhwIIYNG4YRI0bA2NgY9erVw8WLFzVcJeU3IYTUSTF27FgMHToUM2bMwPjx49G3b18NV/flMNgVUtkdanV0dETRokVx7NixD7Yhyo3Mv5jDw8Nx/fp1BAUFYcSIEThw4AA6duyIsLAwzJs3j+GOckWhUEChUODMmTN4+PAhvvvuO4wbNw5DhgzBjh074OTkBE9PT/z111+aLpXygUqlUgt19+/fx/Xr13Hs2DGcOXMGY8eOxeXLl9GhQwcNV/plMNgVUpk7/IsXL6R5ZcqUwYgRI7B8+XJcu3aNh2Pps4wZMwYRERHS9O+//44+ffpg586dKFq0qDR/8uTJaNeuHcLDw/HDDz8gKipKE+VSATNmzBisWLFCmn7z5g18fX3h5eWFO3fuSPOLFSuGwMBAODs7o02bNggPD9dEuZRP7t+/Dx0dHen3KygoCH379oWpqSkqVKiAUqVKoWfPnpg0aRLu3buHjh07arjivMdgV8i8e0hs2bJlGDhwIJYvXw4hBDIyMtCxY0fUrl0bJ0+eBABkZGRoqlQqwM6dO4fU1FTUqlVLmufh4QEvLy+kpKRg165dSEhIkJZNnjwZ7du3x969e7Ft2zZNlEwFTOXKleHi4iJNFylSBIGBgWjTpg1OnjyJf//9F8DbIw+Z4a5y5cro1asXUlJSNFU2fUETJ07EN998A+Dtb9fr16/x6NEjxMTE4NatW1AqlQAAQ0NDdOjQAX5+frh//z6aNm2qybLznELweFuhtHnzZpw5cwZ6enrYvn07KlSogJYtW8LX1xczZ87EgQMHcOXKFZ5wTLmWeShky5YtsLCwgKenJ1QqFcaMGYPQ0FB06dIFw4cPh4mJibTOzz//jJ49e0JXV1eDlVNB8vvvv+Pq1auYMGECAODu3bvo27cv4uLiEBoaCisrK2lfjI+Px6tXr1CmTBkNV01fwp07d+Dg4AA9PT3ExsaiRIkSiI2NxZYtWzBv3jx06NABa9euldonJydj8+bNOHnyJIKCguTzeyeoUMjIyJD+vWLFCmFpaSnu3bsnhBAiNjZWjB8/XjRp0kSUKVNGTJgwQSgUCrF27VpNlUsyce/ePdGoUSPRvHlzcfToUSHE233x22+/FfXr1xf+/v7i1atXWdZLT0/P71KpgFqxYoVQKBRi0aJF0rw7d+6Ihg0bCkdHRxETEyOEEEKlUmmqRMpn27ZtE0qlUly+fFkIIURcXJxYtGiRqFGjhhg+fLha25SUFOnf7/5OFmQyiaf0XzL/Evnrr78QFRWFZcuWwcHBAenp6bC0tMT8+fMREhKCcePGITIyEvr6+ti3b5+Gq6aCzsHBAVOmTIGRkRF++OEHHD16FDo6Oli1ahW+/vpr7N69G/PmzcPr16/V1mOPHX2qkSNHYtWqVRg/fjwWLlwIAKhQoQJ+/vlnWFtbo0qVKoiNjeU5w4VI+fLl4ebmhrZt2+Lq1asoXrw4fHx84OPjg1OnTuG7776T2hoYGEj/Zo8dFTjnzp0TCoVC6OrqisDAQGn++3+lJCYmimPHjglDQ0MRHBycz1VSQfWxv3YPHDggWrVqJdzd3UVISIgQ4m0PSq9evcTAgQPZm0KfJHM/SUlJEampqWrLMnvuFixYIM27efOmaNGihbh7926+1kn550PfOxcvXhTt2rUTpUqVEleuXBFCvD06tWTJElGyZEmxePHi/CwzX/EcOxmLjo5GbGwsLl++jNq1a6N69erYtWsXOnXqhH79+mH+/PkoUaKE1F78//NQhBBQqVTo3Lkz6tWrh6lTp2rwVVBBoFKppL92AwMDER4eDqVSia+//hrdu3cHABw4cABr1qxBeno6Jk6ciObNm0vjj+no6KgNT0D0vsz94/Dhw1i/fj2ePXuGSpUqYc6cObC0tIRCocDKlSsxatQoLFy4EGPHjgUApKWlQV9fX8PV05fw7vfOxYsXpe+ROnXqAHh7hGrGjBm4cOECDh06hBo1aiAmJgbHjx9Hly5d5HtkQGORkr6onTt3ilatWglra2thamoqDAwMRLt27cSjR4/Ezp07hUKhEHPmzBEvX7784DZcXV1F//7987FqKugmTJggrKysxNChQ0XHjh1F7dq1xffffy8tP3DggGjTpo2oW7euOH/+vDRfLue20Je1e/duYWpqKoYPHy4CAwOFjY2NaNeunbhw4YLUm7dq1SqhUCjEihUrNFwtfUnv9vJPnTpVVK5cWZQrV044OjqKH374QVp28eJF0b59e1G2bFkRERGhtg25nsvLYCdD69evF8WKFROLFi0SISEh4sWLF2LWrFmiQoUKomLFiuLRo0di8+bNQqFQiHnz5on4+Pgs24iIiBAODg7ir7/+yv8XQAXSjz/+KBwdHUV4eLgQQohffvlFGBgYiLJlywpfX1+p3Y4dO8S4ceMY5ihHbt68KapUqSJWrVolhBAiISFBlCpVSiiVSlG/fn0REREh7VPr1q0TN27c0GS5lE9mzZolSpQoIU6cOCGePHkihg8fLhQKhZg2bZrU5q+//hLOzs6iffv2Qgj5X0jDYCcz69evFwYGBmLnzp1Zlm3fvl1Ur15duLi4CJVKJdasWSN0dXXF5MmTRWJiolrb58+fi9jY2PwqmwqYd78YM39M586dK32Z7t69WxQrVkzMnz9fjBs3ThQrVkzti/b9dYkyfehHNzw8XMyePVukp6eLf//9V9jb24vvvvtOPHnyRFhZWYnWrVuLsLAw2f9o0/+5cuWKaNmypThy5IgQQoj9+/cLc3Nz0bNnT6GrqyumT58utb1z506h+b5hsJOR48ePC4VCIWbOnCmEePsFqVKpRFpamtRm1apVQqlUih07dgghhJg9e7Zo1KgRvwwpR54/fy4SExPFmzdvpHlpaWniwYMH4t9//xXVqlWThp+IiIgQFhYWomjRorI+YZk+X+YP78uXL8W9e/fE06dPpXnJyclSL1zv3r1Fr169RFJSkhBCCHd3d6FQKETz5s1FcnKyZoqnfPf8+XOxdOlSkZSUJE6cOCFKlSolAgICRFpamujatatQKBRi1KhRausUhnAnk2t7CQBKly6Nxo0b4+LFizh16pR0/0Q9PT3pjhPDhw9HxYoVERISAgCYOnUqQkNDpYsmiP7Lb7/9hi5dusDZ2Rne3t7S/V319PRQrlw5XLt2DWlpadJFExkZGXBzc8PGjRsxatQoTZZOWizzRPjr16/D09MTrVq1QtWqVbFy5UrExsZCqVSiSpUqSEtLw6NHj1C3bl3p1nTVq1fH2bNnsWHDBunuAiQvp06dwo8//gh/f3+8evUKwNvbxQ0bNgxFixbFjh074OXlhX79+kFPTw92dnZo3rw5rl69qnbHJdkMafIR8n+FhUiFChWwceNGpKSkYO7cuQgNDZWWZV5tmJCQgDdv3qBUqVJqywSvSKRPsG7dOvj4+MDd3R1ubm64efMmWrdujcTERKmNsbExkpOTsX37djx58gQzZsyAqakpunXrBl1dXd6mjrLIyMiAjo4OLl++DCcnJzRo0AArV66Em5sbvv/+e1y+fBkApKuonz17huPHj+Pw4cMYN24cfvnlF9jZ2cHBwUHDr4S+hI0bN6J79+5Yv3495syZA1dXVzx8+BAAoK+vj7S0NFy6dAlpaWkwNDTEmzdvcPfuXXzzzTfS2JmFquNCo/2F9EXcuXNHeHp6Cg8PDxEaGiqE+L/zVv766y/h6uoqnZPAQ7D0qTZt2iQUCoU0Dp0QQgwaNEhYWFiImzdvSvMeP34sRowYIUqWLCnKlCkj6tatK405xv2NPuTq1avCxMRETJo0SZp37do1oaenl+Vw2tWrV4WVlZVwcHAQDg4O4uLFi/lcLeWXdevWCT09PREcHCxiYmJESEiIUCgUYujQoVna6ejoiI4dO4p69eqJWrVqSachFbbvHfbYyVCFChWwYsUKKBQKzJ49Wzosm56ejilTpsDY2Bhubm4AwF46+iQPHjzAggULUKNGDWnfAYCHDx/ixYsXOHnyJEJDQxEbG4tSpUphwYIFOHLkCNavX4/w8HDo6+sjPT2d+xt90OrVq5GYmAhPT0+pV3f79u3SzdyXLl2Ky5cv4++//0b16tVx//59HD9+HOfOnZPGLSN5CQkJwdChQxEcHIwOHTqgZMmSqF69OkqVKoXY2Fi1tn369EFAQAB0dHTg5OSE8+fPQ09PDxkZGYXue4cDFMvY3bt38d1330FHRweTJ0/GkiVLcOvWLVy6dAn6+vpqgzsSfUxqaio2bdqEoKAglClTBtu2bUOPHj0QGhqKnj17IioqCn///Tdu3LiBPn36wM7ODmPGjJHWz8jIkO9goJRn2rVrh/DwcOzfvx9HjhzB/PnzMWbMGJQoUQK///47YmJiEBsbi2bNmqFz585o3bq1pkumL+j48ePo2rUrXF1d8dtvvwEAOnfujD179sDR0RF16tTBs2fPMHjwYDg5OaF06dJq66enp0NPT08TpWsUg53M3b17F2PGjMGRI0fg4OCAq1evSr0nhXGHp5wT///8y9TUVGzZsgUBAQG4f/8+LC0tER4eDmNjYwDAmzdvEBgYiOPHjyMqKgp//vkn/3CgT/Lu95GXlxcOHz4MU1NTbN26FZ6enlK7q1evIjQ0FJs3b8amTZtQvnx5TZVM+UAIgdDQUOliLV1dXdy5cwcbN26EsbExEhISsGjRIjx8+BDh4eFYvHix9AelKMTnjTPYFQK3bt3CmjVrsGTJEujp6THUUY69H+5WrVoFS0tL7N+/P8s+9ebNGxgaGvKiHMqRd/ehnj17Ys+ePdi/fz8aN24s3RIsc3/ibcIKlz///BNDhgzB7du38c8//6BMmTJqy+Pi4nDixAl4e3vztw0MdoUOQx3lVnY9d2XKlMHPP/+MokWLIjU1FQYGBlnaE32qd7+fWrVqhYsXL2LTpk1wc3ODnp6e2v2suW8VHiqVSjrto379+ti9ezeA7O8DzN84Bjsi+oj3z8N8P9ytXbsWZcuWRWBgIIyMjDRYKcnFuz/MrVu3xpUrVxAQEABPT89C/4MtZ/8V1oUQOHXqFLp164YGDRpgz549n7ReYcQTYIhIcuHCBenfy5cvx7Fjx9SWZ/aWGBgYoGfPnhg2bBguXLiAefPm5XepJDOZfQyZh/YB4MCBAyhXrhzGjRuHlJQUTZZHX1hmOHv06NEHlzdp0gTbtm1DREQEnJ2d1daj/8MeOyICANy+fRvt2rVDy5Ytoa+vjxUrVuDGjRuoWLFilrbv9tyFhITAw8ODV73Sf8rcb65cuYLY2FjExcXBy8sLpqamWdq+eyX1o0ePYGtrm9/lUj4LCAjAoUOHpN64D/njjz+wcuVK7N69mxdoZYPBjogAvL0ryZYtWzBlyhSkpqbi7NmzqFat2gdPVH//EAiHNKGPydxfgoODMXz4cFSqVAm3bt1ClSpV4OPjg379+mVZh/tU4XLs2DF4enriyJEjcHV1/aR1OGxXVnw3iAhCCJiamsLa2hpCCFhZWWH9+vUA3t6yJ7vbgL1/CIQ/wPQxCoUC4eHhGDJkCObOnYsTJ07g8OHDOHnypNot6d7FfUq+3u9TysjIwFdffYX27dvj0KFDAKB2j9cPYajLiu8IUSGW+cWZGdIaNmyIsLAw+Pr64tixYxg2bBgA9R9Y3uuVcuvKlSuoX78+BgwYgDt37qBjx44YOHAgRowYAQB4+vSphiuk/JL5nfPs2TMAb79jTExM0LBhQ2zYsAFPnz4tfPd4zSMMdkSFVFpamvTX7tmzZ3HhwgWkp6ejUqVK6NatGwYMGIDQ0FDpRxcAJk6ciDNnzmiqZCoA3u1lyfwjILNHLioqCtbW1gAANzc3tGjRAuvWrQMABAcHY+vWrbxIQube3T8yh7IJCgrCkydPAADjxo1DtWrVMG/evEJ5O7C8wGBHVMj07t0bZ86ckc6bmzhxIlq1aoVOnTqhbt26CAkJQfHixdG/f38MHDgQx48fh6urK7y8vLB582Y4OTlp+BWQNtPR0cGDBw9w/Phx6OrqYseOHfD39wcANG/eHDt27ICRkRE6d+6MdevWSX9chISE4MyZM9IVsSRPmZ/348ePUaZMGXh4eGDs2LHo27cvRo8ejbi4ODRq1AgPHz5EWloagKyHbenjGOyICpH4+HjExMSgdevWiIiIwPXr17Fz507s27cPv/zyC7p06YJWrVphx44dMDc3x4ABAzBr1iyUKVMGpUqVwv3796UbaxNlJzk5GfPmzcOAAQMwffp0dO3aFZUqVQIA1KlTByNHjoSJiQnq1KkD4G0v3pQpU7B9+3ZMnz6d4yEWAvv374eDgwOqV6+O+fPnIzQ0FB07dsThw4fRqVMn3LlzB3v27MGmTZsAcEiTHBNEVKhER0eL7t27C3Nzc7F48WIxY8YMaVlycrIYM2aM0NfXFzt27Mh2/bS0tPwqlQqoa9euiUaNGgmFQiEmTpwohBBCpVIJIYS4evWqGDFihNDX1xcVKlQQdevWFeXLlxcXL17UZMmUj6Kjo4Wzs7NYsmRJlu+TlStXipEjRwpdXV3h7u4uYmNjpX2HPg2HOyEqJN4dFiAmJga+vr749ddf0adPH2zatEltbDo/Pz8EBATgxx9/RM+ePaVtCI7yTp/g+fPn6Ny5MxISEpCeno4FCxagZcuW0vKkpCTcuHED58+fR7ly5VCrVq0s9/8kechuOBIhBIYOHYorV64gLCwMQNbbg+3evRs+Pj7Yu3cvmjZtmq81F3QMdkSFTGY4e/LkCaZNm4Zt27bhjz/+gJOTk9pN1ocNG4bIyEicOHFC0yVTAZOWloZXr17hwYMHWLRoEa5evYrFixerhTuOP1a4PHnyBCVLlpRuCxcXF4dq1aph7NixmDBhAoCsfzh26NABJUqUwNq1a7mv5ADfKSKZe/cqtEWLFqF///54/fo1SpUqBX9/f7Rp0wYeHh44f/68dMswfX19rF27FsePH9dg5VRQZPYPPH78GJGRkYiKioKFhQXq1q2Lb7/9FjVq1MD48eNx5MgRAMCcOXMwY8YMXgFbSGzYsAFubm749ttv8e+//0KlUsHS0hKDBg3C6dOn8ezZM7VQl7k/JSUlQU9Pj0cJcoh3VCaSsXd7RS5cuIC4uDj873//g5WVFWbNmoWSJUtixYoVEELA3d0dISEhqF+/PoQQ0l/W7Fmhj8n8Qd6zZw/mzJmDqKgoODo6wsnJCf7+/mjcuDGAtz/uXbt2RaNGjXDkyBGEh4dDqVRquHrKD126dEFcXByOHz+OmjVr4ptvvkHHjh3Rr18/1KlTB+Hh4fDy8pLaKxQK3L59G6dPn8b8+fMZ7HKIh2KJCoEJEyZg165daNOmDS5fvoxTp05h0KBBWL58OQwMDPD06VOMHj0aW7duxY0bN1C5cmVNl0wFyMGDB9G1a1fMmzcPTZs2xf79+zFt2jR8++23WLVqFQDg+vXrCA0NxdWrVzFixAjuYzL1/h+CKSkpUCqV0h8AK1aswLFjx3Ds2DGMGTMGu3btgoGBAQ4dOgRLS0u1bb148QLFihXL75dQ4DHYEcnM++epHDt2DB06dMDBgwfh7OyMlJQU7N27F3379sWAAQOwePFiGBoaIioqCgEBAfj++++l3jqi/xITE4NevXqhXbt2+O677xAXF4e6devC0dERly9fRteuXREQECC15wU48vVuqFu3bh3OnTuHV69eoXPnzujWrZvU7vnz5wgPD8fcuXNx+fJl1K1bF8ePH+d+kUd4fIVIRrp27YrLly+rzYuPj4elpSVq1qwJAFAqlejSpQsCAgIQEBCAWbNmITU1FTY2Npg5cyb09PQ4SCx9VGZ/wP3792FlZQUvLy94eHggOjoaTZs2RevWrbFr1y507doV69atQ79+/aR1+eMtX5mhbtKkSZg9ezb09fVhZ2eHHj16YPny5UhOTgYAWFhYwNPTE3v37sXBgwdx9OhRKBSKT7o3LP03BjsiGTEwMEDVqlXV5pUpUwYPHjyQhhXI/FH++uuvYWFhgR9++AGTJ08G8H8/uuyxo4/JPKeubdu2uHPnDsaMGYNKlSph8+bNsLe3x+zZs2FmZoaKFSuiVq1auHjxonTLKJK3zZs3Y9u2bQgODsa6devg7u4OABgzZgz8/f3V7iZRrFgxNG7cGLq6usjIyOC5vHmE395EMpCRkQFdXV388ssvAIDVq1ejatWqaNy4MWrWrInu3btjzpw5MDQ0RJMmTQAAxYoVQ5cuXdCoUSMMGDAATZs2Rdu2bTX5MkjLZR5Gffz4MQICAvDdd9+hYsWK0vJr167hxYsX0rlSjx8/RufOnTF69GjeUaIQSE1NRUJCAiZOnIgGDRrgwIED6NmzJzZs2ID09HQMGzYMZmZmGDFiBAwMDNTW1dXV1VDV8sNz7IhkJPOHt1KlSkhJScGWLVvQqFEjnDp1CkuWLEFkZCSGDRuG0qVLY82aNcjIyMCvv/4KFxcXDBo0COPGjdP0SyAt9+eff2Lbtm24f/8+1q1bB1tbW+ncqt9++w3jx4+Hs7MzDAwMsGvXLoSHh6uFP5KPzO+bd8+b/Oeff5CRkQEDAwO0atUKPj4+8PX1xdWrV+Hk5ITXr19j7dq1+OabbzRcvXyxx45Ihm7fvo3GjRujd+/e2LJlC1xcXGBoaIht27Zh0qRJKFeuHCwsLHD06FHo6enB1NQUpqammi6bCoCHDx9i48aN0NHRwd9//w1bW1vpEJqLiwvGjh2LnTt3wtjYGCdPnmSok6l3L5SIi4uDgYEB9PX1UbZsWQBAeHg4MjIypGFMihQpgoEDB8LT01M6PEtfBnvsiGTg3S/Z9PR06Ry5r7/+Gk+fPsXmzZvh5OQE4O1VjEqlEubm5gDeDoWyfft2nDhxAnZ2dpoonwqY4OBgDBs2DJ6enpg8eTIqVaqUpc3r169RtGhRDVRHX9q7PXQ//PADDhw4gKSkJBgYGGDDhg2oUaMGzp8/j4YNG2L9+vX46quvMGXKFCgUCuzbtw+A+vcU5S0GO6IC6ujRowgLC8PUqVMBfDzcxcXFYdOmTWjQoIF0P8awsDD88ssv2LFjBw4dOoQ6depo5oWQ1sr8Ab958yaePn2KV69eoVWrVtDR0cGvv/6K8ePHo2PHjhg5ciQqVKgA4P/O9yT5mzZtGtauXYvVq1fD3t5euqvN6dOnYWNjg9mzZ2P69OkoX748zMzMEBYWBn19fQ5584UxLhMVQCkpKdi+fTvCwsKgVCoxfvx46OjoSOFOT09Puqn22bNn0bhxY7Rs2RJhYWHSsCeOjo6oXbs2fH19Ub58eQ2/ItI2mT++wcHBmDhxIpRKJfT09DBy5EgcOHAAPXr0gBACEyZMgK6uLoYMGYLKlSsz1MnU+2EsOjoaR48exf/+9z94eXlh3759ePz4MebNmwcbGxsAb4Nf27ZtkZaWhnr16kFHR4c9dflBEFGB9PjxYzFq1CjRsGFD8cMPP0jzMzIysv33yJEjRXp6uhBCCJVKpfZfouyEhoYKU1NTsWHDBiGEEOHh4UKhUIhly5ZJbTZv3iwMDQ3FxIkTRWpqqqZKpS/swYMHatM3btwQFhYWIjExURw6dEgYGxuLgIAAIYQQr169EgsXLhQJCQlq62R+/9CXxUFjiAqoUqVKYdKkSfjqq6+wa9cuzJ8/HwCknjsAiI2NRffu3bF//36sWLFCGi8q8y9vHg6hTA8fPgTwf+McAsDVq1fRtWtXDBo0CPfv30fnzp0xdOhQjBo1Smrbs2dPBAUFYeDAgdJhfpKX69evw97eHj/99JM0r0KFCmjUqBEmTJiAzp07Y+nSpRg6dCiAt8PcHDlyBGfPnlXbDntz8weDHVEBZm1tjSlTpkjh7ocffgDwNtxFRUWhU6dOuHjxIjw9PaV1+OVK7zt48CDs7e2lOwBkhrvr16/jxYsXePr0KZo2bQpPT0+sXr0aALBlyxbMmjULANCtWzfpHDuSn3LlymH8+PEYNmwY/ve//wF4ey5lmTJlEBgYiF69emHQoEEA3l404+vrCx0dHbi5uWmy7EKLB7qJCrjMcDd37lzs3r0burq6GDBgAHr16oUXL17g+vXr0NPT40nt9EENGjSAj48PvL29sWfPHjRv3hwA0KZNGyxcuBBVq1ZFhw4dsG7dOqk3+OzZs3j9+jWSkpI4+LDMGRsbY/LkyTA2Nka/fv1gYGCA7t27w9/fH/fu3UN4eDi6d+8Oe3t7nD59Gi9fvkRERITaeb+Uf/huE8lAZrhr0KABdu7cifLlyyM6OhqXLl2Cvr4+0tPTGerogywtLbFq1Sr07dsXrVu3RmhoKACgatWq0NfXh7GxsTQe2YsXLzB16lRs27YNY8eOZaiTufT0dKhUKpiZmWHatGkoW7asdPjd3NwcW7duRdeuXZGUlIR79+6hUaNGuHjxovS9w1CX/zjcCZGMREdHY+LEiYiNjcWePXukL1dehUYfktmjEhoailu3buHbb79F0aJFERwcjObNm+POnTvo378/EhISEB8fD0dHR0RGRmLPnj0cIkem3h9KKVOXLl1w584duLi4YM2aNdi4cSP69++f7fAlPEKgOfy2J5IRa2trLFu2DGZmZhxagD6Jjo4Odu3ahf79+2PkyJEYOHAg/vrrL7Ru3Rp79+6Fu7s7tm/fjlu3buHs2bOoUaMGatWqhXLlymm6dPoC3h1KSV9fHxMnTgQAdOrUCXfu3MGBAwdgY2ODYsWKYfDgwdDT00OfPn2ybIehTnPYY0ckUzy3hT7Fq1ev4O7uDjc3N8ydOxcA8ODBA0yfPh3bt2/HwYMH0axZMw1XSfnpyZMnWLBgAc6dO4fu3bvj9OnTuH37NoKDg6UxL5OSkrBgwQLMnj0bBw8eVLtAizSLwY6IqBB7/vw56tati8mTJ0s3ZhdC4P79++jUqRP+/fdfbNu2TbqgggqHqKgozJs3DwcOHEB8fDyuXLmC0qVLqx0FSExMxNatW9GvXz8eGdAi/HOeiKgQs7CwQMOGDbF7927Ex8cDeDu+oYODA2rWrImEhAT07NkTr1+/1nCllJ9sbGwwdepUtG3bFvb29vj1118BQLrCHnh7teygQYOgp6eH9PR0TZZL72CwIyIqJDIP0KSlpeHNmzfS/Pbt2yM2NhZLlizBq1evpPlGRkbYtGkTrl27hqJFi+Z7vaRZVlZW8PPzg5OTE3bs2CENgq6rqysNe5OJPXbag4diiYgKgcwrFw8ePIgff/wRf//9N7766it07doV7u7umDdvHoKDg2FqagoPDw9cv34dv//+O8LCwuDo6Kjp8kmDoqOjMW/ePERERKBZs2aYM2eOpkuij2DEJiIqBBQKBfbv349OnTph2LBhqFOnDvbu3YurV6/i/v37mDx5MipVqoS9e/di69atKFmyJP744w+GOoK1tTUmT56MCRMm4OnTp9kOb0Lagz12REQy8+4Pb+ZXfEJCAjp27AhXV1dMmzYNwNt7Cc+cORMXLlzAggUL0KRJEwBvT4rX19eHUqnUzAsgrfT8+XOYm5tDR0eH4U6L8Rw7IiIZUalUUCgUiIuLw8uXL6FQKKBQKGBsbIz4+Hjpx1ilUqFEiRKYOXMmXr9+jV27dknbMDY2ZqijLCwsLKTbhDHUaS8GOyIiGdHR0UFkZCQaNGiASZMmIS4uDgCke7r+/fffUluVSoXixYvDzc0NV69ela52JPoYjo+p3fjpEBHJiEqlws8//4wHDx4gMjISs2fPRkxMDExNTTFp0iQEBQVh8eLF0NHRkX6gnzx5grJly7IXhkgGeI4dEZHMXLp0Cc2aNUP9+vWhq6uLypUrw8/PD1ZWVli1ahW+++47dO/eHTY2NkhKSsLmzZsRFhaG6tWra7p0IvpMDHZERAXY+xdKqFQq6Orq4vvvv8fr169RtGhRHDx4EC4uLpg6dSqKFy+OkJAQrFixAklJSTA3N8eMGTNQo0YNDb8SIsoLDHZERAVU5v2Anz9/jvT0dJQsWVIKehs3bsSGDRsQEhKCjRs34ueff4aLiwsmTZoEKysrKfQlJyfD0NBQ0y+FiPIIz7EjIiqgdHR0cPfuXTRo0ADNmzfH3r17cefOHQDAwIEDUbRoUcyePRujRo2Ct7c3zpw5g4ULFyI6Olq6kwSvfiWSFw5QTERUQKlUKgQFBSE6OhomJiaYMWMGHB0dYWlpifnz56N3794IDQ1Famoqpk6dCoVCgf/9739QKpWYPXs2dHR0eMEEkcww2BERFVA6OjoYMWIEkpKS8PDhQ1hYWKBHjx7w8/ND7969kZSUhGPHjsHFxQX9+/fHlClToFQq0blzZw5ZQSRT/D+biKgAs7GxwYQJE1C6dGncunULkZGROH/+PIYMGYLatWsDAExMTKT248aNg52dnWaKJaIvjhdPEBHJQFRUFObNm4ewsDD07t0bo0ePBgD8/fffcHBw0GxxRJRvGOyIiGQiOjoac+fORXh4ONq3b4/JkycDADIyMqCrq6vh6ogoPzDYERHJSGa4++uvv+Dm5oaZM2dquiQiykc8x46ISEasra0xZcoUVKhQAWfOnMGzZ880XRIR5SP22BERyVBMTAwAwMrKSsOVEFF+YrAjIiIikgkeiiUiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IiIiIplgsCMiIiKSCQY7IpINV1dXjB49WtNlEBFpDIMdEWlcv379oFAooFAooK+vD3t7e0yYMAHJyck52k5wcDBmz5792fVER0dj5MiRcHBwgFKphK2tLdq2bYujR49+8jaCgoJgbm7+2bUQEeWEnqYLICICAE9PTwQGBiItLQ0RERHw8fGBQqHA/PnzP3kbFhYWn13HgwcP4OzsDHNzcyxcuBA1atRAWloaDh8+jOHDh+PWrVuf/RyakJaWBn19fU2XQURfGHvsiEgrKJVKWFtbw9bWFt7e3mjRogX++OMPafmzZ8/Qo0cPlC5dGkWLFkWNGjXw66+/qm3j/UOxdnZ2mDdvHgYMGAATExOULVsW69ev/2gd3377LRQKBcLDw9GpUydUrFgR1apVg6+vL86ePSu1W7JkCWrUqAEjIyPY2tri22+/RWJiIgDgxIkT6N+/P+Lj46WeyBkzZgAAUlJSMG7cOJQuXRpGRkZo2LAhTpw4oVbDhg0bYGtri6JFi6JDhw5YsmRJlt6/gIAAlC9fHgYGBqhUqRJ+/vlnteUKhQIBAQFo164djIyMMGfOHDg6OmLRokVq7S5dugSFQoHIyMiPvi9EVDAw2BGR1rl27RrOnDkDAwMDaV5ycjLq1auHAwcO4Nq1a/jmm2/Qp08fhIeHf3RbixcvRv369fHXX3/h22+/xbBhw3D79u1s2z5//hyHDh3C8OHDYWRklGX5u+FKR0cHK1aswPXr17Fp0yYcO3YMEyZMAAA0atQIy5Ytg6mpKaKiohAVFYVx48YBAEaMGIGwsDBs3boVV65cQZcuXeDp6Ym7d+8CAE6fPo2hQ4di1KhRuHTpEtzd3TF37ly1Onbt2oVRo0Zh7NixuHbtGoYMGYL+/fvj+PHjau1mzJiBDh064OrVqxg4cCAGDBiAwMBAtTaBgYFo0qQJHB0dP/o+ElEBIYiINMzHx0fo6uoKIyMjoVQqBQCho6MjduzY8dH1WrduLcaOHStNN23aVIwaNUqaLleunOjdu7c0rVKpRMmSJUVAQEC22zt37pwAIIKDg3P8Gn777TdRvHhxaTowMFCYmZmptXn48KHQ1dUVjx8/Vpvv5uYm/Pz8hBBCdOvWTbRu3Vptea9evdS21ahRIzF48GC1Nl26dBGtWrWSpgGI0aNHq7V5/Pix0NXVFefOnRNCCJGamiosLS1FUFBQzl4sEWkt9tgRkVZo1qwZLl26hHPnzsHHxwf9+/dHp06dpOUZGRmYPXs2atSoAQsLCxgbG+Pw4cP4559/PrrdmjVrSv9WKBSwtrbG06dPs20rhPjkekNCQuDm5obSpUvDxMQEffr0wbNnz/D69esPrnP16lVkZGSgYsWKMDY2lh4nT57EvXv3AAC3b99GgwYN1NZ7f/rmzZtwdnZWm+fs7IybN2+qzatfv77adKlSpdC6dWv89NNPAIB9+/YhJSUFXbp0+eTXTUTajRdPEJFWMDIykg4H/vTTT6hVqxY2btyIgQMHAgAWLlyI5cuXY9myZdK5baNHj0ZqaupHt/v+BQMKhQIqlSrbthUqVIBCofjPCyQePHiANm3aYNiwYZg7dy4sLCwQGhqKgQMHIjU1FUWLFs12vcTEROjq6iIiIgK6urpqy4yNjT/6nLmR3eHkQYMGoU+fPli6dCkCAwPRrVu3D9ZLRAUPe+yISOvo6Ohg8uTJmDp1Kt68eQPg7bln7du3R+/evVGrVi04ODjgzp07efq8FhYW8PDwwOrVq5GUlJRl+cuXLwEAERERUKlUWLx4Mb7++mtUrFgRT548UWtrYGCAjIwMtXl16tRBRkYGnj59CkdHR7WHtbU1AKBSpUo4f/682nrvT1epUgWnT59Wm3f69GlUrVr1P19jq1atYGRkhICAABw6dAgDBgz4z3WIqOBgsCMirdSlSxfo6upi9erVAN72pv3xxx84c+YMbt68iSFDhiAmJibPn3f16tXIyMhAgwYNsHPnTty9exc3b97EihUr4OTkBABwdHREWloaVq5cib///hs///wz1q5dq7YdOzs7JCYm4ujRo4iLi8Pr169RsWJF9OrVC3379kVwcDDu37+P8PBw+Pv748CBAwCAkSNH4uDBg1iyZAnu3r2LdevW4ffff4dCoZC2PX78eAQFBSEgIAB3797FkiVLEBwcLF2g8TG6urro168f/Pz8UKFCBek1EZE8MNgRkVbS09PDiBEjsGDBAiQlJWHq1KmoW7cuPDw84OrqCmtra3h7e+f58zo4OODixYto1qwZxo4di+rVq8Pd3R1Hjx5FQEAAAKBWrVpYsmQJ5s+fj+rVq2Pz5s3w9/dX206jRo0wdOhQdOvWDSVKlMCCBQsAvL0KtW/fvhg7diwqVaoEb29vnD9/HmXLlgXw9ly5tWvXYsmSJahVqxYOHTqEMWPGwNDQUNq2t7c3li9fjkWLFqFatWpYt24dAgMD4erq+kmvMfOQcf/+/fPgHSMibaIQOTlbmIiI8t3gwYNx69YtnDp1Kk+2d+rUKbi5ueHRo0ewsrLKk20SkXbgxRNERFpm0aJFcHd3h5GREX7//Xds2rQJa9as+eztpqSkIDY2FjNmzECXLl0Y6ohkiIdiiYi0THh4ONzd3VGjRg2sXbsWK1aswKBBgz57u7/++ivKlSuHly9fSoeGiUheeCiWiIiISCbYY0dEREQkEwx2RERERDLBYEdEREQkEwx2RERERDLBYEdEREQkEwx2RERERDLBYEdEREQkEwx2RERERDLBYEdEREQkE/8PEnyRQ1p0BwkAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ax = rain_flow_SI_df['Rain_Category'].value_counts().reindex(columns).plot(kind='bar')\n",
+    "ax.set_title('Rainfall Category Counts')\n",
+    "ax.set_xlabel('Rain Category')\n",
+    "ax.set_ylabel('Count')\n",
+    "plt.xticks(rotation=45)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
   },
   {
    "cell_type": "markdown",