Updated Layout

Gradio_app.ipynb

@@ -2,14 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Running on local URL:  http://127.0.0.1:7873\n",
+      "Running on local URL:  http://127.0.0.1:7860\n",
       "\n",
       "To create a public link, set `share=True` in `launch()`.\n"
      ]
@@ -17,7 +17,7 @@
     {
      "data": {
       "text/html": [
-       "<div><iframe src=\"http://127.0.0.1:7873/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -30,196 +30,9 @@
      "data": {
       "text/plain": []
      },
-     "execution_count": 49,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Starting to download inventory\n",
-      "Finished downloading inventory\n",
-      "Processing CI.CCC...\n",
-      "Downloading waveform for CI_CCC_2019-07-04T17:33:40.494920Z\n",
-      "Skipping CI_CCC_2019-07-04T17:33:40.494920Z\n",
-      "Processing CI.CLC...\n",
-      "Processing CI.JRC2...\n",
-      "Reading cached waveform\n",
-      "Added CI.JRC2 to the list of waveforms\n",
-      "Processing CI.LRL...\n",
-      "Reading cached waveform\n",
-      "Added CI.LRL to the list of waveforms\n",
-      "Processing CI.MPM...\n",
-      "Reading cached waveform\n",
-      "Processing CI.Q0072...\n",
-      "Reading cached waveform\n",
-      "Processing CI.SLA...\n",
-      "Reading cached waveform\n",
-      "Added CI.SLA to the list of waveforms\n",
-      "Processing CI.SRT...\n",
-      "Reading cached waveform\n",
-      "Added CI.SRT to the list of waveforms\n",
-      "Processing CI.TOW2...\n",
-      "Reading cached waveform\n",
-      "Added CI.TOW2 to the list of waveforms\n",
-      "Processing CI.WBM...\n",
-      "Downloading waveform for CI_WBM_2019-07-04T17:33:40.063616Z\n",
-      "Skipping CI_WBM_2019-07-04T17:33:40.063616Z\n",
-      "Processing CI.WCS2...\n",
-      "Downloading waveform for CI_WCS2_2019-07-04T17:33:40.200958Z\n",
-      "Skipping CI_WCS2_2019-07-04T17:33:40.200958Z\n",
-      "Processing CI.WMF...\n",
-      "Reading cached waveform\n",
-      "Added CI.WMF to the list of waveforms\n",
-      "Processing CI.WNM...\n",
-      "Reading cached waveform\n",
-      "Processing CI.WRC2...\n",
-      "Downloading waveform for CI_WRC2_2019-07-04T17:33:38.698099Z\n",
-      "Skipping CI_WRC2_2019-07-04T17:33:38.698099Z\n",
-      "Processing CI.WRV2...\n",
-      "Reading cached waveform\n",
-      "Processing CI.WVP2...\n",
-      "Downloading waveform for CI_WVP2_2019-07-04T17:33:39.650402Z\n",
-      "Skipping CI_WVP2_2019-07-04T17:33:39.650402Z\n",
-      "Processing NP.1809...\n",
-      "Reading cached waveform\n",
-      "Processing NP.5419...\n",
-      "Reading cached waveform\n",
-      "Processing PB.B916...\n",
-      "Reading cached waveform\n",
-      "Processing PB.B917...\n",
-      "Reading cached waveform\n",
-      "Processing PB.B918...\n",
-      "Reading cached waveform\n",
-      "Processing PB.B921...\n",
-      "Reading cached waveform\n",
-      "Starting to run predictions\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:299: FutureWarning: The input object of type 'Tensor' is an array-like implementing one of the corresponding protocols (`__array__`, `__array_interface__` or `__array_struct__`); but not a sequence (or 0-D). In the future, this object will be coerced as if it was first converted using `np.array(obj)`. To retain the old behaviour, you have to either modify the type 'Tensor', or assign to an empty array created with `np.empty(correct_shape, dtype=object)`.\n",
-      "  waveforms = np.array(waveforms)[selection_indexes]\n",
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:299: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
-      "  waveforms = np.array(waveforms)[selection_indexes]\n",
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:306: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
-      "  waveforms = [torch.tensor(waveform) for waveform in waveforms]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Starting plotting 3 waveforms\n",
-      "Fetching topography\n",
-      "Plotting topo\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/anovosel/miniconda3/envs/phasehunter/lib/python3.11/site-packages/bmi_topography/api_key.py:49: UserWarning: You are using a demo key to fetch data from OpenTopography, functionality will be limited. See https://bmi-topography.readthedocs.io/en/latest/#api-key for more information.\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Plotting waveform 1/3\n",
-      "Station 35.98249, -117.80885 has P velocity 4.13660431013202 and S velocity 2.2622770044299756\n",
-      "Plotting waveform 2/3\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:391: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
-      "  output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]],\n",
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:391: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
-      "  output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]],\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Station 36.11758, -117.85486 has P velocity 4.743224278343435 and S velocity 2.6493777937777434\n",
-      "Plotting waveform 3/3\n",
-      "Station 35.69235, -117.75051 has P velocity 3.4168555245020182 and S velocity 1.6801806885131727\n",
-      "Plotting stations\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:391: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
-      "  output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]],\n",
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:411: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  ax[i].set_xticklabels(ax[i].get_xticks(), rotation = 50)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  station_name    st_lat     st_lon                    starttime  p_phase, s  \\\n",
-      "0      CI.JRC2  35.98249 -117.80885  2019-07-04T17:33:39.947494Z    7.320212   \n",
-      "1       CI.WMF  36.11758 -117.85486  2019-07-04T17:33:41.867962Z    9.509396   \n",
-      "2       CI.SRT  35.69235 -117.75051  2019-07-04T17:33:38.029990Z    4.530285   \n",
-      "\n",
-      "   p_uncertainty, s  s_phase, s  s_uncertainty, s  velocity_p, km/s  \\\n",
-      "0          0.020417   13.385108          0.028439          4.136604   \n",
-      "1          0.017238   17.024826          0.043195          4.743224   \n",
-      "2          0.013012    9.212895          0.018260          3.416856   \n",
-      "\n",
-      "   velocity_s, km/s  \n",
-      "0          2.262277  \n",
-      "1          2.649378  \n",
-      "2          1.680181  \n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:529: MatplotlibDeprecationWarning: Unable to determine Axes to steal space for Colorbar. Using gca(), but will raise in the future. Either provide the *cax* argument to use as the Axes for the Colorbar, provide the *ax* argument to steal space from it, or add *mappable* to an Axes.\n",
-      "  plt.colorbar(m)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  station_name    st_lat     st_lon                    starttime  p_phase, s  \\\n",
-      "0      CI.JRC2  35.98249 -117.80885  2019-07-04T17:33:39.947494Z    7.320212   \n",
-      "1       CI.WMF  36.11758 -117.85486  2019-07-04T17:33:41.867962Z    9.509396   \n",
-      "2       CI.SRT  35.69235 -117.75051  2019-07-04T17:33:38.029990Z    4.530285   \n",
-      "\n",
-      "   p_uncertainty, s  s_phase, s  s_uncertainty, s  velocity_p, km/s  \\\n",
-      "0          0.020417   13.385108          0.028439          4.136604   \n",
-      "1          0.017238   17.024826          0.043195          4.743224   \n",
-      "2          0.013012    9.212895          0.018260          3.416856   \n",
-      "\n",
-      "   velocity_s, km/s  \n",
-      "0          2.262277  \n",
-      "1          2.649378  \n",
-      "2          1.680181  \n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/3370384716.py:529: MatplotlibDeprecationWarning: Unable to determine Axes to steal space for Colorbar. Using gca(), but will raise in the future. Either provide the *cax* argument to use as the Axes for the Colorbar, provide the *ax* argument to steal space from it, or add *mappable* to an Axes.\n",
-      "  plt.colorbar(m)\n"
-     ]
     }
    ],
    "source": [
@@ -760,7 +573,10 @@
     "\n",
     "    return image\n",
     "\n",
-    "model = torch.jit.load(\"model.pt\")\n",
+    "# model = torch.jit.load(\"model.pt\")\n",
+    "model = torch.jit.load(\"quantized_model.pt\")\n",
+    "\n",
+    "model.eval()\n",
     "\n",
     "with gr.Blocks() as demo:\n",
     "    gr.HTML(\"\"\"\n",
@@ -823,17 +639,18 @@
     "                                    )\n",
     "            with gr.Column(scale=1):\n",
     "                upload = gr.File(label=\"Or upload your own waveform\")\n",
-    "                sampling_rate_inputs = gr.Slider(minimum=10,\n",
-    "                        maximum=1000,\n",
-    "                        value=100,\n",
-    "                        label=\"Samlping rate, Hz\",\n",
-    "                        step=10,\n",
-    "                        info=\"Sampling rate of the waveform\",\n",
-    "                        interactive=True,\n",
-    "                        )\n",
-    "                order_input = gr.Text(value='ZNE', \n",
-    "                                      label='Channel order', \n",
-    "                                      info='Order of the channels in the waveform file (e.g. ZNE)')\n",
+    "                with gr.Row():\n",
+    "                    sampling_rate_inputs = gr.Slider(minimum=10,\n",
+    "                            maximum=1000,\n",
+    "                            value=100,\n",
+    "                            label=\"Samlping rate, Hz\",\n",
+    "                            step=10,\n",
+    "                            info=\"Sampling rate of the waveform\",\n",
+    "                            interactive=True,\n",
+    "                            )\n",
+    "                    order_input = gr.Text(value='ZNE', \n",
+    "                                        label='Channel order', \n",
+    "                                        info='Order of the channels in the waveform file (e.g. ZNE)')\n",
     "\n",
     "        button = gr.Button(\"Predict phases\")\n",
     "        outputs = gr.Image(label='Waveform with Phases Marked', type='numpy', interactive=False)\n",
@@ -963,140 +780,15 @@
     "                         inputs=inputs_vel_model, \n",
     "                         outputs=outputs_vel_model)\n",
     "\n",
-    "\n",
-    "            \n",
-    "\n",
-    "\n",
     "demo.launch()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[53, 52, 28, ...,  0,  0,  0]], dtype=int32)"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Loaded (1, 25412)\n",
-      "Reshaped (1, 25412)\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Loaded (1, 25412)\n",
-      "Reshaped (1, 25412)\n"
-     ]
-    }
-   ],
-   "source": [
-    "np.load('test_no_p.npy')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "2023-04-10T00:16:56.000000Z"
-      ]
-     },
-     "execution_count": 48,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "obspy.UTCDateTime('2023-04-09T17:16:56-07')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "np.save(\"test.npy\", np.random.randint(0,10, size=(6000)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1 0 2\n"
-     ]
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "\n",
-    "\n",
-    "# Example usage:\n",
-    "waveform = np.random.rand(3, 100)  # A random waveform with 3 channels and 100 samples\n",
-    "channels = 'NZE'\n",
-    "\n",
-    "sorted_waveform = sort_channels_to_ZNE(waveform, channels)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "KeyboardInterrupt\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABhtUlEQVR4nO3deXxTdbo/8E+WJum+r1AoZStlp0gtIKB0KMqIOG44OCiD8BtHvCJeF2ZGmHEZ3MY7V+XKiOKO28ygiE4Ryw6FYmtZW6BQaKFN9yZdkyY5vz/SE6i00EKTk5x83q9XXrxIT5InoZw857s8j0IQBAFEREREMqKUOgAiIiKi3sYEh4iIiGSHCQ4RERHJDhMcIiIikh0mOERERCQ7THCIiIhIdpjgEBERkewwwSEiIiLZUUsdgBRsNhvKysoQGBgIhUIhdThERETUDYIgoKGhAXFxcVAqLz9G45UJTllZGeLj46UOg4iIiK5CaWkp+vbte9ljvDLBCQwMBGD/gIKCgiSOhoiIiLrDaDQiPj7e8T1+OV6Z4IjTUkFBQUxwiIiIPEx3lpdwkTERERHJDhMcIiIikh0mOERERCQ7THCIiIhIdpjgEBERkewwwSEiIiLZYYJDREREssMEh4iIiGSHCQ4RERHJjlMTnJ07d+LWW29FXFwcFAoFvvrqqys+Zvv27Rg3bhy0Wi0GDRqE999//5JjVq9ejYSEBOh0OqSmpiInJ6f3gyciIiKP5dQEp6mpCaNHj8bq1au7dXxxcTFmzZqFG2+8Efn5+Vi6dCkefPBBbN682XHM559/jmXLlmHlypXIy8vD6NGjkZGRgcrKSme9DSIiIvIwCkEQBJe8kEKBDRs2YM6cOV0e89RTT+Hbb7/FkSNHHPfNnTsX9fX1yMzMBACkpqbiuuuuw5tvvgkAsNlsiI+PxyOPPIKnn366W7EYjUYEBwfDYDCwFxUREZGH6Mn3t1s128zOzkZ6enqH+zIyMrB06VIAgNlsRm5uLpYvX+74uVKpRHp6OrKzs7t8XpPJBJPJ5Pi70Wjs3cCpUxarDQXlDTh0vh56QytMFht0aiX6hPpiWGwQhscFQ6W8csM0IqLLEQQB5+pakFdSh3N1LahvNkOjViLMX4uh0YEY0y8EAVq3+rojF3Crf3G9Xo/o6OgO90VHR8NoNKKlpQV1dXWwWq2dHlNYWNjl865atQp/+ctfnBIzXerIeQPW55Tgm4NlaGi1dHlcuL8GN4+MwQMTEzAoKtCFERKRHNQ0mvBpTgn+nXcep6ubujxOo1Ji8uAI3Hd9P0wbEgUlL6y8glslOM6yfPlyLFu2zPF3o9GI+Ph4CSOSp6LKRryyuRCbj1Y47gvUqTGuXyj6hvrCX6tGs9mCszXNyC+pR02TGR/vK8HH+0owa1Qslt+chL6hfhK+AyLyBE0mC/5vexHe23MGzWYrAMBHpcDwuGAMjgpAqL8GZosNekMrjpQZcK6uBVsLK7G1sBJDowPxzC+TMXlwhMTvgpzNrRKcmJgYVFRUdLivoqICQUFB8PX1hUqlgkql6vSYmJiYLp9Xq9VCq9U6JWYCrDYBa3edxmvfn4DZaoNSAcwaFYd7r4tHamJ4p9NQbVYbsk/V4KN9Z/FDQQW+PVSOH45V4I+zhuE31/eHQsErLCK61N6iajz5r0M4V9cCABjZJxjz0/rj5pGxnU5DCYKAospGfPFjKT7LKcXxigbc9+5+zB4dh+dvH4EgnY+r3wK5iFslOGlpafjuu+863LdlyxakpaUBADQaDVJSUpCVleVYrGyz2ZCVlYUlS5a4OlwCUN9sxsPr87CnqAYAMHVIJP40axgGR19+yslHpcSUIZGYMiQSR8sMeG7TMew7XYsVXx/FzhNV+J97xiCQJx4iaicIAt7YWoTXtpwAAPQJ8cUzv0xGxvDoy14QKRQKDI4OxB9nJWPJjYPxPz+cwEf7zmLjwTL8VFqHt+alYESfYFe9DXIhp24Tb2xsRH5+PvLz8wHYt4Hn5+ejpKQEgH3qaP78+Y7jf/e73+H06dN48sknUVhYiP/7v//DF198gccee8xxzLJly7B27Vp88MEHKCgowEMPPYSmpiYsWLDAmW+FOnGqqhFzVu/BnqIa+GlUePmOUXh/wXVXTG5+bnhcMD5ddD3+fGsyNGolfiioxF1rslFW3+KkyInIk5gsVixZ/5Mjubl3Qjw2PzYFM0fE9Gi0N9jPB3+ePRxf/i4NfUN9UVrbgrvWZGNbIcuMyJFTt4lv374dN9544yX333///Xj//ffxwAMP4MyZM9i+fXuHxzz22GM4duwY+vbti2eeeQYPPPBAh8e/+eabeOWVV6DX6zFmzBi8/vrrSE1N7XZc3CZ+7U5UNODXa/ejutGEPiG+eOf+8RgWe+2f5eFzBvz2gwOoajAhJkiHzxZfj4QI/16ImIg8UYvZiv/3cS52nqiCj0qB524bgbkT+l3z8xpa2rBkfR52nayGSqnAq3eNwu1j+/ZCxORMPfn+dlkdHHfCBOfaHNc34Ndr96GmyYxhsUH4aOEERAT03hqnc3XNeOC9AyiqbERcsA6f/780xIdx8TGRt2lts+K37x/A3lM18PVR4d37x2PioN5bHNxmteHpfx3Gv/LOQakAXr93LH45Kq7Xnp96X0++v9mLinqk3NCC+9floKbJjBF9gvDpotReTW4AoG+oH9YvSkVipD/KDK349Tv7UN1ouvIDiUg2rDYBy77Ix95TNQjQqvHhwgm9mtwA9rWAr9w5CveMj4dNAJZ+ls/pKhlhgkPd1tDahgXvHYDe2IpBUQH4eGEqQvw0TnmtqEAdPl10PfqF+aG0tgWLP/wRrW1Wp7wWEbmf5789hu8O66FRKbF2/nhclxDmlNdRKhX4669GYs6YOFhsApasz8NxfYNTXotciwkOdYvNJmDpZ/ko1DcgMlCL9x64zmnJjSg6SId1D1yHIJ0aeSX1eOpfh+CFM6pEXueLA6V4b88ZAMCrd49G2sBwp76eSqnAK3eNxvWJYWgyW7HwgwMcNZYBJjjULWt2nkJWYSU0aiXevX+8y9bEDIoKwJr7UqBWKvB1fhk+2nfWJa9LRNI4WmbAM1/b+xEu+8UQzB7tmjUxPiol3pqXgv7hfjhX14JHP/sJNhsvqDwZExy6on2na/Dq5uMAgGdnD8eoviEuff2JgyKw/JZhAIDnNxXgyHmDS1+fiFzD0NKGhz7Og8liw01JUVhy4yCXvn6ovwbvzB8PXx8V9hTV4K0dp1z6+tS7mODQZRma2+xXMgLwq3F9cM910rS4+O2kBKQPi4bZasOS9XloNHXd44qIPNOfNx5FSW0z+ob64rW7R0vSM2pwdCD+cttwAMBrW07gxzO1Lo+BegcTHLqsv3xzFBVGExIj/PH8nBGStVBQKOx1KvqE+OJMTTNe+k/XzVWJyPNkHinHhp/OO7ZrO3uN3+XcldIXt42Jg9Um4LEv8tFs5gWVJ2KCQ136/qge/24/4bx692j4aaTt7BHip8HLd44CAHy07yyyT9VIGg8R9Y7qRhP+uMG+7uZ3UwdiXL9QSeNRKBR4fs4IxAXrUFrbglc3n5A0Hro6THCoU/XNZvyh/YSzeIr0JxzRpEERuLe9iulT/zrEKysiGVi58ShqmsxIignEo+mDpQ4HABCo88FffzUSAPDe3mLknuVUladhgkOdemXzcVQ3mjAoKgBL3eSEI/rDLUmIC9ahpLYZf//hpNThENE12HmiCt8eKm9vlzAaWrVK6pAcpg2Nwh3j+kIQgCf/eQhmi03qkKgHmODQJQ6dq8f6HHtD1BfmjIDOx31OOID9yur520cAANbtLkZRJYtyEXkik8WKlRuPAgDuT0twy67ez/xyGCICNDhV1YT39xZLHQ71ABMc6sBmE/DM10chCMDtY/sgNdG5Bbau1k1J0UgfFgWLTcCfNx5jAUAiD7R252kUVzchMlCLpb9wr5FiUYifBk/OTAIA/O8PJ1FpbJU4IuouJjjUwRc/luJgaT0CtGosvzlJ6nAu65lfJkOjVmJ3UTU2H9VLHQ4R9cD5+ha8ua0IAPCnWcMQpPOROKKu3TmuL0bHh6DJbMWLmdzB6SmY4JBDk8mCV7+37xZYmj4YUUE6iSO6vP7h/vjdlEQAwPPfFsBkYa8qIk/xt++Po7XNhgkDwlxWrfhqKZUK/GW2vTbOv/POI6+kTuKIqDuY4JDDu7uLUd1oQv9wP8xPS5A6nG55aNogRAdpca6uBZ/sK5E6HCLqhmNlRmz46TwA4I+3DJOsvlZPjIkPwZ0pfQEAL35XyGlxD8AEhwDY61D8o70s+X/PGAqN2jN+NXw1KixNHwIAeHNbERpa2ySOiIiu5MXMQggC8MtRsRgdHyJ1ON32+Iwh0KiVyDlTi+0nqqQOh67AM77FyOne3FqEJrMVo/oGY9bIWKnD6ZG7UvoiMdIftU1mrN15WupwiOgydp+sxs4TVfBRKfBExlCpw+mR2GBfPDAxAQDwcuZxNuN0c0xwCCU1zfhkv71L99MzkyTp/3It1Colnmw/Ua7dVYzKBu5yIHJHgiDg5c32RbrzUvujf7i/xBH13ENTByJQq0ZBuRHfHCqTOhy6DCY4hNXbitBmFXDD4AhMHBQhdThXJWN4DMbEh6ClzYp/7OAoDpE72n68CofOGeDro8IjN7m2U3hvCfXX4P9NtW9u+Nv3J2Cxsvifu2KC4+XO1TXjX3nnAMCxlsUTKRQKPPYLe/yf7D+L6kaTxBER0cUEQcDfs+yVx+en9Ud4gFbiiK7ebycPQLi/BiW1zdh4kKM47ooJjpd7a/spWGwCJg+KQEp/9+g3dbWmDI7A6L7BaG2zYe0ujuIQuZOdJ6txsLQeOh8lHrwhUepwromfRo2FNwwAYB8Bt3ItjltiguPFyg0t+PJH++iNpw4XX0yhUOCRm+zVUD/KPou6JrPEERERYB+9+d8f7DW25qX2R2Sg547eiH5zfX8E6dQ4VdWEzCMsNOqOmOB4sX/sOA2z1V5oy11bMvTU9GFRSI4NQrPZinV72DeGyB3sPVWDvJJ6aNVK/L8pnj16IwrU+WDBJPsozhtbT7IujhtiguOlqhtN+LS9oeaj092zB8zVUCgU+K/p9tGo9/ecYV0cIjfw1nZ7ja17J/Rz+wrpPbFgUgL8NSoU6huQVVApdTj0M0xwvNSH2WdhstgwOj4EEwfKY/RGNCM5BgMj/dFgsuDzA6VSh0Pk1Y6VGbG7qBoqpQILJw+QOpxeFeKnwW/aq76/1V4oldwHExwv1Npmxcf77HVvFt0wwCPKpPeEUqnAwsn2YfD39pzhNk4iCb3TvuD/5hExiA/zkzia3vfbyQnQqJTIPVuHn9ijyq0wwfFC/847j9omM/qE+GLm8Bipw3GKX43rg3B/Dc7Xt+A/XABIJIlyQ4tjG/Vimay9+bmoQB1ubW8W+u5urvtzJ0xwvIzNJuDd3fYrqt9OHgC1Sp6/AjofFe67vj8A+xUkFwASud77e8/AYhOQOiAMo/qGSB2O04hTb/85ose5umaJoyGRPL/dqEvbT1TiVFUTArVq3D2+r9ThONVv0vpDo1bi4DkDcoprpQ6HyKs0tLZh/T77RoZFHl735kqS44IwcWA4rDYBH+w9I3U41I4JjpdZu9M+hHpvaj8E6nwkjsa5IgK0uGNcHwDAOxw6JnKpf+aeQ4PJgsRIf9yUFCV1OE73YHvhv89yStFoskgcDQFMcLxKod6I7NM1UCkVjo64cicOHWcVVHDomMhFBEHAR+0bGRZMTPC4Br5XY9qQKCS279788kfu3nQHLklwVq9ejYSEBOh0OqSmpiInJ6fLY6dNmwaFQnHJbdasWY5jHnjggUt+PnPmTFe8FY8m7pyakRyNuBBfiaNxjUFRgZg4MBw2AY66P0TkXHtP1eB0VRP8NSrcPk7eU+EipVKBBe0Xjh/vO8t1f27A6QnO559/jmXLlmHlypXIy8vD6NGjkZGRgcrKzosi/fvf/0Z5ebnjduTIEahUKtx1110djps5c2aH4z799FNnvxWP1miyYEPeeQD2EuPeRHy/nx8ohclilTgaIvn7KNt+MfWrcX0RoFVLHI3rzBnbB34aFU5VNSH7dI3U4Xg9pyc4r732GhYtWoQFCxYgOTkZa9asgZ+fH9atW9fp8WFhYYiJiXHctmzZAj8/v0sSHK1W2+G40FDPbhTpbF/9dB5NZisSI/2RJrPCfleSnhyN6CAtqhvN7BlD5GTlhhZsKagAYF/o700CdT6YM9a+7u+TfRwxlppTExyz2Yzc3Fykp6dfeEGlEunp6cjOzu7Wc7z77ruYO3cu/P39O9y/fft2REVFYejQoXjooYdQU9N1tmwymWA0GjvcvIkgCI7pqXmp/WVX2O9KfFRK3DuhHwCedIic7dP9JbC2bw0fEh0odTgud1+qPanbfFSPSmOrxNF4N6cmONXV1bBarYiOju5wf3R0NPT6K19J5+Tk4MiRI3jwwQc73D9z5kx8+OGHyMrKwksvvYQdO3bg5ptvhtXa+fTDqlWrEBwc7LjFx8df/ZvyQHkldSjUN0Dno8SdXjIf/nP3TugHlVKBnDO1KNR7V4JL5Cpmiw2ftrdH8bbRG1FyXBDG9QuBxSawVYzE3HoX1bvvvouRI0diwoQJHe6fO3cuZs+ejZEjR2LOnDnYtGkTDhw4gO3bt3f6PMuXL4fBYHDcSku965dOnA+/dVQcgv3kvTW8K9FBOmQMtyfa4udBRL3r+2N6VDWYEBmoxYxkeVZJ7w6xyOinOfbRLJKGUxOciIgIqFQqVFRUdLi/oqICMTGX/+VvamrCZ599hoULF17xdRITExEREYGioqJOf67VahEUFNTh5i1qm8z47rB9tMxbr6hE4tDx1/llaDFzsTFRbxNHLO4ZHw+N2q2vn53qlpGxCPXzQZmhFVsL2WVcKk79DdRoNEhJSUFWVpbjPpvNhqysLKSlpV32sV9++SVMJhPuu+++K77OuXPnUFNTg9jY2GuOWW42/HQeZqsNI/sEy7pUendcnxiOfmF+aDRZ8N3hcqnDIZKVc3XN2F1UDQC4e7x3LQP4OZ2PCnem2JcDfMGaOJJxeoq9bNkyrF27Fh988AEKCgrw0EMPoampCQsWLAAAzJ8/H8uXL7/kce+++y7mzJmD8PCOO34aGxvxxBNPYN++fThz5gyysrJw2223YdCgQcjIyHD22/EogiA4Ck7dfZ13n3AAe52Ku3jSIXKKf+aegyAAEweGo1+4/LqG95SY5G0trERlAxcbS8HpCc4999yDV199FStWrMCYMWOQn5+PzMxMx8LjkpISlJd3vJo+fvw4du/e3en0lEqlwqFDhzB79mwMGTIECxcuREpKCnbt2gWtVuvst+NRjpw3olDfAI1aidmj4qQOxy3cOb4vFApgf3EtzlQ3SR0OkSzYbAK+/PEcAI7eiAZHB2JsvxBYbQK++um81OF4JZdUYFqyZAmWLFnS6c86Wxg8dOjQLqtA+vr6YvPmzb0ZnmyJoxQZw2O8dnHxz8UG+2LK4EjsOFGFL3NL8URGktQhEXm8vadqcL6+BYE6NWaO8N7FxT93V0o8fiqpxxc/nsOiGxK9rkSH1Lx3FZjMtbZZ8XW+/apB7l3De+qe9um6f+aeg8VqkzgaIs8nXkzdNiYOOh+VxNG4j1+OjoXOR4miykbkl9ZLHY7XYYIjU1uOVcDYakFcsA4TB0ZIHY5bmT4sCqF+PqgwmrDrZLXU4RB5NENzGzKP2ndqcnqqoyCdD24ZYd/88kX7FB65DhMcmRKvqO5I6QuVF3Ty7QmtWoXbx9pHtViIi+jafH3wPMwWG5JiAjGyT7DU4bidO9tH0L85yPIUrsYER4bK6lsc2zXFrYrU0d3X2T+XrMIK1DWZJY6GyHNdvLiYa0wudf2AcMSH+aLRZMF/jrA8hSsxwZGhf+fZt2umDghD/3D/Kz/ACyXFBCE5NghtVgHfsiYO0VUpqmzA4fMGqJQK3DaGOzU7o1QqcOc4+9Tdv/O4m8qVmODIjCAI2NC+JfEOjt5c1pyx9hOyuBibiHrmq5/KAABTh0QiPIBlOrpye3uH8b2nqtmA04WY4MjM0TIjTlU1QaNW4mZu17ys2aP7QKEADpypQ2lts9ThEHkUQRDwVfvFAUdvLq9fuB/G9QuBTQA2HiyTOhyvwQRHZsTRiPRhUQjUsfbN5cQE6zBxoL1SNkdxiHom92wdztW1wF+j8urGmt01p30U5+t8JjiuwgRHRqw2wXF1cNuYPhJH4xnmtH9OG34632VxSSK6lDh6kzE8Br4a1r65klkjY6FSKnD4vAFFlY1Sh+MVmODIyP7iGlQYTQjSqTFtaKTU4XiEmSNioFUrcaqqCUfLjFKHQ+QRzBYbvj1kX5wvjkzQ5YUHaDF1iP28zBFj12CCIyNfty/4u2VkLLRqXlF1R6DOB+nJ9r5oG9gvhqhbdp6oQl1zGyIDtY5pXroyca3S1/llHDF2ASY4MmGyWPFde40FTk/1zO3tn9fGg2Vs3UDUDeL01K2j4qBW8Wuku36RHA0/jQoltc3IK6mXOhzZ42+mTGwrrEJDqwUxQTqkDgiTOhyPMmVIJEL9fFDVYMLeUzVSh0Pk1hpa27DlWAWAC9ufqXv8NGpkDLcvyOY0lfMxwZGJjQft/1lmj4mDkq0ZekSjVuKWkfZ+MeK6AiLq3JZjFTBZbEiM9MeIPkFSh+NxxGmqTYfK0cYRY6digiMDxtY2/FBQCYD1KK7WrFH2BCfzqJ4nHaLLEC8Cbh0Vx9YMV2HyoAiE+2tQ22TGvtMcMXYmJjgy8MOxCpgtNgyKCkByLK+orkbqgHBEBGhhaGlz9PEioo4MLW3YebIKwIWLAuoZtUqJjPYirBwxdi4mODLwXXsvpVtGxvKK6iqplArcMpInHaLL+eFYBdqsAgZHBWBIdKDU4XisX7ZPiW/miLFTMcHxcMbWNuw8YR9xmDWSV1TXYtZFJx2zhScdop8TG9Ny9ObaTBgQhnB/Deqa25DNjQ1OwwTHw20tqITZasPASH8MiQ6QOhyPNj4hDFGBWjS0WrC7qErqcIjciqGlDbvE6SleTF0TtUqJme3TVOIIPPU+JjgeznFFxempa2afprKfuDdxmoqogy3t01NDogMwmNNT10xMErmxwXmY4HiwhtY27Dhhv6K6hUPGvUIcet9ytAImi1XiaIjcx7eH7JXSZ43kTs3eMGFAGCICNKhvbmP9LSdhguPBthZWwmyxITHCH0N5RdUrUvqFIiZIhwaTxbG2icjbGZrbsOtk+1q/Uewc3hvUKqWj6N93HDF2CiY4Hkzc7cPdU71HedE0lXjFSuTtNh/Tw2ITMDQ6EIOieDHVW8QR483HOE3lDExwPFSjyYLt4vQUF/z1Ksc01bEKtLZxmoroO+6ecgp7/S1OUzkLExwPlVVgL+43IMIfw2J5RdWbxsaHICZIhyazFXtY9I+8XH2zGbvbp6d4MdW7VEqFYzcVR4x7HxMcD3WhuF8Mp6d6mVKpwIzh0QDsNXGIvFlWQeVF01MsRdHbxKRxy7EKWDhN1auY4HigJpMF249zesqZZrYv/vuhoJInHfJqYpKf0Z70U++akBCGED8f1DW34cezdVKHIytMcDzQzhNVMFls6Bfmx95TTjJhgP2kU9tk5kmHvFaL2eroPTVjOHdPOYNapcT0JI4YOwMTHA+05VgFAGBGcjSnp5yEJx0iYOfJKrS22dAnxBfD43gx5Szi6Nj3RysgCILE0cgHExwP02a1IauwEgCvqJyNJx3ydt8fbb+YGs6LKWeaMiQSvj4qnK9vwdEyo9ThyAYTHA9zoLgWhpY2hPlrkNI/VOpwZO3ik86R8zzpkHexWG3IKrQnOBm8mHIqnY8KU4dEAuCIcW9ySYKzevVqJCQkQKfTITU1FTk5OV0e+/7770OhUHS46XS6DscIgoAVK1YgNjYWvr6+SE9Px8mTJ539NtzC9+3TU+nDoqBS8orKmXjSIW+Wc6YW9c1tCPXzwXheTDndjItGjKl3OD3B+fzzz7Fs2TKsXLkSeXl5GD16NDIyMlBZWdnlY4KCglBeXu64nT17tsPPX375Zbz++utYs2YN9u/fD39/f2RkZKC1tdXZb0dSgiDg+/Yv2hnJvKJyhYwRXIdD3kn8ok0fFg21ioP9zjY9KRpqpQLHKxpwprpJ6nBkwem/ta+99hoWLVqEBQsWIDk5GWvWrIGfnx/WrVvX5WMUCgViYmIct+joC9sTBUHA3//+d/zpT3/CbbfdhlGjRuHDDz9EWVkZvvrqK2e/HUkdLTOizNAKXx8VJg+OkDocr3DTUPtJ52RlI05XNUodDpFLXHwxxekp1wj288H1ieEAeEHVW5ya4JjNZuTm5iI9Pf3CCyqVSE9PR3Z2dpePa2xsRP/+/REfH4/bbrsNR48edfysuLgYer2+w3MGBwcjNTW1y+c0mUwwGo0dbp5IPOFMHRIJnY9K4mi8Q7CfD9IGiicdDh2Tdzhy3n4x5afhxZQrscBo73JqglNdXQ2r1dphBAYAoqOjodd3/g84dOhQrFu3Dl9//TU+/vhj2Gw2TJw4EefOnQMAx+N68pyrVq1CcHCw4xYfH3+tb00S4vqbGSy45VLiFWwmTzrkJTbzYkoS4tKDn0rrUWmU95ILV3C7idW0tDTMnz8fY8aMwdSpU/Hvf/8bkZGR+Mc//nHVz7l8+XIYDAbHrbS0tBcjdo2zNU0o1DdApVTgpqQoqcPxKjOS7QnlwdJ6VPCkQ17g+2Pta/14MeVSMcE6jI4PgSAAWwo4YnytnJrgREREQKVSoaKi4z9URUUFYmK6N6/r4+ODsWPHoqioCAAcj+vJc2q1WgQFBXW4eRqxuF/qgDCE+Gkkjsa7RAXZTzoAsLWw68XxRHJQXN2EExWNUCsVuGkoExxXy3BMUzHBuVZOTXA0Gg1SUlKQlZXluM9msyErKwtpaWndeg6r1YrDhw8jNtbec2nAgAGIiYnp8JxGoxH79+/v9nN6ou8vql5MrpfePmqWxasqkrkt7aM31yeGI9jPR+JovI94jt93qgaNJovE0Xg2p09RLVu2DGvXrsUHH3yAgoICPPTQQ2hqasKCBQsAAPPnz8fy5csdxz/77LP4/vvvcfr0aeTl5eG+++7D2bNn8eCDDwKw77BaunQpnn/+eWzcuBGHDx/G/PnzERcXhzlz5jj77UiiptGEH8/UAgB+wR0Nkpg+zH7S2V1UjdY2q8TREDnPDwX2Ucpf8GJKEgMjA9A/3A9mqw27T1ZLHY5HUzv7Be655x5UVVVhxYoV0Ov1GDNmDDIzMx2LhEtKSqBUXsiz6urqsGjRIuj1eoSGhiIlJQV79+5FcnKy45gnn3wSTU1NWLx4Merr6zF58mRkZmZeUhBQLrIKK2ETgOFxQegT4it1OF5pWGwg4oJ1KDO0Yk9RtSPhIZKT+mYzctuby3KtnzQUCgWmJ0Vj3Z5iZBVUYOYIXtReLYXghU12jEYjgoODYTAYPGI9zu8+ykXmUT2Wpg/G0vQhUofjtZ756gg+2ncW907oh1W/Gil1OES97uv883j0s3wMiQ7A949NlTocr7WnqBrz3tmPiAANcv6QDiWr1jv05Pvb7XZRUUdmiw27TlYB4BWV1KYPs3/+WwvZfJPkKat9eoojlNK6LiEMgVo1qhvNOHiuXupwPBYTHDeXU1yLJrMVkYFajIgLljocr3Z9Yjj8NCpUGE1svkmyY7HasP14e4LDiylJadRKTBlq74MnJp3Uc0xw3JzYzfemoVEcppSYzkeFG9qruv7A3VQkM7ln62BstSDUzwdj+7G5ptTEJDOLpSmuGhMcNyYIgqPuyk3DeEXlDsShezHxJJIL8Yv0xqFRUPFiSnLThkZBqQAKyo04X98idTgeiQmOGztd3YSzNc3QqJSYPIj9YNzBTUlRUCjsvXr0BlY1JvkQazzxYso9hPlrMK59JI0FRq8OExw3trV97jU1MQz+Wqfv6KduiAjQYkx7VWOO4pBcnKluwqmqJqiVCkwZEil1ONTOMWLMKfGrwgTHjYlfoFzw517SHScdXlWRPIgjBBMGhCFIx+rF7iK9fTRt76kaNJtZ1binmOC4KUNLGw6cEQtuccumOxETnD1F1Wgxs6oxeT7HZgZeTLmVQVEBiA/zhdnCqsZXgwmOm9p5ogpWm4BBUQHoF+4ndTh0kSHRAegb6guTxYbdRTzpkGdraG3D/tP2VjCsf+NexKrGAEeMrwYTHDe1rZD1KNyV/aRj/3fZdpwnHfJsu05Ww2ITkBjpjwER/lKHQz8jjhhvPV4Jm40FRnuCCY4bstoExxcnh4zd07T2f5fthZWsakweTazpxIsp9zRhQBgCtGpUNZhw+LxB6nA8ChMcN5RfWoe65jYE6dRI6c+CW+4oLTEcWrUSZYZWnKxslDocoqtitQnYflxsBcPpKXekUSsdBUY5YtwzTHDckDjXOm1oFNQq/hO5I52PCmkDwwFcmE4k8jT5pfWobTIjUKfG+AReTLmrae1tG8RklLqH355uyFG9mEPGbu3Goe3TVDzpkIfa0T4iMGVIJHx4MeW2pg6xn2sOnrMnpNQ9/I12M+frW1Cob4BSAUxlwS23Jl5VHThTi4bWNomjIeq57Sfsyfk0nmvcWkywDkkxgRAEYNdJXlB1FxMcNyN28x3XLxSh/hqJo6HL6R/uj8QIf1hsAvYU1UgdDlGPVDeacOicfdEqL6bc341JHDHuKSY4bmZH+y+vODpA7m2qY26c63DIs4gjAcmxQYgK0kkcDV2JOMq240QVt4t3ExMcN2K22LD3lH0kQJxzJfd28TocbhcnT7KdF1MeZVz/UARq1ahtMuMQt4t3CxMcN5J7tg6NJgsiAjQYHhckdTjUDRMGhMHXRwW9sRWF+gapwyHqFqtNwE5x/c1QXkx5Ah+VEpPbt4tzxLh7mOC4kR3tJ5wpgyOhVCokjoa6Q+ejwkRxuzhPOuQhDp2rR11zGwK1aoztFyJ1ONRN3C7eM0xw3IiY4EzlkLFH4UmHPI14rpk8OILbwz0It4v3DH+z3USFsRUF5UYoFMANg5ngeBJxiD/3bB0MLdwuTu6P6288E7eL9wwTHDchXlGN6huCMG4P9yjxYX4YGOkPq03AHnYXJzdX22TGwXP1ALiZwROJ28VZQf3KmOC4Ccf0FOtReCRxNxVPOuTudp2sgiAASTGBiAnm9nBPI24X33mymtvFr4AJjhuwWG3YfdJ+5c8ExzOJ01TbT3C7OLk3sdYW1/p5Jm4X7z4mOG7g4Ll6GFraEOzrgzHxIVKHQ1fhugGh8NOoUNVgwtEyo9ThEHXKZhMco8XTOD3lkbhdvPuY4LgB8YrqhsERUHF7uEfSqlWYONB+0hG/QIjczZEyA2qazAjQqpHSn93DPRV3bnYPExw3wPU38iAO+TPBIXclfiFOHBgOjZqnf0918XbxmkaTxNG4L/6GS6ym0eSYR2WC49mmtm/vzztbx+7i5JZ2sHqxLHTcLs6dm11hgiOxXSerIQhseCcH/cL9kBDuB4tNQPYpdhcn91LfbMZPJXUAWP9GDsQkdSdHjLvEBEdirF4sL1PaR+F4VUXuZtfJatgEYEh0AOJCfKUOh67RlCH2NX87T1Zz52YXXJLgrF69GgkJCdDpdEhNTUVOTk6Xx65duxY33HADQkNDERoaivT09EuOf+CBB6BQKDrcZs6c6ey30etsFzW84/SUPIhVqHeyyii5GXH9Dc818pDSPxS+PipUN5pQUM5Gv51xeoLz+eefY9myZVi5ciXy8vIwevRoZGRkoLKy8+1t27dvx7333ott27YhOzsb8fHxmDFjBs6fP9/huJkzZ6K8vNxx+/TTT539VnoddzTIT9rAcKiVCpytacbZmiapwyECAAiC4Ei6uf5GHrRqFdLaG/2ybUPnnJ7gvPbaa1i0aBEWLFiA5ORkrFmzBn5+fli3bl2nx3/yySf4/e9/jzFjxiApKQnvvPMObDYbsrKyOhyn1WoRExPjuIWGel6CIG4PnzQonA3vZOLiZJVz4+QuCvUNqGowwddHhfEJnneupM7dMFicpuK5pjNO/VY1m83Izc1Fenr6hRdUKpGeno7s7OxuPUdzczPa2toQFhbW4f7t27cjKioKQ4cOxUMPPYSamq4XdZpMJhiNxg43d7DdMT3FKyo5Edfh7DjBdTjkHsQr/NTEMGjVKomjod4inmsOFNehxWyVOBr349QEp7q6GlarFdHR0R3uj46Ohl6v79ZzPPXUU4iLi+uQJM2cORMffvghsrKy8NJLL2HHjh24+eabYbV2/g+8atUqBAcHO27x8fFX/6Z6iaG5zbGjgQuM5UVc45B9qhptVpvE0RBdWPQurhEjeUiM8EefEF+YrTbsK+bOzZ9z63mRF198EZ999hk2bNgAne7CFuq5c+di9uzZGDlyJObMmYNNmzbhwIED2L59e6fPs3z5chgMBsettLTURe+ga3tO2Xc0DIoKQB/uaJCV5NgghPtr0GS2Iu9sndThkJdrbbMip7gWADClfUqD5EGhUDh2U+3iiPElnJrgREREQKVSoaKiosP9FRUViImJuexjX331Vbz44ov4/vvvMWrUqMsem5iYiIiICBQVFXX6c61Wi6CgoA43qV24ouIJR26USoWjVwznxklqB87UwmSxISZIh0FRAVKHQ71MHJXjQuNLOTXB0Wg0SElJ6bBAWFwwnJaW1uXjXn75ZTz33HPIzMzE+PHjr/g6586dQ01NDWJjY3slbmcTBMHxyziFQ8ayJP677uRVFUns4osphYK97uRm0sAIKBXAycpGlNW3SB2OW3H6FNWyZcuwdu1afPDBBygoKMBDDz2EpqYmLFiwAAAwf/58LF++3HH8Sy+9hGeeeQbr1q1DQkIC9Ho99Ho9GhsbAQCNjY144oknsG/fPpw5cwZZWVm47bbbMGjQIGRkZDj77fSKszXNOFfXAh+VAqmJYVd+AHkccWTuSJmBvWJIUuJuvhtY/0aWgv18MDo+BACwmwVGO3B6gnPPPffg1VdfxYoVKzBmzBjk5+cjMzPTsfC4pKQE5eXljuPfeustmM1m3HnnnYiNjXXcXn31VQCASqXCoUOHMHv2bAwZMgQLFy5ESkoKdu3aBa1W6+y30yt2Fdl/Ccf1C4WfRi1xNOQMUUEXesXsLuJJh6RRaWxFob4BCgUweRCnw+VKHDHewWmqDlzy7bpkyRIsWbKk05/9fGHwmTNnLvtcvr6+2Lx5cy9FJo1d7VdUU3hFJWtTh0SiUN+AnSeqcduYPlKHQ15ITK5HxAUjzF8jcTTkLFOGROB/s05iT1E1rDYBKiWnIgE330UlRxarzdGIkVdU8nahL1UVe8WQJLiZwTuM7huCQJ0a9c1tOHzeIHU4boMJjosdPFePBpMFIX4+GNEnWOpwyInGJ9h7xVQ2mFCoZ68Yci2bTXAkOJOZ4MiaWqXEpIHidnFOU4mY4LiYeMKZNDCCw4gyp1WrcH37InJu4SRXK9Q3oLrR3p6Bve7kTxwxZmmKC5jguBiHjL3LDdwuThLZXWT/orue7Rm8gvidkldSj4bWNomjcQ9McFzI2NqG/NJ6ABwy9hbiVVXOmVr2iiGXYnsG7xIf5ofECH9YbQL2nmLbBoAJjkvtO1UDq03AgAh/9A31kzoccoGBke29YizsFUOu09pmxX6xPcMQXkx5C3EUh1PidkxwXIjTU97n4l4xO7n4j1wkp7gWZosNscE6DIxkewZv4ViHwylxAExwXEqsScHt4d5FnCJglVFyFfEKnu0ZvMv1ieHwUSlQUtuMszVNUocjOSY4LlJa24zi6iaolAqkDQyXOhxyoYkDw6Fo7xWjN7RKHQ55Aa6/8U7+WrVjxxxHjJnguIw4ejM2PgSBOh+JoyFXCvHTYFR7zSO2bSBnu7g9wySOFnsdMandwWkqJjiuIg4Zc/eUdxL/3Xdz8R85mTh6w/YM3mlq+zqcfadr0Ga1SRyNtJjguIDVJmBPkX0HDYeMvdPkQe3rcIpq2LaBnOri9TfkfZJjgxDmr0GjyeIoS+KtmOC4wOHzBhha2hCoU2N0X7Zn8Ebj+ofA10eF6ka2bSDnsdkE7ObFlFdTKhWOqUlvb9vABMcFxGmJiQPDoVbxI/dGWrUKqe1tG7ibipxFbM/gp1FhXP8QqcMhiYijdzu9/FzDb1sXuNDwjldU3kwsD7CLC43JScTpqesTw9mewYuJCc6hc/WobzZLHI10mOA4WZPJgrySOgDAFM6JezVxyiCnuAatbWzbQL2PxUQJAGKDfTE4KgA2AV7dtoEJjpPtL65Bm1VAfJgv+of7Sx0OSWhIdACiArVobbMh72yd1OGQzLSYrcg5Y2/PwPU3JP4O7PLiaSomOE4mlswWd9GQ91IoFJymIqfJOWNvzxAXrMPASF5MebsbLmoR4607N5ngOJlY2I3TUwRcXA+HCQ71LnHHzGS2ZyAAqQPCoFEpcb6+BWdqmqUORxJMcJyo3NCCospGKBXAxIFMcOjCQuMjZQbUNXnv4j/qfWzPQBfz01xo2+Ct3cWZ4DiReMIZ1TcEwX5sz0BAVJAOQ6MDIQjAnlMcxaHeUWFsxfEKtmegji5MU3nnuYYJjhPt5o4G6gSnqai37WZ7BurElMHe3baBCY6T2CuKcsiYLiUmOLtOVnvt4j/qXWzPQJ3x9rYNTHCc5Fi5EbVNZvhrVBjbL0TqcMiNXLz476yXLv6j3iMIF9ozsJkvXUypvGjnphe2bWCC4yTi+pvrE8Phw/YMdBE/jdpRRp/bxelaie0ZfH1UjkWlRKLJXty2gd+8TrK7iEPG1DVx2nK3l+5uoN4jrr+ZMCCM7RnoEt7ctoEJjhO0mK04UGyvVMv+U9QZcdh476kaWLxw8R/1nl1F3MxAXfPmtg1McJwg50wtzFZWFKWujegTjGBfHzS0WnDovEHqcMhDmSxW5BRz/Q1d3oW2Dd41YswExwnEaQdWFKWuqJQKTBoUDoDbxenq5Z6tQ2ubDZGBWgyNDpQ6HHJTF9fD8aadm0xwnIAVRak7xP5kTHDoaom/O5MH8WKKuuatbRuY4PSySmMrCvWsKEpXJq7DySupQ6PJInE05InEWluTea6hy/DTqDE+wfvaNrgkwVm9ejUSEhKg0+mQmpqKnJycyx7/5ZdfIikpCTqdDiNHjsR3333X4eeCIGDFihWIjY2Fr68v0tPTcfLkSWe+hW4TTzjD44JYUZQuq1+4H/qF+cFiE7D/tHct/qNrV9dkxuH29Vtcf0NX4tgu7kVtG5ye4Hz++edYtmwZVq5ciby8PIwePRoZGRmorKzs9Pi9e/fi3nvvxcKFC/HTTz9hzpw5mDNnDo4cOeI45uWXX8brr7+ONWvWYP/+/fD390dGRgZaW1ud/XauaDenp6gHLq5qTNQTe0/VQBCAIdEBiA7SSR0OuTmxbUP2qWqvadvg9ATntddew6JFi7BgwQIkJydjzZo18PPzw7p16zo9/n//938xc+ZMPPHEExg2bBiee+45jBs3Dm+++SYA++jN3//+d/zpT3/CbbfdhlGjRuHDDz9EWVkZvvrqK2e/ncsSBOHClk0OGVM3iL8nu1nwj3pIrLXFqXDqDrFtQ5PZip9K6qUOxyWcmuCYzWbk5uYiPT39wgsqlUhPT0d2dnanj8nOzu5wPABkZGQ4ji8uLoZer+9wTHBwMFJTU7t8TpPJBKPR2OHmDMcrGlDVYILOR4mUBFYUpSubODACSgVQVNmIckOL1OGQhxAE4aLNDExw6Mo6tG3wknU4Tk1wqqurYbVaER0d3eH+6Oho6PX6Th+j1+sve7z4Z0+ec9WqVQgODnbc4uPjr+r9XIk4PZU6IJwVRalbgv18MLJvCADupqLuO1vTjHN1LfBRKZA6IFzqcMhD3OBlU+JesYtq+fLlMBgMjltpaalTXmfiwAgsuXEQ7kjp65TnJ3niNBX1lDgVPrZfKPy1aomjIU8hrg31lrYNTk1wIiIioFKpUFFR0eH+iooKxMTEdPqYmJiYyx4v/tmT59RqtQgKCupwc4bkuCD8d8ZQzB4d55TnJ3kSFxrvKaqGzeY9Rbjo6onFRLnWj3oiJljnVW0bnJrgaDQapKSkICsry3GfzWZDVlYW0tLSOn1MWlpah+MBYMuWLY7jBwwYgJiYmA7HGI1G7N+/v8vnJHJn4/qFwk+jQnWjGYX6BqnDITdnsdocX07cHk495U1tG5w+RbVs2TKsXbsWH3zwAQoKCvDQQw+hqakJCxYsAADMnz8fy5cvdxz/6KOPIjMzE3/7299QWFiIP//5z/jxxx+xZMkSAIBCocDSpUvx/PPPY+PGjTh8+DDmz5+PuLg4zJkzx9lvh6jXadRKpA4IA3BhZwxRVw6dN6Ch1YIgnRqj2tdvEXWXN7VtcPrk7T333IOqqiqsWLECer0eY8aMQWZmpmORcElJCZTKC3nWxIkTsX79evzpT3/CH/7wBwwePBhfffUVRowY4TjmySefRFNTExYvXoz6+npMnjwZmZmZ0OlYC4I80+TBkdh2vAq7TlZj8ZSBUodDbkxcjD5xYARUSrZnoJ65uG1DcXUTEiMDpA7JaRSC3FO4ThiNRgQHB8NgMDhtPQ5RT5yoaMCM/9kJrVqJgytnQOfDXXjUubvXZCPnTC2enzMC913fX+pwyAP9eu0+7D1Vg7/MHo77JyZIHU6P9OT72yt2URG5u8FRAYgO0sJksSH3bJ3U4ZCbajRZkFdi//1g/Ru6WhfW4ch75yYTHCI3oFAoHBVpuV2curL/dA0sNgHxYb7oH+4vdTjkocTkWO5tG5jgELkJ8aTDgn/UlQvdw9nrjq6et7RtYIJD5CbEEZwjZQbUNcm/CBf13G62Z6Be4C1tG5jgELmJqEAdkmICIQjAnlMcxaGO9IZWnKxshEIBTBzI9gx0bcQkeaeMR4yZ4BC5EcdV1Qn5nnTo6ojTU6P6BCPETyNxNOTpvKFtAxMcIjdywxD7SWd3kfyLcFHPiO0ZWL2YekNMsA5DogMgyLhtAxMcIjcyISEMGrW9CNfp6iapwyE3IQgCdhe1t2fgAmPqJeLvklzX4TDBIXIjvhoVrksIBQDsOiHPkw71XKG+AdWNJvj6qDCuf4jU4ZBMyL1tAxMcIjfjLUW4qPvE3VMTBoRBq2aVa+odP2/bIDdMcIjcjLi7Yd/pGpgt8i3CRd23q4jbw6n3+WnUGC+OGMvwgooJDpGbGRYThIgAsQgX2zZ4u9Y2K3KK29ffMMGhXnZhxFh+U+JMcIjcTMciXPK7qqKeyTtbh9Y2GyIDtRgaHSh1OCQzF9o21MiubQMTHCI3NFnGV1XUM7sc7RkioFAoJI6G5CY5NgjhMm3bwASHyA2JV1WHzrNtg7cTFxiLo3pEvUmpvNDoV24XVExwiNxQdJAOQ6MDZV2Ei66srsmMI2UGAFx/Q84j17YNTHCI3JR40pHbVRV1355T1RAEYEh0AKKDdFKHQzIl17YNTHCI3JTYtmHXSXkW4aIruzA9xerF5DwXt23YUySfEWMmOERuakLChSJcbNvgfQRBcOyiY/0bcjY5bhdngkPkpnw1Klw3gG0bvNWZmmacr2+Bj0qB1MQwqcMhmbswJS6fEWMmOERujG0bvNfu9u3h4/qFwk+jljgakrvUAeGya9vABIfIjbFtg/cSR+04PUWu4KtRya5tAxMcIjfGtg3eqc1qc5QHmDKEC4zJNeS2DocJDpEb61iESx5XVXRlP5XUo9FkQaifD4bHBUsdDnmJi9s2yGHEmAkOkZuT21UVXZn4bz15cCRUSrZnINfo2LbB80eMmeAQuTm2bfA+O9vX30zh+htyIaVS4aiYLS5y92RMcIjcHNs2eJfaJjMOnbe3ZxBH74hcRex5Joe2DUxwiDzAZLZt8Bq7i+ztGYZGByImmO0ZyLXk1LaBCQ6RB5BjES7qnLg9fMoQTk+R68mpbQMTHCIPcHERLrZtkC9BELDzpJjgcHqKpCGXjQ1McIg8ANs2eIcTFY2oMJqgVStxXQLbM5A05DJi7NQEp7a2FvPmzUNQUBBCQkKwcOFCNDY2Xvb4Rx55BEOHDoWvry/69euH//qv/4LBYOhwnEKhuOT22WefOfOtEEmObRvkT7xiTk0Mh85HJXE05K3kMmLs1ARn3rx5OHr0KLZs2YJNmzZh586dWLx4cZfHl5WVoaysDK+++iqOHDmC999/H5mZmVi4cOElx7733nsoLy933ObMmePEd0IkPXF3A9s2yNcObg8nN3DxiPFuD76gcloHt4KCAmRmZuLAgQMYP348AOCNN97ALbfcgldffRVxcXGXPGbEiBH417/+5fj7wIED8cILL+C+++6DxWKBWn0h3JCQEMTExDgrfCK3Ixbhqmky46eSOqQmhksdEvWi1jYrcoprAXD9DUlv8qBI7Cmqwa6TVbh/YoLU4VwVp43gZGdnIyQkxJHcAEB6ejqUSiX279/f7ecxGAwICgrqkNwAwMMPP4yIiAhMmDAB69atu+w8oclkgtFo7HAj8jQXF+HiNJX87C+uhcliQ0yQDoOjAqQOh7ycHNo2OC3B0ev1iIqK6nCfWq1GWFgY9Hp9t56juroazz333CXTWs8++yy++OILbNmyBXfccQd+//vf44033ujyeVatWoXg4GDHLT4+vudviMgNyGV3A13q4u3hCgXbM5C05NC2occJztNPP93pIt+Lb4WFhdccmNFoxKxZs5CcnIw///nPHX72zDPPYNKkSRg7diyeeuopPPnkk3jllVe6fK7ly5fDYDA4bqWlpdccH5EU2LZBvrg9nNyJHEaMe5zgPP744ygoKLjsLTExETExMaisrOzwWIvFgtra2iuunWloaMDMmTMRGBiIDRs2wMfH57LHp6am4ty5czCZTJ3+XKvVIigoqMONyBNFB10owiWHXjFkV25owYmKRigUwKSBXGBM7sHTR4x7vMg4MjISkZFXvsJIS0tDfX09cnNzkZKSAgDYunUrbDYbUlNTu3yc0WhERkYGtFotNm7cCJ3uyqXK8/PzERoaCq1W2/03QuShpg6JxImKRuw4UYVbR1+6WJ88j3iFPKpvCEL9NRJHQ2R38YhxfbMZIX6e9bvptDU4w4YNw8yZM7Fo0SLk5ORgz549WLJkCebOnevYQXX+/HkkJSUhJycHgD25mTFjBpqamvDuu+/CaDRCr9dDr9fDarUCAL755hu88847OHLkCIqKivDWW2/hr3/9Kx555BFnvRUitzJtqH1t244TVbDZPLcIF10gdg+fyu3h5EYuHjH2xLYNTtsmDgCffPIJlixZgunTp0OpVOKOO+7A66+/7vh5W1sbjh8/jubmZgBAXl6eY4fVoEGDOjxXcXExEhIS4OPjg9WrV+Oxxx6DIAgYNGgQXnvtNSxatMiZb4XIbYxPCIWfRoWqBhOOlRsxok+w1CHRNbDaBMd04w1cf0Nu5obB9hHjXSerMGtUrNTh9IhTE5ywsDCsX7++y58nJCR02N49bdq0K5aFnjlzJmbOnNlrMRJ5Gq1ahYkDw/FDQSV2nKhiguPhDp83oL65DYFaNcbEh0gdDlEHNwyOwLu7ix1tGzxphx97URF5oKniNNVxz1z8RxeI28MnDgqHj4qnZHIvnty2gf+biDzQtPapjNySOhhb2ySOhq6FuD1c3LFC5E48udEvExwiDxQf5ofESH9YbQL2eGiNCgIMzW3IK6kHYN8dR+SOPLXRLxMcIg81bYh9mmo7p6k81q6iKlhtAgZFBSA+zE/qcIg65amNfpngEHmoqUPtV1U7TlRdcXE+uScxOZ3G0RtyY57atoEJDpGHSh0QBp2PEnpjK45XNEgdDvWQzSY4Epwbk6KucDSRdDy1bQMTHCIPpfNRIS0xHACnqTzRsXIjqhtN8NOoMD4hVOpwiC7LE9s2MMEh8mDiwlRuF/c82wrtvfomDYqAVq2SOBqiy/PERr9McIg8mNi24ceztWg0WSSOhnpie/uW22lDuf6G3F90kA5DowPtbRtOecY0FRMcIg+WEOGPhHA/tFkF7GF3cY9R32x2LNYUk1Qidyeuw9ntIetwmOAQeTjHNJWHFeHyZjtPVsMmAEOiA9AnxFfqcIi6RZym8pSdm0xwiDzctIvaNnjCSYeA7cft629u5OgNeZDrE8Oh81Gi3NCKQr3779xkgkPk4a5PDIdGbe8VU1TZKHU4dAU2m+BYFD6V62/Ig+h8VJg00D6Ks7V9kbw7Y4JD5OF8NSqkDggDwGkqT3CkzICaJjP8NSqM7x8mdThEPSLWbNrGBIeIXEGcpmI9HPe3rdD+bzR5cAQ0ap6CybOICU5eSZ3bbxfn/y4iGRC3GucU16KJ28Xd2vYT9itf7p4iT9QnxBdJMYGwCe4/YswEh0gGEiP80S/MD2arjdvF3Vhtkxn5pfUAWP+GPJc4iuPu63CY4BDJgEKhwE3tJ52sAvc+6XizXSerIAhAUkwgYoO5PZw8k3iu2XGiChar+3YXZ4JDJBPTh7VfVR2vhM3G7eLuSFyYyekp8mRj40MQ7OsDQ0sbfmofkXRHTHCIZGLCgDD4a1SoajDhSJlB6nDoZ6w2wbFmgdNT5MnUKqWjwKg7T1MxwSGSCa1ahSntJx1OU7mfvJI61DW3IUinRkp/dg8nz3aTB2wXZ4JDJCM3ecjiP28kJp3ThkbBR8VTL3m2qUMioVQAhfoGnK9vkTqcTvF/GZGMTBsaBYUCOHzegApjq9Th0EWyCioAXFgrReTJQv01GNfPPhLprhdUTHCIZCQyUIvRfUMAuO9JxxuV1DTjZGUjVEoFpg1hgkPy4O5VjZngEMnMdG4Xdzs/tI/eXJcQimA/H4mjIeod4pT43lPVaG2zShzNpZjgEMnMTe1TIHuK3POk442yCu0JTvqwaIkjIeo99npOOrS22ZB9qkbqcC7BBIdIZpJjgxAbrENLmxXZp93vpONtjK1t2H+6FgAwnQkOyYhCoXDrqsZMcIhk5uKqxls5TSW5nSeqYLEJSIz0x4AIf6nDIepVNw29kOAIgnsVGGWCQyRDjqrGbnjS8TbiWihOT5EcTRoUAZ2PEufrW3Cs3Ch1OB0wwSGSoYkDL5x0jlc0SB2O17LaBGw7bk9wxMXfRHLiq1HhhsH2AqNbjlVIHE1HTHCIZEjno8KkgREAuJtKSnkldahvbkOwrw+rF5Ns/SLZPjrpVQlObW0t5s2bh6CgIISEhGDhwoVobGy87GOmTZsGhULR4fa73/2uwzElJSWYNWsW/Pz8EBUVhSeeeAIWi8WZb4XI44i7qcQtyuR64md/49BIqFm9mGRqelIUlArgaJnRraoaO/V/3Lx583D06FFs2bIFmzZtws6dO7F48eIrPm7RokUoLy933F5++WXHz6xWK2bNmgWz2Yy9e/figw8+wPvvv48VK1Y4860QeZzpSfarqvzSelQ2sKqxFMTRM+6eIjkLD9A6Rih/cKNRHKclOAUFBcjMzMQ777yD1NRUTJ48GW+88QY+++wzlJWVXfaxfn5+iImJcdyCgoIcP/v+++9x7NgxfPzxxxgzZgxuvvlmPPfcc1i9ejXMZrOz3g6Rx4kJ1mF0fAgEAfjhGKepXO1sTROKKhuhViocTVCJ5GpGcgwA4PtjeokjucBpCU52djZCQkIwfvx4x33p6elQKpXYv3//ZR/7ySefICIiAiNGjMDy5cvR3Nzc4XlHjhyJ6OgLV0QZGRkwGo04evRop89nMplgNBo73Ii8wYz2ufHNR93npOMtvj9qv5KdMCAMwb6sXkzyJq7D2X+6FoaWNomjsXNagqPX6xEV1XHXgFqtRlhYGPT6rk+2v/71r/Hxxx9j27ZtWL58OT766CPcd999HZ734uQGgOPvXT3vqlWrEBwc7LjFx8df7dsi8igZw+1XVXtPVaOh1T1OOt5CTCrFfwMiOUuI8MfgqABYbAK2H3ePEeMeJzhPP/30JYuAf34rLCy86oAWL16MjIwMjBw5EvPmzcOHH36IDRs24NSpU1f9nMuXL4fBYHDcSktLr/q5iDzJoKgAJEb6o80qYNvxKqnD8RpVDSbkltQBAGYM5/ob8g7iKM73brIOR93TBzz++ON44IEHLntMYmIiYmJiUFnZMYuzWCyora1FTEz3r2hSU1MBAEVFRRg4cCBiYmKQk5PT4ZiKCvuH2dXzarVaaLXabr8mkZxkDI/BW9tP4fujesweHSd1OF5hy7EKCAIwum8wYoN9pQ6HyCVmDI/B/20/hR3Hq2CyWKFVqySNp8cJTmRkJCIjr7xgLi0tDfX19cjNzUVKSgoAYOvWrbDZbI6kpTvy8/MBALGxsY7nfeGFF1BZWemYAtuyZQuCgoKQnJzcw3dDJH8zkqPx1vZT2O4mJx1vIE5PzeD0FHmRUX2CERWoRWWDCftO12KqxIvrnbYGZ9iwYZg5cyYWLVqEnJwc7NmzB0uWLMHcuXMRF2e/ijx//jySkpIcIzKnTp3Cc889h9zcXJw5cwYbN27E/PnzMWXKFIwaNQoAMGPGDCQnJ+M3v/kNDh48iM2bN+NPf/oTHn74YY7SEHVidN8QRAdp0WiyYK8bdvyVG2NrG/aeqgbA9TfkXZRKBdLFaSo32Njg1Do4n3zyCZKSkjB9+nTccsstmDx5Mt5++23Hz9va2nD8+HHHLimNRoMffvgBM2bMQFJSEh5//HHccccd+OabbxyPUalU2LRpE1QqFdLS0nDfffdh/vz5ePbZZ535Vog8llKpuDA3ftQ95sblbFthJdqsAgZG+mNQVIDU4RC5lHiu+aGgAjabtH3wejxF1RNhYWFYv359lz9PSEjo0AgwPj4eO3bsuOLz9u/fH999912vxEjkDTKGx+DjfSXYcqwCz88ZAZVSIXVIsiUmkRy9IW80cWA4/DUqVBhNOHzegNHxIZLFwtrhRF4gdUA4AnVqVDeakF9aJ3U4stXaZnVskWWCQ95Iq1Zh2lD7+lip628xwSHyAhq10tHNejOnqZxmT1E1msxWxAbrMKpvsNThEEkiY0QM/DQqWCSeomKCQ+QlxB09m4/qO0wNU+9x7J5KjoZCwWlA8k4Zw6OR98wv8IdbhkkaBxMcIi8xdUgkNGolztY0o1DfIHU4smOx2vBDAaeniLRqFXQ+0pejYIJD5CX8tWpMa69L8d3hcomjkZ8DZ+pQ22RGiJ8PJgwIkzocIq/HBIfIi8waZS+Y+e2hck5T9bJvD5cBsE9PqVU8tRJJjf8LibzI9GHR0KiVOF3dxGmqXmSx2pB5xL7+ZtYotsMgcgdMcIi8SMBF01TfHuI0VW/JKa5FdaN9emriwHCpwyEiMMEh8jriNNV3hzlN1Vu+bV/TNHN4DHw4PUXkFvg/kcjLXDxNVVDOaaprdfH01C0jYyWOhohETHCIvEyAVo0bh3I3VW/ZX1yLmiYzQv18kMbpKSK3wQSHyAuJIw3fcprqmm1qX8s0cwSnp4jcCf83Enmh6cOioVUrUcxpqmtin56yJzizRnL3FJE7YYJD5IUCtGpMa5+mEuu3UM9ln65BXXMbwvw1uD6Rxf2I3AkTHCIvJdZrYdG/qyeuYZo5IobF/YjcDP9HEnmp6UlR0PkocaamGYfOGaQOx+OYLTb8Ryzux91TRG6HCQ6Rl/LXqvGLZHtTyK/yz0scjefZeaIK9c1tiAzU4vpE7p4icjdMcIi82O1j7dNU3xwsh8Vqkzgaz7KhPSmcPToOKqVC4miI6OeY4BB5sRsGRyLMX4PqRhP2nKqROhyP0dDahh+OVQAAbh/bR+JoiKgzTHCIvJiPSulYP/L1T5ym6q7MI3qYLDYMjPTH8LggqcMhok4wwSHycnPap6k2H9WjxWyVOBrPIK5Zun1sHygUnJ4ickdMcIi83Lh+oYgP80WT2YotBRVSh+P2Koyt2Ns+nXfbGE5PEbkrJjhEXk6hUGBO+xf1V5ymuqKN+WUQBGB8/1DEh/lJHQ4RdYEJDhE5RiJ2nqhCbZNZ4mjc24b2JHAOFxcTuTUmOESEQVEBGNknGBabgE2H2LqhKycrGnCs3Ai1UsHifkRujgkOEQG4MCLxz9xzEkfivsTPZtrQKIT6aySOhoguhwkOEQEA5oyJg49KgUPnDCgoN0odjttps9rwrzz79NTd4/tKHA0RXQkTHCICAIQHaJE+LBoA8OWPHMX5ue3Hq1DdaEJEgAY3JkVJHQ4RXQETHCJyuHt8PABgw0/nYLawdcPFPj9QCgD41bi+8GHncCK3x/+lRORww+AIRAdpUdfchh9YE8ehsqEV245XAgDuSuH0FJEnYIJDRA5qlRJ3tn+Bf/FjqcTRuI8NeedhtQkY2y8Eg6MDpQ6HiLrBqQlObW0t5s2bh6CgIISEhGDhwoVobGzs8vgzZ85AoVB0evvyyy8dx3X2888++8yZb4XIa9yVYp+m2nmiCuWGFomjkZ4gCI5kT5zCIyL359QEZ968eTh69Ci2bNmCTZs2YefOnVi8eHGXx8fHx6O8vLzD7S9/+QsCAgJw8803dzj2vffe63DcnDlznPlWiLxGQoQ/JgwIg00A/sUt48grqcepqibofJT45SjWviHyFGpnPXFBQQEyMzNx4MABjB8/HgDwxhtv4JZbbsGrr76KuLi4Sx6jUqkQExPT4b4NGzbg7rvvRkBAQIf7Q0JCLjmWiHrHPePjkVNciy9+PIffTxsEpdJ7G0p+mlMCALhlZCwCdT4SR0NE3eW0EZzs7GyEhIQ4khsASE9Ph1KpxP79+7v1HLm5ucjPz8fChQsv+dnDDz+MiIgITJgwAevWrYMgCF0+j8lkgtFo7HAjoq7Zv8zVKKltxs6TVVKHI5n6ZjO+OWiv7DwvtZ/E0RBRTzgtwdHr9YiK6lgrQq1WIywsDHq9vlvP8e6772LYsGGYOHFih/ufffZZfPHFF9iyZQvuuOMO/P73v8cbb7zR5fOsWrUKwcHBjlt8POfRiS7HV6NyrMX5eN9ZiaORzj9zz8FksWFYbBDG9QuVOhwi6oEeJzhPP/10lwuBxVthYeE1B9bS0oL169d3OnrzzDPPYNKkSRg7diyeeuopPPnkk3jllVe6fK7ly5fDYDA4bqWl3B1CdCXzrrePWGQVVqK0tlniaFzPZhMcyd1vru8PhcJ7p+mIPFGP1+A8/vjjeOCBBy57TGJiImJiYlBZWdnhfovFgtra2m6tnfnnP/+J5uZmzJ8//4rHpqam4rnnnoPJZIJWq73k51qtttP7iahrAyMDMHlQBHYXVWN9TgmempkkdUgutedUNc7UNCNQq8ZtYy5dM0hE7q3HCU5kZCQiIyOveFxaWhrq6+uRm5uLlJQUAMDWrVths9mQmpp6xce/++67mD17drdeKz8/H6GhoUxiiHrZfdf3x+6ianx+oBRL0wdDq1ZJHZLLfJRtH7351bg+8Nc6bT8GETmJ09bgDBs2DDNnzsSiRYuQk5ODPXv2YMmSJZg7d65jB9X58+eRlJSEnJycDo8tKirCzp078eCDD17yvN988w3eeecdHDlyBEVFRXjrrbfw17/+FY888oiz3gqR10ofFoXYYB1qm8z47nC51OG4TFl9i6OS833X95c4GiK6Gk6tg/PJJ58gKSkJ06dPxy233ILJkyfj7bffdvy8ra0Nx48fR3Nzx/n9devWoW/fvpgxY8Ylz+nj44PVq1cjLS0NY8aMwT/+8Q+89tprWLlypTPfCpFXUquU+PUE+1qcD7O9Z7HxJ/vPwiYA1yeGsXIxkYdSCJfbXy1TRqMRwcHBMBgMCAoKkjocIrdW2dCKSS9uRZtVwIbfT8RYme8majZbMPHFrahvbsOa+8Zh5ggW9yNyFz35/mYvKiK6rKhAHWaP7gMAeGdXscTRON+/8s6jvrkN/cL88ItkFhMl8lRMcIjoih68YQAA4D9HymW9ZdxmE7Butz2J++2kBKi8uIIzkadjgkNEVzQsNgg3DI6ATQDe3S3fUZyswkoUVzchSKfGXWysSeTRmOAQUbcsuiERAPDFj6UwNLdJHI1zrN11GgDw69T+3BpO5OGY4BBRt9wwOAJJMYFoNlvxSY78dlQdLK1HTnEt1EoF7p/IreFEno4JDhF1i0KhwIPtozjv7TmD1jarxBH1rje3FQEAZo+JQ2ywr8TRENG1YoJDRN02e3Qc+oT4oqrBhM9ySqQOp9cUlBux5VgFFArg99MGSR0OEfUCJjhE1G0atRIPTRsIAHhrxynZjOK8udU+ejNrZCwGRQVIHA0R9QYmOETUI3eN74vYYB0qjCZ8mXtO6nCuWVFlA747Ym9DseQmjt4QyQUTHCLqEa1adWEUZ1sRzBabxBFdmze3FkEQgBnJ0UiKYWVzIrlggkNEPXb3+HhEBWpRZmjFl7mlUodz1Y7rG/D1wTIAwCM3DZY4GiLqTUxwiKjHdD4XRnFezzqJFrNnrsV5ZfNxCAJw84gYjOwbLHU4RNSLmOAQ0VX5dWo/9A31RYXRhHV7PK+68Y9navFDQQWUCuDxGUOlDoeIehkTHCK6Klq1Ck9k2BODt7afQk2jSeKIuk8QBLyUWQjAPt3GnVNE8sMEh4iu2q2j4jCyTzAaTRa80b7V2hNkFVTiwJk6aNVKPJrOtTdEcsQEh4iumlKpwNM3JwEAPtl/FsXVTRJHdGUmixXPf3sMAPDApARWLSaSKSY4RHRNJg2KwI1DI9FmFbBy41EIgiB1SJf1zq5inKlpRlSgFktuZN0bIrligkNE12zlrcOhUSux80QVMo/opQ6nS+WGFkfV4uW3JCFQ5yNxRETkLExwiOiaJUT443dT7dvGn910DM1mi8QRde75TQVoabNifP9QzBnTR+pwiMiJmOAQUa/4/bSBiA/zRbmhFf+z5YTU4Vwi84ge3x4uh0qpwJ9nD4dCoZA6JCJyIiY4RNQrdD4qPDt7BADgnd3F+PFMrcQRXWBobsMzXx8BACyekogRfVjUj0jumOAQUa+5MSkKd6b0hSAA//3lQbeZqnp20zFUNZiQGOmPR6dzWziRN2CCQ0S9asWtyYgL1uFMTTNe/E+h1OFg06Ey/CvvHBQK4JU7R0Hno5I6JCJyASY4RNSrgnQ+eOnOUQCAD7PPIvNIuWSxlNQ0Y/m/DgMAHpo6ECn9wySLhYhciwkOEfW6GwZHYvGURADAE18ekqQAoMlixSOf/YQGkwUp/UOx7BdDXB4DEUmHCQ4ROcUTGUMxISEMDSYLHvo4F00m163HEQQBf9xwBAdL6xHs64PX7x0LtYqnOyJvwv/xROQUPiol3vj1WEQEaFGob8CS9XmwWG0uee1/7DyNf+aeg1IBvH7vWPQJYTsGIm/DBIeInCY6SIe356dAq1Zi2/Eq/OmrI05v5bDhp3OOTuErbx2OqUMinfp6ROSemOAQkVON6xeKN+4dC6UC+OxAKf7yzTGnJTnfHirH418chCAAD0xMwP0TE5zyOkTk/pjgEJHTzRgegxduHwkAeH/vGfzxqyOw2no3yfln7jk8+tlPsAnA3eP7YsUvk3v1+YnIszDBISKXuHdCP7x85ygoFMD6/SV48IMDMLa2XfPz2mwC/v7DCfz3lwdhsQn41dg+WPWrUVAq2YqByJs5LcF54YUXMHHiRPj5+SEkJKRbjxEEAStWrEBsbCx8fX2Rnp6OkydPdjimtrYW8+bNQ1BQEEJCQrBw4UI0NjY64R0QUW+7e3w83rh3rGNNzpw39+Cnkrqrfr6qBhMeeP8A/v6D/Tzxu6kD8epdo6FickPk9ZyW4JjNZtx111146KGHuv2Yl19+Ga+//jrWrFmD/fv3w9/fHxkZGWhtbXUcM2/ePBw9ehRbtmzBpk2bsHPnTixevNgZb4GInOCXo+Lwz99NRGywDqerm3DHW3vx3KZjqGsyd/s5LFYbPso+g/TXdmDniSrofJR46Y6RePrmJI7cEBEAQCE4eUvD+++/j6VLl6K+vv6yxwmCgLi4ODz++OP47//+bwCAwWBAdHQ03n//fcydOxcFBQVITk7GgQMHMH78eABAZmYmbrnlFpw7dw5xcXHdisloNCI4OBgGgwFBQUHX9P6I6OrUN5vx541H8VV+GQAgQKvG3OvicUdKXyTFBHba7bvc0IJNB8vx/t4zOF/fAgAYFhuE1+eOweDoQJfGT0Su15Pvb7WLYrqi4uJi6PV6pKenO+4LDg5GamoqsrOzMXfuXGRnZyMkJMSR3ABAeno6lEol9u/fj9tvv73T5zaZTDCZTI6/G41G570RIuqWED8N/j53LOaM7YOXM4/jWLkR7+wuxju7ixERoMXIPkGIDtJBoVCgvtmMExUNOFV1oSJymL8GS9MH49cT+rGIHxFdwm0SHL1eDwCIjo7ucH90dLTjZ3q9HlFRUR1+rlarERYW5jimM6tWrcJf/vKXXo6YiHrDtKFRmDI4EtuOV+LLH89h6/FKVDeasO141SXHKhT2bed3jOuLX43rw8aZRNSlHiU4Tz/9NF566aXLHlNQUICkpKRrCqq3LV++HMuWLXP83Wg0Ij4+XsKIiOhiSqUC04dFY/qwaLS2WXHkvAEnKhpR3WgfeQ3QqjEwKgAj4oIQHqCVOFoi8gQ9SnAef/xxPPDAA5c9JjEx8aoCiYmJAQBUVFQgNjbWcX9FRQXGjBnjOKaysrLD4ywWC2prax2P74xWq4VWy5MikSfQ+agwPiEM4xPY+ZuIrl6PEpzIyEhERjqn7PmAAQMQExODrKwsR0JjNBqxf/9+x06stLQ01NfXIzc3FykpKQCArVu3wmazITU11SlxERERkedx2sq8kpIS5Ofno6SkBFarFfn5+cjPz+9QsyYpKQkbNmwAACgUCixduhTPP/88Nm7ciMOHD2P+/PmIi4vDnDlzAADDhg3DzJkzsWjRIuTk5GDPnj1YsmQJ5s6d2+0dVERERCR/TltkvGLFCnzwwQeOv48dOxYAsG3bNkybNg0AcPz4cRgMBscxTz75JJqamrB48WLU19dj8uTJyMzMhE6ncxzzySefYMmSJZg+fTqUSiXuuOMOvP766856G0REROSBnF4Hxx2xDg4REZHn6cn3N4tHEBERkewwwSEiIiLZYYJDREREssMEh4iIiGSHCQ4RERHJDhMcIiIikh0mOERERCQ7THCIiIhIdpjgEBERkew4rVWDOxOLNxuNRokjISIiou4Sv7e704TBKxOchoYGAEB8fLzEkRAREVFPNTQ0IDg4+LLHeGUvKpvNhrKyMgQGBkKhUPTqcxuNRsTHx6O0tJR9rpyIn7Nr8HN2DX7OrsHP2XWc9VkLgoCGhgbExcVBqbz8KhuvHMFRKpXo27evU18jKCiI/4FcgJ+za/Bzdg1+zq7Bz9l1nPFZX2nkRsRFxkRERCQ7THCIiIhIdpjg9DKtVouVK1dCq9VKHYqs8XN2DX7OrsHP2TX4ObuOO3zWXrnImIiIiOSNIzhEREQkO0xwiIiISHaY4BAREZHsMMEhIiIi2WGC04tWr16NhIQE6HQ6pKamIicnR+qQZGXVqlW47rrrEBgYiKioKMyZMwfHjx+XOizZe/HFF6FQKLB06VKpQ5Gl8+fP47777kN4eDh8fX0xcuRI/Pjjj1KHJStWqxXPPPMMBgwYAF9fXwwcOBDPPfdct/oZUdd27tyJW2+9FXFxcVAoFPjqq686/FwQBKxYsQKxsbHw9fVFeno6Tp486bL4mOD0ks8//xzLli3DypUrkZeXh9GjRyMjIwOVlZVShyYbO3bswMMPP4x9+/Zhy5YtaGtrw4wZM9DU1CR1aLJ14MAB/OMf/8CoUaOkDkWW6urqMGnSJPj4+OA///kPjh07hr/97W8IDQ2VOjRZeemll/DWW2/hzTffREFBAV566SW8/PLLeOONN6QOzaM1NTVh9OjRWL16dac/f/nll/H6669jzZo12L9/P/z9/ZGRkYHW1lbXBChQr5gwYYLw8MMPO/5utVqFuLg4YdWqVRJGJW+VlZUCAGHHjh1ShyJLDQ0NwuDBg4UtW7YIU6dOFR599FGpQ5Kdp556Spg8ebLUYcjerFmzhN/+9rcd7vvVr34lzJs3T6KI5AeAsGHDBsffbTabEBMTI7zyyiuO++rr6wWtVit8+umnLomJIzi9wGw2Izc3F+np6Y77lEol0tPTkZ2dLWFk8mYwGAAAYWFhEkciTw8//DBmzZrV4feaetfGjRsxfvx43HXXXYiKisLYsWOxdu1aqcOSnYkTJyIrKwsnTpwAABw8eBC7d+/GzTffLHFk8lVcXAy9Xt/h/BEcHIzU1FSXfS96ZbPN3lZdXQ2r1Yro6OgO90dHR6OwsFCiqOTNZrNh6dKlmDRpEkaMGCF1OLLz2WefIS8vDwcOHJA6FFk7ffo03nrrLSxbtgx/+MMfcODAAfzXf/0XNBoN7r//fqnDk42nn34aRqMRSUlJUKlUsFqteOGFFzBv3jypQ5MtvV4PAJ1+L4o/czYmOOSRHn74YRw5cgS7d++WOhTZKS0txaOPPootW7ZAp9NJHY6s2Ww2jB8/Hn/9618BAGPHjsWRI0ewZs0aJji96IsvvsAnn3yC9evXY/jw4cjPz8fSpUsRFxfHz1nGOEXVCyIiIqBSqVBRUdHh/oqKCsTExEgUlXwtWbIEmzZtwrZt29C3b1+pw5Gd3NxcVFZWYty4cVCr1VCr1dixYwdef/11qNVqWK1WqUOUjdjYWCQnJ3e4b9iwYSgpKZEoInl64okn8PTTT2Pu3LkYOXIkfvOb3+Cxxx7DqlWrpA5NtsTvPim/F5ng9AKNRoOUlBRkZWU57rPZbMjKykJaWpqEkcmLIAhYsmQJNmzYgK1bt2LAgAFShyRL06dPx+HDh5Gfn++4jR8/HvPmzUN+fj5UKpXUIcrGpEmTLil1cOLECfTv31+iiOSpubkZSmXHrzuVSgWbzSZRRPI3YMAAxMTEdPheNBqN2L9/v8u+FzlF1UuWLVuG+++/H+PHj8eECRPw97//HU1NTViwYIHUocnGww8/jPXr1+Prr79GYGCgYx43ODgYvr6+EkcnH4GBgZesa/L390d4eDjXO/Wyxx57DBMnTsRf//pX3H333cjJycHbb7+Nt99+W+rQZOXWW2/FCy+8gH79+mH48OH46aef8Nprr+G3v/2t1KF5tMbGRhQVFTn+XlxcjPz8fISFhaFfv35YunQpnn/+eQwePBgDBgzAM888g7i4OMyZM8c1Abpkr5aXeOONN4R+/foJGo1GmDBhgrBv3z6pQ5IVAJ3e3nvvPalDkz1uE3eeb775RhgxYoSg1WqFpKQk4e2335Y6JNkxGo3Co48+KvTr10/Q6XRCYmKi8Mc//lEwmUxSh+bRtm3b1uk5+f777xcEwb5V/JlnnhGio6MFrVYrTJ8+XTh+/LjL4lMIAks5EhERkbxwDQ4RERHJDhMcIiIikh0mOERERCQ7THCIiIhIdpjgEBERkewwwSEiIiLZYYJDREREssMEh4iIiGSHCQ4RERHJDhMcIiIikh0mOERERCQ7THCIiIhIdv4/PI2wfcCbA7cAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "filename.split(\"/\")[-1]\n",
-    "    eq_lat = float(filename.split(\"_\")[0])\n",
-    "    eq_lon = float(filename.split(\"_\")[1])"
-   ]
+   "source": []
   }
  ],
  "metadata": {

app.py

@@ -535,7 +535,10 @@ def compute_velocity_model(azimuth, elevation):
 
     return image
 
-model = torch.jit.load("model.pt")
+# model = torch.jit.load("model.pt")
+model = torch.jit.load("quantized_model.pt")
+
+model.eval()
 
 with gr.Blocks() as demo:
     gr.HTML("""
@@ -598,17 +601,18 @@ with gr.Blocks() as demo:
                                     )
             with gr.Column(scale=1):
                 upload = gr.File(label="Or upload your own waveform")
-                sampling_rate_inputs = gr.Slider(minimum=10,
-                        maximum=1000,
-                        value=100,
-                        label="Samlping rate, Hz",
-                        step=10,
-                        info="Sampling rate of the waveform",
-                        interactive=True,
-                        )
-                order_input = gr.Text(value='ZNE', 
-                                      label='Channel order', 
-                                      info='Order of the channels in the waveform file (e.g. ZNE)')
+                with gr.Row():
+                    sampling_rate_inputs = gr.Slider(minimum=10,
+                            maximum=1000,
+                            value=100,
+                            label="Samlping rate, Hz",
+                            step=10,
+                            info="Sampling rate of the waveform",
+                            interactive=True,
+                            )
+                    order_input = gr.Text(value='ZNE', 
+                                        label='Channel order', 
+                                        info='Order of the channels in the waveform file (e.g. ZNE)')
 
         button = gr.Button("Predict phases")
         outputs = gr.Image(label='Waveform with Phases Marked', type='numpy', interactive=False)
@@ -738,8 +742,4 @@ with gr.Blocks() as demo:
                          inputs=inputs_vel_model, 
                          outputs=outputs_vel_model)
 
-
-            
-
-
 demo.launch()

quantized_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d40a1160ed3c55d8734acf65f7a84a305207bef49eea14c24f5dd18b77def98
+size 68482653

traced_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45db366167ca7646cddf7220c51b2f1f8d97a050b8f80c526b23058aca1f23f5
+size 68481478