diff --git a/.gitignore b/.gitignore index b291312..17d4b90 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ *.png *random*.fits +*random*.lis *.DS_Store *.pyc .ipynb_checkpoints/ diff --git a/docs/flystar/examples/motion_model_example.ipynb b/docs/flystar/examples/motion_model_example.ipynb new file mode 100644 index 0000000..b3de4b9 --- /dev/null +++ b/docs/flystar/examples/motion_model_example.ipynb @@ -0,0 +1,1363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "333cd262", + "metadata": {}, + "source": [ + "# Motion Model Examples" + ] + }, + { + "cell_type": "markdown", + "id": "9251851e", + "metadata": {}, + "source": [ + "# Table of Contents" + ] + }, + { + "cell_type": "markdown", + "id": "1e4364ed", + "metadata": {}, + "source": [ + "# Table of Contents\n", + "- [1. Motion Model](#1-motion-model)\n", + " - [1.1. Example: Linear Model Fit](#11-example-linear-model-fit)\n", + " - [1.2. Example: Acceleration Model Fit](#12-example-acceleration-model-fit)\n", + " - [1.3. Example: Parallax Model Fit](#13-example-parallax-model-fit)\n", + "- [2. Fit Motion Model in StarTable](#2-fit-motion-model-in-startable)\n", + " - [2.1. Example: Default Fitting](#21-example-default-fitting)\n", + " - [2.2 Example: Specify Motion Models](#22-example-specify-motion-models)\n", + " - [2.3. Example: Specify the `motion_model_input` Column](#23-example-specify-the-motion_model_input-column)\n", + " - [2.4. Example: Infer Positions](#24-example-infer-positions)\n", + " - [2.5. Speed Test](#25-speed-test)\n" + ] + }, + { + "cell_type": "markdown", + "id": "4bd92a9d", + "metadata": {}, + "source": [ + "# 1. Motion Model" + ] + }, + { + "cell_type": "markdown", + "id": "0d084c38", + "metadata": {}, + "source": [ + "Summary of currently implemented motion models" + ] + }, + { + "cell_type": "markdown", + "id": "faddd6d8", + "metadata": {}, + "source": [ + "| Motion Model | required params | fit_params | fixed_params | model | Description |\n", + "|--------------|----------|--------------------------------------------|-------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n", + "| Empty | 0 | NA | NA | $x(t) = $ NaN / fill_value
$x_e(t) = $ Inf | |\n", + "| Fixed | 1 | $x_0$
$y_0$ | NA | $x(t) = $ np.average($x$, weights=$x_{wt}$) | $x_{wt} = 1/xe^2$ if weighting='var'
$x_{wt} = 1/\\|xe\\|$ if weighting = 'std' |\n", + "| Linear | 2 | $x_0, v_x$
$y_0, v_y$ | optional: $t_0 =$ np.average($t, 1/\\sqrt{x_e^2 + y_e^2}$) | $x(t) = x_0 + v_x * (t - t_0)$ | |\n", + "| Acceleration | 3 | $x_0, v_{x0}, a_x$
$y_0, v_{y0}, a_y$ | optional: $t_0 =$ np.average($t, 1/\\sqrt{x_e^2 + y_e^2}$) | $x(t) = x_0 + v_{x0} * (t - t_0) + 1/2 * a_x * (t - t_0)^2$ | |\n", + "| Parallax | 3 | $x_0, v_x, pi$
$y_0, v_y$ | required: ra, dec
optional: $t_0 =$ np.average($t, 1/\\sqrt{x_e^2 + y_e^2}$); $pa=0$; obsLocation='earth' | $x(t) = x_0 + v_x * (t - t_0) + pvec * (t - t_0)$ | pvec is the parallax vector calculated based on ra, dec, pa, and obsLocation.
Only supports the same obsLocation for all stars in StarTable.fit_motion_model right now. |" + ] + }, + { + "cell_type": "markdown", + "id": "6fdc98af", + "metadata": {}, + "source": [ + "Examples on using `flystar.MotionModel`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "51c963a1", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "473b0674", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ce4edb88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from flystar import motion_model\n", + "from flystar.startables import StarTable\n", + "from flystar.motion_model import Empty, Fixed, Linear, Acceleration, Parallax" + ] + }, + { + "cell_type": "markdown", + "id": "8c0e8559", + "metadata": {}, + "source": [ + "Prepare data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "86b6319d", + "metadata": {}, + "outputs": [], + "source": [ + "t = np.array([0, 1., 2.2, 3.5, 5.]) + 2025.0\n", + "x = np.array([0., 0.5, 2.1, 3.2, 8.0])\n", + "y = np.array([10.2, 8.5, 9.1, 10.5, 13.0])\n", + "xe = np.array([0.2, 0.5, 0.3, 0.4, 0.6])\n", + "ye = np.array([0.3, 0.2, 0.5, 0.2, 0.4])\n", + "t_test = np.linspace(2025.0, 2030.0, 100) # Test times for model evaluation" + ] + }, + { + "cell_type": "markdown", + "id": "b1a87102", + "metadata": {}, + "source": [ + "## 1.1. Example: Linear Model Fit" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0926c0a8", + "metadata": {}, + "outputs": [], + "source": [ + "mm = Linear()\n", + "params, param_errs = mm.fit(t, x, y, xe, ye)" + ] + }, + { + "cell_type": "markdown", + "id": "1fad1962", + "metadata": {}, + "source": [ + "Evaluate model at time t:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "840693ae", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model = mm.model(t, params)" + ] + }, + { + "cell_type": "markdown", + "id": "42fbd575", + "metadata": {}, + "source": [ + "Or if uncertainties of parameters is provided at the same time, the model will return the model uncertainties as well:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8fcbdc5d", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t, params, param_errs)" + ] + }, + { + "cell_type": "markdown", + "id": "6f9954ef", + "metadata": {}, + "source": [ + "Note that we did not provide the `fixed_params_dict` parameter in the `model` function, so the MotionModel will use the saved self.fixed_params_dict. One can also specify the fixed_params_dict as:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6752e477", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'t0': np.float64(2027.0454838983064)}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mm.fixed_params_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "eba675c8", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs, mm.fixed_params_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "a2acbe90", + "metadata": {}, + "source": [ + "Define a helper function to visualize result" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7dba325f", + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm_name, t_test=None):\n", + " if t_test is None:\n", + " t_test = t\n", + " x = np.atleast_2d(x)\n", + " y = np.atleast_2d(y)\n", + " xe = np.atleast_2d(xe)\n", + " ye = np.atleast_2d(ye)\n", + " x_model = np.atleast_2d(x_model)\n", + " y_model = np.atleast_2d(y_model)\n", + " xe_model = np.atleast_2d(xe_model)\n", + " ye_model = np.atleast_2d(ye_model)\n", + " \n", + " N_cases = x.shape[0]\n", + " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n", + " for i in range(N_cases):\n", + " l0 = ax1.errorbar(t, x[i], yerr=xe[i], fmt='o', color=f'C{i%10}', label='Data')\n", + " l1, = ax1.plot(t_test, x_model[i], label=f'{mm_name} Fit')\n", + " l2 = ax1.fill_between(t_test, x_model[i] - xe_model[i], x_model[i] + xe_model[i], color=f'C{i%10}', alpha=0.3, label='Model Uncertainty')\n", + "\n", + " r0 = ax2.errorbar(t, y[i], yerr=ye[i], fmt='o', color=f'C{i%10}', label='Data')\n", + " r1, = ax2.plot(t_test, y_model[i], label=f'{mm_name} Fit')\n", + " r2 = ax2.fill_between(t_test, y_model[i] - ye_model[i], y_model[i] + ye_model[i], color=f'C{i%10}', alpha=0.3, label='Model Uncertainty')\n", + " ax1.set_xlabel('Time')\n", + " ax1.set_ylabel('X Position')\n", + " ax1.set_title(f'{mm_name} Motion Model Fit')\n", + " ax1.legend(\n", + " [l0, (l1, l2)], \n", + " ['Data', 'Model Fit'],\n", + " )\n", + " \n", + " ax2.set_xlabel('Time')\n", + " ax2.set_ylabel('Y Position')\n", + " ax2.set_title(f'{mm_name} Motion Model Fit')\n", + " ax2.legend(\n", + " [r0, (r1, r2)], \n", + " ['Data', 'Model Fit'],\n", + " )\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ad03fc67", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "98d3e2c4", + "metadata": {}, + "source": [ + "## 1.2. Example: Acceleration Model Fit" + ] + }, + { + "cell_type": "markdown", + "id": "ede486e5", + "metadata": {}, + "source": [ + "Upon further inspection, acceleration model seems to be a better representation of the data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0a0d9d1f", + "metadata": {}, + "outputs": [], + "source": [ + "mm = Acceleration()\n", + "params, param_errs = mm.fit(t, x, y, xe, ye)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b3d63417", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9wAAAHqCAYAAAD27EaEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAA6NNJREFUeJzs3Xd8W9X5P/CPZEmWvOS9Zxxn7z0ISSBAQggr7BmglL1LW779tYSWMjpYBUKhlKSQQNkEysoiJAQycfb03lN7697z+8PYxImHJA95fN6vl1+NpKt7H8U0R8895zyPQgghQERERERERETdShnsAIiIiIiIiIgGIibcRERERERERD2ACTcRERERERFRD2DCTURERERERNQDmHATERERERER9QAm3EREREREREQ9gAk3ERERERERUQ9gwk1ERERERETUA5hwExEREREREfUAJtw0oM2bNw/z5s0LdhinWblyJRQKBYqLi4MdSq/Kzs7GsmXLgh1Gr1IoFFi+fLnf7ysuLoZCocDKlSuDFgMRUTBxDO9bOIb7jmM4nYwJN3Wbl19+GQqFAtOnTw92KH3GE088gY8//jjYYbSSnZ0NhUKBBQsWtPn6a6+9BoVCAYVCgV27dvl9/m3btmH58uUwGo1djLT7NH85UigU2Lp162mvCyGQkZEBhUKBCy64IAgRBu6bb75p+Wyn/lx11VVtvqcv/o6IKLg4hp+OY3jfwDG8tb74O6KOqYIdAA0cq1evRnZ2Nnbs2IETJ05g6NChwQ4p6J544glcdtlluPjii1s9f/311+Oqq65CaGhoUOLSarXYtGkTqqurkZyc3Oq11atXQ6vVwul0BnTubdu24bHHHsOyZcsQHR3d6rWjR49CqQzefT6tVos1a9bgjDPOaPX85s2bUV5eHrTfR3e49957MXXq1FbPZWdnAwAcDgdUqp//ue/od0REgxPH8NNxDI9u9RrH8J7DMXxg4ww3dYuioiJs27YNzzzzDBISErB69epgh9TtZFkOeAA7VUhICLRaLRQKRbecz1+zZ89GREQE/vvf/7Z6vry8HFu2bMHixYt75LqhoaFQq9U9cm5fnH/++Xjvvffg9XpbPb9mzRpMnjz5tC8u/cmcOXNw3XXXtfpp/lKi1WpbDdZERCfjGO4fjuHBwTGc+ism3NQtVq9ejZiYGCxevBiXXXZZu4O10WjEAw88gOzsbISGhiI9PR033HAD6uvrW45xOp1Yvnw5hg0bBq1Wi5SUFFx66aUoKChoOUaWZTz33HMYPXo0tFotkpKScNttt8FgMHQaq8vlwqOPPoqhQ4ciNDQUGRkZ+PWvfw2Xy9XqOIVCgbvvvhurV6/G6NGjERoaii+//BIA8Le//Q2zZs1CXFwcdDodJk+ejPfff/+099tsNqxatapleVDz3qf29n+9/PLLLddKTU3FXXfdddqSoXnz5mHMmDE4dOgQ5s+fj7CwMKSlpeEvf/lLp5+9mVarxaWXXoo1a9a0ev7tt99GTEwMzjvvvDbft3HjRsyZMwfh4eGIjo7GRRddhMOHD7e8vnz5cjz88MMAgJycnJbP3fw529r/VVhYiMsvvxyxsbEICwvDjBkz8L///a/VMc1Lrt599138+c9/Rnp6OrRaLc4++2ycOHHC58999dVXo6GhAevWrWt5zu124/3338c111zT5ntsNhseeughZGRkIDQ0FMOHD8ff/vY3CCFaHedyufDAAw8gISEBkZGRuPDCC1FeXt7mOSsqKnDzzTcjKSkJoaGhGD16NP7973/7/Dn8dfL+r85+R0Q0+HAM5xgOcAznGE49hbdLqFusXr0al156KTQaDa6++mqsWLECO3fubLU8xmq1Ys6cOTh8+DBuvvlmTJo0CfX19Vi7di3Ky8sRHx8PSZJwwQUXYMOGDbjqqqtw3333wWKxYN26dThw4AByc3MBALfddhtWrlyJm266Cffeey+Kiorw4osv4scff8R3333X7h1YWZZx4YUXYuvWrfjlL3+JkSNHYv/+/Xj22Wdx7Nix0/Zqbdy4Ee+++y7uvvtuxMfHtyzvef7553HhhRfi2muvhdvtxjvvvIPLL78cn332Wcud5TfffBO/+MUvMG3aNPzyl78EgJb427J8+XI89thjWLBgAe644w4cPXq05e/x1M9kMBiwcOFCXHrppbjiiivw/vvv4ze/+Q3Gjh2LRYsW+fQ7u+aaa3DuueeioKCgJa41a9bgsssua/Pvb/369Vi0aBGGDBmC5cuXw+Fw4B//+Admz56NPXv2IDs7G5deeimOHTuGt99+G88++yzi4+MBAAkJCW3GUFNTg1mzZsFut+Pee+9FXFwcVq1ahQsvvBDvv/8+LrnkklbHP/XUU1AqlfjVr34Fk8mEv/zlL7j22muxfft2nz5zdnY2Zs6cibfffrvl7+mLL76AyWTCVVddhRdeeKHV8UIIXHjhhdi0aRNuueUWTJgwAV999RUefvhhVFRU4Nlnn2059he/+AXeeustXHPNNZg1axY2btzY5ixDTU0NZsyY0fJlMCEhAV988QVuueUWmM1m3H///T59llNZLJZWX3oBIDY29rTlf/7+joho4OMYzjGcYzjHcOpBgqiLdu3aJQCIdevWCSGEkGVZpKeni/vuu6/VcX/4wx8EAPHhhx+edg5ZloUQQvz73/8WAMQzzzzT7jFbtmwRAMTq1atbvf7ll1+e9vzcuXPF3LlzWx6/+eabQqlUii1btrR67yuvvCIAiO+++67lOQBCqVSKgwcPnhaL3W5v9djtdosxY8aIs846q9Xz4eHh4sYbbzzt/W+88YYAIIqKioQQQtTW1gqNRiPOPfdcIUlSy3EvvviiACD+/e9/t/pMAMR//vOfludcLpdITk4WS5cuPe1ap8rKyhKLFy8WXq9XJCcniz/96U9CCCEOHTokAIjNmze3xLdz586W902YMEEkJiaKhoaGluf27t0rlEqluOGGG1qe++tf/9rqs5167ZP/Pu6//34BoNXvw2KxiJycHJGdnd3yd7Fp0yYBQIwcOVK4XK6WY59//nkBQOzfv7/Dz3zy53nxxRdFZGRky+/w8ssvF/Pnz2/1d9Ps448/FgDE448/3up8l112mVAoFOLEiRNCCCHy8/MFAHHnnXe2Ou6aa64RAMSjjz7a8twtt9wiUlJSRH19fatjr7rqKqHX61viKioqEgDEG2+80eFna/67aeun+Xdwagwd/Y6IaHDhGM4xnGM4x3DqWVxSTl22evVqJCUlYf78+QCalr5ceeWVeOeddyBJUstxH3zwAcaPH3/aHc/m9zQfEx8fj3vuuafdY9577z3o9Xqcc845qK+vb/mZPHkyIiIisGnTpnZjfe+99zBy5EiMGDGi1XvPOussADjtvXPnzsWoUaNOO49Op2v5s8FggMlkwpw5c7Bnz552r92R9evXw+124/777291N/PWW29FVFTUacuzIiIicN1117U81mg0mDZtGgoLC32+ZkhICK644gq8/fbbAJp+jxkZGZgzZ85px1ZVVSE/Px/Lli1DbGxsy/Pjxo3DOeecg88//9zn657s888/x7Rp01oVQImIiMAvf/lLFBcX49ChQ62Ov+mmm6DRaFoeN8fqz+e+4oor4HA48Nlnn8FiseCzzz5rdyna559/jpCQENx7772tnn/ooYcghMAXX3zRchyA04479U63EAIffPABlixZAiFEq/8GzzvvPJhMpoD/G/rDH/6AdevWtfrpz/vZiKh3cAznGM4xnGM49SwuKacukSQJ77zzDubPn4+ioqKW56dPn46///3v2LBhA84991wAQEFBAZYuXdrh+QoKCjB8+PAOi0McP34cJpMJiYmJbb5eW1vb4XsPHz7c7tKbU9+bk5PT5nGfffYZHn/8ceTn57faNxZoAZWSkhIAwPDhw1s9r9FoMGTIkJbXm6Wnp592rZiYGOzbt8+v615zzTV44YUXsHfvXqxZswZXXXVVm5+hvfgAYOTIkfjqq69gs9kQHh7u1/VLSkrabEEzcuTIltfHjBnT8nxmZmar42JiYgDAp31/zRISErBgwQKsWbMGdrsdkiThsssuaze+1NRUREZGthtf8/8qlcrTlhue+vdVV1cHo9GIV199Fa+++mqb1+zov9+OjB07tt02MUREbeEYzjGcYzjHcOp5TLipSzZu3Iiqqiq88847eOedd057ffXq1S2DdXeRZRmJiYntFnXpaB+LLMsYO3YsnnnmmTZfz8jIaPX45LvgzbZs2YILL7wQZ555Jl5++WWkpKRArVbjjTfeOK2ASU8JCQlp83lxShGQzkyfPh25ubm4//77UVRU1O5d4r6iuz73Nddcg1tvvRXV1dVYtGhRr7XVkGUZAHDdddfhxhtvbPOYcePG9UosREQcwzmG9yaO4TRYMeGmLlm9ejUSExPx0ksvnfbahx9+iI8++givvPIKdDodcnNzceDAgQ7Pl5ubi+3bt8Pj8bRbNCU3Nxfr16/H7Nmz2xxMOzv/3r17cfbZZwd8J/uDDz6AVqvFV1991arn4xtvvHHasb5eIysrC0BTj8shQ4a0PO92u1FUVNSjdz2vvvpqPP744xg5ciQmTJjQaXynOnLkCOLj41vujPvz95qVldXuOU++bne75JJLcNttt+GHH344ra3KqfGtX78eFoul1R3yU+PLysqCLMstszvNTv1szdVPJUkK6p3sYLWyIaK+hWM4x3CO4RzDqedxDzcFzOFw4MMPP8QFF1yAyy677LSfu+++GxaLBWvXrgUALF26FHv37sVHH3102rma724uXboU9fX1ePHFF9s95oorroAkSfjTn/502jFer/e0Fhwnu+KKK1BRUYHXXnutzc9js9k6/dwhISFQKBSt9rYVFxefVh0VAMLDwzuMp9mCBQug0WjwwgsvtLrT+/rrr8NkMvVYT02gqTLno48+ir///e/tHpOSkoIJEyZg1apVrT7PgQMH8PXXX+P8889vea550Pblc59//vnYsWMHvv/++5bnbDYbXn31VWRnZ7e59647REREYMWKFVi+fDmWLFnSYXySJJ323+Ozzz4LhULRUiW1+X9PrZD63HPPtXocEhKCpUuX4oMPPmjzi2tdXV0gH8dv/vyOiGhg4hjOMZxjOMdw6h2c4aaArV27FhaLBRdeeGGbr8+YMQMJCQlYvXo1rrzySjz88MN4//33cfnll+Pmm2/G5MmT0djYiLVr1+KVV17B+PHjccMNN+A///kPHnzwQezYsQNz5syBzWbD+vXrceedd+Kiiy7C3Llzcdttt+HJJ59Efn4+zj33XKjVahw/fhzvvfcenn/++Xb381x//fV49913cfvtt2PTpk2YPXs2JEnCkSNH8O677+Krr77ClClTOvzcixcvxjPPPIOFCxfimmuuQW1tLV566SUMHTr0tP1XkydPxvr16/HMM88gNTUVOTk5be53SkhIwCOPPILHHnsMCxcuxIUXXoijR4/i5ZdfxtSpU1sVV+luWVlZLf0dO/LXv/4VixYtwsyZM3HLLbe0tBTR6/Wt3j958mQAwO9+9ztcddVVUKvVWLJkSZt7w37729+2tPe49957ERsbi1WrVqGoqAgffPDBae0wulN7y8FOtmTJEsyfPx+/+93vUFxcjPHjx+Prr7/GJ598gvvvv79lv9eECRNw9dVX4+WXX4bJZMKsWbOwYcOGNvuLPvXUU9i0aROmT5+OW2+9FaNGjUJjYyP27NmD9evXo7Gxsds/66n8+R0R0cDEMZxjOMdwjuHUS3q/MDoNFEuWLBFarVbYbLZ2j1m2bJlQq9Ut7RMaGhrE3XffLdLS0oRGoxHp6enixhtvbNVewW63i9/97nciJydHqNVqkZycLC677DJRUFDQ6tyvvvqqmDx5stDpdCIyMlKMHTtW/PrXvxaVlZUtx5zaUkSIpvYfTz/9tBg9erQIDQ0VMTExYvLkyeKxxx4TJpOp5TgA4q677mrzc73++usiLy9PhIaGihEjRog33nhDPProo+LU/0sdOXJEnHnmmUKn0wkALe00Tm0p0uzFF18UI0aMEGq1WiQlJYk77rhDGAyGVsfMnTtXjB49+rSYbrzxRpGVldVmvCc7tW1GW9pqKSKEEOvXrxezZ88WOp1OREVFiSVLlohDhw6d9v4//elPIi0tTSiVylaf89SWIkIIUVBQIC677DIRHR0ttFqtmDZtmvjss89aHdPcNuO9995r9byvbTfa+zynauvvxmKxiAceeECkpqYKtVot8vLyxF//+teWFjfNHA6HuPfee0VcXJwIDw8XS5YsEWVlZae18xBCiJqaGnHXXXeJjIyMlv/Gzz77bPHqq6/6/dna+7s5WVsxtPc7IqLBgWM4x3CO4T/jGE49SSGEn5UKiIiIiIiIiKhT3MNNRERERERE1AOYcBMRERERERH1ACbcRERERERERD2ACTcRERERERFRD2DCTURERERERNQDmHATERERERER9QBVsAPoClmWUVlZicjISCgUimCHQ0RE5BchBCwWC1JTU6FUDq574BzDiYioP/N1DO/XCXdlZSUyMjKCHQYREVGXlJWVIT09Pdhh9CqO4URENBB0Nob364Q7MjISQNOHjIqKCnI0RERE/jGbzcjIyGgZzwYTjuFERNSf+TqG9+uEu3kJWlRUFAdrIiLqtwbjkmqO4URENBB0NoYPrg1jRERERERERL2ECTcRERERERFRD2DCTURERERERNQD+vUebl9JkgSPxxPsMMgParUaISEhwQ6DiIiCjGN4/8MxnIjoZwM64RZCoLq6GkajMdihUACio6ORnJw8KIsJERENdhzD+zeO4URETQZ0wt08UCcmJiIsLIz/6PcTQgjY7XbU1tYCAFJSUoIcERER9TaO4f0Tx3AiotYGbMItSVLLQB0XFxfscMhPOp0OAFBbW4vExEQuTSMiGkQ4hvdvHMOJiH42YIumNe/3CgsLC3IkFKjm3x337hERDS4cw/s/juFERE0GbMLdjEvQ+i/+7oiIBjeOA/0Xf3dERE0GfMLdHexuL7J/+z9k//Z/sLu9wQ6HiIiIfMDxm4iIgo0JNxEREREREVEPYMLtA0kWLX/eUdTY6nFPWLZsGRQKBRQKBdRqNZKSknDOOefg3//+N2RZ9vk8K1euRHR0dM8FSkRE1If19vgNcAwnIqLWmHB34ssDVVjwzOaWx8ve2Ikznt6ILw9U9eh1Fy5ciKqqKhQXF+OLL77A/Pnzcd999+GCCy6A18tlcURERB0J1vgNcAwnIqKfMeHuwJcHqnDHW3tQY3a1er7a5MQdb+3p0UE7NDQUycnJSEtLw6RJk/B///d/+OSTT/DFF19g5cqVAIBnnnkGY8eORXh4ODIyMnDnnXfCarUCAL755hvcdNNNMJlMLXfaly9fDgB48803MWXKFERGRiI5ORnXXHNNS79MIiKi/i6Y4zfAMZyIiH7GhLsdkizw2KeH0Nbis+bnHvv0UK8sT2t21llnYfz48fjwww8BAEqlEi+88AIOHjyIVatWYePGjfj1r38NAJg1axaee+45REVFoaqqClVVVfjVr34FoKlFx5/+9Cfs3bsXH3/8MYqLi7Fs2bJe+xxERNS3ffvtt1iyZAlSU1OhUCjw8ccft3vs7bffDoVCgeeee67X4utIXxy/AY7hRESDlSrYAfRVO4oaUWVytvu6AFBlcmJHUSNm5sb1WlwjRozAvn37AAD3339/y/PZ2dl4/PHHcfvtt+Pll1+GRqOBXq+HQqFAcnJyq3PcfPPNLX8eMmQIXnjhBUydOhVWqxURERG98jmIiKjvstlsGD9+PG6++WZceuml7R730Ucf4YcffkBqamovRtexvjp+AxzDiYiCySPJMNjcSIzS9up1OcPdjlpL+4N1IMd1FyFES2/L9evX4+yzz0ZaWhoiIyNx/fXXo6GhAXa7vcNz7N69G0uWLEFmZiYiIyMxd+5cAEBpaWmPx09E1F8NphZTixYtwuOPP45LLrmk3WMqKipwzz33YPXq1VCr1b0YXcf66vgNcAwnIgqmonobdhUbev26TLjbkRjp250PX4/rLocPH0ZOTg6Ki4txwQUXYNy4cfjggw+we/duvPTSSwAAt9vd7vttNhvOO+88REVFYfXq1di5cyc++uijTt9HRETUTJZlXH/99Xj44YcxevToYIfTSl8dvwGO4UREwSLJAidqrXB4ev+GOZeUt2NaTixS9FpUm5xt7gNTAEjWazEtJ7bXYtq4cSP279+PBx54ALt374Ysy/j73/8OpbLpvsm7777b6niNRgNJklo9d+TIETQ0NOCpp55CRkYGAGDXrl298wGIiGhAePrpp6FSqXDvvff6/B6XywWX6+ciZmazuSdC65PjN8AxnIgomGotTtSYnIjS9X76yxnudoQoFXh0ySgATYPzyZofP7pkFEKUp77aPVwuF6qrq1FRUYE9e/bgiSeewEUXXYQLLrgAN9xwA4YOHQqPx4N//OMfKCwsxJtvvolXXnml1Tmys7NhtVqxYcMG1NfXw263IzMzExqNpuV9a9euxZ/+9Kce+QxERDTw7N69G88//zxWrlzZsjzaF08++ST0en3LT3PC2N2CPX4DHMOJiPqakgY7jA5PUK7NhLsDC8ekYMV1k5AYFdrq+WS9Fiuum4SFY1J67NpffvklUlJSkJ2djYULF2LTpk144YUX8MknnyAkJATjx4/HM888g6effhpjxozB6tWr8eSTT7Y6x6xZs3D77bfjyiuvREJCAv7yl78gISEBK1euxHvvvYdRo0bhqaeewt/+9rce+xxERDSwbNmyBbW1tcjMzIRKpYJKpUJJSQkeeughZGdnt/u+Rx55BCaTqeWnrKysx2IM5vgNcAwnIupLLE4PiuttCNeEBOX6CiFE7/bF6EZmsxl6vR4mkwlRUVGtXnM6nSgqKkJOTg602q7t07I4PRi7/GsAwMqbpmJOXkKP3hmnJt35OyQi6iq724tRf/gKAHDoj+chTNP1ZWkdjWN9hUKhwEcffYSLL74YANDQ0ICqqtZ9rM877zxcf/31uOmmmzB8+HCfztsbYzjH7+DhGE5EfcWRajM2H61DtE4NVYgCSyd3zworX8dw7uH2wcmD87ScWA7WREQ0oFmtVpw4caLlcVFREfLz8xEbG4vMzEzExbVup6VWq5GcnOxzst1bOH4TEQ1uXknGiRorwoI0uw0w4fZJmEaF4qcWBzsMIiKiXrFr1y7Mnz+/5fGDDz4IALjxxhuxcuXKIEXlP47fRESDW43FhRqLEylROlicwdnDzYSbiIiIWpk3bx782XFWXFzcc8EQEREFqLjOBiEENKrglS5j0TQiIiIiIiIaUEwOD0oabYgJC+384B7EhJuIiIiIiIgGlAqDAxanF1Ha4C7qZsJNREREREREA4ZHknG81oKIUBUUiuAWzGTCTURERERERANGldGJOosLseGaYIfChJuIiIiIiIgGjsJ6KxQKQB0S/HQ3+BEQERERERERdYNGmxtlBjviglwsrdmgbAvm9EhwS3KvXEsTooRWHbxG6+355ptvMH/+fBgMBkRHR/v0nuzsbNx///24//77/b7esmXLYDQa8fHHH/v9XiIiomaDfQzn+E1E1LGyRhscbgkpUbpghwJgECbcTo+Erw9Ww9RLjc/1WjXOHZ3s14C9bNkyrFq1CrfddhteeeWVVq/dddddePnll3HjjTdi5cqV3Rxt1yxfvhyPPfbYac+vW7cOzz//fKuervPmzcOECRPw3HPP9WKERETUn/X1MZzjNxFRcDk9Ek7U2hAZqg52KC0GXcLtlmSYnB5oVSEI7eEG6C5v07Xckuz3HfKMjAy88847ePbZZ6HTNd2dcTqdWLNmDTIzM3si3G4xevRorF+/vtVzsbGx0GiCX7CAiIj6t/4whnP8JiIKnkqjAw02NzJj+8bsNjCI93CHqpQI06h69KcrXwYmTZqEjIwMfPjhhy3Pffjhh8jMzMTEiRNbHetyuXDvvfciMTERWq0WZ5xxBnbu3NnqmM8//xzDhg2DTqfD/PnzUVxcfNo1t27dijlz5kCn0yEjIwP33nsvbDabX3GrVCokJye3+tFoNFi2bBkuvvhiAE0zAJs3b8bzzz8PhUIBhULRZjxERH2VLIvOD6Ie05fHcI7fRETBIYRAQZ0VaqUCKmXfSXP7TiS9QAgBh9sLj1eG2yvD5ZV69MftleHxyq2WYvnj5ptvxhtvvNHy+N///jduuumm04779a9/jQ8++ACrVq3Cnj17MHToUJx33nlobGwEAJSVleHSSy/FkiVLkJ+fj1/84hf47W9/2+ocBQUFWLhwIZYuXYp9+/bhv//9L7Zu3Yq77747oNg78vzzz2PmzJm49dZbUVVVhaqqKmRkZHT7dYiIupPH+/O+4R+KGiAx6e5V/WkM5/hNRNT76qwuVBqdiIvoWytzgrqkXJIkLF++HG+99Raqq6uRmpqKZcuW4f/9v//XIw3KHR4J05/Y2O3n7czicSnQB7Cq4brrrsMjjzyCkpISAMB3332Hd955B998803LMTabDStWrMDKlSuxaNEiAMBrr72GdevW4fXXX8fDDz+MFStWIDc3F3//+98BAMOHD8f+/fvx9NNPt5znySefxLXXXttSUCUvLw8vvPAC5s6dixUrVkCr1foU8/79+xEREdHyeNSoUdixY0erY/R6PTQaDcLCwpCcnOz33wsRUW/78kAV/t/HB1oe/2LVbqTotXh0ySgsHJMSxMgGj/40hnP8JiLqfaUNdri8EsI0fWc5ORDkhPvpp5/GihUrsGrVKowePRq7du3CTTfdBL1ej3vvvTeYofUJCQkJWLx4MVauXAkhBBYvXoz4+PhWxxQUFMDj8WD27Nktz6nVakybNg2HDx8GABw+fBjTp09v9b6ZM2e2erx3717s27cPq1evbnlOCAFZllFUVISRI0f6FPPw4cOxdu3alsehoX2jHD8RUaC+PFCFO97ag1PnOatNTtzx1h6suG4Sk25qheM3EVHvsrm8KKizIVrXt2a3gSAn3Nu2bcNFF12ExYsXA2hqW/H222+fdke1u+jUIdj+f2fhf/uqEKVVQ6fp2VYfDrcEs9PTpZYiN998c8uysJdeeqm7QjuN1WrFbbfd1uaNDn+KvGg0GgwdOrQ7QyMiChpJFnjs00OnJdsAIAAoADz26SGcMyoZIcruX5lFP+tvYzjHbyKi3lNucMBodyMnPjzYoZwmqAn3rFmz8Oqrr+LYsWMYNmwY9u7di61bt+KZZ55p83iXywWXy9Xy2Gw2+3U9hUIBnUYFtUoJjUqJUFXPDtaSLKBWKbu0PH7hwoVwu91QKBQ477zzTns9NzcXGo0G3333HbKysgAAHo8HO3fubFleNnLkyFZ3rQHghx9+aPV40qRJOHToUK8NthqNBpIk9cq1iIgCtaOoEVUmZ7uvCwBVJid2FDViZm5c7wU2CPW3MZzjNxFR7/BKMo7XWBCmCYGyB7Yld1VQi6b99re/xVVXXYURI0ZArVZj4sSJuP/++3Httde2efyTTz4JvV7f8jMYCnWEhITg8OHDOHToEEJCTv9yER4ejjvuuAMPP/wwvvzySxw6dAi33nor7HY7brnlFgDA7bffjuPHj+Phhx/G0aNHsWbNmtN6gP7mN7/Btm3bcPfddyM/Px/Hjx/HJ5980iNFV4Cm1Qzbt29HcXEx6uvrIcty528iIuplVUaHT8fVWtpPymlw4vhNRNQ7qs1O1FpciAvvm1thgppwv/vuu1i9ejXWrFmDPXv2YNWqVfjb3/6GVatWtXn8I488ApPJ1PJTVlYW8LVdXhl2t7dHf1ze7hmEoqKiEBUV1e7rTz31FJYuXYrrr78ekyZNwokTJ/DVV18hJiYGQNOSsg8++AAff/wxxo8fj1deeQVPPPFEq3OMGzcOmzdvxrFjxzBnzhxMnDgRf/jDH5Camtotn+FUv/rVrxASEoJRo0YhISEBpaWlPXIdIqKucHl9m8lLjPStMBV1j/4yhnP8JiLqeUX1NggIaLrQkrknKUSgPau6QUZGBn7729/irrvuannu8ccfx1tvvYUjR450+n6z2Qy9Xg+TyXTagOZ0OlFUVIScnJxWFTqdHglfH6yGyenpvg/SAb1WjXNHJ3dpH/dg1d7vkIioNzTa3PjyQBWe/vIoTI62xwwFgGS9Flt/c1ZAe7g7GscGOo7hAxvHcCLqDUa7G//bX4UwdQgiteoOj22wuqAKUWDp5O5ZJe3rGB7UPdx2ux3KU5qSh4SE9OjyJK06BOeOToZb6p0lUJoQJQdqIqJ+RpYF9pUbYXV5cc20DKzYXHjaMc3p9aNLRrFgWi/hGE5ERCcrbbTD4vQiMaJvLicHgpxwL1myBH/+85+RmZmJ0aNH48cff8QzzzyDm2++uUevq1WHcAAlIqJ2FdbbUFBrRapehyHxEbhjrgJv7yiF8aSZ7mT24Q4KjuFERAQ0rXo6XmOFXqvuUpHqnhbUhPsf//gHfv/73+POO+9EbW0tUlNTcdttt+EPf/hDMMMiIqJBzOryYl+5EaGqnxO7yVkxGJUciXv+mw8A+NeNkzF/eBJntomIiIKk0uhAg82NzFhdsEPpUFAT7sjISDz33HN47rnnghkGERERAEAIgYMVJtRZXKf18lSelFxPzY5lsk1ERBQksixwvNYKdYgCKmXfLJbWrG9HR0RE1IsqjA4cqbYgKVLbJ3t5EhEREVBrcaHS6EBCH9673WzAJ9zsD9l/8XdHRL3J6ZGwt9QIIQQitEFdAEY/4TjQf/F3R0Q9qbjBBq8k+kVNjwH7jUKj0UCpVKKyshIJCQnQaDR9ejM9/UwIAbfbjbq6OiiVSmg0mmCHRESDwJEqM8qNDmTFhQU7lEGPY3j/xTGciHqa2elBUZ0NMWEdtwHrKwZswq1UKpGTk4OqqipUVlYGOxwKQFhYGDIzM09rHUdE1N1qLU4crDIjLlzT5/eCDQYcw/s/juFE1FPKGu0wOz0Yckqtlb5qwCbcQNMd8szMTHi9XkiSFOxwyA8hISFQqVSc0SCiHueRZOwtM8Lh9iIpLiLY4dBPOIb3XxzDiainuL0yjtdYERHq/78xQggAvf/v0oBOuAFAoVBArVZDre4fSw6IiKh3FdRZUVxvQ1o0l5L3NRzDiYjoZJVGB+osTmTE+DdmeyQZ/9h0AhMyorF4XGqv7v0e8Ak3ERFRe4x2N/aWmRARqoZGxaWvREREfZUQAifqrAhRKqEK8W/M/r6wARVGJ2yuhl5v68lvF0RENCjJskB+mREmhxvxESzsRERE1JfVWV2oMDj8HrNlIfD1oRoAwJnD4qH2M1nvKibcREQ0KBU12FBQa0WqXse9pkRERH1ccZ0NLq+EMI1/i7T3V5hQbXIiVKXE9JzYHoqufUy4iYho0LE4PcgvNSJUFdIvengSERENZhanB4X1NsSG+b8i7auD1QCAGUNigzLmM+EmIqJBRQiB/RUm1FldSIwKDXY4RERE1ImyRgdMdg+idP4V0Syqt+FYjRVKBbD5WD0eem8f7G5vD0XZNibcREQ0qJQ1OnC0yoKUKC2UXEpORETUp7m9Mo7VWBChVfk9bn99qGl2e2pW7y8lb8aEm4iIBg2HW0J+mQFKhQLhoWzUQURE1NdVGB2otTgRF+7fcvJ6qwu7SgwAgLNHJPZEaD5hwk1ERIPGwUoTqkxOJOu1wQ6FiIiIOiHLAidqLVAH0Aps/eEaCAGMTolCWoyuhyLsHBNuIiIaFCqMDhysNCMxMjSgHpzHay0tf642ObszNCIiImpDndWFCqMD8RH+1VyxubzYcrweAHDu6KSeCM1nTLiJiGjAc3ok7C01QhYCkVr/Cq4AgN3txarvS1oec4aciIio5xXV2+D2ytBp/Ksu/s2xOri8MtJjdBiVEtVD0fmGCTcREQ14h6vMKDPYkRJgorx6eykMdk83R0VERETtMTk8KKqzIS7cv9ltjyRjw+EaAMB5o5OhCHKBVCbcREQ0oNWYnThQaUJcuAYqpf/D3vaiBmwvakQAq9CJiIgoQKUNNpidHkRp/Sty+n1BA8xOL2LDNJiaHdND0fmOJVqJiGjAcntl5Jca4PbKSInyv2BKg9WFt34oBQAsHpuCucMSIAsgTMPhk4iIqKc4PRKO1VgRpVX7NUMtywJf/dQK7JxRSQHdaO9uwY+AiIiohxyrMaOkwY5Uvf/JtiwE3thWDIdHwpD4cCwel9IDERIREdGpyg0ONNhciPWzFVh+uRE1ZhfCNCGYkxffQ9H5hwk3ERENSHUWF/aVmxAdpoHaz1YiAPD1wRocqbZAo1LiljNy+sRdciIiooFOkgWO11oQqgrxq6uIEAJfHmia3Z43PAFatX+F1noKvz0QEdGA45Fk5JcZYHN7/b47DgAlDTZ8lF8BALhqagaSoliVnIiIqDdUm52oNDoQH+Hf+H2i1orCehtUSgXOHhHcVmAnY8JNREQDzrEaC4rqbUiPDvP7vS6vhNe2FEGSBSZmRmPO0L6xJI2IiGgwOFFrAQCEqvybof7yYNPs9qzcOOh1/rcA7SlMuImIaEBpsLqwr8wEvVYd0FLy93aVo9rsRLROjRtnZAe9nQgREdFg0WB1obTBjrgw/1qBVRod2FtuggLAuaOSeya4ADHhJiKiAcMryfixzAiry4u4CP8GawDILzPim2N1AICbZmcjws9WJERERBS4kgY77G7J7/G3eXZ7QkY0kvV9axsYE24iIhowjtdaUVhnRWq0/4OtyeHBqu+LATS1Ehmdqu/m6IiIiKg9NpcXx2utiAnzb+92o82N7YWNAIBFY/rW7DbAhJuIiAaIBqsLe8uMiNKq/d73JQuBf39XBIvTi/QYHS6dmNZDURIREVFbShvtMNrdiA7zb//1ukM1kITA8KRIDEmI6KHoAseEm4iI+j2vJCO/zAiL04u4AKqSbzhci4OVZqhDFPjlnCEB7f0mIiKiwLi9Mo5WWxARqoLSj9opVpcX3x5v2grWF2e3ASbcREQ0AByvtaLgp6Xk/hY5K22044M95QCAK6ZkIDVa1xMhEhERUTvKDXbUWV1+3zTfdLQWLq+MjBgdRqdG9VB0XcOEm4iI+rVGmzvgpeRNLcAK4ZUFJqRHY96whB6KkoiIiNoiywLHa61QKRVQ+bHCzOWVsOFwLQBg0ZiUPttVhAk3ERH1W15Jxo+lBpidnoCWkr+3qxxVJif0OjVunJXVZwdrIiKigara7ESFwY4EP7uLfHeiAVaXF/ERGkzOiumh6LqOCTcREfVbTUvJbUiL1vmdLP9YamhpAXbz7GxEav0r0jKQffvtt1iyZAlSU1OhUCjw8ccft3p9+fLlGDFiBMLDwxETE4MFCxZg+/btwQmWiIj6tRO1FshCQKv2fZWaJAt89VMrsPNGJyNE2fF3AFkWLX/eUdQI6aTHPY0JNxER9Us/VyVX+b2UvNHmxsptxQCA89gC7DQ2mw3jx4/HSy+91Obrw4YNw4svvoj9+/dj69atyM7Oxrnnnou6urpejpSIiPqzBqsLJQ12xIf7185zR3EjGmxuRGpVmJ0b3+Gxu0sM+P3agy2Pl72xE2c8vRFfHqgKKGZ/+ddRnIiIqA/wSDJ+/KkqeXZcmF/vlWWB17cWweaWkBUXhkvYAuw0ixYtwqJFi9p9/Zprrmn1+JlnnsHrr7+Offv24eyzz+7p8IiIaIAoqrfB7pGQove9YKksBL7Y35QsnzMyCRpV+3PIu0sMWLG54LTnq01O3PHWHqy4bhIWjknxP3A/cIabiIj6nWM1FhTWWQNaSv75gSocrbEgVKXEL+cM8atAC53O7Xbj1VdfhV6vx/jx44MdDhER9RNWlxcn6qyI0flXg2VvmRGVJid06hDMG95+sVNZFnhnZ2mbrzUvKH/s00M9vryc3zKIiKhfqbe6sK/MBL1W3eFd7bYU1Fmxdm8lAOCaaZlIivJvCRv97LPPPkNERAS0Wi2effZZrFu3DvHx7S/rc7lcMJvNrX6IiGjwKmmwwWT3IDrM9xoqQgh8fqBp7/b84QkI07S/YPtYrQUGu6f9cwGoMjmxo6jR5+sHggk3ERH1G56fqpLb3F7E+VnN1O724rUthZAFMC07FrNy43ooysFh/vz5yM/Px7Zt27Bw4UJcccUVqK2tbff4J598Enq9vuUnIyOjF6MlIqK+xOmRcLTagkitCko/VqodqbagqN4GdYgCC0YmdXisydF+sn2yWovT5+sHggk3ERH1G0eqzCiqb6pK7g8hBN78oQT1VjfiIzS4bkYmW4B1UXh4OIYOHYoZM2bg9ddfh0qlwuuvv97u8Y888ghMJlPLT1lZWS9GS0REfUm5wY56qwuxfrb0/PynQmdnDI1HlK7jmXF9J683S4zs2dVuLJpGRET9Qq3ZiX0VJkTrNFD7ue9664l67Cw2QKkAbp0zpMMlaBQYWZbhcrnafT00NBShof6tSiAiooHHK8k4Vm2FVhUCldL38byo3obDVRaEKBRYODq50+OHJUYiJkzd7rJyBYBkvRbTcmJ9jiEQnOEmIqI+z+WVsKfUAKdH8vtueKXRgbd3NM2mXjIxDbkJET0R4oBitVqRn5+P/Px8AEBRURHy8/NRWloKm82G//u//8MPP/yAkpIS7N69GzfffDMqKipw+eWXBzdwIiLq8yqNTlSZHIj3c2tY8+z2tJxYn7aVKZUKXDU1s83Xmte4PbpkVKc9vLuKCTcREfV5hyrNKGmwI9WPtiFA057vV7cUwi3JGJUShfN8uCNOwK5duzBx4kRMnDgRAPDggw9i4sSJ+MMf/oCQkBAcOXIES5cuxbBhw7BkyRI0NDRgy5YtGD16dJAjJyKivkwIgeO1FigUCr8Kn1YaHcgvNQIAFo3xfSyfnBWDO+bmIvqU5eXJem2vtAQDuKSciIj6uCqTAwcqTIgL938p+bu7ylBucCBSq8ItZ+T4VZhlMJs3bx6EaL9NyocfftiL0RAR0UBRY3ahzGBHQgCz2wLAxMxopPpZx2VyVgxGJUfinv/mAwBW3jQVc/ISenxmuxlnuImIqM9yeiT8WGqERxKIDvNvKfmeUgM2Ha0DANwyO8fn4ikdcUsyQpQ/L0UjIiIi3xXUWeH1Cug0IT6/p9byc+uuxWMDm5FWnpRcT8uJ7bVkG2DCTUREfZQQAgcqTChrsCM12r8Kog1WF1ZuKwYAnDcqCWPS9F2Ox+bywu6WMCpVD5WfM+1ERESDXaPNjeIGG+Ii/LuB/uWBasgCGJMahey48B6KrufwGwMREfVJ5QYHDlaakRgV6lcVU6/ctG/b7paQEx+OSyamdTkWjySj2uzE2DQ9hidFdvl8REREg01xvQ1WpxeRWt9XnDXa3PiuoAFA4LPbwcaEm4iI+hyby4s9pQYIIfwamAFgbX4lCups0KlD8Ms5Q7o8Gy0LgTKDHbkJ4ZiQGd1qWRoRERF1zuL04FiNxe9OI18fqoYkCwxLikBeF254Sx3UJelpTLiJiKhPEUJgb7kRVSan31XJD1aa8MWBagDAjTOzkBDZ9b7PlUYHEiO1mJoTh1CV73vOiIiIqElJgw0mh8eveipmhwffHqsH0PXZ7Qaru0vv7wom3ERE1KcU1dtwpMqClCitX7PJJocHr28tggAwd1gCpmTHdjmWeqsLapUS03Jiu6XoGhER0WDj9Eg4Wm1FlFbtV7eQdYdr4JZkZMeFYVRKVMDX98oybG5vwO/vKibcRETUZ5idHvxYaoQ6RIHwUN87V8qywGtbCmF2epEWrcOVUzK6HIvV6YXNJWFqdqzfLUiIiIioSWmjHQ1WF+L8WE5uc3mx6WgtAOCCcalQdKGtZ53FhcSorq94CxQTbiIi6hMkWWBPiQH1VheSovyrSv6/A1U4Um2BRqXEbWcOgUbVteHN5ZVQY3FiXIYeeYkRXToXERHRYOX2yjhSZUaYRuXXqrX1h2vg9MhIi9ZhXHrgnUa8kgynR8KI5MBnyLuKCTcREfUJJ2qtOFZjQVq0zq8lZ0erLVi7txIAcN30zC7PRsuyQLnBgWFJkRifHt2lu+pERESDWYXRgWqzE/F+tAJzuCVsONI8u53i13eCU9VaXEjW65AZGxbwObqKCTcREQVdg9WFH0sNiAxVQ6v2vTCZxenBa1sKIQQwKzcOs3LjuxxLmdGOFL0WU3NiuzxTTkRENFhJssDRajM0IUq/OoZsPFoLu1tCsl6LyZkxAV/fI8lwSTJGpkQFdTznNwkiIgoqt1fGnlIDrE6vX3fAZSHw+tYiGB0eJOu1uHZaZpdjqTE7Ea5RYUZuHCL82ENORERErVUaHag0OpEQ4fv+aadHwrpDNQCaKpN3pRVnrdmFNL0OWXHBm90GmHATEVGQHa4yo7DOhrQYnV/Lt788UI0DlWaoQxS4/cwhCPVjZrwtJocHbknGtJxYJEb6t4eciIiIfiaEwPEaKwDh1/j8zdE6WF1eJEaGYloXuo24vTK8soyRqVFQ+zG73hOYcBMRUdBUmRzYV25EXLjGrwHxWI0FH+VXAACumZaJ9Jiu3b12uCU02FyYmBGNnPjwLp2LiIhosKsxu1BqsCEhwvcb2C6vhK8OVQMAzh+bgpAuzG7XmJ1Ij9EhIyb4XUaYcBMRUVA43BJ2FxvgkQSiw3xfSm52ePDqt037tmcOicMZQ7u2b9sryag0OTAqJQpjWSSNiIioy47VmOGRZOg0vs9ubzleD8tP28tmDAl8dtvpkSAAjEzR+7V3vKcEPwIiIhp0hBDYV25EhdGBND+qip+2b3t6ZpcSZFkIlBrsyIoLw5Ts2C7dTSciIqKmvtclDXYkhPs+u+2RZHx5oGl2e9GYFKiUgaepNRYnMuPCkN4HZrcBJtxERBQERfU2HKw0IylK61eS+/n+Khysaqp4eseZuX5VNG9LpdGB+IhQzBgS1+VzEREREVBYZ4XDIyFC63vx0S3H62F0eBATpsas3LiAr+1wS1BCgZEpUV0quNadmHATEVGvMtk9+LHUCE2I0q9K4Eeqzfjkp37b107PRFoX71zXW11QhSgwfUicX0vaiYiIqG1GuxsFdVbEhftemdwjyfjiQBUA4PwxKV0qclZjcSAnIRwpUX2n+CkTbiIi6jVeScaPZQbUW11IjPJ9MDadtG97Vm4cZndx37bF6YHNJWFqdpxfS9qJiIiofYV1NlicXkT5Mbu99Xg9DPam2e0z8gIf320uL9QhIRiR3HdmtwEm3ERE1IuOVltwrMaC9GgdlD7uvZZlgVe/LYTZ6UVatA7XTu9av22XR0KtxYXxGXoMS4ro0rmIiIioicXpwbFaC2LCND7XV/FIMj7/aXZ7UZdnt53ITQhHkh839HuD77ceiIiIuqDG7ER+uRF6rdqvnpyf7K3E0RoLQlVK3DE3F6GqwPdae2UZ5UYHhidHYnwGK5ITERF1l6J6G0x2j1/tNb870TS7Ha1TY04XZrctTg90mhAMT45qc2wP06hQ/NTigM/fFZzhJiKiHuf0SNhdYoDTIyEuwvc7z/srTPjf/qY73zfMzEKyPvA9WUIIlBnsyIgJw9Ts2C7dRSciIqKf2d1eHKm2IFqn9nkFm0eS8fn+5srkyQGPy0II1FpdGJYYiYTIvjW7DTDhJiKiHiaEwL4yI8oa7H7tl26wuvD61iIAwLxhCZieE3jVUgCoNDkRowvF9CGxCPejWBsRERF1rKjeBoPNjZhw34uQbitoQKPdDb1OjTOHJQR8bZPDg8hQFYYnRwZ8jp7EhJuIiHpUcYMdBypNSIrS+txX0yvJ+Oe3hbC6vMiKC8OVUzO6FEOD1QWlApg+JNavGXYiIiLqmNMj4UiVBZFalc+z215Jxuf7m/duBz67LQuBepsbI5Kj+mzHESbcRETUY0wOD/aUGKAOUfrVj/Pd3eUorLchTBOC28/M7dLyb6vTC6vbiynZsciIDQv4PERERHS6kgY76q0uv1qBfVfQgAbbT7PbeYHPbhtsbsSEaZDXh4ugMuEmIqIe4ZVk7ClpagGW5Ec/zB1Fjdh4pBYAcMsZOV3aj+XySqixODEuPRrDk/rmUjMiIqL+yuWVcLjKjPBQFUJ8bMXlkWT8b9/Ps9saVYCz27KA0eHBqJRIRGrVAZ2jNzDhJiKiHnGk2ozjtRakx/jeAqzS6MCq74sBAOePScb49OiAr++VZZQbfqpInh7dp3pyEhERDQRljXbUWpyIj/B9OffW4/VotLsRrVNjbhf2btfbXIiPCEVuYt+d3QaYcBMRUQ+oMjnwY5kRMWEan9t4OT0SXtlcAJdXxojkSFw0IS3g67dUJI9tqkge6N1zIiIiaptHknGkygKtKsTnGi0n990+f2zgfbe9sgyr04vRaVEI0/TtQqj8BkJERN3K7vZid7EBHq9AjI8FTIQQ+M/3Jag0OaHXqXHrnCE+L01rS6Xxp4rkOaxITkRE1BPKGu2oNDn82vr17bE6GOwexIR1re92rdmFZL3Wr57fwcKEm4iIuo0sC+SXGVFhdPjVAmzT0TrsKG5EiEKB288cAr0u8L1YDVYXlCGsSE5ERNRTvJKMI9UWhKpCfJ6ldntlfH6gqe/24i7MbnskGU6vhFGpep9X0QVT0BPuiooKXHfddYiLi4NOp8PYsWOxa9euYIdFREQBKKiz4nClGSl6rc8z1AV1Vvx3VxkA4LLJ6cjrQnEzi9MDq0vCtOw4ViQnIiLqIWUGByqNDiT6M7t9vA4mhwex4RqcMTTw2e1qkxMZsWHIiusf43xQ19kZDAbMnj0b8+fPxxdffIGEhAQcP34cMTExwQyLiIgCUG91YXeJATpNiM/7qcwOD17ZXABJFpiSFYMFIxMDvr7TI6HO6sLkzBgM68PtQYiIiPozSRY4Wm1GiFLh8yy1yyu19N2+YGwKVAHObjs9EgSA0Sn6LrUM7U1BTbiffvppZGRk4I033mh5LicnJ4gRERFRIJweCbuKG2FxeZAd69t+KkkWeHVLIQx2D5L1WiyblQ2Fj9XMT+WVZFQYHRiZEolxGdEBn4eIiIg6VmFwoMLgQIre961j3xytg9npRXyEBrNy4wK+do3Fiey4cKTH+H7tYAvqbYG1a9diypQpuPzyy5GYmIiJEyfitddea/d4l8sFs9nc6oeIiIJLCIH9FSYUN9iQHh3mc7L70Y8VP+3/UuLOubnQqgPbhyULgVKDHVlxYZiaHddv7ngTERH1N5IscLjaDKVC4XMHEKdHwhc/7d1eMi414Nltm8sLlVKJkSlR/arVZ1C/lRQWFmLFihXIy8vDV199hTvuuAP33nsvVq1a1ebxTz75JPR6fctPRkZGL0dMRESnKm6w40C5CUmRWp+T3d0lBnx5sGnwXTYrG6l+FFg7VYXRgYQILWYMiYNO0/eLpxAREfVXlcam2W1/9m6vP1wDq8uLpKhQzBjStdntnPgwpOi1AZ8jGIKacMuyjEmTJuGJJ57AxIkT8ctf/hK33norXnnllTaPf+SRR2AymVp+ysrKejliIiI6mdHuxu5iA1QhCkRqfassXmVy4I1tRQCAc0YlYWp2bMDXrzE7oVWFYGZuHKJ9bEFGRERE/pN/2rsNAKE+rkqzu734+lANAODC8akBt/w0OTwI04RgVKq+320bC2rCnZKSglGjRrV6buTIkSgtLW3z+NDQUERFRbX6ISKi4HB7ZewqMaDR7kJylG93m50eCS9/UwCnR8awpAhcNik94Osb7W64JRnThsQiuZ/d7SYiIupvKk0OlDba/Zrd/vpQDexuCanR2oBvsAshUGd1YXhyFOL7YbvPoCbcs2fPxtGjR1s9d+zYMWRlZQUpIiIi8tXBChMKaq0+79sWQmDltmJUmZyI1qlx25m5Ad/ptrm8aLS7MSUrBrkJrEhORETUk2RZ4Ei1BQB8rrlicXqw7qfZ7YvGp0EZ4Mx0o82N6DA1hicH3jY0mIKacD/wwAP44Ycf8MQTT+DEiRNYs2YNXn31Vdx1113BDIuIiDpR2mDHvgoT4iNCfS6a8vWhGuwqMSBEocDtc3Oh1/m2BP1ULq+EarMT49OjMTpVH9A5iIiIyHeVJgdKG2xIjPR9RdlXB2vg8srIjA3DxMzogK4rywJGhwejU6IQ5ePWtb4mqAn31KlT8dFHH+Htt9/GmDFj8Kc//QnPPfccrr322mCGRUREHTA5PNhV0ggAPifNh6vMeH9POQDgqqkZGJoY2Ky0JAuUGxwYlhSJiZkx/apKKRERUX/UtHfbAgHfZ7dNDg82HqkFAFw0ITXg2e06qwsJkaEYmtg/Z7eBIPfhBoALLrgAF1xwQbDDICIiH3gkGXtKDKizuJAT71u/7QarC//8thBCALNy4zBveEJA15aFQFmjHRkxYZiWE+vzzDoREREFrsrsREmDDUl+zG7/b18V3JKMIfHhGJcW2Go0ryTD5vZiak5sv+5Cwm8rRETks4MVJhyvtSA9RufT3Wq3V8ZL3xTA6vIiKy4M103PCri6aIXRgZhwDWbkxiE8NOj3i4mIiAY8WRY4WuXf7Ha91YXNx+sAAJdMTAt43K8xu5Cm1yE7zrcb/H0VE24iIvJJWaMde8tNiAsPRaiq80FXCIG3tpegtNGOiFAV7pybG/CsdK3FiVCVEjNz4xAbzvZfREREvSGQ2e21eyshyQIjkyMxMiWwrlIujwSvLGN0mr7fr2jr39ETEVGvMDk82Fns377tTUfrsK2gAQoFcNuZQxAXYCsPo90Nl0fGtJw4pEbrAjoHERER+ad5dluG8Hl2u9LowPeFDQCaZrcDVW1xIis+HJmxYQGfo69gwk1ERB3ySDJ2Fzft207xsd/1sRoL/ruzDABw2aT0gO9w291eGBweTM6OQW5C/15SRkRE1J80z24nRvg3uy0EMCEjGkMCbNtpdXmhUioxJlU/IIqjMuEmIqIOHagw4YQf+7YbbW6s2FwASQhMz4nFuaOSArquyyuhyuTEuDQ9xqTqA94DRkRERP6RZYEjVWbIED4XLCtpsGFXiQEKABdPSA342jVmJ4YmRiApKrCVcX0NE24iImpXSYMN+8pNiIvwbd+2R5Lx8jcnYHF6kRGjww0zAyuS5pVllBscGJ7M9l9ERES9rdLk8Hvv9kf5FQCAaTmxSI8JbCm40e5GpFaFkSlRA+ZGOxNuIiJqk9Huxq7ipjvVvuzbFkLgzR9KUNxgR7gmBHfOG+pTkn4qWQiUNtqREcv2X0RERL2teXYb8L0y+bEaCw5UmKFUABeOD2x2WxYCDTY3RiZHDagCqfwWQ0REp3F7ZewqbkSDzYVkH/dtbzxSe1KRtFwkRAa2FKzc4EBChBazcuMQpmH7LyIiot5UYXSgtNGBRB9nt4UQ+GBPOQBgTl4CkqJ8nxU/Wb3VhbjwUOQlRwb0/r6KCTcREbUihMC+ciMK6mzIiAnzad/2kWoz/rurqUja5ZPTMSo1sCJp1SYnwjQhmJkbh+iwgXN3m4iIqD+QZYEj1f7Nbu8tN6GgzgZNiBJLxqUEdF2vJMPq8mJMehQiQgfWzXYm3ERE1EpRvQ37yo1IjAyFOqTzYaLe6sIrmwshC2DGkFicMzKwImmNNjdkITBjSJzPs+pERETUfSqMDpQ1OpDk4yo1WRb48Mem2e2zRyYGfLO8xuxCql6HnPiB15GECTcREbVosLqws9gAjSoEkdrO9227PBJe2nQCVpcX2XFhuGFGdkBFTixODyxOL6bmxCJ7AA62REREfZ0kCxyqMkOhAEJ9nN3+oagBlcam1WkLRycHdF2nR4JXFhiTpg+o9ktfx4SbiIgANA14O4obYXa6fbqzLYTAG9uKUWZwIFKrwp3zhgZU4MzhllBndWFiZjRGDLB9W0RERP1FucGO8kYHEiN8m932SDI+ya8EACwak4zwAJeC11icyI4PQ2ZsYJXN+zom3EREBFkW2FNqQGmDHRnRYT7NUv9vfxV2lRgQolDgzrm5AVUU9UgyKo0OjE7RY1w6e20TEREFg1eScbiqqcq4r7Pbm4/VocHmRrROjbNGJAZ0XYvTA7VSiTFp+gHbApQJNxER4VitBYcqzUjRa6HyYd92fpkRH/90V/ua6ZnIS/J/ZtoryyhttCM3KQKTs2N8ui71jm+//RZLlixBamoqFAoFPv7445bXPB4PfvOb32Ds2LEIDw9HamoqbrjhBlRWVgYvYCIi6pIygwPlBofPFcadHgn/218FAFgyPjWgpeBCCNRaXMhLigi4snl/wG83RESDXLXJid0lBkSGqnxqw1VhdOC1LYUAgPnDEzB3WILf15SFQFmjAxmxYZgxJM7nSqjUO2w2G8aPH4+XXnrptNfsdjv27NmD3//+99izZw8+/PBDHD16FBdeeGEQIiUioq7ySDIOV5qhVip93hr21cFqWJxeJEWGYvbQuICua7B7oNepMSpFH9D7+4uBVXOdiIj8YnF6sKOoAS6PjCQf9k5ZXV68uOkEXF4Zw5MiceXUjICuW25wIC5Cg5lD4gZc+4+BYNGiRVi0aFGbr+n1eqxbt67Vcy+++CKmTZuG0tJSZGZm9kaIRETUTUoa7Cg3OpARo/PpeJPDg68P1QAALp2UDpXS/zlcSRYw2N2YlRsHfVjnRVr7M85wExENUh5Jxu4SA6pMTqRHdz7IemUZ/9xcgDqLC/ERGtw+d0hAg2yVyYEwTQhm5cYjJoB939T3mEwmKBQKREdHBzsUIiLyg8sr4VClCVqV0qdWoADw6d5KuLwyhsSHY1JmdEDXrbU4kRSlDWhLWn/DaQUiokFICIED5SYcq7YgPVrnU6GSd3eW43C1BaEqJe6aP9SntmGnarC6AIC9tgcQp9OJ3/zmN7j66qsRFRXV7nEulwsul6vlsdls7o3wiIioAyUNdlSbnT5XCK82O/Ht8ToAwNJJ6QEVO3V5JTg9EmYNjR8UW8o4w01ENAgVN9iRX25EXESoT9VINx+rw8ajtQCAX5yRg4wY/1t3mBwe2NwSe20PIB6PB1dccQWEEFixYkWHxz755JPQ6/UtPxkZgW1HICKi7uH0SDhUaUaYRuXzirWPfqyALIBxaXoMD7CVZ7XZiez4cGQN0DZgp2LCTUQ0yDRYXdhZ1Ai1Ugm9rvNZ6iPVZqzZXgoAuGRiGiZmxvh9TbvbiwabGxMzozF8ECwfGwyak+2SkhKsW7euw9ltAHjkkUdgMplafsrKynopUiIiaktRvQ01ZicSfOy7XVhnxe4SAxRomt0OhNXlhUqpxOhU/aDpTsIl5UREg4jDLWF7USNMTjeyYzufZa6zuPDK5kJIQmBadizOH5Ps9zVdHglVJifGp+sxLj2avbYHgOZk+/jx49i0aRPi4jqvUBsaGorQUN++1BERUc+yu704VGlGpFaFEB+2lQkh8P6ecgDAzNw4pPlYYO3Uc9SYnRiTpkfKINpWxoSbiGiQkGSB3SWNKG20IzsurNPE1+GW8I9Nx2F1eZEdF4Zls7L9TpY9koxyowPDkyMxKSvWp0Gdgs9qteLEiRMtj4uKipCfn4/Y2FikpKTgsssuw549e/DZZ59BkiRUV1cDAGJjY6HRsBAeEVFfV1BrRb3FhRwft3jtLTfhWI0VKqUCF09IC+iazW3ARqdGDaqb70y4iYgGiUOVJhyqsiBNr+t0r5YsC7y6pRCVRieidWrcNX+oz705m0myaEru48MxPSfO7/dT8OzatQvz589vefzggw8CAG688UYsX74ca9euBQBMmDCh1fs2bdqEefPm9VaYREQUAIvTg0NVFkSHqX0qmirJP89uLxiZhNgAOoyc3AYsOmxw3Zhlwk1ENAiUNtjxY6kRMWFq6DSdF0l7b0859leYoAlR4u75QxHj5+AoC4FSgw1p0TrMzI3z6ZrUd8ybNw9CiHZf7+g1IiLq247XWGGwu5Hr4+z21hP1qDY5ERGqwvlj/d9aBgA1ZieS9YOjDdipON1ARDTAGWxu7CxuBACfEuctx+uw7lANAOCm2dkBVRSvMDoQGxaKmblxiAqgfRgRERF1P6PdjaPVFsSHa3xa1u30SPgkvwIAcMG4FIRp/J+vdXkkeCQZY9P0g6IN2KmYcBMRDWBOj4TtRQ1otLl9KlByrMaCt36qSH7R+FRMzY71+5pVJgd06hDMGhqHOB8rnxIREVHPO1ptgdnp8alLCQB8dbAaZqcXiZGhmDcsIaBrVlucyIoPR1bc4GwJyoSbiGiAaiqSZkBJgx0ZMbpO72TXmJ14adMJSLLA1OwYXDAuxe9r1ltdAIAZQ+KQove/gikRERH1jDqLC8dqLUiICPVpdttod+Orn1a8LZ2UHlAbL4vTA02IEmPT9IO2cCoTbiKiAepwlQmHqsxI0Ws7HSRtLi/+sfEEbG4p4IrkRrsbdrcX04fEBbQMnYiIiHqGEAKHq0xwuCVE+Ti7/Ul+JdxeGbkJ4ZiUGe33NWUhUGtxYVhSJJKiBk8bsFMx4SYiGoBKG+zYXWJEtE7d6X4rryzjlc0FqDY7ERumwT1n5SFU5d8eK6vTC6PDg6nZschLjOhK6ERERNTNqs1OFNbbkBTpW+JbbrBja0E9AODyyRkBtfFqsLoRE6bByNQov987kDDhJiIaYBqsLuwoaoQCnRdJE0JgzfZSHK62IFSlxD1nDfV5X1czh1tCrdWJ8RnRGJ2qH1S9NYmIiPo6WRY4WGmGJAuEh3Ze9EwIgXd3lUMIYEpWDIYGcCPdI8mwuDwYm64f9MVTmXATEQ0gDreE7UWNMNp9K5K27nANvj1eDwWAX545BBmxYX5dz+2VUWlyYHSKHhMzon3q50lERES9p9zgQEm93efZ7QOVZhyqMkOlVGDppPSArlltciI9Jgy5CVz1xoSbiGiA8EoydhY3oLTRjvTYzouk5ZcZ8d6ucgDA5VPSMT492u/rlRnsGJYUiSk5MQEVUyEiIqKe45FkHKg0QamETy25JFng3V1lAICzRyQiIdL/biN2txcAMDZND42K3w34N0BENAAIIbC/woQj1RakR+ugUnb8z3tJgw2vbimEADB3WALOGZnk1/UkWaCk0Y7s+HBMHxLr955vIiIi6nklDXaUGxxI9rFo2ZbjdagyORERqsLiALqVCCFQbXYiLykC6THsVgIw4SYiGhAK623ILzUiLjy00zvYjTY3/rHxBNxeGaNTonD1NP+KochCoKzRjrRoHWbmxnValI2IiIh6n9Mj4WClCTq1EmofVqHZ3V58srcSAHDh+NSAxneD3YPIUDVrupyECTcRUT9Xa3ZiZ1EjNCplpwXPnB4J/9h4HEaHB6nRWtw2d0ins+EnE0Kg3GBHbIQGs4bGD/pCKERERH1VQZ0V1Sanz8vCP99fDYvTi+QoLc4cFu/39byyDIPdjTFpUYgJ77ho62DChJuIqB8zOz34obABNre30x6Xsizw6pZClBkciNSqcO9ZeX7fva40OhEeqsbsofGI5WBKRETUJ1mcHhysNCNKq/bpxnqdxYX1h2sAAJdNTvfrZnyzGrMLKXot8pIi/X7vQMaEm4ion3J5JewoakSVyYmM6I6riwsh8PbOUuwrN0EdosA984ciPsK/Qig1ZifUKgVm5cZ1mtwTERFR8ByvscJgcyMuwreb4+/vKYdXFhiZHInx6Xq/r+dwS5BkgXHp0T4VZxtMmHATEfVDsiywp8SAglorMmPDOm3Hte5wDTYdrYMCwC/OGIIhfrbpaLC6IMkCM4bE+d06jIiIiHpPg9WFI9VmxIVroPRhH/WxGgt2lxigUABXTvWvrkuzKrMDQxLCkcnvCKfxeye8JElYuXIlNmzYgNraWsiy3Or1jRs3dltwRETUtkNVJhyoMCFFr+20EMqeUkNL+6/LJqdjclaMX9cy2t2wuSXMHhrvd6JOREREvUcIgSNVFlhdXgyJ73zMlmWBd3Y2tQE7My8B6TH+J8wGuxsRoSqMTdN3OgEwGPmdcN93331YuXIlFi9ejDFjxrD6HBFRLyuut2F3iRHRYZpO92AX1lvxry1FLe2/zh3lX/svi9MDo8OD6TmxGJbEZLuv27BhQ7s3xP/9738HKSoiIuot1WYnTtRZkRjp29avbYUNKG20Q6cOwcUTUv2+niQLNNrcmJ4Tizg/t6oNFn4n3O+88w7effddnH/++T0RDxERdaDW4sT2okYoFUBMWMf7suosrqb2X5KMMWlRuGZapl83Se1uL+qsLkzKjGF7j37gsccewx//+EdMmTIFKSkp/H0REQ0ykixwsNIMrywjIrTzNM/pkfDRjxUAgCXjUxAZQOeRGrMTKXotRqRE+f3ewcLvhFuj0WDo0KE9EQsREXXA4vTgh4IGWF0eZHay5Mvq8uL5DcdhcXqREaPD7WfmIsSPZV5Oj4QqkxPj0vWYmBnDJWL9wCuvvIKVK1fi+uuvD3YoREQUBKWNdpTU25DsY2HTz/dXweTwIDEyFGcNT/T7ek6PBI8kMJaF0jrkd9G0hx56CM8//zyEED0RDxERtcHpkbD9pIrkHc1eeiQZL206gWqzE7FhGtx3dp5fA6HbK6PC4MDIlEhMyY71K1Gn4HG73Zg1a1awwyAioiBweSUcrDBBFaJEqA9jfp3Fha8PNbUBu2JKBlSd1INpS6XJgdzEcGSxUFqH/J7h3rp1KzZt2oQvvvgCo0ePhlrdeunBhx9+2G3BERFR0xKxPaW+VSSXhcC/vyvC8VordOoQ3Hd2HqI7WXp+Mq8ko8xgR15SJKblxHVakI36jl/84hdYs2YNfv/73wc7FCIi6mWFdTZUGh3IjPMt+X13Vxm8ssColKiA2oA12lgozVd+J9zR0dG45JJLeiIWIiI6hRACBytNOFhp9qki+Yd7KrCz2IAQhQJ3zstFWozO52tJskBJox3Z8eGYkRvL5WH9jNPpxKuvvor169dj3Lhxp90Qf+aZZ4IUGRER9SSry4sDFSZEatVQKTu/UX6o0owfy4xQKoCrAmgD5pVlGOxuzMyNY6E0H/idcL/xxhs9EQcREbWhoM6G3SUGxOjUnVYk33ikFl8erAYA3DgrCyP9KGAiywIljTZkxIZhVm5cp9eivmffvn2YMGECAODAgQOtXmMBNSKigetIlRmNNjdy4sM7PdYry3hnZykA4KwRiUiN9v3GfLMakwtp0ToMS4r0+72DUcDfqOrq6nD06FEAwPDhw5GQkNBtQREREVBpdGBHUQM0IcpOl4XvKTXg7R1NA+jFE1IxKzfe5+vIQqDU0FRkZVZuXEBVSin4Nm3aFOwQiIiol9VbXThaY0F8RCiUPtxc/eZoHSpNTkSEqrBknP9twOxuLyQhMI6F0nzm9+Y8m82Gm2++GSkpKTjzzDNx5plnIjU1FbfccgvsdntPxEhENOgYbG78UNgAt1dGUifVRgvqrHhtSyEEgDPz4rF4bIrP1xFCoNxgR2x4KGYPjfdrvzf1XeXl5SgvLw92GERE1IOEEDhUaYLN5YVe1/nNcovTg7V7KwEAl0xMQ7gPrcNOvV6VyYm8pAik+7FlbbDzO+F+8MEHsXnzZnz66acwGo0wGo345JNPsHnzZjz00EM9ESMR0aBid3vxfWEDGqzuTpd6VZud+MfGE/BIAuPS9bh2epZfy4crjA5EatWYPTSe+7D6OVmW8cc//hF6vR5ZWVnIyspCdHQ0/vSnP0GW5WCHR0RE3azc4EBBre9twD76sQJ2t4SMGB3mDPV9JVyzRpsbep2ahdL85PeS8g8++ADvv/8+5s2b1/Lc+eefD51OhyuuuAIrVqzozviIiAYVt1fGjqJGlDXakRUX1uHyMJPDg+fWH4PV5UV2XBhumzPErxZeVSYHtOoQzBoa3+ksOvV9v/vd7/D666/jqaeewuzZswE0dRZZvnw5nE4n/vznPwc5QiIi6i4eScaBShOggE91V0oabNhyvB4AcPW0TL8TZo8kw+T0cDVcAPxOuO12O5KSkk57PjExkUvKiYi6QJYFfiw14Gi1Bekxug4rjTrcEp7fcBz1VjcSIkNx71l5PvXdbFZjdkKhAGblxiMtgIIp1PesWrUK//rXv3DhhRe2PDdu3DikpaXhzjvvZMJNRDSAFNXbUNZoR0ZM523AZCGwZkcpBIBp2bEBFTurMjmQGRuGvEQWSvOX30vKZ86ciUcffRROp7PlOYfDgcceewwzZ87s1uCIiAYLIQQOVJqwt9yI5CgtQlXtJ89eScbLm0+gtNGOSK0KDyzIQ5QPe7eaNVhdkGSBmbnxPvfrpL6vsbERI0aMOO35ESNGoLGxMQgRERFRT7C5vNhfbkK4RtVpu1AA+L6wAQV1NoSqlLhiSrrf17M4PQhRKjEuPRoald/p46Dn9wz3888/j/POOw/p6ekYP348AGDv3r3QarX46quvuj1AIqLBoKDOit3FBsSGaTosYiILgTe2FeNwlQWhKiXuOysPiZG+LwdvtLlhd0uYnReP3ISI7gid+ojx48fjxRdfxAsvvNDq+RdffLFlvCYiov7vaLUFdVYXhvjQBszu9uL93U1FNJeMS/V7ObgsBGosLkzKiA6ohRgFkHCPGTMGx48fx+rVq3HkyBEAwNVXX41rr70WOh1/CURE/qowOrC9qBFadUinA+EHe8qxvagRIQoF7pibi2wfBttmJocHVpcX04fEIi+RyfZA85e//AWLFy/G+vXrW1acff/99ygrK8Pnn38e5OiIiKg71FtdOFxtRny4xqc2YGv3VsLi9CI5SosFIxP9vl6txYXEyFCMStMHEi4hwD7cYWFhuPXWW7s7FiKiQafe6sL3Jxrg8cpI72Qf1teHqvHVwRoAwA2zsjDGj8HP4vTAaHdjak4sRqVE+VXJnPqHuXPn4tixY3jppZdabohfeumluPPOO5Ga6n+vVSIi6ltkWeBARVMbsKT4zm+cVxgc2HikFgBw9bQMqHxYfn4yl0eC0yNhxpA4RPjZQox+5tPf3Nq1a7Fo0SKo1WqsXbu2w2NPLtZCRETtMzs92HaiHianG5mdJNs/FDbg3V1NS8KWTkrD7Fzf23lYXV7UWd2YkhWDMal6JtsDWGpqKoujERENUOUGBwrrbEiJ6nxVsfipUJosgEmZ0Rid6v8MdaXJiaGJEcjxYzUdnc6nhPviiy9GdXU1EhMTcfHFF7d7nEKhgCRJ3RUbEdGA5XBL+L6gAVUmJ3LiwjtMgg9UmPDGd8UAgAUjE7FwdLLP17G7vai1ODEhIwbjM6LZN3OA2bdvH8aMGQOlUol9+/Z1eOy4ceN6KSoiIupuLq+EfeVGKBWATtN5V5LtRY04WmOBJkSJK6dk+H29Rpsb4aEhGJeu96vlKJ3Op4RbluU2/0xERP7zSDK2FzWgqN6GrNiwDpPgonobVmwugCQEpmXH4oopGT7PUDs9EqpMToxL12NSZjQHzAFowoQJLTfEJ0yYAIVCASHEacfxhjgRUf92osaKCqMDWbGddxexu714d1cZAGDxuBTERYT6dS2vJMNgd2NWbpzf76XT+b0Y/z//+Q+uvPJKhIa2/st3u9145513cMMNN3RbcEREA40sC+wpaeq1nRGt67CdR5XJgec3HIfLK2NUShRunp3tU4EUoGnfVYXRgdGpUZiSHev3vi3qH4qKipCQkNDyZyIiGnhMDg/2V5qg16l9Gs8/ya+E2elFUlQozh2V5Pf1Kk1OZMSGYVgye253B7+/gd10000wmUynPW+xWHDTTTd1S1BERAOREAL7yo3YV2Fq6rWtbn9JWKPNjWfXHYfV5UV2XBjunJfrc9Ls8kooNzgwIiUS03LifOrRSf1TVlZWy4qHkpISpKWlISsrq9VPWloaSkpKghwpEREFQgiBg5UmmOwexIV33tKrtNGOjUebCqVdOy3L7+8ATT23FRifEY1QVedL16lzfn8LE0K0uZyxvLwcej3LxRMRtedYjRV7So2d9tq2Or14dv0xNNrdSI7S4r6z86DtIDk/mUeSUW5wYFhyJKbnxEGjYrI9WMyfPx+NjY2nPW8ymTB//vwgRERERF1VZXLieI0VSVHaTreUyUJg9fYSCAFMyYrBqNQov64lC4FaiwsjkiORqtd2JWw6ic9LyidOnAiFQgGFQoGzzz4bKtXPb5UkCUVFRVi4cGGPBElE1N8V19uwo6gB4ZoQ6HXqdo9zeSS8sPE4qkxOxISp8cCCPERq2z/+ZB5JRmmjHbmJEZgxJM7nJJ0GhvZuiDc0NCA8nBVmiYj6G48kY3+FCZIs+9SWa9uJBhTU2RCqUuLKqf4XSqsxO5EYqcWYNHY06U4+J9zN1cnz8/Nx3nnnISLi595vGo0G2dnZWLp0abcHSETU31WZHPihsAEKKDosPuKVZLy8uQCF9TaEa0LwwIJhPhcr8cpNyfaQhHDMyo3zqYIpDQyXXnopgKbCaMuWLWtVY0WSJOzbtw+zZs0KVnhERBSgwjobShpsyOikdSjQtDru/T1N7UMvHJ+KmLDOl5+fzOGW4PYKjB+q73AVHvnP57/NRx99FACQnZ2NK6+8ElotlxkQEXWm3urCthMNcHokpHcwYMqywL+2FuFgpRkalRL3np2H1OjO+2wCTcl2SYMdWXFhmJkbjzANB8rBpHk7lxACkZGR0Ol+/u9Go9FgxowZuPXWW4MVHhERBcDi9GB/uQkRoSqf9mG/v6ccVpcXadE6nD0y0a9rCSFQaXJgZEoksuO4Iqq7+f2t7MYbb+yJOIiIBhyT3YNtJ+phsLuQFdv+ACaEwFvbS7CrxIAQpQJ3zctFbkJEu8efTJIFShvtyIgNw+yh8T4tOaOB5Y033gDQdEP8V7/6FZePExENAIcqzWiwuZAT3/m/6cdrLNh6oh4AcN2MTKiU/tVvqbe6ER2mwfj0mA5blVJgfPpmFhsbi2PHjiE+Ph4xMTEdrulvq2ALEdFgY3N5sa2wHtVmJ7Jjwzv8d/OjHyvw7fF6KADcekYORqf6VoBSlgVKGm1I1eswe2i8z3u9aWBqXolGRET9W5XJgSPVFiRGhnbaDtQry3hze1MnijlD45GX6F8rL5dXgsXlxdxhCdCH8XtET/Ap4X722WcRGRnZ8mduoiciap/TI+H7wgaU/rTMu6O7xV8drMbnB6oBANfPyMKU7FifriGLppnt5CgtzsiL77AQGw1ckyZNwoYNGxATE9NS3LQ9e/bs6cXIiIgoEB5Jxr7ypkJpvtxIX3eoBpVGJyJCVVg6Kd3v61WaHBgSH47cBK6O6ik+JdwnLyNftmxZT8VCRNTveSQZO4oaUFBrRWZsWIfLur49Vof3djcVOFk6KQ1nDkvw6RqyaJrZTozSYk5eAqL9LIxCA8dFF13UUiStubgpERH1X4V1NpQ22Dqs+9Ks3urCp3urAABXTElHhNa/bWWNNjfCNSqMz4iBys9+3eQ7vzf77dmzB2q1GmPHjgUAfPLJJ3jjjTcwatQoLF++HBoNv/gR0eAkyQK7ihtxuMqCtGhdh0VOdhQ14s0fmpaALRqTjEVjUny6hiwEygx2JERoccbQeMSE89/cwezkZeRcUk5E1L+ZnR7sKzci3IdCaUIIrNlRCrckY1hSBGYOifPrWh5JhsHuxqzcOCRE+tYRhQLj962M2267DceOHQMAFBYW4sorr0RYWBjee+89/PrXv+72AImI+gNZFvix1ID9FSak6LUd9sDeV27E61uLIADMHZaASyem+XQN8VOyHROmwRl58T63DKPBoaysDOXl5S2Pd+zYgfvvvx+vvvpqEKMiIiJfCCFwoMKERpsb8T6M77tLDdhXbkKIUoHrpmf5veW30uRAVlwYhidHBRoy+cjvhPvYsWOYMGECAOC9997D3LlzsWbNGqxcuRIffPBBd8dHRNTnCSFwsNKE/DIjEiJCO2zLdbTaghWbCyAJgek5sbh2eqZPg2Rzsh2t02BOXoJPgzENLtdccw02bdoEAKiursaCBQuwY8cO/O53v8Mf//jHIEdHREQdqTA6cLTagqQobaeF0uxuL97eUQYAOH9Mss9tRJuZHB5oQpSYkBEDjYpLyXua33/DQgjIsgwAWL9+Pc4//3wAQEZGBurr6wMO5KmnnoJCocD9998f8DmIiILhaI0FO4sNiNapOyxwUlhnxQsbj8MjCYxL1+Om2dmdDqpAc7LtgF6nwZy8eC79ojYdOHAA06ZNAwC8++67GDt2LLZt24bVq1dj5cqVwQ2OiIja5fJK2FduggLwqb3nB3sqYHJ4kBQVivPH+rYlrZlXllFndWJMqh7Jem2AEZM//E64p0yZgscffxxvvvkmNm/ejMWLFwMAioqKkJSUFFAQO3fuxD//+U+MGzcuoPcTEQXLiVorthc2IlwT0mHxsjKDHc9tOA6XV8aI5EjcfmauT30yhRAoNzoQpVXjjLx4JEZxcKS2eTyelgJq69evx4UXXggAGDFiBKqqqoIZGhERdeB4jQVlP3Ue6fTYWgs2H6sD0NTdpLO93qeqNjmRER2GkalcSt5b/E64n3vuOezZswd33303fve732Ho0KEAgPfffx+zZs3yOwCr1Yprr70Wr732GmJiYvx+PxFRsJQ02PB9YT3UIYoO91NXm5x4Zt0x2N0SchPCcff8oT4t4RJCoMLoQESoCmfkxSOJyTZ1YPTo0XjllVewZcsWrFu3DgsXLgQAVFZWIi7Ov2I6RETUOxptbuwvNyNap+60UrhXkvHm900FV88YGo8Rfu6/tjg9UCgUmJAV02GtGepeflcpHzduHPbv33/a83/9618REuL/L+6uu+7C4sWLsWDBAjz++OMdHutyueByuVoem81mv69HRNQdKowObDvRAAh0OOtcb3Xh7+uOwuL0IiNGh/vOzvNpkBNCoNzgQPhPyTaXfVFnnn76aVxyySX461//ihtvvBHjx48HAKxdu7ZlqTkREfUdsiywr9wIi8uDnLjO+2B/ebAalSYnIrUqXDbZv57bkixQa3FhclYM0vzc801d43fC3Wz37t04fPgwAGDUqFGYNGmS3+d45513sGfPHuzcudOn45988kk89thjfl+HiKg71Zid+O54PVxeqcM+mQa7G3//+hgMdg9S9Fo8eM6wDguqnazc6EDYT8l2ip4DI3Vu3rx5qK+vh9lsbrVi7Je//CXCwjrv50pERL2ruMGGglorUvW6TguoVpuc+Gxf0/agK6dk+LTX+2SVJgdS9FqMTtUHHC8Fxu+Eu7a2FldeeSU2b96M6OhoAIDRaMT8+fPxzjvvICEhwafzlJWV4b777sO6deug1fo2c/PII4/gwQcfbHlsNpuRkZHh70cgIgpYncWFrcfrYXV5kNFBsm1yePD3r4+hzupCQmQoHjpnWIcF1U5WbrAjTNOUbPtbeZQGt5CQEHi9XmzduhUAMHz4cGRnZwc3KCIiOo3N5cXeMhM0KmWnK99kIbDq+2J4ZYHRqVGYnhPr17WalpIDEzNjoNNwKXlv83sP9z333AOr1YqDBw+isbERjY2NOHDgAMxmM+69916fz7N7927U1tZi0qRJUKlUUKlU2Lx5M1544QWoVCpIknTae0JDQxEVFdXqh4iotzTa3PjuRD2MDjcyYsLavRttdXrxzLpjqDY7ERuuwa/OGdZhQbWTlRvs0GpCcEZePJd8kV9sNhtuvvlmpKSk4Mwzz8SZZ56J1NRU3HLLLbDb7X6d69tvv8WSJUuQmpoKhUKBjz/+uNXrH374Ic4991zExcVBoVAgPz+/+z4IEdEgcLDChFqLE0mRnU88fnusDsdrrQhVKXHDDP96bjcvJR+VHIX0GH6vCAa/E+4vv/wSL7/8MkaOHNny3KhRo/DSSy/hiy++8Pk8Z599Nvbv34/8/PyWnylTpuDaa69Ffn5+QPvBiYh6isnuwdbjdai3uDpMtu1uL57dcAwVRgf0OjUeOmdYhwXVTtacbM/JS2CyTX578MEHsXnzZnz66acwGo0wGo345JNPsHnzZjz00EN+nctms2H8+PF46aWX2n39jDPOwNNPP90doRMRDSoVRgcOV1uQGBkKpbLj5LnR5sb7e8oBAJdMTPP5O0Wzqp+Wko9Nj/YrUafu4/eSclmWoVafvixSrVa39Of2RWRkJMaMGdPqufDwcMTFxZ32PBFRMJmdHnx3oh7VZieyY8Pb7Z3t9Eh4bv1xlDTYEalV4aFzhvlcWZzJNnXVBx98gPfffx/z5s1ree7888+HTqfDFVdcgRUrVvh8rkWLFmHRokXtvn799dcDAIqLiwMNl4hoUHJ5JewtM0KSRadbzYQQWL29BE6PjCHx4ThreKJf17I4PRDgUvJg83uG+6yzzsJ9992HysrKlucqKirwwAMP4Oyzz+7W4IiIgs3q8mLbiXqUGezIig1v9060yyPh+Q3HUVhvQ5gmBA8uGObz/usKgwNaNZNt6hq73Y6kpKTTnk9MTPR7STkREfWMY9VNPbdTfeg+sqvEgL3lJoQoFbhxVnans+Ena15KPjqFS8mDze8Z7hdffBEXXnghsrOzWwqWlZWVYcyYMXjrrbe6FMw333zTpfcTEXUnu9uL707Uo6TBjqy4MIS0l2x7Jfxj0wkcr7VCpw7Bg+cMQ0asb1WhW/ZsD+WebeqamTNn4tFHH8V//vOflmKkDocDjz32GGbOnBnk6Njak4io3urC/goTYsI0nfbctjg9WLOjFABw/phkv78jVHIpeZ/hd8KdkZGBPXv2YMOGDS1twUaOHIkFCxZ0e3BERMHicEvYdqIexfU2ZMWGQaVse2D0SDJe2lSAI9UWaNVKPLAgD9k+9NIUQqDC6OAycuo2zz33HM477zykp6e39ODeu3cvtFotvvrqqyBHx9aeRDS4eSUZ+WVG2F0SsuM7n91+Z2cZLE4vUqO1OH9sil/Xsjg9UCoUXEreR/iVcP/3v//F2rVr4Xa7cfbZZ+Oee+7pqbiIiILG6ZHwfUEDTtT9lGy3cxfaI8l46ZsTOFRlRqhKifvOysOQhIhOzy+EaOqz/VPrLybb1B3Gjh2LEydOYM2aNS03xK+++mpce+210OmC/98YW3sS0WBWUGdDYZ0NadGdJ9v5ZUZsL2qEQgHcNCsH6k5mw0/mlWXUml2YnB3j82o76lk+J9wrVqzAXXfdhby8POh0Onz44YcoKCjAX//6156Mj4ioVzk9En4obMDxWgsyY8LaHeQ8kowV3xTgQIUZmhAl7jlrKPKSIjs9vxAC5QYHwkJVmMM+29RNfvjhB3z66adwu90466yz8Itf/CLYIZ0mNDQUoaH+VdclIhoIjHY38suMiAxVIVTV8YyzzeXFmz+UAADOG5WMnPjOV82drMrkRFqMDmPS9AHHS93L59slL774Ih599FEcPXoU+fn5WLVqFV5++eWejI2IqFc1J9tHqy1Ij9FBo2r7n0ivJOOVzQXYV2GCOkSBe84aihHJUZ2ev3lmO5zJNnWj999/H7Nnz8bzzz+Pf/3rX7jgggvwt7/9rUvntFqtLS07AaCoqAj5+fkoLW3aT9jY2Ij8/HwcOnQIAFq+G1RXV3fpukREA40sC+SXGWFyuBEfoen0+Hd3lcHk8CA5SosLx6f6dS2Tw4MQhQITs2KgVXMpeV/hc8JdWFiIG2+8seXxNddcA6/Xi6qqqh4JjIioN7m8PyXbVRakR+vavQPtlWX889tC7C03QaVU4O75QzEyxbdku8zgQESoCnOGMdmm7vPkk0/i1ltvhclkgsFgwOOPP44nnniiS+fctWsXJk6ciIkTJwJo6vE9ceJE/OEPfwAArF27FhMnTsTixYsBAFdddRUmTpyIV155pWsfhohogCmst6Gg1opUva7T4mUHKkz4rqABCgA3zspq98Z/W7ySjHqrC2PT9Nyq1scohBDClwOVSiVqamqQkJDQ8lxkZCT27t2LIUOG9FiAHTGbzdDr9TCZTIiK6vwLLxFRW9xeGT8U1uNwc7Ldzl1hryzj1W8LsafU2JJs+7JkqynZtiNKq8EZefFI9qEVCA0O3TGORUREID8/H0OHDgUAuN1uhIeHo6KiAomJ/vVs7U0cw4looLM4Pfj6YA0cbqnTsd/u9mL52kNotLuxYGQirpqa6de1ShptSI3W4awRiZ0uW6fu4es45lfRtN///vcIC/t5873b7caf//xn6PU/f+F85plnAgiXiCg43F4ZO4oacLjKgrROku1/fluIH39Ktu/yMdmWf0q2o3UazMmLR2IUk23qXna7vdVAr9FooNVqYbVa+3TCTUQ0kMmywN4yI+qtLp/2Yb+7qxyNdjcSIkNxyYQ0v65lsLsRqlJiUmYMk+0+yOeE+8wzz8TRo0dbPTdr1iwUFha2PGaPNyLqT5qT7YOVZqRF69rd79RWsj3Wj2Q7JqxpZjsxksk29Yx//etfiIj4uUK+1+vFypUrER8f3/LcvffeG4zQiIgGpeIGG47VWJGi10LZSY60v8KErSfqoQBw06zsdm/+t8UjyTDY3Zg5JA5JvKnfJ/m8pLwv4nI0IgpUbyTbpY02xIVrcUZePBIiWZ2ZTtcd41h2dnanN7wVCkWrG+R9AcdwIhqoLE4P1h2qgc3lRYq+4/3UNpcXj649CKPDg3NGJuHKqb63SxRCoKTBjqz4MMwbnuhX+zDquh5ZUk5ENBC0JNtVnSTb0k/Jdpl/e7Ydbi/ueScfALD11/OZbFOPKi4uDnYIRET0E1kW2FduQp3Ft6Xk/91VBqPDg6SoUFw80b+q5PVWNyK0KkzKjGGy3YfxN0NEg0qrmW19+8m2R5KxYnOB38m2JAuUNjpaHsf60AKEiIiIBoaSRjuOVlt8WkqeX2bEtoIGKBTAzbNz/Np/7fRIsLg8mJgZg7gI3tjvyzjDTUSDhssrYXvhzwXSOkq2X/6mAPt/6rN99/yhGJ3aebLtlWWUNtqRrOfAR0RENNhYnB78WGqASqlAmKbjNMvi9OA/3xcDAM4dlYTchIgOjz+ZLAQqTA4MT4rE0ETf30fBwYSbiAaF5j7bRzpJtt1eGS99cwIHK83QhChxz1m+9dn2yjJKGuzIiA3DxIzobo6eiIiI+jJZFthX5ttSciEE3tpeCrPTi1S9Fhf7WZW8xuxEfHgoJmXFIETJotV9HZeUE9GA5/RI+L6gKdlO7yDZdnkk/GPj8aZkW6XEvWf7mGxLTcl2VlwYzsiLhz5M3d0fgahdlZWVwQ6BiGjQK2qw4YiPS8l3FDVid4kBIQoFbjkjx6/911aXF15ZYFJWDKK0/L7RH/j82/39738Pr9fb7uulpaU455xzuiUoIqLu4vQ0zWwf/SnZbq/VhtMj4fmNx3G42oJQlRL3n52HEcmdJ9seSUZxox3Z8eE4Iy+Bgx/1utGjR2PNmjXBDoOIaNAyOTzILzUiVK3sdCl5o82N1TtKAQAXjE9BVlznhdWaSbJAjdmJUSlRyI4L61LM1Ht8TrhXrVqFqVOn4sCBA6e99s9//hNjxoyBSsUV6kTUdzjcEradaMDRagvSY9tPtu1uL55dfwzHaqzQqUPw4DnDMCwpstPzu7wSShrtGJoQjjl58YgI5b+B1Pv+/Oc/47bbbsPll1+OxsbGYIdDRDSoyLJAfpkB9TYXEjvpSiKEwMptxbC7JeTEh+P8MSl+XavC6EBatA7j0qM7bQdJfYfPCfeBAwcwduxYTJkyBU8++SRkWUZpaSkWLFiAX//61/jb3/6GL774oidjJSLymd3txXcn6nC81oKMmLB2K3/aXF48s+4YCupsCNOE4KFzhvlUuMTlkVBuaCpYMntoQqd3tIl6yp133ol9+/ahoaEBo0aNwqeffhrskIiIBo2COiuO11iRptd1upT8m6N1OFRlhjpEgVtm5/i1/9pgd0OtUmBydgx0Gt+rmVPw+fwNMSoqCv/5z3+wdOlS3Hbbbfjvf/+LoqIiTJs2Dfv27UNWVlZPxklE5DOry4ttJ+pRVG9DZmxYu3ujzA4Pnl1/DGUGByJCVXjwnGHIjO18iZbTI6HC6MDw5EjMGBLX7p5wot6Sk5ODjRs34sUXX8Sll16KkSNHnrbqbM+ePUGKjohoYDLY3NhTaoROHdLpd4EqkwPv7S4HACydlI5kvdbn67i8Egx2N2YOiUOKXtelmKn3+T0lM2PGDIwdOxYbNmxAeHg4/t//+39MtomozzA7Pdh2oh6lDfYOk22j3Y2/rTuGapMTUVoVHjpnONJiOh/E7G4vqkxOjE6NwrScOGhUrD1JfUNJSQk+/PBDxMTE4KKLLuI2LyKiHuSRZOwpNcDkcCOnk33YXknGa1uK4JZkjEqJwlkjEn2+jhACFUYHchMiMMKHQq7U9/g1Gr/99tu4++67MWHCBBw+fBivv/46zj33XNx555148sknodX6fqeGiKi7Ge1ubDvRgDJDU8VwlbLtZLjB6sLf1h1DncWFmDA1Hjp3OJKjOv/3y+r0otbqxLh0PaZkx/pVVZSoJ7322mt46KGHsGDBAhw8eBAJCQnBDomIqF+yu70Y9YevAACH/nheu1vGjlabUVBnRVq0rtP91Gv3VaK00Y5wTQhunp3d6dLzk9VaXIgJ02ByVgy/d/RTPv/Wli5diltvvRXLly/Hhg0bMHz4cPzlL3/Bpk2b8Pnnn2P8+PH4/vvvezJWIqJ2Ndrc+PZYHcqNdmTHhbebbNeYnXj6y6Oos7iQEBGK3ywc4VOybXZ4UGdzYWJmDKYy2aY+ZOHChfjNb36DF198ER9++CGTbSKiHlZrdmJvuQnROk27NWKaHaux4Iv91QCA62dmITpM4/N1bC4vXF4ZEzNj/Hof9S0+z3BXV1fjxx9/RF5eXqvnZ82ahfz8fPz2t7/F3Llz4Xa7uz1IIqKO1Flc+O5EPeotLmTHhkPZThGScoMdz6w7BrPTi+QoLR46dxhifBjAjHY3TA4PpmTFYHx6dLvnbybJouXPO4oaMScvwa/CKET+kCQJ+/btQ3p6erBDISIa8JweCbtKDHB6JCTFdnzD3u724vWtRRAAZuXGYUpWrM/X8coyqs1OjE/XIzfB99Zh1Pf4nHBv2bIFynZmjHQ6HZ5//nksXbq02wIjIvJFtcmJ707Uw+hwIzMurN1lWoX1Vjy3/jjsbgkZMTrcv2AY9LrOe2Y32tywuryYlhOL0an6TpPtLw9U4dG1B1seL3tjJ1L0Wjy6ZBQW+tn+g8gX69atC3YIRESDghACBytMKG20ITu28yT47R1laLC5ER+hwdVTM/26VoXRgYyYMIzPiGELsH7O5zWR7SXbJzvzzDO7FAwRkT/KDXZsPlYHs9ODzJj2k+2j1Rb8/etjsLslDIkPx6/OHe5Tsl1nccHhkTAzNw5j0nxLtu94aw9qzK5Wz1ebnLjjrT348kCV7x+OiIiI+pSyRgf2V5qQGKGFqpOtZT8UNuD7wgYoFMAtZ+T41cqrweqCVh3CFmADBDchElG/VFxvw5Zj9XC6JaR3ULBkX7kRz204BpdXxojkSDx4zjCEh3a+uKfa5IRXljF7aBxGpkR1endZkgUe+/QQRBuvNT/32KeHWi03JyIiov7B4vRgd4kBCigQ1clN+zqLC29tLwEAXDA2BXmJkT5fx+mRYHJ6MSEjGkk+1Jihvo8JNxH1OydqLdhyog6SLJAW036yvb2oAS9tKoBHEhiXrsd9Z+d12idTCIEKgwNKJTAnLwFDfRwkdxQ1osrkbP+8AKpMTuwoavTpfERERNQ3SLLAnlIDai1OpHTSP1uSBV7bUginR8bQhAhcMC7V5+vIP7UAG5YUgRHJbAE2ULBJJxH1G0IIHKoyY2dxI0JDQpAQFdrusZuO1mLN9lIIANNzYnHT7Ox2K5c3k4VAucGB8FAVZg+NQ3pMmM+x1VraT7YDOY6IiIj6huO1FhyttiAtWtdpS69P91WisN4GnToEt87J8atoaqXRgaQoLSZnxbDY6gDChJuI+gVZFthXbsSeUiMiQlWIDW+7urgQAl8cqMaHP1YAAOYPT8DV0zI7HSBlWaDUYENMWCjOyIv3exlXYqRvx/t6HBEREfW+UzuNDE+OxI8lRkRp1Z2ukjtWY8H/9jfVa7l+RhbiItqfGDiV0e6GUqHA5KwYRGo7rzND/QcTbiLq87ySjB/LjPix1IC48NB2C54JIfDe7nJ8fagGQNO+qYsmpHa6/9oryyhttCM5SotZQ+MR78cA2WxaTixS9FpUm5xt7uNWAEjWazEtx/eWIERERNR72uo0Eh2mxoKRiVg4uuNOI1anF69tKYQQTS3A/BnvXV4JjXY3pmXHIiPW99V11D9wDzcR9Wkur4TtRY34sdSAxEhtu8m2JAu8sa24Jdm+Yko6Lp6Y1mmy7ZFklDTYkR4ThjOHJQSUbANAiFKBR5eMAtCUXJ+s+fGjS0ZxiRgREVEf1F6nEaPdg/d3V2B3iaHd9wohsHJbMQx2D5IiQ3HNNN9bgDVvZxuaEInRafqA46e+iwk3EfVZdrcX3xc04ECFCSlROkS0U13c7ZWx4psCbCtogFIB3Dw7G+eOSu70/C6vhNJGO4YkhGNOXjyiw9pepu6rhWNSsOK6SUg8ZW95sl6LFddNYh9uIiKiPqijTiPN3tlZCrmdTiMbjtQiv9wIlVKB2+bmdrr0/GTVJifiI0IxOTsG6k5ajVH/xCXlRNQnmZ0efF/QgKJ6GzJidAhVtT142d1evLjpBI7VWKEOUeC2M3MxISO60/M73BIqTHaMSI7C9Jy4butzuXBMCmYPjcfY5V8DAFbeNBVz8hI4s01ERNRHddZpBAAMdg+O1VpOqx5e0mDD+7vLAQBXTMlAph9Lwk0ODwSAKdkx7a7go/6PCTcR9TmNNje2nahHhdGB7NgwqNq542u0u/H8huMoMzigU4fgnrOGYlhS5228rC4vas1OjE2NxpScmHaT+UCdnFxPy4llsk3Uw+xuL0b94SsAwKE/nocwDb/eEJHvfO0gYnJ4Wj12eiT889tCeGWBiRnRmD88wedrur0yGqwuTM2JRVZcuF/xUv/CEYmI+pRqkxPbCurRaHMjOy683WS12uzEc+uPod7qhl6nxn1n5/l0V9nk8KDB5sKEzBhMyoxuN5knIiKiwcHXDiInz0ILIfDmDyWotbgQG67BjbOyO60b00wWAmUGO/ISIzGG+7YHPCbcRNRnFNfb8ENhAxweCZmxYe228iqqt+H5DcdhdXmRGBmKBxYMQ0Jk58XOGqwu2NwSpmXHYlx6NJSceSYiIhr0mjuNdLSsPCZMjWGJP6+i+/Z4PbYXNUKpAG6dk9NunZm2VJmcSIjkvu3Bgr9hIgo6IQSOVluw5XgdvJJARkz7yfaBChP+9vVRWF1eZMWF4bcLR/iUbNeYnXB6ZczMjcP4DCbbRERE1CREqcBD5wzr8Jirpma2fHcobbTj7R2lAIBLJqYhL7Hz7WzNjHY3AGBqdiz3bQ8STLiJKKgkWWBvmRHfnaiHJkSJZH37y7q2FdTjHxtPwOWVMTIlEg+fOxxRnQxWQghUGBxQKIA5efEYmRLl85IvIiIiGvhcXgn6MDUunZSG6FO+V8SEqXHH3FxMzooB0FR09ZXNBfDKAuPS9ThvdOddUVqu42nqtz0+Xc9+24MIl5QTUdC4vTJ2lzRif4UZceGadu/0CiHwxYFqfPhjBQBgek4sbpqV3en+6+Y9UlFaNWbmxiE9hoMbERER/UwIgX3lJhTW2XDOyCTMz0vAPf/NBwDcd9ZQjE7Vt8xsCyGw6vviln3bN8/OaXdF3qlkWaDc6MDwZO7bHmyYcBNRUNjdXuwoasTRagtS9Np2qwrLssA7O8uw8WgtAOC80UlYOim90wHOK8sobbQjMVKLWUPjfC6IQkRERINHYb0N+8tNSIwMhTpE2arX9rCkyFZb0DYdrcOuEgNCFArcduYQv/ZtV5gcSNZrMTkrhgVbBxkm3ETU64x2N34obEBJgx3pHfTYdntlvLa1ED+WGqEAcOXUDCwYmdTp+T1SU7KdERuGWblxiA7TdPMnICIiov6u3urCzuJGhKqUiNR2vEWtoM6K/+4qAwAsnZyG3IQIn6/TYHVBo1JiWk5sp9ehgYcJNxH1qmqTEz8UNqDW4kRWXBhUyrbv8lqcHvxj4wkU1tugUirwizNyMCU7ttPzOz0SKgwO5CZFYMaQOL/uPhMREdHg4HBL2FHUCKvTg6zYjvtgW5wevLK5AJIsMDkzBuf4cPO/md3thcXlxeyh8UjR67oaNvVD/CZKRL2mqN6G7YUNsLslZMeFt7ssvMbsxPMbjqPW4kKYJgR3zx+KYUmdVwC1Or2otTgxOi0KU7JjoVW3PXNOREREg5ckC+wuaURZox1ZcWEdFlOVZYFXtxTCYPcgKSoUy/zot+2VZVSZnBibrsdwH77H0MDEhJuIepwsCxyuMjfte1IqkNlBZc6COite3HQCFqcXceEa3Hd2HlKjO78jbLS7YXR4MDErBhMyooPa1zJMo0LxU4uDdn0iIiJq35EqMw5XW5Cq17W70q7Z2r2VOFxlgUalxJ3zhkKn8e1mvhAC5Y0OZMaFYVJmDNuRDmJMuImoR3kkGT+WGrG/3IgonRoxHeyn3l1iwL+2FsIjCWTGhuG+s/N86lFZZ3HB6ZUwPSe2VTVRIiIiopOVG+zYU2qAXqvuNHneX2HCZ/urAAA3zshCmg8TAM2qzU7ow9SYxhV3gx4TbiLqMSdXIk+K0ra7n1oIga8P1eD93eUQAMal6fHLM4d0OkAJIVBpdEKlUmBOXjxyEyLYY5uIiIjaZLS7saOoEZIsEBve9gRAqDoE/7phCmrMTjz+v8MAgPnDEzB9SJzP1zE5PJCEwNTsWMRFhHZL7NR/MeEmoh7RaGuqRF7W2HElckkWeGdnKTYdrQPQNKhdNTUTIZ3MUsuyQJnRDr1Wgxm5seyxTURERO1yeiRsL2pEvdWF7LiOi6Q5PRJe+uYEHB4JuQnhuHJKhl/XabC5MC07FtnxHV+HBgcm3ETU7coNdmwvbITB5u6wErnDLeGfWwpwoMIMBYDLp6TjnJFJnc5SeyUZpQY7kqO0mJkbj4RI3j0mGsykk/rm7ihqxJy8hE5v2hHR4CHLAntKDSiusyEzLqzdoq1A0+q5lduKUWl0Qq9T4465uT73zZZkgXKjAyOSIzEmTd9d4VM/x4SbiLqNEALHaqzYUdwASRIdVv5ssLrwwsYTqDA6oAlR4pYzcjA5K6bTazg9EsqNDuTEh2PGkDif9ngT0cD15YEqPLr2YMvjZW/sRIpei0eXjMLCMSlBjIyI+orDVWYcrDAhJVrbaVHVrw7WtBR5vWNuLqI7qD1zMiEEyo12pEfrMDU71ucknQY+/pdARN3i/7d333F2XeWh93+n9zq9d3VbXbIkXHEHxyYhGF9MwAnNGIPjCwkmAV8nufEleS9giIEEsKkBbgzYYILBuBfZsiU3dWmappczc3o/e71/HM1YsiXNmV70fD+fsTT7bJ299vbMWfvZa63nyeQ0dneO8uyRIcx6PdW+0wfbHcMx/vl3B+kJJvDYTHzuiuUFBdvRZJaeYIKVFS4uaCmRYFuIs9wje/u4+cd7GAinTtreH0py84/38MjevnlqmRBioegaOZ4kzWbGbj7zWOP+3jC/eKUbgPdvrqG51FnwcQYiKZwWE1sbi3CcJmeNODvJT4MQYtpiqSwvdeSTo5W6LLispw+Ed3eO8r1n20nnNKq8Nj59SXNBCUVG42lCiQwbFkDZLyHE/Mtpirt+sx91itcUoAPu+s1+LltVLtPLhThLBaIpXmwbQVOcNknamMFIkm8/3YpSsKOpiIuWlRR8nFAiQyansaNZlrmJt5OAWwgxLUORFC+2BegOJqjx2rCcJrO4Uor/3tvPr17pAWBNlZuPn99UUD3LgXCSrKbY1ljEygq3lP0SQrCrfYS+UPK0ryugL5RkV/sI25oKzy4shFga4uksL7aPMBovLEnavz1xlHg6R2OxgxvPqyu46slJSdKKJIGreDsJuIUQU9YxHOPF9hGiqQwNRY7TjiJlcho/3NnJzrYAAO9cUcr7NtVMnIlcKbpHE9jNBrY1FdFYUvjULiHE0jYYOX2wPZX9hBBLRyansat9hK6R+BnzyUD+XuO7z7aPJ0n75EVNBc+iy2oa3cEEqyrySdKkNKk4FQm4hRCTltMU+3pDvHIsiEGno/YM67XDiQz3PnmU1qEYeh3csKWWi5eXTniMsUzkJU4r25qKKPdYZ/o0hBCLWKmrsM+EQvcTQiwNSile6wpyuD9Ctdd22kopY379Wi+vdgUx6nXccvEkk6SNJKj129kkSdLEGUjALYSYlEQ6x+7OEfb3RfDbTWfsmLpG4nzjiaOMxNLYTAY+cWEjqysnLpORyuToCiaoL7JzXmNRwZ2fEOLssaXBT4XHSn8oecp13Dqg3GNlS4N/rpsmhJhHhweivNYVosRlOe0ytzEvd47w8Ov55Ip/sa2OxuLCZ9L1hpL4HGbOayyaMBmbOLvJoxghRMEC0RRPHBpkb2+YCrf1jIHwnmOj3P3IQUZiacpcFr5w9YqCgu1oMjtew/KCZSUSbAshTsmg13HnNauAfHB9orHv77xmlSRME+Is0jUSZ1dHAIfFcMYErpBfFnffsx0AXLayjO1NxQUfJxBNodflH/xNlIxNCAm4hRAF6QzEePzgIL2j+ZHn0yU7U0rx8Ou9fPPJVtJZjZUVLr5w9UoqPLYJjxGIphiOpdhQ52NHc7E8MRZCnNGVayr41o0bKHWfnBW43GPlWzdukDrcQpxFhiIpXmgLoGlQPEH1k9F4mn974ijpnMaaKjfv3Vhd8HGiqSzRVJZN9X5q/JIkTUxM7maFEGeUzWns7wvzyrEgeh1nTD6SyuS4//kOXu4cBQpPjqaUoi+URKeDHc3FLC9zSSZyIURBrlxTwY7mYs75X38A4Ps3beb8lhIZ2RbiLBJOZtjZOkw4maHWd+YgOJXNZyQPJjJUeqx87PzGgj8vUtkcA+Ek62u8LC9zzUTTxVlAAm4hxGnFUll2d45wsD+C324+4/TuQDTFvz1xlK7RBAa9jg9sqeWCAmpY5jRFdzCOy2LivMYiaqWkhhBikk68Wd7S4JdgW4izSDKTY1dbgL5QkoYix4QZye97roPOQBynxcitl7QUPJsup+Urpywrc7Gu1icDA6JgEnALIU5pMJJkV9sIPcEEVV4b1jMkHjnUH+FbT7USTWVxWY188sImWgp48pvOanSNxqny2tjaWESJ68xTwIQQQgghxmRzGi93jNA6FKPWb58wCH7o1V52d45i0Ov45EVNBd93KKU4Nhqj2mtjc4Mfs1FW5YrCyU+LEItUPJ2l/vO/pf7zvyWezs7Y+yqlODoY4fEDgwxEktQXOU4bbCulePzgIF959DDRVJZav50vvmtVQcF2NJWlKxinpdTFRStKJdgWYgF5+umnueaaa6isrESn0/Hggw+e9LpSii996UtUVFRgs9m49NJLOXLkyPw09i0Gw6n5boIQYg5omuLVriD7+8JUeW0T1s5+9ugwv33jeEby8+pYNokp4b2hJD6bhfOainBaZLxSTI4E3EKIcalsjpfaR3jq0DCaUtT5HaedmpnJadz/fAf/uesYOaXYUu/nb69cXlC2zpFYmuFoinXVXt7RUiydlxALTCwWY+3atdx7772nfP1f/uVf+PrXv863v/1tXnzxRRwOB1dccQXJZHKOW/p2L7QFCMbT890MIcQs298X4tWuIKVO6xln4QEc6Avzo52dALzrnHzeh0IFoin0etja6KdogmRsQpyK3OUKIQAYjaXZ1TFC+3CUcpcNp/X0Hw8jsTTffPIoHYE4Oh28d0M1l68qO+O6KTg5Odq2piJWlrtlDZQQC9BVV13FVVdddcrXlFJ87Wtf4+///u+59tprAfjhD39IWVkZDz74IO9///vnsqlvMxxNsbMtwIXLSqTSgRBL1NHBKC91jOKxmc54vwLQG0zwzSdbxwcHrltXWfBxIskM0VSOHS1FkpFcTJmMcAtxllNK0TEc47EDg3QGYtT5HWfsvA71R/jH3+6nIxDHYTbw1+9cxhWryycMtrOaRsdIDLvZyEXLS1ld6ZFgW4hFqL29nf7+fi699NLxbR6Ph61bt7Jz5855bFlejd/GsUCcXe0jpLPafDdHCDHDukbivNgewGLU4ztDMleAUCLD1x8/QiKTo7nEyU076ie8XxmTSOcYiqZYXysZycX0yKNfIc5i6azG3p4Qr3UHMep1Z8zuqZTi0QMDPLC7G01Bjc/GJy9qLmjtdSqTozuYoMZvZ2uDTMkSYjHr7+8HoKys7KTtZWVl46+dSiqVIpV6c311OByelfYZdXqqvTYO9UewmQxsrvfLwz0hloiBcJKdrQGyOUWV13bGfZOZHN94/AjD0TSlLgu3XNw04TrvMZmcRm8owepKN+dWewoO0oU4FQm4hThLBePp8cyeJU4LbpvptPumMjl+sLOTXR0jAJzX6OeD59VhMZ55zRRAOJFhOJZiebmLLQ1+meIpxFnq7rvv5q677pqTY1lMBsrdVl7vCWEx6llb45UbZiEWuUA0xXNHh4mmMtRMUGs7pyn+/ek2Oo6X//r0O1twWU9/n3MiTVMcG4nTVOJgU70fY4FBuhCnIz9BQpxllFJ0BvJTyNuGY9T47GcMtgfCSf75dwfZ1TGCQafjf2yp5a92NBQUbA+EkwQTaTbX+dnRXCzBthBLQHl5OQADAwMnbR8YGBh/7VTuuOMOQqHQ+FdXV9esttNhMeK3m9lzLMjhgeisHksIMbtCiQzPHR0mEEtR7bOf8QGaUoofv9DJGz0hzAY9t17STLnbWtBxlFJ0Bd8sVzpRMjYhCiF3v0IsUjlNjf99V/sI57eUnDaj+JgTp5AbdDrqixzoz9Bp7Tk2yv3PdZDI5PDYTHzigsaCSn5pmqI7GMduNnLBslKaSk4/VV0Isbg0NDRQXl7OY489xrp164D89PAXX3yRm2+++bT/zmKxYLHM7XISj81ENqex6/h6z/pix5weXwgxfbFUlp2tw/SHk9T7z3zfAvDw6308c3QYnQ4+dkEjTSXOgo/VE0zgsZo5r6mo4BFxISYiAbcQi9Aje/u489f7xr//8P0vUeGxcuc1q7hyTcUp/81oLM3LnSO0FTCFPKcpfrmnm9/vz49gtZQ6+fgFjXgnSE4C+dJi3aMJKjxWtjYWUVbgU2UhxMIRjUY5evTo+Pft7e28+uqr+P1+amtrue222/inf/onWlpaaGho4Itf/CKVlZVcd91189fo0yhyWugPJXmhLYDFpKfCc+Z1n0KIhSOZybGzdZjOQJy6IvuE+RieOTLEQ6/1AvCBLbWsq/EWfKyBcBKzUc+25iKKJdeMmEEScAuxyDyyt4+bf7wH9Zbt/aEkN/94D9+6ccNJQbdSirbhGHs6RxmNp6n128+YNCQYT/Mfz7SNT8G8YlUZ79lQhVE/8QqUSDLDYCTFsjIXm+p98nRYiEXq5Zdf5uKLLx7//vbbbwfgQx/6EN///vf5m7/5G2KxGB/72McIBoO84x3v4JFHHsFqXZgP2Mo9VrpH4zx/NMAFy0oKSvYohJhfyUyOF9oCHB2KUee3T3gf8sqxUX74Qr7W9tVryrloeWnBxxqNp8lqine0FE+YjE2IyZKAW4hFJKcp7vrN/rcF2wAK0AF3/WY/l60qx6DXkczkeK0ryL7eMGaj/oxZyAEO9IX5j2faiCSzWE16btrewMY6X0FtG4wkSWY0Ntb5WFvjLTgTqBBi4bnoootQ6lSfNHk6nY5/+Id/4B/+4R/msFXTU+W1cWw0znNHh7loeUlBM3aEEPMjnc0vBTnUF6HGb5vwnuLwQIR/f7oNpeAdzcW8Z31VwceKJDOEExnOayya1PRzIQo1r3fEd999N5s3b8blclFaWsp1113HoUOH5rNJQixou9pH6AslT/u6AvpCSXa1jzAQTvL4gUFe7Qrid5gpd1tPG2xrSvGb13v5yh8PE0lmqfLa+Pt3rSoo2M5pimMjMXTouGBZMRvrfBJsCyHmlN1s5Nm/vZgvXL0Cy2mSHOl0Omp8doYiKZ4/GiCSzMxxK4UQhcjkNF7qGOFAX4Qqn23CJK1dI3G+8fhRsppiXbWXD55XN+la22trvKyscM9E84V4m3m9K37qqae45ZZbeOGFF3j00UfJZDJcfvnlxGKx+WyWEAvWYOT0wfaJ9hwb5bEDA/SFE9QV2XFaTj+ZJZLMcM9jR3jo1d7xJ8NfuHpFQRk9U5kcHYEYxU4Ll6wspbnUJcnRhBALll6no9Zvp2s0zvOtAeLp7Hw3SQhxgmxOY0/nKPt6QlR6bBNmCR+KpPjaY0dIZHK0lDr52AWNEyaQHZPK5o7X2vawrsY74fpwIaZqXqeUP/LIIyd9//3vf5/S0lJ2797NBRdcME+tEmLhKnUVtj6yNxin2OGlzn/mjLyHByL8x9NtBBMZzAY9H9hay47m4oKOEUpkCByvr72p3n/GoF4IIRYKg15Hnd9Ox3AMo17HjuZiKf0jxAKQ0xS7O0d5rTtImduKzXzm38tgPM3/ffQQoUSGKq+NWy9pxmwsbCwxm9PoGk2wojyfc0ZqbYvZtKDukEOhEAB+v3+eWyLEwrSlwU+Fx0p/KHnKddwALquR8+qLsJ0hANaU4r/f6OOh1/Kj2uUeK5+4oJFqn33CNiil6A8nySnF5no/51R5pKMSQiwqRoOeGp+do4NRDHod25qKJpy2KoSYPTlNsefY8WDbZcUxwUP8SDLDVx49zHA0TYnTwl9f2oLdXFhYk9MUnSNxGoodbGnwy+++mHULJuDWNI3bbruNHTt2sGbNmlPuk0qlSKVS49+Hw+G5ap4QC4JBr+POa1Zx84/3oINTBt0f2Fp7xmA7lMjwvWfb2d+X//3Z1ljEB7bWFjTCk81pdI8m8NhNbKr3U19klynkQohFyWzUU+2zcag/gl4H5zUWFzw6JoSYOTlN8cqxUV45NkppAcF2Ip3jnseO0BtK4rObuP2yZQUnQdRUPu9MldfGtqaigoN0IaZjwfQst9xyC3v37uVnP/vZafe5++678Xg84181NTVz2EIhFoYr11TwrRs3UOo+uayN12bi5gub2FR3+hki+3pD3PWbfezvC2M26Llpez1/9Y6GgoLteDpL50icar+Nd64so6H4zBnPhRBiobMYDVR5bRzoi/BSxwiZnDbfTRLirDIebHcFKXVaJ1yels5qfOOJI3QE4jgtRv760mUFl/lTStE1GqfYaWV7czFuKV0q5siCeKzzqU99iocffpinn36a6urq0+53xx13jNcChfwItwTd4mx0yYoyXBYjH/jeLgBuvbiJc6pOn/Ajq2k89Govj+ztRwGVXisfv6Cp4FqTw9EUsVSWc6s9rK/1yXpHIcSSYTUZqPTY2NsTQq+DzfV+WSYjxBwYm0b+yrEgJU4zTuuZw5JMTuObTx7l8EAUm8nAX1/aQuUkamZ3BxO4rSZ2NBfhd0hZQDF35jXgVkpx66238qtf/Yonn3yShoaGM+5vsViwWAp7iiXEUjUYSbKnc5QjA9HxbSvK3acNtociKb7zTBttw/ns/xcuK+H6TTUFTZ3MaYqeYByrycA7WkpoKXVKFk8hxJJjMxuo8Fh5oyeEXqdjY50kURJiNo1lI3+tO0ipa+KR7WxO49tPtbK3N4zZqOfTlzRTV3TmxLAn6gslsJkMbG8uprSAKixCzKR5DbhvueUW/vM//5OHHnoIl8tFf38/AB6PB5ut8CdWQpwNMjmNQ/1hXu8OkcjkqPFP/DvyYluAH794jEQmh81k4EPb68445fxEyUyOnmCCKq+NzQ1+yqSDEkIsYXazkXK3lde6gwASdAsxS7I5bTwbeSHBdk5TfOeZdl7rDmEy6Lj14mZaylwFH28okgIdbGsqKnhmnxAzaV4D7m9961sAXHTRRSdtv//++/nwhz889w0SYoEKRFO80hWkbSiK12amzm8llcmddv9kJsdPXjzGzrYAAE0lDj56fiPFzsJmiIzE0gQTGVZWuNhY558wgYkQQsy3rpE4Oe109RsKI0G3ELMrndV4uXOEvT0hyt3WCZOWaZrivufa2X1sFKNexy0XNbOywl3w8QLRFOmcxo7mokmNiAsxk+Z9SrkQ4vSyOY3DA1Fe7w4SSWap9tonnAreNhTlO8+2MxRJodPBu8+p4N3nVmIoYCq4pil6QwkMBh3bm/ysrPAU9O+EEGI+7esN8fEf7abCa+OvL23BqJ96kGw3GylzSdAtxExLZnLsag9woC9ChaewYPv+5zt4sX0Eg07HJy5sYk2Vp+DjjcbTxNM5tjcX01xa+Ii4EDNNhq2EWKDGRrXbh6K4rSYais/8ZDan5Wtr/+b1XjQFfruZj5zfwLICp12NTSEv91jZXO+fVCISIYSYT4ORFIlMjkP9Ef7j6TY+dkHjtIJuh8VIGfmgO6cUm+v9mCToFmLKEukcL7YHONQXocpnmzD56liwvbMtgF4HH72ggXU13oKPF0pkCCeynNfoZ1mZc5qtF2J6JOAWYoHJ5DSOnDCqXem1YTGeuWMajqb44QudtA7lE6Ntqfdz43m1BdeXzE8hT7O83MWmev+E66mEEGIhuXh5Kf/8nnP4/C/fYM+xIP/+dBsfP79xWiPTDouRcp2VN7pDaJpiS0OR1OkWYgpiqSw7W4dpHYpR7Z/4nuatwfbHLmgsOP8MQCSZYTSeZlOdj1WVbilhKuad3FULsYAMRVK81jVK23AMj9VEfZH9tB2FxWTgOx/cyHNHA/zz7w6SymrYTAY+sLWW8xqLCjqepil6QgmMBh3bm4pYUe6WqZNCiEVpW1MR791QxS/29PDKWNB9wfSCbrvZSJXXxr7eMJrKB91SFlGIwoXiGXa2DdMZiFPrt084U2S6wXY0mWU4lmZjrY9zq70SbIsFQQJuIRaAdDafgfyNnhCxdGFrtcOJDD98oZNXu4IAtJQ6+at3NBScGC2RztEbSlDhsbJJppALIZaAplInn7q4mX974iivdAX59lNtfPzCxmlNB7eaDFR5bRzojaAp2NpQhM0sQbcQExmOpnj+6DD94SR1RfYJl3nkjidIe7F9BL0OPn5BExvrfAUfL5rKMhhNsqHWx7oar5QxFQuGBNxCzLP+UJJXu0Y5FojjtZtpKJp4rdGrXUF+sLODSDKLQa/junWVXLGqvODOJRBNEUpmWFXpZkOtT7KQCyGWjDVVnvGg+9XuIP/2xFE+eVHThNNYz8RqMlDtt3GwP0I2p3FeU7EsvRHiDPpCCZ4/GmA0nqLe75jw/iSb0/iPZ9rYcyyIQafjYxc0TirYjqWyDEaSrKvxsb7WJ8G2WFCktxBiniQzOfb3htnXGyKd06gpYKpVIp3jZy8d47nWfLmvSq+Vj7yjkVq/vaBjZjWNnmACm8nA+S0lLCtzSRZyIcSSs6bKw2fe2cI3njjKvt4wX3/sKLde0jyt6eAWo4E6v53WoRjpnGJHczEem2kGWy3E0tAZiLGzNUAyk6PO75hwWncmp/GtJ1t5vSeEUZ/PRj6ZBGnxdJaBSJK11V421HrlvkYsOLJYU4g5ppTiWCDOH/b181L7CHazkTq/Y8Jg+0BfmDt/s4/nWgPogMtWlfHFd60qONiOprJ0BuJUeGxcuqqMlRVu6ZSEEEvWygo3f31pC1aTnkMDEb76x8PE09lpvafJoKeuyE7XaJynDg0SiKZmqLVCLH5KKQ72h3n68BCZnEa17/R5aMakMjm+/vgRXu8JYTboufWS5kkH2/2hJOdUeaSEn1iwZIRbiDkUSmTY2x3i0EAYg05PfbFjwqA3lcnxi1d6ePzgIAAlTgs37agvuNyXUoqBcIp0TmNdjZe1NV5J+iOEOCu0lLr4n5ct56t/PEzrUIz/7w+H+etLW3BZpz4ybdTrafA76ByN8dThIbY3FVPusc5gq4VYfLI5jTe6Q7zSFcRhNlBUQD6ZeDrL1x87ytGhKBajnk9f0sLy8sLrZY8H29UeNtX7JdgWC5b8ZAoxB7I5jUP9Ef6wr5+9vSGKnRaqfLYJg+3DAxH+12/2jwfbFy4r4c5rVhUcbKeyOdoDMawmAxctL2FLg1+CbSHEWaWh2MHnLl+Oy2rk2EicLz9yaNoj03q9jjq/g2A8w5OHBukMxGaoteJsEU9nqf/8b6n//G+nPfNiviUzOV5sH+GlzhF8dlNBwXYokeFff3+Io0NR7GYDt1+2bFrB9nQSIwox22SEW4hZNhBO8np3kPbhOE6LgcbiidczpTI5fvlKD48dD7R9dhMf2lbPmipPwccdjacZjadpLnGxoc6L126e1nkIIcRiVeO387dXruArjx6mP5zky48c4vbLlk1rZFqv01Hrt9MXSvD04SG2NGgsK3NKGSJxVgknM+xqC9A6GKPSaysog38gmuL/PnqYwUgKt9XIX1+2jBpfYcvjQIJtsfhIwC3ELImns+zvDXOgL0w6p1HttU1Y6gvgUH+E7+/sYCiSH4E5v7mYP99Ujd1c2K9rVtPoDSYwGfVsayxiRYVbOiMhxFmv3G3l81eu4Ct/PEx/KMmXf3+Q297ZQl2RY1rvW+GxMRxN8dzRYRLpLOdUS9ImcXYYDCd5oS1AXyhJbdHEiV8BeoMJvvrHw4zGMxQ5zNx+2TLK3IU/+Iql8gnSJNgWi4kE3ELMsJymaB+O8UZ3iMFIkmKnhYoCMtkmMzke2N3Nk4eHgKmNakeT+Y6o2mtjY71f1hUKIcQJ/A4zf3vFcr722BE6A3H+9Q+H+OSFzayqdE/rfYudFkKJDLs6Rolncmys802rDJkQC137cIwX2wPEUlkaiiYu+wVwZDDCNx4/Sjydo8Jj5fbLluGbxOy7aDJfZ3tttVcSpIlFRQJuIWbQYCTJG90h2odjWIz6gjuhvT0hfvhCJyOxNJBfq/3eDdUFTc0C0JSiP5QkpynW13g5VxKjCSHEKbmsJj572XLuffIoB/sj3PP4Ef5yRz1bG4qm9b4emwmTQccb3SHi6RxbG/zTSs4mxEKU0xT7e0P5etnHcxkU4tWuIP/+dCuZnKKx2MGtlzRP6vcjkswwFE2zvtbHhlqfzCIRi4oE3ELMgFgqy8H+CPv7QiQzOSrdNiwFBLyRZIafv9zFC20jQD4D+Ye217GivPDRlmQmR08wQYnLwoZaH3VFE5fhEEKIs5nNbOAz72zhvufaealjlO88004okeHyVeXTel+72Uit307rUJRkOsfWxiJKXBMnkBJiMUikc+zuHGF/Xxi/3Vxwbpinjwzxoxc6UQrOrfLw8QsaC7pHGhNOZAjEUmyq87O2RpZsiMVHAm4hpiGT0+gYjvF6d4jhaCo/fdxtm/DfKaXY1T7CT1/qIprKotPBO1eU8p51VQV3QkophqIp4ukcKytcrK/1yWiKEEIUyGTQ89HzG/HYuvjjgUH+38vdjMYy/PmmavTTeGhpMuip9zvoDsZ54uAgWxr81BdPb524EPMtEE3xYvsIXSNxqry2gmbRKaX49Wu9/Ob1PgB2NBXxwW11GPWFTwUPxtOEEhk21ftZW+0taNagEAuNBNxCTIFSit5Qkr09IToDcRxmAw3FjoJu0oYiKX6yq5O9PWEAqrw2PrS9jsZiZ8HHT2Xzo9oem5kLl/lpKnFKJySEEJOk1+m4flMNXpuZB/Z08+iBAQKxFH/1joZprcE26HXU+uz0h5M8dXiISDLDqkqPjMyJRUcpRUcgzssdIwQTaeqK7AUFzNmcxg92drKzLQDAu86p4Lp1lZOagReIpoilc2xp8LO60iP3OWLRkoBbiEkajaXZ3xvm6FCUnKZR47MVlCUzq2k8un+A37zWRzqnYdTrePe5FVy5unxSiT8C0RThZIamEicban34HFLuSwghpkqn03HlmnJ8DhP3P9fBnmNBRv9wmE9d3IyngISXZ3rfCo+NYDzNzrYRwoksG+t9kl9DLBrprMbenhCvdQUxGnTU+ycuawr5ZXbffLKVQwMR9Dq48bw6LmgpmdSxhyIpUrkc25qKWFHukqVyYlGTgFuIAiXSOQ71hznQFyGczFDmtuK0FPYr1DYU5YcvdNI9mgBgeZmLD55XN6ks4pmcRvdoHKfFxPbmYpaXuSRDpxBCzJCtDUX47GbufeIo7cMx7v7dAT59SQuV3omXCZ2J127GYjSwtzdEJJVhc72fIqes6xYLWyie4eXOEY4ORilxWnAX+PBpKJLinseP0B9KYjXp+cQFTZOqtgLQH0qiULyjuZjmUtdUmi/EgiIBtxATGFunvbcnzGA4ic9hprG48Ke8v3ylh6cPD6EAh9nA+zbVsL2paFJPa0diaYLxNA0lDtbX+iiWmzUhhJhxy8pc3HH1Su557AhDkRR3/+4gH7+gcdIBw1vZzAbq/Ha6RxKEE4NsbvBTLwkuxQJ1LBDn5c4RhqMpanx2zMbCHu4fHojwzSdbiaay+OwmPn1JCzV+e8HHVUrRE0xgNurZ1lRCg+Q+EEuEBNxCnIamKbpHE+ztDdE9GsduNubXaRewhkgpxQvtI/y/l7uIJLMAbGss4n2bqieV2CyT0+gJ5o+9ramIFRXugqavCyGEmJpyt5UvXLWCe59o5ehQlHseP8L1m2p454rSaQXIRoOeuiI7A+EUTx4cZF2NlzXVHvlMFwvG2BTy13uC6NBRX1RYbhqAZ44M8eMXj5HTFHVFdj51cfOkamxrStE1Gsdtzc/iq5rmzBIhFhIJuIU4hYFwkgN9YdqGYuiAGp+94Jui3mCC/9x1jIP9EQDKPVZu3Fo7qVJf8Oaodl2xg/W1XkpdhU8/F0IIMXUuq4n/efkyfvRCJ8+3BvjZS130BhP8j621k8qw/FY6nY5yj5VwIsOujhFG4mk21fnx2KXChJhfI7E0L3eM0D4cm9QUck1TPLCnmz/sHwBgU52Pm3bUTyrpYE5TdI3EKXZZ2N5cJPc7YsmRgFuIE4zE0hzsD3N0IEo6l6PcXVjpC8jXw/7Na7388cAgOaUwGXS8+9xKrlhVNqm11pmcRncwjkNGtYUQYt6YDHpu2l5PldfGA7u7efrIMP3hJJ+4oKngYOR03DYTVpOBo0NRgvEMG+p8MsVczAtNU7QORdl9bJRoIkutv/ABhmgqy3eeaWNfb77qyjXnVnDN2spJldXL5DSOHS81tqO5WBLBiiVJAm4hgHAyw5H+CIcGIkRTWUqdVpzWwqYzKaV4qWOU/9rdxWg8A8C6Gi/Xb6qhxDW5tdaBaIpQMkNDsYO1NTKqLYQQhdLpdOjQkczkZiwTuE6n44rV5VR4rPzHM20cHojyj7/dzy0XNU+7trbZqKehyMFAOMmTBwc5p9rDOdWeaZUjE2IyIskMrxwb5fBAFLvZQN0kHvp0j8a594lWhqIpzAY9H95ez5YG/6SOn8zkS5w2ljg4r7FoUkvuhFhMJOAWZ7VYKkvrUJT9fWFC8QxFDvOk6mF3jcb56a5jHB6IAlDitHDDlhrOrfZOqh2pTI7eUBKnxciO5mKWlblkVFsIISah2GlmRYWLA31hih2FT4ktxLnVXv7u6pXc+0Qr/eEk/+eRg3zwvDp2NBdP6331x0uHRZIZdneOMhxNsaHOJw9bxaxSStEZiLPn2ChDkRSVHhs2c+EPel7uHOH+5zpIZTWKnWY+eVEztZNIjgb5+6/+cJIVFS62NhRJuTyxpEnALc5KyUyOtqEY+3vDBGIpvDZTwZnHId9RPPRqL08cHkQpMBl0XL2mgivXlE8qUFZKMRRNEUvnaCpxsrbGI+VihBBiCixGA9sai3CajbzSFSSV1SY9y+hMKjw2vnD1Cu57toNXu4Pc/3wHHYEY79tUM+0HpC6rCZvJQE8wwUgszdoar5R+FLMimsryRneQA31hjHp9Phlsgfc+OU3xy1e6+f2+/HrtFeUuPn5B46RHpkOJDIFYinU1XjbU+WSAQSx5EnCLs0oyk6N9OMaBvjBDkRRuq2nSnc3Th4d46LVeoql89vGNdT7et7F60oFyIp2jN5TA7zBz4TI/TSVODAVkQBdCCHFqRoOedbVeXDYju9pH6B6NU+m1TWpN6ZnYzUY+eXETD7/ex69f6+WJQ0O0D8e4+cKmaT8sNRr01PkdBKIpnjs6zEAoxYY6L95JZHoW4nQ0TdE5EufVY0EGI0nK3FaclsLDgGA8Pb6sAuCyVWW8d0P1pO9bBiNJUhmNrQ1FnFPlKajyixCLnQTc4qyQzOToDMTZ3xtmMJKfut1QVFiJrzEH+sL87KUueoIJACq9Vm7YXMvKisllH9c0RX84SSanWFnhYm2ND88MTn0UQoizmU6no7nUhd1s5MW2EToCsUlVmpiIXqfjT9ZWUl9k57vPttMRiHPXw/v5yDsaJr2c6FSKnBacViNHhyIMRfOjgM2l8kBWTF04meGNrhCHBiIY9bpJDTQAHOqP8O9PtxJOZrGa8uu1N9VNbr22UoruYAKLUc/5y0poKil8VqEQi50E3GJJOzHQHookcViM1Bc5JnXj0h9O8sDubl7tCgLgMBu4dl0VFy4rmfQNUCSZYTCSosxtZW2Nlzq/XZ7uCiHELKj02rhkRSm7OgK0Dcao8Fqxm2futufcai93vnsV33qqlY5AnK8/fpSr15TzJ+sqp1U6DPLT4xuKHAxH0zx9ZIie0QTrar34JYOzmIRsTqNtOMZrXUFGY2nKPZP7HdA0xe/29fPQqz1oCqq8Nm6+qIly9+RyDOQ0xbGRGH6HhfOaiqTGtjjrSMAtlqRkJkdHIMaB3sh4oF1bZJ/UTVA0leXh13t54uAQOaXQ6+Ci5aX8ydrKSU3DgnzZi75QAqNez4Y6H6sr3TN64yeEEOLtPHYT57eU4LQY2dsTwmMzz2jQWuS08LdXruD/vdzFE4eG+O+9/RwaiPCx8xunPcVcp9NR4rLgzuRHuwcjSc6t9tJS5pQ1r2JCg5Ekr3cFaRuO47QYqJ/kqHYwnuZ7z7ZzoD8CwLbGIm7cWotlksnNUtkc3aMJanx2zmsqkodG4qwkd/xiSYmns7QPxTjYH2E4msJpMVI3yRHtTE7jiUODPPx6H/F0DoBzqzy8d2M1lZN8KquUYiSWJpTMUOu3s7bGS4VHnuwKIcRcsZoMbG0owm0zsadzdMbXdZsMej6wtY7lZS5+sLOT1qEYdz28nw9tq2djnW/a728x5Ue7A7E0zx4d4thITPoScVrxdJaDfRH294VIZnJUe+2YjZN7QLO3J8T3nmsnksxiNur5wNZadjRNPiN/NJllIJJkebmLzfV+HJMcrBBiqZCffLEkhJMZOoZjHOqPMBJL47aaJj11XFOKlzpG+NUrPQxH0wBU+2y8b2MNqyont04b8knR+sIJ3DYTO5qLaSl1TbrTE0IIMX16vY7VlR68djO72kZoH86v657Jz+RN9X7qihx855k22oZjfOupVi5cVsL7NlZPelTwrXQ6HcVOCx6biZ5ggsFwipWVblZVuCWIEUB++nj7cIw3ekIMRVIUOy2Uuyf3UCaT0/jlnh4ePZDPQl7ts/HxCxqn9HAnEE0RTWXZUOdjXY1XZmWIs5p8SotFbSSWpm0oytHBKKFEBo9tclnHxxzsD/PA7m46AnEAPDYT162rZEdT8aTXWGc1jYFQipxSrCh3cW61ZJkVQoiFoMpr45KVpbzUMULrYJRSl2XSJY3OpMRl4W+uXM6Dr/TyyL5+njo8xMG+MH91fgONxc5pv7/peCbzsbrdxwJxzq32UF/skIDmLKWUojeUZG9PiGMjcezHZ0RM9t6lazTOd59pH08Me/HyEv58Y82kH0ppStEXTKI3wI6WYpaVuiRXjTjrScAtFh2lFIORFK1DUdqGosRSOfwO86TqaI85NhLnl3u62dsbBsBi1HPVmnIuW1k2pRGJ0XiakViaCk8+KVqNT5KiCSHEQuKxmbigpQSvzcQbPSFi6RxlLsuMZUw26vW8d2M1qyvd3PdcOwORFP/ndwe55txKrj6nYkayjbusJhwWI0ORFE8cGqJuOMaaKg+VHqtkfj6LDEdT7O8N0ToUQ1OKKo9tSgHyHw8M8Ms9PWQ1hctq5Kbt9VPKuJ/JaXSNxil2WtjS4KfaZ5/0ewixFEnALRaNbE6jN5jkyGCErtE4mayiyGGe9JQpgKFIigdf7eHF9hEADDodFywr5t3nVk6pRFcyk6+p7bQY2drgZ0WFG+s0pxAKIYSYHWajno11PnwOM7s7RukMxKny2WZ0lHhlhZv/dc1qfvxiJy91jPLQa7283hPipu31k84Hcip6nY4yt5VMTqNnNE5fKEFLiYsVFa5pJ2wTC1s4meFwf4RDAxFiqSzl7qll4B+MJLn/uQ6ODOZra6+t9vChbfW4p3AfFE9n6QsmqS9xsLXBLzP7hDiBBNxiwUukc3SNxjncH2EgnMxnbnVasJmnNgL98Ot9PHtkmJxSAGyp93PtukrKJlnmAo5PHw+nyOYUy8pcnFPlkRsdIYRYBHQ6HU0lTrw2Ey93jtIxHKPMZcVpnblbI4fFyMfOb2Rt9Qg/efEY7cMx/uHh/Vy7rpIrVpXPyAwok0FPrd9BNJVlX1+IjpEYy8tcLC93zeh0eTH/oqksRwYiHOqPEEpkKHZaKHNN/t5FU4onDw3xwJ5u0lkNi1HP+zbVcEFL8ZRmSASiKSKpLOfWeFhf65MBByHeQgJuMW3xdJZVX/o9APv/4YoZK3c1GkvTEYjROhhjJJbCajJQ6Z3aCEQkmeGRvf08fmiQTC4faK+ucPOnG6qoK3JM+v2UUozGM4zG89PHz632Uis1tYUQYtEpclq4cFkJPruZvT0hoqksZe6Zm2Ku0+k4r7GI5eUufrizkzd6QvxiTw+vHAvy4Rka7QZwWow4LU5Cifz67tahGKsqXDSWOCWx2gKU09T433e1j3B+S8lplxvEUlnahqIc6IswGk/js09tGR3kR7V/uLOTg8fLfS0vc/Hh7fWUuCY/WKBpip5QApNBx/amYlaUy3ptIU5FPoHFgpLNafSHk7QNRTk2EieWyuG15TOOT+VDPJrK8of9/Tx2YJBUVgOgpdTJe9ZXsazMNaU2xlJZ+sNJ3FYT25uKaClzydNcIYRYxKwmA5vrfRQ7zezpDNIeiE2pnNKZ+OxmPn1JM8+1Bvj5S120HR/tvvqcCq5aUz5j09k9NhNuq5GRWJrnjwY42B9h5fHAe6YeiIvpeWRvH3f+et/49x++/yUqPFbuvGYVV66pGN8eSWZoH45xsC/CaCyN1z61xLCQD/D/sL+fX7/WSyanMBv1vHdDNRctL5nS+6UyObqDCco9VjbX+2fswZEQS5F88ooFIZrK0jOa4MhAhMFICoXCb5/a+mzIj7o/un+APx4YJJHJ19Ku9dt5z/oq1lS6p/RUOHP8YQDA6ko3a6o8skZJCCGWCJ1OR2OJE7/DzMudo7QNRvE7zDP6Oa/T6XhHczGrKtz8+MVOXu8O8evXenmpY4S/2FZHS+nUHgSf6jhFTgs+h5lANM1zRwMc7IuyosJJfbETp4x4z5tH9vZx84/3oN6yvT+U5OYf7+FbN27gvMYi2odiHBrITx332kw0lEwt0AboCMT4wfMddI3mM5CvLHfxwW11lE5hOjpAMJ5mJJ5mebmLjXU+WbogxATkE1fMG03LZxvvDMRoH44RSmawmwyUu61THlWIpbL88cDJgXa1z8a1aytZV+OdUqCtKcVQJEU8naXGb2dNlYcqr00ywQohxBLktZu5cFkJxQ4zb/SEiIzGqfTYZiS7+Bi/w8ytFzfzcucoP911jL5Qki8/cogLWor50/XVM7aOXK/TUeKyUOQ8HngfCbCvN8KyUicNJQ55aDzHcprirt/sf1uwDYxv+7tf7eW2y1qIp3LTmjoO+cGHB1/t5YlDgygFdrOB6zfVsL2paMr3Q33BJDpdPv/N6iqPlKMTogAScIs5F0lm6AslOToYZSCUJKsUPpspXzdyip1K9Hig/dgJgXalx8qfrK1kQ51vyu8bjKcJxNIUOy1sbvDTILVOhRBiyTMZ9Kyr9VHqtrKnc5SOQIwyt3VGR4Z1Oh2b6/2sqnDzX7u7efboME8fGWZ35yh/tqGad7QUT7nveqsTA+9gPMOujhEO9IdpLHHSUOygxGmRtbdzYFf7CH2h5Bn3CcTS9I0mWV87tUECyOeZeaF9hP96uYtwMgvkA+T3b66ZUgZyOD6FPJSg1GllU72PGr+U/BKiUBJwizmRyWkMhJMcG4lzLBAnlMxgMxoocVmmtf45lMjw6P4Bnjj05hrtKq+Na86tmFagHUtlGYgkcVqMbKn3s7zCJWvfhBDiLFPpteGzm3m9O8j+vjCRZIYyt3XGAmHIZzL/8PZ6tjcV8ZMXj9ETTPDDFzp55ugwN2ypobHYOWPH0ut0+B1mfHYT4WSW17uDHOwPU+W10Vzqoso7+TrOonCDkTMH22MymjblYLtrJM5PXzrG4YF8qa9yt5X/saWWVZXuKb0fwEgsTTCRZnmZTCEXYiokghCzRimVf1IbTNA6FGMklianNPx2y7RGsyH/4f/Ivn6eOTI0nnW8xmfj3edWsr7WO+X3TmVzDIST6PU6Vla4WVXhljJfQghxFrOZDWxp8FPqtvLKsVHah2NUeKZW9/hMlpW5+NK7V/HEoUEefLWH9uEY//zfB9nWWMSfbqjCN8NryT02Ex6biUQ6R/dIgvbhGMVOC82lTqq8NvwOsyydmmE+e2GBqmcKo9DhRIYHX+3hmSPDKMBs0PPucyu4bFXZlGfmZTWN3mACs1HP9qYiVpS7McosPyEmTQJuMePCyQz9oSQdgRj9wSTJbA6nxUiFxzrt6di9wQSP7OvnxbaR8TrajcUO3nVuBedWeaZ8c5DVNAbDKdI5jboiO6sqPVR6rHKzIYQQpxGJRPjiF7/Ir371KwYHB1m/fj333HMPmzdvnu+mzTidTkdDsYNip5nXuoIc6o9iMWYpdVtmdLTboNdx6coyNtX5+MWeHna2BdjZFmD3sVGuWl3O5avLsBhntiqGzWygxm8nm9MYjWd4oS2AzWSgymunrtg+Kw8XziY5TTEcTdE7mmAgnMJlNRI5Ps37VHx2E8smkTwvk9N4/OAgD7/eN76kblOdjz/fWD2tAYNoMj/Tr8ZnZ0Odj3LP1BKsCSEk4BYz7JnDQwRiaSKpLFaDAZ/DhN08/VIRrUNRHtnbzytdwfFty8tcvPvcClaUu6YcGGsq3xFGk1nKPVZWV3mo89vlCa4QQkzgIx/5CHv37uVHP/oRlZWV/PjHP+bSSy9l//79VFVVzXfzZoXLamJ7UzEVXhuvHgvO2mi3127mr97RwCUrSvnZS8doHYrx0Gu9PHl4iGvXVrKjuXhGk7gBGA16SlwWSlwWYqksnYEYR4ciuG0mav12anz2aS8DO1toWn6GX38oP3MgEEuTySncViP/Y0sN//50+2n/7fs31xa0nl7TFC+0B3jw1V5GYmkgX43l/Ztrplz2FPL3Rf2hJFlNY12Nl7U1Xvl/LsQ06ZRSp0qWuCiEw2E8Hg+hUAi3e+prU8TUJNL56ddHBiN89Ie7Afj8lSsodVlwWY3THh3WlOK1riC/3zfA0aH8WiQdsK7Wy1Wry2ksmfq6NqUUo/EMo/E0RQ4Lq6vcNBQ7pFMRQsypxdqPJRIJXC4XDz30EO9617vGt2/cuJGrrrqKf/qnf5rwPRbruY8JJzO83hXk8EAUo15Huds6K4nHlFK81DHKL1/pZjiaD6zK3Vbes76KDdNIrFUITVOEkxlCyQwocNtM1Pjzo96lLis2s/SZYzI5jUA0zUA4QWcgzmg8Qyqbw2E24rWZsJxwf7H7eHb6YCIzvs1nN/H+zbVsrPOd8ThKKd7oCfHLV3roPl7my2c3ce26KrY3FU1rxkU8naUvlKTEZWF9rY/6IrvM9BPiDArtx2SEW0xKLJVlMJKiezROTzBBJJklm9PGX6/x2U7qVKYilc2xszXAowcGGAinADDqdWxt8HPF6nIqvdMbMQ8nMgxFU7itJrY0+FlW5sIhNUmFEKJg2WyWXC6H1XryNFObzcazzz47T62aW+7jo91VPjuvdQVpD8SOP3Ce2YRSOp2OLQ1+1td6eerwEA+/3kd/OMm3nmqlrsjOn6ytnNaSqjPR63V47fla5FlNI5zIsq83xOvdQdw2ExUeK5UeG0VOC16b6azKdK6UIpzMMhJLMxhO0j2aIJhIk9PAYTZQ5DCf9iH+xjofq8pd3PrzVwH4zCXNrK70nPH6KaU40Bfhodd6aB2KAWAzGbj6nHIuWVE6raUGSuXLtCYzOVZXullb45XEaELMIIkyxBkppQgnsgxF851JfyhJJJlBr9fhsZqo9dlPCrinIxhP8/ihQZ46NEQsnV+HZDMZuGh5Ce9cUTrteqFjmcdtZgPra7wsL3fjKTCBiRBCiDe5XC62bdvGP/7jP7Jy5UrKysr46U9/ys6dO2lubj7lv0mlUqRSqfHvw+HwXDV31uj1+bXdpS4Le3tCHOyPMBrPUOmxzvjSJJNBz6Ury9jRVMzv9/fz6P4BOgNxvvH4UeqL7Fy7roo1le5ZG5E06vX4HWb8DjM5TRFJZmgdjHGwP4LdZMBjM1Htsx/Pgm7GZTUuqQBcKUUklSUYyzASS9EbSjIaTxNLZdHrdLgsRio9toJz1Zx4bZaVuU57rZRSHBqI8NCrvRwZzM/2Mxl0XLy8lKvPqZh2qbpEOkdvOEGR3cLWxiIaix1L6v+bEAuBBNzibbI5jZFYmuFomq6RGEPRFLFUDpNBj8dmou4tGcazuekdr304xmMHB3ipY5Scll/hUOw0884VZZzfUjztad6JdI6BSAKTwcCqCjcrKtwUS+ZxIYSYlh/96Ef85V/+JVVVVRgMBjZs2MANN9zA7t27T7n/3XffzV133TXHrZwbDouRLQ1+qv350e7OkThem2lWMn3bzAauW1fFO1eU8vt9Azx+aJCOQJx7HjtCXZGdq9dUTKtaRyEMJ4x8Q76fDScz7O4cQR1vo8dqotxjw+8w4baacNtMi2rZVjKTP6dwIstoPM1AKEkomSGWyic8s5uMOK3GfA3zWbjWSile6w7xu7194yPaRr2OC5eVcNWa8mkPQmhKMRBOks4qVpa7WFvjm1J2dCHExCTgFgBEkpn8tKhIimMjccKJDOmshs1kwG0zUeaa2Yzd2ZzG7mOjPHZgkLbh2Pj2llInl64sY32Nd9pPWFOZHAORJDp0NJe6WFHupsxtkfVIQggxA5qamnjqqaeIxWKEw2EqKiq4/vrraWxsPOX+d9xxB7fffvv49+FwmJqamrlq7qzT6XRUeW2UOC0cHgiztydMeyBGhds2K2udXVYT791YzeWrynhkXz9PHhqiMxDnW0+1Uu62cuWacs5r8M9JElCb2TB+jppSJNI5IsksQ5EgWU1hNuixWQy4LSaKnWbcdhNOixGH2YjNbMBi1M9L36yUIpXViKdzxNNZoqks4XiG4WiacCpDIpUjo2nodTpsJgMO8+wF2GOymsbujlH+e28/PcH8Gm2jXsf5LcVctaYCv2P65eGiqSyDkSTFTgs7mr3UF8mothCzSQLus1Qyk2M0niYQTdMzGicQSxNN5dDpFC6LiVKXZcZLj0C+fvbTR4Z45sgwoePJQox6HZvr/bxzRSn1xY5pHyOVzTEYSaFUPmPnykoPFbOUzEYIIc52DocDh8PB6Ogov//97/mXf/mXU+5nsViwWJb+7CKzUc+aKi9VXjtv9AQ5OhhDr4NyjxWjfuaDX7fNxPs21XDVmnIeOzDI44cG6Q8n+f7zHfzqlR4uXl7ChctK5mxNrl6nw2ExnpQbJZPLB7Uj8TS9oQSaUuh1OswGPWaTHqvRgO94EG4zGzEb9ViMesxGPUa9DpNRj0mvR68Hg06HXqc7ZZ+uaYqcUuQ0haYUWU2RyWpkcopMTiOV1UhmciQyOSLHR6+TmRyprEY6p4ECnS6/nM1qMuDxmKZdzrRQsVSWp48M8fjBQUbj+fsji1HPxctLuWxV2YyMPmc1jb5gEnSwpsrDudXeaU9JF0JMTH7LzhLJTI7g8azc/aEkg5EU0VSGXE5hNRlwWY0UT/Gpraa9mej+8EDkbYk/NKU42BfhycODvNoVZGx3j83ERctKuGBZyYx0JOmsxkA4iaYU1X47qyrcVHltEmgLIcQs+P3vf49SiuXLl3P06FE+97nPsWLFCm666ab5btqC4HOYeUdzCfVFTl7vDtIZmL1p5pAf8b5ufRVXrC7n6SNDPLp/gGAiw4Ov9vLbN/o4r6GIS1aUUuO3z/ixJ5JfkqY/qa/XlCKdzQfBiXSOUDxDOqeRv0XI/9eg12HU6zHo82vIdTodeh3ku3UdY88vlMp/gSKn8u+tNMgqjZymxr906ACFTqfDZNBjNuQDe5fFiMmon9WR6zP5+ctdvNg+Qiqbz4njshp554pSLl5eOmNJXUdiaUbjaaq9Ns6t8VLts8mMPyHmiATcS5BSilg6RyiRIXg8wB6OpomlMuNTu5wWI1Ue27Snmo2Vthhzz+NHx0tbtJQ6ea51mKePDDMUeTNRzvIyFxcvL2FdrXdGnvansxoDkSSapqjy2VhZ4abaZ5/xGqVCCCHeFAqFuOOOO+ju7sbv9/Nnf/Zn/O///b8xmWQd6Bi9XkdtkZ0yj4WjA1H29oZpG56dbOZjbGYDV6wu550rS9ndMcqjBwboCMR55ugwzxwdprHYwYXLS9hc58dsnJvR21PR63RYj48kn4pSb45Wj31p6vh2DZTS4C05ZMYCcoNej94ABr3heMCuW1D3BJmcxssdI+PfP31kGIAqr43LV5WxpcE/YyPriXSOvnACp8XItqYilpW5FtVaeiGWAqnDvQSksjnCiSzhZIZgLE1/OEkokSGRzpHTFBajAYfFgMNinNGpUbs7R/nWU62nfV2vY3w022YycF6jn4uWl1I1zbJeY94aaK8od1Ptm/5DBCGEmCtncz92Np57KJHhYF+YwwMRktkcFW7brAc/SimODkZ57OAgr3QFx5OT2s0Gtjb42dFUTJ3UW54TXSNxnmsd5oW2EaLHk68BrK32cOnKMlaUu2bs/0NW0xgIpcgpRWOJg3OqPBRJwlghZpTU4V6ixrJmRpPZ4/Wk04zG0sQzWdJZhU6nsJuM2M0GihyWWXuiq2mKn7107Mz7KKgvsnPRslI21/umXZ97TCqTX6OtqTdHtKu8EmgLIYRY2Dw2E1sbi2godrCvN0z7cAwd+fXds7VWWKfT0VLmoqXMRSiR4bmjwzx1eIhALM0Th4Z44tAQlR4r25uK2dLgn5GkXOJNwXialzpGeb51mK7RxPh2j800nsvmY+c3ztg9klKKkViaYCJDldfGOdUeanx2WV4nxDySgHuBSmZyxNM5Yql81sxQIkMgmiKSzJJI58hoCh350Wu72UCJc3aSnJ3O4cHIeFKPM3nvxmpWlM/MyEXyeKANHB/RdkmgLYQQYtEpdVspdlpoKnGyvy/EsZE4VqOBUrdlVhKrjfHYTFx9TgVXri7nQH+Y51sD7Dk2Sm8oyQN7unlgTzfNJU62NPjZWCdloqYqksyw51iQlzpGONQfYWwqqVGvY22Nlx1NRTSXOPn0z1+d0ePmB2JSeO1mdjQX0Vwq08eFWAgk4J4nY6UoEukc8UyORDr/FUqkGY1niKWzpDIa6WwORT4rp3Uesma+laYUhwci/Oa1voL2H3t6Ox3xdJahaAod+azjy8vdVHptC2o9lhBCCDEZY+u7K71WOkfi7OsJcSwQx2HJJzGdzT5Or9exutLD6koP8XSWlztG2dkW4OhglKND+a+f7jpGU4mTdTVe1td6KXNbZ609S8FQJMWrXUFe7QpyZDDCCflkaSpxsLWhiC31fpzW/K13KpM7zTtNXiKdYyCcxGLWs77Gy4pKN+45ykovhJiYBNwzTClFJqdI5zTS2Te/Utl82YnY8dHqaCr75us5De34UnqTXo/FpMdiNOBy5EtjLIR1VT3BBC+2BXihfYSRWLrgfzedp+PRZJbhaAqTUU9TiZOWMpeU9xJCCLGkGA35Pq7aZ6NjOM7+3jAdgRhOy/Gaz7Pc59nNRi44XjFkNJ7m5Y5RXuoYoW04Nh58P7CnmwqPlTWVHlZXullW5prXhGsLQSancXQwyt6eEHt7w+M1s8fU+u1srvexpd4/a2unU5kcA5EkOnQ0lzlZVemm1CUPRoRYaCTgPoGmKYZjKTQNFCpfZuL4dk3ls2OOZcrMavlSE5msRuJ4DcexWo6ZnCKn5f8c2y9fiCI/Um025ktRjGULN89jKYozCURT7OoY4cX2EbpPWHdkMxnYWOvlte4QkROSfryVz25iWalrUsdUShFOZgnEUthMBpZXuGgpdVHmtiyIBw9CCCHEbLAYDSwvd1FXZKd9OMaBvjDtxwPv2R7xHuOzm7lsVRmXrSpjJJbm1a4gr3SNcrg/Sl8oSV8oyaMHBjDqdbSUOVle5mJ5mYv6Yse8zbybK1lNozMQ5/BAhEMDEQ4PREkfL+MF+USxLaUu1td6WVfjpXgWE5Rlchr94SSaBrVFdlZVemRAQogFTALuEwzHUjx+cJBYKgvHg+180J0PmOHEDzJ1fItuvNxEvl6kDqNBj8VoxHT874tp6vNILM3uzlFe7hyhdSg2vt2g13FOpYfzGv2srfFiMugnzFL+/s21BX/4a0oxejzJh8tqZG21l8YSJyUuyagphBDi7GE1GVhZ4aa+yEFHIB94dwZi2M1Gil3mWV3jfSK/w8wlK0q5ZEUp8XSW/b1h9vaG2dcbYjSe4UBfhAN9EQBMBh0NxQ4ai500FDtoKHbgs5sW9YPyUCJD21CU9uEYbcMx2odj43Wyx3hsJlZXullT6WFVhXt8uvhsSWc1BiNJspqi0mtjdaWUQRViMZCA+wRKQSyVpdLz5vpgHSzqDqMQgWiKPceC7O4c5ehQdHy7Dlhe7sonT6n14bCc/OOysc7HzRc28dNdxwiesFZ7rA73xjrfhMfOahqBaJpoKovXbmZLg5/GYiceu6w9EkIIcfaymfOBd0Oxg2MjcQ70hTk2ksBi0FPsMs9polS72cimej+b6v0opegLJTnQF+bwYJTDAxEiySyHB6IcHnjzHsJjM1HttVHts1Hts1PltVHqtiy4JF6pbD4ha28wQddIgu5gnO6RxEn3NWMcZgPLylwsK3OxotxFtc82J/eIbw20V1a4qZEyqEIsGhJwn4Jep1uQU7xnUl8owSvHguw5NkpHID6+XQc0lzrZXO9nQ60Xr/3M5UE21vlYVe7i1uOZNj9zSTOrKz0TjmynsjmGo2lS2RylLisb6nzU+u1vC+qFEEKIs5nVlA/y6orsdI8mONQfoT+UBBTFTgt289z2mzqdjkqvjUqvjXeuLEMpxUA4xZHBCB2BOG1DUXqCCUKJDKFEhn194ZP+vddmotRtodRlxe8w47eb8TlM+OxmXFYjDrNxxqZGa0oRS2WJJPP5c0Zi6fGvoWiKgXDytBVXdECl1zY+Yt9U4qDSa5vT+8Ox6ixKQYXXKoG2EIuURDdnCU1TtAdivHIsn0GzP5wcf00HtJQ52VDrY2OdD98EQfZbndgxLitznbGjjKby67N16KjwWmkpdVHjt83pk3ohhBBisbEYDTSVOKkvctAbTHBkIErXaJyBcBKf3YzbZpqXwQKdTke5x0q5x8r5LfltqWyO7tEEPaMJukfzo8a9wSTRVJZgIkMwkTlpNPyk9wMcFiMOiwGL0YDVpMdqNIznuzHodeh1+eOO5dXJKUUmp5HKaCSzufHSqtFUFqVOeZiTOMwGyj1Wanz28RH5ap9t3kbjo8ksw7EkBr2e2iI7y0pdVPmkOosQi5UE3EtYIp1jX1+I17tDvNETIpJ8M8GZQa9jRbmLDbU+1tV4Z7XWpqYUwXiG0Xgauzl/w9Bc6qTCI52HEEIIMRkGvY4afz4gHIqm6AzEaR3MrzV2WIwUOczznsBs7OFAU4nzpO2xVJaBSJKBcIrhSCo/2hxPj+dwiafzpVCjqSzRMyRlnSy72YDbasqPqDvMFDnM+J1myt1WylzWWV97XYiT7pUs+VkNLWUuylySDE2IxW7+P2HEjFFK0R1M5EtU9IQ5Ohgld8KjXZvJwDlVHtbVeDmnyoPNPLtPbjM5jUAsTSyVxWM3sbHOR32xgyKHecmvixdCCCFmk06no9RlpdRlZUW5i66RBEcHI/QGk6BT+Gz5KdoLqb91WIw0Wpw0FjtP+XpW04ilckSSGWKp3HhJ1WQmRzqroSmOV43JV5LJj3a/mbTWajo+Im4yYDMZcFmNOK3GOUs0N1X94fz6bJ/dzJZ6P7VF9lkrJSaEmHsScC9y4USGA31h9vWFOdAXfttapHK3lXOrPZxb7aG51DknnU4slSUQS6MpRYnLwsY6HzV+O05Zny2EEELMOJfVxKpKE8vKnPSFknQEYnSNxBkaTmE3G/DbzVgWWLKyUzHq9Xhs+lmddbcQaEoRSp6QbNZhYnWllxq/bc7X5AshZp/8Vi8yiXSOI4MRDvRHONgXpuuE+tgAZoOe5eUuzqnysLrSTZnbOqftaxuO4bGZqC9y0FSaTzAy31PbhBBCiLOB0aCnxm+nxm8nFM/QG0rQNhRlMJwiq2m4rSY8NpMk3ZoniXSOkXiaZDaH1fDmA5DLVpXjsi7thwxCnM0k4F7g4uksRwejx8ttROgIxNDekgCkxmdjVaWbVRVulpW55jTATWVy9IXeTMC2vtbL8nI3xU6ZNi6EEELMF4/dhMduYlmZi+Foiu7RBB3DMbqDCRQKj9WMx2Yim9O45aevAHDvDesXxUj4YpLOagQTaSKpLFajgVK3haYSJx6bkTt/sw9A8tkIscRJwL3AjMbTHB2McmQwytHBfAbSt2bYLHFZWFnuYnm5i5XlbtxzPPVKU4pwIkMwnkGvhyLXm1nNN9T5ZDqUEEIIsUAY9DrK3FbK3FbWVLkZDOdrTncG4nSNxkllc/PdxCUnk9MIxjNEUxkMeh1+h4XVlW4qvDaKHRb0eh3x9MwlhRNCLGwSGR0XT2fZ+s+PAfD196+bk6Axk9M4NhKnbShG23CUtqEYgVj6bfuVuizHs1U6WVHmmrdEGumsRiCWIp7O4bGZWF3lpq7IgWsBZPcUQgghxJlZjIbxKedra7wMhlN0DL9Znqs9EMuXGLOaZj2x6lKTzOQIJTLE0jmMevDYzWwq91PutVLitMg0fiHOYhIpzZFsTqM3mKRjJEZnIE5HIEb3aILcW+aH63RQ47PTfLx0VkuZc9J1sWfSiaPZOj2UuaxsbnBS5bWNrzeSp7RCCCHE4mI1GagtslN8wiy1jXU+hiIpRuNpekM5TAZ9PtO3xSj5WN4iq2lEk1kiySxpTcNqNOB3mDmn2kOpy0qRc/7LswkhFgYJuGdBNJWlZzRB92icYyP5r95Q8m3BNYDLaqSp2ElDiYPGYgcNxQ6sC2D9VDKTYySWJpE5eTS7zG2VtUZCCCHEErS2xovVaCCYyDAcTdEfStIfTtIXSpDVFGaDHofFiMNsxGw8u4LJnKaIHa8PnsxqGHTgsBppKMkniPU7zPjtZqmZLYR4mwURcN97773867/+K/39/axdu5ZvfOMbbNmyZU7bcGIwfGQgwjlV3gk/NOPpLH2hJH3BJL2hBL3BBD3BxNtKc42xmw3U+e3UFTmoL7ZTX7SwalLnNEUwniaUzGA26ilzW2kqcVLptUlJLyGEEOIsoNfr8sGjw8yyMhepbI7RWIaRWJrBcJLBaIqBcJKMptDr8vc2dpMRm9mwZB7IK6VIZTXi6RyxdJZMTsOg0+GwGCnzWKny2vDaTRQ5LDL1XggxoXmPon7+859z++238+1vf5utW7fyta99jSuuuIJDhw5RWlo6J214ZG8fd/563/j333iiFZ/dxPs317Km0s1gNMVQJP81EM4/7e0PJQknTz+Vuthppspro8Znp7bITq3fvqCC6zFKKaKpLKPxNFlN4bdb2FTnp9pno9hpkSe1QgghxFnMYjRQ7jFQ7rGyqtJNKptfqxyK54PwgXCSaCpLIJZCUwqdTofVaMBq0mM1GTAb9Av6XiKT00hmcqSyGol0jszxARirUY/DYqCxxEGJ04rHbsJnN81Yjh+72UjH/3nXjLyXEGJhm/eA+ytf+Qof/ehHuemmmwD49re/zW9/+1vuu+8+Pv/5z8/68R/Z28fNP97DWyd7j8YzfOup1gn/vddmosJrpdJjo9Jro9Kbf/K50DN1nzhl3GU10ljipL7IQbnHuiCmtAshhBBi4bEYDZS6DJS6rED+wX0snSOcyBBNZYkkMgxFU4QT+Yf5qayGpkCHwqjXYzLqMRv0mAw6TAY9RoMOo352pqcrpchqikxOI5PL/5nOaqRzGkqBQmHS67GY9NjMhvGp4W6rCafViNtqlGRnQohpm9eoMJ1Os3v3bu64447xbXq9nksvvZSdO3fO+vFzmuKu3+x/W7D9VjZTfnp1ictCmdtK+fGvUrdlwQfWJxorUxFOZbAaDZS4LDSWOKjw2PDMcWkxIYQQQsy/E5fU7Wof4fyWkklNDdfpdDgtxrctPUtnNeLpLPF0bvzPSDJDOJklnsqSzGhEklkymkZOU+SPqIPjd2U6nQ69TodOR/7PUxxbqXxy1/E/UW++h04HinxAfzy4t5j0FLsseGwm7GYDDrMRuyX/p81kWNAj8UKIxWteo8Xh4WFyuRxlZWUnbS8rK+PgwYNv2z+VSpFKpca/D4fD0zr+rvYR+kLJCfe75eJmVpS7p3Ws+ZLTFKFEhnAig06XX5e1qtJ1Ui1IIYQQQpx93rqk7sP3v0SFx8qd16ziyjUV03pvs1GP2WjGa3/7azlNkcrm8qPNWY3U8VHnbE6R1fJ/pnMamaxGTik0LT9S/VZGfT6YNuj1mPQ6TEZ9fhTdoMNo0OfbcDzQNhv0WIz6Bbe0Twix9C2e4Vng7rvv5q677pqx9xuMTBxsA4QSp06CtlBpmiKczBBKZMgphddu5txqD1V+O6Uuy4yXqZB1SEIIIcTicroldf2hJDf/eA/funHDtIPu0zHoddjNRuax6qkQQsyZeQ24i4uLMRgMDAwMnLR9YGCA8vLyt+1/xx13cPvtt49/Hw6HqampmfLxx9YfTWQxTLfWlCKSzBKKZ8gqDbfVxIpyN9V+G2VuWZcthBBCiLwzLakbm5R912/2c9mq8iWTeVwIIebLvAbcZrOZjRs38thjj3HdddcBoGkajz32GJ/61Kfetr/FYsFisczY8bc0+KnwWOkPJU+7jttnN7Gs1DVjx5xJmlJEk1mCiQxZTcNlMdFY6qDWb6fMbcUhpbyEEEII8RYTLalTQF8oya72EbY1Fc1dw4QQYgma94js9ttv50Mf+hCbNm1iy5YtfO1rXyMWi41nLZ9NBr2OO69Zxc0/3nNCmo6TvX9z7YJa5/zWkWyXxURjiYOa40G21MsWQgghxJkUuqSu0P2EEEKc3rxHZ9dffz1DQ0N86Utfor+/n3Xr1vHII4+8LZHabLlyTQXfunEDd/56HwPhNxOyjdXh3ljnm5N2nElOU0SSGULJDJqmcFlNNJU5qPbl12S7rAt/yrsQQgghFoZCl9QVup8QQojTm/eAG+BTn/rUKaeQz5Ur11Swo7mYc/7XHwC49eImzqnyzuvIdianEU7kS3jp0OGymlhR5qbSZ6PUZZHp4kIIIYSYkomW1OmAco+VLQ3+uW6aEEIsORK1HXdiUpCWMte8BNvJTI5QIkMsncWg1+G1mVlb5aXcY6PUbZHEZ0IIIYSYtjMtqRu7+7nzmlWSME0IIWaABNzzSFOKWCpLOJEllc1hMRnw2U2sqXJT6rZS5LBgNs5sCS8hhBBCiNMtqSufoTrcQggh8iTgPs5uNvLiF97Jw6/3YjHO3khyOqsRSWaIprPkNHBaDFT5bVT7bBQ7Lfjt5gWVpE0IIYQQS9Nbl9R9/6bNnN9SIiPbQggxgyTgnmXjo9jJ/Ci2Sa/HbTdxTrEnP4rtNEvSMyGEEELMixOD6y0Nfgm2hRBihknAPQuSmRyRZJZoOoNSOpwWAxVeK9VeO0VOM36HGZNBpooLIYQQQgghxFImAfcMSGc1oqks0WSWrNKwGg24bSZaypyUuCwUOS1SH1sIIYQQQgghzjISBU5BJqcRS2WJpLJkchomvR6n1ciycidlbit+hxmv3SzTsoQQQgghhBDiLCYBdwEyufwIdiyVJZ3VMBh0uCwmGoodlLmtFB0PsCWjuBBCCCGEEEKIMRJwn0IqmyOZyY9iZzQNo16H02KivshB6fgItknqYgshhBBCCCGEOC0JuN/CYtQzGs/gsBhoKnVS6rbgs+cD7NksFyaEEEIIMdfsZiMd/+dd890MIYRYsiTgPoHfYeYdzSU4rUY8NpNkEhdCCCGEEEIIMWUScJ/AZNBTX+yY72YIIYQQQgghhFgCZAhXCCGEEEIIIYSYBRJwCyGEEEIIIYQQs0ACbiGEEEIIIYQQYhZIwC2EEEIIIYQQQswCCbiFEEIIIYQQQohZIAG3EEIIIYQQQggxCyTgFkIIIYQQQgghZoEE3EIIIYQQQgghxCyQgFsIIYQQQgghhJgFEnALIYQQQgghhBCzQAJuIYQQQgghhBBiFkjALYQQQgghhBBCzAIJuIUQQgghhBBCiFkgAbcQQgghhBBCCDELJOAWQgghhBBCCCFmgXG+GzAdSikAwuHwPLdECCGEmLyx/musPzubSB8uhBBiMSu0D1/UAXckEgGgpqZmnlsihBBCTF0kEsHj8cx3M+aU9OFCCCGWgon6cJ1axI/VNU2jt7cXl8uFTqeb9vuFw2Fqamro6urC7XbPQAvPHnLtpkau29TJtZs6uXZTN9PXTilFJBKhsrISvf7sWuUlffjCIdduauS6TZ1cu6mTazd189WHL+oRbr1eT3V19Yy/r9vtlh/gKZJrNzVy3aZOrt3UybWbupm8dmfbyPYY6cMXHrl2UyPXberk2k2dXLupm+s+/Ox6nC6EEEIIIYQQQswRCbiFEEIIIYQQQohZIAH3CSwWC3feeScWi2W+m7LoyLWbGrluUyfXburk2k2dXLuFS/7fTJ1cu6mR6zZ1cu2mTq7d1M3XtVvUSdOEEEIIIYQQQoiFSka4hRBCCCGEEEKIWSABtxBCCCGEEEIIMQsk4BZCCCGEEEIIIWbBkgq47777bjZv3ozL5aK0tJTrrruOQ4cOnbRPMpnklltuoaioCKfTyZ/92Z8xMDAw/vprr73GDTfcQE1NDTabjZUrV3LPPfec9B5PPvkkOp3ubV/9/f1zcp6zYa6uHUAqleLv/u7vqKurw2KxUF9fz3333Tfr5zhb5uraffjDHz7lz93q1avn5Dxnw1z+3P3kJz9h7dq12O12Kioq+Mu//EsCgcCsn+Nsmctrd++997Jy5UpsNhvLly/nhz/84ayf32yZiesWCAS48sorqaysxGKxUFNTw6c+9SnC4fBJ7/Pkk0+yYcMGLBYLzc3NfP/735+LU1y0pA+fOunDp0768KmTPnxqpP+eukXbh6sl5IorrlD333+/2rt3r3r11VfV1VdfrWpra1U0Gh3f5xOf+ISqqalRjz32mHr55ZfVeeedp7Zv3z7++ve+9z316U9/Wj355JOqtbVV/ehHP1I2m0194xvfGN/niSeeUIA6dOiQ6uvrG//K5XJzer4zaa6unVJK/cmf/InaunWrevTRR1V7e7t6/vnn1bPPPjtn5zrT5uraBYPBk37eurq6lN/vV3feeedcnu6Mmqtr9+yzzyq9Xq/uuece1dbWpp555hm1evVq9Z73vGdOz3cmzdW1++Y3v6lcLpf62c9+plpbW9VPf/pT5XQ61a9//es5Pd+ZMhPXbWRkRH3zm99UL730kuro6FB//OMf1fLly9UNN9wwvk9bW5uy2+3q9ttvV/v371ff+MY3lMFgUI888sicnu9iIn341EkfPnXSh0+d9OFTI/331C3WPnxJBdxvNTg4qAD11FNPKaXyH3Ymk0n913/91/g+Bw4cUIDauXPnad/nk5/8pLr44ovHvx/rrEdHR2et7fNttq7d7373O+XxeFQgEJi9xs+z2bp2b/WrX/1K6XQ61dHRMXONn2ezde3+9V//VTU2Np60z9e//nVVVVU1w2cwf2br2m3btk199rOfPWmf22+/Xe3YsWOGz2B+zNR1u+eee1R1dfX493/zN3+jVq9efdI+119/vbriiitm+AyWLunDp0768KmTPnzqpA+fGum/p26x9OFLakr5W4VCIQD8fj8Au3fvJpPJcOmll47vs2LFCmpra9m5c+cZ32fsPU60bt06KioquOyyy3juuedmuPXza7au3a9//Ws2bdrEv/zLv1BVVcWyZcv47Gc/SyKRmKUzmXuz/XM35nvf+x6XXnopdXV1M9Ty+Tdb127btm10dXXx3//93yilGBgY4IEHHuDqq6+epTOZe7N17VKpFFar9aR9bDYbu3btIpPJzOQpzIuZuG69vb388pe/5MILLxzftnPnzpPeA+CKK64447UXJ5M+fOqkD5866cOnTvrwqZH+e+oWSx++ZANuTdO47bbb2LFjB2vWrAGgv78fs9mM1+s9ad+ysrLTrt16/vnn+fnPf87HPvax8W0VFRV8+9vf5he/+AW/+MUvqKmp4aKLLmLPnj2zdj5zaTavXVtbG88++yx79+7lV7/6FV/72td44IEH+OQnPzlr5zOXZvPanai3t5ff/e53fOQjH5nR9s+n2bx2O3bs4Cc/+QnXX389ZrOZ8vJyPB4P995776ydz1yazWt3xRVX8N3vfpfdu3ejlOLll1/mu9/9LplMhuHh4Vk7p7kw3et2ww03YLfbqaqqwu12893vfnf8tf7+fsrKyt72HuFweEkFJ7NF+vCpkz586qQPnzrpw6dG+u+pW0x9+JINuG+55Rb27t3Lz372sym/x969e7n22mu58847ufzyy8e3L1++nI9//ONs3LiR7du3c99997F9+3a++tWvzkTT591sXjtN09DpdPzkJz9hy5YtXH311XzlK1/hBz/4wZK4CZ3Na3eiH/zgB3i9Xq677ropH2ehmc1rt3//fj7zmc/wpS99id27d/PII4/Q0dHBJz7xiZlo+rybzWv3xS9+kauuuorzzjsPk8nEtddey4c+9CEA9PrF3YVM97p99atfZc+ePTz00EO0trZy++23z3ALz17Sh0+d9OFTJ3341EkfPjXSf0/dourDpzQRfYG75ZZbVHV1tWpraztp+2OPPXbKdVu1tbXqK1/5yknb9u3bp0pLS9UXvvCFgo752c9+Vp133nnTavdCMNvX7i/+4i9UU1PTSdv279+vAHX48OGZOYl5Mlc/d5qmqebmZnXbbbfNWNvn22xfuxtvvFG9973vPWnbM888owDV29s7MycxT+bq5y6dTquuri6VzWbHE7Es5iRTM3HdTvTWn6fzzz9ffeYznzlpn/vuu0+53e4Zaf9SJn341EkfPnXSh0+d9OFTI/331C22PnxJBdyapqlbbrlFVVZWnvKDf2wh/QMPPDC+7eDBg29bSL93715VWlqqPve5zxV87EsvvXTRZktUau6u3b//+78rm82mIpHI+LYHH3xQ6fV6FY/HZ/CM5s5c/9yNJfx54403Zu4k5slcXbs//dM/Ve973/tO2vb8888rQPX09MzQ2cyt+fy8u+CCC07K5rmYzNR1e6unnnpKAaq9vV0plU+4smbNmpP2ueGGGyRp2hlIHz510odPnfThUyd9+NRI/z11i7UPX1IB980336w8Ho968sknTyq9cGIn8IlPfELV1taqxx9/XL388stq27Ztatu2beOvv/HGG6qkpETdeOONJ73H4ODg+D5f/epX1YMPPqiOHDmi3njjDfWZz3xG6fV69cc//nFOz3cmzdW1i0Qiqrq6Wr33ve9V+/btU0899ZRqaWlRH/nIR+b0fGfSXF27MTfeeKPaunXrnJzbbJura3f//fcro9GovvnNb6rW1lb17LPPqk2bNqktW7bM6fnOpLm6docOHVI/+tGP1OHDh9WLL76orr/+euX3+8c7pcVmJq7bb3/7W3XfffepN954Q7W3t6uHH35YrVy58qTMr2MlRT73uc+pAwcOqHvvvVfKgk1A+vCpkz586qQPnzrpw6dG+u+pW6x9+JIKuIFTft1///3j+yQSCfXJT35S+Xw+Zbfb1Xve8x7V19c3/vqdd955yveoq6sb3+fLX/6yampqUlarVfn9fnXRRRepxx9/fA7PdObN1bVTKp+e/9JLL1U2m01VV1er22+/fdE+GVdqbq9dMBhUNptN/cd//Mccnd3smstr9/Wvf12tWrVK2Ww2VVFRoT7wgQ+o7u7uOTrTmTdX127//v1q3bp1ymazKbfbra699lp18ODBOTzTmTUT1+3xxx9X27ZtUx6PR1mtVtXS0qL+9m//9m1T2J544gm1bt06ZTabVWNj40nHEG8nffjUSR8+ddKHT5304VMj/ffULdY+XHe88UIIIYQQQgghhJhBiz9FnRBCCCGEEEIIsQBJwC2EEEIIIYQQQswCCbiFEEIIIYQQQohZIAG3EEIIIYQQQggxCyTgFkIIIYQQQgghZoEE3EIIIYQQQgghxCyQgFsIIYQQQgghhJgFEnALIYQQQgghhBCzQAJuIc5yH/7wh7nuuuvmuxlCCCGEmCTpw4VY+Izz3QAhxOzR6XRnfP3OO+/knnvuQSk1Ry0SQgghRCGkDxdiadAp+S0VYsnq7+8f//vPf/5zvvSlL3Ho0KHxbU6nE6fTOR9NE0IIIcQZSB8uxNIgU8qFWMLKy8vHvzweDzqd7qRtTqfzbdPRLrroIm699VZuu+02fD4fZWVlfOc73yEWi3HTTTfhcrlobm7md7/73UnH2rt3L1dddRVOp5OysjI++MEPMjw8PMdnLIQQQiwN0ocLsTRIwC2EeJsf/OAHFBcXs2vXLm699VZuvvlm/vzP/5zt27ezZ88eLr/8cj74wQ8Sj8cBCAaDXHLJJaxfv56XX36ZRx55hIGBAd73vvfN85kIIYQQZxfpw4VYWCTgFkK8zdq1a/n7v/97WlpauOOOO7BarRQXF/PRj36UlpYWvvSlLxEIBHj99dcB+Ld/+zfWr1/PP//zP7NixQrWr1/PfffdxxNPPMHhw4fn+WyEEEKIs4f04UIsLJI0TQjxNueee+743w0GA0VFRZxzzjnj28rKygAYHBwE4LXXXuOJJ5445Vqy1tZWli1bNsstFkIIIQRIHy7EQiMBtxDibUwm00nf63S6k7aNZU7VNA2AaDTKNddcw5e//OW3vVdFRcUstlQIIYQQJ5I+XIiFRQJuIcS0bdiwgV/84hfU19djNMrHihBCCLFYSB8uxOySNdxCiGm75ZZbGBkZ4YYbbuCll16itbWV3//+99x0003kcrn5bp4QQgghTkP6cCFmlwTcQohpq6ys5LnnniOXy3H55ZdzzjnncNttt+H1etHr5WNGCCGEWKikDxdidumUUmq+GyGEEEIIIYQQQiw18thKCCGEEEIIIYSYBRJwCyGEEEIIIYQQs0ACbiGEEEIIIYQQYhZIwC2EEEIIIYQQQswCCbiFEEIIIYQQQohZIAG3EEIIIYQQQggxCyTgFkIIIYQQQgghZoEE3EIIIYQQQgghxCyQgFsIIYQQQgghhJgFEnALIYQQQgghhBCzQAJuIYQQQgghhBBiFkjALYQQQgghhBBCzIL/H3oCuZf5k4OiAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs)\n", + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "9d1f63b4", + "metadata": {}, + "source": [ + "Moreover, `MotionModel.model` is fully vectorized, and can infer positions of multiple stars at multiple times, and the resulting inferred positions has shape (N_stars, N_times). See the example below:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d1e406c5", + "metadata": {}, + "outputs": [], + "source": [ + "t = np.array([0, 1., 2.2, 3.5, 5.]) + 2025.0\n", + "\n", + "xs = np.array([\n", + " [0., 0.5, 2.1, 3.2, 8.0],\n", + " [10.0, 8.9, 9.2, 7.4, 7.0],\n", + " [2.5, 6.2, 5.2, 3.2, 5.0]\n", + "])\n", + "\n", + "ys = np.array([\n", + " [10.2, 8.5, 9.1, 10.5, 13.0],\n", + " [8.0, 9.9, 8.2, 7.4, 7.0],\n", + " [5.2, 6.2, 4.7, 3.2, 6.0]\n", + "])\n", + "\n", + "xes = np.array([\n", + " [0.2, 0.5, 0.3, 0.4, 0.6],\n", + " [0.5, 0.2, 0.7, 0.3, 0.2],\n", + " [0.5, 0.7, 0.6, 0.4, 0.3]\n", + "])\n", + "\n", + "yes = np.array([\n", + " [0.3, 0.2, 0.5, 0.2, 0.4],\n", + " [0.2, 0.5, 0.6, 0.4, 0.2],\n", + " [0.4, 0.2, 0.3, 0.4, 0.5]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4adebbe8", + "metadata": {}, + "outputs": [], + "source": [ + "params = []\n", + "param_errs = []\n", + "for xi, yi, xei, yei in zip(xs, ys, xes, yes):\n", + " p, pe = mm.fit(t, xi, yi, xei, yei)\n", + " params.append(p)\n", + " param_errs.append(pe)" + ] + }, + { + "cell_type": "markdown", + "id": "4e0424df", + "metadata": {}, + "source": [ + "Once we have the params and param errors, we can infer the model positions at any given time." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "95745baa", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs)" + ] + }, + { + "cell_type": "markdown", + "id": "06fdca50", + "metadata": {}, + "source": [ + "The inferred positions should have shape (N_stars, N_times):" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "54206834", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 100)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_model.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e6a4e42e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_fit(t, xs, ys, xes, yes, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "f7ae3e7f", + "metadata": {}, + "source": [ + "## 1.3. Example: Parallax Model Fit" + ] + }, + { + "cell_type": "markdown", + "id": "08eceab5", + "metadata": {}, + "source": [ + "Parallax model requires some fixed parameters: `ra`, `dec`, `pa`, `obsLocation`, and `t0`.\n", + "- `ra` and `dec` are required parameters. \n", + "- `pa = 0` by default\n", + "- `obsLocation = 'earth'` by default\n", + "- `t0 = np.average(t, 1./np.hypot(xe, ye))` by default\n", + "\n", + "We need to provide the fixed parameters in the `fixed_params_dict`:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "018fc13a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 1 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 2 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 2 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 1 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"taiutc\" yielded 1 of \"dubious year (Note 4)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n" + ] + } + ], + "source": [ + "mm = Parallax()\n", + "fixed_params_dict = {'ra': 0., 'dec': 10., 'pa': 0., 'obsLocation': 'earth'}\n", + "params, param_errs = mm.fit(t, x, y, xe, ye, fixed_params_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "73dafb1f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 20 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 40 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 40 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 20 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"taiutc\" yielded 20 of \"dubious year (Note 4)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs)\n", + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "5be8fb7e", + "metadata": {}, + "source": [ + "# 2. Fit Motion Model in StarTable" + ] + }, + { + "cell_type": "markdown", + "id": "3bd8dec7", + "metadata": {}, + "source": [ + "Examples on `flystar.StarTable.fit_motion_model`. Prepare the data with invalid values:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "aa698e86", + "metadata": {}, + "outputs": [], + "source": [ + "t = np.array([0, 1., 2.2, 3.5, 5.]) + 2025.0\n", + "\n", + "x = np.array([\n", + " [0., 0.5, 2.1, 3.2, 8.0], # Increasing 5 Epochs\n", + " [10.0, 8.9, 9.2, 7.4, 7.0], # Decreasing 5 Epochs\n", + " [2.5, np.nan, 5.2, np.nan, 5.0], # 3 Epochs\n", + " [np.nan, 6.2, np.nan, np.nan, 9.2], # 2 Epochs\n", + " [np.nan, 2.0, np.nan, np.nan, np.nan], # 1 Epoch\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan] # All NaNs\n", + "])\n", + "\n", + "y = np.array([\n", + " [10.2, 8.5, 9.1, 10.5, 13.0], # Increasing 5 Epochs\n", + " [8.0, 9.9, 8.2, 7.4, 7.0], # Decreasing 5 Epochs\n", + " [5.2, np.nan, 4.7, np.nan, 6.0], # 3 Epochs\n", + " [np.nan, 1.2, np.nan, np.nan, 3.2], # 2 Epochs\n", + " [np.nan, 2.0, np.nan, np.nan, np.nan], # 1 Epoch\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan] # All NaNs\n", + "])\n", + "\n", + "xe = np.array([\n", + " [0.2, 0.5, 0.3, 0.4, 0.6],\n", + " [0.5, 0.2, 0.7, 0.3, 0.2],\n", + " [0.5, np.nan, 0.6, np.nan, 0.3],\n", + " [np.nan, 0.6, np.nan, np.nan, 0.3],\n", + " [np.nan, 0.4, np.nan, np.nan, np.nan],\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan]\n", + "])\n", + "\n", + "ye = np.array([\n", + " [0.3, 0.2, 0.5, 0.2, 0.4],\n", + " [0.2, 0.5, 0.6, 0.4, 0.2],\n", + " [0.7, np.nan, 0.5, np.nan, 0.2],\n", + " [np.nan, 0.4, np.nan, np.nan, 0.5],\n", + " [np.nan, 0.5, np.nan, np.nan, np.nan],\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan]\n", + "])\n", + "\n", + "x = np.ma.masked_invalid(x)\n", + "y = np.ma.masked_invalid(y)\n", + "xe = np.ma.masked_invalid(xe)\n", + "ye = np.ma.masked_invalid(ye)\n", + "mask = np.ma.getmaskarray(x) | np.ma.getmaskarray(y) | np.ma.getmaskarray(xe) | np.ma.getmaskarray(ye)\n", + "\n", + "tab = StarTable({\n", + " 'x': x,\n", + " 'y': y,\n", + " 'xe': xe,\n", + " 'ye': ye\n", + "})\n", + "tab.meta['list_times'] = t" + ] + }, + { + "cell_type": "markdown", + "id": "9201897f", + "metadata": {}, + "source": [ + "There are a 2 ways to specify the desired motion models:\n", + "1. Let MotionModel automatically determine which motion model to use among the given `motion_models` list based on the number of valid observations. MotionModel will choose the motion model that has enough observations, i.e. $n_\\text{fit} \\geq n_\\text{params}$. \n", + "2. Specify a motion model for each star in the `motion_model_input` column. In case there is not enough observations, MotionModel will \"downgrade\" to a model with less parameters until $n_\\text{fit} \\geq n_\\text{params}$ among all the unique motion models specified in the column.\n", + "\n", + "Note that when `absolute_sigma=False` and `n_fit == n_params`, we don't have enough degree of freedom to rescale the uncertainties, so the uncertainties will be set to infinity -- the same behavior as `scipy.optimize.curve_fit`.
By default `motion_models = [Empty, Fixed, Linear]`. `Empty` and `Fixed` will always be added in the list to handle 0 and 1 point cases. See examples below for details. Let's start with the most basic usage." + ] + }, + { + "cell_type": "markdown", + "id": "e58f429d", + "metadata": {}, + "source": [ + "## 2.1. Example: Default Fitting" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "02642d3b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Empty: 0%| | 0/1 [00:00StarTable length=6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
n_fitn_requiredmotion_model_used
int64int64str20
52Linear
52Linear
32Linear
22Linear
12Fixed
02Empty
" + ], + "text/plain": [ + "\n", + "n_fit n_required motion_model_used\n", + "int64 int64 str20 \n", + "----- ---------- -----------------\n", + " 5 2 Linear\n", + " 5 2 Linear\n", + " 3 2 Linear\n", + " 2 2 Linear\n", + " 1 2 Fixed\n", + " 0 2 Empty" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab['n_required'] = 2\n", + "tab[['n_fit', 'n_required', 'motion_model_used']]" + ] + }, + { + "cell_type": "markdown", + "id": "20470c6e", + "metadata": {}, + "source": [ + "Next, let's try `absolute_sigma=False`. As mentioned above, we don't have enough degree of freedom to rescale the uncertainties for the forth star. In this case, the parameter uncertainties will be set to infinity, which is the same behavior as `scipy.optimize.curve_fit`. The same `OptmizieWarning` as in `scipy` will be raised." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "26b11593", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Empty: 0%| | 0/1 [00:00\n", + "0.2398025689409276\n", + "0.07197698078673948\n", + "0.26723109004421475\n", + "inf\n", + "inf\n", + "inf\n", + "" + ], + "text/plain": [ + "\n", + " 0.2398025689409276\n", + "0.07197698078673948\n", + "0.26723109004421475\n", + " inf\n", + " inf\n", + " inf" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab['vx_err']" + ] + }, + { + "cell_type": "markdown", + "id": "241ab6d6", + "metadata": {}, + "source": [ + "## 2.2. Example: Specify Motion Models" + ] + }, + { + "cell_type": "markdown", + "id": "220922c5", + "metadata": {}, + "source": [ + "Alternatively, one can specify a list of motion models to use, and the function will also automatically determine which model to use for each star depending on the valid observed epochs. In the following example, we specify `Acceleration` model, but **the function will always implicitly add `Empty` and `Fixed`** to handle the 0 or 1 epoch stars." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a596c8e8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Acceleration: 0%| | 0/3 [00:00StarTable length=6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
n_fitmotion_model_used
int64str20
5Acceleration
5Acceleration
3Acceleration
2Fixed
1Fixed
0Empty
" + ], + "text/plain": [ + "\n", + "n_fit motion_model_used\n", + "int64 str20 \n", + "----- -----------------\n", + " 5 Acceleration\n", + " 5 Acceleration\n", + " 3 Acceleration\n", + " 2 Fixed\n", + " 1 Fixed\n", + " 0 Empty" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab[['n_fit', 'motion_model_used']]" + ] + }, + { + "cell_type": "markdown", + "id": "188290a9", + "metadata": {}, + "source": [ + "## 2.3. Example: Specify the `motion_model_input` Column" + ] + }, + { + "cell_type": "markdown", + "id": "99624463", + "metadata": {}, + "source": [ + "One can also specify a motion model for each star as a column in the star table. However, the function will \"downgrade\" the model to one with fewer parameters until $n_\\text{fit} \\geq n_\\text{params}$:" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "04db5f9e", + "metadata": {}, + "outputs": [], + "source": [ + "ra = np.zeros(len(x))\n", + "dec = np.zeros(len(x))\n", + "pa = np.zeros(len(x))\n", + "\n", + "motion_model_input = [\n", + " 'Acceleration', # Will use Acceleration\n", + " 'Parallax', # Will use Parallax\n", + " 'Linear', # Will use Linear\n", + " 'Acceleration', # Will use Linear, as n_fit = 2 < 3\n", + " 'Linear', # Will use Fixed, as n_fit = 1 < 2\n", + " 'Fixed' # Will use Empty, as n_fit = 0 < 1\n", + "]\n", + "tab = StarTable({\n", + " 'x': x,\n", + " 'y': y,\n", + " 'xe': xe,\n", + " 'ye': ye,\n", + " 'ra': ra,\n", + " 'dec': dec,\n", + " 'pa': pa,\n", + " 'motion_model_input': motion_model_input\n", + "})\n", + "tab.meta['list_times'] = t" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "2b61fbcf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Acceleration: 0%| | 0/1 [00:00StarTable length=6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
n_fitn_requiredmotion_model_inputmotion_model_used
int64int64str12str12
53AccelerationAcceleration
53ParallaxParallax
32LinearLinear
23AccelerationLinear
12LinearFixed
01FixedEmpty
" + ], + "text/plain": [ + "\n", + "n_fit n_required motion_model_input motion_model_used\n", + "int64 int64 str12 str12 \n", + "----- ---------- ------------------ -----------------\n", + " 5 3 Acceleration Acceleration\n", + " 5 3 Parallax Parallax\n", + " 3 2 Linear Linear\n", + " 2 3 Acceleration Linear\n", + " 1 2 Linear Fixed\n", + " 0 1 Fixed Empty" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_mm_map = motion_model.motion_model_map()\n", + "tab['n_required'] = np.array([all_mm_map[mm].n_params for mm in tab['motion_model_input']], dtype=int)\n", + "tab[['n_fit', 'n_required', 'motion_model_input', 'motion_model_used']]" + ] + }, + { + "cell_type": "markdown", + "id": "d4f96fcb", + "metadata": {}, + "source": [ + "## 2.4. Example: Infer Positions" + ] + }, + { + "cell_type": "markdown", + "id": "c660ec98", + "metadata": {}, + "source": [ + "Continuing from the previous example: Once we fit the motion models and the parameters are added into the table, we can infer the positions at arbitrary times with `StarTable.infer_positions`" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "095be28f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 20 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 40 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 40 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 20 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"taiutc\" yielded 20 of \"dubious year (Note 4)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n" + ] + } + ], + "source": [ + "x_model, y_model, xe_model, ye_model = tab.infer_positions(t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "a4df5458", + "metadata": {}, + "source": [ + "As in `MotionModel.model`, `StarTable.infer_positions` is also vectorized and returns positions and uncertainties in shapes of $(N_\\text{stars}, N_\\text{times})$" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "2f7e8b7a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6, 100)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_model.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7aab0868", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "12bb0136", + "metadata": {}, + "source": [ + "## 2.5. Speed Test" + ] + }, + { + "cell_type": "markdown", + "id": "43fd87c5", + "metadata": {}, + "source": [ + "Speed test for the most commonly used Linear model. As the `use_scipy=False` option for the Linear model uses the [matrix multiplication solution](https://en.wikipedia.org/wiki/Weighted_least_squares#Solution), it is extremely fast at fewer epochs: " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "de576a47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 10 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 6350.75it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:00<00:00, 25802.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 31 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 6184.77it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:00<00:00, 23908.79it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 100 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 6347.19it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:00<00:00, 14309.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 316 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 5023.37it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:03<00:00, 3288.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 1000 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:02<00:00, 4314.91it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [01:19<00:00, 125.47it/s]\n" + ] + } + ], + "source": [ + "import time\n", + "N = 10000\n", + "dims = np.logspace(1, 3, 5, dtype=int)\n", + "rng = np.random.default_rng(42)\n", + "\n", + "scipy_times = []\n", + "analytic_times = []\n", + "\n", + "for dim in dims:\n", + " print(f'Fitting {dim} epochs...')\n", + " t = np.linspace(2025.0, 2030.0, dim)\n", + " x = rng.random((N, dim))\n", + " y = rng.random((N, dim))\n", + " xe = rng.uniform(0, 0.2, size=(N, dim))\n", + " ye = rng.uniform(0, 0.2, size=(N, dim))\n", + " tab = StarTable({\n", + " 'x': x,\n", + " 'y': y,\n", + " 'xe': xe,\n", + " 'ye': ye\n", + " })\n", + " tab.meta['list_times'] = t\n", + " \n", + " start = time.time()\n", + " tab.fit_motion_model(use_scipy=True)\n", + " end = time.time()\n", + " scipy_times.append(end - start)\n", + " \n", + " start = time.time()\n", + " tab.fit_motion_model(use_scipy=False)\n", + " end = time.time()\n", + " analytic_times.append(end - start)\n", + "\n", + "scipy_times = np.array(scipy_times)\n", + "analytic_times = np.array(analytic_times)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3d2a8457", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "280" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Collect memory garbage data\n", + "import gc\n", + "gc.collect()" + ] + }, + { + "cell_type": "markdown", + "id": "06442faf", + "metadata": {}, + "source": [ + "Let's visualize the performance:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "03d53769", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(dims, N / scipy_times, marker='o', label='Scipy Curve Fit')\n", + "ax.plot(dims, N / analytic_times, marker='o', color='C3', label='Motion Model Analytic')\n", + "ax.set_xscale('log')\n", + "ax.set_xlabel('Number of Epochs')\n", + "ax.set_ylabel('Stars Fit per Second')\n", + "ax.set_title(f'Motion Model Fitting Performance of {N} Stars')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ea672ab4", + "metadata": {}, + "source": [ + "It can be seen that for epochs < 200, the analytic solution is faster than scipy, and vice versa for > 300 epochs." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "main", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/flystar/align.py b/flystar/align.py index db37954..a99d354 100755 --- a/flystar/align.py +++ b/flystar/align.py @@ -1,41 +1,63 @@ -import numpy as np -from flystar import match -from flystar import transforms -from flystar import plots -from flystar.starlists import StarList -from flystar.startables import StarTable -from flystar import motion_model -from astropy.table import Table, Column, vstack -import datetime -import copy import os +import gc import pdb +import copy import time -import warnings import pickle +import warnings +import datetime +import numpy as np +import matplotlib.pyplot as plt +from tqdm import tqdm +from . import match, transforms, plots, motion_model +from .starlists import StarList +from .startables import StarTable +from .motion_model import Empty, Fixed +from astropy.table import Table, Column, vstack from astropy.utils.exceptions import AstropyUserWarning + class MosaicSelfRef(object): - def __init__(self, list_of_starlists, ref_index=0, iters=2, - dr_tol=[1, 1], dm_tol=[2, 1], - outlier_tol=[None, None], - trans_args=[{'order': 2}, {'order': 2}], - init_order=1, - mag_trans=True, mag_lim=None, trans_weights=None, vel_weights='var', - trans_input=None, trans_class=transforms.PolyTransform, - calc_trans_inverse=False, - init_guess_mode='miracle', iter_callback=None, - default_motion_model='Fixed', - motion_model_dict = {}, - use_scipy=True, - absolute_sigma=False, - save_path=None, - verbose=True): + def __init__( + self, + list_of_starlists, + starlist_vertices=None, + # Alignment parameters + ref_index=0, + iters=2, + dr_tol=[1, 1], + dm_tol=[2, 1], + outlier_tol=None, + # Transformation parameters + trans_class=transforms.PolyTransform, + trans_args=[{'order': 2}, {'order': 2}], + trans_input=None, + trans_weighting=None, + init_order=1, + init_guess_mode='miracle', + briteN=None, + calc_trans_inverse=False, + # Magnitude parameters + mag_trans=True, + mag_lim=None, + # Motion model parameters + motion_models=['Empty', 'Fixed'], + # motion_model_for_new_star=None, + fixed_params_dict=None, + vel_weighting='var', + use_scipy=True, + absolute_sigma=False, + # Advanced options + iter_callback=None, + save_path=None, + prefix_name='msr', + verbose=True + ): """ - Make a mosaic object by passing in a list of starlists and then running fit(). + Make a mosaic object by passing in a list of starlists and then running fit(). Required Parameters - ---------- + ------------------- list_of_starlists : array of StarList objects An array or list of flystar.starlists.StarList objects (which are Astropy Tables). There should be one for each starlist and they must contain 'x', 'y', and 'm' columns. @@ -43,24 +65,28 @@ def __init__(self, list_of_starlists, ref_index=0, iters=2, Note that there is an optional weights column called 'w'. If this column exists in any of the lists, it will be queried to determine if an individual star can be used to derive the transformations between starlists. This is the most flexible way - to allow you to determine, as a function of time and star, which ones are good enough - in the transformation. Note that just because it can be used (i.e. w_in=1), - doesn't meant that it will be used. The mag limits and outliers still take precedence. - Note also that the weights that go into the transformation are + to allow you to determine, as a function of time and star, which ones are good enough + in the transformation. Note that just because it can be used (i.e. w_in=1), + doesn't meant that it will be used. The mag limits and outliers still take precedence. + Note also that the weights that go into the transformation are star_list['w'] * ref_list['w'] * weight_from_keyword (see the weights parameter) for those stars not trimmed out by the other criteria. Optional Parameters - ---------- + ------------------- + starlist_vertices : list or array + A list or array of polygon vertices coordinates for each starlist. Initial guess will only use stars in overlapping regions defined by these polygons. + Shape of (N_lists, N_vertices, 2) in the format of [[x1, y1], [x2, y2], ..., [xN, yN]] for each starlist, by default None + ref_index : int The index of the reference epoch. (default = 0). Note that this is the reference - list only for the first iteration. Subsequent iterations will utilize the sigma-clipped - mean of the positions from all the starlists. + list only for the first iteration. Subsequent iterations will utilize the sigma-clipped + mean of the positions from all the starlists. iters : int - The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? + The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? dr_tol : list or array The delta-radius (dr) tolerance for matching in units of the reference coordinate system. @@ -68,73 +94,80 @@ def __init__(self, list_of_starlists, ref_index=0, iters=2, dm_tol : list or array The delta-magnitude (dm) tolerance for matching in units of the reference coordinate system. - This is a list of dm values, one for each iteration of matching/transformation. + This is a list of dm values, one for each iteration of matching/transformation. outlier_tol : list or array - The outlier tolerance (in units of sigma) for rejecting outlier stars. + The outlier tolerance (in units of sigma) for rejecting outlier stars. This is a list of tol values, one for each iteration of matching/transformation. + If not provided, will be None for each iteration. - mag_trans : boolean - If true, this will also calculate and (temporarily) apply a zeropoint offset to - magnitudes in each list to bring them into a common magnitude system. This is - essential for matching (with finite dm_tol) starlists of different filters or - starlists that are not photometrically calibrated. Note that the final_table columns - of 'm', 'm0', and 'm0_err' will contain the transformed magnitudes while the - final_table column 'm_orig' will contain the original un-transformed magnitudes. - If mag_trans = False, then no such zeropoint offset it applied at any point. + trans_class : transforms.Transform2D object (or subclass) + The transform class that will be used to when deriving the optimal + transformation parameters between each list and the reference list. - mag_lim : array - If different from None, it indicates the minimum and maximum magnitude - on the catalogs for finding the transformations. Note, if you want specify the mag_lim - separately for each list and each iteration, you need to pass in a 2D array that - has shape (N_lists, 2). + trans_args : dictionary + A dictionary (or a list of dictionaries) containing any extra keywords that are needed + in the transformation object. For instance, "order". Note that if a list is passed in, + then the transformation argument (i.e. order) will be changed for every iteration in + iters. + + trans_input : array or list of transform objects + def = None. If not None, then this should contain an array or list of transform + objects that will be used as the initial guess in the alignment and matching. - trans_weights : str + trans_weighting : str Either None (def), 'both,var', 'list,var', or 'ref,var' depending on whether you want to weight by the positional uncertainties (variances) in the individual starlists, or also with the uncertainties in the reference frame itself. Note weighting only works when there are positional uncertainties availabe. Other options include 'both,std', 'list,std', 'list,var'. - - vel_weights : str - Either 'var' (def) or 'std', depending on whether you want to weight the motion model - fits by the variance or standard deviation of the position data - trans_input : array or list of transform objects - def = None. If not None, then this should contain an array or list of transform - objects that will be used as the initial guess in the alignment and matching. + init_order : int + The order of the initial transformation used for the first iteration. - trans_class : transforms.Transform2D object (or subclass) - The transform class that will be used to when deriving the optimal - transformation parameters between each list and the reference list. + init_guess_mode : string + If no initial transformations are passed in via the trans_input keyword, then we have + to make the initial transformation and matching blindly. We can do this in a couple of + different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). - trans_args : dictionary - A dictionary (or a list of dictionaries) containing any extra keywords that are needed - in the transformation object. For instance, "order". Note that if a list is passed in, - then the transformation argument (i.e. order) will be changed for every iteration in - iters. + briteN : int + If init_guess_mode is 'miracle', this is the number of brightest stars to use in the miracle match. + Default is min(50, len(star_list)). - calc_trans_inverse: boolean + calc_trans_inverse: boolean If true, then calculate the inverse transformation (from reference to starlist) in addition to the normal transformation (from starlist to reference). The inverse calculation is calculated by switching the order to the positions in match_and_transform. The inverse transformations are saved in self.trans_list_inverse. - self.trans_list_inverse doesn't exist if calc_trans_inverse == False - init_guess_mode : string - If no initial transformations are passed in via the trans_input keyword, then we have - to make the initial transformation and matching blindly. We can do this in a couple of - different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). + mag_trans : boolean + If true, this will also calculate and (temporarily) apply a zeropoint offset to + magnitudes in each list to bring them into a common magnitude system. This is + essential for matching (with finite dm_tol) starlists of different filters or + starlists that are not photometrically calibrated. Note that the final_table columns + of 'm', 'm0', and 'm0_err' will contain the transformed magnitudes while the + final_table column 'm_orig' will contain the original un-transformed magnitudes. + If mag_trans = False, then no such zeropoint offset it applied at any point. - iter_callback : None or function - A function to call (that accepts a StarTable object and an iteration number) - at the end of every iteration. This can be used for plotting or printing state. + mag_lim : array + If different from None, it indicates the minimum and maximum magnitude + on the catalogs for finding the transformations. Note, if you want specify the mag_lim + separately for each list and each iteration, you need to pass in a 2D array that + has shape (N_lists, 2). - default_motion_model : string - Name of motion model to use for new or unassigned stars + motion_models : list of MotionModel or str, optional + Motion models or their names to use for new or unassigned stars - motion_model_dict : None or dict - Dict of motion model name keys (strings) and corresponding MotionModel object values + motion_model_for_new_star : str or MotionModel, optional + Motion model or its name for newly added stars in the ref table. Used in add_rows_for_new_stars(). + If None, the most complex motion model in motion_models will be used, by default None. + + fixed_params_dict : None or dict + Dictionary of motion model fixed parameters, e.g., ra, dec, pa, obsLocation, t0, etc. See motion_model classes for details. + + vel_weighting : str + Either 'var' (def) or 'std', depending on whether you want to weight the motion model + fits by the variance or standard deviation of the position data use_scipy : bool, optional If True, use scipy.optimize.curve_fit for velocity fitting. If False, use linear @@ -144,74 +177,119 @@ def = None. If not None, then this should contain an array or list of transform If True, the velocity fit will use absolute errors in the data. If False, relative errors will be used, by default False. + iter_callback : None or function + A function to call (that accepts a StarTable object and an iteration number) + at the end of every iteration. This can be used for plotting or printing state. + save_path : str, optional Path to save the MosaicSelfRef object as a pickle file. - - verbose : int (0 to 9, inclusive) + + prefix_name : str, optional + Prefix for the file names, including PREFIX_input.log, PREFIX.pkl, PREFIX_ref_table.fits. + + verbose : bool or int (0 to 9, inclusive) Controls the verbosity of print statements. (0 least, 9 most verbose). For backwards compatibility, 0 = False, 9 = True. (Note: technically right now no checks on whether the number is an integer or not...) Example - ---------- - msc = align.MosaicToRef(list_of_starlists, iters=1, + ------- + mtr = align.MosaicToRef(list_of_starlists, iters=1, dr_tol=[0.1], dm_tol=[5], outlier_tol=[None], mag_lim=[13, 21], trans_class=transforms.PolyTransform, trans_args=[{'order': 1}], weights='both,std', init_guess_mode='miracle', verbose=False) - msc.fit() + mtr.fit() # Access a list of all the transformation parameters: - trans_list = msc.trans_list + trans_list = mtr.trans_list # Access the fully-combined reference table. - stars_table = msc.ref_table + stars_table = mtr.ref_table # Plot the magnitude of the first star vs. time: - # Overplot the mean magnitude. + # Overplot the mean magnitude. plt.plot(stars_table['t'][0, :], stars_table['m'][0, :], 'k.') - plt.axhline(stars_table['m0'][0]) + plt.axhline(stars_table['m0'][0]) # Plot the X position of the first star vs. time: # Overplot the best-fit proper motion. times = stars_table['t'][0, :] plt.errorbar(times, stars_table['x'][0, :], yerr=stars_table['xe'][0, :]) - plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) - + plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) """ self.star_lists = list_of_starlists + self.starlist_vertices = starlist_vertices self.ref_index = ref_index self.iters = iters self.dr_tol = dr_tol self.dm_tol = dm_tol - self.outlier_tol = outlier_tol self.trans_args = trans_args self.init_order = init_order self.mag_trans = mag_trans self.mag_lim = mag_lim - self.trans_weights = trans_weights - self.vel_weights = vel_weights + self.trans_weighting = trans_weighting + self.vel_weighting = vel_weighting self.trans_input = trans_input self.trans_class = trans_class self.calc_trans_inverse = calc_trans_inverse - self.motion_model_dict = motion_model_dict self.use_scipy = use_scipy self.absolute_sigma = absolute_sigma - self.default_motion_model = default_motion_model + self.fixed_params_dict = fixed_params_dict self.init_guess_mode = init_guess_mode + self.briteN = briteN self.iter_callback = iter_callback self.save_path = save_path + self.prefix_name = prefix_name self.verbose = verbose + if self.starlist_vertices is not None: + import shapely + self.reflist_polygon = shapely.make_valid(shapely.Polygon(self.starlist_vertices[self.ref_index])) + else: + self.reflist_polygon = None + + # Check x and y are 1d + for ii in range(len(self.star_lists)): + if self.star_lists[ii]['x'].ndim != 1 or self.star_lists[ii]['y'].ndim != 1: + raise ValueError(f"StarList at index {ii} has x and y that are not 1D. x.ndim={self.star_lists[ii]['x'].ndim}, y.ndim={self.star_lists[ii]['y'].ndim}. Please flatten these columns to be 1D.") + + if outlier_tol is None: + self.outlier_tol = [None] * self.iters + else: + self.outlier_tol = outlier_tol + + all_mm_map = motion_model.motion_model_map() + if all(isinstance(mm, str) for mm in motion_models): + assert all(mm in all_mm_map.keys() for mm in motion_models), f"All motion model names must be in {list(all_mm_map.keys())}" + mm_names = motion_models + motion_models = [all_mm_map[mm] for mm in motion_models] + else: + mm_names = [mm.name for mm in motion_models] + if 'Empty' not in mm_names: + motion_models.append(all_mm_map['Empty']) + if 'Fixed' not in mm_names: + motion_models.append(all_mm_map['Fixed']) + + # Sort by increasing n_params + motion_models = sorted(motion_models, key=lambda mm: mm.n_params) + self.motion_models = motion_models + + # if motion_model_for_new_star is None: + # self.motion_model_for_new_star = self.motion_models[-1] + # elif isinstance(motion_model_for_new_star, str): + # assert motion_model_for_new_star in all_mm_map.keys(), f"motion_model_for_new_star must be in {list(all_mm_map.keys())}" + # self.motion_model_for_new_star = all_mm_map[motion_model_for_new_star] + # For backwards compatibility. - if self.verbose is True: - self.verbose = 9 - if self.verbose is False: - self.verbose = 0 - + # if self.verbose is True: + # self.verbose = 9 + # if self.verbose is False: + # self.verbose = 0 + self.N_lists = len(self.star_lists) # Hard-coded values: @@ -233,45 +311,40 @@ def = None. If not None, then this should contain an array or list of transform # is passed in, replicate for all star lists, all loop iterations. ########## self.setup_trans_info() - - # Make sure the motion models are ready - self.motion_model_dict = motion_model.validate_motion_model_dict(self.motion_model_dict, - StarTable(), self.default_motion_model) - return def fix_iterable_conditions(self): if not np.iterable(self.dr_tol): self.dr_tol = np.repeat(self.dr_tol, self.iters) - assert len(self.dr_tol) == self.iters + assert len(self.dr_tol) == self.iters, f'len(dr_tol)={len(self.dr_tol)} != iters={self.iters}' if not np.iterable(self.dm_tol): self.dm_tol = np.repeat(self.dm_tol, self.iters) - assert len(self.dm_tol) == self.iters + assert len(self.dm_tol) == self.iters, f'len(dm_tol)={len(self.dm_tol)} != iters={self.iters}' if not np.iterable(self.outlier_tol): self.outlier_tol = np.repeat(self.outlier_tol, self.iters) - assert len(self.outlier_tol) == self.iters + assert len(self.outlier_tol) == self.iters, f'len(outlier_tol)={len(self.outlier_tol)} != iters={self.iters}' if self.mag_lim is None: self.mag_lim = np.repeat([[None, None]], len(self.star_lists), axis=0) - elif (len(self.mag_lim) == 2): + elif (len(self.mag_lim) == 2) and (np.ndim(self.mag_lim) == 1): self.mag_lim = np.repeat([self.mag_lim], len(self.star_lists), axis=0) assert len(self.mag_lim) == len(self.star_lists) return - - + + def fit(self): """ Using the current parameter settings, match and transform all the lists to a reference position. Note in the first pass, the reference position is just the specified input reference starlist. In subsequent iterations, - this is updated. + this is updated. The ultimate outcome is the creation of self.ref_table. This reference table will contain "averaged" quantites as well as a big 2D array of all - the matched original and transformed quantities. + the matched original and transformed quantities. Averaged columns on ref_table: x0 @@ -283,6 +356,45 @@ def fit(self): additional motion_model columns """ + # Setup save_path: + if self.save_path: + if not os.path.exists(os.path.dirname(self.save_path)): + os.makedirs(os.path.dirname(self.save_path)) + + # Save input params + input_filename = f'{self.prefix_name}_input.txt' + input_dict = { + 'ref_index': self.ref_index, + 'iters': self.iters, + 'dr_tol': self.dr_tol, + 'dm_tol': self.dm_tol, + 'outlier_tol': self.outlier_tol, + 'trans_class': self.trans_class, + 'trans_args': self.trans_args, + 'trans_input': self.trans_input, + 'trans_weighting': self.trans_weighting, + 'init_order': self.init_order, + 'init_guess_mode': self.init_guess_mode, + 'calc_trans_inverse': self.calc_trans_inverse, + 'mag_trans': self.mag_trans, + 'mag_lim': self.mag_lim, + 'motion_models': self.motion_models, + 'fixed_params_dict': self.fixed_params_dict, + 'vel_weighting': self.vel_weighting, + 'use_scipy': self.use_scipy, + 'absolute_sigma': self.absolute_sigma, + 'iter_callback': self.iter_callback, + 'save_path': self.save_path, + 'prefix_name': self.prefix_name, + 'verbose': self.verbose + } + if self.save_path is not None: + if not os.path.exists(self.save_path): + os.makedirs(self.save_path) + with open(os.path.join(self.save_path, input_filename), 'w') as file: + for key, value in input_dict.items(): + file.write(f'{key}:\t{value}\n') + ########## # Setup a reference table to store data. It will contain: # x0, y0, m0 -- the running average of positions: 1D @@ -290,7 +402,7 @@ def fit(self): # x_orig, y_orig, m_orig, (opt. errors) -- the transformed errors for the lists: 2D # w, w_orig (optiona) -- the input and output weights of stars in transform: 2D ########## - self.ref_table = self.setup_ref_table_from_starlist(self.star_lists[self.ref_index],motion_model_used='Fixed') + self.ref_table = self.setup_ref_table_from_starlist(self.star_lists[self.ref_index]) # Save the reference index to the meta data on the reference list. self.ref_table.meta['ref_list'] = self.ref_index @@ -300,8 +412,8 @@ def fit(self): # ########## for nn in range(self.iters): - - # If we are on subsequent iterations, remove matching results from the + + # If we are on subsequent iterations, remove matching results from the # prior iteration. This leaves aggregated (1D) columns alone. if nn > 0: self.reset_ref_values() @@ -315,10 +427,10 @@ def fit(self): print("**********") # ALL the action is in here. Match and transform the stack of starlists. - # This updates trans objects and the ref_table. + # This updates trans objects and the ref_table. self.match_and_transform(self.mag_lim[self.ref_index], self.dr_tol[nn], self.dm_tol[nn], self.outlier_tol[nn], - self.trans_args[nn]) + self.trans_args[nn], nn) # Clean up the reference table # Find where stars are detected. @@ -326,18 +438,19 @@ def fit(self): ### Drop all stars that have 0 detections. idx = np.where((self.ref_table['n_detect'] == 0))[0] - print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) + if self.verbose: + print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) self.ref_table.remove_rows(idx) if self.iter_callback != None: self.iter_callback(self.ref_table, nn) - + ########## # # Re-do all matching given final transformations. # No trimming this time. - # First rest the reference table 2D values. + # First rest the reference table 2D values. ########## self.reset_ref_values(exclude=['used_in_trans']) @@ -352,39 +465,75 @@ def fit(self): ########## # Clean up output table. - # + # ########## # Find where stars are detected. if self.verbose > 0: print('') print(' Preparing the reference table...') - + self.ref_table.detections() ### Drop all stars that have 0 detections. idx = np.where((self.ref_table['n_detect'] == 0))[0] - print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) + if self.verbose: + print(f' *** Getting rid of {len(idx):d} out of {len(self.ref_table):d} junk sources') self.ref_table.remove_rows(idx) if self.iter_callback != None: self.iter_callback(self.ref_table, nn) - - if self.save_path: - with open(self.save_path, 'wb') as file: + + # Add times into ref_table meta data + # complete_times = np.array([np.unique(col[~np.isnan(col)])[0] for col in self.ref_table['t'].T]) + all_epochs = get_all_epochs(self.ref_table) + self.ref_table.meta['list_times'] = list(all_epochs) + + # Update chi2 values in ref table, as motion_model_used may have changed + x_inferred, y_inferred, _, _ = self.ref_table.infer_positions(all_epochs) + # Ensure x_inferred and y_inferred is 2D for chi2 calculation + if x_inferred.ndim == 1: + x_inferred = x_inferred[:, np.newaxis] + if y_inferred.ndim == 1: + y_inferred = y_inferred[:, np.newaxis] + chi2_x_2d = ((self.ref_table['x'] - x_inferred) / self.ref_table['xe'])**2 + chi2_y_2d = ((self.ref_table['y'] - y_inferred) / self.ref_table['ye'])**2 + chi2_x = np.nansum(chi2_x_2d, axis=1) + chi2_y = np.nansum(chi2_y_2d, axis=1) + chi2_x[~np.isfinite(chi2_x_2d).any(axis=1)] = np.nan + chi2_y[~np.isfinite(chi2_y_2d).any(axis=1)] = np.nan + self.ref_table['chi2_x'] = chi2_x + self.ref_table['chi2_y'] = chi2_y + + if self.save_path is not None: + filename = f'{self.prefix_name}.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: pickle.dump(self, file) + # Using pickle here because nan in a fits file is auto-converted to a masked value in astropy.io.fits.open() + filename = f'{self.prefix_name}_ref_table.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: + pickle.dump(self.ref_table, file) + + if self.verbose > 0: + print('===================================') + print('========== Done with fit ==========') + print('===================================') return - def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_args): + def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_args, nn=None): """ Given some reference list of positions, loop through all the starlists transform and match them. """ + if self.starlist_vertices is not None: + import shapely for ii in range(len(self.star_lists)): if self.verbose > 0: msg = ' Matching catalog {0} / {1} with {2:d} stars' msg2 = ' {0:8s} < {1:0.3f}' print(" ") print(" **********") + if nn is not None: + print(f" Iteration {nn+1} / {self.iters}") print(msg.format((ii + 1), len(self.star_lists), len(self.star_lists[ii]))) print(msg2.format('dr', dr_tol)) print(msg2.format('|dm|', dm_tol)) @@ -407,18 +556,29 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar ### Initial match and transform: 1st order (if we haven't already). if trans is None: # Only use "use_in_trans" reference stars, even for initial guessing. - keepers = np.where(ref_list['use_in_trans'] == True)[0] - - trans = trans_initial_guess(ref_list[keepers], star_list_orig_trim, self.trans_args[0], self.motion_model_dict, - mode=self.init_guess_mode, - order=self.init_order, - verbose=self.verbose, - mag_trans=self.mag_trans) + keepers = ref_list['use_in_trans'] + trans = trans_initial_guess( + ref_list=ref_list[keepers], + star_list=star_list_orig_trim, + trans_args=self.trans_args[0], + mode=self.init_guess_mode, + order=self.init_order, + briteN=self.briteN, + polygon_reflist=self.reflist_polygon, + polygon_starlist=shapely.Polygon(self.starlist_vertices[ii]) if self.starlist_vertices is not None else None, + buffer=dr_tol, + motion_models=self.motion_models, + fixed_params_dict=self.fixed_params_dict, + mag_trans=self.mag_trans, + verbose=self.verbose + ) + if np.isnan(trans.px.parameters).any() or np.isnan(trans.py.parameters).any(): + raise ValueError(f"Initial transformation contains NaN parameters. trans.px={trans.px.parameters}, trans.py={trans.py.parameters}.") if self.mag_trans: star_list_T.transform_xym(trans) # trimmed, transformed else: - star_list_T.transform_xy(trans) + star_list_T.transform_xy(trans) # Match stars between the transformed, trimmed lists. idx1, idx2, dr, dm = match.match(star_list_T['x'], star_list_T['y'], star_list_T['m'], @@ -430,31 +590,30 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar # Outlier rejection if outlier_tol != None: - keepers = self.outlier_rejection_indices(star_list_T[idx1], ref_list[idx2], - outlier_tol) + keepers = self.outlier_rejection_indices(star_list_T[idx1], ref_list[idx2], outlier_tol, verbose=self.verbose) if self.verbose > 1: - print( ' Rejected ', len(idx1) - len(keepers), ' outliers.' ) - + print( ' Rejected ', len(idx1) - sum(keepers), ' outliers.' ) + idx1 = idx1[keepers] idx2 = idx2[keepers] # Only use stars specified by "use_in_trans" column. if 'use_in_trans' in ref_list.colnames: - keepers = np.where(ref_list[idx2]['use_in_trans'] == True)[0] - + keepers = ref_list[idx2]['use_in_trans'] + if self.verbose > 1: - print( ' Rejected ', len(idx1) - len(keepers), ' with use_in_trans=False.' ) - + print( ' Rejected ', len(idx1) - sum(keepers), ' with use_in_trans=False.' ) + idx1 = idx1[keepers] idx2 = idx2[keepers] # Determine weights in the fit. weight = self.get_weights_for_lists(ref_list[idx2], star_list_T[idx1]) - # Derive the best-fit transformation parameters. + # Derive the best-fit transformation parameters. if self.verbose > 1: print( ' Using ', len(idx1), ' stars in transformation.' ) - trans = self.trans_class.derive_transform(star_list_orig_trim['x'][idx1], star_list_orig_trim['y'][idx1], + trans = self.trans_class.derive_transform(star_list_orig_trim['x'][idx1], star_list_orig_trim['y'][idx1], ref_list['x'][idx2], ref_list['y'][idx2], **trans_args, m=star_list_orig_trim['m'][idx1], mref=ref_list['m'][idx2], @@ -492,7 +651,7 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar ml='m_lis_T', mr='m_ref', dx='dx_mpix', dy='dy_mpix', dm='dm', xo='x_orig', yo='y_orig', mo='m_orig')) - + fmt = '{nr:20s} {n:20s} {xl:9.5f} {xr:9.5f} {yl:9.5f} {yr:9.5f} {ml:6.2f} {mr:6.2f} ' fmt += '{dx:7.2f} {dy:7.2f} {dm:6.2f} {xo:9.5f} {yo:9.5f} {mo:6.2f}' for foo in range(len(idx1)): @@ -502,38 +661,43 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar print(fmt.format(nr=star_r['name'], n=star_s['name'], xl=star_t['x'], xr=star_r['x'], yl=star_t['y'], yr=star_r['y'], ml=star_t['m'], mr=star_r['m'], - dx=(star_t['x'] - star_r['x']) * 1e3, + dx=(star_t['x'] - star_r['x']) * 1e3, dy=(star_t['y'] - star_r['y']) * 1e3, dm=(star_t['m'] - star_r['m']), xo=star_s['x'], yo=star_s['y'], mo=star_s['m'])) - + idx_lis, idx_ref, dr, dm = match.match(star_list_T['x'], star_list_T['y'], star_list_T['m'], ref_list['x'], ref_list['y'], ref_list['m'], dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose) - + if self.verbose > 1: print( ' Match 2: After trans, found ', len(idx_lis), ' matches out of ', len(star_list_T), '. If match count is low, check dr_tol, dm_tol.' ) ## Make plot, if desired - plots.trans_positions(ref_list, ref_list[idx_ref], star_list_T, star_list_T[idx_lis], - fileName='{0}'.format(star_list_T['t'][0])) - + if self.save_path: + plots.trans_positions(ref_list, ref_list[idx_ref], star_list_T, star_list_T[idx_lis], + save_path=os.path.join(self.save_path, f"Transformed_Positions_{ii}_{star_list_T['t'][0]}.png"), + show_plot=False) ### Update the observed (but transformed) values in the reference table. self.update_ref_table_from_list(star_list, star_list_T, ii, idx_ref, idx_lis, idx2) ### Update the "average" values to be used as the reference frame for the next list. - keep_ref_orig = (self.update_ref_orig==False) or (self.update_ref_orig=='atend') or (self.update_ref_orig=='periter' and ii<(len(self.star_lists)-1)) - if keep_ref_orig and ii<(len(self.star_lists)-1): - keep_orig = np.where(self.ref_table['ref_orig'] | np.isnan(self.ref_table['x'][:,ii]))[0] + keep_ref_orig = (self.update_ref_orig==False) or (self.update_ref_orig=='atend') or (self.update_ref_orig=='periter' and ii<(len(self.star_lists) - 1)) + if keep_ref_orig and ii < (len(self.star_lists) - 1): + keep_orig = self.ref_table['ref_orig'] | np.isnan(self.ref_table['x'][:,ii]) elif keep_ref_orig: - keep_orig = np.where(self.ref_table['ref_orig'])[0] - elif ii<(len(self.star_lists)-1): - keep_orig = np.where(np.isnan(self.ref_table['x'][:,ii]))[0] + keep_orig = self.ref_table['ref_orig'] + elif ii < (len(self.star_lists) - 1): + keep_orig = np.isnan(self.ref_table['x'][:,ii]) else: keep_orig=None self.update_ref_table_aggregates(keep_orig=keep_orig) - + + # Update ref list polygon + if self.starlist_vertices is not None: + self.reflist_polygon = shapely.make_valid(self.reflist_polygon.union(shapely.Polygon(self.starlist_vertices[ii]))) + # Print out some metrics if self.verbose > 0: msg1 = ' {0:2s} (mean and std) for {1:10s}: {2:8.5f} +/- {3:8.5f}' @@ -544,7 +708,7 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar # Calculate the residuals just for those used in the transformation used = np.where(self.ref_table['used_in_trans'][:, ii] == True)[0] used_good = used[ np.where(np.isin(used, idx_ref) == True)[0] ] - + dr_u = np.hypot(self.ref_table['x'][used_good, ii] - ref_list['x'][used_good], self.ref_table['y'][used_good, ii] - ref_list['y'][used_good]) dm_u = np.abs(self.ref_table['m'][used_good, ii] - ref_list['m'][used_good]) @@ -552,9 +716,9 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar print(msg1.format('dm', 'trans stars', dm_u.mean(), dm_u.std())) print(' Used {0:d} trans ref stars.'.format(len(used))) print(' Dropped {0:d} matches after transform.'.format(len(used) - len(used_good))) - + gc.collect() # clean up memory after each iteration return - + def setup_trans_info(self): """ Setup transformation info into a usable format. @@ -567,7 +731,7 @@ def setup_trans_info(self): trans_args = self.trans_args N_lists = len(self.star_lists) iters = self.iters - + trans_list = [None for ii in range(N_lists)] if trans_input != None: trans_list = [trans_input[ii] for ii in range(N_lists)] @@ -583,20 +747,21 @@ def setup_trans_info(self): # Add inverse trans list, if desired if self.calc_trans_inverse: - trans_list_inverse = [None for ii in range(N_lists)] + trans_list_inverse = [None] * N_lists self.trans_list_inverse = trans_list_inverse return - def setup_ref_table_from_starlist(self, star_list, motion_model_used=None): - """ + def setup_ref_table_from_starlist(self, star_list): + """ Start with the reference list.... this will change and grow over time, so make a copy that we will keep updating. The reference table will contain one column for every named array in the original reference star list. """ col_arrays = {} - motion_model_col_names = motion_model.get_all_motion_model_param_names(with_errors=True, with_fixed=True) + ['m0','m0_err','use_in_trans', 'motion_model_input', 'motion_model_used'] + + motion_model_col_names = motion_model.all_motion_model_param_names(with_errors=True, with_fixed=True) + ['m0','m0_err','use_in_trans', 'motion_model_input', 'motion_model_used'] for col_name in star_list.colnames: if col_name == 'name': # The "name" column will be 1D; but we will also add a "name_in_list" column. @@ -605,20 +770,20 @@ def setup_ref_table_from_starlist(self, star_list, motion_model_used=None): else: new_col_name = col_name - # Make every column's 2D arrays except "name" and those + # Make every column's 2D arrays per star except "name" and those # columns used for the motion model. if col_name in motion_model_col_names: col_arrays[new_col_name] = star_list[col_name].data else: - new_col_data = np.array([star_list[col_name].data]).T + new_col_data = star_list[col_name].data[:, None] col_arrays[new_col_name] = new_col_data # Use the columns from the ref list to make the ref_table. ref_table = StarTable(**col_arrays) - + # Make new columns to hold original values. These will be copies # of the old columns and will only include x, y, m, xe, ye, me. - # The columns we have already created will hold transformed values. + # The columns we have already created will hold transformed values. trans_col_names = ['x', 'y', 'm', 'xe', 'ye', 'me', 'w'] for tt in range(len(trans_col_names)): old_name = trans_col_names[tt] @@ -630,19 +795,18 @@ def setup_ref_table_from_starlist(self, star_list, motion_model_used=None): # Make sure ref_table has the necessary x0, y0, m0 and associated # error columns. If they don't exist, then add them as a copy of - # the original x,y,m etc columns. + # the original x,y,m etc columns. new_cols_arr = ['x0', 'y0', 'm0'] orig_cols_arr = ['x', 'y', 'm'] ref_cols = ref_table.keys() - for ii in range(len(new_cols_arr)): - if not new_cols_arr[ii] in ref_cols: + for new_col, orig_col in zip(new_cols_arr, orig_cols_arr): + if new_col not in ref_cols: # Some munging to convert data shape from (N,1) to (N,), # since these are all 1D cols - vals = np.transpose(np.array(ref_table[orig_cols_arr[ii]]))[0] + vals = np.array(ref_table[orig_col]).flatten() # Now add to ref_table - new_col = Column(vals, name=new_cols_arr[ii]) - ref_table.add_column(new_col) + ref_table.add_column(vals, name=new_col) # Do the same thing for the x0e, y0e, m0e columns, but # ONLY IF THEY ALREADY EXIST IN REF_TABLE! Otherwise, @@ -651,64 +815,63 @@ def setup_ref_table_from_starlist(self, star_list, motion_model_used=None): # work later on. new_err_cols = ['x0_err', 'y0_err', 'm0_err'] orig_err_cols = ['xe', 'ye', 'me'] - for ii in range(len(new_err_cols)): + for new_err_col, orig_err_col in zip(new_err_cols, orig_err_cols): # If the orig col name (e.g. xe) is in the ref_table, but the new col name # (e.g. x0e) doesn't exist, then add the x0e column as a duplicate of xe. - if (orig_err_cols[ii] in ref_cols) & (not new_err_cols[ii] in ref_cols): + if (orig_err_col in ref_cols) and (new_err_col not in ref_cols): # Some munging to convert data shape from (N,1) to (N,), # since these are all 1D cols - vals = np.transpose(np.array(ref_table[orig_err_cols[ii]]))[0] + vals = np.transpose(np.array(ref_table[orig_err_col]))[0] # Now add to ref_table - new_col = Column(vals, name=new_err_cols[ii]) - ref_table.add_column(new_col) - elif (not orig_err_cols[ii] in ref_cols) & (not new_err_cols[ii] in ref_cols): + ref_table.add_column(vals, name=new_err_col) + elif (orig_err_col not in ref_cols) and (new_err_col not in ref_cols): # If neither the orig_err_col or new_err_col is in the ref_table, put in the # new_err_cols as an array of zeros vals = np.zeros(len(ref_table)) - new_col = Column(vals, name=new_err_cols[ii]) - ref_table.add_column(new_col) + ref_table.add_column(vals, name=new_err_col) # Final check: ref_table should now have x0, y0, m0, x0e, y0e, and m0e columns # This is necessary for later steps, even if the columns are just zeros. final_new_cols = np.concatenate((new_cols_arr, new_err_cols)) for ii in final_new_cols: - assert ii in ref_table.keys() - + assert ii in ref_table.keys(), f"ref_table is missing necessary column {ii}." + # Make sure we have a column to indicate whether each star # CAN BE USED in the transformation. This will be 1D if 'use_in_trans' not in ref_table.colnames: - new_col = Column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') - ref_table.add_column(new_col) + ref_table.add_column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') # Make sure we have a column to indicate whether each star # IS USED in the transformation. This will be 2D if 'used_in_trans' not in ref_table.colnames: - new_col = Column(np.zeros([len(ref_table),1], dtype=bool), name='used_in_trans') - ref_table.add_column(new_col) - + ref_table.add_column(np.zeros([len(ref_table), 1], dtype=bool), name='used_in_trans') + # Keep track of whether this is an original reference star. - col_ref_orig = Column(np.ones(len(ref_table), dtype=bool), name='ref_orig') - ref_table.add_column(col_ref_orig) + ref_table.add_column(np.ones(len(ref_table), dtype=bool), name='ref_orig') # Now reset the original values to invalids... they will be filled in # at later times. Preserve content only in the columns: name, x0, y0, m0 (and 0e). # Note that these are all the 1D columsn. for col_name in ref_table.colnames: if len(ref_table[col_name].data.shape) == 2: # Find the 2D columns ref_table._set_invalid_list_values(col_name, -1) - + if 'motion_model_input' not in ref_table.colnames: - ref_table.add_column(Column(np.repeat(self.default_motion_model, len(ref_table)), name='motion_model_input')) - if 'motion_model_used' not in ref_table.colnames: - if motion_model_used is None: - ref_table.add_column(Column(np.repeat(self.default_motion_model, len(ref_table)), name='motion_model_used')) - else: - ref_table.add_column(Column(np.repeat(motion_model_used, len(ref_table)), name='motion_model_used')) + ref_table.add_column(np.repeat(self.motion_models[-1].name, len(ref_table)), name='motion_model_input') + # FIXME: Why do we need to set motion_model_used here before fitting? + # if 'motion_model_used' not in ref_table.colnames: + # # Order self.motion_models by decreasing n_params + # sorted_mms = sorted(self.motion_models, key=lambda mm: mm.n_params, reverse=True) + # # Save the most complex motion model that can infer the positions with the existing columns. + # for mm in sorted_mms: + # if all([_ in ref_table.colnames for _ in mm.fit_param_names]) and all([_ in ref_table.colnames for _ in mm.fixed_param_names]): + # ref_table.add_column(np.repeat(mm.name, len(ref_table)), name='motion_model_used') + # break return ref_table def apply_mag_lim_via_use_in_trans(self, ref_list, ref_mag_lim): - """Set the use_in_trans flag to False for any star in the - star list that falls beyond the magnitude limits. + """Set the use_in_trans flag to False for any star in the + star list that falls beyond the magnitude limits. This should really only be applied to reference star lists. """ @@ -719,21 +882,20 @@ def apply_mag_lim_via_use_in_trans(self, ref_list, ref_mag_lim): else: mcol = 'm' - no_use = np.where((ref_list[mcol] < ref_mag_lim[0]) | - (ref_list[mcol] >= ref_mag_lim[1])) + no_use = (ref_list[mcol] < ref_mag_lim[0]) | (ref_list[mcol] >= ref_mag_lim[1]) ref_list['use_in_trans'][no_use] = False - + return def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=True): """ Determine the outliers based on the residual positions between two different - starlists and some threshold (in sigma). Return the indices of the stars - to keep (that shouldn't be rejected as outliers). + starlists and some threshold (in sigma). Return the indices of the stars + to keep (that shouldn't be rejected as outliers). Note that we assume that the star_list and ref_list are already transformed and - matched. + matched. Parameters ---------- @@ -744,8 +906,8 @@ def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=Tr starlist with 'x0', 'y0' outlier_tol : float - Number of sigma inside which we keep stars and outside of which we - reject stars as outliers. + Number of sigma inside which we keep stars and outside of which we + reject stars as outliers. Optional Parameters -------------------- @@ -753,8 +915,8 @@ def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=Tr Returns ---------- - keepers : nd.array - The indicies of the stars to keep. + keepers : boolean array + The boolean array of the stars to keep. """ # Optionally propogate the reference positions forward in time. xref = ref_list['x'] @@ -766,11 +928,11 @@ def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=Tr resid_on_old_trans = np.hypot(x_resid_on_old_trans, y_resid_on_old_trans) threshold = outlier_tol * resid_on_old_trans.std() - keepers = np.where(resid_on_old_trans < threshold)[0] + keepers = resid_on_old_trans < threshold if verbose: msg = ' Outlier Rejection: Keeping {0:d} of {1:d}' - print(msg.format(len(keepers), len(resid_on_old_trans))) + print(msg.format(sum(keepers), len(resid_on_old_trans))) return keepers @@ -779,7 +941,7 @@ def update_ref_table_from_list(self, star_list, star_list_T, ii, idx_ref, idx_li Inputs ---------- star_list : StarList - The original star list. + The original star list. star_list_T : StarList The original star list now transformed into the reference coordinate system. @@ -794,7 +956,7 @@ def update_ref_table_from_list(self, star_list, star_list_T, ii, idx_ref, idx_li The indices of the matched targets in the origin starlist (epoch). idx_ref_in_trans : np.array dtype=int - The indices in the reference table (self.ref_table). + The indices in the reference table (self.ref_table). """ ### Update the reference table for matched stars. # Add the matched stars to the reference table. @@ -802,94 +964,135 @@ def update_ref_table_from_list(self, star_list, star_list_T, ii, idx_ref, idx_li if ((self.ref_table['x'].shape[1] != len(self.star_lists)) and (ii != self.ref_index) and (ii >= self.ref_table['x'].shape[1])): - + self.ref_table.add_starlist() - + copy_over_values(self.ref_table, star_list, star_list_T, ii, idx_ref, idx_lis) self.ref_table['used_in_trans'][idx_ref_in_trans, ii] = True ### Add the unmatched stars and grow the size of the reference table. - self.ref_table, idx_lis_new, idx_ref_new = add_rows_for_new_stars(self.ref_table, star_list, idx_lis, - default_motion_model=self.default_motion_model) + self.ref_table, idx_lis_new, idx_ref_new = add_rows_for_new_stars( + self.ref_table, + star_list, + idx_lis, + # motion_model_name=self.motion_model_for_new_star.name + motion_model_name=self.motion_models[-1].name, + fixed_params_dict=self.fixed_params_dict + ) + if len(idx_ref_new) > 0: if self.verbose > 0: print(' Adding {0:d} new stars to the reference table.'.format(len(idx_ref_new))) - + copy_over_values(self.ref_table, star_list, star_list_T, ii, idx_ref_new, idx_lis_new) # Copy the single-epoch values to the aggregate (only for new stars). self.ref_table['x0'][idx_ref_new] = star_list_T['x'][idx_lis_new] self.ref_table['y0'][idx_ref_new] = star_list_T['y'][idx_lis_new] self.ref_table['m0'][idx_ref_new] = star_list_T['m'][idx_lis_new] - + self.ref_table['name'] = update_old_and_new_names(self.ref_table, ii, idx_ref_new) if self.use_ref_new == True: self.ref_table['use_in_trans'][idx_ref_new] = True else: self.ref_table['use_in_trans'][idx_ref_new] = False - + return - - def update_ref_table_aggregates(self, keep_orig=None, n_boot=0): - """ - Average positions or fit velocities. + + def update_ref_table_aggregates(self, keep_orig=None, n_boot=0, seed=None): + """ Average positions or fit velocities. Average magnitudes. Calculate bootstrap errors if desired. - Update the use_in_trans values as needed. TODO: ???? + Update the use_in_trans values as needed. TODO: ????. Updates aggregate columns in self.ref_table in place. + + + Parameters + ---------- + keep_orig : array-like of bool, optional + Boolean array indicating which stars to keep original values for, by default None + n_boot : int, optional + Number of bootstrap iterations, by default 0 + seed : int, optional + Random seed for reproducible bootstrap results, by default None + """ # Keep track of the original reference values. # In certain cases, we will NOT update these. - if keep_orig is not None: + if (keep_orig is not None) and (sum(keep_orig) > 0): vals_orig = {} vals_orig['m0'] = self.ref_table['m0'][keep_orig] vals_orig['m0_err'] = self.ref_table['m0_err'][keep_orig] - motion_model_class_names = self.ref_table['motion_model_input'].tolist() + # Collect all motion model parameter names + motion_model_class_names = [] + if 'motion_model_input' in self.ref_table.keys(): + motion_model_class_names += self.ref_table['motion_model_input'].tolist() if 'motion_model_used' in self.ref_table.keys(): motion_model_class_names += self.ref_table['motion_model_used'][keep_orig].tolist() vals_orig['motion_model_used'] = self.ref_table['motion_model_used'][keep_orig] - motion_model_col_names = motion_model.get_list_motion_model_param_names(motion_model_class_names, with_errors=True, with_fixed=True) + vals_orig['n_params'] = self.ref_table['n_params'][keep_orig] + # vals_orig['n_fit'] = self.ref_table['n_fit'][keep_orig] + motion_model_col_names = motion_model.motion_model_param_names(motion_model_class_names, with_errors=True, with_fixed=True) for mm in motion_model_col_names: - if mm in self.ref_table.keys(): + if f'{mm}_mm' in self.ref_table.keys(): + vals_orig[mm] = self.ref_table[mm][keep_orig] + elif mm in self.ref_table.keys(): vals_orig[mm] = self.ref_table[mm][keep_orig] - fit_star_idxs = [idx for idx in range(len(self.ref_table)) if idx not in keep_orig] + fit_star_idxs = ~keep_orig else: fit_star_idxs = None - #pdb.set_trace() - # Figure out whether motion fits are necessary - all_fixed = np.all(self.ref_table['motion_model_input']=='Fixed') - if all_fixed: + + if ('motion_model_input' in self.ref_table.keys()) and np.all(self.ref_table['motion_model_input']=='Fixed'): + # self.ref_table.fit_motion_models( + # motion_models=['Fixed'], + # weighting=self.vel_weighting, + # use_scipy=self.use_scipy, + # absolute_sigma=self.absolute_sigma, + # verbose=self.verbose + # ) weighted_xy = ('xe' in self.ref_table.colnames) and ('ye' in self.ref_table.colnames) weighted_m = ('me' in self.ref_table.colnames) self.ref_table.combine_lists_xym(weighted_xy=weighted_xy, weighted_m=weighted_m) else: - # Combine positions with a velocity fit. - self.ref_table.fit_velocities(bootstrap=n_boot, - verbose=self.verbose, - show_progress=(self.verbose>0), - default_motion_model=self.default_motion_model, - select_stars=fit_star_idxs, - motion_model_dict=self.motion_model_dict, - weighting=self.vel_weights, - use_scipy=self.use_scipy, - absolute_sigma=self.absolute_sigma) - + self.ref_table.fit_motion_models( + motion_models=self.motion_models, + fixed_params_dict=self.fixed_params_dict, + weighting=self.vel_weighting, + use_scipy=self.use_scipy, + absolute_sigma=self.absolute_sigma, + select_stars=fit_star_idxs, + bootstrap=n_boot, + seed=seed, + verbose=self.verbose + ) # Combine (transformed) magnitudes if 'me' in self.ref_table.colnames: weights_col = None else: weights_col = 'me' self.ref_table.combine_lists('m', weights_col=weights_col, ismag=True) + + # if (keep_orig is not None) and (sum(keep_orig) > 0): + # Determine motion_model_used for keep_orig stars + # Filter possible motion models based on available columns + motion_model_used, n_params = determine_motion_model(self.ref_table, self.motion_models, self.fixed_params_dict) + + # Assign the determined motion models + # self.ref_table['motion_model_used'][keep_orig] = motion_model_used + self.ref_table['motion_model_used'] = Column(motion_model_used, name='motion_model_used', dtype='U20') + # self.ref_table['n_fit'] = Column(n_params, name='n_fit', dtype=int) + self.ref_table['n_params'] = Column(n_params, name='n_params', dtype=int) + # Replace the originals if we are supposed to keep them fixed. - if keep_orig is not None: + if (keep_orig is not None) and (sum(keep_orig) > 0): for val in vals_orig.keys(): self.ref_table[val][keep_orig] = vals_orig[val] return - + def get_weights_for_lists(self, ref_list, star_list): if 'xe' in ref_list.colnames: var_xref = ref_list['xe']**2 @@ -897,7 +1100,7 @@ def get_weights_for_lists(self, ref_list, star_list): else: var_xref = 0.0 var_yref = 0.0 - + if 'xe' in star_list.colnames: var_xlis = star_list['xe']**2 var_ylis = star_list['ye']**2 @@ -905,19 +1108,19 @@ def get_weights_for_lists(self, ref_list, star_list): var_xlis = 0.0 var_ylis = 0.0 - if self.trans_weights != None: - if self.trans_weights == 'both,var': + if self.trans_weighting != None: + if self.trans_weighting == 'both,var': weight = 1.0 / (var_xref + var_xlis + var_yref + var_ylis) - if self.trans_weights == 'both,std': + if self.trans_weighting == 'both,std': weight = 1.0 / np.sqrt(var_xref + var_xlis + var_yref + var_ylis) - if self.trans_weights == 'ref,var': + if self.trans_weighting == 'ref,var': weight = 1.0 / (var_xref + var_yref) - if self.trans_weights == 'ref,std': + if self.trans_weighting == 'ref,std': weight = 1.0 / np.sqrt(var_xref + var_yref) - if self.trans_weights == 'list,var': + if self.trans_weighting == 'list,var': weight = 1.0 / (var_xlis + var_ylis) - if self.trans_weights == 'list,std': - weight = 1.0 / np.sqrt(var_xlis, var_ylis) + if self.trans_weighting == 'list,std': + weight = 1.0 / np.sqrt(var_xlis + var_ylis) else: weight = None @@ -936,16 +1139,20 @@ def get_weights_for_lists(self, ref_list, star_list): # Fix bad weights: weight[bad] = 0.0 + if weight is not None and np.all(weight == 0.0): + # Catch the case where all weights were bad. + weight = None + return weight - + def match_lists(self, dr_tol, dm_tol): """ Using the existing trans objects, match all the starlists to the - reference starlist (self.ref_table), propogated to the appropriate epoch. + reference starlist (self.ref_table), propogated to the appropriate epoch. No trimming of stars. - No new transformations derived. + No new transformations derived. The resulting matched values will be used to update self.ref_table """ @@ -957,16 +1164,16 @@ def match_lists(self, dr_tol, dm_tol): star_list_T.transform_xym(self.trans_list[ii]) else: star_list_T.transform_xy(self.trans_list[ii]) - - xref, yref = get_pos_at_time(star_list_T['t'][0], self.ref_table, self.motion_model_dict) + + xref, yref = infer_positions(star_list_T['t'][0], self.ref_table, self.motion_models, self.fixed_params_dict) mref = self.ref_table['m0'] idx_lis, idx_ref, dr, dm = match.match(star_list_T['x'], star_list_T['y'], star_list_T['m'], xref, yref, mref, dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose) - + if self.verbose > 0: - fmt = 'Matched {0:5d} out of {1:5d} stars in list {2:2d} [dr = {3:7.4f} +/- {4:6.4f}, dm = {5:5.2f} +/- {6:4.2f}' + fmt = 'Matched {0:5d} out of {1:5d} stars in list {2:2d} [dr = {3:7.4f} ± {4:6.4f}, dm = {5:5.2f} ± {6:4.2f}]' print(fmt.format(len(idx_lis), len(star_list_T), ii, dr.mean(), dr.std(), dm.mean(), dm.std())) copy_over_values(self.ref_table, self.star_lists[ii], star_list_T, ii, idx_ref, idx_lis) @@ -976,7 +1183,7 @@ def match_lists(self, dr_tol, dm_tol): def get_ref_list_from_table(self, epoch): """ Convert the averaged quantites in self.ref_table into a StarList object - appropriate for the specified epoch. + appropriate for the specified epoch. Columns in resulting reference list will include: name @@ -988,25 +1195,20 @@ def get_ref_list_from_table(self, epoch): me (optional) use_in_trans (optional) """ - # Reference stars will be named. + # Reference stars will be named. name = self.ref_table['name'] + # Calculate x, y, xe, ye - if ('motion_model_used' in self.ref_table.colnames): - x,y,xe,ye = self.ref_table.get_star_positions_at_time(epoch, self.motion_model_dict, allow_alt_models=True) - else: - # No velocities... just used average positions. - x = self.ref_table['x0'] - y = self.ref_table['y0'] - - if 'x0_err' in self.ref_table.colnames: - xe = self.ref_table['x0_err'] - ye = self.ref_table['y0_err'] - else: - xe = None - ye = None + if 'motion_model_used' not in self.ref_table.colnames: + motion_model_used, n_params = determine_motion_model(self.ref_table, self.motion_models, self.fixed_params_dict) + self.ref_table['motion_model_used'] = Column(motion_model_used, name='motion_model_used', dtype='U20') + # self.ref_table['n_fit'] = Column(n_params, name='n_fit', dtype=int) + self.ref_table['n_params'] = Column(n_params, name='n_params', dtype=int) + + x, y, xe, ye = self.ref_table.infer_positions(epoch, fixed_params_dict=self.fixed_params_dict) m = self.ref_table['m0'] - + if 'm0_err' in self.ref_table.colnames: me = self.ref_table['m0_err'] else: @@ -1036,32 +1238,32 @@ def reset_ref_values(self, exclude=None): """ Reset all the 2D arrays in the reference table. This is the action we take at the beginning of each new iteration. We don't preserve matching - results from the prior iterations. + results from the prior iterations. """ # All 2D columns should be reset. for col_name in self.ref_table.colnames: if (exclude != None) and (col_name in exclude): continue - + if len(self.ref_table[col_name].data.shape) == 2: # Find the 2D columns # Loop through epochs for this array. for cc in range(self.ref_table[col_name].shape[1]): self.ref_table._set_invalid_list_values(col_name, cc) return - - def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_bootstrap=True, weighting='var', use_scipy=True, absolute_sigma=False, show_progress=True, update_errors=False): + + def calc_bootstrap_errors(self, n_boot=100, seed=None, boot_epochs_min=-1, calc_vel_in_bootstrap=True, update_errors=False, verbose=True): """ Function to calculate bootstrap errors for the transformations as well as the proper motions. For each iteration, this will: - 1) Draw full-size bootstrap w/replacement sample from reference stars in + 1) Draw full-size bootstrap w/replacement sample from reference stars in ref_table and re-calculate the transformations for each epoch 2) Apply transformation to all stars in each epoch - If calc_vel_in_bootstraps: + If calc_vel_in_bootstrap: 3) For each star, draw full-size boostrap sample w/replacement from epochs 4) Calculate proper motion for each star using resampled epochs - + The saved outputs will be: x_trans, y_trans, m_trans (transformed postions/mags), as well as the proper motion fit parameters. @@ -1075,46 +1277,45 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot MosaicToRef object after the complete match_and_transform process n_boot: int, must be greater than 0 - Number of bootstrap iterations when calculating transformations and the proper motion. + Number of bootstrap iterations when calculating transformations and the proper motion. PM bootstrap is only done for final proper motion calculation (e.g., not for each iteration of the starlist for matching) + seed: int, optional + Random seed for reproducible bootstrap results. + boot_epochs_min: int or -1 - In order to be included in bootstrap analysis, non-reference stars must be detected in - at least boot_epochs_min epochs. If boot_epochs_min = -1, then all stars will + In order to be included in bootstrap analysis, non-reference stars must be detected in + at least boot_epochs_min epochs. If boot_epochs_min = -1, then all stars will be included in the analysis, regardless of the number of epochs detected. For stars that fail boot_epochs_min criteria, np.nan is used calc_vel_in_bootstrap: boolean - If true, do bootstrap sample w/ replacement over the epochs and calculate + If true, do bootstrap sample w/ replacement over the epochs and calculate stellar proper motions, as well as the bootstrap over reference stars - to calculate positional alignment errors. If false, only + to calculate positional alignment errors. If false, only calculate position alignment errors. - - weighting: str - 'var' or 'std' weighting for velocity fitting, by default 'var'. If 'var', use the variance of the residuals to weight the fit. - If 'std', use the standard deviation of the residuals to weight the fit. - - absolute_sigma: boolean - If True, use the absolute sigma in the velocity fitting. If False, use the relative sigma, by default False. - + update_errors: boolean If True, save the starlist errors as xe_list, bootstrap errors as xe_boot, and their quad sum as xe (and likewise for ye and me). If False (default), leave the starlist errors in place as xe and bootstrap errors as xe_boot. - + + verbose: boolean + Print verbose information or not, by default True + Output: ------ New columns will be added to self.ref_table: 'xe_boot', 2D column: bootstrap x pos uncertainties due to transformation for each epoch 'ye_boot', 2D column: bootstrap y pos uncertainties due to transformation for each epoch 'me_boot', 2D column: bootstrap mag uncertainties due to transformation for each epoch - + If calc_vel_in_bootstrap: '_err_boot', 1D column: bootstrap uncertainties in for motion model fit For stars that fail boot_epochs_min criteria, np.nan is used """ # First, assert than n_boot > 0 - assert n_boot > 0 + assert n_boot > 0, f'{n_boot=} is not possive!' ref_table = copy.deepcopy(self.ref_table) n_epochs = len(ref_table['x'][0]) @@ -1130,9 +1331,9 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot t0_arr = t0_arr[idx_good] else: idx_good = np.arange(0, len(ref_table), 1) - + #idx_ref = np.where(ref_table['use_in_trans'] == True) - + # Initialize sums for output x_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) x2_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) @@ -1140,34 +1341,41 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot y2_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) m_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) m2_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) - + # Set up motion model parameters - motion_model_list = ['Fixed', self.default_motion_model] if 'motion_model_used' in ref_table.keys(): - motion_model_list += ref_table['motion_model_used'].tolist() + motion_model_list = np.unique(ref_table['motion_model_used']).tolist() elif 'motion_model_input' in ref_table.keys(): - motion_model_list += ref_table['motion_model_input'].tolist() - motion_col_list = motion_model.get_list_motion_model_param_names(np.unique(motion_model_list).tolist(), with_errors=False, with_fixed=False) + motion_model_list = np.unique(ref_table['motion_model_input']).tolist() + + if 'Empty' not in motion_model_list: + motion_model_list.append('Empty') + if 'Fixed' not in motion_model_list: + motion_model_list.append('Fixed') + + motion_col_list = motion_model.motion_model_param_names(motion_model_list, with_errors=False, with_fixed=False) if calc_vel_in_bootstrap: motion_boot_sum = {} motion2_boot_sum = {} for col in motion_col_list: motion_boot_sum[col] = np.zeros((len(ref_table['x']))) motion2_boot_sum[col] = np.zeros((len(ref_table['x']))) - motion_boot_min_epochs = np.max([self.motion_model_dict[mod].n_pts_req - for mod in np.unique(motion_model_list)]) + + all_mm_map = motion_model.motion_model_map() + motion_model_list = [all_mm_map[mm_name] for mm_name in motion_model_list] + motion_boot_min_epochs = np.max([mm.n_params for mm in motion_model_list]) ### IF MEMORY PROBLEMS HERE: ### DEFINE MEAN, STD VARIABLES AND BUILD THEM RATHER THAN SAVING FULL ARRAY ### DECREASE PRECISION ON ARRAYS (32 bit instead of 64: dtype=np.float32) ### AT SOME POINT, NEED TO CONVERT BACK (LOOK UP HOW TO DO THIS CAREFULLY) - t1 = time.time() - for ii in range(n_boot): + rng = np.random.default_rng(seed) + for ii in tqdm(range(n_boot), desc='Bootstrap iterations', disable=not verbose): # Recalculate transformations using bootstrap sample of # reference stars. Use a loop for each epoch here, so we # can handle case where different reference stars are used # in different epochs - + # Initialize data arrays x_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 y_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 @@ -1175,13 +1383,13 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot xe_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 ye_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 me_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 - + for jj in range(n_epochs): # Extract bootstrap sample of matched reference stars for this epoch #good = np.where(~np.isnan(ref_table['x_orig'][idx_ref][:,jj])) good = np.where( (ref_table['used_in_trans'][:,jj] == True) & (~np.isnan(ref_table['x_orig'][:,jj])) ) - samp_idx = np.random.choice(good[0], len(good[0]), replace=True) - + samp_idx = rng.choice(good[0], len(good[0]), replace=True) + # Get reference star positions in particular epoch from ref_list. t_epoch = t_arr[jj] ref_orig = self.get_ref_list_from_table(t_epoch)[idx_good] @@ -1215,10 +1423,10 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot # Sanity check: makes sure names match between ref_boot and starlist_boot, # since they need to line up assert np.all(ref_boot['name'] == starlist_boot['name']) - + # Calculate weights based on weights keyword. If weights desired, will need to # make starlist objects for this - if self.trans_weights != None: + if self.trans_weighting != None: # In order for weights calculation to work, we need to apply a transformation # to the star_list_T so it is in the same units as ref_boot. So, we'll apply # the final transformation for the epoch to get close enough for the @@ -1228,11 +1436,11 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot starlist_boot_T.transform_xym(self.trans_list[jj]) else: starlist_boot_T.transform_xy(self.trans_list[jj]) - + weight = self.get_weights_for_lists(ref_boot, starlist_boot_T) else: weight = None - + # Recalculate transformation trans = self.trans_class.derive_transform(starlist_boot['x'], starlist_boot['y'], ref_boot['x'], ref_boot['y'], @@ -1240,7 +1448,6 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot m=starlist_boot['m'], mref=ref_boot['m'], weights=weight, mag_trans=self.mag_trans) #print(jj) - #pdb.set_trace() # Apply transformation to *all* orig positions in this epoch. Need to make a new # FLYSTAR starlist object with the original positions for this. We don't @@ -1257,7 +1464,7 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot starlist_T.transform_xym(trans) else: starlist_T.transform_xy(trans) - + # Add output to pos arrays x_trans_arr[:,jj] = starlist_T['x'] y_trans_arr[:,jj] = starlist_T['y'] @@ -1265,7 +1472,7 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot xe_trans_arr[:,jj] = starlist_T['xe'] ye_trans_arr[:,jj] = starlist_T['ye'] me_trans_arr[:,jj] = starlist_T['me'] - + x_boot_sum += x_trans_arr x2_boot_sum += x_trans_arr**2 y_boot_sum += y_trans_arr @@ -1273,21 +1480,21 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot if self.mag_trans: m_boot_sum += m_trans_arr m2_boot_sum += m_trans_arr**2 - - t2 = time.time() + + # t2 = time.time() #print('=================================================') #print('Time to do {0} epochs: {1}s'.format(n_epochs, t2-t1)) #print('=================================================') - + # Finally, calculate proper motions for this bootstrap iteration # for each star, if desired. Draw a full-sample bootstrap over the epochs # for each star, and then run it through the startable fit_velocities machinery if calc_vel_in_bootstrap: - boot_idx = np.random.choice(np.arange(0, n_epochs, 1), size=n_epochs) + boot_idx = rng.choice(np.arange(0, n_epochs, 1), size=n_epochs) while len(np.unique(boot_idx)) < motion_boot_min_epochs: - boot_idx = np.random.choice(np.arange(0, n_epochs, 1), size=n_epochs) + boot_idx = rng.choice(np.arange(0, n_epochs, 1), size=n_epochs) t_boot = t_arr[boot_idx] - + star_table = StarTable(name=ref_table['name'], x=x_trans_arr[:,boot_idx], y=y_trans_arr[:,boot_idx], @@ -1301,12 +1508,19 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot # Now, do proper motion calculation, making sure to fix t0 to the # orig value (so we can get a reasonable error on x0, y0) - star_table.fit_velocities( - fixed_t0=t0_arr, - default_motion_model=self.default_motion_model, - motion_model_dict=self.motion_model_dict, + if self.fixed_params_dict is None: + fixed_params_dict = {'t0': t0_arr} + elif 't0' not in self.fixed_params_dict.keys(): + fixed_params_dict = self.fixed_params_dict.copy() + fixed_params_dict['t0'] = t0_arr + + star_table.fit_motion_models( + motion_models=self.motion_models, + fixed_params_dict=fixed_params_dict, + weighting=self.vel_weighting, use_scipy=self.use_scipy, - absolute_sigma=self.absolute_sigma + absolute_sigma=self.absolute_sigma, + verbose=self.verbose ) # Save proper motion fit results to output arrays @@ -1316,7 +1530,7 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot # Quick check to make sure bootstrap calc was valid: output t0 should be # same as input t0_arr, since we used fixed_t0 option - assert np.sum(abs(star_table['t0'] - t0_arr) == 0) + np.testing.assert_array_equal(star_table['t0'], t0_arr) #t3 = time.time() #print('=================================================') @@ -1347,43 +1561,59 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot data_dict = {'xe_boot': x_err_b, 'ye_boot': y_err_b, 'me_boot': m_err_b} for col in motion_col_list: data_dict[col+'_err_boot'] = motion_data_err[col] - + for ff in col_heads_2D: col = Column(np.ones((len(self.ref_table), n_epochs)), name=ff) col.fill(np.nan) - + col[idx_good] = data_dict[ff] self.ref_table.add_column(col) - - # Calculate chi^2 with bootstrap positional errors - x_pred, y_pred, _, _ = self.ref_table.get_star_positions_at_time(t_arr, self.motion_model_dict, allow_alt_models=True) + + # # Calculate chi^2 with bootstrap positional errors + # # Determine which motion model to use: + # motion_model_list = sorted(motion_model_list, key=lambda mm: mm.n_params) + # mm_n_params = np.sort([mm.n_params for mm in motion_model_list]) + + # required_params = [all_mm_map[mm_name].n_params for mm_name in self.ref_table['motion_model_input']] + # mm_digitized = np.digitize( + # x=np.minimum(np.array(self.ref_table['n_detect']), required_params), + # bins=mm_n_params + # ) - 1 + # self.ref_table['motion_model_used'] = np.array([motion_model_list[d].name for d in mm_digitized], dtype='U20') + + + x_pred, y_pred, _, _ = self.ref_table.infer_positions(t_arr, fixed_params_dict=self.fixed_params_dict) + if np.ndim(x_pred) == 1: + x_pred = x_pred[:, np.newaxis] + if np.ndim(y_pred) == 1: + y_pred = y_pred[:, np.newaxis] xe_comb = np.hypot(self.ref_table['xe'], self.ref_table['xe_boot']) ye_comb = np.hypot(self.ref_table['ye'], self.ref_table['ye_boot']) - data_dict['chi2_x_boot'] = np.nansum((self.ref_table['x']-x_pred)**2/(xe_comb)**2,axis=1) - data_dict['chi2_y_boot'] = np.nansum((self.ref_table['y']-y_pred)**2/(ye_comb)**2,axis=1) + data_dict['chi2_x_boot'] = np.nansum((self.ref_table['x'] - x_pred)**2 / xe_comb**2, axis=1) + data_dict['chi2_y_boot'] = np.nansum((self.ref_table['y'] - y_pred)**2 / ye_comb**2, axis=1) for ff in ['chi2_x_boot', 'chi2_y_boot']: col = Column(np.ones(len(self.ref_table)), name=ff) col.fill(np.nan) - + col[idx_good] = data_dict[ff][idx_good] self.ref_table.add_column(col) # Now handle the velocities, if they were calculated if calc_vel_in_bootstrap: col_heads_1D = [col+'_err_boot' for col in motion_col_list] - + for ff in col_heads_1D: col = Column(np.ones(len(self.ref_table)), name=ff) col.fill(np.nan) - + col[idx_good] = data_dict[ff] self.ref_table.add_column(col) - #pdb.set_trace() - - print('===============================') - print('Done with bootstrap') - print('===============================') - + + if verbose: + print('===================================') + print('======= Done with bootstrap =======') + print('===================================') + if update_errors: self.ref_table['xe_list'] = self.ref_table['xe'] self.ref_table['ye_list'] = self.ref_table['ye'] @@ -1394,37 +1624,62 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot print("Saved starlist errors to xe_list and added xe_boot to xe in quadrature.") print("The same was done for ye and me.") - + if self.save_path is not None: + with open(os.path.join(self.save_path, self.prefix_name+'_bootstrap.pkl'), 'wb') as file: + pickle.dump(self, file) + with open(os.path.join(self.save_path, self.prefix_name+'_ref_table_bootstrap.pkl'), 'wb') as file: + pickle.dump(self.ref_table, file) + return - + class MosaicToRef(MosaicSelfRef): - def __init__(self, ref_list, list_of_starlists, iters=2, - dr_tol=[1, 1], dm_tol=[2, 1], - outlier_tol=[None, None], - trans_args=[{'order': 2}, {'order': 2}], - init_order=1, - mag_trans=True, mag_lim=None, ref_mag_lim=None, - trans_weights=None, vel_weights='var', - trans_input=None, - trans_class=transforms.PolyTransform, - calc_trans_inverse=False, - use_ref_new=False, - update_ref_orig=False, - init_guess_mode='miracle', - iter_callback=None, - default_motion_model='Fixed', - motion_model_dict={}, - use_scipy=True, - absolute_sigma=False, - save_path=None, - verbose=True): + def __init__( + self, + ref_list, + list_of_starlists, + reflist_vertex=None, + starlist_vertices=None, + # Alignment parameters + iters=2, + dr_tol=[1, 1], + dm_tol=[2, 1], + outlier_tol=None, + # Reference behavior (MosiacToRef specific) + use_ref_new=False, + update_ref_orig=False, + # Transformation parameters + trans_class=transforms.PolyTransform, + trans_args=[{'order': 2}, {'order': 2}], + trans_input=None, + trans_weighting=None, + init_order=1, + init_guess_mode='miracle', + briteN=None, + calc_trans_inverse=False, + # Magnitude parameters + mag_trans=True, + mag_lim=None, + ref_mag_lim=None, + # Motion model parameters + motion_models=['Empty', 'Fixed'], + # motion_model_for_new_star=None, + fixed_params_dict=None, + vel_weighting='var', + use_scipy=True, + absolute_sigma=False, + # Advanced options + iter_callback=None, + save_path=None, + prefix_name='mtr', + verbose=True + ): """ Required Parameters - ---------- + ------------------- ref_list : StarList object - Can optionally have velocities. All starlists will be aligned to this one. + Can optionally have velocities. All starlists will be aligned to this one. list_of_starlists : array of StarList objects An array or list of flystar.starlists.StarList objects (which are Astropy Tables). @@ -1433,20 +1688,28 @@ def __init__(self, ref_list, list_of_starlists, iters=2, Note that there is an optional weights column called 'w'. If this column exists in any of the lists, it will be queried to determine if an individual star can be used to derive the transformations between starlists. This is the most flexible way - to allow you to determine, as a function of time and star, which ones are good enough - in the transformation. Note that just because it can be used (i.e. w_in=1), - doesn't meant that it will be used. The mag limits and outliers still take precedence. - Note also that the weights that go into the transformation are + to allow you to determine, as a function of time and star, which ones are good enough + in the transformation. Note that just because it can be used (i.e. w_in=1), + doesn't meant that it will be used. The mag limits and outliers still take precedence. + Note also that the weights that go into the transformation are star_list['w'] * ref_list['w'] * weight_from_keyword (see the weights parameter) - for those stars not trimmed out by the other criteria. + for those stars not trimmed out by the other criteria. Optional Parameters ---------- + reflist_vertex : array + An array of polygon vertices coordinates for the reference starlist. Initial guess will only use stars in overlapping regions defined by these polygons. + Shape of (N_vertices, 2) in the format of [[x1, y1], [x2, y2], ..., [xN, yN]] for the reference starlist, by default None + + starlist_vertices : list or array + A list or array of polygon vertices coordinates for each starlist. Initial guess will only use stars in overlapping regions defined by these polygons. + Shape of (N_lists, N_vertices, 2) in the format of [[x1, y1], [x2, y2], ..., [xN, yN]] for each starlist, by default None + iters : int - The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? + The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? dr_tol : list or array The delta-radius (dr) tolerance for matching in units of the reference coordinate system. @@ -1454,100 +1717,103 @@ def __init__(self, ref_list, list_of_starlists, iters=2, dm_tol : list or array The delta-magnitude (dm) tolerance for matching in units of the reference coordinate system. - This is a list of dm values, one for each iteration of matching/transformation. + This is a list of dm values, one for each iteration of matching/transformation. outlier_tol : list or array - The outlier tolerance (in units of sigma) for rejecting outlier stars. + The outlier tolerance (in units of sigma) for rejecting outlier stars. This is a list of tol values, one for each iteration of matching/transformation. - mag_trans : boolean - If true, this will also calculate and (temporarily) apply a zeropoint offset to - magnitudes in each list to bring them into a common magnitude system. This is - essential for matching (with finite dm_tol) starlists of different filters or - starlists that are not photometrically calibrated. Note that the final_table columns - of 'm', 'm0', and 'm0_err' will contain the transformed magnitudes while the - final_table column 'm_orig' will contain the original un-transformed magnitudes. - If mag_trans = False, then no such zeropoint offset it applied at any point. - - mag_lim : array - If different from None, it indicates the minimum and maximum magnitude - on the catalogs for finding the transformations. Note, if you want specify the mag_lim - separately for each list and each iteration, you need to pass in a 2D array that - has shape (N_lists, 2). + use_ref_new : boolean + Each pass, new stars are matched and added to the ref_table. However, we don't + necessarily want to use these in the reference frame in subsequent passes. + If True, then the new stars will be used in later passes/iterations. + If False, then the new stars will be carried, but not used in the transformation. + We determine which stars to use through setting a boolean use_in_trans flag. - ref_mag_lim : array - If different from None, it indicates the minimum and maximum magnitude - on the reference catalog for finding the transformations. + update_ref_orig : boolean or str + Should we update the reference values (position, velocity, t0) after each starlist + is transformed in each iteration? - trans_weights : str - Either None (def), 'both,var', 'list,var', or 'ref,var' depending on whether you want - to weight by the positional uncertainties (variances) in the individual starlists, or also with - the uncertainties in the reference frame itself. Note weighting only works when there - are positional uncertainties availabe. Other options include 'both,std', 'list,std', 'list,var'. - - vel_weights : str - Either 'var' (def) or 'std', depending on whether you want to weight the motion model - fits by the variance or standard deviation of the position data + False if you want to get into an absolute reference frame and are using Gaia data. + True if you want to use the reference list as more of an initial guess. + 'periter' if you want to align all the starlists, then calculate the velocity. - trans_input : array or list of transform objects - def = None. If not None, then this should contain an array or list of transform - objects that will be used as the initial guess in the alignment and matching. + Note that this only impacts the stars that are in the original reference list... the + newly identified stars that end up in ref_table will always be updated; but not always + used for transformation fitting. trans_class : transforms.Transform2D object (or subclass) The transform class that will be used to when deriving the optimal - transformation parameters between each list and the reference list. + transformation parameters between each list and the reference list. trans_args : dictionary - A dictionary (or a list of dictionaries) containing any extra keywords that are needed - in the transformation object. For instance, "order". Note that if a list is passed in, + A dictionary (or a list of dictionaries) containing any extra keywords that are needed + in the transformation object. For instance, "order". Note that if a list is passed in, then the transformation argument (i.e. order) will be changed for every iteration in iters. + trans_input : array or list of transform objects + def = None. If not None, then this should contain an array or list of transform + objects that will be used as the initial guess in the alignment and matching. + + trans_weighting : str + Either None (def), 'both,var', 'list,var', or 'ref,var' depending on whether you want + to weight by the positional uncertainties (variances) in the individual starlists, or also with + the uncertainties in the reference frame itself. Note weighting only works when there + are positional uncertainties availabe. Other options include 'both,std', 'list,std', 'list,var'. + init_order: int Polynomial transformation order to use for initial guess transformation. Order=1 should be used in most cases, but sometimes higher order is needed + init_guess_mode : string + If no initial transformations are passed in via the trans_input keyword, then we have + to make the initial transformation and matching blindly. We can do this in a couple of + different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). + + briteN : int + If init_guess_mode is 'miracle', this is the number of brightest stars to use in the miracle match. + Default is min(50, len(star_list)). + calc_trans_inverse: boolean If true, then calculate the inverse transformation (from reference to starlist) in addition to the normal transformation (from starlist to reference). The inverse calculation is calculated by switching the order to the positions in match_and_transform. The inverse transformations are saved in self.trans_list_inverse. - self.trans_list_inverse doesn't exist if calc_trans_inverse == False - update_ref_orig : boolean or str - Should we update the reference values (position, velocity, t0) after each starlist - is transformed in each iteration? + mag_trans : boolean + If true, this will also calculate and (temporarily) apply a zeropoint offset to + magnitudes in each list to bring them into a common magnitude system. This is + essential for matching (with finite dm_tol) starlists of different filters or + starlists that are not photometrically calibrated. Note that the final_table columns + of 'm', 'm0', and 'm0_err' will contain the transformed magnitudes while the + final_table column 'm_orig' will contain the original un-transformed magnitudes. + If mag_trans = False, then no such zeropoint offset it applied at any point. - False if you want to get into an absolute reference frame and are using Gaia data. - True if you want to use the reference list as more of an initial guess. - 'periter' if you want to align all the starlists, then calculate the velocity. + mag_lim : array + If different from None, it indicates the minimum and maximum magnitude + on the catalogs for finding the transformations. Note, if you want specify the mag_lim + separately for each list and each iteration, you need to pass in a 2D array that + has shape (N_lists, N_iters). - Note that this only impacts the stars that are in the original reference list... the - newly identified stars that end up in ref_table will always be updated; but not always - used for transformation fitting. + ref_mag_lim : array + If different from None, it indicates the minimum and maximum magnitude + on the reference catalog for finding the transformations. - use_ref_new : boolean - Each pass, new stars are matched and added to the ref_table. However, we don't - necessarily want to use these in the reference frame in subsequent passes. - If True, then the new stars will be used in later passes/iterations. - If False, then the new stars will be carried, but not used in the transformation. - We determine which stars to use through setting a boolean use_in_trans flag. + motion_models : list of str or MotionModel objects + List of motion model names (strings) or MotionModel objects to use - init_guess_mode : string - If no initial transformations are passed in via the trans_input keyword, then we have - to make the initial transformation and matching blindly. We can do this in a couple of - different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). + motion_model_for_new_star : str or MotionModel, optional + Motion model or its name for newly added stars in the ref table. Used in add_rows_for_new_stars(). + If None, the most complex motion model in motion_models will be used, by default None. - iter_callback : None or function - A function to call (that accepts a StarTable object and an iteration number) - at the end of every iteration. This can be used for plotting or printing state. - - default_motion_model : string - Name of motion model to use for new or unassigned stars - - motion_model_dict : None or dict - Dict of motion model name keys (strings) and corresponding MotionModel object values + fixed_params_dict : None or dict + Dictionary of fixed parameters for motion models + + vel_weighting : str + Either 'var' (def) or 'std', depending on whether you want to weight the motion model + fits by the variance or standard deviation of the position data use_scipy : bool, optional If True, use scipy.optimize.curve_fit for velocity fitting. If False, use linear algebra fitting, by default True. @@ -1555,12 +1821,21 @@ def = None. If not None, then this should contain an array or list of transform absolute_sigma : bool, optional If True, the velocity fit will use absolute errors in the data. If False, relative errors will be used, by default False. + iter_callback : None or function + A function to call (that accepts a StarTable object and an iteration number) + at the end of every iteration. This can be used for plotting or printing state. + save_path : str, optional Path to save the MosaicToRef object as a pickle file. + verbose : bool or int (0 to 9, inclusive) + Controls the verbosity of print statements. (0 least, 9 most verbose). + For backwards compatibility, 0 = False, 9 = True. + (Note: technically right now no checks on whether the number is an integer or not...) + Example - ---------- - msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, + ------- + mtr = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, dr_tol=[0.1], dm_tol=[5], outlier_tol=[None], mag_lim=[13, 21], trans_class=transforms.PolyTransform, @@ -1570,45 +1845,84 @@ def = None. If not None, then this should contain an array or list of transform mag_trans=False, weights='both,std', init_guess_mode='miracle', verbose=False) - msc.fit() + mtr.fit() # Access a list of all the transformation parameters: - trans_list = msc.trans_list + trans_list = mtr.trans_list # Access the fully-combined reference table. - stars_table = msc.ref_table + stars_table = mtr.ref_table # Plot the magnitude of the first star vs. time: - # Overplot the mean magnitude. + # Overplot the mean magnitude. plt.plot(stars_table['t'][0, :], stars_table['m'][0, :], 'k.') - plt.axhline(stars_table['m0'][0]) + plt.axhline(stars_table['m0'][0]) # Plot the X position of the first star vs. time: # Overplot the best-fit proper motion. times = stars_table['t'][0, :] plt.errorbar(times, stars_table['x'][0, :], yerr=stars_table['xe'][0, :]) - plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) + plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) """ - super().__init__(list_of_starlists, ref_index=-1, iters=iters, - dr_tol=dr_tol, dm_tol=dm_tol, - outlier_tol=outlier_tol, trans_args=trans_args, - init_order=init_order, - mag_trans=mag_trans, mag_lim=mag_lim, - trans_weights=trans_weights, vel_weights=vel_weights, - trans_input=trans_input, trans_class=trans_class, - calc_trans_inverse=calc_trans_inverse, - default_motion_model = default_motion_model, - init_guess_mode=init_guess_mode, - iter_callback=iter_callback, - motion_model_dict=motion_model_dict, - verbose=verbose, use_scipy=use_scipy, - absolute_sigma=absolute_sigma, save_path=save_path) - + super().__init__( + list_of_starlists, + # Alignment parameters + ref_index=-1, + iters=iters, + dr_tol=dr_tol, + dm_tol=dm_tol, + outlier_tol=outlier_tol, + # Transformation parameters + trans_class=trans_class, + trans_args=trans_args, + trans_input=trans_input, + trans_weighting=trans_weighting, + init_order=init_order, + init_guess_mode=init_guess_mode, + briteN=briteN, + calc_trans_inverse=calc_trans_inverse, + # Magnitude parameters + mag_trans=mag_trans, + mag_lim=mag_lim, + # Motion model parameters + motion_models=motion_models, + # motion_model_for_new_star=motion_model_for_new_star, + fixed_params_dict=fixed_params_dict, + vel_weighting=vel_weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + # Advanced options + iter_callback=iter_callback, + save_path=save_path, + prefix_name=prefix_name, + verbose=verbose + ) + + self.starlist_vertices = starlist_vertices self.ref_list = copy.deepcopy(ref_list) self.ref_mag_lim = ref_mag_lim self.update_ref_orig = update_ref_orig self.use_ref_new = use_ref_new + if reflist_vertex is not None: + import shapely + self.reflist_polygon = shapely.make_valid(shapely.Polygon(reflist_vertex)) + else: + self.reflist_polygon = None + + # If motion_model_used in columns but params columns are missing, raise a warning and remove motion_model_used column to avoid confusion. + # if 'motion_model_used' in self.ref_list.colnames: + # motion_model_params = motion_model.motion_model_param_names(np.unique(self.ref_list['motion_model_used']), with_errors=False, with_fixed=True) + # missing_params = [param for param in motion_model_params if (param not in self.ref_list.colnames) and (f'{param}_err' not in self.ref_list.colnames) and (param not in self.fixed_params_dict.keys())] + # if len(missing_params) > 0: + # warnings.warn("Warning: 'motion_model_used' column found in ref_list, but the following motion model parameter columns are missing: " + ", ".join(missing_params) + ". Removing 'motion_model_used' column to avoid confusion.") + # self.ref_list.remove_column('motion_model_used') + + # If motion_model_used in columns, remove it and raise a warning, since it will only be determined after the fit. + if 'motion_model_used' in self.ref_list.colnames: + warnings.warn("Warning: 'motion_model_used' column found in ref_list. This column will be determined after the fit, so it is being removed from the input ref_list to avoid confusion.") + self.ref_list.remove_column('motion_model_used') + # Do some temporary clean up of the reference list. if ('x' not in self.ref_list.colnames) and ('x0' in self.ref_list.colnames): self.ref_list['x'] = self.ref_list['x0'] @@ -1622,24 +1936,20 @@ def = None. If not None, then this should contain an array or list of transform self.ref_list['me'] = self.ref_list['m0_err'] if ('t' not in self.ref_list.colnames) and ('t0' in self.ref_list.colnames): self.ref_list['t'] = self.ref_list['t0'] - - # Make sure the motion models are ready - self.motion_model_dict = motion_model.validate_motion_model_dict(self.motion_model_dict, - self.ref_list, self.default_motion_model) return - + def fit(self): """ Using the current parameter settings, match and transform all the lists to a reference position. Note in the first pass, the reference position is just the specified input reference starlist. In subsequent iterations, - this is (optionally) updated. + this is (optionally) updated. The ultimate outcome is the creation of self.ref_table. This reference table will contain "averaged" quantites as well as a big 2D array of all - the matched original and transformed quantities. + the matched original and transformed quantities. Averaged columns on ref_table: x0 @@ -1652,27 +1962,70 @@ def fit(self): """ # Create a log file of the parameters used in the fit. - with open('MosaicToRef_input_params.log', 'w',) as _log: - logger(_log, 'Parameters used for fit: ', self.verbose) - logger(_log, '------------------------- ', self.verbose) - logger(_log, ' dr_tol = ' + str(self.dr_tol), self.verbose) - logger(_log, ' dm_tol = ' + str(self.dm_tol), self.verbose) - logger(_log, ' outlier_tol = ' + str(self.outlier_tol), self.verbose) - logger(_log, ' trans_args = ' + str(self.trans_args), self.verbose) - logger(_log, ' mag_trans = ' + str(self.mag_trans), self.verbose) - logger(_log, ' mag_lim = ' + str(self.mag_lim), self.verbose) - logger(_log, ' ref_mag_lim = ' + str(self.ref_mag_lim), self.verbose) - logger(_log, ' trans_weights = ' + str(self.trans_weights), self.verbose) - logger(_log, ' vel_weights = ' + str(self.vel_weights), self.verbose) - logger(_log, ' trans_input = ' + str(self.trans_input), self.verbose) - logger(_log, ' trans_class = ' + str(self.trans_class), self.verbose) - logger(_log, ' calc_trans_inverse = ' + str(self.calc_trans_inverse), self.verbose) - logger(_log, ' use_ref_new = ' + str(self.use_ref_new), self.verbose) - logger(_log, ' default_motion_model = ' + str(self.default_motion_model), self.verbose) - logger(_log, ' update_ref_orig = ' + str(self.update_ref_orig), self.verbose) - logger(_log, ' init_guess_mode = ' + str(self.init_guess_mode), self.verbose) - logger(_log, ' iter_callback = ' + str(self.iter_callback), self.verbose) - logger(_log, '-------------------------\n', self.verbose) + # Setup save_path: + if self.save_path: + if not os.path.exists(os.path.dirname(self.save_path)): + os.makedirs(os.path.dirname(self.save_path)) + + # Save input params + input_filename = f'{self.prefix_name}_input.txt' + input_dict = { + 'iters': self.iters, + 'dr_tol': self.dr_tol, + 'dm_tol': self.dm_tol, + 'outlier_tol': self.outlier_tol, + 'use_ref_new': self.use_ref_new, + 'update_ref_orig': self.update_ref_orig, + 'trans_class': self.trans_class, + 'trans_args': self.trans_args, + 'trans_input': self.trans_input, + 'trans_weighting': self.trans_weighting, + 'init_order': self.init_order, + 'init_guess_mode': self.init_guess_mode, + 'calc_trans_inverse': self.calc_trans_inverse, + 'mag_trans': self.mag_trans, + 'mag_lim': self.mag_lim, + 'ref_mag_lim': self.ref_mag_lim, + 'motion_models': self.motion_models, + 'fixed_params_dict': self.fixed_params_dict, + 'vel_weighting': self.vel_weighting, + 'use_scipy': self.use_scipy, + 'absolute_sigma': self.absolute_sigma, + 'iter_callback': self.iter_callback, + 'save_path': self.save_path, + 'prefix_name': self.prefix_name, + 'verbose': self.verbose + } + if self.save_path is not None: + if not os.path.exists(self.save_path): + os.makedirs(self.save_path) + with open(os.path.join(self.save_path, input_filename), 'w') as file: + for key, value in input_dict.items(): + file.write(f'{key}:\t{value}\n') + + + # if self.save_path is not None: + # with open(f'{os.path.dirname(self.save_path)}/MosaicToRef_input_params.log', 'w',) as _log: + # logger(_log, 'Parameters used for fit: ', self.verbose) + # logger(_log, '------------------------- ', self.verbose) + # logger(_log, ' dr_tol = ' + str(self.dr_tol), self.verbose) + # logger(_log, ' dm_tol = ' + str(self.dm_tol), self.verbose) + # logger(_log, ' outlier_tol = ' + str(self.outlier_tol), self.verbose) + # logger(_log, ' trans_args = ' + str(self.trans_args), self.verbose) + # logger(_log, ' mag_trans = ' + str(self.mag_trans), self.verbose) + # logger(_log, ' mag_lim = ' + str(self.mag_lim), self.verbose) + # logger(_log, ' ref_mag_lim = ' + str(self.ref_mag_lim), self.verbose) + # logger(_log, ' trans_weighting = ' + str(self.trans_weighting), self.verbose) + # logger(_log, ' vel_weighting = ' + str(self.vel_weighting), self.verbose) + # logger(_log, ' trans_input = ' + str(self.trans_input), self.verbose) + # logger(_log, ' trans_class = ' + str(self.trans_class), self.verbose) + # logger(_log, ' calc_trans_inverse = ' + str(self.calc_trans_inverse), self.verbose) + # logger(_log, ' use_ref_new = ' + str(self.use_ref_new), self.verbose) + # logger(_log, ' motion_models = ' + str([mm.name for mm in self.motion_models]), self.verbose) + # logger(_log, ' update_ref_orig = ' + str(self.update_ref_orig), self.verbose) + # logger(_log, ' init_guess_mode = ' + str(self.init_guess_mode), self.verbose) + # logger(_log, ' iter_callback = ' + str(self.iter_callback), self.verbose) + # logger(_log, '-------------------------\n', self.verbose) ########## @@ -1690,8 +2043,7 @@ def fit(self): # ########## for nn in range(self.iters): - - # If we are on subsequent iterations, remove matching results from the + # If we are on subsequent iterations, remove matching results from the # prior iteration. This leaves aggregated (1D) columns alone. if nn > 0: self.reset_ref_values() @@ -1703,13 +2055,13 @@ def fit(self): print('Starting iter {0:d} with ref_table shape:'.format(nn), self.ref_table['x'].shape) print("**********") print("**********") - + # ALL the action is in here. Match and transform the stack of starlists. - # This updates trans objects and the ref_table. + # This updates trans objects and the ref_table. self.match_and_transform(self.ref_mag_lim, self.dr_tol[nn], self.dm_tol[nn], self.outlier_tol[nn], - self.trans_args[nn]) - + self.trans_args[nn], nn) + # Clean up the reference table # Find where stars are detected. self.ref_table.detections() @@ -1737,43 +2089,216 @@ def fit(self): print("**********") self.match_lists(self.dr_tol[-1], self.dm_tol[-1]) - keep_ref_orig = (self.update_ref_orig==False) - if keep_ref_orig: - keep_orig = np.where(self.ref_table['ref_orig'])[0] - else: + if self.update_ref_orig: keep_orig=None + else: + keep_orig = self.ref_table['ref_orig'] self.update_ref_table_aggregates(keep_orig=keep_orig) ########## # Clean up output table. - # + # ########## # Find where stars are detected. if self.verbose > 0: - print('') print(' Preparing the reference table...') - + self.ref_table.detections() ### Drop all stars that have 0 detections. - idx = np.where((self.ref_table['n_detect'] == 0) & (self.ref_table['ref_orig'] == False))[0] - print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) + idx = np.where((self.ref_table['n_detect'] == 0))[0] # & (self.ref_table['ref_orig'] == False))[0] + if self.verbose: + print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) self.ref_table.remove_rows(idx) if self.iter_callback != None: self.iter_callback(self.ref_table, nn) - if self.save_path: - with open(self.save_path, 'wb') as file: + # Add times into ref_table meta data + all_epochs = get_all_epochs(self.ref_table) + self.ref_table.meta['list_times'] = all_epochs + + # Update chi2 values in ref table, as motion_model_used may have changed + x_inferred, y_inferred, _, _ = self.ref_table.infer_positions(all_epochs, fixed_params_dict=self.fixed_params_dict) + # Convert x_inferred and y_inferred to 2D arrays if they are 1D (i.e. if only one epoch), so that the chi2 calculation works correctly. + if x_inferred.ndim == 1: + x_inferred = x_inferred[:, np.newaxis] + if y_inferred.ndim == 1: + y_inferred = y_inferred[:, np.newaxis] + chi2_x_2d = ((self.ref_table['x'] - x_inferred) / self.ref_table['xe'])**2 + chi2_y_2d = ((self.ref_table['y'] - y_inferred) / self.ref_table['ye'])**2 + chi2_x = np.nansum(chi2_x_2d, axis=1) + chi2_y = np.nansum(chi2_y_2d, axis=1) + chi2_x[~np.isfinite(chi2_x_2d).any(axis=1)] = np.nan + chi2_y[~np.isfinite(chi2_y_2d).any(axis=1)] = np.nan + self.ref_table['chi2_x'] = chi2_x + self.ref_table['chi2_y'] = chi2_y + + if self.save_path is not None: + filename = f'{self.prefix_name}.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: pickle.dump(self, file) + # Using pickle here because nan in a fits file is auto-converted to a masked value in astropy.io.fits.open() + filename = f'{self.prefix_name}_ref_table.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: + pickle.dump(self.ref_table, file) + + if self.verbose > 0: + print('===================================') + print('========== Done with fit ==========') + print('===================================') return +# TODO: This is sometimes run on a startable, not a starlist, at least as currently used +def infer_positions(t, startable, motion_models=None, fixed_params_dict=None, return_errors=False): + """ + Take a startable, check to see if it has motion/velocity columns. + If it does, then propagate the positions forward in time + to the desired epoch. If no motion/velocities exist, then just + use ['x0', 'y0'] or ['x', 'y'] + + Parameters + ---------- + t : float + The time to propagate to. Usually in decimal years; + but it should be in the same units + as the 't0' column in starlist. + startable : StarTable + Startable that needs to be inferred. + motion_models : list of MotionModel classes or strings + The motion models to check for in the startable + return_errors : boolean + Whether to return the inferred position errors. If True, then the function returns x, y, xe, ye. If False, then it just returns x, y, by default False. + + Returns + ------- + x, y, (xe, ye) : tuple + Inferred position (and errors) at time t + """ + if ('motion_model_used' in startable.colnames): + x, y, xe, ye = startable.infer_positions(t, fixed_params_dict=fixed_params_dict) + if return_errors: + return x, y, xe, ye + else: + return x, y + + # Convert motion_models from strings to MotionModel classes if needed. + if motion_models is None: + # Setting the default to None to avoid mutable default argument issue + # See https://stackoverflow.com/questions/15189245/assigning-class-variable-as-default-value-to-class-method-argument + motion_models = [Empty, Fixed] + all_mm_map = motion_model.motion_model_map() + if all(isinstance(mm, str) for mm in motion_models): + mm_names = motion_models + motion_models = [all_mm_map[mm] for mm in motion_models] + else: + mm_names = [mm.name for mm in motion_models] + + # Always add Empty and Fixed in motion models + if 'Fixed' not in mm_names: + motion_models.insert(0, Fixed) + if 'Empty' not in mm_names: + motion_models.insert(0, Empty) + + # Otherwise, infer positions using the most complex motion model with the existing columns, until it reaches Fixed or Empty + # Sort motion models inversely by mm.n_params + motion_models = sorted(motion_models, key=lambda mm: mm.n_params, reverse=True) + for mm in motion_models: + if mm.name == 'Empty': + x = startable['x'] + y = startable['y'] + return x, y + + required_columns = mm.fit_param_names + mm.fixed_param_names + if all([param in startable.colnames for param in required_columns]): + # Check if the values are finite for non-string columns in the required columns for this motion model. If not, skip to the next motion model. + if not all([np.isfinite(startable[param]).all() for param in required_columns if startable[param].dtype.kind in 'if']): + continue + + # If we have error columns for all fit parameters, then use them in the model inference. Otherwise, just use the fit parameters without errors. + x, y = mm().model( + t=t, + fit_params=np.array([startable[param] for param in mm.fit_param_names]).T, + fixed_params_dict={param: startable[param] for param in mm.fixed_param_names} + ) + break + + return x, y + + # # If no motion model, check for velocities + # elif ('vx' in startable.colnames) and ('vy' in startable.colnames) and (np.isfinite(startable['vx']).all()) and (np.isfinite(startable['vy']).all()): + # x = startable['x0'] + startable['vx'] * (t - startable['t0']) + # y = startable['y0'] + startable['vy'] * (t - startable['t0']) + + # # If no velocities, try fitted positon + # elif ('x0' in startable.colnames) and ('y0' in startable.colnames) and (np.isfinite(startable['x0']).all()) and (np.isfinite(startable['y0']).all()): + # x = startable['x0'] + # y = startable['y0'] + # # Otherwise, use measured position + # else: + # x = startable['x'] + # y = startable['y'] + # return x, y + +def determine_motion_model(startable, motion_models=None, fixed_params_dict=None): + """Determine motion model used in star table based on the finite model parameter columns + + Parameters + ---------- + startable : startable + Startable with motion model parameter columns + motion_models : list of MotionModel or str, optional + List of motion model classes or their names to select from. + If None, all available motion models will be considered, by default None + fixed_params_dict : dict, optional + Dictionary of fixed parameters, by default None + + Returns + ------- + motion_model_used : list + List of motion model used for each star + n_params : list + List of n parameters per direction for each star + """ + + if motion_models is None: + motion_models = motion_model.MotionModel.__subclasses__() + elif all(isinstance(mm, str) for mm in motion_models): + all_mm_map = motion_model.motion_model_map() + motion_models = [all_mm_map[mm] for mm in motion_models] + + if fixed_params_dict is None: + fixed_params_dict = {} + + motion_models_possible = [] + for mm in motion_models: + required_columns = mm.fit_param_names + mm.fixed_param_names + req_col_in_table = [col for col in required_columns if (col in startable.colnames)] + req_col_in_dict = [col for col in required_columns if (col in fixed_params_dict.keys())] + if all((col in startable.colnames) or (col in fixed_params_dict.keys()) for col in required_columns): + motion_models_possible.append((mm, req_col_in_table, req_col_in_dict)) + + # Check if values are finite for required columns in possible motion models + motion_model_used = [] + n_params = [] + + for k in range(len(startable)): + for mm, req_col_in_table, req_col_in_dict in motion_models_possible[::-1]: + # If requested column in table/fixed_params dict is numeric, check if values are finite. + if all(np.isfinite(startable[col][k]) for col in req_col_in_table if np.issubdtype(startable[col].dtype, np.number)) \ + and all(np.isfinite(fixed_params_dict[col]) for col in req_col_in_dict if np.issubdtype(np.array(fixed_params_dict[col]).dtype, np.number)): + motion_model_used.append(mm.name) + n_params.append(mm.n_params) + break + return motion_model_used, n_params + + def get_all_epochs(t): """ Helper function to get times of all epochs from a ref table. - This is required because our previous approach - of simply taking the time array of the star with the most detections - fails for mosaicked catalogs, because it is then possible that + This is required because our previous approach + of simply taking the time array of the star with the most detections + fails for mosaicked catalogs, because it is then possible that no star is detected in all fields. """ nepochs = len(t['t'][0]) @@ -1790,17 +2315,17 @@ def get_all_epochs(t): all_epochs = np.array(all_epochs) return all_epochs - -def setup_ref_table_from_starlist(star_list): - """ + +def setup_ref_table_from_starlist(star_list, motion_models): + """ Start with the reference list.... this will change and grow over time, so make a copy that we will keep updating. The reference table will contain one columne for every named array in the original reference star list. """ col_arrays = {} - motion_model_col_names = motion_model.get_all_motion_model_param_names(with_errors=True) + motion_model_col_names = motion_model.motion_model_param_names(motion_models, with_errors=True) for col_name in star_list.colnames: if col_name == 'name': # The "name" column will be 1D; but we will also add a "name_in_list" column. @@ -1808,7 +2333,7 @@ def setup_ref_table_from_starlist(star_list): new_col_name = "name_in_list" else: new_col_name = col_name - + # Make every column's 2D arrays except "name" and those # columns used for the motion model. if col_name in motion_model_col_names: @@ -1822,7 +2347,7 @@ def setup_ref_table_from_starlist(star_list): # Make new columns to hold original values. These will be copies # of the old columns and will only include x, y, m, xe, ye, me. - # The columns we have already created will hold transformed values. + # The columns we have already created will hold transformed values. trans_col_names = ['x', 'y', 'm', 'xe', 'ye', 'me', 'w'] for tt in range(len(trans_col_names)): old_name = trans_col_names[tt] @@ -1834,32 +2359,30 @@ def setup_ref_table_from_starlist(star_list): # Make sure ref_table has the necessary x0, y0, m0 and associated # error columns. If they don't exist, then add them as a copy of - # the original x,y,m etc columns. + # the original x,y,m etc columns. new_cols_arr = ['x0', 'x0_err', 'y0', 'y0_err', 'm0', 'm0_err'] orig_cols_arr = ['x', 'xe', 'y', 'ye', 'm', 'me'] assert len(new_cols_arr) == len(orig_cols_arr) ref_cols = ref_table.keys() - for ii in range(len(new_cols_arr)): - if not new_cols_arr[ii] in ref_cols: + for new_col, orig_col in zip(new_cols_arr, orig_cols_arr): + if new_col not in ref_cols: # Some munging to convert data shape from (N,1) to (N,), # since these are all 1D cols - vals = np.transpose(np.array(ref_table[orig_cols_arr[ii]]))[0] + vals = np.array(ref_table[orig_col]).flatten() # Now add to ref_table - new_col = Column(vals, name=new_cols_arr[ii]) - ref_table.add_column(new_col) - + ref_table.add_column(vals, name=new_col) + if 'use_in_trans' not in ref_table.colnames: - new_col = Column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') - ref_table.add_column(new_col) - + ref_table.add_column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') + # Now reset the original values to invalids... they will be filled in # at later times. Preserve content only in the columns: name, x0, y0, m0 (and 0e). - # Note that these are all the 1D columsn. + # Note that these are all the 1D columns. for col_name in ref_table.colnames: if len(ref_table[col_name].data.shape) == 2: # Find the 2D columns - ref_table._set_invalid_list_values(col_name, -1) + ref_table._set_invalid_list_values(col_name, -1) return ref_table @@ -1869,14 +2392,14 @@ def copy_over_values(ref_table, star_list, star_list_T, idx_epoch, idx_ref, idx_ into the reference table we carry around and that is the final output product. Copy only those values for stars that match. - Copy all columns that are in both ref_table and star_list_T. + Copy all columns that are in both ref_table and star_list_T. Copy all columns that are also in star_list but copy them into _orig. Parameters ---------- ref_table : StarTable The table we will be copying values into. Note the columns with the appropriate - names and dimensions must already exist. + names and dimensions must already exist. star_list : StarList The astropy table to copy values from. These should be untransformed (orig) values. star_list_T : StarList @@ -1903,7 +2426,7 @@ def reset_ref_values(ref_table): """ Reset all the 2D arrays in the reference table. This is the action we take at the beginning of each new iteration. We don't preserve matching - results from the prior iterations. + results from the prior iterations. """ # All 2D columns should be reset. for col_name in ref_table.colnames: @@ -1911,25 +2434,27 @@ def reset_ref_values(ref_table): # Loop through epochs for this array. for cc in range(ref_table[col_name].shape[1]): ref_table._set_invalid_list_values(col_name, cc) - + return -def add_rows_for_new_stars(ref_table, star_list, idx_lis, default_motion_model='Fixed'): +def add_rows_for_new_stars(ref_table, star_list, idx_list, motion_model_name='Fixed', fixed_params_dict=None): """ - For each star that is in star_list and NOT in idx_list, make a - new row in the reference table. The values will be empty (None, NAN, etc.). + For each star that is in star_list and NOT in idx_list, make a + new row in the reference table. The values will be empty (None, NAN, etc.). Parameters ---------- ref_table : StarTable The reference table that the rows will be added to. - star_list : StarList The starlist that will be used to estimate how many new stars there are. - - idx_lis : array or list + idx_list : array or list The indices of the non-new stars (those that matched already). The complement of this array will be used as the new stars. + motion_model_name : str + The motion model name to assign to the new stars. + fixed_params_dict : dict + The default fixed parameters to assign to the new stars. Returns ---------- @@ -1938,40 +2463,58 @@ def add_rows_for_new_stars(ref_table, star_list, idx_lis, default_motion_model=' idx_lis_new : list The list of indices into the star_list object for the "new" stars. idx_ref_new : list - The list of indices into the ref_table object for the "new" stars. + The list of indices into the ref_table object for the "new" stars. """ last_star_idx = len(ref_table) idx_lis_orig = np.arange(len(star_list)) - idx_lis_new = np.array(list(set(idx_lis_orig) - set(idx_lis))) + idx_lis_new = np.array(list(set(idx_lis_orig) - set(idx_list))) + N_newstars = len(idx_lis_new) + + mm_map = motion_model.motion_model_map() + mm = mm_map[motion_model_name] - if len(idx_lis_new) > 0: + # Add optional fixed params default values into fixed params dict, prioritizing values in fixed_params_dict + if fixed_params_dict is not None: + fixed_params_dict.update({k: v for k, v in mm.optional_fixed_params.items() if k not in fixed_params_dict}) + else: + fixed_params_dict = mm.optional_fixed_params.copy() + + if N_newstars > 0: col_arrays = {} for col_name in ref_table.colnames: new_col_name = col_name - - if ref_table[col_name].dtype == np.dtype('float'): + + if col_name in fixed_params_dict.keys(): + new_col_empty = fixed_params_dict[col_name] + elif col_name=='n_params': + new_col_empty = mm.n_params + elif col_name=='motion_model_input': + new_col_empty = motion_model_name + elif col_name=='motion_model_used': + new_col_empty = 'Empty' + elif ref_table[col_name].dtype == np.dtype('float'): new_col_empty = np.nan elif ref_table[col_name].dtype == np.dtype('int'): new_col_empty = -1 elif ref_table[col_name].dtype == np.dtype('bool'): new_col_empty = False - elif col_name=='motion_model_input': - new_col_empty = default_motion_model - elif col_name=='motion_model_used': - new_col_empty = 'Fixed' else: new_col_empty = np.nan - + if len(ref_table[col_name].shape) == 1: - new_col_shape = len(idx_lis_new) + new_col_shape = N_newstars else: - new_col_shape = [len(idx_lis_new), ref_table[col_name].shape[1]] + new_col_shape = [N_newstars, ref_table[col_name].shape[1]] + + new_col_data = Column( + data=np.tile(new_col_empty, new_col_shape), + name=col_name, + dtype=ref_table[col_name].dtype + ) - new_col_data = Column(data=np.tile(new_col_empty, new_col_shape), - name=col_name, dtype=ref_table[col_name].dtype) col_arrays[new_col_name] = new_col_data ref_table_new = StarTable(**col_arrays) @@ -1982,7 +2525,7 @@ def add_rows_for_new_stars(ref_table, star_list, idx_lis, default_motion_model=' ref_table = vstack([ref_table, ref_table_new]) idx_ref_new = np.arange(last_star_idx, len(ref_table)) - + return ref_table, idx_lis_new, idx_ref_new """ @@ -1990,7 +2533,7 @@ def add_rows_for_new_stars(ref_table, star_list, idx_lis, default_motion_model=' """ def calc_mag_avg_all_stars(d): - # Determine how many stars there are. + # Determine how many stars there are. N_stars = len(d) # Determine how many epochs there are. @@ -2032,7 +2575,7 @@ def initial_align(table1, table2, briteN=100, y: y position xe: error in x position ye: error in y position - + vx: proper motion in x direction vy proper motion in y direction vxe: error in x proper motion @@ -2040,11 +2583,11 @@ def initial_align(table1, table2, briteN=100, m: magnitude me: magnitude error - + t0: linear motion time zero point use: specify use in transformation - + Parameters: ---------- @@ -2072,7 +2615,7 @@ def initial_align(table1, table2, briteN=100, Output: ------ Transformation object - + """ # Extract necessary information from tables (x, y, m) x1 = table1['x'] @@ -2120,7 +2663,7 @@ def transform_and_match(table1, table2, transform, dr_tol=1.0, dm_tol=None, verb starlist file positions. -transform: transformation object - + -verbose: bool, optional Prints on screen information on the matching @@ -2191,7 +2734,7 @@ def find_transform(table1, table1_trans, table2, transModel=transforms.PolyTrans if weights=='starlist', we only use postion error in transformed starlist. if weights=='reference', we only use position error in reference starlist. if weights==None, we don't use weights. - + verbose: bool (default=True) Prints on screen information on the matching @@ -2207,7 +2750,7 @@ def find_transform(table1, table1_trans, table2, transModel=transforms.PolyTrans (transModel != transforms.LegTransform) ): print(( '{0} not supported yet!'.format(transModel))) return - + # Extract *untransformed* coordinates from starlist 1 # and the matching coordinates from starlist 2 x1 = table1['x'] @@ -2285,7 +2828,7 @@ def find_transform_new(table1_mat, table2_mat, if weights = 'both' or 'starlist' then the positions in table 1 are first transformed using the transInit object. This is necessary if the plate scales are very different between the table 1 and the reference list. - + verbose: bool (default=True) Prints on screen information on the matching @@ -2298,7 +2841,7 @@ def find_transform_new(table1_mat, table2_mat, if ( (transModel != transforms.four_paramNW) & (transModel != transforms.PolyTransform) ): print(( '{0} not supported yet!'.format(transModel))) return - + # Extract *untransformed* coordinates from starlist 1 # and the matching coordinates from starlist 2 x1 = table1_mat['x'] @@ -2315,10 +2858,10 @@ def find_transform_new(table1_mat, table2_mat, if transInit != None: table1T_mat = table1_mat.copy() - table1T_mat = transform_by_object(table1T_mat, transInit) + table1T_mat = transform_from_object(table1T_mat, transInit) - x1e = table1T_mag['xe'] - y1e = table1T_mag['ye'] + x1e = table1T_mat['xe'] + y1e = table1T_mat['ye'] # Calculate weights as to user specification if weights == 'both': @@ -2386,7 +2929,7 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric outFile: string (default: 'outTrans.txt') Name of output text file - + Output: ------ txt file with the file name outFile @@ -2394,7 +2937,7 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric # Extract info about transformation trans_name = transform.__class__.__name__ trans_order = transform.order - + # Extract X, Y coefficients from transform if trans_name == 'four_paramNW': Xcoeff = transform.px @@ -2403,12 +2946,11 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric Xcoeff = transform.px.parameters Ycoeff = transform.py.parameters else: - print(( '{0} not yet supported!'.format(transType))) - return - + raise Exception(f'{trans_name} not yet supported!') + # Write output _out = open(outFile, 'w') - + # Write the header. DO NOT CHANGE, HARDCODED IN JAVA ALIGN _out.write('## Date: {0}\n'.format(datetime.date.today()) ) _out.write('## File: {0}, Reference: {1}\n'.format(starlist, reference) ) @@ -2421,7 +2963,7 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric _out.write('## N_trans: {0}\n'.format(N_trans)) _out.write('## Delta Mag: {0}\n'.format(deltaMag)) _out.write('{0:16s} {1:16s}\n'.format('# Xcoeff', 'Ycoeff')) - + # Write the coefficients such that the orders are together as defined in # documentation. This is a pain because PolyTransform output is weird. # (see astropy Polynomial2D documentation) @@ -2432,12 +2974,12 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric # CODE TO GET INDICIES N = trans_order - 1 idx_list = list() - + # when trans_order=1, N=0 idx_list.append(0) idx_list.append(1) idx_list.append(N+2) - + if trans_order >= 2: for k in range(2, N+2): idx_list.append(k) @@ -2458,7 +3000,7 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric _out.close() - + return @@ -2472,7 +3014,7 @@ def transform_from_file(starlist, transFile): are present in starlist. WARNING: THIS CODE WORKS FOR POLYTRANSFORM - + Parameters: ---------- starlist: astropy table @@ -2502,8 +3044,8 @@ def transform_from_file(starlist, transFile): # Do transform transform = transforms.PolyTransform(order, Xcoeff, Ycoeff) return transform_from_object(starlist, transform) - - + + def transform_from_object(starlist, transform): """ @@ -2512,7 +3054,7 @@ def transform_from_object(starlist, transform): if they are present in starlits. If a more complex motion_model is implemented, the motion parameters are set to nan, as we need the full time series to refit. - + Parameters: ---------- starlist: astropy table @@ -2534,7 +3076,7 @@ def transform_from_object(starlist, transform): keys = list(starlist.keys()) # Check to see if velocities or motion_model are present in starlist. - vel = ('vx' in keys)and ~("motion_model_input" in keys) + vel = ('vx' in keys) and ("motion_model_input" not in keys) mot = ("motion_model_input" in keys) # If the only motion models used are Fixed and Linear, we can still transform velocities. if mot: @@ -2546,11 +3088,11 @@ def transform_from_object(starlist, transform): if len(motion_models_unique)==0: vel=True mot=False - + # Prior code before motion_model implementation # Can still be used as shortcut for Linear+Fixed motion_model only err = 'xe' in keys - + # Extract needed information from starlist x = starlist_f['x'] y = starlist_f['y'] @@ -2571,7 +3113,7 @@ def transform_from_object(starlist, transform): vy = starlist_f['vy'] vxe = starlist_f['vx_err'] vye = starlist_f['vy_err'] - + # calculate the transformed position and velocity x_new, y_new, xe_new, ye_new = position_transform_from_object(x, y, xe, ye, transform) @@ -2584,7 +3126,7 @@ def transform_from_object(starlist, transform): starlist_f['y'] = y_new starlist_f['xe'] = xe_new starlist_f['ye'] = ye_new - + if vel: starlist_f['x0'] = x0_new starlist_f['y0'] = y0_new @@ -2594,15 +3136,15 @@ def transform_from_object(starlist, transform): starlist_f['vy'] = vy_new starlist_f['vx_err'] = vxe_new starlist_f['vy_err'] = vye_new - + # For more complicated motion_models, # we can't easily transform them, set the values to nans and refit later. if mot: - motion_model_params = motion_model.get_all_motion_model_param_names() + motion_model_params = motion_model.motion_model_param_names() for param in motion_model_params: if param in keys: starlist_f[param] = np.nan - + return starlist_f @@ -2615,7 +3157,7 @@ def position_transform_from_object(x, y, xe, ye, transform): - x, y: original position - xe, ye: original position error - transform: transformation object from astropy.modeling.models.polynomial2D - + Outpus: - x_new, y_new: transformed position - xe_new, ye_new: transformed position error @@ -2632,8 +3174,8 @@ def position_transform_from_object(x, y, xe, ye, transform): order = transform.order else: txt = 'Transform not yet supported by position_transform_from_object' - raise StandardError(txt) - + raise Exception(txt) + # How the transformation is applied depends on the type of transform. # This can be determined by the length of Xcoeff, Ycoeff N = order - 1 @@ -2657,7 +3199,7 @@ def position_transform_from_object(x, y, xe, ye, transform): for j in range(1, N+2-i): sub = int(2*N + 2 + j + (2*N+2-i) * (i-1)/2.) y_new += Ycoeff[sub] * (x**i) * (y**j) - + """ THIS IS WRONG BELOW! - NOTE: I don't think this is wrong any more @@ -2667,7 +3209,7 @@ def position_transform_from_object(x, y, xe, ye, transform): Should be doing: ((A**2 + B**2 + C**2) * xe**2) """ - + # xe_new & ye_new in (x,y,xe,ye) xe_new = 0 temp1 = 0 @@ -2715,11 +3257,11 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform - x0, y0, x0e, y0e: original position and position error - vx, vy, vxe, vye: original velocity and velocity error - transform: transformation object from astropy.modeling.models.polynomial2D - + Outpus: - vx_new, vy_new, vxe_new, vye_new: transformed velocity and velocity error """ - + # Read transformation: Extract X, Y coefficients from transform if transform.__class__.__name__ == 'four_paramNW': Xcoeff = transform.px @@ -2731,8 +3273,8 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform order = transform.order else: txt = 'Transform not yet supported by velocity_transform_from_object' - raise StandardError(txt) - + raise Exception(txt) + # How the transformation is applied depends on the type of transform. # This can be determined by the length of Xcoeff, Ycoeff N = order - 1 @@ -2793,7 +3335,7 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform for i in range(1, N+1): for j in range(1, N+2-i): sub = 2*N + 2 + j + (2*N+2-i) * (i-1)/2. - temp3 += i * Xcoeff[int(sub)] * (x0**(i-1)) * (y0**j) + temp3 += i * Xcoeff[int(sub)] * (x0**(i-1)) * (y0**j) for j in range(1, N+2): temp4 += j * Xcoeff[N+1+j] * (y0**(j-1)) @@ -2836,7 +3378,7 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform for i in range(1, N+1): for j in range(1, N+2-i): sub = 2*N + 2 + j + (2*N+2-i) * (i-1)/2. - temp3 += i * Ycoeff[int(sub)] * (x0**(i-1)) * (y0**j) + temp3 += i * Ycoeff[int(sub)] * (x0**(i-1)) * (y0**j) for j in range(1, N+2): temp4 += j * Ycoeff[N+1+j] * (y0**(j-1)) @@ -2867,7 +3409,7 @@ def check_trans_input(list_of_starlists, trans_input, mag_trans): if trans_input != None: assert len(trans_input) == len(list_of_starlists) - if mag_trans: + if mag_trans: for ii in range(len(trans_input)): if trans_input[ii] != None: try: @@ -2876,33 +3418,50 @@ def check_trans_input(list_of_starlists, trans_input, mag_trans): print('Missing trans.mag_offset on trans_input[{0:d}].'.format(ii)) print('Setting mag_offset = 0 and dm_tol[0] = 100 and hoping for the best!!') trans_input[ii].mag_offset = 0.0 - + return -def trans_initial_guess(ref_list, star_list, trans_args, motion_model_dict, mode='miracle', - ignore_contains='star', verbose=True, n_req_match=3, - mag_trans=True, order=1): +def trans_initial_guess( + ref_list, + star_list, + trans_args, + mode='miracle', + order=1, + briteN=None, + n_req_match=3, + polygon_reflist=None, + polygon_starlist=None, + buffer=0, + motion_models=None, + fixed_params_dict=None, + ignore_contains='star', + mag_trans=True, + verbose=True +): """ Take two starlists and perform an initial matching and transformation. This function will grow with time to handle difference types of initial guess transformations (triangle matching, match by name, etc.). For now it - is just blind triangle matching on the brightest 50 stars. + is just blind triangle matching on the brightest 50 stars. """ warnings.filterwarnings('ignore', category=AstropyUserWarning) - + if motion_models is None: + motion_models = [] + + # Match by name if mode == 'name': # First trim the two lists down to only those that don't contain # the "ignore_contains" string. - idx_r = np.flatnonzero(np.char.find(ref_list['name'], ignore_contains) == -1) - idx_s = np.flatnonzero(np.char.find(star_list['name'], ignore_contains) == -1) + idx_r = np.flatnonzero(np.char.find(ref_list['name'].astype(str), ignore_contains) == -1) + idx_s = np.flatnonzero(np.char.find(star_list['name'].astype(str), ignore_contains) == -1) # Match the star names name_matches, ndx_r, ndx_s = np.intersect1d(ref_list['name'][idx_r], star_list['name'][idx_s], assume_unique=True, return_indices=True) - + x1m = star_list['x'][idx_s][ndx_s] y1m = star_list['y'][idx_s][ndx_s] m1m = star_list['m'][idx_s][ndx_s] @@ -2911,31 +3470,47 @@ def trans_initial_guess(ref_list, star_list, trans_args, motion_model_dict, mode m2m = ref_list['m'][idx_r][ndx_r] N = len(x1m) - else: - # Default is miracle match. - briteN = min(50, len(star_list)) + # Default is miracle match. + elif mode == 'miracle': + if briteN is None: + briteN = min(50, len(star_list)) + else: + assert (type(briteN) == int) and (briteN > 0), f'briteN must be a positive integer, but got {briteN}.' # If there are velocities in the reference list, use them. # We assume velocities are in the same units as the positions. - xref, yref = get_pos_at_time(star_list['t'][0], ref_list, motion_model_dict) + xref, yref = infer_positions(star_list['t'][0], ref_list, motion_models, fixed_params_dict=fixed_params_dict) if 'm' in ref_list.colnames: mref = ref_list['m'] else: mref = ref_list['m0'] - - N, x1m, y1m, m1m, x2m, y2m, m2m = match.miracle_match_briteN(star_list['x'], - star_list['y'], - star_list['m'], - xref, - yref, - mref, - briteN) - - err_msg = 'Failed to find more than '+str(n_req_match) - err_msg += ' (only ' + str(len(x1m)) + ') matches, giving up.' - assert len(x1m) >= n_req_match, err_msg + + N, x1m, y1m, m1m, x2m, y2m, m2m = match.miracle_match_briteN( + star_list['x'], + star_list['y'], + star_list['m'], + xref, + yref, + mref, + briteN, + polygon_reflist, + polygon_starlist, + buffer=buffer + ) + else: + raise ValueError(f'flystar.align.trans_initial_guess: Unknown mode: {mode}. Must be one of ["name", "miracle"].') + + if len(x1m) < n_req_match: + fig, ax = plt.subplots() + ax.scatter(star_list['x'], star_list['y'], s=1, label='star_list') + ax.scatter(xref, yref, s=1, label='ref_list') + ax.legend() + ax.set_aspect('equal') + plt.show() + raise AssertionError(f'Failed to find more than {n_req_match} (only {len(x1m)}) matches, giving up.') + if verbose > 1: - print('initial_guess: {0:d} stars matched between starlist and reference list'.format(N)) + print('Initial_guess: {0:d} stars matched between starlist and reference list'.format(N)) # Calculate position transformation based on matches if ('order' in trans_args) and (trans_args['order'] == 0): @@ -2952,12 +3527,15 @@ def trans_initial_guess(ref_list, star_list, trans_args, motion_model_dict, mode trans.mag_offset = np.mean(m2m - m1m) else: trans.mag_offset = 0 - + if verbose > 1: - print('init guess: ', trans.px.parameters, trans.py.parameters) + print('Initial guess:') + print(f'{trans.px.parameters=}') + print(f'{trans.py.parameters=}') + print(f'{trans.mag_offset=}') warnings.filterwarnings('default', category=AstropyUserWarning) - + return trans @@ -2967,7 +3545,7 @@ def update_old_and_new_names(ref_table, list_index, idx_ref_new): new_name_len_max = 0 for ss in idx_ref_new: - new_name = '{0:3d}_{1:s}'.format(list_index, ref_table['name_in_list'][ss, list_index]) + new_name = f"{list_index:3d}_{str(ref_table['name_in_list'][ss, list_index]):s}" new_names.append(new_name) new_name_len_max = max(new_name_len_max, len(new_name)) @@ -2979,15 +3557,15 @@ def update_old_and_new_names(ref_table, list_index, idx_ref_new): all_names = old_names.astype('U{0:d}'.format(new_name_len_max)) else: all_names = old_names - + all_names[idx_ref_new] = new_names - + return all_names def copy_and_rename_for_ref(star_list): """ Make a deep copy of the starlist and rename the columns to include - "0". This only applies to x, y, m and xe, ye, me (if they exist) + "0". This only applies to x, y, m and xe, ye, me (if they exist) columns. Input @@ -3010,7 +3588,7 @@ def copy_and_rename_for_ref(star_list): if 'w' in star_list.colnames: old_cols += ['w'] new_cols += ['w'] - + ref_list = copy.deepcopy(star_list) for ii in range(len(old_cols)): @@ -3018,51 +3596,51 @@ def copy_and_rename_for_ref(star_list): return ref_list -def outlier_rejection_indices(star_list, ref_list, outlier_tol, verbose=True): +def outlier_rejection_indices(star_list, ref_list, outlier_tol, motion_models, fixed_params_dict=None, verbose=True): """ Determine the outliers based on the residual positions between two different - starlists and some threshold (in sigma). Return the indices of the stars - to keep (that shouldn't be rejected as outliers). + starlists and some threshold (in sigma). Return the indices of the stars + to keep (that shouldn't be rejected as outliers). Note that we assume that the star_list and ref_list are already transformed and - matched. + matched. Parameters ---------- star_list : StarList starlist with 'x', 'y' - ref_list : StarList starlist with 'x0', 'y0' - outlier_tol : float - Number of sigma inside which we keep stars and outside of which we - reject stars as outliers. - - Optional Parameters - -------------------- - verbose : boolean + Number of sigma inside which we keep stars and outside of which we + reject stars as outliers. + motion_models : list of motion_model objects + The motion models to use in the star_list + fixed_params_dict : dict or None, optional + Dictionary of fixed parameters for motion models, by default None + verbose : bool, optional + If True, print information about the outlier rejection process, by default True Returns ---------- - keepers : nd.array - The indicies of the stars to keep. + keepers : bool array + The boolean array of the stars to keep. """ # Optionally propogate the reference positions forward in time. - xref, yref = get_pos_in_time(star_list['t'][0], ref_list) - + xref, yref = infer_positions(star_list['t'][0], ref_list, motion_models, fixed_params_dict=fixed_params_dict) + # Residuals x_resid_on_old_trans = star_list['x'] - xref y_resid_on_old_trans = star_list['y'] - yref resid_on_old_trans = np.hypot(x_resid_on_old_trans, y_resid_on_old_trans) threshold = outlier_tol * resid_on_old_trans.std() - keepers = np.where(resid_on_old_trans < threshold)[0] + keepers = resid_on_old_trans < threshold if verbose > 0: msg = ' Outlier Rejection: Keeping {0:d} of {1:d}' - print(msg.format(len(keepers), len(resid_on_old_trans))) - + print(msg.format(sum(keepers), len(resid_on_old_trans))) + return keepers def setup_trans_info(trans_input, trans_args, N_lists, iters): @@ -3082,12 +3660,12 @@ def setup_trans_info(trans_input, trans_args, N_lists, iters): if type(trans_args) == dict: tmp = trans_args trans_args = [tmp for ii in range(iters)] - + return trans_list, trans_args def apply_mag_lim(star_list, mag_lim): - """ Apply a magnitude limit to the list. If no magnitude limit is - specified, then return a copy of the list. This works on a + """ Apply a magnitude limit to the list. If no magnitude limit is + specified, then return a copy of the list. This works on a reference list (with 'm0') or a star_list ('m') with 'm0' taking priority. @@ -3106,7 +3684,7 @@ def apply_mag_lim(star_list, mag_lim): mcol = 'm' conditions = {} - + cond_key = '{0:s}_min'.format(mcol) conditions[cond_key] = mag_lim[0] @@ -3124,7 +3702,7 @@ def get_weighting_scheme(weights, ref_list, star_list): else: var_xref = 0.0 var_yref = 0.0 - + if 'xe' in star_list.colnames: var_xlis = star_list['xe']**2 var_ylis = star_list['ye']**2 @@ -3155,41 +3733,9 @@ def get_weighting_scheme(weights, ref_list, star_list): return weight -# TODO: This is sometimes run on a startable, not a starlist, at least as currently used -def get_pos_at_time(t, starlist, motion_model_dict): - """ - Take a starlist, check to see if it has motion/velocity columns. - If it does, then propogate the positions forward in time - to the desired epoch. If no motion/velocities exist, then just - use ['x0', 'y0'] or ['x', 'y'] - - Inputs - ---------- - t_array : float - The time to propogate to. Usually in decimal years; - but it should be in the same units - as the 't0' column in starlist. - """ - # Check for motion model - if 'motion_model_used' in starlist.colnames: - x,y,xe,ye = starlist.get_star_positions_at_time(t, motion_model_dict, allow_alt_models=True) - # If no motion model, check for velocities - elif ('vx' in starlist.colnames) and ('vy' in starlist.colnames): - x = starlist['x0'] + starlist['vx']*(t-starlist['t0']) - y = starlist['y0'] + starlist['vy']*(t-starlist['t0']) - # If no velocities, try fitted positon - elif ('x0' in starlist.colnames) and ('y0' in starlist.colnames): - x = starlist['x0'] - y = starlist['y0'] - # Otherwise, use measured position - else: - x = starlist['x'] - y = starlist['y'] - - return (x, y) def logger(logfile, message, verbose = 9): if verbose > 4: print(message) logfile.write(message + '\n') - return + return \ No newline at end of file diff --git a/flystar/analysis.py b/flystar/analysis.py index 3121458..7deaa36 100644 --- a/flystar/analysis.py +++ b/flystar/analysis.py @@ -1,17 +1,11 @@ import numpy as np import pylab as plt -from flystar import starlists -from flystar import startables -from flystar import align -from flystar import match -from flystar import transforms +from . import starlists, match from astropy import table from astropy.table import Table, Column from astropy.coordinates import SkyCoord from astropy import units as u from astropy.wcs import WCS -from astroquery.gaia import Gaia -from astroquery.mast import Observations, Catalogs import pdb, copy import math from scipy.stats import f @@ -35,13 +29,14 @@ def query_gaia(ra, dec, search_radius=30.0, table_name='gaiadr3'): Dec. in degrees in the format such as '-29:00:28.0' search_radius : float - The search radius in arcseconds. + The search radius in arcseconds. Optional Input -------------- table_name : string Options are 'gaiadr2' or 'gaiaedr3' """ + from astroquery.gaia import Gaia target_coords = SkyCoord(ra, dec, unit=(u.hourangle, u.deg), frame='icrs') ra = target_coords.ra.degree dec = target_coords.dec.degree @@ -49,11 +44,12 @@ def query_gaia(ra, dec, search_radius=30.0, table_name='gaiadr3'): search_radius *= u.arcsec Gaia.ROW_LIMIT = 50000 - gaia_job = Gaia.cone_search_async(target_coords, search_radius, table_name = table_name + '.gaia_source') + gaia_job = Gaia.cone_search_async(target_coords, radius=search_radius, table_name=table_name + '.gaia_source') gaia = gaia_job.get_results() #Change new 'SOURCE_ID' column header back to lowercase 'source_id' so all subsequent functions still work: - gaia['SOURCE_ID'].name = 'source_id' + if 'SOURCE_ID' in gaia.colnames: + gaia.rename_column('SOURCE_ID', 'source_id') return gaia @@ -107,13 +103,13 @@ def check_gaia_parallaxes(ra,dec,search_radius=10.0,table_name='gaiadr3',target= plt.yscale('log') plt.tight_layout() plt.savefig('gaiaplx'+file_ext+'.png') - + def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, pi_err_limit=0.4, default_motion_model='Linear'): """ Take a Gaia table (from astroquery) and produce a new table with a tangential projection - and shift such that the origin is centered on the target of interest. - Convert everything into arcseconds and name columns such that they are + and shift such that the origin is centered on the target of interest. + Convert everything into arcseconds and name columns such that they are ready for FlyStar input. Inputs @@ -130,7 +126,7 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, target_coords = SkyCoord(ra, dec, unit=(u.hourangle, u.deg), frame='icrs') ra = target_coords.ra.degree # in decimal degrees dec = target_coords.dec.degree # in decimal degrees - + cos_dec = np.cos(np.radians(dec)) x = (gaia['ra'] - ra) * cos_dec * 3600.0 # arcsec y = (gaia['dec'] - dec) * 3600.0 # arcsec @@ -149,7 +145,7 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, gaia_new['vy'] = gaia['pmdec'].data / 1e3 gaia_new['vx_err'] = gaia['pmra_error'].data / 1e3 gaia_new['vy_err'] = gaia['pmdec_error'].data / 1e3 - + gaia_new['t0'] = gaia['ref_epoch'].data gaia_new['source_id'] = gaia['source_id'].data.astype('S19') @@ -159,7 +155,7 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, gaia_new['vy'][idx] = 0.0 gaia_new['vx_err'][idx] = 0.0 gaia_new['vy_err'][idx] = 0.0 - + gaia_new['m'] = gaia['phot_g_mean_mag'] gaia_new['me'] = 1.09/gaia['phot_g_mean_flux_over_error'] gaia_new['pi'] = gaia['parallax'].data*1e-3 @@ -171,7 +167,7 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, gaia_new['vx_err'][idx] = 0.0 gaia_new['vy'][idx] = 0.0 gaia_new['vy_err'][idx] = 0.0 - + # Cut out stars with high plx error and set motion models idx = np.where((gaia_new['pi_err']>(pi_err_limit/1e3)) | (gaia['parallax'].mask == True))[0] gaia_new['pi'][idx] = 0.0 @@ -190,9 +186,13 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, gaia_new['motion_model_input'] = 'Fixed' gaia_new['motion_model_used'] = 'Fixed' gaia_new['n_params'] = 1 + elif default_motion_model=='Empty': + gaia_new['motion_model_input'] = 'Empty' + gaia_new['motion_model_used'] = 'Empty' + gaia_new['n_params'] = 0 else: print("Invalid motion model",default_motion_model,"- none assigned") - + #macy additions to try to fix wild magnitude values #gaia_new['ruwe'] = gaia['ruwe'] #try: @@ -228,9 +228,9 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, print('Found match for: ', targ_names[idx], ' - ',gaia_new['source_id'][i_gaia]) return gaia_new - + def run_flystar(): - + test_file = '/u/jlu/work/microlens/OB150211/a_2018_10_19/a_ob150211_2018_10_19/lis/stars_matched2.fits' t = Table.read(test_file) @@ -262,39 +262,39 @@ def run_flystar(): ym_t = y0 + vy * (t - t0) # Model distorted positions - - + + return def project_gaia(gaia, epoch, ra, dec): """ Take the Gaia measurements, forward them in time, and then convert them into a tangential projection. - + Inputs ---------- epoch : float (year) The decimal year to project the measurement to. Note that we use 365.25 days per year. - + ra : float (deg) The right ascension (J2000) in decimal degrees of the center of the field. - + dec : float (deg) The declination (J2000) in decimal degrees of the center of the field. - + """ t0 = gaia['ref_epoch'] x0 = (gaia['ra'] - ra) * np.cos(np.radians(dec)) * 3600.0 # Arcsec y0 = (gaia['dec'] - dec) * 3600.0 x0e = gaia['ra_error'] / 1.0e3 # arcsec, already in alpha* (multiplied by cos(delta)) y0e = gaia['dec_error'] / 1.0e3 # arcsec - - + + vx = gaia['pmra'] / 1.0e3 # arcsec / yr - vy = gaia['pmdec'] / 1.0e3 + vy = gaia['pmdec'] / 1.0e3 vxe = gaia['pmra_error'] / 1.0e3 # arcsec / yr vye = gaia['pmdec_error'] / 1.0e3 - + # Modify any vx/vy, etc. that are zero and make a regular (unmasked) numpy array. vx[vx.mask] = 0.0 vy[vy.mask] = 0.0 @@ -304,29 +304,29 @@ def project_gaia(gaia, epoch, ra, dec): vy = np.array(vy) vxe = np.array(vxe) vye = np.array(vye) - + dt = epoch - t0 x_now = (x0 + (vx * dt)) * -1.0 # Switch to a left-handed coordinate system, like detector pixels. y_now = (y0 + (vy * dt)) xe_now = np.hypot(x0e, vxe*dt) ye_now = np.hypot(y0e, vye*dt) - + # Format as a starlist - gaia_lis = starlists.StarList(name=gaia['source_id'], + gaia_lis = starlists.StarList(name=gaia['source_id'], x=x_now, y=y_now, m=gaia['phot_g_mean_mag'], xe=xe_now, ye=ye_now, me=1.0/gaia['phot_g_mean_flux_over_error']) - + # Duplicate columns to 'x_avg', etc. Needed for initial guessing. gaia_lis['x_avg'] = gaia_lis['x'] gaia_lis['y_avg'] = gaia_lis['y'] - gaia_lis['m_avg'] = gaia_lis['m'] - + gaia_lis['m_avg'] = gaia_lis['m'] + return gaia_lis def rename_after_flystar(star_tab, label_dat_file, new_copy=True, dr_tol=0.05, dm_tol=0.3, verbose=False): """ - Take a StarTable output from FlyStar MosaicToRef that has been + Take a StarTable output from FlyStar MosaicToRef that has been aligned into R.A. and Dec. (usually by way of Gaia). Align the output to a label.dat file for this source and rename everything. @@ -354,20 +354,20 @@ def rename_after_flystar(star_tab, label_dat_file, new_copy=True, dr_tol=0.05, d x_lab[ndx_lab[ii]], star_tab['x0'][ndx_star[ii]], y_lab[ndx_lab[ii]], star_tab['y0'][ndx_star[ii]], m_lab[ndx_lab[ii]], star_tab['m0'][ndx_star[ii]])) - + print('Temporary shift transformations: ') print(' dm = {0:8.4f} +/- {1:8.4f}'.format(dm.mean(), dm.std())) print(' dx = {0:8.4f} +/- {1:8.4f}'.format(dx.mean(), dx.std())) print(' dy = {0:8.4f} +/- {1:8.4f}'.format(dy.mean(), dy.std())) - + m_lab = label_tab['m'] + dm.mean() x_lab += dx.mean() y_lab += dy.mean() - + # Now that we are in a common coordinate and magnitude # system, lets match the whole lists by coordinates. - idx_lab, idx_star, dr, dm = match.match(x_lab, y_lab, m_lab, + idx_lab, idx_star, dr, dm = match.match(x_lab, y_lab, m_lab, star_tab['x0'], star_tab['y0'], star_tab['m0'], dr_tol=dr_tol, dm_tol=dm_tol, verbose=verbose) #print('idx_lab:') @@ -375,7 +375,7 @@ def rename_after_flystar(star_tab, label_dat_file, new_copy=True, dr_tol=0.05, d # print(label_tab["name"][idx_lab[iii]], star_tab["name"][idx_star[iii]]) print('Renaming {0:d} out of {1:d} stars'.format(len(idx_lab), len(star_tab))) - + # Make a copy of the table, UNLESS, the user specifies. if new_copy: new_tab = copy.deepcopy(star_tab) @@ -385,9 +385,9 @@ def rename_after_flystar(star_tab, label_dat_file, new_copy=True, dr_tol=0.05, d # copy over the original names... don't overwrite (this could mean data loss) if 'name_orig' not in new_tab.colnames: new_tab.add_column(Column(star_tab['name'].data, name='name_orig')) - + new_tab['name'][idx_star] = label_tab[idx_lab]['name'] - + return new_tab def pick_good_ref_stars(star_tab, r_cut=None, m_cut=None, p_err_cut=None, pm_err_cut=None, name_cut=None, reset=True): @@ -432,9 +432,9 @@ def pick_good_ref_stars(star_tab, r_cut=None, m_cut=None, p_err_cut=None, pm_err def startable_subset(tab, idx, mag_trans=True, mag_trans_orig=False): """ - Input is MosaicToRef table from alignment of multiple filters, + Input is MosaicToRef table from alignment of multiple filters, such that the astrometry is combined but the photometry is not. - This function is used to separate out a selected filter from the + This function is used to separate out a selected filter from the combined astrometry + uncombined photometry table. """ # Multiples: ['x', 'y', 'm', 'name_in_list', 'xe', 'ye', 'me', 't', @@ -466,7 +466,7 @@ def startable_subset(tab, idx, mag_trans=True, mag_trans_orig=False): # Update the original table. if mag_trans_orig: tab['m'][:,idx[ii]] += mag_offset - + return new_tab @@ -476,13 +476,13 @@ def startable_subset(tab, idx, mag_trans=True, mag_trans_orig=False): def calc_chi2(ref_mat, starlist_mat, transform, errs='both'): """ - calculate the chi2 and reduced chi2 of the position + calculate the chi2 and reduced chi2 of the position between two matched starlists. Input: ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in the transformation. Standard column headers are assumed. @@ -522,7 +522,7 @@ def calc_chi2(ref_mat, starlist_mat, transform, errs='both'): elif errs == 'starlist': xerr = starlist_mat['xe'] yerr = starlist_mat['ye'] - + # For both X and Y, calculate chi-square. Combine arrays to get combined # chi-square @@ -530,11 +530,11 @@ def calc_chi2(ref_mat, starlist_mat, transform, errs='both'): chi_sq_y = diff_y**2. / yerr**2. chi_sq = np.append(chi_sq_x, chi_sq_y) - + # Calculate degrees of freedom in transformation num_mod_params = calc_nparam(transform) deg_freedom = len(chi_sq) - num_mod_params - + # Calculate reduced chi-square chi_sq = np.sum(chi_sq) chi_sq_red = chi_sq / deg_freedom @@ -551,7 +551,7 @@ def calc_nparam(transformation): nparam = 4 elif transformation.__class__.__name__ == 'PolyTransform': order = transformation.order - nparam = (order+1) * (order+2) + nparam = (order+1) * (order+2) return nparam def calc_F(red_chi2_1, red_chi2_2, v1, v2): @@ -572,24 +572,24 @@ def calc_F(red_chi2_1, red_chi2_2, v1, v2): for 1st order polynomial fitting: x' = a0 + a1*x + a2*y y' = b0 + b1*x + b2*y - v1 = 2*N1 - 2*3 (2*: because x and y direction) + v1 = 2*N1 - 2*3 (2*: because x and y direction) red_chi2_1 = chi2/v1 for 2nd order polynomial fitting: x' = a0 + a1*x + a2*y + a3*x**2 + a4*y**2 + a5*x*y y' = b0 + b1*x + b2*y + b3*x**2 + b4*y**2 + b5*x*y - v1 = 2*N1 - 2*6 + v1 = 2*N1 - 2*6 red_chi2_2 = chi2/v2 calc_F(red_chi2_1, red_chi2_2, v1, v2) - + ***Note*** - * make sure the first model is the simple model + * make sure the first model is the simple model and the second model is the more complicated model - * the return value represents the probability that + * the return value represents the probability that the first model is better than the second model, in other words, the small P means the more colicated model is needed. the large P means the simple model is good enough. - * normally, the P value will increase from model1->model2, to - model2->model3, to model3->model4. The user can decide a + * normally, the P value will increase from model1->model2, to + model2->model3, to model3->model4. The user can decide a critical value (eg, 0.7) to find the proper model. """ diff --git a/flystar/archive_io.py b/flystar/archive_io.py index 88de5cb..2177e40 100755 --- a/flystar/archive_io.py +++ b/flystar/archive_io.py @@ -1,9 +1,9 @@ import pickle -# Need to add these functions to a utility .py file rather than storing them in general structure. +# Need to add these functions to a utility .py file rather than storing them in general structure. def open_archive(file_name): """ - Helper function to open archived files. + Helper function to open archived files. """ with open(file_name, 'rb') as file_archive: file_dict = pickle.load(file_archive) @@ -11,7 +11,7 @@ def open_archive(file_name): def save_archive(file_name, save_data): """ - Helper function to archive a file. + Helper function to archive a file. """ with open(file_name, 'wb') as outfile: pickle.dump(save_data, outfile, protocol=pickle.HIGHEST_PROTOCOL) diff --git a/flystar/examples.py b/flystar/examples.py index 8059562..0165cb3 100644 --- a/flystar/examples.py +++ b/flystar/examples.py @@ -1,11 +1,5 @@ -from flystar import transforms -from flystar import match -from flystar import align -from flystar import starlists -from flystar import plots import numpy as np -import copy -import pdb +from . import transforms, match, align, starlists, plots def align_example(labelFile, reference, transModel=transforms.four_paramNW, order=1, N_loop=2, @@ -38,7 +32,7 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde dr_tol: float (default = 1.0) The search radius for the matching algorithm, in the same units as the starlist file positions. - + dm_tol: float or None If float, sets the maximum magnitude difference allowed in matching between label.dat and starlist. Note that this should be set to @@ -54,10 +48,10 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde outFile: string (default = 'outTrans.txt') Name of output ascii file which contains the transform parameters. - + Output: ------ - + """ # Read in label.dat file and reference starlist, changing columns to their # standard column headers/epochs/orientations @@ -72,7 +66,7 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde # Apply intial transformation to label.dat (for error weighting purposes below) label_trans = align.transform_from_object(label, trans) - + # Use transformation to match starlists, then recalculate transformation. # Iterate on this as many times as desired for i in range(N_loop): @@ -80,10 +74,10 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde trans, dr_tol=dr_tol, dm_tol=dm_tol) - + trans, N_trans = align.find_transform(label[idx_label], label_trans[idx_label], - starlist_mat[idx_starlist], + starlist[idx_starlist], transModel=transModel, order=order, weights=weights) @@ -91,14 +85,14 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde # Write final transform in java align format print('Write transform to {0}'.format(outFile)) align.write_transform(trans, labelFile, reference, N_trans, outFile=outFile) - + # Test transform: apply final transformation to label.dat label_trans2 = align.transform(label, outFile) # Make diagnostic plots - + return - + def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order=1, N_loop=2, dr_tol=1.0, dm_tol=None, briteN=100, weights=None, restrict=False, @@ -131,7 +125,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order dr_tol: float (default = 1.0) The search radius for the matching algorithm, in the same units as the starlist file positions. - + dm_tol: float or None (default = None) If float, sets the maximum magnitude difference allowed in matching between label.dat and starlist. Note that this should be set to @@ -143,7 +137,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order weights: string (default=None) if weights=='both', we use both position error and velocity error in transformed - starlist and reference starlist as uncertanties. And weights is the reciprocal + starlist and reference starlist as uncertanties. And weights is the reciprocal of this uncertanty. if weights=='starlist', we only use postion error and velocity error in transformed starlist as uncertainty. @@ -156,7 +150,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order outFile: string (default = 'outTrans.txt') Name of output ascii file which contains the transform parameters. - + Output: ------ outFile is written containing the tranformation coefficients @@ -170,11 +164,11 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order positions and the label.dat positions after transformation. -Positions_quiver.png: Quiver plot showing the difference between reference - positions and transformed label.dat positions as a function of location. - + positions and transformed label.dat positions as a function of location. + -Magnitude_hist.png: Histogram of the difference between the reference list magnitude and label.dat magnitude for matched stars. - + """ # Read in label.dat file and reference starlist, changing columns to their # standard column headers/epochs/orientations @@ -192,10 +186,10 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order # Perform blind matching of 100 brightest stars and calculate initial transform trans = align.initial_align(label_r, starlist, briteN, transformModel=transModel, order=order) - + # Apply transformation to label.dat file, for weighting purposes. label_trans = align.transform_from_object(label, trans) - + # Use transformation to match starlists, then recalculate transformation. # Iterate on this as many times as desired for i in range(N_loop): @@ -223,7 +217,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order print('Write transform to {0}'.format(outFile)) align.write_transform(trans, labelFile, reference, N_trans, deltaMag=delta_m, restrict=restrict, weights=weights, outFile=outFile) - + # Test transform: apply to label.dat, make diagnostic plots label_trans2 = align.transform_from_file(label, outFile) @@ -241,7 +235,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order label_trans2[idx_label], xlim=xlim, ylim=ylim) # Histogram of difference in transformed and reference positions for - # matched stars + # matched stars plots.pos_diff_hist(starlist[idx_starlist], label_trans2[idx_label]) # Histogram of difference in transformed and reference positions for @@ -250,7 +244,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order plots.pos_diff_err_hist(starlist[idx_starlist], label_trans2[idx_label], trans, errs='both', bin_width=0.5, xlim=[-6,6]) - # Histogram of difference in the magnitudes for the matched stars + # Histogram of difference in the magnitudes for the matched stars plots.mag_diff_hist(starlist[idx_starlist], label_trans2[idx_label]) # Quiver plot showing difference between transformed and reference @@ -260,7 +254,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order ylim=ylim, outlier_reject=None) print('Done with plots') - print('Done with plots') + print('Done with plots') return @@ -274,7 +268,7 @@ def align_gc(starFile, refFile, transModel=transforms.PolyTransform, order=1, N_ Parameters: ----------- starFile: string - Starlist we would like to transform into the reference frame, eg:label.dat + Starlist we would like to transform into the reference frame, eg:label.dat refFile: string Starlist that defines the reference frame. @@ -312,7 +306,7 @@ def align_gc(starFile, refFile, transModel=transforms.PolyTransform, order=1, N_ """ #---------------------------------------------- - # Read in starlist and reference + # Read in starlist and reference #---------------------------------------------- # starlist has postion & postion err ref = starlists.read_starlist(refFile, error=True) @@ -400,7 +394,7 @@ def align_starlists(starlist, ref, transModel=transforms.PolyTransform, order=2, Parameters: ----------- starlist: Table - Starlist we would like to transform into the reference frame, eg:label.dat + Starlist we would like to transform into the reference frame, eg:label.dat ref: Table Starlist that defines the reference frame. @@ -433,7 +427,7 @@ def align_starlists(starlist, ref, transModel=transforms.PolyTransform, order=2, outFile: string('outTrans.txt') the name of the output transformation file """ - + #-------------------------------------------------- # Initial transformation with brightest briteN stars #-------------------------------------------------- diff --git a/flystar/match.py b/flystar/match.py index d7c391e..241d334 100644 --- a/flystar/match.py +++ b/flystar/match.py @@ -1,23 +1,20 @@ +import copy +import itertools import numpy as np -from flystar import starlists, transforms, startables, align +import matplotlib.pyplot as plt +from . import starlists, transforms, startables from collections import Counter -from scipy.spatial import cKDTree as KDT -from astropy.table import Column, Table -import itertools -import copy -import scipy.signal -from scipy.spatial import distance -import math -import pdb +from astropy.table import Column +from scipy.spatial import KDTree as KDT -def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, - Nbins_vmax=200, Nbins_angle=360,verbose=False): +def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, + polygon1=None, polygon2=None, buffer=0, Nbins_vmax=200, Nbins_angle=360,verbose=False): """ Take two input starlists and select the brightest stars from each. Then perform a triangle matching algorithm along the lines of Groth 1986. - + For every possible triangle (combination of 3 stars) in a starlist, compute the ratio of two sides and the angle between those sides. These quantities are invariant under scale and rotation transformations. @@ -30,23 +27,115 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, and brightness uncertainties, the more bigger the bin sizes should really be. But this isn't well tested. """ - + if verbose: print( '') print( ' miracle_match_briteN: use brightest {0}'.format(Nbrite)) print( ' miracle_match_briteN: ') print( ' miracle_match_briteN: ') + xin1 = np.array(xin1) + yin1 = np.array(yin1) + min1 = np.array(min1) + xin2 = np.array(xin2) + yin2 = np.array(yin2) + min2 = np.array(min2) + + if (polygon1 is not None) and (polygon2 is not None): + import shapely + points1 = shapely.points(xin1, yin1) + points2 = shapely.points(xin2, yin2) + overlap = polygon1.intersection(polygon2).buffer(buffer) + in_poly1 = shapely.contains(overlap, points1) + in_poly2 = shapely.contains(overlap, points2) + xin1 = xin1[in_poly1] + yin1 = yin1[in_poly1] + min1 = min1[in_poly1] + xin2 = xin2[in_poly2] + yin2 = yin2[in_poly2] + min2 = min2[in_poly2] + # else: + # # Only look for matches within overlapping minimum-bounding-boxes of the 2 lists + # valid1 = (np.isfinite(xin1)) & (np.isfinite(yin1)) & (np.isfinite(min1)) + # valid2 = (np.isfinite(xin2)) & (np.isfinite(yin2)) & (np.isfinite(min2)) + # if (sum(valid1) < Nbrite) or (sum(valid2) < Nbrite): + # raise ValueError( + # f'Not enough valid stars to find matches! Need at least {Nbrite} valid stars.\n' + + # f'Valid stars in list 1: {sum(valid1)}\n' + + # f'Valid stars in list 2: {sum(valid2)}\n' + # ) + + # xin1 = xin1[valid1] + # yin1 = yin1[valid1] + # min1 = min1[valid1] + # xin2 = xin2[valid2] + # yin2 = yin2[valid2] + # min2 = min2[valid2] + + # xmin1, xmax1 = np.min(xin1), np.max(xin1) + # ymin1, ymax1 = np.min(yin1), np.max(yin1) + # xmin2, xmax2 = np.min(xin2), np.max(xin2) + # ymin2, ymax2 = np.min(yin2), np.max(yin2) + + # # Find the overlapping minimum bounding box + # x_overlap = (max(xmin1, xmin2), min(xmax1, xmax2)) + # y_overlap = (max(ymin1, ymin2), min(ymax1, ymax2)) + # if x_overlap[0] >= x_overlap[1] or y_overlap[0] >= y_overlap[1]: + # fig, ax = plt.subplots() + # ax.scatter(xin1, yin1, s=1, label='List 1') + # ax.scatter(xin2, yin2, s=1, label='List 2') + # ax.set_aspect('equal') + # ax.legend() + # plt.show() + # raise ValueError('The two star lists do not have an overlapping region!') + + # # Select overlapping regions + # in_overlap1 = (xin1 >= x_overlap[0]) & (xin1 <= x_overlap[1]) & (yin1 >= y_overlap[0]) & (yin1 <= y_overlap[1]) + # in_overlap2 = (xin2 >= x_overlap[0]) & (xin2 <= x_overlap[1]) & (yin2 >= y_overlap[0]) & (yin2 <= y_overlap[1]) + # if sum(in_overlap1) < Nbrite or sum(in_overlap2) < Nbrite: + # raise ValueError( + # 'Not enough stars in the overlapping region to find matches!\n' + + # f'Stars in overlap for list 1: {sum(in_overlap1)}\n' + + # f'Stars in overlap for list 2: {sum(in_overlap2)}\n' + # ) + + # from matplotlib.patches import Rectangle + # fig, ax = plt.subplots() + # polygon1 = Rectangle((xmin1, ymin1), xmax1-xmin1, ymax1-ymin1, fill=True, edgecolor='C0', facecolor='C0', alpha=0.5, label='MBB List 1') + # polygon2 = Rectangle((xmin2, ymin2), xmax2-xmin2, ymax2-ymin2, fill=True, edgecolor='C2', facecolor='C2', alpha=0.5, label='MBB List 2') + # polygon_overlap = Rectangle((x_overlap[0], y_overlap[0]), x_overlap[1]-x_overlap[0], y_overlap[1]-y_overlap[0], fill=True, edgecolor='red', facecolor='C3', alpha=0.5, label='Overlap Region') + # ax.scatter(xin1, yin1, s=1, label='List 1') + # ax.scatter(xin2, yin2, s=1, label='List 2') + # ax.add_patch(polygon1) + # ax.add_patch(polygon2) + # ax.add_patch(polygon_overlap) + # ax.set_aspect('equal') + # ax.legend() + # plt.show() + + # xin1 = xin1[in_overlap1] + # yin1 = yin1[in_overlap1] + # min1 = min1[in_overlap1] + # xin2 = xin2[in_overlap2] + # yin2 = yin2[in_overlap2] + # min2 = min2[in_overlap2] + # Get/check the lengths of the two starlists nin1 = len(xin1) nin2 = len(xin2) if (nin1 < Nbrite) or (nin2 < Nbrite): - print(( 'You need at least {0} to '.format(Nbrite))) - print( 'find the matches...') - print(( 'NIN1: ', nin1)) - print(( 'NIN2: ', nin2)) - return (0, None, None, None, None, None, None) + raise ValueError( + f'Not enough stars in the overlapping region to find matches! Need at least {Nbrite} valid stars.\n' + + f'Stars in overlap for list 1: {nin1}\n' + + f'Stars in overlap for list 2: {nin2}\n' + ) + # print(f'WARNING: You need at least {Nbrite} to find the matches...') + # print(f'NIN1: {nin1}') + # print(f'NIN2: {nin2}') + # # Nbrite = min(nin1, nin2) + # # print(f'Updating Nbrite to {Nbrite}...') + # return (0, None, None, None, None, None, None) # Take the Nbrite brightest stars from each list and order by brightness. if verbose: @@ -55,7 +144,7 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, print( ' miracle_match_briteN: ') x1, y1, m1 = order_by_brite(xin1, yin1, min1, Nbrite, verbose=verbose) x2, y2, m2 = order_by_brite(xin2, yin2, min2, Nbrite, verbose=verbose) - + #################### # # Triangle Matching @@ -111,7 +200,6 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, idx2_vmax_hist = idx2_vmax_hist[good_idx2] idx2_angl_hist = idx2_angl_hist[good_idx2] - ########## # Possible Matches ########## @@ -125,7 +213,7 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, # Now vote for all stars in the triangles that have possible matches (same vmax, angle) # between the first and second lists. votes = np.zeros((Nbrite, Nbrite)) - + matches = np.where(stars_in1_matches2[:,0] >= 0)[0] match_stars1 = stars_in1_matches2[matches,:] match_stars2 = stars_in_tri2[matches,:] @@ -138,7 +226,7 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, add_votes(votes, match_stars1[:,0], match_stars2[:,0]) add_votes(votes, match_stars1[:,1], match_stars2[:,1]) add_votes(votes, match_stars1[:,2], match_stars2[:,2]) - + ########## # Find matching triangles with most votes (and that pass threshold) ########## @@ -166,7 +254,6 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, x1_mat = x1[votes_sdx[0, good]] y1_mat = y1[votes_sdx[0, good]] m1_mat = m1[votes_sdx[0, good]] - return len(x1_mat), x1_mat, y1_mat, m1_mat, x2_mat, y2_mat, m2_mat @@ -207,8 +294,8 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): if one is found that is the best match in both brightness and positional offsets (closest in both), then the match is made. Otherwise, their is a conflict and no match is returned for the star. - - + + Parameters x1 : array-like X coordinate in the first catalog @@ -230,9 +317,9 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): How close in delta-magnitude a match has to be to count as a match. If None, then any delta-magnitude is allowed. verbose : bool or int, optional - Prints on screen information on the matching. Higher verbose values + Prints on screen information on the matching. Higher verbose values (up to 9) provide more detail. - + Returns ------- idx1 : int array @@ -245,27 +332,27 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): Distance between the matches. dm : float array Delta-mag between the matches. (m1 - m2) - + """ - + x1 = np.array(x1, copy=False) y1 = np.array(y1, copy=False) m1 = np.array(m1, copy=False) x2 = np.array(x2, copy=False) y2 = np.array(y2, copy=False) m2 = np.array(m2, copy=False) - + if x1.shape != y1.shape: raise ValueError('x1 and y1 do not match!') if x2.shape != y2.shape: raise ValueError('x2 and y2 do not match!') - + # Setup coords1 pairs and coords 2 pairs # this is equivalent to, but faster than just doing np.array([x1, y1]) coords1 = np.empty((x1.size, 2)) coords1[:, 0] = x1 coords1[:, 1] = y1 - + # this is equivalent to, but faster than just doing np.array([x1, y1]) coords2 = np.empty((x2.size, 2)) coords2[:, 0] = x2 @@ -283,7 +370,7 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): #KDTree handling of NaNs throws error in scipy v1.10.1 and newer. #Replace NaNs in coords2 with zero (0). -SKT kdt = KDT(np.where(np.isfinite(coords2), coords2, 0), balanced_tree=False) - + # This returns the number of neighbors within the specified # radius. We will use this to find those stars that have no or one # match and deal with them easily. The more complicated conflict @@ -293,7 +380,6 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): # What is the largest number of matches we have for a given star? Nmatch_max = Nmatch.max() - # Loop through and handle all the different numbers of matches. # This turns out to be the most efficient so we can use numpy # array operations. Remember, skip the Nmatch=0 objects... they @@ -306,7 +392,7 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): if nn == 1: i2_nn = np.array([i2_match[mm][0] for mm in i1_nn]) - if dm_tol != None: + if dm_tol is not None: dm = np.abs(m1[i1_nn] - m2[i2_nn]) keep = dm < dm_tol idxs1[i1_nn[keep]] = i1_nn[keep] @@ -327,10 +413,10 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): x2_nn = x2[i2_tmp] y2_nn = y2[i2_tmp] m2_nn = m2[i2_tmp] - dr = np.abs(x1_nn - x2_nn, y1_nn - y2_nn) + dr = np.hypot(x1_nn - x2_nn, y1_nn - y2_nn) dm = np.abs(m1_nn - m2_nn) - if dm_tol != None: + if dm_tol is not None: # Don't even consider stars that exceed our # delta-mag threshold. dr_msk = np.ma.masked_where(dm > dm_tol, dr) @@ -379,7 +465,7 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): # Assume the duplicates are confused first... see if we # can resolve the confusion below. keep[dups] = False - + dm_dups = m1[idxs1[dups]] - m2[idxs2[dups]] dr_dups = np.hypot(x1[idxs1[dups]] - x2[idxs2[dups]], y1[idxs1[dups]] - y2[idxs2[dups]]) @@ -391,7 +477,7 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): if dm_min == dr_min: keep[dups[dm_min]] = True else: - if verbose: + if verbose > 3: print(' confused, dropping star at',x2[idxs2[dups]][0],y2[idxs2[dups]][0]) @@ -400,12 +486,12 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): idxs2 = idxs2[keep] dr = dr[keep] dm = dm[keep] - + return idxs1, idxs2, dr, dm def calc_triangles_vmax_angle(x, y): idx = np.arange(len(x), dtype=np.int16) - + # Option 1 -- this takes 0.217 seconds for 50 objects # t1 = time.time() # combo_iter1 = itertools.combinations(idx1, 3) @@ -414,53 +500,53 @@ def calc_triangles_vmax_angle(x, y): # print( 'Finished Option 1: ', t2 - t1) # print( combo_idx1_1.shape) # print( combo_idx1_1) - + # Option 2 -- this takes 0.016 seconds for 50 objects combo_iter = itertools.combinations(idx, 3) combo_dt = np.dtype('i2,i2,i2') combo_idx_tmp = np.fromiter(combo_iter, dtype=combo_dt) combo_idx = combo_idx_tmp.view(np.int16).reshape(-1, 3) - + ii0 = combo_idx[:,0] ii1 = combo_idx[:,1] ii2 = combo_idx[:,2] - + dxab = x[ii1] - x[ii0] dyab = y[ii1] - y[ii0] dxac = x[ii2] - x[ii0] dyac = y[ii2] - y[ii0] - + dab = np.hypot(dxab, dyab) dac = np.hypot(dxac, dyac) - + dmax = np.max([dab, dac], axis=0) dmin = np.min([dab, dac], axis=0) - + vmax = dmin ** 2 / dmax ** 2 vmax[dab < dac] *= -1 - + vdprod = dxab * dxac + dyab * dyac vcprod = dxab * dyac - dyab * dxac - + angle = np.degrees( np.arctan2( vdprod, vcprod) ) angle[angle < 0] += 360.0 angle[angle > 360] -= 360.0 - + return combo_idx, vmax, angle def add_votes(votes, match1, match2): # Construct a histogram of how often a bin is matched... then add the delta flat_idx = np.ravel_multi_index((match1, match2), dims=votes.shape) - + # extract the unique indices and their position unique_idx, idx_idx = np.unique(flat_idx, return_inverse=True) - + # aggregate the repeated indices deltas = np.bincount(idx_idx) - + # Sum them to the array votes.flat[unique_idx] += deltas - + return @@ -517,7 +603,7 @@ def generic_match(sl1, sl2, init_mode='triangle', init_mode verbose : bool, optional Prints on screen information on the matching - + Returns ------- transf : Transform2D @@ -526,16 +612,17 @@ def generic_match(sl1, sl2, init_mode='triangle', Startable of the two matched catalogs """ - + from . import align + # Check the input StarLists and transform them into astropy Tables if not isinstance(sl1, starlists.StarList): raise TypeError("The first catalog has to be a StarList") if not isinstance(sl2, starlists.StarList): raise TypeError("The second catalog has to be a StarList") - + # Find the initial transformation if init_mode == 'triangle': # Blind triangles method - + # Prepare the reduced starlists for matching sl1_cut = copy.deepcopy(sl1) sl2_cut = copy.deepcopy(sl2) @@ -545,21 +632,21 @@ def generic_match(sl1, sl2, init_mode='triangle', y_min=xy_match[6], y_max=xy_match[7]) sl1_cut.restrict_by_value(m_min=m_match[0], m_max=m_match[1]) sl2_cut.restrict_by_value(m_min=m_match[2], m_max=m_match[3]) - + # Find the transformation # TODO: test 'initial_align' with StarList input transf = align.initial_align(sl1_cut, sl2_cut, briteN=n_bright, transformModel=model, order=order_dr[0]) #order_dr[i_loop][0] ? - + elif init_mode == 'match_name': # Name match sl1_idx_init, sl2_idx_init, _ = starlists.restrict_by_name(sl1, sl2) transf = model(sl2['x'][sl2_idx_init], sl2['y'][sl2_idx_init], sl1['x'][sl1_idx_init], sl1['y'][sl1_idx_init], order=int(order_dr[0][0])) - + elif init_mode == 'load': # Load a transformation file transf = transforms.Transform2D.from_file(kwargs['transf_file']) - + else: # None of the above raise TypeError("Unrecognized initial matching method") @@ -568,20 +655,24 @@ def generic_match(sl1, sl2, init_mode='triangle', sl2_match = copy.deepcopy(sl2) sl1_match.restrict_by_value(m_min=m_match[0], m_max=m_match[1]) sl2_match.restrict_by_value(m_min=m_match[2], m_max=m_match[3]) - + # Refine the transformation if sigma_match: order_dr_len = len(order_dr) - + for i_loop in range(sigma_match[1]): order_dr = np.vstack((np.array(order_dr), np.array(order_dr[-1]))) - + for i_loop in range(len(order_dr)): - + # Transform and match the catalog to the reference frame # sl2_idx, sl1_idx = align.transform_and_match(sl2_match, sl1_match, transf, # dr_tol=order_dr[i_loop][1], # verbose=verbose) + import matplotlib.pyplot as plt + plt.clf() + plt.plot(sl1_match['x'], sl1_match['y'], 'x', ms=10) + plt.plot(sl2_match['x'], sl2_match['y'], 'o') sl2_idx, sl1_idx = align.transform_and_match(sl2_match, sl1_match, transf, dr_tol=order_dr[1], @@ -589,7 +680,7 @@ def generic_match(sl1, sl2, init_mode='triangle', # Transform the catalog to the reference frame sl2_transf_match = align.transform_from_object(sl2_match, transf) - + # Sigma-rejection if sigma_match and (i_loop >= order_dr_len): resid = np.sqrt((sl1_match['x'][sl1_idx] - @@ -598,29 +689,29 @@ def generic_match(sl1, sl2, init_mode='triangle', sl2_transf_match['y'][sl2_idx])**2) sl1_idx = sl1_idx[resid <= (sigma_match[0] * np.std(resid))] sl2_idx = sl2_idx[resid <= (sigma_match[0] * np.std(resid))] - + # Test section to observe the matching catalogs before refining the transformation """ from matplotlib import pyplot - + _, axarr = pyplot.subplots(nrows=1, ncols=1, figsize=(10,10)) axarr.scatter(sl1_match['x'][sl1_idx], sl1_match['y'][sl1_idx]) xlim = axarr.get_xlim() ylim = axarr.get_ylim() - + _, axarr = pyplot.subplots(nrows=1, ncols=1, figsize=(10, 10)) axarr.scatter(sl2_transf_match['x'][sl2_idx], sl2_transf_match['y'][sl2_idx]) axarr.set_xlim(xlim) axarr.set_ylim(ylim) """ - + # Find a better transformation transf, _ = align.find_transform(sl2_match[sl2_idx], sl2_transf_match[sl2_idx], sl1_match[sl1_idx], transModel=model, order=order_dr[0], verbose=verbose) # order=int(order_dr[i_loop][0]), verbose=verbose) - + # This section was used for testing transformations with normalized # coordinates. Only several catalogs had reduced residuals when using # high order polynomials (>3), some of them became unstable @@ -639,15 +730,15 @@ def generic_match(sl1, sl2, init_mode='triangle', sl1_match_norm, transModel=model, order=poly_order, verbose=verbose) c_exp = np.zeros(len(transf.px._parameters)) - + for i_c in range(len(transf.px._parameters)): c_exp[i_c] = int(transf.px._param_names[i_c][1:].split('_')[0]) +\ int(transf.px._param_names[i_c][1:].split('_')[1]) - + c_corr = mm ** (1 - c_exp) transf.px._parameters = transf.px._parameters * c_corr transf.py._parameters = transf.py._parameters * c_corr""" - + # Do the final transformation and matching using sl2_idx, sl1_idx = align.transform_and_match(sl2, sl1, transf, dr_tol=dr_final, verbose=verbose) @@ -662,10 +753,10 @@ def generic_match(sl1, sl2, init_mode='triangle', # ep_name=np.column_stack((np.array(sl1['name'][sl1_idx]), np.array(sl2_transf['name'][sl2_idx]))), # list_times=[sl1.meta['list_time'], sl2.meta['list_time']], # list_names=[sl1.meta['list_name'], sl2.meta['list_name']]) - + for col in sl1.colnames: if col in sl2.colnames: if col not in ['name', 'x', 'y', 'm']: st.add_column(Column(np.column_stack((np.array(sl1[col][sl1_idx]),np.array(sl2_transf[col][sl2_idx]))), name=col)) - + return transf, st diff --git a/flystar/motion_model.py b/flystar/motion_model.py index 0b86d07..d4750bc 100644 --- a/flystar/motion_model.py +++ b/flystar/motion_model.py @@ -1,72 +1,91 @@ import numpy as np from abc import ABC -import pdb from flystar import parallax from astropy.time import Time -from scipy.optimize import curve_fit +from scipy.optimize import curve_fit, OptimizeWarning import warnings class MotionModel(ABC): - # Number of data points required to fit model - n_pts_req = 0 - # Degrees of freedom for model - n_params = 0 + name = "MotionModel" # Fit paramters: Shared fit parameters - fitter_param_names = [] + fit_param_names = [] + n_fit_params = len(fit_param_names) + # Number of fit parameters/required observations in each direction + n_params = int((n_fit_params + 1) / 2) - # Fixed parameters: These are parameters that are required for the model, but are not + # Fixed parameters: These are parameters that are required for the model, but are not # fit quantities. For example, RA and Dec in a parallax model. fixed_param_names = [] + required_fixed_param_names = [] + optional_fixed_params = {} + fixed_meta_data = [] # Non-fit paramters: Custom paramters that will not be fit. # These parameters should be derived from the fit parameters and # they must exist as a variable on the model object - optional_param_names = [] def __init__(self, *args, **kwargs): """ - Make a motion model object. This object defines the fitter and fixed parameters, - and if needed stores metadata such as RA and Dec for Parallax, - for the given motion model and contains functions to fit these values to data - and apply the values to compute expected positions at given times. Each instance - corresponds to a given motion model, not an individual star, and thus the fit - values are only input/returned in functions and not stored in the object. + Make a motion model object. This object defines the fit and fixed parameters, + and contains functions to fit the model to data and infer positions at given times. + Each instance corresponds to a given motion model, not an individual star, + and thus the fit values are only input/returned in functions, not stored in the object. """ return - def get_pos_at_time(self, params, t): - """ - Position calculator for a single star using a given motion model and input - model parameters and times. - """ - #return x, y - pass - - def get_batch_pos_at_time(self, t): - """ - Position calculator for a set of stars using a given motion model and input - model parameters and times. - """ - #return x, y, x_err, y_err - pass - - def run_fit(self, t, x, y, xe, ye, t0, weighting='var', - use_scipy=True, absolute_sigma=True): - """ - Run a single fit of the data to the motion model and return the best parameters. - This function is used by the overall fit_motion_model function once for a basic fit - or several times for a bootstrap fit. + def _check_param_dimensions(self, fit_params, fit_params_errs, fixed_params_dict): + """Check that parameters is either a scalar or length of N_stars + + Parameters + ---------- + fit_params: array-like + Fit parameters, shape (N_fit_params,) or (n_stars, N_fit_params) + fit_params_errs: array-like + Errors of fit parameters, shape (N_fit_params,) or (n_stars, N_fit_params) + fixed_params_dict : dict + Dictionary of fixed parameters """ + N_stars = fit_params.shape[0] if fit_params.ndim > 1 else 1 + if fit_params_errs is not None: + assert fit_params_errs.shape == fit_params.shape, "fit_params and fit_params_errs must have the same shape!" + + if fixed_params_dict is not None: + for key, value in fixed_params_dict.items(): + # assert key in fixed_params_dict, f"Missing fixed parameter {key} in fixed_params_dict!" + value = fixed_params_dict[key] + if np.isscalar(value): + continue + else: + assert len(value) == N_stars, f"Length of fixed parameter {key} must be either 1 or N_stars={N_stars}!" + + def model_fit(self, dt): + return np.full_like(dt, np.nan) + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + if fit_param_errs is None: + return np.full_like(t, np.nan), np.full_like(t, np.nan) + return np.full_like(t, np.nan), np.full_like(t, np.nan), np.full_like(t, np.inf), np.full_like(t, np.inf) + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + verbose=True + ): # Run a single fit (used both for overall fit + bootstrap iterations) - pass - - def get_weights(self, xe, ye, weighting='var'): - """ - Get the weights for each data point for fitting. Options are 'var' (default) - and 'std'. - """ + if return_chi2: + return np.full(self.n_fit_params, fill_value), np.full(self.n_fit_params, np.inf), np.nan, np.nan + return np.full(self.n_fit_params, fill_value), np.full(self.n_fit_params, np.inf) + + def calc_weights(self, xe, ye, weighting='var'): if weighting=='std': return 1./xe, 1./ye elif weighting=='var': @@ -74,488 +93,1210 @@ def get_weights(self, xe, ye, weighting='var'): else: warnings.warn("Invalid weighting, using default weighting scheme var.", UserWarning) return 1./xe**2, 1./ye**2 - - def scale_errors(self, errs, weighting='var'): - """ - Rescale the fit result errors as needed, according to the weighting scheme used. + + def fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + fill_value=np.nan, + params_guess=None, + return_chi2=False, + bootstrap=0, + seed=None, + verbose=True + ): + """Fit stellar motion parameters + + Parameters + ---------- + t : array-like + Times of measurements + x : array-like + x-coordinates + y : array-like + y-coordinates + xe : array-like + Uncertainty of x + ye : array-like + Uncertainty of y + fixed_params_dict : dict, optional + Dictionary of fixed parameters, see each motion model's fixed_param_names for details, by default None + weighting : str, optional + Use standard error weighting ('std': w=1/xe, 1/ye) or variance weighting ('var': w=1/xe**2, 1/ye**2), by default 'var' + use_scipy : bool, optional + Use scipy for optimization. Otherwise, use linear algebraic solution (Linear model only), which is faster for < 300 epochs, by default True + absolute_sigma : bool, optional + Absolute sigma. See scipy.optimize.curve_fit for details, by default True + fill_value : float, optional + Fill value for parameters when not enough data points to fit model, by default np.nan + params_guess : array-like, optional + Initial guess for the fit parameters used in scipy curve_fit, by default None + return_chi2 : bool, optional + Return chi^2 values along with parameters and uncertainties in params, param_errs, chi2_x, chi2_y, by default False + bootstrap : int, optional + Bootstrapping uncertainties, by default 0 + seed : int, optional + Seed for the random number generator, by default None + verbose : bool, optional + Print warning messages, by default True + + Returns + ------- + params, param_errs(, chi2_x, chi2_y) + Parameters, uncertainties, and chi squares if return_chi2 is True. The corresponding parameter names are in self.fit_param_names. """ - if weighting=='std': - return np.array(errs)**2 - elif weighting=='var': - return errs + assert np.ndim(t) == np.ndim(x) == np.ndim(y) == np.ndim(xe) == np.ndim(ye) == 1, "Input arrays must be 1D! Motion model can only fit individual stars" + assert len(t) == len(x) == len(y) == len(xe) == len(ye), "Input arrays must have the same length!" + + if not verbose: + warnings.filterwarnings("ignore", category=OptimizeWarning) + + fit_result = self.run_fit( + t, x, y, xe, ye, + fixed_params_dict=fixed_params_dict, + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + fill_value=fill_value, + params_guess=params_guess, + return_chi2=return_chi2, + verbose=verbose + ) + + if return_chi2: + params, param_errs, chi2_x, chi2_y = fit_result else: - warnings.warn("Invalid weighting, using default weighting scheme var.", UserWarning) - return errs + params, param_errs = fit_result + + + # Bootstrap errors + n_obs = len(t) + + if (bootstrap > 0) and (n_obs > self.n_params): + rng = np.random.default_rng(seed) + edx = np.arange(n_obs, dtype=int) + # Precompute All Bootstrap Draws at Once + # Ensure there are enough unique points in each bootstrap sample + bdx_unique = np.stack([ + rng.choice(edx, size=self.n_params, replace=False) + for _ in range(bootstrap) + ]) + # Draw with replacement for the rest + bdx_extra = np.stack([ + rng.choice(edx, size=n_obs - self.n_params, replace=True) + for _ in range(bootstrap) + ]) + bdx_all = np.hstack((bdx_unique, bdx_extra)) - def fit_motion_model(self, t, x, y, xe, ye, t0, bootstrap=0, weighting='var', - use_scipy=True, absolute_sigma=True): - """ - Fit the input positions on the sky and errors - to determine new parameters for this motion model (MM). - Best-fit parameters will be returned along with uncertainties. - Optionally, bootstrap error estimation can be performed. - """ - params, param_errs = self.run_fit(t, x, y, xe, ye, t0=t0, weighting=weighting, - use_scipy=use_scipy, absolute_sigma=absolute_sigma) - - if bootstrap>0 and len(x)>(self.n_pts_req): - edx = np.arange(len(x), dtype=int) bb_params = [] bb_params_errs = [] - for bb in range(bootstrap): - bdx = np.random.choice(edx, len(x)) - while len(np.unique(bdx))= 0 + # Calculate weighted average position + x_wt, y_wt = self.calc_weights(xe, ye, weighting=weighting) + x_wt_norm = x_wt / np.sum(x_wt) + y_wt_norm = y_wt / np.sum(y_wt) + x0 = np.average(x, weights=x_wt) + x0e = (np.sum(x_wt_norm**2 * xe**2))**0.5 # Error propagation + y0 = np.average(y, weights=y_wt) + y0e = (np.sum(y_wt_norm**2 * ye**2))**0.5 # Error propagation + + params = np.array([x0, y0]) + param_errors = np.array([x0e, y0e]) + + if (not absolute_sigma) or return_chi2: + chi2x, chi2y = self.calc_chi2(t, x, y, xe, ye, params) + + if not absolute_sigma: + if degree_of_freedom > 0: + reduced_chi2x = chi2x / degree_of_freedom + reduced_chi2y = chi2y / degree_of_freedom + + param_errors[0] *= reduced_chi2x**0.5 + param_errors[1] *= reduced_chi2y**0.5 + else: + # degree_of_freedom == 0, as < 0 case already handled above + warnings.warn( + f'Degree of freedom < 0. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + # Set parameter uncertainties to np.inf, same behavior as scipy.optimize.curve_fit + param_errors = np.full_like(param_errors, np.inf) + + if return_chi2: + return params, param_errors, chi2x, chi2y else: - x_wt, y_wt = self.get_weights(xe,ye, weighting=weighting) - x0 = np.average(x, weights=x_wt) - x0e = np.sqrt(np.average((x-x0)**2,weights=x_wt)) - y0 = np.average(y, weights=y_wt) - y0e = np.sqrt(np.average((y-y0)**2,weights=y_wt)) - - params = [x0, y0] - param_errors = [x0e, y0e] - - return params, param_errors - + return params, param_errors + class Linear(MotionModel): """ A 2D linear motion model for a star on the sky. """ - n_pts_req = 2 - n_params=2 - fitter_param_names = ['x0', 'vx', 'y0', 'vy'] - fixed_param_names = ['t0'] - + name = "Linear" + fit_param_names = ['x0', 'vx', 'y0', 'vy'] + required_fixed_param_names = ['t0'] + optional_fixed_params = {} + fixed_param_names = required_fixed_param_names + list(optional_fixed_params.keys()) + + n_fit_params = len(fit_param_names) + # Number of fit parameters/required observations in each direction + n_params = int((n_fit_params + 1) / 2) + def __init__(self, **kwargs): - # Must call after setting parameters. # This checks for proper parameter formatting. super().__init__() return - - def get_pos_at_time(self, fit_params, fixed_params, t): - fit_params_dict = dict(zip(self.fitter_param_names, fit_params)) - fixed_params_dict = dict(zip(self.fixed_param_names, fixed_params)) - dt = t-fixed_params_dict['t0'] - return fit_params_dict['x0'] + fit_params_dict['vx']*dt, fit_params_dict['y0'] + fit_params_dict['vy']*dt - - def get_batch_pos_at_time(self, t, x0=[],vx=[], y0=[],vy=[], t0=[], - x0_err=[],vx_err=[], y0_err=[],vy_err=[], **kwargs): - if hasattr(t, "__len__"): - dt = t-t0[:,np.newaxis] - x = x0[:,np.newaxis] + dt*vx[:,np.newaxis] - y = y0[:,np.newaxis] + dt*vy[:,np.newaxis] - x_err = np.hypot(x0_err[:,np.newaxis], vx_err[:,np.newaxis]*dt) - y_err = np.hypot(y0_err[:,np.newaxis], vy_err[:,np.newaxis]*dt) + + def model_fit(self, dt, x0, v): + """Linear motion model fit function + + Parameters + ---------- + dt : array-like + Time offset, shape (N_times,) + x0 : float or array-like + Initial position, shape (N_stars,) or scalar + v : float or array-like + Velocity, shape (N_stars,) or scalar + + Returns + ------- + x : array-like + Predicted position(s) + """ + return x0 + v * dt + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Model positions (and uncertainties, if fit_param_errs is provided) at time t of Linear model. + + Parameters + ---------- + t : float or array-like + Time(s) at which to evaluate the model + fit_params : array-like + x0, vx, y0, vy in shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Uncertainties of fit parameters in shape (N_fit_params,) or (N_stars, N_fit_params), by default None + fixed_params_dict : dict + t0, shape (1,) or (N_stars,) + + Returns + ------- + x, y (, xe, ye) + Predicted positions (and uncertainties, if fit_param_errs is provided) with shape (N_stars, N_times), or (N_times,) if N_stars=1, or (N_stars,) if N_times=1 + """ + if fixed_params_dict is None: + fixed_params_dict = self.fixed_params_dict + assert 't0' in fixed_params_dict, "Fixed parameter t0 is required for Linear model." + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + + N_stars = fit_params.shape[0] + N_times = len(t) + + x0, vx, y0, vy = fit_params.T # Each shape (N_stars,) + t0 = np.atleast_1d(fixed_params_dict['t0']) # Shape (N_stars,) or (1,) + + if N_times == N_stars: + # Assume each time corresponds to each star, so N_times = 1 + dt = t - t0 # Shape (N_stars,) + dt = dt[:, np.newaxis] # Shape (N_stars, 1) + N_times = 1 else: - dt = t-t0 - x = x0 + dt*vx - y = y0 + dt*vy - x_err = np.hypot(x0_err, vx_err*dt) - y_err = np.hypot(y0_err, vy_err*dt) - return x,y,x_err,y_err - - def run_fit(self, t, x, y, xe, ye, t0, weighting='var', params_guess=None, - use_scipy=True, absolute_sigma=True): - dt = t-t0 - x_wt, y_wt = self.get_weights(xe,ye, weighting=weighting) + dt = t[np.newaxis, :] - t0[:, np.newaxis] # Shape (N_stars, N_times) + + x = self.model_fit(dt, x0[:, np.newaxis], vx[:, np.newaxis]) # Shape (N_stars, N_times) + y = self.model_fit(dt, y0[:, np.newaxis], vy[:, np.newaxis]) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x = x.flatten() + y = y.flatten() + + if fit_param_errs is None: + return x, y + + fit_param_errs = np.atleast_2d(fit_param_errs) # (N_stars, N_fit_params) + x0_err, vx_err, y0_err, vy_err = fit_param_errs.T # Each shape (N_stars,) + x_err = np.hypot(x0_err[:, np.newaxis], vx_err[:, np.newaxis] * dt) # Shape (N_stars, N_times) + y_err = np.hypot(y0_err[:, np.newaxis], vy_err[:, np.newaxis] * dt) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x_err = x_err.flatten() + y_err = y_err.flatten() + return x, y, x_err, y_err + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + verbose=True + ): + if fixed_params_dict is None: + fixed_params_dict = {} + if 't0' not in fixed_params_dict: + # Default t0 to weighted average time + fixed_params_dict['t0'] = np.average(t, weights=1./np.hypot(xe, ye)) + self.fixed_params_dict = fixed_params_dict + t0 = np.atleast_1d(fixed_params_dict['t0']) + t = np.atleast_1d(t) + x = np.atleast_1d(x) + y = np.atleast_1d(y) + xe = np.atleast_1d(xe) + ye = np.atleast_1d(ye) + + n_obs = len(t) + degree_of_freedom = n_obs - self.n_params + # Not enough data points to fit model + if degree_of_freedom < 0: + warnings.warn( + f'Not enough data points to fit model. Setting parameters to {fill_value} and uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + if return_chi2: + return params, param_errors, np.nan, np.nan + else: + return params, param_errors + + # degree_of_freedom >= 0 + dt = t - t0 + x_wt, y_wt = self.calc_weights(xe, ye, weighting=weighting) if params_guess is None: - params_guess = [x.mean(),0.0,y.mean(),0.0] - - # Handle 2-data point case - if len(np.unique(dt))==2: - if len(x)>2: # Catch case where bootstrap sends only 2 unique epochs - _,idx=np.unique(dt, return_index=True) - dt = dt[idx] - x = x[idx] - y = y[idx] - xe = xe[idx] - ye = ye[idx] - dx = np.diff(x)[0] - dy = np.diff(y)[0] - dt_diff = np.diff(dt)[0] - vx = dx / dt_diff - vy = dy / dt_diff - # TODO: still not sure about the error handling here - x0 = x[0] - dt[0]*vx # np.average(x, weights=x_wt) # - y0 = y[0] - dt[0]*vy # np.average(y, weights=y_wt) # - x0e = np.abs(dx) / 2**0.5 # np.sqrt(np.sum(xe**2)/2) # - y0e = np.abs(dy) / 2**0.5 # np.sqrt(np.sum(ye**2)/2) # - vxe = 0.0 #np.abs(vx) * np.sqrt(np.sum(xe**2/x**2)) - vye = 0.0 #np.abs(vy) * np.sqrt(np.sum(ye**2/y**2)) - + params_guess = [x.mean(), 0., y.mean(), 0.] + + if use_scipy: + x_opt, x_cov, x_info, x_msg, x_ier = curve_fit(self.model_fit, dt, x, p0=np.array(params_guess[:2]), sigma=1/x_wt**0.5, absolute_sigma=absolute_sigma, full_output=True) + y_opt, y_cov, y_info, y_msg, y_ier = curve_fit(self.model_fit, dt, y, p0=np.array(params_guess[2:]), sigma=1/y_wt**0.5, absolute_sigma=absolute_sigma, full_output=True) + x0, vx = x_opt + y0, vy = y_opt + x0e, vxe = np.sqrt(x_cov.diagonal()) + y0e, vye = np.sqrt(y_cov.diagonal()) + params = np.array([x0, vx, y0, vy]) + param_errors = np.array([x0e, vxe, y0e, vye]) + if return_chi2: + # chi2_x, chi2_y = self.calc_chi2(t, x, y, xe, ye, params, fixed_params_dict) + chi2_x = np.sum(x_info['fvec']**2) + chi2_y = np.sum(y_info['fvec']**2) + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors + + # Linear algebraic solution + # Use https://en.wikipedia.org/wiki/Weighted_least_squares#Solution_scheme + X_mat_t = np.vander(dt, 2) + + # x calculation + W_mat_x = np.diag(x_wt) + XTWX_mat_x = X_mat_t.T @ W_mat_x @ X_mat_t # Shape (2, 2) + pcov_x = np.linalg.pinv(XTWX_mat_x) # Covariance Matrix + popt_x = pcov_x @ X_mat_t.T @ W_mat_x @ x # Linear Solution + + # Singular matrix (not enough unique times): Fill uncertainty with Inf. + if np.linalg.matrix_rank(XTWX_mat_x) < 2: + warnings.warn( + f'Singular matrix. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + perr_x = np.full_like(popt_x, np.inf) + else: + perr_x = np.sqrt(np.diag(pcov_x)) # Uncertainty of Linear Solution + + # y calculation + W_mat_y = np.diag(y_wt) + XTWX_mat_y = X_mat_t.T @ W_mat_y @ X_mat_t # Shape (2, 2) + pcov_y = np.linalg.pinv(XTWX_mat_y) # Covariance Matrix + popt_y = pcov_y @ X_mat_t.T @ W_mat_y @ y # Linear Solution + + # Singular matrix (not enough unique times): Fill uncertainty with Inf. + if np.linalg.matrix_rank(XTWX_mat_y) < 2: + warnings.warn( + f'Singular matrix. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + perr_y = np.full_like(popt_y, np.inf) else: - if use_scipy: - def linear(t, c0, c1): - return c0 + c1*t - x_opt, x_cov = curve_fit(linear, dt, x, p0=np.array(params_guess[:2]), sigma=1/np.sqrt(x_wt), absolute_sigma=absolute_sigma) - y_opt, y_cov = curve_fit(linear, dt, y, p0=np.array(params_guess[2:]), sigma=1/np.sqrt(y_wt), absolute_sigma=absolute_sigma) - x0, vx = x_opt - y0, vy = y_opt - x0e, vxe = np.sqrt(x_cov.diagonal()) - y0e, vye = np.sqrt(y_cov.diagonal()) - x0e, vxe, y0e, vye = self.scale_errors([x0e, vxe, y0e, vye], weighting=weighting) + perr_y = np.sqrt(np.diag(pcov_y)) # Uncertainty of Linear Solution + + # prepare values to return + vx, x0 = popt_x + vy, y0 = popt_y + vxe, x0e = perr_x + vye, y0e = perr_y + + params = np.array([x0, vx, y0, vy]) + param_errors = np.array([x0e, vxe, y0e, vye]) + + # Does not use get_chi2 to accelerate calculation + if return_chi2 or (not absolute_sigma): + residual_x = x - X_mat_t @ popt_x + residual_y = y - X_mat_t @ popt_y + + chi2_x = residual_x.T @ W_mat_x @ residual_x + chi2_y = residual_y.T @ W_mat_y @ residual_y + + if not absolute_sigma: + if degree_of_freedom > 0: + reduced_chi2_x = chi2_x / degree_of_freedom + reduced_chi2_y = chi2_y / degree_of_freedom + + param_errors[0:2] *= reduced_chi2_x**0.5 + param_errors[2:4] *= reduced_chi2_y**0.5 + else: - # Use https://en.wikipedia.org/wiki/Weighted_least_squares#Solution scheme - x = np.array(x) - y = np.array(y) - dt = np.array(dt) - X_mat_t = np.vander(dt, 2) - # x calculation - W_mat_x = np.diag(x_wt) - XTWX_mat_x = X_mat_t.T @ W_mat_x @ X_mat_t - pcov_x = np.linalg.inv(XTWX_mat_x) # Covariance Matrix - popt_x = pcov_x @ X_mat_t.T @ W_mat_x @ x # Linear Solution - perr_x = np.sqrt(np.diag(pcov_x)) # Uncertainty of Linear Solution - # y calculation - W_mat_y = np.diag(y_wt) - XTWX_mat_y = X_mat_t.T @ W_mat_y @ X_mat_t - pcov_y = np.linalg.inv(XTWX_mat_y) # Covariance Matrix - popt_y = pcov_y @ X_mat_t.T @ W_mat_y @ y # Linear Solution - perr_y = np.sqrt(np.diag(pcov_y)) # Uncertainty of Linear Solution - # prepare values to return - x0, vx = popt_x[1], popt_x[0] - y0, vy = popt_y[1], popt_y[0] - x0e, vxe = perr_x[1], perr_x[0] - y0e, vye = perr_y[1], perr_y[0] - x0e, vxe, y0e, vye = self.scale_errors([x0e, vxe, y0e, vye], weighting=weighting) - - params = [x0, vx, y0, vy] - param_errors = [x0e, vxe, y0e, vye] - return params, param_errors - - + # degree_of_freedom == 0, as < 0 case already handled above + warnings.warn( + f'Degree of freedom < 0. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + # Set parameter uncertainties to np.inf, same behavior as scipy.optimize.curve_fit + param_errors = np.full_like(param_errors, np.inf) + + if return_chi2: + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors + class Acceleration(MotionModel): """ A 2D accelerating motion model for a star on the sky. """ - n_pts_req = 4 # TODO: consider special case for 3 pts - n_params=3 - fitter_param_names = ['x0', 'vx0', 'ax', 'y0', 'vy0', 'ay'] - fixed_param_names = ['t0'] - - def __init__(self, x0=0, vx0=0, ax=0, y0=0, vy0=0, ay=0, t0=None, - x0_err=0, vx0_err=0, ax_err=0, y0_err=0, vy0_err=0, ay_err=0, **kwargs): + name = "Acceleration" + fit_param_names = ['x0', 'vx0', 'ax', 'y0', 'vy0', 'ay'] + required_fixed_param_names = ['t0'] + optional_fixed_params = {} + fixed_param_names = required_fixed_param_names + list(optional_fixed_params.keys()) + + n_fit_params = len(fit_param_names) + # Number of required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + def __init__(self): # Must call after setting parameters. # This checks for proper parameter formatting. super().__init__() return - - def get_pos_at_time(self, fit_params, fixed_params, t): - fit_params_dict = dict(zip(self.fitter_param_names, fit_params)) - fixed_params_dict = dict(zip(self.fixed_param_names, fixed_params)) - dt = t-fixed_params_dict['t0'] - x = fit_params_dict['x0'] + fit_params_dict['vx0']*dt + 0.5*fit_params_dict['ax']*dt**2 - y = fit_params_dict['y0'] + fit_params_dict['vy0']*dt + 0.5*fit_params_dict['ay']*dt**2 - return x, y - - def get_batch_pos_at_time(self,t, - x0=[],vx0=[],ax=[], y0=[],vy0=[],ay=[], t0=[], - x0_err=[],vx0_err=[],ax_err=[], y0_err=[],vy0_err=[],ay_err=[], **kwargs): - if hasattr(t, "__len__"): - dt = t-t0[:,np.newaxis] - x = x0[:,np.newaxis] + dt*vx0[:,np.newaxis] + 0.5*dt**2*ax[:,np.newaxis] - y = y0[:,np.newaxis] + dt*vy0[:,np.newaxis] + 0.5*dt**2*ay[:,np.newaxis] - x_err = np.sqrt(x0_err[:,np.newaxis]**2 + (vx0_err[:,np.newaxis]*dt)**2 + (0.5*ax_err[:,np.newaxis]*dt**2)**2) - y_err = np.sqrt(y0_err[:,np.newaxis]**2 + (vy0_err[:,np.newaxis]*dt)**2 + (0.5*ay_err[:,np.newaxis]*dt**2)**2) + + def model_fit(self, t, x0, v0, a): + """Model positions at time t of Acceleration model. + + Parameters + ---------- + t : float or array-like + Time(s) at which to evaluate the model + x0 : float or array-like + Initial position(s) + v0 : float or array-like + Initial velocity(ies) + a : float or array-like + Acceleration(s) + + Returns + ------- + float or array-like + Model positions at time t of Acceleration model + """ + return x0 + v0*t + 0.5*a*t**2 + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Model positions (and uncertainties, if fit_param_errs is provided) at time t of Acceleration model. + + Parameters + ---------- + t : float or array-like + Time(s) at which to evaluate the model + fit_params : array-like + x0, vx, ax, y0, vy, ay in shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Fit parameter uncertainties with shape (N_stars, N_fit_params) or (N_fit_params,), by default None + fixed_params_dict : dict + t0, shape (1,) or (N_stars,) + + Returns + ------- + x, y (, xe, ye) + Predicted positions (and uncertainties, if fit_param_errs is provided) with shape (N_stars, N_times), or (N_times,) if N_stars=1, or (N_stars,) if N_times=1 + """ + if fixed_params_dict is None: + fixed_params_dict = self.fixed_params_dict + assert 't0' in fixed_params_dict, "Fixed parameter t0 is required for Acceleration model." + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + + N_stars = fit_params.shape[0] + N_times = len(t) + + x0, vx0, ax, y0, vy0, ay = fit_params.T # Each shape (N_stars,) + t0 = np.atleast_1d(fixed_params_dict['t0']) # Shape (N_stars,) or (1,) + + if N_times == N_stars: + # Assume each time corresponds to each star, so N_times = 1 + dt = t - t0 # Shape (N_stars,) + dt = dt[:, np.newaxis] # Shape (N_stars, 1) + N_times = 1 else: - dt = t-t0 - x = x0 + dt*vx0 + 0.5*dt**2*ax - y = y0 + dt*vy0 + 0.5*dt**2*ay - x_err = np.sqrt(x0_err**2 + (vx0_err*dt)**2 + (0.5*ax_err*dt**2)**2) - y_err = np.sqrt(y0_err**2 + (vy0_err*dt)**2 + (0.5*ay_err*dt**2)**2) - return x,y,x_err,y_err - - def run_fit(self, t, x, y, xe, ye, t0, weighting='var', params_guess=None, - use_scipy=True, absolute_sigma=True): + dt = t[np.newaxis, :] - t0[:, np.newaxis] # Shape (N_stars, N_times) + + x = self.model_fit(dt, x0[:, np.newaxis], vx0[:, np.newaxis], ax[:, np.newaxis]) # Shape (N_stars, N_times) + y = self.model_fit(dt, y0[:, np.newaxis], vy0[:, np.newaxis], ay[:, np.newaxis]) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x = x.flatten() + y = y.flatten() + + if fit_param_errs is None: + return x, y + + fit_param_errs = np.atleast_2d(fit_param_errs) # (N_stars, N_fit_params) + x0_err, vx0_err, ax_err, y0_err, vy0_err, ay_err = fit_param_errs.T + x_err = np.sqrt(x0_err[:, np.newaxis]**2 + (vx0_err[:, np.newaxis] * dt)**2 + (0.5 * ax_err[:, np.newaxis] * dt**2)**2) # Shape (N_stars, N_times) + y_err = np.sqrt(y0_err[:, np.newaxis]**2 + (vy0_err[:, np.newaxis] * dt)**2 + (0.5 * ay_err[:, np.newaxis] * dt**2)**2) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x_err = x_err.flatten() + y_err = y_err.flatten() + + return x, y, x_err, y_err + + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + verbose=True + ): + if fixed_params_dict is None: + fixed_params_dict = {} + if 't0' not in fixed_params_dict: + # Default t0 to weighted average time + fixed_params_dict['t0'] = np.average(t, weights=1./np.hypot(xe, ye)) + self.fixed_params_dict = fixed_params_dict + t0 = np.atleast_1d(fixed_params_dict['t0']) + t = np.atleast_1d(t) + x = np.atleast_1d(x) + y = np.atleast_1d(y) + xe = np.atleast_1d(xe) + ye = np.atleast_1d(ye) + if not use_scipy: - Warning("Acceleration model has no non-scipy fitter option. Running with scipy.") - dt = t-t0 - x_wt, y_wt = self.get_weights(xe,ye, weighting=weighting) + if verbose: + warnings.warn("Acceleration model has no non-scipy fitter option. Running with scipy.") + + n_obs = len(t) + degree_of_freedom = n_obs - self.n_params + # Not enough data points to fit model + if degree_of_freedom < 0: + warnings.warn( + f'Not enough data points to fit model. Setting parameters to {fill_value} and uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + if return_chi2: + return params, param_errors, np.nan, np.nan + else: + return params, param_errors + + # degree_of_freedom >= 0 + dt = t - t0 + x_wt, y_wt = self.calc_weights(xe,ye, weighting=weighting) if params_guess is None: - params_guess = [x.mean(),0.0,0.0,y.mean(),0.0,0.0] - - def accel(t, c0,c1,c2): - return c0 + c1*t + 0.5*c2*t**2 - - x_opt, x_cov = curve_fit(accel, dt, x, p0=np.array(params_guess[:3]), sigma=1/x_wt**0.5, absolute_sigma=True) - y_opt, y_cov = curve_fit(accel, dt, y, p0=np.array(params_guess[3:]), sigma=1/y_wt**0.5, absolute_sigma=True) - x0 = x_opt[0] - y0 = y_opt[0] - vx0 = x_opt[1] - vy0 = y_opt[1] - ax = x_opt[2] - ay = y_opt[2] - + # Initial guess for velocity: + idx_first, idx_last = np.argmin(t), np.argmax(t) + t_span = t[idx_last] - t[idx_first] + params_guess = [x.mean(), (x[idx_last] - x[idx_first]) / t_span, 0., y.mean(), (y[idx_last] - y[idx_first]) / t_span, 0.] + + x_opt, x_cov, x_info, x_msg, x_ier = curve_fit(self.model_fit, dt, x, p0=np.array(params_guess[:3]), sigma=1/x_wt**0.5, absolute_sigma=absolute_sigma, full_output=True) + y_opt, y_cov, y_info, y_msg, y_ier = curve_fit(self.model_fit, dt, y, p0=np.array(params_guess[3:]), sigma=1/y_wt**0.5, absolute_sigma=absolute_sigma, full_output=True) + x0, vx0, ax = x_opt + y0, vy0, ay = y_opt x0e, vx0e, axe = np.sqrt(x_cov.diagonal()) y0e, vy0e, aye = np.sqrt(y_cov.diagonal()) - x0e, vx0e, axe, y0e, vy0e, aye = self.scale_errors([x0e, vx0e, axe, y0e, vy0e, aye], weighting=weighting) - params = [x0, vx0, ax, y0, vy0, ay] - param_errors = [x0e, vx0e, axe, y0e, vy0e, aye] - - return params, param_errors + params = np.array([x0, vx0, ax, y0, vy0, ay]) + param_errors = np.array([x0e, vx0e, axe, y0e, vy0e, aye]) + if return_chi2: + # chi2_x, chi2_y = self.calc_chi2(t, x, y, xe, ye, params, fixed_params_dict) + chi2_x = np.sum(x_info['fvec']**2) + chi2_y = np.sum(y_info['fvec']**2) + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors class Parallax(MotionModel): """ Motion model for linear proper motion + parallax - - Requires RA & Dec (J2000) for parallax calculation. + + Requires RA and Dec J2000 (degrees) for parallax calculation. Optional PA is counterclockwise offset of the image y-axis from North. Optional obs parameter describes observer location, default is 'earth'. """ - n_pts_req = 4 - n_params=3 - fitter_param_names = ['x0', 'vx', 'y0', 'vy', 'pi'] - fixed_param_names = ['t0'] - fixed_meta_data = ['RA','Dec','PA','obs'] - - def __init__(self, RA, Dec, PA=0.0, obs='earth', **kwargs): - self.RA = RA - self.Dec = Dec - self.PA = PA - self.obs = obs - self.plx_vector_cached = None + name = "Parallax" + fit_param_names = ['x0', 'vx', 'y0', 'vy', 'pi'] + required_fixed_param_names = ['t0', 'ra', 'dec'] + optional_fixed_params = {'pa': 0., 'obsLocation': 'earth'} + fixed_param_names = required_fixed_param_names + list(optional_fixed_params.keys()) + + + n_fit_params = len(fit_param_names) + # Number of required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + def __init__(self): + super().__init__() + self.pvec_cached = None # Cache for parallax vector + self.t_mjd_cached = None # Cache for times corresponding to cached parallax vector return - - def get_parallax_vector(self, t_mjd): - recalc_plx = True - if self.plx_vector_cached is not None: - if hasattr(t_mjd, "__len__"): - if list(t_mjd) == list(self.plx_vector_cached[0]): - pvec = self.plx_vector_cached[1:] - recalc_plx = False - elif all([t_mjd_i in self.plx_vector_cached[0] for t_mjd_i in t_mjd]): - pvec_idxs = [np.argwhere(self.plx_vector_cached[0]==t_mjd_i)[0][0] for t_mjd_i in t_mjd] - pvec = [self.plx_vector_cached[1][pvec_idxs], self.plx_vector_cached[2][pvec_idxs]] - recalc_plx = False - elif t_mjd in self.plx_vector_cached[0]: - idx = np.where(t_mjd==self.plx_vector_cached[0])[0][0] - pvec = np.array([self.plx_vector_cached[1][idx], self.plx_vector_cached[2][idx]]) - recalc_plx = False - if recalc_plx: - pvec = parallax.parallax_in_direction(self.RA, self.Dec, t_mjd, obsLocation=self.obs, PA=self.PA).T - if hasattr(t_mjd, "__len__"): - self.plx_vector_cached = [t_mjd, pvec[0], pvec[1]] + + def calc_parallax_vector(self, t_mjd, ra, dec, pa=0., obsLocation='earth'): + """Calculate parallax vector of shape (N_stars, 2, N_times) + + Parameters + ---------- + t_mjd : array-like + Time array in mjd + ra : float or array-like + Right ascension(s) in degrees + dec : float or array-like + Declination(s) in degrees + pa : float or array-like, optional + Position angle(s) of image y-axis from North in degrees, by default 0. + obsLocation : str, optional + Observer location, by default 'earth' + + Returns + ------- + pvec + Parallax vector of shape (N_stars, 2, N_times) + """ + if self.pvec_cached is not None: + t_mjd = np.atleast_1d(t_mjd) + t_mjd_cached = self.t_mjd_cached + if np.array_equal(t_mjd, t_mjd_cached): + # If cached values match input times, return cached values + return self.pvec_cached + + elif all(np.isin(t_mjd, t_mjd_cached)): + # If all input times are in cached values, return those + # Calculate pvec_idxs such that t_mjd_cached[ pvec_idxs ] == t_mjd + pvec_idxs = np.array([np.where(t_mjd_cached == t_mjd_i)[0][0] for t_mjd_i in t_mjd]) + pvec = self.pvec_cached[:, :, pvec_idxs] + return pvec + + pvec = parallax.parallax_in_direction(ra, dec, t_mjd, obsLocation=obsLocation, pa=pa) # Shape (N_stars, 2, N_times) + # self.plx_vector_cached = [t_mjd, pvec] + self.t_mjd_cached = t_mjd + self.pvec_cached = pvec return pvec - - def get_pos_at_time(self, fit_params, fixed_params, t): - fit_params_dict = dict(zip(self.fitter_param_names, fit_params)) - fixed_params_dict = dict(zip(self.fixed_param_names, fixed_params)) - dt = t-fixed_params_dict['t0'] - - t_mjd = Time(t, format='decimalyear', scale='utc').mjd - pvec = self.get_parallax_vector(t_mjd) - pvec_x = np.reshape(pvec[0], t.shape) - pvec_y = np.reshape(pvec[1], t.shape) - x = fit_params_dict['x0'] + fit_params_dict['vx']*dt + fit_params_dict['pi']*pvec_x - y = fit_params_dict['y0'] + fit_params_dict['vy']*dt + fit_params_dict['pi']*pvec_y - return x, y - - def get_batch_pos_at_time(self, t, - x0=[],vx=[], y0=[],vy=[], pi=[], t0=[], - x0_err=[],vx_err=[], y0_err=[],vy_err=[], pi_err=[], **kwargs): - t_mjd = Time(t, format='decimalyear', scale='utc').mjd - pvec = self.get_parallax_vector(t_mjd) - if hasattr(t, "__len__"): - dt = t-t0[:,np.newaxis] - x = x0[:,np.newaxis] + dt*vx[:,np.newaxis] + pi[:,np.newaxis]*pvec[0].T - y = y0[:,np.newaxis] + dt*vy[:,np.newaxis] + pi[:,np.newaxis]*pvec[1].T - try: - x_err = np.sqrt(x0_err[:,np.newaxis]**2 + (vx_err[:,np.newaxis]*dt)**2 + (pi_err[:,np.newaxis]*pvec[0].T)**2) - y_err = np.sqrt(y0_err[:,np.newaxis]**2 + (vy_err[:,np.newaxis]*dt)**2 + (pi_err[:,np.newaxis]*pvec[1].T)**2) - except: - x_err,y_err = [],[] + + def model_fit(self, dt, x0, vx, y0, vy, pi): + """Model positions at time t of Parallax model. + + Parameters + ---------- + dt : float or array-like + Time(s) at which to evaluate the model + x0 : float or array-like + Initial position(s) + vx : float or array-like + Velocity(ies) + y0 : float or array-like + Initial position(s) + vy : float or array-like + Velocity(ies) + pi : float or array-like + Parallax factor(s) + + Returns + ------- + x_result, y_result : array-like + Model positions at time t of Parallax model, shape (N_stars, N_times) + """ + # x0, vx, y0, vy, pi are all shape (N_stars, N_times) + x_result = x0 + vx * dt + pi * self.pvec[:, 0, :] # Parallax contribution in x direction + y_result = y0 + vy * dt + pi * self.pvec[:, 1, :] # Parallax contribution in y direction + return x_result, y_result + + def _model_fit(self, dt, x0, vx, y0, vy, pi): + """Wrapper for model_fit to return concatenated results for scipy fitting.""" + x_result, y_result = self.model_fit(dt, x0, vx, y0, vy, pi) + # scipy.optimize.curve_fit expects a 1D output array with the same length + # as the input ydata. For single-star fits, intermediate broadcasting can + # yield arrays with shape (1, N_times); flatten to avoid M=1 interpretation. + return np.hstack([np.ravel(x_result), np.ravel(y_result)]) # Shape (2*N_times,) + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Model positions (and uncertainties, if fit_param_errs is provided) at time t of Parallax model. + + Parameters + ---------- + t : float or array-like + Times at which to evaluate the model + fit_params : array-like + x0, vx, y0, vy, pi in shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Uncertainties in fit parameters, by default None + fixed_params : dict + - t0, shape (N_stars,) or (1,). + - ra, shape (N_stars,) or (1,). + - dec, shape (N_stars,) or (1,). + - pa, optional, shape (N_stars,) or (1,), by default 0. + - obsLocation, optional, string, by default 'earth' + + Returns + ------- + x, y (, xe, ye) + Predicted positions (and uncertainties, if fit_param_errs is provided) with shape (N_stars, N_times), or (N_times,) if N_stars=1, or (N_stars,) if N_times=1 + """ + if fixed_params_dict is None: + fixed_params_dict = self.fixed_params_dict + assert all([_ in fixed_params_dict for _ in ['t0', 'ra', 'dec']]), "Fixed parameters t0, ra, and dec are required for Parallax model." + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + + N_stars = fit_params.shape[0] + N_times = len(t) + + x0, vx, y0, vy, pi = fit_params.T # Each shape (N_stars,) + t0 = np.atleast_1d(fixed_params_dict['t0']) # Shape (N_stars,) or (1,) + ra = np.atleast_1d(fixed_params_dict['ra']) + dec = np.atleast_1d(fixed_params_dict['dec']) + pa = np.atleast_1d(fixed_params_dict.get('pa', 0.0)) + obsLocation = fixed_params_dict.get('obsLocation', 'earth') + + # TODO: vectorize parallax.parallax_in_direction to handle multiple obsLocation? + assert isinstance(obsLocation, str) or (np.unique(obsLocation).size == 1), "obsLocation must be a single string for all stars at this time." + if not isinstance(obsLocation, str): + obsLocation = np.unique(obsLocation)[0] + + + if N_times == N_stars: + # Assume each time corresponds to each star, so N_times = 1 + dt = t - t0 # Shape (N_stars,) + dt = dt[:, np.newaxis] # Shape (N_stars, 1) + N_times = 1 else: - dt = t-t0 - x = x0 + dt*vx + pi*pvec[0] - y = y0 + dt*vy + pi*pvec[1] - try: - x_err = np.sqrt(x0_err**2 + (vx_err*dt)**2 + (pi_err*pvec[0])**2) - y_err = np.sqrt(y0_err**2 + (vy_err*dt)**2 + (pi_err*pvec[1])**2) - except: - x_err,y_err = [],[] - return x,y,x_err,y_err - - def run_fit(self, t, x, y, xe, ye, t0, weighting='var', params_guess=None, - use_scipy=True, absolute_sigma=True): + dt = t[np.newaxis, :] - t0[:, np.newaxis] # Shape (N_stars, N_times) + + t_mjd = Time(t, format='decimalyear', scale='utc').mjd # Shape (N_times,) + self.pvec = self.calc_parallax_vector(t_mjd, ra, dec, pa=pa, obsLocation=obsLocation) # Shape (N_stars, 2, N_times) + x, y = self.model_fit(dt, x0[:, np.newaxis], vx[:, np.newaxis], y0[:, np.newaxis], vy[:, np.newaxis], pi[:, np.newaxis]) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x = x.flatten() + y = y.flatten() + + if fit_param_errs is None: + return x, y + + fit_param_errs = np.atleast_2d(fit_param_errs) # (N_stars, N_fit_params) + x0_err, vx_err, y0_err, vy_err, pi_err = fit_param_errs.T + x_err = np.sqrt(x0_err[:, np.newaxis]**2 + (vx_err[:, np.newaxis] * dt)**2 + (pi_err[:, np.newaxis] * self.pvec[:, 0, :])**2) # Shape (N_stars, N_times) + y_err = np.sqrt(y0_err[:, np.newaxis]**2 + (vy_err[:, np.newaxis] * dt)**2 + (pi_err[:, np.newaxis] * self.pvec[:, 1, :])**2) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x_err = x_err.flatten() + y_err = y_err.flatten() + return x, y, x_err, y_err + + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + verbose=True + ): if not use_scipy: - Warning("Parallax model has no non-scipy fitter option. Running with scipy.") + if verbose: + warnings.warn("Parallax model has no non-scipy fitter option. Running with scipy.", UserWarning) + + assert all([k in fixed_params_dict for k in ['ra', 'dec']]), "Parallax model requires 'ra' and 'dec' in fixed_params." + t = np.atleast_1d(t) + + if 't0' not in fixed_params_dict: + # Default t0 to weighted average time + fixed_params_dict['t0'] = np.average(t, weights=1./np.hypot(xe, ye)) + if 'obsLocation' not in fixed_params_dict: + fixed_params_dict['obsLocation'] = 'earth' + self.fixed_params_dict = fixed_params_dict + t0 = np.atleast_1d(fixed_params_dict['t0']) + ra = np.atleast_1d(fixed_params_dict['ra']) + dec = np.atleast_1d(fixed_params_dict['dec']) + pa = np.atleast_1d(fixed_params_dict.get('pa', 0.0)) + obsLocation = fixed_params_dict['obsLocation'] + + n_fit = len(t) + degree_of_freedom = n_fit - self.n_params + # Not enough data points to fit model + if degree_of_freedom < 0: + warnings.warn( + f'Not enough data points to fit model. Setting parameters to {fill_value} and uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + if return_chi2: + return params, param_errors, np.nan, np.nan + else: + return params, param_errors + + # degree_of_freedom >= 0 t_mjd = Time(t, format='decimalyear', scale='utc').mjd - pvec = self.get_parallax_vector(t_mjd) - x_wt, y_wt = self.get_weights(xe,ye, weighting=weighting) - def fit_func(use_t, x0,vx, y0,vy, pi): - x_res = x0 + vx*(use_t-t0) + pi*pvec[0] - y_res = y0 + vy*(use_t-t0) + pi*pvec[1] - return np.hstack([x_res, y_res]) + self.pvec = self.calc_parallax_vector(t_mjd, ra, dec, pa=pa, obsLocation=obsLocation) # Shape (2, N_times) + x_wt, y_wt = self.calc_weights(xe, ye, weighting=weighting) + # Initial guesses, x0,y0 as x,y averages; # vx,vy as average velocity if first and last points are perfectly measured; - # pi for 10 pc disance + # pi for 10 pc distance if params_guess is None: idx_first, idx_last = np.argmin(t), np.argmax(t) - params_guess = [x.mean(),(x[idx_last]-x[idx_first])/(t[idx_last]-t[idx_first]), - y.mean(),(y[idx_last]-y[idx_first])/(t[idx_last]-t[idx_first]), 0.1] - res = curve_fit(fit_func, t, np.hstack([x,y]), - p0=params_guess, sigma = 1.0/np.hstack([x_wt,y_wt])) - x0,vx,y0,vy,pi = res[0] - x0_err,vx_err,y0_err,vy_err,pi_err = self.scale_errors(np.sqrt(np.diag(res[1])), weighting=weighting) - - params = [x0, vx, y0, vy, pi] - param_errors = [x0_err, vx_err, y0_err, vy_err, pi_err] - return params, param_errors - - -def validate_motion_model_dict(motion_model_dict, startable, default_motion_model): - """ - Check that everything is set up properly for motion models to run and their - required metadata. - """ + t_span = t[idx_last] - t[idx_first] + params_guess = np.array([ + x.mean(), (x[idx_last] - x[idx_first]) / t_span, + y.mean(), (y[idx_last] - y[idx_first]) / t_span, + 0.1 + ]) - # Collect names of all motion models that might get used. - all_motion_model_names = ['Fixed'] - if default_motion_model is not None: - all_motion_model_names.append(default_motion_model) - if 'motion_model_input' in startable.columns: - all_motion_model_names += np.unique(startable['motion_model_input']).tolist() - if 'motion_model_used' in startable.columns: - all_motion_model_names += np.unique(startable['motion_model_used']).tolist() - all_motion_model_names = np.unique(all_motion_model_names) - - # Check whether all motion models are in the dict, and if not, try to add them - # here or raise an error. - for mm in all_motion_model_names: - if mm not in motion_model_dict: - mm_obj = eval(mm) - if len(mm_obj.fixed_meta_data)>0: - raise ValueError(f"Cannot use {mm} motion model without required metadata. Please initialize with required metadata and provide in motion_model_dict.") - else: - motion_model_dict[mm] = mm_obj() - warnings.warn(f"Using default model/fitter for {mm}.", UserWarning) + # Convert weights to 1-sigma uncertainties for curve_fit. + # calc_weights returns w = 1/sigma^2 for 'var' and w = 1/sigma for 'std'. + if weighting == 'std': + sigma_x = 1.0 / x_wt + sigma_y = 1.0 / y_wt + else: + sigma_x = 1.0 / np.sqrt(x_wt) + sigma_y = 1.0 / np.sqrt(y_wt) - return motion_model_dict - + popt, pcov, infodict, mesg, ier = curve_fit( + self._model_fit, t - t0, np.hstack([x, y]), + p0=params_guess, sigma=np.hstack([sigma_x, sigma_y]), + absolute_sigma=absolute_sigma, full_output=True + ) + x0, vx, y0, vy, pi = popt + x0_err, vx_err, y0_err, vy_err, pi_err = np.sqrt(pcov.diagonal()) -def get_one_motion_model_param_names(motion_model_name, with_errors=True, with_fixed=True): - """ - Get all the motion model parameters for a given motion_model_name. - Optionally, include fixed and error parameters (included by default). - """ - mod = eval(motion_model_name) - list_of_parameters = [] - list_of_parameters += getattr(mod, 'fitter_param_names') - if with_fixed: - list_of_parameters += getattr(mod, 'fixed_param_names') - if with_errors: - list_of_parameters += [par+'_err' for par in getattr(mod, 'fitter_param_names')] - return list_of_parameters + params = np.array([x0, vx, y0, vy, pi]) + param_errors = np.array([x0_err, vx_err, y0_err, vy_err, pi_err]) + if return_chi2: + # chi2_x, chi2_y = self.calc_chi2(t, x, y, xe, ye, params, fixed_params_dict) + chi2_x = np.sum(infodict['fvec'][:len(t)]**2) + chi2_y = np.sum(infodict['fvec'][len(t):]**2) + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors -def get_list_motion_model_param_names(motion_model_list, with_errors=True, with_fixed=True): - """ - Get all the motion model parameters for all models given in motion_model_list. - Optionally, include fixed and error parameters (included by default). + +def motion_model_param_names(motion_models, with_errors=True, with_fixed=True): + """Get the motion model parameter names from a list of MotionModels. + + Parameters + ---------- + motion_models : MotionModel, str, or list of MotionModels/strings. + Motion model to query parameter names from. If str, should be the name of a MotionModel class. + with_errors : bool, optional + Add uncertainty names with '_err' suffix or not, by default True + with_fixed : bool, optional + Add fixed param names with '_fixed' suffix or not, by default True + + Returns + ------- + list + List of all unique parameter names across all motion models """ list_of_parameters = [] - all_motion_models = [eval(mm) for mm in np.unique(motion_model_list).tolist()] - for aa in range(len(all_motion_models)): - param_names = getattr(all_motion_models[aa], 'fitter_param_names') - param_fixed_names = getattr(all_motion_models[aa], 'fixed_param_names') - param_err_names = [par+'_err' for par in param_names] - list_of_parameters += param_names + def list_add(name): + if name not in list_of_parameters: + list_of_parameters.append(name) + + motion_models = np.atleast_1d(motion_models) + mm_map = motion_model_map() + for mm in motion_models: + if isinstance(mm, str): + mm = mm_map[mm] + for param in mm.fit_param_names: + # Fitter params + list_add(param) + # Error params + if with_errors: + list_add(param + '_err') + # Fixed params if with_fixed: - list_of_parameters += param_fixed_names - if with_errors: - list_of_parameters += param_err_names - - return np.unique(list_of_parameters).tolist() + for param in mm.fixed_param_names: + list_add(param) + return list_of_parameters -def get_all_motion_model_param_names(with_errors=True, with_fixed=True): - """ - Get all the motion model parameters for all models defined in this module. - Optionally, include fixed and error parameters (included by default). +def all_motion_model_param_names(with_errors=True, with_fixed=True): + """Get all motion model parameter names from all available MotionModels. + + Parameters + ---------- + with_errors : bool, optional + Add uncertainty names with '_err' suffix or not, by default True + with_fixed : bool, optional + Add fixed param names with '_fixed' suffix or not, by default True + + Returns + ------- + list + List of all unique parameter names across all motion models """ - list_of_parameters = [] - all_motion_models = MotionModel.__subclasses__() - for aa in range(len(all_motion_models)): - param_names = getattr(all_motion_models[aa], 'fitter_param_names') - param_fixed_names = getattr(all_motion_models[aa], 'fixed_param_names') - param_err_names = [par+'_err' for par in param_names] + return motion_model_param_names(MotionModel.__subclasses__(), with_errors=with_errors, with_fixed=with_fixed) - list_of_parameters += param_names - if with_fixed: - list_of_parameters += param_fixed_names - if with_errors: - list_of_parameters += param_err_names - - return np.unique(list_of_parameters).tolist() - +def motion_model_map(): + """Get a dictionary mapping motion model names to MotionModel classes. + + Returns + ------- + mm_map : dict + Dictionary mapping motion model names to MotionModel classes. + """ + mm_map = dict( + [(mm.__name__, mm) for mm in MotionModel.__subclasses__()] + ) + # Sort by required epochs + mm_map = dict(sorted(mm_map.items(), key=lambda item: item[1].n_params)) + return mm_map \ No newline at end of file diff --git a/flystar/parallax.py b/flystar/parallax.py index 4792ec6..1605060 100755 --- a/flystar/parallax.py +++ b/flystar/parallax.py @@ -23,44 +23,64 @@ # Default cache size is 1 GB cache_memory.reduce_size() -@cache_memory.cache() -def parallax_in_direction(RA, Dec, mjd, obsLocation='earth', PA=0): +# @cache_memory.cache() +def parallax_in_direction(ra, dec, mjd, obsLocation='earth', pa=0.): """ - | R.A. in degrees. (J2000) - | Dec. in degrees. (J2000) - | MJD - | PA in degrees. (counterclockwise offset of the image y-axis from North) - - Equations following MulensModel. + Calculate the parallax vector in a given direction following MulensModel. + + Parameters + ---------- + RA : float or array-like + Right Ascension in degrees. (J2000) + Dec : float or array-like + Declination in degrees. (J2000) + mjd : float or array-like + Modified Julian Date. + obsLocation : str, optional + Observer location, by default 'earth'. + PA : float, optional + Position angle in degrees (counterclockwise offset of the image y-axis from North), by default 0. + + Returns + ------- + pvec : ndarray + Parallax vector components, shape of (N_stars, 2, N_times), where the second dimension corresponds to the x or y components. """ - #print('parallax_in_direction: len(t) = ', len(mjd)) - # Munge inputs into astropy format. - times = Time(mjd + 2400000.5, format='jd', scale='tdb') - coord = SkyCoord(RA, Dec, unit=(units.deg, units.deg)) - - direction = coord.cartesian.xyz.value + # times = Time(mjd + 2400000.5, format='jd', scale='tdb') + ra = np.atleast_1d(ra) + dec = np.atleast_1d(dec) + mjd = np.atleast_1d(mjd) + pa = np.atleast_1d(pa) + times = Time(mjd, format='mjd', scale='tdb') # convert to TDB + coord = SkyCoord(ra, dec, unit=(units.deg, units.deg)) # Shape (N_stars,) + + directions = coord.cartesian.xyz.value.T # Shape (N_stars, 3) north = np.array([0., 0., 1.]) - _east_projected = np.cross(north, direction) / np.linalg.norm(np.cross(north, direction)) - _north_projected = np.cross(direction, _east_projected) / np.linalg.norm(np.cross(direction, _east_projected)) + # Cross product of each star with north vector + _east_projected = np.cross(north, directions) + _east_projected /= np.linalg.norm(_east_projected, axis=1)[:, np.newaxis] # Shape (N_stars, 3) + _north_projected = np.cross(directions, _east_projected) + _north_projected /= np.linalg.norm(_north_projected, axis=1)[:, np.newaxis] # Shape (N_stars, 3) - obs_pos = get_observer_barycentric(obsLocation, times) - sun_pos = get_body_barycentric(body='sun', time=times) + obs_pos = get_observer_barycentric(obsLocation, times) # Shape (N_times,) + sun_pos = get_body_barycentric(body='sun', time=times) # Shape (N_times,) sun_obs_pos = sun_pos - obs_pos - pos = sun_obs_pos.xyz.T.to(units.au) + pos = sun_obs_pos.xyz.T.to(units.au).value # Shape (N_times, 3) + # Broadcast pos to (N_stars, 3, N_times) and take dot product with east and north unit vectors to get components in those directions. + pos = np.broadcast_to(pos.T, (directions.shape[0], 3, pos.shape[0])) # Shape (N_stars, 3, N_times) + + e = np.einsum('sdt,sd->st', pos, _east_projected) # Shape (N_stars, N_times) + n = np.einsum('sdt,sd->st', pos, _north_projected) # Shape (N_stars, N_times) - e = np.dot(pos, _east_projected) - n = np.dot(pos, _north_projected) - # Rotate frame e,n->x,y accounting for PA - PA_rad = np.pi/180.0 * PA - x = -e.value*np.cos(PA_rad) + n.value*np.sin(PA_rad) - y = e.value*np.sin(PA_rad) + n.value*np.cos(PA_rad) - - pvec = np.array([x, y]).T - + pa = np.deg2rad(pa) # shape (N_stars,) + x = -e * np.cos(pa[:, np.newaxis]) + n * np.sin(pa[:, np.newaxis]) # Shape (N_stars, N_times) + y = e * np.sin(pa[:, np.newaxis]) + n * np.cos(pa[:, np.newaxis]) # Shape (N_stars, N_times) + # pvec Shape (N_stars, 2, N_times) + pvec = np.stack((x, y), axis=1) return pvec @@ -144,6 +164,4 @@ def get_observer_barycentric(body, times, min_ephem_step=1, velocity=False): if velocity: return (obs_pos, obs_vel) else: - return obs_pos - - + return obs_pos \ No newline at end of file diff --git a/flystar/plots.py b/flystar/plots.py index 2d65b2c..7213174 100755 --- a/flystar/plots.py +++ b/flystar/plots.py @@ -1,21 +1,20 @@ -from flystar import analysis, motion_model, startables -import pylab as py -import pylab as plt +import pdb +import math +import astropy +import matplotlib import numpy as np import matplotlib.mlab as mlab -import matplotlib -from matplotlib import colors -import matplotlib.cm as cm +import matplotlib.pyplot as plt +import matplotlib.colors as mcolors +from matplotlib import cm from scipy.stats import chi2 -from scipy.optimize import curve_fit from scipy.stats import norm -import pdb -import math -import astropy -from astropy.table import Table +from scipy.optimize import curve_fit from astropy.io import ascii -from astropy.coordinates import SkyCoord from astropy import units as u +from astropy.table import Table +from astropy.coordinates import SkyCoord +from . import motion_model, startables #################################################### # Code for making diagnostic plots for astrometry @@ -23,8 +22,8 @@ #################################################### -def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, fileName=None, - equal_axis=True, root='./'): +def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, + equal_axis=True, save_path=None, show_plot=True): """ Plot positions of stars in reference list and the transformed starlist, in reference list coordinates. Stars used in the transformation are @@ -40,7 +39,7 @@ def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, transformation. Standard column headers are assumed. starlist: astropy table - Transformed starist with the reference starlist coordinates. + Transformed starlist with the reference starlist coordinates. Standard column headers are assumed starlist_mat: astropy table @@ -51,35 +50,41 @@ def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, If not None, sets the xmin and xmax limit of the plot ylim: None or list/array [ymin, ymax] - If not None, sets the ymin and ymax limit of the plot + If not None, sets the ymin and ymax limit of the plot equal_axis: boolean If true, make axes equal. True by default - + + save_path: string + Path to save the figure to. Default is None + + show_plot: boolean + If true, show the plot. Default is True + """ - py.figure(figsize=(10,10)) - py.clf() - py.plot(ref['x'], ref['y'], 'g+', ms=5, label='Reference') - py.plot(starlist['x'], starlist['y'], 'rx', ms=5, label='starlist') - py.plot(ref_mat['x'], ref_mat['y'], color='skyblue', marker='s', ms=10, alpha=0.3, + plt.figure(figsize=(10,10)) + plt.clf() + plt.plot(ref['x'], ref['y'], 'g+', ms=5, label='Reference') + plt.plot(starlist['x'], starlist['y'], 'rx', ms=5, label='starlist') + plt.plot(ref_mat['x'], ref_mat['y'], color='skyblue', marker='s', ms=10, alpha=0.3, linestyle='None', label='Matched Reference') - py.plot(starlist_mat['x'], starlist_mat['y'], color='darkblue', marker='s', ms=5, alpha=0.3, + plt.plot(starlist_mat['x'], starlist_mat['y'], color='darkblue', marker='s', ms=5, alpha=0.3, linestyle='None', label='Matched starlist') - py.xlabel('X position (Reference Coords)') - py.ylabel('Y position (Reference Coords)') - py.legend(numpoints=1) - py.title('Label.dat Positions After Transformation') + plt.xlabel('X position (Reference Coords)') + plt.ylabel('Y position (Reference Coords)') + plt.legend(numpoints=1) + plt.title('Label.dat Positions After Transformation') if xlim != None: - py.axis([xlim[0], xlim[1], ylim[0], ylim[1]]) + plt.axis([xlim[0], xlim[1], ylim[0], ylim[1]]) if equal_axis: - py.axis('equal') - if fileName!=None: - #py.savefig(root + fileName[3:8] + 'Transformed_positions_' + '.png') - py.savefig(root + 'Transformed_positions_{0}'.format(fileName) + '.png') - else: - py.savefig(root + 'Transformed_positions.png') + plt.axis('equal') - py.close() + if save_path: + plt.savefig(save_path, dpi=300) + if show_plot: + plt.show() + else: + plt.close() return @@ -93,10 +98,10 @@ def pos_diff_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, xlim=None, fi ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in - the transformation. Standard column headers are assumed. + the transformation. Standard column headers are assumed. nbins: int Number of bins used in histogram, regardless of data range. This is @@ -108,7 +113,7 @@ def pos_diff_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, xlim=None, fi xlim: None or [xmin, xmax] If not none, set the X range of the plot - + """ diff_x = ref_mat['x'] - starlist_mat['x'] diff_y = ref_mat['y'] - starlist_mat['y'] @@ -120,23 +125,23 @@ def pos_diff_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, xlim=None, fi max_range = max([max(diff_x), max(diff_y)]) bins = np.arange(min_range, max_range+bin_width, bin_width) - - py.figure(figsize=(10,10)) - py.clf() - py.hist(diff_x, histtype='step', bins=bins, color='blue', label='X') - py.hist(diff_y, histtype='step', bins=bins, color='red', label='Y') - py.xlabel('Reference Position - starlist Position') - py.ylabel('N stars') - py.title('Position Differences for matched stars') + + plt.figure(figsize=(10,10)) + plt.clf() + plt.hist(diff_x, histtype='step', bins=bins, color='blue', label='X') + plt.hist(diff_y, histtype='step', bins=bins, color='red', label='Y') + plt.xlabel('Reference Position - starlist Position') + plt.ylabel('N stars') + plt.title('Position Differences for matched stars') if xlim != None: - py.xlim([xlim[0], xlim[1]]) - py.legend() + plt.xlim([xlim[0], xlim[1]]) + plt.legend() if fileName != None: - py.savefig(root + fileName[3:8] + 'Positions_hist_' + '.png') + plt.savefig(root + fileName[3:8] + 'Positions_hist_' + '.png', dpi=300) else: - py.savefig(root + 'Positions_hist.png') + plt.savefig(root + 'Positions_hist.png', dpi=300) - py.close() + plt.close() return def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None, errs='both', xlim=None, @@ -154,7 +159,7 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in the transformation. Standard column headers are assumed. @@ -185,9 +190,10 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None outlier: float (default = 10) Defines how many sigma away from 0 a star must be in order to be considered - an outlier. - + an outlier. + """ + from . import analysis diff_x = ref_mat['x'] - starlist_mat['x'] diff_y = ref_mat['y'] - starlist_mat['y'] @@ -201,7 +207,7 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None elif errs == 'starlist': xerr = starlist_mat['xe'] yerr = starlist_mat['ye'] - + # Calculate ratio between differences and the combined error. This is # what we will plot ratio_x = diff_x / xerr @@ -209,7 +215,7 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None # Identify non-outliers, within +/- sigma away from 0 good = np.where( (np.abs(ratio_x) < outlier) & (np.abs(ratio_y) < outlier) ) - + """ # For both X and Y, calculate chi-square. Combine arrays to get combined # chi-square @@ -217,11 +223,11 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None chi_sq_y = diff_y**2. / yerr**2. chi_sq = np.append(chi_sq_x, chi_sq_y) - + # Calculate degrees of freedom in transformation num_mod_params = calc_nparam(transform) deg_freedom = len(chi_sq) - num_mod_params - + # Calculate reduced chi-square chi_sq_red = np.sum(chi_sq) / deg_freedom """ @@ -233,13 +239,13 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None starlist_mat[good], transform, errs=errs) - + num_mod_params = analysis.calc_nparam(transform) #-------------------------------------------# # Plotting #-------------------------------------------# - + # Set the binning as per user input bins = nbins if bin_width != None: @@ -247,52 +253,52 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None max_range = max([max(ratio_x), max(ratio_y)]) bins = np.arange(min_range, max_range+bin_width, bin_width) - - py.figure(figsize=(10,10)) - py.clf() - n_x, bins_x, p = py.hist(ratio_x, histtype='step', bins=bins, color='blue', + + plt.figure(figsize=(10,10)) + plt.clf() + n_x, bins_x, p = plt.hist(ratio_x, histtype='step', bins=bins, color='blue', label='X', density=True, linewidth=2) - n_y, bins_y, p = py.hist(ratio_y, histtype='step', bins=bins, color='red', + n_y, bins_y, p = plt.hist(ratio_y, histtype='step', bins=bins, color='red', label='Y', density=True, linewidth=2) # Overplot a Gaussian, as well mean = 0 sigma = 1 x = np.arange(-6, 6, 0.1) - py.plot(x, norm.pdf(x,mean,sigma), 'g-', linewidth=2) - + plt.plot(x, norm.pdf(x,mean,sigma), 'g-', linewidth=2) + # Annotate reduced chi-sqared values in plot: with outliers - xstr = '$\chi^2_r$ = {0}'.format(np.round(chi_sq_red, decimals=3)) - py.annotate(xstr, xy=(0.3, 0.77), xycoords='figure fraction', color='black') + xstr = r'$\chi^2_r$ = {0}'.format(np.round(chi_sq_red, decimals=3)) + plt.annotate(xstr, xy=(0.3, 0.77), xycoords='figure fraction', color='black') txt = r'$\nu$ = 2*{0} - {1} = {2}'.format(len(diff_x), num_mod_params, deg_freedom) - py.annotate(txt, xy=(0.25,0.74), xycoords='figure fraction', color='black') + plt.annotate(txt, xy=(0.25,0.74), xycoords='figure fraction', color='black') xstr2 = 'With Outliers' - xstr3 = '{0} with +/- {1}+ sigma'.format(len(ratio_x) - len(good[0]), outlier) - py.annotate(xstr2, xy=(0.29, 0.83), xycoords='figure fraction', color='black') - py.annotate(xstr3, xy=(0.25, 0.80), xycoords='figure fraction', color='black') - + xstr3 = '{0} with ± {1}+ sigma'.format(len(ratio_x) - len(good[0]), outlier) + plt.annotate(xstr2, xy=(0.29, 0.83), xycoords='figure fraction', color='black') + plt.annotate(xstr3, xy=(0.25, 0.80), xycoords='figure fraction', color='black') + # Annotate reduced chi-sqared values in plot: without outliers - xstr = '$\chi^2_r$ = {0}'.format(np.round(chi_sq_red_good, decimals=3)) - py.annotate(xstr, xy=(0.7, 0.8), xycoords='figure fraction', color='black') + xstr = r'$\chi^2_r$ = {0}'.format(np.round(chi_sq_red_good, decimals=3)) + plt.annotate(xstr, xy=(0.7, 0.8), xycoords='figure fraction', color='black') txt = r'$\nu$ = 2*{0} - {1} = {2}'.format(len(good[0]), num_mod_params, deg_freedom_good) - py.annotate(txt, xy=(0.65,0.77), xycoords='figure fraction', color='black') + plt.annotate(txt, xy=(0.65,0.77), xycoords='figure fraction', color='black') xstr2 = 'Without Outliers' - py.annotate(xstr2, xy=(0.67, 0.83), xycoords='figure fraction', color='black') - - py.xlabel('(Ref Pos - TransStarlist Pos) / Ast. Error') - py.ylabel('N stars (normalized)') - py.title('Position Residuals for Matched Stars') + plt.annotate(xstr2, xy=(0.67, 0.83), xycoords='figure fraction', color='black') + + plt.xlabel('(Ref Pos - TransStarlist Pos) / Ast. Error') + plt.ylabel('N stars (normalized)') + plt.title('Position Residuals for Matched Stars') if xlim != None: - py.xlim([xlim[0], xlim[1]]) - py.legend() + plt.xlim([xlim[0], xlim[1]]) + plt.legend() if fileName != None: - py.savefig(root + fileName[3:8] + 'Positions_err_ratio_hist_' + '.png') + plt.savefig(root + fileName[3:8] + 'Positions_err_ratio_hist_' + '.png', dpi=300) else: - py.savefig(root + 'Positions_err_ratio_hist.png') + plt.savefig(root + 'Positions_err_ratio_hist.png', dpi=300) - py.close() + plt.close() return @@ -306,10 +312,10 @@ def mag_diff_hist(ref_mat, starlist_mat, bins=25, fileName=None, root='./'): ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in - the transformation. Standard column headers are assumed. + the transformation. Standard column headers are assumed. """ diff_m = ref_mat['m'] - starlist_mat['m'] @@ -318,19 +324,19 @@ def mag_diff_hist(ref_mat, starlist_mat, bins=25, fileName=None, root='./'): bad = np.isnan(diff_m) bad2 = np.where(bad == True) diff_m = np.delete(diff_m, bad2) - - py.figure(figsize=(10,10)) - py.clf() - py.hist(diff_m, bins=bins) - py.xlabel('Reference Mag - TransStarlist Mag') - py.ylabel('N stars') - py.title('Magnitude Difference for matched stars') + + plt.figure(figsize=(10,10)) + plt.clf() + plt.hist(diff_m, bins=bins) + plt.xlabel('Reference Mag - TransStarlist Mag') + plt.ylabel('N stars') + plt.title('Magnitude Difference for matched stars') if fileName != None: - py.savefig(root + fileName[3:8] + 'Magnitude_hist_' + '.png') + plt.savefig(root + fileName[3:8] + 'Magnitude_hist_' + '.png', dpi=300) else: - py.savefig(root + 'Magnitude_hist.png') + plt.savefig(root + 'Magnitude_hist.png', dpi=300) - py.close() + plt.close() return def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, ylim=None, @@ -344,7 +350,7 @@ def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in the transformation. Standard column headers are assumed. @@ -389,7 +395,7 @@ def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, diff_y = diff_y[good] xpos = xpos[good] ypos = ypos[good] - + # Divide differences by reference error, if desired if sigma: @@ -410,36 +416,36 @@ def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, diff_y = np.append(diff_y, 0) s = len(xpos) - - py.figure(figsize=(10,10)) - py.clf() - q = py.quiver(xpos, ypos, diff_x, diff_y, scale=qscale) + + plt.figure(figsize=(10,10)) + plt.clf() + q = plt.quiver(xpos, ypos, diff_x, diff_y, scale=qscale) fmt = '{0} ref units'.format(keyLength) - #py.quiverkey(q, 0.2, 0.92, keyLength, fmt, coordinates='figure', color='black') + #plt.quiverkey(q, 0.2, 0.92, keyLength, fmt, coordinates='figure', color='black') # Make our reference arrow a different color - q2 = py.quiver(xpos[s-2:s], ypos[s-2:s], diff_x[s-2:s], diff_y[s-2:s], scale=qscale, color='red') + q2 = plt.quiver(xpos[s-2:s], ypos[s-2:s], diff_x[s-2:s], diff_y[s-2:s], scale=qscale, color='red') # Annotate our reference quiver arrow - py.annotate(fmt, xy=(xpos[-1]-2, ypos[-1]+0.5), color='red') - py.xlabel('X Position (Reference coords)') - py.ylabel('Y Position (Reference coords)') + plt.annotate(fmt, xy=(xpos[-1]-2, ypos[-1]+0.5), color='red') + plt.xlabel('X Position (Reference coords)') + plt.ylabel('Y Position (Reference coords)') if xlim != None: - py.axis([xlim[0], ylim[1], ylim[0], ylim[1]]) + plt.axis([xlim[0], ylim[1], ylim[0], ylim[1]]) if sigma: if fileName != None: - py.title('(Reference - Transformed Starlist positions) / sigma') - py.savefig(root + fileName[3:8] + 'Positions_quiver_sigma_' + '.png') + plt.title('(Reference - Transformed Starlist positions) / sigma') + plt.savefig(root + fileName[3:8] + 'Positions_quiver_sigma_' + '.png', dpi=300) else: - py.title('(Reference - Transformed Starlist positions) / sigma') - py.savefig(root + 'Positions_quiver_sigma.png') + plt.title('(Reference - Transformed Starlist positions) / sigma') + plt.savefig(root + 'Positions_quiver_sigma.png', dpi=300) else: if fileName != None: - py.title('Reference - Transformed Starlist positions') - py.savefig(root + fileName[3:8] + 'Positions_quiver_' + '.png') + plt.title('Reference - Transformed Starlist positions') + plt.savefig(root + fileName[3:8] + 'Positions_quiver_' + '.png', dpi=300) else: - py.title('Reference - Transformed Starlist positions') - py.savefig(root + 'Positions_quiver.png') + plt.title('Reference - Transformed Starlist positions') + plt.savefig(root + 'Positions_quiver.png', dpi=300) - py.close() + plt.close() return def vpd(ref, starlist_trans, vxlim, vylim): @@ -464,7 +470,7 @@ def vpd(ref, starlist_trans, vxlim, vylim): If not None, sets the vxmin and vxmax limit of the plot vylim: None or list/array [vymin, vymax] - If not None, sets the vymin and vymax limit of the plot + If not None, sets the vymin and vymax limit of the plot """ # Extract velocities ref_vx = ref['vx'] @@ -472,17 +478,17 @@ def vpd(ref, starlist_trans, vxlim, vylim): trans_vx = starlist_trans['vx'] trans_vy = starlist_trans['vy'] - py.figure(figsize=(10,10)) - py.clf() - py.plot(trans_vx, trans_vy, 'k.', ms=8, label='Transformed', alpha=0.4) - py.plot(ref_vx, ref_vy, 'r.', ms=8, label='Reference', alpha=0.4) - py.xlabel('Vx (Reference units)') - py.ylabel('Vy (Reference units)') + plt.figure(figsize=(10,10)) + plt.clf() + plt.plot(trans_vx, trans_vy, 'k.', ms=8, label='Transformed', alpha=0.4) + plt.plot(ref_vx, ref_vy, 'r.', ms=8, label='Reference', alpha=0.4) + plt.xlabel('Vx (Reference units)') + plt.ylabel('Vy (Reference units)') if vxlim != None: - py.axis([vxlim[0], vylim[1], vylim[0], vylim[1]]) - py.title('Reference and Transformed Proper Motions') - py.legend() - py.savefig('Transformed_velocities.png') + plt.axis([vxlim[0], vylim[1], vylim[0], vylim[1]]) + plt.title('Reference and Transformed Proper Motions') + plt.legend() + plt.savefig('Transformed_velocities.png', dpi=300) return @@ -507,7 +513,7 @@ def vel_diff_err_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, vxlim=Non bin_width: None or float If float, sets the width of the bins used in the histograms. Will override nbins - + vxlim: None or [vx_min, vx_max] If not none, set the X axis of the Vx plot by defining the minimum and maximum values @@ -519,7 +525,7 @@ def vel_diff_err_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, vxlim=Non # Will produce 2-panel plot: Vx resid and Vy resid diff_vx = ref_mat['vx'] - starlist_mat['vx'] diff_vy = ref_mat['vy'] - starlist_mat['vy'] - + vx_err = np.hypot(ref_mat['vx_err'], starlist_mat['vx_err']) vy_err = np.hypot(ref_mat['vy_err'], starlist_mat['vy_err']) @@ -537,28 +543,28 @@ def vel_diff_err_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, vxlim=Non mean = 0 sigma = 1 x = np.arange(-6, 6, 0.1) - - py.figure(figsize=(20,10)) - py.subplot(121) - py.subplots_adjust(left=0.1) - py.hist(ratio_vx, bins=xbins, histtype='step', color='black', density=True, + + plt.figure(figsize=(20,10)) + plt.subplot(121) + plt.subplots_adjust(left=0.1) + plt.hist(ratio_vx, bins=xbins, histtype='step', color='black', density=True, linewidth=2) - py.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) - py.xlabel('(Ref Vx - Trans Vx) / Vxe') - py.ylabel('N_stars') - py.title('Vx Residuals, Matched') + plt.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) + plt.xlabel('(Ref Vx - Trans Vx) / Vxe') + plt.ylabel('N_stars') + plt.title('Vx Residuals, Matched') if vxlim != None: - py.xlim([vxlim[0], vxlim[1]]) - py.subplot(122) - py.hist(ratio_vy, bins=ybins, histtype='step', color='black', density=True, + plt.xlim([vxlim[0], vxlim[1]]) + plt.subplot(122) + plt.hist(ratio_vy, bins=ybins, histtype='step', color='black', density=True, linewidth=2) - py.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) - py.xlabel('(Ref Vy - Trans Vy) / Vye') - py.ylabel('N_stars') - py.title('Vy Residuals, Matched') + plt.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) + plt.xlabel('(Ref Vy - Trans Vy) / Vye') + plt.ylabel('N_stars') + plt.title('Vy Residuals, Matched') if vylim != None: - py.xlim([vylim[0], vylim[1]]) - py.savefig('Vel_err_ratio_dist.png') + plt.xlim([vylim[0], vylim[1]]) + plt.savefig('Vel_err_ratio_dist.png', dpi=300) return @@ -606,17 +612,17 @@ def residual_vpd(ref_mat, starlist_trans_mat, pscale=None): yerr = np.hypot(ref_mat['vy_err'], starlist_trans_mat['vy_err']) # Plotting - py.figure(figsize=(10,10)) - py.clf() - py.errorbar(diff_x, diff_y, xerr=xerr, yerr=yerr, fmt='k.', ms=8, alpha=0.5) + plt.figure(figsize=(10,10)) + plt.clf() + plt.errorbar(diff_x, diff_y, xerr=xerr, yerr=yerr, fmt='k.', ms=8, alpha=0.5) if pscale != None: - py.xlabel('Reference_vx - Transformed_vx (mas/yr)') - py.ylabel('Reference_vy - Transformed_vy (mas/yr)') + plt.xlabel('Reference_vx - Transformed_vx (mas/yr)') + plt.ylabel('Reference_vy - Transformed_vy (mas/yr)') else: - py.xlabel('Reference_vx - Transformed_vx (reference coords)') - py.ylabel('Reference_vy - Transformed_vy (reference coords)') - py.title('Proper Motion Residuals') - py.savefig('resid_vpd.png') + plt.xlabel('Reference_vx - Transformed_vx (reference coords)') + plt.ylabel('Reference_vy - Transformed_vy (reference coords)') + plt.title('Proper Motion Residuals') + plt.savefig('resid_vpd.png', dpi=300) return @@ -626,7 +632,7 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', print( 'Creating residuals plots for star(s):' ) print( starNames ) - + s = starset.StarSet(rootDir + align) s.loadPolyfit(rootDir + poly, accel=0, arcsec=0) Nstars = len(starNames) @@ -636,18 +642,18 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', else: Nrows = math.ceil(Nstars / (Ncols / 2)) * 3 - py.close('all') - py.figure(2, figsize=figsize) + plt.close('all') + plt.figure(2, figsize=figsize) names = s.getArray('name') mag = s.getArray('mag') x = s.getArray('x') y = s.getArray('y') r = np.hypot(x,y) - + for i in range(Nstars): - + starName = starNames[i] - + ii = names.index(starName) star = s.stars[ii] @@ -728,9 +734,9 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', idx = np.where(abs(sig) > 4) print( 'Star: ', starName ) - print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % (fitx.chi2red, fitx.chi2, fitx.dof)) - print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % (fity.chi2red, fity.chi2, fity.dof)) # print( 'X Outliers: ', time[idxX] ) # print( 'Y Outliers: ', time[idxY] ) @@ -745,8 +751,8 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', t0 = int(np.floor(np.min(time))) tO = int(np.ceil(np.max(time))) - - dateTicLoc = py.MultipleLocator(3) + + dateTicLoc = plt.MultipleLocator(3) dateTicRng = [t0-1, tO+1] dateTics = np.arange(t0, tO+1) DateTicsLabel = dateTics-2000 @@ -754,7 +760,7 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', # See if we are using MJD instead. if time[0] > 50000: print('MJD') - dateTicLoc = py.MultipleLocator(1000) + dateTicLoc = plt.MultipleLocator(1000) t0 = int(np.round(np.min(time), 50)) tO = int(np.round(np.max(time), 50)) dateTicRng = [t0-200, tO+200] @@ -775,125 +781,125 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', row = 1 else: col = 1 + 2*(i % (Ncols/2)) - row = 1 + 3*(i//(Ncols/2)) - + row = 1 + 3*(i//(Ncols/2)) + ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, fitLineX, 'b-') - py.plot(time, fitLineX + fitSigX, 'b--') - py.plot(time, fitLineX - fitSigX, 'b--') - py.errorbar(time, x, yerr=xerr, fmt='k.') - rng = py.axis() - py.ylim(np.min(x-xerr-0.1),np.max(x+xerr+0.1)) - py.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, fitLineX, 'b-') + plt.plot(time, fitLineX + fitSigX, 'b--') + plt.plot(time, fitLineX - fitSigX, 'b--') + plt.errorbar(time, x, yerr=xerr, fmt='k.') + rng = plt.axis() + plt.ylim(np.min(x-xerr-0.1),np.max(x+xerr+0.1)) + plt.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('X (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('X (pix)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - py.yticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2)) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) - py.annotate(starName,xy=(1.0,1.1), xycoords='axes fraction', fontsize=12, color='red') + plt.yticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) + plt.annotate(starName,xy=(1.0,1.1), xycoords='axes fraction', fontsize=12, color='red') col = col + 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, fitLineY, 'b-') - py.plot(time, fitLineY + fitSigY, 'b--') - py.plot(time, fitLineY - fitSigY, 'b--') - py.errorbar(time, y, yerr=yerr, fmt='k.') - rng = py.axis() - py.axis(dateTicRng + [rng[2], rng[3]], fontsize=fontsize1) - py.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, fitLineY, 'b-') + plt.plot(time, fitLineY + fitSigY, 'b--') + plt.plot(time, fitLineY - fitSigY, 'b--') + plt.errorbar(time, y, yerr=yerr, fmt='k.') + rng = plt.axis() + plt.axis(dateTicRng + [rng[2], rng[3]], fontsize=fontsize1) + plt.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('Y (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('Y (pix)', fontsize=fontsize1) #paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=12) - py.ylim(np.min(y-yerr-0.1),np.max(y+yerr+0.1)) - py.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) + plt.ylim(np.min(y-yerr-0.1),np.max(y+yerr+0.1)) + plt.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) row = row + 1 col = col - 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigX, 'b--') - py.plot(time, -fitSigX, 'b--') - py.errorbar(time, x - fitLineX, yerr=xerr, fmt='k.') - py.axis(dateTicRng + resTicRng, fontsize=fontsize1) - py.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigX, 'b--') + plt.plot(time, -fitSigX, 'b--') + plt.errorbar(time, x - fitLineX, yerr=xerr, fmt='k.') + plt.axis(dateTicRng + resTicRng, fontsize=fontsize1) + plt.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('X Residuals (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('X Residuals (pix)', fontsize=fontsize1) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) col = col + 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigY, 'b--') - py.plot(time, -fitSigY, 'b--') - py.errorbar(time, y - fitLineY, yerr=yerr, fmt='k.') - py.axis(dateTicRng + resTicRng, fontsize=fontsize1) - py.xlabel('Date -2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigY, 'b--') + plt.plot(time, -fitSigY, 'b--') + plt.errorbar(time, y - fitLineY, yerr=yerr, fmt='k.') + plt.axis(dateTicRng + resTicRng, fontsize=fontsize1) + plt.xlabel('Date -2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('Y Residuals (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('Y Residuals (pix)', fontsize=fontsize1) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) row = row + 1 col = col - 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.errorbar(x,y, xerr=xerr, yerr=yerr, fmt='k.') - py.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) - py.xticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2), rotation = 270) - py.axis('equal') + paxes = plt.subplot(Nrows, Ncols, ind) + plt.errorbar(x,y, xerr=xerr, yerr=yerr, fmt='k.') + plt.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) + plt.xticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2), rotation = 270) + plt.axis('equal') paxes.tick_params(axis='both', which='major', labelsize=fontsize1) paxes.yaxis.set_major_formatter(FormatStrFormatter('%.2f')) paxes.xaxis.set_major_formatter(FormatStrFormatter('%.2f')) - py.xlabel('X (pix)', fontsize=fontsize1) - py.ylabel('Y (pix)', fontsize=fontsize1) - py.plot(fitLineX, fitLineY, 'b-') + plt.xlabel('X (pix)', fontsize=fontsize1) + plt.ylabel('Y (pix)', fontsize=fontsize1) + plt.plot(fitLineX, fitLineY, 'b-') col = col + 1 ind = (row-1)*Ncols + col bins = np.arange(-7.5, 7.5, 1) - paxes = py.subplot(Nrows, Ncols, ind) + paxes = plt.subplot(Nrows, Ncols, ind) id = np.where(diffY < 0)[0] - sig[id] = -1.*sig[id] - (n, b, p) = py.hist(sigX, bins, histtype='stepfilled', color='b', label='X') - py.setp(p, 'facecolor', 'b') - (n, b, p) = py.hist(sigY, bins, histtype='step', color='r', label='Y') - py.axis([-7, 7, 0, 8], fontsize=10) - py.legend() - py.xlabel('Residuals (sigma)', fontsize=fontsize1) - py.ylabel('Number of Epochs', fontsize=fontsize1) + sig[id] = -1.*sig[id] + (n, b, p) = plt.hist(sigX, bins, histtype='stepfilled', color='b', label='X') + plt.setp(p, 'facecolor', 'b') + (n, b, p) = plt.hist(sigY, bins, histtype='step', color='r', label='Y') + plt.axis([-7, 7, 0, 8], fontsize=10) + plt.legend() + plt.xlabel('Residuals (sigma)', fontsize=fontsize1) + plt.ylabel('Number of Epochs', fontsize=fontsize1) ########## # @@ -901,9 +907,9 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', # ########## if (radial == True): - py.clf() + plt.clf() - dateTicLoc = py.MultipleLocator(3) + dateTicLoc = plt.MultipleLocator(3) maxErr = np.array([rerr, terr]).max() resTicRng = [-3*maxErr, 3*maxErr] @@ -912,90 +918,90 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', fmtX = FormatStrFormatter('%5i') fmtY = FormatStrFormatter('%6.2f') - paxes = py.subplot(3,2,1) - py.plot(time, fitLineR, 'b-') - py.plot(time, fitLineR + fitSigR, 'b--') - py.plot(time, fitLineR - fitSigR, 'b--') - py.errorbar(time, r, yerr=rerr, fmt='k.') - rng = py.axis() - py.axis(dateTicRng + [rng[2], rng[3]]) - py.xlabel('Date (yrs)') - py.ylabel('R (pix)') + paxes = plt.subplot(3,2,1) + plt.plot(time, fitLineR, 'b-') + plt.plot(time, fitLineR + fitSigR, 'b--') + plt.plot(time, fitLineR - fitSigR, 'b--') + plt.errorbar(time, r, yerr=rerr, fmt='k.') + rng = plt.axis() + plt.axis(dateTicRng + [rng[2], rng[3]]) + plt.xlabel('Date (yrs)') + plt.ylabel('R (pix)') paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) - paxes = py.subplot(3, 2, 2) - py.plot(time, fitLineT, 'b-') - py.plot(time, fitLineT + fitSigT, 'b--') - py.plot(time, fitLineT - fitSigT, 'b--') - py.errorbar(time, t, yerr=terr, fmt='k.') - rng = py.axis() - py.axis(dateTicRng + [rng[2], rng[3]]) - py.xlabel('Date (yrs)') - py.ylabel('T (pix)') + paxes = plt.subplot(3, 2, 2) + plt.plot(time, fitLineT, 'b-') + plt.plot(time, fitLineT + fitSigT, 'b--') + plt.plot(time, fitLineT - fitSigT, 'b--') + plt.errorbar(time, t, yerr=terr, fmt='k.') + rng = plt.axis() + plt.axis(dateTicRng + [rng[2], rng[3]]) + plt.xlabel('Date (yrs)') + plt.ylabel('T (pix)') paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) - paxes = py.subplot(3, 2, 3) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigR, 'b--') - py.plot(time, -fitSigR, 'b--') - py.errorbar(time, r - fitLineR, yerr=rerr, fmt='k.') - py.axis(dateTicRng + resTicRng) - py.xlabel('Date (yrs)') - py.ylabel('R Residuals (pix)') + paxes = plt.subplot(3, 2, 3) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigR, 'b--') + plt.plot(time, -fitSigR, 'b--') + plt.errorbar(time, r - fitLineR, yerr=rerr, fmt='k.') + plt.axis(dateTicRng + resTicRng) + plt.xlabel('Date (yrs)') + plt.ylabel('R Residuals (pix)') paxes.get_xaxis().set_major_locator(dateTicLoc) - paxes = py.subplot(3, 2, 4) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigT, 'b--') - py.plot(time, -fitSigT, 'b--') - py.errorbar(time, t - fitLineT, yerr=terr, fmt='k.') - py.axis(dateTicRng + resTicRng) - py.xlabel('Date (yrs)') - py.ylabel('T Residuals (pix)') + paxes = plt.subplot(3, 2, 4) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigT, 'b--') + plt.plot(time, -fitSigT, 'b--') + plt.errorbar(time, t - fitLineT, yerr=terr, fmt='k.') + plt.axis(dateTicRng + resTicRng) + plt.xlabel('Date (yrs)') + plt.ylabel('T Residuals (pix)') paxes.get_xaxis().set_major_locator(dateTicLoc) bins = np.arange(-7, 7, 1) - py.subplot(3, 2, 5) - (n, b, p) = py.hist(sigR, bins) - py.setp(p, 'facecolor', 'k') - py.axis([-5, 5, 0, 20]) - py.xlabel('T Residuals (sigma)') - py.ylabel('Number of Epochs') - - py.subplot(3, 2, 6) - (n, b, p) = py.hist(sigT, bins) - py.axis([-5, 5, 0, 20]) - py.setp(p, 'facecolor', 'k') - py.xlabel('Y Residuals (sigma)') - py.ylabel('Number of Epochs') - - py.subplots_adjust(wspace=0.4, hspace=0.4, right=0.95, top=0.95) - py.savefig(rootDir+'plots/plotStarRadial_' + starName + '.png') - py.show() + plt.subplot(3, 2, 5) + (n, b, p) = plt.hist(sigR, bins) + plt.setp(p, 'facecolor', 'k') + plt.axis([-5, 5, 0, 20]) + plt.xlabel('T Residuals (sigma)') + plt.ylabel('Number of Epochs') + + plt.subplot(3, 2, 6) + (n, b, p) = plt.hist(sigT, bins) + plt.axis([-5, 5, 0, 20]) + plt.setp(p, 'facecolor', 'k') + plt.xlabel('Y Residuals (sigma)') + plt.ylabel('Number of Epochs') + + plt.subplots_adjust(wspace=0.4, hspace=0.4, right=0.95, top=0.95) + plt.savefig(rootDir+'plots/plotStarRadial_' + starName + '.png', dpi=300) + plt.show() title = rootDir.split('/')[-2] - py.suptitle(title, x=0.5, y=0.97) + plt.suptitle(title, x=0.5, y=0.97) if Nstars == 1: - py.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) - py.savefig(rootDir+'plots/plotStar_' + starName + '.png') + plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) + plt.savefig(rootDir+'plots/plotStar_' + starName + '.png', dpi=300) else: - py.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) - py.savefig(rootDir+'plots/plotStar_all.png') - py.show() + plt.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) + plt.savefig(rootDir+'plots/plotStar_all.png', dpi=300) + plt.show() - py.show() + plt.show() print('Fubar') - + ################################################## # New codes for velocity support in FlyStar and using -# the new StarTable and StarList format. +# the new StarTable and StarList format. ################################################## def plot_pm(tab): @@ -1005,7 +1011,7 @@ def plot_pm(tab): q = plt.quiver(tab['x0'].data, tab['y0'].data, tab['vx'].data*1e3, tab['vy'].data*1e3, scale=1e2, angles='xy') - plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', + plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', coordinates='figure', labelpos='E') plt.xlabel(r'$\Delta \alpha$ (")') plt.ylabel(r'$\Delta \delta$ (")') @@ -1022,7 +1028,7 @@ def plot_gaia(gaia): d_ra_tan = (ra_tan - ra_tan_mean) * cos_dec * 3600.0 d_de_tan = (de_tan - de_tan_mean) * 3600.0 - + pmra = gaia['pmra'] pmdec = gaia['pmdec'] plt.figure(figsize=(6,6)) @@ -1031,7 +1037,7 @@ def plot_gaia(gaia): q = plt.quiver(d_ra_tan.data, d_de_tan.data, pmra.data, pmdec.data, scale=1e2, angles='xy') - plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', + plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', coordinates='figure', labelpos='E') plt.xlabel(r'$\Delta \alpha \cos \delta$ ('')') plt.ylabel(r'$\Delta \delta$ ('')') @@ -1039,42 +1045,45 @@ def plot_gaia(gaia): fmt = r'[$\alpha$, $\delta$] = [{0:8.3f}$^\circ$, {1:8.3f}$^\circ$]' plt.title(fmt.format(ra_tan_mean, de_tan_mean)) plt.gca().invert_xaxis() - - - return -def plot_pm_error(tab): - plt.figure(figsize=(6,6)) - plt.clf() - plt.semilogy(tab['m0'], tab['vx_err']*1e3, 'r.', label=r'$\sigma_{\mu_{\alpha *}}$', alpha=0.4) - plt.semilogy(tab['m0'], tab['vy_err']*1e3, 'b.', label=r'$\sigma_{\mu_{\delta}}$', alpha=0.4) - plt.legend() - plt.xlabel('Mag') - plt.ylabel('PM Error (mas/yr)') return -def plot_mag_error(tab): - plt.figure(figsize=(6,6)) - plt.clf() - plt.semilogy(tab['m0'], tab['m0_err'], 'r.', alpha=0.4) - plt.legend() - plt.xlabel('Mag') - plt.ylabel('Mag Error (mag)') +def plot_pm_error(tab, save_path=None): + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + ax.semilogy(tab['m0'], tab['vx_err']*1e3, color='C0', marker='.', ls='none', ms=3, label=r'$\sigma_{\mu_{\alpha *}}$', alpha=0.3) + ax.semilogy(tab['m0'], tab['vy_err']*1e3, color='C3', marker='.', ls='none', ms=3, label=r'$\sigma_{\mu_{\delta}}$', alpha=0.3) + ax.legend() + ax.set_xlabel('Mag') + ax.set_ylabel('PM Error (mas/yr)') + plt.tight_layout() + if save_path is not None: + plt.savefig(save_path, dpi=300) + plt.show() + return +def plot_mag_error(tab, save_path=None): + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + ax.semilogy(tab['m0'], tab['m0_err'], color='C0', marker='.', ls='none', alpha=0.4) + ax.legend() + ax.set_xlabel('Mag') + ax.set_ylabel('Mag Error (mag)') + plt.tight_layout() + if save_path is not None: + plt.savefig(save_path, dpi=300) + plt.show() return -def plot_mean_residuals_by_epoch(tab, motion_model_dict={}): +def plot_mean_residuals_by_epoch(tab): """ Plot mean position and magnitude residuals vs. epoch. Note we are plotting the mean( |dx} ) to see the size of the mean residual. """ # Predicted model positions at each epoch - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod, yt_mod, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - + xt_mod, yt_mod, xt_mod_err, yt_mod_err = tab.predict_positions(tab['t'][i_all_detected]) + # Residuals dx = tab['x'] - xt_mod dy = tab['y'] - yt_mod @@ -1119,33 +1128,43 @@ def plot_mean_residuals_by_epoch(tab, motion_model_dict={}): plt.axhline(0, ls='--', color='black') plt.xlabel('Time (yr)') plt.ylabel('Mag Residuals') - + return -def plot_quiver_residuals_all_epochs(tab, motion_model_dict={}, unit='arcsec', scale=None, plotlim=None): +def plot_quiver_residuals_all_epochs(tab, unit='arcsec', scale=None, plotlim=None, save_path=None, show_plot=True): # Keep track of the residuals for averaging. dr_good = np.zeros(len(tab), dtype=float) n_good = np.zeros(len(tab), dtype=int) dr_ref = np.zeros(len(tab), dtype=float) n_ref = np.zeros(len(tab), dtype=int) - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) complete_times = np.array([np.unique(col[~np.isnan(col)])[0] for col in tab['t'].T]) - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(complete_times, motion_model_dict, allow_alt_models=True) + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(complete_times, motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(complete_times) for ee in range(tab['x'].shape[1]): xt_mod = xt_mod_all[:,ee] yt_mod = yt_mod_all[:,ee] - + good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] - dx, dy = plot_quiver_residuals(tab['x'][:, ee], tab['y'][:, ee], - xt_mod, yt_mod, - good_idx, ref_idx, - 'Epoch {0:d}'.format(ee), - unit=unit, scale=scale, plotlim=plotlim) + dx, dy = plot_quiver_residuals( + tab['x'][:, ee], + tab['y'][:, ee], + xt_mod, + yt_mod, + good_idx, + ref_idx, + 'Epoch {0:d}'.format(ee), + unit=unit, + scale=scale, + plotlim=plotlim, + show_plot=show_plot, + save_path=f'{save_path}/Quiver_Residual_{ee}.png' if save_path else None + ) # Building up average dr for a set of stars. dr = np.hypot(dx, dy) @@ -1159,13 +1178,13 @@ def plot_quiver_residuals_all_epochs(tab, motion_model_dict={}, unit='arcsec', s dr_good_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_good > 0)[0] dr_good_avg[idx] = dr_good[idx] / n_good[idx] - + dr_ref_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_ref > 0)[0] dr_ref_avg[idx] = dr_ref[idx] / n_ref[idx] - hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' - fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' + # hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' + # fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' # print() # print('##########') @@ -1185,75 +1204,76 @@ def plot_quiver_residuals_all_epochs(tab, motion_model_dict={}, unit='arcsec', s # if (dr_ref_avg[rr] > 0): # print(fmt.format(name=tab['name'][rr], mag=tab['m0'][rr], dr=dr_ref_avg[rr], # x=tab['x0'][rr], y=tab['y0'][rr], r=np.hypot(tab['x0'][rr], tab['y0'][rr]))) - + return -def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, motion_model_dict={}, unit='arcsec', scale=None, plotlim=None, scale_orig=None, cte_fit=None, mlim=15): +def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, unit='arcsec', scale=None, plotlim=None, scale_orig=None, cte_fit=None, mlim=15, show_plot=True, save_path=None): # Keep track of the residuals for averaging. dr_good = np.zeros(len(tab), dtype=float) n_good = np.zeros(len(tab), dtype=int) dr_ref = np.zeros(len(tab), dtype=float) n_ref = np.zeros(len(tab), dtype=int) - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + for ee in range(tab['x'].shape[1]): dt = tab['t'][:, ee] - tab['t0'] xt_mod = xt_mod_all[ee] yt_mod = yt_mod_all[ee] - + good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] da = calc_da(trans_list[ee]) - dx, dy = plot_quiver_residuals(tab['x'][:, ee], tab['y'][:, ee], - xt_mod, yt_mod, + dx, dy = plot_quiver_residuals(tab['x'][:, ee], tab['y'][:, ee], + xt_mod, yt_mod, good_idx, ref_idx, - 'Epoch {0:d}'.format(ee), - unit=unit, scale=scale, plotlim=plotlim) + 'Epoch {0:d}'.format(ee), + unit=unit, scale=scale, plotlim=plotlim, show_plot=show_plot, save_path=f'{save_path}/Quiver_Residual_{ee}.png' if save_path else None) - plot_quiver_residuals_orig(tab['x'][:, ee], tab['y'][:, ee], - xt_mod, yt_mod, + plot_quiver_residuals_orig(tab['x'][:, ee], tab['y'][:, ee], + xt_mod, yt_mod, good_idx, ref_idx, tab['x_orig'][:, ee], tab['y_orig'][:, ee], da, - 'Epoch {0:d}'.format(ee), - scale=scale_orig, plotlim=plotlim) + 'Epoch {0:d}'.format(ee), + scale=scale_orig, plotlim=plotlim, show_plot=show_plot, save_path=f'{save_path}/Quiver_Residual_Orig_{ee}.png' if save_path else None) - plot_mag_scatter(tab['m'][:, ee], + plot_mag_scatter(tab['m'][:, ee], tab['m0'], tab['m0_err'], - tab['x'][:, ee], tab['y'][:, ee], + tab['x'][:, ee], tab['y'][:, ee], tab['xe'][:, ee], tab['ye'][:, ee], - xt_mod, yt_mod, + xt_mod, yt_mod, good_idx, ref_idx, 'Epoch {0:d}'.format(ee), da=da, xorig=tab['x_orig'][:, ee], yorig=tab['y_orig'][:, ee], - cte_fit=cte_fit, mlim=mlim) + cte_fit=cte_fit, mlim=mlim, show_plot=show_plot, save_path=f'{save_path}/Mag_Scatter_{ee}.png' if save_path else None) - plot_y_scatter(tab['m'][:, ee], + plot_y_scatter(tab['m'][:, ee], tab['m0'], tab['m0_err'], - tab['x'][:, ee], tab['y'][:, ee], + tab['x'][:, ee], tab['y'][:, ee], tab['xe'][:, ee], tab['ye'][:, ee], - xt_mod, yt_mod, + xt_mod, yt_mod, good_idx, ref_idx, 'Epoch {0:d}'.format(ee), da=da, xorig=tab['x_orig'][:, ee], yorig=tab['y_orig'][:, ee], - cte_fit=cte_fit, mlim=mlim) + cte_fit=cte_fit, mlim=mlim, show_plot=show_plot, save_path=f'{save_path}/Y_Scatter_{ee}.png' if save_path else None) # plot_quiver_residuals_orig_angle_xy(tab['x'][:, ee], tab['y'][:, ee], -# xt_mod, yt_mod, +# xt_mod, yt_mod, # good_idx, ref_idx, # tab['x_orig'][:, ee], tab['y_orig'][:, ee], da, # 'Epoch {0:d}'.format(ee)) # # plot_quiver_residuals_vs_pos_err(dx, dy, good_idx, ref_idx, -# 1e3 * tab['xe'][:, ee], 1e3 * tab['ye'][:, ee], +# 1e3 * tab['xe'][:, ee], 1e3 * tab['ye'][:, ee], # 'positional err (mas)', 'Epoch {0:d}'.format(ee), da=da) - + # Building up average dr for a set of stars. dr = np.hypot(dx, dy) @@ -1266,13 +1286,13 @@ def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, motion_model_dic dr_good_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_good > 0)[0] dr_good_avg[idx] = dr_good[idx] / n_good[idx] - + dr_ref_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_ref > 0)[0] dr_ref_avg[idx] = dr_ref[idx] / n_ref[idx] - hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' - fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' + # hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' + # fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' # print() # print('##########') @@ -1292,27 +1312,28 @@ def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, motion_model_dic # if (dr_ref_avg[rr] > 0): # print(fmt.format(name=tab['name'][rr], mag=tab['m0'][rr], dr=dr_ref_avg[rr], # x=tab['x0'][rr], y=tab['y0'][rr], r=np.hypot(tab['x0'][rr], tab['y0'][rr]))) - + return -def plot_mag_scatter_multi_trans_all_epochs(tab_list, trans_list_list, motion_model_dict={}, unit='arcsec', scale=None, plotlim=None, scale_orig=None): +def plot_mag_scatter_multi_trans_all_epochs(tab_list, trans_list_list, unit='arcsec', scale=None, plotlim=None, scale_orig=None): m_t_list = [] x_t_list = [] y_t_list = [] - xe_t_list = [] + xe_t_list = [] ye_t_list = [] x_ref_list = [] - y_ref_list = [] - good_idx_list = [] - ref_idx_list =[] + y_ref_list = [] + good_idx_list = [] + ref_idx_list =[] da_list = [] ntrans = len(tab_list) - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + for mm in range(ntrans): tab = tab_list[mm] trans_list = trans_list_list[mm] @@ -1320,7 +1341,7 @@ def plot_mag_scatter_multi_trans_all_epochs(tab_list, trans_list_list, motion_mo dt = tab['t'][:, ee] - tab['t0'] xt_mod = xt_mod_all[ee] yt_mod = yt_mod_all[ee] - + good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] @@ -1329,19 +1350,19 @@ def plot_mag_scatter_multi_trans_all_epochs(tab_list, trans_list_list, motion_mo m_t_list.append(tab['m'][:, ee]) x_t_list.append(tab['x'][:, ee]) y_t_list.append(tab['y'][:, ee]) - xe_t_list.append(tab['xe'][:, ee]) + xe_t_list.append(tab['xe'][:, ee]) ye_t_list.append(tab['ye'][:, ee]) x_ref_list.append(xt_mod) y_ref_list.append(yt_mod) - good_idx_list.append(good_idx) - ref_idx_list.append(ref_idx) + good_idx_list.append(good_idx) + ref_idx_list.append(ref_idx) da_list.append(da) for ee in range(tab_list[0]['x'].shape[1]): - plot_mag_scatter_multi_trans(m_t_list[ee::ntrans], x_t_list[ee::ntrans], y_t_list[ee::ntrans], - xe_t_list[ee::ntrans], ye_t_list[ee::ntrans], x_ref_list[ee::ntrans], y_ref_list[ee::ntrans], + plot_mag_scatter_multi_trans(m_t_list[ee::ntrans], x_t_list[ee::ntrans], y_t_list[ee::ntrans], + xe_t_list[ee::ntrans], ye_t_list[ee::ntrans], x_ref_list[ee::ntrans], y_ref_list[ee::ntrans], good_idx_list[ee::ntrans], ref_idx_list[ee::ntrans], 'Epoch {0:d}'.format(ee), da_list[ee::ntrans]) - + return @@ -1363,7 +1384,7 @@ def calc_da(trans_list): c01 = trans_list.px.parameters[c01_idx] c10 = trans_list.px.parameters[c10_idx] da = np.degrees(np.arctan2(-c01, c10)) - + return da @@ -1371,7 +1392,7 @@ def plot_mag_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, # Residual dx = (x_t - x_ref) dy = (y_t - y_ref) - + # Magnitude mgood = m_t[good_idx] mref = m_t[good_idx][ref_idx] @@ -1468,7 +1489,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r # Residual dx = (x_t - x_ref) dy = (y_t - y_ref) - + # Magnitude mgood = m_t[good_idx] mref = m_t[good_idx][ref_idx] @@ -1579,23 +1600,23 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r if cte_fit=='power': idx = np.where(mgood > mlim)[0] gpopt, gpcov = curve_fit(T_cte_y, mgood[idx], ygood[idx], maxfev=100000) - + marr = np.linspace(13, 24, 1000) - + # Corrected values ygood_new = ygood - T_cte_y(mgood, *gpopt) yref_new = yref - T_cte_y(mref, *gpopt) - + agood = angle_from_xy(xgood, ygood) % 360 rgood = np.hypot(xgood, ygood) aref = angle_from_xy(xref, yref) % 360 rref = np.hypot(xref, yref) - + agood_new = angle_from_xy(xgood, ygood_new) % 360 rgood_new = np.hypot(xgood, ygood_new) aref_new = angle_from_xy(xref, yref_new) % 360 rref_new = np.hypot(xref, yref_new) - + fig, ax = plt.subplots(4, 2, figsize=(12,12), sharex=True, sharey='row', num=105) plt.subplots_adjust(hspace=0.01, wspace=0.01) ax[0,0].scatter(mgood, ygood, color='black', alpha=0.3, s=2) @@ -1605,24 +1626,24 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[0,0].axhline(y=0) ax[0,0].plot(marr, T_cte_y(marr, *gpopt), 'k-') ax[0,0].set_title('No correction') - + ax[0,1].scatter(mgood, ygood_new, color='black', alpha=0.3, s=2) ax[0,1].scatter(mref, yref_new, color='red', alpha=0.3, s=2) ax[0,1].set_ylim(-0.01, 0.01) ax[0,1].axhline(y=0) ax[0,1].set_title('Corrected') - + ax[1,0].scatter(mgood, ygood/yegood, color='black', alpha=0.3, s=2) ax[1,0].scatter(mref, yref/yeref, color='red', alpha=0.3, s=2) ax[1,0].set_ylabel('Res/Pos Err, y') ax[1,0].set_ylim(-10, 10) ax[1,0].axhline(y=0) - + ax[1,1].scatter(mgood, ygood_new/yegood, color='black', alpha=0.3, s=2) ax[1,1].scatter(mref, yref_new/yeref, color='red', alpha=0.3, s=2) ax[1,1].set_ylim(-10, 10) ax[1,1].axhline(y=0) - + ax[2,0].scatter(mgood, rgood, color='black', alpha=0.3, s=2) ax[2,0].scatter(mref, rref, color='red', alpha=0.3, s=2) ax[2,0].set_ylabel('Modulus (arcsec)') @@ -1631,7 +1652,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood.data, rref.data]))) else: ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood, rref]))) - + ax[2,1].scatter(mgood, rgood_new, color='black', alpha=0.3, s=2) ax[2,1].scatter(mref, rref_new, color='red', alpha=0.3, s=2) ax[2,1].set_yscale('log') @@ -1639,12 +1660,12 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new.data, rref_new.data]))) else: ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new, rref_new]))) - + ax[3,0].scatter(mgood, agood, color='black', alpha=0.3, s=2) ax[3,0].scatter(mref, aref, color='red', alpha=0.3, s=2) ax[3,0].set_ylabel('Angle (deg)') ax[3,0].set_xlabel('mag') - + ax[3,1].scatter(mgood, agood_new, color='black', alpha=0.3, s=2) ax[3,1].scatter(mref, aref_new, color='red', alpha=0.3, s=2) ax[3,1].set_xlabel('mag') @@ -1658,7 +1679,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r gpopt1, gpcov1 = curve_fit(T_line, mgood[idx1], ygood[idx1], maxfev=100000) gpopt2, gpcov2 = curve_fit(T_cte_y, mgood[idx2], ygood[idx2], maxfev=100000) - + marr1 = np.linspace(13, 18.5, 1000) marr2 = np.linspace(18.5, 24, 1000) @@ -1686,7 +1707,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r xeref2 = xeref[idx2r] yeref1 = yeref[idx1r] yeref2 = yeref[idx2r] - + # Corrected values ygood_new1 = ygood1 - T_line(mgood1, *gpopt1) yref_new1 = yref1 - T_line(mref1, *gpopt1) @@ -1712,7 +1733,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r rgood_new2 = np.hypot(xgood2, ygood_new2) aref_new2 = angle_from_xy(xref2, yref_new2) % 360 rref_new2 = np.hypot(xref2, yref_new2) - + fig, ax = plt.subplots(4, 2, figsize=(12,12), sharex=True, sharey='row', num=105) plt.subplots_adjust(hspace=0.01, wspace=0.01) ax[0,0].scatter(mgood, ygood, color='black', alpha=0.3, s=2) @@ -1723,7 +1744,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[0,0].plot(marr1, T_line(marr1, *gpopt1), 'b-') ax[0,0].plot(marr2, T_cte_y(marr2, *gpopt2), 'b-') ax[0,0].set_title('No correction') - + ax[0,1].scatter(mgood1, ygood_new1, color='black', alpha=0.3, s=2) ax[0,1].scatter(mref1, yref_new1, color='red', alpha=0.3, s=2) ax[0,1].scatter(mgood2, ygood_new2, color='black', alpha=0.3, s=2) @@ -1731,20 +1752,20 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[0,1].set_ylim(-0.01, 0.01) ax[0,1].axhline(y=0) ax[0,1].set_title('Corrected') - + ax[1,0].scatter(mgood, ygood/yegood, color='black', alpha=0.3, s=2) ax[1,0].scatter(mref, yref/yeref, color='red', alpha=0.3, s=2) ax[1,0].set_ylabel('Res/Pos Err, y') ax[1,0].set_ylim(-10, 10) ax[1,0].axhline(y=0) - + ax[1,1].scatter(mgood1, ygood_new1/yegood1, color='black', alpha=0.3, s=2) ax[1,1].scatter(mref1, yref_new1/yeref1, color='red', alpha=0.3, s=2) ax[1,1].scatter(mgood2, ygood_new2/yegood2, color='black', alpha=0.3, s=2) ax[1,1].scatter(mref2, yref_new2/yeref2, color='red', alpha=0.3, s=2) ax[1,1].set_ylim(-10, 10) ax[1,1].axhline(y=0) - + ax[2,0].scatter(mgood, rgood, color='black', alpha=0.3, s=2) ax[2,0].scatter(mref, rref, color='red', alpha=0.3, s=2) ax[2,0].set_ylabel('Modulus (arcsec)') @@ -1753,7 +1774,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood.data, rref.data]))) else: ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood, rref]))) - + ax[2,1].scatter(mgood1, rgood_new1, color='black', alpha=0.3, s=2) ax[2,1].scatter(mref1, rref_new1, color='red', alpha=0.3, s=2) ax[2,1].scatter(mgood2, rgood_new2, color='black', alpha=0.3, s=2) @@ -1763,18 +1784,18 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new.data2, rref_new.data2]))) else: ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new2, rref_new2]))) - + ax[3,0].scatter(mgood, agood, color='black', alpha=0.3, s=2) ax[3,0].scatter(mref, aref, color='red', alpha=0.3, s=2) ax[3,0].set_ylabel('Angle (deg)') ax[3,0].set_xlabel('mag') - + ax[3,1].scatter(mgood1, agood_new1, color='black', alpha=0.3, s=2) ax[3,1].scatter(mref1, aref_new1, color='red', alpha=0.3, s=2) ax[3,1].scatter(mgood2, agood_new2, color='black', alpha=0.3, s=2) ax[3,1].scatter(mref2, aref_new2, color='red', alpha=0.3, s=2) ax[3,1].set_xlabel('mag') - + def T_cte_y(m, A, m0, alpha, m1): base = m/m0 @@ -1784,16 +1805,16 @@ def T_line(m, a, b): return a + m*b -def plot_quiver_residuals(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, title, - unit='pixel', scale=None, plotlim=None): +def plot_quiver_residuals(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, title, + unit='pixel', scale=None, plotlim=None, save_path=None, show_plot=True): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -1822,52 +1843,57 @@ def plot_quiver_residuals(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, title, unit2 = 'mas' - plt.figure(101, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + q = ax.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], color='black', scale=quiv_scale, angles='xy', alpha=0.5) - plt.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], + ax.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], color='red', scale=quiv_scale, angles='xy') - plt.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, + ax.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, coordinates='figure', labelpos='E', color='green') - plt.xlabel('X (ref ' + unit + ')') - plt.ylabel('Y (ref ' + unit + ')') - plt.title(title) - plt.axis('equal') + ax.set_xlabel('X (ref ' + unit + ')') + ax.set_ylabel('Y (ref ' + unit + ')') + ax.set_title(title) + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) - plt.show() - plt.pause(1) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) + plt.tight_layout() + if save_path: + plt.savefig(save_path, dpi=300) + if show_plot: + plt.show() + else: + plt.close() - str_fmt = 'Residuals (mean, std): dx = {0:7.3f} +/- {1:7.3f} {5:s} dy = {2:7.3f} +/- {3:7.3f} {5:s} for {4:s} stars' + str_fmt = '{0:s}: Residuals (mean, std): dx = {1:7.3f} ± {2:7.3f} {6:s} dy = {3:7.3f} ± {4:7.3f} {6:s} for {5:s} stars' if len(ref_idx) > 1: - print(str_fmt.format(dx[good_idx][ref_idx].mean(), dx[good_idx][ref_idx].std(), + print(str_fmt.format(title, dx[good_idx][ref_idx].mean(), dx[good_idx][ref_idx].std(), dy[good_idx][ref_idx].mean(), dy[good_idx][ref_idx].std(), 'REF', unit2)) else: - print(str_fmt.format(dx[good_idx][ref_idx].mean(), 0.0, + print(str_fmt.format(title, dx[good_idx][ref_idx].mean(), 0.0, dy[good_idx][ref_idx].mean(), 0.0, 'REF', unit2)) - - print(str_fmt.format(dx[good_idx].mean(), dx[good_idx].std(), + + print(str_fmt.format(title, dx[good_idx].mean(), dx[good_idx].std(), dy[good_idx].mean(), dy[good_idx].std(), 'GOOD', unit2)) return (dx, dy) -def plot_quiver_residuals_magcolor_all_epochs(tab, motion_model_dict={}, unit='arcsec', scale=None, plotlim=None, lower_mag=18, upper_mag=13): +def plot_quiver_residuals_magcolor_all_epochs(tab, unit='arcsec', scale=None, plotlim=None, lower_mag=18, upper_mag=13): # Keep track of the residuals for averaging. dr_good = np.zeros(len(tab), dtype=float) n_good = np.zeros(len(tab), dtype=int) dr_ref = np.zeros(len(tab), dtype=float) n_ref = np.zeros(len(tab), dtype=int) - idx = np.where((tab['m0'] < lower_mag) & + idx = np.where((tab['m0'] < lower_mag) & (tab['m0'] > upper_mag))[0] tab = tab[idx] - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + for ee in range(tab['x'].shape[1]): dt = tab['t'][:, ee] - tab['t0'] xt_mod = xt_mod_all[ee] @@ -1877,10 +1903,10 @@ def plot_quiver_residuals_magcolor_all_epochs(tab, motion_model_dict={}, unit='a good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] - dx, dy = plot_quiver_residuals_magcolor(tab['x'][:, ee], tab['y'][:, ee], + dx, dy = plot_quiver_residuals_magcolor(tab['x'][:, ee], tab['y'][:, ee], xt_mod, yt_mod, mag, good_idx, ref_idx, - 'Epoch {0:d}'.format(ee), + 'Epoch {0:d}'.format(ee), unit=unit, scale=scale, plotlim=plotlim) # Building up average dr for a set of stars. @@ -1895,7 +1921,7 @@ def plot_quiver_residuals_magcolor_all_epochs(tab, motion_model_dict={}, unit='a dr_good_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_good > 0)[0] dr_good_avg[idx] = dr_good[idx] / n_good[idx] - + dr_ref_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_ref > 0)[0] dr_ref_avg[idx] = dr_ref[idx] / n_ref[idx] @@ -1905,16 +1931,16 @@ def plot_quiver_residuals_magcolor_all_epochs(tab, motion_model_dict={}, unit='a -def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_idx, title, +def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_idx, title, unit='pixel', scale=None, plotlim=None): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -1942,51 +1968,48 @@ def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_id quiv_label_val = 1.0 unit2 = 'mas' - norm = matplotlib.colors.Normalize() + norm = mcolors.Normalize() norm.autoscale(mag) - cm = matplotlib.cm.viridis - sm = matplotlib.cm.ScalarMappable(cmap=cm, norm=norm) + cmap = matplotlib.colormaps['viridis'] + sm = matplotlib.cm.ScalarMappable(cmap=cmap, norm=norm) # cmap = mpl.cm.cool -# norm = mpl.colors.Normalize(vmin=np.min(mag), vmax=np.max(mag)) -# +# norm = mpl.mcolors.Normalize(vmin=np.min(mag), vmax=np.max(mag)) +# # cb1 = mpl.colorbar.ColorbarBase(ax, cmap=cmap, # norm=norm, # orientation='horizontal') - plt.figure(101, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], + fig, ax=plt.subplots(1, 1, figsize=(6, 6)) + q = ax.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], color=cm(norm(mag[good_idx])), scale=quiv_scale, angles='xy', alpha=0.8) - plt.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, + ax.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, coordinates='figure', labelpos='E', color='green') - plt.colorbar(sm) - plt.xlabel('X (ref ' + unit + ')') - plt.ylabel('Y (ref ' + unit + ')') - plt.title(title + ', Good') - plt.axis('equal') + fig.colorbar(sm, ax=ax) + ax.set_xlabel('X (ref ' + unit + ')') + ax.set_ylabel('Y (ref ' + unit + ')') + ax.set_title(title + ', Good') + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) + plt.tight_layout() plt.show() - plt.pause(1) - plt.figure(102, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], + fig, ax = plt.subplots(1, 1, figsize=(6,6)) + q = ax.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], color=cm(norm(mag[good_idx][ref_idx])), scale=quiv_scale, angles='xy', alpha=0.8) - plt.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, + ax.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, coordinates='figure', labelpos='E', color='green') - plt.colorbar(sm) - plt.xlabel('X (ref ' + unit + ')') - plt.ylabel('Y (ref ' + unit + ')') - plt.title(title + ', Ref') - plt.axis('equal') + fig.colorbar(sm, ax=ax) + ax.set_xlabel('X (ref ' + unit + ')') + ax.set_ylabel('Y (ref ' + unit + ')') + ax.set_title(title + ', Ref') + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) plt.show() - plt.pause(1) str_fmt = 'Residuals (mean, std): dx = {0:7.3f} +/- {1:7.3f} {5:s} dy = {2:7.3f} +/- {3:7.3f} {5:s} for {4:s} stars' if len(ref_idx) > 1: @@ -1995,7 +2018,7 @@ def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_id else: print(str_fmt.format(dx[good_idx][ref_idx].mean(), 0.0, dy[good_idx][ref_idx].mean(), 0.0, 'REF', unit2)) - + print(str_fmt.format(dx[good_idx].mean(), dx[good_idx].std(), dy[good_idx].mean(), dy[good_idx].std(), 'GOOD', unit2)) @@ -2003,17 +2026,17 @@ def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_id return (dx, dy) -def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, - x_orig, y_orig, da, title, - scale=None, plotlim=None): +def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, + x_orig, y_orig, da, title, + scale=None, plotlim=None, save_path=None): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -2028,8 +2051,8 @@ def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, dy /= 0.04 # Residual modulus - r_good = np.hypot(dx[good_idx], dy[good_idx]) - r_ref = np.hypot(dx[good_idx][ref_idx], dy[good_idx][ref_idx]) + # r_good = np.hypot(dx[good_idx], dy[good_idx]) + # r_ref = np.hypot(dx[good_idx][ref_idx], dy[good_idx][ref_idx]) # Residual angle agood = angle_from_xy(dx[good_idx], dy[good_idx]) @@ -2045,21 +2068,23 @@ def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, dx_ref_new, dy_ref_new = rotate(dx[good_idx][ref_idx], dy[good_idx][ref_idx], -da) print('Rotation angle between HST and Gaia (deg): ', da) - plt.figure(102, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_orig[good_idx], y_orig[good_idx], dx_good_new, dy_good_new, + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + q = ax.quiver(x_orig[good_idx], y_orig[good_idx], dx_good_new, dy_good_new, color='black', scale=scale, angles='xy', alpha=0.5) - plt.quiver(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], dx_ref_new, dy_ref_new, + ax.quiver(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], dx_ref_new, dy_ref_new, color='red', scale=scale, angles='xy') - plt.quiverkey(q, 0.5, 0.85, 0.3, '0.3 pix', + ax.quiverkey(q, 0.5, 0.85, 0.3, '0.3 pix', coordinates='figure', labelpos='E', color='green') - plt.xlabel('X (ref pix)') - plt.ylabel('Y (ref pix)') - plt.title(title) - plt.axis('equal') + ax.set_xlabel('X (ref pix)') + ax.set_ylabel('Y (ref pix)') + ax.set_title(title) + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) + plt.tight_layout() + if save_path: + plt.savefig(save_path, dpi=300) plt.show() plt.pause(1) @@ -2073,11 +2098,11 @@ def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, # ax1.hist(aref ,color='red', histtype = 'step', # alpha=0.8, bins = 36, density=True) # ax1.set_xlabel('Quiver angle (degrees), HST camera') -# -# ax2.scatter(x_orig[good_idx], y_orig[good_idx], +# +# ax2.scatter(x_orig[good_idx], y_orig[good_idx], # s=5e3 * r_good**2, alpha=0.3, color='black') -# ax2.scatter(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], -# s=5e3 * r_ref**2, alpha=0.5, color='red') +# ax2.scatter(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], +# s=5e3 * r_ref**2, alpha=0.5, color='red') # ax2.set_xlabel('X (orig pix)') # ax2.set_ylabel('Y (orig pix)') # plt.title(title) @@ -2103,16 +2128,16 @@ def rotate(x, y, theta): return xnew, ynew -def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, +def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, x_orig, y_orig, da, title, scale=None, plotlim=None): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -2120,7 +2145,7 @@ def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_id """ dx = (x_t - x_ref) dy = (y_t - y_ref) - + # Residual modulus r_good = np.hypot(dx[good_idx], dy[good_idx]) r_ref = np.hypot(dx[good_idx][ref_idx], dy[good_idx][ref_idx]) @@ -2164,7 +2189,7 @@ def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_id return -def plot_chi2_dist(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, boot_err=False): +def plot_chi2_dist(tab, Ndetect, xlim=40, n_bins=50, boot_err=False): """ tab = flystar table Ndetect = Number of epochs star detected in @@ -2172,16 +2197,17 @@ def plot_chi2_dist(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, boot_ chi2_x_list = [] chi2_y_list = [] fnd_list = [] # Number of non-NaN error measurements - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) for ii in range(len(tab)): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) fnd_list.append(len(fnd)) - + x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] if boot_err: @@ -2198,7 +2224,7 @@ def plot_chi2_dist(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, boot_ diffY = y - fitLineY sigX = diffX / xerr sigY = diffY / yerr - + chi2_x = np.sum(sigX**2) chi2_y = np.sum(sigY**2) chi2_x_list.append(chi2_x) @@ -2207,7 +2233,7 @@ def plot_chi2_dist(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, boot_ x = np.array(chi2_x_list) y = np.array(chi2_y_list) fnd = np.array(fnd_list) - + idx = np.where(fnd == Ndetect)[0] # Fitting position and velocity... so subtract 2 to get Ndof n_params = np.nanmean(tab['n_params'][idx]) @@ -2226,7 +2252,7 @@ def plot_chi2_dist(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, boot_ plt.hist(x[idx], bins=chi2_bins, histtype='step', label='X', density=True) plt.hist(y[idx], bins=chi2_bins, histtype='step', label='Y', density=True) plt.plot(chi2_xaxis, chi2.pdf(chi2_xaxis, Ndof), 'r-', alpha=0.6, - label='$\chi^2$ ' + str(round(Ndof,2)) + ' dof') + label=r'$\chi^2$ ' + str(round(Ndof,2)) + ' dof') plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(round(Ndof,2))) plt.xlim(0, xlim) plt.legend() @@ -2234,7 +2260,7 @@ def plot_chi2_dist(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, boot_ chi2red_x = x / Ndof chi2red_y = y / Ndof chi2red_t = (x + y) / (2.0 * Ndof) - + print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' med_chi2red_x_f = np.median(chi2red_x[idx]) @@ -2249,7 +2275,7 @@ def plot_chi2_dist(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, boot_ return -def plot_chi2_reduced_dist(tab, Ndetect, motion_model_dict={}, xlim=8, n_bins=50, boot_err=False): +def plot_chi2_reduced_dist(tab, Ndetect, xlim=8, n_bins=50, boot_err=False): """ tab = flystar table Ndetect = Number of epochs star detected in @@ -2257,16 +2283,17 @@ def plot_chi2_reduced_dist(tab, Ndetect, motion_model_dict={}, xlim=8, n_bins=50 chi2_x_list = [] chi2_y_list = [] fnd_list = [] # Number of non-NaN error measurements - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) for ii in range(len(tab)): # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) fnd_list.append(len(fnd)) - + x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] if boot_err: @@ -2283,7 +2310,7 @@ def plot_chi2_reduced_dist(tab, Ndetect, motion_model_dict={}, xlim=8, n_bins=50 diffY = y - fitLineY sigX = diffX / xerr sigY = diffY / yerr - + chi2_x = np.sum(sigX**2) chi2_y = np.sum(sigY**2) chi2_x_list.append(chi2_x) @@ -2292,7 +2319,7 @@ def plot_chi2_reduced_dist(tab, Ndetect, motion_model_dict={}, xlim=8, n_bins=50 x = np.array(chi2_x_list) y = np.array(chi2_y_list) fnd = np.array(fnd_list) - + idx = np.where(fnd == Ndetect)[0] n_params = tab['n_params'] Ndof = Ndetect - n_params @@ -2312,7 +2339,7 @@ def plot_chi2_reduced_dist(tab, Ndetect, motion_model_dict={}, xlim=8, n_bins=50 chi2red_x = x / Ndof chi2red_y = y / Ndof chi2red_t = (x + y) / (2.0 * Ndof + 1*(tab['motion_model_used']=='Parallax')) - + print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' med_chi2red_x_f = np.median(chi2red_x[idx]) @@ -2328,7 +2355,7 @@ def plot_chi2_reduced_dist(tab, Ndetect, motion_model_dict={}, xlim=8, n_bins=50 return -def plot_chi2_dist_per_filter(tab, Ndetect, motion_model_dict={}, xlim=40, n_bins=50, filter=None, boot_err=False): +def plot_chi2_dist_per_filter(tab, Ndetect, xlim=40, n_bins=50, filter=None, boot_err=False): """ tab = flystar table Ndetect = Number of epochs star detected in @@ -2336,16 +2363,17 @@ def plot_chi2_dist_per_filter(tab, Ndetect, motion_model_dict={}, xlim=40, n_bin chi2_x_list = [] chi2_y_list = [] fnd_list = [] # Number of non-NaN error measurements - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) for ii in range(len(tab)): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) fnd_list.append(len(fnd)) - + x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] if boot_err: @@ -2362,7 +2390,7 @@ def plot_chi2_dist_per_filter(tab, Ndetect, motion_model_dict={}, xlim=40, n_bin diffY = y - fitLineY sigX = diffX / xerr sigY = diffY / yerr - + chi2_x = np.sum(sigX**2) chi2_y = np.sum(sigY**2) chi2_x_list.append(chi2_x) @@ -2373,8 +2401,8 @@ def plot_chi2_dist_per_filter(tab, Ndetect, motion_model_dict={}, xlim=40, n_bin x = np.array(chi2_x_list) y = np.array(chi2_y_list) fnd = np.array(fnd_list) - - + + idx = np.where(fnd == Ndetect)[0] # Fitting position and velocity... so subtract n_params to get Ndof n_params = np.nanmean(tab['n_params'][idx]) @@ -2390,7 +2418,7 @@ def plot_chi2_dist_per_filter(tab, Ndetect, motion_model_dict={}, xlim=40, n_bin plt.hist(x[idx], bins=chi2_bins, histtype='stepfilled', label='RA', density=True, color='skyblue', alpha=0.8, edgecolor='k') plt.hist(y[idx], bins=chi2_bins, histtype='stepfilled', label='DEC', density=True, color='orange', alpha=0.8, edgecolor='k') plt.plot(chi2_xaxis, chi2.pdf(chi2_xaxis, Ndof), 'r-', alpha=0.6, - label='$\chi^2$ ' + str(Ndof) + ' dof') + label=r'$\chi^2$ ' + str(Ndof) + ' dof') #plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(Ndof)) plt.title(str(filter)+' (N = '+str(len(chi2_x_list))+')', fontsize=22) plt.xlim(0, xlim) @@ -2399,12 +2427,12 @@ def plot_chi2_dist_per_filter(tab, Ndetect, motion_model_dict={}, xlim=40, n_bin plt.tick_params(labelsize=20, direction='in', right=True, top=True) - plt.savefig(str(filter)+'_chi2_dist.png', dpi=400) + plt.savefig(str(filter)+'_chi2_dist.png', dpi=300) chi2red_x = x / Ndof chi2red_y = y / Ndof chi2red_t = (x + y) / (2.0 * Ndof) - + print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' med_chi2red_x_f = np.median(chi2red_x[idx]) @@ -2420,7 +2448,7 @@ def plot_chi2_dist_per_filter(tab, Ndetect, motion_model_dict={}, xlim=40, n_bin return -def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14,21], ylim = [-1, 1], target_idx = 0, motion_model_dict={}, boot_err=False): +def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14, 21], ylim=[-1, 1], target_idx=0, boot_err=False): """ tab = flystar table Ndetect = Number of epochs star detected in @@ -2432,15 +2460,16 @@ def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14,21], ylim = [-1, 1], target_ sigX_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) sigY_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) m_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + for ii in range(len(tab['xe'])): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) - if len(fnd) == Ndetect and tab['use_in_trans'][ii]: + if len(fnd) == Ndetect and tab['use_in_trans'][ii]: time = tab['t'][ii, fnd] x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] @@ -2455,7 +2484,7 @@ def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14,21], ylim = [-1, 1], target_ fitLineX = xt_mod_all[ii, fnd] fitLineY = yt_mod_all[ii, fnd] - + diffX = x - fitLineX diffY = y - fitLineY sigX = diffX / xerr @@ -2464,7 +2493,7 @@ def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14,21], ylim = [-1, 1], target_ diffX_arr[ii] = diffX.reshape(Ndetect,) diffY_arr[ii] = diffY.reshape(Ndetect,) errX_arr[ii] = xerr.reshape(Ndetect,) - errY_arr[ii] = yerr.reshape(Ndetect,) + errY_arr[ii] = yerr.reshape(Ndetect,) sigX_arr[ii] = sigX.reshape(Ndetect,) sigY_arr[ii] = sigY.reshape(Ndetect,) m_arr[ii] = m.reshape(Ndetect,) @@ -2497,14 +2526,14 @@ def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14,21], ylim = [-1, 1], target_ ax2.legend() #print(errX_arr[:, ii]) - ax3.errorbar(m_arr[:, ii], diffX_arr[:, ii]*1E3, yerr=errX_arr[:, ii]*1E3, + ax3.errorbar(m_arr[:, ii], diffX_arr[:, ii]*1E3, yerr=errX_arr[:, ii]*1E3, marker='s', label = 'X', ls='none', color='tab:blue', alpha=0.4, ms=5) - ax3.errorbar(m_arr[:, ii], diffY_arr[:, ii]*1E3, yerr=errY_arr[:, ii]*1E3, + ax3.errorbar(m_arr[:, ii], diffY_arr[:, ii]*1E3, yerr=errY_arr[:, ii]*1E3, marker='o', label = 'Y', ls='none', color='tab:orange', alpha=0.4, ms=5) if target_idx is not None: - ax3.errorbar(m_arr[target_idx, ii], diffX_arr[target_idx, ii]*1E3, yerr=errX_arr[target_idx, ii]*1E3, + ax3.errorbar(m_arr[target_idx, ii], diffX_arr[target_idx, ii]*1E3, yerr=errX_arr[target_idx, ii]*1E3, marker='s', ls='none', color='black', ms=5) - ax3.errorbar(m_arr[target_idx, ii], diffY_arr[target_idx, ii]*1E3, yerr=errY_arr[target_idx, ii]*1E3, + ax3.errorbar(m_arr[target_idx, ii], diffY_arr[target_idx, ii]*1E3, yerr=errY_arr[target_idx, ii]*1E3, marker='o', ls='none', color='black', ms=5) ax3.set_xlim(mlim[0], mlim[1]) ax3.set_ylim(ylim[0], ylim[1]) @@ -2515,7 +2544,7 @@ def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14,21], ylim = [-1, 1], target_ ax3.set_ylabel('residual (mas)') return - + # TODO: update for motion model def plot_chi2_ecliptic_per_epoch(tab, Ndetect,ra,dec, mlim=[14,21], ylim = [-1, 1], target_idx = 0): """ @@ -2529,7 +2558,7 @@ def plot_chi2_ecliptic_per_epoch(tab, Ndetect,ra,dec, mlim=[14,21], ylim = [-1, sigX_arr = -99 * np.ones((len(tab['xe']), Ndetect)) sigY_arr = -99 * np.ones((len(tab['xe']), Ndetect)) m_arr = -99 * np.ones((len(tab['xe']), Ndetect)) - + rad_to_as = 180/np.pi * 60 * 60 deg_to_as = 60 * 60 def eq_to_ec(ra,dec): @@ -2570,7 +2599,7 @@ def eq_to_ec(ra,dec): dt = tab['t'][ii, fnd] - tab['t0'][ii] fitLineX = lambda_pm fitLineY = beta_pm - + diffX = lambda_obs - fitLineX diffY = beta_obs - fitLineY sigX = diffX / xerr @@ -2645,10 +2674,10 @@ def plot_chi2_dist_mag(tab, Ndetect, xlim=40, n_bins=30, boot_err=False): fnd_list = [] # Number of non-NaN error measurements for ii in range(len(tab['me'])): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['me'][ii,:])) fnd_list.append(len(fnd)) - + m = tab['m'][ii, fnd] if boot_err: merr = np.hypot(tab['me_boot'][ii, fnd], tab['me'][ii, fnd]) @@ -2659,7 +2688,7 @@ def plot_chi2_dist_mag(tab, Ndetect, xlim=40, n_bins=30, boot_err=False): diff_m = m0 - m sig_m = diff_m/merr - + chi2_m = np.sum(sig_m**2) chi2_m_list.append(chi2_m) @@ -2676,8 +2705,8 @@ def plot_chi2_dist_mag(tab, Ndetect, xlim=40, n_bins=30, boot_err=False): plt.figure(figsize=(6,4)) plt.clf() plt.hist(chi2_m[idx], bins=np.arange(xlim*10), histtype='step', density=True) - plt.plot(chi2_maxis, chi2.pdf(chi2_maxis, Ndof), 'r-', alpha=0.6, - label='$\chi^2$ ' + str(Ndof) + ' dof') + plt.plot(chi2_maxis, chi2.pdf(chi2_maxis, Ndof), 'r-', alpha=0.6, + label=r'$\chi^2$ ' + str(Ndof) + ' dof') plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(Ndof)) plt.xlim(0, xlim) plt.legend() @@ -2685,7 +2714,7 @@ def plot_chi2_dist_mag(tab, Ndetect, xlim=40, n_bins=30, boot_err=False): print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' print(fmt.format('M', np.median(chi2_m[idx] / (fnd[idx] - 2)), np.median(chi2_m / (fnd - 2)))) - + return def plot_chi2_dist_mag_per_filter(tab, Ndetect, mlim=40, n_bins=30, xlim=40, file_name=None, filter=None): @@ -2697,10 +2726,10 @@ def plot_chi2_dist_mag_per_filter(tab, Ndetect, mlim=40, n_bins=30, xlim=40, fil fnd_list = [] # Number of non-NaN error measurements for ii in range(len(tab['me'])): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['me'][ii,:])) fnd_list.append(len(fnd)) - + m = tab['m'][ii, fnd] merr = tab['me'][ii, fnd] m0 = tab['m0'][ii] @@ -2708,7 +2737,7 @@ def plot_chi2_dist_mag_per_filter(tab, Ndetect, mlim=40, n_bins=30, xlim=40, fil diff_m = m0 - m sig_m = diff_m/merr - + chi2_m = np.sum(sig_m**2) chi2_m_list.append(chi2_m) @@ -2725,8 +2754,8 @@ def plot_chi2_dist_mag_per_filter(tab, Ndetect, mlim=40, n_bins=30, xlim=40, fil plt.figure(figsize=(6,4)) plt.clf() plt.hist(chi2_m[idx], bins=np.arange(xlim*10), label='mag', histtype='stepfilled', density=True, color='green', alpha=0.7, edgecolor='k') - plt.plot(chi2_maxis, chi2.pdf(chi2_maxis, Ndof), 'r-', alpha=0.6, - label='$\chi^2$ ' + str(Ndof) + ' dof') + plt.plot(chi2_maxis, chi2.pdf(chi2_maxis, Ndof), 'r-', alpha=0.6, + label=r'$\chi^2$ ' + str(Ndof) + ' dof') #plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(Ndof)) plt.xlim(0, xlim) plt.xlabel(r'$\chi^{2}$', fontsize=28) @@ -2735,28 +2764,28 @@ def plot_chi2_dist_mag_per_filter(tab, Ndetect, mlim=40, n_bins=30, xlim=40, fil plt.tick_params(labelsize=20, direction='in', right=True, top=True) - plt.savefig(str(filter)+'_chi2_dist_mag.png', dpi=400) + plt.savefig(str(filter)+'_chi2_dist_mag.png', dpi=300) print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' print(fmt.format('M', np.median(chi2_m[idx] / (fnd[idx] - 2)), np.median(chi2_m / (fnd - 2)))) - + return -def plot_stars(tab, star_names, motion_model_dict={}, NcolMax=2, epoch_array = None, figsize=(15,25), color_time=False, boot_err=False): +def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), color_time=False, boot_err=False): """ - Plot a set of stars positions, flux and residuals over time. + Plot a set of stars positions, flux and residuals over time. epoch_array : None, array Array of the epoch indicies to plot. If None, plots all epochs. """ - + def rs(x): return x.reshape(len(x)) - + print( 'Creating residuals plots for star(s):' ) print( star_names ) - + Nstars = len(star_names) Ncols = 3 * np.min([Nstars, NcolMax]) if Nstars <= Ncols/3: @@ -2771,15 +2800,17 @@ def rs(x): x = tab['x0'] y = tab['y0'] r = np.hypot(x, y) - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] cont_times = np.arange(np.min(tab['t'][i_all_detected]), np.max(tab['t'][i_all_detected]), 0.01) - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.get_star_positions_at_time(cont_times, motion_model_dict, allow_alt_models=True) - + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + # xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.get_star_positions_at_time(cont_times, motion_model_dict, allow_alt_models=True) + xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.infer_positions(cont_times) + for i in range(Nstars): starName = star_names[i] - + try: ii = np.where(tab['name'] == starName)[0][0] except IndexError: @@ -2794,7 +2825,7 @@ def rs(x): fnd = fnd.reshape(len(fnd),1) time = tab['t'][ii, fnd] - dtime = time.data % 1 + dtime = time.data % 1 x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] m = tab['m'][ii, fnd] @@ -2809,7 +2840,7 @@ def rs(x): merr = tab['me'][ii, fnd] dt = tab['t'][ii, fnd] - tab['t0'][ii] - + fitLineX = xt_mod_all[ii, fnd] fitLineY = yt_mod_all[ii, fnd] @@ -2846,14 +2877,14 @@ def rs(x): chi2_red_x = chi2_x / dof chi2_red_y = chi2_y / dof chi2_red_m = chi2_m / dofM - + print( 'Star: ', starName ) - print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_x, chi2_x, dof)) - print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_y, chi2_y, dof)) - print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_m, chi2_m, dofM)) if 'motion_model_used' in tab.keys(): print('\tMotion model:', tab['motion_model_used'][ii]) @@ -2902,7 +2933,7 @@ def rs(x): row = 1 else: col = 1 + 3*(i % (Ncols/3)) - row = 1 + 3*(i//(Ncols/3)) + row = 1 + 3*(i//(Ncols/3)) ind = int((row-1)*Ncols + col) @@ -2918,7 +2949,7 @@ def rs(x): plt.errorbar(rs(time), rs(x), yerr=rs(xerr), fmt='k.') #plt.errorbar(time, x, yerr=xerr, fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, x, xerr, time_color): @@ -2950,7 +2981,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(y), yerr=rs(yerr), fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, y, yerr, time_color): @@ -2980,7 +3011,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(m), yerr=rs(merr), fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, m, merr, time_color): @@ -2996,7 +3027,7 @@ def rs(x): paxes.xaxis.set_major_formatter(fmtX) paxes.yaxis.set_major_formatter(fmtM) paxes.tick_params(axis='both', which='major', labelsize=12) - + ########## # X residuals vs time @@ -3012,7 +3043,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(x - fitLineX)*1e3, yerr=rs(xerr)*1e3, fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (x - fitLineX)*1e3, xerr*1e3, time_color): @@ -3040,7 +3071,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(y - fitLineY)*1e3, yerr=rs(yerr)*1e3, fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (y - fitLineY)*1e3, yerr*1e3, time_color): @@ -3068,7 +3099,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(m - fitLineM), yerr=rs(merr), fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (m - fitLineM), merr, time_color): @@ -3099,7 +3130,7 @@ def rs(x): sc = plt.scatter(x, y, s=0, c=dtime, vmin=0, vmax=1, cmap='hsv') clb = plt.colorbar(sc) clb.ax.tick_params(labelsize=fontsize1) - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, eexx, eeyy, color in zip(x, y, xerr, yerr, time_color): @@ -3112,7 +3143,7 @@ def rs(x): plt.xlabel('X (asec)', fontsize=fontsize1) plt.ylabel('Y (asec)', fontsize=fontsize1) plt.plot(xt_cont_all[ii], yt_cont_all[ii], 'b-') - + ########## # X, Y Histogram of Residuals ########## @@ -3122,7 +3153,7 @@ def rs(x): bins = np.arange(-7.5, 7.5, 1) paxes = plt.subplot(Nrows, Ncols, ind) id = np.where(diffY < 0)[0] - sig[id] = -1.*sig[id] + sig[id] = -1.*sig[id] (n, b, p) = plt.hist(sigX, bins, histtype='stepfilled', color='b', label='X') plt.setp(p, 'facecolor', 'b') (n, b, p) = plt.hist(sigY, bins, histtype='step', color='r', label='Y') @@ -3148,24 +3179,24 @@ def rs(x): plt.xlabel('Residuals (sigma)', fontsize=fontsize1) plt.ylabel('Number of Epochs', fontsize=fontsize1) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + if Nstars == 1: - plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) - # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png') + plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) + # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png', dpi=300) else: plt.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) - # plt.savefig(rootDir+'plots/plotStar_all.png') + # plt.savefig(rootDir+'plots/plotStar_all.png', dpi=300) plt.show() plt.show() return -def plot_stars_nfilt(tab, star_names, motion_model_dict={}, NcolMax=2, epoch_array_list = None, color_list = None, +def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_list = None, figsize=(15,25), color_time=False, resTicRng=None, save_name=None, boot_err=False): """ - Plot a set of stars positions, flux and residuals over time. + Plot a set of stars positions, flux and residuals over time. epoch_array : None, array Array of the epoch indicies to plot. If None, plots all epochs. @@ -3177,11 +3208,12 @@ def plot_stars_nfilt(tab, star_names, motion_model_dict={}, NcolMax=2, epoch_arr print( star_names ) def rs(x): return x.reshape(len(x)) - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + Nstars = len(star_names) Ncols = 3 * np.min([Nstars, NcolMax]) if Nstars <= Ncols/3: @@ -3196,36 +3228,38 @@ def rs(x): x = tab['x0'] y = tab['y0'] r = np.hypot(x, y) - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] cont_times = np.arange(np.min(tab['t'][i_all_detected]), np.max(tab['t'][i_all_detected]), 0.01) - xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) - xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.get_star_positions_at_time(cont_times, motion_model_dict, allow_alt_models=True) - + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + # xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.get_star_positions_at_time(cont_times, motion_model_dict, allow_alt_models=True) + xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.infer_positions(cont_times) + for i in range(Nstars): for ea, epoch_array in enumerate(epoch_array_list): color=color_list[ea] starName = star_names[i] - + try: ii = np.where(tab['name'] == starName)[0][0] except IndexError: print("!! %s is not in this list"%starName) continue - + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) - + if epoch_array is not None: fnd = np.intersect1d(fnd, epoch_array) fnd = fnd.reshape(len(fnd),1) - + time = tab['t'][ii, fnd] - dtime = time.data % 1 + dtime = time.data % 1 x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] m = tab['m'][ii, fnd] - + if boot_err: xerr = np.hypot(tab['xe'][ii, fnd], tab['xe_boot'][ii, fnd]) yerr = np.hypot(tab['ye'][ii, fnd], tab['ye_boot'][ii, fnd]) @@ -3234,16 +3268,16 @@ def rs(x): xerr = tab['xe'][ii, fnd] yerr = tab['ye'][ii, fnd] merr = tab['me'][ii, fnd] - + fitLineX = xt_mod_all[ii, fnd] fitLineY = yt_mod_all[ii, fnd] - + fitSigX = xt_mod_err[ii, fnd] fitSigY = yt_mod_err[ii, fnd] - + fitLineM = np.repeat(tab['m0'][ii], len(time)).reshape(len(time),1) fitSigM = np.repeat(tab['m0_err'][ii], len(time)).reshape(len(time),1) - + diffX = x - fitLineX diffY = y - fitLineY diffM = m - fitLineM @@ -3253,42 +3287,42 @@ def rs(x): sigY = diffY / yerr sigM = diffM / merr sig = diff / rerr - + # Determine if there are points that are more than 4 sigma off idxX = np.where(abs(sigX) > 4) idxY = np.where(abs(sigY) > 4) idxM = np.where(abs(sigM) > 4) idx = np.where(abs(sig) > 4) - + # Calculate chi^2 metrics chi2_x = np.sum(sigX**2) chi2_y = np.sum(sigY**2) chi2_m = np.sum(sigM**2) - + dof = len(x) - 2 dofM = len(m) - 1 - + chi2_red_x = chi2_x / dof chi2_red_y = chi2_y / dof chi2_red_m = chi2_m / dofM - - + + print( 'Star: ', starName ) - print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_x, chi2_x, dof)) - print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_y, chi2_y, dof)) - print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_m, chi2_m, dofM)) - + tmin = time.min() tmax = time.max() - + dateTicLoc = plt.MultipleLocator(3) dateTicRng = [np.floor(tmin), np.ceil(tmax)] dateTics = np.arange(np.floor(tmin), np.ceil(tmax)+0.1) DateTicsLabel = dateTics - + # See if we are using MJD instead. if time[0] > 50000: print('MJD') @@ -3298,12 +3332,12 @@ def rs(x): dateTicRng = [tmin-200, tmax+200] dateTics = np.arange(dateTicRng[0], dateTicRng[-1]+500, 1000) DateTicsLabel = dateTics - - + + maxErr = np.array([(diffX-xerr)*1e3, (diffX+xerr)*1e3, (diffY-yerr)*1e3, (diffY+yerr)*1e3]).max() maxErrM = np.array([(diffM - merr), (diffM + merr)]).max() - + if maxErr > 2: maxErr = 2.0 if maxErrM > 1.0: @@ -3311,13 +3345,13 @@ def rs(x): if resTicRng == None: resTicRng = [-1.1*maxErr, 1.1*maxErr] resTicRngM = [-1.1*maxErrM, 1.1*maxErrM] - + from matplotlib.ticker import FormatStrFormatter fmtX = FormatStrFormatter('%5i') fmtY = FormatStrFormatter('%6.3f') fmtM = FormatStrFormatter('%5.2f') fontsize1 = 10 - + ########## # X vs time ########## @@ -3326,10 +3360,10 @@ def rs(x): row = 1 else: col = 1 + 3*(i % (Ncols/3)) - row = 1 + 3*(i//(Ncols/3)) - + row = 1 + 3*(i//(Ncols/3)) + ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(cont_times, xt_cont_all[ii], 'b-') plt.plot(cont_times, xt_cont_all[ii] + xt_cont_err[ii], 'b--') @@ -3338,7 +3372,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(x), yerr=rs(xerr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, x, xerr, time_color): @@ -3355,14 +3389,14 @@ def rs(x): paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) plt.annotate(starName, xy=(1.0,1.1), xycoords='axes fraction', fontsize=12, color='red') - - + + ########## # Y vs time ########## col = col + 1 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(cont_times, yt_cont_all[ii], 'b-') plt.plot(cont_times, yt_cont_all[ii] + yt_cont_err[ii], 'b--') @@ -3370,7 +3404,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(y), yerr=rs(yerr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, y, yerr, time_color): @@ -3386,13 +3420,13 @@ def rs(x): paxes.xaxis.set_major_formatter(fmtX) paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # M vs time ########## col = col + 1 ind = int((row - 1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, fitLineM, 'g-') plt.plot(time, fitLineM + fitSigM, 'g--') @@ -3400,7 +3434,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(m), yerr=rs(merr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, m, merr, time_color): @@ -3416,15 +3450,15 @@ def rs(x): paxes.xaxis.set_major_formatter(fmtX) paxes.yaxis.set_major_formatter(fmtM) paxes.tick_params(axis='both', which='major', labelsize=12) - - + + ########## # X residuals vs time ########## row = row + 1 col = col - 2 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'b-') plt.plot(cont_times, xt_cont_err[ii]*1e3, 'b--') @@ -3432,7 +3466,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(x - fitLineX)*1e3, yerr=rs(xerr)*1e3, marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (x - fitLineX)*1e3, xerr*1e3, time_color): @@ -3446,13 +3480,13 @@ def rs(x): plt.ylabel('X Residuals (mas)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # Y residuals vs time ########## col = col + 1 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'b-') plt.plot(cont_times, yt_cont_err[ii]*1e3, 'b--') @@ -3460,7 +3494,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(y - fitLineY)*1e3, yerr=rs(yerr)*1e3, marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (y - fitLineY)*1e3, yerr*1e3, time_color): @@ -3474,13 +3508,13 @@ def rs(x): plt.ylabel('Y Residuals (mas)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # M residuals vs time ########## col = col + 1 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'g-') plt.plot(time, fitSigM*1e3, 'g--') @@ -3488,7 +3522,7 @@ def rs(x): if not color_time: plt.errorbar(rs(time), rs(m - fitLineM), yerr=rs(merr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (m - fitLineM), merr, time_color): @@ -3502,15 +3536,15 @@ def rs(x): plt.ylabel('m Residuals (mag)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - - + + ########## # X vs. Y ########## row = row + 1 col = col - 2 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) if not color_time: plt.errorbar(rs(x),rs(y), xerr=rs(xerr), @@ -3519,7 +3553,7 @@ def rs(x): sc = plt.scatter(x, y, s=0, c=dtime, vmin=0, vmax=1, cmap='hsv') clb = plt.colorbar(sc) clb.ax.tick_params(labelsize=fontsize1) - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, eexx, eeyy, color in zip(x, y, xerr, yerr, time_color): @@ -3531,18 +3565,18 @@ def rs(x): paxes.xaxis.set_major_formatter(FormatStrFormatter('%.3f')) plt.xlabel('X (asec)', fontsize=fontsize1) plt.ylabel('Y (asec)', fontsize=fontsize1) - plt.plot(fitLineX, fitLineY, 'b-') - + plt.plot(fitLineX, fitLineY, 'b-') + ########## # X, Y Histogram of Residuals ########## col = col + 1 ind = int((row-1)*Ncols + col) - + bins = np.arange(-7.5, 7.5, 1) paxes = plt.subplot(Nrows, Ncols, ind) id = np.where(diffY < 0)[0] - sig[id] = -1.*sig[id] + sig[id] = -1.*sig[id] (n, b, p) = plt.hist(sigX, bins, histtype='stepfilled', color='b', label='X') plt.setp(p, 'facecolor', 'b') (n, b, p) = plt.hist(sigY, bins, histtype='step', color='r', label='Y') @@ -3552,13 +3586,13 @@ def rs(x): plt.xlabel('Residuals (sigma)', fontsize=fontsize1) plt.ylabel('Number of Epochs', fontsize=fontsize1) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # M Histogram of Residuals ########## col = col + 1 ind = int((row-1)*Ncols + col) - + bins = np.arange(-7.5, 7.5, 1) paxes = plt.subplot(Nrows, Ncols, ind) (n, b, p) = plt.hist(sigM, bins, histtype='stepfilled', color='g', label='m') @@ -3568,17 +3602,17 @@ def rs(x): plt.xlabel('Residuals (sigma)', fontsize=fontsize1) plt.ylabel('Number of Epochs', fontsize=fontsize1) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + if Nstars == 1: - plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) - # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png') + plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) + # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png', dpi=300) else: plt.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) - # plt.savefig(rootDir+'plots/plotStar_all.png') + # plt.savefig(rootDir+'plots/plotStar_all.png', dpi=300) plt.show() if save_name is not None: - plt.savefig(save_name + '.png') + plt.savefig(save_name + '.png', dpi=300) plt.show() return @@ -3586,9 +3620,9 @@ def rs(x): def plot_errors_vs_r_m(star_tab, vmax_perr=0.75, vmax_pmerr=0.75): """ - Plot the positional errors and the proper motion errors as a function of radius - and magnitude. The positional an proper motion errors will be the mean in the - two axis (as is used in pick_good_ref_stars()). + Plot the positional errors and the proper motion errors as a function of radius + and magnitude. The positional an proper motion errors will be the mean in the + two axis (as is used in pick_good_ref_stars()). """ r = np.hypot(star_tab['x0'], star_tab['y0']) p_err = np.mean((star_tab['x0_err'], star_tab['y0_err']), axis=0) * 1e3 @@ -3597,7 +3631,7 @@ def plot_errors_vs_r_m(star_tab, vmax_perr=0.75, vmax_pmerr=0.75): plt.figure(figsize=(12, 6)) plt.clf() plt.subplots_adjust(wspace=0.4) - + plt.subplot(1, 2, 1) plt.scatter(star_tab['m0'], r, c=p_err, s=8, vmin=0, vmax=vmax_perr) plt.colorbar(label='Pos Err (mas)') @@ -3625,7 +3659,7 @@ def plot_plxs(star_tab, target_idx=0): ax[1].set_xlabel('Plx/Plx_err') plt.tight_layout() ax[0].set_ylim(-5,5) - + def plot_sky(stars_tab, plot_errors=False, center_star=None, range=0.4, xcenter=0, ycenter=0, show_names=False, saveplot=False, @@ -3639,8 +3673,8 @@ def plot_sky(stars_tab, Parameters ---------- stars_tab : flystar.startables.StarTable - The StarTable containining 'x', 'y', 't', 'xe', 'ye', columns etc. - for plotting, where each of these columns is a 2D array of + The StarTable containining 'x', 'y', 't', 'xe', 'ye', columns etc. + for plotting, where each of these columns is a 2D array of [star_index, epoch_index]. @@ -3685,11 +3719,11 @@ def plot_sky(stars_tab, good_t = np.isfinite(stars_tab['t']) epochs = np.unique(stars_tab['t'][good_t]) assert len(epochs) == stars_tab['t'].shape[1] - + yearsInt = np.floor(epochs).astype('int') # Set up a color scheme - cnorm = colors.Normalize(stars_tab['t'][0, :].min(), stars_tab['t'][0, :].max() + 1) + cnorm = mcolors.Normalize(stars_tab['t'][0, :].min(), stars_tab['t'][0, :].max() + 1) cmap = plt.cm.gist_ncar colorList = [] @@ -3697,8 +3731,8 @@ def plot_sky(stars_tab, foo = cnorm(yearsInt[ee]) colorList.append( cmap(cnorm(yearsInt[ee])) ) - py.close(2) - fig = py.figure(2, figsize=(13,10)) + plt.close(2) + fig = plt.figure(2, figsize=(13,10)) previousYear = 0.0 @@ -3736,13 +3770,13 @@ def plot_sky(stars_tab, label = '_nolegend_' if plot_errors: - (line, foo1, foo2) = py.errorbar(x, y, xerr=xe, yerr=ye, + (line, foo1, foo2) = plt.errorbar(x, y, xerr=xe, yerr=ye, color=colorList[ee], fmt='^', markeredgecolor=colorList[ee], markerfacecolor=colorList[ee], label=label, picker=4) else: - (line, foo1, foo2) = py.errorbar(x, y, xerr=None, yerr=None, + (line, foo1, foo2) = plt.errorbar(x, y, xerr=None, yerr=None, color=colorList[ee], fmt='^', markeredgecolor=colorList[ee], markerfacecolor=colorList[ee], @@ -3760,19 +3794,19 @@ def plot_sky(stars_tab, point_labels[line] = points_info foo = PrintSelected(point_labels, fig, stars_tab, mag_range, manual_print=manual_print) - py.connect('pick_event', foo) + plt.connect('pick_event', foo) xlo = xcenter + (range) xhi = xcenter - (range) ylo = ycenter - (range) yhi = ycenter + (range) - py.axis('equal') - py.axis([xlo, xhi, ylo, yhi]) - py.xlabel('R.A. Offset from Sgr A* (arcsec)') - py.ylabel('Dec. Offset from Sgr A* (arcsec)') + plt.axis('equal') + plt.axis([xlo, xhi, ylo, yhi]) + plt.xlabel('R.A. Offset from Sgr A* (arcsec)') + plt.ylabel('Dec. Offset from Sgr A* (arcsec)') - py.legend(handles=epochs_legend, numpoints=1, loc='lower left', fontsize=12) + plt.legend(handles=epochs_legend, numpoints=1, loc='lower left', fontsize=12) if show_names: xpos = stars_tab['x0'] @@ -3780,20 +3814,20 @@ def plot_sky(stars_tab, goodind = np.where((xpos <= xlo) & (xpos >= xhi) & (ypos >= ylo) & (ypos <= yhi))[0] for ind in goodind: - py.text(xpos[ind], ypos[ind], stars_tab['name'][ind], size=10) + plt.text(xpos[ind], ypos[ind], stars_tab['name'][ind], size=10) if saveplot: - py.show(block=0) + plt.show(block=0) if (center_star != None): - py.savefig('plot_sky_' + center_star + '.png') + plt.savefig('plot_sky_' + center_star + '.png', dpi=300) else: - py.savefig('plot_sky.png') + plt.savefig('plot_sky.png', dpi=300) else: - py.show() + plt.show() return - - + + class PrintSelected(object): def __init__(self, points_info, fig, tab, mag_range, manual_print=False): self.points_info = points_info @@ -3861,3 +3895,93 @@ def __call__(self, event): self.fig.canvas.draw() return + + +def plotly_stars(x, y, m=None, star_name=None, marker_size=3, color=None, alpha=0.7, symbol='circle', label='starlist', fig=None, figsize=(700, 700), show=True): + """Plot stars with plotly in interactive html format + + Parameters + ---------- + x : array-like + x positions + y : array-like + y positions + m : array-like, optional + magnitude to be added in hover label, by default None + star_name : array-like, optional + Star names to be added in hover label, by default None + marker_size : int, optional + Size of marker, by default 10 + color : array or str, optional + Color of marker, either a string (e.g., 'red') or rgba array, by default None + alpha : float, optional + Opacity of marker color, by default 0.7 + symbol : str, optional + Marker symbol, by default 'circle' + label : str, optional + Label for the star list, by default 'starlist' + fig : plotly.graph_objects.Figure object, optional + Figure if the stars are to be added to an exisiting plot, by default None + figsize : tuple, optional + Figure size, by default (700, 700) + show : bool, optional + Show figure or not, by default True + + Returns + ------- + fig : plotly.graph_objects.Figure + Figure object + """ + import plotly.graph_objects as go + x = np.asarray(x) + y = np.asarray(y) + hover_template = 'x: %{x:.3f}
y: %{y:.3f}' + + if isinstance(color, str) and color.startswith('C') and color[1:].isdigit(): + color = mcolors.to_rgba(color, alpha=alpha) + color = f'rgba({color[0]*255}, {color[1]*255}, {color[2]*255}, {color[3]:.2f})' + + customdata = [] + if star_name is not None: + hover_template = 'name: %{customdata[0]}
' + hover_template + customdata.append(star_name) + + if m is not None: + m = np.asarray(m) + m_idx = len(customdata) + hover_template += f'
m: %{{customdata[{m_idx}]:.2f}}' + customdata.append(m) + + if customdata: + customdata = np.column_stack(customdata) + hover_template += '' + + fig_data = go.Scattergl( + x=x, + y=y, + mode='markers', + marker=dict( + size=marker_size, + color=color, + symbol=symbol + ), + customdata=customdata, + hovertemplate=hover_template, + name=label + ) + + if fig is None: + fig = go.Figure(data=[fig_data]) + else: + fig.add_trace(fig_data) + + fig.update_layout( + xaxis_title='x', + yaxis_title='y', + xaxis=dict(scaleanchor='y', scaleratio=1), # Ensure equal aspect ratio + width=figsize[0], + height=figsize[1] + ) + if show: + fig.show() + return fig \ No newline at end of file diff --git a/flystar/starlists.py b/flystar/starlists.py index 23df44f..ef8a666 100644 --- a/flystar/starlists.py +++ b/flystar/starlists.py @@ -31,7 +31,7 @@ def restrict_by_name(table1, table2): name1 = table1['name'] name2 = table2['name'] - + Name = np.intersect1d(name1, name2) # trim out stars begin with 'star' idx = [] @@ -67,7 +67,7 @@ def restrict_by_area(table1, area, exclude=False): exclude: boolean (default=False) If true, *exclude* the stars that fall within the given area. If false, then only return stars that fall within the given area - + Output: ------ array of indicies corresponding to stars which are within the designated @@ -76,7 +76,7 @@ def restrict_by_area(table1, area, exclude=False): # Extract star coordinates xpos = table1['x'] ypos = table1['y'] - + # Extract desired coordinate ranges x_range = area[0] y_range = area[1] @@ -89,7 +89,7 @@ def restrict_by_area(table1, area, exclude=False): else: good = np.where( ( (xpos < x_range[0]) | (xpos > x_range[1]) ) & ( (ypos < y_range[0]) | (ypos > y_range[1]) ) ) - + return good[0] def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): @@ -114,7 +114,7 @@ def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): idx_starlist: array of indicies Indicies of the matched stars in the starlist. - + Output: ------- idx_label_f: array of indicies in the label catalog that fulfill the restrict @@ -122,15 +122,15 @@ def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): idx_starlist_f: array of indicies in the starlist that fulfill the restrict condition - - + + label_trim: astropy table label table with only use > 2 stars starlist_trim: astropy table reference table with only stars that correspond to use > 2 stars in the label_mat table. - + """ print( 'Restrict option activated') @@ -151,7 +151,7 @@ def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): print( 'Restrict option activated') print(( 'Keeping {0} of {1} stars'.format(len(idx_restrict), len(label_mat)))) - + return idx_label_f, idx_starlist_f @@ -188,7 +188,7 @@ def read_label(labelFile, prop_to_time=None, flipX=True): If true, multiply the x positions and velocities by -1.0. This is useful when label.dat has +x to the east, while reference starlist has +x to the west. - + #OLD# tref: reference epoch that label.dat is converted to. Output: @@ -196,11 +196,11 @@ def read_label(labelFile, prop_to_time=None, flipX=True): labelFile: astropy.table. containing name, m, x0, y0, x0e, y0e, vx, vy, vxe, vye, t0, use, r0, (if prop_to_time: x, y, xe, ye, t) - + x and y is in arcsec, converted to tref epoch, *(-1) so it increases to west - + vx, vy, vxe, vye is converted to arcsec/yr """ @@ -248,7 +248,7 @@ def read_label(labelFile, prop_to_time=None, flipX=True): t_label['y'].format = '.5f' t_label['xe'].format = '.5f' t_label['ye'].format = '.5f' - + # flip the x axis if flipX is True if flipX == True: t_label['x0'] = t_label['x0'] * (-1.0) @@ -295,7 +295,7 @@ def read_label_accel(labelFile, prop_to_time=None, flipX=True): If true, multiply the x positions and velocities by -1.0. This is useful when label.dat has +x to the east, while reference starlist has +x to the west. - + #OLD# tref: reference epoch that label.dat is converted to. Output: @@ -303,11 +303,11 @@ def read_label_accel(labelFile, prop_to_time=None, flipX=True): labelFile: astropy.table. containing name, m, x0, y0, x0e, y0e, vx, vy, vxe, vye, t0, use, r0, (if prop_to_time: x, y, xe, ye, t) - + x and y is in arcsec, converted to tref epoch, *(-1) so it increases to west - + vx, vy, vxe, vye is converted to arcsec/yr """ @@ -411,21 +411,21 @@ def read_starlist(starlistFile, error=True): col7: corr col8: N_frames col9: ? (left as default) - + error: boolean (default=True) If true, assumes starlist has error columns. This significantly changes the order of the columns. - + Output: ------ starlist astropy table. containing: name, m, x, y, xe, ye, t """ - t_ref = Table.read(starlistFile, format='ascii', delimiter='\s') + t_ref = Table.read(starlistFile, format='ascii', delimiter=r'\s') # Check if this already has column names: cols = t_ref.colnames - + if cols[0] != 'col1': t_ref['name'] = t_ref['name'].astype(str) return t_ref @@ -436,7 +436,7 @@ def read_starlist(starlistFile, error=True): t_ref.rename_column(cols[2], 't') t_ref.rename_column(cols[3], 'x') t_ref.rename_column(cols[4], 'y') - + if error==True: t_ref.rename_column(cols[5], 'xe') t_ref.rename_column(cols[6], 'ye') @@ -449,61 +449,56 @@ def read_starlist(starlistFile, error=True): t_ref.rename_column(cols[6], 'corr') t_ref.rename_column(cols[7], 'N_frames') t_ref.rename_column(cols[8], 'flux') - + return t_ref class StarList(Table): - """ - A StarList is an astropy.Table with star catalog from a single image. - - Required table columns (input as keywords): - ------------------------- - name : 1D numpy.array with shape = N_stars - List of names of the stars in the table. + def __init__(self, *args, **kwargs): + """ + A StarList is an astropy.Table with star catalog from a single image. - x : 1D numpy.array with shape = N_stars - Positions of N_stars in the x dimension. + Required table columns (input as keywords): + ------------------------- + name : 1D numpy.array with shape = N_stars + List of names of the stars in the table. - y : 1D numpy.array with shape = N_stars - Positions of N_stars in the y dimension. + x : 1D numpy.array with shape = N_stars + Positions of N_stars in the x dimension. - m : 1D numpy.array with shape = N_stars - Magnitudes of N_stars. + y : 1D numpy.array with shape = N_stars + Positions of N_stars in the y dimension. - Optional table columns (input as keywords): - ------------------------- - xe : 1D numpy.array with shape = N_stars - Position uncertainties of N_stars in the x dimension. + m : 1D numpy.array with shape = N_stars + Magnitudes of N_stars. - ye : 1D numpy.array with shape = N_stars - Position uncertainties of N_stars in the y dimension. + Optional table columns (input as keywords): + ------------------------- + xe : 1D numpy.array with shape = N_stars + Position uncertainties of N_stars in the x dimension. - me : 1D numpy.array with shape = N_stars - Magnitude uncertainties of N_stars. - - corr : 1D numpy.array with shape = N_stars - Fitting correlation of N_stars. + ye : 1D numpy.array with shape = N_stars + Position uncertainties of N_stars in the y dimension. - Optional table meta data - ------------------------- - list_name : str - Name of the starlist. + me : 1D numpy.array with shape = N_stars + Magnitude uncertainties of N_stars. - list_time : int or float - Time/date of the starlist. + corr : 1D numpy.array with shape = N_stars + Fitting correlation of N_stars. + Optional table meta data + ------------------------- + list_name : str + Name of the starlist. - """ - - def __init__(self, *args, **kwargs): - """ + list_time : int or float + Time/date of the starlist. """ # Check if the required arguments are present arg_req = ('name', 'x', 'y', 'm') found_all_required = True - + for arg_test in arg_req: if arg_test not in kwargs: found_all_required = False @@ -526,6 +521,7 @@ def __init__(self, *args, **kwargs): # Check if the type and size of the arguments are correct. # Name checking: type and shape + kwargs['name'] = np.asarray(kwargs['name']) if (not isinstance(kwargs['name'], np.ndarray)) or ( len(kwargs['name']) != n_stars): err_msg = "The '{0:s}' argument has to be a numpy array " @@ -544,8 +540,8 @@ def __init__(self, *args, **kwargs): raise TypeError(err_msg.format(arg_test)) if kwargs[arg_test].shape != (n_stars,): - err_msg = "The '{0:s}' argument has to have shape = ({1:d},)" - raise TypeError(err_msg.format(arg_test, n_stars)) + err_msg = "The '{0:s}' argument has to have shape = ({1:d},), but has shape = {2}" + raise TypeError(err_msg.format(arg_test, n_stars, kwargs[arg_test].shape)) # We have to have special handling of meta-data meta_tab = ('list_time', 'list_name') @@ -583,7 +579,7 @@ def __init__(self, *args, **kwargs): self.add_column(MaskedColumn(data=kwargs[arg], name=arg)) else: self.add_column(Column(data=kwargs[arg], name=arg)) - + return @classmethod @@ -624,7 +620,7 @@ def from_lis_file(cls, filename, error=True, fvu_file=None): ------ starlists.StarList() object (subclass of Astropy Table). """ - t_ref = Table.read(filename, format='ascii', delimiter='\s') + t_ref = Table.read(filename, format='ascii', delimiter=r'\s') # Check if this already has column names: cols = t_ref.colnames @@ -641,22 +637,22 @@ def from_lis_file(cls, filename, error=True, fvu_file=None): t_ref.rename_column(cols[2], 't') t_ref.rename_column(cols[3], 'x') t_ref.rename_column(cols[4], 'y') - + if error==True: t_ref.rename_column(cols[5], 'xe') t_ref.rename_column(cols[6], 'ye') - t_ref.rename_column(cols[7], 'snr') + t_ref.rename_column(cols[7], 'me') t_ref.rename_column(cols[8], 'corr') t_ref.rename_column(cols[9], 'N_frames') t_ref.rename_column(cols[10], 'flux') else: - t_ref.rename_column(cols[5], 'snr') + t_ref.rename_column(cols[5], 'me') t_ref.rename_column(cols[6], 'corr') t_ref.rename_column(cols[7], 'N_frames') t_ref.rename_column(cols[8], 'flux') - - if ('me' not in cols) and ('snr' in cols) and (error == True): - t_ref['me'] = 1.0 / t_ref['snr'] + + # if ('me' not in cols) and ('snr' in cols) and (error == True): + # t_ref['me'] = 1.0 / t_ref['snr'] if fvu_file is not None: t_fvu = Table.read(fvu_file, format='ascii.no_header') @@ -667,16 +663,16 @@ def from_lis_file(cls, filename, error=True, fvu_file=None): msg = 'Star list and metric list have different lengths.\n' msg += '\t len(stars) = {0:d}\n' msg += '\t len(fvu) = {1:d}\n' - + raise RuntimeError(msg.format(len(t_ref), len(t_fvu))) - - t_ref = astropy.table.hstack([t_ref, t_fvu]) + + t_ref = astropy.table.hstack([t_ref, t_fvu]) return cls.from_table(t_ref) def to_lis_file(self, filename): _out = open(filename, 'w') - + hdr = '{name:13s} {mag:>6s} {year:>8s} ' hdr += '{x:>9s} {y:>9s} {xe:>9s} {ye:>9s} ' hdr += '{snr:>20s} {corr:>6s} {nimg:>8s} {flux:>20s}\n' @@ -684,7 +680,7 @@ def to_lis_file(self, filename): _out.write(hdr.format(name='# name', mag='m', year='t', x='x', y='y', xe='xe', ye='ye', snr='snr', corr='corr', nimg='N_frames', flux='flux')) - + fmt = '{name:13s} {mag:6.3f} {year:8.3f} ' fmt += '{x:9.3f} {y:9.3f} {xe:9.3f} {ye:9.3f} ' @@ -697,10 +693,10 @@ def to_lis_file(self, filename): flux=self['flux'][ss])) _out.close() - + return - - + + @classmethod def from_table(cls, table): """ @@ -709,7 +705,7 @@ def from_table(cls, table): will be added to the new StarList object that is returned. """ starlist = cls(name=table['name'], x=table['x'], y=table['y'], m=table['m'], meta=table.meta) - + for col in table.colnames: if col in ['name', 'x', 'y', 'm']: continue @@ -721,10 +717,10 @@ def from_table(cls, table): def fubar(self): print('This is in StarList') return - + def restrict_by_value(self, **kwargs): """ - Restrict a table to any min/max range of column values. For instance, + Restrict a table to any min/max range of column values. For instance, to restrict to only stars between 10 <= m <= 15, use: starlist.restrict_by_value(m_min=10, m_max=15) @@ -732,31 +728,31 @@ def restrict_by_value(self, **kwargs): where 'm' was the column name. This function acts on self, so the rows are removed - forever. + forever. """ # Loop through all conditions and build up - # an array of indicies of rows to remove. + # an array of indicies of rows to remove. remove_flag = np.zeros(len(self), dtype=bool) - - for kwarg in kwargs: - if kwargs[kwarg] is not None: + + for key, value in kwargs.items(): + if value is not None: # Get the name of the column to act on and # whether the condition is min or max. - kwarg_split = kwarg.split('_') + key_split = key.split('_') + + # Support column names such as x_0. + col = '_'.join(key_split[:-1]) - # Support column names such as x_0. - col = '_'.join(kwarg_split[:-1]) + if key_split[-1] == 'min': + remove_flag = np.logical_or(remove_flag, self[col] <= value) - if kwarg_split[-1] == 'min': - remove_flag = np.logical_or(remove_flag, self[col] <= kwargs[kwarg]) - - if kwarg_split[-1] == 'max': - remove_flag = np.logical_or(remove_flag, self[col] >= kwargs[kwarg]) + if key_split[-1] == 'max': + remove_flag = np.logical_or(remove_flag, self[col] >= value) rem_idx = np.where(remove_flag == True)[0] - + self.remove_rows(rem_idx) - + return def transform_xym(self, trans): @@ -769,7 +765,7 @@ def transform_xym(self, trans): self.transform_xy(trans) self.transform_m(trans) - + return def transform_xy(self, trans): @@ -781,7 +777,7 @@ def transform_xy(self, trans): """ if trans == None: return - + x_T, y_T = trans.evaluate(self['x'], self['y']) self['x'] = x_T self['y'] = y_T @@ -792,7 +788,7 @@ def transform_xy(self, trans): self['ye'] = ye_T return - + def transform_m(self, trans): """ Apply a transformation (instance of flystar.transforms.Transform2D) @@ -802,14 +798,14 @@ def transform_m(self, trans): """ if trans == None: return - + m_T = trans.evaluate_mag(self['m']) self['m'] = m_T if 'me' in self.colnames: me_T = trans.evaluate_magerror(self['m'], self['me']) self['me'] = me_T - + return diff --git a/flystar/startables.py b/flystar/startables.py index d75fca9..367436a 100644 --- a/flystar/startables.py +++ b/flystar/startables.py @@ -1,5 +1,5 @@ from astropy.table import Table, Column, MaskedColumn, hstack -from astropy.stats import sigma_clipping +from astropy.stats import sigma_clip from astropy.time import Time from scipy.optimize import curve_fit from tqdm import tqdm @@ -11,78 +11,75 @@ import copy from flystar import motion_model import pandas as pd - +from flystar.motion_model import Empty, Fixed, Linear +from pandas.api.types import is_string_dtype +from collections.abc import Iterable class StarTable(Table): - """ - A StarTable is an astropy.Table with stars matched from multiple starlists. + def __init__(self, *args, ref_list=0, **kwargs): + """ + A StarTable is an astropy.Table with stars matched from multiple starlists. - Required table columns (input as keywords): - ------------------------- - name : 1D numpy.array with shape = N_stars - List of unique names for each of the stars in the table. + Required table columns (input as keywords): + ------------------------- + name : 1D numpy.array with shape = N_stars + List of unique names for each of the stars in the table. - x : 2D numpy.array with shape = (N_stars, N_lists) - Positions of N_stars in each of N_lists in the x dimension. + x : 2D numpy.array with shape = (N_stars, N_lists) + Positions of N_stars in each of N_lists in the x dimension. - y : 2D numpy.array with shape = (N_stars, N_lists) - Positions of N_stars in each of N_lists in the y dimension. + y : 2D numpy.array with shape = (N_stars, N_lists) + Positions of N_stars in each of N_lists in the y dimension. - m : 2D numpy.array with shape = (N_stars, N_lists) - Magnitudes of N_stars in each of N_lists. + m : 2D numpy.array with shape = (N_stars, N_lists) + Magnitudes of N_stars in each of N_lists. - Optional table columns (input as keywords): - ------------------------- - motion_model : 1D numpy.array with shape = N_stars - string indicating motion model type for each star - - xe : 2D numpy.array with shape = (N_stars, N_lists) - Position uncertainties of N_stars in each of N_lists in the x dimension. + Optional table columns (input as keywords): + ------------------------- + motion_model : 1D numpy.array with shape = N_stars + string indicating motion model type for each star - ye : 2D numpy.array with shape = (N_stars, N_lists) - Position uncertainties of N_stars in each of N_lists in the y dimension. + xe : 2D numpy.array with shape = (N_stars, N_lists) + Position uncertainties of N_stars in each of N_lists in the x dimension. - me : 2D numpy.array with shape = (N_stars, N_lists) - Magnitude uncertainties of N_stars in each of N_lists. + ye : 2D numpy.array with shape = (N_stars, N_lists) + Position uncertainties of N_stars in each of N_lists in the y dimension. - ep_name : 2D numpy.array with shape = (N_stars, N_lists) - Names in each epoch for each of N_stars in each of N_lists. This is - useful for tracking purposes. - - corr : 2D numpy.array with shape = (N_stars, N_lists) - Fitting correlation for each of N_stars in each of N_lists. + me : 2D numpy.array with shape = (N_stars, N_lists) + Magnitude uncertainties of N_stars in each of N_lists. - Optional table meta data - ------------------------- - list_names : list of strings - List of names, one for each of the starlists. + ep_name : 2D numpy.array with shape = (N_stars, N_lists) + Names in each epoch for each of N_stars in each of N_lists. This is + useful for tracking purposes. - list_times : list of integers or floats - List of times/dates for each starlist. + corr : 2D numpy.array with shape = (N_stars, N_lists) + Fitting correlation for each of N_stars in each of N_lists. - ref_list : int - Specify which list is the reference list (if any). + Optional table meta data + ------------------------- + list_names : list of strings + List of names, one for each of the starlists. - Examples - -------------------------- + list_times : list of integers or floats + List of times/dates for each starlist. - t = startables.StarTable(name=name, x=x, y=y, m=m) + ref_list : int + Specify which list is the reference list (if any). - # Access the data: - print(t) - print(t['name'][0:10]) # print the first 10 star names - print(t['x'][0:10, 0]) # print x from the first epoch/list/column for the first 10 stars - """ - def __init__(self, *args, ref_list=0, **kwargs): - """ + Examples + -------------------------- + + t = startables.StarTable(name=name, x=x, y=y, m=m) + + # Access the data: + print(t) + print(t['name'][0:10]) # print the first 10 star names + print(t['x'][0:10, 0]) # print x from the first epoch/list/column for the first 10 stars """ - + # Check if the required arguments are present arg_req = ('name', 'x', 'y', 'm') - - found_all_required = True - for arg_test in arg_req: - if arg_test not in kwargs: - found_all_required = False + + found_all_required = all(arg in kwargs for arg in arg_req) if not found_all_required: if len(args) > 1: # If there are no arguments, it's because the @@ -105,9 +102,9 @@ def __init__(self, *args, ref_list=0, **kwargs): # Check if the type and size of the arguments are correct. # Name checking: type and shape if (not isinstance(kwargs['name'], np.ndarray)) or (len(kwargs['name']) != n_stars): - err_msg = "The '{0:s}' argument has to be a numpy array " - err_msg += "with length = {1:d}" - raise TypeError(err_msg.format('name', n_stars)) + err_msg = f"The 'name' argument has to be a numpy array, not {type(kwargs['name'])};" + err_msg += f"Its length should be {n_stars}, not {len(kwargs['name'])}." + raise TypeError(err_msg) # Check all the 2D arrays. arg_tab = ('x', 'y', 'm', 'xe', 'ye', 'me', 'name_in_list') @@ -115,21 +112,22 @@ def __init__(self, *args, ref_list=0, **kwargs): for arg_test in arg_tab: if arg_test in kwargs: if not isinstance(kwargs[arg_test], np.ndarray): - err_msg = "The '{0:s}' argument has to be a numpy array" - raise TypeError(err_msg.format(arg_test)) + err_msg = f"The '{arg_test}' argument has to be a numpy array, not {type(kwargs[arg_test])}" + raise TypeError(err_msg) if kwargs[arg_test].shape != (n_stars, n_lists): - err_msg = "The '{0:s}' argument has to have shape = ({1:d}, {2:d})" - raise TypeError(err_msg.format(arg_test, n_stars, n_lists)) + err_msg = f"The '{arg_test}' argument has to have shape = ({n_stars}, {n_lists})" + raise TypeError(err_msg) # Check that the reference list is specified. if ref_list not in range(n_lists): - err_msg = "The 'ref_list' argument has to be an integer between 0 and {0:d}" - raise IndexError(err_msg.format(n_lists-1)) + err_msg = f"The 'ref_list' argument has to be an integer between 0 and {n_lists-1}" + raise IndexError(err_msg) # We have to have special handling of meta-data (i.e. info that has # dimensions of n_lists). meta_tab = ('list_times', 'list_names') + meta_tab = ('list_times', 'list_names') meta_type = ((float, int), str) for mm in range(len(meta_tab)): meta_test = meta_tab[mm] @@ -137,13 +135,12 @@ def __init__(self, *args, ref_list=0, **kwargs): if meta_test in kwargs: if len(kwargs[meta_test]) != n_lists: - err_msg = "The '{0:s}' argument has to have length = {1:d}" - raise ValueError(err_msg.format(meta_test, n_lists)) + err_msg = f"The '{meta_test}' argument has to have length = {n_lists}" + raise ValueError(err_msg) if not all(isinstance(tt, meta_type_test) for tt in kwargs[meta_test]): - err_msg = "The '{0:s}' argument has to be a list of {1:s}." - raise TypeError(err_msg.format(meta_test, str(meta_type_test))) - + err_msg = f"The '{meta_test}' argument has to be a list of {str(meta_type_test)}." + raise TypeError(err_msg) ##### # Create the startable ##### @@ -161,7 +158,7 @@ def __init__(self, *args, ref_list=0, **kwargs): del kwargs[meta_arg] for arg in kwargs: - if arg in ['name', 'x', 'y', 'm']: + if arg in ['name', 'x', 'y', 'm', 'list_times', 'list_names']: continue else: self.add_column(Column(data=kwargs[arg], name=arg)) @@ -175,12 +172,12 @@ def __init__(self, *args, ref_list=0, **kwargs): # self['motion_model_input'] = np.repeat(self.default_motion_model, len(self['name'])) return - + def add_starlist(self, **kwargs): """ - Add data from a new list to an existing StarTable. + Add data from a new list to an existing StarTable. Note, you can pass in the data via a StarList object or - via a series of keywords with a 1D array on each. + via a series of keywords with a 1D array on each. In either case, the number of stars must already match the existing number of stars in the StarTable. @@ -216,16 +213,16 @@ def _add_list_data_from_starlist(self, starlist): old_type = self[col_name].info.dtype new_data = np.empty((old_data.shape[0], old_data.shape[1] + 1), dtype=old_type) new_data[:, :-1] = old_data - + # Save the new data array (with both old and new data in it) to the table. - self[col_name] = new_data - + self[col_name] = new_data + if (col_name in starlist.colnames): # Add data if it was input self[col_name][:, -1] = starlist[col_name] else: # Add junk data it if wasn't input self._set_invalid_list_values(col_name, -1) - - + + ########## # Update the table meta-data. Remember that entries are lists not numpy arrays. ########## @@ -234,38 +231,38 @@ def _add_list_data_from_starlist(self, starlist): lis_meta_keys = list(starlist.meta.keys()) # append 's' to the end to pluralize the input starlist. lis_meta_keys_plural = [lis_meta_key + 's' for lis_meta_key in lis_meta_keys] - + for kk in range(len(tab_meta_keys)): tab_key = tab_meta_keys[kk] # Meta table entries with a size that matches the n_lists size are the ones # that need a new value. We have to add something... whatever was passed in or None - if isinstance(self.meta[tab_key], collections.abc.Iterable) and (len(self.meta[tab_key]) == self.meta['n_lists']) and (not isinstance(self.meta[tab_key], str)): + if isinstance(self.meta[tab_key], Iterable) and (len(self.meta[tab_key]) == self.meta['n_lists']) and (not isinstance(self.meta[tab_key], str)): # If we find the key in the starlists' meta argument, then add the new values. # Otherwise, add "None". - idx = np.where(lis_meta_keys_plural == tab_key)[0] - if len(idx) > 0: - lis_key = lis_meta_keys[idx[0]] + idx = lis_meta_keys_plural.index(tab_key) if tab_key in lis_meta_keys_plural else None + if idx is not None: + lis_key = lis_meta_keys[idx] self.meta[tab_key] = np.append(self.meta[tab_key], [starlist.meta[lis_key]]) else: self._append_invalid_meta_values(tab_key) # Update the n_lists meta keyword. self.meta['n_lists'] += 1 - + return - - + + def _add_list_data_from_keywords(self, **kwargs): # # Check if the required arguments are present # arg_req = ('x', 'y', 'm') - + # for arg_test in arg_req: # if arg_test not in kwargs: # err_msg = "Added lists require a '{0:s}' argument" # raise TypeError(err_msg.format(arg_test)) - + # # If we have errors, we need them in both dimensions. # if ('xe' in kwargs) ^ ('ye' in kwargs): # raise TypeError("Added lists with errors require both 'xe' and" + @@ -283,21 +280,21 @@ def _add_list_data_from_keywords(self, **kwargs): old_type = self[col_name].info.dtype new_data = np.empty((old_data.shape[0], old_data.shape[1] + 1), dtype=old_type) new_data[:, :-1] = old_data - + # Save the new data array (with both old and new data in it) to the table. self[col_name] = new_data - + if (col_name in kwargs): # Add data if it was input self[col_name][:, -1] = kwargs[col_name] else: # Add junk data it if wasn't input self._set_invalid_list_values(col_name, -1) - + # Update the table meta-data. Remember that entries are lists not numpy arrays. for key in self.meta.keys(): # Meta table entries with a size that matches the n_lists size are the ones # that need a new value. We have to add something... whatever was passed in or None - if isinstance(self.meta[key], collections.abc.Iterable) and (len(self.meta[key]) == self.meta['n_lists']) and (not isinstance(self.meta[key], str)): + if isinstance(self.meta[key], Iterable) and (len(self.meta[key]) == self.meta['n_lists']) and (not isinstance(self.meta[key], str)): # If we find the key is the passed in meta argument, then add the new values. # Otherwise, add "None". if 'meta' in kwargs: @@ -311,7 +308,7 @@ def _add_list_data_from_keywords(self, **kwargs): # Update the n_lists meta keyword. self.meta['n_lists'] += 1 - + return def _set_invalid_list_values(self, col_name, col_idx): @@ -325,7 +322,7 @@ def _set_invalid_list_values(self, col_name, col_idx): self[col_name][:, col_idx] = np.nan else: self[col_name][:, col_idx] = None - + return def _set_invalid_star_values(self, col_name, row_idx): @@ -339,13 +336,13 @@ def _set_invalid_star_values(self, col_name, row_idx): self[col_name][row_idx] = np.nan else: self[col_name][row_idx] = None - + return - + def _append_invalid_meta_values(self, key): """ - For an existing meta keyword that is a list (already known), - add an invalid value depending on the type. + For an existing meta keyword that is a list (already known), + add an invalid value depending on the type. """ if issubclass(type(self.meta[key][0]), np.integer): self.meta[key] = np.append(self.meta[key], [-1]) @@ -361,11 +358,11 @@ def _append_invalid_meta_values(self, key): warnings.warn(err_msg, UserWarning) return - - + + def get_starlist(self, list_index): """ - Return a StarList object for the specified list_index or epoch. + Return a StarList object for the specified list_index or epoch. Parameters ---------- @@ -385,26 +382,26 @@ def get_starlist(self, list_index): col_req_dict[col_name] = self[col_name] starlist = StarList(**col_req_dict) - + for col_name in self.colnames: if col_name in col_req_names: pass - + if len(self[col_name].data.shape) == 2: # Find the 2D columns starlist[col_name] = self[col_name][:, list_index] else: starlist[col_name] = self[col_name] - + return starlist - def combine_lists_xym(self, weighted_xy=True, weighted_m=True, mask_lists=False, sigma=3): + def combine_lists_xym(self, weighted_xy=True, weighted_m=True, mask_lists=None, sigma=3): """ For x, y and m columns in the table, collapse along the lists direction. For 'x', 'y' this means calculating the average position with outlier rejection. Optionally, weight by the 'xe' and 'ye' individual uncertainties. Optionally, use sigma clipping. - "mask_lists" is a list with the indices of starlists that are + "mask_lists" is a list with the indices of starlists that are excluded from the combination. Also, count the number of times a star is found in starlists. """ @@ -421,15 +418,15 @@ def combine_lists_xym(self, weighted_xy=True, weighted_m=True, mask_lists=False, weights_colm = 'me' else: weights_colm = None - + self.combine_lists('x', weights_col=weights_colx, mask_lists=mask_lists, sigma=sigma) self.combine_lists('y', weights_col=weights_coly, mask_lists=mask_lists, sigma=sigma) self.combine_lists('m', weights_col=weights_colm, mask_lists=mask_lists, sigma=sigma, ismag=True) - + return def combine_lists(self, col_name_in, weights_col=None, mask_val=None, - mask_lists=False, meta_add=True, ismag=False, sigma=3): + mask_lists=None, meta_add=True, ismag=False, sigma=3): """ For the specified column (col_name_in), collapse along the starlists direction and calculated the average value, with outlier rejection. @@ -439,75 +436,78 @@ def combine_lists(self, col_name_in, weights_col=None, mask_val=None, 0e -- the std (with outlier rejection) Masking of NaN values is also performed. - - "mask_lists" is a list with the indices of starlists that are + + "mask_lists" is a list with the indices of starlists that are excluded from the combination. - + A flag can be stored in the metadata to record if the average was weighted or not. """ - # Get the array we are going to combine. Make a copy so we don't mod it. - val_2d = copy.deepcopy( self[col_name_in].data ) + if mask_lists is not None: + # Extract list of indices that we want to keep (i.e. not mask) + mask_lists = np.atleast_1d(mask_lists) + assert mask_lists.dtype == int, "mask_lists needs to be a list of integers." + list_indices = np.array([i for i in np.arange(self[col_name_in].data.shape[1]) if i not in mask_lists]) + else: + # Use all indices + list_indices = np.arange(self[col_name_in].data.shape[1]) + + val_2d = np.ma.masked_invalid(self[col_name_in].data[:, list_indices]) if ismag: # Convert to flux. - val_2d = 10**(-val_2d / 2.5) + val_2d = 10**(-0.4 * val_2d) # Make a mask of invalid (NaN) values and a user-specified invalid value. - val_2d = np.ma.masked_invalid(val_2d) + if mask_val: val_2d = np.ma.masked_values(val_2d, mask_val) - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - val_2d.mask[:, mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') + + # Figure out which ones are outliers. Returns a masked array. + if sigma: + # with warnings.catch_warnings(): + # warnings.filterwarnings('ignore', category=RuntimeWarning) + val_2d_clip = sigma_clip(val_2d, sigma=sigma, maxiters=5, axis=1) + else: + val_2d_clip = val_2d # Decide if we are going to have weights (before we # do the expensive sigma clipping routine). Note that - # if we have only 1 column to average, then we can't do weighting. + # if we have only 1 column to average, then we can't do weighting. if (weights_col and weights_col in self.colnames) and (val_2d.shape[1] > 1): - err_2d = self[weights_col].data - + err_2d = np.ma.masked_invalid(self[weights_col].data[:, list_indices]) + if ismag: # Convert to flux error - err_2d = err_2d * val_2d * np.log(10) / 2.5 - - np.seterr(divide='ignore') - wgt_2d = np.ma.masked_invalid(1.0 / err_2d**2) - np.seterr(divide='warn') - + err_2d = 0.4 * np.log(10) * val_2d * err_2d + + # Unify masks + unified_mask = val_2d_clip.mask | err_2d.mask + val_2d_clip.mask = unified_mask + err_2d.mask = unified_mask + + # Inverse variance weights minimize the propagated uncertainty + wgt_2d = np.ma.masked_invalid(1. / err_2d**2) + + # Calculate the weighted mean and uncertainty + avg = np.ma.average(val_2d_clip, weights=wgt_2d, axis=1) + std = np.ma.sqrt(1 / np.ma.sum(wgt_2d, axis=1)) # Error propagation for weighted mean + if meta_add: self.meta[col_name_in + '0'] = 'weighted' else: wgt_2d = None + # Calculate the weighted mean and uncertainty + avg = np.ma.mean(val_2d_clip, axis=1) + std = np.ma.std(val_2d_clip, axis=1) / np.sqrt(len(list_indices)) # Standard error of the mean + if meta_add: self.meta[col_name_in + '0'] = 'not_weighted' - # Figure out which ones are outliers. Returns a masked array. - if sigma: - warnings.filterwarnings('ignore', category=RuntimeWarning) - val_2d_clip = sigma_clipping.sigma_clip(val_2d, sigma=sigma, maxiters=5, axis=1) - warnings.filterwarnings('default', category=RuntimeWarning) - else: - val_2d_clip = val_2d - - # Calculate the (weighted) mean and standard deviation along - # the N_lists direction (axis=1). - if wgt_2d is not None: - avg = np.ma.average(val_2d_clip, weights=wgt_2d, axis=1) - std = np.sqrt(np.ma.average((val_2d_clip.T - avg).T**2, weights=wgt_2d, axis=1)) - else: - avg = np.ma.mean(val_2d_clip, axis=1) - std = np.ma.std(val_2d_clip, axis=1) + # FIXME: What does this part do? # To Do: bring the previous uncertainties of stars that are detected # in only one input frame. if (weights_col and weights_col in self.colnames) and (val_2d.shape[1] > 1): - mask_for_singles = ((~np.isnan(val_2d_clip)).sum(axis=1)==1) + mask_for_singles = ((np.isfinite(val_2d_clip)).sum(axis=1)==1) std[mask_for_singles]=np.nanmean(err_2d[mask_for_singles], axis=1) # Save off our new AVG and STD into new columns with shape (N_stars). @@ -515,355 +515,609 @@ def combine_lists(self, col_name_in, weights_col=None, mask_val=None, col_name_std = col_name_in + '0_err' if ismag: - std = (2.5 / np.log(10)) * std / avg + std = 2.5 / np.log(10) * std / avg # Error propagation avg = -2.5 * np.ma.log10(avg) + + # Fill mask with nan or inf + avg = avg.filled(np.nan) + std = std.filled(np.inf) + if col_name_avg in self.colnames: - self[col_name_avg] = avg.data - self[col_name_std] = std.data + self[col_name_avg] = avg + self[col_name_std] = std else: - self.add_column(Column(data=avg.data, name=col_name_avg)) - self.add_column(Column(data=std.data, name=col_name_std)) - + self.add_column(Column(data=avg, name=col_name_avg)) + self.add_column(Column(data=std, name=col_name_std)) + return def detections(self): """ Find where stars are detected. # """ - n_detect = np.sum(~np.isnan(self['x']), axis=1) - + n_detect = np.sum(np.isfinite(self['x']) & np.isfinite(self['y']), axis=1) + if 'n_detect' in self.colnames: self['n_detect'] = n_detect else: - self.add_column(Column(n_detect), name='n_detect') - + self.add_column(Column(data=n_detect, name='n_detect')) + return - - def fit_velocities(self, weighting='var', use_scipy=True, absolute_sigma=True, bootstrap=0, - fixed_t0=False, verbose=False, mask_val=None, mask_lists=False, show_progress=True, - default_motion_model='Linear', reassign_motion_model=False, select_stars=None, motion_model_dict={}): - """Fit velocities for all stars in the table and add to the columns 'vx', 'vxe', 'vy', 'vye', 'x0', 'x0e', 'y0', 'y0e'. + + def fit_motion_models( + self, + motion_models=None, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + select_stars=None, + bootstrap=0, + seed=None, + mask_value=None, + mask_lists=None, + fill_value=np.nan, + verbose=True + ): + """Fit velocity for star table Parameters ---------- + motion_models : list of MotionModel or str, optional + Motion models to use, by default Empty, Fixed and Linear. + Empty and Fixed models are always added automatically for stars with n_fit = 0 or 1. + The behavior is as follows: + 1. If 'motion_model_input' column is NOT in table: + - Use the most complex model that has enough parameters to fit the data (n_fit >= n_params). + - If multiple models are supplied, prioritize the model with the most parameters to fit. + - If multiple models have the same number of parameters, raise AssertionError: not sure which to use. + 2. If 'motion_model_input' column IS in table: + - Use the model specified in the 'motion_model_input' column. + - If not enough data points to fit the specified model, use the most complex model in any 'motion_model_input' column that has enough parameters to fit the data (n_fit >= n_params) among the provided motion_models and 'motion_model_input'. + The actual used motion model is stored in the 'motion_model_used' column. The default motion_models are [Empty, Fixed, Linear]. + fixed_params_dict : dict, optional + Dictionary of fixed parameters for motion models, e.g., {'t0': 0., 'ra': np.array([...]), 'dec': np.array([...])}. + - Scalar values are used for all stars, array values should have length = N_stars. + - t0 is automatically calculated as np.average(t, weights=1/np.hypot(xe, ye)) if not provided. + - The keys should match the fixed parameter names in the motion models. See MotionModel class for details, by default None weighting : str, optional - Weight by variance 'var' or standard deviation 'std', by default 'var' + Uncertainty weighting, 'std' for weight=1/xe(ye) or 'var' for weight=1/xe(ye)**2, by default 'var' + use_scipy : bool, optional + Use scipy.optimize.curve_fit or algebraic solution (for Linear model only), by default False + absolute_sigma : bool, optional + Use absolute sigma or not, see scipy curve_fit for details, by default True + select_stars : list of int, optional + Indices of stars to fit, by default None (fit all stars) bootstrap : int, optional - Calculate uncertainty using bootstraping or not, by default 0 - fixed_t0 : bool or array-like, optional - Fix the t0 in dt = time - t0 if user provides an array with the same length of the table, or automatically calculate t0 = np.average(time, weights=1/np.hypot(xe, ye)) if False, by default False + Number of bootstrap for uncertainty resampling, by default 0 + seed : int, optional + Random seed for bootstrap resampling, by default None + mask_value : float, optional + Values to mask in data, by default None + mask_lists : list of int, optional + Indices of lists to mask/exclude from fitting, by default None + fill_value : float, optional + Fill value when there is not enough data points to fit, by default np.nan verbose : bool, optional - Output verbose information or not, by default False - mask_val : float, optional - Value that needs to be masked in the data, e.g. -100000, by default None - mask_lists : list, optional - Columns that needs to be masked, by default False - show_progress : bool, optional - Show progress bar or not, by default True + Print verbose messages or not, by default True + Raises ------ ValueError - If weighting is neither 'var' or 'std' + If weighting is not 'var' or 'std'. KeyError - If there's not time information in the table + If time values are not found in the table or meta. + KeyError + If required columns 'x' and 'y' are missing in the table. """ + ########################### + ####### Check Params ###### + ########################### if weighting not in ['var', 'std']: - raise ValueError(f"fit_velocities: Weighting must either be 'var' or 'std', not {weighting}!") - + raise ValueError(f"fit_motion_models: Weighting must either be 'var' or 'std', not {weighting}!") + if ('t' not in self.colnames) and ('list_times' not in self.meta): - raise KeyError("fit_velocities: Failed to access time values. No 't' column in table, no 'list_times' in meta.") - + raise KeyError("fit_motion_models: Failed to access time values. No 't' column in table, no 'list_times' in meta.") + # Check if we have the required columns if not all([_ in self.colnames for _ in ['x', 'y']]): - raise KeyError(f"fit_velocities: Missing required columns in the table: {', '.join(['x', 'y'])}!") - + raise KeyError(f"fit_motion_models: Missing required columns in the table: {', '.join(['x', 'y'])}!") + + # Make a copy of fixed_params_dict to avoid modifying the original one outside the function + fixed_params_dict = copy.deepcopy(fixed_params_dict) + + # Check fixed_params_dict is a dict + if fixed_params_dict is not None: + if not isinstance(fixed_params_dict, dict): + raise ValueError("fit_motion_models: fixed_params_dict must be a dictionary!") + + # Convert motion_models to MotionModel objects if they are strings: + if motion_models is None: + # Setting the default to None to avoid mutable default argument issue + # See https://stackoverflow.com/questions/15189245/assigning-class-variable-as-default-value-to-class-method-argument + motion_models = [Empty, Fixed, Linear] + all_mm_map = motion_model.motion_model_map() + if all(isinstance(mm, str) for mm in motion_models): + mm_names = motion_models + motion_models = [all_mm_map[mm] for mm in motion_models] + else: + mm_names = [mm.name for mm in motion_models] + + # Always add Empty and Fixed in motion models + if 'Fixed' not in mm_names: + motion_models.insert(0, Fixed) + if 'Empty' not in mm_names: + motion_models.insert(0, Empty) + mm_names = [mm.name for mm in motion_models] + + # Construct motion models if motion_model_input column exists + if 'motion_model_input' in self.colnames: + input_mm_names = np.unique(self['motion_model_input']) + assert all([name in all_mm_map.keys() for name in input_mm_names]), \ + f"fit_motion_models: Unknown motion model name(s) in 'motion_model_input' column. Available motion models are: {', '.join(all_mm_map.keys())}." + for mm_name in input_mm_names: + if mm_name not in mm_names: + motion_models.append(all_mm_map[mm_name]) + + # Sort motion models by required epochs + motion_models = sorted(motion_models, key=lambda mm: mm.n_params) + + input_mm_map = {mm.name: mm for mm in motion_models} + + mm_n_params = np.sort([mm.n_params for mm in motion_models]) + if 'motion_model_input' not in self.colnames: + # If motion_model_input column is not provided, assert that motion model n_params are unique and sorted + # Otherwise the fitter does not know which motion model to use based on n_obs + assert len(mm_n_params) == len(set(mm_n_params)), \ + f"fit_motion_models: Provided motion model n_params are not unique! Motion Models are: {[_.name for _ in motion_models]}" + '\n' + "Cannot decide which motion model to use based on n_obs. Please provide unique motion_models or a 'motion_model_input' column." + + + ########################### + ####### Prepare Data ###### + ########################### + # Prepare data for fitting N_stars = len(self) + N_times = self['x'].data.shape[1] + if mask_lists is not None: + list_indices = np.array([i for i in range(N_times) if i not in mask_lists]) + else: + list_indices = np.arange(N_times) + x_data = np.ma.masked_invalid(self['x'].data[:, list_indices], copy=True) + y_data = np.ma.masked_invalid(self['y'].data[:, list_indices], copy=True) + xe_data = np.ma.masked_invalid(self['xe'].data[:, list_indices], copy=True) if 'xe' in self.colnames else np.ones_like(x_data) + ye_data = np.ma.masked_invalid(self['ye'].data[:, list_indices], copy=True) if 'ye' in self.colnames else np.ones_like(y_data) + + # Mask out close to 0 values to avoid infinite weights + if xe_data is not None: + xe_data.mask[np.isclose(xe_data, 0)] = True + if ye_data is not None: + ye_data.mask[np.isclose(ye_data, 0)] = True + + # If all of xe and ye is masked for a star, effectively no uncertainties provided, fill with 1. + # Note that this automatically turn the mask to False for these stars + if (xe_data is not None) and (ye_data is not None): + fill_with_one = np.all(xe_data.mask, axis=1) & np.all(ye_data.mask, axis=1) + xe_data[fill_with_one] = 1. + ye_data[fill_with_one] = 1. + + # Ensure data is 2D for consistent indexing, even if we have only one list/epoch (shape (N_stars, 1) instead of (N_stars,)) + if np.ndim(x_data) == 1: + x_data = x_data[:, np.newaxis] + if np.ndim(y_data) == 1: + y_data = y_data[:, np.newaxis] + if np.ndim(xe_data) == 1: + xe_data = xe_data[:, np.newaxis] + if np.ndim(ye_data) == 1: + ye_data = ye_data[:, np.newaxis] + + # if mask_lists is not None: + # x_data.mask[:, mask_lists] = True + # y_data.mask[:, mask_lists] = True + # xe_data.mask[:, mask_lists] = True + # ye_data.mask[:, mask_lists] = True + + # t_data: 2d array with shape (N_stars, N_epochs) + # t0: 1d array with shape (N_stars,) + if 't' in self.colnames: + t_data = copy.deepcopy(self['t'].data[:, list_indices]) + else: + t_data = copy.deepcopy(np.array(self.meta['list_times']))[list_indices] + t_data = np.broadcast_to(t_data, x_data.shape) + + fixed_params_dict = {} if fixed_params_dict is None else fixed_params_dict + # Add default t0 if not provided in fixed_params_dict + if 't0' not in fixed_params_dict: + weights = 1/np.hypot(xe_data, ye_data) if (xe_data is not None) and (ye_data is not None) else None + fixed_params_dict['t0'] = np.average(t_data, axis=1, weights=weights) + else: + if np.ndim(fixed_params_dict['t0']) == 0: + fixed_params_dict['t0'] = np.full(N_stars, fixed_params_dict['t0']) + + t0 = fixed_params_dict['t0'] + + # Apply mask_value if provided + if mask_value: + x_data = np.ma.masked_values(x_data, mask_value) + y_data = np.ma.masked_values(y_data, mask_value) + if xe_data is not None: + xe_data = np.ma.masked_values(xe_data, mask_value) + if ye_data is not None: + ye_data = np.ma.masked_values(ye_data, mask_value) + + + # Calculate mask array + xy_mask = ~ (x_data.mask | y_data.mask) + if (xe_data is not None) and (ye_data is not None): + xy_mask = xy_mask & (~ (xe_data.mask | ye_data.mask)) + + # Calculate n_fit: unmasked x y values + # This will be used to determine which motion model to use for each star. + # Note that we don't require unique times here + # as scipy.curve_fit and Linear algebra can fit non-unique times. + # self['n_fit'] = np.sum(xy_mask, axis=1) + + # Calculate n_fit: unique times & unmasked x y values + self['n_fit'] = np.array([ + len(set(t_data[i][xy_mask[i]])) + for i in range(N_stars) + ]) + + + ########################### + ####### Determine MM ###### + ########################### + n_fit = np.array(self['n_fit']) + if 'motion_model_input' in self.colnames: + # Determine which motion model to use based on motion_model_input column + # If n_fit < n_params for the input motion model, use the most complicated motion model with n_fit >= n_params + required_params = np.array([all_mm_map[mm_name].n_params for mm_name in self['motion_model_input']]) + reassign_mm = n_fit < required_params + + mm_digitized = np.digitize( + x=n_fit[reassign_mm], + bins=mm_n_params + ) - 1 # Convert to 0-based index + + # Assign motion models to stars + self['motion_model_used'] = self['motion_model_input'] + self['motion_model_used'][reassign_mm] = np.array([motion_models[d].name for d in mm_digitized], dtype='U20') - if verbose: - start_time = time.time() - msg = 'Starting startable.fit_velocities for {0:d} stars with n={1:d} bootstrap' - print(msg.format(N_stars, bootstrap)) - - # Set all to default_motion_model if none assigned already. - # Reset motion_model_used to the inputs for now -> will change as fits run - if ('motion_model_input' not in self.colnames) or reassign_motion_model: - self['motion_model_input'] = default_motion_model - self['motion_model_used'] = self['motion_model_input'] - - motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, self, default_motion_model) - - # - # Fill table with all possible motion model parameter names as new - # columns. Make everything empty for now. - # - all_motion_models = np.unique(self['motion_model_input'].tolist() + ['Fixed']+[default_motion_model]).tolist() - new_col_list = motion_model.get_list_motion_model_param_names(all_motion_models, with_errors=True) - # Append goodness of fit metrics and t0. + else: + # If motion_model_input column is not provided, use the most complicated model in motion_models with n_fit >= n_params. + mm_digitized = np.digitize( + x=n_fit, + bins=mm_n_params + ) - 1 # Convert to 0-based index + + # Assign motion models to stars + self['motion_model_used'] = np.array([motion_models[d].name for d in mm_digitized], dtype='U20') + + ############################ + # Prepare Fixed Parameters # + ############################ + # If required fixed params in self but not provided in fixed_params_dict, add them to fixed_params_dict + motion_model_used = [all_mm_map[name] for name in np.unique(self['motion_model_used'])] + raise_key_error = False + missing_params = [] + for mm in motion_model_used: + # Check required fixed parameters + for param in mm.required_fixed_param_names: + if param not in fixed_params_dict: + # If not provided in fixed_params_dict, it must be in table columns + if param in self.colnames: + fixed_params_dict[param] = self[param].data + else: + raise_key_error = True + missing_params.append(f"'{param}'") + + # Check optional fixed parameters + # Set to default value if not provided in fixed_params_dict or in self + for param, value in mm.optional_fixed_params.items(): + if param not in fixed_params_dict: + # If param is not provided in fixed_params_dict + if param in self.colnames: + # Set to column value if column exists + fixed_params_dict[param] = self[param].data + else: + # Set to default value if neither in columns nor provided in fixed_params_dict + fixed_params_dict[param] = value + self.meta[param] = value + + if raise_key_error: + raise KeyError(f"fit_motion_models: Missing required fixed parameter(s) for the motion models used: {', '.join(missing_params)}! Please provide them in fixed_params_dict or as columns in the table.") + + + # Prepare fixed_params_dict for each star + # This avoids checking types and slicing inside the fitting loop + fixed_params_stars = [{} for _ in range(N_stars)] + # Identify array parameters (length N_stars) and scalar parameters + array_params = {k: v for k, v in fixed_params_dict.items() if np.ndim(v) > 0 and len(v) == N_stars} + scalar_params = {k: v for k, v in fixed_params_dict.items() if k not in array_params} + + # Construct list of dicts for each star + # Using list comprehension for speed + fixed_params_stars = [ + {**scalar_params, **{k: v[i] for k, v in array_params.items()}} + for i in range(N_stars) + ] + + + ############################ + ####### Prepare Table ###### + ############################ + # Fill table with all possible motion model parameter names as new columns. + new_col_list = motion_model.motion_model_param_names(motion_model_used, with_errors=True, with_fixed=False) new_col_list += ['chi2_x', 'chi2_y', 'n_params'] + if 't0' not in new_col_list: new_col_list.append('t0') - # Define output arrays for the best-fit parameters. + # Add new columns if they do not exist for col in new_col_list: - # Clean/remove up old arrays. - if col in self.colnames: self.remove_column(col) - # Add column #TODO: is this good for filling??? - self.add_column(Column(data = np.full(N_stars, np.nan, dtype=float), name = col)) - - # Add a column to keep track of the number of points used in a fit. - self['n_fit'] = 0 - - # Preserve the number of bootstraps that will be run (if any). - self.meta['n_fit_bootstrap'] = bootstrap - - # (FIXME: Do we need to catch the case where there's a single *unmasked* epoch?) - # Catch the case when there is only a single epoch. Just return 0 velocity - # and the same input position for the x0/y0. - if len(self['x'].shape) == 1: - self['motion_model_used'] = 'Fixed' - self['x0'] = self['x'] - self['y0'] = self['y'] - if 't' in self.colnames: - self['t0'] = self['t'] + if col in self.colnames: + # Keep old data if the column already exists + continue + if col.endswith('_err'): + self.add_column( + Column(data=np.full(N_stars, np.inf, dtype=float), name=col), + rename_duplicate=True + ) else: - self['t0'] = self.meta['list_times'][0] - if 'xe' in self.colnames: - self['x0_err'] = self['xe'] - self['y0_err'] = self['ye'] - self['n_fit'] = 1 - self['n_params'] = 1 - return - - if (self['x'].shape[1] == 1): - self['motion_model_used'] = 'Fixed' - self['x0'] = self['x'][:,0] - self['y0'] = self['y'][:,0] - if 't' in self.colnames: - self['t0'] = self['t'][:, 0] + self.add_column( + Column(data=np.full(N_stars, fill_value, dtype=float), name=col), + rename_duplicate=True + ) + + # Add fixed parameter meta if scalar, column if array. + fixed_param_names = [] + for mm in motion_model_used: + for param in mm.fixed_param_names: + if param not in fixed_param_names: + fixed_param_names.append(param) + # Remove t0 from fixed_param_names as it will be saved during fitting + if 't0' in fixed_param_names: + fixed_param_names.remove('t0') + + + for param in fixed_param_names: + coldata = np.array([fps[param] for fps in fixed_params_stars]) + + if param in self.colnames: + existing = self[param] + + # Skip if identical + same = ( + np.array_equal(existing, coldata) + if is_string_dtype(existing) + else np.allclose(existing, coldata, equal_nan=True) + ) + + if same: + continue + + # Different (or column does not yet exist) + if len(np.unique(coldata)) == 1: + self.meta[param] = coldata[0] else: - self['t0'] = self.meta['list_times'][0] - if 'xe' in self.colnames: - self['x0_err'] = self['xe'][:,0] - self['y0_err'] = self['ye'][:,0] - self['n_fit'] = 1 - self['n_params'] = 1 - return - - # Only fit selected stars, if list given - fit_star_idxs = range(N_stars) + self.add_column( + Column(data=coldata, name=f"{param}_mm"), + rename_duplicate=True, + ) + + # Add a column to keep track of the number of points used in a fit and number of bootstrap used. + self.meta['n_bootstrap'] = bootstrap + + + ########################### + ######### FITTING ######### + ########################### + unique_motion_models, unique_inv_indices = np.unique(self['motion_model_used'], return_inverse=True) if select_stars is not None: - fit_star_idxs = select_stars - # STARS LOOP through the stars and work on them 1 at a time. - # This is slow; but robust. - if show_progress: - for ss in tqdm(fit_star_idxs): - self.fit_velocity_for_star(ss, motion_model_dict, weighting=weighting, bootstrap=bootstrap, - use_scipy=use_scipy, absolute_sigma=absolute_sigma, - fixed_t0=fixed_t0, default_motion_model=default_motion_model, - mask_val=mask_val, mask_lists=mask_lists) + select_stars = np.asarray(select_stars) + if select_stars.dtype == bool: + select_stars = np.flatnonzero(select_stars) + else: + select_stars = np.asarray(select_stars, dtype=int) + indices_by_motion_model = {key: np.intersect1d(select_stars, np.flatnonzero(unique_inv_indices == k)) for k, key in enumerate(unique_motion_models)} else: - for ss in fit_star_idxs: - self.fit_velocity_for_star(ss, motion_model_dict, weighting=weighting, bootstrap=bootstrap, - use_scipy=use_scipy, absolute_sigma=absolute_sigma, - fixed_t0=fixed_t0, default_motion_model=default_motion_model, - mask_val=mask_val, mask_lists=mask_lists) - if verbose: - stop_time = time.time() - print('startable.fit_velocities runtime = {0:.0f} s for {1:d} stars'.format(stop_time - start_time, N_stars)) - + indices_by_motion_model = {key: np.flatnonzero(unique_inv_indices == k) for k, key in enumerate(unique_motion_models)} + + # Unmasked indices for each star: + unmasked_idx = [np.flatnonzero(xy_mask[i]) for i in range(N_stars)] + + # For each motion model + for unique_motion_model, unique_index in indices_by_motion_model.items(): + # Create motion model instance + motion_model_instance = input_mm_map[unique_motion_model]() + param_names = motion_model_instance.fit_param_names + # Initialize arrays to store results + n_stars_this_model = len(unique_index) + n_params = len(param_names) + + params_array = np.full((n_stars_this_model, n_params), fill_value, dtype=float) + param_errs_array = np.full((n_stars_this_model, n_params), np.inf, dtype=float) + chi2_x_array = np.full(n_stars_this_model, np.nan, dtype=float) + chi2_y_array = np.full(n_stars_this_model, np.nan, dtype=float) + + # Prepare data as lists of arrays for faster access during fitting + t_stars = [np.array(t_data[i][unmasked_idx[i]]) for i in unique_index] + x_stars = [np.array(x_data[i][unmasked_idx[i]]) for i in unique_index] + y_stars = [np.array(y_data[i][unmasked_idx[i]]) for i in unique_index] + xe_stars = [np.array(xe_data[i][unmasked_idx[i]]) for i in unique_index] if xe_data is not None else [None]*n_stars_this_model + ye_stars = [np.array(ye_data[i][unmasked_idx[i]]) for i in unique_index] if ye_data is not None else [None]*n_stars_this_model + + # For each star + # Expensive for loop! Prepare everything beforehand to speed up. + if len(unique_index) > 0: + for idx, i_star in enumerate(tqdm(unique_index, disable=not verbose, desc=f"Fitting motion model {unique_motion_model}")): + # Fit the star + params, param_errs, chi2_x, chi2_y = motion_model_instance.fit( + t=t_stars[idx], + x=x_stars[idx], + y=y_stars[idx], + xe=xe_stars[idx], + ye=ye_stars[idx], + fixed_params_dict=fixed_params_stars[i_star], + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + fill_value=fill_value, + return_chi2=True, + bootstrap=bootstrap, + seed=seed, + verbose=verbose + ) + params_array[idx] = params + param_errs_array[idx] = param_errs + chi2_x_array[idx] = chi2_x + chi2_y_array[idx] = chi2_y + + # Store results back to the table + for j, param_name in enumerate(param_names): + self[param_name][unique_index] = params_array[:, j] + self[param_name + '_err'][unique_index] = param_errs_array[:, j] + self['chi2_x'][unique_index] = chi2_x_array + self['chi2_y'][unique_index] = chi2_y_array + self['t0'][unique_index] = t0[unique_index] + + # Update n_params regardless of selections + for mm in motion_model_used: + self['n_params'][self['motion_model_used'] == mm.name] = mm.n_params return - def fit_velocity_for_star(self, ss, motion_model_dict, weighting='var', use_scipy=True, absolute_sigma=True, - bootstrap=False, fixed_t0=False, mask_val=None, mask_lists=False, - default_motion_model='Linear'): - # TODO: "weighting" is not used - # - # Make a mask of invalid (NaN) values and a user-specified invalid value. - # - - x = np.ma.masked_invalid(self['x'][ss, :].data) - y = np.ma.masked_invalid(self['y'][ss, :].data) - if mask_val: - x = np.ma.masked_values(x, mask_val) - y = np.ma.masked_values(y, mask_val) - # If no mask, convert x.mask to list - if not np.ma.is_masked(x): - x.mask = np.zeros_like(x.data, dtype=bool) - if not np.ma.is_masked(y): - y.mask = np.zeros_like(y.data, dtype=bool) - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - x.mask[mask_lists] = True - y.mask[mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') - # - # Assign the appropriate positional errors - # - if 'xe' in self.colnames: - # Make a mask of invalid (NaN) values and a user-specified invalid value. - xe = np.ma.masked_invalid(self['xe'][ss, :].data) - ye = np.ma.masked_invalid(self['ye'][ss, :].data) - - # Catch the case where we have positions but no errors for - # some of the entries... we need to "fill in" reasonable - # weights for these... just use the average weights over - # all the other epochs. - pos_no_err = np.where((np.isfinite(x) & np.isfinite(y)) & - (np.isfinite(xe) == False) & (np.isfinite(ye) == False))[0] - pos_with_err = np.where((np.isfinite(x) & np.isfinite(y)) & - (np.isfinite(xe) & np.isfinite(ye)))[0] - - if len(pos_with_err) > 0: - xe[pos_no_err] = xe[pos_with_err].mean() - ye[pos_no_err] = ye[pos_with_err].mean() - else: - xe[pos_no_err] = 1.0 - ye[pos_no_err] = 1.0 - else: - N_epochs = len(x) - xe = np.ones(N_epochs, dtype=float) - ye = np.ones(N_epochs, dtype=float) - xe = np.ma.masked_invalid(xe) - ye = np.ma.masked_invalid(xe) + def infer_positions(self, times, fixed_params_dict=None, fill_value=np.nan): + """Infer star positions at given times using fitted motion models. - if mask_val: - xe = np.ma.masked_values(xe, mask_val) - ye = np.ma.masked_values(ye, mask_val) - # If no mask, convert xe.mask to list - if not np.ma.is_masked(xe): - xe.mask = np.zeros_like(xe.data, dtype=bool) - if not np.ma.is_masked(ye): - ye.mask = np.zeros_like(ye.data, dtype=bool) - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - xe.mask[mask_lists] = True - ye.mask[mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') - - # - # Make a mask of invalid (NaN) values and a user-specified invalid value. - # - if 't' in self.colnames: - t = np.ma.masked_invalid(self['t'][ss, :].data) - else: - t = np.ma.masked_invalid(self.meta['list_times']) + Parameters + ---------- + times : array_like + Times at which to predict positions. Scalar, or (N_times,) array, or (N_stars, N_times) array. + fixed_params_dict : None or dict, optional + Dictionary of fixed parameters to use for prediction. + If not provided, will try to look for fixed parameters in the meta data then in table columns. + If fixed params are found in both the table and the fixed_params_dict, the values in the table will be used and the fixed_params_dict values will be ignored, + by default None + fill_value : float, optional + Value to use for missing data, by default np.nan - if mask_val: - t = np.ma.masked_values(t, mask_val) - if not np.ma.is_masked(t): - t.mask = np.zeros_like(t.data, dtype=bool) - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - t.mask[mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') - - # For inconsistent masks, mask the star if any of the values are masked. - new_mask = np.logical_or.reduce((t.mask, x.mask, y.mask, xe.mask, ye.mask)) - - # - # Figure out where we have detections (as indicated by error columns) - # - good = np.where((xe != 0) & (ye != 0) & - np.isfinite(xe) & np.isfinite(ye) & - np.isfinite(x) & np.isfinite(y) & ~new_mask)[0] - - N_good = len(good) - - # Catch the case where there is NO good data. - if N_good == 0: - #self['motion_model_used'][ss] = 'None' - self['n_fit'][ss] = N_good - self['n_params'][ss] = 0 - return + Returns + ------- + x, y, xe, ye : ndarray + Arrays of predicted x, y positions and their uncertainties xe, ye, with shape (N_stars, N_times) or (N_stars,) if N_times=1, or (N_times,) if N_stars=1, or scalar. + """ + assert 'motion_model_used' in self.colnames, \ + "infer_positions: 'motion_model_used' column not found in the table. Please run fit_motion_models() first." - # Everything below has N_good >= 1 - x = x[good] - y = y[good] - t = t[good] - xe = xe[good] - ye = ye[good] - - # - # Unless t0 is fixed, calculate the t0 for the stars. - # - if fixed_t0 is False: - t_weight = 1.0 / np.hypot(xe, ye) - t0 = np.average(t, weights=t_weight) - elif fixed_t0 is True: - t0 = self.t0 - else: - t0 = fixed_t0[ss] - self['t0'][ss] = t0 - self['n_fit'][ss] = N_good - - # - # Decide which motion_model to fit. - # - motion_model_use = self['motion_model_input'][ss] - # Go to default model if not enough points for assigned but enough for default - # TODO: think about whether we want other fallbacks besides the singular default and Fixed - if (N_good < motion_model_dict[motion_model_use].n_pts_req) and \ - (N_good >= motion_model_dict[default_motion_model].n_pts_req): - motion_model_use = default_motion_model - # If not enough points for either, go to a fixed model - elif (N_good < motion_model_dict[motion_model_use].n_pts_req) and \ - (N_good < motion_model_dict[default_motion_model].n_pts_req): - motion_model_use = 'Fixed' - # If the points do not cover multiple times, go to a fixed model - if (t == t[0]).all(): - motion_model_use = 'Fixed' - - self['motion_model_used'][ss] = motion_model_use - -# # Get the motion model object. -# modClass = motion_model_dict[motion_model_use] -# -# # Load up any prior information on parameters for this model. -# param_dict = {} -# for par in modClass.fitter_param_names+modClass.fixed_param_names: -# if ~np.isnan(self[par][ss]): -# param_dict[par] = self[par][ss] - - # Model object - mod = motion_model_dict[motion_model_use] - fixed_params = [self[par][ss] for par in mod.fixed_param_names] - - # Fit for the best parameters - params, param_errs = mod.fit_motion_model(t, x, y, xe, ye, t0, bootstrap=bootstrap, - weighting=weighting, use_scipy=use_scipy, absolute_sigma=absolute_sigma) - chi2_x,chi2_y = mod.get_chi2(params,fixed_params, t,x,y,xe,ye) - self['chi2_x'][ss]=chi2_x - self['chi2_y'][ss]=chi2_y - self['n_params'][ss] = mod.n_params - - # Save parameters and errors to table. - for pp in range(len(mod.fitter_param_names)): - par = mod.fitter_param_names[pp] - par_err = par + '_err' - self[par][ss] = params[pp] - self[par_err][ss] = param_errs[pp] - - return + N_stars = len(self) + times = np.atleast_1d(times) + N_times = len(times) + + x_pred = np.full((N_stars, N_times), fill_value, dtype=float) + y_pred = np.full((N_stars, N_times), fill_value, dtype=float) + xe_pred = np.full((N_stars, N_times), np.inf, dtype=float) + ye_pred = np.full((N_stars, N_times), np.inf, dtype=float) + + # Calculate the dictionary of {motion_model: indices of stars with this motion model} for faster access during prediction + unique_motion_models, unique_inv_indices = np.unique(self['motion_model_used'], return_inverse=True) + indices_by_motion_model = {key: np.flatnonzero(unique_inv_indices == k) for k, key in enumerate(unique_motion_models)} + mm_map = motion_model.motion_model_map() + # Prepare fit_params, fixed_params, fit_param_errs for each star + for unique_motion_model, unique_index in indices_by_motion_model.items(): + # Create motion model instance + motion_model_instance = mm_map[unique_motion_model]() + # Prepare parameters for prediction + fit_params = np.array([ + self[param_name][unique_index] for param_name in motion_model_instance.fit_param_names + ]).T # shape (N_stars_this_model, N_params) + + fit_param_errs = np.array([ + self[param_name + '_err'][unique_index] for param_name in motion_model_instance.fit_param_names + ]).T # shape (N_stars_this_model, N_params) + + # Construct fixed_params: Look for fixed_params_dict -> table columns -> meta data -> default value + fixed_params = fixed_params_dict.copy() if fixed_params_dict is not None else {} + for param in motion_model_instance.required_fixed_param_names: + if param not in fixed_params: + # If required fixed param not provided, find it in the table columns or meta data + if param in self.colnames: + fixed_params[param] = self[param][unique_index] + elif param in self.meta: + fixed_params[param] = self.meta[param] + else: + raise KeyError(f"infer_positions: Required fixed parameter '{param}' not found for motion model '{unique_motion_model}'. Please provide it in fixed_params_dict, or add it as a column in the table, or add it to the meta data.") + else: + fixed_params[param] = fixed_params_dict[param] + + for param, default_value in motion_model_instance.optional_fixed_params.items(): + if param not in fixed_params: + # If optional fixed param not provided, find it in the table columns or meta data, otherwise use default value + if param in self.colnames: + if param == 'obsLocation': + # Special case for obsLocation: no vectorization implemented yet, use the value from the first star + assert np.unique(self[param][unique_index]).size == 1, \ + f"infer_positions: obsLocation fixed parameter has different values ({np.unique(self[param][unique_index])}) for different stars. Vectorized handling not implemented yet." + fixed_params[param] = self[param][unique_index] + elif param in self.meta: + fixed_params[param] = self.meta[param] + else: + fixed_params[param] = default_value + else: + fixed_params[param] = fixed_params_dict[param] + + # for param_name in motion_model_instance.fixed_param_names: + # col_name = copy.deepcopy(param_name) + # # If column not in table, check if it's provided in fixed_params_dict. If not, raise error. If provided, use the value from fixed_params_dict for all stars. + # if (col_name not in self.colnames) and (f'{col_name}_mm' not in self.colnames): + # if col_name in fixed_params_dict: + # fixed_params[param_name] = fixed_params_dict[col_name] + # continue + # else: + # raise KeyError(f"infer_positions: Fixed parameter '{param_name}' not found in table columns or fixed_params_dict. Please provide the value for this parameter in fixed_params_dict or add a column named '{param_name}' to the table.") + + # # If original table has column and fit_motion_models added the column with _mm suffix, use the _mm column for prediction. + # if param_name + '_mm' in self.colnames: + # col_name = param_name + '_mm' + # fixed_params[param_name] = self[col_name][unique_index] + + # if (param_name == 'obsLocation'): + # assert np.unique(fixed_params[param_name]).size == 1, \ + # "infer_positions: obsLocation fixed parameter has different values for different stars. Vectorized handling not implemented yet." + # fixed_params[param_name] = fixed_params[param_name][0] + + # Predict positions + # shape = (N_stars_this_model, N_times) or (N_stars_this_model,) if N_times=1 or (N_times,) if N_stars_this_model=1 or scalar + x, y, xe, ye = motion_model_instance.model( + times, fit_params, fit_param_errs, fixed_params + ) + if N_stars==1 and N_times > 1: + # Reshape (N_times,) to (1, N_times) + x = x[np.newaxis, :] + y = y[np.newaxis, :] + xe = xe[np.newaxis, :] + ye = ye[np.newaxis, :] + elif N_times==1 and N_stars > 1: + # Reshape (N_stars,) to (N_stars, 1) + x = x[:, np.newaxis] + y = y[:, np.newaxis] + xe = xe[:, np.newaxis] + ye = ye[:, np.newaxis] + + x_pred[unique_index] = x + y_pred[unique_index] = y + xe_pred[unique_index] = xe + ye_pred[unique_index] = ye + + if N_stars==1 or N_times==1: + # Reshape back to 1D array or scalar + x_pred = x_pred.flatten() + y_pred = y_pred.flatten() + xe_pred = xe_pred.flatten() + ye_pred = ye_pred.flatten() + return x_pred, y_pred, xe_pred, ye_pred + + # New function, to use in align def get_star_positions_at_time(self, t, motion_model_dict, allow_alt_models=True): """ Get current x,y positions of each star according to its motion_model @@ -893,7 +1147,7 @@ def get_star_positions_at_time(self, t, motion_model_dict, allow_alt_models=True mod = motion_model_dict[mm] # Set up parameters param_dict = {} - for par in mod.fitter_param_names + mod.fixed_param_names + [pm+'_err' for pm in mod.fitter_param_names]: + for par in mod.fit_param_names + mod.fixed_param_names + [pm+'_err' for pm in mod.fit_param_names]: param_dict[par] = self[par][idx] x[idx],y[idx],xe[idx],ye[idx] = mod.get_batch_pos_at_time(t,**param_dict) except: @@ -913,147 +1167,9 @@ def get_star_positions_at_time(self, t, motion_model_dict, allow_alt_models=True param_dict[par] = self[par][idx] x[idx],y[idx],xe[idx],ye[idx] = mod.get_batch_pos_at_time(t,**param_dict) - return x,y,xe,ye - + return x, y, xe, ye - def fit_velocities_all_detected(self, motion_model_to_fit, weighting='var', use_scipy=True, absolute_sigma=True, times=None, - select_stars=None, epoch_cols='all', mask_val=None, art_star=False, return_result=False): - """Fit velocities for stars detected in all epochs specified by epoch_cols. - Criterion: xe/ye error > 0 and finite, x/y not masked. - Parameters - ---------- - motion_model_to_fit : MotionModel - Motion model object to use for fitting all stars - weighting : str, optional - Variance weighting('var') or standard deviation weighting ('std'), by default 'var' - select_idx : array-like, optional - Indices of stars to select for fitting, by default None (fit all detected stars) - epoch_cols : str or list of intergers, optional - List of epoch column indices used for fitting velocity, by default 'all' - mask_val : float, optional - Values in x, y to be masked - art_star : bool, optional - Artificial star or observation star catalog. If artificial star, use 'det' column to select stars detected in all epochs, by default False - return_result : bool, optional - Return the velocity results or not, by default False - - Returns - ------- - vel_result : astropy Table - Astropy Table with velocity results - """ - - N_stars = len(self) - if select_stars is None: - select_stars = np.arange(N_stars) - else: - select_stars = np.asarray(select_stars) - - if epoch_cols == 'all': - epoch_cols = np.arange(np.shape(self['x'])[1]) - - # Artificial Star - if art_star: - detected_in_all_epochs = np.all(self['det'][select_stars, :][:, epoch_cols], axis=1) - - # Observation Star - else: - valid_xe = np.all(self['xe'][select_stars, :][:, epoch_cols]!=0, axis=1) & np.all(np.isfinite(self['xe'][select_stars, :][:, epoch_cols]), axis=1) - valid_ye = np.all(self['ye'][select_stars, :][:, epoch_cols]!=0, axis=1) & np.all(np.isfinite(self['ye'][select_stars, :][:, epoch_cols]), axis=1) - - if mask_val: - x = np.ma.masked_values(self['x'][select_stars, :][:, epoch_cols], mask_val) - y = np.ma.masked_values(self['y'][select_stars, :][:, epoch_cols], mask_val) - - # If no mask, convert x.mask to list - if not np.ma.is_masked(x): - x.mask = np.zeros_like(self['x'][select_stars, :][:, epoch_cols].data, dtype=bool) - if not np.ma.is_masked(y): - y.mask = np.zeros_like(self['y'][select_stars, :][:, epoch_cols].data, dtype=bool) - - valid_x = ~np.any(x.mask, axis=1) - valid_y = ~np.any(y.mask, axis=1) - detected_in_all_epochs = np.logical_and.reduce(( - valid_x, valid_y, valid_xe, valid_ye)) - else: - detected_in_all_epochs = np.logical_and(valid_xe, valid_ye) - - N = len(self['x'][select_stars, :]) - fit_params = motion_model_to_fit.fitter_param_names - param_data = {p: np.zeros(N) for p in fit_params} - param_data.update({p+'_err': np.zeros(N) for p in fit_params}) - param_data.update({p: np.zeros(N) for p in motion_model_to_fit.fixed_param_names}) - param_data['chi2_x'] = np.zeros(N) - param_data['chi2_y'] = np.zeros(N) - - if times is None: - if 'YEARS' in self.meta: - times = np.array(self.meta['YEARS'])[epoch_cols] - elif 't' in self.colnames: - times = self['t'][0, epoch_cols] - else: - raise ValueError("No valid time column found.") - - if not art_star: - x_arr = self['x'][select_stars, :][:, epoch_cols] - y_arr = self['y'][select_stars, :][:, epoch_cols] - else: - x_arr = self['x'][select_stars, :][:, epoch_cols, 1] - y_arr = self['y'][select_stars, :][:, epoch_cols, 1] - - xe_arr = self['xe'][select_stars, :][:, epoch_cols] - ye_arr = self['ye'][select_stars, :][:, epoch_cols] - - # Only fit for >1 epochs, otherwise all velocities will be 0 - if len(epoch_cols) > 1: - # For each star - for i in tqdm(range(N)): - x = x_arr[i] - y = y_arr[i] - xe = xe_arr[i] - ye = ye_arr[i] - t0 = np.average(times, weights=1. / np.hypot(xe, ye)) - - # Run fit and record results - params, param_errs = motion_model_to_fit.fit_motion_model( - times, x, y, xe, ye, t0, weighting=weighting, - use_scipy=use_scipy, absolute_sigma=absolute_sigma - ) - if 't0' in motion_model_to_fit.fixed_param_names: - param_data['t0'][i] = t0 - for j, param in enumerate(fit_params): - param_data[param][i] = params[j] - param_data[f'{param}_err'][i] = param_errs[j] - chi2x, chi2y = motion_model_to_fit.get_chi2(params, [t0], times, x, y, xe, ye) - param_data['chi2_x'][i] = chi2x - param_data['chi2_y'][i] = chi2y - - vel_result = Table.from_pandas(pd.DataFrame(param_data)) - - # Add n_vfit - n_fit = len(epoch_cols) - vel_result['n_fit'] = n_fit - - # Clean/remove up old arrays. - columns = [*vel_result.keys(), 'n_fit'] - for column in columns: - if column in self.colnames: self.remove_column(column) - - # Update self - for column in columns: - column_array = MaskedColumn(np.ma.zeros(N_stars), dtype=float, name=column) - column_array[select_stars] = vel_result[column] - column_array[select_stars][~detected_in_all_epochs] = np.nan - column_array.mask[select_stars] = ~detected_in_all_epochs - # Mask unselected indices - column_array.mask[~np.isin(np.arange(N_stars), select_stars)] = True - self[column] = column_array - - if return_result: - return vel_result - else: - return def shift_reference_frame(self, delta_vx=0.0, delta_vy=0.0, delta_pi=0.0, motion_model_dict={}): @@ -1062,7 +1178,7 @@ def shift_reference_frame(self, delta_vx=0.0, delta_vy=0.0, delta_pi=0.0, the absolute frame using either Gaia or a Galactic model. This modified the motion model fit parameters as well as the time series astrometry, assuming zero error on the shift values. - + Parameters ---------- delta_vx : float, optional @@ -1097,7 +1213,7 @@ def shift_reference_frame(table, delta_vx=0.0, delta_vy=0.0, delta_pi=0.0, the absolute frame using either Gaia or a Galactic model. This modified the motion model fit parameters as well as the time series astrometry, assuming zero error on the shift values. - + Parameters ---------- delta_vx : float, optional diff --git a/flystar/stitch_method2.py b/flystar/stitch_method2.py index 8cab361..f9aa4e0 100644 --- a/flystar/stitch_method2.py +++ b/flystar/stitch_method2.py @@ -42,7 +42,7 @@ def align_starlists(starlist, ref, transModel=transforms.PolyTransform, order=2, if weights==None, we don't use weights. """ - + #-------------------------------------------------- # Initial transformation with brightest briteN stars #-------------------------------------------------- @@ -98,7 +98,7 @@ def weighted_mean(df,x,xe,frames_in_use): # error = xe or ye # all_frames = e.g. ['A', 'B', 'C', ...] - + cols_x=["{0}_{1}".format(x,f) for f in frames_in_use] # columns for x_* e.g. ['x_A', 'x_B', 'x_C', ....] cols_xe=["{0}_{1}".format(xe,f) for f in frames_in_use] # columns for xe_* e.g. ['xe_A', 'xe_B', 'xe_C', ....] @@ -120,11 +120,11 @@ def weighted_mean(df,x,xe,frames_in_use): xe_master.append(array_xe[i][mask][0]) else: rows_to_drop.append(i) - + df=df.drop(rows_to_drop) df[x]=np.array(x_master) df[xe]=np.array(xe_master) - + return df @@ -132,12 +132,12 @@ def normal_mean(df,x,frames_in_use): cols_x=["{0}_{1}".format(x,f) for f in frames_in_use] df[x]=df[cols_x].mean(axis=1) - + return df def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaster='./master.lis'): - + # all_starslist: the list of the names of all starlists e.g. ['A', 'B', 'C', ... ] # name_initial_ref: the name of the reference that you use in the very first match. # corr_thresh : threshold for correlation values. @@ -149,11 +149,11 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste input_starslists.remove(name_initial_ref) for name_starlist in input_starslists: - + starlist=starlists.read_starlist('{0}.lis'.format(name_starlist)) if 'ref' not in locals(): ref=starlists.read_starlist('{0}.lis'.format(name_initial_ref)) - + #------------ Choose good stars to use for a trans object -------------------- @@ -162,14 +162,14 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste # Select the very first 11 columns (i.e. the master reference) consistent with those of the starlist. # Table -> dataframe -> Table, which lets us avoid the following error: 'MaskedColumn' object has no attribute '_mask' - + ref_for_align=ref_for_align.to_pandas() - + ref_for_align=Table.from_pandas(ref_for_align[starlist_for_align.colnames]) _,_,_,trans=align_starlists(starlist_for_align,ref_for_align,order=2,dr_tol=1,N_loop=15) - + #------------ Transform the whole starlist using the trans object and match with the reference ------------- starlist_transformed=align.transform_from_object(starlist,trans) @@ -183,7 +183,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste #-------------Convert the astropy talbes into dataframes --------------------- df_ref=ref.to_pandas() df_starlist_transformed=starlist_transformed.to_pandas() - + #-------------Columns 11-21 contain the measurments for the initial reference-------------- colnames=starlist.colnames @@ -199,11 +199,11 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste for col in colnames: df_ref['{0}_{1}'.format(col,name_starlist)]=np.nan df_ref.loc[idx_ref_matched,'{0}_{1}'.format(col,name_starlist)]= np.array(df_starlist_transformed.loc[idx_starlist_transformed_matched,col]) - + else: for col in colnames: - + df_ref.insert(len(df_ref.columns),'{0}_{1}'.format(col,name_starlist),np.nan) df_ref.loc[idx_ref_matched,'{0}_{1}'.format(col,name_starlist)]= np.array(df_starlist_transformed.loc[idx_starlist_transformed_matched,col]) @@ -218,7 +218,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste #-------------- Figure out which frames are currently included in the master frame ----------- frames_in_use=sorted(set([column[-1] for column in columns if (column[-1] in all_starlists)])) - + #-------------- Average the measurements ------------- for col in colnames: if (col!='name') and (col!='x') and (col!='y') and (col!='xe') and (col!='ye') and (col!='N_frames'): @@ -226,7 +226,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste df_comb=weighted_mean(df_comb,'x','xe',frames_in_use) df_comb=weighted_mean(df_comb,'y','ye',frames_in_use) - + #-------------Recalculate 'N_frames' for the master frame -> N_frames = the number of input starlists containing the star----------- # N_frames = the number of notnull columns at each row in the master frame divided by the number of columns in an input starlist, then minus one. # The "minus one" at the end accounts for the very first columns, i.e. master columns, that contain the averaged values of all the input starlists. @@ -244,7 +244,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste #-------------- Convert the final dataframe back into an astropy table ------ ref=Table.from_pandas(df_comb) - + ref.write(outMaster,format='ascii.commented_header', header_start=-1, overwrite=True) return diff --git a/flystar/template.py b/flystar/template.py index c714f9d..1373799 100644 --- a/flystar/template.py +++ b/flystar/template.py @@ -8,28 +8,28 @@ import pdb -def align_template(labelFile, reference, transModel=transforms.PolyTransform, order=1, N_loop=2, +def align_template(labelFile, reference, transModel=transforms.PolyTransform, order=1, N_loop=2, dr_tol=1.0, dm_tol=None, briteN=100, weights='both', restrict=False, outFile='outTrans.txt'): """ Base example of how to use the flystar code. Assumes we are transforming a label.dat into a reference starlist. - + Parameters: ----------- labelFile: ascii file Starlist we would like to transform into the reference frame. For this code, we expect a label.dat file - + reference: ascii file Starlist that defines the reference frame - + transModel: transformation class (default: transforms.polyTransform) Defines which transformation model to use. Both the four-parameter and polynomial transformations are supported - + order: int (default=1) Order of the polynomial transformation. Only used for polynomial transform - + N_loop: int (default=2) How many times to iterate on the transformation calculation. Ideally, each iteration adds more stars and thus a better transform, to some @@ -39,11 +39,11 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or the distance tolerance for matching two stars in align.transform_and_match dm_tol: float (defalut=None) - the magnitude tolerance for matching two stars in align.trnasform_and_match + the magnitude tolerance for matching two stars in align.trnasform_and_match briteN: int (default=100) the number of stars used in blind matching - + weights: string (default='both') if weights=='both', we use both position error in transformed starlist and reference starlist as uncertanty. And weights is the reciprocal of this uncertanty. @@ -66,7 +66,7 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or tref = starlist['t'][0] # label.dat has position & position err and velocity & velocity error label = starlists.read_label(labelFile, prop_to_time=tref, flipX=True) - + #-------------------------------------------------- # Initial transformation with brightest briteN stars @@ -79,21 +79,21 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # and calculate initial transform label_ini = label[idx_ini_label] starlist_ini = starlist[idx_ini_starlist] - + trans = align.initial_align(label_ini, starlist_ini, briteN=briteN, transformModel=transModel, order=order) - + # apply the initial transform to label.dat # this is used for future weights calculation label_trans_ini = align.transform_from_object(label, trans) - + #------------------------------------------------------------------------ # Use transformation to match starlists, then recalculate transformation. #------------------------------------------------------------------------ # Iterate on this as many times as desired for i in range(N_loop): - # apply the transformation to label.dat and + # apply the transformation to label.dat and # matched the transformed label with starlist. idx_label, idx_starlist = align.transform_and_match(label, starlist, trans, dr_tol=dr_tol, dm_tol=dm_tol) @@ -101,17 +101,17 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or if restrict: label_match = label[idx_label] starlist_match = starlist[idx_starlist] - idx_label, idx_starlist = stalists.restrict_by_use(label_match, starlist_match, + idx_label, idx_starlist = stalists.restrict_by_use(label_match, starlist_match, idx_label, idx_starlist) - + # use the matched stars to calculate new transformation label_match = label[idx_label] starlist_match = starlist[idx_starlist] label_ini_match = label_trans_ini[idx_label] - trans, N_trans = align.find_transform(label_match, label_ini_match, starlist_match, + trans, N_trans = align.find_transform(label_match, label_ini_match, starlist_match, transModel=transModel, order=order, weights = weights) - + #--------------------------------------------- # Write final transform in java align format @@ -121,7 +121,7 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # write the transformation coefficients to 'outTrans.txt' align.write_transform(trans, labelFile, reference, N_trans, deltaMag=delta_m, restrict=restrict, weights=weights, outFile=outFile) - + #----------------------------------------------------------- # Test transform: apply to label.dat, make diagnostic plots @@ -129,11 +129,11 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # apply the final transformation to label.dat label_trans = align.transform_from_object(label, trans) label_trans_match = label_trans[idx_label] - + # postion map with every star in starlist and transformed label. # both matched and unmatched stars. plots.trans_positions( starlist, starlist_match, label_trans, label_trans_match) - + # position difference histogram for matched stars. plots.pos_diff_hist( starlist_match, label_trans_match) @@ -146,6 +146,6 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # quiver plot of postion residules plots.pos_diff_quiver( starlist_match, label_trans_match) - + return - + diff --git a/flystar/tests/test_align.ipynb b/flystar/tests/test_align.ipynb deleted file mode 100644 index 02442b9..0000000 --- a/flystar/tests/test_align.ipynb +++ /dev/null @@ -1,366 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Notebook for Running Align Tests" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from flystar.tests import test_align\n", - "from flystar import starlists\n", - "from astropy.table import Table" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Test: make_fake_starlists_poly1_vel\n", - "\n", - "Just make sure the tables look sensible and are in the right units." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name m0 m0e ... vye t0 \n", - "-------- ----------------- -------------------- ... ------------------- ------\n", - "star_155 9.106905292995506 0.054167528156861204 ... 0.1564397531527286 2019.5\n", - "star_113 9.153031462110043 0.0421090989942197 ... 0.08128628950126615 2019.5\n", - "star_077 9.16547870263162 0.02021147759307802 ... 0.05907352582911862 2019.5\n", - "star_069 9.169817788300977 0.027788213230369625 ... 0.04965351499764548 2019.5\n", - "star_037 9.173200786855755 0.007665400875860144 ... 0.22723357600795704 2019.5\n", - " name m me ... ye t \n", - "-------- ----------------- -------------------- ... -------------------- ------\n", - "star_155 9.198437965086988 0.054167528156861204 ... 0.02649499466969545 2018.5\n", - "star_113 9.257333243243941 0.0421090989942197 ... 0.02606700846524875 2018.5\n", - "star_077 9.252158908537464 0.02021147759307802 ... 0.04250920654497108 2018.5\n", - "star_069 9.267901667333167 0.027788213230369625 ... 0.042689240225924296 2018.5\n", - "star_037 9.276780126418494 0.007665400875860144 ... 0.03592203011554212 2018.5\n", - " name m me ... ye t \n", - "-------- ----------------- -------------------- ... -------------------- ------\n", - "star_155 9.478887659623185 0.054167528156861204 ... 0.02649499466969545 2019.5\n", - "star_113 9.569878576042546 0.0421090989942197 ... 0.02606700846524875 2019.5\n", - "star_077 9.575998150724095 0.02021147759307802 ... 0.04250920654497108 2019.5\n", - "star_069 9.593581807234129 0.027788213230369625 ... 0.042689240225924296 2019.5\n", - "star_037 9.553127108740597 0.007665400875860144 ... 0.03592203011554212 2019.5\n", - "['name', 'm0', 'm0e', 'x0', 'x0e', 'y0', 'y0e', 'vx', 'vxe', 'vy', 'vye', 't0']\n", - "['name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n" - ] - } - ], - "source": [ - "test_align.make_fake_starlists_poly1_vel()\n", - "\n", - "ref = Table.read('random_vel_ref.fits')\n", - "lis0 = Table.read('random_vel_0.fits')\n", - "lis1 = Table.read('random_vel_1.fits')\n", - "\n", - "print(ref[0:5])\n", - "print(lis0[0:5])\n", - "print(lis1[0:5])\n", - "\n", - "print(ref.colnames)\n", - "print(lis0.colnames)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## test_align_vel\n", - "\n", - "Make sure it runs, make some plots along the way, etc." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n", - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "**********\n", - "**********\n", - "Starting iter 0 with ref_table shape: (200, 1)\n", - "**********\n", - "**********\n", - " \n", - " **********\n", - " Matching catalog 1 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 50 stars matched between starlist and reference list\n", - "initial_guess: [-6.05144456e+00 1.01098279e+00 -2.50608887e-04] [-1.07161761e+01 4.89226304e-05 1.01096529e+00]\n", - " Found 0 duplicates out of 196 matches\n", - "In Loop 0 found 196 matches\n", - " Found 0 duplicates out of 196 matches\n", - " \n", - " **********\n", - " Matching catalog 2 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 49 stars matched between starlist and reference list\n", - "initial_guess: [-1.02158015e+02 1.02080743e+00 -1.45081519e-04] [-5.07779471e+01 -2.60729494e-05 9.99423500e-01]\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 0 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - " **********\n", - " Matching catalog 3 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 50 stars matched between starlist and reference list\n", - "initial_guess: [-2.14220566e-10 1.00000000e+00 -2.24089697e-16] [2.50622339e-10 0.00000000e+00 1.00000000e+00]\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 0 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - " **********\n", - " Matching catalog 4 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 50 stars matched between starlist and reference list\n", - "initial_guess: [-2.57803428e+02 1.03052409e+00 -5.28390832e-05] [ 2.49886631e+02 -6.00884405e-05 9.98642952e-01]\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 0 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - "**********\n", - "**********\n", - "Starting iter 1 with ref_table shape: (204, 4)\n", - "**********\n", - "**********\n", - " \n", - " **********\n", - " Matching catalog 1 / 4 in iteration 1 with 200 stars\n", - " **********\n", - " Found 0 duplicates out of 199 matches\n", - "In Loop 1 found 199 matches\n", - " Found 0 duplicates out of 199 matches\n", - " \n", - " **********\n", - " Matching catalog 2 / 4 in iteration 1 with 200 stars\n", - " **********\n", - " Found 0 duplicates out of 198 matches\n", - "In Loop 1 found 198 matches\n", - " Found 0 duplicates out of 199 matches\n", - " \n", - " **********\n", - " Matching catalog 3 / 4 in iteration 1 with 200 stars\n", - " **********\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Found 0 duplicates out of 200 matches\n", - "In Loop 1 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - " **********\n", - " Matching catalog 4 / 4 in iteration 1 with 200 stars\n", - " **********\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 1 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - "**********\n", - "Final Matching\n", - "**********\n", - " Found 0 duplicates out of 199 matches\n", - "Matched 199 out of 200 stars in list 0\n", - " Found 0 duplicates out of 199 matches\n", - "Matched 199 out of 200 stars in list 1\n", - " Found 0 duplicates out of 200 matches\n", - "Matched 200 out of 200 stars in list 2\n", - " Found 0 duplicates out of 199 matches\n", - "Matched 199 out of 200 stars in list 3\n", - "\n", - " Preparing the reference table...\n" - ] - } - ], - "source": [ - "test_align.test_mosaic_lists_vel()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> /Users/jlu/code/python/flystar/flystar/align.py(3244)apply_mag_lim()\n", - "-> star_list_T.restrict_by_value(**conditions)\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) conditions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'m0_min': None, 'm0_max': None}\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) type(star_list_T)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) type(ref_list)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** NameError: name 'ref_list' is not defined\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) ref_list\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** NameError: name 'ref_list' is not defined\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) u\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> /Users/jlu/code/python/flystar/flystar/align.py(991)mosaic_lists()\n", - "-> ref_list_T = apply_mag_lim(ref_list, mag_lim[ref_index])\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) type(ref_list)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) q\n" - ] - } - ], - "source": [ - "import pdb\n", - "pdb.pm()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/flystar/tests/test_align.py b/flystar/tests/test_align.py index 2d6b0dc..5b9494b 100644 --- a/flystar/tests/test_align.py +++ b/flystar/tests/test_align.py @@ -1,21 +1,18 @@ -from flystar import align -from flystar import starlists -from flystar import startables -from flystar import transforms -from flystar import analysis -from flystar import motion_model -from astropy.table import Table -import numpy as np -import pylab as plt import pdb -import datetime -import pytest +import flystar +import numpy as np +import matplotlib.pyplot as plt +from astropy.table import Table +from flystar.plots import plot_stars +from flystar import align, starlists, transforms, analysis, motion_model + +test_data_path = f'{flystar.__path__[0]}/tests/test_data' def test_MosaicSelfRef(): """ Cross-match and align 4 starlists using the OO version of mosaic lists. """ - list_files = ['A.lis', 'B.lis', 'C.lis', 'D.lis'] + list_files = [f'{test_data_path}/{f}' for f in ['A.lis', 'B.lis', 'C.lis', 'D.lis']] lists = [starlists.StarList.from_lis_file(lf) for lf in list_files] ########## @@ -28,7 +25,7 @@ def test_MosaicSelfRef(): trans_args={'order': 2}) msc.fit() - + # Check some of the output quantities on the final table. assert 'x0' in msc.ref_table.colnames assert 'x0_err' in msc.ref_table.colnames @@ -42,7 +39,6 @@ def test_MosaicSelfRef(): assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape - # Check that we have some matched stars... should be at least 35 stars # that are detected in all 4 starlists. @@ -50,11 +46,11 @@ def test_MosaicSelfRef(): assert len(idx) > 35 # Check that the transformation error isn't too big - assert (msc.ref_table['x0_err'] < 3.0).all() # less than 1 pix - assert (msc.ref_table['y0_err'] < 3.0).all() - #assert (msc.ref_table['m0_err'] < 1.0).all() # less than 0.5 mag - assert (msc.ref_table['m0_err'] < 1.5).all() # less than 0.5 mag - + valid_err = np.isfinite(msc.ref_table['x0_err']) & np.isfinite(msc.ref_table['y0_err']) & np.isfinite(msc.ref_table['m0_err']) + assert (msc.ref_table['x0_err'][valid_err] < 3.0).all() # less than 1 pix + assert (msc.ref_table['y0_err'][valid_err] < 3.0).all() + #assert (msc.ref_table['m0_err'][valid_err] < 1.0).all() # less than 0.5 mag + assert (msc.ref_table['m0_err'][valid_err] < 1.5).all() # less than 0.5 mag # Check that the transformation lists aren't too wacky for ii in range(4): np.testing.assert_allclose(msc.trans_list[ii].px.c1_0, 1.0, rtol=1e-2) @@ -81,17 +77,15 @@ def test_MosaicSelfRef(): plt.plot(msc.ref_table['x0'], msc.ref_table['y0'], '.', color='black', alpha=0.2) - - return def test_MosaicSelfRef_vel_tconst(): """ Cross-match and align 4 starlists using the OO version of mosaic lists. The 4 lists are all taken at the same time (so 0 velocities should result). - + """ - list_files = ['A.lis', 'B.lis', 'C.lis', 'D.lis'] + list_files = [f'{test_data_path}/{f}' for f in ['A.lis', 'B.lis', 'C.lis', 'D.lis']] lists = [starlists.StarList.from_lis_file(lf) for lf in list_files] ########## @@ -102,11 +96,11 @@ def test_MosaicSelfRef_vel_tconst(): dr_tol=[3, 3], dm_tol=[1, 1], trans_class=transforms.PolyTransform, trans_args={'order': 2}, - default_motion_model='Linear', + motion_models=['Empty', 'Fixed', 'Linear'], verbose=False) msc.fit() - + # Check some of the output quantities on the final table. assert 'x0' in msc.ref_table.colnames assert 'x0_err' in msc.ref_table.colnames @@ -114,55 +108,48 @@ def test_MosaicSelfRef_vel_tconst(): assert 'y0_err' in msc.ref_table.colnames assert 'm0' in msc.ref_table.colnames assert 'm0_err' in msc.ref_table.colnames - assert 'vx' in msc.ref_table.colnames - assert 'vx_err' in msc.ref_table.colnames - assert 'vy' in msc.ref_table.colnames - assert 'vy_err' in msc.ref_table.colnames + # Since they are in the same epoch, no velocity information can be inferred + # assert 'vx' in msc.ref_table.colnames + # assert 'vx_err' in msc.ref_table.colnames + # assert 'vy' in msc.ref_table.colnames + # assert 'vy_err' in msc.ref_table.colnames assert 't0' in msc.ref_table.colnames # Check that we have some matched stars... should be at least 35 stars # that are detected in all 4 starlists. idx = np.where(msc.ref_table['n_detect'] == 4)[0] - assert len(idx) > 35 + assert len(idx) > 35 # Check that the transformation error isn't too big - assert (msc.ref_table['x0_err'] < 3.0).all() # less than 1 pix - assert (msc.ref_table['y0_err'] < 3.0).all() - assert (msc.ref_table['m0_err'] < 1.0).all() # less than 0.5 mag - + valid_err = np.isfinite(msc.ref_table['x0_err']) & np.isfinite(msc.ref_table['y0_err']) & np.isfinite(msc.ref_table['m0_err']) + assert (msc.ref_table['x0_err'][valid_err] < 3.0).all() # less than 1 pix + assert (msc.ref_table['y0_err'][valid_err] < 3.0).all() + assert (msc.ref_table['m0_err'][valid_err] < 1.0).all() # less than 0.5 mag + # Check that the transformation lists aren't too wacky for ii in range(4): np.testing.assert_allclose(msc.trans_list[ii].px.c1_0, 1.0, rtol=1e-2) np.testing.assert_allclose(msc.trans_list[ii].py.c0_1, 1.0, rtol=1e-2) - - # Check that the velocities aren't crazy... - # they should be non-existent (since there is no time difference) - assert np.isnan(msc.ref_table['vx']).all() - assert np.isnan(msc.ref_table['vy']).all() - assert np.isnan(msc.ref_table['vx_err']).all() - assert np.isnan(msc.ref_table['vy_err']).all() - return def test_MosaicSelfRef_vel(): """ Cross-match and align 4 starlists using the OO version of mosaic lists. - """ - list_files = ['A.lis', 'B.lis', 'C.lis', 'D.lis'] + list_files = [f'{test_data_path}/{f}' for f in ['A.lis', 'B.lis', 'C.lis', 'D.lis']] lists = [starlists.StarList.from_lis_file(lf) for lf in list_files] # Modify the times so that we get velocities out. - lists[0].meta['list_time'] = 2001.4 + lists[0].meta['list_times'] = 2001.4 lists[0]['t'] = 2001.4 - - lists[1].meta['list_time'] = 2002.4 + + lists[1].meta['list_times'] = 2002.4 lists[1]['t'] = 2002.4 - - lists[2].meta['list_time'] = 2003.4 + + lists[2].meta['list_times'] = 2003.4 lists[2]['t'] = 2003.4 - - lists[3].meta['list_time'] = 2004.4 + + lists[3].meta['list_times'] = 2004.4 lists[3]['t'] = 2004.4 @@ -170,13 +157,13 @@ def test_MosaicSelfRef_vel(): # Test instantiation and basic fitting. ########## msc = align.MosaicSelfRef(lists, ref_index=0, iters=3, - dr_tol=[5, 3, 3], dm_tol=[1, 1, 0.5], outlier_tol=None, + dr_tol=[5, 3, 3], dm_tol=[1, 1, 0.5], outlier_tol=None, briteN=30, trans_class=transforms.PolyTransform, - trans_args={'order': 2}, default_motion_model='Linear', + trans_args={'order': 2}, motion_models=['Empty', 'Fixed', 'Linear'], verbose=False) msc.fit() - + # Check some of the output quantities on the final table. assert 'x0' in msc.ref_table.colnames assert 'x0_err' in msc.ref_table.colnames @@ -193,49 +180,44 @@ def test_MosaicSelfRef_vel(): # Check that we have some matched stars... should be at least 35 stars # that are detected in all 4 starlists. idx = np.where(msc.ref_table['n_detect'] == 4)[0] - assert len(idx) > 35 + assert len(idx) >= 35, f"Expected at least 35 stars detected in all 4 starlists, but only found {len(idx)}" # Check that the transformation error isn't too big - assert (msc.ref_table['x0_err'] < 3.0).all() # less than 1 pix - assert (msc.ref_table['y0_err'] < 3.0).all() - assert (msc.ref_table['m0_err'] < 1.0).all() # less than 0.5 mag - + valid_err = np.isfinite(msc.ref_table['x0_err']) & np.isfinite(msc.ref_table['y0_err']) & np.isfinite(msc.ref_table['m0_err']) + assert (msc.ref_table['x0_err'][valid_err] < 3.0).all() # less than 1 pix + assert (msc.ref_table['y0_err'][valid_err] < 3.0).all() + assert (msc.ref_table['m0_err'][valid_err] < 1.0).all() # less than 0.5 mag + # Check that the transformation lists aren't too wacky for ii in range(4): - np.testing.assert_allclose(msc.trans_list[ii].px.c1_0, 1.0, rtol=1e-2) - np.testing.assert_allclose(msc.trans_list[ii].py.c0_1, 1.0, rtol=1e-2) - + np.testing.assert_allclose(msc.trans_list[ii].px.c1_0, 1.0, rtol=2e-2) + np.testing.assert_allclose(msc.trans_list[ii].py.c0_1, 1.0, rtol=2e-2) + plt.clf() plt.plot(msc.ref_table['vx'], msc.ref_table['vy'], 'k.', color='black', alpha=0.2) + return def test_MosaicToRef(): make_fake_starlists_poly1(seed=42) - - ref_file = 'random_ref.fits' - list_files = ['random_0.fits', - 'random_1.fits', - 'random_2.fits', - 'random_3.fits', - 'random_4.fits', - 'random_5.fits', - 'random_6.fits', - 'random_7.fits'] + + ref_file = f'{test_data_path}/random_ref.fits' + list_files = [f'{test_data_path}/random_{i}.fits' for i in range(8)] ref_list = Table.read(ref_file) # Switch our list to a "increasing to the West" list. ref_list['x0'] *= -1.0 - + lists = [starlists.StarList.read(lf) for lf in list_files] msc = align.MosaicToRef(ref_list, lists, iters=2, dr_tol=[0.2, 0.1], dm_tol=[1, 0.5], trans_class=transforms.PolyTransform, - trans_args={'order': 2}, default_motion_model='Fixed', + trans_args={'order': 2}, motion_models=['Empty', 'Fixed'], update_ref_orig=False, verbose=False) msc.fit() @@ -266,21 +248,14 @@ def test_MosaicToRef(): # Also double check that they aren't exactly the same for the reference stars. assert np.not_equal(msc.ref_table['x0'], ref_list['x0']).all() assert np.not_equal(msc.ref_table['y0'], ref_list['y0']).all() - - return msc + + return def test_MosaicToRef_p0_vel(): make_fake_starlists_poly0_vel(seed=42) - - ref_file = 'random_vel_ref.fits' - list_files = ['random_vel_p0_0.fits', - 'random_vel_p0_1.fits', - 'random_vel_p0_2.fits', - 'random_vel_p0_3.fits'] - #'random_vel_4.fits', - #'random_vel_5.fits', - #'random_vel_6.fits', - #'random_vel_7.fits'] + + ref_file = f'{test_data_path}/random_vel_ref.fits' + list_files = [f'{test_data_path}/random_vel_p0_{i}.fits' for i in range(4)] ref_list = Table.read(ref_file) @@ -293,14 +268,14 @@ def test_MosaicToRef_p0_vel(): # Switch our list to a "increasing to the West" list. ref_list['x0'] *= -1.0 ref_list['vx'] *= -1.0 - + lists = [starlists.StarList.read(lf) for lf in list_files] msc = align.MosaicToRef(ref_list, lists, iters=2, dr_tol=[0.2, 0.1], dm_tol=[1, 0.5], outlier_tol=[None, None], trans_class=transforms.PolyTransform, - trans_args={'order': 1}, default_motion_model='Linear', + trans_args={'order': 1}, motion_models=['Empty', 'Fixed', 'Linear'], update_ref_orig=False, verbose=False) msc.fit() @@ -326,27 +301,20 @@ def test_MosaicToRef_p0_vel(): # The velocities should be almost the same (but not as close as before) # as the input velocities since update_ref == True. assert (msc.ref_table['name']==ref_list['name']).all() - assert np.max(np.abs(msc.ref_table['vx']-ref_list['vx']))<3e-4 - assert np.max(np.abs(msc.ref_table['vy']-ref_list['vy']))<3e-4 + np.testing.assert_allclose(msc.ref_table['vx'], ref_list['vx'], rtol=1e-1, atol=3e-4) + np.testing.assert_allclose(msc.ref_table['vy'], ref_list['vy'], rtol=1e-1, atol=3e-4) # Also double check that they aren't exactly the same for the reference stars. #assert np.any(np.not_equal(msc.ref_table['vx'], ref_list['vx'])) assert np.not_equal(msc.ref_table['vx'], ref_list['vx']).any() - - return msc + + return def test_MosaicToRef_vel(): make_fake_starlists_poly1_vel(seed=42) - - ref_file = 'random_vel_ref.fits' - list_files = ['random_vel_0.fits', - 'random_vel_1.fits', - 'random_vel_2.fits', - 'random_vel_3.fits'] - #'random_vel_4.fits', - #'random_vel_5.fits', - #'random_vel_6.fits', - #'random_vel_7.fits'] + + ref_file = f'{test_data_path}/random_vel_ref.fits' + list_files = [f'{test_data_path}/random_vel_{i}.fits' for i in range(4)] ref_list = Table.read(ref_file) @@ -359,14 +327,14 @@ def test_MosaicToRef_vel(): # Switch our list to a "increasing to the West" list. ref_list['x0'] *= -1.0 ref_list['vx'] *= -1.0 - + lists = [starlists.StarList.read(lf) for lf in list_files] msc = align.MosaicToRef(ref_list, lists, iters=2, dr_tol=[0.2, 0.1], dm_tol=[1, 0.5], outlier_tol=[None, None], trans_class=transforms.PolyTransform, - trans_args={'order': 1}, default_motion_model='Linear', + trans_args={'order': 1}, motion_models=['Empty', 'Fixed', 'Linear'], update_ref_orig=False, verbose=False) msc.fit() @@ -377,14 +345,14 @@ def test_MosaicToRef_vel(): assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape - # The velocities should be almost the same as the input + # The velocities should be almost the same as the input # velocities since update_ref_orig == False. assert (msc.ref_table['name']==ref_list['name']).all() np.testing.assert_allclose(msc.ref_table['vx'], ref_list['vx'], rtol=1e-5) np.testing.assert_allclose(msc.ref_table['vy'], ref_list['vy'], rtol=1e-5) ########## - # Align and let velocities be free. + # Align and let velocities be free. ########## msc.update_ref_orig = 'periter' msc.fit() @@ -398,21 +366,14 @@ def test_MosaicToRef_vel(): # Also double check that they aren't exactly the same for the reference stars. #assert np.any(np.not_equal(msc.ref_table['vx'], ref_list['vx'])) assert np.not_equal(msc.ref_table['vx'], ref_list['vx']).any() - - return msc + + return def test_MosaicToRef_acc(): make_fake_starlists_poly1_acc(seed=42) - - ref_file = 'random_acc_ref.fits' - list_files = ['random_acc_0.fits', - 'random_acc_1.fits', - 'random_acc_2.fits', - 'random_acc_3.fits', - 'random_acc_4.fits', - 'random_acc_5.fits', - 'random_acc_6.fits', - 'random_acc_7.fits'] + + ref_file = f'{test_data_path}/random_acc_ref.fits' + list_files = [f'{test_data_path}/random_acc_{i}.fits' for i in range(8)] ref_list = Table.read(ref_file) @@ -427,19 +388,19 @@ def test_MosaicToRef_acc(): ref_list['ay'] *= 1e-3 ref_list['ax_err'] *= 1e-3 ref_list['ay_err'] *= 1e-3 - + # Switch our list to a "increasing to the West" list. ref_list['x0'] *= -1.0 ref_list['vx0'] *= -1.0 ref_list['ax'] *= -1.0 - + lists = [starlists.StarList.read(lf) for lf in list_files] msc = align.MosaicToRef(ref_list, lists, iters=2, dr_tol=[0.4, 0.2], dm_tol=[1, 0.5], trans_class=transforms.PolyTransform, trans_args={'order': 2}, - default_motion_model='Acceleration', + motion_models=['Acceleration'], update_ref_orig=False, verbose=False) msc.fit() @@ -451,7 +412,7 @@ def test_MosaicToRef_acc(): assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape - # The velocities should be almost the same as the input + # The velocities should be almost the same as the input # velocities since update_ref_orig == False. i_orig, i_fit = [],[] for i,star in enumerate(ref_list["name"]): @@ -462,7 +423,7 @@ def test_MosaicToRef_acc(): np.testing.assert_allclose(msc.ref_table['ay'][i_fit], ref_list['ay'][i_orig], rtol=1e-5) ########## - # Align and let velocities be free. + # Align and let velocities be free. ########## msc.update_ref_orig = 'periter' msc.fit() @@ -476,257 +437,528 @@ def test_MosaicToRef_acc(): if ~np.isnan(msc.ref_table['ax'][ix_fit]): i_orig.append(i) i_fit.append(ix_fit) - np.testing.assert_allclose(msc.ref_table['ax'][i_fit], ref_list['ax'][i_orig], rtol=1e-1, atol=3e-4) - np.testing.assert_allclose(msc.ref_table['ay'][i_fit], ref_list['ay'][i_orig], rtol=1e-1, atol=3e-4) + # Accelerations all too small, rtol doesn't work well here. + atol = 3e-4 + np.testing.assert_allclose(msc.ref_table['ax'][i_fit], ref_list['ax'][i_orig], atol=atol) + np.testing.assert_allclose(msc.ref_table['ay'][i_fit], ref_list['ay'][i_orig], atol=atol) + + ax_min = np.min(ref_list['ax'][i_orig]) + ax_max = np.max(ref_list['ax'][i_orig]) + ay_min = np.min(ref_list['ay'][i_orig]) + ay_max = np.max(ref_list['ay'][i_orig]) + + plt.clf() + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5)) + ax1.plot(ref_list['ax'][i_orig], msc.ref_table['ax'][i_fit], '.') + ax1.plot([ax_min, ax_max], [ax_min, ax_max], color='C3') + ax1.plot([ax_min, ax_max], [ax_min - atol, ax_max - atol], ls='--', color='C3') + ax1.plot([ax_min, ax_max], [ax_min + atol, ax_max + atol], ls='--', color='C3') + ax1.set_xlabel('Input ax') + ax1.set_ylabel('Ref Table ax') + ax1.set_title('Acceleration in X') + + ax2.plot(ref_list['ay'][i_orig], msc.ref_table['ay'][i_fit], '.') + ax2.plot([ay_min, ay_max], [ay_min, ay_max], color='C3') + ax2.plot([ay_min, ay_max], [ay_min - atol, ay_max - atol], ls='--', color='C3') + ax2.plot([ay_min, ay_max], [ay_min + atol, ay_max + atol], ls='--', color='C3') + ax2.set_xlabel('Input ay') + ax2.set_ylabel('Ref Table ay') + ax2.set_title('Acceleration in Y') + plt.tight_layout() # Also double check that they aren't exactly the same for the reference stars. - assert np.any(np.not_equal(msc.ref_table['ax'][:200], ref_list['ax'][:200])) - - return msc + assert np.any(np.not_equal(msc.ref_table['ax'][i_fit], ref_list['ax'][i_orig])) + return +def test_MosaicToRef_hst_me(): + """ + Test Casey's issue with 'me' not getting propogated + from the input starlists to the output table. -def make_fake_starlists_shifts(): - N_stars = 200 - x = np.random.rand(N_stars) * 1000 - y = np.random.rand(N_stars) * 1000 - m = (np.random.rand(N_stars) * 8) + 9 - - sdx = np.argsort(m) - x = x[sdx] - y = y[sdx] - m = m[sdx] - - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + Use data from MB10-364 microlensing target for the test. + """ + # Target RA and Dec (MOA data download) + # ra = '17:57:05.401' + # dec = '-34:27:05.01' - # Save original positions as reference (1st) list. - fmt = '{0:10s} {1:5.2f} 2015.0 {2:9.4f} {3:9.4f} 0 0 0 0\n' - _out = open('random_0.lis', 'w') - for ii in range(N_stars): - _out.write(fmt.format(name[ii], m[ii], x[ii], y[ii])) - _out.close() + # Load up a Gaia catalog (queried around the RA/Dec above) + my_gaia = Table.read(f'{test_data_path}/mb10364_data/my_gaia.fits') + my_gaia['me'] = 0.01 + my_gaia.rename_columns( + ['x0e', 'y0e', 'vxe', 'vye'], + ['x0_err', 'y0_err', 'vx_err', 'vy_err'] + ) + # Gather the list of starlists. For first pass, don't modify the starlists. + # Loop through the observations and read them in, in prep for alignment with Gaia + epochs = [2011.83, 2012.73, 2013.81] + starlist_names = [f'{test_data_path}/mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib', + f'{test_data_path}/mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib', + f'{test_data_path}/mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib'] - ########## - # Shifts - ########## - # Make 4 new starlists with different shifts. - shifts = [[ 6.5, 10.1], - [100.3, 50.5], - [-30.0,-100.7], - [250.0,-250.0]] + list_of_starlists = [] - for ss in range(len(shifts)): - xnew = x - shifts[ss][0] - ynew = y - shifts[ss][1] + # Just using the F606W filters first. + for ee in range(len(starlist_names)): + lis = starlists.StarList.from_lis_file(starlist_names[ee]) - # Perturb with small errors (0.1 pix) - xnew += np.random.randn(N_stars) * 0.1 - ynew += np.random.randn(N_stars) * 0.1 + # # Add additive error term. MAYBE YOU DON'T NEED THIS + # lis['xe'] = np.hypot(lis['xe'], 0.01) # Adding 0.01 pix (0.1 mas) in quadrature. + # lis['ye'] = np.hypot(lis['ye'], 0.01) - mnew = m + np.random.randn(N_stars) * 0.05 + lis['t'] = epochs[ee] - _out = open('random_shift_{0:d}.lis'.format(ss+1), 'w') - for ii in range(N_stars): - _out.write(fmt.format(name[ii], mnew[ii], xnew[ii], ynew[ii])) - _out.close() + # Lets dump the faint stars. + idx = np.where(lis['m'] < 20.0)[0] + lis = lis[idx] - return shifts + list_of_starlists.append(lis) -def make_fake_starlists_poly1(seed=-1): - # If seed >=0, then set random seed to that value - if seed >= 0: - np.random.seed(seed=seed) - - N_stars = 200 + msc = align.MosaicToRef( + my_gaia, list_of_starlists, iters=1, + dr_tol=[0.1], dm_tol=[5], + outlier_tol=[None], mag_lim=[13, 21], + trans_class=transforms.PolyTransform, + trans_args=[{'order': 1}], + motion_models=['Empty', 'Fixed'], + use_ref_new=False, + update_ref_orig=False, + mag_trans=False, + trans_weighting='both,std', + init_guess_mode='miracle', + # save_path=f'{test_data_path}/mb10364_data/test_MosaicToRef_hst_me.pkl', + verbose=False + ) + msc.fit() - x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) - y0 = np.random.rand(N_stars) * 10.0 # arcsec - x0e = np.random.randn(N_stars) * 5.0e-4 # arcsec - y0e = np.random.randn(N_stars) * 5.0e-4 # arcsec - m0 = (np.random.rand(N_stars) * 8) + 9 # mag - m0e = np.random.randn(N_stars) * 0.05 # mag - t0 = np.ones(N_stars) * 2019.5 + assert 'me' in msc.ref_table.colnames + return - # Make all the errors positive - x0e = np.abs(x0e) - y0e = np.abs(y0e) - m0e = np.abs(m0e) - - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] +def test_bootstrap(): + """ + Test to make sure calc_bootstrap_error() call is working + properly (e.g., only called when user calls calc_bootstrap_error, + n_boot param for calc_bootstrap_error only, boot_epochs_min working, + etc.) + """ + # Read in starlists for MosaicToRef + ref = Table.read(f'{test_data_path}/ref_vel.lis', format='ascii') + list1 = Table.read(f'{test_data_path}/E.lis', format='ascii') + list2 = Table.read(f'{test_data_path}/F.lis', format='ascii') - # Make an StarList - lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, t0], - names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', 't0')) - - sdx = np.argsort(m0) - lis = lis[sdx] + list1 = starlists.StarList.from_table(list1) + list2 = starlists.StarList.from_table(list2) - # Save original positions as reference (1st) list - # in a StarList format (with velocities). - lis.write('random_ref.fits', overwrite=True) + # Set parameters for alignment + transModel = transforms.PolyTransform + trans_args = {'order':2} + N_loop = 1 + dr_tol = 0.08 + dm_tol = 99 + outlier_tol = None + mag_lim = None + ref_mag_lim = None + trans_weighting = 'both,var' + mag_trans = False - ########## - # Shifts - ########## - # Make 4 new starlists with different shifts. - times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] - xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], - [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], - [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], - [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], - [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], - [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], - [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], - [[ 94.0, 1.00, 9e-6], [-182.0, 0.0, 0.99]]] - mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] - - # Convert into pixels (undistorted) with the following info. - scale = 0.01 # arcsec / pix - shift = [1.0, 1.0] # pix + n_boot = 15 + boot_epochs_min=-1 - for ss in range(len(times)): - dt = times[ss] - lis['t0'] - - x = lis['x0'] - y = lis['y0'] - t = np.ones(N_stars) * times[ss] + # Run FLYSTAR, no bootstraps yet! + match1 = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, + dm_tol=dm_tol, outlier_tol=outlier_tol, + trans_class=transModel, + trans_args=trans_args, + mag_trans=mag_trans, + mag_lim=mag_lim, + ref_mag_lim=ref_mag_lim, + trans_weighting=trans_weighting, + motion_models=['Linear'], + use_ref_new=False, + update_ref_orig=False, + init_guess_mode='name', + verbose=False) + match1.fit() - # Convert into pixels - xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) - yp = (y / scale) + shift[1] - xpe = lis['x0_err'] / scale - ype = lis['y0_err'] / scale + # Make sure no bootstrap columns exist + assert 'xe_boot' not in match1.ref_table.keys() + assert 'ye_boot' not in match1.ref_table.keys() + assert 'vxe_boot' not in match1.ref_table.keys() + assert 'vye_boot' not in match1.ref_table.keys() - # Distort the positions - trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) - xd, yd = trans.evaluate(xp, yp) - md = trans.evaluate_mag(lis['m0']) + # Run bootstrap: no boot_epochs_min + match1.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min, seed=42) + # Make sure columns exist, and none of them are nan values + assert np.sum(np.isnan(match1.ref_table['xe_boot'])) == 0 + assert np.sum(np.isnan(match1.ref_table['ye_boot'])) == 0 + assert np.sum(np.isnan(match1.ref_table['vx_err_boot'])) == 0 + assert np.sum(np.isnan(match1.ref_table['vy_err_boot'])) == 0 - # Perturb with small errors (0.1 pix) - xd += np.random.randn(N_stars) * 0.1 - yd += np.random.randn(N_stars) * 0.1 - md += np.random.randn(N_stars) * 0.02 - xde = xpe - yde = ype - mde = lis['m0_err'] + # Test 2: make sure boot_epochs_min is working + # Eliminate some rows to list2, so some stars are only in 1 epoch. + # Rerun align. Some stars should only be detected in 1 epoch + list3 = list2[0:60] - # Save the new list as a starlist. - new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], - names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + match2 = align.MosaicToRef(ref, [list1, list3], iters=N_loop, dr_tol=dr_tol, + dm_tol=dm_tol, outlier_tol=outlier_tol, + trans_class=transModel, + trans_args=trans_args, + mag_trans=mag_trans, + mag_lim=mag_lim, + ref_mag_lim=ref_mag_lim, + trans_weighting=trans_weighting, + motion_models=['Linear'], + use_ref_new=False, + update_ref_orig=False, + init_guess_mode='name', + verbose=False) + match2.fit() - new_lis.write('random_{0:d}.fits'.format(ss), overwrite=True) + # Now run_calc_bootstrap_error, with boot_epochs_min engaged + boot_epochs_min2 = 2 + match2.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min2, seed=42) - return (xy_trans,mag_trans) + # Make sure boot_epochs_min cut worked as intended + out = match2.ref_table + bad = np.where( (out['n_detect'] == 1) & (out['use_in_trans'] == False) ) + good = np.where(out['n_detect'] == 2) -def make_fake_starlists_poly0_vel(seed=-1): - # If seed >=0, then set random seed to that value - if seed >= 0: - np.random.seed(seed=seed) - - N_stars = 200 + # Some stars must exist in both "good" and "bad" criteria, + # otherwise this test isn't as useful as intended. + assert len(bad[0]) > 0 + assert len(good[0]) > 0 - x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) - y0 = np.random.rand(N_stars) * 10.0 # arcsec - x0e = np.ones(N_stars) * 1.0e-4 # arcsec - y0e = np.ones(N_stars) * 1.0e-4 # arcsec - vx = np.random.randn(N_stars) * 5.0 # mas / yr - vy = np.random.randn(N_stars) * 5.0 # mas / yr - vxe = np.ones(N_stars) * 0.05 # mas / yr - vye = np.ones(N_stars) * 0.05 # mas / yr - m0 = (np.random.rand(N_stars) * 8) + 9 # mag - m0e = np.random.randn(N_stars) * 0.05 # mag - t0 = np.ones(N_stars) * 2019.5 + # For "good" stars: all bootstrap vals should be present + assert np.sum(~np.isfinite(out['xe_boot'][good])) == 0 + assert np.sum(~np.isfinite(out['ye_boot'][good])) == 0 + assert np.sum(~np.isfinite(out['vx_err_boot'][good])) == 0 + assert np.sum(~np.isfinite(out['vy_err_boot'][good])) == 0 + + # For "bad" stars, all bootstrap vals should be nans + assert np.sum(np.isfinite(out['xe_boot'][bad])) == 0 + assert np.sum(np.isfinite(out['ye_boot'][bad])) == 0 + assert np.sum(np.isfinite(out['vx_err_boot'][bad])) == 0 + assert np.sum(np.isfinite(out['vy_err_boot'][bad])) == 0 + + return + +def test_calc_vel_in_bootstrap(): + """ + Check calc_vel_in_bootstrap performance in calc_bootstrap_errors() + + Only calculate velocity bootstrap (e.g., bootstrap over epochs and + calculating proper motions) if calc_vel_in_bootstrap=True. + + """ + import copy + + # Define match parameters + ref = Table.read(f'{test_data_path}/ref_vel.lis', format='ascii') + list1 = Table.read(f'{test_data_path}/E.lis', format='ascii') + list2 = Table.read(f'{test_data_path}/F.lis', format='ascii') + + list1 = starlists.StarList.from_table(list1) + list2 = starlists.StarList.from_table(list2) + + # Set parameters for alignment + transModel = transforms.PolyTransform + trans_args = {'order':2} + N_loop = 1 + dr_tol = 0.08 + dm_tol = 99 + outlier_tol = None + mag_lim = None + ref_mag_lim = None + trans_weighting = 'both,var' + mag_trans = False + + n_boot = 15 + boot_epochs_min=-1 + + # Run match + match = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, + dm_tol=dm_tol, outlier_tol=outlier_tol, + trans_class=transModel, + trans_args=trans_args, + mag_trans=mag_trans, + mag_lim=mag_lim, + ref_mag_lim=ref_mag_lim, + trans_weighting=trans_weighting, + motion_models=['Linear'], + use_ref_new=False, + update_ref_orig=False, + init_guess_mode='name', + verbose=False) + match.fit() + + # Make 2 copies of match object: one to test + # each case of calc_vel_in_bootstrap + match_vel = copy.deepcopy(match) + + # Run calc_bootstrap_error function with calc_vel_in_bootstrap=True. + # Make sure bootstrap velocity errors are calculated and valid + n_boot = 50 + match_vel.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=True, seed=42) + + assert 'xe_boot' in match_vel.ref_table.keys() + assert np.sum(np.isnan(match_vel.ref_table['xe_boot'])) == 0 + assert 'vx_err_boot' in match_vel.ref_table.keys() + assert np.sum(np.isnan(match_vel.ref_table['vx_err_boot'])) == 0 + + # Run without calc_vel_in_bootstrap, make sure velocities are NOT calculated + match.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=False, seed=42) + + assert 'xe_boot' in match.ref_table.keys() + assert np.sum(np.isnan(match.ref_table['xe_boot'])) == 0 + assert 'vx_err_boot' not in match.ref_table.keys() + + return + +def test_transform_xym(): + """ + Test to make sure transforms are being done to mags only + if mag_trans = True. This can cause subtle bugs + otherwise + """ + #---Align 1: self.mag_Trans = False---# + ref = Table.read(f'{test_data_path}/ref_vel.lis', format='ascii') + list1 = Table.read(f'{test_data_path}/E.lis', format='ascii') + list2 = Table.read(f'{test_data_path}/F.lis', format='ascii') + + list1 = starlists.StarList.from_table(list1) + list2 = starlists.StarList.from_table(list2) + + # Set parameters for alignment + transModel = transforms.PolyTransform + trans_args = {'order':2} + N_loop = 1 + dr_tol = 0.08 + dm_tol = 99 + outlier_tol = None + mag_lim = None + ref_mag_lim = None + trans_weighting = 'both,var' + n_boot = 15 + + mag_trans = False + + # Run FLYSTAR, with bootstraps + match1 = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, + dm_tol=dm_tol, outlier_tol=outlier_tol, + trans_class=transModel, + trans_args=trans_args, + mag_trans=mag_trans, + mag_lim=mag_lim, + ref_mag_lim=ref_mag_lim, + trans_weighting=trans_weighting, + motion_models=['Fixed'], + use_ref_new=False, + update_ref_orig=False, + init_guess_mode='name', + verbose=False) + + match1.fit() + match1.calc_bootstrap_errors(n_boot=n_boot, seed=42) + + # Make sure all transformations have mag_offset = 0 + trans_list = match1.trans_list + + for ii in trans_list: + assert ii.mag_offset == 0 + + # Check that no mag transformation has been applied to m col in ref_table + tab1 = match1.ref_table + assert np.all(tab1['m'] == tab1['m_orig']) + + # Check me_boost == 0 or really small (should be the case + # since we don't transform mags) + assert np.isclose(np.max(tab1['me_boot']), 0, rtol=10**-5) + print('Done mag_trans = False case') + + #---Align 2: self.mag_Trans = True---# + # Repeat, this time with mag_trans = False + mag_trans = True + match2 = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, + dm_tol=dm_tol, outlier_tol=outlier_tol, + trans_class=transModel, + trans_args=trans_args, + mag_trans=mag_trans, + mag_lim=mag_lim, + ref_mag_lim=ref_mag_lim, + trans_weighting=trans_weighting, + motion_models=['Fixed'], + use_ref_new=False, + update_ref_orig=False, + init_guess_mode='name', + verbose=False) + + match2.fit() + match2.calc_bootstrap_errors(n_boot=n_boot, seed=42) + + + # Make sure all transformations have correct mag offset + trans_list2 = match2.trans_list + + for ii in trans_list2: + assert ii.mag_offset > 20 + + # Make sure final table mags have transform applied (i.e, + tab2 = match2.ref_table + assert np.all(tab2['m'] != tab2['m_orig']) + + # Check me_boost > 0 + assert np.min(tab2['me_boot']) > 10**-3 + + print('Done mag_trans = True case') + + return + +def test_MosaicToRef_mag_bug(): + """ + Bug found by Tuan Do on 2020-04-12. + """ + make_fake_starlists_poly1_vel(seed=42) + + ref_list = starlists.StarList.read(f'{test_data_path}/random_vel_0.fits') + lists = [ref_list] + + msc = align.MosaicToRef(ref_list, lists, + mag_trans=True, + iters=1, + dr_tol=[0.2], dm_tol=[1], + outlier_tol=None, + trans_class=transforms.PolyTransform, + trans_args=[{'order': 1}], + motion_models=['Fixed'], + use_ref_new=False, + update_ref_orig=False, + verbose=True) + + msc.fit() + + out_tab = msc.ref_table + + # The issue is that in the initial guess with + # mag_trans = True + # somehow the transformed magnitudes are nan. + # This causes zero matches to occur. + assert len(out_tab) == len(ref_list) + + return + +def test_masked_cols(): + """ + Test to make sure analysis.prepare_gaia_for_flystar + produces an astropy.table.Table, NOT a masked column + table. MosaicToRef cannot handle masked column tables. + + Also make sure this example works, since we use it for the examples + jupyter notebook. + """ + # Get gaia reference stars using analysis.py + # around a test location. + # target = 'ob150029' + ra = '17:59:46.60' + dec = '-28:38:41.8' + + # Coordinates are arcsecs offset +x to the East. + targets_dict = { + 'ob150029': [0.0, 0.0], + 'S005': [1.1416, 3.7405], + 'S002': [-4.421, 0.027] + } + + # Get gaia catalog stars. Note that this produces a masked column table + search_rad = 10.0 # arcsec + gaia = analysis.query_gaia(ra, dec, search_radius=search_rad) + my_gaia = analysis.prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=targets_dict) + + assert isinstance(my_gaia, Table) + + # Let's make sure the entire align runs, just to be safe + + # Get starlists to align to gaia + epochs = ['15jun07','16jul14', '17may21'] + + list_of_starlists = [] + + for ee in range(len(epochs)): + lis_file = 'mag' + epochs[ee] + '_ob150029_kp_rms_named.lis' + lis = starlists.StarList.from_lis_file(f'{test_data_path}/{lis_file}') + list_of_starlists.append(lis) + + # Run the align + msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=2, + dr_tol=[0.2, 0.1], dm_tol=[1, 1], + trans_class=transforms.PolyTransform, + trans_args=[{'order': 1}, {'order': 1}], + motion_models=['Linear'], + use_ref_new=False, + update_ref_orig=False, + mag_trans=True, + init_guess_mode='name', verbose=True) + + msc.fit() + return + +def make_fake_starlists_shifts(): + N_stars = 200 + x = np.random.rand(N_stars) * 1000 + y = np.random.rand(N_stars) * 1000 + m = (np.random.rand(N_stars) * 8) + 9 + + sdx = np.argsort(m) + x = x[sdx] + y = y[sdx] + m = m[sdx] - # Make all the errors positive - x0e = np.abs(x0e) - y0e = np.abs(y0e) - m0e = np.abs(m0e) - vxe = np.abs(vxe) - vye = np.abs(vye) - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] - # Make an StarList - lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, vx, vxe, vy, vye, t0], - names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', - 'vx', 'vx_err', 'vy', 'vy_err', 't0')) - - sdx = np.argsort(m0) - lis = lis[sdx] + # Save original positions as reference (1st) list. + fmt = '{0:10s} {1:5.2f} 2015.0 {2:9.4f} {3:9.4f} 0 0 0 0\n' + _out = open(f'{test_data_path}/random_0.lis', 'w') + for ii in range(N_stars): + _out.write(fmt.format(name[ii], m[ii], x[ii], y[ii])) + _out.close() + - # Save original positions as reference (1st) list - # in a StarList format (with velocities). - lis.write('random_vel_ref.fits', overwrite=True) - ########## - # Propogate to new times and distort. + # Shifts ########## - # Make 4 new starlists with different epochs and transformations. - times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] - xy_trans = [[[ 6.5], [ 10.1]], - [[100.3], [ 50.5]], - [[ 0.0], [ 0.0]], - [[250.0], [-250.0]], - [[ 50.0], [ -31.0]], - [[ 78.0], [ 45.0]], - [[-13.0], [ 150]], - [[ 94.0], [-182.0]]] - mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] - - # Convert into pixels (undistorted) with the following info. - scale = 0.01 # arcsec / pix - shift = [1.0, 1.0] # pix - - for ss in range(len(times)): - dt = times[ss] - lis['t0'] - - x = lis['x0'] + (lis['vx']/1e3) * dt - y = lis['y0'] + (lis['vy']/1e3) * dt - t = np.ones(N_stars) * times[ss] - - # Convert into pixels - xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) - yp = (y / scale) + shift[1] - xpe = lis['x0_err'] / scale - ype = lis['y0_err'] / scale + # Make 4 new starlists with different shifts. + shifts = [[ 6.5, 10.1], + [100.3, 50.5], + [-30.0,-100.7], + [250.0,-250.0]] - # Distort the positions - trans = transforms.PolyTransform(0, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) - xd, yd = trans.evaluate(xp, yp) - md = trans.evaluate_mag(lis['m0']) + for ss in range(len(shifts)): + xnew = x - shifts[ss][0] + ynew = y - shifts[ss][1] # Perturb with small errors (0.1 pix) - xd += np.random.randn(N_stars) * xpe - yd += np.random.randn(N_stars) * ype - md += np.random.randn(N_stars) * 0.02 - xde = xpe - yde = ype - mde = lis['m0_err'] - - # Save the new list as a starlist. - new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], - names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + xnew += np.random.randn(N_stars) * 0.1 + ynew += np.random.randn(N_stars) * 0.1 - new_lis.write('random_vel_p0_{0:d}.fits'.format(ss), overwrite=True) + mnew = m + np.random.randn(N_stars) * 0.05 - return (xy_trans, mag_trans) + _out = open(f'{test_data_path}/random_shift_{ss+1}.lis', 'w') + for ii in range(N_stars): + _out.write(fmt.format(name[ii], mnew[ii], xnew[ii], ynew[ii])) + _out.close() + return shifts -def make_fake_starlists_poly1_vel(seed=-1): +def make_fake_starlists_poly1(seed=-1): # If seed >=0, then set random seed to that value if seed >= 0: np.random.seed(seed=seed) - + N_stars = 200 x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) y0 = np.random.rand(N_stars) * 10.0 # arcsec - x0e = np.ones(N_stars) * 1.0e-4 # arcsec - y0e = np.ones(N_stars) * 1.0e-4 # arcsec - vx = np.random.randn(N_stars) * 5.0 # mas / yr - vy = np.random.randn(N_stars) * 5.0 # mas / yr - vxe = np.ones(N_stars) * 0.05 # mas / yr - vye = np.ones(N_stars) * 0.05 # mas / yr + x0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + y0e = np.random.randn(N_stars) * 5.0e-4 # arcsec m0 = (np.random.rand(N_stars) * 8) + 9 # mag m0e = np.random.randn(N_stars) * 0.05 # mag t0 = np.ones(N_stars) * 2019.5 @@ -735,32 +967,29 @@ def make_fake_starlists_poly1_vel(seed=-1): x0e = np.abs(x0e) y0e = np.abs(y0e) m0e = np.abs(m0e) - vxe = np.abs(vxe) - vye = np.abs(vye) - + name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] # Make an StarList - lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, vx, vxe, vy, vye, t0], - names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', - 'vx', 'vx_err', 'vy', 'vy_err', 't0')) - + lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, t0], + names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', 't0')) + sdx = np.argsort(m0) lis = lis[sdx] # Save original positions as reference (1st) list # in a StarList format (with velocities). - lis.write('random_vel_ref.fits', overwrite=True) - + lis.write(f'{test_data_path}/random_ref.fits', overwrite=True) + ########## - # Propogate to new times and distort. + # Shifts ########## - # Make 4 new starlists with different epochs and transformations. + # Make 4 new starlists with different shifts. times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], - [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.000]], - [[250.0, 1.01, 2e-5], [-250.0, 1e-5, 0.98]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], @@ -770,12 +999,12 @@ def make_fake_starlists_poly1_vel(seed=-1): # Convert into pixels (undistorted) with the following info. scale = 0.01 # arcsec / pix shift = [1.0, 1.0] # pix - + for ss in range(len(times)): dt = times[ss] - lis['t0'] - - x = lis['x0'] + (lis['vx']/1e3) * dt - y = lis['y0'] + (lis['vy']/1e3) * dt + + x = lis['x0'] + y = lis['y0'] t = np.ones(N_stars) * times[ss] # Convert into pixels @@ -789,27 +1018,35 @@ def make_fake_starlists_poly1_vel(seed=-1): xd, yd = trans.evaluate(xp, yp) md = trans.evaluate_mag(lis['m0']) - # Perturb with small errors (0.1 mas) - xd += np.random.randn(N_stars) * xpe - yd += np.random.randn(N_stars) * ype + # Perturb with small errors (0.1 pix) + xd += np.random.randn(N_stars) * 0.1 + yd += np.random.randn(N_stars) * 0.1 md += np.random.randn(N_stars) * 0.02 xde = xpe yde = ype mde = lis['m0_err'] + # fig, ax = plt.subplots() + # ax.scatter(x0, y0, s=2, label='Reference') + # ax.scatter(xd, yd, s=2, label='Starlist') + # ax.set_xlabel('X (pix)') + # ax.set_ylabel('Y (pix)') + # ax.legend() + # plt.show() + # Save the new list as a starlist. new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) - new_lis.write('random_vel_{0:d}.fits'.format(ss), overwrite=True) + new_lis.write(f'{test_data_path}/random_{ss}.fits', overwrite=True) - return (xy_trans, mag_trans) + return (xy_trans,mag_trans) -def make_fake_starlists_poly1_acc(seed=-1): +def make_fake_starlists_poly0_vel(seed=-1): # If seed >=0, then set random seed to that value if seed >= 0: np.random.seed(seed=seed) - + N_stars = 200 x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) @@ -818,12 +1055,8 @@ def make_fake_starlists_poly1_acc(seed=-1): y0e = np.ones(N_stars) * 1.0e-4 # arcsec vx = np.random.randn(N_stars) * 5.0 # mas / yr vy = np.random.randn(N_stars) * 5.0 # mas / yr - vxe = np.ones(N_stars) * 0.1 # mas / yr - vye = np.ones(N_stars) * 0.1 # mas / yr - ax = np.random.randn(N_stars) * 0.5 # mas / yr^2 - ay = np.random.randn(N_stars) * 0.5 # mas / yr^2 - axe = np.ones(N_stars) * 0.01 # mas / yr^2 - aye = np.ones(N_stars) * 0.01 # mas / yr^2 + vxe = np.ones(N_stars) * 0.05 # mas / yr + vye = np.ones(N_stars) * 0.05 # mas / yr m0 = (np.random.rand(N_stars) * 8) + 9 # mag m0e = np.random.randn(N_stars) * 0.05 # mag t0 = np.ones(N_stars) * 2019.5 @@ -834,54 +1067,45 @@ def make_fake_starlists_poly1_acc(seed=-1): m0e = np.abs(m0e) vxe = np.abs(vxe) vye = np.abs(vye) - axe = np.abs(axe) - aye = np.abs(aye) - - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + + name = [f'star_{ii:03d}' for ii in range(N_stars)] # Make an StarList - lis = starlists.StarList([name, m0, m0e, - x0, x0e, y0, y0e, - vx, vxe, vy, vye, - ax, axe, ay, aye, - t0], - names = ('name', 'm0', 'm0_err', - 'x0', 'x0_err', 'y0', 'y0_err', - 'vx0', 'vx0_err', 'vy0', 'vy0_err', - 'ax', 'ax_err', 'ay', 'ay_err', - 't0')) - + lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, vx, vxe, vy, vye, t0], + names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', + 'vx', 'vx_err', 'vy', 'vy_err', 't0')) + sdx = np.argsort(m0) lis = lis[sdx] # Save original positions as reference (1st) list # in a StarList format (with velocities). - lis.write('random_acc_ref.fits', overwrite=True) - + lis.write(f'{test_data_path}/random_vel_ref.fits', overwrite=True) + ########## # Propogate to new times and distort. ########## # Make 4 new starlists with different epochs and transformations. times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] - xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], - [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], - [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.000]], - [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], - [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], - [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], - [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], - [[ 94.0, 1.00, 9e-6], [-182.0, 0.0, 0.99]]] + xy_trans = [[[ 6.5], [ 10.1]], + [[100.3], [ 50.5]], + [[ 0.0], [ 0.0]], + [[250.0], [-250.0]], + [[ 50.0], [ -31.0]], + [[ 78.0], [ 45.0]], + [[-13.0], [ 150]], + [[ 94.0], [-182.0]]] mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] # Convert into pixels (undistorted) with the following info. scale = 0.01 # arcsec / pix shift = [1.0, 1.0] # pix - + for ss in range(len(times)): dt = times[ss] - lis['t0'] - - x = lis['x0'] + (lis['vx0']/1e3) * dt + 0.5*(lis['ax']/1e3) * dt**2 - y = lis['y0'] + (lis['vy0']/1e3) * dt + 0.5*(lis['ay']/1e3) * dt**2 + + x = lis['x0'] + (lis['vx']/1e3) * dt + y = lis['y0'] + (lis['vy']/1e3) * dt t = np.ones(N_stars) * times[ss] # Convert into pixels @@ -891,7 +1115,7 @@ def make_fake_starlists_poly1_acc(seed=-1): ype = lis['y0_err'] / scale # Distort the positions - trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + trans = transforms.PolyTransform(0, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) xd, yd = trans.evaluate(xp, yp) md = trans.evaluate_mag(lis['m0']) @@ -907,27 +1131,26 @@ def make_fake_starlists_poly1_acc(seed=-1): new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) - new_lis.write('random_acc_{0:d}.fits'.format(ss), overwrite=True) + new_lis.write(f'{test_data_path}/random_vel_p0_{ss}.fits', overwrite=True) return (xy_trans, mag_trans) - -def make_fake_starlists_poly1_par(seed=-1): + + +def make_fake_starlists_poly1_vel(seed=-1): # If seed >=0, then set random seed to that value if seed >= 0: np.random.seed(seed=seed) - + N_stars = 200 x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) y0 = np.random.rand(N_stars) * 10.0 # arcsec - x0e = np.random.randn(N_stars) * 5.0e-4 # arcsec - y0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + x0e = np.ones(N_stars) * 1.0e-4 # arcsec + y0e = np.ones(N_stars) * 1.0e-4 # arcsec vx = np.random.randn(N_stars) * 5.0 # mas / yr vy = np.random.randn(N_stars) * 5.0 # mas / yr - vxe = np.random.randn(N_stars) * 0.1 # mas / yr - vye = np.random.randn(N_stars) * 0.1 # mas / yr - pi = np.random.randn(N_stars) * 0.5 # mas - pie = np.random.randn(N_stars) * 0.01 # mas + vxe = np.ones(N_stars) * 0.05 # mas / yr + vye = np.ones(N_stars) * 0.05 # mas / yr m0 = (np.random.rand(N_stars) * 8) + 9 # mag m0e = np.random.randn(N_stars) * 0.05 # mag t0 = np.ones(N_stars) * 2019.5 @@ -938,62 +1161,45 @@ def make_fake_starlists_poly1_par(seed=-1): m0e = np.abs(m0e) vxe = np.abs(vxe) vye = np.abs(vye) - pie = np.abs(pie) - - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + + name = [f'star_{ii:03d}' for ii in range(N_stars)] # Make an StarList - lis = starlists.StarList([name, m0, m0e, - x0, x0e, y0, y0e, - vx, vxe, vy, vye, - pi, pie, - t0], - names = ('name', 'm0', 'm0_err', - 'x0', 'x0_err', 'y0', 'y0_err', - 'vx', 'vx_err', 'vy', 'vy_err', - 'pi', 'pi_err', - 't0')) - + lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, vx, vxe, vy, vye, t0], + names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', + 'vx', 'vx_err', 'vy', 'vy_err', 't0')) + sdx = np.argsort(m0) lis = lis[sdx] # Save original positions as reference (1st) list # in a StarList format (with velocities). - lis.write('random_par_ref.fits', overwrite=True) - + lis.write(f'{test_data_path}/random_vel_ref.fits', overwrite=True) + ########## # Propogate to new times and distort. ########## # Make 4 new starlists with different epochs and transformations. - '''times = [2018.5, 2019.5, 2020.5, 2021.5] - xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], - [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], - [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], - [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]]] - mag_trans = [0.1, 0.4, 0.0, -0.3]''' - times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], - [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], - [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], - [[ 50.0, 1.00, 0.0], [ -31.0, 0.0, 1.000]], - [[ 78.0, 1.00, 0.0 ], [ 45.0, 0.0, 1.00]], - [[-13.0, 1.00, 0.0], [ 150, 0.0, 1.00]], - [[ 94.0, 1.00, 0.0], [-182.0, 0.0, 1.00]]] - mag_trans = [0.1, 0.4, 0.0, -0.3, 0.0, 0.0, 0.0, 0.0] + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.000]], + [[250.0, 1.01, 2e-5], [-250.0, 1e-5, 0.98]], + [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], + [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], + [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], + [[ 94.0, 1.00, 9e-6], [-182.0, 0.0, 0.99]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] # Convert into pixels (undistorted) with the following info. scale = 0.01 # arcsec / pix shift = [1.0, 1.0] # pix - + for ss in range(len(times)): dt = times[ss] - lis['t0'] - - par_mod = motion_model.Parallax(PA=0,RA=18.0, Dec=-30.0) - par_mod_dat = par_mod.get_batch_pos_at_time(dt+lis['t0'], x0=lis['x0'],vx=lis['vx']/1e3, pi=lis['pi'], - y0=lis['y0'], vy=lis['vy']/1e3, t0=lis['t0']) - x,y = par_mod_dat[0], par_mod_dat[1] + + x = lis['x0'] + (lis['vx']/1e3) * dt + y = lis['y0'] + (lis['vy']/1e3) * dt t = np.ones(N_stars) * times[ss] # Convert into pixels @@ -1007,9 +1213,9 @@ def make_fake_starlists_poly1_par(seed=-1): xd, yd = trans.evaluate(xp, yp) md = trans.evaluate_mag(lis['m0']) - # Perturb with small errors (0.1 pix) - xd += np.random.randn(N_stars) * 0.1 - yd += np.random.randn(N_stars) * 0.1 + # Perturb with small errors (0.1 mas) + xd += np.random.randn(N_stars) * xpe + yd += np.random.randn(N_stars) * ype md += np.random.randn(N_stars) * 0.02 xde = xpe yde = ype @@ -1019,435 +1225,250 @@ def make_fake_starlists_poly1_par(seed=-1): new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) - new_lis.write('random_par_{0:d}.fits'.format(ss), overwrite=True) + new_lis.write(f'{test_data_path}/random_vel_{ss}.fits', overwrite=True) return (xy_trans, mag_trans) - -def test_MosaicToRef_hst_me(): - """ - Test Casey's issue with 'me' not getting propogated - from the input starlists to the output table. - - Use data from MB10-364 microlensing target for the test. - """ - # Target RA and Dec (MOA data download) - ra = '17:57:05.401' - dec = '-34:27:05.01' - - # Load up a Gaia catalog (queried around the RA/Dec above) - my_gaia = Table.read('mb10364_data/my_gaia.fits') - my_gaia['me'] = 0.01 - - # Gather the list of starlists. For first pass, don't modify the starlists. - # Loop through the observations and read them in, in prep for alignment with Gaia - epochs = [2011.83, 2012.73, 2013.81] - starlist_names = ['mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib', - 'mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib', - 'mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib'] - - list_of_starlists = [] - - # Just using the F606W filters first. - for ee in range(len(starlist_names)): - lis = starlists.StarList.from_lis_file(starlist_names[ee]) - - # # Add additive error term. MAYBE YOU DON'T NEED THIS - # lis['xe'] = np.hypot(lis['xe'], 0.01) # Adding 0.01 pix (0.1 mas) in quadrature. - # lis['ye'] = np.hypot(lis['ye'], 0.01) - - lis['t'] = epochs[ee] - - # Lets dump the faint stars. - idx = np.where(lis['m'] < 20.0)[0] - lis = lis[idx] - - list_of_starlists.append(lis) - - msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, - dr_tol=[0.1], dm_tol=[5], - outlier_tol=[None], mag_lim=[13, 21], - trans_class=transforms.PolyTransform, - trans_args=[{'order': 1}], - default_motion_model='Fixed', - use_ref_new=False, - update_ref_orig=False, - mag_trans=False, - trans_weights='both,std', - init_guess_mode='miracle', verbose=False) - msc.fit() - tab = msc.ref_table - - assert 'me' in tab.colnames - - return - -def test_bootstrap(): - """ - Test to make sure calc_bootstrap_error() call is working - properly (e.g., only called when user calls calc_bootstrap_error, - n_boot param for calc_bootstrap_error only, boot_epochs_min working, - etc.) - """ - # Read in starlists for MosaicToRef - ref = Table.read('ref_vel.lis', format='ascii') - list1 = Table.read('E.lis', format='ascii') - list2 = Table.read('F.lis', format='ascii') - - list1 = starlists.StarList.from_table(list1) - list2 = starlists.StarList.from_table(list2) - - # Set parameters for alignment - transModel = transforms.PolyTransform - trans_args = {'order':2} - N_loop = 1 - dr_tol = 0.08 - dm_tol = 99 - outlier_tol = None - mag_lim = None - ref_mag_lim = None - trans_weights = 'both,var' - mag_trans = False - - n_boot = 15 - boot_epochs_min=-1 - - # Run FLYSTAR, no bootstraps yet! - match1 = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, - dm_tol=dm_tol, outlier_tol=outlier_tol, - trans_class=transModel, - trans_args=trans_args, - mag_trans=mag_trans, - mag_lim=mag_lim, - ref_mag_lim=ref_mag_lim, - trans_weights=trans_weights, - default_motion_model='Linear', - use_ref_new=False, - update_ref_orig=False, - init_guess_mode='name', - verbose=False) - match1.fit() - - # Make sure no bootstrap columns exist - assert 'xe_boot' not in match1.ref_table.keys() - assert 'ye_boot' not in match1.ref_table.keys() - assert 'vxe_boot' not in match1.ref_table.keys() - assert 'vye_boot' not in match1.ref_table.keys() - - # Run bootstrap: no boot_epochs_min - match1.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min) - # Make sure columns exist, and none of them are nan values - assert np.sum(np.isnan(match1.ref_table['xe_boot'])) == 0 - assert np.sum(np.isnan(match1.ref_table['ye_boot'])) == 0 - assert np.sum(np.isnan(match1.ref_table['vx_err_boot'])) == 0 - assert np.sum(np.isnan(match1.ref_table['vy_err_boot'])) == 0 - #pdb.set_trace() - - # Test 2: make sure boot_epochs_min is working - # Eliminate some rows to list2, so some stars are only in 1 epoch. - # Rerun align. Some stars should only be detected in 1 epoch - list3 = list2[0:60] - - match2 = align.MosaicToRef(ref, [list1, list3], iters=N_loop, dr_tol=dr_tol, - dm_tol=dm_tol, outlier_tol=outlier_tol, - trans_class=transModel, - trans_args=trans_args, - mag_trans=mag_trans, - mag_lim=mag_lim, - ref_mag_lim=ref_mag_lim, - trans_weights=trans_weights, - default_motion_model='Linear', - use_ref_new=False, - update_ref_orig=False, - init_guess_mode='name', - verbose=False) - match2.fit() - - # Now run_calc_bootstrap_error, with boot_epochs_min engaged - boot_epochs_min2 = 2 - match2.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min2) - - # Make sure boot_epochs_min cut worked as intended - out = match2.ref_table - bad = np.where( (out['n_detect'] == 1) & (out['use_in_trans'] == False) ) - good = np.where(out['n_detect'] == 2) - - # Some stars must exist in both "good" and "bad" criteria, - # otherwise this test isn't as useful as intended. - assert len(bad[0]) > 0 - assert len(good[0]) > 0 - - # For "good" stars: all bootstrap vals should be present - assert np.sum(np.isnan(out['xe_boot'][good])) == 0 - assert np.sum(np.isnan(out['ye_boot'][good])) == 0 - assert np.sum(np.isnan(out['vx_err_boot'][good])) == 0 - assert np.sum(np.isnan(out['vy_err_boot'][good])) == 0 - - # For "bad" stars, all bootstrap vals should be nans - assert np.sum(np.isfinite(out['xe_boot'][bad])) == 0 - assert np.sum(np.isfinite(out['ye_boot'][bad])) == 0 - assert np.sum(np.isfinite(out['vx_err_boot'][bad])) == 0 - assert np.sum(np.isfinite(out['vy_err_boot'][bad])) == 0 - - return - -def test_calc_vel_in_bootstrap(): - """ - Check calc_vel_in_bootstrap performance in calc_bootstrap_errors() - - Only calculate velocity bootstrap (e.g., bootstrap over epochs and - calculating proper motions) if calc_vel_in_bootstrap=True. - - """ - import copy - - # Define match parameters - ref = Table.read('ref_vel.lis', format='ascii') - - list1 = Table.read('E.lis', format='ascii') - list2 = Table.read('F.lis', format='ascii') - - list1 = starlists.StarList.from_table(list1) - list2 = starlists.StarList.from_table(list2) - - # Set parameters for alignment - transModel = transforms.PolyTransform - trans_args = {'order':2} - N_loop = 1 - dr_tol = 0.08 - dm_tol = 99 - outlier_tol = None - mag_lim = None - ref_mag_lim = None - trans_weights = 'both,var' - mag_trans = False - - n_boot = 15 - boot_epochs_min=-1 +def make_fake_starlists_poly1_acc(seed=-1): + # If seed >=0, then set random seed to that value + if seed >= 0: + np.random.seed(seed=seed) - # Run match - match = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, - dm_tol=dm_tol, outlier_tol=outlier_tol, - trans_class=transModel, - trans_args=trans_args, - mag_trans=mag_trans, - mag_lim=mag_lim, - ref_mag_lim=ref_mag_lim, - trans_weights=trans_weights, - default_motion_model='Linear', - use_ref_new=False, - update_ref_orig=False, - init_guess_mode='name', - verbose=False) - match.fit() + N_stars = 200 - # Make 2 copies of match object: one to test - # each case of calc_vel_in_bootstrap - match_vel = copy.deepcopy(match) + x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) + y0 = np.random.rand(N_stars) * 10.0 # arcsec + x0e = np.ones(N_stars) * 1.0e-4 # arcsec + y0e = np.ones(N_stars) * 1.0e-4 # arcsec + vx = np.random.randn(N_stars) * 5.0 # mas / yr + vy = np.random.randn(N_stars) * 5.0 # mas / yr + vxe = np.ones(N_stars) * 0.1 # mas / yr + vye = np.ones(N_stars) * 0.1 # mas / yr + ax = np.random.randn(N_stars) * 0.5 # mas / yr^2 + ay = np.random.randn(N_stars) * 0.5 # mas / yr^2 + axe = np.ones(N_stars) * 0.01 # mas / yr^2 + aye = np.ones(N_stars) * 0.01 # mas / yr^2 + m0 = (np.random.rand(N_stars) * 8) + 9 # mag + m0e = np.random.randn(N_stars) * 0.05 # mag + t0 = np.ones(N_stars) * 2019.5 - # Run calc_bootstrap_error function with calc_vel_in_bootstrap=True. - # Make sure bootstrap velocity errors are calculated and valid - n_boot = 50 - match_vel.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=True) + # Make all the errors positive + x0e = np.abs(x0e) + y0e = np.abs(y0e) + m0e = np.abs(m0e) + vxe = np.abs(vxe) + vye = np.abs(vye) + axe = np.abs(axe) + aye = np.abs(aye) - assert 'xe_boot' in match_vel.ref_table.keys() - assert np.sum(np.isnan(match_vel.ref_table['xe_boot'])) == 0 - assert 'vx_err_boot' in match_vel.ref_table.keys() - assert np.sum(np.isnan(match_vel.ref_table['vx_err_boot'])) == 0 + name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] - # Run without calc_vel_in_bootstrap, make sure velocities are NOT calculated - match.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=False) + # Make an StarList + lis = starlists.StarList([name, m0, m0e, + x0, x0e, y0, y0e, + vx, vxe, vy, vye, + ax, axe, ay, aye, + t0], + names = ('name', 'm0', 'm0_err', + 'x0', 'x0_err', 'y0', 'y0_err', + 'vx0', 'vx0_err', 'vy0', 'vy0_err', + 'ax', 'ax_err', 'ay', 'ay_err', + 't0')) - assert 'xe_boot' in match.ref_table.keys() - assert np.sum(np.isnan(match.ref_table['xe_boot'])) == 0 - assert 'vx_err_boot' not in match.ref_table.keys() - - return + sdx = np.argsort(m0) + lis = lis[sdx] -def test_transform_xym(): - """ - Test to make sure transforms are being done to mags only - if mag_trans = True. This can cause subtle bugs - otherwise - """ - #---Align 1: self.mag_Trans = False---# - ref = Table.read('ref_vel.lis', format='ascii') - list1 = Table.read('E.lis', format='ascii') - list2 = Table.read('F.lis', format='ascii') + # Save original positions as reference (1st) list + # in a StarList format (with velocities). + lis.write(f'{test_data_path}/random_acc_ref.fits', overwrite=True) - list1 = starlists.StarList.from_table(list1) - list2 = starlists.StarList.from_table(list2) - - # Set parameters for alignment - transModel = transforms.PolyTransform - trans_args = {'order':2} - N_loop = 1 - dr_tol = 0.08 - dm_tol = 99 - outlier_tol = None - mag_lim = None - ref_mag_lim = None - trans_weights = 'both,var' - n_boot = 15 + ########## + # Propogate to new times and distort. + ########## + # Make 4 new starlists with different epochs and transformations. + times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.000]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], + [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], + [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], + [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], + [[ 94.0, 1.00, 9e-6], [-182.0, 0.0, 0.99]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] - mag_trans = False + # Convert into pixels (undistorted) with the following info. + scale = 0.01 # arcsec / pix + shift = [1.0, 1.0] # pix - # Run FLYSTAR, with bootstraps - match1 = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, - dm_tol=dm_tol, outlier_tol=outlier_tol, - trans_class=transModel, - trans_args=trans_args, - mag_trans=mag_trans, - mag_lim=mag_lim, - ref_mag_lim=ref_mag_lim, - trans_weights=trans_weights, - default_motion_model='Fixed', - use_ref_new=False, - update_ref_orig=False, - init_guess_mode='name', - verbose=False) + for ss in range(len(times)): + dt = times[ss] - lis['t0'] - match1.fit() - match1.calc_bootstrap_errors(n_boot=n_boot) + x = lis['x0'] + (lis['vx0']/1e3) * dt + 0.5*(lis['ax']/1e3) * dt**2 + y = lis['y0'] + (lis['vy0']/1e3) * dt + 0.5*(lis['ay']/1e3) * dt**2 + t = np.ones(N_stars) * times[ss] - # Make sure all transformations have mag_offset = 0 - trans_list = match1.trans_list + # Convert into pixels + xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) + yp = (y / scale) + shift[1] + xpe = lis['x0_err'] / scale + ype = lis['y0_err'] / scale - for ii in trans_list: - assert ii.mag_offset == 0 + # Distort the positions + trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + xd, yd = trans.evaluate(xp, yp) + md = trans.evaluate_mag(lis['m0']) - # Check that no mag transformation has been applied to m col in ref_table - tab1 = match1.ref_table - assert np.all(tab1['m'] == tab1['m_orig']) - - # Check me_boost == 0 or really small (should be the case - # since we don't transform mags) - assert np.isclose(np.max(tab1['me_boot']), 0, rtol=10**-5) - print('Done mag_trans = False case') + # Perturb with small errors (0.1 pix) + xd += np.random.randn(N_stars) * xpe + yd += np.random.randn(N_stars) * ype + md += np.random.randn(N_stars) * 0.02 + xde = xpe + yde = ype + mde = lis['m0_err'] - #---Align 2: self.mag_Trans = True---# - # Repeat, this time with mag_trans = False - mag_trans = True - match2 = align.MosaicToRef(ref, [list1, list2], iters=N_loop, dr_tol=dr_tol, - dm_tol=dm_tol, outlier_tol=outlier_tol, - trans_class=transModel, - trans_args=trans_args, - mag_trans=mag_trans, - mag_lim=mag_lim, - ref_mag_lim=ref_mag_lim, - trans_weights=trans_weights, - default_motion_model='Fixed', - use_ref_new=False, - update_ref_orig=False, - init_guess_mode='name', - verbose=False) + # Save the new list as a starlist. + new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], + names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) - match2.fit() - match2.calc_bootstrap_errors(n_boot=n_boot) + new_lis.write(f'{test_data_path}/random_acc_{ss}.fits', overwrite=True) + return (xy_trans, mag_trans) - # Make sure all transformations have correct mag offset - trans_list2 = match2.trans_list +def make_fake_starlists_poly1_par(seed=-1): + # If seed >=0, then set random seed to that value + if seed >= 0: + np.random.seed(seed=seed) - for ii in trans_list2: - assert ii.mag_offset > 20 + N_stars = 200 - # Make sure final table mags have transform applied (i.e, - tab2 = match2.ref_table - assert np.all(tab2['m'] != tab2['m_orig']) - - # Check me_boost > 0 - assert np.min(tab2['me_boot']) > 10**-3 + x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) + y0 = np.random.rand(N_stars) * 10.0 # arcsec + x0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + y0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + vx = np.random.randn(N_stars) * 5.0 # mas / yr + vy = np.random.randn(N_stars) * 5.0 # mas / yr + vxe = np.random.randn(N_stars) * 0.1 # mas / yr + vye = np.random.randn(N_stars) * 0.1 # mas / yr + pi = np.random.randn(N_stars) * 0.5 # mas + pie = np.random.randn(N_stars) * 0.01 # mas + m0 = (np.random.rand(N_stars) * 8) + 9 # mag + m0e = np.random.randn(N_stars) * 0.05 # mag + t0 = np.ones(N_stars) * 2019.5 - print('Done mag_trans = True case') - - return + # Make all the errors positive + x0e = np.abs(x0e) + y0e = np.abs(y0e) + m0e = np.abs(m0e) + vxe = np.abs(vxe) + vye = np.abs(vye) + pie = np.abs(pie) -def test_MosaicToRef_mag_bug(): - """ - Bug found by Tuan Do on 2020-04-12. - """ - make_fake_starlists_poly1_vel() + name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] - ref_list = starlists.StarList.read('random_vel_0.fits') - lists = [ref_list] + # Make an StarList + lis = starlists.StarList([name, m0, m0e, + x0, x0e, y0, y0e, + vx, vxe, vy, vye, + pi, pie, + t0], + names = ('name', 'm0', 'm0_err', + 'x0', 'x0_err', 'y0', 'y0_err', + 'vx', 'vx_err', 'vy', 'vy_err', + 'pi', 'pi_err', + 't0')) - msc = align.MosaicToRef(ref_list, lists, - mag_trans=True, - iters=1, - dr_tol=[0.2], dm_tol=[1], - outlier_tol=None, - trans_class=transforms.PolyTransform, - trans_args=[{'order': 1}], - default_motion_model='Fixed', - use_ref_new=False, - update_ref_orig=False, - verbose=True) + sdx = np.argsort(m0) + lis = lis[sdx] - msc.fit() + # Save original positions as reference (1st) list + # in a StarList format (with velocities). + lis.write(f'{test_data_path}/random_par_ref.fits', overwrite=True) - out_tab = msc.ref_table + ########## + # Propogate to new times and distort. + ########## + # Make 4 new starlists with different epochs and transformations. + '''times = [2018.5, 2019.5, 2020.5, 2021.5] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]]] + mag_trans = [0.1, 0.4, 0.0, -0.3]''' - # The issue is that in the initial guess with - # mag_trans = True - # somehow the transformed magnitudes are nan. - # This causes zero matches to occur. - assert len(out_tab) == len(ref_list) + times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], + [[ 50.0, 1.00, 0.0], [ -31.0, 0.0, 1.000]], + [[ 78.0, 1.00, 0.0 ], [ 45.0, 0.0, 1.00]], + [[-13.0, 1.00, 0.0], [ 150, 0.0, 1.00]], + [[ 94.0, 1.00, 0.0], [-182.0, 0.0, 1.00]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.0, 0.0, 0.0, 0.0] - return + # Convert into pixels (undistorted) with the following info. + scale = 0.01 # arcsec / pix + shift = [1.0, 1.0] # pix -def test_masked_cols(): - """ - Test to make sure analysis.prepare_gaia_for_flystar - produces an astropy.table.Table, NOT a masked column - table. MosaicToRef cannot handle masked column tables. + for ss in range(len(times)): + dt = times[ss] - lis['t0'] - Also make sure this example works, since we use it for the examples - jupyter notebook. - """ - # Get gaia reference stars using analysis.py - # around a test location. - target = 'ob150029' - ra = '17:59:46.60' - dec = '-28:38:41.8' + par_mod = motion_model.Parallax(pa=0,ra=18.0, dec=-30.0) + par_mod_dat = par_mod.get_batch_pos_at_time(dt+lis['t0'], x0=lis['x0'],vx=lis['vx']/1e3, pi=lis['pi'], + y0=lis['y0'], vy=lis['vy']/1e3, t0=lis['t0']) + x,y = par_mod_dat[0], par_mod_dat[1] + t = np.ones(N_stars) * times[ss] - # Coordinates are arcsecs offset +x to the East. - targets_dict = {'ob150029': [0.0, 0.0], - 'S005': [1.1416, 3.7405], - 'S002': [-4.421, 0.027] - } + # Convert into pixels + xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) + yp = (y / scale) + shift[1] + xpe = lis['x0_err'] / scale + ype = lis['y0_err'] / scale - # Get gaia catalog stars. Note that this produces a masked column table - search_rad = 10.0 # arcsec - gaia = analysis.query_gaia(ra, dec, search_radius=search_rad) - my_gaia = analysis.prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=targets_dict) + # Distort the positions + trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + xd, yd = trans.evaluate(xp, yp) + md = trans.evaluate_mag(lis['m0']) - assert isinstance(my_gaia, Table) + # Perturb with small errors (0.1 pix) + xd += np.random.randn(N_stars) * 0.1 + yd += np.random.randn(N_stars) * 0.1 + md += np.random.randn(N_stars) * 0.02 + xde = xpe + yde = ype + mde = lis['m0_err'] - # Let's make sure the entire align runs, just to be safe - - # Get starlists to align to gaia - epochs = ['15jun07','16jul14', '17may21'] + # Save the new list as a starlist. + new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], + names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) - list_of_starlists = [] + new_lis.write(f'{test_data_path}/random_par_{ss}.fits', overwrite=True) - for ee in range(len(epochs)): - lis_file = 'mag' + epochs[ee] + '_ob150029_kp_rms_named.lis' - lis = starlists.StarList.from_lis_file(lis_file) - - list_of_starlists.append(lis) + return (xy_trans, mag_trans) - # Run the align - msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=2, - dr_tol=[0.2, 0.1], dm_tol=[1, 1], +if __name__ == '__main__': + import pickle + with open(f'{test_data_path}/my_gaia.pkl', 'rb') as f: + my_gaia = pickle.load(f) + with open(f'{test_data_path}/list_of_starlists.pkl', 'rb') as f: + list_of_starlists = pickle.load(f) + ra_deg, dec_deg = 18.0, -30.0 + my_gaia.remove_column('motion_model_used') + msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=3, + dr_tol=[0.2, 0.1, 0.08], dm_tol=[5,5,5], + outlier_tol=[None, None, 3], mag_lim=[6, 20], trans_class=transforms.PolyTransform, - trans_args=[{'order': 1}, {'order': 1}], - default_motion_model='Linear', - use_ref_new=False, + trans_args=[{'order': 1}, {'order': 1}, {'order': 1}], + motion_models=['Linear','Parallax'], + fixed_params_dict = {'ra':ra_deg, 'dec':dec_deg, 'pa':0.0, 'obsLocation':'earth'}, + use_ref_new=True, update_ref_orig=False, mag_trans=True, - init_guess_mode='name', verbose=True) - + trans_weighting='both,std', + init_guess_mode='name', verbose=3) msc.fit() - - return + for i in range(msc.ref_table['x'].shape[1]): + plt.scatter(msc.ref_table['x'][:, i], msc.ref_table['y'][:, i]) + plt.show() + plot_stars(msc.ref_table, msc.ref_table['name'][:3]) \ No newline at end of file diff --git a/flystar/tests/test_all_detected.fits b/flystar/tests/test_all_detected.fits deleted file mode 100644 index ae56198..0000000 --- a/flystar/tests/test_all_detected.fits +++ /dev/null @@ -1,2911 +0,0 @@ -SIMPLE = T / conforms to FITS standard BITPIX = 8 / array data type NAXIS = 0 / number of array dimensions EXTEND = T END XTENSION= 'BINTABLE' / binary table extension BITPIX = 8 / array data type NAXIS = 2 / number of array dimensions NAXIS1 = 632 / length of dimension 1 NAXIS2 = 2000 / length of dimension 2 PCOUNT = 0 / number of group parameters GCOUNT = 1 / number of groups TFIELDS = 21 / number of table fields TTYPE1 = 'name ' TFORM1 = 'K ' TTYPE2 = 'x ' TFORM2 = '12D ' TDIM2 = '(2,6) ' TTYPE3 = 'y ' TFORM3 = '12D ' TDIM3 = '(2,6) ' TTYPE4 = 'm ' TFORM4 = '12D ' TDIM4 = '(2,6) ' TTYPE5 = 'xe ' TFORM5 = '6D ' TDIM5 = '(6) ' TTYPE6 = 'ye ' TFORM6 = '6D ' TDIM6 = '(6) ' TTYPE7 = 'me ' TFORM7 = '6D ' TDIM7 = '(6) ' TTYPE8 = 'n ' TFORM8 = '6D ' TDIM8 = '(6) ' TTYPE9 = 'det ' TFORM9 = '6D ' TDIM9 = '(6) ' TTYPE10 = 'vx ' TFORM10 = 'D ' TTYPE11 = 'vy ' TFORM11 = 'D ' TTYPE12 = 'vxe ' TFORM12 = 'D ' TTYPE13 = 'vye ' TFORM13 = 'D ' TTYPE14 = 'x0 ' TFORM14 = 'D ' TTYPE15 = 'y0 ' TFORM15 = 'D ' TTYPE16 = 'x0e ' TFORM16 = 'D ' TTYPE17 = 'y0e ' TFORM17 = 'D ' TTYPE18 = 'chi2_vx ' TFORM18 = 'D ' TTYPE19 = 'chi2_vy ' TFORM19 = 'D ' TTYPE20 = 't0 ' TFORM20 = 'D ' TTYPE21 = 'n_vfit ' TFORM21 = 'D ' EPNAMES = '2005_F814W_F1' EPNAMES = '2010_F125W_F3' EPNAMES = '2010_F139M_F2' EPNAMES = '2010_F160W_F1' EPNAMES = '2013_F160W_F1' EPNAMES = '2015_F160W_F1' ZPOINTS = 32.6783 ZPOINTS = 25.2305 ZPOINTS = 23.2835 ZPOINTS = 24.5698 ZPOINTS = 24.5698 ZPOINTS = 24.5698 YEARS = 2005.485 YEARS = 2010.652 YEARS = 2010.652 YEARS = 2010.652 YEARS = 2013.199 YEARS = 2015.148 HIERARCH DATE PRODUCED = '2025-06-30' HIERARCH INSTRUMENT = 'ACSWFC ' HIERARCH INSTRUMENT = 'WFC3IR ' HIERARCH INSTRUMENT = 'WFC3IR ' HIERARCH INSTRUMENT = 'WFC3IR ' HIERARCH INSTRUMENT = 'WFC3IR ' HIERARCH INSTRUMENT = 'WFC3IR ' END @ 1&y@ c+(@ 1&y@ 4U*@ 1&y@ OS@ 1&y@ŕ@ 1&y@ !@ 1&y@]H/@nzG@ns2ph@nzG@n:t@nzG@mI@nzG@mm@nzG@nb3@nzG@ns@8䎊@8m1@4S@3!d@3~"@3Q@䩤@2@2h4Z@2@2ĊRd@2@2&EK?hjaQ?*?iy?Û? -Ld?OU=6i?/nI|??`l??!g?'?χ1?# ?jo?/O?ޥe?.Eôv? [\@@"@@"@4@.???????Ek?mo?zS ?T 8O@@n?/?? Cs?9wZe`?3#@溦z@k%>@@`ě@\1'@`ě@Q4K@`ě@Mw1@`ě@G@`ě@:6@`ě@4j~@ۊ=p@ێV@ۊ=p@{lD@ۊ=p@۞Q@ۊ=p@ہTɅ@ۊ=p@ۙb@ۊ=p@۝cA@6=:@6:)^@4 hr@4SMj@3`A@3\(@3._o @3:L/|@3._o @3BC,@3._o @3G?Ol?.5?{?d`Xp?͵ ?>;? ?>%?:?Җhn?|9.)?@ ~? -B?7ly\?J鞤?Jf?8?J6Л@@@@@,@(??????C&Ԡ?*2iۂA?Y領~@OûZ@یc?D?tN'p?{Q( ?׺@bn{@@+.@+.@+.@+.@+@٦ @+@ k@(6E.@(6E.@(6E.@(6E.@(6E@)Q@(6E@!p<@8s.>@4S.Mm@3`A7.Qn@2YJ.NC,@2YJ@2>@2YJ@1E2a|@8J@8#@8:@8 >+?BxT?g{=@8J@8@8i@8?VYk ?Պu@8p@8 *@8p@8?Z?\@@ ??@zG@w@zG@rGF@zG@s@zG@=b@zG@*0@zG@X@շKƧ@ռ(Ž@շKƧ@7@շKƧ@շX@շKƧ@շ@շKƧ@նz@շKƧ@ո}H@8g l@8\N@4hr @4&@4"-V@4*͞&@3B@5@3GKƧ@3B@5@3G@3B@5@3H9Xb?q!U?+W?](s?A2x?wX?>V$?TU?[G,?ҌI?,#t?s?|[z?ӖO_?[ S? e?Za7?Us?DΊ@@@@@*@(???????VMB“x?QԬy!?Bex.@W.V@ոAA?nɢf?[~?u?+\t@oF5i@@EQ@9R4@EQ@G2@EQ@?'-9@EQ@DqN@EQ@D @EQ@FW@/j~#@/,l@/j~#@/i3ߢ@/j~#@/qjK>h@/j~#@/fX@/j~#@/m*@/j~#@/uA@8g l@8u@2r Ĝ@2QU|@2gKƧ@2l76@1&@1 "@1&@1[@1&@1} t?ڢ??b r}?N[x?},A? J?P*i?6 k?ZU?1O}?=е?zpY?i ?V0qRi?@&pp??~?zA?Ad`@@ @&@"@&@.???????gyG{G;T?DO?n@٨3@C{y"E@/p4}pE?g j?փ$,?g*u?8̷@oʛ@@V.@V@ܻf@V@@3@3ѹ wC@2A7K@2@2(@2DR@2(@24@2(@2":>Ff@8J?uPք -?}?]9t?fN= ?wp@8J?o!ȼ?@;?)? @?3f-? -]D@ҰǴ@xn@?SB!?8F?ؼxq ?|s]@fŞV@@ě@F$/@ě@CZ@ě@F@ě@rp;@ě@Dg8@ě@M:@=p -@j~@=p -@@4c.Mm@317Kƨ.Qn@3G k.NC,@3G k.NC,@3G k.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8  -@;C@;=L@;C@;=~@;C@;Qb@;C@;^ʷ@;C@;풟@;C@; @ʜ1'@ʕe@ʜ1'@ʗFo@ʜ1'@ʜZ -l@ʜ1'@ʟ-fU@ʜ1'@ʦ@ʜ1'@ʠM@7S&@7vU@3kS@3nesg'@2`A7L@26@2 [W?@2,$@2 [W?@22P@2 [W?@2 Tn?}xC@R$/@Ru\(@R$/@R;s@R$/@R0D@7v.>@4G+@43a@N@4~"@3kP@2xF^@2R<6@2xF^@2L_@2xF^@2a@@8J?5O}?^sx?I,?L!{?U A@8J?iCv?z/=?ըE?9?l @8p? $F)?S?D'?tgi?_@@@@,@*????? @1z@1z@1z@1 ^ @1z@1RT`@1z@1z@1z@1-@1z@1lC@ I@p@ I@L@ I@ I@ I@W@ I@Ƨ@ I@f@4`D@4`d7@1i+ @1iy @1,j~#@1-V@0O M@0r@0O M@0[W>@0O M@0v_ح?| ?x1? ?菁k?E@?C!?|O?Q_ڸFN?FN ?%_D?YF?Q(?7?7@@@@@*@,??????oX?x?I9l?oc2@1u@um?'!ŗ?@(61څ?\^s1Ȧ?7C&@fZ| @ @@ -=p@@y%@@ -=p@@2@@ -=p@@?@@ -=p@@Mj@@ -=p@@(@@ -=p@@z@{>vȴ9@{>"@{>vȴ9@{DJ@{>vȴ9@{DT@{>vȴ9@{B&I@{>vȴ9@{B@{>vȴ9@{B&J@4ks@4kk50@2J^5?|@2KQ@2 "`B@2 O;dZ@1xD*@1zY@1xD*@1yXbM@1xD*@1y_o?}xZw?< N ?}?8wx@@@@@(@,??????5?: a?@*z?)@@;_@{@%;?`D?7¦$%+?[&+@8I@8?+ I@8@8i@8@8S@8?s5r@8 *@8p@8@8 @8 @?@EKƧ@EQ&x@EKƧ.@EKƧ.@EKƧ.@EKƧ.@EKƧ.@G@tj@G.@G.@G.@G.@G.@7 D@7 ->B@3 hr.Mm@2`A7.Qn@1iB.NC,@1iB.NC,@1iB.NC,?1j@8#@8:@8 >+@8I@8?h?@8@8i@8@8S@8?Ú5BZ@8 *@8p@8@8 @8 @?@:V.@:V@:`d@:V@:@:V@:,<@:V@:@:V@:@$/.@$/@\@$/@\)@$/@H@$/@ݲ-V@$/@ȧ@8H.>@3n5?|@3d xF@3-V@3 [7@2!.I@2jf@2!.I@2#@2!.I@2#9@8J?V[u9??]`?k;?U A@8J?lV?J?5;7ĻM?Q?A8D@8p?Ov_ح? - l]?vI??g@@@@,@,?????@3E@/;dZ@3E@5\)@3E@33332@3E@3E@3E@3@3E@4!-w@E1&x@E.V@E1&x@E2@E1&x@E3*0U@E1&x@E49Xb@E1&x@E3@E1&x@E8W@6:@6YJ@1 I^@1|@1i"`@1i~($ @0‚@5@0Zc@0‚@5@0GE85@0‚@5@0vȴ:?NIɮ?t0?wk?Њ?Dj?#{׈?h?? -?}7.?M =?+!? # -?P7?c I??/X?=aw%?gϵ? -r@@@@@(@$???????@%+sT?^> -3F?5?d/?BZƦ@3@E4q?I\I;?_)T`l?:{?Rū\k@oy@@۩x@۩7Kƨ@۩x@ۯ*/@۩x@n+@8I@8?ɱb)Q@8@8i@8@8S@8?`S@8 *@8p@8@8 @8 @?@b%@bT@b%@buc@b%@b@b%@bߩ*@b%@bZVn@b%@b)oU@?|@E@?|@̤@?|@H@?|@q@?|@~=@?|@@4 xF@4U=@0&+ J@0&?1@/XF@/WI@.(ۋq @.(_n @.(ۋq @.(*@.(ۋq @.(&I?}@TΥ?n!?B?I?F B?*?}@TΥ? R? FO??b?nG$GI?]SXd?o,qV?k/?X ?Lx?1C? -9X@@,@$@*@4@7??????/ڇj ?.Kn?"详S?oi@b*l@Ca?BlKJ?(P3?hk?^rT?@gؿ @@u?|@r-V@u?|@qX@u?|@jڹZ@u?|@8Z@u?|@x_@u?|@|쿱@S@`B@S@l@S@ᰉ&@S@u@S@@S@6@7*0U2b@7oiD@4hr@4$tS@3Ƨ@3^5?}@3!.I@3u@3!.I@3$/@3!.I@3]cf?)T?05 [?Fw?gt>?ťBW?A!X?Ol? LP?O?tdE? ?AP0P?o\Z{?K)?+k?Z?<שN?8wx@@@@@$@(???????btZ?_L|HbK?Ej-M0@y4_@޻? /ذ?efб)?8ا?K{~@h,@@ěT@G@ěT@üZ@ěT@hی@ěT@Q@ěT@ں@ěT@@ -=@R@ -=@Mj@ -=@ I^@ -=@j~@ -=@*0@ -=@O;d@7įO M@7ơaf@3kS@3m@27KƧ@28Y@1_o @16@1_o @1\(@1_o @1nO?}ѿ,? ?IK?nii)?jF?ҸBz3?sD?8{:?%gǿ?Nw]6?r?m\@?x}?Эs_`?~}o_?{Cx?屘?zy@@@@@,@*???????i|?W?8"?Ufݸbzi@ q@j?Xw6O?r8G?P?n9@fQF$`@@=p -.@=p -@=qu@=p -@;:)@=p -@<L_@=p -@;P|@=p -@;@qm.@qm@gRT`@qm@cw@qm@ix@qm@g8}@qm@de@7䎊.>@2 I^@2ԕ*@2 -V@2 A@1a:S@1_iDg8@1a:S@1_U=@1a:S@1_As@8J?hX*?=?Kh?:Z2b?`?SJ@8J?4i?tP*?Җhn?C ;?]˙$>@8p?u/X?8*?ۮetZ?Cns?WZ@@@@*@*?????@!@%Q@!@$e@!@#e@!@$7@!@!TɅ@!@!TɅ@n@[@n@}U@n@g8~@n@u%F @n@n.@n@\(@7Q|Q@7Qn@1O|hr@1O@017Kƨ@01u!S@/fL/{K@/fIQ@/fL/{K@/fL/{K@/fL/{K@/f&J?E?$?,fC6?#t? 9?:?2}?)[+@8I@8? @8@8i@8@8S@8?X@8 *@8p@8@8 @8 @?@nzH@mV@nzH.@nzH.@nzH.@nzH@o-@nzH@mV@i@n@i:^5?}@i@n.@i@n.@i@n.@i@n@iC -=q@i@n@i?|h@8[~($@8WrH@2 ě.Mm@1`A7.Qn@1 k.NC,@1 k@1@@1 k@1Ϫ͟?ȉak@8#@8:@8 >+? f?/?Ol@8@8i@8? ?998?hJ@8 *@8p@8?&f?o@@@???@LC@LC@LC@LzH@LC@Lhr@LC@Lv_خ@LC@L˒;@LC@Ly@,`A7L@,`ě@,`A7L@,aaf@,`A7L@,_;dZ@,`A7L@,]ڹ@,`A7L@,c@,`A7L@,cn@3 ]ce@3 C\@/"`A@/#@/NO<@/C$@-Xy=@-B@-Xy=@-P{@-Xy=@-P{? ?J`Y?"?̒?+?Q`?| ?eCO?LE?@[*^?*v7?w8?s@a?=d??k,?o? .0v@@@@@,@,??????8Z?2?HT*?D)Z<@L7L@,a%?g !/?ct2?IN?щm&@fg`@@.@@(Z;@@ S@@w6@@xQ@@\&S@E49Xb.@E49Xb@E3i6@E49Xb@E g@E49Xb@D\8@E49Xb@E";Է@E49Xb@E7g@84m8.>@3hr @3{R!4@2t@2cN`@2 -0U2a|@1PX@2 -0U2a|@1ň@2 -0U2a|@1ܷ+@8J?Mt?sο?|v?N?e@8J?p&tC?s?Yg3?J](?Y@8p?Ŕs ? -Nr)?l-Q?I`N?up-z@&@"@*@.@0?????@C@}@C@:=@C@ȨV@C@B%@C@.@C@φ@(@@(@x[@(@@(@g@(@g^V@(@G@6*0U2b@6(E\@1+ I@1+{N@0"`@0mK@03&@0*SE@03&@0@03&@0lR?Z=?^ ‰?42`??7?L?F0^?}E?'?>?1ߔ?G -̾?PQ-2? ab?Tx??m p?:wB?Yf@@"@$@@2@2???????o?'8?YP;rq?d#@}@Ƞ߼x?zXXdW?ta%?\2e@.^F;!@h@ @ʍ@ʍhr@ʍ@ʌ!-@ʍ@ʋƧ@ʍ@ʍqu@ʍ@ʍC]@ʍ@ʌ@u@KƧ@u@@u@D@u@kP@u@}Vm@u@+j@6䎊@6ae@1 hr@1 wkP@0Vu@0쿱[@0&YJ@0&@0&YJ@0'@0&YJ@0'1?1j?q' -B?5$?Њ?% -?^?|O?4 "?;,?M =? ^??lINՄ?}?3I#i?!A -m?=aw%?ad|?ܑ @@@@@*@(??????Y&=3!@?J?zթ)@ʍcX@:?<)?:ej?G涟Fa?n A@g9.@!@WV.@WV@Wě@WV@Wq@WV@WOv@WV@W *@WV@WYJ@n.@n@w@n@.@n@q @n@@n@'/@8#g l.>@4!hr @3ߤ@@3lj~#@3[xF]@2@2qi@2@2-@2@2{J#9@8J?B?e?4M^?xs?9j@8J?Ɠ0f?`;9?'G_J?Fl}?:;@8p?G?N?.BZO?pO4I?/̽`@@@@(@*?????"@ΗO;@Ζȴ9X@ΗO;@Ζ+ @ΗO;@Θ}G@ΗO;@Γ@ΗO;@Λm@ΗO;@ΚC\@9XbN@9XbN@9XbN@6_ح@9XbN@2p:@9XbN@7X@9XbN@0D@9XbN@1iC@6*0U2b@6K]c@2ԛS@2TɅo@1j~@1GE85@1B@5@1;P{@1B@5@1F@1B@5@1DFs?1j?_?q -*?+YI?1,j?&Gf?sD?7fps??,ў?*?ω:hT?z"2(?Ol?]b?#ѧ? 1 D@?3@@@@@,@*???????Fٝ0[!x?COصC?:ݶFNc@ΘIC@5m$?enD`?[7Y?^dq? @i2О;@#@"E@,1&@"E@H`@"E@Z^-@"E@]&W@"E@-¼@"E@2-0@"v@% ě@"v@%y@"v@% @"v@%)3@"v@%]d*@"v@%1MY@6 xF@3Y@3I^5?@/24@2j~#@.l o@2iB@-WM4@2iB@-jVw)@2iB@-]`߈?}@TΥ?H%]^?,Q"?Q#?}xM?&C@=V?QS?EZJ@@ @"@$@,@0??????O-b, ww?@LU?# 㥐@-+,@[?_.?Cτ?dw"D?JE@gvY@%@hr@hr@hr@}n@hr@9@hr@"9@hr@ew@hr@b@@@@}I@@7@@6k@@W@@@3:qiC@3:kP|@-"`A@-?ÿ@-4E@-5F -L0@,=Vl"@,=\@,=Vl"@,=|@,=Vl"@,=?|h2:?˚]us?B?8?)>?T|/?|h2:?;*;h?w&?1 ?h1?Tq/G?nڨ8?w?uk=? ZE?7is\?@@*@,@&@;@;?????? -xJ?'@?"g?{k@bn@R?p?Bo{?2@C?f?r6@fN[@&@T5?|@T/@T5?|@T%@T5?|@TQ@T5?|@T6z@T5?|@Tѷ@T5?|@TVl@I^5?@L@I^5?@I7Kƨ@I^5?@I^5?@I^5?@JL@I^5?@I@I^5?@JW@6Q|Q@6O\(@0 I^5@0M@/rnO@/r{n@-p'RU@-p -=q@-p'RU@-p|@-p'RU@-p{?| ?{j?Gy??˅T?6r In?*WF?Br?›?ދ"?6)}?2&h?eDQQ? ?§d߱?YF?E 8?f_Ԋ?b/bJ@@@@@,@,???????%WۭCCW ?&.?",|x@T -@K?G>uT?Bah?|NRu?d;T0@hpID@'@ Ƨ@ Ƨ@ Ƨ@ a@ Ƨ@ "h @ Ƨ@ @ Ƨ@ cA @ Ƨ@ B@+u?|@+u$@+u?|@+tɅn@+u?|@+uXy>@+u?|@+uᰋ@+u?|@+tm:@+u?|@+tɅo@5-v@5-C\@1sS@1seN@0V@0IQ@0xF^@0jf@0xF^@0I^5@@0xF^@0C]? ? KG?O%c?l?n{K?\.:@?|O?CO?;,?߇O?l{9َ?Q\?ZaP?3I#i? ݎ8? mmsi?L8AS?@@@@@,@,???????1`ߐ#ZLw?AdAI?=!^@ aPP@+u9:?4-4L:??'mw?r1V0?Y[P@g%{ђ?@(@dS@dkŔ@dS.@dS.@dS.@dS.@dS.@@nQ@.@.@.@.@.@6]ce@6n*@2S.Mm@2ttj.Qn@2 [W?.NC,@2 [W?.NC,@2 [W?.NC,?Z=@8#@8:@8 >+@8I@8?Qp@8@8i@8@8S@8?Tʼ=@8 *@8p@8@8 @8 @?)@#Cn.@#Cn@#9#x@#Cn@#F?@#Cn@#5L_@#Cn@#,Vϫ@#Cn@#3 @5?|.@5?|@Ǡ m@5?|@ ě@5?|@B@5?|@ q@5?|@fA@9.>@5hr@55?|@4-V@4O;d@40@41$/@40@4$`d@40@4%Xy=@8J?J f?؋)?pW?U܈9?mZ@8J?k3~?ōɗ?˿ o?KN?H"#@8p?/őB??W?zoV?ЀIN@@@@,@(?????*@{dZ@x@{dZ@~҈p@{dZ@[W>@{dZ@ح@{dZ.@{dZ.@S_vȴ@Sg+ K@S_vȴ@S\1(@S_vȴ@SYJ@S_vȴ@S rG@S_vȴ.@S_vȴ.@64m8@6O M@4+@4@4R`A@4쿱[W@4 k@4 ~($@4 k.NC,@4 k.NC,?Ol?Ey?iX?, -d@8I@8??k3~?9؂?R(gF@8S@8?N?:?ȧu ? vrC@8 @8 @@@@????+@kP`A@kQm@kP`A@kEo@kP`A@k-@kP`A@k(eP@kP`A@kSg@kP`A@kݗ@Xtj@s@Xtj@3Mj@Xtj@W3@Xtj@s @Xtj@h>BZ@Xtj@0@95S&@9?v_ح@5@5P{@5lj~#@5usg@46z@4}Vl@46z@4@46z@4z0U2a|?W$B? -?9/?>5c??7?2d?xaz#?ռ2?P@?5OW?#U?̷~ ?m?:/ʼn?6?e8?馪C?Y')@@@@@$@(???????k{Ta}?hfz?yV"@kRp@nÏ^?S~?8@}c?lIߡ@l@,@>=E@>9"@>=E@>CZ@>=E@>F1@>=E@>Ik}@>=E@>B I_@>=E@>@n@55\)@56E@55\)@5:6@55\)@52@55\)@584֡@55\)@5/hی@55\)@5/V@4,<@4~($@1 I^@1bM@1,j~#@1(@0D*@0 '0@0D*@0Z@0D*@0S&?qv?U ?/͔p?Z.??;?봤G?qv?)[j=?V$f@>CƱ@53z?|Ml?qӇl?h<~5?$m@nG.@-@A7K.@A7K@A@A7K@B@@A7K@Ae@A7K@@4m@A7K@@4m@)x.@)x@(r @)x@(TɆ@)x@(u%@)x@)*0U2@)x@(TɅ@3įO M.>@0n5?|@0nvȴ9X@/@/oiDg@.PH@.@N@.PH@.Z@.PH@.sQ@8J? KG?\H{gX?ݶ\r?ǹT?{<@8J?0n=Q?Jj?7枪y7?A B{?SV.@8p?§d߱? SF?!ˠ*(??b/bJ@@@@&@&?????.@~vȴ9@~"@~vȴ9@U=@~vȴ9@}ce@~vȴ9@|?@~vȴ9@}!.I@~vȴ9@~Ov_@F,C@F,C@F,C@F+҈@F,C@F$ xH@F,C@F&,=@F,C@F)Dg8@F,C@F'K]@3cg l@3cS@0ԛS@0fA@0~"@0/V@0c@0eڹ@0c@0f$/@0c@0eS?| ?m0?BI{?{@?@@No9?봤G?| ?j%Ra?A -;?| ?A?:i?nwf?%_D?z_?p=J?GZ?A0)n@@@@@(@"??????5w"xQ(?-"S`?9zT@~%1@F*$h(^?M8M?Yw6?&YD!?G@f?%<@/@n@F@n@x@n@|@n@4.y@n@Vɡ@n@p:@tE@uPa$@tE@tԿ@tE@ud?q\^/?(#@@(@(@*@;@*??????q}o{?0tz?nAօ`?hk@y@uٵo?Bh?~,?cs{e?4~@^T@0@Z1@XQ@Z1@OV@Z1@U=@Z1@TzG@Z1@9"@Z1@@N@ ?|h@ 9"@ ?|h@ m8@ ?|h@ i^ @ ?|h@ Q2X@ ?|h@ Q@ ?|h@ ^Ov_@7 xF@7҈p;@4i+ @4QiB@3~"@3Q@2O M@2w1@2O M@2z@2O M@21?E@?Z]$?×DZ?XԠ#{?Xz=?\LTu?)T?*J?S]:?agf ?,<?(U?Ʉ?qlPg?e?a%?;ܔ?S![c@@@@@&@*??????tt ?ޒE?ij?P݀ ?@Qw@ M^^G?P}d?n7/?r@M?eI@h@1@=`A@=bM@=`A@="`B@=`A@=!@=`A@==@=`A@=LI^4@=`A@=_o@p -=@p -=@p -=@qm@p -=@m q@p -=@P`A@p -=@JڹZ@p -=@%zxl#@4]ce@4 q@2hr@2 ԕ*@2t@1H@2OO M@29ᰉ(@2OO M@20@2OO M@20|?~?J? w(?dl\?lsC^?Җ? G?|h2:?\?%c~??`c?r{?e?f)"?v'X?[?8N0?{=rK@@@@@(@,???????=x<?A:%^?<|d@= $@e#?Qv?Nb$h? o]?gu@]e䟽@2@Ǯz@`B@Ǯz@n.@Ǯz@Ϫ͟@Ǯz@n@Ǯz@Țu%@Ǯz@B@޸Q@@޸Q@α2@޸Q@յs@޸Q@<63@޸Q@<@޸Q@#@9[~($@9mC\@4}hr @4s%2@4lj~#@4g+j@3@3ϱ[W>@3@3Ӝߤ@3@3{J#9?@?}>?.O?1x?*bQt6?=B+?g;+t??B?:?o?Y{?n+?a,F?1?d&??S@Gd@@@@@$@(??????f6tM -@?pBa&\?a\r@zP'@},?#v u@m)\@3@KƧ@KƧ@KƧ@LVϫ@KƧ@L@KƧ@MM;@KƧ@KP}@KƧ@JL@vE@vE@vE@vOva@vE@v4@vE@usi@vE@v@vE@vz@2qiC@2xl"h -@/`A7@/D@.cnP@.cS&@-At@-Mj@-At@-v@-At@-'/W?^Q5P?_?@?eU!? f?ˡK?bM_x?f?'Q?4ډ3?ڂc?SV.?n|̲?§d߱??ʬv?j?@@@@@,@(??????U,$ ?>; ?.[}H?/YXu @KT;p@v'?=:|7v?>#},?tO ?s3u@s't@4@S@VE@S@*@S@FIR@S@c,zx@S@~@S@@.O@-@.O@*0@.O@ D@.O@&@.O@ye+@.O@mw1@8:@8䎊r@4S@4M@4tj@4҈p@3m8@3De@3m8@3>BZc @3m8@3Q??!?ʒK?Dc?aOD@@@@@*@(??????_mWFt??W8?@Ho4@%f?ӝ?…?#x@GF5@`17@5@r @@r @唯O@r @&@r @p:@r @+ J@r @Ov_@F@Cn@F@Cw@F@>@F@<n0@F@>@F@$?@8}:@8'R@3hr @3b}@3V@3JL@2䎊r@2}:@2䎊r@2|~($ x@2䎊r@2qae?Ol?#T?2+@8I@8?I~y@8@8i@8@8S@8?Is -@8 *@8p@8@8 @8 @?8@M@M@M@m@M@@M@ӳ@M@T@M@Q"ڻ@}r @}#x`@}r @}ZX\@}r @}tCx@}r @}hՅ@}r @} @}r @}*=@8 xF@8 L@3f+ J@3c@@2y7KƧ@2z }@1@1ߩs@1@1ߋ'ZE@1@1)5F?pV?}\\?~\ ?ە?W"/?h$[?o"? -~>i?O%?޿I\?qAx?/? kD?XM=nk?QW%;2?=\b -?'wCh? -)@@,@,@*@9@5????????x`x?V6K?6Sw?A5p@A@}?VTDm?a0x?YVF*v?ƹHqi@h+@9@j~#@ow@j~#.@j~#.@j~#.@j~#.@j~#.@j~@a/ @j~.@j~.@j~.@j~.@j~.@4䎊@4w1ث@2?|h.Mm@2KƧ.Qn@2O M.NC,@2O M.NC,@2O M.NC,?|>G3@8#@8:@8 >+@8I@8?P&x@8@8i@8@8S@8?n8@8 *@8p@8@8 @8 @?:@%@A7L@%@ I^@%@o@%@A \@%@e+@%@{J#:@qDT@qDZ@qDT@qCZ@qDT@qC,zx@qDT@qCA \@qDT@qDq@qDT@qDZ@7B䎊@7BZc@2!hr @2!n@0j~@0֡a@0O M@0b}V@0O M@0-w1@0O M@0H˒:?Y͍_?[e?iTC~t?ʳ_?=rE=?OO ? -t@@@@@,@,???????EB -t>-@?7Q m?@C@qDQ`?VFc/?0eos ?½?fZR@iL?@;@ @@ .@ .@ .@ .@ .@~mV@~TzG@~mV.@~mV.@~mV.@~mV.@~mV.@8*0U2b@8tj~@5 -^5?|.Mm@4~".Qn@4xD*.NC,@4xD*.NC,@4xD*.NC,?{QB@8#@8:@8 >+@8I@8?=,܊{g@8@8i@8@8S@8?KxMR@8 *@8p@8@8 @8 @?<@"@1@"@^5?}@"@lD@"@;dZ@"@-V@"@A7L@7K@@7K@@7K@"@7K@T@7K@`A7@7K@+ I@34m8@3'RT`@0@0e@/;dZ@/Y|@/#Z@/C,zy@/#Z@/5?|@/#Z@/]ce?|O? 1H?*"AaI?%?Dj?[2?|O?? :?qF?ni" ?tP*?'? J??m+&?XW~?O|q?<71@@@@@@???????TS8?PD?5hp8? ܱ@30@ ?TZ?2OR?cXZG?qjW`@f@=@ߝ-V@ߪ=p@ߝ-V@ߍw1@ߝ-V@ߠě@ߝ-V@ߠě@ߝ-V@ߚQ@ߝ-V.@@@[@@4֡b@@hۍ@@s@@{@@m]@tj@1&@tj@Y|@tj@ݗ+@tj@SM@tj@䎊r@tj@|@8B䎊@8C*0U2@3i+ @3jL_@2b-V@2a-@1䎊r@2hr @1䎊r@2C@1䎊r@2 [7?:-%?dY{?ՠΆ{?,OKu?n{K??2}?&uE@?mK?"6Wz?uvo4.?9?(L5}y@%~%@cn?!_G?9Ӣס?=F"W?fy@s @@@w@w@w@oiDg@w@$s@w@|@w@\@w@C]@@@@@@@.H@@\(@@u%F @@'@04m8@0:~@.MV@.L@.h1&x@.h1&x@.kjf@.k҈@.kjf@.k)^ @.kjf@.kjf?^Q5P?m0?Gy??뤽??Dj?F0?bM_x? ,C?'Q?>\?2&h?{L բD?bMky?3;?8*?xqC?M684?L@@@@@,@*??????S7L?B\ vS?"\{Y@@EƎ*?Q?1@?(+q:?Z4[@sY@A@ -=p@ -~#@ -=p@ -L@ -=p@ۋr@ -=p@ ^5?@ -=p@1@ -=p@r @qtj@q@qtj@qC@qtj@qbM@qtj@q_@qtj@q$@qtj@qs@3Y*0U2b@3Y+ @1?|h@1%1@1tj~@1ohی@0m8@0iB@0m8@02W@0m8@0GE85?|O?Kb?aR ?a_b?PY8~Qj?)'3?|O?V"y$R? -\?< /0?u$6?pN.>7E?u@>N ?9o?^&?˴C?7zE?ymcw\@@@@@,@*??????CGT?2Wy?1>`@ @3J@q]?Ro-'?QAfw?&?࣏ <@f;@B@ڟv@ٙ@ڟv@ٳ|@ڟv@ۋq@ڟv@t@ڟv@ڬ=@ڟv@A@P`A@Qhr!@P`A@P- @P`A@PbM@P`A@P:~@P`A@P )@P`A@P{@5!.@52a|@1S@1xF]@0ȓtj@0ȓtj@0?䎊r@0@{@0?䎊r@0@H@0?䎊r@0?;dZ?| ??"?:Z2b?% -?-/ge?}ѿ,? H?j?>\? ^??'+?oܧ?/?y8$?Gϵ'?ܑ ? Ğ@@@@@(@,???????r}M@([p?0a|ă?6Y @RO@PZ?PU&"?8? Cv??~`(@fè8@C@inP@inQ@inP.@inP.@inP.@inP.@inP.@=p@=p@=p.@=p.@=p.@=p.@=p.@4Y*0U2b@4X@@0I^5@.Mm@06-.Qn@/uXy=.NC,@/uXy=.NC,@/uXy=.NC,?}ѿ,@8#@8:@8 >+@8I@8?| @8@8i@8@8S@8?٤@8 *@8p@8@8 @8 @?D@MO;d@W -=p@MO;d.@MO;d.@MO;d.@MO;d.@MO;d.@o-@}-W@o-.@o-.@o-.@o-.@o-.@9 xF@8hr @3S.Mm@27KƧ.Qn@2ush.NC,@2ush.NC,@2ush.NC,?+-/@8#@8:@8 >+@8I@8?A[F@8@8i@8@8S@8?Ä`e@8 *@8p@8@8 @8 @?E@ܬ1'@ I@ܬ1'.@ܬ1'.@ܬ1'.@ܬ1'.@ܬ1'.@n@Q@n.@n.@n.@n.@n.@7]ce@7P{@30ěT.Mm@2U`A7L.Qn@2V!.I.NC,@2V!.I.NC,@2V!.I.NC,?| @8#@8:@8 >+@8I@8?xDž@8@8i@8@8S@8?' -}B@8 *@8p@8@8 @8 @?F@@;dZ@@xl"h@@a@@ȴ9X@@Xe@@rGE8@cW -=p@cdZ@cW -=p@cSMj@cW -=p@c["`@cW -=p@cRs@cW -=p@cV!.@cW -=p@cU!S@804m8@8.Vu@3hr@3͸@3lj~#@3l]ce@2[W?@2'RT`@2[W?@2U=@2[W?@2At?xDž?" ?\H{gX?,Z?z|?"eM?}ѿ,?lE0?)_?:u. ?4?⍄o?eo?)h?~/O?rsw?Ee,?8@@@@@,@,???????./0n) ?P6;?RH|@5l/@cWZJ?ak?y^*?׸ ?!M^#b@o̘:(@G@.O@5\(@.O@3Mj@.O@Aoh@.O@;q@.O@.;5@.O@)*0U2@>lD@?n@>lD@>xl"h@>lD@? w1@>lD@>/V@>lD@? [@>lD@>#@7䎊@7˒:)@5?|h@5>6z@4i"`@4k:)z@4O M@4?|i@4O M@4ᰉ@4O M@4- ?qv?d̺?oq u?\eú?h?oNR?3a=?4i?9]t`?Z.?8?ے|?#iN?KQ5?R ?AX|y?z"+;?ԤA]@@@@@,@(??????fH?{vo?eDF ,w?;ބ?/5@k@H@M@M@M@ xF@M@ح@M@oh@M@u"@M@ѷX@ƃn@ƃn@ƃn@Ɓs@ƃn@Ɖ7Kƨ@ƃn@Ƃ I^@ƃn@ƃ@ƃn@Ƃ&I@35S&@352a|@1kS@1kQ@1,j~#@1+lC@0ce@0N;@0ce@0?@0ce@0!.H?| ?W[?=?Kh?Q;}?a\?pf@iqu'@J@;"@;1@;"@;dZ@;"@;^5?}@;"@;v@;"@;YJ@;"@;4֡@ w@ +@ w@ \(@ w@ `A@ w@ -@ w@ hۍ@ w@ ;5@5~($@5m^@/tj@/A [@.Z1@.?@-z)_@-z)y@-z)_@-{"`B@-z)_@-z)_?|O?ߋb?*"AaI?eU5?2A?:?1j? aҹz?s8r?-I`K?إ<(?Uyu#?W?򯞼?֘>D?hB^?pk Y?B @@@@@@??????-U?(U?y? @; @ ޯ,?Hb3l?AJ-x+?֏[$?|@gJ@2 Ĝ@-@2 Ĝ@ qv@2 Ĝ@%1@2 Ĝ@r @2 Ĝ@qi@2 Ĝ@1@9Q|Q@9Bѷ@6+ J@8Qn@5t@6Fs@5a:S@7u!S@5a:S@5DɅoj@5a:S@5%+a?:%?̰C?Ђx6?VI?֤??CږF?ԥ(Щ?h2E?p?5Kؘ? -5?RP?➪U?*'n? 2,?݃?BXFzS@@@@@&@*???????T~| Pm4?~>?7@j]@ - ??Ýq^@ݧbF@8NE@mIY|@L@ I^@tj~@ I^@ :)@ I^@ -L@ I^@ @ I^@?@ I^@m\@\O;@\S@\O;@\S@\O;@\e@\O;@\[V@\O;@\ qw@\O;@\Zc!@7s@7!-w2@3 ě@34֡a@2-V@2xl"h -@1D*@1S&@1D*@1+ I@1D*@1??}?.jM?ub5?G?X?I?}ѿ,?rnc?9Y,?9~F?dLt??hE?=fA:?'#g?hSp]?=P|?TI@@@@@(@&???????y$?d~?ePEI?U7m@R @\e?,1\?uќ=@&;?}@g\H@M@X4j~@X4j~@X4j~@X5!@X4j~@X5?|@X4j~@X4D@X4j~@X4m:@X4j~@X4zG@(@j~@(@@(@@(@쿱@(@#@(@1'@2p4m8@2p- r@-Ƨ@-a@@-cnP@-b`A@,jf@,6z@,jf@,jf@,jf@,6z?^Q5P?°R;?>f?|*(? 9?/]?bV,?%F?~Q?; $?A B{?M\ٓ@?b@?3;?u@>N ?8 ^?a+?a+@@@@@*@ ??????, p>?ыGKx>b9ԇ@X4ѐ@ܑ?%? ) pn?Et? I j,@s -~@N@bl1&@bl1&@bl1&@bn@bl1&@bra|@bl1&@bw'@bl1&@bx}H@bl1&@bw -=p@-V@-V@-V@1@-V@12X@-V@6E@-V@7X@-V@6Fs@0B䎊@0Be+@-`A7@-B@-h1&x@-b @--C\@-#S&@--C\@-#@--C\@-#eN?^Q5P?? -tI?ׂa?~9n4?oNR?bM_x?&uE@?DP?j?4.? Ӻ^?bMky?.x? ݎ8?l?Rv?“y@@@@@,@*??????5u?WO?Cj=S?&PNkxO@bw}e@6 ?R[?5 /|B?W ?`I7"@rߓ@O@ dZ.@ dZ.@ dZ.@ dZ.@ dZ.@ dZ.@G{.@G{.@G{.@G{.@G{.@G{.@8*0U2b.>@4+.Mm@3V.Qn@2D*.NC,@2D*.NC,@2D*.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 P@4{lD@4{lE@4{lD@4x@4{lD@4}K^@4{lD@4@4{lD@4zc@4{lD@4|64@qm@o;dZ@qm@o@qm@nzH@qm@p)^@qm@t*@qm@tO @5 xF@5@3W+ I@3Vaf@2K"`B@2H*0@1u@1.H@1u@1D@1u@1m8? ?5{#? '?'$5?(+Zk?ʟ?1j?\?;~?{d?H<?U3p?{V?3a=???$?k!l@@@@@,@"???????'}}`?O?C[VZ?.]@4|>@q뭼 ?cP8Dj?Oj.M?6h?,.W@gs8a@Q@lglC@lk %@lglC@lm]j^@lglC@lxb)@lglC@lx+@lglC@l[@lglC@lz@u@ܶƍ@u@ꗵ<@u@@u@ۭh@u@,?@u@`@7@8D@3S@36a0@3lj~#@3k/+@2}ce@2qGg"@2}ce@2q -ӌ@2}ce@2p݁C?D6?E?קa?R=?l~?LeT?%t;?Z=?8?8Y?bڑ?`?KaOb?&?ipR? ݮ5?6 a"?=E8?,:@@*@(@&@7@3???????k(?a瑭"?`0ֲks@lx[8o@?{[Ds? -w?@`?Dž^<@l*r>@R@/.@/@o@/@iB@/@R@/@0U2b@/@s@(.@(@,zy@(@$e@(@?|h@(@m9@(@tj@0.>@) -~"@) -=p@(wO;d@(m^@&73@,;6@&73@&҈q@&73@&%1@8 -Ny??,Z@67U? -0ggk?4g9?aYZq? ?pN.>7E?no?[ș8?hE?{0?WZ? `@@@@@&@*??????Da2?JA?E*!@^l@?"k4?Z_2w?hsƈ?{R?ͨߔn@qV@T@ ě@;dZ@ ě@H@ ě@|@ ě@{@ ě@{@ ě@&x@dx@dx@dx@dXy=@dx@dL_@dx@dE86@dx@d9X@dx@d_o @4[~($@4[$@1c@1d!-w1@0Ͳ-V@0>@0Q@0(@0Q@0ce@0Q@05Xy>?|O?'? ??b?V^?w'?| ?p RN%?"a?j?=d^?U3p?=Ca?O?ʳ_?v_.^??\?k!l@@@@@,@,???????0jh`?+{P?vx$N?"|>@l}d@db6? cPG?C _=?LwzL?5Pg$@fbُ -@U@7Kƨ@;dZ@7Kƨ@eO@7Kƨ@@7Kƨ@@7Kƨ@-@7Kƨ@ۼZ@`(@`XbN@`(@`e+@`(@`s@`(@`<65@`(@`cB@`(@`dZ@7įO M@7nP@3|hr@3(\@3-@3}Vm@2._o @2)rGF@2._o @2'eں@2._o @2H˒? ?sp?Uy*>ǜL>$@h@(?~'b? F?Hu[9?DFLx0@gpa@X@O;@Ƨ@O;@@O;@a|@O;@͞@O;@N;@O;@䎊r@y4j~@y3E@y4j~@y:v@y4j~@y9b@y4j~@y:)y@y4j~@y;n@y4j~@y=@8g l@9d8@4+ @4F@3V@3ce@2:S@2jOv@2:S@2n@2:S@2ۅQ?}?Tے}?=5?niʢ?(i^?"X??@׮? ?,ў?$Z?\ũU?&-?xCZ?Aᆽ?q+U?HAY?Oh6c@@@@@,@&???????W,d?`"a?IO*(?(BӜ@w@y:%?/%-`?F32H(?E{YH$?|?q@p&q@Y@/@Q@/@&I@/@;dZ@/@ں@/@m\@/@@̠A7L@̡G{@̠A7L@̠҈@̠A7L@̥`A7@̠A7L@̣A [@̠A7L@̣,zx@̠A7L@̧#@5*0U2b@5_o@3.5?|@3-}H@2Htj@2GO;d@2(@2(1&x@2(@2(˒:*@2(@2&IQ?1j?`[?:?Њ?q?A!X?Br??xrI?2'?\d?6m)? 3W?oܧ?ѿ,?~$?bv{3dZ?P\?T@@@@@"@$??????"a?Q^̤?3};t$?7b|(kr@H@̣?SfQ -?W:Ks?ҟH|?h9l@g/e+@Z@(\@)^5?@(\@7sQ@(\@2p;@(\@?|h@(\@>iB@(\@fFt@71'@7lE@71'@7ڹ@71'@7Z@71'@7=L@71'@7&@71'@7}H@4@4-V@0 I^@0D@0'KƧ@0!R@0:,<@02@4n@0:,<@0&@0:,<@0'fA?|O?gˣ?ھ?؆{~? )?'t?|O?p RN%?tP*?j?5D?j^q?~/M?Ф?/X?bv{3dZ?a眷D?tl@@@@@ @,???????~#|KS{D?VVn?Fr\@47@7Bz?pWZ?a?S? wp?ʕZ{@ax@15d@[@j~#@h\@j~#.@j~#.@j~#.@j~#.@j~#.@zL@zN\2@zL.@zL.@zL.@zL.@zL.@7䎊@7XI@3S.Mm@3A7K.Qn@3&YJ.NC,@3&YJ.NC,@3&YJ.NC,?Hg @8#@8:@8 >+@8I@8?o"@8@8i@8@8S@8?Y,n@8 *@8p@8@8 @8 @?\@)g-.@)g-.@)g-.@)g-.@)g-.@)g-.@h(.@h(.@h(.@h(.@h(.@h(.@8qiC.>@5^5?|.Mm@5v-.Qn@4̿[W?.NC,@4̿[W?.NC,@4̿[W?.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 ]@p -@-@p -@`C@p -@ۋr@p -@6@p -@b}@p -@@F$/@I^5?@F$/@P ě@F$/@xe,@F$/@F&@F$/@pbM@F$/@lq @8YJ@86@45S@4!n.@3`A7L@3mjOw@3O M@2s@3O M@2\@3O M@2 M;?I~y??|JO?F?l?/߲^|@s @_@mV@a$/@mV.@mV.@mV.@mV.@mV.@;lD@A$/@;lD.@;lD.@;lD.@;lD.@;lD.@8?@88TɅ@5+.Mm@5"-V.Qn@4QiB.NC,@4QiB.NC,@4QiB.NC,?}@8#@8:@8 >+@8I@8?X@8@8i@8@8S@8?ʳ_@8 *@8p@8@8 @8 @?`@ I^.@ I^@xl"h@ I^@#@ I^@@N@ I^.@ I^.@YO;d.@YO;d@Y:)z@YO;d@Z ě@YO;d@YR<7@YO;d.@YO;d.@7O M.>@5S@4H˒:@47Kƨ@4!.I@3YJ@3;5Y@3YJ.NC,@3YJ.NC,@8J?;)ry/?Ɣد? @8I@8@8J?0?ċIVq?Eɨ@8S@8@8p?r -e&#?þسq?oQw@8 @8 @@@???a@"hr@"-@"hr@"B@"hr@"l@"hr@"n@"hr@"p -@"hr@"TɅ@ 7Kƨ@nP@ 7Kƨ@KƧ@ 7Kƨ@4֡b@ 7Kƨ@T@ 7Kƨ@w4m@ 7Kƨ@s@7*0U2b@7"h ԕ@4}hr @4v$/@4`A7@4iDg8~@3sh@3ۋq @3sh@3 @3sh@3\)?]?d^?;w{?ߦ>??XP#?]?&ژ?#fL -?f *N?QE?#?*wjs?XԠ#{?KxMR?q?VM?N;?@@@@&@,???????5ma?0{?U$+'?N1J@"ߞ: @*RX?e|kP?g#? ?8m?)-[@3{ I^.Mm@2`A7.Qn@2m8.NC,@2m8.NC,@2m8.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 c@n@y"@n@mhr@n@q[W>@n@gK]@n@ezxl#@n@f (@M@GlC@M@["_@M@P{@M@UXy>@M@Y~($@M@WsP@7`D@7au@1hr @1RT`d@0Vu@03@0 [W?@0 ^@0 [W?@0?@0 [W?@0'RT`? ?Ug@@@@@,@*??????vlYQ?q o?Qߛi ?Jʻ(@nN@O?m[_?h%8.?xc^?6V@dWr@d@}\1'@}]p -@}\1'@}n;5@}\1'@}o@}\1'@}$tS@}\1'@}'Q@}\1'@}bM@+ I@)^5?@+ I@!$/@+ I@)B@+ I@@+ I@hی@+ I@rGE9@5@@5 ԕ*@6hr @6&x@6V@5Xe@5(@4͞@5(@4`A7L@5(@4oiE?|O?+?q?T%?xTl?N*?|O?|Fef?7tg?&*N?gz?5t3w9?>Zw~?e?MB?U]^,?EL?ھ۲@@@@@(@(???????=̀?g˯N?|6z@2_o @2YJ??@@No9?B 'nr?U=K?bJֵ?F?g1?PuN?+l?M =?YNژ?H? -eKs?8A?]b?bv{3dZ?I$? {t@@@@@"@(??????\“^rC6?nS l?S~Ȇ@sI@·rd?}jo?`fe@/sD36?XTW@p/%Æ5@g@nO@w@nO@ov_خ@nO@p -=@nO@m q@nO@pD@nO@p )@kI^5@k1&@kI^5@kУ ->@kI^5@k)^@kI^5@kЖ@kI^5@k˒:)@kI^5@k I@7䎊@6v_ح@2ahr @2cS&@1-@1fB@1a:S@1g&@1a:S@1cn.3@1a:S@1dFs?Ol?: ?jhq9?,Z?o?P??#?Y͍_?uie?i?V\F?SY?to(?C ?]ivL?/X?[?{2?DV@@@@@,@,??????]ZP,?Kxn_?DA)Tل@r@kr@?kW:?d~#^?uP*K?o@h>>w@h@s-@s\(@s-@s@s-@s ě@s-@s@s-@shی@s-@s1@O@@O@w@O@{J"@O@hی@O@+@O@2@4*0U2b@4 @/"`@/>BZ@,;dZ@,|hs@+Ǔݗ,@+dž&@+Ǔݗ,@+Ǡ k@+Ǔݗ,@+Ǔݗ,?|O?GA?!!׋7?/? 9?2I/?|O? aҹz?A)N?7枪y7?֧QD?X78?m!?u?8*?ʬv?a+?@@@@@,@(??????ˀ?.V?Ǚ?@sY3r&@a2+?? ?5{^ކ1??wTC0@g[@i@;ě@;`A6@;ě@;\(@;ě@;G{@;ě@;ě@;ě@;@N@;ě@;oh@7-@7G@7-@7;5@7-@7L/@7-@7R@7-@7]c@7-@7͞@7Y*0U2b@7B<64@1 I^@1ڹY@1W-@1V '@1~($ @1kP@1~($ @1*0@1~($ @1y ?)T?J`Y?"?Rw#z?ԁ?4?F/P5?5CQ?ܿ?-I`K?W;zY?.8 -B?Z?Rii?],m=?v_.^??\??\@@@@@(@*??????OI=H?oK ?9> ׫?Q_Xe@;k@76E?W|oJ?qy .?r+p8?fٴk+@i!y@j@M@"`@M@fB@M@b}@M@`A6@M@b|@M@`A7@"`@-@"`@?@"`@@"`@]cf@"`@n@"`@n/@8>6z@8p:@3I^5?@3!.H@3W-@3ZS&@3m8@3&@3m8@31@3m8@3?|i? ?+!?XY?ׂa?yq?*Mis?(eI?6c?A -;?|lU?a]?Qʾ?p`D?*J?+ ?C SG?|)-}(@@@@@@???????_O:$RCu?Hw?Z-ʋ@P,{(@i?q_?kr -?ٺX?TbBO@r>:`@k@PE@P+ @PE@PE@PE@Pᰊ@PE@PwkP@PE@P '@PE@P҈@}E@y@}E@~Ov_@}E@K]e@}E@$ x@}E@xPH@}E@~҈p@8|Q@8R@3hr @3x@3PA7K@3LC@2xF^@2?@2xF^@2@2xF^@2}Vl?1j?Ѝ`Hh?K9\?㬱_?bC?#gh??j%Ra??íuA?W ??vk? ҇?[L?q' -B?a?"#?P^eNQ@@@@@,@*??????BC}?@oqI?`1Xk?c̽f,@PF@~?ryP?,A?."?~~-m@h V`@l@Stj@==}mq@Stj@@Stj@ :o@Stj@@Stj@+@Stj@W@!@8Q@!@/F@!@1T@!@2qI@!@Z@!@.H@7䎊@7tt@4?|h@4U@3~"@3J!"6@3fYJ@3Tf@3fYJ@3Cp~W@3fYJ@2lC?6]g?fA?QO&7*?5 -z?-T?H[ RC??'P?m'x?2"??NG -?d -Oe??{b?r7\?!N/p?ki?3s@@(@,@(@7@*??????Rԥi@f ?k#L4?s4@{@,Ż?9Q)Mf?x~?{0@ f0@dU @m@Ձ$@Լj~@Ձ$@ȴ9X@Ձ$@֔Fs@Ձ$@8YJ@Ձ$@՛=@Ձ$@`d@@KƧ@@+@@[W@@@n0@@)y@@_@7-v@7.2X@2+ @2=b@2"-V@2"T`d@1O M@1v@1O M@1!-w1@1O M@1쿱[X?us\?1?ՠΆ{?gk\0?״6z@9g3@4ٺ^5?}@4ߪ͞@4ttj@4y (@3D*@3쿱[X@3D*@3_o @3D*@3'RT?}?$? 1B?GZ0e;? ا ?!2f?1?GE?Hyq?)h?Z?2?W|DC?Cns@@@@@,@$??????6nۜP/:[?@$ ?S]^0_@O] @\#R,?U^.(?mHE?,xc?=?i&C?7PK?~7q?m?%aȲ?]k7?]m3ƌ?2X@@&@$@*@7@9???????UcFc ?clj?cC@1V@ao."?(ZN)?M@]KV?H:@c@r@>,1&@>> [@>,1&.@>,1&.@>,1&.@>,1&@@u@>,1&@=# -=q@)n@)V@)n.@)n.@)n.@)n@B I^@)n@.V+ @9|Q@9 -7?1k@5pěT.Mm@4-V.Qn@4_o .NC,@4_o @31@4_o @4֮}Vl?C I@8#@8:@8 >+?WTi?d?_o_d@8@8i@8?-Ci|?1=IL?-@8 *@8p@8?q2?]ws@@@???s@Ob`B@O`ě@Ob`B@Oa]K@Ob`B@OC@Ob`B@O`S@Ob`B@OHG@Ob`B@OR @ 7Kƨ@]y@ 7Kƨ@&@ 7Kƨ@[@ 7Kƨ@I@ 7Kƨ@r(@ 7Kƨ@c@8 _o@8 #59 @2E?|h@2#2Vi@1~Vu@1RzEn@0iB@0C@0iB@0b5@0iB@0z&W?]Ov?m@pZG?[?K;0?Ҧ?z9?/?)?!vqG_?(?qQ'?`R?e ND?HQaG?f-%l?V5?&X?E L@@ @$@(@2@3??????lE`?e65?qP~*h@OUJk@ю?X?I%?' f@" @nl.:C@t@}bM@}+@}bM.@}bM.@}bM.@}bM.@}bM.@ßvȴ@öȴ9W@ßvȴ.@ßvȴ.@ßvȴ.@ßvȴ.@ßvȴ.@8*0U2b@81@4hr .Mm@3t.Qn@3iB.NC,@3iB.NC,@3iB.NC,?@8#@8:@8 >+@8I@8?X@8@8i@8@8S@8?뼑:@8 *@8p@8@8 @8 @?u@+R@)^5?@+R@+C,@+R@ح@+R@Ce@+R@/w@+R@>쿱[@]eS@]glC@]eS@]>vȴ9@]eS@]J=p@]eS@]XbM@]eS@]Sg@]eS@]D+@5*0U2b@5@20ěT@2XTɅ@1KƧ@12W@1 -0U2a|@1":)y@1 -0U2a|@1\@1 -0U2a|@1 xF^?F/P5?Na~|>?%'^?OXi}i?p?p?| ?~;?Sw?u/?0?)?lBCk?],V?+>G?. ?"x?o(?8~,@@@@@,@&???????oQyZ?Y7?Ck}@/@]]̽?y_~? B[?5}'?eV?S)$?X?@?!2f?X?Oy?_?`ֆ?B*Z?y?y5?6?5"GW?sq?d?ҸBz4@@@@@(@&???????rSl?QZ`E3?PM.$@ -Mt@qiN4?e'?gbS? -X ,?ҜY@o @z@A7L@>70@A7L@y7@A7L@?@A7L@wo @A7L@Let@A7L@[@ -=@ I^@ -=@G@ -=@P@ -=@򌬑@ -=@n@ -=@PA@8zqiC@8+[@25?|@2=L@1j~@1s6z@10@11B@10@10~@10@10m?,(g? -׷?r+@8I@8?@8@8i@8@8S@8?p̺@8 *@8p@8@8 @8 @?|@%@%zH@%@%O,@%@%]/@%@%@%@%@%@%,v{@WI^5?@WI7Kƨ@WI^5?@W-H@WI^5?@W1"ۡy@WI^5?@WYSP@WI^5?@WaCUӈ@WI^5?@Wa'@1s@1;dZ@0 -^5?|@0 -T@/ΗO<@/9@.`d@.K+I@.`d@.E@.`d@.m]&?^ee?Ϧlۄ?{ͱϑ?@ Q?T) -K?ϡSbw>?bO;C?\ӯ?@?.G? ]?|5?&?bb˙?:(?[c? =?eˍ?@LD@ @,@$@*@7@7???????C?_{l?0 |3?C/nT\.@%qLw>@W^6 ?uVi?Ʈ#;@rғ\@}@7@Ižz@7@g/W@7@Y~@7@ߤ@@7@5W@7@rGE9@xQ@x?8Ie@xQ@v@xQ@wO;@xQ@wV8YL@xQ@v3@xQ@yp'R@9(YJ@9&qi@6pěT@57@6V@4u84֡@5_o @4 ě@5_o @39XbN@5_o @75??j |?ܡuk?NxZB?ľ}'0y?%Oܖ?uYdP?*Y*??Eʻ)?pQ$?OY?8?|[D?enUW?6h? ~?;ܔ?=ɧ@@@@@@"??????D(?5d?Yr@rs@wUrǒ?gΙtY?a}DG@mN}@J%SR3@i~f@~@LzH@LV@LzH@Lߤ@@LzH@LN;6@LzH@Lx@LzH@Lzxl@LzH@LƧ@fffff@f+ K@fffff@fx@fffff@f˒:@fffff@fe@fffff@f,<@fffff@fq@4Y*0U2b@4X\)@2f+ J@2f+ J@2-V@2H˒:@16z@1%@16z@1 @16z@1C]?|O?j‚?X~4w? -?,I ?WA?|O?c?ǀr?#X?إ<(?]˙$>?],mBZ@ɺ^5?@ۋp@-bM@-bM@-bM@-)^@-bM@-- @-bM@- @-bM@-@-bM@-$t@0YJ@0YJ@/j~@/ߥ@-n@-$tS@-Z@-:T@-Z@-n.@-Z@-'S?^Q5P?3i?4!p?̒? f?CXs?bM_x?u߿?['?6)}?M?lINՄ?bMky?/?2Y0?xqC?f_Ԋ?B @@@@@,@(??????,</Lm~?0IP?,EX@N@-F?>-]+?;'L%?wO6/ά?p{&AE@se -@@a@J=p@a@de@a@b7@a@d*@a@c -=q@a@f?@ ^5?@p -@ ^5?@K]@ ^5?@ )^@ ^5?@D@ ^5?@Mj@ ^5?@!-@9+s@9,~($ x@4)+ @4(73@3)"`@3(K]c@35sh@34g8}@35sh@33@35sh@30`A8?`m?Ѝ`Hh?X~4w?CF ?91?HAm?[Xxp?0?t-E?r?Op?q?rR? -tM?+-/?w%?6m?*:R}@@@@@(@(???????aer%UC?b?Q4@dh:@R?r0U?gS?ٙ?6ě@pH/Vz@@|h@\(@|h@Hˑ@|h@#{J#:@|h@Q@|h@/V@|h.@vȴ@-@vȴ@Y_p@vȴ@u=@vȴ@Mj@vȴ@kP@vȴ.@8۹~($@8As@4I^5?@4tZ1@4"-V@3ק&@3kxF^@3 P{@3kxF^@3@3kxF^.NC,?)T?ts3?%16?䌛%?Ԯ>@8?|O?rO?•0}|?E)p?A\"I @8?`Ƕ?a5?k@{?7h?'@8 @@@@@,?????@R@1&@R@*0@R@u%G@R@ M@R@ ҉@R@-V@ffff@x@ffff@;5@ffff@Z@ffff@p@ffff@@ffff@˒:*@4+s@4+S@1S@1e+a@16-@1,u"@0m8@0-@0m8@0~($ x@0m8@0p ->?}ѿ,?'Qp?b/?ѮvtQ?t/1 ?dkU?| ?@`WӐ?h?= 6?z&>?TS?n88?9WTW?US9?*Q_? -e?L.C-@@@@@*@*???????YK] ǀ?_p?[ς@@%?tט?qs0?1:X[?~|@_X@@&ffff@49Xb@&ffff@RT`@&ffff@s@&ffff@$t@&ffff@}H@&ffff@>6y@@u@@C@@̥zxk@@յs@@7KƩ@@=K@8䎊@8}p ->@3c@3PIQ@2~"@2)_@2&YJ@2 #x@2&YJ@1t@2&YJ@1˒:)?X?Ѝ`Hh?BI{?`ĉ55?,j -[?=c?h??[u?AuG1? 3լT?ɬ\?p=D?=c"?XԠ#{?q6tN6?k.A?Q?]?İ^@@@@@*@*??????k?sK?nC0U?Yu@:Ɲ@\@Xqx?D4Ii?u2v#6?+>F?0Q@e[:@@dZ@cS@dZ@g+s@dZ@lAp@dZ@[#5y@dZ@c -k@dZ@c@9Xb@9Xb@9Xb@ok@9Xb@3@9Xb@2q@9Xb@Ib@9Xb@@45S&@45L_@1 -^5?|@1Fn@0 "`B@0=KW@/-w1@/ת,@/-w1@/o@/-w1@/< -?|h2:?R?;"ٵ?S?/] ?&X=I?}@TΥ?DZ? =׿?J?^ ?Rnw?o,qV?2sFH?˄f?is?I.?Rq1@@$@&@ @:@8??????1p&?`3k?Bob?Fek@a_b@D?a<#O?e鈨g?U? q,C@f>uJ}@@ -=q@t@ -=q@䎊q@ -=q@e@ -=q@e@ -=q@ @ -=q@9@@b`B@@b`B@@b`B@@bM@@b`B@@a@@b`B@@` qu@@b`B@@bM@@b`B@@bZc!@1_o@1"`@-~"@-0U2a}@+wO;d@+w>6z@+L/{K@+@+L/{K@+ڹ@+L/{K@+?_\p)?m?@?ArU@?6r In??bM_x?)[M@s @@\M@\@\M@\7@\M@\7@\M@\t@\M@\7@\M@\!.@Dt@D/@Dt@C\@Dt@De@Dt@Cn.@Dt@Dt@Dt@@IQ@5S&@5tj@2ahr @2bn@1-@1 k~@1p@1qX@1p@1t2W@1p@1mC\?2}? KG?Z*C?nii)?j?^m*?|O?$i %h?qN?|}Յ?=W?f:[c#?m+&?rbT?`x?< N ?7?+`ȓ@@@@@(@*??????3OA0BL?TM?0PKW@\"QOh@Cv?tV lw?P>o -?'PŶ?` @fbs@@UۥS@U7KƧ@UۥS@U_ح@UۥS@U@UۥS@UIQ@UۥS@U}H@UۥS@Uޞ@+@O;d@+@$/@+@ɺ^5>@+@@+@#@+@ƍ@7H@7>BZ@3kS@3gsPH@2tj~@2-@2Eu@2҈p;?oC?m0??A|x?~9n4?EeX?)T?;N?5 ? ;q??I}?? ?E?WhQ? $4?$jB@@@@@,@(???????qnW|?[?6ȃn9@UBX@rӹ?yY?X/̕h?#<Д?v/@kj9l@@r .@r .@r .@r .@r .@r .@o/.@o/.@o/.@o/.@o/.@o/.@3YJ.>@2; I^.Mm@1`A7.Qn@0D*.NC,@0D*.NC,@0D*.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @-@Ƨ@-@w1@-@ @-@@-@sh@-@A@?m@?-V@?m@?n.@?m@?^5?~@?m@?Y@?m@?N;6@?m@?я@6!.@6R<6@3 I^@3Q@3tj~@3lD@3:S@3u%F -@3:S@3g8}@3:S@3?Y͍_?PƧ$?U%x?gk\0??X|? ?ڲt?+l?#q\-v?þ_.?/\Ӂ?+B?<{?@K/{? Y? ? g@@@@@&@"???????p=^'s<?^P~?t+@7 -@?&5?z8R ?c6ZG?m6c*4@b[@c(@@ow@n+@ow@n@ow@oiDg7@ow@ow@ow@mqu@ow@l@S@ffff@S@e@S@wj@S@&@S@\(@S@|Q@5:qiC@59y @35S@35sh@34tj@33ߤ@2u@2š@2u@2Fs@2u@2?1j?6 '8?a#mU?!#?<?K&?| ?ā?1ک! ?/:?qn?.?`w?`F?A'_^?#ѧ?3?<שN@@@@@*@(??????5@QីD?*-(?0n>4@nI*@zg?Ip/2?P ,Y?$?/ru2-@f'a@@Q@W@Q@Mf*@Q@I@Q@T4@Q@t@Q@N1?@Mn@Mb@Mn@M5L@Mn@MN@Mn@M?"@Mn@MG@Mn@Mg,qz@7uS&@7tn;%@23S@23QeP@1Htj@1H63@1Q@1Uł@1Q@1s@1Q@1Z?I'%?;",?y$?LHfX)?[p2?;>z?|Ί?Cb?N{BU?ňw@8RnP@8C -=q@8RnP@8DT@8RnP@8L@8RnP@8M(@@S@@`A7@@S@@q@@S@@҈@@S@@6@@S@@e+@@S@@N@7`D@7`|@2 I^5@2"h ԕ@1q7Kƨ@1l>@0iB@0L_@0iB@0C,zy@0iB@0hr?F/P5?). -?9a?^t -a?Nty"?m\Wq? ??cu%+?3?V i!?6 a@B?CK?O? ?_u@@@@@,@,??????O]bQ}V%?Q A?4e1@8MU v@@߶h?qQ?U ?ɑɚ?{ip -@g= 2@@O;d.@O;d@B @O;d@`NJ@O;d@ -@O;d@wq_@O;d@i(ш@:w.@:w@9MW@:w@9 4@:w@:` @:w@:_@:w@:@9S&.>@5{ I^@5b!]4>@517Kƨ@53y6@3m8@3vE@3m8@3АO$@3m8@3VW@8J?롕?^?ֳ ?iꚆ?bC3@8J?̹м?-Φn?nX?}BH?ҖP@8p?0UF?#!?Q?NA. ?u˾@@(@(@2@,?????@j~@Q@j~@J@j~@,*@j~@zL^@j~@d@j~@h@)l@(r @)l@(@)l@&$@)l@!trJ@)l@#;ZV@)l@!̑e@7 ]ce@7N@3kS@3m\@3~"@3=(,@20U2a|@2 @20U2a|@2\^u@20U2a|@2΍p߃?t?WB~&?6z/?_\?K-\?=?|b@?y?i"4?y? <@@??44]?m֩?Zn@@ @*@$@9@7??????@HsN?CL?(mnl@@$kcbv?bOUD?Kr%W+@8I@8?e@8@8i@8@8S@8?yAd@8 *@8p@8@8 @8 @?@S@F@S@Z@S@B@S@?@S@1u!@S@{@&x@ě@&x@m^@&x@ \@&x@Vl@&x@#n.@&x@#n@6s@6]p ->@4R I^5@4W_o@46-@4?iDg8@4Tm8@4A2W@4Tm8@4-K]@4Tm8@4Os?wVz?oNQ?70t_c?n?N?_]?r5]v?S?|? Jy ?%v[?ӽbȷ?>ҝ-?rIs?f8?B?Nka8?lb% @@@@@@*@,???????(4?Z핂?.?ݽa@I~@~?S"X?]sC ?ı=.G?[Æ@rżEf@@ -.@ -.@ -.@ -.@ -.@ -.@%j~.@%j~.@%j~.@%j~.@%j~.@%j~.@9%!..>@4^5?}.Mm@3`A.Qn@3:,<.NC,@3:,<.NC,@3:,<.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @N@N͞@N@Nw*@N@NQ?@N@Nލ@N@Nt@N@N'OG@R@r @R@V@R@[.t@R@qu@R@—@R@ߤ@7֚,<@7Uv@3 ě@3u@2"`B@2V@2=ce@270+hP@2=ce@25JW7@2=ce@25mĒ?|B &?ukB? aMP?.bs?@sM?Q荌?t ] ?i_??Rɐ?͡?N?㾉?v'G?fP6?𦒽L?jAr?t1? TO@@*@*@,@8@7??????I..Zk?G7Ը?V̆o@N\N@ՠXŃ?o?q6b?հ%@?r~H@mO@@$/@t@$/@˒:*@$/@m9@$/@̈́M<@$/@m\@$/@6@bM@~#@bM@ɭB@bM@9@bM@J@bM@_o @bM@ -L0@8(YJ@8#@5c@5g -=p@4-@4\(@4QiB@4*@4QiB@4[P{@4QiB@4Zݘ?ꯨT?o5?П?%W$?"y??V¹?ٛP?w? ?#Vz?!kD?6hC]?{Tä=?T?z?5 -: ?l?F@@@@@*@*??????1uMrR?P67?^vl@]*@?oP'Lf?}믏]`?T?յ @k!f|@@@@@҈@@d@@҈@@b}@@?@1m@1m@1m@1.@1m@1N;7@1m@2@1m@1N;@1m@2@0,<@0,<@,Ƨ@,Ƨ@,&x@, @+jf@+xF_@+jf@+C,{@+jf@+C$?^Q5P?{j?$C@?XQ>?Ot?ˡK?bM_x? ,C?qF?Hn?إ<(?SV.?bMky?u? SF?xqC?l&?B @@@@@(@(??????Bؽ?1+?ub@FOB@1?@'=H?!vȸN(?z%rd?:Kxf8@s -b@@E@v@E@1@E@_p@E@Q@E@,<@E@S@(@lE@(@ӶE@(@nP@(@C@(@JM@(@k}@5䎊@5l@2hr @2x@2'KƧ@2"GE85@1Ǡ k@1-w1@1Ǡ k@1U2a|@1Ǡ k@1*0V?|O?'?`כm?wX/8?2F0?P?|O?0n=Q?%8?ҧ?4.?F5?T0?Ϸ+?],m=?"a??*Z}?Tj@@@@@,@,???????V;<q읂=?IBH?F7~p@Oh@ңK Z?hJP͂?e[?`d>D?罜@eG"@@T-V@T-V@T-V@TJ@T-V@TD@T-V@T9Xb@T-V@T @T-V@Tu@C@C@C@xF@C@:)@C@f@C@:)@C@~#@3H@3c @/t@/ݗ+j@.x@.m\@-C\@-V@-C\@-M:@-C\@-M:? ?j‚?WD@?|*(??}?| ?,#?)_?Hn?,Y?{L բD?oܧ?˛͇q?W ?':?j?pk Y@@@@@&@&?????? -+ -E,@?7tw'6?RM@TRVPx@̃V?W@?9?2L?~[@gv!p@@ )x@ $d@ )x@ (*R@ )x@ 2@ )x@ %@ )x@ !>^S@ )x@ @\(@=p@\(@l@\(@;@@\(@ș@\(@w߽@\(@Kp@8䎊@8@@3S@3$0@3t@3 -Gvz@2s&@2wd"6@2s&@2uPy/@2s&@2qM5?Äp? P?/b?V黀?D. -r?Ұ(=?nDyB?O3?6'@ ?!2?zO?WX.?dvG݃?I_S?zb?bc?N^@p?5*[@@"@"@"@,@,??????U[&?_>`?JYAb,?CB@ "@2?g<=,?c٥z?Uq?.Ö*@kn3@@+ J.@+ J@@+ J@x@+ J@索3@+ J@捸@+ J@Fs@H!.@H!@H k@H!@H ě@H!@H!s@H!@H u!@H!@H!t@5`D.>@1I^5?@1@07Kƨ@0n.@0#@0# -=p@0#@0$?@0#@0#*0U2@8J?m?"?菁k?@ A2?w'@8J?I?#Gf?e[|(?֧QD?'+@8p?3I#i??E 8?L? -t@@@@ @*?????@M@S@M@捸@M@eO@M@G{@M@:@M@7@+ J@+ J@+ J@ĵ?@+ J@4m@+ J@n@+ J@@4@+ J@?@5]ce@5B@2S@2tj~@1-@1R<6@1@1rG@1@1k~(@1@1?}ѿ,?@k=[?Uy*@1u@1L_@1u@1ĵ?@1u@1tk?)T?4L?jhq9?)?״ ?_u@@@@@(@,???????H> ?#uw#ѷY@2tj~@2u!R@1~($ @1Vϫ@1~($ @1`d@1~($ @1qj?F/P5?@%:!?Р'?avfڵ?6?o@@@@@*@*???????Sb?ʉGl~?kBJa@il@@  I^@ ??@  I^@ @  I^@ }@  I^@ H4@  I^@ =p@  I^@ h@QXbM@Qcq@QXbM@Q+@QXbM@ST@QXbM@Q@QXbM@QxQ@QXbM@P)~@6Q|Q@6SJ,@3ahr @3Cj @2j~@2=c;$L@2iB@1D|@2iB@1ռn/@2iB@1=?| V?Y@T?W%W?VWD^?[q)?2}hJ?pV?n?K? #?Z.J?"4M? 1?-?lo?{iO?#.?]@@@ @$@@.??????\aM⹀?CX?^p@ k @Q-Rx?k?#Ɲ@]r{04@53[@aos@@| A7L@|@| A7L@|$/@| A7L@|@| A7L@|" I^@| A7L@|]cg@| A7L@|U=@ |h@ -x@ |h@ Vl @ |h@ $tT@ |h@ -M@ |h@ -4m@ |h@ -ě@7쿱[X@7=K^@3pěT@3s{J#9@2-@2r Ĝ@2J0U2a|@2FFs@2J0U2a|@2KC%@2J0U2a|@2I^5?}?}?;?K̃?eU5?ԁ?lP {?|O? l?J?1'7?X#?ua?~$?6?Q?.SM??*Q@@@@@@???????YV8XS\?SlD?)q,sl@|W@ -LeL?q?KP2s?Y6? +|@h5`@@J O;d@J-#@J O;d@J -|#@J O;d@Jߦ@J O;d@J%%@J O;d@J[aJ@J O;d@J SS@-@Tɇ@-@;@-@Q@-@˩}@-@:@-@Mк@8G>6z@8=\E$@3ԛS@3٢t@36-@3;j@2Q@26' @2Q@2g@2Q@2vJ#?Äp??a0{"Y?}o#? ? >Ǥ?|"<~~?Xq?Z5_?xC?UZ"?zS!Ń? F?%$ ? Ur?Gt?wOH]?8Ϝf@@(@$@&@$@.??????HT?Q?3m<?8H@J@q[N?,!bG`?[ʐ[?X9J*z?.@j<K@@:^5?}@8bM@:^5?}@;/V@:^5?}@4@:^5?}@5!T@:^5?}@.qk@:^5?}@.;5@(\@$Z@(\@v@(\@tj@(\@@(\@˒:*@(\@ - @6 _o@6A@3|hr@3 k~@2Vu@2!R@2@2r Ĝ@2@2C\@2@2jf?F/P5?.5?F}?gt>? QQ0?(?qn?iCv?CbNy?cgp?Fl}?6%6?E}?`F?Me_??$jB? N@@@@@,@*??????`R䑼Q?:?cT@37L@u&p?]LOB?ួ?e:?2!@iy@@o-@o;dZ@o-@p*/@o-@np:~@o-@q&x@o-@n1@o-@n*@KƧ@L@KƧ@KC@KƧ@KC@KƧ@Mqu@KƧ@L[W@KƧ@L<@5ks@5k:)z@0+@0_o@/O;dZ@/Vt@-N;6@-33334@-N;6@-m\@-N;6@-m\?2}?Z.?U#?ݶ\r?6r In?aX? ?`5a?90?@Cv?Ff$?+d?W?˛͇q?]?3{Z? -t?j@@@@@&@*??????!s>>&?1Trso?A<.@o{h@L?QAڡX?3&1?}H?qj@h&@@kR@k I@kR@l"h @kR@l1&@kR@lL_@kR@k I@kR@kC@ȻlD@ȼ(@ȻlD@ȼߤ@ȻlD@Ȼqu"@ȻlD@Ȼqu#@ȻlD@Ȼ6@ȻlD@Ȼm@4O M@4oh@,`A7K@,S&@) 1&y@) C]@&L/{K@&?@&L/{K@&?@&L/{K@&L/{K?Ol?°R;?"?eU!?Ot?*WF?|O?%F?90?1'7?%y*=?N`?2Y0?.+?q6tN7?avh?#.?#.@@@@@,@*???????~ap ?#CT^7? dw@ @kP8@Ȼ۾?BtM?-֪?'c<3d?eFX% @h 16@@\)@_@\)@d5@\)@h@\)@~@\)@ù.@\)@хD@\S@\S,"@\S@\M@A@\S@\JءK@\S@\l݊@U@\S@\Âw@\S@\Lˌ@6@6U2@3hr @3x@3"@3쌜q -@3u@3 ,@3u@3v@3u@3t' f?~Ov_ح?Hk7?9 /?83?\ǵ"5?/J?N7?q'?XA?jKf?\s?fLO?}t7?~^O0?`xb?- ?FRv.?6`%@@&@,@*@:@7???????s?|<%@?Q?SPGBf@Ke@\fN -?kQ)d?o?]?̚rZS@a3i q@@ -=p@KƧ@ -=p@ᰊ@ -=p@ȴ9Y@ -=p@$@ -=p@_ح@ -=p@ -=p@Q@^5?}@Q@ح@Q@5?|@Q@\O@Q@IQ@Q@R<@7֚,<@7т @3J^5?|@3KC,z@2-@2+@2a:S@2a|Q@2a:S@2aN;5@2a:S@2a:T?Q,Ě?:L -?S?9.?.Kn?=?=fA:?-NI`(?ދ"?.}$?*v7?lINՄ?Fp'?)Zw?Ol?__C?k!l?L@@@@@@???????4G,?U/X?5[X?8☈@%Ǥ@=6?Iݜ&?X#_?M}gK?b]@oza^@@q7@q/- @q7@qO@q7@qTJ@q7@qLI^4@q7@qH@q7@qG&@FT@F+ J@FT@E#@FT@Eح@FT@FN@FT@F@FT@F *0U3@7YJ@7҈@2hr @2n@2-V@21@10U2a|@1g8}@10U2a|@1@4n@10U2a|@1s?oC??b? {4?W?$?Ol?Ғ](+?ud?R?6?*?ʭ#г^?????>LR_5?x@@@@@$@$???????sf<3z?g1?P@qCy>@FG?ZI?rm9?gzOJ>?w`@kr @@sE@-@sE@jra@sE@k/1l@sE@kB[@sE@k>Q@sE@kU@E@8@E@30 @E@>eH@E@D9@E@I2@E@GENO@8`D@8XNU@2?|h@1>Y@1`A7@0KTk@0}ce@0z~o@0}ce@0|c*@0}ce@0jD?Z?1Q?[Ze6?G&̮?H?4,X?Z?̡Z?6?5) ?+2?4V?A?P?܇R?9??(?uRZIr@@,@$@$@:@2???????#L]?E|7?2HQ?C@k##@F}9?BdC;?R Ph?~Əet?~H -@sXlb@@I^5?@Ix@I^5?@Iԕ+@I^5?@Iy@I^5?@Iy@I^5?@I'RS@I^5?@Ix@u@E@u@Ov`@u@R<6@u@+ @u@z@u@u@/ @/ @*7KƧ@*7KƧ@*E@*R<6@)`d@)SMk@)`d@)SMk@)`d@)`d?^Dw'?+g߶?S?XQ>?/`?*WF?bV,? -?A)N?3.Yl?֧QD?SV.?b@? ?s@a?avh?O|q?O|q@@@@@,@*?????? p+P*>4Z?0,@II@\E?';&?$Y?KO?CTd5r@s@@.@.@.@.@.@.@3z.@3z.@3z.@3z.@3z.@3z.@8S&.>@48r Ĝ.Mm@3'KƧ.Qn@2䎊r.NC,@2䎊r.NC,@2䎊r.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @}p -@o@}p -@ qv@}p -@Fs@}p -@ὥ@}p -@HK]c@}p -@- @Aݲ-V@AƧ@Aݲ-V@A C@Aݲ-V@A]/@Aݲ-V@BD%2@Aݲ-V@A#@Aݲ-V@AM;@8[~($@80@3?|h@3`d@2v-@2i k~@1D*@0@1D*@1ae@1D*@1}H?'[ V?ȔS?ƀvFd?T ?C7@O;@Xe@O;@l!@8w@@8or@3S@3E@2-V@2@1a:S@1bm@1a:S@1cZ@1a:S@1cnP?}?#T?=P?$? ?5@4@4S)@4b-V@4n٠+@35sh@37庭ά@35sh@35f@35sh@3n<@8J??1?oM"?W}8?pȭv?!k$_@8J?ܚ?g^}?G% ?9.? -`?Pa?nK/?`w?9o?ʳ_? ???\?Rv@@@@@(@,??????+AU 5?*k4??kJ@Bs#A@E+x?Jxu?5Yh5?-?v_á@f{@@Q'lC@Q'lC@Q'lC@QFYJ@Q'lC@Q-M;@Q'lC@Q#@Q'lC@Q&Ft@Q'lC@Q*ڹZ@I^5?@KS@I^5?@J͞@I^5?@V+j@I^5?@L@I^5?@QiC@I^5?@P ě@7[~($@7^$t@2+@2u%F -@24tj@2#&@1B@5@1:ڹY@1B@5@19|@1B@5@16 '?)T?Vjn?/T?zRU?BPbC?W4??;TMn?Z7?,ў?Hد[?)u%? uf?vv?6~A?< N ?w w?屘@@@@@,@*???????Lj`?S⛤?H7g?A"FS@Q',@N)Lf?hLd?^mzlj?lN D7?@i=H/`@@H9X@BM@H9X@JL@H9X@Iᰉ@H9X@GRT`@H9X@F@H9X@H@"@;dZ@"@4m@"@"@"@ k@"@@"@-@87@@823@3pěT@3r&IQ@2tj@2@2n_o @2ohۋ@2n_o @2p6@2n_o @2q4J?Y͍_?tH?~"?Rw#z?r {#&?Q`?K{O?PuN?kCnL?^W.?V?*%>g?&?)h? - l]?"a??|)-}(?`i2@@@@@*@,???????UlR>]2?4ds!?G}[ɭ@F¢@=Z?UƇ"?_vz? -g1?3w>@no@@q&x@o @q&x@E9g@q&x@kHĘ@q&x@k@q&x@cr@q&x@z?@.w@.v@@.w@.]ث7@.w@-l]@.w@-@.w@.gFd@.w@.h@7DO M@7@JK;@3; I^@3.c5u@27KƧ@2抝t@2z,<@23]@2z,<@2S20@2z,<@2U ?eXW? ?|i=? c??}?(_]?3?C#]?ѩ.?l3?lf|?ږَ? H3?y?yyȧ?*niC?W@@$@@(@;@8???????U4^c4~"?l;?lJ@qlj&@.lW+O+?}l[:?Xl@g ?sr(@e7@@@ow@@wKƧ@@ow@@oDG/P@@ow@@qFݗ@@ow@@p@@ow@@mFW@@ow@@ml@4V@4"M@4V@4"u@4V@4@4V@4 @4V@4 ?; @4V@4oJ@804m8@8=\(@3?|h@3T@2Ͳ-V@2|@23&@26@23&@2:Y@23&@2;?Z?P 6?N6?OO;V?-??Z?h)-?ɡ%?39M???A?-dʦ?>JM?t66?[!.?Vm3Y@@(@,@@<@:??????Wc?]&B?0D9\?L*z5S@@nv@4??[8 ?Z3?t}*>d?Bt@r8@@S I^5@S @S I^5@S 5Xy@S I^5@S &@S I^5@S U@S I^5@S ~)@S I^5@S a@t@\(@t@S@t@?@t@@t@?@t@%2@54m8@5u!@1n5?|@1nu@0]V@0]qu"@/b~@/"a@/b~@/ (@/b~@/6D?| ?%ñ?e -!C?ArU@?2A?7F?| ?0n=Q?LE?Y?=d^?m/w+@8I@8?ҸBz3@8@8i@8@8S@8?Aᆽ@8 *@8p@8@8 @8 @?@1&y@1&y@1&y@9X@1&y@ @1&y@ 7Kƨ@1&y@ݗ@1&y@ݗ@0zG@0zG@0zG@0Ʌo@0zG@0m9@0zG@0Լj~@0zG@0D@0zG@0[@0쿱[X@01@,\j~"@,\j~"@*|1&@*|?@*\ߤ@@*\Q@*\ߤ@@*\Q@*\ߤ@@*\(]?^Q5P??(? Y?/`?tJ?bM_x? -?90?0N:s?@?N`?bMky?~('?q6tN7?͓E'?Ѐ>(?l&@@@@@&@*??????HuG?4?0eL?{Y@=@0;å?>WM ?kMh?wRD2?!z"@@sU@@Jo@J~#@Jo@<#@Jo@,@Jo@)y@Jo@qu!@Jo@ xG@@XbM@@d@@ؓtj@@Cn@@P ->@@)^5?@6qiC@6ߤ?@2|hr@1ѷY@1b-V@1)lD@1iB@0m\@1iB@0y @1iB@0>BZc?ٛP?Q?F.?ʺd9.?qS=?y?Y͍_?1Q?c2M?A?,Q0b?r -?t -j?anñ?҃N%?<-V?&?Oh6c@@@@@,@*??????p' ?'l`?Ow?}Exw@8@ˇ?mb'PN?'| a?!ʶb?yAĈ@`""@@lC@-@lC@˒9@lC@ᨚu%@lC@TɆ@lC@YJ@lC@YJ@TF@U?|@TF@TɅo@TF@U*1@TF@TO @TF@U?|@TF@U%F -@+@+@&kƧ@&kƧ@$O;d@$O;d@$73@$73@$73@$73@$73@$D+?^Q5P? ?m?8v?DE?tJ?bV,? -?j?/Z?(T >?N`?b@? ?nwg?~\?h?#.@@@@@(@,??????R ?+t?7 -9n4?N@R@T^?F'>\?*pƮ?&CLAA?NaJ@s*)v@@n@;dZ@n@Xe@n@],@n@捸@n@8D@n@be+@;@;Q @;@`u?2ci?j8n?1'h -?Nϸ?(ƴ? \d?÷?o ?־c[@@@@@,@(???????؜DGKx ?[?{E[a@ē1u@;H???:2*Y?zZ@y?щ3@d|EgL@@zN+.@zN+@zPP?9@zN+@zO2!@zN+@zP@zN+@zMȊw@zN+@zMӾq@\Vu.@\Vu@\V@\Vu@\Y*@\Vu@\V:@\Vu@\UzO@\Vu@\U\;@/A'R.>@*$tj@*$}@(E@(4@( -#9@( 8@( -#9@( *R%@( -#9@(.])@8 -Ny?V?Σ1?.mA+?+?\XV@82r??=?|v*?3FNc$?~@#Z?OZQE@8L?T?q?懒nW?ҕ@?i= @(@,@2@=@9?????@|h@$K@|h@ @|h@fL<3@|h@ -Z(@|h@f~@|h@n@kR@$M{@kR@RN:@kR@u.МS@kR@vI@kR@oo@kR@t| =@8_o@7)s@5+S@539I@4A7K@4/@4ush@4"#*@4ush@4&7@4ush@4"&?@l#?׮ ?߱?y?\l5w? j?#{W?+21?(w?=#o?MZЮ?b4?K:q?0m -i?f?R]?.:N?eq+k?>┅@@$@$@,@<@8??????G.o?Ix ?n|NW?l7y]@P@r7?}j:?|^ʲ ?*7]?j@5)@s-5@@+1m@+2-V@+1m@+5!S@+1m@+1iC@+1m@+/o@+1m@+1@+1m@+4SM@8@9+@8@84֡@8@6z@8M:@4@ ě@4Ft@417Kƨ@4>5?|@3!.I@3"T`d@3!.I@3t@3!.I@3??_$?%ñ? 3з&?K?3;5??% ?u߿? q)?Z.?h?'qTrQ?*?ڱP?p?'w?cZ?K&?Us@@@@@,@&???????])T?bI?vjCUR?OBzWO@'uj@^1o?lY?q4@:?Ż @oݪz@@p ě.@p ě.@p ě.@p ě.@p ě.@p ě.@F.@F.@F.@F.@F.@F.@74m8.>@3S.Mm@3 "`B.Qn@1&.NC,@1&.NC,@1&.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @ěT@ěT@ěT@š@ěT@J@ěT@o@ěT@S@ěT@n.@&x@&x@&x@&ffff@&x@%84@&x@%ں@&x@%F -L@&x@%n@3۹~($@31&y@0!hr @0!n.@/mO;dZ@/m@.Vl"@."`B@.Vl"@.wkP@.Vl"@.C,zy?]??K]4?MA8??t?]?NۈV(?CXs?3.Yl?IM?ȏ'T?*wjs?l?֘>D?k,?SP?M684?@@@@&@&??????H+A!3?0ßݕ1?)0^j@@%!?@4^3?87,?xx?iUa@sB@@sE@v+@sE@{J#;@sE@l"h @sE@tm:@sE.@sE.@p@p @p@pV@p@p@p@p>6y@p.@p.@8,<@8I@5+@5҈p@4Ͳ-V@4- r@3,<@3($ x@3,<.NC,@3,<.NC,?$?"O.ڗ?E?yFc@8I@8?| V?,Z?is?*o@8S@8?5`b??E?"Ԛ@8 @8 @@@@????@1&@9X@1&@a@1&@˒:@1&@g@1&@l>B@1&@ush@dZ@S@dZ@a@dZ@ߤA@dZ@~'@dZ@v_د@dZ@`A7@7>6z@7eں@3hr@3]ce@36-@3qiC@2:S@2|Q@2:S@2z)y@2:S@2|!-x?us\?P񰦍?br !?~ -]z?HM?}}?1j?K26?(?vEB?>΀m?^U?ʳ_?5?ʭ#г_?O.ce??OONS@@@@@,@,??????R6ksT5?u.?JH<@i:@ -?n٤;?f(d?Z\?Q @c&Ѓ@@9V@9(@9V@9`[8@9V@9˒:*@9V@9V@9V@9e+@9V@9E@61'@6"M@61'@6@61'@7@61'@7 -o@61'@6[/V@61'@6U=@8 ]ce@8\(@3@3i k~@3 -V@2ƔFs@2 k@1а{@2 k@1Ͼvȴ:@2 k@1o?qv?ǩ2?(b?o]އ&??pt#??ҸBz3? W~?%i|?ѹ[0?<ՖEI?I2}?P@?!?; Ր?0eʪv??%d?aʕTI@@@@@ @*??????zc ?0?Y1/~|?7D@9 h@6X-u?s$etg?L ?ȋǧ"7@*o \#j@hh -@@dZ@00@dZ@@dZ@N!/@dZ@o5@dZ@@dZ@b@Kvȴ9@K3$@Kvȴ9@KD@Kvȴ9@K@Kvȴ9@K\yL@Kvȴ9@K$P@Kvȴ9@Kg^@8!.@8 @4|hr@4$wMp@2Vu@2p([@2!.I@2o@2!.I@2Չqm@2!.I@2Uc?2?3?YsN?V-TL?=?{?J\m?%?0{rw?m?$,3?]?._?- ?bs?4YQ?&N?mt -@@@"@&@3@*??????1`?>&8p?Kx~ҁ?Eeʓ@@K?`5Erx?e3]]?e{N?Zj64@p*܀@@ I^5.@ I^5.@ I^5.@ I^5.@ I^5.@ I^5.@nP.@nP.@nP.@nP.@nP.@nP.@6-v.>@2^5?|.Mm@1n".Qn@0‚@5.NC,@0‚@5.NC,@0‚@5.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @p -=@VE@p -=@L/|@p -=@8*0@p -=@S&@p -=@l@p -=@lcA@G{@F@G{@3@G{@5fA@G{@\(@G{@ ě@G{@+@8,<@8u!@55?|@5\(@4Ƨ@4c @4Y~($ @42<64@4Y~($ @4Jc @4Y~($ @4MVl"?K{O?'5?np?]\?|QS?6|Ob?ϱQm?%!{A?Z42?`ؤ?M#?¤n,i?NN7?ɚ?u?'D[?xfr?io+p@@@@@*@"???????thiD+?vh}?zGW@ae$@ ? ?h6E-y?t;@B#@l۠@@3E@3E@3E@4,<@3E@43@3E@4Fs@3E@3Mi@3E@3Z@Qhr!@Qhr!@Qhr!@PD@Qhr!@P|@Qhr!@Q_@Qhr!@Q4K@Qhr!@PD@05S&@05S&@*V@*V@*:1'@*9Y}@(@(vȴ:@(@([W>@(@(˒:)?^Q5P??&??eU!?/`?ˡK?bM_x? g?ܿ?6)}?A B{?PS2K?b@?~('?q6tN7?͓E'?O|q?Ѐ>(@@@@@,@*??????:s"?ї;?x@3튰@QY?$Hj?$ࡾ>?D/-ђ?C(ap@s_p@@xG+ J@xH1&y@xG+ J@xI @xG+ J@x)l@xG+ J@xHK]d@xG+ J@x7@xG+ J@x=+k@2 Ĝ@2-V@2 Ĝ@1N;@2 Ĝ@0$u@2 Ĝ@>m\@2 Ĝ@iy@2 Ĝ@dq@6,<@68YJ@3S@30 (@2"@2!-w2@2YJ@2_o@2YJ@28Z@2YJ@2eO?Ol?/)s?ƐW?ghT?=U?`~?| ?u߿?36G?%hF?XO?lN?q6tN6?ɅoiE?W+ ?WA:?Xk?Xk@@@@@,@(??????a-?M+o?W^ũ?eqT@xEW26d@=0?sI1Up?5?Fa?ȿ@alh@@D@Ds@D@Dc@D@D Vc@D@Dʘ4@D@D#'@D@D|jt@\)@@\)@@\)@L @\)@΁5@\)@5g@\)@HH@7V,<@7Yt@2+ I@2"P @1~"@1ڊ@1!.I@1@O%@1!.I@14&@1!.I@1n⻠?eXW?<?* rދ?w+?2U?ЈVi?ԧx?8~#?֋?`]Y-?03I?L?_wwo?0,i?p>?A?sCa?H@@"@$@(@0@,??????QBl0X?Cd]?0uz|@Diߍ1@?d=?PU;?Ҭ~?! -Ve@iyh @@NW -=p@N^"@NW -=p@Mv@NW -=p@Mu@NW -=p@NHeU0@NW -=p@NZb@NW -=p@N{$#@E@1\L]@E@r+@E@y -!@E@Ȕ?ߦ?kM@4 hr@4U@3V@3\>@2fYJ@2@2fYJ@2oiDh@2fYJ.NC,@8J? \?Dڰ*?>5c?i -@8@8J?ǛȦBS?ŀ&՗?S?@@8@8p?>UP?Uq(?yD ?MكN@8 @@@@,????@.S@."@.S@.b@.S@.vȳ@.S@.xl"h@.S@. -=p@.S@.@[$/@[G{@[$/@[{v@[$/@[~Ov_@[$/@[~6z@[$/@[o4֡c@[$/@[rs@6 ]ce@6 ~($ x@1+ @11@1A7K@1 Q@/@/ ě@/@/˅Q@/@/̲?|O?m0?JC?Uyu#?X?-! )m?|O?I`ӛ?mK??hY?V.H?z"2(?sq#?T?Gϵ'?fW?ܑ @@@@@,@*??????Wgh+?7:;H?O ?@.:ad@[{k?WTfUI?na%\g?742?g^@e(V@@]/@XJ@]/@XN@]/@W\r.@]/@Wi@]/@S -@]/@T@$/@vp@$/@P@$/@>0X@$/@;R&@$/@VX@$/@B@7䎊@7nii@2pěT@2hѪG@2tj~@1`,@1Tm8@1H!@1Tm8@1I@1Tm8@1HہL?}x?2uHA?3')ք?C I?Sw?!m -K?CQl?;l?b?ﻰWs?r?rn?i?jL?uE@@(@(@(@8@:??????MK@vY?4R:Kp?_M@Vֹ@_ ?S|*?~fC?_?~?S,2)@e0@@)x@)^5@@)x@2nP@)x@'lC@)x@&&@)x@%Q@)x@& (@x@-@x@|@x@9Xb@x@@x@bM@x@zxk@7@@7Ov`@3S@3Ϫ͞@2W-@2W3@2~($ @2N;@2~($ @26z@2~($ @2#?ٛP? )}o?RsW?6W=t?X?*?% ?-',?ԕ]I?DH?NM8/?ey?A\#?p-t?+QK?c^)?%d?8ϣ@@@@@$@&??????E_?SÌ?;E2?P}˅x@&-&@A:?Uc~™.?p"]S?B|?@mI@@t9Xb@xQ@t9Xb@xPH@t9Xb@rnP@t9Xb@sg@t9Xb@}c@@t9Xb@t,<@]@] ě@]@]я@]@]O;d@]@] '@]@]@]@]@8쿱[X@8?@3^5?}@3e@3t@3@N@2V!.I@2JڹY@2V!.I@2Iѷ@2V!.I@2F_ح?ꯨT?Čۨ1A? -tI?(D?|(?=)Jn??o ?D?9 ?O??B7?]FV?K|?7N?^':?@@@@@&@(???????(褠[\s?[H\?n>@wzp@]о?vi}@:?/'`?O\?/8@i @@9ěT@9Q@9ěT@9o@9ěT@9 ԕ@9ěT@9@9ěT@9œwk@9ěT@9M@1'@/@1'@"`@1'@}H@1'@v@1'@ (@1'@p;@5g l@5GE85@2^5?}@2lC@0tj@0?@0:S@04m9@0:S@0GE85@0:S@0E?}ѿ,?*|3N? ?W0 ?yq?Id6z@7 -V@2I^5?.Mm@217Kƨ.Qn@1ce.NC,@1ce.NC,@1ce.NC,?)T@8#@8:@8 >+@8I@8?qv@8@8i@8@8S@8?z@8 *@8p@8@8 @8 @?@U^5?}@U5o@U^5?}@U\Aǎ@U^5?}@UY@U^5?}@U@U^5?}@U[|@U^5?}@U@EH9X@Ez@f^m@@w^5?|@w^vȴ9@w^5?|@w^iB@w^5?|@w^5?|@w^5?|@w^m\@w^5?|@w]<64@w^5?|@w^Ov_@t@t@t@ xF@t@āoi@t@ěT@t@g8~@t@t@1쿱[X@11@. -~"@. -g @-E@-+jg@,a-w1@,a-w1@,a-w1@,aohی@,a-w1@,a?^Dw'?1?&??q@v?E{?$?bM_x?&uE@?['?Kd]?2&h?X78?b@?u?|׿pZ?hB^?pk Y?b/bJ@@@@@,@*??????3=9o+ﰈL?:7xH?R;s@w^0)@dy?I{9? bON?Y1 ?"UP@s -~i@@o-@f@o-@Ci@o-@_<@o-@]Dy@o-@T~j.@o-@@JQ@J\PeȦ@JQ@J8=@JQ@JGD8@JQ@Jgx.'@JQ@J@V@JQ@JXͻ-6@7zqiC@7dN@3|hr@3Nn@2Ft@28@1_o @1`XȎ@1_o @1h%@1_o @1޴G?Ҟ8A?@ E? KM?Ӿ?ݠ@?H_I($ x@SKƧ@Q״3@SKƧ@S`u"@SKƧ@Sݘ@bM@@bM@4֡b@bM@âw@bM@n.@bM@#x@bM@~$@8,<@8V@4!hr @4%@3`A7L@4s@2&@3C@2&@2Ʌoj@2&@2ߤ?E@?jK?Yo?ߤE?;p?"Px??V1,? G?{7?' ?q??j`cq?ek+?42?6m?Us@@@@@$@(??????kszG?ǃ Q?dLG4a#@Rȏ9M@s?в3?񓅣@q9u(K?)l0@iz@@M@P -<@M.@M.@M.@M.@M.@~vȴ9@|ht@~vȴ9.@~vȴ9.@~vȴ9.@~vȴ9.@~vȴ9.@704m8@7.҈p;@4 I^.Mm@4PA7K.Qn@4O M.NC,@4O M.NC,@4O M.NC,?}@8#@8:@8 >+@8I@8?Br@8@8i@8@8S@8?Fp'@8 *@8p@8@8 @8 @?@w&ffff.@w&ffff.@w&ffff.@w&ffff.@w&ffff.@w&ffff.@1&x.@1&x.@1&x.@1&x.@1&x.@1&x.@8,<.>@5+ J.Mm@4Vu.Qn@46z.NC,@46z.NC,@46z.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @$@$@$@v[O@$@$*V@$@Tx@$@-@$@+, -@Fr @Fr @Fr @F攀M@Fr @F}@Fr @F>|@Fr @F-<@Fr @Fk@1|Q@1y @,-@,K@+ΗO;@+^b@+PH@+W@+PH@+`."R@+PH@+8T?ޖL I?Ԯm#?!,1 ?If4)? ǫO?Կ<?r-?Tշ?rh?ri?w?g!_'?M? ?ď?F"@@*@(@*@9@5??????E?2* ?9f/5?,(x&@2@F:Զ?H$N?:ڝBl?u#4?o?/8H@sm@@nzH@i^5?@nzH@kR@nzH@l"h @nzH@kC,@nzH@m:@nzH@jF@^Q@a$/@^Q@[5W@^Q@]ڹ@^Q@^5?|@^Q@^($ x@^Q@]ce@7p4m8@7nH@2r Ĝ@2#w@2PA7K@2R @10U2a|@1'/@10U2a|@1͞&@10U2a|@1ݘ?%?4$?ھ?iP?\7?)]\?}?D.x?8G?ݤ`h?7=^9?`@0k?}??,DP?T0?9XNu?&I?&I@@@@@&@(???????5 H=S?=? O @kU@^Vp^?T, ?@5I? -[T?H@m[@@+ @"`B@+ .@+ .@+ .@+ .@+ .@)o@)\3@)o.@)o.@)o.@)o.@)o.@7qiC@7ה8@3+.Mm@3tj~.Qn@2z,<.NC,@2z,<.NC,@2z,<.NC,?|b@@8#@8:@8 >+@8I@8?uGS:@8@8i@8@8S@8?,NN @8 *@8p@8@8 @8 @?@PN+@P_vȴ@PN+@PP ě@PN+@P;qu#@PN+@PY|@PN+@P]@PN+.@NO@N@NO@N?@NO@NQ@NO@NbM@NO@N?|@NO.@9Y*0U2b@9mVl!@5ahr @5ZD@4tj~@4Dg8~@3YJ@3l!.@3YJ@3]cf@3YJ.NC,?ꯨT?\?aBӌ?XvM?֩d@8?S?U(?Ê$?GuS?%"5@8?Vr?TWn?GLl?<05?ȩ@8 @@@@@&?????@@ I^5@@ ԕ@@ @@ C@@ U>@@ qu@!p -@!0@!p -@!G@!p -@!l!@!p -@!'RTa@!p -@!쿱[@!p -@!"`@7>6z@7ěT@2+ J@2@4@2'KƧ@2$Fs@1O M@1Vl"@1O M@1b@1O M@1zG?3a=?m0?פ?,OKu?+?OPl[?}?#maЀ?h_N%?.}$?J>?998?-]?e+?D(p?k3`E`-?HAY?I$@@@@@,@(??????? )@?Ch?(bi?JZl@ 3@!Ã?E֢^B?jY;?k?qW@jE@@w I^@w$/@w I^@vY͔@w I^@w @w I^@wLP@w I^@vW!@w I^@w;@V@;dY@V@{F@V@f_>b@V@$d@V@P,@V@WI@5v@5??X@2S@25e*N@2U`A7L@2*/@1Ǡ k@1#:`@1Ǡ k@1kf@1Ǡ k@1$q?}@TΥ?Ƈs3?]> >?6z@4&I@3° ě@0ěT@2-@0C\@2@/^($ x@2@/#(;@2@/\(?Z?j`cq? 3 *??~a?r#? % -?Z?-NI`(?*޺j?=Ei?ܜ?ORh?A?Cx}x%?(14z?W?2?]2@@@@@1@??????9?rE?yAXؕ?tme@-@ ?DB?zc_[5?҈m;?F/@sR@@\(.@\(@t xG@\(@ě@\(@@\(@F]@\(.@H+R.@H+R@H jg@H+R@H`A@H+R@H#{J#:@H+R@Gh ԕ@H+R.@8g l.>@5+@5zxl"h@5`A7@5{@5!:S@4ݿH˒@5!:S@4ȴ9Xc@5!:S.NC,@8J?VӋ?K+HN?ڡ?Н?@8@8J?C?•,X1?GLD3?_@8@8p??ܸIU,?p)Տ?[}?@8 @@@@(????@V.@V.@V.@V.@V.@V.@U-V.@U-V.@U-V.@U-V.@U-V.@U-V.@7DO M.>@3hr.Mm@3Ctj~.Qn@2,<.NC,@2,<.NC,@2,<.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @`B@\(@`B@T2@`B@KP@`B@@`B@@`B@<@^@^v!@^@^YR1}@^@^-#@^@_{K|@^@^V@^@_@8G>6z@8^6o@5E?|h@5Qj֘@47KƧ@431@4=ce@4Pa@4=ce@4Rэf@4=ce@4[?V ?(a??G>,)?? ?6]g?xSV?pCm?Ww??Oa'?ZY?)N!? -?|X.?hk?is^za@@&@*@$@8@9??????Up??ML?F'=*?:b{@ Y@_rt?e -?YQ^Y? 8@4@bT@d -P>5@@+T.@+T@/M @+T@/d/9@+T@/w@+T@/o_p6@+T@/Rs*@2-V.@2-V@@2-V@=>,@2-V@p/@2-V@p @2-V@Ì>@9N쿱[W.>@3 I^@1Z@3-V@1D=p?@2!.I@0ku@2!.I@0 W@2!.I@0˼U@8J?)kE5?7.C??vWW?e+@8J?Sl?uCcCO?@;+?cQ?"8@8p?td?'+M?v? 'S?[L @$@*@&@:@1?????@-hr!@-;~N@-hr!@-%`A6@-hr!@,/@-hr!@,qm@-hr!@,+ @-hr!@-12W@x@dZ@x@@x@N@x@G|@x@c@x@@7}:@7oK=@4^+@4 ě@3"`@3-@3^6z@3 -=q@3^6z@2~($ @3^6z@2d8?| V?b0Biŋ?/b?;Ϝ(? -Q?'i?gQ?W"?Ni?[3.?Wl4t ;? ={2?.)w?J>?6weN?s?6YkC?ʩDP2@@@@@*@*???????=??6@-do.@$$?i?C@2m>2@-Oc!@Zx;H@@|RnP@|7KƧ@|RnP@|TJ@|RnP@|T֡a@|RnP@|S @|RnP@|Q@|RnP@|Qu!@<n@6@`A@D=@`A@@`A@Х*Z@`A@ï2@7>6z@7!@1TS@1T[W>@0ttj@0t6@/QN;6@/Rr"@/QN;6@/Q~@/QN;6@/Q!?(?eqa?ۃ{?M?4sF ?KK$?wogl?@{?&Dd?26H?wh??iDby?[?;?s*զ?A&?"?I@@"@@(@1@1??????4Ըp.\?/1c?/l{q@4x?Ifx*???Iue@m!@@$/@`A@$/@\(@$/@ɺ^5@@$/@r @$/@;dZ@$/@عXbN@%|h@& x@%|h@&9X@%|h@& V@%|h@%S@%|h@%5?|@%|h@%+ @8@8ȴ9X@4#@4%`A7L@3`A7@3\N@2_o @24J@2_o @2@N@2_o @2wkQ?3a=?O9?go]?iP?#6_?6J?g;+t?? :?mK?{d?R?Q,Ě?c?{?Z $@b@%-?\{?n:x @eQN?@oqr@@$/@\?@$/@s@$/@t#@$/@Ƨ@$/.@$/.@B+@BڳQ|@B+@Bce@B+@B-@B+@Bќu@B+.@B+.@8 _o@8 k@5 I^5@5N;6@4"@4g8}@4!.I@4W@4!.I.NC,@4!.I.NC,?eM?iî7?%Lє?O#A@8I@8?)>}?U?J;.?!V@8S@8?-Iz?t ?7V/r?}2;@8 @8 @@@@????@`v@`^5?}@`v@`u@`v@`ߤ@`v@`ߣ@`v@`|@`v@`W>6@EQ@EQ@EQ@Gݗ@EQ@F$/@EQ@FYJ@EQ@F$/@EQ@GlC@2@2s@1E?|h@1Dqj@0-V@0C@/Ǔݗ,@/oi@/Ǔݗ,@/ xF@/Ǔݗ,@/84֢?^Dw'??,fC6?'$5?Z)?ʟ?bnl?`5a?NJ?Hn?&Tm?低NV? ?lo>?c?Z?]ߒ?6@@@@@*@*??????=L?<?DOƭ?2$H~ v?@`,z@F?S\?A'4??xx=lF@rf@@g-@n+@g-@'_@g-@֗0B@g-@i @g-@d71@g-@i[%@0 -=@4s%@0 -=@=@0 -=@-/n@0 -=@C*{@0 -=@ņ@0 -=@?ׂc@8-v@89Y}@4hr@4E3Op@497KƧ@34+֒@3z,<@3[QKN@3z,<@3=¤@3z,<@3IË2?R ?Y?JVX?!?L;G?腔?GP?F?\]?VkG?W-?H樑? -a?K?'*E?b(ق?ק{?SD2@@"@(@(@9@5??????]@'(?A*7?d;y[;@kDt@Ȍ?\]x5?u?QpR?޵OL@dӜp@@;lD@5?|@;lD@Hj(n@;lD@?_=@;lD@K.Q@;lD@<<@;lD@? ɶ_ ?}@TΥ?T!,?Mw @7H@7)详@4 ě@4Jّ@37Kƨ@3D=:@3iB@3<'`@3iB@3D|@3iB@3A;xv?'Z]&?8 w? -.` ?]x?ّlq?/Z?&??PY?=R?Mi?\/?'5b?wX '?R+r7?uk?e;Ƶ?1?T(U@@&@&@,@:@:??????Ws8TS2?S\1L.?>-tCX@Q@Q?p/$l?`R?fV?26"@k}5t@@-@@-@\(@-@>BZ@-@`A7@-@@-@q@4Ƨ@4I^5@4Ƨ@4iB@4Ƨ@4ߤ?@4Ƨ@4ރ%@4Ƨ@4ңS'@4Ƨ@4ѷX@6^H@6`)^@1^5?|@1@1i"`@1a @0h@0cS&@0h@0h@@0h@0hK]c?F/P5?"2?QaQR?(+Zk?% -? $4?2}?wi*?y?.pC?=.e1?äqY? ҇??o}?;B?gϵ?|)-}(@@@@@*@"??????8uK?LFj?D ?Lc w@Zib@4ѳd?6]?m ?s,Xf?5#@h{݆@@@1sh.NC,@1sh@1.H?1j?` ?E +?n@8I?= =F?M^?M\ٓ@?0W) [?j{X@8S?% mc?=!? ?JzUf?'{>@8 ?LiA@@@@@,?????@j~@Q@j~@ce@j~@@j~@ߤ@j~@QZ@j~@"L@y"@pb@y"@xl"h -@y"@w4m@y"@y#y@y"@w'@y"@vH@7e!.@7gƷ@0+@0;dZ@0`A7L@0`A7L@0Tm8@0Tj~@0Tm8@0Um]a@0Tm8@0U`B&?~?J?4$?,fC6?Rw#z?22$?G~?| V?u߿?LE?|}Յ?=Aq|?6??l?O?E 8?ܐ?g*6@@@@@.@,??????c_?JS??Όg%?3g(@l@lɵ@t%VP?_?w?S֮WG?kr?̣ 7@gRlj@@mhr@pmނY@mhr@qg@mhr@p8f@mhr@q*@mhr@w6B@mhr@x\@3vȴ9@3nd@3vȴ9@3Lo@3vȴ9@3@3vȴ9@3+o@3vȴ9@3k@3vȴ9@34J@7cg l@7iR§@2+@2~ݮ@1"@192@1kxF^@1gLs@1kxF^@1dWXnQ@1kxF^@1d_p?|0pJ?c?%`B`?@h?1?ױ4?r?Ԝ-4?\0.?*4f?vQ8?0C?'i?H?6ݞ}%?:r.;?0e?N @@*@"@,@7@6???????Wj?<;3 -?CkȠu?!kGϜ!\@sC@3u>x?c&8`+?A3-k\?^b?P=$@fܲZw@@S@1@S@Y@S@[ @S@CW@S@/@S@Zw@i"`B@i# -=r@i"`B@i&@i"`B@i/$@i"`B@i& -@i"`B@i%?*@i"`B@i#@5`D@5aR<6@0hr@0$5@0`A@0qB@/73@/ V@/73@/~@/73@/u;?Qp??Sպk?isi?RyUq?>/d?~?J?LN?b̼h?4Vr?1{f?jۻBF&?%?56#?$?t+$?p( @@ @"@@5@4??????[J?/"?TgG"?4 =@@i$?(ӭ@?UP J?Z&?ĠR@gT@@8@+p@8@ l@8@M@8@2Y@8@҈p@8@!7K@1&y@֊r@1&y@!@1&y@%F -@1&y@|Q@1&y@aG{@1&y@NV@9-v@90:"@3?|h@3n.@3Ft@3a|Q@2&@2~%@2&@2hr @2&@2W>6z?M:?SZ?~4F?D ?^&.?A:?|<~%>?!Z?On{-?;`Ε??-O?S?M'-?2W?5W? .0v?**Z@@@@@*@*??????grI?_ϒ?sM@'NO@;?w"i?_|?|/@ l@_ژ@@r .@r .@r .@r .@r .@r .@/-.@/-.@/-.@/-.@/-.@/-.@8@.>@3hr .Mm@3-.Qn@3Eu.NC,@3Eu.NC,@3Eu.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @@@@B@@&e@@Ҙ@@@ ѡ-@@=f@\(@<,t@\(@73E@\(@5҄@\(@@\(@]@\(@{h@8V,<@8?@2.5?|@1<"LR@1b-V@14q7@0Y~($ @0=OM@0Y~($ @0BxXd>@0Y~($ @0C ?Ҟ8A?2_?B?c'`?BDr?vkc??Xנ^?u+?pÇ?7kM=;?l1e? ?Q<(?]נ?I?(!My?n\V@@ @*@*@9@8??????Iƨp?D~E.NTw?J-<@۪@!f? Y?R`^?>?bMn?>`?A)N?-I`K?a?JU4?bM]f?2a?oܧ?~\?[J?@@@@@0@.??????SX?$m?0xj|?,~{@aW@???E&?:ߧ`P?xMPh?o[@s d @@֩x@֩l@֩x@֪͞@֩x@֪0 @֩x@֫ I@֩x@֨>BZ@֩x@֨Tɇ@iJ=p@iJ~#@iJ=p@iJd9@iJ=p@iJ=p@iJ=p@iK)^@iJ=p@iJڹZ@iJ=p@iJg@2>6z@2>6z@.a7Kƨ@.a7Kƨ@-1'@-C\@,ߤ@@,n.@,ߤ@@,5Xz@,ߤ@@,lC?^Q5P??&??eU5?b\?i{?bV,? ,C?A)N?3.Yl?B[@Y+@Zxl"h@Y+@W&@Y+@Wq@\(@\*Ak@\(@[u@\(@[@\(@["`@\(@[W>5@\(@\ߤ@/jL/|@/jLg@).Vt@).Vt@(&x@(&x@'#9@'Ov`@'#9@'lD@'#9@' ?^j?GA?m?XQ>?/`?O+y?bM7? g?j?3.Yl?@?J&d?k?bM]f? ?oܧ?~\?#.?h@@@@@,@*??????SzA?( X?=]QqX?$͘@XZD@[y?Lh?=;j? =?4Ӱ:@s @@7'lC.@7'lC@7#S@7'lC@7'H Zw@7'lC@7A@7'lC@7*\@7'lC@7$ -0 @V.@V@W@V@bs@V@]@V@bL@V@VK@7-v.>@2 ě@2ˀV @1tj@1G&@1䎊r@1aw@1䎊r@1}W@1䎊r@15b@8J?WDvg?%H9I@jlP,@<"'Q?W -mA?C2^? rVoL?N@mM=@@=p@O;d@=p@^ @=p@qi@=p@d8@=p@艭B@=p@@. -o@. R@. -o@.@. -o@. 7Kƨ@. -o@. -0@. -o@. -0U2a@. -o@.fA@4,<@4 @2+ I@2e+@2`A7@2 k@10@11.H@10@10IQ@10@1/H˒:?sD?_?>(lQ ?^:f?`?ʟ?1j?0n=Q?T֩E?ǧ?D6?u$6?jOI?]mZR? -?L?π9"?ĭ?_խW@@@@@,@*??????L/8B| 6l?cKs?&}vi@R@. -)y?:2*M2?Idpzt?v8p?|~V@i9+@@t}p -@t}p -@t}p -@t}@t}p -@t~$@t}p -@t~s@t}p -@t|O@t}p -@t|jcx@<$/@<$/@<$/@<$@<$/@<ں@<$/@<q@<$/@<J^|@<$/@<E@.}Vl @.}Vl @+`A@+»쪸@,4E@,5p -@*PH@*@N@*PH@*m$@*PH@*KU?^6P??YK6?I?Zj?Za?bMn?𕧌?~@?@/{?w. _ ?3'n}@s@@? ě@?!$/@? ě@?" @? ě@?"ѷ@? ě@?!af@? ě@?H@? ě@?!@;{dZ@;{dZ@;{dZ@;~@;{dZ@;u"@;{dZ@;yXbN@;{dZ@;~%@;{dZ@;z)@4T xF@4T`d@2+ I@2 k@1i"`@1k6z@16z@1U=@16z@1Mj@16z@1s?|O?ru?ě?U*?h|?C!?| ?$i %h?I??77?nK/?|׿pY?3XMV?+k?{B0?&I? -r@@@@@"@"??????$ ?`@?9renO??+r@? @;{9l?YO̴(I?_ Un?4ZW?CbQi@f0?@@[]/@[\1'@[]/@[Oi*O@[]/@[A- @[]/@[Hg1#@[]/@[Al"[@[]/@[@@E@\b@E@qz@E@B@E@ר@E@vM\@E@@4T xF@4Sv@1hr@1Ca@1Z~"@1S}!@00U2a|@0Ǥ@00U2a|@0ys P|@00U2a|@0}d} ?}@TΥ??nǾf?7Xt?&vo?腈V'?| V?æ?j :O?!?By?G县?K??`/@?gXk?dca?)?٤a@fd@@n@̋C@n@g@n@*0U2@n@u%F @n@"@n@Zc @Ghs@GA7M@Ghs@G+ J@Ghs@Gѷ@Ghs@G q@Ghs@G,@Ghs@GsP@8 D@8|hr@5{ I^@5sA [@47KƧ@4F -L0@4䎊r@41@4䎊r@4̋C@4䎊r@4BZc ?F^S?}_Z?'=DP?"?|QS?d?|O?k!?Q\?pe?g?L ֎?=Ca?*ŪZ[?\œ?rG?1 R?9^@@@@@,@$??????_pcUCBW?jXO\?X(@aς@Ga@H9X@H@H9X@>Q@8@@8{@3I^5?@3߾vȴ9@3q7Kƨ@3w/V@2^6z@2c$@2^6z@2^+@2^6z@2Z1'?ʎa]?@K/z?G)?A%?i]i?y%?A[F?@C?!b?>G]!?SY?Y@?9&?GA?+B\@dZ@S@dZ@@dZ@tS@dZ@$.@dZ@@dZ@p -@4mv@4mIQ@2?|h@2g8}@2`A@2ěT@1&@1҈p@1&@1- @1&@1 ?|O?`[?mGSq?5~pY5?[9,?.'?|O?A}?t(?#q\-v?4.?Qʾ?Ol?7}?],m=?9XNu?{2?*Q@@@@@(@ ???????@p ?E '?MfM?=]D޺@c@BZ=?l#?^k=6?#ZN? @f@@@\(@-V@\(@ -=p@\(@kP@\(@@\(@}Vl@\(@:)y@#vȴ@#$/@#vȴ@#:)z@#vȴ@#s@#vȴ@#쿲@#vȴ@#sQ@#vȴ@#ѷ@5|Q@5VϪ@15?|@1Ҷ}Vm@1PA7K@14?@0@0tj@0@0p:~@0@0kP?|O?|5z?.O?ׂa?g;+u?YLU?|O?y?]"?ޝ?z?6/?W ??H6?Za7?1 R?a]o@@@@@,@,???????7^?*>?Pp ?l=3ڳ@@#nNl?gȣ5b?u6Λ?օ66?򜿊@_Cw<%@@lC@&x@lC@橠'RT@lC@xF@lC@L^@lC@@lC@)`@7K@n,@7K@{J#:@7K@ qv@7K@H˒@7K@N@7K@A7M@7I_o@7x@2 -^5?|@2 ᰉ'@1"`@1˒:*@1 k@1$/@1 k@1@1 k@1l!.?ȉak?:L -?u*y?TnE?% -?nM?Hߝ_`?7fps???݄ ??y?)Zw?],m=??$?Cns@@@@@ @,??????`ج9?U7?(h=B?S5X#S@b`@X??~?d)?t`j?k@0@qIU@@#S@"@#S@$Z@#S@#@#S@!R<@#S@#\@#S@!G|@3S@3`A@3S@31'@3S@3m9@3S@3J@3S@37K@3S@3<64@8H@8L_@3S@3!-w1@317Kƨ@32 I^5@2YJ@2PH@2YJ@2F -L0@2YJ@2F -L0?>sN?B-?3Z?IW`g?>{~?.'?Zm?eCO?J?nca?Y:J?U3p?eS?]ivL?[?f?q' -B?C SG@@@@@*@???????Mn9WV T?LbFB?bV@"'&@3h*?_oF;?tb3?rH?Q%@r[]@@&7@&>Yۖ@&7@&9@&7@&8t@&7@&8@&7@&71@&7@&5%f@+@ P@+@;@+@S|]@+@$@+@4@+@f@8+s@8/҄7@2@ ě@2@YB-@0j~@0o@/At@/ 3W@/At@/e@/At@/-U?ڡG7@TF@dz|@TF.@TF.@ 7Kƨ@\@ 7Kƨ@*@ 7Kƨ@#%@ 7Kƨ@@ 7Kƨ.@ 7Kƨ.@6֚,<@6ԇ#@4S@3s@3-V@3c{J#9@3p@3%oi@3p.NC,@3p.NC,?}ѿ,?UG -?ѳՂM?@8I@8?us\?Sn\}?M1#?>b@8S@8?oܧ?0Uo(?)?S@8 @8 @@@@???? @Cv@C@Cv@C)kv@Cv@CG@Cv@C@@Cv@C-Q@Cv@CcI@v@v@v@@v@w@v@@v@;A@v@uT"\@5v@5XRv@1° ě@1_s@0]V@0\NhZ=@0:,<@09ڎUu@0:,<@09@0:,<@09'?| V?78?'Wc?\?n?NU?;%?}@TΥ?  A$??h?-$: ?vS?q箭?L|?_ ?z (?,H X?*?3NA@@$@*@@3@5?????? l0 ?7G#>?!uK@Cr=@r-?WЦ?AL/$?"?bs@fH@ @cS@c%@cS@f@cS@aG{@cS@b I^@cS@^"@cS@[S@%@1&z@%@@%@$/@%@x@%@~vȴ8@%@n@7,<@7sh@2@2%2@1"`@1+ @1xF^@1N;@1xF^@1S@1xF^@1jf?1j?Z.?ě?_?STS?<_?% ?? :??1'7?UBi?K#N ?tgi?§d߱?OW?8 ^?,a@k -Z)@@ -=@ڟv@ -=@ BZc@ -=@ y>B[@ -=@ S@ -=@ k҉@ -=@ s@@@@ Dg8@@?@@ŭ@@ŴD@@ſ$tT@7D@7֔Fs@5n5?|@4oiDg8@5-V@3p[6@5m8@2VϪ@5m8@2 -=p@5m8@2n.?Br?]]?Z{f?Jʮ?V?0 ?q!U?_*_'?H?,?|I -?*?a -?"M*?*\??c?5@@@@@,@*??????غ+\N<?!su-?\@ Kj1@ebd?Wd~m?F V@`v@qfyE@fH}@@z@?![$?PP]?|b@?:l?\?:G ?B{ $?_rd+?R?6?ʏF?g3#?͆? S@@&@,@,@9@:??????I K\?4d!L??12[>@;&@܀%"?TyQ?Qn?]e?D"@fZ8@@a.@a@a7K@a@b I^@a@Iԕ+@a@q@a.@V+ .@V+ @Z@V+ @}p @V+ @9Y@V+ @tj~@V+ .@9DO M.>@4S@4q @3-V@3zG@3ce@3Ƶ '@3ce@3R<6@3ce.NC,@8J?*U?S?+j?7@8@8J?39?ZH|:? ?K+Gq)@8@8p?7'nK?>{~?8zt?ԤA]@8 @@@@????@7KƧ@6u@7KƧ@64@7KƧ@5!S@7KƧ@8U@7KƧ@7X@7KƧ@12X@w@V@w@O L@w@iDg8@w@}H@w@{@w@KƧ@82@8hۋ@2ěT@2L/{@2t@2}/w@1_o @1`A@1_o @1wkQ@1_o @1s?F/P5?nqV?~"? 4? -0ggk? ا ?Zm?ā? yz?hJ?%3?C.NT?JTACG?Az? - l]?J]j?=P|?b@@@@@$@(??????5%<~?C N_.?i4@5,|(@?j{ά?{r_T?ݏ?~g<@pub[@@7T@7T@7T@7\@7T@7@7T@7$/@7T@7U@7T@77K@|hs@|G@|hs@|"@|hs@|@|hs@|ht@|hs@|<64@|hs@|6z@6]ce@6H˒@3+@31@26-@28K]c@2@5@2?@2@5@2wkQ@2@5@2{n?Ol?/)s?K]4?j6_?GBm?ʟ? ?uie?ܿ?ט??C ;?`w???"a??=P|?)@Jq@@@@@@ ??????34m?Gn?=rLv?5@7VT@|?]VH}?3a-A?ZO}?oΑޘ@h+!@@g -=p@g^5?}@g -=p@gY@g -=p@gܹ#@g -=p@gC@g -=p@g?|@g -=p@g+j@%S@ ě@%S@1 @%S@-qu@%S@,>B@%S@-jO@%S@*#9@6 xF@6"@2@2(@17Kƨ@1j~#@1B@5@1@ -? ?xu)?X/?ӑ@t)o@@4ow@4qI4 s@4ow@4[o@4ow@439H~@4ow@4`yx@4ow@4u}$@4ow@4wǠc@۸Q@۱I@۸Q@)G&@۸Q@@۸Q@~@۸Q@ۓ<{'@۸Q@۩Mh@8쿱[W@8ź@3ԛS@3fo @36-@3]@2Y~($ @2l5~@2Y~($ @2m[au@2Y~($ @2m?x.?0[?]?b}??.?&?[P~?!Nd?VwU?ʣ7?.׮3?iW?;z?ab?]M-?պ?gy?X3@@$@&@*@9@6???????mvg#6?rל-;N?r1`@4l/u@۰Ws?C͋/?&?M}_@WbF@n9@@8Q@8bM@8Q@8yV@8Q@8hFW@8Q@9LI@8Q@74@8Q@7e@wVu@wUϪ͟@wVu@wU) @wVu@wTfrH@wVu@wV sy@wVu@wU@TZ@wVu@wU" @4_o@4ɅoiD@0)+ @0) }@/O;dZ@/u@.(ۋq @.(PA@.(ۋq @.(I@.(ۋq @.(A h?|b@?xet?9Q&?g˄ ?g?u?|B &?'3 -k?x?4km?BNl?IXuj?pa?Ճ?u"7? -q?%9G?3eBp@@,@,@(@5@3??????7q?1S0% -?9\e|@88:@wUL?QAg%e\?5m;?@5J?wV@g=ނ@@/dZ@/G@/dZ@/"@/dZ@/;dZ@/dZ@/b@/dZ@/XbM@/dZ@/S@tև+ @tև+ @tև+ @tY|@tև+ @trGE9@tև+ @t$tS@tև+ @t!@tև+ @t\)@4įO M@4JL@2^5?|@2lD@26-@26@1̿[W?@1VϪ@1̿[W?@1:@1̿[W?@1̞쿱\?}ѿ,?u:|?RsW?,OKu?ҧ?X?| ?r5MS?CXs?aYZq?u$6??? uf?bv{3dZ?gϵ?wͶ@@@@@,@*??????? s`Z?>zZ?CN*@/X@t].+?]ob?>Z?ŰT&R?S@fz4.@@w.@w@trf@w@MHh@w@7@w@lU/@w@@%;@FH9X.@FH9X@FIE;s@FH9X@FJ̊@FH9X@FH@FH9X@FIvG@FH9X@FIQ@3~($.>@/V@/+~%@/Ix@/I"k@-#Z@-#rdR@-#Z@-#n.3@-#Z@-#@8J?qC ?(( D?p?éw?0N@8J?Cl?BVx?--?.$?MmUѽ@8p?$-a5[?g?V*?D#?@,@(@ @;@:?????@y"@|1'@y"@&@y"@f?@y"@m\@y"@{dZ@y"@t!-x@)@)O;@)@)`A6@)@),zx@)@) -L0@)@)"@)@)G@9T xF@9i>BZ@4kS@4t?@3-@3|@3u@3 "`@3u@3g@3u@3~($ ?/q*q:?UJ?u[>u@rjo@)B?{~vCP?J,_??vL? >Fwv@q*Sn@@n\(@n\j~@n\(@n\wkQ@n\(@n\1'@n\(@n\@n\(@n[qu"@n\(@n\C,z@lC@l@lC@mM<@lC@nzI@lC@l@lC@mV@lC@lcA@2@@2@0c@0dtj@0$j~@0%m\@.@.[6@.@.A7K@.@.[6?^Dw'?h?WD@?̒?Dj??bV,?#maЀ?qN?0N:s?֧QD?SV.?g)? -?]?=rE=?SP?@@@@@*@&??????'e*Zp?3dYa3?#ݼh@n\" ޒ@lLD?B -SҦ?2lɎ?Q4#?_a9$;@su@@-+ @-+ @-+ @-+ @-+ @-A@-+ @-C@-+ @-R<6@-+ @-!S@8G{@87K@8G{@8n.@8G{@8s@8G{@8ě@8G{@8&J@8G{@8e+@3:qiC@3:W&@.Vt@.}Vl@.&x@.$tT@--C\@-.!R=@--C\@-._o @--C\@--C\?| ?`?7[䭝?̒??װ*w?|O?j%Ra?'Q?-I`K?2&h?eDQQ?q6tN6?u?u@>N ?~\?a+?l&@@@@@*@,??????߻?~0@?'ќ?!O_.@-` @8ߖ?<?Aφ?$!9?#|д@f@@$ O;d.@$ O;d.@$ O;d.@$ O;d.@$ O;d.@$ O;d.@m49Xb.@m49Xb.@m49Xb.@m49Xb.@m49Xb.@m49Xb.@8DO M.>@3ěT.Mm@3b-V.Qn@2J0U2a|.NC,@2J0U2a|.NC,@2J0U2a|.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @.?|.@.?|@.\(@.?|@.iDg8@.?|@.@.?|.@.?|.@0 ě.@0 ě@dq@0 ě@G)_@0 ě@_F@0 ě.@0 ě.@1D.>@0.5?|@0Q@/Z1@/-V@/ -#9@.g l@/ -#9.NC,@/ -#9.NC,@8 -Ny?3"??Hyq@8I@8@82r?q?)(?Bݎ4@8S@8@8L?i--?<{?P )k@8 @8 @@@???@`t@`Z@`t@`&@`t@`A \@`t@`*@`t@`S@`t@`e+@)l@)l@)l@*Ov@)l@)Q@)l@,Vϫ@)l@)7Kƨ@)l@-U@3uS&@3u`A7L@1^+@1_iDg8@1i"`@1i^5?}@0@0Z@0@03@0@0ѷ?|O?3i?TS?<ݝ? g?P@*W?JԹ*j?Zxȿh?+dRַ?oQŋ@f ?S@@o-@nzH@o-@ql@o-@hp:@o-@h@o-@eoiD@o-@fIR@E@G-@E@B @E@<@E@=E@E@Ce@E@C9@6(YJ@6!TɅo@2+@2}H@2Vu@2rGE9@2 k@2 0 )@2 k@2S&@2 k@2KƧ?| ?PƧ$?3Z?,OKu??E?F/P5?l?O?P?v> ?>[Fh?#IӨ&?&Z#?*0x)??a#? P@@@@@,@*??????]M$X*?,@Wa?Pak;@jH.g@DNQd?K*( ?oO?2K?@fpȟ@f -As@ @2-V.@2-V@*~#@2-V@8PH@2-V@'K]@2-V@(@2-V@,1&@zG.@zG@@zG@Mj@zG@ ԕ@zG@q@zG@ -qi@97@.>@5 ě@43@4A7K@3qu"@3 k@3t9XbN@3 k@3s -=p@3 k@3w+@8J??q-*7?D?`FC:?VAg@8J?XSra1?To?Җhn?7c/?>/@8p?f1?ji?!??{%@@@@*@(?????!@+ @l@+ @@+ @@+ @*1@+ @D@+ @$@CzG@Cq^@CzG@C@CzG@CO:@CzG@C)l@CzG@C:)y@CzG@C$e@8쿱[W@8&-r@4#@4!l@3tj@3*0@2‚@5@2u@2‚@5@21@2‚@5@2:~?zM ?D?ub5?{y6?EE?*j?__`?_lWF_?Z;?%ja?Ng x? Ӻ^?Vʴ}?qv?GB?VED?܂N.?"#@@@@@,@???????s8-?a^E?hmg?dWa@l@C%??l_w5?9&T`?fxU@o d@"@daG{@db I^@daG{@dh9X@daG{@djg@daG{@dTF@daG{@dU!S@daG{@dZ>@uF@uԼj~@uF@u -=p@uF@uǓݗ@uF@u@uF@u -=r@uF@uR<@8YJ@8D@3hr @4nP@3t@3쿱[W@2‚@5@2A [@2‚@5@2K]@2‚@5@2Ƨ.?o 6}?:}T?go]?Hyq??S:Ъ;5?:-%??luOv_@.zH@E`A8@.zH@2 ě@.zH@(p:@.zH@<1'@.zH@0 ě@.zH@+xF@8v@8iB@5I^5?@5 ě@4j~#@4,<@4 [W?@3sh@4 [W?@44m9@4 [W?@4T`d?E@?K'B?mr?%?Ͻt/9? C@L(?F/P5?6S{?kCnL?#Vz?͋>?k?Z? h?7}?^FC}?Q?]?4\ɵ@@@@@*@&???????xۂte;?Y9id?>@.%t@8T?wl?bc-?!?8@jL֖B@$@#^5?.@#^5?.@#^5?.@#^5?.@#^5?.@#^5?@$Fs@KC.@KC.@KC.@KC.@KC.@KC@f@9V,<.>@4S.Mm@4~".Qn@3YJ.NC,@3YJ.NC,@3YJ@4B@8J@8#@8:@8 >+@8I?]@8J@8@8i@8@8S?b*@8p@8 *@8p@8@8 ?HucL@&?%@}E.@}E.@}E.@}E.@}E.@}E.@.@.@.@.@.@.@8,<.>@3.Mm@2`A7L.Qn@26z.NC,@26z.NC,@26z.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 &@z^5?}@lI^5@z^5?}@[@z^5?}@j~@z^5?}@ٌL_@z^5?}@مQ@z^5?}@Fs@@\j~@@š@@W@@@@Q@@lVϫ@9hYJ@9Y#w@4^5?|@4ݗ+k@4t@4 P{@3u@3h ԕ@3u@3@3u@35\(?p"7?q?3}C?ʺd9.?*5>?D1 `?k|jʨ?f?$G"?ln<9?Iph?"v?o7\?JfA?wG?Gs#4I?*fd?C3`ow@@@@@(@"??????E?M n@?fOm?&@D@xGG:@E?0U?\7Y@$à@Î@m[@'@6z@8~%@5 ě.Mm@4'KƧ.Qn@3c.NC,@3c.NC,@3c.NC,?]@8#@8:@8 >+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??)@1&x@1hr"@1&x@1@1&x@2nP@1&x@12Y@1&x@0@1&x@0 )@T@/@T@Q@T@84@T@84@T@+a@T@o@2쿱[X@21@-\j~"@-\wkP@-]E@-^Ov_خ@+̲@+̲@+̲@+̿[W?@+̲@+̋C?^Dw'?°R;?=?Kh?G?6r In?}?bV,? -?NJ?6)}?A B{?_~t?cPQ?.+?y8$?XLL?a+?@@@@@,@,???????V?)j>?"@1@%N?8߯P? ?n_H?|8@s32v@*@Rt@R_@Rt.@Rt.@Rt.@Rt.@Rt.@hr@l@hr.@hr.@hr.@hr.@hr.@8V,<@8[AjZ C@40ěT.Mm@37Kƨ.Qn@2s&.NC,@2s&.NC,@2s&.NC,?7娠@8#@8:@8 >+@8I@8?!@8@8i@8@8S@8?i@8 *@8p@8@8 @8 @?+@u@ -@u.@u.@u.@u.@u.@r @[C@r .@r .@r .@r .@r .@6:@6I0<@3+ I.Mm@2KƧ.Qn@2 -0U2a|.NC,@2 -0U2a|.NC,@2 -0U2a|.NC,?| V@8#@8:@8 >+@8I@8?eXW@8@8i@8@8S@8?^$@8 *@8p@8@8 @8 @?,@LO;d@L`A@LO;d@L -=p@LO;d@Lr @LO;d@M O;d@LO;d@Ls@LO;d@L-V@u C@u`A@u C@u%@u C@u ^5?@u C@u;dZ@u C@tp -@u C@uhs@8p4m8@8t,<@5!hr @5=,<@4K"`B@4aN;5@4p@4?@4p@4|@4p@4o?{QB?}d?FB:?_B?M,?*j?Ol?dx/?Rs??tPYz?L "? ' %?fb?*wjs?,|?xb?+C@???@@???????.a@?a/9?Bz^ʉ?U0f@L2@ug5?Z?Va?b?YS?\U@rz26\@-@/\)@/v@/\)@/4@/\)@/Ov`@/\)@/+ @/\)@/Ʌo@/\)@/@fXtj@fX@fXtj@fX74@fXtj@fW3@fXtj@fY+@fXtj@fXD@fXtj@fWkP@0>6z@0>6z@0 I^5@0s@.dZ@.dZ@.@.vȴ:@.@.حV@.@.?^Dw'?3i?7[䭝?lDžN9?Dj?{+@8I@8?F @8@8i@8@8S@8?=@8 *@8p@8@8 @8 @?0@?x@?x@?x@?W@?x@?L/@?x@?C,@?x@?Q@?x@?ᰉ@P ě@PbM@P ě@PU2a|@P ě@Pv_خ@P ě@P@P ě@P'R@P ě@P@3T xF@3S\N@0 ě@/>BZ@.F@.&@.At@.t@.At@. M;@.At@.1?}ѿ,?jN ?O??!ˠ*(?B ?fW@@@@@$@,??????? /(@  ?, m?;@@?r@P!!?Kߵsq?9am,p?]? -@g@0@1@Jz^5?}@JwKƧ@Jz^5?}@JxV@Jz^5?}@Jw@Jz^5?}@J|wkQ@Jz^5?}@J{lD@Jz^5?}@J|1'@/@$/@/@Z @/@Q@/@fffg@/@@/@>BZ@7qiC@7 @3 I^5@3|@3Ctj~@3D?@2Q@2}H@2Q@2Ov_خ@2Q@2ڹZ?qv?m0?RsW?ҕV{?RXFf??=?F/P5?5CQ?Jj?L?n ?Us?+QK?`F?~/O?WhQ?t?`i=@@@@@*@&???????N2_8?@ݸ?;V[lE?'>w@J{E3@ `?VhCņ?Kz?q7V?=@l#s@2@*߾vȴ@*߾vȴ@*߾vȴ@*IQ@*߾vȴ@*j~@*߾vȴ@* [@*߾vȴ@*Z@*߾vȴ@*@ސbM@ސ ě@ސbM@ތ"h @ސbM@މ7Kƨ@ސbM@|(@ސbM@ޑhr!@ސbM@ގ}Vl@5S&@5F -L0@3ahr @3_;dZ@2Ƨ@2e+a@2YJ@2 k@2YJ@2U>@2YJ@2zxl"?| ?Čۨ1A?oq u?Hyq?R?0 -?F/P5?j%Ra?v@b? ?=M?J,?m!?3a=?,1'?k,??w w@@@@@*@(???????C>,`^ؚ$?/z?h1@*(@ފx*?M<(?wn?Fq|s@ -kY)@eFV@3@j~@$@j~@j@j~@.@j~@O9n)@j~@lgb@j~@S@w@V@w@՞@w@"P@w@fq@w@hXc@w@C@4@4@2; I^@23͞@1-@1a@1=ce@19؇@1=ce@14w5@1=ce@15N?|b@?@9?[6.7?Ѻn?<$a?\ۅv?}@TΥ?y?)3^?C\7hv?3|Oi?C⟗?SS?mO5?Ԗo=?%A?lh8??@@@&@(@,@9@7???????Q?spl?-h^]K[?F;@P@nk?L$q\}?f6?@?ա@ereX@4@vE@v+ @vE@q-@vE@O@vE@pO*@vE@ F@vE@MPA@E@ȴ9X@E@u @E@=l@E@Q(@E@i4@E@ؑk@3H@3UhƓ@0sS@0eR@0."@0pF@0&YJ@/̵d@0&YJ@/JS@0&YJ@/yUY?}#?Ğ?ґ?:7C1?W?.|[?|b@?#wg?_m24?}5,?v.*?Eim?n3?KU!?eW^_?u<^?a,=?"ۀA@@$@*@$@9@:??????f^ـ?oTr?}@c(E;@:?v?r.I-?oF?x%A@ӹ0 -@Z(P@5@F@G,@F@@d@F@Ar@F@G&@F@IB@F@Jo@ffff@㕁%@ffff@)_@ffff@A7M@ffff@F]e@ffff@S&@ffff@L/|@6YJ@6D@2ٺ^5?}@2+jf@2,j~#@2)@1&@1'/W@1&@1g l@1&@1 ě?}? q?,Z?\2? -`?IdGc# @Ii@ixm$?C>?^ZP?g+?ģf!@gN;@7@{`A7.@{`A7@{e@{`A7@{+j@{`A7@{ݗ@{`A7@{Q@{`A7.@$/.@$/@3@$/@@$/@)^@$/@|R@$/.@3 xF.>@08r Ĝ@0MH˒@/ӶE@/vȴ@.73@. '0@.73@.oiDi@.73.NC,@8J?R?uN?0K?=U@8@8J? QnS#?U"?sZ-?1H9v@8@8p?ָ.?ji?]O8?&n_@8 @@@@&????8@8Q.@8Q.@8Q.@8Q.@8Q.@8Q.@sE.@sE.@sE.@sE.@sE.@sE.@7~($.>@2!hr .Mm@1"`B.Qn@0u.NC,@0u.NC,@0u.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 9@j~#@h1&y@j~#@oA@j~#@ka@j~#@k~(@j~#@d?@j~#@fIQ@݀@݁7K@݀@~5?|@݀@݁n.@݀@.H@݀@݄oi@݀@݃,zy@6YJ@64֡b@3; I^@3;s@2`A7@2ˆp:@2?䎊r@2C,zxl@2?䎊r@2>ߤ?@2?䎊r@2?o?F/P5?L?&t?CF ? ?5ŋ?}ѿ,?'`?Kd+?.}$?=?kj?v'X?oM?Z?0?1?a@@@@@*@*??????4R?2p?Iv%aq?> ݤ@gX@݁?hS,P?^O ?>tk ?C@fK@:@;lD@;dZ@;lD@hr @;lD@@ qw@;lD@Xtj@;lD@?o@;lD@ 8@S@-@S@ڟv@S@E@S@B@S@@S@̿[W@8:@8SMj@4hr@4hۋq@3"`@3{J#:@3!.I@3@- @3!.I@3Q-w1@3!.I@3Mj?5}'?>I ?3}C?(&V? K?OY?X?''5?9|/?c6; ?eB?@ؤ? /x/?-8?fr[?A ?wY?&侱4@@@@@,@&??????y5[6?k!_?2r?y|J'@9,d@%,?UfX?Ȏq?EjF(v?>0@j趴@;@cS@cS@cS@eo@cS@`- @cS@c{J#:@cS@dt@cS@ce@dZ@dT@dZ@ZS@dZ@]!.I@dZ@g@dZ@eݘ@dZ@ezxl"@4įO M@4+a@0ٺ^5?|@0E84@0Ƨ@0\)@0@4@0d8@0@4@0&IR@0@4@0.H?| ?"2? ??V^?f]G?|O?[45?y?3F0?JL\?m/wE@cc|@eF.p?/w؛?L՛Do?i3y? Uu^@f{ʺ@<@Aٙ@Aٙ@Aٙ@Aۘ@Aٙ@AG@Aٙ@A״3@Aٙ@A"@Aٙ@AحV@/"M@/ti@/"M@/%o@/"M@/(1&y@/"M@/$Z @/"M@/#{J#:@/"M@/!@7uS&@7s ҈@3+@3.H@3U`A7L@3Vt@2J0U2a|@2JC\@2J0U2a|@2L(\@2J0U2a|@2Ka@?sD?oNQ?^*G?btx=?p[?XE%:?)T?7fU?t-E?FT \*?'#g?kj?~~?@C@@C@!-@C@oi@C@cA @C@H@C@O@ȴ9X@ȴ9X@ȴ9X@1&@ȴ9X@@ȴ9X@J@ȴ9X@4@ȴ9X@S%@3|Q@3ae@/"`@/U2a|@-nO@-ව4m@.@- (@.@.ݗ@.@.?|O?b[?Mq ?xx?h5+P? Ck?| ?M7F?Fy -?s҆L?,rg?-[w?8*?7}?aI*?.SM?_խW?*Z}@@@@@,@,????????[0Qy4?1,9Qt?V7:g-@턼@?N3 V?r:s~\K?ϴ'?#;@bI@?@xQ@xtj@xQ@yXbN@xQ@ye+@xQ@ye+@xQ@w>6z@xQ@wKƧ@mhr@nzI@mhr@lq @mhr@l"h @mhr@lzxm@mhr@m8@mhr@mB@0@@0@@+MV@+Mqu!@*x@*ɠ'RTa@*oi@*e@*oi@*oh@*oi@*oi?^j? ?&??eU5?tKc?tJ?bQ넛? g?j?; $?Ff$?SV.?bM]f?u?u@>N ?avh?l&?@@@@@(@,??????OZ?"J?5/B?!63@x!J@m.,?D_?oo?0P7?g7j?X'Ec@s 9 @@@n@@n@7Kƨ@n@Mj@n@PH@n@`B@n@e+@$$@$bM@$$@$`hۋ@$$@$NV@$$@$Q @$$@#y @$$@#C@8:@8u@4O|hr@4E '0@3V@3@3fYJ@3Z>C@3fYJ@3TtSN@3fYJ@3LN;?E?05 [?3Z?998?+|˟ @g`@A@A7L@𘰢@A7L.@A7L.@A7L.@A7L@B|z@A7L@Ձ$@yE@yXbL@yE.@yE.@yE.@yE@|S-@yE@|Y~@8>6z@8q -W@3S.Mm@2KƧ.Qn@2Ǡ k.NC,@2Ǡ k@1*,@2Ǡ k@1i0 (?`@8#@8:@8 >+?Ҏ?ѻ,?wvHf@8@8i@8?җ#?ڑL'?^}\Б@8 *@8p@8??] @@2@*???B@s\@s7Kƨ@s\@s l@s\@sݗ@s\@sz@s\@so@s\@swk@"@"@"@u%F@"@"@"@y=~@"@@"@y=@3I_o@3Iy @1xr Ĝ@1xl"h @1"-V@1!_p@0u@0䎊q@0u@0 ҉@0u@0@N?2}?]Û? '?,Z?u?dW?| ?Q_ڸFN?}7.?Җq?UBi?P=?nwf?Q?֘>D?9XNu?7?k!l@@@@@&@&??????R3*?0iT?]Xؗ&@s;0@')Ĩ?PC\i?4#ŵAr?8¸(q?s[P@grC 0@C@S@dZ@S@5?|@S@!n.@S@\@S@ '@S@W@m@ ĝ@m@x@m@hۋ@m@E@m@S@m@0@6H@6}Vl@3}hr @3}hr @3{Ƨ@3|wkP@3@5@3wkQ@3@5@3䎊q@3@5@31&x?1j?*|3N? ?o=\>? ?7fps?qN?1`?C B?O[?nwf?p51?E~?VED?΋N?HF!6@@@@@,@(??????eY?nAc]x?D H~?c0-@\@z ?brcP?Zޣ?Yٱ@f@c -4@D@G+ J@Fffff@G+ J@F&@G+ J@GfB@G+ J@Cn@G+ J@JL/@G+ J@I@`A@-V@`A@о *@`A@V@`A@hr!@`A@ʦL/@`A@;dZ@7!.@7͞&@3)+ @3)0 (@2`A7L@21&x@1_o @14֡a@1_o @1:)z@1_o @1xl"h -?q!U?_X -?P"hI?)?P=?)'3??Hk#?Qc -?ihA? ?.?z"2(?7'nK?aI*?cZ?b? )D)@@@@@*@,???????UMX=xM?TFI?PsR@F Jl@ϝ|?n3,V|?jV *;??υ̞@m4@E@Q@ӈ@Q@kX@Q@75@Q@+L@Q@dl@Q@[~.@ctj~@c;(@ctj~@cDn@ctj~@cw^(@ctj~@cm*J@ctj~@cke@ctj~@cnR@8쿱[W@8(ےP@3S@36=C@2q7Kƨ@2f]b@1xF^@1a+E@1xF^@10L@1xF^@1*GQ?Dʯθ?u3v?E&?y??%?Xd?4?1ͻ?,?:?2%?8 -$?ǒ}?(tl? gz?gK?s ?Fu@@"@(@&@8@5???????1Kq:(?W??bٶ7^@K@cvZb;?yRT;?|X?qjZ?An]oV@l1@F@v"M@v!@v"M@v#,zw@v"M@v"\(@v"M@v!.H@v"M@v˒:*@v"M@v" I^@lC@l1&@lC@m5Xx@lC@m(@lC@l>B@lC@l~($ @lC@m(@4,<@4l!.@0R I^5@0Rs@/F@/؆YJ@/Gݗ,@/F@/Gݗ,@/Fx@/Gݗ,@/G-?| ?Čۨ1A?"?:Z2b?,I ??}ѿ,?j%Ra?A)N?>\?Hc?Uyu#?8*?)Zw?YF?E 8?ˢL1?A0)n@@@@@*@$??????oqQ?*{:?-t{ Ћ?EM@v!)L@l|?M?/G|?, S?h@gIzA@G@o)x@o)^5?@o)x@o)Dg8@o)x@o)@o)x@o.O@o)x@o)'RS@o)x@o)@bM@h9X@bM@`4n@bM@em\@bM@gݗ@bM@eO@bM@hK]c@8,<@8S&@3ahr @3`4m8@3,j~#@3+U=@26z@2b@26z@2iB@26z@2[?us\?d_s? -D?!#?n{K?1a?o 6}?\j? yz?@[*^?c3c(? C`? nI?|׿pZ?p-?{0?/̽`?T8@@@@@(@(??????# -g c?O@^?G!1N@o+nП$@g/ i?k?Z_IĚ?ӆq ? o@pHZC@H@p$/@pG{@p$/@p I_@p$/@poh@p$/@pR<@p$/@p?@p$/@p˒:)@e#S@e#%@e#S@e"`B@e#S@e!af@e#S@e"wk@e#S@e"\(@e#S@e"&I@2H@2.2@-A7K@-IQ@-;dZ@-[6@-fL/{K@-gfA@-fL/{K@-i*0U2b@-fL/{K@-hۋq?^Dw'?&H?(?䆀{6? 9?aX?bV,?j%Ra?ԕ]I?e[|(?M?rJs?:9?.+?٤?hB^?ˢL1?L@@@@@*@(??????KS)z@{?4!Kp?Q8-@py̸@e"vR?CQZ?!Ə%?!r?;&b@s04@I@`A7L@`n@`A7L@a7K@`A7L@a7K@`A7L@b I^@`A7L@^m\@`A7L@_F@[ ě@[bM@[ ě@['R@[ ě@[@[ ě@[)^@[ ě@[{@[ ě@[bM@304m8@30A7K@.Ƨ@.q @.x@. k@-oi@-m\@-oi@-S&@-oi@-m\?|O? ?=?Kh?lDžN9? f?2I/?|O? ,C?O(?Y?IM?rJs?q6tN6?.x?2Y0?8 ^?pk Y?pk Y@@@@@*@,??????, ?5?5ՔZ]4c? ܽb R@`>@[?U$?*&"V?x%?aK@f|@J@ߥS@ߩl@ߥS@ߤZ @ߥS@ߡG{@ߥS@ߠhۋ@ߥS@ߝb@ߥS@ߝ,@;dZ@A7L@;dZ@2W@;dZ@ۘ@;dZ@~@;dZ@@;dZ@dZ@6s@6bM@2 ě@2}ڹY@1t@1° ě@1!:S@1U=@1!:S@1c @1!:S@1ߤ@?Ol?9؊??̒?Jj~u?ީqk#?)T?p RN%?I?,?#:d ?to(?Ƌ?3a=?d --?ȏG?0&YEd?e(Os@@@@@,@,??????g3S?=y |%?6:@K@ߢN@9?\֘e$X?Vc5*i?)?y$ @hP@K@Ƨ@=p@Ƨ@2c@Ƨ@e@Ƨ@`@Ƨ@ȱA@Ƨ@#@Hvȴ9@HhY@Hvȴ9@H2@Hvȴ9@H+@Hvȴ9@HR/@Hvȴ9@H&@Hvȴ9@H/6vY@5 xF@5@.kƧ@.lKk=@-ӶE@-ԫ_K@+Z@+)_@+Z@+ I?@+Z@+ l?|b@?yi?&!R?V{?T^?6m*w?}x?sn?y Y?"F@@*@(@,@7@9??????!_$E4?)Cʽ!?-@P@H1?I/#J:?3L$R?B ?s"q@gf`@L@wr @wr @wr @w@wr @wIu(@wr @w2Z@wr @wt&@wr @wf@ -V@ -hr@ -V@ ,C@ -V@ ,pt@ -V@ ,g@ -V@ ,@&R@ -V@ ,>B@/u%F -@/u%F -@)~"@)`@(SE@(S;W@'Vl"@'K]@'Vl"@'K]@'Vl"@'[?^6P? l???D?s&?4Q?bQ넛?K}?qΪ?2j)6e?μjH0?L5Sk?bM]f?P0?pDRh?N?_cd?8'@@(@,@&@:@9??????H~_??2#?ZSV@w3e@ ,.?Ap^?%M'\?}!?CqgJ@s @M@e1'@e2@e1'.@e1'.@e1'.@e1'.@e1'.@\m@\"i@\m.@\m.@\m.@\m.@\m.@7@@7XGmI@2S.Mm@1"`.Qn@1V!.I.NC,@1V!.I.NC,@1V!.I.NC,?Q.K@8#@8:@8 >+@8I@8?r@8@8i@8@8S@8?kZ@8 *@8p@8@8 @8 @ ?N@t7Kƨ@t~#@t7Kƨ.@t7Kƨ.@t7Kƨ.@t7Kƨ.@t7Kƨ.@D@Cp -@D.@D.@D.@D.@D.@1DO M@1AA [@-j~.Mm@,dZ.Qn@,V.NC,@,V.NC,@,V.NC,?`~E @8#@8:@8 >+@8I@8?bQ넛@8@8i@8@8S@8?L@8 *@8p@8@8 @8 @?O@$Z@#%@$Z@,cA @$Z@*W@$Z@8V@$Z@1@$Z.@gG+ J@gGz@gG+ J@gDt@gG+ J@gB}V@gG+ J@g;=K@gG+ J@g6+ @gG+ J.@35S&@33&@1hr @1D@1U`A7L@1LPH@0‚@5@0 k@0‚@5@0ߤ?@0‚@5.NC,?|O?+!?13??Fq/b?V0o~8@8?| ?HG^?Q\?< /0?V@8? SF?i--?ArUA?q$_54?@C@8 @@@@@*?????P@$/@p@$/@n.@$/@TɅ@$/@7@$/@d@$/@~쿱[@G@Z@G@@G@)y@G@)y@G@Y@G@#@8L]ce@8N;5X@2+S@2*fB@1ttj@1sA [@0c@0c@0c@0dzG@0c@0c?WZM?]Û?K?vHn&?\2?9?E?`?|ɽ?1? ^??P=?xJ?Q?],m=?E 8?fW?*Z}@@@@@@"??????`0[Mg'?1? 6?T% R@@ D@l;?B'#?ker2O?WxZx?4cBM6@p&U@Q@_lD@_S@_lD.@_lD.@_lD.@_lD@_@_lD@_"@Gz@DZ@Gz.@Gz.@Gz.@Gz@B I^@Gz@Gz@6L]ce@6JqiC@2Lhr.Mm@1j~.Qn@1 [W?.NC,@1 [W?@1Q@1 [W?@1 -?2}@8#@8:@8 >+?J+?I ?F/P5@8@8i@8?q?p?],V@8 *@8p@8??oڕ??oڕ@?????R@p -@E@p -@,@p -@m\@p -@IQ@p -@+k@p -@@RnP@R@RnP@S@N@RnP@Sa@@RnP@RW@RnP@S@RnP@R䎊s@3ks@3k'/@/p`A7@/p{@/*n@/*0U2a|@.`d@.9XbN@.`d@.zG@.`d@.O L?| ?{j?1f_?ݶ\r?ǹT?2I/?| ?0n=Q?O(?@[*^?Cq$u?+d?u@>N ???+ ??ˢL1@@@@@*@,??????&K@? 7? %̓)1?0V@@S^B?+.?2*?d+8?q@ffX$@S@HT.@HT.@HT.@HT.@HT.@HT.@Q.@Q.@Q.@Q.@Q.@Q.@9v.>@5S.Mm@5.".Qn@4:S.NC,@4:S.NC,@4:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 T@;dZ.@;dZ@74@;dZ@KƧ@;dZ@@;dZ@ @;dZ@5Xy@.G{.@.G{@.u@.G{@.xF@.G{@.1@.G{@.:)@.G{@.7KƩ@9۹~($.>@3hr@3IQ@3)"`@3:)z@2,<@2'R@2,<@2kP@2,<@2 ԕ+@8J?-56+?b?Ԧ?n?rA:/?8@8J?,g?{2??pFs? CQͫ@8p?j?Mf ?ə?2:U?R|@@@@*@*?????U@/-@/@/-@0`P@/-@09@/-@0%@/-@./Ia@/-@/(@Yt@YT@Yt@YQ@Yt@Y @Yt@Y<@Yt@YaG@Yt@Yx@44m8@4zhJ[@0+ @0/4]@0~"@0P%@/a-w1@/b#-=@/a-w1@/a8*:@/a-w1@/ar?|B &?٣AV?+m7?:Xv?/[ap?`?|b@? ?1!?1?F7*?K~P?q9?  ?m6`?F ?ǤE+?gӼc@@"@$@ @0@,?????? ? i?0)?$-@%@/}@Y+?Pfqwa?D>f?4QF"?+O%X@f@V@E@m@E@}Vm@E@Q@E@sQ@E@4@E@sh@`A7L@a$/@`A7L@^ߤ?@`A7L@`4m@`A7L@aTɅ@`A7L@^ߤ?@`A7L@_$tT@7@8Q@1+ I@1RT`d@0j~@0JL@0!.I@0Fs@0!.I@0,@0!.I@0)^??1?TS?菁k?% -?ʟ?2}?jכc?8G?>G]!?,Y?A_f;j? -e?G - ?],m=? ??ˢL1?Rv@@@@@&@*??????1(6M0?FAv -?)9v?@f @_nn?YkF?PhP6?hKld?9L@pŗ~@W@["`@XUGS"@["`@UPm@["`@S@["`@Q>Z[@["`@Kl@["`@CN-@7K@|h@7K@0@7K@”(@7K@sJ'@7K@ 5@7K@@6@6+1@2+ @2y@1ȓtj@1@@1+xF^@1%@1+xF^@1$20Ջ@1+xF^@1$?ɏ?Q%?~dO?fb -Y,?~7ix?OdB!?nO?{C%O]"?F?(,!B@@(@(@,@6@4??????_wt?WWZ?5fD?Bj@OV?H@>?T38?cm?{ ?Au8H@j.@X@5?|.@5?|@%K@5?|@'@5?|@$J@5?|@"k6@5?|@ {(%@ěT.@ěT@!$OC@ěT@gL@ěT@:@ěT@E@ěT@ub%@8T xF.>@4+@4|h@27Kƨ@2o$ޑ@20U2a|@2SK@20U2a|@2"û@20U2a|@2|>:@8J?'g?itv?K! ?d{B? -w@8J?ATa?6?u8?䝟?Z`L@8p?z\?z?KwK?7?%d](@&@"@"@;@:?????Y@׍O;@Ƨ@׍O;@@׍O;@bM@׍O;@_@׍O;@"@׍O;@}I@mV@kƧ@mV@l/{K@mV@eoiD@mV@nH@mV@lC@mV@l@7]ce@7zG@4i+ @4mK]@3`A@3ѷ@2:S@20 )@2:S@2s@2:S@2]cf??;=?T?MDe?/? -æ?DIx?F/P5? -?(?{k4?| ?%3?6@(/?tgi???G'?ϯs &@@@@@*@,??????q?5VYX?ahW$DG?1`)~@ Ù@lDj?|~Yjl?R<5d?%;$U?g%C@iE@Z@^5?|@^vȴ9@^5?|@_@^5?|@_;dZ@^5?|@^5?|@^5?|@]/@^5?|@]+j@b I^5@b @b I^5@b I^5@b I^5@b @b I^5@b /{J@b I^5@b t@b I^5@b Ƨ@3~($@3~($@/kƧ@/k6z@-n@- @-V@-U?@-V@-Uᰉ@-V@-U=L?|O?ߋb?$C@?!#?% -?ˡK?| ?NۈV(?A)N?]bn~?%y*=?X78?oܧ?.+?y8$?E 8?j?l&@@@@@"@??????+h/+̾`?\>2S[j@^Z@b V?{)n?㗳V?v@l9@\@7@7p @7@7PH@7@7oi@7@7}V@7@7҈p@7@7䎉@u@!@u@,1&@u@C\@u@O;@u@z@u@@7O M@7ᰉ@2@2A [@1ȓtj@1;dZ@1QiB@1M%@1QiB@1O @1QiB@1P6?E?d̺?mGSq?:L -?#0Y?}>h'?)T?g3?FRX?YE?Otx?OW?/?%d?@@@@@,@,??????=|idFk?Pw ~?6m,H@7@e ?fIy?W?zr?{D@m7B@]@+@8I@8?cnŀ@8@8i@8@8S@8?+;=H@8 *@8p@8@8 @8 @?^@tj@E@tj.@tj.@tj.@tj@nP@tj@GE8@kR@kR@kR.@kR.@kR.@kR@k]c@kR@k]c@1|Q@1҈p:@-7Kƨ.Mm@,x.Qn@,PH.NC,@,PH@,*0U4@,PH@,tj~?_\p)@8#@8:@8 >+? f?wZL?bM_x@8@8i@8? xV?SV.?4e@8 *@8p@8??O|q@@@???_@`A@E@`A@v8@`A@opKQ@`A@f -L0@`A@i@`A@;@Vvȴ9X@VeUV@Vvȴ9X@V֔G@Vvȴ9X@V3m@Vvȴ9X@Vk8`@Vvȴ9X@V?@Vvȴ9X@V@8N쿱[X@8Sz@3S@3ĺ`[@2j~#@2ކ@2&@2ZҦH@2&@2FA$@2&@2?پ?>,*?O_?# -t?v77|?nVV*V?)jgï?-C]?\?忚"~?Ϝ? ve\? -kș?vV?wEH? n??Vy/s?앸4@@,@,@,@5@6???????!K P?ye@?ye?t@싕8^@V/?,A?C%! -@B?8`j@mB@`@ @  I@ .@ .@ .@ .@ .@01@/-V@01.@01.@01.@01.@01.@8w@@8*ڹY@4?|h.Mm@3`A7.Qn@3Q.NC,@3Q.NC,@3Q.NC,?sW]@8#@8:@8 >+@8I@8?wp@8@8i@8@8S@8?עH'@8 *@8p@8@8 @8 @?a@nn@n@nn@nz<@nn@n@nn@nY@nn@nK7@nn@nțQ@\(@˅R@\(@'@\(@@\(@#@\(@.^@\(@?@7!.@7@3hr@3LK@27Kƨ@2@2(@2/߬o[@2(@20 @2(@2/pe?E[i)?*e?R?o?caК!?Ό#?~?J?]Y?Nw -?wਙ?n_?H2C?MŅ?4S?o;!R?RI=?h9?Y@@ @"@&@9@7???????G>h7c?LV"t"@lffff@l@/@`A7@/@壯@/@Z@/@夨T@/@夨T@/@夁oi@5?@5@6@2+ I@2fffff@0tj@0MjP@0,<@0s@0,<@00U2a|@0,<@0qiC?|O?W[?U#?U*?\7?i{?}ѿ,?4i?ԕ]I? Y?&Tm?h,à?m~Z_s,?G - ? -`z@l!@Ӭ?8WE? ߲N?Y-?GK@gY@c@ffff@ffff@ffff@4m@ffff@@ffff@㢜w@ffff@ߺڵ@ffff@ @;;dZ@;;dZ@;;dZ@;@;;dZ@;kf@;;dZ@;e,@;;dZ@;>@;;dZ@; 9Sg@2w@@2w@0S@0HtP<@0q7Kƨ@0v@/-w1@/&IR@/-w1@/SM@/-w1@/l\?^6P?waG?ַHk?ھ۲?)C3?gɜY^?bMn?%l Z?R*?j?[w}^ʨ?#qA?bw' g?&&Y? ѿ?O.ce?7kPz?ǭ7@@@,@@9@7??????L`?Ldk?3c0?2@W}t@;?B@?Ai3?6 3z?w/ c#@s5pP @d@Ӫ~#@ӚG@Ӫ~#@ө@Ӫ~#@ӧ)_@Ӫ~#@ӭ5Xz@Ӫ~#@Ө˒9@Ӫ~#@ө^5?@KƧ@Hr @KƧ@KƧ@KƧ@O'/@KƧ@P)^@KƧ@O@KƧ@Ow@8*0U2b@8wkP@3xr Ĝ@3z͞&@27Kƨ@2Xy=@2J0U2a|@2L@2J0U2a|@2L(\@2J0U2a|@2K:)z?E@?@K/z?1V?Q??WA:@8 ?{%@@@@@&?????f@2-V@ޯ9@2-V@4~f7@2-V@09 r@2-V@5 S,@2-V@1*4@2-V@0`A@~"@ A7K@~"@xO@~"@sB@~"@uMU@~"@yQ@~"@|Ã@8v@8 D@2^5?|@2A@1"`@1t{@0D*@0$31@0D*@0챔@0D*@0̐d?%2)`?>k^?Uw&?Ӳg?(e ??ay?r4?m:x'?7?qHO?,^ڰ?9?C s?? |~?[yמG?X ya?AShU@@$@,@(@9@4??????bNaI?`X?`G?XY@2T[@x!*?o!=?gT`Es?[ť h?'Y_@s #@g@@n@@$/@@&H@@@4@@IQ@@ح@@3333@@@@ҽ<6@@ҽ<6@@iC@@GE8@7֚,<@71'@2 ě@1Vϫ@0-@0@0iB@0 @0iB@0W@0iB@0䎋?sD?Z.? ?Ac ?u?WA?1j?,#?d0R?.? A?B8? - l\?9o?`x?Gϵ'?j?7@@@@@$@(??????Eݺ .X@?6I?1t2'V@Q)@ҙ< ?T6k?2\b?tvd?l<#9@jl@h@Ƨ@nP@Ƨ@n˧@Ƨ@!7@Ƨ@uk'@Ƨ@ffn@Ƨ@v$@M@sY@M@@M@@M@=A@M@@M@7@7Y*0U2b@7[X"@4 I^5@4F M@3-V@3c@2ޫ6z@2͔JG@2ޫ6z@2K@2ޫ6z@2?R ?/s?3sL?1_?8U`?h6z@7v@3^5?}@3P{@2y7KƧ@2z^5?|@1kxF^@1mhr!@1kxF^@1l1&y@1kxF^@1k$?UbB2?E?Q/ -?wX/8?R%(0?f]G? ?-NI`(?}7.??az?C ;?pr?r?m~Z_s,?< N ? Ğ?Y͍_@@@@@$@ ??????`RYEY0?8 ?#~> @$N@ana?S9.?FΚ,?#j(?{H@l;@k@l@C@l@x@l@1&@l@ -L0@l@W@l@6>@ߝ-V@ߛS@ߝ-V@ߨXy=@ߝ-V@߻s@ߝ-V@ߥv@ߝ-V@ߚ}@ߝ-V@ߊ=p@6=:@6;}@33S@3,~($ x@2j~@2n@2._o @2%S@2._o @2@2._o @2$\n?|h2:? #?/Çf?btx=?t8 ?M?nO6z@3p@3{W>6z@3p@3vl!.?qv?+Rja??&1}?']?cJlD?qv?S̵E??B3?Y:J?,4r9?fg?l&?y\?*+JҚF?Oh6c?P$`*@@@@@,@,???????QMOL?w&׀?Bl5?T>G@M,@+L?^H?r2l?ަ 9?_tc@l}rQ@o@NaG{.@NaG{@Nn.@NaG{@N@NaG{@NM@NaG{@Nzxl"@NaG{@Nn2@$/.@$/@Ϫ͠@$/@g@$/@:~@$/@Fs@$/@Z@904m8.>@2 -^5?|@1D@1j~@1}K]@0xF^@0ߤ?@0xF^@0j~#@0xF^@0H@8J?J f?bY?':?0O?KAb@8J?ֶ?J&?"JÁ!?^候?p@8p?`P?a -?{Cx?%d?<@@@@,@&?????p@g-@hr @g-@hu%@g-@i*0U2@g-@i@g-@fFt@g-@g)`@n @n V@n @n jO@n @n \@n @n @n @n 5Xy@n @n !-@0@0@+WKƧ@+WXe+@+XF@+X4֡c@)@)!.I@)@)@)@)!.J?^XN?[e@3sS@3i^@2-V@2T`d@25sh@20- r@25sh@2+s@25sh@2& '@8J?-56+?IK?؆{~?Y?O@8J?{UO?a>&?%hF?s?Vϊ޲@8p?<2?Śn?w%?Q?]?@@@@$@(?????r@Hfffff@Hk I@Hfffff@Hf,=@Hfffff@Hf&@Hfffff@HeoiD@Hfffff@He1@Hfffff@HeO@+ J@vȴ9Y@+ J@$/@+ J@J@+ J@@+ J@Ft@+ J@YJ@8B䎊@89b~@1&+ J@1')^@0_-V@0_v_ح@.ߤ@@.?@.ߤ@@.ݿH˓@.ߤ@@.Vl"?{B@nzH@|쿱@nzH@|PH@nzH@pě@nzH@l]cf@u2 Ĝ.@u2 Ĝ@u9Y@u2 Ĝ@u-(@u2 Ĝ@u9#x@u2 Ĝ@u-%@u2 Ĝ@uڹ@8]ce.>@6|hr@6W@5n"@5yJE@4ޫ6z@4zG@4ޫ6z@4a@O@4ޫ6z@4D@8J??B?|?C˗?x7V?c+:X@8J?vj?R?:$I0?&?him?/+@8p?e]Z?CRv?>0Om??Ϭ -f@@@@*@(?????u@%@%@%@r -@%@@%@n`V@@%@<&@%@%@zG@@zG@E_@zG@@zG@F\@zG@ -]@zG@N@4䎊@4-V@0hr@0Q@/|1&@/}@.L/{K@.@.L/{K@.X @.L/{K@.1"?~?J?>ȍg?F<4?Ki8?h?ʋ?|B &?'7x?]Լ?Ay>$;?Us?  &?]ivL?sg?9XNu?:1?W|DC@@@@@,@(??????YF~?=:?Kbh ?YW8`G@i^Y@Qh?ckwH?t(Oml?7֖?09@mЬ@x@>"@6+ @>".@>".@>".@>".@>".@gS@g&-1@gS.@gS.@gS.@gS.@gS.@7쿱[X@7 c@40ěT.Mm@3.".Qn@3!:S.NC,@3!:S.NC,@3!:S.NC,??2ZF@8#@8:@8 >+@8I@8?o"@8@8i@8@8S@8?[@8 *@8p@8@8 @8 @?y@E@@E@j~@E@G@E@Fs@E@-V@E@a|@8$/@8$/@8$/@8d@8$/@8$.@8$/@8 k@8$/@8e@8$/@8af@.5Xy>@.5Xy>@- -~"@- -g @,n@,d8@,ۋq @,y -@,ۋq @,B@,ۋq @,B?^Dw'?&H?m?!#?@ A2??bM_x? -?d0R?7枪y7?Hc?Z,a?bMky?u?2Y0?XLL?B ?B @@@@@$@&??????L<?*f?6 2#4?.4q@N@8a.?EC E??=$(to?([?r:#@s p@z@ȴ9X@v@ȴ9X@@ȴ9X@kP@ȴ9X@XbO@ȴ9X@%F -@ȴ9X@Fs@w@bM@w@ -<@w@E@w@@w@+@w@1@7 xF@7l"h @25?|@2N;6@2-V@2*1@1O M@1Z2@1O M@1|Q@1O M@1 qv?}?J?-.?b?? -`?X?h??M7F?_M?j9@@@@@&@,??????U^Ȩ`,z?7KR+??4xW@jA@?VgfT1?R\ o2?`@?]@l()}@{@->vȴ9.@->vȴ9@- 4m@->vȴ9@-S|@->vȴ9@-*d7@->vȴ9@- ؝@->vȴ9@-@$/.@$/@/{J@$/@)@$/@TɅ@$/@U[u@$/@yz-7@9}:.>@5&+ J@5 @4"-V@4N;6@4iB@3D+@4iB@3MMvl@4iB@38@8J?>I}?Bg2?X?Ks(I,?O֔@8J?Qpj?O?9.?guoĺ?w@8p?Fۯ/??e??[-D?.}y@@@@.@.?????|@V@@V@jO@V@p:~@V@:@V@/7@V@̋R2@-V@in@-V@{@-V@O M@-V@-@-V@p@-V@t9@6S&@6ez~@2 hr@2}Vl@1"`@1PH@0iB@0ѷX@0iB@0vA@0iB@0bo(?ڡG7@.@.~˾@.@.+|?^P!?Û* ?.t`>?=@v?1\? #?bQ넛? ?-ƴ?0r>?9%~E?]VK?bF?"?ڸcX?{ 4?Ez?GS@@"@,@"@6@4??????Ol U?*WVTb@?@A-@Z?9R0/?(-??oo(?IOw@su@~@@zI@@\(@@α2@@(@@cA @@C,@1'@/@1'@q @1'@S@1'@S@1'@<64@1'@]cf@3D@3$/@0+@0y @0t@0sg@/C\@/(@/C\@/(@/C\@/?|O?W[?&P?W0 ?u?̉ߚ?| ?jכc?&?ihA?Jj?低NV?q6tN6?%_D?@A?E 8?SP?ˢL1@@@@@(@,??????>U$m ?&Y?%7@2@$?FB, $?FT<|?J?gc)@f|@@S@󣕁%@S@?@S@/@S@󤛥T@S@@5@S@&I@x@x@x@xW@x@x@x@xGE8@x@xS&@x@xp:@+-5Xy>@+-5Xy>@')7KƧ@')Dg8}@&cnP@&cnP@&z)_@&z)_@&z)_@&z)_@&z)_@&z)_?`&x?GA?!!׋7?MA8?DE?:?bM_x? -?~Q?6)}?@?Kc?bMky?8 T?oܧ?avh?#.?#.@@@@@,@*??????REs%?_Ű?5Jx?u4=@,L @xw?DӹȘ(?#?B?PZz??UfT@s >Q@@|h@7K@|h@?|@|h@2@|h@@|h@1&@|h@BZc@{dZ@$/@{dZ@y>B\@{dZ@xbM@{dZ@u=@{dZ@|@{dZ@|N<@8֚,<@8@5B ě@5?@5K"`B@5G@@4ce@49@4ce@4x@4ce@4!.?_pP1?EX?^RpX?;Ϝ(?VK?pt#??Zm?=0́?ꉬ>V?mۀ|?<1*T!?poIo ? E?,?M,L6?ڧ? ?D d}@@@@@$@(??????zl.?,f ?S?ewBNC@DP@zb?ojr?zx+C??w:5@mZ`P@@qWO;@q]-V@qWO;@qOA@qWO;@q\(@qWO;@q>BZd@qWO;@q@ k@qWO;@qA [@K\(@K^@K\(@Kn@K\(@Kš@K\(@K1@K\(@Kҽ<6@K\(@KbM@7p4m8@7_?D@3^5?|@3!.H@26-@2/[W>@20U2a|@2z#9@20U2a|@2zS&@20U2a|@2'RT?eM?V[u9?O%c?Ģ??1?5}'?yjP?>ÔR?rVx?1?z\~?"ߨ>?Pn -E?GA?W?u4? -.ԕ?8$ -"@@@@@,@*??????{?rsÀ?XF=b۩?Y;G@qMK@K?z!k?z01?B@3S@3wK]d@3 -V@2tj@2\Q@2KC,{@2\Q@2U '0@2\Q@22<64@8J?V_^?􈤪q?㬱_?{ )?lRA@8J?kM..?P{j?^18??.?Эn~@3I^5?@3J#9@27KƧ@2zxl"h@2kxF^@2jd7@2kxF^@2hۋq @2kxF^@2iy @8J? #?괰E? R?ťBW?! @8J?ԍD?$z¾6?kH?^?&ŏ@8p?zx?(?< N ?8wx?T8@@@@(@,?????@[S@ꯝ-@[S@M(@[S@[S@[S@Y>B[@[S@WkP@[S@UY}@+@;dZ@+@ C]@+@?|@+@+j@+@>6z@+@@8*0U2b@6L/{J@4=hr @46Fs@3Ͳ-V@3Ȍ@2̿[W?@2K]c@2̿[W?@2W>6z@2̿[W?@2ǍO;d?]?hĔV?~"?Uv??S{d?]?^1??f?ֳ?l{9َ?SS?*wjs?Q6?bk?Oc?t?x?@@@@&@&??????^L?mΘ?WCC3?p{fP@W7@@O?f(Kwb?|(gOK?'h8/V?W;C@t -@@>"@ƀ@>"@LI^5@>"@VE@>"@H˒:@>"@WsO@>"@P)^@jC@j@jC@j|@jC@j7Kƨ@jC@jߤ@@jC@jd7@jC@jv@8^H@7 I^@4#@4!7Kƨ@3@`A7@3>BZc @2:S@2R<6@2:S@2ךkP@2:S@2KƧ?LV?LS{?$f%?W?/cե?q;?ni?њH?cGo?? +A?/[?jҍ?)2?8A?~/O?Qx?8?\'jK@@@@@,@,???????s2XfN?pj,z;?p @Ml@jd?|\C?{&]-)?R_uW??ٳoY7@pX@@1&y@ C@1&y@y @1&y@?@1&y@&H@1&y@ce@1&y@"@ EQ@ G+ J@ EQ@ S@ EQ@ XPH@ EQ@ H9X@ EQ@ i7KƩ@ EQ@ Xtj@6@@6m\@4+S@4<64@46-@4%@3B@5@3$e@3B@5@3'@3B@5@3>B? ?p~v]?K9yA?tN+6?ME(l?$ kH2?qn?p?<7T?:?R$(?͂c5?m!?A ?Q?z?J'Y=?%5@@@@@*@??????/ߩ?ex?c񋓏?`z2^@}@ Kc`?0g?z/u?ګ?NA@@cMڿ@@@bM@@lD@@~@@qu"@@Y}@@PH@TzG@Tj~@TzG@TzG@TzG@QN;6@TzG@P )@TzG@Q @TzG@R@2@2$tS@/KƧ@/Ar@-@-[W>@-C\@-TɅ@-C\@-@-C\@-e?^Dw'?q' -B?QX?^:f?yq?uk=?bV,?0n=Q?^ o?wxR?c? C`?j|?Ф?!A -m?__C?L8AS? ;8@@@@@*@(??????W?HL?XG=].?)6.t@=@QP?ggl?8E'?ǫO2?fXh}@r+@@@lD.@lD.@lD.@lD.@lD.@lD.@Y.@Y.@Y.@Y.@Y.@Y.@5~($.>@2S.Mm@1`A7.Qn@1c.NC,@1c.NC,@1c.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @G/@G㕁%@G/@G&@G/@G@G/@Gs@G/@Gr @G/@G@nlD@n;dZ@nlD@o @nlD@o3@nlD@o1@nlD@oh ԕ@nlD@ov_خ@6]ce@6#@2G+@2X$ xF@1`A@1,@0𖻘@0D@0𖻘@0Q@0𖻘@0s?Y͍_?^?ApJ?998?[5?lg|*?Y͍_?Hz??U(\;?SN?ۨ[u@ [?^@f _Ϯ@@W~#@VkS@W~#@W@W~#@Ws @W~#@WXX@W~#@W@W~#@WT&@ffff@XbN@ffff@D_@ffff@9,z@ffff@ݖ@ffff@/S@ffff@迫L@7hYJ@7"Zc@3|hr@3;~&@2V@2 /2l@2OO M@2QJ7@2OO M@2RIIq7@2OO M@2RR$?Pac?m?9{Scr?.HF,?L@Q?Vu.Qn@36z.NC,@36z.NC,@36z.NC,?E@@8#@8:@8 >+@8I@8?qn@8@8i@8@8S@8?64 Ú@8 *@8p@8@8 @8 @?@\)@以S@\)@jO@\)@䮗O@\)@g@\)@oiDh@\)@g@<+R@<B[@2䎊r@2|VϪ@2䎊r@2|?@2䎊r@2}v?F^S?'\?^@?,rg?PY8~Qj??UbB2?Q??.}$?h_N%?F5?&ljm? DS?bk?O"?;kr>?̶j@@@@@*@,??????XI[Po m?Q߂Xc?QJg(@S~|@<.t?g(?m&tr/?ɹ_9?Я3ax@n(;@@/-@.O@/-@4m9@/-@1hr!@/-@4j~@/-@0@/-@/A@j~#@j~"@j~#@kxF@j~#@gݗ@j~#@fffff@j~#@o\(@j~#@mM:@7O M@7,zxl@3+@3ʙ0 @3"-V@3"m\@2:,<@2?;dZ@2:,<@2<@2:,<@2BZc@0j~@0J@.@.[@.@.\N<@.@.Vl"?3a=?`?WD@?%?6r In?i{?A[F? aҹz?DP?߇O?Hc?90??G'?/?ʳ_?hB^?Rv?L@@@@@@??????H -*c^?.n?m&@@)g@?JCW?;/\?xSڅ?tɴeJ@l^@@ -cS@ -^"@ -cS@ -h6@ -cS@ -g@ -cS@ -hy@ -cS@ -d \@ -cS@ -b'C@w@wO;d@w@w~ @w@w|x@w@wV@w@whVa@w@wϩ@8䎊@8 -;[k#@3S@32d@2A7K@2=F@15sh@13oK@15sh@14ݶ@15sh@13"3?g^XF?,?5\n?I?C?#pj?|N2?Äp?N?K?9^?5Y?4;QQ|?‘?gvfb?l?Â6$?dZV?Ub@@&@&@@5@8?????? Cנ?O;V?Y8@k??o@ -eJ`@w:8?r5g?\IN?o?\@m ?{@@bM.@bM.@bM.@bM.@bM.@bM.@I^5.@I^5.@I^5.@I^5.@I^5.@I^5.@9*0U2b.>@45?|.Mm@4A7K.Qn@3䎊r.NC,@3䎊r.NC,@3䎊r.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @(.@(@ l@(@@(@`d@(@&H@(@v@Y+.@Y+@Mw1@Y+@?$tT@Y+@3g @Y+@:^5?}@Y+@E84@8@.>@4+ I@4hr @3V@3ȴ9X@3O M@35%F -L@3O M@3,@3O M@373@8J?Y?26?#- ? 'UA? -æ?S:Ъ;5@8J?I9Bf?J?z?Ri?ø4@8p?:K?o}?:?M\{W? 4e -@@@@*@(?????@+@1@+@@+@~|pA@+@@+@d8@+@X@Vqm@Vmhr@Vqm@Tg ]@Vqm@T-DŽ~@Vqm@T8ڶs@Vqm@SIQ@Vqm@TGy @4䎊@4 z@2^5?}@1 @2 "`B@1coB'@10U2a|@0s"@10U2a|@0K]d@10U2a|@0ސ$u?| V?Qth?h7JZ?Քd?'z_6?1[ݶ?}@TΥ?[?˸R{?7f9P?$m>?˕V u?/y?"vJC?j ?@lI^5@lw1@lI^5@lC@8H@8s@3f+ J@3f1.@2q7Kƨ@2rnO@1[W?@1_@1[W?@1IQ@1[W?@1M:?2}?Z.?Gk;m?{@?o?P?&Gf?% ?5CQ?C\?# Y?pPȻ?`@0k?.ge%? h?W ?3{Z?՘]G?7zE@@@@@,@*??????^ *4fLd?*8q<^?Uj򳙥 @K\p@lu?L7 [B?sU)?{R[ ?WrNܨ@k!ŋ@@l1&@hr @l1&@qN;7@l1&@i^5?@l1&@w@l1&@w$tS@l1&@sMj@hI^5?@hH1&z@hI^5?@hO;dZ@hI^5?@hQ2X@hI^5?@hQX@hI^5?@hNH@hI^5?@hGE84@7`D@7aTɅp@2+@2M:@1ߝ-V@1lC@1(@1 ѷX@1(@1T@1(@1O M?)T?V_^? ?rՉ?R?4<7?% ?H*?I?_?[0o_?SmImb?ua?,1'?J?+QK?q+U?0&YEd?0a@@@@@*@&???????hrYRl?/t?TTI7/?WHT/S@q!@hJ+?u,?w_$?Zd.a?ar@iҕV@@|h@}-V@|h@3@|h@^5?~@|h@@|h@G l@|h@(Xy=@@O@@ǻ6@@ƞiB@@K҉@@ȸ4֡@@ǔJ@8`D@8G1@3S@3y@3-@3@*0U@2s&@2'@@2s&@3VFs@2s&@2>5?|?TU?[T?Cq;l?dc?mעA?M9?}ѿ,?%@&?!-F?S^ٙ?,ي?Æ"Y?bO?3XMV?Q?$–?i ?uqR7@@@@@*@*???????u???8PN?É"}@mc@,I?^b?@+ P@(>@b1f@@TF@i7Kƨ@TF@J*NWY@TF@NN-@TF@:@TF@F|W/@TF@Ję@O;@"_@O;@#Uf@O;@.<3@O;@4S2@O;@%q!r @O;@K@9>6z@9w^er@4 ě@4)@3~Vu@3}#+@3+xF^@3,@3+xF^@3+r[ @3+xF^@31T?(?/?=?ݵ?&a?e?C2?>99?cg >'?c>Ep|?E?sa36?"uM?\B ??#hM9jh?8O$k?&'x -@#$@!?X/Ղo?Fj9M?&Rz?oZG@g1m -@@ -=@ -=@ -=@lN@ -=@`|@ -=@?U+U@ -=@>{@ -=@?l@@0@@Wյ@@!j%@@ ʿWr@@W@@^%@6 ]ce@6 9@2 ě@1`7~@1"`@1Tͬ@0Q@0 ;@0Q@026@0Q@0EVA^?}@TΥ?mS?o:6@?HO?[`?HAu?gQ?OS6?)U?}?&?}F[n?pM>?M? y7?v$/?N%ɖ?8@@ @(@*@:@7??????Phg,?Nbʐ"?~@*@i@!|?m9{?2?Tb?iUi@e6:@@-A7L.@-A7L@-ᰋ@-A7L@-a@@-A7L@-$/@-A7L@-<[@-A7L@-ƨ@+ J.@+ J@6z@+ J@!.@+ J@$/@+ J@#@+ J@r@9_o.>@4n5?|@4u=L@3tj~@3Q`@3~($ @3!-x@3~($ @3=M@3~($ @3Z@8J??8?Lqa/?ܳA?O5cO:?!Qi@8J? ?f?p?%9\?+><@8p?cK4+?kn}?k2m?J?dWj>@@@@1@0?????@DO@D\(@DO@Ez:^@DO@E@DO@E0?@DO@EAnp@DO@E9-@r`B@rIE@r`B@r$@r`B@r\A@r`B@s2p@r`B@s:_@r`B@r@7H@7 - B@25?|@2is@2Htj@22 -6#@2ush@2I21PH@2ush@2JuQQ-@2ush@2KG5{?yjP?uA b?_ps?L5?Ρ?Tň?E[i)?glF?.?y7?E.X?4(??PgDm?IE?~O0?d /?{cm@@$@&@*@7@8???????ac?8E# ?g?s"RP,@Ea6@r9QB??P-??ʢ@iL@dv@@@>]/@>W -=p@>]/@>V_@>]/@>m&/@>]/@>Z9,6@>]/@>Y:Y@>]/@>Ysf9T@?vȴ@?` |@?vȴ@?:@?vȴ@?JL@?vȴ@?ç2@?vȴ@?#@?vȴ@?G@8,<@89 @2hr@2ψ@2`A@2 ѹ{@1=ce@1;(5n@1=ce@195 @1=ce@1;F2T{?$?aUY?,?F|?mt?"&?]? E?, eRZ? $YF@? >?Sd<9?{?J?87?@n= n@@-V@@-V.@-V.@-V.@-V@zI@-V@9X@Ƨ@I^5@Ƨ.@Ƨ.@Ƨ.@Ƨ@n@Ƨ@n@7B䎊@7>u@3W+ I.Mm@2t.Qn@1𖻘.NC,@1𖻘@1@1𖻘@1%2?}@8#@8:@8 >+? f? d?| @8@8i@8??m/w@*dZ@*G{@+L@+KQ@+L@+K]cB@+L@+KC&?`&x?GA?(?G?Dj?wZL?bV,? ,C?['?@[*^?Cq$u?X78?b@?.+?s@a?8 ^??b/bJ@@@@@,@(??????:Y?9P1`?E;?#&@nyz@A_b? aI?2\ ?;12Nh?^sL@sd#@@ ;dZ@ Z@ ;dZ@ cA @ ;dZ@ .3@ ;dZ@ Ϸ@ ;dZ@ V@ ;dZ@ L`@UO;@US@UO;@UlD@UO;@Us@UO;@U"@UO;@UF]@UO;@UJ#9@904m8@9.zG@3|hr@3@4n@3"-V@3$*1@28D*@2:ݘ@28D*@2:d7@28D*@29lD?pEIt?ru?l5B?{y6?Xe?4 ?ʻd9\?z?A -;?:u. ?>H>d#?1鄽 ?ȉvw?*T?d --?J]j?)@Jq?^^ω@@@@@,@&??????cJe?OB{#?TPZ ?T6i;@ ΚFv@Uko?d+O#?dBN?NO?K _@rC@@.9XbN.@.9XbN@-"wk@.9XbN@,G{@.9XbN@,֡a@.9XbN@-NH@.9XbN.@Õ%.@Õ%@!-@Õ%@v_خ@Õ%@c@Õ%@%zxl"@Õ%.@9p4m8.>@4ԛS@4\64@44tj@3ߤ@@3ush@3F@3ush@2l"h @3ush.NC,@8J?'l? - ?dҦ 3?֜r@8@8J?lu?!zs?.Oc?֝Sx@8@8p?S1z??|Rs?K/JRZ?‘x4?W Z?6s?~'T#?}ߊ9?N•w"?"Q$@@@@@,@(???????F7޺?1?z}@tf{@=ދ?r웧 ?5A@/"G{?!K?$@^>>FT@@q&x.@q&x.@q&x.@q&x.@q&x.@q&x.@ lD.@ lD.@ lD.@ lD.@ lD.@ lD.@75S&.>@3 ě.Mm@2-V.Qn@1&.NC,@1&.NC,@1&.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @-V@S@-V@u%@-V@rGE9@-V@l!@-V@t@-V@$ x@0%`A7@0 A7L@0%`A7@0' l@0%`A7@0*#9@0%`A7@07r@0%`A7@02@0%`A7@0 'RT`@8v@8ᰉ@4J^5?|@4?;dZ@3ߝ-V@3m\@3 -0U2a|@24m9@3 -0U2a|@2A [@3 -0U2a|@2M?+-/?DE?s3gp?˃.?Kbo?F}^?{@hr@;dZ@hr.@hr.@hr.@hr@ V@hr@ -Ow@74m8@7 @3pěT.Mm@2b-V.Qn@1p.NC,@1p@12W@1p@1rs?E@8#@8:@8 >+?DE?}>h'?2}@8@8i@8?%g?O&P? -tM@8 *@8p@8?4\ɵ?a@@@???@g 7Kƨ@g\(@g 7Kƨ@f8YK@g 7Kƨ@f0 @g 7Kƨ@frG@g 7Kƨ@f~#@g 7Kƨ@fPH@ݲ-V@@ݲ-V@4֡b@ݲ-V@E@ݲ-V@L_@ݲ-V@.@ݲ-V@U2a|@8@8u@3 I^5@3ѩl@36-@31'R@2sh@2&x@2sh@2䎊q@2sh@2,(@@@@@*@*??????Q=?(T?29]?Xd)?Qwq^@s -m_^@@҄T@҄T@҄T@҆YJ@҄T@҅+a@҄T@҅@҄T@҃e@҄T@҃S@G+ J@Fx@G+ J@H$ x@G+ J@G&@G+ J@H>BZ@G+ J@G8}@G+ J@HK]d@3v@3@0^5?|@0ԕ*@/|1&@/|]ce@.fL/{K@.fIQ@.fL/{K@.fL/{K@.fL/{K@.f1.? ?m?K]4? Iy?b\?i{?|O?La?'Q?ihA?݄ ?R g!ڢ?|׿pY?/? SF?+ ?L?L@@@@@,@*??????&>?/X0?0vd?X`@҄lw@G}?P6@N?@p<9r?NĬ?M7۵@gQ(H@@\(.@\(@bM@\(@ "h @\(.@\(@]cf@\(@Mi@'-.@'-@Z@'-@!@'-.@'-@%@'-@0 @:V,<.>@5?|h@6) @5>Vu@5wXe@4L[W?.NC,@4L[W?@2,<@4L[W?@2~($@8J?뒌P?Q@8 >+?aC1 ?A0R@8J?ڤ4H4?'@8?:V?Mp@8p? -6#6?qL@8?F?ķ@@@,@*????@tj@5?|@tj@$@tj@# @tj@&@tj@1u@tj@0@)@)-V@)@))^@)@)A@)@),zw@)@)l/{J@)@) I^@74m8@7U=@4S@4ԁoh@4ttj@4WlC@3&@3~($@3&@3H˒:@3&@3-V?3a=?P񰦍?hΌF?H} y??;K.?E?tMP?'_#? m -?h`i?%?ԫ?{f?MA8?tKc?*WF?bM_x? -?['?9~F? xV?L "?bMky?8 T?nwg?~\?h?h@@@@@,@*??????PR? ?4j ?&9 (@F@Xp?Cèz?5߂t?~-F>?cd(co@s 5g@@4bM@4zG@4bM@4$%2@4bM@4$?@4bM@4|h@4bM@4@4bM@4=K@I(@I5?|@I(@ID@I(@Iu@I(@Iv@I(@I*1@I(@IPI@7~($@7ݗ,@2 ě@2wy @17Kƨ@1U=@0𖻘@0=b@0𖻘@0zxl"h@0𖻘@0Y|?Ol? /??뤽??ZAj?8J&7? ?u(?aB#Gi?mqa?A?EBl??~?|aQ?*|\/?6?`i=@@@@@(@(???????` f?QZʜ?A#t@4j`@I{?p_s?bl?嫏7?z@gk,@@W7K@W7K@W7K@W4m@W7K@W}!.J@W7K@WzG@W7K@W{"`@W7K@WzQ@ 6E@ 6+ @ 6E@ <@ 6E@ :^5?|@ 6E@ ;Q@ 6E@ 8@ 6E@ 7$tS@5(YJ@5(*@3E?|h@3D3@3)"`@3*qiC@20U2a|@2@20U2a|@24m@20U2a|@2eO?| ?q' -B?w4f?o]އ&?<?U?avf?Λ?>5Ptv@t/NB@@?|@@?|@Dcwb@?|@1lFp@?|@em(@?|@:a2@?|@;TB@K9XbN@K6E@K9XbN@KB|@K9XbN@KY@K9XbN@K"@K9XbN@KP/9@K9XbN@K\yO@7#g l@7srh@3@3t@3t@2&'V@20U2a|@2N"j @20U2a|@2֝@20U2a|@2WPbK?|B &?A?C}?!Vk?e?|**??t?xœ?ĉ?r_? *?u?+?Lwy?F:>^?Ug?B?I'@@,@,@*@9@:???????H?o?ra`?@!jb@K[ |?R6[?== @ Q-@2+@gn~@@\(@ӶE@\(@J@\(@ڹZ@\(@ֽp @\(@r @\(@Љ'R@ ^5?@ C@ ^5?@w@ ^5?@ ^5?@ ^5?@ (@ ^5?@/@ ^5?@wkQ@7@@7Y|@4ٺ^5?}@4|Q@4A7K@4O M@4:S@4#w@4:S@4䎊r@4:S@4Ft?:-%?UW?hb?:-?S2̍? $Μ$?3a=?.+?\K\?b̤?&5 -M?Zg?nwf?&!+?XTo?wb?^_r?$3@@@@@*@$??????U#?m:o?p d$u?Iy@&c@cKM?}Qb=?pNK??TB@ltq@@p%@o|h@p%@pS@p%@pS@p%@p7K@p%@pn.@p%@p}V@$]-V@$`A7L@$]-V@$[lD@$]-V@$_vȴ@$]-V@$]E@$]-V@$^ߤ?@$]-V@$a [@7G>6z@7Doh@2E?|h@2Eu@1`A7L@1Xy=@1:,<@1;"`B@1:,<@19"`@1:,<@1:#9?{?&+B@@@@@,@,?????? ǪF~?Cڳ;?c1!ۙ@ٟ0@y ~_X?bS#?tK?ÚI?Dd@eo@@tj@vȴ@tj@s@tj@s@tj@4֡@tj@Ϫ͟@tj@Fs@nP@"`@nP@=H@nP@?Wp@{ @fvn@@WlC@WlC@WlC@W˒:@WlC@Wr @WlC@W@WlC@Ws@WlC@WL/{@rQ@rQ@rQ@rQ@rQ@rRnP@rQ@rR@rQ@rR@rQ@rR{@/ߤ@/ߤ@)MV@)M(@'1&x@'@'`d@'`d@'`d@'`d@'`d@'SMk?^Q5P?ƿ57?N?8v?tKc?*WF?bM_x? ,C?|,!?/Z?%y*=?M\ٓ@?bMky? ?oܧ?͓E'?O|q?#.@@@@@,@*??????QhU>?#6b?3{~*|?5; \@WKHw@rR:?C} V?!<(?'{?:T9Ot@sM9 @@&x@&x@&x@ ě@&x@&x@&x@ -=@&x@ M@&x@@$Ov_@$@3~($@3~$@.`A7K@.?@,&x@,@+b~@+y=d@+b~@++@+b~@+YJ?}ѿ,? ?!!׋7?˅T?6r In?$?|O?f?~Q?; $?IM?PS2K?s@a??y8$?͓E'??l&@@@@@(@*??????8 p?'3Y? e0L?i@`F@Q@$=nH?< r?97?B6 nK?@Yx<@g&Q@@@tj@@ @@A@@l=W@@-$@@\fȗ@9~#@9R@9~#@9>I@9~#@9*0U2@9~#@9?O@9~#@9 @9~#@92X@47@@47=@F@0f+ J@0fe״.@/n@/#?@.p'RU@.p칗"@.p'RU@.s˃Ú@.p'RU@.s,?}@TΥ?o -W¤?@?LdTO?GBx?ݐ{?}@TΥ?hjS?S`?0r?t]r?gT@0n5?|@0J#9@0-@0($ x@0~($ @0p{@0~($ .NC,@0~($ .NC,@8 -Ny?^S2{?U?;w~4@8I@8@82r?}y?6k?M#@8S@8@8L?"{Ę?M?*vZ@8 @8 @@@???@-V@,C@-V@..3@-V@.1@-V@-O;d@-V@+:)@-V.@Q@T@Q@@Q@IS@Q@ں@Q@w@Q.@6_o@6@2S@2ߤ@@2PA7K@2O @1@1qj@1@1ߤ@1.NC,?}ѿ,??ցC ?BI{?Uyu#?o?P@8?}ѿ,?V"y$R?K54;?QĨ?h@8?yjk?lo>?hE?(Q?A0)n@8 @@@@@,?????@Ƨ@Ƨ@Ƨ@qu@Ƨ@Vϫ@Ƨ@qu@Ƨ@Ƨ@Ƨ@C,@F@+ @F@l"h -@F@s@F@l"h -@F@@F@"@4qiC@4^5?|@0S@0xl"h -@0Htj@0G8}H@/QN;6@/OAt@/QN;6@/N!R=@/QN;6@/M\?}ѿ,? KG?5$?菁k?u?)]\?}ѿ,?@׮?T֩E?,?!U?{?e\p?q6tN6?Q?qn?˴C?v> ?Cns@@@@@$@*??????ý?E6I?+_6w?@6 -^5?|.Mm@5ߝ-V.Qn@5䎊r.NC,@5䎊r.NC,@5䎊r.NC,?qv@8#@8:@8 >+@8I@8?A[F@8@8i@8@8S@8?d3>@8 *@8p@8@8 @8 @?@.O@"`B@.O@(eO@.O@4m@.O@ @.O@qu!@.O@Ϫ@%Õ%@%@%Õ%@%$/@%Õ%@%ɺ^5?@%Õ%@%iC@%Õ%@%a@@%Õ%@%/V@8įO M@8,<@4I^5?@4ѷX@3"`@3o@3!:S@3ߤ?@3!:S@3 ҉@3!:S@3 >? Z ?-56+?ay?E>? M%?Ylp?NIɮ?u9?G?8k -7H? ?.W旓?yWRqf?&Z#?eI6?DάR?_?9)N-@@@@@,@,??????`~g?q?I"{m?p"/p@ -@%WO?cz[?>4.?D,?-o @m.@@+@XbN@+@^5?}@+@ٳ|@+@1@+@@+@73@nKƧ@nKƧ@nKƧ@nL1&@nKƧ@nKC@nKƧ@nLcA @nKƧ@nLzxl@nKƧ@nL_@2qiC@2~"@-{"`A@-{W>6z@,|1&@,|Z@+Bu%F -@+Bh ԕ@+Bu%F -@+Bѷ@+Bu%F -@+B`A?_\p)?GA?"?XQ>?Ot?ˡK?bM_x? ,C?~Q?9~F?%y*=?M\ٓ@?cPQ?.+?y8$?ʬv??f_Ԋ@@@@@*@(??????MMv?I}?9nQv? z2q@A2C@nLS?Hs8?B[MkN?P:L?)̬w r@s p@@ɺ^5?@[S@ɺ^5?@ŋq @ɺ^5?@A@ɺ^5?@ň1&y@ɺ^5?@-@ɺ^5?@ѷ@ I^@o@ I^@XPH@ I^@fx@ I^@;5X@ I^@Z^5?}@ I^@nMj@9,<@9K]c@4E?|h@4#@3ȓtj@3)^@20U2a|@2*1@20U2a|@2$t@20U2a|@2s?]?97?$כ?U oi?oD?sY(?]?.?P#Gӗ?!=?^o i?y~3Y?*wjs? F2?1?⇦?X^2If=?Eݑz6??@@@@,@*???????`1`?>@?ʹ\?}_@щ)@\W?eа?*nR?;XA?dD%@uF{@@~vȴ9@$/@~vȴ9@PbM@~vȴ9@y|@~vȴ9@tS@~vȴ9@r Ĝ@~vȴ9@mhr@E@7Kƨ@E@ >B@E@\(@E@}V@E@A@E@@8Q|Q@8 bM@4R I^5@4Rl@3;Ƨ@34Z@2m8@2h ԕ@2m8@2@2m8@2C,?fi?Vjn?LD?D??5ŋ?G`O_?S`c?f?MN? E!?Dfv=? ԩ?rX?٤?w^2&?xS?**Z@@@@@"@*??????[@M@?d?rwJn@wH@AgQ$?r۲>*.?Wd?YEn/?5p@(\@)O^Ux@(\@(BH@_;dZ@_;dZ@_;dZ@as@_;dZ@aS*P@_;dZ@b;@_;dZ@`u@_;dZ@c)f@3s@3 t#*@0?|h@0ș-@/n@/:p@.PH@.@.PH@.~5@.PH@.lc?~Ov_ح?z ?/S}]?Zk8?d25??|h2:? ;a?+G?Z3^:@)׻@`?LT?8񚨝?ti^?|p@gτ@@ Ƨ@U@ Ƨ@F]c@ Ƨ@3@ Ƨ@ q @ Ƨ@"@ Ƨ.@w@n@w@|h@w@oi@w@33333@w@?@w.@3g l@3--@0B ě@/]cA@/dZ@.[u%@.@-hr Ĝ@.@- n@..NC,?|B &?bl$I?T[?E>? q&@8?}@TΥ?أ?'O?20& ?qJ@8?Q3?Cy^?MM.?q*?4|;@8 @@@@@,?????@PXbN@P@PXbN@Q L_@PXbN@Q @PXbN@Q?U=@PXbN@Q%u@PXbN@Qm\@ -8Q@ -9Y@ -8Q@ -B@ -8Q@ H@ -8Q@ -@ -8Q@ -%@ -8Q@ -&A@54m8@5X@1r Ĝ@1H˒@1$j~@1\(@0xF^@0\@0xF^@0$/@0xF^@0҂@5?Qp?{V ]?zNa ?d]Q?$"? % -?|B &?^?-5U?| 5r4?w??;{c?Ne|?6?]mZR?ԿX?J6Л?^_r@@@@@,@,???????-a>p ?qJ{{B?bmmd*@Q!B~ @ -1p,|? ӕ?v]t?pwe? D@^s@@Zv@H\@Zv@e@Zv@X75@Zv@Z(@Zv@Qu@Zv@YrGE9@j~@Ƨ@j~@-V@j~@`B@j~@cA @j~@@j~@tj@9 ]ce@9,쿱\@4f+ J@4_v_ح@37KƧ@3 k@2YJ@2ܬ1&@2YJ@2w1@2YJ@2cA!?:-%?D ?{Xn |?nii)?Xs~?`1`?1$@an;@?R2K0?XA6:4?SJD? `G+L@gCm@@>B I^@>DU@>B I^@>A@>B I^@>Aaf@>B I^@>>BZd@>B I^@>B I^@>=H@, I^@+j~@, I^@,n@, I^@,e@, I^@,'RTa@, I^@,- @, I^@, @7S&@7s@3R I^5@3Q-@2-@2Xy=ـ@1,<@1,<@1,<@1~($ @1,<@1=b??Mj̑?]P?g(6?j?"X?}ѿ,?;N?>?aYZq?e?]˙$>?am ?Ov_ح??Yʒ?їJ?@@@@@,@(??????Tu!?Tz?B171? @>>o9@,A6?\Nvp?Cl9BZ@޳3333@ޮ}Vl@޳3333@޳@޳3333@A@޳3333@,<@7 xF@7]|@33S@37+@2Z~"@2]hr!@1ޫ6z@1@1ޫ6z@1\)@1ޫ6z@1L_?W?nx?)?>\?l?.Kn?y+PYu?D?La?I?ni" ?R? a?ڞQa?.?7#!xv?0 ~?|)-}(?;m7.@@@@@*@(??????e8Q6?f - ?2?[*Tq@5_@DI?QeT?z -? ?eb@@h^dJ@@ ě@Z@ ě@N;6@ ě@氾 *@ ě@|@ ě@hی@ ě@\(@K=p@KKC@K=p@KU<@K=p@KW@K=p@Kp@K=p@K6z@K=p@K]c@7w@@7.ߤ?@1!hr @1 u!@0-V@0&x@/N;6@/nO@/N;6@/nO@/N;6@/o?5}'?Čۨ1A?\H{gX?̒?'ř ?<_?5}'?r/B?c#$?6)}?Jj?Q\?C)?H?d --?8 ^?<71? Ğ@@@@@,@,???????0s?rg@?R&Pp?tQTb@ @K8i?cUW~??nh?+ >@S8X@qJj@@aG{@a7K@aG{@a@aG{@bZc @aG{@b@@aG{@`4m@aG{@`4m@噙@"@噙@Y@噙@kP@噙@嚟v@噙@u%F@噙@1@/KC\@/KC\@(a7Kƨ@(a|Q@(;dZ@(;dZ@'#Z@'#Z@'#Z@'#Z@'#Z@'#Z?_\p)?Čۨ1A?!!׋7?8v?@ A2?$?bV,?%F?ԕ]I?-I`K?%y*=?L "?b@? ?oܧ?avh?#.?#.@@@@@,@,??????QA- x?6/q ?O+7 @a#@G+?EUt_?,DÔ?_n?RHH<@s@@ S@ |h@ S.@ S.@ S.@ S.@ S.@^5?}@ -=p@^5?}.@^5?}.@^5?}.@^5?}.@^5?}.@6w@@6f!.I@2{ I^.Mm@1Ͳ-V.Qn@1_o .NC,@1_o .NC,@1_o .NC,?]@8#@8:@8 >+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??@(@Lo@(@@(@>@(@7@(@,F@(@8@A@A-V@A@A9l@A@A~@A@Amp@A@A.@A@AԹv@6YJ@6Ӥ@2?|h@2U2a|@2"-V@2*m@1p@1v<&C@1p@1v0@1p@1wTx?E[i)?H?mX!%?$8?(a?[o?|h2:??eƟ?X*_?Ee_?E?~P[]?(?{ї5?s6?w/xv?@@&@&@&@4@2???????[ϦN]H?B۱=?G_i@ @AY~D?ak/?hYK?9~f?F2@g&8t@@&ffff@&x@&ffff@!@&ffff@* @&ffff@'K]@&ffff@'/W@&ffff@#\@:^5?}@;lD@:^5?}@2 Ĝ@:^5?}@5sg@:^5?}@;6@:^5?}@4O @:^5?}@4[@6>6z@6>6z@3@ ě@3=8Y@3 "`B@3fffff@2\Q@2ZQ`@2\Q@2YJE@2\Q@2X˒:*? ?DE?f?˅T??oW? d?sD?eB^t? }>_?agf ?GO˺?.?eI5?Ф?bR?1R?x?t@@@@@,@(??????*RX7t?82?F9\c@&%?@9>?Y:\?e):?4>?ȑRTt@iJw?S@@٦x@٣VvL@٦x.@٦x.@٦x.@٦x.@٦x.@Xtj@Xtj@Xtj.@Xtj.@Xtj.@Xtj.@Xtj.@6zqiC@6{(}qv@2{ I^.Mm@1`A7.Qn@1Tm8.NC,@1Tm8.NC,@1Tm8.NC,?| V@8#@8:@8 >+@8I@8?nO<@8@8i@8@8S@8?&z7 @8 *@8p@8@8 @8 @?@Ao@Ap@Ao@A0#Y@Ao@A˝b@Ao@A^Ś@Ao@AZ@Ao@Aύ/@ʎV@ʎV@ʎV@ʍ؆8@ʎV@ʍNGcX@ʎV@ʎ業@ʎV@ʋliQ@ʎV@ʌ5R@1T xF@1T!-w2@,-@,A@,DZ1@,E:w)@+̲@+`X@+̲@+N@+̲@+ʥ?^m d?'?7%Y?0of?6Q?Əi?bMn? X7?|~o?C? -˗@s6@@bM@+@bM@kō4@bM@J@bM@2Y@bM@ y'@bM@ ۇ@'-@',@'-@(ʕ@'-@( ԕ@'-@(; @'-@(I"3@'-@'۱l@5mv@5mv @0S@0;L@0A7K@06g?@.u%F -@.]2X@.u%F -@.IQ@.u%F -@.Q-l?}x?<'_? -V @g!@(m&?\ڀ֧?*ߠQ&^?ń?aa@ga5m.@@!@#n@!@"\(@!@" @!@"M@!@"Zc @!@!af@sE@s3333@sE@w$tS@sE@tFs@sE@wKƧ@sE@t9Xb@sE@sݗ*@5@5U=@2B ě@2B&IQ@1Z~"@1Z1'@0𖻘@0䎊r@0𖻘@06@0𖻘@0'RT?|O?/)s?#}i?Fq/b?'ř ?_Oo? ?uie?36G?Nw]6?M?`@0k??Rii?~/O?ۮetZ?L?P\@@@@@$@*??????2T,P?4, B`?(,/#?<7Ȥ@"v -@t,9?0*y?\g?iCt`?®h@g/<@@7.@7.@7.@7.@7.@7.@vDT.@vDT.@vDT.@vDT.@vDT.@vDT.@8쿱[X.>@4+.Mm@4;Ƨ.Qn@3xF^.NC,@3xF^.NC,@3xF^.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @ Q@ l@ Q@ 3@ Q@ G{@ Q@ @ Q@ ĝ@ Q@ c @Q@;dZ@Q@s@Q@ݗ@Q@j~@Q@1@Q@y -@8Y*0U2b@8Vaf@3TS@3WrG@2j~@2 '@1_o @1n@1_o @1Mj@1_o @1!-w1?+-/?LS{?d3"7?J?l!-w?Q,Ě?UbB2?ଚw?s?{d?4{?ey?zk 3U?Cx}x%?ZAj?vI?^^ω?zy@@@@@*@(??????vHTy?@N;?epR0@ @O0n?W%gi?B@10U2a|@1!2W?|O?ASU?'{~?Ғkŀ?3kse?_J?}ѿ,?%L?fTEk?J?Rj ? ޅ;?8*?L?&-\a?Y?Gam?0xh@@@@@*@,??????@?h`?IY8?2џG@3U@JI -c? ?~|xr@?;"V?!0{2@X.&@@X=p@X=p@X=p@XC@X=p@Xn@X=p@XP}@X=p@X@X=p@X\@tj@tj@tj@tj@tj@PH@tj@#x@tj@ k@tj@ k@0cg l@0cg l@*{"`A@*{s@*nO@*ᰊ@)@)@)@)@)@)حW?^Q5P?`?U#?eU!?tKc?/]?bM_x?>`?j?; $?%y*=?M\ٓ@?bMky?8 T?u@>N ?͓E'?a+?O|q@@@@@*@&??????Qk6ZH?34?$>mU:@@X1q@q?BIk?!t?~?i@s -Sc@@ \)@ ␷G@ \)@ 8է@ \)@ (r@ \)@ wf@ \)@ YKuj@ \)@ pB,@ mhr@ o`7@ mhr@ jJ-N@ mhr@ aӮ:@ mhr@ ns6@ mhr@ geu @ mhr@ gk݆@6*0U2b@6`: n@40ěT@434k@3tj@3&Hh@3?䎊r@3C[X@3?䎊r@3B7e@3?䎊r@3B!{T?ڡG7=?d~?~k??'$S?x?I3$?_<4?Y:?ט5?I&?Vk%e/?J9A?e\?Rꊇ@@,@(@*@6@9??????A K\?>RUwU?0Z–k@ $@ lbϧx?^f?PMQ?ʁp?m{k@g M@@I6E@I6ȴ9X@I6E@I:Q@I6E@I8y=@I6E@I9+@I6E@I0*1@I6E@I3g @Z@Z@Z@PH@Z@E85@Z@zxl#@Z@n@Z@YJ@3 xF@3!-w2@0Y^5?|@0Vl!.@/;dZ@/ᰉ(@.N;6@.@.N;6@.@.N;6@. -L/?| ?PƧ$?BI{?b?Փz?K&?| ?-',?tP*???sB?9x]e?n88?{Muk@I5mH@+?h 5ɯ?'?ST)Jh?6l{5@e&_ף@@;?x}?a,F??G'?|nӿ?"r?3B@@@@@$@*???????ZOxS ?S'?Ea@@0_o @0v@0_o @0vȴ9X@0_o @0\N@3S.Mm@2n".Qn@1&.NC,@1&.NC,@1&.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @)x.@)x@ֿJpS+@)x@<@)x@ֹ6@)x@ֶ.@)x@ֺIG@/.@/@7@/@<:@/@5E@/@uJp@/@vg^@7D.>@2c@+7@2'KƧ@+%@1䎊r@*q@1䎊r@*|?=Ca?{a?{ -W?]O?V @?tO?ļ:P`?"Q~@ch@@^N+@^N+@^N+@^QL@^N+@^O~}@^N+@^Q'} @^N+@^[6@^N+@^Sk@77Kƨ@77Kƨ@77Kƨ@7{?n@77Kƨ@7|@77Kƨ@7uO8F@77Kƨ@7k%S1@77Kƨ@7j]@1_o@1N;6@0 hr@0Qn@/?;dZ@/3p1@.b~@.K7@.b~@. 3?9G@.b~@. xD?^6P?(bʟ$?wQZ?7??{O?K bT?bMn?&Y-(??6 BY? w_?͙e?c>)?3K_n ?#F?v>?P?~@.@@&@"@ @6@5???????VGfOF?e5: ?GP+]@^T{@7o[j-?tҢcZ?U'{?Q9?͓@r)U)@@|g-@|h9X@|g-@|h@|g-@|i@|g-@|h˒:@|g-@|gݗ@|g-@|gz@$@v@$@D@$@8YK@$@E@$@L_@$@2a|@4v@4jOw@0S@0E@0"-V@0" @.@/-w1@.@/@N@.@/Zc?1j?W[?jhq9?:Z2b?Dj?aX?}ѿ,?'`?tJ?@[*^? f?ٶm?y8#?Ф?]?$H?L?_խW@@@@@&@(??????+)f=??x{@|hC0}@@?1 B.?2Ge -$?mj)K?p°qRs@gV/p@@š.@š@KƧ@š@$@š@}H@š@@š@_@S.@S@+@S@L/@S@@S@Q^@S@~@9䎊.>@6 ě@6S&@6'KƧ@6hy=c@5Q@5GE85@5Q@5l?@5Q@5lL_@8J?l?A|?(ޞs?b&?ғa@8J?R܆?u:?Po?hA?шo٭@8p?­?Uj? V|L?\T?r@@@@,@*?????@zx.@zx@{M$ @zx@{j'@zx@{ F@zx@zi7@zx@ziq@x.@x@ԂOm@x@Yz @x@2v@x@%2G#@x@ -O}|]@9g l.>@4ahr @4 @3;Ƨ@3$@2J0U2a|@2+%@@2J0U2a|@2 -n@2J0U2a|@2 `.@8J? Q"0?.%?ˋUO??Kf/? ѣ@8J?ӯ?ObN? -/ -?`jNn?Q\@8p?tl* ?)o?\)?.?u@"@@$@:@7?????@r Ĝ@r@r Ĝ@rs@r Ĝ@s3333@r Ĝ@sMj@r Ĝ@r-V@r Ĝ@r:)z@;dZ@;dZ@;dZ@@;dZ@:~@;dZ@bM@;dZ@ -=@;dZ@H@/o@/o@)j~"@)j~"@*rnO@*rp:@(ۋq @(ۋq @(ۋq @(ۋq @(ۋq @(?_\p)?{j?(?8v?Ot??bM_x?%F?A)N?0N:s?ѡb??R g!ڢ?b@? ?q6tN7?avh?Ѐ>(?O|q@@@@@(@*??????D+?+)T?sk]@rL @n8?:h?*F_?qvLd?O$@s,2@@]/@Qn@]/@H@]/@=cA@]/@SMj@]/@YXbN@]/@L1&@ȴ9X@1&y@ȴ9X@Ӝ@ȴ9X@U=@ȴ9X@tj@ȴ9X@e+@ȴ9X@֡a@8YJ@8kP@5; I^@5:fB@5 "`B@53{J#9@4OO M@4^ߤ?@4OO M@4P$tT@4OO M@4RT`d?YgoK?hX*?TH? ?U ,?+ w? Z ?%!{A?Ēۇ?߈{?As?L?RWP?5.?_YK?(?CRU?[ё@@@@@*@,??????C4q1r?j0\?rbPbQ@Ty@?wy35t?󂂷_?˧"?@qd|@@ և+ @ ȴ9X@ և+ .@ և+ .@ և+ .@ և+ .@ և+ .@j~@ I@j~.@j~.@j~.@j~.@j~.@8:@8ȴ9X@4n5?|.Mm@3KƧ.Qn@2!.I.NC,@2!.I.NC,@2!.I.NC,?}ѿ,@8#@8:@8 >+@8I@8?{QB@8@8i@8@8S@8?@8 *@8p@8@8 @8 @?@hr.@hr@"!@hr@2@hr@>@hr@k@hr@GC\@91&y.@91&y@9 -M@91&y@9b}@91&y@9>Z@91&y@93M@91&y@9@8YJ.>@3 I^@3GP@3R`A@39N@2Tm8@2FBI@2Tm8@2[4D@2Tm8@2\!-x@8J?KQt -?9e5?*F?'c$x?+@8J?uk?{?i?E*z?@8p?`K?0|wF?yk?R HE?[s@&@&@(@8@7?????@7(@7O;@7(.@7(.@7(.@7(.@7(.@nj~#@n_;dZ@nj~#.@nj~#.@nj~#.@nj~#.@nj~#.@7*0U2b@7#@3I^5?.Mm@3v-.Qn@2!.I.NC,@2!.I.NC,@2!.I.NC,?]@8#@8:@8 >+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??@.@@@6@@-w1@@irF@@eS&@@b7@DT.@DT@@N@DT@3@DT@"`@DT@H@DT@|64@9p4m8.>@4|hr@3!.H@4'KƧ@3E@3Eu@2bM@3Eu@2䎊r@3Eu@2~O<@8J?j#?IM\g-?T?&eS?|@8J?%xW8??=q?z?Mc2h@8p???Z`(?@j-?GX?P^eNQ@@@@,@*?????@^qm@^r@^qm@^q @^qm@^rS&@^qm@^q_@^qm@^n!R@^qm@^mB@YěT@Y\(@YěT@Yq @YěT@YH@YěT@Y\)@YěT@Y4@YěT@YaA@5*0U2b@5u%F -@1S@1M@0`A7L@0Ɍ~($ @/Xy=@/㯷@/Xy=@/S&@/Xy=@/A [?Y͍_?I'?JC?:Z2b?P?uC0!?5 ?Hz#,@i`C@@-Xtj@-Xtj@-Xtj@-Y_p@-Xtj@-XQ @-Xtj@-Y @-Xtj@-VC@-Xtj@-S|@ffff@$/@ffff@8}@ffff@e@ffff@8X@ffff@+a@ffff@Q@5-v@5-,<@0ԛS@0@0-V@0v@.@.ѷY@.@.v@.@.Y}?| ?m??lDžN9? 9?봤G?|O?4 "?O)AT?agf ?ڂc? R?oܧ?l?ʳ_? ??j?gϵ@@@@@&@(??????CGP0?2X?=s?81@-WƓ@?]VOX?Xj#o?ǐ>F? F -@f10@@kR@e z0@kR.@kR.@kR.@kR.@kR.@&lC@& I@&lC.@&lC.@&lC.@&lC.@&lC.@8@@8!@5kS.Mm@4Vu.Qn@4D*.NC,@4D*.NC,@4D*.NC,?ڡG7<@8#@8:@8 >+@8I@8?π>@8@8i@8@8S@8?/r@8 *@8p@8@8 @8 @?@7K@@7K@($ w@7K@ 7Kƨ@7K@ q @7K@u$@7K@@jE@jE@jE@jO @jE@jIQ@jE@jS@jE@jX@jE@j{J#@3:@35Xy>@2?|h@1 qu@1"@1 @15sh@1,Z@15sh@1-@15sh@1.1?|O?E|s8?y]?_?PU`?uV`?| ?I4>?kE<%?e[|(?6?^̀@!? J?1j?9@0w? ??;WZ?8ϣ@@@@@*@$???????[*?UtPL?D@@j6iD?sDJ?b[`?P-.2"?^iQ@d_@@1'@"@1'@@1'@+j@1'@2W@1'@/V@1'@ce@F@-V@F@E@F@zH@F@넛T@F@델@F@8@6*0U2b@6/{J$@4 ě@4Zc@3j~@3!.H@3a:S@3_4֡a@3a:S@3b<64@3a:S@3bs?|O?u4ޕ?!Gf? HN? ?(ϢU?}?S"ꝉ? ?GW?'bA?~VԪ??WBH? DS?N?aP?&+B?b@@@@@&@*???????MjߢTSC?IA/?R&"@P@Z?jWz\?rt`?$-jC7?۪KLD -@fEmņ@@W+R@W#n@W+R@W*͞@W+R@W/iDg7@W+R@W-8@W+R@W0@W+R@W)@7KƧ@>vȴ9@7KƧ@:)y@7KƧ@'#@7KƧ@=E@7KƧ@8*0@7KƧ@9|@8-v@8-!.H@3+@30 (@2ߝ-V@2ѷ@2p@2m5Xy>@2p@2m@2p@2l64?^*?I\O?2 :M?g(6?7?YD?| ?蠔?ҌI?%)?? j?$?+0T?ٹ?ѳ9?F?cR@@@@@,@&???????__GQ4n?Y#7J3?33uK@W+i1n@;\?sCyA?X0E?ҡWP?P,C@jxD@@mY+@mWO;@mY+@m>@mY+@mG+ J@mY+@mhK]e@mY+@mGz@mY+@mIB@]5?|@]*@]5?|@]tj@]5?|@]q@]5?|@]ᰉ@]5?|@]8@]5?|@]:@74m8@7ѷ@5^5?}@5- @4V@3 @3,<@3@3,<@3"`@3,<@3O;d?qn?ʿnP?拗? ?|p9?ʗAm?}?#O?#*0?%hF? U?SЧ?.\?-?$RHZ?@l?F?aZ@@@@@&@(??????[~\1Bw"?t W?zM@m\];@]iX?-C?@QX@~Q$@fȶI@@ȴ9X.@ȴ9X@Ϫ@ȴ9X@"@ȴ9X@b@ȴ9X@PH@ȴ9X@-@1.@1@+j@1@ -=p@1@64@1@٦ @1@sh@6 xF.>@1+ @1q @1"-V@1#Z@0,<@0oiDg@0,<@0@0,<@0!.I@8J?6 '8?O%c?5d?r?cLb@8J?eB^t?2'?[?P!=4?74l@8p?=!K?sg?]O8?8ϣ?:/ʼn@@@@,@,?????@o/.@o/.@o/.@o/.@o/.@o/.@E.@E.@E.@E.@E.@E.@8B䎊.>@3}hr .Mm@27KƧ.Qn@20U2a|.NC,@20U2a|.NC,@20U2a|.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @F$/@.zI@F$/@R:){@F$/@H$ x@F$/@B3@F$/@>%@F$/@6Ov`@6ȴ9X@'+ I@6ȴ9X@8Q@6ȴ9X@0|@6ȴ9X@12X@6ȴ9X@2nP@6ȴ9X@+C@5O M@5iᰉ(@1+ I@1|@117Kƨ@106@0Eu@0B䎊q@0Eu@0A @0Eu@0=Vl"?qv?1e -?X?}fУ?BPbC?Q,Ě?F/P5?0,3?C\ >?=U1WK?+hd{? a?,?/o?YY?0ڌ#?4hpɄ?$jB@@@@@,@(???????_ޥ?[I ?d`@?P*ڸ@8f@,E w?:JBE!?sj4q?^G?Nhw|J@k9K@@0/@1&$/@0/@0@0/@0@0/@0A@0/@0*@0/.@n@hr"@n@$/@n@^5?}@n@|h@n@!.@n.@1 ]ce@1X@.KƧ@.՛=K@/4E@/873@.@.~$u@.@.F -L0@..NC,?Ol?m0?S?Q@/$tj.Mm@.]E@&$.L@,ߤ@.NC,@,ߤ@.NC,@,ߤ@.NC,@8 -Ny@8#?`m_B@8 >+@8I@8@82r@8?#(v@8@8S@8@8L@8 *?&|@8@8 @8 @6?@G|h@G|h@G|h@G˒:+@G|h@G qv@G|h@G|h@G|h@Gb}@G|h@G;dZ@+R@+Ƨ@+R@+a@+R@+R@+R@+҉@+R@+:)@+R@,"h @0:@0:@(`A7K@(`A7K@'O;dZ@'O;dZ@&PH@&PH@&PH@&&@&PH@&PH?^Q5P?[e>J?$<'ε@Ga<=@+W?q ?`1<@s;@@<$/.@<$/@;ߤ@<$/@;@<$/@;`d@<$/@;C,@<$/@;U2a{@O.@O@ (@O@+`@O@Z@O@՛=@O@յs@3>6z.>@/"@/VϪ@-nP@-֮}Vl@-oi@-ql@-oi@-@[6@-oi@-FA@8J?m0?'?Jʮ?!g7?A+KW@8J?6c?D?_3\? e?c5W@8p?oM?/X??3?Evn@@@@*@,?????@g-@hr @g-.@g-.@g-.@g-.@g-.@'"`@'|h@'"`.@'"`.@'"`.@'"`.@'"`.@8H@8"GE85@4 ě.Mm@3lj~#.Qn@2sh.NC,@2sh.NC,@2sh.NC,?}ѿ,@8#@8:@8 >+@8I@8?q!U@8@8i@8@8S@8?c@8 *@8p@8@8 @8 @?@+@+@+@rGE@+@bM@+@:~@+@B@+@(@;dZ@;lE@;dZ@:>@;dZ@:)@;dZ@:)y@;dZ@:?@;dZ@;@2@2$tS@/8tj@/84֡b@. n@. 4m@-QN;6@-R ě@-QN;6@-RnO@-QN;6@-Ra|R?^Q5P? ?"?G?ǹT?2I/?bV,?&uE@?['?6)}?إ<(?h,à?cPQ?6?W ? ??a+?@@@@@&@*??????RΦ?3fB?AXm?Uc@Ϊ@:d ?Q6I?  ?Z -Ze?9y@s4gK@@e`A7@kC@e`A7@f?@e`A7@dT@e`A7@eO@e`A7@dg8~@e`A7@eS&@ě@Ƨ@ě@TɅ@ě@D@ě@:@ě@d@ě@R=@5O M@5xp:~@1.5?|@1.ѷX@0v-@0v@0?䎊r@0@:~@0?䎊r@0@H@0?䎊r@0@:~?^*?/)s?WD@?#t?u?Id6z@5*1@1S@1:)y@07KƧ@0lC@0c@0US@0c@0T`d@0c@0Tm8?}ѿ,?b}?K9\?Jʮ?'֙:0?Z?}ѿ,?-NI`(??íuA?a6io? bV?2R2'֕?/X??z_?k3`E`-?^':?y\@@@@@,@*??????-?c'"&<?E!Q?NOlr@70^@g?b(Bo?h[?3*r?Q%@bHΑ@@+@+@+@@+@oiDg@+@`A@+@ -=@+@:~@I1'@I1'@I1'@IN<@I1'@Ice@I1'@I\N@I1'@I@I1'@I<64@0e!.@0e?@*\j~"@*["`A@)E@)g m@)b~@)Xf@)b~@)Xf@)b~@)eڻ?_𩫝?GA?K]4? Y?2A?7F?bM_x? -?S?0N:s?ߒh!?h,à?e@'? ?q6tN7?XLL?Ѐ>(?b/bJ@@@@@*@,??????0X?7?\5Q6 -?2BX@@I1?(f:?$^?Lqմ?Bel@sTR@@:@:ȴ9X@:@: xF@:@: -ڹZ@:@:z@:@:`B@:@:ں@-z@-9Xb@-z@-t$@-z@-t@-z@-wO;@-z@-r@-z@-s@8!.@8 @3@30 (@2ȓtj@2j~#@2 [W?@2o@2 [W?@2'R@2 [W?@2䎊?|O?KTD?Mq ?Att?<_+fj?7D -?Cy3?\j?fˌ?ҧ?S?;?[K-$I?HO?}?0?Tj?Q?]@@@@@*@,??????qXp<,)s?Ke38/?bhI@:CGR@-vf?ro!?tToat?f`}^?ֽu@oEۿ@@=p@r @=p@Q@=p@^ @=p@'0@=p@ߤ?@=p@ƍ@5?|@ ě@5?|@2@5?|@ߥ@5?|@;dZ@5?|@!$/@5?|@cB@7DO M@7Eᰉ@4c@4esg@4v-@4}ڹZ@3Tm8@3X ԕ+@3Tm8@3W1@3Tm8@3Y'RTa?us\?ʖSS?:r ?m}9?p?l}?)T?,T?]^߿?L?hY?Y@??Эs_`?%Cr?L??,yfY?**Z@@@@@@??????J5p<0?Vx_p?29o@i~@F~ -?ty@?S .?A@?zl@j6F@@;dZ@|h@;dZ@@;dZ@;dZ@;dZ@vȴ@;dZ@!-w2@;dZ@쿱\@v/@vT@v/@v?@v/@v@v/@v@v/@v+ I@v/@v1@4`D@4`D@0+@0@/E@/fA@.@.vȴ:@.@.!-w1@.@/- ?|O?Z.?*"AaI?lDžN9?E{?6J?1j?#maЀ?d0R?; $?c3c(? f?s@a?Ϸ+?٤?RJ?j?)@Jq@@@@@*@(??????Ƈ?:6x?U?+8<@^h@v1?2K5?L+57?r ?*ZO@g2x+@@c -=q@\1'@c -=q@NV@c -=q@V_ح@c -=q@VOv`@c -=q@\64@c -=q@W&@$E@$dZ@$E@$5X@$E@$C@$E@$=L@$E@$ƚ,=@$E@$@8T xF@8S @3|hr@3~H@2`A7@2/w@1̿[W?@1rH@1̿[W?@1@N@1̿[W?@1?_pP1?L?Ji?Sz?i]i?P?|?=x?Ր?ƨ'?%y*=?CwB?O"?mΝ?DΊ@@@@@*@"??????7F`?j?Xo9R0?oZ @Xւ@$͠0?oxzd ?|T[?αv@ Ie@p;N @@@x@@E@@R<@@4K@@ۥS@@ըXy?@֨r @֬@֨r @֯@֨r @-@֨r @ֹ0 @֨r @֙"@֨r @֙#x@904m8@9FV?>sN?o΃?SDN?FMG?9?͑?#q?x?}Z?a㸂?F?2:U@@@@@,@(??????=@r'&?u,^?aܼ-Y@ڡrJL@֠s:?۾?1 l?Ҏ?h,X@p8:T@@V@9Xc@V@~@V@E@V@2@V@@V@IR@$3E@$.V@$3E@$)y@$3E@$(@$3E@$1hr @$3E@$*L@$3E@$,L_@7D@7|hr@3S@3>B@2A7K@2w1@23&@20 -=q@23&@21u@23&@21iB??B?F}?vk?ҧ?_ ?[Xxp? /ّ?%c~?!zt9?W;zY?m/w+?(d?7y?sD@8@8i@8?(S?H{?@8 *@8p@8??*N@@@???@nO.@nO.@nO.@nO.@nO.@nO.@11&y.@11&y.@11&y.@11&y.@11&y.@11&y.@8֚,<.>@5+ I.Mm@4t.Qn@4._o .NC,@4._o .NC,@4._o .NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @:M.@:M@:h`@:M@:]*@:M@:N*7@:M@:S{G@:M@:Q>9@j~.@j~@LL@j~@n恖@j~@|@j~@:h@j~@fE_@3cg l.>@/.Vt@/-.@.ӶE@.j@-QN;6@-? -!@-QN;6@-BdzF@-QN;6@->:@8J?rW?禛?*&?h ?Mm,bz@8J?h?W ?#~\?.ؗ?܏=@8p?@c MQ?'".@B>"@BDM:@B>"@B?[W@@B>"@B5*2@B>"@B3tj@B>"@B@3ěT@34֡b@3-@3|@3!:S@374m@3!:S@32M@3!:S@32a|Q@8J?'5? 1B?F"b?l(?ݷ@8J? /ّ??6l@0=ce@0p`L^-m?[c?QY@8@ -f?kp ?iD!?\z?B4H@qk]@@klD@kB@klD@kPH@klD@k6@klD@kq@klD@k"@klD@k@ly"@l\(@ly"@lz)@ly"@lx4֠@ly"@lrGE8@ly"@lxl"h -@ly"@lxQ@7YJ@7/y'@3^5?|@3U=@2"`@2>B[@1Q@1vȴ9X@1Q@1!R=@1Q@1 ě?|B &?:?XY?Z!ǟ?.Kn??=?7娠?аl??T ?:u. ?m^?jOI?4f5ׅ?&!+?D/ -b?rsw?W|DC?]ߒ@@@@@,@,???????jNB?LS?[d=@k(@lx1_I?r_}?r[$Q?jL?֦/i@n*3{@ @1m@+Ƨ@1m@/ M@1m@4*@1m@0 -=@1m@1A [@1m@1@>Q@>dZ@>Q@>@>Q@>cA@>Q@>@>Q@>o@>Q@>6@7䎊@7{)^@3\I^5?@3`d8@2i"`@2o;dZ@1,<@2$tT@1,<@2 -=p@1,<@2ᰊ?1j?[ ?p?؆{~?Nty"?uk=?F/P5?K?J?% . ?E?998?&1V?e+?Ile?J@4B ě.Mm@3A7K.Qn@3ush.NC,@3ush.NC,@3ush.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8  @6ȴ9X@8Q@6ȴ9X@*͞@6ȴ9X@ 4m@6ȴ9X@%8X@6ȴ9X@'-@6ȴ9X@6u@~"@T@~"@8V@~"@'#@~"@GfB@~"@>6z@~"@d/@7:@7ce@33S@3 )^@2M-V@2<ߤ@@1Y~($ @1KC,{@1Y~($ @1MK]@1Y~($ @1Nߤ???J f?XՇs_?fJ5 ?Kbo?d?sD?,i?Ľ;!?]$_2.?l?m(~2?D?[ S?[?J?_u? Ğ@@@@@,@(???????7cܰ"Ȁ?i2\ -?q@\)@1"d@kZ?D??jL?#y+b?cg:@iy6@ @jXbN@j*@jXbN@jv@jXbN@jM'@jXbN@j'C@jXbN@jˁ@jXbN@j@9@9v=@9@9@9@9@9@9<]y@9@9O@9@9b@8g l@8Gv@4ahr @4c?rz@3tj@3  z@2O M@2vA@@2O M@2M{@2O M@22?TVm?-Z?^I??۱[V?*Jۓ?=?'a?poؐ?S.&?`?M{3i?#B?6c?[K?⹯{?C9?צm8@@"@"@*@7@3???????6l6(dUU/?A7*0l?2crRc@j@9n8?[K ?O_6 ?B:?`v@m-]G@ @-@O@-.@-.@-.@-.@-@D@ ۥS@ + J@ ۥS.@ ۥS.@ ۥS.@ ۥS.@ ۥS@ _@7:@7C%@3#.Mm@2Ctj~.Qn@1D*.NC,@1D*.NC,@1D*@1d8?ϱQm@8#@8:@8 >+@8I?N5W?@8@8i@8@8S??+k@8 *@8p@8@8 ?SH@@*??@Z@䛥T@Z@@Z@@Z@M:@Z@e@Z@g8~@F@G+ J@F@G@F@Gݗ@F@G@F@Fffff@F@H1&y@3䎊@3.H@1+S@1,L_@07Kƨ@03@0@0XbM@0@0Q @0@0^?|O?j?cvJz?bC?3n'?.]?]f?I?Z@@$@&@,@4@6??????En?4p 9?#???'Ut@ r@nvF?2?6ef"?a:4?f+qto @s "@@\@G{@\.@\.@\.@\.@\.@+ J@C@+ J.@+ J.@+ J.@+ J.@+ J.@7Q|Q@7bGE85@2ěT.Mm@1`A.Qn@1h.NC,@1h.NC,@1h.NC,?]@8#@8:@8 >+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??@M@M I^@M@Mϝ-@M@M4֡@M@M]c@M@M@M@MϪ͠@ 7Kƨ@z@ 7Kƨ@Y@ 7Kƨ@Ov_@ 7Kƨ@Ͳ䎊s@ 7Kƨ@;vȴ9@ 7Kƨ@а{@6#g l@6!n@4c@4QR<6@3;Ƨ@34?@4Tm8@4/;dZ@4Tm8@41_p@4Tm8@4,wkP?|O?5b&?g ?m$.?F?9Ud? ?n4??p:2?0/f?v8' ?d -,?RQF?Vr?P )k?C$\j$?j)@@@@@ @$??????>e?J<]?q;W@MyfK@/h?_\*Kb??`?{m&?6@^_U~@@+.@+@=<64@+@SMj@+@Q@+@sMj@+@ '@ٙ.@ٙ@@ٙ@w@ٙ@kP@ٙ@PH@ٙ@$oi@9g l.>@5I^5?@5#F]c@5`A7L@4Qe@4fYJ@34m@4fYJ@36z@4fYJ@3p:~@8J?;gF?C>S?;?VҾ?8R} -.@8J?$a? gA?Ƅ@l|L?ҨP'?9Y145@8p?/I#?_?ˍ?xb?!zt9@@@@,@(?????@(@E@(@u@(@"M@(@)B@(@쿱\@(@@sDt@s8@sDt@s?@sDt@s@4o@sDt@s6z@8Y*0U2b@8a.H@3W+ I@3U?@2lj~#@2n쿱[W@1,<@1K]d@1,<@1PH@1,<@1Fs?bk0?ĵS_??`x?RJ? Ğ? -t@@@@@&@*??????An\?S{"?%!P<d?<1bc@䚊@ZQ(-?EP }?]b}? .+?n`@g%\"@@V@O@V@˒:@V@j~@V@S@V@r @V@@8:G@8:v@8:G@814K@8:G@812W@8:G@8=,@8:G@85L_@8:G@84Fs@3H@3.2@0E?|h@0<#x@0`A7L@0D@.b~@-]ce@.b~@-6z@.b~@.6?2}?R?+(?ᕮ0?0 碽?5}'?|O?yG?Vh?} ?rrl?НFW?nwf??z_?.SM? 1 D@?/̽`@@@@@,@,??????[iP(B u ?FpQ?Mg -@ @89/?d1Dt ?i,u)?3?o>a@b"J@@I7Kƨ.@I7Kƨ.@I7Kƨ.@I7Kƨ.@I7Kƨ.@I7Kƨ.@/ -=.@/ -=.@/ -=.@/ -=.@/ -=.@/ -=.@6:.>@2hr .Mm@2V.Qn@1䎊r.NC,@1䎊r.NC,@1䎊r.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @x@o@x@E@x@}[@x@O~@x@ش:)@x@_o@tj@@tj@@tj@B@tj@9@tj@?@tj@3=@6I_o@6G1@4 ě@3cb@3]V@3qQd@30@3?}@@30@3:Z@30@3@CHޱ?}#?v?Ca&?C`vg?y?dv?gQ?g'*/?%/ϴ?TMG?h?e?vc0?G?Wy+?I ?oy?pA@@(@(@"@7@7?????? ?qT??q~?i1?Ֆz?26d?l{ :?:?D( ?߷ڙT?&'c?&Z?!?v-?{¢?H???qgu?(6 +@@(@*@$@<@9???????Oj -Bt?wa??ப?wnB@I۰E@lz?\Rj?[}\?),@&%@m-1@@>^Q@>V+ @>^Q@>R@>^Q@>L"h @>^Q@>?b}@>^Q@>\C,z@>^Q@>P{@i$@iu@i$@ix@i$@iIQ@i$@i@i$@i=@i$@i?@7YJ@7*0U2b@2TS@2Rᰊ@1`A7L@1!-w1@1B@5@1:=p -@1B@5@1E$/@1B@5@1<!-w?]?`?gOw?lsC^?di?uV`?]??co?96 ?JL\?e\p?*wjs? -??!B?GZ?I$?@@@@$@"???????t?y{H?: -?HE&33@>SUW@i7?M ]?Q4V@\,?sG 5@up;f@@D@D;dZ@D@DsPo@D@D~<#@D@D@D@Db7@D@DN@|ix@|_ycZy@|ix@|M9@|ix@|m@|ix@|msx@|ix@|kce@|ix@|kR(@8DO M@85-@4i+ @4kiF@3R`A@3VK @2s&@2w>x@2s&@2v@2s&@2w -O)?cГA?3?qJ?k@3 e,@˒m?IZT?[)V7?V,?SuY4@mr*@@Dj~@D`B@Dj~@D$@Dj~@DoiDh@Dj~@DY}@Dj~@D&x@Dj~@D@N1@N%`A6@N1@Ns@N1@N@N1@N@N1@NZ@N1@N64@8>6z@8 "`@3R I^5@3R74@2,j~#@2,cA \@1@1@1@1u%F -@1@1F]c?1j?܄ (?4 b5?{@?<_+fj?[2???xrI?OՃ?@[*^?.<?Q?R[SA?4?(?2? -r?&f@@@@@*@,??????q[S?:}%\3l?[j@DCJ@NԬ?_6/?ut#?۴$Z=?q@l͸@@. O;d@.&x@. O;d@. zxl@. O;d@. -=p@. O;d@. @. O;d@. 1&@. O;d@. :)@i$@i+@i$@i6@i$@i%2@i$@i@i$@i@i$@i+j@7>6z@7+a@1hr @1Ƨ@1 "`B@1fA@.@.Z@.@..H@.@."?q!U?:L -?:?j6_??F0?2}?-NI`(?S?Җhn?إ<(?+d?^'?H?sg?!ˠ*(? -t??\@@@@@$@,??????P%?Q-{?1??6/Y7@. s@i<?JI: ?Z&"1 ?u*@2Ͳ-V@2V@2~($ @2#(r8@2~($ @2(fM@2~($ @2$ƿ6?,r?d?7m-J?N*?#Զ}_=? kR?x/0 ?Њ?q(.W?'?#)X;?UCJL?b|&?e!?Du?(A? -e?S@@*@$@&@7@8??????o\?[(I?\;XL(?Xbe@W@?|+T~?!?u_F/?ynֿ?ᒻg#t@kAci@@ I^@ I^@ I^@U=@ I^@ě@ I^@üZ@ I^@@ I^@b@a$/@a I^@a$/@aA \@a$/@aM@a$/@an.@a$/@an.@a$/@aC-@5@5䎊r@2° ě@24m8@2 -V@2 )^ @1@1 @1@1 -=p@1@1TɆ?Ol? ?e -!C?Uyu#?GBm?U@5 I^@53@5Z~"@5dd~@5:,<@5;V+:@5:,<@5@-S@5:,<@5=?wvHf? -?"R?ȭ?h?zF?-V4?O}e?,d@e&i`O@!@3333@M@3333@Q2W@3333@-w1@3333@"h @3333@7Xe@3333@3333@|R@{`A@|R@|@|R@| O;d@|R@{XbN@|R@|ڹ@|R@|Bѷ@8G>6z@7+ I^@5@4Nc @4"`@3GE85@4Q@3a-@4Q@3_ @4Q@3[~%?F^S?t?UA?%?„ ? RAQ?%?^?%?7&c?6P?߱Z?*?ڱP?Fg*V3?1,j?~?]B0?CRU?/̽`@@@@@ @&??????i@?@?Wf>h?^==QV@Cx@{W&?so0?(O-hh?ђ?4P @b]|9@"@-hr@-@-hr@.Mj@-hr@.zH@-hr@,[V@-hr@+]c@-hr@+R@ϕ$@ϖu@ϕ$@ϖȴ9Y@ϕ$@ϗ>6z@ϕ$@ϔ3@ϕ$@ϔ9Xc@ϕ$@ϗsP@3@@3@@2!hr @2!@1KƧ@14m@1\Q@1\[W?@1\Q@1\j~#@1\Q@1\ߤ@?1j?ߋb?l>?,Z?j?_ ?| ?La?h?!zt9?=W?C ;?/Y}?򯞼?T?ij6?L8AS?Y͍_@@@@@(@*??????@0 T?s@(?5Q[v|@, Ũ@ϕwů?3[F"3a?U?'?rTrb z?5D@fNk@#@bv@b"`@bv@b)^@bv@bZ@bv@b @bv@bv}Vl@bv@c ~)@M@ I^@M@Q@M@@M@ڹ@M@hr!@M@iB@7 D@7 - r@3^5?}@3+Q@1Vu@2 Y|@1xF^@1j~#@1xF^@1A7K@1xF^@2zxl"h?% ?L -xNC??=?5"?ZF,U?us\?|-J?cu%+??Xxe?Ŷ'?=Ca?I1;?ZaQ?k,?S1z?G?jx?yC?n=?%_D?/Y}?RJ?oC?*Z}@@@@@(@*??????Zt$?Q3?44B?^f0@y@Wv?QuI$?ryF?%Lw$?ڢ|!@o@'@ah\@aix@ah\@ah@ah\@an;5@ah\@ai*0U2@ah\@ai7Kƨ@ah\@aen@mV@lC@mV@il@mV@fx@mV@l/{J@mV@n@mV@nc @64m8@6O M@3hr@3Vl!@3tj@3˒:*@26z@2K]@26z@2<64@26z@2U=?]?4Kl?e -!C?H?4w??]?=}?低NU?ǧ?D6??f1-&?*wjs?H?~}o_?bv{3dZ?`i=?GZ?@@@@,@(??????Vwq?P,sPq?B/%?:no'b@ag(@mJ?R8N ?͓E'?Ѐ>(?f_Ԋ@@@@@,@*??????A (?':eN?!F @vp@$Q?6?06X0d?iE\?V*<@s j8 .@)@t@+@t@%F -@t@;5@t@ƀIR@t@- @t@d@/z^5?}@/|j~@/z^5?}@/s@N@/z^5?}@/dS@/z^5?}@/{~@/z^5?}@/g#@/z^5?}@/z)@7@@7sg@53S@5/U=@4`A7@4RT`e@4 [W?@4JL@4 [W?@4PH@4 [W?@4 '/?Ol?̂?6KX??p/?c:e??. -?B?j3(? -s? '?6ז?W<ܾo?y\?jv ?t#$ ?Nty"@@@@@,@(??????d˦T~Ÿ?M -s7?cX@S @/xI8?p=?:8??`l@j6w@*@kƧ@kR@kƧ@kU@kƧ@kU=@kƧ@kx'@kƧ@k҇@kƧ@kv@^cS@^cS@^cS@^bTg@^cS@^ba@@^cS@^bf@^cS@^cTvw@^cS@^e|*@3䎊@30@/\j~"@/]t`@-nO@-̱Q@,@,.@,@,<0G@,@, 1?|b@?ר4?"(#*m?O*je?-??|h2:?R?J:?9~F?ڥW?JU4?pDRg?z+?xuhy?ST)FS?Үc?H@@*@(@*@3@,???????l?"`?|$H?}c[.@k@^cё?9Yi?8o}?$f?X*@f>E@+@`B.@`B.@`B.@`B.@`B.@`B.@bM.@bM.@bM.@bM.@bM.@bM.@4䎊.>@2TS.Mm@1ȓtj.Qn@1a:S.NC,@1a:S.NC,@1a:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 ,@wn@ -G4@J!kX?mˉ?j;1?QeSz?޻@d@/@C%@,@C%@jL/@C%@Iԕ,@C%@\PH@C%@]@C%.@/@;dZ@/@j~@/@p;@/@WX@/@Q4K@/.@9>6z@9#33333@6 ě@5߃{J#:@5tj~@5"M@4iB@4Ďqj@4iB@4R@4iB.NC,?|O?Lx5BL? -?lE ]?ÛҮU@8?µ'&?vj?R?F͵sS?֎yP?ݔJ {@8?T# ?W$B?j?K?116@8 @@@@@,?????0@1&@0 -T@1&@I:@1&@R<6@1&@@1&@^uƖ@1&@]@KƧ@ d@KƧ@@KƧ@鳋@O@KƧ@H.c@KƧ@Ҡ1@KƧ@ܟ@7]ce@7@3f+ J@3li.p@2A7K@2By@2@5@1).@2@5@1M{@2@5@1pK?ؗ?we ?b|S?u)Pnf?!=?臫?ڡG7?%d?%d@@@@@(@(???????A~8?L(T ?0y/L?D}_*@pڧ@/=?NM?A?b35?un'2?7%@ -Z@dF:g@2@+R@{#@+R@&8X@+R@')n@+R@%@+R@ -̯Q@+R@$[@vȴ9X@;?F|@vȴ9X@y▄@vȴ9X@~;@vȴ9X@xiag@vȴ9X@o@vȴ9X@n~y@8H@7/>m@3W+ I@3S<@2"`@2Fj@2h@2_Jrz@2h@2Wlg@2h@2^K?F?E `?ZZ/?M2?˄Ve*?hSG?8c?f?:s -?+< ?}]?pDD?4<?w?:[?Ӄ?AVq[?EH ~ -@@(@*@,@8@6??????ywfz@]S?v:?p5:@?Κ@s!_'?=CIJ??VjT8?ۢ+@r,W@3@?|@?|@?|@fA@?|@2X@?|@ k@?|@jO@?|@ߤ@@c@cS@c@clC@c@c$/@c@c -=q@c@cC-@c@c [@4 xF@4wl@05?|@0 (@06-@09k~(@/Vl"@/:T@/Vl"@/|@/Vl"@/F]d? ?j‚?WD@?U=K?>{~?ZzZ? ?ā?8G?!zt9?m^?^?~/M???k3`E`-? 3?<Dx@@@@@*@"??????Rd/1t?Q*_?+S-@g4@cA?qЉk?LXr֪?X[?0@g:oC@4@b I@b -=@b I@bl!@b I@bg@b I@bGE8@b I@bݘ@b I@b@Z1@Z^5?}@Z1@X-@Z1@a@N@Z1@4֡b@Z1@ @Z1@@7>6z@7Mj@4+ J@5'RT`@4A7K@5ae@4:,<@4@4:,<@4_o@4:,<@4K]c?sD?g?q} ?Kw?WOr?MȳYh?F/P5?2M®?vux"E?Ǔy[?uf -?Ó?ٸ?=?C9?Y 0?ԏ >"Q?!7~.W@@@@@*@,???????ɠt?n75R?d@b)@9{?\?y?* \?y@_Os @5@G@G@G@dZ@G@q @G@q @G@c@G@@$:G@$;S@$:G@$;@$:G@$;W>6@$:G@$;q @$:G@$<(@$:G@$:C\@5v@5b@0hr @0H˒@/XF@/X@@.Z@. xF@.Z@.Z@.Z@.tj?}ѿ,?h?>f?lDžN9?G?-tT?|O?NۈV(?'Q?Kd]?qN?lINՄ?^&? -??8 ^?b/bJ? -t@@@@@&@$??????>5E }s?\pn?%FcC@e1@$;luT?<46#?E{#}?SQ?2@g@6@6E@5\)@6E@G{@6E@KI+@6E@cO@6E@fO@6E@dli@YlC@Yx@YlC@YPYa@YlC@Y9@YlC@Yއ`@YlC@YQ@YlC@Ya%@6Q|Q@6Rn@3+@3̮@Rϒ@3"@3كuH@3Q@3e@3Q@3~@3Q@3?|h2:?"i!?zB"?.)/I? ?C .?{si?t𔻝,?Tm՜?oh$?k?.jdY?Q?Ɍ?sr?%bȜ?:9‚?+[+ -~@@*@(@$@:@:????????VO?e,*;?D.H @K|S@Y,=X?n4sT?al~8?Aw*?@b%@7@KC@u?|@KC@KƧ@KC@H9X@KC@KC@KC@Il@KC@KƧ@ +@ 1&@ +@ `A@ +@ -@ +@ C\@ +@ -@ +@ bM@9~($@9 H˒@1+ @1- @0tj~@0nP@/N;6@/ѷX@/N;6@/W@/N;6@/ ҉? T?ߋb?N?#t?DE?R?!q ?I?s8r?9~F?tP*?H, -r_? nI?Ф? SF?!ˠ*(?L?7@@@@@@??????./G<?W 칸?`<@K"̡@ A|:?f_?ph? ?W@r ޥ@8@j -=q@j@j -=q@jhی@j -=q@j@j -=q@jr @j -=q@j@j -=q@j84@?|h@BZ@3-@3`A@2YJ@2ⶮ}Vm@2YJ@29@2YJ@2J?]?Mj̑?%Lє?vI?] - ?ZzZ?]?V i!?`1B(??*v7?vMUu?*wjs?:?9@0w??Xk-7?q?@@@@@??????Vkb?c#c?0?Gm9V'@j%P@Ds?@(z :?V-{?q?Uf3@s޼@9@xR@xI^4@xR@x(@xR@x[W@xR@x0U2a@xR@xV@xR@x{J#@ ^5?@@ ^5?@ xF@ ^5?@ U@ ^5?@@ ^5?@ - @ ^5?@;5@97@@9(1&x@3+@3sg@2Ƨ@2)_@2Q@2Q`@2Q@2"`B@2Q@2fB?CږF?t,?-a} ?Ac ?X?0 -?>sN?&O?>4g9?Җq?~?XS9??# -3/g?їJ?}@@@@@(@&??????FYZ?1,W?SB#No@v>@X@P?RÊph?o}P?Yr?њ@lG@<@7K@7K@7K@-BH@7K@e@7K@? h@7K@@7K@[@Im@I@Im@IFb@Im@ISX+@Im@IY7@Im@I"S)@Im@Iᐜ@3?@3?x5@@0hr@012@0tj@0l"h @.Vl"@.V6@.Vl"@.DF@.Vl"@.# ?}@TΥ? @ ?"?t?0 s?Ȯ`e?| V? ӫI?8ο?/Sϵ?W#&-?\?pDRg?f?)j?f GA?[w?I@@$@*@(@7@5??????[?t?p"@>+ @>ti@>+ @>b}@>+ @>(@>+ @>!@>+ @>zG@>+ @>5?|@t@Ƨ@t@;dZ@t@C,@t@4֡b@t@S@t@kP@2T xF@2Zݘ@/-V@/g8}@/*n@/"@4n@/Bu%F -@/7+j@/Bu%F -@/D7@/Bu%F -@/1&x?^Q5P?31p?Uy*?Aᆽ?.SM?}?q' -B@@@@@,@&??????cfJ?l'H -?qZd?xlo@>;׫@̉F9?)u hj?p:@?J?AY@rg<@?@@ȴ9W@@nO@@zG@@s@@N;6@@2X@F@Hr @F@Dg8~@F@Gz@F@Gݗ@F@EoiD@F@F&@7zqiC@7xTɅ@1ԛS@1J@0j~@07@0V!.I@0W -=p@0V!.I@0W)^@0V!.I@0WsPI?Y͍_?sp?N?!#?#6_?C!?h??CO?qF?siqe?݄ ?P=?K?%_D?oܧ?!ˠ*(?L8AS?b/bJ@@@@@@??????S+<6x?,g0?+ )M@0@G0$?LVC?F??O n>@lX|@@@b`B@d/@b`B@ev@b`B@`hۋ@b`B@bM@b`B@`D@b`B@c,zx@jA7L@jffff@jA7L@j܄@jA7L@j (@jA7L@j҈p@jA7L@j\N@jA7L@jK^@6H@6?@2° ě@2?@2t@2ڹ@1䎊r@1{n@1䎊r@1 I^6@1䎊r@1.H?]?hX*?ě?W0 ?P?-gfQ?CgE ?=U -3??iAA??_PV ?LQ9@@$@ @ @3@7???????`9' ?$?2h{W?Pmv@IN(X@!TJ?RƽaE?p`eo Y?ܹ]?+" @ir#:@C@gWO;@gNzI@gWO;@gU%F -@gWO;@gU?@gWO;@gU*1@gWO;@gTj~@gWO;@gS3333@(\@&ffff@(\@/'/@(\@,C@(\@%@(\@&@(\@* @7!.@7l!-@33S@34m8@2lj~#@2jݘ@1䎊r@2'RT@1䎊r@1H˒:@1䎊r@1hr!?|O?sI?,Z?ھ۲?'`?5H>d#?]˙$>?.\?`P?ʳ_?__C?ĭ?]ߒ@@@@@*@*???????X?;*?A_V?6P }@gQ@'?aǁI?Vu?3z?#O̸^@f{v8N@D@3A7K@3A@3A7K@3B}U@3A7K@3B\(@3A7K@3B\(@3A7K@3@hۋ@3A7K@3@[7@yv@yv@yv@yQ@yv@yJ#9@yv@y)@yv@y~@yv@yG@0H@0Ov_ح@+`A7K@+m\@*rnO@*r{m@)Xy=@)Xy=@)Xy=@)\(@)Xy=@)\(?b'f?{j?!!׋7?G?6r In?tJ?bM_x? g?90?@[*^?إ<(?]#O?bMky?~('?s@a?XLL?O|q?Ѐ>(@@@@@,@,??????Pmo? -vXW?4㽰M? -Fx@3AC}@y#?CL;??s6z@2D*1@0S@0 @0`A7@0'RT@/@/4K@/@/حU@/.NC,?^Q5P?dY{?,Z?GZ0e;?/m{@8?bV,?V i!?}7.?,~[?we @8?i ?,?f)"?O?rsw?C SG@8 @@@@@*?????G@+ J@1&y@+ J@{@+ J@ᰊ@+ J@X_@+ J.@+ J.@6;dZ@6@@6;dZ@6M(@6;dZ@60 ě@6;dZ@6A [@6;dZ.@6;dZ.@1@1$tS@0+@0E@/;dZ@/C,@/73@/8tj@/73.NC,@/73.NC,?OW?O'q|?G)?nx@8I@8?;0?Ò7=?3?!@8S@8?!?|\?7^|?ޒ7:ʪ@8 @8 ?@@@????H@P`A.@P`A.@P`A.@P`A.@P`A.@P`A@d%3@Y+.@Y+.@Y+.@Y+.@Y+.@Y+@s@8۹~($.>@3 I^5.Mm@2-.Qn@1:S.NC,@1:S.NC,@1:S@1R@8J@8#@8:@8 >+@8I?@8J@8@8i@8@8S?:;{@8p@8 *@8p@8@8 ?Xk@&?I@/@5?|@/@-@/@-@/@ޞ@/@qu"@/@ۘ@-V@nP@-V@W@-V@D@-V@2X@-V@沣S&@-V@䎊s@4Q|Q@4Q[W>6@0 ě@0GE84@0]V@0\C,zx@/`d@/ߥ@/`d@/zG@/`d@/!-w2? ?h?RsW?q@v?Dj??|O? -?pM?@[*^?&Tm?b-x?W ?/? J?hB^?SP?ˢL1@@@@@,@$??????@7?=G?2[?+t@Mѣ@vӭ?R{ -dM?<Kt?M?Gq@g| kd@J@4j~.@4j~@DĈ@4j~@=ĥ @4j~@X;y@4j~@O -p@4j~@@Ov@r.@r@rv@r@r0@r@r.@r@r\%@r@rͳB @4Y*0U2b.>@0hr @0"h@0'KƧ@08@05sh@0 W@05sh@0 -sa@05sh@/ -@8J?;??tp{?goA?u;V?H@8J? ,E?|QHf?= B0?h@8@.>@3\I^5?@3cA @2`A@2@2O M@2D2W@2O M@21@2O M@2"@4n@8J?%߰?X+??=T^@8?F/P5@8@8i@8?=x@8?`w@8 *@8p@8?h@@8 @@ ??N@߷KƧ@߫K@߷KƧ@@߷KƧ@ߦ"@߷KƧ@߻.@߷KƧ@84֠@߷KƧ@YPI@S@&fffe@S@m@S@LKL@S@@S@H@S@0a@6H@6]{.@4G+@4=]jo@3v-@3b@3QiB@3Sr@3QiB@30oiDg8@3QiB@3%H? 1Ӡ?;@3+ I.Mm@4~".Qn@2O M.NC,@2O M.NC,@2O M.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 P@i/@i$/@i/@i@@i/@ii8@i/@i(@i/@i>(@i/@if@Q@CS@Q@!%@Q@+Mڑ@Q@'>s@Q@&4Ü@Q@'Ò@8*0U2b@8:@3&+ J@3%Ff2@2;Ƨ@29_@1YJ@1raϥ@1YJ@15f@1YJ@1_?>KtA?4TN?v|*f?xLɀ?J/?^L~?uq?]m? p ?x_?x7m#??֙DQ?I͑Q?p ?k ?юf@?#&z?^а~@@ @(@(@5@6??????F@z[V?"z&CJ?\ψ@i99-@-MJ?9F\*\?}{fp?nmQj?;EAG@n~5p@Q@\@9X@\@C@\@Ov@\@'/@\@L`@\@_@H9X@H\@H9X@H1&y@H9X@Kq @H9X@L@H9X@LC@H9X@KC@3>6z@3eں@1S@1{m@1"`@1u"@1}ce@1}jOv@1}ce@1zn@1}ce@1zL_?|O?L?ojVrnBZ@4 I^5@4?@4`A@48}H@4@5@4JM@4@5@4$tS@4@5.NC,?q!U?B ?&)_? -Y?\ǿ@8?sD?^? u?Zf?B<'@8? uf? $F)? U?71lQ?W1x@8 @@@@@*?????S@^5?}@nآ@^5?}@R~@^5?}@ 9@^5?}@P@^5?}@\A2@^5?}@D=F@`A7@l^@`A7@}T@`A7@f @`A7@GD@`A7@U@`A7@n!@6@633@2E?|h@2C&g/@y@1tj~@1|@0m8@0UՑB@0m8@05*@0m8@0fG)?ڡG7? ;m ?ש;?|ǵ9? %M}?jB/?=ak3?)RP?BL?Ê?: O'm?!2{? L?-?gp0@@"@ @"@3@2???????g vD?UHK?PWp(?H.Q@xxYU@c?p>B?h]wh? 5T?ُ͊?@f(y@T@:E@: X@:E@;[?@:E@;J@:E@:i@:E@;}̇@:E@;E@(\@;@(\@+"v@(\@.5)j@(\@'c3j@(\@! @(\@&* @8hYJ@8C;p@4!hr @4#%W@3tj@3s]@2@2V@2@2hb@2@2Q!?Mo?c -_?Y&??j6?X ?7?0f?%%?BTV?؛HN?H_?J?Un?Ŷ0lW??@ i2?)B}@@&@(@,@"@(???????x@@t0XU?bO -?[mLx@:@(Pܷ&?ub'/?yP㞺 -?{-?H;}@pC7@z@U@E0 -=@E0`A@E0 -=@E1:@E0 -=@E1'+@E0 -=@E2+ǭ@E0 -=@E.@E0 -=@E.u@V@hr@V@@@V@(@V@.@V@<]@V@쪗b@1䎊@1䎊@,A7K@,@+n@+@*Xy=@*S@*Xy=@*Z@*Xy=@*2#n?_?R?lj?}?꘏?O?bMn?𕧌?v?-4?J/51^?T`0?bF?r?nڨ8?p?%ip-?Yp@@ @"@ @:@8??????[С)T0p?@n?*N!1@E/ʨ@쯯?P%",?9= -BVT?#~cyp?k1'a@s]Q@V@v@O@v@9XbN@v@4*@v@,C@v@*JM@v@,L_@yO@zx@yO@y\@yO@y'@yO@y!-w3@yO@ytj@yO@y%@8e!.@7w1@5+@5<쿱@4Vu@5ѷX@4&YJ@44%1@4&YJ@40`A8@4&YJ@4-8Z?' ?0!?1?W?5Ç?JpT"?{6O?j{?S]:?Y`?/m?*ML?٧??[e'?7?$–?3 D?y@@@@@,@(??????CID?nl~*?k6wDžn@,$VJ@yً?}?|x?%{c8?Ϫ]1I @tj@W@C@@@C@C~@C@ϒygz@C@l~@C@ʒT3@C@_j@1'@j~@1'@K@1'@':K'@1'@  @1'@ײ@1'@*Y$O@7mv@7hG~#R@3B ě@3DB$@2ttj@2uQp@1n_o @1oF@1n_o @1n+(+H@1n_o @1n+kw?\l6?@-?U?+@8I@8?lOx#@8@8i@8@8S@8?8$@8 *@8p@8@8 @8 @?Z@M@P_@M@ǔzG@M@ǔj~@M@džIR@M@т @M@zxl#@hZ@hI<@hZ@i&@hZ@iMM;@hZ@itj@hZ@h1&@hZ@h@6w@@6v=6@3J^5?|@3y=b@2~"@24J@2Tm8@2>BZc@2Tm8@2r@2Tm8@2xF]d?E[i)?h(O?ޑKO? :>Co?FILXT? ا ?~Ov_ح?Klր? Ķ?ۦkQ?Gfx^K?Y@?R?K)?J8ȟ?h1oS?r?|)-}(@@@@@@???????{˲NK{?q,?Z.7@tmI@h^?RF*?zb^f@v ?rb@d!1<@[@R`A7L@R`ě@R`A7L@RT֡a@R`A7L@RWkP@R`A7L@RV_ح@R`A7L@Rzu%F@R`A7L@Rvȴ@W -=p@S@W -=p@KC,@W -=p@P*0@W -=p@G&@W -=p@w@W -=p@ohی@6qiC@6g -@3S@3A [@3 -V@3c @2iB@2M:@2iB@2a@N@2iB@2-? ?U@3 hr@2[C K@2U`A7L@16@1D*@1!9@1D*@1"8a@1D*@1$_*Y@8J?:?Mi1?ƦJG? ג3?^M@8J?EW?9V?nY?su*o?߭%@8p?֢?CJ"h?JP?#_?p?8>@&@,@,@<@;?????]@d/@\hs@d/@BZc!@d/@A \@d/@SMj@d/@ca@N@d/@kC@]V@]"@]V@]}H@]V@]p:@]V@]:@]V@]@]V@]Y@8>6z@8}ce@5I^5?@5-V@4V@4oiD@3iB@3Ŏ!R@3iB@3tSN@3iB@3 [7??Ld{6?>?%?U?0eʪv?.pC?Z?/+?E?܉a^?M3 ?Җ(??@@@@@*@(??????[v[?Fqu%?[lt@^)@d<R?e;N?u$?Ŷ?6FV$c@jyQ/@`@h^5?@hl@h^5?@hC@h^5?@hƧ@h^5?@h=p@h^5?@hۋr@h^5?@hfB@9l@9~#@9l@9^5?@9l@9'RT@9l@9'RT@9l@9L/@9l@9*0U3@3:@3!-x@0ԛS@0ԯO N@/x@/\)@06z@0}Vl @06z@0At@06z@0At?|O?'?Gy??Rw#z?#6_?6J?| ?? :?ދ"?Uh;?I?sx/T?W?/?٤?RJ?b/bJ?_խW@@@@@,@(??????4h('@?&PD?!(K%@hl@9Rp?F[M.?Ax4Y#?}!?X*l@fv@a@9NV@9MV@9NV@9Y_q@9NV@9? @9NV@9Kt@9NV@9U?@9NV@9W@+@@+@̥zxl@+@_o@+@1&z@+@Ϫ͞@+@̿[X@6S&@68YJ@3+ J@39@3-V@3Rn@2m8@2p:@2m8@2ԯO M@2m8@2䎊q?F/P5?2?FI?L?e7@?S:Ъ;5?us\?z]藍?ܜ?lyx?]vM ?>[Fh?!A -m?3 ?a?pLA?xb?zy@@@@@@ ???????aΫc?An&ן?@E|@9RQv@ҝU?ck?aU:P?o%7^?SQ0@iɈ=@b@Q.@Q@Xy=@Q@Qhr!@Q@Y+@Q@UL_@Q@QN;6@ .@ @p:@ @|@ @ ~'@ @ @ @ rF@8YJ.>@4S@4-@417Kƨ@42}Vm@3Tm8@3\(\@3Tm8@3Z,<@3Tm8@3YQ @8J?Qi{cj?=՛?Zto?wX?ߑ@rY@8J?蠔?lU ?%ja?B*Z?]'Y@8p?+0T?=o -F?{ޏ?vucʲ?/̽`@@@@*@,?????c@^7@^6ȴ9X@^7@^0|@^7@^$Z@^7@^%84@^7@^#w@^7@^3 @pzH@pV@pzH@p@pzH@p2@pzH@q$/@pzH@q*g@pzH@qc@7_o@7@5+@5 -L/@56-@5Stj~@4@5@4Q @4@5@4oh@4@5@4n.2? ?AZ?"?%I _?QW᎕?̀m?oC?t?ń ?_*>?07\?b&?_??"x?OMy?pZ;d?-o@@@@@*@$??????b(7?$?\tG?e/~Q>@^1Uh@qR ?}9?U-wX^/?/oc?o@<@fs[@d@\1'@5?|@\1'@о )@\1'@nP@\1'@r @\1'.@\1'.@խhr@Քj~@խhr@!-w@խhr@ӝ-V@խhr@O@խhr.@խhr.@8!.@8.2@4|hr@35oiDg@3ȓtj@2͑hr!@2&@2D?@2&.NC,@2&.NC,?pEIt?ĩa@x˖?91G@8I@8?mX?kb?me\? &@8S@8?d? [b?Dø;?i,@8 @8 @@@@????e@C@|hs@C@֡a@C@bM@C@&@C@Ʌn@C@aA@vȴ9X@ه-@vȴ9X@r<6@vȴ9X@ق&I@vȴ9X@zc@vȴ9X@x@vȴ9X@xPH@8hYJ@8i^5?}@4ěT@4䎊r@4V@4'RTa@3xF^@3@3xF^@3S&@3xF^@333334?ȉak?:@+kjf@+kC%@+kjf@+k:)z@+kjf@+kU=?^Q5P?Čۨ1A?$C@?/?@ A2?}?bV,?>`?['?3.Yl?@?Z,a?b@?~('?8*?͓E'??l&@@@@@(@*??????M+d?%?4qmC? Gϼ>B@Ň<@y?C94?.΃N?wX9?TAZݛ@sS@g@RnP@c @RnP@FL@RnP@Rޞ@RnP@*!7@RnP@/fn̉@RnP@(*@.7KƧ@.>"@.7KƧ@.ί@.7KƧ@...n@.7KƧ@.kW@.7KƧ@.r9$`@.7KƧ@.Hj,@8@9O @4I^5?@4"0@3PA7K@3KOy@2O M@2e@2O M@2 t@2O M@2j=6?|B &?ͼԦ?s?sNȺ?5m;0 ?`?Eg??{.V?{?cO(?aő ?Ko?%j?*?X?`oe^?!8@@ @(@ @2@9??????&S?6?zx?CwB?GZ?їJ?*@@@@@,@*???????9Pa?M_dɗ?Yȏ %@vJw@M`?k2rP?v}:w\?k!?1Q(@h/@j@XbN@ȴ9X@XbN@XbM@XbN@@XbN@"@XbN@F]@XbN@Q@y"@z1@y"@{u@y"@{s@y"@yXbN@y"@z)y@y"@yb@6]ce@6_o@2hr@2@2~"@2ݘ@10U2a|@1Q@10U2a|@1W'@10U2a|@1ݘ?Br?sI?tcj?$jB?FL{?<_?|O?\tW?%gǿ?.?O ?低NV?T?1j?~/O?l?Cns?Tj@@@@@*@&???????8]P}*`?5>hc ?6@{@yO?Tf|X1{?7 -6#?Y^S?xN @hmH k@k@O;.@O;@ @O;@*@O;@@O;@ЇYV@O;@u@+x.@+x@+x~@+x@)N@+x@,~yW@+x@,xg0@+x@,l @8쿱[X.>@4i+ @49=]?@3t@3KDP@2𖻘@2oE@2𖻘@2s%9s@2𖻘@2Fh@8J?2?!ұr?cet?*- -Q?a@,@8J?Is|?,n?^\Nb?D?? @8p?sg̘?uc4?7,?<?+̪W@*@&@(@;@8?????l@{@{KJ@{@{޳c@{@{\N@{@{4.@{@{%&@{@{Uϖ@=p -@=)4@=p -@K@=p -@: 2@=p -@=hH@=p -@BlJa@=p -@Af@4 xF@4tj@1S@1BJv@1"`B@1vG6@0sh@0%@0sh@0y/r@0sh@00?| V?|28?N?`?]j?P+?| V?l0F?j?aݚ?p? OYb?ח?(c? ?+@?1?G@@@@ @2@,???????`?F<?LחԘ?9 3P@{ғ)@??j"<@D?XTױ!?Kw?{i@@e'b}@m@LvE@Lv+ @LvE@Lu\)@LvE@LvFs@LvE@LvR<6@LvE@Lus@LvE@Lu*1@ݒnP@ݒ ĝ@ݒnP@ݒ:)z@ݒnP@ݒ@ݒnP@ݓa@@ݒnP@ݓ3333@ݒnP@ݓtj@304m8@30:~@0S@0O M@/n@/Gz@.̲@.̘_@.̲@.̲@.̲@.̲?|O?3i?1f_?vHn&? f?^?|O? g?NJ?uX?Cq$u?b-x?nwf?u?u@>N ?͓E'?SP?M684@@@@@*@(??????.z`?&?F ?^C@Lv^@ݓ?2>=q?5E??q=?w"@fW@n@w@]@w@(R@w@q5@w@(@w@qOh@w@ڧ}@"`B@$(*@"`B@'L>@"`B@$qB@"`B@ z@"`B@$[ @"`B@@8 ]ce@8cA&II@3^5?|@3n@2`A7@2[@2z,<@2tR!LT@2z,<@2vYt@2z,<@2vV?'Z]&?5;-?`&בɽ?2K?5?"?I'%?2S8?y'?E?JWV'?a?%?@w%?D3?vCy? a7?*@@$@(@,@4@2???????>C3/?Um_s?B^0@kU_@!V -?qMyG?_9m?K`?QJe6@n9@ym@o@  I^@ u a@  I^@ n@  I^@ ѷ@  I^@  @  I^@ `A@  I^@ n;@bPbM@bP -=@bPbM@bPc^K@bPbM@bPv7@bPbM@bP]0@bPbM@bP 1 @bPbM@bP|@4۹~($@4ܥz(@.8tj@.8jZ@-h1&x@-h @+873@+8_W1@+873@+82&@+873@+8YJ?}x@LC?d3r?pX?ȗ ?9G@m߀@q@3Z1@3Z1@3Z1@3\]cf@3Z1@3X@3Z1@3Z~@3Z1@3YJ@3Z1@3YXbN@ I@~#@ I@~'@ I@0@ I@xF@ I@6z@ I@xF@5>6z@5+ I@1ٺ^5?}@1"`@0Ƨ@0Q@0u@0O @0u@02a|@0u@02a|?}ѿ,?nx?)?&P?^:f?,I ?^?}ѿ,?0n=Q?CXs?@Cv?UBi?]#O?T0?Q?`x?8 ^?SP?ˢL1@@@@@,@&???????+^0?'R? |X }@3Y{@h?GP)&^?-~}e?^;I?eIq@g%u@r@(@(1&y@(@"`B@(@ - @(@6@(@l"h -@(@!e@9Xb@@9Xb@oiDg@9Xb@ὥ@9Xb@SM@9Xb@ȴ9W@9Xb@@7v@7<쿲@3+@3"3@2"`B@2nO@1@1zxl"@1@1M:@1@1&??d_s?ޑKO?$?[Fh?.EkЍ?Эs_`?S[D?7N?4\ɵ?Ee,@@@@@&@*??????JX|pcX?e%6׾?T\Ү@v|#@8Pp?wNI?n&K?'aM?N7٤@oHwi@t@8@8F]@8@70Vn@8@9G@8@7!n@8@5(=@8@4@r-V@q@r-V@q<@r-V@r@r-V@u`/@r-V@q'@r-V@rB@4*0U2b@4E@1hr@1@0tj@0V@0Tm8@0R~@0Tm8@0TGa&@0Tm8@0S_g{?|B &?9?e>c-?'?6θ ?9d?|b@?~?>IA?-HD4?i֭?x9f?tw{O?HZS?̯.3?:Il?#?$@@@ @ @3@2??????Baw?/Eʫ?DPp?δ7?]|?cx?>@fngb@u@"@Q@"@.H@"@"@"@vȴ9@"@-V@"@ڹ@Y@YzG@Y@Ya?@Y@Y@Y@YSN@Y@YMj@Y@Y3332@3䎊@3&IR@0 ě@/U=@.DZ1@.CF]c@.V@.UXy=@.V@.UϪ͞@.V@.UfA?|O?'?U#?<ݝ? 9?aX?| ?4 "?'Q??Cq$u?eDQQ?nwf?§d߱?|׿pZ? ??L?SP@@@@@(@*??????-d%0Yֽ? LѡF)?.}H@Cj=@YYh3?+nԡ]?2$3U[?di\T -?pLG@fIZw9@v@dZ@k@dZ.@dZ.@dZ.@dZ.@dZ.@&x@BӮ!@&x.@&x.@&x.@&x.@&x.@8%!.@8'm@43S.Mm@3W-.Qn@20U2a|.NC,@20U2a|.NC,@20U2a|.NC,?}x+@8I@8?t D5@8@8i@8@8S@8?l{@8 *@8p@8@8 @8 @?w@ I^@hs@ I^@tS@ I^@{J#:@ I^@҈@ I^@-w1@ I^@vȵ@"`@F@"`@PH@"`@ޞ@"`@~@"`@)y@"`@)y@8 _o@8s@3° ě@39XbN@2tj~@274@2u@2Z@2u@2z@2u@2t?X?t,?Q/ -?̒?e7@?7D -?)T?9}=? -oɧ?,??j?oeư0?3a=?I6y@=u@=u@=u@=*1@~6E@~4F@~6E@~73@~6E@~6z@~6E@~5Y~@~6E@~5*1@~6E@~43@5H@5u"@2+ I@2_F@1A7K@1u%F -@0?䎊r@0@ k@0?䎊r@0@ѷX@0?䎊r@0@ ě?|O?Qd?njĕx?'$5?#6_?f]G?F/P5?[ K0R?"a?N?<}?m/w ?=P|@@@@@,@*??????؏؀VTx?*(43?=~@=0s@~5?J݄inj?3Va?g?mð,!@h>@y@u@S@u@33334@u@+R@u@5?|@u.@u.@wp -@w+ K@wp -@w^$@wp -@v1@wp -@wQhr!@wp -.@wp -.@8^H@8`- @3hr@3ES@3v-@2ڹY@2ٌ~($ @2Ohۋ@2ٌ~($ .NC,@2ٌ~($ .NC,?A[F?po_?PQ?fP@8I@8?8ȺJ?&`?;+?X@8S@8?UWci?4r?H/b?DZ@8 @8 @@@@????z@:^5?}@;dZ@:^5?}@;u@:^5?}@:^5?}@:^5?}@9_q@:^5?}@84֡@:^5?}@8tj@@@@jO@@C\@@"h @@a@@a@5[~($@5\!-w@1I^5@@1O;dZ@0"-V@0"`A@/Ǔݗ,@/@@/Ǔݗ,@/ɠ'RTa@/Ǔݗ,@/ɅoiE?]?J`Y?"? -?'ř ?+ʦ_?]?p RN%?90?Hn? f?U3p?*wjs?9o?D(p?v_.^?SP?E݋N?@@@@,@,??????A"=c? k? Sg>@9$7,@x?c)xT)?kA\?2!?%PzX@s~@{@Tr-V@T~vȴ9@Tr-V@ToA@Tr-V@TuL_@Tr-V@Tuᰋ@Tr-V@Tp ě@Tr-V@Th ԕ@@ȴ9W@@@@ @@oiC@@wk@@SM@8g l@8K]@4E?|h@4G@@3tj@3e@3J0U2a|@3H@@3J0U2a|@3H9Xc@3J0U2a|@3CMj?oC?Ȼv\?@^ڢ?IW`g?n.}?`$-?,e?-',? ?GW??!oj`?#N? -e?vv?Vn?u4?K7~w>?q@@@@@*@(??????[u?upY-ڀ?a{?hN@3B ě@3@A7K@2`A@2n.@1iB@1;dZ@1iB@1{@1iB@1а{@8J?W[?=P?)?u??=@8J?ۣ0Τ?pI?? ^??X<@8p?3a=?/X?"a??E݋N? `@@@@ @,?????~@-V@ -=@-V@1@-V@TɅ@-V@h ԕ@-V@Ft@-V@!-w@A7L@9X@A7L@F]@A7L@A \@A7L@t@A7L@ ԕ@A7L@%2@7e!.@7e`A7L@4^5?|@4j~@3j~@3wkQ@3u@3TɅ@3u@3_p@3u@3#x?% ??0? N:??Pzj?1j?4\2?)~Y6 ?*Gk?9]t`?汝/&?MM.?:K?~gN?C.ΐ?E>g?r:vI@@@@@,@,???????n<y`?b!ftB?j0a$mT"@d4@:t?|#N?P?@l.d?ဩP@`@@2w@2n@2w@2|PH@2w@2v4@2w@2uᰊ@2w@2t!-v@2w@2vv@n@ě@n@[W?@n@s@n@4֢@n@u@n@Ϫ͟@8uS&@8k҈@3hr @3B@3~"@3%1@3m8@3ѷY@3m8@3JM@3m8@3r?@?u~?_?998??y+PYu?|O?z? -?|?MuVQ?6@(/?uDJ`?*T?ٹ?O"?\,!?>LR_5@@@@@*@*??????Qr{>dlHL?Q"?/U0L@2v<@"?eA1ċG?UTK?[2?q8@oBM3@@p -=@:A@p -=.@p -=.@p -=.@p -=.@p -=.@$9Xb@$F<@$9Xb.@$9Xb.@$9Xb.@$9Xb.@$9Xb.@7*0U2b@7Y@3S.Mm@3$j~.Qn@3!.I.NC,@3!.I.NC,@3!.I.NC,?3@8#@8:@8 >+@8I@8?kz -~@8@8i@8@8S@8?ksP@8 *@8p@8@8 @8 @?@\(.@\(.@\(.@\(.@\(.@\(.@*/.@*/.@*/.@*/.@*/.@*/.@7|Q.>@3xr Ĝ.Mm@2Z~".Qn@1𖻘.NC,@1𖻘.NC,@1𖻘.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @/޸Q@/@/޸Q@/'RU@/޸Q@/O;e@/޸Q@/ws@/޸Q@/&@/޸Q@/c -@w@p -@w@银E@w@騴9X@w@0 @w@@N@w@꙳|@9Y*0U2b@9N($ x@55?|@5c @5 "`B@5N;6@4[W?@4a@@4[W?@4w@4[W?@4u?xg?q?BI{?ߦ>?aRo?3:?_?M\ٓ@?DP??{T??6-K?^w?A8 K?j?U#?uqR7?Tј+@@@@@@???????>F@?5?3+0|\?>Hr&@/u@Prf?pYfL?y1D@#/>@=rQȈ8@os@@a@a#@a@at@a@eL@a@d|@a@6L@a@0:@jcS@jR@jcS@i[Y@jcS@i@Ϭ@jcS@iU -@jcS@i".@jcS@iAق;@7~($@7+p@3W+ I@2e*A@1A7K@1;@16z@1jp|& @16z@1k ̒@16z@1pz&?~Ov_ح?WMʨ ?'N5?1?\?Zl?lhFB?ڡG7?K@o?u:d?Q?~u@@&@ @,@:@9???????k~D돎?XÊ?f2@mGm@j/(?p?}"5y?׋:?l5B@_(@@]V@]O;d@]V@]p:@]V@]y=@]V@]@]V@]:)z@]V@]^ @3ě@3G{@3ě@3*0U2@3ě@3J@3ě@3@3ě@3wj@3ě@39#w@3|Q@3e+@2n5?|@2jY@24tj@23S&@10U2a|@1 -=p@10U2a|@1@@10U2a|@1҈p?|O?6 '8?ub5?Uv?#?3ƒ?kʍL?|O?馿j?*&k?{G_rV?Լ2#?Y٭ 8?|׿pY?P<}?*0x)??DΊ?@@@@@*@*???????Y~;?T:4?Wk3^"@]@3M]?psHeG?rD?pAK|?xم@ac5U @@4j~@4j~@4j~@5$@4j~@6u@4j~@5\*@4j~@5 '@4j~@3@F&x@F'+ K@F&x@F'lC@F&x@F)7Kƨ@F&x@F'-@F&x@F)Dg8@F&x@F(Xy=@2B䎊@2Be+@-{"`A@-{lC@-%@-%+a@,#Z@,#9@,#Z@,"ѷ@,#Z@,"@5?^Q5P?ƿ57?S?|*(?/`?{`?s8r?-I`K?@?M\ٓ@?cPQ?3;?|׿pZ?^ a?pk Y?pk Y@@@@@@??????Lp?-8"x?)~W?8@4=C@F(x)?8?G<788Z?mWZ?l1@s -@@ 1'@ 1'@ 1'@ Z@ 1'@ 1(@ 1'@ ?@ 1'@ u@ 1'@ +k@Lr @L9X@Lr @Lt@Lr @L/@Lr @Lh ԕ@Lr @L|h@Lr @LF]e@4(YJ@4(eO@0 ě@0n@/E@/s@.̲@.+ I@.̲@.Ǔݗ+@.̲@.ȧ?| ?:L -?D&?؆{~?E@? ]V?|O?> -fu?NJ?.?R? Ӻ^?٤?sq#?`x?*|\/?j?L8AS@@@@@&@&??????? h Z?d~?@5@ 笿@L((?/ND?a q:8?j xG ?ɳ?@fQ@@4j~@+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??@Ձ$@և+ @Ձ$@@Ձ$@Ʌo@Ձ$@+j@Ձ$@z@Ձ$@!.@u\)@vu@u\)@vȴ9X@u\)@x4֢@u\)@u*1@u\)@q@u\)@sg @6Q|Q@6Q4J@2+@2(@1`A@1ae@0:S@0}Vl@0:S@0˒:)@0:S@0?}ѿ,?`?RsW?˅T?<_+fj?nM?F/P5? ,C?i?@[*^?qn?"?Me^?.+?OW?3{Z?ܑ ?gϵ@@@@@,@*??????>E`?~sL+?2w}@ֈ5*@tZl?4u?R6?ub`?Q U@g!1@@d%S@d%S@d%S@d&[@d%S@d&$PR@d%S@d''A@d%S@d%Yfa@d%S@d$Ζ,@@bM@@f@@Xzx@@h@@3@@}G@2䎊@2䎊@/G-@/GrG@-|1&@-{E@-(ۋq @-(fsF@-(ۋq @-)'W{N@-(ۋq @-(^9?^6P?S?,5? ?4ح5?j?bQ넛?5-?6?8Q9?מd?\j4?bw' g?Z[?{L?&{A?3 ?pu{,@@,@,@,@8@7??????PJ#dTX?)P"?(Y9-@d%d@i/?8d?6 -voE?n)?f@s%[@@l@3 ě@3/ޖ@27KƧ@2?2@2䎊r@2|`ӺM@2䎊r@2 @2䎊r@2~)@3!hr .Mm@2`A.Qn@26z.NC,@26z.NC,@26z.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @1@Q@1@A@1@hی@1@b@1@\(@1@iC@ 7Kƨ@lC@ 7Kƨ@@ 7Kƨ@`A@ 7Kƨ@@ 7Kƨ@#x@ 7Kƨ@Xy=@7H@72W@3S@3jOv@36-@3*vȴ@2s&@2_$tS@2s&@2b3@2s&@2b䎋?2}?i1[?<Ӟ?g(6?l??Y͍_?/ω(2?KF?:`?͖M?87?<{?  l?6P?B?y\? -e@@@@@,@,???????4>?p'?fP3?[?F@Z4Mf@ 뛑?7W?a6 +?9?ya}Q*@bOo@@7K@Ž@7K.@7K.@7K.@7K.@7K.@eO;@eɻ[@eO;.@eO;.@eO;.@eO;.@eO;.@7Q|Q@7QE@3hr.Mm@2`A.Qn@1:S.NC,@1:S.NC,@1:S.NC,?| V@8#@8:@8 >+@8I@8?E[i)@8@8i@8@8S@8?jK@8 *@8p@8@8 @8 @?@%T@%~T@%T@%*@%T@%O@%T@%w@%T@%t5@%T@%@A@B@A@BM:@A@B@A@A+@A@A(a@A@A#@8zqiC@8{h @4 ě@4YL@417Kƨ@45-y@3m8@3)qb@3m8@3XC@3m8@3|?C I?ӡ?g?? _? -*?ŰCz??qP:6?  -1?̦2?JS6z?^Q5P?*|3N?d3"7?ݡu(r?<_+fj?dW?bM_x?#maЀ?HD?Ѝ`Hi?GU?Bh?L[]? $gv?Me_?RJ?<71?ad|@@@@@*@*??????]+?|!V"?GXZ?lb^@LPߥ@Q]DK?@?Vl?xTR\?_Hm ?Uh@s&a@@n@%$]\@n@EO@n@" @n@g{}@n@)L@n@o@nP@[ E@nP@ےR{@nP@ @nP@ -W@nP@\B@nP@#B@8,<@8A`M* @4S@4w@3"@3>@O@3p@3oa@@3p@3nOx4h@@3p@3pj?c|iqd?Åt.?XMX?4<~??7?nwe?3<' ?\P?̴?-IG?Q7?E͵k?ޗf8u?Kjw?! f?|? ?uT@@@&@ @,@,???????6qx?gSZiu?QW L(@\@A?|,ez?ufђ?q+?냣V Q@nH&@@ë I@él@ë I@Ç#@ë I@P'R@ë I@CZ@ë I@`D@ë I@f$/@ @ ě@ @ @ @ +@ @ oh@ @ ffff@ @ U=@6v@6_ح@3S@3U2a|@3"`B@3nvȴ9X@2ce@2Ov`@2ce@2qj@2ce@20 )??). -?L7S?@@TbM@T -=@TbM@T @TbM@T Ĝ@TbM@T@TbM@TMj@TbM@T@+@-@+@ C]@+@@+@qj@+@ :@+@ (@5:@5,<@2|hr@2А- @2$j~@2%zxl"h@26z@2! @26z@2"p:@26z@2(\?2}?d_s?,Z?@R?#0Y?0 -?1j?u(?Qrz?{d?Q?9x]e? uf?"`?t -j?9XNu??%@@@@@,@*??????#z?S?2@;@{?W)'@Td%/@KT?Q0ɳ?vS[?^?])^3@f8K @@ C@ @ C@C,z@ C@)@ C@Xy?@ C@q@ C.@"@n@"@$@"@D@"@'@"@\@".@6@7- @3 I^@3حV@3tj~@3T@2sh@2쿱\@2sh@2p:@2sh.NC,? ?̣\C)?eI2?²E|?`ގ q@8?qv?~?OT?@/@{?8i=F @8?|aQ?Us?F@8 @@@@@,?????@ŋƧ@ŋƧ@ŋƧ@ŋq @ŋƧ@Ō"h @ŋƧ@Ō"h @ŋƧ@ŋ~(@ŋƧ@ŋƧ@چ@چ@چ@چ&@چ@چ@چ@چ@چ@چ]c@چ@چ&@0-v@0-v@*tj~@*@)E@)%F -L@*#Z@*# -=p@*#Z@*# -=p@*#Z@*#A [?^Q5P?°R;?$C@?8v?Ot?O+y?bM_x?%F?j?0N:s?IM?Kc?bMky?u?oܧ?avh?O|q?@@@@@,@&??????%1X? ?A?fi? -4*K@ŋ@چ[?!vy?S돤?>+d??+ :-y @s@@lD@hs@lD@hs@lD@G@lD@@lD@)@lD@-V@G}E@GyXbN@G}E@G}<64@G}E@G{lD@G}E@G}IQ@G}E@G~%@G}E@G'RTa@8%!.@8# ҉@2^5?|@2/V@2`A7L@2-@2Tm8@2Vt@2Tm8@2VR<6@2Tm8@2Vl!.??6 '8?BI{?Att?EE?!w?)T?PuN??ǧ?D6?$) ?'?LR_5?r@@@@@*@,??????&3P?V\ ?E%C? {ї@J@G}zwW?^2:?/?0f?ZՏYZw~?U6 y?fr[?|M4^?!D?bk6@@@@@(@(??????b?xsg5?shY*?dX@hq@VZo?0Aq?{Eq5?F<7_?Eb@g@@b`B@ti @b`B@ ě@b`B@-V@b`B@33333@b`B.@b`B.@C A7L@C&>@C A7L@B1@C A7L@B@C A7L@A~Q@C A7L.@C A7L.@8|Q@8gb@2hr @2@4@2tj~@2XbM@2 [W?@1\(@2 [W?.NC,@2 [W?.NC,?tJ?Yz?$:HT=?;kE_@8I@8?t D5?y>cv?J?Zy@8S@8?T -a?[9\?6_[?F@8 @8 @@@@????@t@ 3g@t@ͼ|M@t@/@t@=$7@t@yYG@t@sf@6E@2F@6E@I{ 6@6E@(yd@6E@SJV@6E@@B-@6E@Cr@7-v@7,`@4O|hr@4bLmU@3"`B@3f@2@25h@2@2x@2@2 P? 8+?ɅK?w[W?"?[@F'?Z&v?eXW? A:?? ,%L1?PBl?$n润?Wl?N ?͓E'?#.?O|q@@@@@,@*??????QzNs` ?9\*?ģ-n@f@ua?H"?V搄?$ ? E?Bd>8 -@s#~@@s5?|@sS@s5?|@s$*@s5?|@s)Q@s5?|@s;dZ@s5?|@s @s5?|@qH˒@OA7L@O-V@OA7L@Oqu"@OA7L@OU=@OA7L@O"h @OA7L@OPH@OA7L@UtzG@8hYJ@8c$@4sS@4~@3-V@3p ->@3Tm8@3ao@3Tm8@3`- r@3Tm8@2g??N`?}g?nii)?3!E?+պ???KF?T?mɣ&Z?8烔o?fr[?k8'?$?]-W,?s?qmE@@@@@$@$??????P6x/d?s  -??`8@s@O"Z?l\6??U>b?^@ >+9;Z@fO@@^5?|@^5?|@^5?|@?E@^5?|@qi@^5?|@u?@^5?|.@^5?|@ě@ hr@ Z@ hr@ Q@ hr@ 'RS@ hr@ 6}Vn@ hr.@ hr@ XbO@8 ]ce@8j~@4hr @5I#w@4."@4%@3!.I@4`A@3!.I.NC,@3!.I@36z?oC?Z?бM?j0@8I?N:?sD?o,?0?M0D?=C(@8S?^U?Fp'?K^ -N?'*?5@8 ?$@@@@@?????@&ffff@&@&ffff@'K]@&ffff@')_@&ffff@&IR@&ffff@$ xG@&ffff@#&@\;dZ@\:^5?}@\;dZ@\=!.J@\;dZ@\>($ x@\;dZ@\6!/@\;dZ@\8@\;dZ@\8}H@4~($@4i@2S@2*1@2"`B@2PH@1D*@1qiC@1D*@1u%F @1D*@1ݘ?|b@?Z?3?a_b?EE?_Oo?|h2:?d?36G?j?V i!?VT??9o?sg?Z? 1 D@?Tj@@@@@,@*??????A 1*G?*hb? v Xwv@%@\9+L?Iݎ[u"?@ba.?>?Y)y7@f,{@@MO;d@T9Xb@MO;d@z)@MO;d@l~($ @MO;d@WkP@MO;d@y k@MO;d@gy @Ntj@N V@Ntj@MV@Ntj@M=H@Ntj@M.p:@Ntj@M%2@Ntj@MɅn@7v@7F -L0@3i+ @3>}Vl@2KƧ@2d7@2(@1xF^@2(@1j~#@2(@1PH?[Xxp? ?=EDA?㍠kS? Ë??ٛP?gUm?&cu?=שD?vI?pQiB?fi? $F)?B7? -r -Dw? J?-@@@@@@*???????tD#'@GI?i~|.ۙ? -@\xDž@MI]?Ǫ03?b?K? @d`@@=p -@;S@=p -@AbJ@=p -@=42@=p -@=l@=p -@5f*h@=p -@(Q@̛S@̝/@̛S@̣Z'@̛S@̡b@̛S@̞5@̛S@̗y@̛S@̐@6@@6g@3G+@3I[Y@2)"`@2.F9@1h@1j6\+@1h@1d@1h@1_"@1‚@5@1Sg@1‚@5@1[C%?|B &?2w8?9 2me?hiF?{z?5`?{si?bU'V?nv-?/:?`53?9?1BO2??(?gě?l@?%5?mz@@@@@,@,???????{& ?kn?kHv?А@.@Rv+{?zk -?~??0g+@H=t@\>@@vȴ9X@qhr!@vȴ9X@h]@vȴ9X@}Vl@vȴ9X@xYJ@vȴ9X@g&@vȴ9X@dg8~@ʳE@ʸ@ʳE@ʾQ@ʳE@ʹXbO@ʳE@ʸ4֡@ʳE@sh@ʳE@J@7>6z@7lD@1@1=p -@0Vu@0xl"h -@0?䎊r@0+P{@0?䎊r@0#&@0?䎊r@0$oh?h??ߋb?a6H?rӂ?;?Wf8?}ѿ,?-NI`(?Pт?|lU?SmImb?s?4yX?.x?L%.I0?VK} -?Vá?"r@@@@@&@$??????Tr?v- ?a{yr?a-j1m@pQ&R @;B?3R?CM?݅W{h?M -*@eK.@@{;dZ.@{;dZ@yp -@{;dZ@yσ{J#@{;dZ@y{@{;dZ@yѷ@{;dZ@y*@\(.@\(@M@\(@u@\(@o@\(@/V@\(@ ԕ@5*0U2b.>@3S@1q @27KƧ@0h$ xG@3:,<@/Ƨ@3:,<@/o@3:,<@/حV@8J?{ l?d -? N:?՞e?ե̞@8J?iV?Ž?2}?B ?m,h@8p?  l??}(3?{0?w,?t@@@@"@?????@{dZ@sE@{dZ@B@{dZ@sg@{dZ@nߤA@{dZ@f1@{dZ.@x@hr!@x@ѷY@x@g@x@+@x@/iDg9@x.@8^H@8cS&@4?|h@4D@3V@3]ce@3 k@2 @3 k@2@5@3 k.NC,?sD?/ -?4DA?+?Qv8F@8?}?H{V? Ķ?U/?b -@8?7V/r?qv?et??a%?YI@8 @@@@@,?????@>vȴ9@8bM@>vȴ9@X4֡@>vȴ9@[J#9@>vȴ9@Q_@>vȴ9@/@>vȴ9.@-V@q&x@-V@!-w@-V@7K@-V@u%F @-V@u@-V.@7qiC@7ᰉ@3W+ I@27Kƨ@3'KƧ@2Q@2V!.I@1snP@2V!.I@1nm\@2V!.I.NC,?1j?9)u?eJ>?&L=?Dp@8?UbB2?+Qe]-?H?ߖ_-0?D@8?ԇ:?̈?Rw#{?,Uf{? 2@8 @@@@@,?????@s(@s/@s(@sx"@s(@s7LY@s(@s@s(@sО^@s(@s{@h33333@h33333@h33333@h4@h33333@h20@h33333@h3t{@h33333@h5R$@h33333@h?vȵ@3Q|Q@3Qo@0I^5@@06y$@07KƧ@0GB7@0!:T@0vȱy@0!:T@0.~@0!:T@0jԑe?ȧx?Q>?|]x?|B &?, ?vV?-IGmR?"F?fq{?0xs?D^0'?KO?c—[|?5yƶ\?HL@@*@$@$@;@9??????E\>Ja?=.?? n$d^@Pι.G@9[?\l+?@#e?S}?+@8I@8?sD@8@8i@8@8S@8?E.9@8 *@8p@8@8 @8 @?@yXbN@y+@yXbN@zC\@yXbN@z@yXbN@z@yXbN@w+j@yXbN@x*0@M@M@M@MC@M@MVϫ@M@MI^5@M@M!-@M@M̥zxl@/^@/^@)-@)@@(O;d@(sPI@(b~@(0 )@(b~@(0 )@(b~@(0 )?^Dw'?GA?*"AaI?G?@ A2?:?bM_x? ,C?/BH?@[*^?IM?N`?bMky?~('?q6tN7?avh?O|q?O|q@@@@@,@(??????L\?&?6oG-?$zQ@xY@M̚F?EDj9?3?ذ. 1?a (@s -c -@@lj~@lj~@lj~@l @lj~@l=c@lj~@l@lj~@lm\@lj~@l+ @X@X@X@X״3@X@Xe@X@X߾vȴ@X@X۲m@X@X״3@4=:@4@bvȴ9@b^5?}@bvȴ9@bJ#9@bvȴ9@b#@[t@[t@[t@[zxl#@[t@[Ů1@[t@[A [@[t@[2W@[t@[$/@3]ce@3]ce@1 I^@1n.@1~"@1W>6z@1n_o @1q$/@1n_o @1nm\@1n_o @1n2X?| ?q' -B?^RpX? ?[9,?nM?| ?jכc?tWZ?)@a,?pPȻ???]ivL?3Z\?bv{3dZ?:1?E݋N@@@@@,@*??????EvO$?/_?8VPO?'2U@bބ b@[ą?Xo)?G6\c??Q @f`b@@+ J@9X@+ J@s@+ J@ @+ J@~BZc@+ J@Ƨ@+ J@~(@r @n@r @!.@r @~(@r @.H@r @8}@r @RT`@8Y*0U2b@8G-@3° ě@3.H@3,j~#@3%@2!.I@273@2!.I@2ѷ@2!.I@2а{?3a=?u~?sN?zF?J?,#t?SY?6 a@B?zY@?z?lR?&|? `?x@@@@@$@*???????B뿠?]!P?YO+7#?H]U5@$m -@%^?{o?\%V*? o;?[O@pO~-@@1'.@1'.@1'.@1'.@1'.@1'.@m]-V.@m]-V.@m]-V.@m]-V.@m]-V.@m]-V.@8g l.>@3I^5?.Mm@2j~#.Qn@1̿[W?.NC,@1̿[W?.NC,@1̿[W?.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @߾vȴ@@߾vȴ@[7@߾vȴ@U=@߾vȴ@n0@߾vȴ@Ϫ@߾vȴ@r@j~@1@j~@K^@j~@(@j~@N<@j~@ xG@j~@@5!.@5z@2 I^5@2m\@1-V@1r@1̿[W?@1Ɍ~($ @1̿[W?@1@1̿[W?@1?1j?q' -B?wk?U=K?\o?Vu.Qn@1䎊r.NC,@1䎊r.NC,@1䎊r.NC,?1j@8#@8:@8 >+@8I@8?| @8@8i@8@8S@8? SF@8 *@8p@8@8 @8 @?@ և+ @ և+ @ և+ @ և+ @ և+ @ E@ և+ @ -=p@ և+ @ յs@ և+ @ ըXy>@#$/@#$/@#$/@#Q@#$/@#J@#$/@#m\@#$/@#m@#$/@#m\@2䎊@2 IP:@,-V@,O M@*E@*b@)-C\@)-@)-C\@)- qv@)-C\@)-8[?^6P?GA?"?MA8?ǹT?tJ?bMn?MN ?}?3.Yl?@?Uyu#?bM]f?.+?s@a?avh?O|q?@@@@@,@*??????D=6>y?(}L? _[Y2@ ;fԂ@#_J?7vYf?UdC?kAG}?.fε@sw(@@twKƧ@twO:@twKƧ@tx@twKƧ@txtj@twKƧ@tyJ@twKƧ@tv@twKƧ@tv@n@t@n@ح@n@@n@?@n@ѷ@n@e@8!.@8$/@3; I^@3;҈@2-V@2As@1@1D@1@1@1@1?F^S?'?ϙ?:L -?.Kn?sU Z?)T?0n=Q?pI?.}$?8?GӒ?Z`(?)h??l?E݋N?]ߒ@@@@@,@(??????@5_;>/?@}46z@1V@1!-w@1 [W?@1 \@1 [W?@1 U=@1 [W?@1 ce?|O?m0?.Ү_ ?䆀{6?h|?t?| ? g?tJ??77?Q\?s@a?O?{W?3{Z?&I?ܑ @@@@@*@$??????1R?0ղ?&JPit?0-&@ 1L:e@ -5?F?PMN73?[?57@fP'@@[\).@[\).@[\).@[\).@[\).@[\).@E.@E.@E.@E.@E.@E.@804m8.>@3I^5?.Mm@27KƧ.Qn@26z.NC,@26z.NC,@26z.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @vȴ9@@vȴ9@@vȴ9@ -[Zf@vȴ9@y>I@vȴ9@c/@vȴ9@@}E@@}E@}~@}E@|Z@}E@}vB@}E@{/@}E@G@7!.@7 8@2?|h@2k@0`A@0ef @/N;6@/ @/N;6@/Fa@/N;6@/>I?|"<~~?Ҁ?M8rv??&K?c eW?j?&?X?H?7Oi?7k??p0$?Q[/9?p>?`>r?"K?R&U x@@&@ @"@7@1???????8BXL|? -j=D?8ۃS@¡rt@?*@??̞@b@@@-@@C@@hr!@@ ě@@s@@@'W -=p@'W -=p@'W -=p@'XbM@'W -=p@'WO<@'W -=p@'W -=p@'W -=p@& Ĝ@'W -=p@'V+ @6䎊@6[W>6@2^5?}@2#w@1"`@1Ov`@1 -0U2a|@1 -~"@1 -0U2a|@1Hu%F@1 -0U2a|@1 -L/|?1j?ƿ57?ِ?eU5?Z?Rg.?| ?NۈV(?Kd+?>\? R?A_f;j?d3>?~('?!A -m?E 8?Cns?@@@@@@??????)G/OZ?= _j [?c,@d~F@'Aj?\I}?[9?hu@ga}G@f8@@G/w@G0 ě@G/w@G0'R@G/w@G,<@G/w@G1[W>@G/w@G,@G/w@G,!,@ -=q@n@ -=q@@ -=q@ xG@ -=q@g@ -=q@凓ݙ@ -=q@ڹ@704m8@7,]ce@3Lhr@3Qu@3t@3 -fB@2^6z@2c9@2^6z@2^Ov_خ@2^6z@2_iDg8?Br?d̺?~"?(tUo?ZAj?^m*?F/P5?io?b?j.ӌ?F;[k@G/@[?^toC?g]x>D?i7?HkIm@hh,ƭ@@~#@~#@~#@t@~#@ڹ[@~#@'0@~#@ڹY@~#@0 @ɺ^5?@ɺ^5?@ɺ^5?@Ƨ@ɺ^5?@ĵ?@ɺ^5?@ɠ'RT@ɺ^5?@Ƨ@ɺ^5?@ @3D@3'RT@1c@1dZ1@0-@08}H@0+xF^@0+҈@0+xF^@0-O;dZ@0+xF^@0-/w?| ?Kb?tcj?2UT?g?_ ?| ?I?D?N?,Y?`@0k?٤?3I#i?!A -m?^ a?2[s?oC@@@@@"@*????????Y}?YV@45S@47Xe@3Ͳ-V@33@2:S@2wl@2:S@2@2:S@2%2@8J?I'?3Z?,rg?"m?X@8J?Q_ڸFN?3fvI?)@a,?E?,}oJ@8p?3XMV?((W?J?GZ?r@@@@(@(?????@F.@F.@F.@F.@F.@F.@&x.@&x.@&x.@&x.@&x.@&x.@9~($.>@3ěT.Mm@3'KƧ.Qn@2ޫ6z.NC,@2ޫ6z.NC,@2ޫ6z.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @~Q@~@~Q@~ (@~Q@}+j@~Q@~=c@~Q@}=c@~Q@}u@tC@t=p@tC@tɅp@tC@t)*0U2@tC@tEݙ@tC@tI^5@tC@tIQ@5H@58Y@2+ I@2eO @1tj@1-V@1=ce@1S ҉@1=ce@1ZW'@1=ce@1em\? ?n ?.?T|2?d8?՜u?)T?f?x`In?4=" ?5nM8?&rP'?9@0w?qv?~9n4?VMx?c? # @@@@@(@*???????RQ^>?pn@^a?kJ~@~0nB@t|?{x?2lq@ZEʜ?Ӎmv1N@aCſ@@WO;@W@WO;@ 0 @WO;@0kׄH@WO;@ V@WO;@Ձĝ߼@WO;@?n@o@C@o@0 @o@<~5@o@ݞ@o@0k@o@'9@2ks@2jhL@1 ě@0O @/O;dZ@/]@0J0U2a|@0T8@0J0U2a|@/Qq@0J0U2a|@/4?^(x?ʌ@3 I^5@3Zc@2y7KƧ@2y@18D*@1873@18D*@17>6z@18D*@17>6z@8J?t0?9a?Ac ?2ּ9? ٖ@8J?6c?v@b?!zt9?7=^9?'+@8p?r?5q?"a??_խW?{2@@@@&@&?????@ I@ I@ I.@ I.@ I.@ I@l@ I@\@bM@bM@bM.@bM.@bM.@bM@ Ĝ@bM@bM@2H@2BZc @.`A7K.Mm@.rnO.Qn@-b~.NC,@-b~@-|@-b~@-#w?^Q5P@8#@8:@8 >+?bb<]?R?bM_x@8@8i@8?I?h,à?b@@8 *@8p@8?j?L@@@???@KC@KWl@KC.@KC.@KC.@KC.@KC.@A7K@?|h@A7K.@A7K.@A7K.@A7K.@A7K.@6w@@6yFl@3; I^.Mm@2Ͳ-V.Qn@2OO M.NC,@2OO M.NC,@2OO M.NC,?}x+@8I@8?}#@8@8i@8@8S@8?5\a@8 *@8p@8@8 @8 @?@%/w@%0bM@%/w@%L@%/w@%7r@%/w@%bu%F @%/w@%I*0U3@%/w@%Aaf@Cj~@CbM@Cj~@CN;6@Cj~@C$tT@Cj~@D" I^@Cj~@DH@Cj~@D m@6!.@6@4n@4+ @4?@4`A7L@4- @3䎊r@3b<64@3䎊r@3`oiDg8@3䎊r@3]%?Y͍_?LS{?{?@p?OC?yW?1j?Q/J?.cE:"^?,ў?%L$? D?],mg@@@@@,@(???????wX?YĀ?p,W|'?~٥~@%"@x@xSt@x@w%@x@vFs@x@wRC4@`A7@`A7@`A7@벻@`A7@&@`A7@簳@`A7@`@`A7@/#K$@4 ]ce@4 åH@0 I^5@0sC@0y7KƧ@0zkC@/b~@/yR4@/b~@/+ B@/b~@/x5?|h2:?f?1z?JJ0?jfĀ?>,?}@TΥ?ZNZSB?= :?AE?̶e#?fQ:?F?ZSX?Ψ,UiW??m_?UC5}&@?47h@򁆹?8Ò?qOD?7pú?Z-@mF@@(@CB@(@O@(@Vx@(@Kբ@(@&{@(@P_ @\(@=@\(@BM@\(@Ca@\(@{@\(@X@\(@1`W@8>6z@8&mk@35S@35 @2]V@2[I6$@1n_o @1m@1n_o @1mAq@1n_o @1lЇύ?`^zT?dN?8C)*?w?r? -`?S?1?N7?GvQ?_;? Zr ?FjmY?V&?Nu?2@غ ?ZCM?m~MU?3T?Gg@@@"@*@8@4??????Hk.?F~?(~Դ@YI%@d_?_bD?K}T?-f;?2S1*@mf@@bM@>@bM@@bM@793@bM@L(@bM@QOMo<@bM@'@bƧ@b3334@bƧ@b @ZT@bƧ@bS'f@bƧ@abT -Mh@bƧ@bX@bƧ@b)@9H@9y@@3S@4 -OF@3v-@3/@2xF^@2r<[@2xF^@2ʬ@2xF^@2\s4?eM?Zi6&?v:?v]J?_v?1?m?(?s+\?)CH?R^ ?O *ѥ?ch0??Xj?wXPjD8b@@I^5@r Ĝ@I^5@Fs@I^5@O;e@I^5@1@I^5@2a|@I^5@iDg8@7Kƨ@\)@7Kƨ@S&@7Kƨ@\N@7Kƨ@Ov@7Kƨ@0 @7Kƨ@'RTa@8쿱[W@8׍O;d@5+ J@5?@4tj~@4hۋq@4@4˒:)@4@44J@4@4?qv?i1[?>(lQ ?-?V?}Tv@@@@@*@*???????@?p|;?a~d?c@2$4@34-@RФ?~US"?B\_[?҃ȸ?O"G@gp\R@@jx@<=p@v ?yÅ/?xtbrG?BͶ+?E釋_@j.y@@5\)@5$@5\)@:Q@5\)@:6@5\)@:G@5\)@:?@5\)@9"@ow@ow@ow@oiDg8@ow@o{J#@ow@mhr@ow@nH@ow@mw1@3H@3H@1+ I@1 ԕ*@1Z~"@1[)^ @1!.I@1+ I@1!.I@1lC@1!.I@1 k?|O?E?TS?G?Xe? µ?| ?io??6)}?A?B8?u@>N ?2]7?ZaQ?^ a?&I?v> @@@@@,@&???????Sr5I^ ?9R;?6 pdv@8Q֎@n\?Y -@5D?;_\|T?: ?]L/N@fT@@U -=@UbM@U -=@Um@U -=@UN;@U -=@UiC@U -=@U{@U -=@UbM@!Stj@!Stj@!Stj@!S*0U@!Stj@!Sg@!Stj@!T!-w@!Stj@!R䎊r@!Stj@!S&@2=:@2=V@.\j~"@.\ߤ?@.x@.S@,QN;6@,P`A8@,QN;6@,P'RU@,QN;6@,P -=r?^Dw'??=?Kh?ƠJ-M?\7?6J?bM_x?›?ܿ?wxR?+!?]#O?cPQ?.x?|׿pZ?hB^?pk Y?@@@@@,@*??????D<?Y҆D?. a r`@U%_1@!St?*k9q&?=_"?PYfL?rrj.@sѬ@@t@V@t@/@t@ěT@t@ĨT@t@S@t@t@/_;dZ@/R ě@/_;dZ@/_@/_;dZ@/`- @/_;dZ@/^ߤ?@/_;dZ@/_|h@/_;dZ@/_ح@5-v@5!TɅp@05S@06$/@0tj~@0wk@.V@.W -=p@.V@.W>6z@.V@.WXf?ʎa]?Čۨ1A?"?q@v?E{?2I/?W$B?j%Ra?['?; $?M?{L բD?![?3;?Me_?͓E'?B ?f_Ԋ@@@@@*@*??????U*B[@y"@zC\@y"@yrGE9@2*0U2b@2*0U2b@."`A@.c @-1&x@-/V@-@-|hs@-@-|hs@-@-vȴ:?^XN?Čۨ1A?,fC6?_? g?{@Ctj@CcO@Ctj@C+Z@"@İ@"@s@"@@"@m@"@;K@"@v@7|Q@7*`@3+@31 F@2K"`B@2JoF'@1Ǡ k@1LJ}@1Ǡ k@10H@1Ǡ k@1>c?'Z]&?V#.?B-?V?*^@?]?~Ov_ح?p`Hc? E>?WWM@??ZW?57E?6~A??5q?2 ?&I?Rv@@@@@*@(??????B?>L@?Ǧ O?-!K-@8 6@1z!?.`l?NxݨB\@ 2-V@ x@ 2-V@ @E@ 2-V@ 3Mj@ 2-V@ 1m@ 2-V@ Qhr!@ 2-V@ 7Xd@804m8@7lC@1ěT@1ڹY@0"`B@0 k@0L[W?@0!N;5@0L[W?@0C,@0L[W?@0x?M0?4Ӌ?^?ڈ৑? ?) o*?1 ?.M?D?2}?ZC:;?;/S?$c*?ל?}X?OJI-?TI?x@@@@@,@,???????k?Q?=P'?跒 @ň]>@ 8l2?dS2?S ?:U?,̝b@oF@@1R@1/@1R@1t9Xb@1R@1P}@1R@2?@1R.@1R.@"XbM@"dZ@"XbM@"F$/@"XbM@"E@"XbM@"zC\@"XbM.@"XbM.@74m8@7C@5pěT@5TD@4tj@4aN;6@4}ce@4i@4}ce.NC,@4}ce.NC,?ȉak?ma?߹e/?L@8I@8?3a=?4i?ō26?U @8S@8?Z?gz?[K-$I?'|V@8 @8 @@@@????@ݶE@ݶE@ݶE@ݶa@ݶE@ݶC@ݶE@ݷe@ݶE@ݴ9Xb@ݶE@ݵ '@@@@'RTa@@$tT@@hۋ@@H˒@@b}@4=:@4=B@0r Ĝ@0K]c@0@`A7@0AA [@/L/{K@/1@/L/{K@/S@/L/{K@/8YJ?}ѿ,?Čۨ1A?O%c?ƠJ-M?#6_?ʟ?| ?j%Ra?:?; $?=d^?U3p?2Y0?3I#i?٤?Gϵ'? Ğ?fW@@@@@*@*??????.UQ 9?3?OZ@ݵݝ -@/?SXj'9?9(p`?C\?z?7=^9?.8 -B?6P?9o?m!?sMQ(?7zE?f$x@@@@@*@*??????? a@Ms?B -M?2@PPrR@/a6kj?a02?SEZ?DAĵ?l]@hf%^@@ ]/@ ]/@ ]/@ \?@ ]/@ UXy?@ ]/@ I^@ ]/@ CZ@ ]/@ ?E@p9Xb@pj~@p9Xb@q@p9Xb@pG@p9Xb@p/@p9Xb@p"@p9Xb@p;dZ@3įO M@3ļj~@1ahr @1Y k~@1Ctj~@1:vȴ@0m8@0Fs@0m8@0A@0m8@08YJ?}ѿ,?+W?mGSq?btx=?\?iOL?| ?"T?_M? ?a]?⍄o? SF?:? -tM?aP?♊N?M\@@@@@,@*??????zHq?dX?; -D?55g4@ P:@pP?Z&.?Tۧ?Lk8?@ez;7@@pa@p]/@pa@p`X#@pa@p^@pa@pZu@pa@pg@pa@pa*l@z$@z$@z$@z :!1@z$@zb/@z$@zK/@z$@z5i@z$@zӜ@6qiC@6>` @2^5?}@2CG@1Ͳ-V@110@1B@5@14X,?" -?KZvΰ?>ַ4@sN@@kR.@kR@/iDg7@kR@8e+@kR@Em\@kR@CZ@kR@-jO@2~".@2~"@4sh@2~"@45sh@2~"@3^5?}@2~"@3{@2~"@20 @9I_o.>@4 ě@3ix@3~"@2Ft@25sh@1C@25sh@1쿱\@25sh@1-V@8J?2yH?X M?1?l\LW?x@8J?՚썊?Ӣs?С?D?X1@8p? F2?ڬ??/я?24 -@@@@,@?????@_"@_"`@_"@_@_"@_/V@_"@_Ov_@_"@_Q@_"@_@ ě@O@ ě@@ ě@ xG@ ě@@ ě@fA@ ě@_o @7 xF@7.H@3G+@3A.H@2`A7@2|"h ԕ@1&@1\@1&@1/w@1&@1p:~?Y͍_? e?GM?^t -a?l!-w?iOL?3a=?{c?R?dXM?b| W?9x]e?hE?D>S9?m~Z_s,?[?OO ?q' -B@@@@@*@*??????f]ZM۠?>`?Aۂou@_r &@7)?`0ֈB?aI1_?$C?A!Ť@i{ܕ@@ӍO;d@ӏ;dZ@ӍO;d@ӗz@ӍO;d@ӀPy@ӍO;d@z(@ӍO;d@Ӆ[@ӍO;d@ӉϹUL@L@K/kH@L@L@L@T›@L@90@L@F g@L@IQJ@6,<@6 c{Mj@2sS@2oFMxu@2t@189@2!:S@2" Ue @2!:S@25T>@2!:S@21>xh ?~=?S7<@nh@cx6@@Q@;dZ@Q@$t@Q@@Q@C@Q@&J@Q@S&@{x@{^5?}@{x@{'RTb@{x@{䎊r@{x@{@{x@{:~@{x@{@8g l@8}H@4+@4͞@3-V@3PH@3+xF^@3 -=q@3+xF^@38eO@3+xF^@3A4J?3a=?|1?~#?㬱_?$?MǏr?X?44]t?Fy -? g?WT?`1`W?˅W?;!?M3 ? Ӥ?:? g@@@@@$@(??????\d^?dt?v';@ ԅ}@{zd?8]?sU?&@68o@k/@@DT@D/@DT@F@DT@DU@DT@E@DT@CA \@DT@DM:@~#@=p@~#@o@~#@~#@~#@o@~#@﫹~(@~#@P}@3,<@3af@.{"`A@.zc @-NO;@-NVu@,@,~BZc @,@,}!.H@,@,}IQ?|O?`?*"AaI?뤽??b\?F0?|O? aҹz?|,!?Y?IM?90?oܧ?2a? SF?!ˠ*(?j? -t@@@@@$@&??????G?1[:?(36k?YX@D&@t?H캲d?1d?L Y"?p}R@fe@@zH@+ J@zH@?@zH@|@zH@C@zH@q @zH@c @J$@Jhr!@J$@J[@J$@J*0@J$@J{@J$@J ԕ@J$@J6z@7䎊@7Mj@3I^5?@3TɅ@2Ctj~@2>qi@1:S@1Ⴉ @1:S@1d8@1:S@1_p?q!U? -ܦ%?Z-l?r*?i]i??% ?6S{?EψC?} ?pPȻ?p?AK\ ?nBT?Śn??NVC&?aʕTI@@@@@$@,???????; \/)?e1t ?Mw>e@@Jg?xAsR*?k#?^k?Ν@lY@@6E@EQ@6E@Q@6E@)9Z@6E@D2W@6E@4f@6E@9x@F@ #I+@F@@F@ *@F@%#@F@ -@F@p@7S&@7 @2ěT@27m>p@17KƧ@1%2^@1:,<@14<{@1:,<@17݂bp`@1:,<@16V)eS?nDyB?k_?E??tk?\U?CDb??'2?dw?X`&?)P?w#?6 -?q??cQ?q~y?Zv'@@"@"@@7@3??????Uܛ?QǺ4?F3v?Ez@=g @z?iB RM?[u ;$?MhC?6ړ@nt@@gF@gv@gF@g k@gF@g\(@gF@gα2@gF@gߤ?@gF@g @[V@[-@[V@[ag@[V@[hr!@[V@[҈p@[V@\ -L/@[V@\ oi@6V,<@6TɅoi@3 I^@3Q@3KƧ@3\(@3._o @3@ (@3._o @3'rH@3._o @3#A [?Br?܄ (?reE?:Z2b?vNh/?lg|*?| ?8$ -"?cS?E:PXd?Op?lӪ<?DJ~_?[Ci?M3 ?q+U?_M]D?`@@@@@*@"??????pcU*t?wI?P]?A]<@g@[gv?l?a9?c?Ǘ?U@eJ(@@nP@hr@nP@~(@nP@B&I@nP@C@nP@3*0U@nP@,1&@^x@^`A@^x@^{lD@^x@^D/@^x@^c@^x@^wkQ@^x@^?@7L]ce@7A@4+ I@4 '@3-@4 |@3&YJ@2%2@3&YJ@3 k@3&YJ@3zH?E?&Ը?㰱V?$? s:?ixU3?=fA:?r6 ?çh]?\B9?ĉOi?F}$ ?`yz|a@w[@^yk'?O?y>~e?cZ?wœ@a@@zݲ-V@zE@zݲ-V@z5?|@zݲ-V@zޞ@zݲ-V@z (@zݲ-V@zPH@zݲ-V@zߤ@`A@`A@`A@X@`A@&x@`A@_@`A@oiDg@`A@4L@2zqiC@2zd7@.=-V@.=ce@-]E@-^ѷY@-b~@-=b@-b~@-JE@-b~@-@?^Dw'?[e? 9?*WF?bM_x?%F?NJ?6)}? f?N`?cPQ?l?8*?$H??ˢL1@@@@@"@??????Mf">?+LʥP?0 ->@z@~@?:G3>?>wk?pg{u?t6ҵM@sz,@@=p@˅R@=p@C@=p@]c@=p@˹~'@=p@'0@=p@C,@r Ĝ@sE@r Ĝ@ufA@r Ĝ@u!@r Ĝ@tZ@r Ĝ@t,<@r Ĝ@u!@6H@6ߗ$tS@3+ I@39Xb@2~Vu@2hۋ@1D*@1_G@1D*@1rGF@1D*@1#?Y͍_?p~v]? -NA3?v" ?ҧ?1a?)T?jt?t(??uv@#h\@#h٘9@#h\@#h8@H33333@H33333@H33333@H4fd@H33333@H6@H33333@H/ta@H33333@H,A@H33333@H.v@1H@1\N<@,{"`A@,u; $@,dZ@,-҄@+@+̈́@+@+Ef@+@+:q?^P!?y@?=uF?|?%V772?͎$?bMn?kcc??dc?E?Y|?AЊ?l,?fet1?}]}?u?䲧MJ?yu? )`@@(@(@*@6@5??????Q9n\6_?3[ɾ?5m y@#i=@H.8\?BeZIx?D?W.qm?w O`@sm@@@WH@@@@q@@ڗ@@th@@D@2,C@2,@2,C@23@2,C@2.nU@2,C@2.3@2,C@2,R@2,C@2/g@4>6z@4^+@1 ě@1|,7\d@0j~@0t@0OO M@0C@0OO M@0E8@0OO M@0J4O(?| V?{X`(b?"z?nPE?G(M ?&>7?| V?[A?FW?K.w?`0l?Q_{?K??7q?sw"?sQ? -؇?O@@@@@4@6???????V [??#p?Pp.?0ӎ+@͗@2-OW?oK?P=vȕ)?8?λ@eu/ɂO@@E@E@E@ax@E@\0@E@P@E@/+@E@9-@`C@`Ƨ@`C@`ɓy@`C@` @`C@`HOT@`C@`˜ӌ@`C@`@4v@4L?4@0hr @0u%F -@0-@0@/@0@/@0@/@09h?}@TΥ?^K?=|x;?FB ??^8?}@TΥ? {?p‹?-(?M$r?kƊ?;X8?b@?OX?QBn?Jƒ?<@@&@*@ @8@7??????,ɐ>(k?3zk"N?=۬@iS~@`r?Sa=n?1 wJ-@o@s@o@~J@ ě@&fffg@ ě@#1@ ě@!Cc;@ ě@.ԧ'@ ě@'y@ ě@&mT2@7]ce@7f@3+@3F:`@2KƧ@2^P:}@2m8@2'@2m8@2r@2m8@2Ohh?eM?؃ ?cer`?.?5'š?;  ?uq?kʤ?hajO=?=k?S ?# -з?lN#?8?KWQ?sX?!-C?F= 1@@$@$@(@9@5??????L?*6(?D}s%?R.@;ty@(M?cu?sjhY?ƽCJ0?1I;@jϔ@@g-@}/@g-@m(@g-@n.3@g-@nMj@g-@d7@g-@fYJ@`A@\(@`A@F]@`A@ݗ*@`A@%F -@`A@ @`A@s@5N쿱[X@5A @2G+@2P ě@1PA7K@1TSMj@10@16YJ@10@10*0V@10@1/vȴ:?jqp?bDҼ*?#}i?Jʮ?oNŒ+?=W?)T? /ّ?f? &?x9ξO? # -?8x?˛͇q?`x?GZ?Rv?@@@@@*@*??????q"N!?J0?\R?@ ]@j!@ ?n328ow?bū{?`* ?4@q@@Ƨ@V@Ƨ@ը@Ƨ@2@Ƨ@߫U@Ƨ@7ήm@Ƨ@@$7Kƨ@$JH@$7Kƨ@$7d@$7Kƨ@$ y@$7Kƨ@$lL@$7Kƨ@$+@7쿱[X@7 "<5@3; I^@34F}@2lj~#@2gIa@1_o @2 o@1_o @1Hjf@1_o @1ny?(?3F?d?.{>?Y3B?J"?3<' ?9EC?$W??OR^?j -?$PUdG?ԦO?|~!?aDr?A`l?Ü@@$@@,@8@7??????;I0`?z͂?7_;?E5@ͪ~@$ı|?W ?fȅ>A?Dл?ɮV0~@gL~@@t@ -=r@t@?@t@e@t@8Y@t@\)@t@1@^Q@^S@^Q@^u%F @^Q@^ڻ@^Q@^@^Q@]}H@^Q@]˒:+@3`D@3_Vϫ@/tj~@/@/wO;d@/vE@.C\@.e+`@.C\@.D@.C\@.A?|O?:L -?B 'nr?998?q f?s[z?|O?&uE@?T֩E?R? E!?҃~/[?8*?Q?/X?3_?՘]G?P\@@@@@&@(??????m8ʳr1?`-l?`AtF@ -W@]_?~qA|y?} @ai@6+D@dQ#~@@7K.@7K@Τ?@7K@ίrGD@7K@Β@7K@>BZ@7K.@\(.@\(@r@\(@@\(@k~@\(@څ@\(.@8s.>@4 I^5@4 u!@2j~#@3:~@2L[W?@2gsPH@2L[W?@2Ahr @2L[W?.NC,@8J?Z#'f?a6H?E2#?v@@8@8J?HD?`)Ԥ??{%? aK@8@8p?Em??YVϪ?G]Ja@8 @@@@*????@O;@+@O;@+j@O;@tj@O;@bM@O;@a@O;@!.@7Kƨ@ȴ9X@7Kƨ@Ȍ@7Kƨ@7Kƨ@7Kƨ@Q@7Kƨ@˒:@7Kƨ@Xy=@5p4m8@5o͞@/tj@/tj@-x@-Fs@+At@+v@+At@+͞@+At@+?Ol?m0?(?eU!?g?>?Ol?›?qF?6)}?إ<(?PS2K?٤? -? SF?xqC?pk Y?b/bJ@@@@@*@&???????ұ?*H*??:B@"@ȱ?8V\?;II>?{l~l?0">obLJ?Ce9y?G`@@رm:@9Z?a}qT?e<_%n ?ϻ^4?tID@dFç@@lC@1&z@lC@x@lC@^5?@lC@x@lC@s@lC@㕁&@&x@hr"@&x@m]@&x@@&x@@N@&x@3@&x@4m@4|Q@4ѷX@2r Ĝ@2KƧ@297KƧ@27-@1:S@1ߤ?@1:S@1H@1:S@1cA ?|O?4$?TS?l?/m{?mׁe\?|O?[u?-8?:u. ?JL\?:i?],m,?)F@=@?16?V5z?IT?)L? uEl9@f@@;dZ@|h@;dZ@ -JM@;dZ@tS@;dZ@@;dZ@Fs@;dZ@4֡@4zH@4zH@4zH@5!.H@4zH@5J@4zH@5 ~($ @4zH@41&@4zH@5%@3ks@3k/V@2!hr @2$/@1Ft@16_ح@1Y~($ @1<64@1Y~($ @16z@5Q@1xr Ĝ@1wrG@1U`A7L@1S ҈@0kxF^@0i*0U2b@0kxF^@0jڹY@0kxF^@0jS&?|O?]Û?>\?<ݝ?Pa#2{?4¼?,6D>@ԡP@?T|?L!?0眭?._M@gS1r@@ݩl@ݞQ@ݩl@ݭ@ݩl@ݬ@ݩl@ݬ~($ @ݩl@ݣS@ݩl@ݤe@-V@)l@-V@;dZ@-V@b}@-V@"wk@-V@@-V@rGE9@8,<@8)^@2.5?|@21$/@1_-V@1`:~@0u@0@4@0u@0nP@0u@0?Br?6 '8?&?? -?<_+fj?mׁe\?% ?p RN%?ܿ?,~[?pPȻ? Ӻ^?fr[?p51?6E?q+U?4\ɵ?&f@@@@@*@(???????Z?Ao4;u!?Zb?5 ?P@@ݤ<$@$\?z95?mYޮ?H _?_@j@kOm@@p@p@p@p|@p@p>B[@p@pe+@p@p@p@p k@-@V@-@&x@-@1@-@w@-@ߤ?@-@A@6zqiC@6y_o@0° ě@0䎊q@/|1&@/|쿱\@.73@.$tS@.73@.$tS@.73@.>6z?)T?Čۨ1A?=?Kh?䆀{6?/`?aX?}ѿ,? ,C?)_?e[|(?֧QD?lINՄ?S[D?򯞼??+ ?j?M684@@@@@&@(???????1. ??f?$i=Az?{ha@p@Ms_f?C*2?=w9&?;#?j×@iw@@) -=.@) -=.@) -=.@) -=.@) -=.@) -=.@XbN.@XbN.@XbN.@XbN.@XbN.@XbN.@7쿱[X.>@4{ I^.Mm@4"-V.Qn@3ush.NC,@3ush.NC,@3ush.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @@@@n@@N@@n.@@b|@@~"@2 Ĝ@2-V@2 Ĝ@2:){@2 Ĝ@2<6@2 Ĝ@3@2 Ĝ@2-V@2 Ĝ@4@5,<@5R<6@0hr@0͊ڹZ@/O;d@/y=d@0 -0U2a|@0 -S&@0 -0U2a|@0 -0 @0 -0U2a|@0 -fB?}ѿ,?Qd?\H{gX?#t?u?}?}ѿ,?uie?{d?Hn?M?M\ٓ@??Q?֘>D?$H?7?v> @@@@@$@??????9ƀ?2{-Wp?2:nGg?'N\@I@2(?Rei&8U?GpG0} ?`An ? -"@g4ey@@^Q@^"@^Q@\wkQ@^Q@]/@^Q@` k@^Q@`4m@^Q@_[W@@ A7L@5?|@ A7L@1'@ A7L@\N@ A7L@iB@ A7L@ 'RTa@ A7L@o@7T xF@7RC,@2ԛS@2 @17KƧ@1@1QiB@1QX@1QiB@1P6@1QiB@1PU2a|?=fA:?b =??Њ?ԁ?=W? ?аl?Z?jX? 5Y?T_?# Y?H? - l]?˴C? -r?՘]G@@@@@,@,???????)ʬ{?4?1uj~? r@_0@W?O(?Bm??]s? ~@j6IM#3@@4j~@ȴ9W@4j~@5?|@4j~@Ft@4j~@lC@4j~@_ح@4j~@tO @{lD@}E@{lD@k҉@{lD@^($ x@{lD@~҈p@{lD@X73@{lD@i7Kƨ@8*0U2b@8_ح@3sS@34m@2-@2rM@2!.I@2-@2!.I@2*g -@2!.I@23PH?g;+t?[_P? n+?bfg??,af2 ?sD?A#(?n;I ?ϗX? {?@.??}(2?z?z."?O̙?}Tv?$@@@@@,@,???????22sɜ? PP?d#~87@6`@x?ZObs?xȐ9%?3,59?B\@_n@@\1'.@\1'@8bM@\1'@>"@\1'@1N;6@\1'@?vȵ@\1'@F&@nzH.@nzH@i7Kƨ@nzH@gE85@nzH@gݗ@nzH@nT@nzH@oA@9ks.>@4 I^@4l!.@3KƧ@3TɅ@2:S@2C,@2:S@2u&@2:S@2ۅQ@8J?V,M?Р'?ݑl??O<?WD̷ @8J? {?tP*?R6U?uG<?lӪ<@8p?;WZ?>{~?E^u?E݋N?:@@@@,@(?????@S.@S@041@S@9}@S@@S@"@S@å@Zx.@Zx@ZH%@Zx@Zc@Zx@[5/@Zx@Z$'6@Zx@ZM>R@9:qiC.>@4TS@4_|푀@3`A@3CFO4@2&@24@2&@2^!c3@2&@2<+@8J?7?Vo?E?ߜڪA?>xn)@8J?_ꍴ#?1?xR$;Xy?Qj{?p]@8p?2a??O2??ZP@"@ @@2@1?????@!^5?|@!lI^5@!^5?|@!Iᰉ@!^5?|@!V+ @!^5?|@!b7@!^5?|@!Y"@!^5?|@![W>6@ @ܬ1'@ @ !.@ @`A6@ @ -g@ @ -qi@ @,@8 ]ce@7u"@3ěT@3'RT`@2-V@2ݗ@2O M@2 @2O M@2@4n@2O M@2*0U2?1]?`x@rTPw@@b`B@N@b`B@eQ@b`B@]+l@b`B@ezxl"@b`B@e@b`B@eY@š@ܡf@š@@š@Xf@š@R<@š@o@š@+6@7YJ@7RcH@3 ě@3z1'@2j~#@2Ov_خ@1ce@1 '@1ce@1/@1ce@1WK?uCb?:}T?RsW?㬱_?>&?l8??O?Qrz?DH?]? ? -lqbY?/#?*3?Җ(?V'f?!]@@@@@$@.???????jWe6-)?`$7 -?Yw@bz *@S?v9?̟"I?f?ó@oܪx@@dvȴ9X@dwKƧ@dvȴ9X@dz@dvȴ9X@dS@dvȴ9X@dDAy@dvȴ9X@dt]X@dvȴ9X@ds5@fffff@f,=@fffff@f..@fffff@fD@fffff@V&1@fffff@fSB@fffff@e=@4V,<@4U"@/`A@/%W@/1&y@/v@.kjf@.yC @.kjf@.k%@.kjf@.jEi{?gQ?*?Mք?mO?O࡙2?9H[?|B &? -w\o?Pqlg?Vch?IɻBa?S D?e?޸eq? KK?ͩ&?Jƒ?\3@@$@&@"@5@7???????K0?Sfy?^c@dy<@c);?sB'?>,C?P,@ Q@geD>5@@S@o@S@J@S@@S@1@S@]6j@S@U@al@a_@al@a ě@al@a^5?}@al@a)_@al@a/=@al@aM @7G>6z@7-i~U@2|hr@2 -͞&@1{Ƨ@1\(@0m8@0bM@0m8@0A"j@0m8@07'L?\l6?1?w4f?;6? _?'H? 1Ӡ?FHN?/>?cS?JY&?߭)?϶ ?XԠ#{?;aِ?=?y +5G?jc@@@@@.@*???????U@6?0nD?Ur;?:؎T^@ױ@ah?v(M$?\D?!C܄?FwN@h@@C.@C@ěS@C@ce@C@o@C.@C.@+ I.@+ I@ȴ9X@+ I@S@+ I@{J#9@+ I.@+ I.@3D.>@0f+ J@.5Xy=@/SE@-L/{@.#9@,@.#9.NC,@.#9.NC,@8J?D ?ub5?dҦ 3@8I@8@8J?֤}?h?:h@8S@8@8p?8hz=?+-/?fK/@8 @8 @@@???@aW -=p@aTj~@aW -=p@axl"h @aW -=p@a|N<@aW -=p@acA \@aW -=p@aN}Vl@aW -=p@aYY@Cn@L1&@Cn@U$@Cn@ES&@Cn@Z6@Cn@@4@Cn@ /{I@7>6z@7A@3f+ J@3Weں@2"@2%1@1𖻘@1 xF@1𖻘@1Vl!@1𖻘@1ȴ9Xc??fDb? -ڹ `?C>?vge7@s0{@@ Ƨ@ 7Kƨ@ Ƨ@b}@ Ƨ@s@ Ƨ@>6z@ Ƨ.@ Ƨ.@2(@2`A@2(@29|@2(@21N;@2(@2oiD@2(.@2(.@85S&@8BZc@4 ě@4&@4'KƧ@4N$t@3[W?@3 @3[W?.NC,@3[W?.NC,?}ѿ,? cs?i[?´K - @8I@8?3a=?®?vY'?MV<@8S@8?Tc?C SG?Q?w-@8 @8 @@@@????@3tj@31@3tj@3!-w@3tj@3E@3tj@3l!@3tj@3fA@3tj@3N;@ 7Kƨ@9X@ 7Kƨ@Q@ 7Kƨ@zH@ 7Kƨ@ -o@ 7Kƨ@ ~($ @ 7Kƨ@$ x@7]ce@7"`B@3ěT@36@3>Vu@3?b}V@2Ǡ k@2ƍ@2Ǡ k@2W>6z@2Ǡ k@2ʌL`? ?sI?~"?Att?r {#&?uk=?% ?&O?%c~?_3\?Gz}Y?'qTrQ?GEq?.]L?}??$jB? 3@@@@@*@*??????X}U?'?(^~y?CJ׿@3Gڣ@ I?J?aR?ր?:,@jRF7q@ @S@$/@S@^5?}@S@@S@w@S@@S@@4`A7L@4a7K@4`A7L@4De@4`A7L@4R:)z@4`A7L@4KP|@4`A7L@47+j@4`A7L@4Cw@7H@7@2+@2tJL@1n"@1^$t@1@5@0hr@1@5@0b@1@5@0!.H?F^S?VӋ?|?8~?6@G^?^%VN?Y͍_?d$?AFnDk?yCW?lj?D4f?y\?z?],V??_u?aʕTI@@@@@,@"???????tFt|r?g,?Tݫ'y@􎋂9@4N#'6?)"KX?x `|? -1?ڽH@k3~0@ -@{@{hr"@{@{@{@{@{@{{@{@{U2a|@{@{_@$@\)@$@%F -@$@@$@Y~@$@$@$@$@6:qiC@6;s@2&+ J@2&}Vl@0"`@0#9@00U2a|@0D@00U2a|@06D@00U2a|@00U2a|?}ѿ,?4$?"?2UT?oNŒ+?=?2}?#maЀ?ܿ?uX? ?!U?{? SF?3I#i?~/O?˴C?ad|?7@@@@@,@,?????? p"?,:bE?c&B@{d0@h?L4A}X??t??ߑ;@g4_@ @$/@|h@$/@ *@$/@F -L@$/@~҈p@$/@u?|@$/@/W@+@;dZ@+@Z@+@'@+@$tS@+@Z@+@ )@7`D@7e!.@3J^5?|@36&I@2-@2u@1m8@1.H@1m8@1-V@1m8@1"??Cq?wm?eB?- ?JO?% ?Hk#?cu%+?]~ɺ@?uD?j\SD? uf?1j?Ƌ?'{>?\'jK?sra@@@@@,@(??????&_U~; ?] HX?\?@~6 @?z4= ?jJ?8*@hp@f"p@ @wKƧ@w -=p@wKƧ@wKƧ@wKƧ@w(@wKƧ@x74@wKƧ@vȴ9X@wKƧ@u!@,C@,@,C@-qu@,C@+a@,C@.p:@,C@-8@,C@,@2O M@2O M@05?|@0Vt@/1&@/IQ@0@4@0nO@0@4@0䎊q@0@4@0\(?`&x?$??vHn&?\7?װ*w?bV,?La? -\?Hn?UBi?ٶm?e@'? -?٤? mmsi?ˢL1? -t@@@@@,@(??????O|ɵFV-x:?!{:? =@w@-oG?0z;m?01"?Y|?V$ -@s3I.@ @-V.@-V.@-V.@-V.@-V.@-V.@hr.@hr.@hr.@hr.@hr.@hr.@9G>6z.>@5+ .Mm@4ȓtj.Qn@3.NC,@3.NC,@3.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @b.@b@cU=@b@c]c@b@dQ @b@d_o@b@ds@C.@C@`A7@C@1@C@$ x@C@/@C@5X@9.>@5S@5 W>6z@4ttj@3:)y@3&@3?\(@3&@3S%2@3&@3;C%@8J?#M+l?-gi?5?S?Qڏ@4 -^5?|.Mm@3j~.Qn@3.NC,@3.NC,@3.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @@3333@@̔x@@İ@@Ѝ@@h4@@HW@.zH@V+ @.zH@ Ns)@.zH@'_@.zH@1i{@.zH@9[?@.zH@=n@7:@7%ضF@3 ě@3~eN3@3R`A@3QPf@2 k@26QT@2 k@22@2 k@2]')R?wvHf?'$?i?hRr?ML ?$R?+Y?;}?; 3=;?/eGڭ?vY d?@^?j%?W?;]+?QնN?Y*^?T=sA?#"@@$@&@,@9@9??????S@1DP -r -?u($?ccNk@ϰ@:h?5kH?zɧDb1?iE z'T?ä@nyE@@C@8Q@C@&H@C@A@C@'/@C@\@C@qu@p -@ϝ-@p -@Z@p -@Y@p -@-w1@p -@?@p -@Mj@7e!.@6JL@2@274@2PA7K@29@1ce@1!.H@1ce@1cA @1ce@1 k?sg;?sp?hb?lsC^?<5D|? t??xDž?6S{?fh?>}?+?U-nܿ?((?*Mis?$?Hh'$? # ?D d}@@@@@,@,???????Ȓ| }?x?}ha@ٗ5@-Ī,?.?Pt?ϣM9?γ]@o4I@@\o-@\r@\o-@\\|@\o-@\L@\o-@\' l@\o-.@\o-.@-V@tj@-V@Io@-V@K5 =@-V@qȫ@-V.@-V.@6qiC@6bŞƊ@2S@3#Q@1-@19"@1z,<@1BSb@1z,<.NC,@1z,<.NC,?d?q$?g1?;9Υ@8I@8?}@TΥ?L?..?ur @8S@8?JA0?n?60<)y ?9ºC@8 @8 @@,@(@,????@H7K@H\(@H7K@H@@H7K@H7'@H7K@HA@H7K@H7@H7K@H|,@A7L@;dZ@A7L@te\@A7L@⊚@A7L@c@A7L@gB+@A7L@ 8@2@2hr@/"`A@/ R  @.cnP@._x@-oi@-~G1<@-oi@-9@-oi@-Xeuc?^m d?BV?ǧE1Y? τ?Ax?!d0?b^57K?ĭv?4i:?؈?aCN?B?q ?r?׷>?nom?^?@@&@,@*@<@4???????r??{WL@?cC?k)@H.a@ \?rJTbt?zozr?ҪȚ(Y?E@qa1o@@vȴ@ @vȴ@ A7L@vȴ@!-w1@vȴ@ 4m@vȴ@6z@vȴ@5?|@dZ@dZ@dZ@"`@dZ@q@dZ@dZ@dZ@5W@dZ@S@.[J#9@.[J#9@+-@+Fs@,E@,@,@,ߤ?@,@,"@,@,U=?^Dw'?{j?m?Rw#z?6r In?{@O@&3@O@c$h@O@@8?@8D=@4 ě@4ؤ/@44tj@48:4@2ce@2t@2ce@2@2ce@3aU4?\l6?|?G"e?%Ӏ1?͏!?_!6]?lUIr?:?! h?J~?;QC?dp?Z+}?"/k?4LJ?2c%C?2? /@@(@@&@9@6???????8s?V-\}?Q0+ -iQ?RJo2@!@l?p8q?pV?Q?]& :@ky*@@߀n.@߀n@{@߀n@߫@@߀n@q(@߀n@wKt@߀n@oqr@S$/.@S$/@Sf@S$/@S+@S$/@S1@S$/@S&@S$/@S@9T xF.>@5Lhr@5klX3@4Ft@4C{WgÅ@3䎊r@3@3䎊r@37w@3䎊r@3ЃC@8J?Iܟ? X??D>?-W@8J?)ۣ?)Ŋ?X_uSZ?5C?R/@8p?eta?Ǵi?PP?% ? -c@(@"@@3@,?????@E@ł<4@E@j1@E@@E@/R@E@"[@E@H@ew@ed&X@ew@f q@ew@ef xK@ew@fL8@ew@ffQ3@ew@fW@8@8f7n$S@3+@3w2ٲ@3 -V@2P^@2 k@2/3@2 k@2 Y@2 k@2*if??'ܢ?*?5$Ź?BI%?Bg@p??k<8?»큞?6܄a?S?9 <_?Q?iW?d? @?[-H?Snބ?'Y@@(@*@(@9@8??????{?όH?to]?pf@ɒ@f - ?:? /DPv1?oCW??ž@iu @@k I@f@k I.@k I.@k I.@k I.@k I.@ 3E@ &x@ 3E.@ 3E.@ 3E.@ 3E.@ 3E.@8L]ce@8OVϫ@4+ .Mm@4A7K.Qn@4Eu.NC,@4Eu.NC,@4Eu.NC,?}@8#@8:@8 >+@8I@8?ʎa]@8@8i@8@8S@8?CK@8 *@8p@8@8 @8 @?@RU$@RJԭJ@RU$@Rb}V@RU$@R_ @RU$@Rae@RU$@R_V @RU$@Raǁ@`A@6@`A@_o@`A@ǮzG@`A@Ǻ)y@`A@ u@`A@iE@7hYJ@7ġ:@3 ě@3 =b@2W-@2]cA @1kxF^@1kQ@1kxF^@1l0 @1kxF^@1kl?}x?I}?ᘡ?O!mS -?Ê?69?91 |?j?p-?|nӿ?RA*?Ǝ@@@@@*@.???????v-Tv?TI?O\-@RVݯ@͵i=?tS?pCj9@?2"? @fL@@ѯw@Ѷȴ9X@ѯw@т7@ѯw@ш@ѯw@P*0@ѯw@с [@ѯw@rm^@Y+@^vȴ9@Y+@Nqj@Y+@VE@Y+@R:)z@Y+@JOv@Y+@UXy>@804m8@8/o@4c@4P -=p@3;Ƨ@3.m\@3!:S@3 k~@3!:S@3@3!:S@3 rGE?b?oK?yĪo]?,:? T.o?" ?g;+t?U -?00?$z¾6?vv?mɣ&Z?M~W`?-]?Pk"?k@{?9 ?3 D?IQ @@@@@,@*??????Dcg2?X_C?bU OP -@х"p@R?O3 ?{Hq8?L2N?Ȑ!@khw8@@ȃ%@ȉ^5?@ȃ%@aoh@ȃ%@W -=p@ȃ%@E85@ȃ%@ڹ@ȃ%@|@rn@rě@rn@q֡a@rn@r -E@rn@q҈p@rn@qԕ+@rn@qrGE9@7w@@7r I^6@3S@3U@2ȓtj@2qu!@2@2zG@2@2hr!@2@2;dZ?_pP1?T~=I?\=u?\N?(x/?Zj?us\?Q;v?6eI??MWe]{?_#@k&˙}@@o@ffff@o@$/@o@ݘ@o@7KƧ@o@ݗ@o@n@\(@[lE@\(@[J#9@\(@Y=b@\(@W+j@\(@YJ@\(@W$tS@7[~($@7\1&@3B ě@3F -L/@2tj@25Xy@1𖻘@1`A@1𖻘@1p:@1𖻘@1W?=fA:?sp?Q/ -?W0 ?GBm?1?|O?[ K0R??.? A?kj?Ϸ?"`?}Tz?WhQ?Tj?0&YEd@@@@@"@*???????N*?A?/|u@oN@Yfʍ?^Zd+?QP7,?Ӗ?10P"@iUq@ @@n@@n@@n@A@@n@Ae@@n@An.@@n@?b}@@n@?b~@!h\@!i7Kƨ@!h\@!h@!h\@!i@!h\@!h9X@!h\@!i^ @!h\@!i'RU@2?@2? @/tj@/y=b@.XF@.Y k~@-fL/{K@-fs@-fL/{K@-fs@-fL/{K@-f,\?إ<(?b-x?e@'?.x?2Y0??f_Ԋ?@@@@@*@*??????P@FB?: tD?5ӥ?;ds@@L# @!i.g?Dim?݉MD?gb7N?5)@sD @!@vȴ@5?|@vȴ@&@vȴ@@vȴ@@vȴ@T@vȴ@@_|h@_|h@_|h@_U=@_|h@_hۋ@_|h@_e@_|h@_TɅ@_|h@_3@5쿱[X@5҈p;@1?|h@1䎊@0t@0@/C\@/-@/C\@//V@/C\@/^?Ol??GM?[d?RXFf? d?}ѿ,?f?F^S? 5Y?mEB?ҥX[?],V?=d??!ˠ*(?ad|?*Z}@@@@@,@,???????X5(?DZY `?Oڥtt?3P|@\@_?o\9?Tl̳??S6?2}?4Kl?jhq9?GZ0e;?] - ?X?|O?Zk?ԕ]I?ą6 -?B ?|[z?|׿pY?4?+P?R *n?V^?HmEf@{?@p?vdPU?hr9l?^r׺?߭RT\@g3JYC@$@6H9X@6G,@6H9X@6FL/z@6H9X@6Jqi@6H9X@6G@6H9X@6)rG@6H9X@64@)d/@)b`B@)d/@) ᰉ@)d/@)YJ@)d/@(.@)d/@'U2a|@)d/@(F1@7O M@7Zc@3+@2ᰊ@2Htj@2ߤ?@23&@1t@23&@1u"@23&@1$/?Y͍_??np?CV? T?=%?)T?u(?7%O?p?%8? S?2Y0?P!p?UYC?0 ~??NZ@@@@@(@&??????pA?c'vp?'WPD@6F06@)B?Wd?\Sl ? qL?Xԝ4M@[N(@%@.vȴ9@.E@.vȴ9@.ߤ?@.vȴ9@.n@.vȴ9@.!-w2@.vȴ9@. (@.vȴ9@.,@u@ڟv@u@+j@u@v@u@֡a@u@z@u@u@5=:@5>t@1G+@1GO;d@0`A@0p:@/Bu%F -@/A.H@/Bu%F -@/B\(@/Bu%F -@/Be+? ?4$?"?5~pY5?,I ?CXs?Br?La?ԕ]I?Y? A?]#O?3Z\?˛͇q???ˢL1?7@@@@@*@*??????? 'PgW?$ѧ?* -F@.64@!hL?EG6:n?J c ?qN c?})@iU8$@&@x@1&y@x@'Q@x@!-w3@x@hی@x.@x@#x@xM@xffff@xM@x+j@xM@x @xM@x=p@xM.@xM@xĨT@8e!.@8ZfB@4?|h@4jn@4~Vu@48_F@3ޫ6z@3Mj@3ޫ6z.NC,@3ޫ6z@3҈p;?]?}>?99?Y3ۄ@8I?if}?]?lׁ?dj!"`?vr;?Xx??9cX?|b@?]&?䙣K?9[O??T,?UA|?B?ҕ)L?h| 8?!?Uf@@*@*@(@1@0??????O4p!?6is;>I?" W@M@?VM=Z?C /?@Q u?}꽴j@ff7b@(@|hs@9X@|hs@|j~@|hs@z^5?}@|hs@x}H@|hs@|64@|hs@w@m@/@m@䎊q@m@@m@g@m@@m@sh@8Y*0U2b@8?b}V@3ěT@3TɆ@3t@3 5Xy@2Y~($ @2\hr@2Y~($ @2Ye+a@2Y~($ @2X@?% ?3?פ?W0 ?q?I?~\?@C?v@b?3)10F?pPȻ?Cq?>'?㑏\?eI6?ۮetZ?/̽`?DV@@@@@&@,??????kq1^?L'(?Y3?G[Վ{.@z/t@&s?xS)fg?Vz?f?-j{?tof@qb 2j@)@r-V@w@r-V.@r-V.@r-V.@r-V.@r-V.@6B\(@62-V@6B\(.@6B\(.@6B\(.@6B\(.@6B\(.@6[~($@6aae@3+ .Mm@3j~#.Qn@3:S.NC,@3:S.NC,@3:S.NC,?Br@8#@8:@8 >+@8I@8?}ѿ,@8@8i@8@8S@8?;aِ@8 *@8p@8@8 @8 @?*@ dZ@ S@ dZ@ s@ dZ@ PH@ dZ@ U=@ dZ@[6@ dZ@ lC@M# -=q@M.V@M# -=q@M,@M# -=q@M*#9@M# -=q@M!n.@M# -=q@M%oiD@M# -=q@M8F]@7V,<@7V,<@4{ I^@4zc @46-@4%$/@3YJ@3NU@3YJ@3v_ح@3YJ@3nO??l?d?':?/cե?ĞS^ ?G *ǂ?rnc?6eI?ǧ?D6?w@2I^5?@2}H@1Ctj~@1D/@05sh@06L/{J@05sh@06?@05sh@06z@8J??jhq9?'$5?'ř ?-/ge@8J?l?{d??=d^?äqY@8p?Q?qn?k,? Ğ?&I@@@@*@*?????,@8|h@8~Q@8|h@8~vȴ9@8|h@8'RTa@8|h@8hۋ@8|h@8~vȴ9@8|h@8~"@`A@ ě@`A@nP@`A@p;@`A@ݗ+@`A@u!@`A@@6[~($@6Zc@1^5?|@1ɭB@1i"`@1hy=c@0u@0a@N@0u@0S&@0u@0Z?|O?$?K]4?U*?/m{? $4?F/P5? ,C?}7.?; $?2}?äqY?(?9o?D(p?%ϑ?7? -t@@@@@,@(???????9R?<*p?-ڷr"?8 \#@8N@ Z?N>֊?X" -?("a?I3@h1B3 @-@k@k@k@ld@k@l '5@k@k")a@k@kאYux@k@kX%@!@$T@!@.s8@!@6@!@S-@!@Ct@!@>@6~($@6 0@3 I^5@3h: -@2V@20L@2iB@2v@2iB@2#B'@2iB@2y'?}@TΥ?~q4?[?(?>=d4P? X<-/?|b@?iE=?ڙE?n[>L?Ш?Q@$?S\H?y?H?崐?ft?)Ebw? -:8@@$@(@(@5@2???????e&'`;?_r>?KCZ?@k@ ,Q?}Ŏ?iBP?&?F[,?F4@d&qfJ@.@Vu@VE@Vu@X-@Vu@WXe@Vu@Vu@Vu@T9Xa@Vu@Tj~@vȴ9X@vȴ9X@vȴ9X@u\)@vȴ9X@y k@vȴ9X@z>@vȴ9X@u!S@vȴ9X@yXbN@4*0U2b@4@2xr Ĝ@2w-@1-@1@1m8@1`d@1m8@1 @1m8@1F]c?|O?gˣ? ?? Iy?y%?1a?}ѿ,?[45?Zq?wxR?*v7?Qa C?u@>N ?5?ւ?sMQ(?Cns? 1 D@@@@@@(@(??????6(=Ő?+|?!GsD?0>IA @U,~@wr?@܌v?P.`?j $?? /^@fqG@/@nP@e@nP@QS@nP@tT]@nP@Μ(@nP@GT@nP@%5@5`A7L@5i3@5`A7L@5^s@5`A7L@5f6@5`A7L@5g9V@5`A7L@5bj@5`A7L@5iD@7쿱[X@7(&5@3?|h@3ǀfT?@3`A7L@3^ c@2m8@2@@2m8@24P@2m8@2{|?mё>?L ΋?K?Aٯ,?WPJJ"??Ű?)XZ&?q~[?LJ~:?b??*?(@3+ J.Mm@3`A7.Qn@28D*.NC,@28D*.NC,@28D*.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 1@`A7L.@`A7L.@`A7L.@`A7L.@`A7L.@`A7L.@$.@$.@$.@$.@$.@$.@9N쿱[W.>@4+.Mm@4-.Qn@3&.NC,@3&.NC,@3&.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 2@ǯ-@ǯ-@ǯ-@ǰbM@ǯ-@ǯ-@ǯ-@ǯiDg8@ǯ-@Ǯ_o@ǯ-@ǭ@٫ I@٫ I@٫ I@٪ڹZ@٫ I@٪f@٫ I@٫R@٫ I@٫C@٫ I@٫U=@0-v@0-v@*8tj@*8F]c@)@)TɆ@(̲@(˒:)z@(̲@(xF]@(̲@(ˬq ?^Q5P?[e?ǹT?}?bM_x?r/B?90?9~F?ߒh!?Uyu#?bMky?.+?2Y0?':?pk Y?pk Y@@@@@,@,??????Gsw6?R?%L4Hľ? #ؿ@ǮN@٫x5D?4{Q ?*?d%̤C?O-b4@stA@3@?u?|@?xbM@?u?|@?u!@?u?|@?v4@?u?|@?t`d@?u?|@?uϪ͞@?u?|@?vz@Bl1&@Bix@Bl1&@Bka@Bl1&@Bl/{K@Bl1&@BjD@Bl1&@Bn_o@Bl1&@BdM:@6@@6_ح@25S@25ᰉ@1"`B@1qu!@18D*@19@18D*@19Q @18D*@147?1j?jEP?7' ?UL+@?vX=@Bi4`?YL?s*Ց3?Y ?#i@j0jW@4@fx@h9X@fx@tX%@fx@Xg@fx@K@fx@W.@fx@{:@IQ@IiV@IQ@Io>J.@IQ@IaJ,^%@IQ@I!@IQ@I BpY@IQ@I @5@5@4n@3S@2;@2j~@23@2?䎊r@2"n;>@2?䎊r@2j+@2?䎊r@2Ã?|h2:?oN??Vq?xь8?5R?3<' ?ql?0Ƿ?ޝYI?i?\d?lao?ܫ?y?Y*^?h1^?<9}@@&@ @@<@;???????t1ٙ[Ƥ?Ir렄UC?'J< @zese@I\?cPy?A?lj"Tf?sL@bA@5@1&@A7M@1&@u@1&@@1&@֡a@1&@$@1&@si@(S@(NO@(S@(,1&@(S@( @(S@'W>6@(S@(1[W>@(S@(K~(@8[~($@8TJ@3S@3iB@3q7Kƨ@3^!R<@2̿[W?@2$@2̿[W?@2tSN@2̿[W?@2Z?{?vq[@@@@@(@$??????dr7]H?E,?k$)@H@(Is-?ff:#?[x(?.zX@?j+@hv@6@6a@6w@6a.@6a.@6a.@6a.@6a.@-49Xb@-?vȴ@-49Xb.@-49Xb.@-49Xb.@-49Xb.@-49Xb.@9|Q@9A [@4{ I^.Mm@3j~#.Qn@2sh.NC,@2sh.NC,@2sh.NC,?(eI@8#@8:@8 >+@8I@8?[Xxp@8@8i@8@8S@8?UWci@8 *@8p@8@8 @8 @?7@E@Fx@E@Ji@E@G{T@E@L`Vpy@E@@[)',@E@@ W@;dZ@;@;dZ@p@;dZ@ a@;dZ@ -'@;dZ@A X@;dZ@1j@7:qiC@7;s@3hr @3M=$@27Kƨ@2_yA@20U2a|@23-@20U2a|@2dx@20U2a|@2rk)C?m?b?C?&I$>?zK?ٓ)?| V?Ofo?3ho?,>,?S60?XҙN_?'h[8?ܺ_I?XB:3 -?ɛ~1?Bq?SJV@@,@&@,@4@5??????fLW>qk?bmUx?@F@F:z@ӡ?y<Y:?e,u d?&wl.?U2^@lM@8@C-V@CD@C-V@D+J@C-V@D--G@C-V@D=-@C-V@D'^@C-V@DER@j:^5?}@j3E@j:^5?}@i}z@j:^5?}@ij @j:^5?}@i1?"@j:^5?}@h4Po@j:^5?}@iF@4-v@4* ~@2=hr @1o@1KƧ@1_@1OO M@0`p)u@1OO M@04 @1OO M@0t ?|B &?)!,?0?f?FS?^/r?}#?Zz? ?0 _?-?~|J?Q–e?`1?{Rv? y?OjH?-a@@$@&@$@2@1???????cwq ͫR?lhOh?@D u'@i_5?HH?`7Pu\@M@[>.@dD`@9@{lD@{S@{lD@|ߤ@{lD@|u@{lD@}/@{lD@{=K@{lD@{n@Ƨ@+ J@Ƨ@&@Ƨ@Ft@Ƨ@-@Ƨ@Ƶ '@Ƨ@@2=:@2=V@.`A7@.|@.cnP@.b@.kjf@.jfB@.kjf@.jD@.kjf@.jL/|?^Dw'?°R;?.Ү_ ?lDžN9? f?2I/?bM_x?%F?qF?>\?ڂc?rJs?bMky?Ϸ+?2Y0?8 ^?b/bJ?pk Y@@@@@,@(??????G.}8ɿ?8 -ğ?1?@|*\m@O3?G S;?@V+v?(,66?wj !C@sdBP@:@Q@1&y@Q@$/@Q@ Ƨ@Q@ 7Kƨ@Q@n@Q@@C@C@C@r @C@@C@+@C@Q@C@)_@5䎊@5iB@1r Ĝ@18YJ@0"@0n.@0V!.I@0Q-w1@0V!.I@0P)^@0V!.I@0R3?]?}d?FB:?_B?tXS?5@?:?@x6K,@;@.O@.zH@.O@1@.O@&@.O@5\(@.O@)ԕ+@.O@.H@Ƨ@ΗO@Ƨ@Z@Ƨ@V@Ƨ@j~@Ƨ@R<@Ƨ@A \@54m8@5U=@1r Ĝ@1a@@07KƧ@0p ->@0^6z@0He+@0^6z@0F@0^6z@0Hu%F?| ?F?"Hur?ˆ_?|(?%?F/P5?YP?vp6d?TV?2rz%6?Wf?a?BM?dd ?{B0?WZ?>3}@@@@@,@,???????J:,u:is?T1 -X?gzLB7@/$@?q;?GS ?@-S?t=0`@bZ?@<@c -=q@wsK@c -=q@[t@c -=q@G1I@c -=q@sb@c -=q@^͊@c -=q@X4֡@[tj@[vȴ9X@[tj@[@[tj@[9@[tj@[̈@[tj@[@[tj@[`B@8r@8kz7>!@@3 I^@3,m³ -@3A7K@3 [$5z@2QiB@29a`@2QiB@2H=?@2QiB@2P- r?NAc?NHRp?!}')?xe'?> -; ?+?(-~1?e@ ?#:?4o?Y(? sPf?|f^@h|R@[?wwb?d?y@@o@=@`A.@`A@ov_خ@`A@h ԕ@`A@$/@`A@{s@`A@{Q@Qhr!.@Qhr!@Cn.@Qhr!@9XbN@Qhr!@8l"h -@Qhr!@G@Qhr!@&IS@7.>@3r Ĝ@3-@27Kƨ@2$/@2m8@2|hr@2m8@2wlC@2m8@2w&@8J?5ԗjN?yaR?,?v.?)}U@8J? ?t!?"JÁ!?l?|@@8p?Fۯ/?^)7H?V]9V?3?ymcw\@@@@,@*?????>@g.@g@g+]c@g@g@g@g&,=@g@gC,z@g@g$/@ե`A7.@ե`A7@ѯw@ե`A7@ѓE@ե`A7@я@ե`A7@P'R@ե`A7@4!-w@9}:.>@5+@2XK]c@417Kƨ@18bM@3 k@0,<@3 k@0fA@3 k@0@8J?tH?8ʐ?ҵR24?h?wMIf@8J?3Pj?EE+?L?)>$;?s@8p?њH?~}o_?eL2G?, ?7@@@@@*@&??????A ?%N ?%t-x?:@Mk|@@?NJ@?w_8@r>?@A@1'@#@1'@(@1'@/V@1'@($ x@1'@' l@1'@+҉@kY+@k.@kY+@k -=q@kY+@khۋ@kY+@k~($ -@kY+@k@kY+@k*/@8 ]ce@7\@2+ J@2XbM@2Z~"@2<>@1Q@1ըXy=@1Q@1]cf@1Q@19?J ^?WZwn;?ڿA?A2x?|c?uV`?9A?ly=?A qi?Ѝ`Hi?8}??*?ͥ?KF??i - ?Ƽu? # @@@@@,@*???????`?.G?FZ)?h ba@' P@kun+@?avt??gCe?=@lrM -@B@MO;d@Mhr@MO;d@M(@MO;d@NV@MO;d@M(@MO;d@L@MO;d@LI^5@A7L@n@A7L@҈@A7L@d@A7L@҈@A7L@ [@A7L@ě@0:@0>@,kƧ@,kC\@+?;dZ@+?b}V@*u%F -@*\(@*u%F -@*Zc@*u%F -@*œwkQ?^Dw'??"?ƠJ-M?tXS?}?bV,? -?A)N?3.Yl? xV?h,à?bMky?~('?q6tN7?ʬv??Ѐ>(@@@@@@??????GH]r?/?Z5@M;8@:?'5nu?*˟[?L ̱U--?Om!@s?]a@C@ʅQ@ʅQ@ʅQ@ʂ\(@ʅQ@ʄ?@ʅQ@ʆFt@ʅQ@ʆ]c@ʅQ@ʃ @0 I^@0S@0 I^@09X@0 I^@0&@0 I^@0F]d@0 I^@0M@0 I^@0TɅ@5*0U2b@5JD@2+ @2I^5?@2j~#@2 M:@2L[W?@2R-V@2L[W?@2Phۋq@2L[W?@2PA7K?| ?[ew@ʅ"h@0Yg?W#[H?79mܵ?M:?vVqX @e;@D@@n@@A7L@@n@=8Qf@@n@?2zZ@@n@?}5@@n@8@@n@9N.@ix@hr -W@ix@m@ix@Ą\@ix@ĄGC@ix@t@ix@sm@42@43ͅ^L@0hr @0Xu\x@/O;dZ@/n@/73@/Y@/73@/8\h@/73@/sJ?}#?%?J}+&n?}?o@%?WlH?| V?T}?U??"X?+ߊ?J?Ixd?w:?]ޭ*~6?G2ag?*?Q@@@(@"@"@0@.??????Vd~?qY~mY?AqN?g>UVK@=N@q}e?`m,F?,! Sd?]Sp@Rciԃ@efqk@E@jfx@jg+ K@jfx@jh@jfx@jjW@jfx@jh@jfx@jf,=@jfx@jeڹ@Stj@Stj@Stj@SPH@Stj@Rs@Stj@Q@Stj@R Ĝ@Stj@QiC@3@@3 ԕ*@0@0g@/nP@/s@.Xy=@.2a|@.Xy=@.L_@.Xy=@.O M?|O?_?S[?'$5? g?-tT?| ? H?d0R?]bn~?A B{?sx/T?nwf? -?YF??L? -t@@@@@(@,??????7P4JiF@?1 ?wF @jg$;4@Rj?Q~`qm?<$ ?tm?V;+@f˟@F@ě@$/@ě@E'@ě@ [@ě@J{"@ě@Xߊ@ě@N%N@8 I^5@8 I^5@8 I^5@8 B@8 I^5@8 ;߼@8 I^5@8 1&@8 I^5@8  -%@8 I^5@8 ,d@-zu%F -@-zu%F -@&"@&Fs@%dZ@%qu!@$fL/{K@$fV?@$fL/{K@$fYJ@$fL/{K@$fL/{K?^j?ܸn?3:??FB ?y&?O?bMn?F?})"Ҫ?2^? mv?J W?bM]f?.?n3?xFD?[J?I@@&@*@*@<@:??????=fI>0?!$Owj>L]h2]>@e+@8 D'?0{2x8>fuy?ZEe>G=@s [g@G@k Ĝ@kw@k Ĝ@k0M@k Ĝ@k>Fe@k Ĝ@km.@k Ĝ@kbM@k Ĝ@k״3@Ձ$@ԯO @Ձ$@a5@Ձ$@I(2@Ձ$@ĔA@Ձ$@ȴ9X@Ձ$@˟U=@4H@4_q@1R I^5@1E8@0Ƨ@0I^5@@0u@0m@0u@0oo@0u@0p- ?}@TΥ?Ɩw1?m s?.@miz?i]i?SJ?|B &?X?=?N0?I0B?ҥX[?`P~V?{6?^6?\T?7?՘]G@@"@&@&@ @??????uPf8 ?C92q?Tғ@ke@'r?b޻w?tTk"?~W?Ay4@f͌@H@5lC.@5lC.@5lC.@5lC.@5lC.@5lC.@"49Xb.@"49Xb.@"49Xb.@"49Xb.@"49Xb.@"49Xb.@6(YJ.>@1?|h.Mm@0-V.Qn@0_o .NC,@0_o .NC,@0_o .NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 I@r-V@o\(@r-V@cS&@r-V@c -=r@r-V@b`C@r-V@g@@r-V@eO@_M@_PbM@_M@_B I^@_M@_Jo@_M@_9|@_M@_;qu"@_M@_:@62@6/O M@3uS@3j0U2a|@2Vu@2*@2m8@2y=c@2m8@2ڹ@2m8@2bM?Y͍_?)D1?0??q?V?Ol?њH?低NU?ZpÉ?ݤ`i?ք5?T0?vv?fr[?!B?o?h@@@@@*@&??????cUu6#2?Rxd?N*@i ز@_F7?q V>\?my?(l ?erW@e5mz@J@ᙙ@1&y@ᙙ@>B[@ᙙ@ᚬ>@ᙙ@J#9@ᙙ@#x@ᙙ@ᙦ @+@+@+@e+@+@}I@+@ڹY@+@e,@+@>B[@8۹~($@8@1.5?|@1.@0;Ƨ@0;C\@-PH@-PH@-PH@-&@-PH@-33334?NIɮ?j"@vE@S@vE@0@vE@`A@vE@H@vE@@804m8@7}jOv@5c@5]K]@4-@4"`B@4z,<@4^_o @4z,<@4i'RTa@4z,<@4l>B[?\<4??-sA?a?k;?gUaJ?,? KBI?Bȅ?1?OY?%TUx?:B?:?^&Mka?ڧ?Q, -?.P@@@@@&@(???????3Xݏy/ ?XH?@b@i??@k0?L6G?߲n@t@M@j~.@j~@pw@j~@ڙ@j~@u]@j~@>-@j~@@1&.@1&@Ḙ@1&@"C8@1&@JO@1&@\(G@1&@@84m8.>@2 ě@1Nɶ@1,j~#@0qyR@0B@4@0z@0B@4@0%Jb@0B@4@0R߫g@8J?v>F? v??C4-k?.[@8J?G̲f?tDig?It?E?qjߢ@8p?*??Aeǘ?q?sc`D?0~6@(@@$@<@:?????N@0w@0- @0w@0͞@0w@0C]@0w@0-@0w@0- @0w@0 @\(@KƧ@\(@aoh@\(@Y=c@\(@[q@\(@^ѷ@\(@]p -@8 xF@8\N<@3hr @3_p@2`A7L@2u@2 -0U2a|@2 -ݘ@2 -0U2a|@2 ҈@2 -0U2a|@2 P{?qn?ly?TS?v" ?r {#&?=?ȉak?YC?f?WA?SY?VT?E}?ˇ?v'X?VED?l?_u@@@@@,@(???????2<`?fY?#DzOB?U߼@0%5@@Z~?@)"T?ld Q`?z/?*:o@nee@O@7Kƨ@~bM@7Kƨ@~V@7Kƨ@@N@7Kƨ@~[W>@7Kƨ@~@7Kƨ@~qj@(\@bM@(\@Mj@(\@|@(\@TɅ@(\@ӶE@(\@غ@6䎊@3&x@2^5?|@0^vȴ9X@2i"`@/āoh@2~($ @/v_ح@2~($ @/eں@2~($ @/vȵ?1j?UW?MDe?F?Fǥ?yW?}ѿ,?&ژ?j{X?QPL?Z?74l?zny-g?J??hc?N((?8wx@@@@@*@$???????@V.?eH>?c]z@~LSQ@9p?]&t?tS?۰@>Pr@bu @P@rM@rMO;d@rM@rNߤ@@rM@rPU2a{@rM@rPbM@rM@rQm@rM@rR@m Ĝ@mE@m Ĝ@m3333@m Ĝ@m1@m Ĝ@mC,@m Ĝ@m@m Ĝ@mhی@2g l@2tj~@0E?|h@0AA [@.O;d@.bM@/@/v8YJ@/@/v@/@/vȴ9X?OW? ?Gk;m?{O`?uxY?I?;0?$i %h?mK?.?4{?vMUu?!?Ϸ+?YF?0?ad|?oC?@@@@,@*???????I7ݖ?O_N?dv?G+>YI@rQYd@mWٲ{?(X?U+?EA?dw"z@sqgA@Q@!Gz.@!Gz.@!Gz.@!Gz.@!Gz.@!Gz.@}7K.@}7K.@}7K.@}7K.@}7K.@}7K.@9~($.>@4?|h.Mm@3j~#.Qn@3[W?.NC,@3[W?.NC,@3[W?.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 R@ܛS@ܜ1'@ܛS@ܜ墷@ܛS@ܢc@ܛS@ܣmS]@ܛS@ܘ@ܛS@ܙ@Zx@Zx@Zx@Z[ @Zx@ZA@Zx@Zma-i@Zx@Zg]@Zx@Z&@1!.@1/¨@0^+@0^`Ċ@0 -V@0 =Ƣ:@0#@0%Wި`@0#@0$9n @0#@0#Q?^6P?=L?m s?3H+?,kc?ҸQgv?b^57K?!SP?U?xx1?̴>.?^|&?t4n?UQx̚?\3?jN,?{j?¿'@@*@*@&@8@1??????b4J{P/?L߆0?0,@ܝU_@Z ?[]??L59?ߪ+6 ?t5k@s -@S@j~#.@j~#.@j~#.@j~#.@j~#.@j~#.@ I^.@ I^.@ I^.@ I^.@ I^.@ I^.@8YJ.>@3^5?|.Mm@2gKƧ.Qn@1:S.NC,@1:S.NC,@1:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 T@7/@7p -@7/@7ݩ@7/@7$ @7/@7ݮ%@7/@7Rs%@7/@7L@j~@j~@j~@n&c@j~@t:@j~@\ak@j~@@j~@(@5䎊@5:S@0i+ @0iMb@/;dZ@/@.fL/{K@.fw6̷@.fL/{K@.f4G$@.fL/{K@.fC0?|b@?>J|?@5$_2?4!?6?cIS?}@TΥ??>?1x?!WSm?Wf?o,qV?7)?v#0&?$: ?%9G?(Y@@,@*@(@<@:??????xC3@?6(A>? #@7E@'G?5"JT?F,?xQټSd??5|FF@g -~=@U@8V.@8V.@8V.@8V.@8V.@8V.@j~.@j~.@j~.@j~.@j~.@j~.@8`D.>@3^5?|.Mm@3'KƧ.Qn@2!.I.NC,@2!.I.NC,@2!.I.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 V@#LI^5@#ES@#LI^5@#N+@#LI^5@#QiB@#LI^5@#M(@#LI^5@#N.3@#LI^5@#LcA!@1&y@t@1&y@ :@1&y@Z@1&y@:@1&y@E@1&y@g@6r@6nzG@3xr Ĝ@3w#@2ttj@2tJ@2\Q@2\cA \@2\Q@2_?@2\Q@2]\?G *ǂ?O9?mr?\2?cc?S{d?}ѿ,??rVx??^?⍄o?dҦ 4?? - l]?hSp]?b? ;8@@@@@,@*???????M#R 6?Kw??nW:@#LF;v@v?cˡ`?d@,?tjw?PߓZ@mݤb@W@>".@>".@>".@>".@>".@>".@4|hs.@4|hs.@4|hs.@4|hs.@4|hs.@4|hs.@8B䎊.>@3|hr.Mm@2KƧ.Qn@2!:S.NC,@2!:S.NC,@2!:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 X@8$/@8Ƨ@8$/@8u@8$/@8(@8$/@8pY@8$/@8]Q@8$/@8__@bvȴ@bvȴ@bvȴ@b?D@bvȴ@b f@bvȴ@b@bvȴ@b I@bvȴ@b.*@5%!.@5&ʌ@2+ @2˜@27KƧ@2g1b@2u@2EPC6@2u@2TT@2u@2gKo?}#?C`? HCP@?Qð?,92d?[?}W?}^?k?mu?y?)lv?xk?c%?RǶh?2P?Jtѧ'?ۑD@@,@(@&@8@8??????SS8Jh?3Y gm?4x^@8@bZ?RCu#?TT ;6?)bZ?iN#l*@f ձ@Y@;dZ@\(@;dZ@@;dZ@.3@;dZ@n@;dZ@~($ @;dZ@E@z ě@z"`B@z ě@z A7L@z ě@z@z ě@z!:@z ě@z" I^@z ě@z!@6#g l@6#n.3@1@1tj@1K"`B@1K~($@0ޫ6z@0v@0ޫ6z@0ߗ$tS@0ޫ6z@0+? ?hX*?,fC6?=]. ?h|?.'?)T?6S{?I?j?qN?ey?]?=d?T?RJ? Ğ?&I@@@@@&@,??????N+0?4ؖq!#?##\@O~@z"B 7?U%?CLa}?}'UW?@T@ib]@Z@ (@ @ (@ Xȷ@ (@ B @ (@ x@ (@ j09W@ (@ S@t -=p@t@t -=p@sȏ@t -=p@sB5W@t -=p@t%bW5@t -=p@t(Vns@t -=p@t3_E@5w@@5oH@@1S@1=7@1U`A7L@1^+&`@1s&@1" @1s&@1vl@1s&@1s꣊?~Ov_ح?2o?v= ?֟"? p)/?m?|b@?"HS??g-?z7{?U:0?bc畯?hk?\͑i?CER?&?Ɣq?=L"@@$@ @$@:@7??????etk ?hqxS?[ra?.ϒS/@ ܛ@t&A?y?MTNrI?Z[?6D(@dKWkF@[@Xtj@X^5?}@Xtj@XK@Xtj@XY@Xtj@X5@Xtj@X&ɁF@Xtj@X .@$/@{) -K@$/@@$/@A"C@$/@O@$/@Ha@$/@Q@7 xF@7ٔb@1xr Ĝ@1vu@0,j~#@0*#l^@/#Z@/@/#Z@/BA9@/#Z@/R1q?_Kt?ZUb?9D{p?|?; [?NpI?o"?;q?0?s8? ??yѿ?zbH?~m?dt?E?Bz6?$M@@*@&@(@7@8??????O?R:p?D.XV?Dz/"@X@?6_T.n?d@"?u 1i?cH@i ,n@\@߶ȴ9X.@߶ȴ9X@ߒ-V@߶ȴ9X@tzG@߶ȴ9X@GK]@߶ȴ9X@1 @߶ȴ9X@W1@WO;.@WO;@xtj@WO;@Jڹ[@WO;@$/@WO;@H9X@WO;@iy@9_o.>@4ٺ^5?}@4*0@4-@3_o @3@3- @3@3b}W@3@3%F -L@8J?~7* ?G?"d?:N?>͛@8J?Qe?&E֫?BS?">?eI@8p?Fu?k pē*?LD?TS?J*@@@@$@ ?????]@yXbN@e@yXbN@v8YJ@yXbN@z~@yXbN@y0 @yXbN@w@yXbN@xl"h -@,1&@7O;@,1&@*0U2a@,1&@%Q@,1&@*0@,1&@)Q@,1&@)ԕ+@8*0U2b@8Ұ ě@3° ě@3ȆYJ@3."@34S@2iB@2zxl"h@2iB@2RT`e@2iB@2R<6?|O?ʖSS?b? ?Ԧ?n?4<7?ٛP?iCv?HD?h?[h??eBZ?G?qlPg? -e?p=J?OO ?+`ȓ@@@@@*@*???????s,,xc*?Sص* j?RJ@t.o@,?x?X2@@@@@@,@&???????u  ?U8y4z?Zw^u@5 -@dEA?qb/D?yQCqݳ? -?V]$4@i7,7@_@kR@@kR@sMj@kR@"`@kR@\(@kR.@kR@ ѷX@j~#@!@j~#@@j~#@WKƧ@j~#@A$0@j~#.@j~#@Y|@8|Q@8LQ@4)+ @3b}@3-@3 !-w@2xF^@2B&IR@2xF^.NC,@2xF^@2@5?ȉak?B};?>9B? @8I?ric,?&"?yCN?Eʻ)?4Uo@8S?Av"_+S?MM.?G^~?bfU?%)@8 ?J6Л@@@@@*?????`@;dZ@8(@;dZ@T4M@;dZ@=#@;dZ@:S/d@;dZ@; -YL@/5?|@0Q@/5?|@/)c4@/5?|@/j¹@/5?|@/ܵg@/5?|@/ݳ,~@/5?|@/z@8!.@8Jߦ@3?|h@3S`@2A7K@2Nr@1._o @1.,fX@1._o @1.@m;@1._o @1. ?CbyV?dc:N?^?g.$W?j eI?i?$/?6c? -rmH_?f|w?,4N?x4??S?yj?={:?Y#A2?Sͨ@@"@"@"@5@4???????? %qmh?@jl?\zQ[@:Ϗ@/w?`(q?wY;m?2[7?^"{Q@l~@a@ -=p@ -~#@ -=p@ ~(@ -=p@ Ƨ@ -=p@ L_@ -=p@ TɆ@ -=p@ Dg8@V+ @Vȴ9X@V+ @VϪ@V+ @VC@V+ @WXe@V+ @WX@V+ @W>6z@1-v@1-hr!@,-V@,@+dZ@+q @*At@*O M@*At@*\(@*At@*\(?^Dw'??N?8v?Ot?>?bV,? -?rJs?/Z?%y*=?X78?rTg?~('?u@>N ?~\?#.?Ѐ>(@@@@@,@,??????U ?Bǽ^NK??<] @ -B&@W<`?Rd8ӿ?!CGt? + :?:%M@sa@b@$@A7L@$@jW@$@o4֡b@$@doi@$.@$.@@T@@fA@@[@@tS@.@.@9mv@6/hۋ@5+S@5p:@4 -V@4@3s&@3O{J#:@3s&.NC,@3s&.NC,?]?C\ P?6\9?ݡu(r@8I@8?]?qӡh?Qrz?Җhn@8S@8?*wjs?};?|?1R@8 @8 ?@@@????c@9XbN.@9XbN.@9XbN.@9XbN.@9XbN.@9XbN.@ 7Kƨ.@ 7Kƨ.@ 7Kƨ.@ 7Kƨ.@ 7Kƨ.@ 7Kƨ.@9*0U2b.>@43S.Mm@34tj.Qn@2.NC,@2.NC,@2.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 d@ -=q@5?|@ -=q@e@ -=q@p:@ -=q@@ -=q@d@ -=q@64@*E@*\(@*E@*Y~@*E@*+k@*E@*j~@*E@*@*E@*:)@7H@7*0U@3I^5?@3C,zx@2"`@2Y@20U2a|@2@@20U2a|@2_o@20U2a|@2!-w2?Br?p~v]?5$?o]އ&?ԁ?zWmo?h??uie?K54;?8h\?h_N%?I?p-?P!p?֘>D?gtH?Xk-7?♊N@@@@@&@(???????4R?:W?R?]6̳ @3L@**?t?%i?y(:?1z7?ԙ>@jt@e@ Ĝ@^E@ Ĝ@*@ Ĝ@; G@ Ĝ@@ Ĝ@,ln@ Ĝ@)]@i\)@i-@i\)@jy@i\)@j£amO@i\)@j-@i\)@jd47 @i\)@jE6@7 ]ce@7 (W[D@3@3 +@3~"@2%pT@10U2a|@1#$@10U2a|@1]Q@10U2a|@1uO2?F$?Ѥh?)?֣?T-??nOE@+@M?PR+?vn?J?z&6?=pE(@lX°B@h@hs.@hs@wk@hs@凓ݘ@hs@@hs@ k@hs@e@5?|.@5?|@P- @5?|@4*@5?|@Zc@5?|@U\)@5?|@^%@;4m8.>@6S@6 k@5-V@5}cA @5 [W?@4@5 [W?@5$0@5 [W?@5@8J? `?NJL?W?W07q?TA'@8J?I`?5~B?շL?*-@s3?87@8p?SY~?V 2?ih?0C?57@@@@(@*?????i@[S@[S@[S@]!.I@[S@]/@[S@]ce@[S@Z@[S@YY@+ ^5?@+ l@+ ^5?@+ @+ ^5?@+fB@+ ^5?@+ l@+ ^5?@+@@+ ^5?@+@@3 xF@3%1@/t@/E@.nP@.@4n@-N;6@-U2a|@-N;6@-GE85@-N;6@-GE85?| ?1?\H{gX?8v? f?6J?|O?5CQ?['?N?qN?ȏ'T?n88?§d߱?٤?8 ^??b/bJ@@@@@,@(??????+_}@W?7r{@?"!@[j@+?W87?BmWv?}o??r@f(@j@bM@@bM@!-w2@bM@n;5@bM@K]@bM@eݗ@bM@c%@q^5?}@r@q^5?}@q]c@q^5?}@q"h @q^5?}@q}V@q^5?}@qE86@q^5?}@q&x@7įO M@7?@3I^5?@3ʌL_@3"-V@3-Z@23&@2Q`@23&@1GE85@23&@2ěT??d?zeߎ?)[fI?-; ? ׅ.?^*?x\Fp?>4g9?y/2v?0-+?|:?zk 3U?3E?N0?FE%5?zl?hcӗ@@@@@*@$??????R\@?xΑ?G|2@%6@q |? -J? #wy?GFz@-_nj@d@b~@k@_T@_T@_T@_u@_T@_*@_T@_zxl#@_T@_q@_T@_e@`ě@`ě@`ě@a@N@`ě@`D@`ě@a [@`ě@` k@`ě@a-w1@0H@0;5Y@-V@-:@-&x@-`A8@-873@-8- @-873@-873@-873@-8}H?^Q5P?{j?1f_?q@v?DE??bM_x?#maЀ?pM?>\?@?h,à?cPQ?3;?y8$?':?b/bJ?pk Y@@@@@@"??????Ju>I(K@?81?uϹ@_-_@a.?,T?+c?T݆?5삭i@s7@l@UC@UI^5@UC@UK@F@UC@U1@UC@Uz|r@UC@U*@UC@U#-@F I@FƧ@F I@FEԩ@F I@Fs[@F I@FᏭ[@F I@F) Y@F I@F䭨@4>6z@4AեS@2 I^5@2^@1v-@1f?b@1L[W?@18 }ʴ@1L[W?@1>b/7@1L[W?@1>R?|b@?u$M?)~ϙ?O?U'-?)C"f ?|b@?V)o?P3b东?Fq<?Fj.%?7n??/$??'0S?VLS?: ?=B-@@(@@(@9@8??????gf]A?V p?O>N@Ui@F*8?tl7y=?lzQM+?84a?QRF#@dK@m@AGz.@AGz@A,@AGz@AI^5@@AGz@AIx@AGz@AVȴ9X@AGz@A9+@zG.@zG@$@zG@E@zG@v@zG@fA@zG@+@7|Q.>@2° ě@2H˒:@1j~@1oiDg8@1G k@1E@1G k@1?.H@1G k@1@*0V@8J?F?!N?eU5?;"?;@8J?I?;,?RLnj?S?X78@8p?Fp7?(?XW~?&f?WZ@@@@@?????n@>".@>".@>".@>".@>".@>".@E.@E.@E.@E.@E.@E.@9T xF.>@4hr.Mm@46-.Qn@3n_o .NC,@3n_o .NC,@3n_o .NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 o@Q@@Q@1&@Q@"u%F @Q@Q@Q@t֡a@Q@k6z@O;@)^5?@O;@W@O;@O:@O;@d8@O;@+a@O;@(ۋq@8,<@8_ح@3 I^5@3*ڹY@2t@2[q @1@1G{@1@1$tS@1@1g?}?ӻKL?$VL?M. j?RqJ ?õ"- -`?d0R?1'7? 5Y?eDQQ?^?6?S? -t?L8AS@@@@@ @???????@6t?0F+/p??&& ?^\@X4@s?^?:^#9s?1gt?O%@gVϯ @q@r @bM@r @iB@r @@r @@r @+@r @VR<6@v2-V@v+R@v2-V@v>m\@v2-V@v7O;@v2-V@v9>B[@v2-V@vF@v2-V@vU*1@84m8@833334@4#@4@3$j~@3L/{J@2Y~($ @2Cݗ+k@2Y~($ @2?@2Y~($ @2?ٛP??X^ -1?~]?dY5?τˎ^*?UbB2?ङm?c?-ʴ?XDo|?Mp?+ʄ?RHֿb?((?Cmk? Ğ?A@@@@@,@$??????̇|@?yu?f^o-o?F>z@e@v77i?Ӌ?bh$q?\GD?.qTX@dBØ@r@^Q@a$/@^Q@~5?|@^Q@h[@^Q@lC@^Q@HXy=@^Q@Zu%F@ t@ lC@ t@ @ t@ E@ t@ $@ t@ lC@ t@ pD@6 xF@6ԯO M@4+ @4J@4_-V@4ZڹY@3YJ@3u%F@3YJ@3wkQ@3YJ@3??1j?u~??:?'`?@?F/P5?'?ZH|:?;A?6?!kz7?䁜?{_?qyi?@ꘄ@h@t@|h@n@|h@k)@|h@3@|h@2@C@Yj?q{?uM?l{?iy?b?@f :`;@u@CI^5@Cn@CI^5@CDg8@CI^5@Cws@CI^5@Cp$t@CI^5@C|wkQ@CI^5@Cs@Q@DT@Q@J@Q@<@Q@ O;d@Q@הj~@Q@Wr@7s@7?|h@4)+ @41@36-@3kU=@2,<@3z>C@2,<@3c @2,<@3sh?Br?:A{o?%=O>?T?U(?^??Ř?I\8S?qƑ?25?R9y?<?hB?5?S~iX?|?@@@@@*@,??????Aݍ} ?&@?q5C{?ynSF@C#Gv@L-۬?疟e?'4D?Sw?*?@]sY@v@lD@$@lD@U"!@lD@!"f@lD@3}@lD@ @lD@0,@Ƨ@+\:@Ƨ@үS$@Ƨ@:n@Ƨ@Ѿ_@Ƨ@@Ƨ@hT@8_o@8*c@3+@3u)Hl@2`A@2{c@1!.I@1baZ@1!.I@1UvE@1!.I@1?R?5 S? }?R?ynS?U2L?.EZ?4zs?(cf{?Ïb?"I?GEP@@@@@4@(???????\-D?WDo?S·J{^?g=O#@2 mэm@;?n [!h?{댨5?ҿSU?'y@p~ D@y@a@l@a@S@a@MjO@a@TZ@a@T$@a@WsO@ -=q@-@ -=q@ ě@ -=q@ק'@ -=q@u@ -=q@ᰉ'@ -=q@oiD@7@7MjP@4}hr @4~qi@3y7KƧ@3y_o@2@2~%@2@2s@2@2dZ ?^*??[;b@@"@"@(@9@7??????a]?j /?<9İ@oYb@kB?=F?.9@"pm@(dVQ+R@aK[G@}@V.@V.@V.@V.@V.@V.@;dZ.@;dZ.@;dZ.@;dZ.@;dZ.@;dZ.@5qiC.>@3|hr.Mm@2M-V.Qn@1O M.NC,@1O M.NC,@1O M.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 ~@3E@3@3E@/-@3E@,cA @3E@L@3E@U*1@3E@\PH@wKƧ@w -=p@wKƧ@w'@wKƧ@o@wKƧ@=c@wKƧ@lC@wKƧ@+a@3>6z@3RT`d@05S@0._o @.ΗO<@. qu@.L/{K@.ae@.L/{K@.S&@.L/{K@.F -L0?|O?I'?1?&L=?X?|x?|O?M7F?I?-w?:S?5?|׿pY?QdЈ?5q?c^)?4\ɵ? uf@@@@@,@,???????SÀ?%,?7~"-?Qc^zW@;̧@t ?H] ?b0d!^Z?>!j?7 f@] a@@zG@ I@zG@/V@zG@Ձ$@zG@ٳ|@zG@ '@zG@F@:^5?}@["_@:^5?}@:@:^5?}@7+j@:^5?}@=H@:^5?}@9Y@:^5?}@9"@7۹~($@7D*@2ٺ^5?}@2KƧ@2M-V@2L>B[@1u@1M@1u@1$@1u@1-V?G *ǂ?S_?u*y?W0 ?FL{?װ*w?g1??AuG1?{4k?.<?GE?+ʄ?t?*0x)?`?{2?_u@@@@@,@???????/w2b'?_9!?VԨ|@O#)@;tI?t"<K?g9Y?M?Az>@r@@( -=q@(3p@( -=q.@( -=q.@( -=q.@( -=q.@( -=q.@Z1@ms@Z1.@Z1.@Z1.@Z1.@Z1.@8@@8%@4{ I^.Mm@3{Ƨ.Qn@3 k.NC,@3 k.NC,@3 k.NC,?`Q@8#@8:@8 >+@8I@8?%=(@8@8i@8@8S@8?P:Ԕ @8 *@8p@8@8 @8 @?@@bM@@?|@@_@@&@@`d@@@&x@V@&x@@&x@eO@&x@ᰉ@&x@C@&x@1&@6O M@6S@3@3/V@3@`A7@3?\(@2,<@2MjP@2,<@2JL@2,<@20U2a|?}ѿ,?t,?^CjD? "?/Jë?^?:?F/P5??xrI?1ک! ?M=?U"T?.?a -?9WTW?ЙQ$?+B?xb? (0Q@@@@@*@*???????a?z"H= ?b՞?=J^L-@l@)?3=p?[_?s -@ơ#?G)M:@edKF@@:fffff@:o\(@:fffff.@:fffff.@:fffff.@:fffff.@:fffff.@5\)@Jp@5\).@5\).@5\).@5\).@5\).@8uS&@8k~($@5sS.Mm@4-V.Qn@4xF^.NC,@4xF^.NC,@4xF^.NC,?us\@8#@8:@8 >+@8I@8?}ѿ,@8@8i@8@8S@8?@6[@8 *@8p@8@8 @8 @?@~"@b`B@~"@a@~"@t>b@~"@~'@~"@2/@~"@?@m@%~@m@FL@m@񌡙@m@QQ@m@oz@m@6' -@7cg l@7IJ~R@4|hr@3`m0z@4lj~#@2Aʠݜ@3!.I@2\ GB@3!.I@2l<9@3!.I@2~ Cl?Hg ?e= @?V|x{?5Iz?os{p?]ޜ?Xd?5h$?"_l^?a?m\=֌(?h~?g|v?E#&?' ?Gۋ?h>?Mj@@(@$@"@9@5??????KOn?<J`?6|?n})A@5w@?~H?> @t/~5@1vf@e.q@@jZ@jn@jZ@j_p@jZ@j^5?@jZ@j}V@jZ@jE85@jZ.@<@@<6u@<@@<')_@<@@<+@<@@<]b@<@@`?rJs?9~F?Hc?eDQQ?٤?u??':?B ?pk Y@@@@@,@,??????-:ӂ>?'g&?@4d@< Q@Nc&L?Gh}?$GH`r?؟)?U[~@sW@fKH@@KƧ.@KƧ@K'0@KƧ@J=p@KƧ@Q@KƧ@H1&y@KƧ@NzH@蝲-V.@蝲-V@(@蝲-V@J@蝲-V@@蝲-V@TɅ@蝲-V@N;@9YJ.>@4@4@4@3dj~@3e '0@3Y~($ @3QX@3Y~($ @3X\*@3Y~($ @3XK]c@8J?[ ?ƐW?G?(i^?c:e@8J?f?YEX?̶j? R?r@8p?vC ?ީ)?B?zy? -.ԕ@@@@&@*?????@/w.@/w@/O M@/w@$%2@/w@.2@/w@5 r˗@/w@-_>@HA7K.@HA7K@H_;dZ@HA7K@HS&@HA7K@HG#@HA7K@HQH@HA7K@HL'@9I_o.>@4ԛS@4Țu%F@3b-V@3V$/@2u@2œwkQ@2u@2@xK@2u@2jOR@8J?'Qp?f6E?Z)?.>{ -?),@8J?D?/]?mqa?Ug$?M/)a@8p?Cʯ?((W?9 ?LǺ?7@@@@.@&?????@@tj@@Ł{@@ @@k@@3@@Xa@`A7@刕@`A7@`5+@`A7@V=O@`A7@͉N@`A7@Xv@`A7@ܔ@5v@5L_@2° ě@2,=@2Ft@2?U@1xF^@16#@1xF^@1v|2@1xF^@17'(?|b@?΁k?mH?6?u"0X?8t_?}xD A?^Ie$}?PcW?8I@eCV[YH@@$E@$?@$E@$@$E@$hZ@$E@$@$E@$93@$E@$Lo@R@@h@R@C@R@ F@R@Hva@R@Eb@R@U.U@6=:@6/*@2E?|h@28J<1q@1`A@1|j@Z@1J0U2a|@18v -@1J0U2a|@17M}U@1J0U2a|@18ܦf2?D5C?m:S?(ՂA?aGS??rbeEZ?5ً?bZ*?$( ?K[?zdH?@'ÍP?VOhZ?gR?1݉?$?XTl?j*l?"5@@.@,@*@<@<??????sbA?`@?eB`?\@$P8@?{?̶?{r@ zQ8?BW@e$@"^5?|@"Tr`@8 _o@8 X@2}hr @2v85@1tj~@1&\1@1c@1]8@1c@1[W(@1c@1Z?"?dL?y"Bx?GQA?ʦ?D;6k??u3?gPl?Xyb2?D+?F%]?.zu?$?X[?1^g?v?PcW@@*@(@*@<@;???????h``]?4r$?HѥJ"@gr c@"XvV?P?]RKh?vB? d@of}@@ I^@"@ I^@]@ I^@({,@ I^@Ji;@ I^@c@ I^@ @dZ@iP'@dZ@PKU?@dZ@B@dZ@Gi@dZ@$'@dZ@< -@6>6z@6ap4@3+@3 _m@2Ƨ@2_K:@2iB@2g?@2iB@2|t@2iB@1t+/?~?J?*p@"? vWa?6?n? ?}x ?;9?;+t"\?d@@,@*@@<@:??????m48 v -?On[IY?R>@+@TH?kl\?p3;M?EwS?ajX@dl@@XE@X+ @XE@X@XE@X@XE@XKƧ@XE@X$@XE@X4@?|h@?|h@?|h@@4m@?|h@@N@?|h@? @?|h@@u"@?|h@?|h@4>6z@4$tS@0J^5?|@0J^5?|@0`A7L@0`A7L@.'RU@.U2a|@.'RU@.:~@.'RU@.?|O?m?7[䭝?q@v?ǹT?+ʦ_?| ?NۈV(?&?; $?ߒh!?U3p?nwf?/?W?':?b/bJ?L@@@@@(@,???????3?&cʻH?̬re\@Xl@??F;u?::āv>?9Ց?X\@f7@@\(@š@\(@af@\(@e@\(@S&@\(@@\(@M@C@=p@C@~#@C@I^5@C@C,@C@jg@C@˹~(@6:qiC@68\)@2 ě@2%2@197KƧ@1:,<@0[W?@0p:~@0[W?@0_o @0[W?@0v?]?m?U#? -?5 g? ]V?]?I?|,!?? f?Q\?*wjs?Ϸ+?A'_^? mmsi?L8AS?2[s?@@@@(@&??????8-?1e?2$DN>:^ĉ@gs4@gi?A˘ul>bo?}R G>XaE@sxa@@3E@6E@3E.@3E.@3E.@3E.@3E.@m`A@m~Q@m`A.@m`A.@m`A.@m`A.@m`A.@7uS&@7P{@5}hr .Mm@5`A7.Qn@4 k.NC,@4 k.NC,@4 k.NC,?@8#@8:@8 >+@8I@8?Y͍_@8@8i@8@8S@8?ZaP@8 *@8p@8@8 @8 @?@؊=p@؊=p@؊=p@؇K]@؊=p@؁@؊=p@{u@؊=p@F@؊=p@؁$/@`+@`+@`+@`.3@`+@`zI@`+@`;dY@`+@`*0@`+@`ͫU@3 ]ce@3 j~#@/-V@/ I^5?@.rnO@.mC\@.Z@.B@.Z@.^5?|@.Z@.q ?| ?Qd?~"? :>Co?Փz?;?| ?›?i?.pC?Bg43f?P=?oܧ?򯞼?Ol?Z?WZ?*Q@@@@@,@*??????dG Π?Or^w?/oQ*@؄gن@` q\?or<?O|˺? k}?!QG݀@e ׺@@lE@lvȴ9@lE@mn@lE@m I^@lE@lhs@lE@l䎋@lE@m[8@(+ @(ȴ9X@(+ @(A [@(+ @(PH@(+ @(u@(+ @("`@(+ @(=d@4(YJ@4(*0@2c@2a$/@2ttj@2q&x@1m8@1ҕᰊ@1m8@1Gz@1m8@1? ?E?^RpX?_? -? µ?|O?j%Ra?<?z?J>?'+?|׿pY?l? - l]?3_?OO ?;m7.@@@@@,@???????0/''p?L%$ H?7:^?A2@G]@lȗ@(H?VæuR"?a҂X ?rzÆ)?͵@g0@@N+@=Ӽڰ@N+.@N+.@N+.@N+.@N+.@ZQ@ZT@ZQ.@ZQ.@ZQ.@ZQ.@ZQ.@7>6z@7A)@4S.Mm@4tj.Qn@40.NC,@40.NC,@40.NC,?1YP@8#@8:@8 >+@8I@8?l@8@8i@8@8S@8?D%aFy@8 *@8p@8@8 @8 @ ?@a\(@aΗO@a\(@a^@a\(@aMj@a\(@aԯO @a\(@aϷ@a\(@aϪ͞@{Q@{`B@{Q@{\(@{Q@{@{Q@{s@{Q@{fB@{Q@{$ x@5v@5KƧ@2+@2C\@1`A7@1[W>6@1 -0U2a|@1tj@1 -0U2a|@1y=c@1 -0U2a|@1 ѷ?|O?sp?vG?W0 ?'`??=?F/P5?4 "?t(?@Cv?O ?e\p?+QK?Rii?qn?l?<71?Cns@@@@@,@,???????B{.?Sl?G%L ? "@aW@{=o"?h)ty?=yz?]S? @g.I@@j~.@j~@N@j~@^@j~@@q@j~@ @j~@wF@+33333.@+33333@+qc@+33333@*@+33333@++)@+33333@, -#S`@+33333@,"Z$@7zqiC.>@45S@37@3tj~@3:>$@3L[W?@2M@3L[W?@2/u @3L[W?@3'@8J?Έ`?IQ?wo?ť I?8^ܞ@8J?b?d ?М?`Hl?Ơ\eeb@8p?`IM?ĺ?HX?iux_? -6[@&@"@,@<@;?????@I^5@Ƨ@I^5@ @I^5@ϐ@I^5@Ǔݗ@I^5@ں@I^5@-@An@A`C@An@A I^@An@Ap -@An@AM@An@A,<@An@AQ@5[~($@5\>@3uS@3o@3-@3$@2Y~($ @2TE@2Y~($ @2UY|@2Y~($ @2VIQ?| ?q?M?4M^?ťBW?_?|O?ڲt?_@?| ?a]?]g0 -?9@0w?z? - l]?p=J?l?4hpɄ@@@@@(@*??????RrRs(?4 dB?B  @gv@A?S"9?bR%?z?Xi@eT@@)l@)^5?@)l@IS@)l@?@)l@7@)l.@)l.@&׍O;@&+@&׍O;@&XbN@&׍O;@&ȴ9X@&׍O;@& ě@&׍O;.@&׍O;.@7ks@7oo@2S@2"@1t@173@1xF^@1p{@1xF^.NC,@1xF^.NC,?h??)Q?}g?.D@8I@8?ꯨT?i&6?_@? m -@8S@8?' -}B?5?[? Q?@8 @8 @@@@????@\)@ȴ9X@\)@[@\)@=K@\)@$tS@\)@j~@\)@W@I7Kƨ@H9X@I7Kƨ@?$tT@I7Kƨ@;=L@I7Kƨ@?!-w2@I7Kƨ@=-@I7Kƨ@A-w1@5@5$tS@30ěT@3/-V@3tj~@3|@2:S@2B@2:S@2U=@2:S@2 qv? ??TS?U=K?#?3ƒ?Dw? ?2ww ?%gǿ?Y??sB?u!B?s@a?H?W;RT?hSp]?M\?4\ɵ@@@@@*@&??????B)}@amo|?4' ?H+,9@ƒ0@C:kV?Tw[r?h.@D?b< -a1?X @fU@@@bil.@bil.@bil.@bil.@bil.@bil.@j~.@j~.@j~.@j~.@j~.@j~.@9>6z.>@4xr Ĝ.Mm@3V.Qn@2YJ.NC,@2YJ.NC,@2YJ.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @4j~@4zG@4j~@6E@4j~@6Ov`@4j~@6E@4j~@3g @4j~@3@V@V@V@jO@V@cA!@V@_o@V@{J#@V@qj@0^H@0^Ov_خ@-\j~"@-\j~!@-ӶE@-@N@-p'RU@-os@-p'RU@-nMj@-p'RU@-nqi?^Dw'? ?4!p?G?b\?wZL?bM_x?MN ?^ o?C B?qN?]#O?b@?.+? SF?+ ?pk Y?B @@@@@*@&??????T8V?1q?=yk?:M~g@4@ت?K;?I84o?n^c?Q@sC{dw@@ORnP@OR@ORnP@ORGE8@ORnP@OU$@ORnP@OVR<6@ORnP@OVl"@ORnP@O]ڹ@lC@lC@lC@)^@lC@ @lC@B@lC@~$@lC@@4YJ@4@@2+ J@2*@2'KƧ@2'y @1Q@1ڒS&@1Q@1F]d@1Q@1և+ J?}ѿ,??p?btx=?STS?Y\(?| ?yom?ؼZ?#q\-v?.<? ?|׿pY?zx?ʭ#г_?.SM? ;8?`i2@@@@@&@(???????Ylсt?A??ፆG?) aȄ@OUeV@M?_]-?IΔ?kq?5iX8@eR*@@ ě.@ ě@)^@ ě@Ǔݗ@ ě@7K@ ě@ @ ě@@/zG.@/zG@/?@/zG@/e@/zG@/o@/zG@/6@/zG@/@9=:.>@5i+ @5ZD@4v-@4i#w@3xF^@3`A8@3xF^@3Ϫ͞@3xF^@3Ov`@8J?>I ?}\ie?n?M1?I?^e@8J?us76c?n|X?\PK?0d@? <\@8p?$3?6v;v?>?,Ro?S^^G>@@@@*@*?????@rlD@r(@rlD@rp -@rlD@rIQ@rlD@rce@rlD@ru@rlD@r/V@+ I@+C@+ I@*g@+ I@*F@+ I@+6z@+ I@+xF@+ I@+C@1!.@1 -L/@)tj~@)PH@'E@'cA @'fL/{K@'en/@'fL/{K@'en/@'fL/{K@'e?`&x?GA?>f?eU!?ǹT?:?bV,?%F?s8r?7枪y7?ߒh!?N`?cPQ? ?oܧ?avh?#.?Ѐ>(@@@@@,@*??????P> ?8l1E?Ajo @rb@+Nө?G~j?#/L4?a%?@ukw@s;@@l@lv@l.@l.@l.@l.@l.@`B@  I@`B.@`B.@`B.@`B.@`B.@9,<@9 @6kS.Mm@6 -V.Qn@6 -0U2a|.NC,@6 -0U2a|.NC,@6 -0U2a|.NC,?ٛP@8#@8:@8 >+@8I@8?q!U@8@8i@8@8S@8?*̒@8 *@8p@8@8 @8 @?@Dž@ǂM@Dž@DŽ7@Dž@Nj҉@Dž@ǂ}V@Dž@~\N@Dž@xQ@޸Q@5?|@޸Q@ -=q@޸Q@ߊ @޸Q@K]d@޸Q@7K@޸Q@PH@7,<@784֢@3^5?|@3_ح@2U`A7L@2TJM@25sh@23@25sh@22:)y@25sh@2-\?2}?+W?=P?ׂa?W?@*F?Ol?&dU(?cu%+?`ֆ?S?WR?W?E!'??Q ?OO ? `@@@@@*@*??????R?@8?E|W(?TŲȺ@ǀ=.@JCx?dK?tO?ȯL? П,@f[9@@ ě@ě@ ě@@ ě@3333@ ě@˒:)@ ě@u@ ě@"@jtj~@jnV@jtj~@jnzI@jtj~@ja@jtj~@jm%@jtj~@jj#9@jtj~@jSaA@8e!.@8b<64@4J^5?|@4Ln.@3V@3Xe@3L[W?@3WO;d@3L[W?@3Ln.@3L[W?@38???8?uZ?c? ?Zܗ?=fA:?Ҧ??SR?l^%? -Y*?TP??B?\7e)?YY?/#ˮr?R4?l@@@@@(@&??????j3W)j?z=~8A?Q4ױa@GtF@jk?2H^?pOY@3h?YIQȖ@f5@@hr!@B\(@hr!@ @hr!@$/@hr!@ ԕ@hr!@˟U>@hr!@_o @zG@|(@zG@ ᰉ@zG@ -͞@zG@?@zG@ߤA@zG@#@7w@@6$ xG@3E?|h@3=cA @2`A7L@2+j@1_o @1ݗ+k@1_o @1)y@1_o @18}H?B&W?@k=[?l5B?Att?.Kn?-! )m?. #???T ?A8 K?8,T?WR?Zj?7-R?OW?.SM?OO ?$jB@@@@@*@$???????*0?L+ ?aTO[?oM/]@@ -*5?p} -Z?{XO?ٕ?ut%PC@sC(mM@@<ȴ9X@<ȴ9X@<ȴ9X@b@/@/yIK( ?}@TΥ?0q?S4zs?&=?]? 4w?2?|b@??'?P}^U=?-(?R?rGe??t(XW?3p>? ݚi?=x@@$@@@.@1???????@/lw ?V!?b}@@>jO㛦@dٮ.@@V@C@V@jO@V@O;d@V@@V@첕@V@zxl@RnP@R ĝ@RnP@RW@RnP@R@RnP@R䎊s@RnP@R@RnP@R䎊r@0DO M@0DO M@*)7KƧ@*)*0U2b@)h1&x@)h ԕ+@(̲@(̘_@(̲@(̲@(̲@(̲?^Q5P?[ex?$.>>=eP@L@@R蓮?3>pzcy?3x[?b++> 7Z,@sIѨZ@@t1@t5?|@t1@tУ ->@t1@t}H@t1@tߊ @t1@t؆YJ@t1@tiB@ I@-V@ I@l@ I@1'@ I@M:@ I@=d@ I@$tS@7-v@7/b}V@4?|h@4Q@3ߝ-V@3}H@4!.I@4Q@4!.I@4'&@4!.I@4{J#:?% ?V_^?|6zj?a`a?p3/ ?dF?}ѿ,?8$ -"?ud?ѡb?? b9?!kz7??)1_?&,?O.?n?GԚj@@@@@,@ ??????%J]d#?A^ ?by"@tB'@P?cq[b??S6#i? Sz@fp_Gm@@7O\(@7a$0@7O\(@7We@7O\(@7SMj@7O\(@7UY|@7O\(@7M(@7O\(@7MB@`A@$/@`A@nP@`A@{@`A@Xy>@`A@'R@`A@:)z@9 _o@9Fs@3r Ĝ@3K]c@3q7Kƨ@3uzxl"h@3@5@3Q@3@5@3+ J@3@5@38}I?M^?ZAi?U%x?ھ۲?RXFf?Ci- ?jqp?`?Oدi?@[*^?dp?J3?}i?\{?Ƌ?1R?T?NVC&@@@@@(@,??????pci+r?KH\ߙ&?Q@7Qc@?[@!) ?aCB?u? >@p9>@@^`A7@^vȴ9@^`A7@]̲@^`A7@],<@^`A7@]7+j@^`A7.@^`A7.@3333@T@3333@f -L/@3333@64@3333@̋C@3333.@3333.@8@@8|@4hr@4+a@@4~"@3~%@3kxF^@3Ov_خ@3kxF^.NC,@3kxF^.NC,?|O?)#?ߴUmsA?yH>c@8I@8?K{O?l{׬?׉B,|̶?8F@8S@8?KY?zJ?W̩'?/օt,@8 @8 @@@@????@tj@F@tj@1@tj@L/{@tj@@tj@l?@tj@$@&M@&M5Xy@&M@&84@&M@&)^@&M@&qiC@&M@&{@&M@&#pŢ@5@5SO:<@3#@2vȴ:@2~Vu@2V+jg@2!.I@1'RTa@2!.I@12@2!.I@1i?{si?J f?x+?u]?cAq?H N_?|B &??8䂪P$?F'^D?~c]l?j8g/?VE?j$?E@@ ě@bM@ ě@@ ě@YB@ ě@D@ ě@ @ ě@X,@Z@Z@Z@½>@Z@@Z@`@Z@;fq@Z@^@4zqiC@4zin@0hr@0pq@0-@0 /W@.Vl"@.J@.Vl"@.&S@.Vl"@.M:?|b@?UL p?1"?˅T?g*??|B &?R?U.V?FQ"qH?ٙr?Z#\?15?XI|!?Av?:k??dB@@(@(@,@:@:??????& ?*`?)jou8I>bC@{@2?IJN?? e?ejC?%&@f0@@fffff.@fffff@Aoh@fffff@\wkQ@fffff@iB@fffff@Љ'R@fffff.@Y# -=q.@Y# -=q@Xm\@Y# -=q@Z!-w1@Y# -=q@X>vȴ9@Y# -=q@X I^@Y# -=q.@9!..>@4hr@4˒:)@3-V@3E@3c@3*^5?|@3c@3E2a|@3c.NC,@8J?R{?> -A?Ғ?o@8@8J?!?>?tC?B.@8@8p?=X?=Ɂ9?R^?@8 @@@@*????@u@uI^5@u@ub@u@us@u@u҈p@u@un@u@uGz@w@}/@w@^ߤ?@w@Q@w@mjO@w@dT@w@g)_@7@71.@3E?|h@3:u%F -@2dj~@2X*0@1[W?@1R@1[W?@1}O;dZ@1[W?@1'/W?|O?6 '8?XY?r*?GU?YD?E?u߿??A?Q?D4f?K|?HO?c?9 ?k!l?GX@@@@@,@,???????u*3(htP -F?N<}?ST'@u,P@mBb?r+ng?m? /X?e2@kJ@@zH@\(@zH@@zH@;5@zH@U@zH@\@zH@!-@&Q@&;dZ@&Q@&˒:@&Q@&F -L@&Q@&Ƶ (@&Q@&$/@&Q@&m\@7 ]ce@7y @2 I^5@2@2U`A7L@2U?@15sh@16YJ@15sh@168YJ@15sh@16t?Y͍_?J`Y?ě?2UT?(+Zk?J8Ȟ?}?Q_ڸFN?ܿ?/:?O ?C ;?bk?3I#i?~$?3_?Y͍_?{2@@@@@,@*???????p{?WD=?"?- ?U##?LE??VDx-~??]_@@"@$@@0@2???????5 P?ph=@?dZxV?aT1C@:m@+ٺ]b?Q?!n *@^z@.RhR@g^ێL@@sY+@sS3333@sY+.@sY+.@sY+.@sY+.@sY+.@hr @cS@hr .@hr .@hr .@hr .@hr .@7>6z@6ߤ@@3xr Ĝ.Mm@2>Vu.Qn@1m8.NC,@1m8.NC,@1m8.NC,?Z@8#@8:@8 >+@8I@8?Z@8@8i@8@8S@8?A@8 *@8p@8@8 @8 @?@Ha@Ha@Ha@Hae@Ha@Ha@Ha@Hb@4@Ha@Ha-w1@Ha@Hbe+@(\@(\@(\@(\@(\@)*0U1@(\@%S&@(\@'/W@(\@(@2DO M@2Dj~@0S@0Ϫ͞@0-@03@0iB@0N;5@0iB@0N;6@0iB@0o?^Q5P?°R;?\H{gX? -?j?WA?bM_x? -?)_?~m??\{3>a?P=?cPQ??`x?%ϑ?<71?Rv@@@@@*@*??????"*?V*?4)z?2 YC@Ha#@' ?C揇I-?A ?n?xHD}`T@sb^X@@c+ J@c@c+ J.@c+ J.@c+ J.@c+ J.@c+ J.@9x@9lD@9x.@9x.@9x.@9x.@9x.@7DO M@7H˒:*@4+.Mm@4_-V.Qn@3u.NC,@3u.NC,@3u.NC,?Z@8#@8:@8 >+@8I@8?Z@8@8i@8@8S@8?A@8 *@8p@8@8 @8 @?@J=p@J=p@J=p.@J=p.@J=p.@J=p.@J=p.@VI^5?@VIx@VI^5?.@VI^5?.@VI^5?.@VI^5?.@VI^5?.@3G>6z@3G-@1hr .Mm@1"`.Qn@1~($ .NC,@1~($ .NC,@1~($ .NC,?| @8#@8:@8 >+@8I@8?|O@8@8i@8@8S@8?y8#@8 *@8p@8@8 @8 @?@ A7L@'z@ A7L@2䎊r@ A7L@($ x@ A7L@ߤ@@ A7L@Ov_خ@ A7L@VC@z'lC@zw@z'lC@zL_@z'lC@z'8}@z'lC@z=+k@z'lC@zlC@z'lC@zS&@6S&@6@4?|h@4nO@3b-V@3v@3@5@3(˒:*@3@5@3u@3@5@2[6?|O?(?EZS)?C?oA>?̇a?NIɮ?]?Vh?<8?him?I$P?'`?K{O?+HKd?gw_؆?XS]?&A@% @@@@@&@(???????F@O? i?/> @Ct@z ?t?砂X@Ƥ@@1膄@f@O'n@@t.@t@w@t@@t@YJ@t@rG@t@Gz@KƧ.@KƧ@>BZ@KƧ@PH@KƧ@[W?@KƧ@@KƧ@Ƨ@9 xF.>@3?|h@3 ě@2tj~@2xbM@10U2a|@14֡a@10U2a|@1@N@10U2a|@1Zc@8J?U&?/ eb?F?H>?ƻ1Ta?"eM@8J? _?9Y,?+Dx?J>?Q@8p?"IHۜ?-BR1?hc?vI?3@@@@"@ ?????@ۥS@p -@ۥS@xF@ۥS@٦ @ۥS@ (@ۥS@- @ۥS@@R@Ow@R@=ce@R@b&I@R@As@R@Z)y@R@]-V@7_o@7e+@4 I^@51@3tj@3z@3@3@3@3oiDg8@3@3ݗ?1j?J?Q"Ě%?50??7?X—?I~y?~Fs?oi(?%bB?"?kxܓ?Ol?f?W\%?D`?,Z?8@@@@@&@$???????&ʵ?f:?Ut e?pB`@@b@NE+?yS?=?nzT?haj@in@@F%@Ft@F%@F:5@F%@Ff@F%@F@F%@F*:@F%@F=@Ƨ-@ƧQyR@Ƨ-@ƨR@Ƨ-@Ʀd@Ƨ-@ƨ -@Ƨ-@Ƨ[+@Ƨ-@Ƨ@3s@3)^@1pěT@1p-@0)"`@0)n t@/@/P3;@/@/ϲ+@/@/c -?}@TΥ?- ?/N?L7?(?QgH?| V? )?Ք?6K'Y -?,Uw?s0?| #?џT?b?VS -x?9Ν{??$@@,@*@(@:@9??????@ >ӭٟ>!TIJm~@Fq@Ƨ?7? GFF?;y>?!m%z@fB*@@[ Ƨ@[ @[ Ƨ@[;5@[ Ƨ@[4֡b@[ Ƨ@[ ԕ+@[ Ƨ@[ ^ @[ Ƨ@[ I^5@r߾vȴ@r/@r߾vȴ@r@r߾vȴ@rb}@r߾vȴ@r唯O@r߾vȴ@r݊ڹ@r߾vȴ@rae@6@@6@4W+ I@4Y|@3A7K@3Zc@3Eu@3G,@3Eu@3DD@3Eu@3Eu?)T?[ ?d3"7?W0 ?#?3ƒ?1?}ѿ,?ew?fF?v? E!?}X?}Ty?XԠ#{?aI*?7N?I$?Oh6c@@@@@(@*??????=6(ް?LiH?>%K?K1Ϟ@[ ?Ls@ru?\(?l.?ެK?6γ@he`@@]-V@]-V@]-V@^6Gt@]-V@^ Q@]-V@\e@]-V@Y|8@]-V@Yw+@$/@ؤT@$/@|p@$/@~@$/@{/@$/@zǧ@$/@|V|k@3qiC@3ݘ@2J^5?|@2D?h@1`A@1Ѳƒ@0_o @0?@0_o @0zq@0_o @0vM'?}@TΥ?q ֑?Fx+I? ۸ig?DH/7?y>m?| V?!T?CW?WHF,?}v?{8?nݺG?FG???$ɘ1?ŃH? I۵p@@$@(@"@6@1??????MDXz?' qz@?*(8vK@[[@~|?G()1?KXL?XT?X@f#b[@@bM@bM@bM@2X@bM@*2@bM@.3@bM@}Vl@bM@!-@ -=q@㕁%@ -=q@u%F @ -=q@rG@ -=q@߾vȴ@ -=q@ὥ@ -=q@h ԕ@6䎊@6S&@3+S@3+P{@2-@2@2OO M@2NT@2OO M@2NOv_خ@2OO M@2NOv_خ?)T?u:|?0? ?r {#&?R )?=fA:?$i %h?Qc -?H#=? E!?jOI?nwf?t?D(p?Z?0&YEd?|)-}(@@@@@*@*??????D5#YP?!){?KtA?eTC?Xx+?2he?J?-=~?ȧ?;M՚w?A?Mu]P%?f=䛮?O@@(@,@,@5@7???????P -?v0$?lA@?sѭ@Kz@iv?7?!1@LxP@b@m]@@"@V@"@%@"@d@"@dZ@"@1@"@>6{@"I^5@"hr@"I^5@"rF@"I^5@":~@"I^5@"W@"I^5@"~($ -@"I^5@"͑hr@74m8@7@3R I^5@3Rᰉ@2-V@2{@28D*@29x@28D*@2:1'@28D*@29+ ?3}?Qc -?K]4?9.?uxY??”z?&O?&?{4k?uR4H?ey?:Fa?GA?T0?< N ?P\?k!l@@@@@*@(???????A"?a#?mmz?`Gb{@X7qV@"s~?~:I?p s? :?Xa@rݵ)@@~"@;dZ@~"@D(M@~"@8SVE@~"@%@~"@~m@~"@}-@'-@'-@'-@'&@'-@(1&y@'-@'@'-@'#@'-@(P@+b@+b@%G-@%G-@#NO;@#NO;@#`d@#g8}@#`d@#`d@#`d@#`d?^j?؆Qd?c?`ƆƵ?zn~1?vQS?bMn?K}?l:?/ -?μjH0?I'%?bM? (ʢ?nՉW?c[?I?I@@(@*@(@;@:??????PA?JF(?1m76m?@~)&@' -?@+'?ql?{+jP?J@s@@M@z@M@޸Q@M@`B@M@҈p@M@@@M@Zc!@_;dZ@dZ@_;dZ@\hr@_;dZ@ix@_;dZ@`6@_;dZ@ae@_;dZ@a [@7>6z@7zxl"h@3+@3a|Q@3Ctj~@35oi@2Eu@2<!-x@2Eu@2Ezxl"h@2Eu@2En/?NIɮ?6 '8?@^ڢ??ԁ?4 ?| ?r5MS?Ke?Q?NM8/?GӒ?+QK?GA?+-/??*Q?}@@@@@*@(???????01GwY(?U& ?/ˉ@.Հ@aɭ?i>Z?UYaݣ?I֫c?MS:@o@‚ @@nM@nM@nM@n䎊q@nM@n@nM@nn.@nM@n@nM@n@^Q@_;dZ@^Q@^@^Q@^ (@^Q@]cA@^Q@_F@^Q@^"@4B䎊@4B3@/"@/vȴ9X@/DZ1@/Dtk@-Z@-@-Z@-F]c@-Z@-S? ?&H?N?뤽?? 9?^? ?MN ?rJs?EP?ڂc?h,à? J?O?y8$?ʬv?ˢL1?@@@@@*@(???????.j?)SE?$67@n^?@@^uF?I4U?EmL-gr?G;?3Ku@gjvx@@\(@׾5?|@\(.@\(.@\(.@\(@-@\(@׿vȴ@l@@l.@l.@l.@l@ۥS@l@@6۹~($@6d8@3c.Mm@3n".Qn@2&.NC,@2&@2~($ @2&@20U2a|?q!U@8#@8:@8 >+?DE?W_?1j@8@8i@8?dp?"?y\@8 *@8p@8?^nl?xb@@@???@6Ƨ@6@6Ƨ@6^ -@6Ƨ@6f@6Ƨ@6E@6Ƨ@6I^5@6Ƨ@6f@7K@@7K@n.@7K@n@7K@|Q@7K@u"@7K@- @6hYJ@6fR<6@2xr Ĝ@2x$ xG@1~Vu@1}@1(@1)y @1(@1)rGE@1(@1(TɅ? ?&?a#mU?J? -`?dW?)T?ā?36G?l™U?=W?$̤T?<{??3Z\?9XNu?_խW?gϵ@@@@@*@,??????6aUV2H?'?1v0@6@W:?H8&XQ?Q)z?W]ʭ??O@iD.@@S@^5?}@S@֞"@S@{"`@S@ I_@S@gRT`@S@J=p@D$/@DlC@D$/@Dj~@D$/@Dx@D$/@EA7K@D$/@CfA@D$/@D@6D@6ݫU=@4+ J@4hۋq @4V@3IQ@3sh@35sg@3sh@4ME@3sh@3 '?2}?Ea:j?ŏB?³?ST;?<_?Y͍_??MQ?xG?oEcr?K#N ?]b?eg?0@4+ I@5;u8{@4 "`B@4G=ތ@3iB@3zR6@3iB@3!A@3iB@35.@8J?p?'? do)? dߝ?ZK@8J?;]^Y?7?)L ?er?= -@8p?r`?sK?HbL?2Q?^@*@,@(@<@:?????@W ě@Xě@W ě@W5?|@W ě@Xa@W ě@XLzxm@W ě@X=p@W ě.@ehr@e@ehr@dݲ-W@ehr@d@ehr@e+a@ehr@e xG@ehr.@8@8dSMj@4\I^5?@3K]c@3tj~@3"`B@3Y~($ @2+j@3Y~($ @2ٺ^5?~@3Y~($ .NC,?ٛP?;F?Գ/#*?6V?! ٤5@8?:-%?T ?SXt'?َVn?i0K @8?@?l{)ފ?W Z?wc U/?7r_@8 @@@@@?????@#$@#ti@#$.@#$.@#$.@#$@#Z@#$@#lC@0;dZ@0ۥS@0;dZ.@0;dZ.@0;dZ.@0;dZ@/w -=p@0;dZ@/9X@6#g l@6!$/@4=hr .Mm@3`A7L.Qn@2,<.NC,@2,<@2C\@2,<@21&?)T@8#@8:@8 >+?je?:ka?)T@8@8i@8?,ۯ?w[@?D/ -b@8 *@8p@8?>?<@@@???@Λ"`@ΛS@Λ"`@θQ@Λ"`@䎋@Λ"`@n@Λ"`@Ϸ+j@Λ"`@Ϭ@Dt@DZ@Dt@ݘ@Dt@}@Dt@Fs@Dt@:@Dt@@2:@2u"@0\I^5@@02ᰊ@/|1&@/ w1@/(ۋq @.]cA!@/(ۋq @.^ѷY@/(ۋq @.\ߤ@?^Q5P?Q^?NSCQ?t4BT?ͤr?-(?bV,??8K?!!?0??cPQ? $gv?zny-i?$–?Xk?N((@@@@@,@*???????/XڠE?s{ʙ?*i@ό-m@g?iTJ?An?m9@/t@/5%jQ@.cnP@.c)`n;@-Ǔݗ,@-l@-Ǔݗ,@-.J/@-Ǔݗ,@-&sˇ@8 -Ny?M9?(uH?bew?6?N@82r? EN?" ?0j3A? m"?X@8L?Q=s?%?gȶ?$?8(@,@,@&@:@;?????@\).@\)@L/{@\)@T@\)@R@\)@O䎊@\)@KC@8Q.@8Q@oj@8Q@j~@8Q@+@8Q@tj@8Q@*g@8p4m8.>@3kS@34D@2"`@2~($ x@2 [W?@1&x@2 [W?@1|@2 [W?@1sP@8J??n ֋?= 0?Lj!_? V߹@8J?N47?42?,?1Tn]?fF7@8p? Afg?o'@@@@@(@*??????g,!*ynӀ?3h?R@a@ȝV[?N ?iOXvj?ƕ?ϙ?`R@`'%@@ ě.@ ě@q @ ě@?@ ě@ߤ@@ ě@O;d@ ě@(@`A7.@`A7@&x@`A7@ۋq@`A7@@`A7@v@`A7@9@9.>@4+ J@4~$@3V@3PH@2̿[W?@2vȴ9X@2̿[W?@2@2̿[W?@2|@8J?LS{?ɲ?d"QZ?Փz?^A@8J?g3?W@3t?1`?s}?Ft*5@8p?|׿pZ?z."?6F:?mΝ?@@@@*@(?????@bM@Õ%@bM.@bM.@bM.@bM.@bM@ŔO @$/@n@$/.@$/.@$/.@$/.@$/@՛=@7r@7rT`d@5|hr.Mm@4j~.Qn@4a:S.NC,@4a:S.NC,@4a:S@4sE?]@8#@8:@8 >+@8I?9!. ?]@8@8i@8@8S? -#9?*wjs@8 *@8p@8@8 ?J'Y=?@(??@5dZ@5͑hr@5dZ@5ͫU@5dZ@5ȴ9Y@5dZ@59X@5dZ@5̋C@5dZ@5vȴ8@tj@Q@tj@G@tj@%zxl!@tj@( ԕ@tj@An.@tj@L>C@7!.@7>@4hr @4C%@3A7K@3@3:S@3 @3:S@3H˒@3:S@3g l?A[F?\?K̃?yQ?Ji?ZsZ?ك|I?S?~?DzC1?MuVQ?ٲ? }P!?5Jܦ?W+ ?<05?%?)0@@@@@@*??????hUAr?߬?w`) ?i\wa@5A@4O??`1@+G?޽_6@l6k4@@]-V@l@]-V.@]-V.@]-V.@]-V.@]-V.@2mhr@2a@2mhr.@2mhr.@2mhr.@2mhr.@2mhr.@4uS&@4W=g @1^5?|.Mm@1Htj.Qn@0,<.NC,@0,<.NC,@0,<.NC,?}cI@8#@8:@8 >+@8I@8?|}q@8@8i@8@8S@8?h3z@8 *@8p@8@8 @8 @?@-@@-@v @-@-Թ@-@N ?xqC?Ѐ>(?f_Ԋ@@@@@(@*??????<?%%e?e?)ޒ@…&@u$c?, #K?#>ݔ?TS7T?Af@s@@(@@(@s@(@fA@(@߾vȵ@(@׍O;@(@_@HlC@H\(@HlC@Hě@HlC@H1@HlC@Hzxl"@HlC@H@HlC@HeP@5D@5Xe@3}hr @3}C\@3ttj@3q.H@2@2JL@2@2ᰉ@2@2?o 6}?U?cD?CW?U#v?0r>?R+?^?Lw?e?tbJ?%U|5?y4h?@@$@ @"@9@5??????+ӌ7:X?13[*? ^\ݗ@J$@C?Q"0?-p*?|< ?`l`z@i@@@r @.@.@.@.@.@yZ@y+@yZ.@yZ.@yZ.@yZ.@yZ.@4p4m8@4aX@2S.Mm@2A7K.Qn@1O M.NC,@1O M.NC,@1O M.NC,?2}@8#@8:@8 >+@8I@8?| @8@8i@8@8S@8?&*0\@8 *@8p@8@8 @8 @?@\TF@\Cn@\TF@\R@\TF@\^@\TF@\Y=c@\TF@\O@\TF@\Jqi@ߤZ@ߝ/@ߤZ@ߢ&H@ߤZ@߆&@ߤZ@ߐ )@ߤZ@ߏw@ߤZ@ߔm9@8r@8p@4B ě@4?v_ح@3`A@3c @3(@3v_ح@3(@3! [7@3(@3$#?ꯨT?DE?_΋?܆?RC}q?˻??]?sw)?ٶm?T?a8w|?mq`?}?US9?@fo(?3 D?7Q@@@@@(@*???????D%c&7?lrYb?U@\P#Ş@ߔ~?>[?sʫ -zY?gO?ef@mn@@+# -=q@+# -=q@+# -=q@+%@+# -=q@+$P=T@+# -=q@+$r@+# -=q@+"）U@+# -=q@+#;O@_p -=@_p ě@_p -=@_mtMd@_p -=@_o@_p -=@_q.@_p -=@_p@_p -=@_p{@4S&@4r|*@1#@1$2w@0PA7K@0PP3:@0B@4@0BA ~@0B@4@0B!@0B@4@0Bѷ?|h2:?pPb?ȟQK?ɰM6?A]2?"{@Y8?|b@?A*?U#v?=W:f&/?dȨ?Uk>&?p5/?Eʚ? ˁ?b~?6ִ@?o@@$@ @"@2@4??????l? Ȁ`?+xNRv?5@+# q4@_pmkf?K7s?'ca?!l&?\=n~@f*]@@2-V@.+@2-V@"Ѹ@2-V@,<@2-V@'/@2-V@,zxl@2-V@*~"@^bM@^wO;@^bM@^DJ@^bM@^<64@^bM@^>BZd@^bM@^TzG@^bM@^Vl"@8B䎊@8E '0@3I^5?@3kP|@2~"@2F]c@2!.I@2$/@2!.I@2ӕ$@2!.I@2Q?2}?O\?C1?]mM?PY8~Qj?"eM?|O?k@?pg}5z?-w?*v7?J3?>xރ?YW?<?+L?`?ba_@@@@@"@(??????L\(AI??Sy=t& ?YP0Z0@, ,@^g늵5?sT?yWQ?cMF#E??@eBa@@.O@0 ě@.O.@.O.@.O.@.O.@.O.@i1&y@in@i1&y.@i1&y.@i1&y.@i1&y.@i1&y.@3쿱[X@3}Vl@1 I^5.Mm@1tj~.Qn@0iB.NC,@0iB.NC,@0iB.NC,?| @8#@8:@8 >+@8I@8?Ol@8@8i@8@8S@8?aI*@8 *@8p@8@8 @8 @?@/-.@/-@0D@/-@.V@/-@0|@/-@/A@/-@.}Vl@ .@ @ @ @zG@ @.2@ @ߤ?@ @qj@9[~($.>@2S@2$@1-@1؆YJ@1Y~($ @1Z=p -@1Y~($ @1Z0 @1Y~($ @1Z,<@8J?d̺?tcj?Q?Ot?tJ?bM_x?%F?['?1'7?@?PS2K?b@?u?nwg?͓E'?O|q?#.@@@@@,@,??????Snd?_;?8e?(@/]m@4kt?GߵZ%?0G?(m?WG@s߁@@Ux@UxbM@Ux@Up ->@Ux@Ur-V@Ux@UnzH@Ux@Ug8}@Ux@Uiᰉ@o@ I@o@L^@o@$/@o@Z@o@8YJ@o@RT`@5Q|Q@5R&IR@3+@3&@3;Ƨ@3+a@@2D*@2hr @2D*@2- @2D*@2T`d?|O?gUq#?P"hI?L?-w? YdR?m~Z_s,?J>? -tM?Oc?l?}@@@@@,@(??????jT?~j/??ܿ?a }@UsoP@?ZΕ|6z.>@4 I^5.Mm@3)"`.Qn@2䎊r.NC,@2䎊r.NC,@2䎊r.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @fx@;dZ@fx.@fx.@fx.@fx.@fx.@O;d@7Kƨ@O;d.@O;d.@O;d.@O;d.@O;d.@8N쿱[X@8m-V@5sS.Mm@5@`A7.Qn@4s&.NC,@4s&.NC,@4s&.NC,?]@8#@8:@8 >+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??@Q@Z@Q@t@Q@ѷ@Q@u@Q@@Q@cA@0u@0\)@0u@0ӎMk@0u@0,<@0u@0ԇ$@0u@0@0u@0@4g l@4h ԕ@0ěT@0T@0A7K@0zxl"@/ߤ@@/Ԣ3@/ߤ@@/`d@/ߤ@@/2a|?|O?%ñ?!N?,rg?rf???#?|O?uie?v@b?jX?+!?äqY?]?/?T?XW~?$?L8AS@@@@@,@&??????^D<} ?CNE?#9 [@c3@0Ԃ ?ڡG7p> s@3ʚef@BNG? ? ʘH@1iB@0=b@1iB@0*1?Ol? U?-\8?lfW??O#?E?5?1?5;7ĻM?4="C!?ES?ЙQ$?gT?ĶBϪ??ھ۲?{=rK@@@@@*@*???????s(?O9P?Do?o˃@Ɍ@!~?.8r?2Mw@6O`?2D -@\o|@@A$/@2 Ĝ@A$/@?|g@A$/@1&x@A$/@)rG@A$/@,cA @A$/@L@d/@y+@d/@kR@d/@nV@d/@b7@d/@k]c@d/@U=@8H@7u!S@4\I^5?@4_͞@3y7KƧ@3.H@36z@3_ح@36z@3#@36z@3A [?ʘzT? ?c?Z T?r.,i?/?^*?͔{?zh\?u>M? U?PI?Ttn?$jB?q6tN6?4`?**Z?p@@@@@(@*??????? 2?v߄Ŏ?yM6@0ez@[PB'?h?-+?^n!@ F< -T@oW(@@nP@@nP@u0@nP@9!@nP@m@nP@Gi@nP@؀v@dix@bm@dix@di2 @dix@dZU]@dix@d\w@dix@da#3G @dix@d^@8YJ@7 @4\I^5?@4UkAV@3K"`B@3B)@3@5@3,@3@5@2d?@3@5@3-Q-b?qT?`M?:ҖD?8(/?#<'?5xw!?_R?p")?w ?y$?$;d3?{,o?~6?"?5?;Me?_?#"o؅K@@*@&@*@2@6??????Q],?B4L@?pA_l?f\Ӗ@Q@d^sd?}l}?tT5?`N?ܐלvJ@sx9@@@1&@ffff@1&@zxl"@1&@zxl@1&@hr@1&@O@1&@M;@o@T@o@{~@o@z^5?~@o@mV@o@v@o@sE@8?@8/˒:)@4B ě@4M@CTTȺ@f?{AV^?V[־{?ߎ{@ ?HoLh@r0-`u@@_!G{.@_!G{@`0 ->@_!G{@`d@_!G{@`}+j@_!G{@`KC@_!G{@`?.H@.@@/ M@@)^@@T!-w@@.H@@ݗ+@9,<.>@4hr @3т @3`A@3z@30U2a|@2~"@30U2a|@2um\@30U2a|@2y#w@8J?Ȗg?rF)?>?r7?cx @8J?I>Wj?4kU?4i?UTj?>y@8p?bH=?~~?>?I$?{%@@@@,@(?????@`B@ͱ-@`B@ׅ*>~@`B@ߞ9)@`B@*ӿ@`B@,@`B@"@hQ@i$> -@hQ@h`wF@hQ@hhfR@hQ@h{F@hQ@h-nZ@hQ@hIDC@75S&@74mC@40ěT@42fn@3ȓtj@3J@@2O M@2p0@2O M@2 ,@2O M@2ݔ,LO??c8?a?ӯ/?[_0?|G?[y?PC9 -?d)E?Zg?4?]ex‰?}W?6TW;?_qZ?)N?{:5i?#@@$@*@,@6@8???????P{2)90?o -x[?Z@~@h8?J MT\?uPR?Fǂ_@l@ry -:7?|2?f~? 2?$̙?5-?pWϿ?-qvP?O<@@$@$@&@9@7???????r68?]cʷ?eI"x%?hp@@c/Ej?}+՘?x~HO?g-?߁ |@qkd@@eȴ9X.@eȴ9X@e@eȴ9X@e&x@eȴ9X@eO N@eȴ9X@e@eȴ9X.@.v.@.v@."@.v@.j~@.v@.)ᰉ@.v@.;@.v.@7I_o.>@2W+ I@2Sa@N@2ttj@2-V@1a:S@1hQ@1a:S@1W-@1a:S.NC,@8J?u:|?!=T??Q?"@8@8J?P ?,?dXM?Gfx^K@8@8p?8hz=?OD? Q?? S @8 @@@@&????@@`@@@Ǎ@@T6@@kj0@@ʟ@@@Hg@@,@@|E@@U@@_!@@u_5@@Y|K@7>6z@776@4J^5?|@4E@3M-V@3L/r@38D*@32~Ao@38D*@333M@38D*@35?\l6?0?9 %S?}-.?;G?A? C`?3Z\?2]7?`x?!B?՘]G?_u@@@@@,@*??????B/@Wth?9z͟i?3ԑN@rĢg@հ?Y63 ?T 99q?jQ*? -:@fĀ@@p@ohs@p@o1'@p@p}U@p@p ~)@p@p t@p@pm\@э@Ѽhs@э@у9@э@фJ@э@эqu@э@э r@э@ь!-@8@8zxl#@4hr @4@3j~#@3_p@3m8@3y @3m8@3ߤ@3m8@3o?Uy?B-?[_(?w?b0)3? r?,*D7?"JUO?P{j?P?JL\?J3?! ?'h?a?]O8?♊N?ȩ@@@@@$@,???????~ [W)?wyI=?hJFұ@p g6@эqx/?F[)?u}ηx?8E-^ ?1uw@*~MlJ@&挿CX?C5 hG6?$I?>?B~qF@sOԱ@@[?|h@[Ib@[?|h@[?Oy@[?|h@[?ᝆh@ I^@\(@ I^@U@ I^@@ I^@~Ί@ I^@S]H@ I^@G[R@64m8@6ban@2?|h@2Ƥ#ͽ@2`A7@2&\@1c@1d@1c@1c?@1c@1cG?3<' ?O??ꃩ?5G?Qm0I?+ I?$%'?޿`?0ң ?Q9?nL@?,+e?X?܃ݴ?bDn ?$](6@i/^.@@&x@O;d@&x@'*"@&x@}@&x@?$@&x@p @&x@:(@]hs@].@]hs@]7@]hs@]s3@]hs@]>,@]hs@])o@]hs@]6@8 _o@8@2ٺ^5?}@2 W@2tj@2AP%@1kxF^@1M-o#@1kxF^@1I~_@1kxF^@1^%\I?Z?B -?"|=e?}MmH?0Rp?!C?Z?~9;xN?sEj? -@jn[S@@ -Ƨ.@ -Ƨ.@ -Ƨ.@ -Ƨ.@ -Ƨ.@ -Ƨ.@ `B.@ `B.@ `B.@ `B.@ `B.@ `B.@8O M.>@4 I^5.Mm@4`A.Qn@3m8.NC,@3m8.NC,@3m8.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @@`n@@a|@@@@bM@@rGE@@GE8@8E@8@8E@8ѷ@8E@8@8E@8y=~@8E@9/@8E@8@7@7lD@3+@3e@2tj@2:)z@2[W?@2'/W@2[W?@273@2[W?@2H?ai?hĔV?ʶs?,OKu?Ji?(ϢU?Y?^1?? -oɧ?Җq?? 3W?׬?pPȻ? - l]?q+U? `?mΝ@@@@@,@(??????i@R?Qz?^z) ?iر@I@8Q ?m/oו ?{pbf_?D߉E?l\l@rǬ <@@>+R@>+ I@>+R@>,!.@>+R@>+҉@>+R@>-\@>+R@>+)^@>+R@>+ I@*~#@)l@*~#@*JM@*~#@+)^@*~#@*g@*~#@*qi@*~#@+~(@4|Q@42X@0+@0O;@0A7K@0NT@/(ۋq @/)Dg8~@/(ۋq @/(>BZd@/(ۋq @/(9Xb?]?h?D&?:Z2b?Dj?+ʦ_?]?f?DP?C B?݄ ? R?*wjs?򯞼?|׿pZ?$H?pk Y?j?@@@@&@*??????Q?:?25*?2@>+@*?A?F?A7I?}ϷA?zS'sJ@s87e@@?|@ I]@?|@@?|@L@?|@: @?|@m, -@?|@qq@ ě@"^@ ě@0z@ ě@rXV@ ě@A@ ě@8@ ě@,T|@9H@9+٦@3^5?|@3jJJ@3-V@3##N@2}ce@2]6v@2}ce@2{ԸAQ@2}ce@2pe?&#;?3?)`xy?z?:׉?ܐ?Vz?ڝ)?THN?=?6ad=?p6z@4$tS@1 -^5?|@1 -,<@0v-@0vȴ9X@0 k@0@@0 k@0O;e@0 k@0&?|O?*|3N?&P?ArU@? f?.'?}ѿ,?La?^ o?]bn~?!U?{?h,à?^&? -?]??ܑ ?SP@@@@@*@&??????Zb?& ?-?&Gj}@[ -vcG@9a"1Q?Mps:?F9;t?Hi ?S=-v@g v@@޸Q@ݲ-V@޸Q@މU@޸Q@ދ^Z@޸Q@mk6@޸Q@[E<@޸Q@_/@ -=@ ԕ@ -=@@ -=@Ȉ@ -=@'8@ -=@՘M@ -=@@oC@6 xF@6e>i@2^+@2^x@2."@2-Y@1s&@1q@1s&@1rIR1I@1s&@1qyA꥝?gQ?S?b??c娸?PR?|"<~~?#u?^:[,? k?w~A?3?'@?ڦ?[t?s - ?2o9?5zj@@(@$@$@9@6??????s?L[d?t:D?.:Eѕi@ݮU@?:u, ?Oz?HA>q?b]H@g2p|@@[ݲ-V@[ݲ-V@[ݲ-V@[iB@[ݲ-V@[b@[ݲ-V@[ѷ@[ݲ-V@[]cf@[ݲ-V@[lE@nP@nP@nP@U@nP@ ԕ+@nP@ oj@nP@ ]c@nP@ @3*0U2b@3Q @/"@/u"@/dZ@/F]d@.-C\@.*#9@.-C\@.*~"@.-C\@.*L/|?| ?dY{?ě?vk?n{K?w'?| ?jכc?t(?ҧ?c3c(?.8?YE?˛͇q?٤?*|\/?pk Y?&I@@@@@,@*??????3ՀG8t\?$2eXD?6e2f[@[)@`i?DA݀?WG68@2OO M@2L? MV{?sOewS?(`ƴ?__z8`?g;+u??#?I ?,?rPs?kG r?âa?|T ?TK e?+k?B-j?D`?8@@@@@,@*??????t~`H?~y(Ku?]IXwe@z5@]t?? p?Rp@6S?٥f@iud@@o@Y:1@o.@o.@o.@o.@o.@$DT@$Q@@$DT.@$DT.@$DT.@$DT.@$DT.@8V,<@8;$@4?|h.Mm@4-V.Qn@4 [W?.NC,@4 [W?.NC,@4 [W?.NC,?@8#@8:@8 >+@8I@8?NK3@8@8i@8@8S@8?O>F@8 *@8p@8@8 @8 @?@N+@j~"@N+@'&@N+@2X@N+@e@N+@\@N+@ ᰉ@tvȴ9X@t9X@tvȴ9X@tN;5@tvȴ9X@tD2W@tvȴ9X@tF@tvȴ9X@tD/@tvȴ9X@t=b@8]ce@8yDg8~@3uS@3\Z@27KƧ@2ҩ @25sh@2 <64@25sh@2Ov_خ@25sh@2 <쿲?=,܊{g?Ȼv\?c?T|2?Y@?L? Z ?&ژ?-S^?=:=N>?C]F~?(z@?pi?z?v'X?C?wͶ?`i=@@@@@*@*??????)9?"[?y;3@ `R@tH-?CѱK?PTD@Aτ\?`%*@o-@@-bM@-E@-bM@-Ӂ@-bM@-w@-bM@-s@-bM@-e@-bM@-!-w@bM@nP@bM@O @bM@3332@bM@C@bM@s@bM@:~@6 xF@6oiDh@3E?|h@3Iy @2`A7L@2y=c@2#@2)@2#@2)rGE8@2#@2)rGE8?F/P5?AZ??\2?D?2 ?GZ?x@@@@@*@,???????$a2`?9~?:ZU@+w@J`?X ??[&*5l?im4?]G|?0-Bq?͗u*?L5Sk?bM?h2:?n3?>RK?I?I@@,@,@,@7@;??????CDL?/Ϸ>Wu,{g@K%@?i6?>7q?h#l?w>1>m@s *rW@@7Q@7RnQ@7Q.@7Q.@7Q.@7Q.@7Q.@$5?|@$34l@$5?|.@$5?|.@$5?|.@$5?|.@$5?|.@4쿱[X@4 Y@1hr.Mm@1"`B.Qn@1 -0U2a|.NC,@1 -0U2a|.NC,@1 -0U2a|.NC,?|l@8#@8:@8 >+@8I@8?|g68@8@8i@8@8S@8?}@8 *@8p@8@8 @8 @ ?@}p -@ς\(@}p -@b\(@}p -@t3@}p -@p)^@}p -@s@N@}p -@stj~@}aG{@}O\(@}aG{@}R@}aG{@}WO:@}aG{@}ca@P@}aG{@}^m\@}aG{@}a [@8|Q@8 @4f+ J@4`{@3-@3$tT@2[W?@2Y|@2[W?@2ȴ9X@2[W?@24m?3a=? )}o?Q-(Z?4]t?bJֵ?>V$?WZM?UX|e?~?wAV? E!?f:[c#?mW?8J??}(3?.SM?x?r@@@@@*@*??????l0?V"Q?St`7&?ai ~@uD$t@}_&1?ult?uGWIM?ݛs'z?1_@oЏ@@1&@Q@1&@4K@1&@"@1&@C @1&@VOv`@1&@1@O;@z@O;@E@O;@cA@O;@4m@O;@@O;@/@8:@9\(@4+@2&&I@3`A7L@1em\@3p@0ٓ @3p@0n@3p@0ڹ?І$?O;5?ѠD ?^2?.I?̼+Hn?QN?Žs3 ?[?AM?z֪=?Xb?F(?+Qt?%Zo ?L(?;}?S^^G>@@@@@*@*??????nTHìtH?4/?zqC@@#0_@W?لmk ?ſ@DK|>@).@i7ų&@@5?|@L@5?|@|P@5?|@kR@5?|@wkQ@5?|@XyB@5?|@$9?]Ov?ڢ:]S?Tfx?EP\?/j~? Rh?ۃ?K?&Q~?)?ы>?gJ@@@@@5@6??????gm(*E `?u -i?;k@F,%@v?4{7? -9/?Ct?}S?a@c a;N@@aG{@a7K@aG{@a@aG{@a@aG{@aaf@aG{@`d@aG{@`n@Ǯz@Ǯz@Ǯz@@Ǯz@Ǯz@Ǯz@k}@Ǯz@@@Ǯz@˒:@3~($@3Ƨ@/j~@/!-w1@.&x@.H@-`d@-*0U3@-`d@-@-`d@-ߥ?|O?[e?d_#?.cC?@[?íC@5 ě@5j͞&@4~"@4~@4^6z@45\(@4^6z@4FIQ@4^6z@4*͞&@8J?o\3d?cOֲ?- ?'&?@8J?K)?*&k?Y5}Go?֡(?.Э[@8p?:UYP?H/b?*Q_?VM?!f@@@@,@$?????@n(@nj~@n(@n/@n(@nwkP@n(@n!.I@n(@ns@n(@nq @Pmhr@Pm@Pmhr@Pm5Xy@Pmhr@PmB@Pmhr@Pm\@Pmhr@Pm&@Pmhr@Pm@2!.@2oiDh@/G-@/G#@.mO;dZ@.m@.Vl"@.!.H@.Vl"@.!.H@.Vl"@.}H?^Dw'?J`Y?$C@?ƠJ-M?u?+ʦ_?bV,?&uE@?/BH?Kd]?qN?{L բD?b@?6?|׿pZ? ??b/bJ?f_Ԋ@@@@@,@*??????ISZ?)\?8Y#`>w@n >@Pm)?Gߵ? -0^J?9tִ? oM@sg@@qm@qn@qm@qm@qm@rW@qm@u?|@qm@pH@qm@k6z@ow@n+@ow@mhr@ow@ka@ow@lcA@ow@m(@ow@l>B@4[~($@4[҈@0r Ĝ@0y @0b-V@0`C@/QN;6@/N!R=@/QN;6@/O͞@/QN;6@/H9Xb?}ѿ,?`?$C@?G?~|+?-! )m?|O? ,C?O(?9~F?<U?@ A2?=Ca?Ф?]?hB^?7? `@@@@@&@*??????A]:̮?MQϟ77?)K@qFj^@m߀?l?JD8@MzG@Mz*6@MzG@M{6ג@3uS&@3uL_@1^5?|@1Z`@0-@0\@0iB@0PwS@0iB@0C?@0iB@0,V?|b@?zR?7*?ge?c7A?uZΑ?|h2:?.?(Wg?2s`? *+R?SRe?g?Ȋv?Ψ,UiW?ͩ&?B1-?'f@@*@$@@4@4??????8h? gP?GJ?00-C.D@JR@M{GS?72C?PтՆ?~9]?Gh@f @ @v@@@v@!/@v@Ov_@v@1@v@6@v@zI@$3333@$6o*@$3333@$C@$3333@$m]@$3333@$IQ@$3333@$Vϫ@$3333@$hr@7S&@7!:@4G+@4N\N<@3'KƧ@3)'RTa@3?䎊r@3N$t@3?䎊r@3FE@3?䎊r@3Yԕ*?W?1?0?^ܪɅ ?(:)[a?!8?Q?y\?]:.?dc??sB?ٲ?'W?jNR?{W?S̷$?3?57@@@@@*@,???????Y 9}T?QqetC?:٤_#@x~@$e ?o6rr$?X3G??7S#m@eP@ -@V@V@V@.3@V@V@V@ߤA@V@t@V@U=@`+@`XbN@`+@`e+@`+@`u%E@`+@`=c@`+@`"@`+@`e+@2p4m8@2p'RT`@.G-@.HK]c@-?;dZ@-?H˒:@- -#9@- -d7@- -#9@- -W'@- -#9@- -qiC?^Q5P?GA?"?!#?6r In?$?bV,? C`?90?EP?,Y?X78?cPQ?.+?u@>N ?hB^??f_Ԋ@@@@@*@(??????V o?m ?7dh*9?' -B@_JW@`zW?Fnzl?6JDj?'=?e\ @s -ے@ @tQ@tLC@tQ@tK~(@tQ@tBh Ԕ@tQ@tBC,@tQ@tU?@tQ@t+S@J@J@J@J'/@J@JnP@J@JЉ'R@J@Jξߤ@@J@Jt@6쿱[X@6|Q@3+S@3+qu!@2tj@2tSN@2䎊r@2ߤ@2䎊r@2U=@2䎊r@2z^5?|?F/P5?(.?u*y?vI?Fǥ?6% v -?UbB2?Zk?2'?8h\?uG<?>?~$?{37@2B@5@2?q@2B@5@2A -P?~Ov_ح?A?I '?Ă?fRb?PTP?؂QJ?|K"λ@fm(t@@#@@#@n@#@@#A\@#@@#Fbت@#@@#DX k@#@@#@@#@@#A;s@.O@.+@.O@3EN@.O@/4l@.O@9!@.O@6#+k@.O@=܌"@4 xF@4@2=hr @2:c>@1A7K@1o(@0,<@0ca@0,<@0!(@0,<@09@?|h2:?h.vb?f ?Qx?@>?^|#D?|b@?QY??ڙ?1k4x1?#?Znv`#?(?q?xeS?ʽ?v"s?OBX@@$@ @ @4@,???????;3 n@?g.?=S?B9>@#A`a4@58Ɲ?\r`q?b!~R??SM!?kC-b@fA@@7K.@7K@Q$@7K@9@7K@aw@7K@@7K@o@4+ .@4+ @8l6A@4+ @7tO@4+ @8@+:@4+ @9L @4+ @7͞@4(YJ.>@0xr Ĝ@/RO&+@/1'@.Q+u@/b~@-k}@/b~@-Ip@/b~@-%ʏ@8J?]???dX4/? Aw?/Xye@8J?Լ?^C~+?F6Hy?҉[\?6r'@8p?`T?C?_-?x?vH=@"@"@(@>@<?????@&x@E@&x@^5@@&x@+ I@&x@*0U2@&x@rG@&x@u%F @u@tj@u@\*@u@\)@u@2@u@?@u@"`B@8hYJ@8j=p -@3S@3M:@27KƧ@2䎊@2h@2bC,@2h@2\_@2h@2],=?Br?[ꕠ?@g?1t?ťBW?zvȭc?3a=?7fU?6$l?yCW?La?_I?ݾ?k~?ZaQ??;kr>?|+~@@@@@$@,??????jV?\`5?@: -?@?_6{@!Nt@?` A?~R.3???G|Z@ho`w@@ffff@ffff@ffff@ffff@ffff@oi@ffff@cA @ffff@z@ffff@?@:S@:(@:S@:}H@:S@:%@:S@:;dZ@:S@:v@:S@:b@5hYJ@5i#w@3I^5?@35Xy>@2Ƨ@2}Vl@2p@2oAs@2p@2p{@2p@2p{?}ѿ,?@k=[??j6_? i?4?}ѿ,?z?36G?6)}?u$6??oܧ?t?I@1@1N@1@1<˷@1@1wk?`/.~?И?_p?6狳n?A2f?Zf?¨Sp*?].>x3?7$]? 2??oH?Dk'?2?2T?`z&??^.ג4?#4U@@&@"@@7@:???????5Q?ES^p?a+W2?V4h1E@'>b@^zGYH?Zu9?] .An@q Yf@ c?R?7l?,?}pxXVn@f06@@1|h.@1|h@1)@1|h@1@1|h@1|@1|h@1,zx@1|h@1@@nO.@nO@U$@nO@x@nO@Z@nO@s3333@nO@r{@7 ]ce.>@2hr@2hۋq@2'KƧ@2*)y@1ush@1@1ush@1x@1ush@1T`d@8J?OaMy?P"hI?8i?k;?ѫĵ~@8J?k!?AuG1?ѡb??U? ,@8p?fI%?+jf?p_?;kr>?8wx@@@@*@*?????@+.O@+,@+.O@+(6@+.O@+&*7@+.O@+8'V|@+.O@+3#6@+.O@+7@.1@_v@_:S@_v@_=@_v@_4@_v@_ H<@_v@_~3@_v@_@65S&@65/9@3^5?}@3E) -@2]V@2Sѣ[r@1QiB@1;5@1QiB@16HO@1QiB@16Ӫ??:[?9#? rU?C?&)?~Ov_ح?>۶}?!(8?A|:?]g[?;Rtb?PI?&ݮ7?67Dx? -d?7?>-!@@*@"@ @:@8???????e=|KFM?NfO?aC=H@+2pw@_e?k kV? 3c?OBJS@Q{5@dڧ̼@@a9XbN@a<(Ž@a9XbN.@a9XbN.@a9XbN.@a9XbN@a:kP@a9XbN@a;~@s3333@vE@s3333.@s3333.@s3333.@s3333@yb@s3333@w1@7*0U2b@7,zxl@3+.Mm@2`A7L.Qn@2._o .NC,@2._o @2)_o@2._o @2)ԕ*?F^S@8#@8:@8 >+?q?6?Br@8@8i@8??sB? j?pr@8 *@8p@8?)@Jq?)@Jq@@,@*???@Yvȴ.@Yvȴ@Y9{i@Yvȴ@Y{@Yvȴ@Y!O@Yvȴ@Y@Yvȴ@YDc@zG.@zG@xQ@zG@z!@zG@-#@zG@(@zG@"1G@4e!..>@0 I^5@0o:@.1&x@.)"@-u%F -@-c^5@-u%F -@-6:@-u%F -@-Ʋ1@8J?EU?p-n?5?[?y@8J?7rR?S|]?Ä5?]^A?+@8p?zߔ"?yu?ᄢo?~3]?1I@$@(@$@;@8?????@{dZ@|j~@{dZ@u%@{dZ@삨/@{dZ@pr@{dZ@u=@{dZ@ -Wr@^Q@_vȴ@^Q@i@^Q@,T`@^Q@@?Q[@^Q@6b"Y@^Q@<0@4!.@4ڭ>@0hr @0}@0;Ƨ@0%&Y@/Z@/oXKo@/Z@/y%!ٍ@/Z@/tfy9?}@TΥ?Ċa>?9 p?X5?gV?ըzj?nO?_6+@d0\|@@}@}A7M@}@}ae@}@}-w1@}@}҈@}@|҈o@}@|%@_;dZ@_;dZ@_;dZ@_vȴ@_;dZ@_@_;dZ@_@_;dZ@^%@_;dZ@^Ov_@3쿱[X@3t@0?|h@0=J@.;dZ@.:~@/L@/Lzxl"@/L@/Lq @/L@/LL_?|O?Čۨ1A?7[䭝?ݶ\r?V^?)]\?| ? ,C?ٚlq?G>G?77?"?=Ca?sq#?W ?$H?ܑ ?<71@@@@@$@$??????1!G?*=3?!]@|Ҥԫ@_D?J^]a?B |[Q?ߠ=r?3/@f{^@@@n@@n@@n@C9@@n@L"h @@n@=Vl@@n@>($ x@@n@GB?2}?+@4+@4F@397KƧ@39e+a@3+xF^@3*6D@3+xF^@3*qiC@3+xF^@3* @8J?}>??$jB?3 -fu?Qc -?RLnj?7=^9?+d?c?qN??hE?^ a?Xk-7?l@@@@@$@&??????5/z?IzD?3Go@z;X@S;8?hu51D%?T(~*?&9:? kC@i$nQ@%@bM@ -=@bM@GE8@bM@W@bM@|@bM@|@bM@@_`A7L@_`n@_`A7L@_dg8~@_`A7L@_g8}@_`A7L@_p$t@_`A7L@_jqi@_`A7L@_i@2[~($@2[m\@.)7KƧ@.%oh@-4E@-0'RT@,PH@,q @,PH@,C%@,PH@,~($ x?^Dw'?9؊?e -!C?q@v?ɿ?Rg.?bV,?zF?ZH|:?9~F?l}?p?|;}_?3;?֘>D?+ ?W|DC?@@@@@,@,??????^rxi_?9eΡ??RnH@@_mVt#?H*I(?aL J?:}逭?~`wlLF@r5/VM@&@4# -=q@4vȴ:@4# -=q@4$t@4# -=q@4#2@4# -=q@4$7ޡ@4# -=q@4"M@4# -=q@4!D&@ ě@|@@ ě@q@ ě@b )@ ě@mJy@ ě@˶b@ ě@hIXg@8cg l@8W:<@2)+ @2(m@1`A7L@1Y@0̿[W?@0 ^@0̿[W?@0ZoT@0̿[W?@0KR ?R? ߥ?EqF?1?> c? ?z|3?1bşIr?)jSc?H? uv?X8K@@(@&@ @7@6??????+@8I@8?% @8@8i@8@8S@8?n@8 *@8p@8@8 @8 @?(@nP@䛥T@nP@Y@nP@7KƧ@nP@bM@nP@-V@nP@ I@6bM@6ES@6bM@6S@6bM@6@6bM@6 -=p@6bM@6@6bM@6 -=p@8s@7&J@4f+ J@4dM:@3j~#@3cA \@2@2zG@2@2ݲ-V@2@2Ov_?VAK?05 [?[_(?=]. ?[9,?mׁe\?3? ?mK?ni" ? ^??Ր?mh.?2}?_?RJ?HF!6?ā@@@@@@??????a{qe?N߱?cOo>?pޢD}@,҆@6]b?r߻u˫w??zX?ݷR\?GϽ@s{\_@)@\(@\(@\(@:~@\(@H@\(@:~@\(@V@\(@c @A$/@AG{@A$/@An.@A$/@An.@A$/@A'@A$/@Aoh@A$/@A'@-eݗ@-eݗ@+$tj@+#\N@*nO@*䎊@)@)vȴ9W@)@)%@)@)iB?^Q5P?GA?>f?MA8?<`.?:?bV,?r/B?j?3.Yl?@?R g!ڢ?b@?u?s@a?XLL?O|q?Ѐ>(@@@@@(@,??????K~'@?24:?O@~@A̼T?B Š%?%\O:?3[ u?Dˤv@sK$&@*@eEQ@eEQ@eEQ@eE@eEQ@eD2W@eEQ@eCS@eEQ@eC\@eEQ@eDg8~@R!@R" I^@R!@R!'@R!@R䎊@R!@Rvȴ9@R!@R"u%F @R!@R"M@1@1@/WKƧ@/UY|@.o@.Ft@.@.~%@.@.@.@.6z?^XN?h?.Ү_ ?eU5?E{?7F?bV,? H?'Q?RLnj?,Y?wN z_?b@?Ϸ+?֘>D?˴C??B @@@@@,@*???????=j6?[͎?ZDd?Eh8@eC(@R اy?(]c?T?hA?MRק.?[җ@s|Ю+@+@Õ%@ -=r@Õ%@v@Õ%@!@Õ%@!!@Õ%@@Õ%@ϻ@gy"@gy"@gy"@gy۫@gy"@gy"@gy"@gzt#@gy"@gzJu@gy"@gyo.@0qiC@0qiC@.MV@.M)b<@-ΗO;@-XQjw@-z)_@-zD{@-z)_@-z8@-z)_@-z ?^j?{TV?"(#*m??%r}?T|/?bMn?x???/[2?֓j?S!?bM?9?u؆"? ?"F?s`@@$@,@&@;@9??????;Z T&g? ?!o -a@h[@gzf?*g}*?0 -?Q֨?W04@s-H@,@aR@aR@aR@aSMj@aR@aS|@aR@aSa@@aR@aQX@aR@aQ@ٙ@ٙ@ٙ@@ٙ@PH@ٙ@ k@ٙ@A@ٙ@e+@1}:@1}:@/j~@/%F -L@.ΗO<@.α2X@.Z@.M:@.Z@.@.Z@.?^Q5P?[e@4G+@4$`@4`A@3@3#@2FX=@3#@3@@3#@3 @8J?[.[?"!?aU?[$$?XE%:@8J? ;&?ދC?A4?=i6?ے|@8p?Ag?޻ɩ}?Σw'Y?t#$ ?F@@$@@@?????.@@˅R@.@.@.@.@.@Qhr!@MO;d@Qhr!.@Qhr!.@Qhr!.@Qhr!.@Qhr!.@7(YJ@7&_ح@4hr.Mm@4`A7.Qn@3[W?.NC,@3[W?.NC,@3[W?.NC,?1j@8#@8:@8 >+@8I@8?sD@8@8i@8@8S@8?,1'@8 *@8p@8@8 @8 @?/@vE@vE@vE@vJf@vE@vES&@vE@vKC@vE@vI@vE@vM(@=p@=p@=p@@=p@@=p@^ @=p@J@=p@e@1qiC@1~"@-V@-@+nP@+\N<@,At@, ԕ+@,At@,K]e@,At@, k?^XN?'?Gy??5~pY5?y%?EeX?bM_x?CO?:?@[*^?A? 3W?e@'?9o?8*?"a??Tj?WZ@@@@@$@*???????Jk`w9?NE?F.B@vK.y@͙jT?\rC?T?<-?E+\@r'Q@0@]/@nzH@]/@jqi@]/@^ߤ?@]/@W1@]/.@]/@䎊@.zH@;dZ@.zH@@.zH@vȴ@.zH@IR@.zH.@.zH@ᰉ@9hYJ@9Vx@5B ě@5@4dj~@42䎊@3Q@3n.3@3Q.NC,@3Q@3BZc ?)T?^y?Ғn?э -@8I?S* ?J>x?_?k?µAj@8S?:; ݹ? -eKs?d?"i]P? a@8 ?ډ@@@@@,?????1@w@-@w@kʇ0@w@^.@w@li@w@'@w@@ Q@ @ Q@_@ Q@Jt@ Q@% +@ Q@ CV@ Q@ US)@3uS&@3tg|@1 ě@0ã@1$j~@0 ZZ@0&@/B@0&@0")[>@0&@0[R?|h2:?z~?yn'?Gw?#?tm?}@TΥ?˟g?Gšt?u:z0?d=k?llg|??RѢy?ҞM?%?\_?e< ?e@@ @@ @4@5???????dF@?SmY֬?K -5Wf?\>b#@ˠv@ ݇j?\H=K?-:@c?bӤ @IF`y<@_՞@2@XbN@+@XbN@we@XbN@Qu@XbN@@XbN@T@XbN@@k\(@kZܼ@k\(@k@k\(@khH@k\(@kM@k\(@km@k\(@k@47@@48LP@05?|@02W@0 -V@0 Gb@0^6z@0XЯf@0^6z@0Yj *6@0^6z@0X҈p?|b@?]?_Vfv?Z3g?sC?2} ?| V? ?(r?;??Z?wƫ ?;?Av?+?[?@@$@*@*@:@8??????7?$?qFɸk?# ^+/@Nh@k ?6+xX?C.@?x3%~?ka@f.Y@3@)"M.@)"M.@)"M.@)"M.@)"M.@)"M.@X33333.@X33333.@X33333.@X33333.@X33333.@X33333.@9|Q.>@5B ě.Mm@4t.Qn@4䎊r.NC,@4䎊r.NC,@4䎊r.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 4@ I@Ƨ@ I@ @ I@:)@ I@1&@ I@/{K@ I@ݗ@ +@ w@ +@ ^5@@ +@ @ +@ PH@ +@ 1@ +@ -f@6䎊@6 xF@3f+ J@3esg@2t@2u@25sh@23nP@25sh@23F]c@25sh@2/{J#:?Y͍_?%ñ?1V?'$5?+?^m*?F/P5?馿j?|ɽ?RLnj?Ll?Xo?K4@:ۖ>@ r?\$<]E?km>/? *F?H?Ni@hx @5@|-@|F@|-@}/n@|-@|f,=@|-@}v@|-.@|-.@9Xb@^5?}@9Xb@H@9Xb@ڹ@9Xb@=c@9Xb.@9Xb.@804m8@86$/@3+ J@3XF]c@2ߝ-V@2!.I@2@2 -=p@2.NC,@2.NC,?A[F?ū}?οF;? !@8I@8?ȉak?YB9J?42?ny@8S@8?^$f,?"{Ę?(??=U)@8 @8 @@@@????6@|hs@{lE@|hs@|j~@|hs@vȴ@|hs@}E@|hs@{qu"@|hs@|hs@ ě@o@ ě@@ ě@v_ح@ ě@zH@ ě@'@ ě@A [@6v@6W>6z@2@2n.2@2tj@2@@1Q@15Xz@1Q@1jf@1Q@1D?Br? e?K?vHn&? i?#{׈?=fA:? l?'Q?_3\?8,T?.8?7^|?z?],V?`?*Z}?0&YEd@@@@@ @???????% ?RN?4r$?4W@|"@#Q?T{+?T b7?ĘD?1>t@j嬕@7@Q@+@Q@%@Q@hs@Q@! [@Q@+@Q@j~@/@@/@-@/@/@/@@/@<64@/@}H@6@6 ě@2^5?|@2^5?|@2{Ƨ@2{U=@1@1|@1@1F]c@1@1?qn?d̺?&P? h?Xe?T-N?2}?l?'Q?~m??az?.8 -B?W?J>?L?%ϑ?A0)n?A0)n@@@@@,@*???????DkZXBd?R>fv\?rl@@in\?n9K?7/$Y?ZdE?sLtzm@k~ k@8@~".@~"@B}@~"@- @~"@̑=O@~"@Z@~"@9w@bM.@bM@^¬.@bM@W@bM@=Y@bM@G<@bM@r@9w@.>@4J^5?|@47^3 -@46-@4E3@3Tm8@3! @3Tm8@3%,0@3Tm8@3 TR!Wh@8J?p?]]?c ?/1?z+͛@8J?5ot?N-+g?`nk?xu?t @8p?}aE?`oٶ?IH?ǫ?z@$@(@(@3@1?????9@-tj@-r @-tj@-~@-tj@-v@-tj@-vȴ9@-tj@-$/@-tj@-1&x@]tj~@]$@]tj~@^ں@]tj~@]Fs@]tj~@][@]tj~@]L/@]tj~@]vȴ9@8֚,<@8-w1@3 I^5@3\)@3M-V@3G)^@3!.I@3 C]@3!.I@2!R<@3!.I@2XbM?S?AZ?uzH{*?^? ?xh`?ȸa? ?]&7?'y?OL?/Ւ??Ov_ح?7^|?m7>n?Qh@?D7<@@@@@ @&???????xx`vNe?RtR#j?@ ?@-lH@]*?bp?' -먏%?77!?p~z@p@:@O@R@O@8@O@hr@O@-@O@qj@O@@"`B@vȴ@"`B@!-w1@"`B@S@"`B@!s@"`B@ @"`B@64@87@@8: @3R I^5@3Np:~@2tj@2e@2L[W?@2H@2L[W?@2F1.@2L[W?@2G$tS?{@4+.Mm@3-V.Qn@36z.NC,@36z.NC,@36z.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 <@'-@(r @'-@+6@'-@-\@'-@+åX@'-@$]I@'-@%JP@Ӓ@Ӓ@Ӓ@Ӓ\S.@Ӓ@ӏ[Jx@Ӓ@ӐP@Ӓ@ӒY @Ӓ@Ӓ\>@2 xF@2@1TS@1Te핦@1t@1@0kxF^@0jj@0kxF^@0iy@0kxF^@0ii}?^j?F -?;"{? U}ԃ?h2$?݆?bMn?.?<~z?aNl?Q?@)?znU?r,?;?Ʌ%?-#?Zoh$l@@"@ @$@3@4??????XP?Mvh?B7ij?5$@'53@ӑ_?]?2?7?:1?@@@@*@*???????0*<?8@?$wǪrE@Y7g@27?Gύ?3x?CO ?^ g@s@>@M>vȴ9.@M>vȴ9@M+:)@M>vȴ9@M;6@M>vȴ9@M>\N@M>vȴ9@M<n/@M>vȴ9.@t+ I.@t+ I@tkC@t+ I@ti*0U1@t+ I@tSMk@t+ I@t6z@t+ I.@7쿱[X.>@2r Ĝ@2ŨXy=@217Kƨ@2;C\@1O M@1Y|@1O M@1/w@1O M.NC,@8J?97?^?Z.?X@8@8J?۔b?wSZ?uX?^候@8@8p?RQҿ?jx?V]9V?mCc4@8 @@@@*?????@ě@`B@ě@e+@ě@3333@ě@@ě@@ě@+@@r @@@@S&@@-&@@VC@@R{@8}:@7+@3 I^@3U=@397KƧ@3/H˒:@2𖻘@2ѩl@2𖻘@2S&@2𖻘@2Y}?k!˫? e?r?wP??l#?-Apa?WZM?-A?ίM?.6k?=x@@@@@(@&???????ʈ0o?m?'Y@ ,@}#a8?ѓ)/?p:?- -A?@@m~@@@χ+ J@ς I^@χ+ J@φfffe@χ+ J@τT@χ+ J@υ84@χ+ J@σ,zw@χ+ J@π҈@xTF@xW@xTF@xT!-w@xTF@xS3333@xTF@xN}Vl@xTF@xSMj@xTF@xT,<@7uS&@7u$/@2xr Ĝ@2usg@1ߝ-V@1v@1n_o @1jd7@1n_o @1lu"@1n_o @1lC,zy?}ѿ,?p~v]?jhq9?A%?uxY?"X?? -?)_?߇O?A ?Ր?t -j?3a=?ArUA?Z?“y?7zE@@@@@*@(???????#rFQ6z@}A7L@}(@8zqiC@8n (@4+S@4-!.H@3A7K@3g l@3#@3'@3#@3 4m@3#@3{J#:?]? 1H?r?%? 8{?Q`?]?\??RLnj?| u?ܷ-?*wjs?~?=}?@fo(?;kr>?ymcw\?@@@@,@"??????^$6?@o?K@?S(BSX@+$DM@}h)?\U}?c2Ђx?]?VYs?DVR@r#YY@B@ȴ9X.@ȴ9X@s@ȴ9X@-@ȴ9X@‚@@ȴ9X@- @ȴ9X@PH@9v.@9v@9@9v@9Xy>@9v@9@9v@9-@9v@93332@9䎊.>@58r Ĝ@58>BZc@3tj@3*0@3_o @3H˒@3_o @3Mj@3_o @3sg@8J?:}T?g ? :>Co?a`??KAb@8J?HG^?b? aK?C B??4@8p?:?ԇ:? Y?0C?@@@@*@&?????C@y+.@y+@z.@y+@z@y+@z@@y+@xV@y+@x+1@;ě.@;ě@;1@;ě@;p@;ě@; М@;ě@;6F'@;ě@;]y@5mv.>@1+ @1,"@1Z~"@1[E@0@0xe@0@0V.\K@0@05H@8J?I?G6X]?Or?)]E?S{a@8J?V ?g$?0Ij?(~ ?@8p?! ?:C8?!/1?S/?@"@$@@8@5?????D@+ I@a@+ I.@+ I.@+ I.@+ I@֣'@+ I@D@F9X@Fx@F9X.@F9X.@F9X.@F9X@F%zc@F9X@FXk@6V,<@6T(@25S.Mm@1`A.Qn@1z,<.NC,@1z,<@1M @1z,<@1ű%?t D5@8#@8:@8 >+?" -?I ?}@TΥ@8@8i@8?k?J?9sîgD@8 *@8p@8?iCr.?K@@5@$???E@+@8I@8?E[i)@8@8i@8@8S@8?wv@8 *@8p@8@8 @8 @?F@6zG@6@6zG@69Xb@6zG@6tj@6zG@6Z@6zG@6l@6zG.@w@w@w@xl"h -@w@y+@w@|PH@w@u?|@w.@3@3o@0@ ě@0@)^@0'KƧ@0'8}H@/p'RU@/s@/p'RU@/p -=p@/p'RU.NC,? ?t0?wk?ھ۲?Z)@8?}ѿ,?jכc?F@4@ ě.Mm@3ȓtj.Qn@2:S.NC,@2:S.NC,@2:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 H@hr @i7Kƨ@hr @eoiD@hr @p*0@hr @yb@hr .@hr .@R@V@R@R@R@@R@S@R.@R.@6^H@6]\@3hr @3m8@3-@34֡b@3Q@3Xy=ـ@3Q.NC,@3Q.NC,?|O?.5?[:@4|hr.Mm@3".Qn@3ce.NC,@3ce.NC,@3ce.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 K@k"@l@k"@kYJ@k"@kx@k"@k*1@k"@k4J@k"@kL_@N{lD@N"@N{lD@No@N{lD@NnO@N{lD@N@N{lD@N @N{lD@NA@6!.@6!.@4I^5?@4'RT`@3-@3-@36z@3_@36z@3A7K@36z@3$/?Txvc?4o:v?YtBs6?C>$;?m,h?`{wz?ռUӛ?dpn?oɼ|)E? -e?mCc4@@@@@*@*??????p_kKDF?c{?[ͨT@ku>@NߦU?qz+E.?kQS?2L҂?ʕ@r/w0D@L@ r-V@ qn@ r-V@ sZ@ r-V@ s@ r-V@ s@N@ r-V@ qhr!@ r-V@ q_@ q&x@ q&x@ q&x@ qhr"@ q&x@ rs@ q&x@ q[W>@ q&x@ qu!@ q&x@ qu@12@12@,V@,:@,1&y@,҈@+Gݗ,@+G k@+Gݗ,@+G_o@+Gݗ,@+Gy ?^XN?°R;?"?ƠJ-M?g?tJ?bM_x? ,C?j?; $?2&h?PS2K?bMky?.+?|׿pZ?XLL?Ѐ>(?a+@@@@@,@*??????O7#@?د?/ϰ>A@ч@ r@ qv,,?=^ ބ>@ =Ф?u7>Φ~@s -}%@M@1&y@x@1&y@@@1&y@K]@1&y@/W@1&y@)_@1&y@ڹ@*H1&y@*H1&y@*H1&y@*FA@*H1&y@*GE86@*H1&y@*H@*H1&y@*I@*H1&y@*I@4,<@4@0^5?|@0Q@0ttj@0t֡a@.C\@. k@.C\@.kP@.C\@.u?2}?b[? ? {4? i?IdA.(@ -F@*H~?E:-?LQ~?q.?0[^4@g+ -^@N@R_;dZ@RlFtM@R_;dZ@R_W@R_;dZ@R]E@R_;dZ@R` s@R_;dZ@R]K]@R_;dZ@R]~J@te`A7@t]tbs|@te`A7@tvms8@te`A7@tm-͐@te`A7@tg2+@te`A7@tt$@te`A7@tk>@8쿱[X@8wr@2G+@2BtyB@1>Vu@19-@/)_@/lU@/)_@/@ @/)_@/Ʃv?)@?}?K?;m?1)8X?4nr?Vz?G Dh1?X^@3+ J@3zG@2R`A@2^p:~@1Q@1ރ%@1Q@1!-w@1Q.NC,@8J?5FĴ@p@Q@+-@+r@+-@+RT`@+-@+E@+-@+ -L0@+-@+22-@+-@+ ڜ@p1&y@p^5?@p1&y@px74@p1&y@p}Vl@p1&y@pzC\@p1&y@p@p1&y@pxS@4g l@4dZ@2#@2!_p@1-V@1M:@1+xF^@1<ߤ@@1+xF^@14RP@1+xF^@11xv?| V?M?b/?ѮvtQ?BTS??|b@?|?r ?@(?CX-?H, -U}?nՉV?Ov_ح?ԇ:?WhQ?2#Z?6/@@@@@0@0???????:M U?7CIU{?DQs@+}]@p4?X18$?eNF&?D?򰔼$@fnB^ @R@7K@z>Hs@7K@t@7K@s6@7K@6@7K@~b@7K@E6@O;@zG@O;@g@O;@f @O;@}y@O;@q@O;@'X@7 ]ce@70v @05?|@065@0]V@0\d!@/p'RU@/pl;|@/p'RU@/oB&@/p'RU@/l\?ɱb)Q?:4?})Y?=?]X?"? ?nO>?~?C&z?bl?R8?@@$@(@(@;@:???????PCn?RT$?A'&D>?N|@~7 @ϢP?](J%?:?-/wJP?y=v.@k.@S@׍O;@׍O;@׍O;.@׍O;.@׍O;.@׍O;.@׍O;.@?x@?@?x.@?x.@?x.@?x.@?x.@3@@32E@/)7KƧ.Mm@-Z1.Qn@-kjf.NC,@-kjf.NC,@-kjf.NC,?}9X@8#@8:@8 >+@8I@8?|g~D@8@8i@8@8S@8?=@8 *@8p@8@8 @8 @?T@v@vѩm@v@vn.@v@vm\@v@vp:@v@vd9@v@vϷ@(@$t@(@ڹ@(@@(@$@(@3|@(@1.@6YJ@6}Vl@4 ě@4-w1@3tj@3*@35sh@35ݗ@35sh@3.\N<@35sh@3/??E@?}S]N -?B)??$?s[z??t??>#?kH?Ri?Lp%Y?}d1H?  l?LdB"%?(Q?Xs~?>3}@@@@@$@"??????G!- ?i<?NkL??g|f1a@vk@(;-l?f2ZwW?~nR?#Ft ?LP@lee)@U@pO;d.@pO;d.@pO;d.@pO;d.@pO;d.@pO;d.@F.@F.@F.@F.@F.@F.@9p4m8.>@6ěT.Mm@5gKƧ.Qn@4YJ.NC,@4YJ.NC,@4YJ.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 V@Ǯz@$@Ǯz@]c@Ǯz@~@Ǯz@fyD@Ǯz@J@Ǯz@>B@]/@ C@]/@ _ȱ@]/@n@H@]/@$J(@]/@K (@]/@) @8֚,<@8.ʾj@5f+ J@5FL{|@4`A7@4@4@5@4QoV@4@5@4*B΃q@4@5@4&A?|0pJ?X/Z?ք;yK?3R2\?LD??:?O?PJ?|y?gz˛?܊+?&?$niJ=?Gj?c[z?,B S?84|@@&@(@*@<@*??????xLV?vp/@?zi?h%b@=0@%?5?x6iPm@ W;?_*@h0ff@W@}"`@}5?|@}"`@}Zc @}"`@}c@}"`@}G{@}"`@}r @}"`@}״3@˟;dZ@˝-U@˟;dZ@˝ڹ@˟;dZ@˜N;@˟;dZ@ˈp:@˟;dZ@˦1@˟;dZ@ˤe@7 D@7!7Kƨ@4+ J@4GE85@3Ƨ@3+jg@4ush@4d9XbN@4ush@4r@4n@4ush@4r@4n?sD?Ɖ?_r ?O@:??)}U?3a=?%@&??F ??+NP?~$?anñ?7#!xv?^FC}?X昘?9)N-@@@@@"@&???????D}?A*?YP?n=9 @}K@˜.=~?w^B~8?/Xϼ?[@-@gsW@X@%`A7@%Q@%`A7@(p:@%`A7@'ݗ@%`A7@'/W@%`A7@$7@%`A7@!.H@"+@"-V@"+@"Ж@"+@"V@"+@"&@"+@"`A@"+@"- @7@7,<@3@3+ I@2-V@2\N@2 [W?@2 U=@2 [W?@2 H˓@2 [W?@2 +j?ٛP?gUq#?a#mU?ܿ??;??=?us\?Hz? ހ?P?H<?)]\?-]?I1;?/X?O.ce?/̽`?Cns@@@@@*@&??????P4;?KA'o3?4 -Ku@%N=@"qYN?d %?Ryۚۺ?,&j2q?5QZ@nBNb<@Y@;vȴ9X@;n+@;vȴ9X@;|ߤ@;vȴ9X@;y_p@;vȴ9X@;}b@;vȴ9X@;y_o@;vȴ9X@;x-@@`B@@E@@ȴ9X@@ -=@@4@@Mj@74m8@7l@3?|h@3PH@2-@2ݗ+k@23&@2,@23&@2-%@23&@2.\ND?b =?ɟ_?p_? Ğ? -e@@@@@*@&??????g%tX?FG?Qu2?eL1 -cF@H8/@q66?q;?C*9?ߔXC?@k|@[@ěT@ϝ-@ěT@;q @ěT@P{@ěT@BZc @ěT@/V@ěT@m\@F\@FS@F\@DK~)@F\@FOv_@F\@C\(@F\@C+k@F\@Cc@8쿱[X@8n@3+@52wkP@3tj~@3C@2@1;lC@2@1J>B@2@1[Q?Q,Ě?#c?\?ԛ_' ?-hR?:b?UbB2?gn?ڛ?!sz?u?[y jX?A'_]?i^6?N( ? -*?h@?dItP@@@@@*@*??????I'%(ʉ[@?{?J^`u@5O@FP3?ww?7f?Yu}?=՛@[nE@\@mV@mO;d@mV@n_o@mV@nߤ@@mV@n_o@mV@kU=@mV@lq @ -=p@ -=p@ -=p@+ @ -=p@_ح@ -=p@+ @ -=p@ȴ9X@ -=p@@32@32@.f-@.f&I@,nP@,nP@-#Z@-#%2@-#Z@-#%2@-#Z@-#?|O?{j?"?䆀{6? f?װ*w?| ?5CQ?['?C B?Cq$u?_~t?n88??2Y0?':?a+?pk Y@@@@@*@,??????(_@ @?,-#? -Mz@m^1@i?LUsC?+S?9g=?czB"@f-@]@@nP@@Hz@@tGF@@$ړ@@Hr@@Yq@Z9XbN@Z9XbN@Z9XbN@Z<@>@Z9XbN@Z,@-凓ݗ@-凓ݗ@+7KƧ@+-i@+ӶE@+UAB@*Xy=@*5.@*Xy=@*e!Tb@*Xy=@*X}?^m d?jͪ_? n?ʖ?&{?An?bMn?c?4Ә.?@M)%?DE$?jT?bM?4= ?xA}?]s4P;?jfN?{{@@@&@"@"@5@1??????B0<\\F ?AJS֯?9 E@0@Z?,î?PG<7?G^v?D+?n}H@sԟ @^@;lD@=\y@;lD@=+k@;lD@@҈@;lD@<n.@;lD@?vȳ@;lD@C~T?6QLW?6%1B@=I @:T?W=[?UY6b.?QHT?@h?@_@ -=p@ -=p@ -=p@ @ -=p@ m@ -=p@ @ -=p@ )_@ -=p@ @`A@@`A@v_د@`A@̈́M<@`A@,<@`A@_@`A@v_د@5*0U2b@5K]c@1S@1a@@1 "`B@1 C%@06z@0쿱[X@06z@0"@06z@0ߤ??}ѿ,?Z?&t?2UT?G?봤G?Ol?Èa?CXs?Uh;?jx?+d?Ol?Q?Ol?9XNu?fW?7@@@@@,@(??????>܏#N-#>iY??,_@ K&@Ѥp\?A(P?M@DF?=CjƮ?tE D@h @`@ V@ hr@ V@ \Ք@ V@ i@ V@ y9v@ V@ ^x@ V@ e\{ @zGz@z@ѷY@zGz@yM7|@zGz@y -@zGz@yVe@zGz@z1lH@zGz@z5#.f@8|Q@8T@3 ě@3 ʈ@34tj@3N)JC @2c@2hJXH@2c@2]G\@2c@2_.?RL1T?Ӷz? &b?Z: m? -:g?7햞?|B &?o0D?3? A?ˁЅ?pkQ2?_4'0?GTU? ?Č?Fca?͍Q@@*@(@*@5@3??????Do`G?Yn;8u?m[ |@ xq@z7VDj?|2h?:*?RiRT@iw$/*@hF@a@_lC@_z@_lC@_@_lC@_K]d@_lC@_K]d@_lC@_,=@_lC@_,=@u?|@u?|@u?|@u=@u?|@u=@u?|@u?|@u?|@ush@u?|@u=@-7sPH@-7sPH@&MV@&Mqu!@$nP@$nP@$oi@$u@$oi@$u@$oi@$u?_\p)?[eW@_Ik@uj??)=3؏>@ih0?wDۮe>Hvi@sΫ@b@_;dZ@_;dZ@_;dZ@Uᰉ@_;dZ@WXe@_;dZ@U=@_;dZ@ZG@_;dZ@X*0@9)l@9%`A7@9)l@9 ^5?@9)l@8j~@9)l@8ݗ+@9)l@8?@9)l@8a@@5H@5y @3=hr @3,(\@3"-V@3 |@2䎊r@2l"h @2䎊r@2@2䎊r@2!R -fu?׾?"6Wz?O?*cuV??>?yjk?|nӿ?|)-}(? `@@@@@,@*??????[BMZlL'?GE~{_m?kg@\v-id@9 *?dKb? ?*6@O+?r@aޘ?b%?T+?!u?𠑓?'?v>?mGC?U$M\?RY=@@$@@@7@5?????? g##([?be=}w(?B0{VO@n@#rJ^?y"l>?ZA4?n*?r@`M%@d@1&y@`A@1&y@˒:@1&y@t@1&y@g @1&y@0 @1&y@Y@I7Kƨ@@ě@I7Kƨ@Jo@I7Kƨ@I^ -@I7Kƨ@F?@I7Kƨ@As@I7Kƨ@AG|@8*0U2b@8bM@4 I^5@43@3R`A@3R@4n@3@5@2q @3@5@2G{@3@5@2?2}?t0?_?g(6?R ,?`1`?=fA:?=}?$Jw"?~m??C]F~?J3?AK\ ?b =??B@?p& ?0ro{8@@@@@,@*???????Z8`?<3?8@`b?Li@UL@Bc?XV+k?i򲲸??rג@glub@e@d/@d䛥T@d/@doiC@d/@d凓ݘ@d/@d -L0@d/@d -=q@d/@d㢜w@ԛS@ԛS@ԛS@ԛS@ԛS@Ԝ@ԛS@ԜPH@ԛS@Ԝ]cf@ԛS@ԜPH@1YJ@1@-7KƧ@-7KƧ@-1&y@-/{J#@+`d@+Fs@+`d@+m8@+`d@+#?^Dw'? ?.Ү_ ?MA8?g??bM_x?#maЀ?ܿ?3.Yl?A B{?Uyu#?b@?6?2Y0?XLL?f_Ԋ?l&@@@@@*@(??????Q>שw5?3vV? >A}n@dd@ԜTY?B^9?Q>ۅ;?[d;? -C3@s/[@f@97Kƨ@9Z5R@97Kƨ.@97Kƨ.@97Kƨ.@97Kƨ.@97Kƨ.@l@B5O@l.@l.@l.@l.@l.@7H@7"LQ@35?|.Mm@3V.Qn@2m8.NC,@2m8.NC,@2m8.NC,?|gv@8#@8:@8 >+@8I@8?c@8@8i@8@8S@8?@8 *@8p@8@8 @8 @ ?g@mm.@mm@ms@mm@mnP@mm@mp:@mm@mD@mm@mD@-.@-@@-@- @-@V@-@rGE@-@V@(oo.>@"tj@"- @!x@!x@!oj@!oj@!oj@!oj@!oj@!oj@8 -Ny?°R;?m?ƠJ-M?tKc?>@82r? aҹz?rJs?/Z?tP*?L "@8L?8 T?nwg?~\?h?h@@@@,@&?????h@1&x.@1&x.@1&x.@1&x.@1&x.@1&x.@I7Kƨ.@I7Kƨ.@I7Kƨ.@I7Kƨ.@I7Kƨ.@I7Kƨ.@8s.>@4=hr .Mm@3"`.Qn@3Q.NC,@3Q.NC,@3Q.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 i@Cn.@Cn.@Cn.@Cn.@Cn.@Cn.@9x.@9x.@9x.@9x.@9x.@9x.@9%!..>@4i+ .Mm@3".Qn@2ce.NC,@2ce.NC,@2ce.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 j@,C@+C@,C@0- @,C@.@,C@,1&@,C@/iDg8@,C@-C]@-V@ ĝ@-V@@-V@m9@-V@@-V@&@-V@@6@6@2° ě@2[6@2R`A@2O͞@1+xF^@1)*0U2b@1+xF^@1&&J@1+xF^@1&Ov_?F/P5?gˣ? ? Iy?ZAj?6?}ѿ,? -?NH?Kd]?2}?f1-&?9@0w??+J@,G\@=>M?RPØ?_퀊O@?kKt?_1G@g+6@k@mhr@mhr@mhr@nzH@mhr@mV@mhr@mhr@mhr@j=p@mhr@kR@bM@bM@bM@`A@bM@hr!@bM@bM@bM@և+ @bM@˅R@4~($@4C,zx@08r Ĝ@07 k@/dZ@/D*@06z@0>BZ@06z@0C\@06z@0^5?|?]?}d?FB:?_B?ɿ?}?]?dx/?Rs??La?lINՄ?*wjs?fb?*wjs?,|?ad|?#.????@@???????T0Mm8 ?%D?L=} @j׎@[A?$Y?KM1?7&p?Qz1C@xq6@l@Tj~.@Tj~@Ush@Tj~@Sa@O@Tj~@U%F -@Tj~@SS@Tj~@R @53333.@53333@5\)@53333@5fA@53333@5j~@53333@5z@53333@5J#9@8.>@3^5?|@3ݘ@2Ƨ@2Z@2OO M@2Mw1@2OO M@2O\(@2OO M@2WO;d@8J?y)3c?3?@R?'`?+YI@8J?`?F^S?uX?8?Y@@8p?.]L?[Rb?C?ĭ?dItP@@@@,@,?????m@*I7Kƨ@*H9X@*I7Kƨ@*I7Kƨ@*I7Kƨ@*F?@*I7Kƨ@*I @*I7Kƨ@*G+ J@*I7Kƨ@*GfB@DT@D/@DT@E@DT@EQ@DT@FIR@DT@D%2@DT@DJ@5@@5b}@1 ě@1 qu@0ȓtj@0sPH@/fL/{K@/f -L/@/fL/{K@/fA@/fL/{K@/f$/?| ?1?e -!C?̒?E{? $4?1j?u߿?NJ?0N:s?,Y?B8?T0?lo>?!A -m?ۮetZ?L?b/bJ@@@@@(@*??????%,>Oe?-Y?W?.{@*Hs.@E"?MOx_Ye?NMC7e? -yH?vD@g.7@n@և+ @׍O;@և+ @٦ @և+ @4֡@և+ @@և+ @ᰊ@և+ @Ʌp@`B@/@`B@ѷ@`B@e@`B@塣n.@`B@墂@@`B@af@6|Q@6\(@1?|h@1eO@1-V@12X@0L[W?@0L"h Ԗ@0L[W?@0L(\@0L[W?@0L"h Ԗ?Br?sp?`כm?!#?5 g?C!?| ?$i %h?低NU?C B?݄ ? f?|׿pY?%_D?],m=?*|\/?ˢL1?L8AS@@@@@,@,???????i(G? =lj?']39@֌FNF@ >&?@2L_?Hљ-fH?EKl?G_XW@hzz@o@x.@x@A7L@x@Em\@x@v1@x@oiD@x@*0U@-V.@-V@,/{I@-V@bu%F @-V@^\N@-V@~($ @-V@tj@8S&.>@4kS@4*0@3t@3҈p;@2Q@2>t@2Q@2(u%F@2Q@2=b@8J?Wީ?Қ9?TE|?\ٝ?ˉ4+@8J?2? ?`kY?0-+?MQc@8p?F p?Ǚs?{/!?)v?tXr@@@@,@*?????p@Xtj@^vȴ8@Xtj@\1(@Xtj@e`A7@Xtj@]/@Xtj@T9Xb@Xtj@]ce@ ě@ 7K@ ě@ l@ ě@ l@ ě@ hr@ ě@ Z@ ě@ S&@5-v@5zxl"@1hr @1qu!@0`A@0O M@0J0U2a|@0CE@0J0U2a|@0E8YK@0J0U2a|@0EL_?}?ߋb?*"AaI?Ac ?] - ?oNR?|O?l?I?$?az? ,?6ז? U)?:-?(Q?}?7zE@@@@@@??????Qf@?N.?R/2?S0I_J@[U@ 9l?qY -Kh?tX?Sh?J^@h]@q@)sE@)sE@)sE@)t@)sE@)u?|@)sE@)t\@)sE@)uϪ͠@)sE@)v4@KC@KC@KC@LI^5@KC@Jo@KC@L@KC@MM;@KC@Kq @4 _o@4 _o@0+ @0U@0Ctj~@0B@4@0u@0M:@0u@0$@0u@0?| ?Čۨ1A?1f_?9.?\7?7F?| ? ,C?|,!?!zt9?az?y ?m!?2]7?u@>N ?l?7?GZ@@@@@,@$????????${?28>FvS?+O<Q@)t|@K?|4`y?KK}O?FnNl3?Ym@f@r@)8@)4zG@)8@)=IQ@)8@)64@)8@):Y@)8@)6E@)8@)5!R@XbN@-W@XbN@qu"@XbN@l"h -@XbN@XbN@XbN@#@XbN@qu#@5Q|Q@5HPH@3#@3% '0@2ȓtj@2)y@2c@2g -=p@2c@2h˒:*@2c@2f '?us\?+!?ʶs?,rg?yq?Dw?=fA:?o ?ZH|:?#X?Al.6?ܷ-??%2?d --?__C?GZ?E݋N@@@@@(@*???????'Ma;&?P` @}?@{H@)7H+@-(?lTN?`%?ӬI'X?f`m@k[H@s@Vu@?|h@Vu@<(@Vu@2X??ଚw?bdC?~fܤv?G6NM?ը:J0?F^S?56Q?D?byp?;~`?-j?z00!?w}'b?a?h?O?Jʿ?cg@@@@@*@&??????5h?- ?d?慕0@:cǠ@xS?ta"T?vg`@WV2@/a8 -@d& @t@f$/.@f$/@gz@f$/@jS@f$/@m-V@f$/@f4@f$/@eY}@+.@+@rGE9@+@ḭV@+@+ J@+@z@+@}H@8g l.>@4 I^@4W&@3KƧ@38YK@2䎊r@2?@2䎊r@2Mj@2䎊r@2 ҉@8J?=b?&?,rg?ĶBϪ?vȴ:@B\(@;J#9@B\(@Lzxl@B\(@UfA@`A@ hr@`A@?@`A@ @`A@:~@`A@ ԕ@`A@f@7쿱[X@7NV@4+S@4@2-@2Vl"@2Q@2u@2Q@2-w1@2Q@2&IR?ٛP?%=7"?uz?&SF??±|?|O?#?.j ?=M6?NZ׭?%TUx?T̅?AIa?L /?wZR)w?a<?A8 K@@@@@,@*???????iOLf(`U@?S'm?Q9>2@HI@/?t p?rvx|\m?ɂu?}[@fk^@x@`B.@`B.@`B.@`B.@`B.@`B.@i%S.@i%S.@i%S.@i%S.@i%S.@i%S.@5_o.>@2^5?|.Mm@1-.Qn@1O M.NC,@1O M.NC,@1O M.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 y@lF@lG@lF@lzG@lF@l?|@lF@lB@lF@l.@lF@lPH@fě@fě@fě@fS@fě@f.H@fě@f-V@fě@fl@fě@fXy=@3G>6z@3H $ p@/f-@/aR<6@. n@.e+a@,Vl"@,T`d@,Vl"@,g l@,Vl"@,a@O?}@TΥ? 1H?Gy??̒?2F0?&Gf?|h2:?D.x?A)N?6)}?~? # -?nڨ8?3I#i? # ??7?P\@@@@@,@,??????4uP?G54?>3u=8g?@Ni=ޮ@l6@fW?I?^e6?`w\F ?*bVˊ?F@fݐU@z@H+ J.@H+ J@H zV[t@H+ J@H"N_@H+ J@Hm@H+ J@Ga@H+ J@H}@9X.@9X@;R@9X@K@9X@ -@9X@ !@9X@Z:@6YJ.>@2hr@2$@1j~#@1@1+xF^@1+j1@1+xF^@1*XsU@1+xF^@1+T+@8J?Ek?͌ɼ? -A?&>?V)WE7A@8J?PoS?ReIt{~?fȹ}h?q!U?nr|?|ɽ??pPȻ??yz?Ov_ح?F?(> ?>LR_5?^':@@@@@*@*??????^@?b}`?U -ݵ?C!9:@fOBK@E5)?s=?\]A?B`o?1@kJ@|@!G{@!@!G{@#$@!G{@# -=r@!G{@%o@!G{@!'@!G{@!s@ғtj@ғ@ғtj@ҔzG@ғtj@ґ@ғtj@ҖC@ғtj@ҕ!S@ғtj@ҕᰋ@4_o@4B@2J^5?|@2JS&@1tj~@1@1^6z@1][@1^6z@1]<64@1^6z@1]cA ?| ?Čۨ1A?BI{?l?״@0U`A7L@0U\(@/b~@/1'@/b~@/ݘ@/b~@/1'? ?{j?K]4?j6_?% -?t?| ? g?ٚlq? Y?Hc?sx/T?8*?.x?u@>N ?E 8?ˢL1?j@@@@@(@(??????D?!]S?;57G>J@JRP$@M?[ .G?Y?S ?*u@glR|@@aglC@a{S@aglC@afx@aglC@aix@aglC@aa$0@aglC@ai@aglC@abu%F @?|@I^5@?|@H@?|@q @?|@ȴ9X@?|@1@?|@V@9hYJ@9Fs@4{ I^@4W@3>Vu@3DzG@2&@2 @2&@2^5?|@2&@2vȴ?cxt?4Kl?[_(?1t?pK ?MAG?V?I1@?%8?~m??44]s?r?US9?0b])??uЍ?q?%@@@@@(@(??????_Ly?QR#~?i滸?B5!b@ad @9H%?Wq?Se?K -??3gsw@ph@@ԁ7K.@ԁ7K@ԆIR@ԁ7K@q.@ԁ7K@ԁ7K@ԁ7K@lI^4@ԁ7K@`N@ -=p.@ -=p@PH@ -=p@&I@ -=p@@ -=p@ y@ -=p@쿱[@9DO M.>@4&+ J@461.@3j~@36C@3 [W?@3*0U2b@3 [W?@2iDg8@3 [W?@2͞@8J?'G_I?6\9?Kw?ߩ?kʍL@8J?_lWF_?Kw?GuS?ykz4q>?c:l@8p?qv?. ?ׅN?nD.?hvk@@@@*@,?????@ -=p@%Q@ -=p@#e@ -=p@S@ -=p@'RT@ -=p@@ -=p@ qu@>nP@>tj@>nP@>ߤ@>nP@>|@>nP@>ڹ@>nP@>S&@>nP@>ě@8cg l@8TD@6I^5?@6(Xy=@5j~#@5ȧ@5!.I@5ܥzxl#@5!.I@5׮zH@5!.I@5 [7?%? ,[?e2菾?L?V#m?zk?UbB2?''5?_?j3(??Ǫr?W_l?"55A;?S?8'e?Z|?3Y4@@@@@,@(??????}\@?m~?|V?:m#@3@>A#?r%b?TA,?i?Plu@ca$Ն.@@hr!@E@hr!.@hr!.@hr!.@hr!@u@hr!.@`A@+ @`A.@`A.@`A.@`A@4K@`A.@7|Q@7A [@3G+.Mm@2j~.Qn@2=ce.NC,@2=ce@2C%2@2=ce.NC,?@8#@8:@8 >+?RXFf@8?qv@8@8i@8?@8?Ʌ.@8 *@8p@8?Q?]@8 @@??@91&y@91&z@91&y@9^5?@91&y@9*0U2@91&y@97Kƨ@91&y@9Fu@91&y@9)`@N(@@@@@(@(??????P8'v:n$p?6ϳ2?v4;F@9}J@N@2@5@2v_ح@2@5@2zY?Ol?#T?>\?3' ?vk?,&=?%???T ?"JÁ!?M`%?|HKr^?5q?K?~Y?>ڵ?q ?h@@@@@@*@$??????<.J(%?I.K?>S!@r@HP,?mNw?](vV?K3?Ѯr,@l&@@`B@XbN@`B@M@`B@F -L@`B@bM@`B@:){@`B@+ @!G{@E@!G{@vȴ@!G{@"7@!G{@$/@!G{@X@!G{@G@8]ce@8xl"h -@4c@4` ě@3tj@3{@3+xF^@3)D@3+xF^@3#*0U2@3+xF^@3!n.?hA?b =?lڮ?{@? ?kʍL?Ol?\?YEX?3F0? R?½y?uIE ?&3?nf?k6?DL?*:R}@@@@@@*??????e?MgP@?Y_C?i潊N:@z@e?d3$?4e -?ьD@ Hc@oLj@@9Xb@9Xb@9Xb@*2@9Xb@$@9Xb@G@9Xb@@N@9Xb@@N@g-@h1&y@g-@hp:@g-@gݗ@g-@h1&y@g-@h1&y@g-@hXy=@4YJ@4 ԕ*@.-V@.@,o@,&IR@*-C\@*.Vu@*-C\@*-(@*-C\@*.zG? ?[e?Uyu#?Aᆽ?u?y8$?ʬv?O|q?a+@@@@@&@&??????#t!> >?(P`<>ޣd?@B*@h9f?H~`k? 'a?83?%hwn@gů:y@@dZ@d~Q$@dZ@hGl@dZ@^p@dZ@iV<~@dZ@gMkc@dZ@fU@UQ@UlD@UQ@Ug@UQ@U*Wj{@UQ@U6V@UQ@U'X@UQ@UP@6H@6S@3+S@33iː@3tj~@3V62@2:S@2K^D@2:S@2R)@2:S@2I';?o"?mN?qg8?~j@t?}vk?e}B?{si?xm?XFZ\=?*d7:?qbt?Tŗ?vqG?N#9?f;?_Oa?rW?z5K@@,@(@(@5@0???????C?Zշ?5 -6?HBh@eM@U‹?WW?iU?UiYp?uA6@g_?<"@@.O@/w@.O@"7@.O@'@.O@)@.O@#S@.O@)7Kƨ@^zG@^}p -@^zG@^X@^zG@^Q@^zG@^@^zG@^fB@^zG@^;dZ@5cg l@5bn@3G+@31@2t@2/V@1_o @1b~@1_o @1*0U2b@1_o @14K?Ol?J?-.?ě??j?uk=?|O?`?To?A8 K?dLt?~Y?qn?[ș8?Y͍`?"a??P\?aʕTI@@@@@*@$??????_$zِ?s0?HU5?[EO?3@*"@^1L?i#?|tdA?~Ѱ@,@gKg@@Y+@XQ@Y+@Xc -@Y+@[n*@Y+@YH@Y+@X<+k@Y+@X}@zG@@zG@%'@zG@O@zG@Ԡ5@zG@}Vm@zG@2a|@7YJ@7_ֽ=@3i+ @3j v@2-@2OY@2 [W?@2I]I@2 [W?@2 ܰ`@2 [W?@2E ?wogl? dJgQ?:*Q?|[?8I?Ae ?Hq"1?ݗ?b6??I|q?/?<(_?%>p?j ?&};-?zGhƦq??@?ٟR ?hrJe?>)A-?5+ք@@*@$@$@9@9???????g ^@4?|h@3O @317Kƨ@3($ xG@2[W?@2 -=p@2[W?@2l@2[W?@2|@)@8J?"2?w͜?1t?(gx?u.%J@8J?2(_?(?{k4?WA?o -E\K?U].@8p?anñ?o?u4?pXm>?M[70@@@@0@,?????@s\).@s\)@s7K@s\)@sffff@s\)@s@s\)@s@s\)@s7KƧ@vȴ.@vȴ@ezxl#@vȴ@%ݘ@vȴ@nO@vȴ@@2sS@26@1i"`@1e@0iB@1t@0iB@0h ԕ@0iB@0oiDg@8J?u3?.#Y?\2?4+Rږ?.@8J?X?0eʪv?'bA?.ĵd?Pz @8p?e?Dk?[+{A?d~?bH@@@@(@*?????@_Ƨ@_=p@_Ƨ.@_Ƨ.@_Ƨ.@_Ƨ.@_Ƨ.@]F@]XbM@]F.@]F.@]F.@]F.@]F.@74m8@7)^@55S.Mm@5;Ƨ.Qn@4(.NC,@4(.NC,@4(.NC,?]@8#@8:@8 >+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??@nO.@nO.@nO.@nO.@nO.@nO.@0 ě.@0 ě.@0 ě.@0 ě.@0 ě.@0 ě.@44m8.>@15S.Mm@0V.Qn@/.NC,@/.NC,@/.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @ @ȴ9X@ @ Ƨ@ @ :@ @V@ @ -g@ @ zxl@.w@.@.w@.o@.w@.H@.w@.2X@.w@."h @.w@.[W@87@@83@N@2J^5?|@2JD@1Ctj~@1D`d@0z,<@0{:)z@0z,<@0z0 @0z,<@0zqiC?E?j‚?tcj?#t?E@? $4?E@?> -fu?4M^?siqe?1? R? )蠈?)Zw?m!?GZ?&I?7zE@@@@@*@(??????^WQ^]l?LX"?GB@ ? @.:mY6?bR?_s A?{?ӻE2'@o@@V\(.@V\(.@V\(.@V\(.@V\(.@V\(.@fQ.@fQ.@fQ.@fQ.@fQ.@fQ.@8I_o.>@3|hr.Mm@2j~.Qn@28D*.NC,@28D*.NC,@28D*.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @n@n@n@翉@@n@@n@L@n@럺O@n@(<>"@vDT@vE@vDT@vA@vDT@vBtU@vDT@vC}@vDT@v?t͘@vDT@v=Sn@4uS&@4u@ -@2pěT@2n'@1j~#@1 `G@1O M@1БHt@1O M@1a#@1O M@1q?|h2:?1J*@?)zІ???_1@3+@2q @2 -V@2E@1L[W?@1NѷY@1L[W?@1:Q`@1L[W?@12s@8J?q+qW?c0?7ly\?p3/ ?:AJ+@8J?k$?Vn?vEB?du5?<"(o@8p?G?+X8 ?+(?]`??㖆?W$B?>ÔR?{W?P?nW*؄?i 0/?•;(?ڢ?hb?L??,yfY?P|@@@@@*@,??????ne7?~l?RsS?l^y@Kz0@9H8?c*J?B [?FMAr?r`i@q5X@@^y"@^k I@^y"@^Xtj@^y"@^H1&y@^y"@^M&@^y"@^Q2W@^y"@^Ox@\(@V@\(@`A@\(@u@\(@@\(@!R@\(@'/@6 xF@6|Q@1)+ @1Dg8~@0j~#@07KƧ@/Xy=@/Ov_@/Xy=@/ҽ<63@/Xy=@/-?UbB2?L?4F&x?? 2 ?|S6Y?sD?7fps?˗ -"3?.?T?+l?i?*J?a -?ނ F?^^ω?x@@@@@,@(??????|U?1M ?]Z?Gwh7@^[>W@ϵ{Ʉ?}({iR?f[dm@'?&v/??:Q $@fe`@@oc -=q.@oc -=q@ltS@oc -=q@l&@oc -=q@l1'@oc -=q@lp:@oc -=q@lg @\(.@\(@$/@\(@qj@\(@@\(@ @\(@w1@9䎊.>@3^5?|@-䎊@2Ƨ@,#w@1[W?@+rH@1[W?@+w1@1[W?@+ᰉ(@8J?2Q=t?UD?Ԧ?n?)^y?[5@8J?^1??J?$?p G)L?i 0/@8p?a,F??hc?K&?T@@@@(@&?????@d/.@d/@ۉx@d/@kP@d/@Y@d/@($ x@d/@TɆ@]/.@]/@M@]/@glC@]/@o@]/@@@]/@~@8e!..>@4}hr @3k~(@3"`B@3<_@3 k@2l@3 k@2:)y@3 k@2~@8J?Wq?Ȯ|1?G#}?lB_l@O0?V7S ]?R,Xmt?tN?@@gˌ^@@g1@gG@g1@g)y@g1@gp[? @g1@gڟv@g1@g؁N@g1@g׻Ȱk@e1&@eS@e1&@ek@e1&@e$@e1&@e<%J<@e1&@e~@e1&@ey@3쿱[X@3fJ*@0; I^@07@/x@/!v:@.PH@.C]@.PH@.'S1@.PH@.s?Qp?u:I1?%ja a?!.H.?(l?ưz_3?|b@?!!{?-@y?9~F?U1 -?kN? v?r?K ?%?S0iBZd?| ?J`Y?D&?lDžN9?2A?7F?| ?&uE@?^ o?Kd]? A?+d?8*?l?? ??j?f_Ԋ@@@@@,@,??????V@%W?c6,9>ŤN(\@Rq@ϋi\?':{u^>5n/?]^2>`@f}@@4j~.@4j~.@4j~.@4j~.@4j~.@4j~.@V.@V.@V.@V.@V.@V.@9 ]ce.>@5 I^.Mm@5tj.Qn@4̿[W?.NC,@4̿[W?.NC,@4̿[W?.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @Y+@Y+@Y+@Xy=@Y+@YY@Y+@XYJ@Y+@XD@Y+@Y@'-@'-@'-@)y@'-@*W@'-@-@'-@,q @'-@-@32@32䎊q@0)+ @0(F]d@.dZ@.@/#Z@/iB@/#Z@/ @/#Z@/ A7K?Ol?*|3N?7[䭝?A%? -`?#{׈?}ѿ,?Q_ڸFN?tw?owlP?UBi?P=? SF?lo>?W ?v_.^?*Z}?<71@@@@@*@&??????x?T_?#uY7?2;->@X6}r@*?CYZ3JM?STUeG 7?'*?nb;@ga@@ ]-V.@ ]-V.@ ]-V.@ ]-V.@ ]-V@ x7@ ]-V@ ӎMj@lKC.@lKC.@lKC.@lKC.@lKC@lgY|@lKC@l*JL@>2.>@7hr.Mm@6Ͳ-V.Qn@5xF^.NC,@5xF^@5(@5xF^@5@8@8#@8:@8 >+?IT?ֈp&`F@8@8@8i@8??cH?B>@8@8 *@8p@8?Ι?Ċ^@.@??@~#@ -\&@~#.@~#.@~#.@~#@!@~#.@}p -@a#@}p -.@}p -.@}p -.@}p -@˝Vl@}p -.@7v@7@3?|h.Mm@2-V.Qn@2.NC,@2@1ce@2.NC,?E[i)@8#@8:@8 >+?`i%|@8?~Ov_ح@8@8i@8?@8?k%,@8 *@8p@8?E(ɡ@8 @@(??@@&x@@(@@(@@nP@@E@@?@$/@\(@$/@ç_o @$/@Ü1&@$/@ô9Xb@$/@øYJ@$/@ê=p@9䎊@8@5 ě@4N;@497KƧ@4+lC@2,<@2=b@2,<@2,<@2,<@2*0V?hC%?|?(`ƴ? { x?W?{7]['?8ȺJ?}?b?MN?? " z?y?E!'?Ny?1Z?7Q?VM@@@@@,@*???????vn5vDM:?gn[cN`?h?DM@D@öo"?{  ?V?߿|? @ox|@@>vȴ9.@>vȴ9.@>vȴ9.@>vȴ9.@>vȴ9.@>vȴ9.@x.@x.@x.@x.@x.@x.@7֚,<.>@5 I^5.Mm@4A7K.Qn@4!:S.NC,@4!:S.NC,@4!:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @N+@N+@N+@N*@N+@Ohی@N+@L!-@N+@LI^5@N+@L@ ě@ ě@ ě@ M@ ě@ D@ ě@ O M@ ě@ 1@ ě@ 4֡b@1>6z@1RT`e@.Vt@.-W@.1&y@.5Xy>@-uXy=@-u%F -N@-uXy=@-vȴ9X@-uXy=@-w1?^Q5P?J`Y?@?lDžN9?G?-tT?bM_x?4 "?2'?N?qN?90?g)?6?Me_?Q(?<71?ܑ @@@@@,@(?????? #xh?)%)S?0K@L5g@ & ?85 -Tؿ?.!76^?lR ?SlU X@s[@@ -=q@A7L@ -=q@V@ -=q@@ -=q@C,@ -=q@ʙ0@ -=q@.H@(@XbN@(@ ě@(@/@(@E@(@cA@(@dZ@7@@7qj@3xr Ĝ@3o'/W@3Ctj~@3*W&@2u@2@2u@2~ѷY@2u@2}(? ??I!S?㬱_?)^y?I$4}?F^S?~??\PK?>#G?'Ln?׍xG?$G?~gN?J{?Fb2x?q@@@@@&@&??????zz?D~?L?ExVLS@4}a@ @O;dZ@Y.@O;dZ@Yu@O;dZ@[c/@0įO M@0Ʌoi@/A7K@/d?@/&x@/ ZP7@-L/{K@-q@-L/{K@-U6@-L/{K@-ڍD!?^-?#??]Ľ? ?"ٷ?bM;?YFѣ?:q?9GE?i?K?bV?aݍ?i2?/[?!ccC?KVPn@@(@*@,@@@8???????OƲא?@Y?.+s3^?C@E@Zm?=ak -?-:)?t90ɷ?RBZ@sϓw@@ I^@oj@ I^@5C:/@ I^@g@ I^@H>@ I^@@ I^@!@kbM@j\@kbM@k]@kbM@k {@kbM@kwv@kbM@k*蠢@kbM@k9@9(YJ@9);=e^@4!hr @4 u\p@3."@3/8[_@2𖻘@2m!@2𖻘@2W6@2𖻘@2ywW?hȶ?t2x8?@m|x?/?U?1(?x9?A S?0}h-?n,?ej?2 2?t?#L? `?/z?Lď?$X@@(@&@"@;@6???????>@L?{ڢ$U@?kLZ?A[ٸ@ zT@k 8T?|$i?ZrJ?(af?pC:@oXԻ@@=p@=p@=p@JN@=p@0 @=p@g@=p@B@=p@ @@@@˒:+@@?@@@N@@䎊@@҈@2*0U2b@27KƧ@.`A@.¶}Vm@-;dZ@--V@-Vl"@-u!@-Vl"@-IQ@-Vl"@-!.H?^Q5P?$?U#?ƠJ-M?u?-tT?bM_x?#maЀ?rJs?Y??6#ZQ@s@/?1G?Eyx"hM?\Ў?r{@sVB@@u@u@u@1@u@Xe@u@$tS@u@֡a@u@Ʌo@lC@l@lC@l@lC@mV@lC@l!-@lC@l[W@lC@mqu@/!-w1@/!-w1@){"`A@){"`A@(SE@(Sa@O@'73@'73@'73@'73@'73@'D+?^Q5P?GA?$C@?MA8?/`?tJ?bV,? -?j?3.Yl?%y*=?J&d?k?b@? ?oܧ?avh?h?#.@@@@@,@*??????Q"? 9@?5=޶?{w@@l**?D:H?(*j?_?J@s (@@&=p@&d/@&=p.@&=p.@&=p.@&=p@&o@&=p@&nP@us3333@t9Xc@us3333.@us3333.@us3333.@us3333@ut9Xb@us3333@uu\)@8䎊@8($ xG@3S.Mm@3_-V.Qn@2xF^.NC,@2xF^@2Vu@2xF^@2{J#9?ӖlP@8#@8:@8 >+?J+?I ?ߞ.ӭ@8@8i@8?q?p?4hN@8 *@8p@8??oڕ??oڕ@?????@O;@O;@O;@_@O;@4m@O;@}H@O;@fA@O;@\)@ԭV@ԭO;d@ԭV@ԯ@ԭV@ԯA@ԭV@ԭ(@ԭV@ԭM;@ԭV@Ԯ!R@5I_o@5I"`@08r Ĝ@07K]d@.x@.*0U2b@,ߤ@@,ۥS@,ߤ@@,,<@,ߤ@@,G{?| ?{j?Gy??lDžN9? 9?CXs?1j?CO?kE<%?]bn~?@?h,à?^&?§d߱?Z?XLL?SP?Rv@@@@@&@,??????5P?!\?//5T? 19@v@ԭA?O)?.h[?AG?g0Vm@g;F@@5?|@9X@5?|@!-@5?|@䎊@5?|@tj@5?|@U@5?|@C,z@ C@ R@ C@m9@ C@!R@ C@T`e@ C@ ^ @ C@@8s@8҈p@5#@5$!-w1@4j~@4- @30U2a|@3Y}@30U2a|@3֚,<@30U2a|@3҂@5?}? ?r?V0O?&x?LTk?NIɮ?OW?l%FZ?/:?' ?EŐse?x?$n?o\Z|?9 ? 4e -?M\{W@@@@@$@&??????t)?b@?Z L?bLB@;i@<&?z~8u?w,F>? Z &2?uHl}@lLЩ@@"(\@")x@"(\@"&ffff@"(\@"%Q@"(\@"&@"(\@"%o@"(\@"$T@E@EQ@E@=E@E@?˒:)@E@84֡@E@;@E@<n/@34m8@3gCb@0@ ě@0@|@/F@/C\@/ -#9@/ oiE@/ -#9@/˒:*@/ -#9@/ rGF?|h2:?m?ě?@R?R%(0?װ*w?|b@?7fps??aYZq?=.e1?tK?Q(U?sq#?I/?cӗ1?v> ?2[s@@@@@,@&??????PqR$?E.?9L@@"'8:O@?s?0C`h?Zm2I?lMF?h;I@f'@@#;dZ@#+@#;dZ@#ؠ-@#;dZ@#Լj~@#;dZ@#`d@#;dZ@#т @#;dZ@#m]@;dZ@ -=@;dZ@@;dZ@~@;dZ@s@;dZ@[7@;dZ@%@8,<@8o@1kS@1a@0A7K@0 y @.Z@.+jg@.Z@.?@.Z@.sPI?{QB?_X -?c«?2UT?(+Zk?P?_$? KBI?+l??rrl?W'??i--?m!?__C?7zE?q@@@@@*@*??????P;콶?nк?D2Ne?U y@#Әl@|U6?V!?jJ*?3*?Q@ozY@@x@\@x@ I@x@ @x@q @x@˒;@x@@Tm@T@Tm@T@Tm@T[W>@Tm@T-V@Tm@T@Tm@TGE8@2 xF@2@0kS@0ka@@0M-V@0McA @.L/{K@.思IQ@.L/{K@. -L/@.L/{K@.-?^XN?h?WD@?̒? 9? ]V?bV,?5CQ?tw?-I`K?Hc?{L բD?e@'?/?m+&?ʬv?B ?L@@@@@*@*??????W[sD?"?@#~?/@{o@Tr?NB?=#e?AqW?s+@ro@@8M.@8M@8X7@8M@8@8M@8}@8M@8gqU@8M@8~@#P`A.@#P`A@#Jx@#P`A@#Fn@#P`A@#6 -&9@#P`A@#4f~+@#P`A@#/aO @9#g l.>@4.5?|@41p@37KƧ@3)k@3@5@3bSC@3@5@3N0@3@5@30ͩ@8J?CD&?ĚF ?7@?ИZN?*qh!@8J?3jR6?b8[.?vb'?S)z?@8p?;>p?mݹ?/6 4? G+?nĸ@$@*@,@;@9?????@C@C1&@C@C}Vl@C@CA@C@Cqj@C@C @C@CC,@SR@SC@SR@SMj@SR@SMj@SR@SiC@SR@S&@SR@Su!@7^H@7`bM@2ěT@2hr @1-@1t@1?䎊r@1=@1?䎊r@1=H˓@1?䎊r@1=(?^*?d̺?&t?V0O?di?1a??UbB3?$Jw"?#q\-v?A??;?Ƌ?iTC~t?~$?2 ?7?{2@@@@@,@,??????Bd(?U?JH]D?Dp@C,| -@S!Z?dNKL?aS*%?úJȄ?B @m4V@@u?|@xO@u?|@hQ]@u?|@_ +@u?|@tV@u?|@rl@u?|@xXɩ@@z@@j@@h@@گ@@W@@D@9(YJ@9 >0!X@4^5?|@4|N@3v-@3nŦ@33&@3*) @33&@3%K@33&@3#~*G?>,@?R{?L?`m? i?r7?W?!m~?0"?RGl?JGY$l?,s?P5s?(?tqN;?:k?[%?֢.@@$@&@&@4@5??????6`%?`J?P`?`I] @uڥ=@o?l^@?˟9?-~:T@lp ;@k@@TzG@S@TzG@V4@TzG@V@TzG@[S@TzG@Y~($@TzG@;=K@`ě@`A7M@`ě@VC@`ě@[v@`ě@SMj@`ě@]Vl@`ě@6}Vm@5w@@5v '@2TS@2PD@26-@21iB@1z,<@1v@1z,<@1w4m@1z,<@1_$tS?}ѿ,?Fp3?_*k??BPbC?>>? ?I}?ud?{7?J>?@ ~?=Ca? h? - l]?x2?ٔ!x?mCc4@@@@@ @??????:ZXl?e1A?e(]P@T-s@YJ't?ؠ4ۍ?7.@ EI@ -!3 kF@d̯@@v@R5~{@v.@v.@v.@v.@v.@?ڟv@? ,@?ڟv.@?ڟv.@?ڟv.@?ڟv.@?ڟv.@9^H@9`^cc@4n5?|.Mm@3-.Qn@2䎊r.NC,@2䎊r.NC,@2䎊r.NC,?)||n@8#@8:@8 >+@8I@8?i.&@8@8i@8@8S@8?mEKT@8 *@8p@8@8 @8 @?@Ghr!@G+@Ghr!@GKc@Ghr!@G\_y8@Ghr!@GN'@Ghr!@GF@Ghr!@GE@4mhr@4n}@4mhr@4n@4mhr@4p k@4mhr@4met@4mhr@4n\N@4mhr@4nC6)@5S&@5z@1^+@1^0#b@0ȓtj@0Ǻ<@08D*@07$A@08D*@06-Eg@08D*@07 - x?|b@?ݢt'?[4? ?00?sC?eXW? ]?5u?U&>/?Kf@?K t ?]nx@4{ I^.Mm@3y7KƧ.Qn@2.NC,@2.NC,@2.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @@ @@PS @@!U@@@@ e"@@xs @O@Cy@O@( @O@O@O@#@O@.@O@p@7,<@7* @3?|h@3J@2b-V@2Z/>@1_o @1騥@1_o @1(pL@1_o @1LR>?Äp? -"?@>??ڠ؞?g=a?~Ov_ح?$a?<1I?1Ge|?[Ď?B51r?dGE?&>G?!+?:?Jr 7?y@@@ @@5@5???????P:("?K]>V?XQ??J}wr@ u=@M?u[By1?m1-M?UbS?yB@i~6@@L/-@L-@L/-@L1u@L/-@L0U2a|@L/-@L3E@L/-@L/@L/-@L/rGE@Q@O@Q@RT`@Q@/W@Q@^ @Q@`A7@Q@K]@7 xF@7g l@3+ I@3@2tj@2 ѷ@1a:S@1`- r@1a:S@1_vȴ9@1a:S@1_Vϫ?q!U? #?Gk;m?a_b?yq?7F?Y͍_?tMP?ɇ}~?_3\?$) ?IH!w??4?Rw#{?l?gϵ? 1 D@@@@@@,@(??????ku\j?Pi?<{"&@L1ps4@+[?h $?_2[?6*?=[Ex@m7@@tj@3333@tj@ n@tj@(@tj@%@tj@&$/@tj@+t@ǯ-@ǽE@ǯ-@ǫq @ǯ-@Ǭ"h @ǯ-@ǥm\@ǯ-@ǚY@ǯ-@ǟH˒@8|Q@8ȭU@4Lhr@4Jݘ@3`A7@3حV@3B@5@36 -L/@3B@5@3EoiDh@3B@5@3Esg?|O?_X -?}_ܻ?"J]u?a0?s[?+-/?CO?OՃ?"|OV?a5?`u3? ?ae?!?=? # ?hvk@@@@@&@,???????s׏p+"?(s?ZYmMg@l]^@Ǩfc??MJjMP|?w|a}d??@/@j 1[@@@@@ ҈@@bM@@e+@@@@"e+@7Kƨ@V@7Kƨ@C,@7Kƨ@\)@7Kƨ@wKƧ@7Kƨ@vR<7@7Kƨ@l@8w@@8l1&y@4 hr@3o@3_-V@35Q@3 [W?@2-w1@3 [W?@2Љ'RT@3 [W?@2т ?cxt?eąւ?7'v?__z8`?eTm5[]?J"Fr?|?+M??.Oc?|g?T+)? uf?Xy1@>F=E@@>1@>@=@>1@>Ի@>1@>9@>1@>_@>1@>N|@&dZ@&BѮK%@&dZ@&P@&dZ@&U@&dZ@&H@&dZ@&;@&dZ@&-@8@9orX@35?|@3Zc@2"`@2D@2@2SsF -@2@2X r @2@2N?cD?$nba?mB?$~q?Qe,?uhҨ?pEkI?{9JgD?W)Be? c? ?4F:? |ȶ?: ?[?Z%?ەݓ?b$QߤA@@*@&@*@;@8???????nh -2?ehW ?R~| -h?pA:O@>r@&??w;-?gׁn?L?W'@kc@@y"@/@y"@xF]@y"@yb@y"@|N<@y"@z@y"@vR<5@A7L@^5?~@A7L@A \@A7L@C,@A7L@7@A7L@v@A7L@'RTa@9?@8@3S@3!.H@2`A7L@2c @2B@5@2E%F -L@2B@5@2Geں@2B@5@2F?ԭFLg4?Kb?פ?~rV?Q^F?jכb?G *ǂ?0? }>_?&v'?%3?lӪ<?LƴG?/#?6ז?a?k!l?b@@@@@*@&??????h ?Vn(I?s@y2@?f2/? ]3?O@ti;@sN%`EE@@r@rz@r@r7Kƨ@r@r%F -@r@r *@r@rۋp@r@r0@Eě@EG{@Eě@E#@Eě@E2W@Eě@E^5?}@Eě@E%@Eě@E=c@8+s@81hr @3@3b}V@3lj~#@3f@2kxF^@2ffffff@2kxF^@2heO@2kxF^@2hy=c?]?" ? -> ?QR@>\)@>R.@>R.@>R.@>R.@>R.@6g l@6Q@3|hr.Mm@2j~#.Qn@1D*.NC,@1D*.NC,@1D*.NC,?Z@8#@8:@8 >+@8I@8?Z@8@8i@8@8S@8?A@8 *@8p@8@8 @8 @?@+ܬ1'@+ba@+ܬ1'@+tH@+ܬ1'@+-@+ܬ1'@+!u/@+ܬ1'@+xE@+ܬ1'@+]!@#Q@#%e@#Q@#Tg@#Q@#ᒖË@#Q@$ط@#Q@#c@#Q@# @8*0U2b@83@4)+ @3U靪@3-V@3"s@2sh@2f+e@2sh@2y{2@2sh@2z)$?+?Xf[?}q㉽a?-v<?'ݘ? -U[?ɏ?#P5a?J? p@fQ@f-@fQ@f1@fQ@f7@fQ@fěT@fQ@f?@fQ@fe@5uS&@5vR<6@1O|hr@1N"@0`A7L@0Q@/N;6@/4J@/N;6@/u!S@/N;6@/iB?|O?Qd?K]4?'$5? f?װ*w?1j?HG^?qN?ihA?ߒh!?ȏ'T??2]7?W ?E 8?j?ܑ @@@@@$@(??????1"II?LCg?+C8@@{Б@f?4T?L{:*?v>8? @g@)!T@@`A7L@`n@`A7L@a@`A7L@an.@`A7L@a|Q@`A7L@` qv@`A7L@`҈@1-V@13333@1-V@1䎊r@1-V@1 @1-V@1ݗ*@1-V@1W@1-V@1T`e@6H@6M:@1 I^5@1ae@0y7KƧ@0xp:~@.p'RU@.oo@.p'RU@.ov_ح@.p'RU@.oo?|O?h?"?XQ>?u?}?Br?HG^?ܿ?Uh;?<U?eDQQ?zny-g?򯞼?]? ??b/bJ?M684@@@@@,@$???????N ?P?#(?#P9@`@1ԣ?DKE-?CRqE} !?l-L?Lo@h-9@@@C)@@q@@q@@EHu@@,1@@ᆸ>@p -@BZd@p -@Ƭ@p -@kc@p -@M%@p -@d'k0@p -@gPw@5mv@5m, -@1hr @1l@0Ƨ@0i0X'@0sh@0rJ@0sh@0fyT@0sh@01#%H?}x:@-@(@-@_@-@@-@>뽕@\)@\)@\)@4"_@\)@C@\)@Y@\)@_@\)@/q@0|Q@0|Q@)=-V@)>J@) 1&y@) B@'Ǔݗ,@'ʤR@'Ǔݗ,@'0>@'Ǔݗ,@'?N?^6P?6? Y`? :?/?x?bMn?x?t0^[?-(?_$^?N@?bw' g?ʙ ?zb?V?󰉋?y Y@@(@,@$@;@:??????(ϊ(?1:?V|?)r{A@YM@f?+zÁZQ'?8?Wx$?H쮽?B~)ߛ@"@VH?b؄f)?gm="[?Zl?rdJ@m9X@@߾vȴ@vȴ9@߾vȴ@- @߾vȴ@$/@߾vȴ@- @߾vȴ@ސ$@߾vȴ@vȴ9@9"@9"@9"@:G@9"@:^5?|@9"@:)y@9"@:xl"h@9"@:6@4 xF@4e@/j~"@/~$@.NO;@.NVv@-QN;6@-Q-@-QN;6@-QN;5@-QN;6@-Q ?2}?Z.?4!p?8v?g?i{? ?4 "?['?/Z?2&h?sx/T?nwf?.x?q6tN7?XLL?pk Y?pk Y@@@@@(@*???????_Gz?+?3_['?ъ:H@@:G?S>> u?"b?P!>݋I?OY -@h,l,@@Dt@DZ@Dt@D7@Dt@D/@Dt@Eݘ@Dt@C9@Dt@C@pj~@pj~@pj~@p2a|@pj~@p3@pj~@p3@pj~@pg @pj~@pݗ,@204m8@20A7K@/"@/Fs@.;dZ@.+@.3PH@.1hr @.3PH@.-C\@.3PH@.-%?^Dw'?m0?.Ү_ ?q@v? -?ʟ?bM_x?)[+@8I@8?i$@8@8i@8@8S@8? J@8 *@8p@8@8 @8 @?@+R@33333@+R@4@+R@9XbN@+R@`hۋ@+R@l"@+R@vR<6@Xtj@V+ @Xtj@i'RT@Xtj@P`A@Xtj@g&@Xtj@L>C@Xtj@C @7s@7^@5sS@5sn.2@47KƧ@4@4D*@4g -@4D*@4l!.@4D*@45Xy>?}ѿ,?d_s?^RpX?ׇlg?I]mB?:7{*J?oC?{c?低NU?]~ɺ@?>5?{$@?WA?Us?wX?'D[?R͐?8$ -"@@@@@*@*???????Hc@XJL?b?jdx@H@U?xNX(&?3H?Ņp?4K?@`Ql;@@]3E.@]3E.@]3E.@]3E.@]3E.@]3E.@>0 -=.@>0 -=.@>0 -=.@>0 -=.@>0 -=.@>0 -=.@9=:.>@4I^5?.Mm@3~Vu.Qn@3._o .NC,@3._o .NC,@3._o .NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @bM@Q @bM@@bM@=@bM@~@bM@u@bM@@+ J@,NE%@+ J@iG@+ J@2ي@+ J@Fs@+ J@4R!@+ J@d. @204m8@20Fd@.-@.>BZc@-dZ@-Ve\@.C\@.Xs@.C\@.*@.C\@.,٢?^j?]9?"QJ?B*?YY%?/z?bM7?9n?=,D?4i?v -?\ :?bQ?7c?~@\? ?"F?L@@"@"@&@6@5??????'5s]?6?|\t@<@`R?'HJ+b?%Hn?JnG ?CYt@s&)?@@ow@nV@ow@lC@ow@hr @ow@tD@ow@nU@ow@m(@bM@# -=q@bM@r@bM@r@bM@a@@bM@e@bM@4֡@8@8© @3^+@3_ @2~"@2/{J#@2&YJ@2&Fs@2&YJ@2&@2&YJ@2%m\?2}?R?y]?Z.?Xe?sU Z?+-/?yom?FH>d#?fAzQa?Vu@2Bp:@1YJ@14֡b@1YJ@1F]c@1YJ@12W?}?PƧ$?@^ڢ?Rw#z?K/?۝.Yr?% ?Hz?J?@[*^?we ?fAzQa?Nϸ? h?ZaQ?1R?q?;kr>@@@@@&@(??????K8I?9?Ic?B  e݊@J-a@gIrR?h4nR?_l?Ґ5.ؐD?Ct@kzNC@@`A@zG@`A.@`A.@`A.@`A.@`A.@$/@/@$/.@$/.@$/.@$/.@$/.@8G>6z@5T`d@4Y^5?}.Mm@3-V.Qn@3O M.NC,@3O M.NC,@3O M.NC,?Z@8#@8:@8 >+@8I@8?Z@8@8i@8@8S@8?A@8 *@8p@8@8 @8 @?@Z@Z@Z@ -L/@Z@7@Z@@Z@@Z@7K@lC@lI^5@lC@o@lC@m\@lC@lzxl@lC@n.3@lC@m\@4>6z@4&@25S@25?@1A7K@1 qu@1._o @1-ڹZ@1._o @1+A@1._o @1+lC?| ?jD?=d?],V??0&YEd?|)-}(@@@@@,@,??????:\F`?2Ӑ?:ij-?J!@@luP?Z NV=S?= >Rh?f_H?zRW@fi@@Qhr!@^vȴ9@Qhr!@;5X@Qhr!@껲m@Qhr!@ꏷ@Qhr!@ꥮ1@Qhr!@꼄@ڻdZ@$/@ڻdZ@ٙ+@ڻdZ@ l@ڻdZ@=J@ڻdZ@}H@ڻdZ@@7:@7{n@5^5?}@4{J#9@5`A7L@4+6@4O M@3+a@4O M@3\(@4O M@3?F/P5? &/d%?jl|?G> -?ˠ^㪶?B[!?ꯨT?ɖ?3AO?} ?f?Ԃ?@K/{?87?@@ ?:>-?3B?Iv:@@@@@,@*??????=@@3s@3Pab@1 ě@0e1@0Z~"@0Y~N0@0@4@0^{@0@4@0W1@0@4@0O4?|b@?H]9?)?;?ױT?(H?| V?E~*? -?0Ծ1R -?6X?x++?z*?XI?Ho??o?b/bJ@@,@&@$@7@8???????A?;q?8\[?$G72@3rv@?o?X%v1E?E}g?%}Z?" @f]d@@ -_vȴ@ -T9Xb@ -_vȴ@ -~m\@ -_vȴ@ -<@ -_vȴ@ -_p@ -_vȴ@ -wXd@ -_vȴ@ -}+l@@zI@@6Ϫ@@0D@@'@@-@@!@8%!.@8)XbM@3i+ @3P@2Vu@2_p@26z@2䎊r@26z@2Ϫ͞@26z@2cA ?E?kf?s |?U6֧??d4?=fA:?0o>?7ȑC@ěT@hr!@ěT@`[7@ěT@M:@ěT@{J#:@ěT@_@ěT@*0U@8S&@8ݗ,@5r Ĝ@6Vȴ9X@5`A7L@6tm8@4iB@6wkQ@4iB@5ݘ@4iB@5-K]?}?Z:1?jk?,J 3?Lj!_?{='"?1+@8I@8?qn@8@8i@8@8S@8?+:@8 *@8p@8@8 @8 @?@["`@[S@["`@X4֡@["`@ZkP@["`@Y_p@["`@YJ@["`@V}Vm@׊o@׊~#@׊o@׉Dg8@׊o@׊#9@׊o@׋҉@׊o@׎H@׊o@׏hی@4 ]ce@4 VϪ@0 ě@0u!R@0Z~"@0T7@/Ǔݗ,@/"`A@/Ǔݗ,@/쿱[X@/Ǔݗ,@/쿱[X?Ol?: ?\H{gX?U*?>C,4?[2?|O?uie?{d??8?kj?|׿pY?2]7?v'X?WhQ?OO ?0&YEd@@@@@,@,??????Kj?LR?&hy?!(|@Y#@׌TC?F,Fi?B S ?zrt?-@gZ@@Z1@qm@Z1@YA={@Z1@]/}:l@Z1@_i@Z1@Z(@Z1@Y%@ۓ@ۛe@ۓ@۔͒@ۓ@۔V:[@ۓ@ەPs@ۓ@ۖ2H@ۓ@ە@7]ce@7ưj~@1+@1$0@0Z~"@0YpC a@0kxF^@0iyV )x@0kxF^@0h*}@0kxF^@0h(u??'P?aas?{?} -?h?sky?\l6? 71R -?Z5k?p[!B?I}/@?V?Lu۳?ɯnR\?{z&U?!!?5 Y?@@"@ @$@2@2??????b$>.Td?AAJ?>,Za@_Umy@ۖ?Xq9?\ԭ?7!D?@n+M@@U7@U8bM@U7@U8V@U7@U8;@U7@U8@U7@U7Xf@U7@U7*o@1@^5?}@1@;X,@1@*@1@fp@1@FSs@1@vJ@1}:@1}:@."`@.Uzz@.]E@.]+@-uXy=@-uA@-uXy=@-u'@-uXy=@-u?`BcM?}p[?-5AԘ??מ?1Y?bQ넛?,2?k?3]Z@?Mm/?Sܻ_j?bM]f?v??:k?7b ?1C@@*@(@$@5@9??????9|>o?,_\ ? f@U700@a$]?"^2űe?6?@`c,?0!kNQK@sK @@D.O@D'sy@D.O@D#n.@D.O@CbM@D.O@CdZ@D.O@DR<@D.O@C;dZ@r=p@r}: -@r=p@r@r=p@rz)y@r=p@riB@r=p@r`A7@r=p@s+6z@7w@@7nTb@5+S@5" ě@4-V@4u!@48D*@4t@48D*@4*u%F @48D*@4Q?}x@-tj@-{ӷ1#@- 1&y@-ɮ @,#Z@,/3v@,#Z@+)ވx@,#Z@,1S߬@8 -Ny?*)H?9?? -0B?ͭ?Ugsj@82r?pU_?gb?>!u?ǖ&?Qc@8L?%?1QcFe?P0?]^? Gg@$@$@$@9@3?????@eS@mhL@eS@ʚ[07@eS@c2P@eS@[k:@eS@[@eS@[8 @*$@*M[@*$@*@*$@*_@*$@*G={@*$@*Ɋn@*$@*J@9|Q@9_.@3|hr@3H+tw@3Z~"@3,aQ@2Tm8@2FAa@2Tm8@2C]p@2Tm8@2C9rJֳ?]?vK?>?]:VE?}?T?t D5?q A'?lH?Q)\?r|2?<`?6;:?^5? -V??с:?<@@"@(@$@:@9??????lP^?[ ?Ih#L@^_@*n?u(h?fJ0β?ho??íak@l=6@@bM@O@bM@ @bM@̠qo@bM@"c@bM@@Gt@bM@ƈz@@n@?EjGw@@n@@'@@n@??B6?u=?B&Y?¨Sp*?h +?vnA? tEz?N s?Z!}?Tʼ=?޵?o0_+*?Q?*?zw@@*@"@(@4@8??????R(4N[T?8B ?@;@C(@:LW?Wcmn?ahM?T=yr?p؏3|@hX(<@@z}E.@z}E@zce@z}E@z@z}E@z&@z}E@zd9K@z}E@z~bb@#S.@#S@kP@#S@(@#S@ح@#S@ĭ7c3@#S@VBD:@9e!..>@4=hr @46@3U`A7L@3LC@2̿[W?@2 '0@2̿[W?@36L@2̿[W?@2ǒ0d@8J?W@!?RsW?rՉ?P?t -@8J?@׮?HD?} ?NJ@?,3vF@8p? AI??Cx%?u ?$rMy@@@@.@,?????@el1&@e|(@el1&@eP'R@el1&@eN;@el1&@eS|@el1&@e*@el1&@evz@MO;d@49Xb@MO;d@!-w@MO;d@YY@MO;d@:v@MO;d@*0U@MO;d@_o @9DO M@9XU@5Y^5?}@51&x@4dj~@4"@4n@3䎊r@3:S@3䎊r@3u@3䎊r@3?xDž??"6$?ޝ)?aMz?$@?? Z ?*J?c??1Tn]?s_Nr?X?Cy^?tu?F?0?a#@@@@@,@&???????<?|/}?}7"?N"911@erv @Xe?b/G?qwH ?xe@0CX='@lz@@q I^@q~#@q I^.@q I^.@q I^.@q I^.@q I^.@P=E@P1hr @P=E.@P=E.@P=E.@P=E.@P=E.@8įO M@8ڙ0 @4sS.Mm@3t.Qn@3O M.NC,@3O M.NC,@3O M.NC,?ڷ@8#@8:@8 >+@8I@8?W$B@8@8i@8@8S@8?S~6d)@8 *@8p@8@8 @8 @?@g\)@g"`@g\)@gv_خ@g\)@g3@g\)@g@@g\)@gDg8@g\)@grG@mhr@s3333@mhr@.@mhr@Jn@mhr@cw@mhr@oiE@mhr@N;@4۹~($@4xl"h -@1ٺ^5?}@1@1`A7L@0v@0G k@03&@0G k@00bM@0G k@02&IR?)T?ly?9t3C?+?>C,4?y+PYu?q!U?Ғ](+??jSV?hY?u*,?hU?~d?l~J?XW~?՘]G?j]@@@@@*@,???????jМ$?fpۂX?FiSs>?bgnW@g@{mt?g^?6rl? ?_ c@jq@@Vp ě@Vs@Vp ě@Vuᰊ@Vp ě@Vu\*@Vp ě@Vrs@Vp ě@Vr@Vp ě@Vq2W@P I@P~#@P I@Pu%@P I@P0U2a@P I@P=p@P I@Pqi@P I@Pq @6䎊@6D@2|hr@2̑N;@2."@2+C%@1!.I@1oi@1!.I@1C-@1!.I@18}H?2}?? -NA3?{y6?_?4?| ?&uE@?J?.}$??EBl?:t?f)"?z"2)?Yʒ?t? ;8@@@@@,@*??????=oe?Y>산M?/ ع@Vr4@P? -G?@wl -?!,Y=M[?ť@g7H~@@(@x@(@@(@H@(@\M@(@m@(@1@Q@n@Q@wk@Q@$/@Q@n.@Q@@Q@nO@8%!.@8$oh@3+ @3G{@2Ƨ@2]ce@2@5@2@4@2@5@2yb~@2@5@2C\?X?P1"? \?(tUo?zcR?tٵ?}ѿ,?I1@?ؼZ?'G_J?U?/Ւ?Rw#z?2}?[?1(w?p& ?F-@@@@@,@*??????t?BX?T7a?asaYE@CP(@iL~?l6Sl?ew!?;gN?`NZ+@i㹎\@@`A.@`A@ (@`A@;lD@`A@@`A@\@`A@s@#S.@#S@b}V@#S@ae@#S@sP@#S@Np:@#S@c@8~($.>@3ԛS@3kS@2V@2W+@2=ce@1O;dZ@2=ce@11&y@2=ce@2҈q@8J?6?\.?&L=?[XLj?02ۼ@8J?kI}?QaQޚ??f?ʏ-a)@8p?,,? }P!? -K?Oނ?"@@@@,@*?????@x@x@x.@x.@x.@x.@x.@B\(@A7K@B\(.@B\(.@B\(.@B\(.@B\(.@1H@1蛋5@0\I^5@.Mm@0>Vu.Qn@/-w1.NC,@/-w1.NC,@/-w1.NC,?^(ǭ@8#@8:@8 >+@8I@8?bM/^@8@8i@8@8S@8?ngH29@8 *@8p@8@8 @8 @ ?@ -o@S@ -o@ -0@ -o@ -0@ -o@$t@ -o@@ -o@{J#:@$bM@$nP@$bM@$bM@$bM@$׍O<@$bM@$@$bM@$e-@$bM@$.H@9>6z@8:)z@4J^5?|@4I>BZ@3"@3ߤ@@2_o @2Q@2_o @2)y@2_o @2K]c? x??/͔p?\GyƩ?ťBW?;?)T?{UO?Kd+??r=w?x7f?K? *sr?T?R ?ٔ!x? N@@@@@*@&??????pB?X,8?cra@?\lU@ -}z@$ӝ?utꍳ?G?Z}%n?6@o:@@8Q@8Q@8Q@9\h@8Q@9Y @8Q@;s@8Q@6- @8Q@8eC@8g-@8g-@8g-@8h@8g-@8j&_h@8g-@8i-^@8g-@8i]@8g-@8ky@2#g l@2#g l@.8tj@.7E@.*n@.&&V39@-ۋq @-Z@-ۋq @-@-ۋq @-X^?^6P?i<?OG ?o?h?޳E49?bMn? vL? "?$? ?~d?bQ?>?}.?j1s=?(Y?X^)@@@(@*@*@5@8??????IP- ?O^?@W?4˜@9)6f@8i5K?Odħ.?B2􈾇?$_D?~AF@s ҙO6@@\).@\)@/@\)@@\)@fl@\)@h@J@\)@/}@G{.@G{@`\J @G{@$qy@G{@*%@G{@@G{@ǯe H@7.>@3+ J@3 M@3`A7@3'|Q5@2[W?@28mR@2[W?@2CGV@2[W?@2}@-@8J?*}v?0xO?>N?AÓ ?HF@8J??uP;?Kȕ?#PG?^Y:p@8p?ݵ#U?ġ͜+?^כ',?8V?>|O@2@?Hߏ#,?)*FT?'ۂ?Z"&@s @@33333@3@33333.@33333.@33333.@33333.@33333.@@I^5@@hr!@@I^5.@@I^5.@@I^5.@@I^5.@@I^5.@7e!.@7gmt@3r Ĝ.Mm@3 -V.Qn@2.NC,@2.NC,@2.NC,?|h2:@8#@8:@8 >+@8I@8?6]g@8@8i@8@8S@8?Zgr@8 *@8p@8@8 @8 @?@|hs@L@|hs@~]@|hs@v@|hs@)j@|hs@Zt@|hs@T'-K@tj@ moE@tj@6Rw@tj@!NAaw@tj@g@tj@@tj@@74m8@7RR@3+ I@3h k@27KƧ@2+@2z,<@2}0Q@2z,<@2}@2z,<@2~RQ44?ؗ?̏+? T?oc?YB2?B?՘b2?~?}T9I?4Kvx?|;*?PO W? 93?m-?|6}>?iY^#?2T?>!@@&@$@"@.@1??????Hn?bڡc?W-?V8rN@#?@2?rqFn?rdFo7? 0@?S=6`p@m̥@@%;dZ@% I]@%;dZ.@%;dZ.@%;dZ.@%;dZ@%*0V@%;dZ@%-@^5?}@dZ@^5?}.@^5?}.@^5?}.@^5?}@Q@^5?}@/V@7 ]ce@7 Q@3+ .Mm@2Vu.Qn@2iB.NC,@2iB@24m@2iB@2r?Y͍_@8#@8:@8 >+?K/?tY+9>?)T@8@8i@8?dLt?fD?a -@8 *@8p@8?屘?l@@ @(???@C@nO@C@2X@C@[@C@1@C@2@C@jg@7K@lI^5@7K@҈@7K@|@7K@IQ@7K@-V@7K@=K@7Y*0U2b@6A7K@2 ě@2{6z@2 -V@2 "`@1._o @1*ݘ@1._o @1)Y}@1._o @1*vȴ?n(t?S_?-a} ?1?7?ZzZ?H6m?{UO?pI?\d?ۣ0Υ?fAzQa?ꎤR?u/X?v'X?ڠu?v> ?*Z}@@@@@*@(??????UNeQ?_-&_?_w=e"@w@"C(?n|g?mu[?ѿȡ9?5Ta@sB. @@/`A@/`A@/`A@/em@/`A@/C -@/`A@/N2@/`A@/@/`A@/oQV@H;dZ@H;dZ@H;dZ@Hhah@H;dZ@Hg@H;dZ@H):O7@H;dZ@H(ʕV@H;dZ@HnȞ@4v@4_o @1^5?|@1/Hxq@0tj@03 -z|@0Q@0 '@0Q@0;@0Q@0("wk?|b@?i?r?z? Ge?׎L'y#?|h2:?FD?|"x?5?x_Oq?ЎVN??Dޣx?9]?2E?=`XD@3 ě@3fL/{J@3 "`B@2s@2+xF^@2 ě@2+xF^@20L`}@2+xF^@2՘4>b?W? U?/_ ?j}? t4gU?j5?| V?/v\?.U?jV^?^J+?`Lk.?8@?! 6?"x?]C޶? ș?нMrѶ@@@@@7@7??????k`j?OjGP?b@v@Q?a<@lز@ ?eH?~n2??@b~@@hs@/@hs@<63@hs@-V@hs@[8@hs@q @hs@<64@-V@-V@-V@<6@-V@`A@-V@*2@-V@䎊r@-V@3333@4 xF@4|@2i+ @2hYJ@1-V@1As@0𖻘@0hۋ@0𖻘@0'RT`@0𖻘@0;dZ?|O?sp? ??Q@4|hr.Mm@4`A7L.Qn@3ޫ6z.NC,@3ޫ6z.NC,@3ޫ6z.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @0 ě@/-@0 ě@14J@0 ě@0 ě@0 ě@0oiDg@0 ě@.}Vl@0 ě@.p:@۞Q@۟;dZ@۞Q@۟$tT@۞Q@۟[W?@۞Q@۟;dZ@۞Q@۞ߤ?@۞Q@۟b}@4@4a|R@/~"@/ @.rnO@.qR@,N;6@,&x@,N;6@,N;5@,N;6@,4J? ? ?1f_?<ݝ?E{??}ѿ,? g?A)N?e[|(?M@k @@\(@i*w@\(@׍#[@\(@d@\(@ĜBo@\(@׷[]@\(@׻XփA@&ffff@0@E@&ffff@7 @&ffff@5U>@&ffff@'g@&ffff@*@&ffff@3`q3@8@8P׌@3^5?|@3@3A7K@3 ps@2O M@29jė@2O M@2`,u@2O M@2 7L?%h?ZuD?)s??f94Iݍ?̝`? MV{?U:?ehd?,=?kn?h?:?%f+??v#w)?_3+z? a@@@"@$@3@.??????x,;@?R5Z?[\-'+y?a+rf˦@sow@-?uNw?z('? ?5z@nռNg@@h-V@h,@h-V@h+~)@h-V@h.O@h-V@h0 ě@h-V@h/V@h-V@h/@@O;d@@c -@@ͫU@@@@\(@@iC@5[~($@5[~($@2hr @2zxl"@2`A7L@2e@1sh@18YK@1sh@17@1sh@1g l?|O?[ꕠ?IK?Rw#z?Xe?=W?}ѿ,?f?+l?RLnj? ?C ;?Z?7'nK?ԇ:?=rE=?*Z}?OO @@@@@"@$???????HBF?Jq8?,W?'._@h.k@˞f?Lhd,?Gfp$)q?B\g!?A@fA@@ɺ^5?@Z]@ɺ^5?@Q%7@ɺ^5?@n@ɺ^5?@΂3 -@ɺ^5?@ϲ @ɺ^5?@ˊi۴@+@S1@+@Ƨ8d@+@<:@+@ɶaN@+@=@+@@6|Q@6Wv@3#@3'm1x@2tj~@2m߸ @2iB@2@2iB@2S@2iB@2^{?ڡG7Fo?Q+6͖;@k@٧?bvݴj?qn9'l?/o?>GX@i29#@@A7L@ě@A7L@IQ@A7L@u"@A7L@u"@A7L@@N@A7L@@k I@k I@k I@lI^5@k I@i^ @k I@k6z@k I@jqi@k I@iᰉ@4 xF@4tj@0 I^@0L/{@0,j~#@0,1&@/Ǔݗ,@/&J@/Ǔݗ,@/7Kƨ@/Ǔݗ,@/R<6?| ?ߋb?=?Kh?!#?ZAj?9?}ѿ,?NۈV(?:?,~[?a -/ ?m/wBZ@2}:@2}K]@1 ě@14J@/O;dZ@/p:~@0~($ @04J@0~($ @0!.@0~($ @0l!.?^Q5P?E?>\?^t -a?oNŒ+? d?bM_x?)[ -fu?3j_?#X?2}?.8 -B?/Y}?,DP?̈- -?rsw??\? Ğ@@@@@$@*??????BWRN?``A?7b~@9:x*@?;eH _C?XYb?zJ.IR?@hC9=@@5w@5O@5w@5o@5w@5V@5w@5@5w@5.4@5w@5zH@XbM@Y@XbM@W -=p@XbM@WXe@XbM@WXe@XbM@WsP@XbM@V@1w@@1wKƧ@+WKƧ@+WXe,@* 1&y@* 1&z@(@(@(@(حW@(@(䎊r?^XN?[evȴ8@7@6E@7@_o@7@MB@7@R{@7@UfA@33333@.O@33333@1&x@33333@ /{J@33333@@4m@33333@IDg8@33333@? @7uS&@7t9XbN@4^5?}@4Vt@4tj~@4u"@4\Q@4xD*@4\Q@4I^5@@4\Q@4\Np?8YV?v0{Gt?v󒇾O@^0Wp@w6?+o??)?R%{A?M; Y@szl@@+@bM@+.@+.@+.@+.@+.@+ @r-V@+ .@+ .@+ .@+ .@+ .@7O M@6t-N@5uS.Mm@4`A.Qn@4!.I.NC,@4!.I.NC,@4!.I.NC,?"r+@8#@8:@8 >+@8I@8?SV-@8@8i@8@8S@8? @8 *@8p@8@8 @8 @?@Q@\)@Q@;g@Q@𸵜@Q@tw[@Q@ore@Q@ y@}Gz@}A7K@}Gz@}VZ3(@}Gz@}K>%@}Gz@}aGA @}Gz@}O[A*@}Gz@}O0@7]ce@7[X?@33S@33z{@2`A7@2n@@2:,<@2=؆@2:,<@2=@2:,<@2=$0w?~?J?`?) ?~?OmI?\op?anñ?YA?EE/J?-I?H?KC?ކf?Y ?݊X#?QB?]і? t_@@"@"@ @9@6???????i?`ЍtT?0=Mu?XHWq@K@}L=?P. T?y*bUi?@x?QZ@g]'@@S@u@S@.1@S@/A@S@+a@S@"@S@&Ft@1l@1+ @1l@1@1l@1Q@1l@1~(@1l@1D@1l@1b@8p4m8@8TO M@5uS@5~1@56-@5,쿱[@4YJ@5,@4YJ@4@4YJ@4u%F ?+-/?1< ?ӳ?3҃?S?sY(?UbB2?n4?E%:9?,#t?+ҥ/?n]3m?$*a?.9؇8?'w?~lVo?)Ũ(?S@Gd@@@@@(@(???????q<?cW_?a(˞?h\z1@"+s@1)Vu@1={@0ush@0utn) -@0ush@0tZN@0ush@0v5 ?}#?!ԡ.?L߉N2;?0Ѐ?-'i?rC?|h2:?tFLj?41?%=|V?%qߌ?Vz@@$@ @@4@5??????JL?Qs*Μ?0Esɀ?& @_J@((?P!x?GTV?nL;u? -z -ƧL@f];?@@νp -.@νp -@5Y@νp -@γ@νp -@D@νp -@{S@νp -@O @.@@lC@@⩓ @@@@ [@@֡a@6|Q.>@4J^5?|@42-V@3"`@3 M;@3p@3gXe,@3p@3%!.@3p@3-(@8J?# ?H,K?C˗?Ѷĥ?Hg@8J?f\?`R*?=,܄o?ÇޞE? P7L@8p?f?-t*z?+&*?w, ?=i@@@@*@(?????@Qhr!.@Qhr!.@Qhr!.@Qhr!.@Qhr!.@Qhr!.@ -=p.@ -=p.@ -=p.@ -=p.@ -=p.@ -=p.@7Y*0U2b.>@3{ I^.Mm@2-.Qn@2m8.NC,@2m8.NC,@2m8.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @vȴ9X@xQ @vȴ9X@}+k@vȴ9X@jڹZ@vȴ9X@c -=r@vȴ9X@m@vȴ9X@kt@kQ@k-@kQ@kD@kQ@ksP@kQ@k@kQ@k:)z@kQ@k~@6>6z@6F -L/@3hr @3qi@3"`B@3~ѷY@3:,<@33$@3:,<@3..2@3:,<@3*Y? ?J6|?zI#?~mW?r?AŸ?1j?N`?L?3F0?02\?'Ln?m+&?їJ?9@0w?-;d'?\,!?8@@@@@&@&??????q"@h?`35t?`V (?Z[O@pGS|@k -(?|F?vt?QH?qۊ|@c @ @-@E@-@Ov_@-@@-@Mj@-@?@-@ I@ ;lD@ 6ȴ9X@ ;lD@ NV@ ;lD@ {qu"@ ;lD@ X4֡@ ;lD@ -@ ;lD@ 9_o@7쿱[X@7,@45?|@4q @4tj~@4@3m8@3\(@3m8@4Dm8@3m8@3N;6?}?+>? J?ׂa?t#V?/U?+-/?%@&??v?). ?mݪҏ?tFI?&Z#?u?Hh'$?eT?A&@@@@@(@*??????vj?p_?i>:?W85@߹H3@ JBŃ?+L??Ĺ+?Y`,@*?f%H}@fFW - -@ -@P`A@Qm@P`A@R9dfp@P`A@P{@P`A@Q07@P`A@OK?@P`A@Og@v@ -@v@S@v@j@v@\@v@F@v@f`m@304m8@30'RT`@0!hr @0![?@.;dZ@.@-@-deg@-@-ֻC@-@-e?}#?eqa? 5C? -F[?af?Kq?| V?Cl?&٣v?8f_w?bzF?^p_?tw{O?z+?siH4?-B\@.J#9@.J#9@)`A7K@)zxl"h@'n@'IQ@'a-w1@'aGz@'a-w1@'aGz@'a-w1@'a:T?^Q5P?ƿ57?S?MA8?tKc?tJ?bM_x? g?90?7枪y7?@?L "?b@?8 T?oܧ?avh?O|q?#.@@@@@&@(??????R d?Bȹ ^@@y?Gl´a>f 6?4C>Vp@s nY:O@ @,ݲ-V@,/@,ݲ-V@,6@,ݲ-V@,*1@,ݲ-V@,hۋ@,ݲ-V@,W>7@,ݲ-V@,C,y@\1'@]-V@\1'@g)_@\1'@cS@\1'@mV@\1'@a@N@\1'@\PH@5I_o@5IrGE8@2\I^5?@2Z,<@1Vu@1b}@1YJ@1j~@1YJ@1)^@1YJ@16D?| ?4$?K̃?wX/8?o?P? d? ?`5a?1ک! ?鐮|o??|?qn?oM?O?C?l? .0v@@@@@*@*?????? @?AS=d?A΁?UerhO@,\\@_ZA@?a?(J?u>@?[_?'.}\@f7!A9@ @Q9Xb@Q1&y@Q9Xb@Q8@Q9Xb@Qu@Q9Xb@Qg @Q9Xb@QjO@Q9Xb@Q:@1&y@⺟v@1&y@Ft@1&y@u@1&y@⽥@1&y@ⵁ$@1&y@ƀIR@8_o@8ѷ@4^+@4aTɅo@4-V@4'sPH@3G k@3GkP@3G k@3Dm8@3G k@3EF -L0?W$B?vucʲ?XY?'Z?PU`?"eM?ٛP?b?Et?xH +?. ?X2$?]'Y?Ǚs?Az?LO?uЍ?? S @@@@@*@,??????/2A?\%<?ZΈ?b{}b@Q1ψ@?{?sDsY?xl?=Md?hs@o0z@@LI^5@GlC@LI^5@LI^5@LI^5@J=p@LI^5@MU@LI^5@JE@LI^5@L_@2-@2j~@2-@2rGF@2-@2jN@2-@2|@2-@2iDg9@2-@2V@8䎊@7C,@3ěT@3hr @2"@2T@1@1=b@1@1ѷ@1@17KƧ?Q,Ě?tH?UGNA?J?j?J8Ȟ?Ol? Du?$z¾6??.<?:i?]?vv?̈- -?Z?:1?Y͍_@@@@@(@(???????#q@RS>?LNJt?.V,@LBm"@2i1?al9'}?R9Y {y?G4q?t `@o_S!A@@ETF@EU$@ETF@EUϪ͠@ETF@EU$@ETF@EUϪ͞@ETF@ES@ETF@ES*0U@bM@&x@bM@{@bM@ -=@bM@^@bM@hr!@bM@{@4(YJ@4(eO@0 ě@0- r@/n@/7Kƨ@.a-w1@.aohی@.a-w1@.aGz@.a-w1@.aGz? ?&H?*"AaI?ݶ\r?Dj?2I/?|O? C`?A)N?]bn~?6z@4FLy@0hr @0pz 8@0Htj@0H8%%@/@/89@/@/)ە@/@/z?}#?'Ќ?3W?%?B?ױT?V?|h2:?1(?ty!?7ݸ?\C)?sc)?oEP}?l< ?x?k?4?6@@@ @ @5@3?????? -fu?[RKE??~?A_f;j?jx?sq#?z_? ??:1?v> @@@@@*@*??????J:j]zq?NDKRs?@:~@^L@Tnn?g?V5?V7qF,?cx -e@nGc@@D49Xb@D3@D49Xb@D4Fs@D49Xb@D4D@D49Xb@D4SM@D49Xb@D33333@D49Xb@D3@\Q@\Q@\Q@\a@P@\Q@\&I@\Q@\n@\Q@\Zc @\Q@\t@25S&@25Vl!@/A7K@/o@/n@/@.`d@.!-w2@.`d@.zG@.`d@.3?^T?&H?`כm?8v?Dj??bMn? ,C?tJ?3.Yl?ߒh!?eDQQ?bM?3;?W ?':?L?L@@@@@,@&??????:,?(?,Č_?->{!6@D3W@\&?;ٹVlB?;?q"LQ?q~a@s\9@@.s3333@.r@.s3333@.tG@.s3333@.u\)@.s3333@.s @.s3333@.rT`e@.s3333@.qiD@lD@S@lD@\O@lD@ (@lD@@lD@]cf@lD@쿱@4r@4r䎊q@0@0g@0Htj@0H)@/ۋq @/B@/ۋq @/~"@/ۋq @/L/|?|O?ߋb?e -!C?#t?? µ?1j?7fps?'Q?@Cv?M?rJs?2Y0?Q? SF?^ a?ˢL1?fW@@@@@(@,??????$?(3?/.(x>j$ c@.r@ p?6,sto?v3q?z%?@]kh$@g5@@ަffff@ޡ7K@ަffff@ޭB@ަffff@ޥں@ަffff@ޥn@ަffff@ޤT@ަffff@ާE85@"@Q@"@âw@"@Ov_@"@@"@"@"@|h@7v@7@2W+ I@2W8}H@1lj~#@1l1&@0s&@0ra|R@0s&@0rGE85@0s&@0r@4n?|O?*? -NA3?̒?V^?-tT?ꯨT?Eo&?t(?-I`K?77?ٶm?:-?7-R?@A?k,?2[s? Ğ@@@@@(@"???????RADL&Q?0յg?>KMU9@ޥ!@D8?T>`?T @?B WA?,;1@nvr.k@@~"@j~@~"@yF@~"@O.+@~"@&'A@~"@A:@~"@@ǺG@ǬI^5@ǺG@Ǜl@ǺG@ǃU@ǺG@ǀx@ǺG@ l@ǺG@t/=~=@8cg l@8[_O@4 I^5@38@3W-@3*b@3^6z@2 -8|@3^6z@2@5@3^6z@2jD)o?}IT?BGt?r8M?!\|?!?i~r0)?>;f_?'Yb! ?~6gL?۪b?̳r`f?u{0? ?Sp?hbE?{⹭?G[]=?xŪ?ˎYx@@@ @ @$@&???????zBo Հ?aF//?t@Om@lj)f?*˹Z??t"z? S@mGh%J@@XbN@"@XbN@n/@XbN@Y@XbN@"@XbN@74@XbN@}H@A7L@ě@A7L@G{@A7L@n@A7L@@A7L@e+@A7L@@3쿱[X@31@0r Ĝ@0&@0`A@0GE85@/Ǔݗ,@/ƚ,<@/Ǔݗ,@/TɅ@/Ǔݗ,@/?}ѿ,??`כm? Y?V^?ʟ?| ?›?i?1'7?c3c(?äqY?/Y}? -? ݎ8?k,?ܑ ?v> @@@@@*@&??????4ի?' ?!="K?'];؟@?e@?A .S?G&z?"}e?&k -@fӺ@@@^5?}@@"@@64@@G@@-@@O;@Mu\)@M~Q@Mu\)@Mt֡a@Mu\)@Mq.@Mu\)@MsMj@Mu\)@Mva@Mu\)@MvR<6@8,<@8m\@1S@1ԕ*@1Z~"@1Xtj@0}ce@0{xF^@0}ce@0{m]@0}ce@0|wkP?sD?sI?N?Fq/b?Z)?봤G?_$?{c?^ o?"6Wz?<}?U3p? nI?Ϸ+?=Cb?GZ?:1?v> @@@@@&@&??????A|@?53N?T1 @@+@Mu^-x?U'tec$?iy4+?FR?@p9Znf@@2߾vȴ@2㕁$@2߾vȴ@2@2߾vȴ@2Q@2߾vȴ@2?@2߾vȴ@2ݿH@2߾vȴ@2ݗ+k@:KƧ@:v@:KƧ@:/@:KƧ@:~6z@:KƧ@:@:KƧ@:@:KƧ@:7@6@6- r@2° ě@2@2tj@2nu@1iB@1oh@1iB@1 rGE8@1iB@1tSN?Y͍_?5{#?S_??o]އ&?k!e?yW?Y͍_?ߤ??Wz>?1} ?i ?,?e -,?. ?~tZE?C)?]O8?՘]G?Qh@@@@@@,@&??????_'v&A?W0l_+6?d'ʙOl@2ޯz@:ЁP?un ??E['?tص1@eY@@֊=p@֍O;d@֊=p@֔F@֊=p@֍@֊=p@֓g @֊=p@֛@֊=p@֝!.I@vQ@vS@vQ@vz@vQ@v'@vQ@vFt@vQ@v4m@vQ@v@7쿱[X@7u@3@3ӯ@36-@3)7KƧ@2ce@2\)@2ce@2r Ĝ@2ce@2lC?UbB2??p`@i?rӂ?d8?J"Fr?I~y?bH=?ml???Vc?1_A?^&?=!K???YAd?q?°R=@@@@@,@,???????j}L -?A+U{5?P+'c@֕H1^@vq1?aA?q, Y?C=?ܾ@ihi@@U I^@UG{@U I^@UG{@U I^@UbM@U I^@Uhr@U I^@Ui'RT@U I^@UFs@.7K@.@.7K@.0H@.7K@.M(@.7K@.LI^5@.7K@/g@.7K@/oiD@6v@63@2@ ě@2+xF]@1tj@1ۋq @1Tm8@1.Ov_خ@1Tm8@1[@1Tm8@1u%F -?K{O?>? ?%\?B?c>?A[F?z?Y8쪒?GLD3??ϛھ2?]?\{?,?ob4U? )D)? -e@@@@@(@(??????p?GW%?tj '8?Y "@U$"9@.;? -7?\?m:Գ@@cm.):@@ߚ1@ߖE@ߚ1@ߚ~@ߚ1@ߛ"`@ߚ1@ߛ6@ߚ1@ߙrGE8@ߚ1@ߘ-@=ix@=kC@=ix@=il@=ix@=iQ@=ix@=i @=ix@=i@=ix@=i @2,<@2S&@-kƧ@-kq @,rnO@,rGE85@,Ǔݗ,@,)^@,Ǔݗ,@,Fs@,Ǔݗ,@,dž&?q0$?{j?*"AaI?q@v?<`.?^?cE?)[D? $gv?O?7N?*Q?l@@@@@(@(???????R`W~$P?53@?2II/@a!F?@}?T>?Rv?&x?gA_@eOm@@I.@I.@I.@I.@I.@I.@hs.@hs.@hs.@hs.@hs.@hs.@7qiC.>@4hr .Mm@5t.Qn@4Eu.NC,@4Eu.NC,@4Eu.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8  @n@n@n.@n.@n.@n@5Y}@n@҉@vtj@vtj@vtj.@vtj.@vtj.@vtj@w7Xe@vtj@vz,<@4?@4?;dZ@2+ I.Mm@2Ft.Qn@1sh.NC,@1sh@1@1sh@1?}ѿ,@8#@8:@8 >+?BW29?ͬc?| @8@8i@8?" S?KE~?|׿pY@8 *@8p@8?It?Xli@@(@*???!@xQ.@xQ@tFs@xQ@x@xQ@zG@xQ@u$@xQ@tzG@DT.@DT@D7@DT@@[7@DT@C@DT@<1'@DT@>($ y@8^H.>@4@ ě@4=%@3K"`B@3KU=@2@2]cf@2@2=b@2@2~($ @8J?Az;?zeߎ?? -0ggk?U.@8J? x[{?%c~?8wxq?x9l?b+m:@8p?Q?E~?>?T?l@@@@*@(?????"@%@0ĻS@%.@%.@%.@%.@%.@.zH@9@.zH.@.zH.@.zH.@.zH.@.zH.@8!.@7?\zt@6#.Mm@5`A7.Qn@6!:S.NC,@6!:S.NC,@6!:S.NC,?ǁ)H@8#@8:@8 >+@8I@8?̈́g_H@8@8i@8@8S@8?\@@8 *@8p@8@8 @8 @?#@3333@64@3333@oiDh@3333@1'@3333@( @3333@C@3333@6-]@h\@QN;@h\@ebKe@h\@hzK@h\@eR:@h\@oz@h\@t9@8쿱[X@84,Np@3 I^5@3c%n?@3dj~@3f '@2 k@2&@\@2 k@2}N@2 k@2.f?|"<~~?ǍlJ?F:?} ?9/+W?8^?X?**?T[S+?q?,w.@@"@(@ @:@5??????s/o?}ے䮀??d/?0N|kH@@a?D7@9&2@Д.?OvF?d-]]Nݭ?2 ?WsD@f3@%@o!G{@o!7K@o!G{@o&1@o!G{@oDZ @o!G{@oQ@o!G{@odT@o!G{@oNV@@n@@@@n@@t\@@煮1@@狅R@4T xF@4Sݗ+k@1 I^5@1j~@0lj~#@0]w1@08D*@0#w@08D*@0d7@08D*@0s?|O?]fm?w? '`? t(?]GW?}ѿ,?~y?"j?7ߙ?Ti?G)g?u@>N ? ?CwB?zlh?8ϣ?F-@@@@@,@*???????{^\?x#?f2=9C@o+@r?~?r (?}EP?{^@Zzy@&@>-@>ti@>-@> 5@>-@>}V@>-@>t3@>-@>8a~@>-@>2@š@Z@š@T>@š@D5@š@sx@š@ĆQi@š@vd@6S&@6~QE@3.5?|@3/=<$n @2PA7K@2QaDWd@1@5@1Ẅ@1@5@1@>@1@5@1m˩?(?C\-?Dw?9C?U5??:(?|0pJ?REP?n,?hy?*_?L  -?u7G?8G?/|? g?bq?n+.'5@@"@(@(@:@7???????hZPN?Xѡ?C'38@>DX/@za?u ӵ?>bh ?/nxt?%OA@j~VS@'@T@TQ @T@T.KN@T@TK@T@TYf@T@TR@T@TXgK@V@`S@V@uk\W@V@珫 @V@O$1@V@,x@V@ e@7v@7灺>@3E?|h@3F;(@2Ͳ-V@2[@2V!.I@2Wq22@2V!.I@2XFM@2V!.I@2Xұd?0k?!d?A ?ɑ ? F`"?[&?r2?TT%?1 -?^?=Y?֜f};?)xr?Pk?\1k?{j9@?xj*?ˮ@@,@*@*@:@:???????Uh@aW?B~?QOyP@T㌵#@ƾ -J?]K3n?i r?=bB{N ? 2XÂ@nFLj@(@r@r+ K@r@r^ @r@r%F -L@r@q{J#;@r@rU*2@r@rl@p ě@k I@p ě@֡a@p ě@UXy>@p ě@,<@p ě@J#9@p ě@A@7 xF@7䎊@4+@4iB@5$j~@41'@4G k@4/V@4G k@4=v@4G k@48K]c? ?3q?OLï>?ϩƧ;2k?t?B?)3y?Ol?D?hT7?s?&2d??o?z."?rIs?а7DuI? V??(4՞@@@@@*@*??????~;bPܽ?y:!?r I@rm@Z I?9?~$֙@,K^!g?wg@[~;LG@)@zG@f$/@zG@q @zG@iDg8@zG@qi@zG@ qv@zG@b}@Ǵ9Xb@ǭhr@Ǵ9Xb@ǽH@Ǵ9Xb@ǶFs@Ǵ9Xb@fB@Ǵ9Xb@Fs@Ǵ9Xb@Ϫ͞@84m8@8@5}hr @5}M:@5-@5kP@4_o @4S@4_o @4$tS@4_o @4u%F ?F/P5?q+qW?̗>?˃.? ?DX S?WZM?ۣ0Τ?B?6r00M?;C=?*]6?m?nTn?Sn{?}2;?9?DL@@@@@"@$???????G?}?eSFF?aG @{@\H?wQ?| ŀs?Pa?Ru]@ky@rg@*@ -=q@/@ -=q@ᛥS@ -=q@ᙙ@ -=q@/@ -=q@Q@ -=q@ I]@>x@>C@>x@>r @>x@>Q@>x@?+@>x@>o@>x@>@8L]ce@8HU@3S@34J@3~"@3 @2[W?@2 @2[W?@2}E@2[W?@2}v?8ȺJ?`?=5?Xc?W2D?ZF/D6?d&@8@>| tM?r~扩-O?~GD7?|F@)' @oa@+@o`B@o/@o`B@o2W@o`B@o2W@o`B@o㯷@o`B@oZc @o`B@oⶮ}V@z;dZ@z5fj@z;dZ@z]c@z;dZ@zˬq @z;dZ@zqu@z;dZ@zqu@z;dZ@z͸@64m8@6sP@1° ě@1ݗ+k@1tj~@1qj@0&YJ@0'@0&YJ@0'K]d@0&YJ@0'/V?nO@3n5?|.Mm@3M-V.Qn@2D*.NC,@2D*.NC,@2D*.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 .@  I^.@  I^.@  I^.@  I^.@  I^.@  I^.@u.@u.@u.@u.@u.@u.@8֚,<.>@3° ě.Mm@3`A.Qn@2!:S.NC,@2!:S.NC,@2!:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 /@/@1'@/@҈p@/@ (@/@䎊@/@6@/@YJ@IXtj@IX@IXtj@IYXbN@IXtj@IXl"h -@IXtj@IY=d@IXtj@IYb@IXtj@I`E@3䎊@3n@0S@0{J#9@0-@0fA@0ush@0v1.@0ush@0u\(@0ush@0qR<6?}ѿ,?Z.?jhq9?%?@@No9?y%?|O?)[Zw?%ϑ?՘]G?]ߒ@@@@@$@&??????1*?PM?F:?DH@@IZ?f qC$?d?$懪?Hx|@f,2@0@@j~@@5?|@@0 ě@@!(@@@@\@["`@,@["`@Ǔ@["`@qu"@["`@Ǡ k@["`@Eh@["`@t@5_o@5 vkT@2}hr @1CMjO@2'KƧ@0s@N@1u@/حU@1u@/aT@1u@/-V?k?cX?d ?MN:?ξWס?]q;j?C~? -??CRn?R?ǥt?G0?&?fI=C?4;$?oh?Vl?$FtY@@@@@(@???????Is`?{K?bu\? 1@@㫘?~Vi'?)?)g1@37@^ -@1@4j~@;dZ@4j~.@4j~.@4j~.@4j~.@4j~.@|P`A@|$.@|P`A.@|P`A.@|P`A.@|P`A.@|P`A.@8@9R<6@5Y^5?}.Mm@4q7Kƨ.Qn@4#.NC,@4#.NC,@4#.NC,? Z @8#@8:@8 >+@8I@8? x@8@8i@8@8S@8?'[@8 *@8p@8@8 @8 @?2@tj~@vu@tj~@{)%@tj~@fbm@tj~@h:I@@tj~@`''@tj~@i8B6@'~#@'@|@'~#@(@'~#@(a @'~#@(4a@'~#@(1M?@'~#@(R@9*0U2b@9(8@4@4.@4 "`B@4*Xis`@3iB@3|Њ@3iB@3խ@3iB@3Ko?)1?:a?ô0?,H!?).%@g?`P(ee?Y%?Y?"U\#?m?31?ka"?Hr?T?Y?:81?Xh>*?A+d?:#@@&@"@@0@*???????oW?jڕ?&:-?t3@s U@(p ? e x?6lw@&N?^4@p8_v@3@&`B@&`B@&`B@&/@&`B@&9@&`B@&U@&`B@&Fs@&`B@&=p@RkR@Rl1&@RkR@R^\M@RkR@Rd7@RkR@R;@RkR@RE84@RkR@RC -=q@4|Q@4Gz@1{ I^@1v!.I@1{Ƨ@1u84֡@1[W?@1y+ @1[W?@1{'/@1[W?@1|C?| ?GA?ʶs? "?ߩ??| ?ۣ0Τ?1ک! ?\(A?L?|9?y8#?zx?ٺ?;UAE?P|?@@@@@(@,???????j(!Z -?Q\t]?e漫z @&]@R_l?j?{`\a?`V?.}[@_>a6@4@'M@'u6@'M@'@N@'M@'/@'M@'C,@'M@'TɆ@'M@'C]@ě@ -=p@ě@D@ě@8}@ě@\(@ě@'0@ě@J@7:@7l@5+S@51e@4'KƧ@4&?@30U2a|@3ʙ0 @30U2a|@3@30U2a|@3Ƈ+ J?I'%?%=7"?c«?iP?dt O?|&?Qp?ֶ?ܿ?y҇?x9l?X#?>?@/@{?[Rb??HF!6?n$@@@@@*@(???????] -oˁ?H0H^?SE@'d@Un!#?chKqձ?u/e?,p?p:q@j$2 @5@n@^5?}@n@n@n@~@n@TɅ@n@@n@A7M@Œ@‡+ J@Œ@B@Œ@Œ@Œ@Ž_o@Œ@5Xx@Œ@@8N쿱[X@8X ԕ*@2?|h@2ᰉ@1R`A@1R䎊q@0 [W?@0 U=@0 [W?@0 @0 [W?@0 _?|O?t0?U#?vHn&?E{? µ?`m??xrI?ԕ]I?Y?qN?m/w?vsR_?[g??㝯?4?2t?~?J?^??#?8&?l`?GJ ?lq?1C'3? ;n?%?}@@*@,@*@8@6???????yiJ?l?g "$Uz?a'J@ X@,z?F?I?yB -@xAQ](@kJ@7@mbM@mbM@mbM@mrGE9@mbM@mٙ@mbM@m@mbM@m״3@mbM@m>6y@4fffff@4f@4fffff@4g8}@4fffff@4h@4fffff@4fA@4fffff@4f]c@4fffff@4g/W@3쿱[X@3@.MV@.MB@-nO@-GE85@.Vl"@.-V@.Vl"@.p ->@.Vl"@.+j?| ?3i?N?lDžN9?ǹT?-tT?|O?#maЀ?rJs?EP?إ<(?{L բD?2Y0?3;?s@a?ʬv?pk Y?b/bJ@@@@@(@*???????#W`?#cl?e@mX@4f?Ck~?2ٟu?'p?\JY?rg@fla@8@η@δ9Xa@η@η@η@ι@η@κ^5?}@η@ηs@η@θy=@lD@^5?}@lD@p @lD@!.I@lD@/@lD@n.@lD@]ce@6=:@63wl@1G+@1GkP@0i"`@0i|@0._o @0/ M;@0._o @0.ߤ?@0._o @0/H˒:?)T?nx?)?.Ү_ ? Y?; ^?<_?}ѿ,?D.x?tP*?1'7?Hc?nK/?H?lo>?~/O?Gϵ'?A0)n?v> @@@@@@ ???????O{??~?D7P?+FF ,@η6J@J?cSH:Q|?MYui+ ?]_?9T7@iWԑD@9@+@bM@+@`d@+@e@+@+j@+@tj@+@ԕ*@S@Q@S@h ԕ@S@n.@S@1@S@s@S@ xG@5v@5lC@2 I^5@2nO@2Z~"@2\[W?@10U2a|@1/{J$@10U2a|@1:@10U2a|@1ɺ^5?}?| ?hX*?ojVrn7E?/Y}?Otx??ER Y?}?P\@@@@@,@(??????H>G?4k,i?-.qب@֔h@-h?UX5?NoZV?LMa!?%@f@:@m8@ma@m8@m5*0@m8@m/4֡b@m8@m/{J#@m8@m)@m8@m..3@ -=p@3333@ -=p@p -@ -=p@$@ -=p@)y@ -=p@ ԕ@ -=p@p:@7 _o@6Mj@38r Ĝ@33F]c@2y7KƧ@2rS&@1&@1D@1&@1+ @1&@1Q ?t#V?q' -B?&$#/?(tUo?ɨ+?Vd?h??2(_?%8?r?+hd{?'?9&? ?A'_^?[?/̽`? `@@@@@,@(??????_®_ [?gOg?gb-@m.|@͢?xS?Tr"?k(Й@)Ǒi@qJԁ@;@(r @(\@(r @)@(r @)*0U1@(r @(\@(r @'ݗ@(r @'ݗ@޸Q@;dZ@޸Q@ޫ6z@޸Q@5?|@޸Q@޸Q@޸Q@vȴ9@޸Q@@3qiC@3L_@/G-@/Hr ě@-/;dZ@-/Vϫ@,uXy=@,usg@,uXy=@,uᰉ@,uXy=@,u\(?}ѿ,?Z.?$C@? Y??ˡK?| ?#maЀ?ԕ]I?-I`K?ߒh!?Uyu#? ݎ8?§d߱?|׿pZ?ʬv??@@@@@*@&??????1+2?L>KK@(tb}@[?=bqwY?L? k?(݀@gfi@<@ @ @ @ hi)@ @ Gq@ @ @ @AIZ`@ @(C@&W -=p@&V @&W -=p@&R%w@&W -=p@&Te)@&W -=p@&S@&W -=p@&YH.*@&W -=p@&S+@6,<@6jJ@2B ě@2A7kE@1v-@1t)@0@0ޜO@0@0m@0@0%s ?~Ov_ح?C*!?w|?>'?) / 7?q?eXW?8N?^nu?1s#?Zps{?W?U?!01?s9+6d?lpM?ʨt?e-$#{@@@ @ @6@(???????L=E#5A?C+0E?3)}@ +%@&VءB?cˈ?TL]?ӟ?]@gC@IA@=@Н-V@а -=@Н-V@МPH@Н-V@ИD@Н-V@Й@Н-V@З3@Н-V@БX@ȌI^5@Ȍ1&@ȌI^5@Ȟ\N@ȌI^5@Ȗu@ȌI^5@ȧE85@ȌI^5@ȃF]e@ȌI^5@ȗ>6z@8qiC@8@5+@5_F@4"`B@4~@4 -0U2a|@4@4 -0U2a|@4:@4 -0U2a|@4u%F -?_pP1?fDb?=5?Uyu#? )?V?F^S?\L)C?iկ?Y`?f@?W'?œ,?"_?7?Z?*:R}?>3}@@@@@"@$??????t?6J?Z c?uYE@Й[,@Ȕl?oy/?4?O7ϗR@-9Y@n?@>@NV@N_o@NV@OV@NV@OŁFX@NV@LQ@NV@I0@NV@Jf:}@hs@7@hs@[@hs@8\~@hs@8@hs@x@hs@c@4֚,<@4,@13S@13?4ކ@0Vu@0%@0Eu@0A@0Eu@0>ݔ@0Eu@0@-,Z?|B &?UV&w$?'7 O|?#Z?;A1?eVV?| V??o|?kS?Qxy_?.?p?o?vȴ9@6ȴ9X@u@6ȴ9X@<@6ȴ9X@-V@6ȴ9X@m&@6ȴ9X@@dtj@d@dtj@dJf@dtj@ciDg8@dtj@c-@dtj@bF@dtj@bJ=p@7B䎊@7>p:~@4?|h@4+jf@4tj~@4n.3@43&@4m@43&@3`:~@43&@3Zn?Ol?Bx1 ?i?>-?dD2?Β9?_pP1?g*?լ{T?̝TY?R?bI߭??-?įJ?K{~?2 ?NR\@@@@@ @"???????ɓ*4I ?T ?Zk@[#@cqMF?d5?>r@j1,%@"qh-@a'!@@@hr@㕁%@hr@@hr@״3@hr@ק'@hr@PG@hr@֔Fs@߾vȴ@-@߾vȴ@lD@߾vȴ@@߾vȴ@af@߾vȴ@jg@߾vȴ@8}@8@8-V@5+ J@5Zc@4j~@4Mj@4!.I@4p҈p@4!.I@45Xz@4!.I@4oi?|O???.N?"co?60a??bjk?P|?I?Kȁ?]%?P?F{?ߔY?JzUf?Cx%?/я?A=@@@@@@??????l6ʪW?C TUj?krvo|@d@?l##q?e7&?0lFt8?ˮͿt@m9@A@u@\)@u@e@u@`d@u@_ح@u@ӎMj@u@և+ @R@Ƨ@R@5Xz@R@x@R@JM@R@F@R@.@5N쿱[X@5N%@2+ @2U@2-@2Xy=ـ@1@1@1@1⩓ @1@19?|O?W[?y]?wX/8?ɿ?Rg.?1j?,#?8G?GuS?SY?IH!w?m+&?c I??],V?XW~? .0v?4hpɄ@@@@@&@(?????? +4?W-j?3z?H"G(@է@M?SW -LC?i%dl[1?2Xd{?Vo@fH5J@B@tj@1'@tj@ -o@tj@fC@tj@ɺ^5@@tj.@tj.@Gȴ9X@GS@Gȴ9X@G=c@Gȴ9X@GS@Gȴ9X@G+l@Gȴ9X.@Gȴ9X.@7@7o@5 ě@5]O;dZ@4K"`B@4|@4@5@3\N@4@5.NC,@4@5.NC,?sD?I?*?]/@8I@8?Y͍_?W;zY??@8S@8?W;RS?A@S~`?k?/"@8 @8 @@@@????C@C.@C.@C.@C.@C.@C.@n.@n.@n.@n.@n.@n.@7r.>@3 I^5.Mm@3gKƧ.Qn@1sh.NC,@1sh.NC,@1sh.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 D@.@.@.@.@.@.@ hs.@ hs.@ hs.@ hs.@ hs.@ hs.@8:.>@4S.Mm@3"`B.Qn@3 -0U2a|.NC,@3 -0U2a|.NC,@3 -0U2a|.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 E@\@x@\@84@\@죢w@\@5?|@\@쥔O@\@ں@O@V@O@_@O@ @O@ l@O@o@O@C@6!.@6oiDh@3i+ @3cA [@2v-@2r I^5@2 [W?@2A [@2 [W?@2 Dg8~@2 [W?@24K?}ѿ,? q?%HC=s?Q+v?<_+fj?5JA.?HD=??;%\@쥧@x ?h>Fp?[~w?d('?uE@e0@F@ -=@&x@ -=@)^@ -=@ *@ -=@@ -=@- @ -=@@|-@|-@|-@|v_خ@|-@|@|-@|@|-@|'R@|-@|H@6O M@6&@/tj~@/Mj@-nP@-ѷ@,`d@,m8@,`d@,9XbN@,`d@,9XbN? ?3i?m?8v?tKc?*WF?}ѿ,?›?~Q?/Z?@?M\ٓ@?^&?.+?8*?':??f_Ԋ@@@@@,@$??????(`?%?"n#?6G@I@|NO?B6Q?%1O]?V;?Vj0ոJ@gMCE@G@=Ƨ@=Ƨ@=Ƨ@=3@=Ƨ@=¶}W@=Ƨ@=ѷ@=Ƨ@=Õ%@=Ƨ@=¶}V@"O;d@"Ƨ@"O;d@"Љ'R@"O;d@"ҽ<6@"O;d@"{@"O;d@" p@"O;d@"C\@5=:@5:c -@1sS@1h@@0V@0{J#9@/-w1@/1&y@/-w1@/>BZ@/-w1@/Mj?Ol?"2???_dA?"X?| ?zF?pI?1}B-?#b^?j?O?3I#i?Me_?v_.^?fW?mΝ@@@@@"@(??????Kf?E~g0?*ʆk?BZb@.3tj~@.3&@-nP@-C,@+ۋq @+Dg8~@+ۋq @+7KƧ@+ۋq @+?| ?[e(lQ ?wX/8?q f?I?F/P5?6c?ɇ}~?#X? +A?J佪^?Rw#z?p51?3Z\?π9"?&f? 1 D@@@@@@,@&???????H7.@?P]D?1\>?M6mQl!A@X+@[?OZGP?o -ƕi-?֡?D !@iE]@O@vȴ@vȴ@vȴ@@5@vȴ@}V@vȴ@&J@vȴ@R<@vȴ@}W@@$/@@ѷ@@n@@.H@@D@@ح@2]ce@2s@--V@-af@+E@+4J@*)_@**0@*)_@*O L@*)_@*g?^XN?J?-.?&P?9.?`? ٖ?bM_x?6S{? -\?,?JL\?C ;?g)?rbT?],m=?=aw%?:1?Cns@@@@@,@*???????'d?4;p?2NHU?@ Q@&@?B7 ?O|#D/?|!? `ܐW@rYY:@P@*9X@*x@*9X@*I^5@*9X@*!-v@*9X@*qi@*9X@*\)@*9X@*R<5@ 7Kƨ@ -p@ 7Kƨ@z@ 7Kƨ@hs@ 7Kƨ@R<@ 7Kƨ@:@ 7Kƨ@Zc @7w@@7xe+@35?|@3g@2tj~@2*@2Tm8@2O4֡a@2Tm8@2>$t@2Tm8@2@IQ?^*?hĔV?13??㬱_?|QS?[й?% ?z?:-%?"6Wz?VAo?u!#?-]?њH?ʭ#г_?Z?Xs~?qM,@@@@@,@(???????g*^ff?Rn#O?G?@*Jj@RR?mE ?c'?^?d$@g -o@Q@1'@!@1'@\1'@1'@@1'@# -=q@1'@O @1'@>%@I^5?@&ffff@I^5?@=H@I^5?@Xe@I^5?@z@I^5?@&x@I^5?@@8!.@8q9@4 hr@3쿱\@3"`B@31-w1@2@2_4֡a@2@2]E@2@2XK]c?|0pJ?͎#?۸F>8?Ge?٠qsU?lT%u?9?J/p?ζa'~?Ϭlה?Թd-@Q?N)O?[N?~ԙ?yz?7< 4?MX?ȩ@@@@@,@&??????a?.8?KyF4?%@#@@!$?T??n"ef@#&@aEb4@R@`A7@_l@`A7@ -L0@`A7@~#@`A7@=p@`A7@ (@`A7@U@9aG{@9bM@9aG{@9|쿰@9aG{@9{@9aG{@9@9aG{@9x@9aG{@9U<@3=:@3<@1}hr @1zd7@297KƧ@2-<64@1z,<@1s\N@1z,<@1sMjP@1z,<@1kjf?| V?m0?=tQF?(+Zk?7?fsPa?|h2:?j%Ra?#*0???=?of@?l?{Tä=?(> ?4\ɵ?8~,@@@@@,@*???????7Yp?t*?Da?\AS@@D.@9tDF?bLd?yug2?/MW?@cM1@S@ᖇ+ .@ᖇ+ @ᡖR<@ᖇ+ @4֡a@ᖇ+ @+@ᖇ+ @+@ᖇ+ @9Xb@;dZ.@;dZ@@D@;dZ@>6z@;dZ@@IQ@;dZ@D?@;dZ@=E@9B䎊.>@4I^5?@4! @4t@4SMj@2p@2pD@2p@2p҈p@2p@2pn@8J?q? -> ?vI?2F0?۝.Yr@8J?%@&?pI?:u. ?a -/ ?<@8p?7&x?AQ3??|)-}(?+`ȓ@@@@(@(?????T@ I@/Y@ I.@ I.@ I.@ I.@ I.@?|h@E@?|h.@?|h.@?|h.@?|h.@?|h.@8YJ@85@5kS.Mm@5)"`.Qn@4&YJ.NC,@4&YJ.NC,@4&YJ.NC,?RFR@8#@8:@8 >+@8I@8?I@8@8i@8@8S@8?UC @8 *@8p@8@8 @8 @?U@S@vȵ@S@c@S@bu%F @S@[u@S@S*0U@S@T,<@P`A@t@P`A@y0 @P`A@l"h @P`A@]E@P`A@Y#x@P`A@ZY@8w@@8)+ @2hr@2usg@1A7K@1͞@0Q@0m8@0Q@0t@0Q@0o??b[??^:f?j??#?F^S?0?pM?wxR?ˬ?+l?Mi,?t??Q(? $4?**Z@@@@@,@,??????)Ew@R ?e>c*?z?@]X!@d5?rR?L[bv?8v@ouG@n 2@V@1&y@9X@1&y@y@1&y@ԕ,@1&y@@1&y@@1&y@#@ITzG@ITzG@ITzG@IT,<@ITzG@IVE@ITzG@IT3@ITzG@IU2a|@ITzG@IU$@5 xF@5oh@1hr@16@0KƧ@0y @0@04m@0@0A [@0@0)^?| ?*|3N?1f_? Iy?u?aX? ?pPȻ?2'?uX?q1At?eDQQ?],V?u/X?ZaQ? ??<71?ad|@@@@@*@&??????0^2?(xAV?,@@$@"@"@6@7??????3Ɇ?p]ր?6+i?T.THD@zQ@-V?F"<1e?c!8v?Os?l@rH^@Y@KƧ@ߌ =@KƧ@/@KƧ@zD@KƧ@HL>@KƧ@G -@KƧ@8j@{qm@{=\@{qm@{l/Kñ@{qm@{hH@{qm@{q@{qm@{q(a@{qm@{uB@7@7wZ0@3|hr@3<@2KƧ@2@2(@2,$g/}@2(@2,@2(@2,gP)?}x@4; I^@3Ҷ}Vm@2KƧ@2C,zx@2xF^@2^+@2xF^@2hy=c@2xF^@2lC@8J?ε(C?ay?¾9?_ -?*8@8J?B֛?LA?σ&a?[ ?;|h@8p?5w?!?yD ?Qh@?HU@@@@$@*?????\@NbM@N`A8@NbM@N @NbM@Nёv@NbM@NГ:@NbM@Ntٻ@NbM@N@+@P`A@C@P`A@G1S@P`A@B#@P`A@9q:@P`A@AM@P`A@Iy@8qiC@8BZ@2-@1tj~@2kxF^@0Vl"@2kxF^@0T@2kxF^@0|hs?^*?fH?s?sNX?(Q!K?79?% ?^?ꁤ/?)`%;?GZ> -?XEM?ñ0h?ϧ7?? })\?6m? -.ԕ@@@@@,@&??????2vp?,<<?zti?v0Bd@wF@|o?øF?Hb(@or>O@zVt@b|t7@^@Õ%@x@Õ%@Y@Õ%@1@Õ%@`A7@Õ%@Mj@Õ%@hr!@ۥS@@ۥS@w@ۥS@~($@ۥS@(@ۥS@ߤ?@ۥS@?@5s@5@`@cl@cl@cl@cV@cl@cFs@cl@c?@cl@c|h@cl@c-@$/@7K@$/@ ě@$/@Xe@$/@Z@$/@J@$/@@2g l@2eO@1#@1O;@0Vu@0zG@0:,<@01A [@0:,<@00D@0:,<@01$/?OW?Qd?8AWdm?ׂa? -=p?4?;0? H?-hm7?vv? l?c5W?!?O?I/?O.ce?_խW?>LR_5?@@@@,@*???????_z?]_{#?b9v?Tbڄ @c f@ ?r ?cbK?WX"?t-bP־@sf@a@ć+ J@ćz@ć+ J@ć+ J@ć+ J@ćz@ć+ J@Ć@ć+ J@Ć]c@ć+ J@Ć@(\@)7Kƨ@(\@(TɆ@(\@(TɆ@(\@(TɆ@(\@)7Kƨ@(\@)rF@0qiC@0qiC@/.Vt@/.H@.E@.b@-uXy=@-uXy=@-uXy=@-u$0@-uXy=@-u\(?a(?m0?@? Y???bV,?&uE@?ܿ?/Z?%y*=?ȏ'T?b@?~('?2Y0?E 8?f_Ԋ?B @@@@@&@*??????> ?"{x? b?4b@ĆZs@(28?"Z ?(ij/?@ֿ9?Jsw`{@sE@b@M@M@M@>/}@M@֕@M@wzґ@M@Ҏ@M@@@@@IL@@5@@ke@@ @@S @2Y*0U2b@2Y&x@.-@. -W@-n@-,7.4@-b~@-< -!G?@-b~@-exb@-b~@-~le?ޖL I?+B?( '?r2?#h?ulP?r-?j?M?6ͧz?aE?~Ӏ?M"@r&x@pK:)@bM@R@bM@yXbN@bM@m(@bM@sE@bM@x4֡@bM@n.@9}:@6%?|h@50ěT@1{a@@4"`B@0ˬq @30U2a|@0Ae@30U2a|@0>@30U2a|@0;xF^?A[F?Z.?oԀ?CV?saS?G5v?UbB2?c?ZT?,?L7??ArU@?A ?yjk?(> ?;kr>?`i2@@@@@*@&?????? ?@?j6d(R ?Wa0@pN>&q@mh?M`?u-n@Rm?ևW@iq?@f@\@KƧ@\@@\@r @\@cA @\@ݗ@\@ݗ@Q@-V@Q@Q@Q@zR@Q@Q@Q@)_@Q@~($ @8@8VϪ@3+@3NT@3@`A7@3Aae@2\Q@2\1&@2\Q@2\@2\Q@2\64??d̺?&$#/??4f(R?I?UbB2??xrI??T ?u]?nW*؄?ey?!ϟۺ?r?a -?5|G?3?k!l@@@@@,@*??????i]synd?EQǓN?`Pw+@F@/R?`]d?}Z:[?$?q@n2Mx<@g@eE@evȴ9@eE.@eE.@eE.@eE.@eE.@%6E@%6E@%6E.@%6E.@%6E.@%6E.@%6E.@7~($@7x@4}hr .Mm@3Vu.Qn@3,<.NC,@3,<.NC,@3,<.NC,?3a=@8#@8:@8 >+@8I@8?3a=@8@8i@8@8S@8?T0@8 *@8p@8@8 @8 @?h@V@V@V@C^@V@@V@<@V@0U2a@V@E@!;dZ@! ě@!;dZ@!V@!;dZ@!@!;dZ@!X@!;dZ@!@!;dZ@!oiC@4[~($@4[S@2 ě@2- @1KƧ@1KƧ@1:,<@19Dg8~@1:,<@1;~%@1:,<@1/o?| ?d̺??TnE??oW?̉ߚ?|O?;N?ACO?>)!?x9l?ey?=Ca?>?9@0w?4i+?ymcw\?屘@@@@@(@ ???????BC9(TC?JW,JB7?Q+@@!3?i޴hjO?rlO?@?S -"j?t& -r$?b^?9f?3Z#m_?oWe?T(~@@$@(@&@8@6???????X0l?n}x2?%u (8?"[α@SW:@5vg?Doj+F?B [ώ?N\ ?B?,@fBs@j@!@" I^@!@9?@!@8?mE@!@$\{B@!@z% @!@D@j~#@qn@j~#@Ȋ@j~#@bjvxF@j~#@ǫl@j~#@gG@j~#@ȌKk@4]ce@4}"3@1ahr @1FSP@0Ͳ-V@0T@0_o @0Q,3@0_o @0@0_o @05"u\?gQ?Pٽ?6S\?hѺ?%/_[?FvS?~?J?3@$;??uri?/\??qn?2ѧ7?lmUA?!ýe?=CQ?g`O@@&@"@"@4@,??????uw?sp?r7?jd@D@ȁK>%?ߋs?>?|h[@ (U@V@bh@k@w@bM@w@p@w@N;6@w@񂩓 @w@͞@w@빌~'@Μ(@Λ"`@Μ(@ΝE@Μ(@Μ쿱@Μ(@Πě@Μ(@Ξm\@Μ(@Ξ#@6V,<@6X_F@1 I^@1#9@1ȓtj@1eO@15sh@14#@15sh@15\(@15sh@15`A7L?|O?I'?Z*C?%?y%?_ ? ?`?l%FZ?N?=W? Z?qn?3I#i?A'_^?9XNu? Ğ?$@@@@@*@$??????@Ox?M0?>S ?=8M<@r@Ν}y?_05D?^j7Ǫ?g@̨?ġ@g>s@l@?bM@?_vȳ@?bM@?a-w1@?bM@?^ߤ?@?bM@?Rs@?bM@?]ڹ@?bM@?X@Y+@Y+@Y+@W@Y+@R@Y+@YrGE9@Y+@U\)@Y+@TzG@7D@7!-w@2S@2b}@1Ƨ@1p:~@1iB@1qu!@1iB@1fB@1iB@1?ʎa]?'5?%HC=s?ghT?`FC:?$?qv?nr|?0?QĨ?=M?SS?l~J?t?^?3_?Kd\?r@@@@@,@(???????%;TR(?d.ů?B@?W bn@WcPw?|D+3`?] ?ymq?Z5ZJ@n/Ts,@m@@3333@@#)@@6/_@@!~@@щ7K@@(@vȴ9@vȴ9@vȴ9@ϕ@vȴ9@˒:)@vȴ9@VP2@vȴ9@]@vȴ9@֥t -@1[~($@1[Ƨī@0}hr @0}@@/x@/Ab|@/)_@/F.@/)_@/ Z[@/)_@/Q?^T?qy?8R~x?o$͠?!!.?nh&?bMn??1;?5' *x?-4B?bRuPL?bM]f?Y?T.g?vs{?_=D?2ˁU@@*@,@(@4@2??????OQF6*??w(?3+@#@?N^k?B(t[?=`?|ˍ@sF@n@%`A7@u@%`A7@*W@%`A7@%@%`A7@$Z@%`A7@& (@%`A7@$?@IzG@Ie`A7@IzG@I{6@IzG@Iz2@IzG@IxQ@IzG@I}p -@IzG@I{m@7 xF@7I@2+ I@2F]c@2`A@2,<@1\Q@1^p:~@1\Q@1]K]@1\Q@1\]ce?[_g? e?=?Kh?|*(?R%(0?uu?b?bH=?s8r?-I`K?|+~?m/w?=d?ʳ_?cӗ1?&I?A0)n@@@@@@???????:}h8?e"2?]JvT?YB=H@$m@Iz}=x?kC=?k^6YV?˷g -?oF>7@r-b@o@["`@[lE@["`@Zv@["`@TɅo@["`@Wr@["`@XQ@["`@W1@ -=@`A@ -=@2@ -=@ݗ,@ -=@-V@ -=@<@ -=@- @5H@5!R<@2S@2?@2-V@2Fs@2(@2*d7@2(@2-w1@2(@2+s?|O?: ? -tI?q@v?_dA?Dw?1j?$i %h?$Jw"?G>G?n ?yC?֘>D?Ov_ح?hE?=aw%?C SG?wͶ@@@@@*@&??????Q2n4<`?+ARG*T??dY.V@Y(@WP]?Kz[/?`?×:P?[Kl@ff[@p@&ffff@Lƫ!@&ffff@;@&ffff@3fO@&ffff@0@&ffff@x@&ffff@V#@N+@v N@N+@©Er@N+@´{@N+@WWO]<@N+@†]@N+@š@7+s@7( @4S@4Z΢PU@4t@4\"8l@3ce@3@3ce@3L|U@3ce@3ٸ?U?k'?_4?˸M?aE=?83@??1F#?G}?WL*?8J?zwv?hTGb*?7J]92?*}&S@ϕG.A@ѡ?W)mû?J_!?$h7\?fհ -@@fau@r@Vt@V$/@Vt@V+l@Vt@VڹY@Vt@V @Vt@VK_@Vt@VM:@uM@uM@uM@ub}@uM@v -E@uM@vMj@uM@v(9X@uM@v:)z@5@5}Vm@1@1n@1PA7K@17eں@1 -0U2a|@09@1 -0U2a|@0s@1 -0U2a|@0?| ?Be?C1?~L?;V?Dr? ?NH?Si܃?%W? -HQj?ѪC#??}(2?\{?fr[?? )D)?^_r@@@@@,@&???????fp?=1?p K?eOA@Vy@u?~!|_?u?@0?ňR\?Dc@\e_@s@Z1@_vȴ@Z1@TɅp@Z1@z@Z1@%@Z1@<[@Z1@Ca@N@\@)\@\@JM@\@C^@\@ⶮ}V@\@+@\@@8>6z@8ƕe.@4+ I@4JL@397KƧ@3&@3QiB@33tj~@3QiB@3BT=@3QiB@3>2X?wogl?g?w?8 Y?ܡ?VAg?(l_?,4,`?/?۔Y?T=U?2R2'֕?{Qy?=X?L?׿l?d7?W@@@@@3@&??????koK*jB?j/-:?z;A@K^pB@+?}[͊L?:T?_Z%ES?z@p2@t@?|.@?|@!|4b@?|@@?|@ @?|@E@?|@^0AJ@rr-V.@rr-V@r~XP@rr-V@r^#S@rr-V@re m@rr-V@rFx @rr-V@r8SM@8YJ.>@4^+@45@㳃@3Ƨ@3Bմn@2&@2֠[@2&@2Țԫ@2&@2 7@8J? /¹|?y2??V2?|۷t@8J?\pe -?7 OW?!Z ?mC?4@8p?leϞ$?pu?Gyt?m\?4@@@@4@3?????u@TO;d@T\@TO;d@T8@TO;d@TV@TO;d@T@TO;d@T'0@TO;d@T @;dZ@/@;dZ@@;dZ@U=@;dZ@b}@;dZ@@;dZ@ܹ#@7}:@7z)y@0J^5?|@0J6C@.NO;@.Nqi@,V@,V}Vl@,V@,Usg@,V@,UY|?1j?$?>f? Y?'`?PN ? ??b/bJ? -t@@@@@(@$???????@_{Y;r?Cͳ;h%?0CC@T\@kP?cB)?P"?B?Hax2?N+@gjE@v@4ȴ9X@5C@4ȴ9X@5y=@4ȴ9X@4-@4ȴ9X@5'R@4ȴ9X@5O @4ȴ9X@5 -#9@ @E`A8@ @1[W>@ @8Q@ @*W@ @ȴ9X@ @u%F @7>6z@7E@3\I^5?@3PH@2gKƧ@26l!.@1YJ@1^@1YJ@2[6@1YJ@2tSN?5u[E?5O}?bY?C: -??LTk?9?U -?00?}M ?7&c?T? M?ְ\Wg?(p@v?A\#?kR?4?\O:@@@@@,@*??????jg-C@?qy?b@5+*@c[?υ%?e?%Z"Y? -RRC@r;X@w@mo.@mo@b̥zxl@mo.@mo@i"@mo.@mo@ihۋ@OY+.@OY+@R ě@OY+.@OY+@G\(Ž@OY+.@OY+@I-(@8g l.>@4ԛS@1y -@3-.Qn@3@11R@3.NC,@3@1 ߤ@@8J?.q@8:?u86@8I?UzW@8J?7*@8i?ٹN@8S?|pUw@8p?܉a^@8p?a@8 ?馪C@@@*???x@"`@^5?~@"`@Q@"`@A@"`@E@"`@e+@"`@E@";dZ@"G@";dZ@"K^@";dZ@"@";dZ@"W@";dZ@"Z @";dZ@"$ x@8(YJ@8,#x@3hr @3!R@3Vu@3֡a@3n_o @3g_o@3n_o @3iԕ*@3n_o @3kW>6z?K{O?I'?~#?avfV?҇?Oh6c?4\ɵ@@@@@*@*??????)pp,?Qpm?Ig}'@ke A@"Ʋ~b?i?o[Xh?y?@k^>@y@F@'lC@F.@F.@F.@F.@F.@ -=p@ 7Kƨ@ -=p.@ -=p.@ -=p.@ -=p.@ -=p.@7~($@7l?@3=hr .Mm@2y7KƧ.Qn@1ٌ~($ .NC,@1ٌ~($ .NC,@1ٌ~($ .NC,?Z@8#@8:@8 >+@8I@8?Z@8@8i@8@8S@8?A@8 *@8p@8@8 @8 @?z@@+@@ZP@@@@[(@@ӹ@@@`A7L@`A7L@`A7L@_;H@`A7L@^Km+@`A7L@^5*@`A7L@ate@`A7L@_2@2쿱[X@2(LW@/{"`A@/x- @.&x@.ag@-PH@-˰@-PH@-f},GT@-PH@-?^6P??(uH??7p?U@Z?bMn? ??-F|? w!H?Ju?7݉?ۻ~r?UA|?LV#7?ܐ?|@@@ @"@4@(??????R,1(?Gf1?9Ɔ?JXg9,@h^@_}5?HX^?YT?߳ ?3w@s @{@`RnP@`B`C@`RnP@`$tS@`RnP@_5?|@`RnP@`W>6@`RnP@`p ->@`RnP@`1&x@Kx@KnP@Kx@Ku@Kx@K -=@Kx@Lt@Kx@K%@Kx@Le@9 _o@9IQ@45?|@4° ě@4-V@4S@3sh@31&x@3sh@38bM@3sh@31N;5?A[F?d`w?~? ѷ?ʫ[?$q ?,e?wi*? %a?c(&?Ӓ ?xF?ɦvY?k2m? n?Oh6c@@@@@*@(??????o!ua{K?c89?tr@.zY@e>??}/K?2*vb?ޏ"ӱ@mUw@k9@@}@1&y.@1&y@G @1&y@8992@1&y@E"y@1&y@\S@1&y@{@|`B.@|`B@|ZlH@|`B@|t@|`B@|e@|`B@|2@|`B@&b@9p4m8.>@3^5?|@3vƆ&@2tj@2$6@2Q@1Fs@2Q@2 @2Q@3)x@8J?c~V?T?vS }?QWb(?6@8J?>uN? u}?ժQ?h["?WuFY@8p?8)s?[?Ydz?9O?SL鴈@"@*@$@8@1?????~@4j~@]p @4j~@ -=p@4j~@L_@4j~@GE86@4j~.@4j~.@C@ 1&@C@=K@C@ȴ9X@C@S@C.@C.@8쿱[X@8%$/@5S@5C\@5`A@5-w1@50@5F-@50.NC,@50.NC,?W&l? ?Ȅ 2 ?X}v@8I@8?ʻd9\?ߤ -B?ǿ?I @8S@8?Wu?#?fg?兯@8 @8 @@@@????@[@[o\(@[.@[.@[.@[.@[.@1^5?}@1@1^5?}.@1^5?}.@1^5?}.@1^5?}.@1^5?}.@92@92ѷ@5 ě.Mm@4K"`B.Qn@3𖻘.NC,@3𖻘.NC,@3𖻘.NC,?g;+t@8#@8:@8 >+@8I@8?3a=@8@8i@8@8S@8?yMa@8 *@8p@8@8 @8 @?@?|h@c -=r@?|h@L~($ -@?|h@B\(@?|h@Q@?|h@b^@Lχ @+@8I@8?k|jʨ@8@8i@8@8S@8?7V/r@8 *@8p@8@8 @8 @?@?]-V@?]E@?]-V@?[J#9@?]-V@?]Vl@?]-V@?an.@?]-V@?cA ]@?]-V@?`ě@8@8@8@8Q@8@:^5?}@8@=cA@8@:G@8@8-@5qiC@5q @3Y^5?}@3]ce@34tj@3;jf@2‚@5@21@2‚@5@2zxl"h@2‚@5@2ƚ,B@-.zH@--qu@Jo@Jo@Jo@IQ@Jo@J0@Jo@IDg8@Jo@K I@Jo@JJM@3T xF@3T2W@0\I^5@@0\64@/@/TɆ@.@. @.@.vȴ:@.@.?]?%ñ?7[䭝?ݶ\r? g?t?]?CO?DP?e[|(?qN?wN z_?*wjs??YF? ??a+?pk Y?@@@@,@*??????F6۸??d>R?26*&?::g-@--v@J$?A {?HuV?~'06?E1 @s[ PM@@+ @=\@+ @ē@+ @ yԑ@+ @ ɿ@+ @ 7N8@+ @ @bfffff@bFFK=@bfffff@bn@bfffff@bw@bfffff@bns@bfffff@boֲ@bfffff@bs3*/@8H@8ߌ@4+ J@4f@3"`@3Ǟe@3Eu@3@Z8@3Eu@390N@3Eu@3C*?7Yu?n˚@?U۳??Iߏ?Hۂ?En)v?g([Q?8>?-IS?p".?H, -kc? Qж?!?+?gҤ?^ r?5@@"@"@ @.@.???????3_?z+?^[fs+?jo'~9@ [a@bl?lw@lb?{5 F?~^>?-,) -@p`@@́$/@̃W- @́$/@̗Zn@́$/@̆WQ@́$/@̄|@́$/@̄WY @́$/@̄kGih@9z@9L@9z@9@9z@9&u@9z@9p:@9z@9v,@9z@9{GKr@67@@661.@1TS@1Ri@0~"@0ڛQr@0^6z@0]|Y@0^6z@0Ze@0^6z@0Yyp.f?3<' ?^-' -p?Jv?pCza?s޼M?Q^ ?|B &?M6G-\?'??g$%?)?X?p풟?J8?1u? ?}b38/?*%@@"@ @$@4@6???????Twg kp>6Fq )?Um=@̄@9F?>?)?v&aq>P@4sS.Mm@3b-V.Qn@2𖻘.NC,@2𖻘.NC,@2𖻘.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @'-@'j@@'-@7D2@'-@3fc@'-@7/ڏ@'-@2=E@'-@4C@+ @@`E@+ @s.@+ @͙b@+ @@+ @ 5@+ @y5@6^H@6]Yr@2S@2 - @1t@1H{m@16z@1uْ@16z@1ID!@16z@1L7?~Ov_ح?@HM?Z ?ib? U?;Xd?3<' ?Nnu>?iI?NsC)f"?;5L?%O)?kOv ?Lΰ?4K ?ha6?-|Q?_&@@*@*@,@8@9???????jf"ccC J?Rs5?Hč6@.`/@{?rf~?h+=ߓ?y?/r=2@g\hM@@9XbN@1@9XbN@=b@9XbN@8y=@9XbN@:S@9XbN@5sh@9XbN@2T`e@}p -@}-V@}p -@|1'@}p -@}cA@}p -@@}p -@~%@}p -@~ߤ?@7v@7@3hr@3BZc@3W-@3Yԕ*@2h@2k I^@2h@2t*1@2h@2r74?h??gUq#?BI{?=]. ?N?ʗAm?F/P5? l?B<\v?ռ2?k}X??O:b@?6h?"0?0N:s?< N ?r?ۂ@@@@@,@*???????A=?>L?Zue_?AW@6^Ø@ڑ?u|xG{"?cCӑ? ](?<<@iOr@@bM@_|h@bM@gE84@bM@mjN@bM@kP|@bM@a@bM@ce@ ě@zH@ ě@'/@ ě@Q@ ě@<@ ě@1@ ě@"h @72@76+jg@3E?|h@3Doh@3`A7@3D@20@2..2@20@20:~@20@2/ ?|O? e?K]4?lׁ?|?4 ?| ?PuN?qN?# Y?2}?EȀ?H6?*J?OW?sMQ(?,BZ@3n_o @3ca@O?)T?q?\H{gX?zb61?xs?u}I?|O?u(?9]t`? -Ǘ??*%>g?-BR1?k~?7}?=2V?:/ʼn?{=rK@@@@@*@"???????;]?yW?8Y̗?SlTy( {@,@ڝzd?X$!(?sFGs?B?u@fAZ@@жȴ9X@з -=p@жȴ9X@з+j@жȴ9X@иYJ@жȴ9X@лlD@жȴ9X@и@жȴ9X@иA@`A@`A@`A@\(@`A@!R@`A@_o @`A@'/@`A@Ϫ͞@2%!.@2&1.@-3tj~@-2p:@,wO;d@,uXy=@,=Vl"@,7+j@,=Vl"@,8*@,=Vl"@,8e+?^Dw'?[evȴ9@9cg l.>@3° ě.Mm@3`A.Qn@2ce.NC,@2ce.NC,@2ce@2Zc@8J@8#@8:@8 >+@8I?G!r̟Y@8J@8@8i@8@8S?(/氜@8p@8 *@8p@8@8 ?vۋ7@$?@ZS.@ZS@Z qw@ZS@Zڹ@ZS@Zڹ@ZS@Z~@ZS@ZJ#9@.@@e+@@PH@@lD@@u"@@N<@9,<.>@2f+ J@2b`A@0KƧ@0E@/N;6@/_o @/N;6@/;5Y@/N;6@/ΤT@8J?&?y]?Њ?u?i{@8J?0?ދ"?)@a,?O ?m/w<@8p?c I??Ol?+ ?L?@@@@&@*?????@-V@ -=@-V@RT`@-V@o@-V@(\@-V.@-V.@3NV@3A7K@3NV@2u=@3NV@16@3NV@2@3NV.@3NV.@8 ]ce@8@5S@4?@5~"@4Swk@4\Q@4 ]ce@4\Q.NC,@4\Q.NC,?]?L0?Gt ?N.!b@8I@8?]?-',?C=?«{T@8S@8?*wjs?Iݷ?~WC #?8|7@8 @8 ?@@@????@xS@xG@xS@xM@xS@xn.@xS@x7@xS@xRT`@xS@x\@Q@S@Q@hی@Q@{J#;@Q@u%F@Q@N;@Q@ڹ@8 _o@8 x@4?|h@4 -L/@37KƧ@3qu!@3Q@3 qv@3Q@3m@3Q@3@?Y͍_?L?Y#W]?{y6?(E?o:?)T?-c?_x2?Ti?{QB?s?T?їJ?r20/?42?z"+;?6@@@@@*@,???????g@fY?H+4?Teo-/@xHb@u@ƅ?e,?sr=?L kg?@eHl%@@#F@#Y@#F@#2@#F@#BZ@#F@#)ߏZ@#F@#Xgr @#F@#L]-@cS@_q@cS@r@cS@lEn,@cS@mt@cS@3L@cS@'=/@7zqiC@7jhŹ@4S@4\@4KƧ@4FP@46z@4U@46z@4@46z@4Cŧ?3?mg{?4?:G?珗?0;W;?D?h b??xP?=NB?z=?|(?A6PP 4??$Ec?,?0W} ?`P@@@@@0@&??????{ӣ*N0?Ak?t^@#Q/L+@C?87t?Yg_@,p~@(Qc@n/[ɂt@@Q@Q@Q@Q@Q@@Q@ȴ9X@Q@&@Q@tj@ȴ9X@x@ȴ9X@\@ȴ9X@k@ȴ9X@fffg@ȴ9X@@ȴ9X@v_خ@1g l@1ѷ@-R-V@-MC\@-O;d@--@,C\@,ѷ@,C\@,+j@,C\@,b?^Q5P?`?jhq9?1?K/?)?b? aҹz?T֩E? ?I?p0=-#?:)y?§d߱?{W?!B? Ğ?a@@@@@(@&??????\4?p#T?CG~0?Ca5((2@ۛr@kz?QxmA?Rh#?Vj ? _/@q@@hr@V@hr@ -=@hr@`d@hr@ @hr@iC@hr@p;@cvȴ9@cQ@cvȴ9@d@cvȴ9@d'@cvȴ9@dn@cvȴ9@dA7L@cvȴ9@d}V@5I_o@5I"`@1#@1 4m@0-V@0t@/C\@/@/C\@/@/C\@/&IS?}ѿ,?ߋb?,fC6?̒?2{w?|&?1j?,#?kE<%?N?e?6@(/?2Y0?Ϸ+? J?^ a?L8AS?`i2@@@@@*@*???????V?JX?;?:RḼ@ @d -?Z,:J?Yh ?vחM?Kgbt@eܕz@@Q.@Q@l-@Q@O@Q@ ?ɩ@Q@@Q@@RBM@O;dZ.@O;dZ@di@O;dZ@h8@O;dZ@xU@O;dZ@tY-@O;dZ@k@5>6z.>@/A7K@/@6@-1&x@-jL]@+-w1@+v@+-w1@+Ma@+-w1@++@8J?i[?% -s?V&s?mwH+?Hy@8J?dJH?q ,?yp?TV(?w x@8p?'M?P -gN?Jj?*l?.V@*@$@@;@8?????@lC@l@lC@jڹZ@lC@gK]@lC@ce@lC@eҩ?@lC@^=/@?|@\)@?|@@?|@y@?|@"_@?|@Ah@?|@]`UH@4g l@4#i@2Y^5?}@2U!.@17KƧ@1@1@1#w@1@1#p@1@1^gƒ?_Kt?m?UD?7ly\?TFEQ?' e?|b@?u߿?Bx?Ti?@0?־?Rۙ?GA?_?e?YfӶ -?z{@@@@@.@.??????ewjHSn1F?AtAEH?i>w@g ,5@G-_?a=_g?7R?xuq@ګ@fp]@@@Q@@҈o@@5X@@tj@@ @@m\@ O;d@Xtj@ O;d@T@ O;d@@ O;d@m@ O;d@@ O;d@J@8H@8hۋ@4 I^@46@497KƧ@4;Ƨ@3u@3ś=L@3u@3\)@3u@3@?G *ǂ?!}P?tZ'?.[?(i^?@*F?N?.Hp?]^߿?̶j?5D?7&T+?oh56?~tZE?tgi?a?{%? (0Q@@@@@*@(???????ߡpz?`_O\?qv\-2@o'!@?xny? Tl?ds?i D@r @@c -=q@c6"@V@c -=q@MeO@c -=q@\IH@c -=q@V8@c -=q@HtL@c -=q@N[@Ё$/@t~k~@Ё$/@fl@Ё$/@ЍO@Ё$/@k^@Ё$/@n @Ё$/@k?گ@8YJ@8t W@4!hr @4*e@3)"`@3*WE?;@2m8@2@2m8@2 -@2m8@2׆n5?I'%?7?<?/ J3?F_W?<1 v?\l6?J®?|e?1qH:?@I?^d?|3?w43?`@ln;@8$ޤz!?ؾ>p֏)?1=V>A@sQ @@K Ĝ@K W@K Ĝ@K@K Ĝ@KD@K Ĝ@Kط@K Ĝ@K@K Ĝ@K^ɍ@[-@[`A6@[-@[M/@[-@[S@[-@[+b@[-@[@[-@[y@6!.@6̭dJ@2hr @2C(a@2W-@2X˵ag@1z,<@1|T©@1z,<@1|۹L@1z,<@1|H?anñ?D?a?%9bg?VQhFa?/k`?nDyB?ߋ?:d&?ِ:Q?Msy?y[?92j? ?DW4L?Ҳ?̴N?%@@&@*@,@5@5??????-X@?{@MJo@M?j@MJo@MM@MJo@MR4@MJo@MV/ +@MJo@MR@8įO M@8.ma@3G+@3:Ov`@2~"@2: -m@1䎊r@1T E@1䎊r@1l%@1䎊r@1M?}Jh~9Z? 4??j:?Kw~u=@@$@*@$@<@;???????N7?^i?P{m?Pm垸@$ @MQ瀛?` 3u?hӍ2E?bp?= 3h,@p5Rh@@څQ@ڄt@څQ@چA@څQ@ڃZ@څQ@چ&@څQ@~@څQ@ڀ k@nE@n1@nE@nC-@nE@n?@nE@n~($@nE@n#@nE@n5X@7p4m8@7p)^@3 I^@35Xy@3Ctj~@3De@2sh@24m@2sh@2=L@2sh@2 '?sD? ?^RpX?@R?z|?~?%?ā?Z??Ll? ?ArU@?<{?E?C?l?x[:@@@@@,@(??????J;P?BB?O}E t?=25U@ڂN@nm?o v?VPrJ?جf7?"pZwA@m32ZQ;@@lC@+ K@lC@.@lC@Dg8@lC@ ԕ@lC@ffff@lC@&@Bȴ9X@B+ @Bȴ9X@B'@Bȴ9X@B$tS@Bȴ9X@B$@Bȴ9X@B1@Bȴ9X@B@3v@3@0#@0#E@/E@/@/b~@/PH@/b~@/ k@/b~@/F?|O??ցC ?N?_?Dj?-/ge?|O?)[D?*|\/?ܑ ?f_Ԋ@@@@@,@,?????? |ӳ?|?%&?$c)i@#Hr?@B\?EuAn?D7ZB?!%tc?=DX`@f3@@W ě@W@W ě@WH@W ě@WU2a|@W ě@W.@W ě@Whr!@W ě@W\(@ -=p@ۥS@ -=p@"@ -=p@1@ -=p@ݥ@ -=p@,<@ -=p@+@8~($@8Q @28r Ĝ@25?@1U`A7L@1P@0fYJ@0a$/@0fYJ@0a [6@0fYJ@0aX?W$B?M?GM?gk\0?W?f]G? ?-',?I?= 6?5D?U3p?:%?u/X?m!?0? -t?|)-}(@@@@@,@$???????7[E7m ?V]?5gD@WdP6@ڦ??l=I 6?]5?+e ^? r@o=@@(\@(\@(\@)ԕ,@(\@*qi@(\@)*0U2@(\@'_o@(\@($ x@+-V@+-V@+-V@+-V@+-V@+{@+-V@+D@+-V@+񂩓 @+-V@+n@3֚,<@3֚,<@1S@1֡a@06-@06+ J@.L/{K@.zxl"g@.L/{K@.8YK@.L/{K@.8YJ?| ?Kb?tcj?lDžN9?~|+?t?| ?Q_ڸFN?ދ"?@[*^? ^??sx/T? J?򯞼? SF???j@@@@@*@*??????*fS &?#}92?06@(ы@+B?C]ݷ??8!?`>;/?/HW@f%t@@)x@-V@)x@G@)x@z@)x@E@)x@@)x@ě@ I^@G{@ I^@z^5?~@ I^@<ߤ@ I^@$/@ I^@.@ I^@H˒:@6O M@6Fs@4kS@4?ә~$?W ę\?,|?Aź? @@@?@0@(??????՜@v=?]ںj?4-"4m@@FUz?svO?K.,?)Ba?Aby@^^8@@=E@<1'@=E@BZc @=E@>@=E@<Q@=E@A'@=E@En@IdZ@Ifffff@IdZ@Ibu%F @IdZ@I^Q@IdZ@IeO@IdZ@Ia [@IdZ@I`hۋ@5e!.@5bѷ@2 ě@2v@2Vu@2H@2B@5@2Htj@2B@5@2CnP@2B@5@2@[6?2}?j`cq?b?,Z?bJֵ?>V$?Ol?o ?}7.?.}$?Ll?^̀@!?DU#L?.]L?LO?sO>?q' -B?Xk-7@@@@@,@*???????RSf`RV?Fp7?7r{3@>@Id@ܼ?enh?V*>W?S6?@pM(@f:p@@I^5?@Nf~6@I^5?@JV|P@I^5?@JgD]2@I^5?@Jʣ%@I^5?@HV -@I^5?@H}@I@@I8>Z@I@@I;g@I@@I=@I@@I?q@I@@I?^ie@I@@I>3@4qiC@4oԢN@1+ I@14@04tj@03F&@0&YJ@0%ȓ쿊@0&YJ@0&=Hk@0&YJ@0&Q?ɱb)Q?݁;D?lȼ?J_?T?;G 1?I'%?bR?%f[?Lo2?t ?lCY?As $?׫}F?׳S\?h?=?*@@ @ @*@8@2??????V&$?Q)DYN?.pPn?Fp 2j@Jh#P@I>/A8R?I(?aU^%d?*/s?챝@mk@@5-@5hr @5-@5sh@5-@5*0@5-@5ح@5-@5?@5-@5@`A@-@`A@ - @`A@tj@`A@+@`A@Hˑ@`A@~@6#g l@6#33333@40ěT@4+m]@3-V@3`A7L@33&@3 ԕ+@33&@3H˒:@33&@3!-?F/P5?Fp3?=?Kh?niʢ?Vs?h%?Y͍_?*1 V?|ɽ?9.?pc?:;{?D(o? F2?aI*?y\,?,Ro?9@@@@@*@&??????pO?aF?Qaܪc?R 8a^@5t@Kz?pP*\,?r3Uv?ӥ= ?ӻ6ݣ@ez@@)`A7L@)a'녞@)`A7L.@)`A7L.@)`A7L.@)`A7L.@)`A7L.@w߾vȴ@w;6@w߾vȴ.@w߾vȴ.@w߾vȴ.@w߾vȴ.@w߾vȴ.@7s@7<쿲@3.Mm@2"`.Qn@1ce.NC,@1ce.NC,@1ce.NC,?"@8#@8:@8 >+@8I@8?|ǵ9@8@8i@8@8S@8?z&F@8 *@8p@8@8 @8 @?@N+@0`A@N+@R@N+@Kq @N+@Mw1@N+@K~(@N+@Lq @Bu@B\*@Bu@Bxl"h@Bu@B@Bu@Bu!@Bu@B<6@Bu@B@9#g l@9 m]@3{ I^@3|I^5?@2{Ƨ@2ylD@1YJ@1'RT`@1YJ@1:@1YJ@1TɅp?us\?܄ (?5$?S;~?i]i?VFNLG?\ OZ?Èa?pI??#:d ?T?P(?n?U.?z_? Y??vucʲ@@@@@,@(???????x[׮?YZHu+?byZ?~~Pj@K1xD@BS4?Nxb?L'?z\?68^@rw@@F@b@F@duE@F@-#N@F@Ԗ9@0@F@@F@ϔ@n\)@nO;@n\)@n (r@n\)@ne>@n\)@nꐃ@n\)@nl@n\)@nŜ}@5@@5P(@1sS@1n+d@0_-V@0^k+@/L/{K@/W<@/L/{K@/G(@/L/{K@/y?| V?2x? -HO? T!?/+I?fq\?_Kt?5]g?w9L?]]?M?,?w{??8K6?J™a7?ˌ?' Z@@"@@(@:@8???????0xHXD0?6ws??#%>3@v@nX?W6hz?_y1Y?p?|b|@hwu@@gO;dZ@gP -=@gO;dZ@gPy @gO;dZ@gP)'@gO;dZ@gPﲫ@gO;dZ@gO.֧@gO;dZ@gOzc@=hr!@=@=hr!@=$ @=hr!@=[SJ@=hr!@=]U\@=hr!@=G3Q@=hr!@=q@3qiC@3ha:z@+A7K@+0"@)@)KXP@gP Y:@=u1?=RjO?eZ?>R?<+59F@g@@cn@cě@cn@c[7@cn@chۋ@cn@c @cn@b6z@cn@c[6@vȴ@5?|@vȴ@@vȴ@%@vȴ@@vȴ@6z@vȴ@U=@4 ]ce@4 -S&@0|hr@0v_ح@0-V@0͞@/@/\N<@/@/.H@/@/vȴ9W?2}?Čۨ1A?$C@?ƠJ-M?5 g?CXs?}ѿ,?u߿?O(?Hn?77? f?z_?l?qn?!ˠ*(?gϵ?fW@@@@@*@*??????G;z?Q?;Bk?)Y F@cw<@\?Zնͻ?JM?rw9q?R*@g0`@@t.@t.@t.@t.@t.@t.@ -=.@ -=.@ -=.@ -=.@ -=.@ -=.@8쿱[X.>@4I^5?.Mm@3"-V.Qn@3~($ .NC,@3~($ .NC,@3~($ .NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @"@"@"@҈p@"@]cg@"@64@"@u@"@@Vu@VE@Vu@Rs@Vu@Sg@Vu@V}Vm@Vu@SE@Vu@OA@4}:@4|Z@1S@1a|Q@1-@1rH@0O M@0hۋ@0O M@0\@0O M@0Q?| ? ?zkr-?5~pY5?Xs~?#{׈?1j?4 "?c#$?ą6 -?SY?^?@A?l?`x?ȏG?ĭ?{2@@@@@,@(???????G;SxPa+4?M\?@5q@q@M@Tl[}@2tj@2:6@1䎊r@1KV@1䎊r@1+/i@1䎊r@1<'??| V?e?]R?T'?$cCy?w -?}#?hS?83_K?[l7? T?s;?+Z?ɑ6?c: -{?TJ?VZ?}@@$@ @$@1@4???????)8G6s?Q^#A?*B@؟b@n?q}M'Mq?Jfp|?ߝ??s@fLe@@y"@y@y"@{:@y"@xwP@y"@m&@y"@Dk@y"@}b@'-@'RT`@'-@;I@'-@3GO_@'-@/H@'-@+@'-@,^ @5@5.h"@2 I^@2{Z@2)"`@2,,RZ|@1a:S@1fA+@1a:S@1d[Hh@1a:S@1dS9=?~?J?38o?>q?2M7@|@*s?^z3$Y?Rńg?E{j?@g{l@@+R@/-@+R@a.H@+R@Q4K@+R@H\@+R@90 @+R@> (@1@׍O;@1@W@1@}@1@ (@1@ө*0V@1@\@3`D@3Zu%F -@0O|hr@03@/;dZ@/!@.-C\@-rGE9@.-C\@. ᰉ(@.-C\@.ѷ?| ?o|Z[?@?4?di? d?| ?{6?Ēۇ?%i[>?.<?Y@?]?ir?Ͱ{?a ? Ğ?t@@@@@,@*???????fn\O?CbkQkL?Ss@5v@+?cmo?t>12?ϵЛ.k?WEn_K@e6,@@cS@cS@cS@c<@cS@c7LG@cS@d@cS@a"@cS@aP:w@m@m@m@x@m@ ?2@m@\@m@$$@m@<0z@4~($@4$@1TS@1Uc_:@0Vu@0AH@0@4@0q|@0@4@0E -@0@4@0pJ?}@TΥ?19?);`?.?Cju?0_x?|h2:?ͣ?nJd?;4?2rtf?z(-%?n3?!??V,?jGr?~3F@@(@ @&@3@3??????+#;)*~@?3DM@? 0V@c@S9t -?S`f?A1g7ml?pQZ+? \{|@f`^@@J=p@#n@J=p@f@J=p@ -=p@J=p@#{J#:@J=p@;dZ@J=p@@/-@33333@/-@)^@/-@\)@/-@ :)@/-@.H@/-@[W>@8D@8C%@4I^5?@5u%F -@3A7K@4W@@2O M@3X1&x@2O M@2l!.@2O M@2 wkP?Q,Ě?(x~?azL&{?lmĎA?W?>ԛ?Br?=ʄ?X43}?_@@@@@,@*??????~*l?fEz tg?#'@@?V?8?גuȧ&@6 zͯ@qF=r @@^5?}@ cg@^5?}.@^5?}.@^5?}.@^5?}.@^5?}.@V@C@V.@V.@V.@V.@V.@804m8@80 - !@5?|h.Mm@47KƧ.Qn@4u.NC,@4u.NC,@4u.NC,?-,@8#@8:@8 >+@8I@8?uq@8@8i@8@8S@8?NN@8 *@8p@8@8 @8 @?@B\(@L1&@B\(@=@B\(@A|P@B\(@OiDg8@B\(@CF]d@B\(@H9X@\(@`A7@\(@_@\(@@\(@f@\(@)^@\(@y|@9Y*0U2b@9O@5ٺ^5?}@53@5M-V@5T?@5m8@5%=L@5m8@5eں@5m8@5\N?>sN?/>?'Qt?~???n?NIɮ?аl?5U??_Q -?k?mֿtE?nO?4y?Dۖ?7r_?24 -@@@@@&@"??????P(XN ɔ?U?kj.@I@U@&O?s 5ӰD?>|?V&Sn?b?ݽb@n\C@@1@*@1@1g$@1@(@1@#M@1@A@1@Ԏ@ 7Kƨ@@ 7Kƨ@@ 7Kƨ@h*@ 7Kƨ@ -[@ 7Kƨ@۰#@ 7Kƨ@jP0@8D@8>6z@3R I^5@3R*2@2tj@2H:+h@2fYJ@2cr־@2fYJ@2bհ߻@2fYJ@2c$?d?C7j?r8?% ?$Q?R?:Ƶ?bz2?Jz*(`A?$ H*?cP{(?` ?,`I?f?[edWR?|B6g?1xk?RR@@*@$@,@<@6???????˻̀?K/?biLR?XK_@zp@@?%~-M;?n Es@b2G?b[@ob(@@-V@([@-V@,/{J@-V@0)^@-V@*W@-V@+ I@-V@-:@hs@lD@hs@C\@hs@_p@hs@3333@hs@*0@hs@KƧ@7}:@7u%F -@3n5?|@3nH@2`A@21@2~($ @2q @2~($ @2A@2~($ @2a@?)T?vucʲ?M?Z)?i]i?U6@HS@H1'@HS@HPH@HS@H1'@HS@Hp -@6:@6@2&+ J@2'sPH@1`A7L@1֚,<@0O M@0 ě@0O M@0α2X@0O M@0;5Y?1j??ցC ?&t?$?bb<]?Id?=?<ظ??ʾ?ZX?-@@*@*@*@9@3??????'ڶ@?ȁ](?Y@ -&@^b@[?3KOح??1s?u%?}_%@f/M@@*~#@*~$@*~#@,1&@*~#@+:)@*~#@+C@*~#@)@*~#@)7Kƨ@-V@nP@-V@볶E@-V@T`e@-V@Z@-V@벣S&@-V@벽<6@1cg l@1cg l@0+@0&@.1&@.Q@/@/Ov_@/@/Ձ$1@/@/_ح?^XN?ƿ57?WD@?ݶ\r?E@?+ʦ_?bV,?NۈV(?^ o?Y?qN?wN z_?b@?˛͇q?m+&?!ˠ*(?b/bJ?L@@@@@,@*??????T01$y?>D,?!W"2@*Bj.@z?M-K\@?0jK'?K3 ?W5-勇@s~R@@hI7Kƨ@hH\@hI7Kƨ@hOO M@hI7Kƨ@hO4֡b@hI7Kƨ@hMU@hI7Kƨ@hJf@hI7Kƨ@hK]c@Zv@ZG@Zv@X74@Zv@X*0@Zv@Zxl"h@Zv@WXf@Zv@X}H@4~($@4)^@0@0@0W-@0VE@/#9@/A@/#9@/p:@/#9@/@?|O?Z? ?̒?ǹT?F0?|O?4 "?pM?@[*^?A B{? R?>Zw~?vv?6~A?I?0&YEd?$@@@@@@(???????FM1XDT<?=_?+@hJب@Yv?]|?LViS?\Ɲ?w7z@fp@@qZ1@qY@qZ1@q^҈p@qZ1@q]Vl@qZ1@q`@qZ1@q]@qZ1@qcn.@1&@\(@1&@jg@1&@@1&@~"@1&@@1&@_@6@@6@3r Ĝ@3g @3>Vu@3D,<@3OO M@3D7@3OO M@3S9@3OO M@3M,P?)>PJ@"@6G ?8? -A?n ?Xi6S@s Or@@?|@m@?|@}H@?|@@?|@+j@?|@e-@?|@4m@ovȴ9X@os@ovȴ9X@ovFs@ovȴ9X@o|hs@ovȴ9X@o~Ov_@ovȴ9X@ow4m@ovȴ9X@oz1@7DO M@7Ib~@3+@3Ov`@2j~@2j~@2n_o @2mcA @2n_o @2p@2n_o @2pD?3a=?:aGS? ??:Z2b??OPl[?K{O?f;m?f?~m??Ll? ,?/X?H?[Rb?3_?6?DΊ@@@@@,@,???????W+'<?B O?\-=@xI@ozX?aba?s,?-~L?י&Zw@nnG>|@@dQ@dy@dQ@du"H@dQ@dqQ@dQ@d @dQ@d]6@dQ@dvL*@r-V@{ƒ@r-V@g ^@r-V@q+@r-V@vqX@r-V@r4Y@r-V@pL@9䎊@9j~#@3r Ĝ@3f@2-V@2X@1n_o @1qW @1n_o @1p{f!@1n_o @1qߕX?|9?h[? !?cnvm?\,?6-"?%]?Sq?hAů>?tU?0 (`?k$z^s?0Wn?%?{*Č?.P3c?PBc,w?Z@@@@$@2@,??????RDd?e׋%u?+vFV@d'0@s¡f?vL!?A8?vOD?z A@qn~@@Z{dZ@Z{dZ@Z{dZ@Z|N=@Z{dZ@Z|?@Z{dZ@Z|C,z@Z{dZ@ZzkP@Z{dZ@Zz@s3333@stj@s3333@s*0U@s3333@t*@s3333@s*0U@s3333@sMj@s3333@s@N@2:@2qu"@/`A7@/4J@-Z1@-āoh@-oi@-/@-oi@-JM@-oi@-oi?^Q5P?$?4!p?_?Dj?2I/?bV,? g?ܿ?9~F?Cq$u?_~t?bMky?l? SF?xqC?pk Y?M684@@@@@,@,??????P;'?,f?D yX@Z{ @sm9?;ٸr?ǹs?ri?'ϕї@s}@@/-@ n@/-@1 @/-@.}Vl@/-@1N;7@/-@)7Kƨ@/-@*W@%@xbM@%@'R@%@(@%@M:@%@/W@%@M@9e!.@9o䎊r@4?|h@4 ҈@3-V@3iDg8@2OO M@2W@2OO M@2R I^6@2OO M@2OrGE9?xg?y)3c?2 :M?Sz? ?OPl[?vc?*l?Î -i??[fbF?to(?'@hQ?vv?5q?{B0?q?<שN@@@@@&@,??????dJ>^@)<}?`*?_>z0@,mG@}N?nNs?ntPӐ?~–?˓"v@r@@w@`A8@w@ʼn~c@w@Kg3@w@ä]@w@Eh@w@zy@H2-V@GƟ@H2-V@H<@H2-V@H&2=3@H2-V@HV@H2-V@HLp@H2-V@H0k@8r@8-i}@3^5?}@3BHmJy@2tj~@2od.l@28D*@2B,F@28D*@2Jd@28D*@2@";?& ??}C?C I??>$W9?xHgr?TP? -ic?t?C9?_RS8?~eB?_5 ~?y^@@(@"@&@9@8??????>|d?z?jX?q^Ƚ@[@H稜?*hN?t9?QVW@6c @k e/@@@B I^@@B I^@@B I^@@B @@B I^@@E@@B I^@@ES&@@B I^@@>"@@B I^@@?b}@h\@i7Kƨ@h\@mw1@h\@m'@h\@l>A@h\@fFt@h\@gz@27@@27@@.A7K@.v}Vl@-dZ@-<64@,QN;6@,KƧ@,QN;6@,KƧ@,QN;6@,KU=?^XN?DE??U*?2F0?SJ?bV,?[u?;~?!zt9?|+~?:i?g)?Ϸ+?]?3{Z?fW?gϵ@@@@@*@,??????fbTb5@?Pv,8?Q ;S0s@@A^@i|vr?_,?`$ ?[O?B@@r~@@\1'@MV@\1'@KC,@\1'@x_@\1'@r:)z@\1'.@\1'.@U$@NzH@U$@fffff@U$@Y=c@U$@V}Vm@U$.@U$.@9-v@98YK@4 I^@4v@3>Vu@3)@2YJ@2Zc@2YJ.NC,@2YJ.NC,?p?HyR?4E!?lfW@8I@8?ŦTF?݁E?Rt?@8S@8?$A?P(?%Zo ?&@8 @8 @@@@????@/ٙ.@/ٙ@0Fu@/ٙ@/Y@/ٙ@0@/ٙ@0 P|@/ٙ@0SM@܂ I^.@܂ I^@g l@܂ I^@f,<@܂ I^@u%F @܂ I^@C,z@܂ I^@1&y@7`D.>@2ԛS@2@1-V@15Xy@1z,<@1T#@1z,<@1W&@1z,<@1Zu%F -@8J?4o:v?(`ƴ?r,? P Q?@8J?ѿ,?YEX?0+Pl?6Ey?Jr.@8p?e+?yjk?π9"?:/ʼn?8@@@@,@*?????@.O@+ I@.O@,VϪ@.O@+)^@.O@.@.O@._o@.O@/- @[/@[%Q@[/@[1'@[/@[Y@[/@[}H@[/@[쿰@[/@[Q@8v@8D@3uS@3vȴ9X@2]V@2](@1D*@1Ov_@1D*@1TɅ@1D*@1 ?5}'??mGSq? ?>C,4?f]G?K{O?Hz?Zq?#X?h_N%?Ր?ɽ4?%y*=?@A?GZ?o?&f@@@@@,@(????????Z. @?22p?:m?^"$@.x@[_?MLn׸?s\,W?F}?by2@pE@@X@X -=q@X@W#x@X@X}V@X@WQ@X@X/@X@X I^5@޸Q@j~@޸Q@1&y@޸Q@ '@޸Q@̈́M<@޸Q@@޸Q@ݘ@6?@6@@3R I^5@3IXbM@3tj@2xF^@2@2GE85@2@2nO@2@2N;?F/P5?JT? -?8~?X%?9j -?|O?YYFpb?~$9y?0%rp?\r?M>?5q?kc?}??4i+?;WZ?"`@@@@@*@(???????.5@U?WF: "@=E@>ߤ?@=E@>m\@=E@>m\@=E@<@=E@<@M@NV@M@M@M@N_o@M@M\@M@M&@M@M&@0e!.@0eoiDg@*j~@*Ʌoi@(E@(D@(Bu%F -@(Bh ԕ@(Bu%F -@(Bu%F -@(Bu%F -@(B@5?OW?GA?>f?ƠJ-M?@ A2?$?;0?j%Ra?['?C B?@?M\ٓ@?!?u?oܧ?avh?#.?O|q?@@@@,@,??????Kt? ^7?0L`Z?#@=P@Mh??}TYT#?!PA?x*? *<['@s.v@@\@$/@\@ce@\@#@\@U@\@iDg7@\@ Ĝ@,1&@([@,1&@ - @,1&@!TɅ@,1&@@,1&@b|@,1&@H@7!.@7݊ڹZ@3\I^5?@3V@2`A7L@2hr@2䎊r@2vYJ@2䎊r@2ufA@2䎊r@2w4m?Y͍_?"'?=5?IXo_?(E?X8 ?=՛?(uw,?/܊?ڼF?ҸBz3?:? ?7&c?`͓=B?yh?aI*?[ S?$syW?R ?Vá?"#@@@@@,@$??????_:?|aP?eL?cRl~@9K:@f/Q?r)2 ?S8]?)[C?4dP@l%@@/Q@/5?|@/Q@/F -L@/Q@/fC@/Q@/Q@/Q@/ح@/Q@/˒:*@8Q@@t=3@8Q@QX@8Q@7KƧ@8Q@>m\@8Q@>\M@8Q@>6z@8I_o@8Sg l@3|hr@3Q @2t@24m8@2Eu@2Aohی@2Eu@2Ae@2Eu@2Bs??t?'? -tI?,Z?[5?lP {?u?ଚw?t(?`i2?]vM ?K ?#Z?)h?9@0w?cZ?aʕTI?`i2@@@@@,@(???????B 65?E?*k@/!dJ@>F?`&D?*Unԣ?! A?@-o@or94@@Pqm@P}E@Pqm@Pm(@Pqm@Pw1@Pqm@Ps3334@Pqm@PsMj@Pqm@Pu?|@33333@+ I@33333@2 ĝ@33333@12Y@33333@-(@33333@0bM@33333@49Xb@7v@7@3ahr @3al@2~Vu@2U=@2+xF^@2* @2+xF^@2,j~#@2+xF^@2+U=?ꯨT?W[?%HC=s?V0O?b\?_ ??c?ZzZ?!zt9?qN?X78?)dKA? -?>Zw?rsw?{2?їJ@@@@@@??????N?_@?TUb?=Hl@PtЈ@/?j VM?Vk0?ЛgR9?2o@oPo@@>XbN@?@>XbN@>Y@>XbN@>PH@>XbN@?R;@>XbN@>iB@>XbN@?n@μhs@\@μhs@λdZ@μhs@ξ"@μhs@θy=~@μhs@γPI@μhs@ƍ@7۹~($@7ԇ#@4° ě@4F@4"-V@4'Xe,@3c@3i (@3c@3aN;5@3c@3U`A7L? ?ܡU-?=5?Q+v?l(? Y9>?q!U?[G,?Et'?%ja?pFs?s( ? ?j?Vr?2Yy?P;ro?\?/dž@@@@@(@&???????C4(h?&?>ҽRD?h]*@?XbZ@ξe=N?`u ?SkQ??3X\*V@gh@@glC@k I@glC.@glC.@glC.@glC.@glC.@˶E@˴9Xa@˶E.@˶E.@˶E.@˶E.@˶E.@6쿱[X@61@4)+ .Mm@4tj~.Qn@3&.NC,@3&.NC,@3&.NC,?| @8#@8:@8 >+@8I@8?)T@8@8i@8@8S@8?ЙQ$@8 *@8p@8@8 @8 @?@ -o@&x@ -o@_@ -o@N<@ -o@qk@ -o@q@ -o@ Ƨ@ز Ĝ@g+ J@ز Ĝ@جVϫ@ز Ĝ@اfA@ز Ĝ@ءn.@ز Ĝ@ذ`A@ز Ĝ@ج~($ @7^H@7X@35S@3,u"@2K"`B@2A:S@1_o @1*0@1_o @1͞&@1_o @1^5?|?L?5YM?^*G?d?bJֵ?ɖw?f<4?݁E?h?,ў? R?'qTrQ???anñ?ZaizD?*6SpK?8wx?<שN@@@@@*@&??????X?t -X?mZ~sP?mSE@ -{@ت5`?{8)w?{E?[?E<@sI}@@+Y@+U\*@+Y@+f -L0@+Y@+qhr!@+Y@+B3@+Y.@+Y@+Ev@MS@M\)@MS@Mȴ9Y@MS@MKƧ@MS@MmjO@MS.@MS@My=@8įO M@8jOv@4+S@4Fs@3A7K@3&IQ@3L[W?@3)ѷ@3L[W?.NC,@3L[W?@3ݗ+k?us\?s ?z%d?4M^@8I?YM?Wl?5:7? %w?tm>@8S?TEkc?Ny?1?DU#L?a @8 ?>C]@@@@@(?????@ 1.@ 1@ ]#@ 1@ |,*@ 1@ AAgD@ 1@ C`@ 1@ P@@".@"@e@"@ꎠ~@"@ߙhZ@"@ߪ0O[@"@߈$*@8>6z.>@3hr@3is6@2tj~@2mae_@2[W?@2dqY+@2[W?@2dۿ{@2[W?@2j¯@8J?=ذc?17l??UbBl?H!?|Js3@8J???2OozU?ek~?Xqz?4PTF@8p??-b_9?>?r꟧?hS@@ @,@<@:?????@}b`B@}s3333@}b`B@}` qv@}b`B@}JL@}b`B@}X74@}b`B@}MM;@}b`B@}QX@8Q@8Q@8Q@ 'RTa@8Q@?|h@8Q@*Ov@8Q@6+j@8Q@=p -@7@7{J#:@38r Ĝ@3=v@2v-@2hۋ@1@5@1!-w2@1@5@1,zxl@1@5@1oh?]?B-?Ԕ?V0O? -0ggk?$Nx?]?u(?Pт?J6b?[h?⍄o?*wjs?&!+?va4z?0ڌ#?? 3?@@@@,@*??????p!I$?qKx@?aFgXs?0:{@}SAc@3^g?pp?> T?.@?kEPS@rߛX<@@@3333@@^5?~@@G{@@Q@@D@@"h @L9Xb@L9Xb@L9Xb@MaG{@L9Xb@L9Xa@L9Xb@M)x@L9Xb@M?@L9Xb@LF^@5#g l@5# @6@ ě@6>BZc@5;Ƨ@5+Q@4Q@4sh@4Q@4A@4Q@46z?|O?;$.?}vM?~ -]z?3sG &?8?}ѿ,?J2?P?Ţ/? U?VTJ?/X?ܣD?$M?vc?2:U?a#@@@@@@"??????D3x?mjh?Lɭ=^?e|@z+@L^ ?g N?>7?5Vl?:C@a/ɷ@@(.@(@ @(@xJ@(@~[|@(@r@(@ Z@C.@C@h@C@'4@C@ .3@C@}o@C@vE@8v.>@4@4R꿪@3V@3} Z@3iB@3;3T@3iB@2Apz@3iB@2ӵx,@8J?J' o?ps?7#w?Q'?jT@8J?S+?,C?V%/@6_?5I?(@8p?\?37?[-$?^?J^&+@&@"@&@5@5?????@V@/@V@|64@V@ohی@V@f?@V@A7L@V@{"`@UxQ@UXQ@UxQ@U_p@UxQ@T@UxQ@U"7@UxQ@Uu$@UxQ@UH9X@6H@6oiDg8@2 ě@2#w@2R`A@2&@1c@1/ @1c@13ߥ@1c@1 -=p?X?Yd?R&?a]?>C,4?)?CږF?F6?o J?|1?6P?+NP?WHV?RQF?$*a?]=?ܑ ?Cns@@@@@@??????z??~k)?Oߋ@듸@J@UhY?Ma7?a-/U@6? (@Q@r]C@@;dZ@<1'@;dZ.@;dZ.@;dZ.@;dZ.@;dZ.@ɺ^5?@;dZ@ɺ^5?.@ɺ^5?.@ɺ^5?.@ɺ^5?.@ɺ^5?.@4 _o@47c5@0}hr .Mm@0tj.Qn@/#Z.NC,@/#Z.NC,@/#Z.NC,?|b@@8#@8:@8 >+@8I@8?~?J@8@8i@8@8S@8?gl˹@8 *@8p@8@8 @8 @?@@DT@@E`A7@@DT@@F3H+@@DT@@FBN@@DT@@E1@@DT@@CmO@@DT@@Cj=@H&x@H&C\g@H&x@H"@H&x@H,@H&x@Ho힟@H&x@HȜ@H&x@Hl3\@3䎊@3e+@-"`A@- ~@,E@,F!;@+At@+l@+At@+il@+At@+17?}#?V??Qϋ?/?GIv ?| V?I?I?4k?`@?PG&?n3?lJ?wy2u? CB ?΢?΢@@,@*@*@8@9??????7Xt?*ķT? @@D@H!?J|Y?(Q͔0? ӑcE?^Z~@g8@@\(@Y+@\(@_@\(@[u@\(@dT@\(@_F@\(@^ (@Q@š@Q@u#@Q@,@Q@ĵ?@Q@ĨT@Q@\(@7N쿱[X@7L~($ x@3|hr@3<쿱@2-@2ܥzxl"@2c@2ba|Q@2c@2ctj~@2c@2bp:? ?Qi{cj??[d?_dA?*j?}ѿ,?& ?f?Җq??"(L?Rw#z?2}?/Y}?Y8Z? .0v?1&y@>9X@>1&y@> y@>1&y@>:~@>1&y@> @>1&y@>X@>1&y@><6@4:@4>@2?|h@2m8@1"`@1,@1u@1.H@1u@1~"@1u@1~qi?Ol?XMH?e -!C?Fq/b?bJֵ?F?}ѿ,?o ?DP?M =?*?k?|׿pY?Ãx?+QK?=aw%?_խW?<71@@@@@*@*??????S ?e8sB?3f:D?EQEپb@HѦSo@> ?R'J?dLzŏ{?T(?A(@f @@&KƧ@&O;@&KƧ@&h@&KƧ@&dH@&KƧ@&i2@&KƧ@&WP@&KƧ@&@r["`@r[v@r["`@r[\_?@r["`@rg@EB@r["`@ro*@r["`@rYUHa@r["`@ra߶v@5r@5r@3.5?|@3*d&@2A7K@2^@2m8@29f|Z@2m8@2خP*@2m8@2#=?}#?ą"$?T֗g?Sd? ?OIf^ ?~Ov_ح?Ad?>)Skh?QX{Q=?֢Gc?RѥJ?TA?T??5a&?5d| ?[?5# V@@"@&@(@0@1??????t>6z@4sPH@2 I^5@2ѷ@2`A7@2@1,<@1qu"@1,<@16@1,<@1U=?| ?nx?)?BI{?̒h?6={?S{d?| ?c?fM?**?pPȻ? 3W?W?*J?D(p?=aw%?:1?o@@@@@,@,???????k?*̭?*4)@@Rb5?JP3:E'?:9?M*-{\?~S^J@eے/@@@"@@@@"`@@@@A@@-@q^Q@q^Q@q^Q@q]Vl@q^Q@q^@q^Q@q^҈p@q^Q@q_o@q^Q@q_䎊@1S&@1S&@05?|@0ߤ?@0 "`B@0 jf@/Z@/74@/Z@/wkP@/Z@/ ?_\p)?h?,fC6?Њ?E@?t?bM_x?&uE@?:?9~F?!U?{?Q\?bMky?Ф?B@@҉@6s@6xF^@15?|@1C%@1ttj@1qN;5@1O M@1 a@@1O M@1 ~($@1O M@1 ?}?+!? -NA3?[d??| ? l?<?8"?Jn? w -?],m%@D,@/?yO-4?Ye9q?nW?_@a`JC@@l"@lvȴ9@l"@l @l"@lY@l"@lZ@l"@lPH@l"@lE85@0 ě@0`A@0 ě@2S'@0 ě@8U@0 ě@7kP@0 ě@.@0 ě@0H@7~($@7H˓@2^5?|@2S&@297KƧ@2;6z@1=ce@1D#@1=ce@1B&IR@1=ce@16fffff?)T?Sy?K]4?\GyƩ?GBm?VAў?1j?8{:?DP?|zk?+L5?[6?W|DC?zx?q?k,? -r?y\@@@@@,@,??????? \@;`?Wn̡ ?F@l@0?v$W?hg%_H1m?qFP?]l'-@gJ@@YV@Y\(@YV@Y3@YV@Ylj@YV@YڄL@YV@Y\@YV@Yա @ٷKƧ@ٳ3333@ٷKƧ@ٵf@ٷKƧ@ٵ{>@ٷKƧ@پ@`@ٷKƧ@ٵQ@ٷKƧ@ٺ,%L@3qiC@3s9?@1+@1<.?@1A7K@1U@1m8@1Vu`@1m8@1]l:@1m8@1@?}@TΥ?Pnx?Kg(^Յ?@5@5 -=p@2hr @2d8@2q7Kƨ@2p k@20@2.Ov_خ@20@20@20@2/iDg8? ?" ??(tUo?ϲI?jכb?|O?RwS5?3fvI?WA?=x?w8?@A?J?(?=aw%?q ?GZ@@@@@,@&???????J;#[ @?SA%v? @@Z@:J)?s/=?@0"?xI&v?؉7#@fg -!@@ A7L@ n@ A7L@!R<@ A7L@!TɅ@ A7L@"h ԕ@ A7L@҈o@ A7L@G@S@S@S@ -L0@S@O@S@L/{@S@YJ@S@oiE@0v@0%@*-V@*+j@*/;dZ@*/;dZ@)At@)4֡a@)At@)At@)At@)'/W?^Dw'?[e(@@@@@*@,??????Y"Ґ?BtQ/? lr@ U @5:k?Q?&<Xu?HR_?E=%@sZW"@@\&x@\`A@\&x.@\&x.@\&x.@\&x.@\&x.@["`@`n@["`.@["`.@["`.@["`.@["`.@7:@7Ƨ@3TS.Mm@2Vu.Qn@2s&.NC,@2s&.NC,@2s&.NC,?q!U@8#@8:@8 >+@8I@8?2}@8@8i@8@8S@8?}?@8 *@8p@8@8 @8 @?@f^5?.@f^5?@fHۋr@f^5?@f- q@f^5?@fXl"h -@f^5?@f=ڹ@f^5?@fA@+.@+@a [@+@bwk@+@Hp:@+@B I^@+@H@9 D.>@3+ J@3}!.H@3tj@2ӯ@1sh@1"`B@1sh@1ʟvȴ@1sh@1Ǔݗ,@8J?%ñ?%bI?^Z?̺ ?Fb%i@8J??-?6?~]?~NO@8p?E!'?c?'d㗅?y?M\{W@@@@*@&?????@@A$/@ˤ@A$/@˛H@A$/@Eڠ@A$/@@G{.@G{@~F@G{@{O@@G{@[2 @G{@2W@G{@u@4+ @4խ@46-@3A@3ush@3>Rbo@3ush@3bPܘ@3ush@3\t@8J?h/E?@ -?[9??mC?vC@8J?pt4?H$/걺?Rf?19:?VN4LM@8p?t?I&a?2?z'?٦SqUm@$@,@*@7@5?????@L1@L@L1@L1@L1@L 2ܶ@L1@LӜg{@L1@LХޢ@L1@L؋Κ@Q@X_8@Q@pc@Q@V@Q@]~@Q@"@Q@ѕޫ@8g l@8ȯ݅@4#@4(o8@3tj@3O1 @2YJ@2/@2YJ@2~s@2YJ@2ի?d_) ?B|3?LW ?0?N~b?7 -8?}x?| V?J9B?tT|2?!s6?ͮE41?^?|h2:?|4c+?ӝ!*?VE,?=?^ _?+@8I@8?1j@8@8i@8@8S@8?m+&@8 *@8p@8@8 @8 @?@ Ĝ@G@ Ĝ@@ Ĝ@й@ Ĝ@ 5Oi@ Ĝ@m@ Ĝ@(@>vȴ9@MO;d@>vȴ9@vȴ9@$<c@>vȴ9@6i-Ԅ@>vȴ9@8hq@>vȴ9@! -_g@8qiC@8TɅp@4 I^5@4鞦:@4)"`@4E޽@3 k@3U@3 k@3?)L@3 k@3YU?Z?-$? J0?TKF?j6?Y1z?Z?Xw8?4 m?16y?MQe?Dt۱T?A?j&?M?ot?13C1?{0+@@(@ @ @:@8???????gotlgp{%6?b?]ʠG݉@%|@0U#&0?qlkj?mR}?wB?Ǒ*@r)VZ@@^5?}@G@^5?}@~@^5?}@m@^5?}@G@^5?}@e+@^5?}@~($@?|h@?vȴ@?|h@?|h@?|h@?|h@?|h@?H˒@?|h@?b}@?|h@?.H@3H@3H@00ěT@00$tT@0$j~@0$7@/@/ @/@/ qu@/@/6?}ѿ,?{j?,fC6?ArU@? f?-/ge?|O?NۈV(?NJ?Y?݄ ?U3p?q6tN6?.x?֘>D?xqC?M684?b/bJ@@@@@*@,??????1?-T ?>ʃk@^P@?|d{?>PQ?6?(#r??U@g -@@Ni[@?B3 [@?)lIN@N< @ffW?^+H?MOY8? )p?Oh@k6@@J@JbM@J@Jȴ9X@J@J!R@J@J'/@J@J˹~(@J@Ja@7K@;dZ@7K@$/@7K@n.@7K@1@7K@~@7K@t@8^H@8Xu%F@3xr Ĝ@3|L_@2"`B@2\(@2!.I@2 k~@2!.I@2Ov`@2!.I@2RT`e?qn?dY{?ِ?c[=#?X?۝.Yr?F/P5? ,C?-8?X}iQ?nW*؄??;?/X?2}?Aᆽ?l_zU? .0v?^^ω@@@@@(@$??????M `?pZ??3l?X%t2Z@J^:@h?\J?|&))?F?]O@k\ٿ@@XbN@XbN@XbN@b@XbN@C\@XbN@xl"h@XbN@\)@XbN@*1@[E@[E@[E@[F@[E@[\)@[E@[?|@[E@[X@[E@[3@4 xF@4J@1S@1Fs@0"-V@0!u@0._o @0,@0._o @0+aA@0._o @0+Ƨ?}ѿ,?[e_9^?-/3rD@'qJ@[uo?^.Ws;?MΝ8t?^G?oБD@gF(n@@ O@ \)@ O@ @ O@ A7M@ O@ @ O@ @ O@ F@Jv@JbM@Jv@J@Jv@JZ\6@Jv@J@Jv@J[]D@Jv@JF5@7 D@7snN@2r Ĝ@24@1Vu@1r@1iB@1b˧2@1iB@1g@1iB@183>?gQ?S?MV4*-?¤x|?4zu'W?یqnj@ %i@J?^ -ij?9P-mM?{I,?y1W@"@hGL @@`Q@`[B@`Q@`s@`Q@`帶@`Q@`vZ\@`Q@`W&@`Q@`G@4j~@4j~@4j~@3{@4j~@4E{@4j~@4n8[@4j~@4az)@4j~@4w@3 ]ce@3 >(@/`A@/GE84@-n@-G+@-Ǔݗ,@-&%S@-Ǔݗ,@-%@-Ǔݗ,@-O?~Ov_ح?ِ:?*[uƥ@`I?Ob@45+?Y2 ?7x\0?4pk>.W71)@4j{=@C@?Tk?Fά??Laf?8Z矣@h\@@O;@~$@O;@\M@O;@a@O;@2X@O;@A [@O;@Ԣ3@@bM@@l@@UXy>@@xl"h -@@˒:*@@qm@8*0U2b@8 >@3+ @3!-w2@3y7KƧ@3kQ@2u@2~vȴ9X@2u@2zu%F -@2u@2lN;?^*?vucʲ?/b?-i?rA:/?wb@?1j?HG^?wKv?-M?w{_?n%!?^?"`?@K/{?__C?X񄖆?/я@@@@@&@*???????SA}@?eF?f-ϝ3@R@HH? -4~:??:?zy @d\@@|nP@|nP@|nP@|tj@|nP@|@|nP@|a@@|nP@|&x@|nP@|&x@33333@3E@33333@2s@33333@2{@33333@2-V@33333@2s@33333@2a|@.@.@,tj@,A [@,wO;d@,w&@+p'RU@+p@+p'RU@+poiDg9@+p'RU@+p|?^Q5P?[e(?f_Ԋ@@@@@,@*??????SD?@?9dXc?1ٕB@|4@24R?Heb?2K ? V%4T?% `3j@s ;*S@@pV@pzI@pV@pI^4@pV@p I@pV@p=p@pV@pj~@pV@p@s-V@s-V@s-V@ss@s-V@sC@s-V@s,<@s-V@sD@s-V@sa|@4[~($@4[]cA@1hr@1n.@1KƧ@1 '0@1(@1'@1(@1b}W@1(@1<64?|O?M?1V?wX/8?.5?a1?}ѿ,?D.x?c#$?ݤ`h?=M?7&T+?y8#??6~A?{0? g?@8mv@8h ԕ*@5 I^@5e+@5{Ƨ@5~c @4h@4kC,{@4h@4h_G@4h@4k/V?^*?/>?Aa[?gٵV?wX?c+:X?[Xxp?C?I?J6b?>G]!?2;? G0?^?"x*=k?8k4?9j jh? )D)@@@@@@??????br"?^9?O{J0?npta@ -QI@ti?nK?< t?{I?tj%up@nE%@@ I^@ I^@ I^@ @ I^@9@ I^@s@ I^@R<@ I^@4m@:^5?}@:^5?}@:^5?}@;qu"@:^5?}@;"`@:^5?}@9@:^5?}@:kP@:^5?}@8*0@3_o@3y @0|hr@0Ar@/E@/3@/oi@/?@/oi@/oh@/oi@/&IR?}ѿ,?/)s?.Ү_ ?G?K!UČ?6J?| ?[ K0R?NJ?9~F?M?Qʾ? J?Ф? J?*|\/?? Ğ@@@@@,@*??????0 kh27"? 劓9`?'?"/Y@@@@@,@&???????aKTX8?I:岵Z?U D]td@G@ؠ.?hه?u.A ?3E`?9yO@eM-@@hH1&y@h;lE@hH1&y@hEn@hH1&y@hH@hH1&y@hH@hH1&y@hG_o@hH1&y@hGݗ@nP@I^5@nP@Mj@nP@:~@nP@bM@nP@.@nP@&x@6[~($@6MH˒@2+ I@2-@0-@0C-@0n_o @0nѷZ@0n_o @0n (@0n_o @0m,=?}?W[? ??ݶ\r?h|?W_?3a=?[ K0R?,& -\?>\?x9ξO?ȏ'T?gE=`?Q?`x? ?? -t?j@@@@@,@&???????L>R?Q.?Vs왮e?3b@hGY@U]S?k9?RCJ\|?NԊ$? @om2(@@M@n@M@a@M@Tb@M@3D@M@T@M@iB@JQ@JR@JQ@JS@JQ@JS ɫ@JQ@JQ Ʊ@JQ@JNp@JQ@JR7@5|Q@5L@1ěT@1+9k=@117Kƨ@11b@0YJ@09KR@0YJ@0T㧧@0YJ@0u]M?|b@?;?([0?|?'I'?磮R?|h2:?,9B?jz?n-?E=:?ge\?oR?î!?}_?9Ýdk?  3?{)@@&@$@(@<@6??????0P,x?!&?tdE?c3c(?+d?y8#?Q?`x?*|\/?Rv? -t@@@@@,@,??????!z5E?T>i:@ -@ -L?3й*?Bb?s?@?EmIk@f@@/@/}2@/@/ks@/@/1@/@/@/@/\@/@/ @š@ɳs@š@ר@š@јz@š@*@š@Q@š@.@3D@3@N@1=hr @19xC@0tj~@0(wg@0._o @0-z;a:@0._o @0*{@0._o @0*yQ?~Ov_ح?l(?r[?(#O?>X`?[PP; A@^/@^7 -@^/@^q'@^/@^]@-J#9@-J#9@,A7K@,4 @+1'@+"a@+@+d@+@+\(@+@+f n?^6P?j?@?@y[?E>)?Ŷ?bQ넛?B?!.$w?5ei?а?Io?bM]f?6H^4?p®MG?$: ?%ip-?a@@@(@*@8@4??????P'k?6Lv?CPo@: @^ܨNe?E:I?":9?*?=0I0@s ZM@@~"@@~"@~쿱[@~"@H˒@~"@G{@~"@}IQ@~"@}Vl @mffff@m@mffff@m@mffff@m@@mffff@mtS@mffff@mn@mffff@mw@5YJ@5YJ@2n5?|@2l@2t@24J@1u@1ѷ@1u@1|@1u@1Z?}ѿ,?b[?#}i?!#?uxY?WA?1j?M7F?Qa C?RLnj?7=^9?A_f;j? SF?.?]b?XW~?$?Rv@@@@@*@,??????;O?)?9V?yCH@VQ@m3 ?Y,?9,%ބ?Oz?|Y1R@gc@@t9Xb@z1@t9Xb@tG@t9Xb@{/V@t9Xb@u\)@t9Xb@vC@t9Xb@@k=p -@k9XbN@k=p -@kA-w1@k=p -@k:>@k=p -@k=-V@k=p -@k:@k=p -@k6R<6@72@71N;6@2?|h@2z@2>Vu@2?r@1 k@1y=c@1 k@1x@1 k@1 k?2}?gˣ?0? R?[9,?S{d?UbB2?\?-8?uX?4{?{P?A'_]?>?T0??`i=?zy@@@@@*@&???????6>DY?S T?Q0@zJA7@k:V`.?vA72h?mm9?uR?/@k|%Fr@ @y"@y"@y"@~vȴ9@y"@ufA@y"@xV@y"@~iB@y"@{5W@Z1@]/@Z1@X4֠@Z1@W1@Z1@Y|@Z1@V@Z1@U2a|@6,<@6x@3ěT@3Mj@3-V@3 C@2\Q@2[W>6z@2\Q@2Yk~(@2\Q@2Zxl"h -?Ol?x)n?0?GZ0e;?(i^?-/ge?}ѿ,?^1??v@b?#X? ?Z)?7}?,DP?T0?ۮetZ?1?l@@@@@,@"????????yg5&@gnp@ -@EQ@D/@EQ@EO@EQ@K҉@EQ@C,zw@EQ@D7@EQ@B@4@ᅡ@n@ᅡ@ag@ᅡ@$/@ᅡ@~5?|@ᅡ@ح@ᅡ@䎊@6H@6حU@2^5?}@2$ xG@1j~@1@13&@11o@13&@11:S@13&@11?|O?: ?9a?_?<_+fj?=?sD?V i!?~?G>G?W;zY?998?T0?G - ?m~Z_s,?ij6?v> ?)@Jq@@@@@*@,??????:@G|?,o?n88??/X?J?C SG?C SG@@@@@(@*??????G7/j?43XN?;-O@Fx˻@i?Tqf?[? ?69A`n@g`{pR@ @Zv@+C@Zv@T!@Zv@](@Zv@gJSS7@Zv@Y@Zv@Z@_TF@_zBg,@_TF@_KoE@_TF@_gYH@_TF@_D*>@_TF@_f=@_TF@_U@9-v@94.4@4W+ I@4]0/^@3tj@3AZD@35sh@3=V J@35sh@368p@35sh@38vRЯ?3N?T?7?d2f?Pݱq??N'P?31?B?PQA?4L9?z?-ͧG??>D&?rywK ?dX? -A35%`3@}Y=֔@M#=?c-ʓM?^%=%?,x?H2/@j57@@7K@7K@7K@ I^@7K@3@7K@ I^@7K@ě@7K@ѷX@w@w@w@wR<@w@ws@w@wTɅ@w@w|Q@w@w7K@0=:@0=:@*j~"@*]ce@)F@)ؓtj@(L/{K@( -L/@(L/{K@( -L/@(L/{K@( -L/?^Q5P? ?m?ƠJ-M?tKc?$?bM_x? ,C?NJ?1'7?tP*?Z,a?bMky?.+?s@a?͓E'?l&?@@@@@,@,??????B*??)!>Lamj@M=@wpZ?8 ki?ķ?m#bE,?Kh@s2@@R@S3333@R@SZ@R@S|@R@S@R@R@R@R䎊s@ffff@ffff@ffff@1@ffff@E85@ffff@S@ffff@]c@ffff@思IQ@3H@3p:~@.`A7@.D@-1&y@-1&y@,jf@,Q@,jf@,P{@,jf@,C&?|O?GA?&?? Y?2A?}?| ?%F?d0R?-I`K?IM?eDQQ?2Y0?.+?2Y0?XLL?f_Ԋ?b/bJ@@@@@,@*??????>j#?":~?@S2h@l1;?B}1!7?7 p??r?{@fo@@?|@-V@?|.@?|.@?|.@?|.@?|.@|hs@ [@|hs.@|hs.@|hs.@|hs.@|hs.@8!.@8@4E?|h.Mm@3~".Qn@2䎊r.NC,@2䎊r.NC,@2䎊r.NC,?m*H@8#@8:@8 >+@8I@8?/@8@8i@8@8S@8?\;.=@8 *@8p@8@8 @8 @?@9kR.@9kR.@9kR.@9kR.@9kR.@9kR.@4vȴ.@4vȴ.@4vȴ.@4vȴ.@4vȴ.@4vȴ.@8v.>@4+ I.Mm@3PA7K.Qn@2.NC,@2.NC,@2.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @E@gPɟ@E@g@E@Pm@E@ub@E@cW@E@@7XbM@7Y@7XbM@7Y;$@7XbM@7a9a@7XbM@7ZG*@7XbM@7\)@7XbM@7_9(@6!.@6P#Nl@1+@13$e@1Htj@1H\e@0@0 @0@0K;@0@0K?¨Sp*?Ę'}?6nX?7e?8\\?D\Z(?\Η?[L?&aD2?`a^?-?HX?@V;Q?)?S?#?I?2o9@@"@"@@,@*??????I?@'KXt?)s[t?"{H8@~0@7[O?IkyQK?B{MҶ?C3? -*J@i\ @@\G+ J@\[Ē@\G+ J@\PNU @\G+ J@\I'@\G+ J@\_M5@\G+ J.@\G+ J.@tj@'a@tj@樢G'@tj@ٓU@tj@rѠ@tj.@tj.@8*0U2b@8@0f+ J@0h@/O;dZ@/҈@/\ߤ@@/`[6@/\ߤ@@/]b@/\ߤ@@/Y+ ?}ѿ,?h?1f_?A%?\7?װ*w?|O?4 "?ܿ?M =?=d^?h,à? SF?2]7??ʪ?@n?+^@g<@@n@x@n@ᰊ@n@qi@n@PH@n@'y @n@)^5?@E@1'@E@/A@E@{J#:@E@B @E@?|h@E@f&@7mv@7F+jg@3!hr @3Fs@2A7K@2n/@2+xF^@1 k~@2+xF^@2Ϫ͞@2+xF^@1C,zx?A[F?cX?LAJ.?[? -=p?ե8*?Y͍_?8$ -"?VǷ?g(Z%?w{_?覲CU?M3 ?C'?'#g?wZR)w?srY? m9@@@@@&@&???????v-Ҁ?!)?MxA1?gçdi@ Y@A?i*Lz?1Fg?~ ?B6`@c*@@Zv@Vu@Zv@Qhr @Zv@Ohی@Zv@O4֡b@Zv@N!R@Zv@Vȴ9Y@z.O@zI7Kƨ@z.O@z)^ @z.O@z)@z.O@z5*1@z.O@z,I^5@z.O@z6B@7@@7N;6@3!hr @3F]c@2Htj@2=O;dZ@1@1M@1@1ٓ @1@1۲m]?)T?bDҼ*?Q"Ě%?]]gQ?19?zWmo?ʎa]?ѿ,?S`G?fa]G?drK?f٭'?Uu6EE?J>??k2m?,6z@)v@)$tS@4䎊@4S&@1+ @1_F@0"-V@0"ᰊ@0𖻘@0%@0𖻘@0}Vl@0𖻘@0}Vl?|O?m0?Gy??r*?STS?=W?| ?r/B?^ o?y҇??Q?y8#?˛͇q?W ?2?їJ?@@@@@(@$???????D. HKޢ?,<Ч?19^@W3@)5Y?LFgz?QOA3?VLiW? vmt@fcTF@@;dZ@ ě@;dZ@Ѩ@;dZ@/UX!@;dZ@sFI@;dZ@ϴ(lQ ?(~?Қr(?qW?}@TΥ? ~5??*9?lt??X*?o?25?A?hM5?#Ŝf?ləd@@@@@2@4??????P?5"?E S?I3#H)|@[«@Q!U`?et?iGH -?ncXZ? -ϸÁ@e֌x:y@@+E@+9Xb@+E@+!.@+E@+3@+E@+XbO@+E@+!@+E@+=@V;dZ@V|h@V;dZ@V u"@V;dZ@VW>6@V;dZ@V@V;dZ@V($ x@V;dZ@V%@7_o@7ᰉ(@1|hr@1@1PA7K@1PA7K@0n_o @0n (@0n_o @0nc @0n_o @0n.2?Br?m?ě?G?'ř ?װ*w?ٛP?7fps?2'?@[*^?UBi?N`?6P?G - ? ݎ8?!ˠ*(?ad|?M684@@@@@,@"???????>¨ ?+0?Ek??987g@+w.Y@V?f@?W-ad?v)?F7M@n;@@yXbN@u\)@yXbN@y@yXbN@?@yXbN@s|@yXbN@zQ@yXbN@u!T@pR@qě@pR@pr @pR@pv@pR@ptj@pR@p,<@pR@p@8~($@8u!.@3@3S&@3t@3*0@2@2!-w2@2@2tj~@2@2n.3? ?(.?wm?(+Zk?&x?ĵ^M?#[?@p?S1z? -@pm6?m0?pT?\z|?Ǒ8E@oC@@ Ƨ@ L_@ Ƨ@ ~(@ Ƨ@ M=\@ Ƨ@ }@ Ƨ@ _/@ Ƨ@ D'@G{@ě@G{@]^Q@G{@7@G{@\v@G{@ I^@G{@`B@4 xF@4Ӳݛ0@0+@0/oz^@.&x@.@,873@,8|@,873@,8¤T@,873@,8 ?|B &?q?lȼ?-M+?XkZ?1 -qV?|b@? ?F{r?2Nk6y?a$d?VTL}?I? ?I??7is\?Vi@@(@$@(@:@:??????$5 ?'-?>@>D@ ƒ@?!*c#$?A=7?P%#?J.#gdU@f51@@A7L.@A7L.@A7L.@A7L.@A7L.@A7L.@-R.@-R.@-R.@-R.@-R.@-R.@87@.>@4hr.Mm@3KƧ.Qn@2:S.NC,@2:S.NC,@2:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @1@M@1@#@1@3@1@!-w2@1@ k@1@4m@@`A6@@<64@@D@@u@@#@@u@7>6z@7_o@2^+@2\@2M-V@2H@1Eu@1@oiDg8@1Eu@1B3@1Eu@1B I^6?UbB2?:aGS? -NA3?Att?'`? µ?2}?wi*?3j_?u]?H<??B`?D1#Xj@ƥI@)F6?^p{ ?gw/-?|>iH?g+@k@@nP@-V@nP@\@nP@Mj@nP@_ح@nP@E@nP@@S@j~@S@u%F@S@0 @S@bM@S@^5?}@S@)y@4@4Mj@0S@00 @0t@0O M@0~($ @0>6z@0~($ @0rGF@0~($ @0*0U2a?|O?°R;?K]4?q@v?1 v?P(@O@I("@O@V@+_;dZ@+_;dZ@+_;dZ@+^;L's@+_;dZ@+^h>@+_;dZ@+]xY@+_;dZ@+_I@+_;dZ@+^%ͳ@1^H@1^Vu@+Ƨ@+달q @+O;dZ@+^h(@+z)_@+zAM^@+z)_@+y`6@+z)_@+zS?^6P?f^?F??XkZ??bMn?V?j?7iU?5V?N)h?bM?:d?r{e{t?՛?mՙ@7+S.Mm@6`A7.Qn@5xF^.NC,@5xF^.NC,@5xF^.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 "@@az@@߸3@@x@@~2Q@@o@@t|.@ I^@͌ݬ@ I^@ڡڍ@ I^@ջ-@ I^@L,@ I^@ S{X@ I^@d3@8[~($@8[Xz'@3^5?|@3k6@@2`A7L@2 @2G k@2Oj@2G k@2Kk@2G k@2L:G?%h?>EG?wy ?6J?|yl?+ww?| V?ۜ,!?C^]?@Et1?BE?]?":,?R p?)G?6m?m?$^}V@@&@&@@0@0???????M?N,C?hiVٗ?\yQ'/@J@[? -Ư?ufv?>i@wA;@lű1@#@$/.@$/@@@$/@d@$/@@$/@^ -@$/@Ft@cݲ-V.@cݲ-V@c1@cݲ-V@caf@cݲ-V@cQ@cݲ-V@cl"h -@cݲ-V@cbM@904m8.>@4O|hr@4H*0@3~Vu@3}K]@3!.I@3 (@3!.I@3`A8@3!.I@33@8J?Q&g4?go]?IW`g?|K!\?V@8J? {?@N?!ϓ?' ?O[@8p?ɅoiE?bR?/?Oh6c?3@@@@$@&?????$@,1&@+R@,1&@Q@,1&@ qv@,1&@GE8@,1&@[7@,1&@@p -@-V@p -@)^@p -@r@p -@bM@p -@@p -@P{@5O M@5e@3 ě@3y"`@3`A7@3sF]c@3OO M@3A_p@3OO M@3C@3OO M@3C&?| ?I@3&+ J.Mm@2M-V.Qn@1.NC,@1.NC,@1.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 &@Bx.@Bx@BQ@Bx@B@Bx@BH@Bx@B@Bx@B@33333.@33333@,cA@33333@0)^@33333@-\@33333@$M:@33333@*W@9쿱[W.>@3S@3"h ԕ@2t@2JL@2z,<@2|hr@2z,<@2u84֢@2z,<@2v '@8J?4$?GM?tN+6?؍i?u}I@8J?Zk?cu%+?tm>?#\?º@8p?Q?8*??NVC&?R4@@@@,@*?????'@S@@S@S@S@e@S@S@S@,zx@S@F]d@ݲ-V@Q@ݲ-V@ce@ݲ-V@($ x@ݲ-V@ѷ@ݲ-V@b@ݲ-V@($ x@6cg l@6ql@-$tj@-$?@+Ix@+IoiC@)ߤ@@)(^@)ߤ@@)ߤA@)ߤ@@)Q?1j?3i?m?ƠJ-M?tKc?$?F/P5? ,C?/BH?; $?%y*=?X78?6~A?3;?u@>N ?͓E'?O|q?a+@@@@@*@,??????dZ?DU4?@4^+@4lC@3KƧ@3[҈@3+xF^@2Ұ ě@3+xF^@2?@3+xF^@2Ԏqj@8J?-ieZ?pZ?3}s?K?7e@8J?]veb?4Z~?ZhB??jy?צ75@8p?Ãx?}Tz?ނ F?Oh6c?!S{uu@@@@,@(?????)@+R@9@+R@@+R@"7@+R@u%F@+R@!e@+R@(K]d@\)@@\)@'/@\)@쳶E@\)@p:@\)@jf@\)@ѷ@9,<@9䎊q@4?|h@4C@34tj@35S&@3m8@35Xy>@3m8@3')^@3m8@3(*0?F^S?[?U#?%?U7t{V?iUv]?F/P5?ٔ!x?S1z?/{?g> b -@g#{[N@+@8XbN@8"@8XbN@9mL##@8XbN@9>&@8XbN@97Pb@8XbN@9 -`Z@8XbN@9#gT@dZ@dZ@dZ@֠8@dZ@ @dZ@l@dZ@!9 @dZ@8~@1@@1?⒮@-tj~@-'@,E@+'ﴞ^@+jf@+C*)@+jf@+\Zw~?Q?!A -m?Gϵ'?fW?ad|@@@@@"@,??????E1Q? Q?02?& -;[@R }&@8IO$?O)4A?G2zWL?xZN?^\E@f٘E@.@'7K@'7K@'7K@'TɅ@'7K@'@'7K@'|Q@'7K@'䎊@'7K@'[7@l@l@l@ԕ+@l@d8@l@ @l@l@l@ԕ*@0_o@0_o@+-V@+<64@*;dZ@*O M@*L@*K҈@*L@*L1&z@*L@*LI^5@?^Q5P?3i?,fC6?ƠJ-M??:?bM_x?u߿?j?4ډ3?@?R g!ڢ?b@?.+?8*?!ˠ*(??a+@@@@@*@*??????B:(>k?2~(y|>Q -@'1@?B9I?Av??n?37@s 1j@/@KƧ@x@KƧ.@KƧ.@KƧ.@KƧ.@KƧ.@@ֻS@.@.@.@.@.@8~($@8[6@5S.Mm@57Kƨ.Qn@5V!.I.NC,@5V!.I.NC,@5V!.I.NC,?UbB2@8#@8:@8 >+@8I@8?A[F@8@8i@8@8S@8? 1@8 *@8p@8@8 @8 @?0@o-@P=@o-.@o-.@o-.@o-.@o-.@笋C@@笋C.@笋C.@笋C.@笋C.@笋C.@8:@9?W:*@4 I^.Mm@3V.Qn@3s&.NC,@3s&.NC,@3s&.NC,?]@8#@8:@8 >+@8I@8?AH=@8@8i@8@8S@8?Lw@8 *@8p@8@8 @8 @?1@_[S@_^5?|@_[S.@_[S.@_[S.@_[S.@_[S.@&ffff@!G{@&ffff.@&ffff.@&ffff.@&ffff.@&ffff.@7Y*0U2b@7UoiDh@4+ J.Mm@4b-V.Qn@3䎊r.NC,@3䎊r.NC,@3䎊r.NC,?Ol@8#@8:@8 >+@8I@8?3a=@8@8i@8@8S@8?c@8 *@8p@8@8 @8 @?2@`o-@`p ě@`o-@`nO@`o-@`o M@`o-@`oV@`o-@`l[W@`o-@`l_@ t9Xb@ tG@ t9Xb@ t$@ t9Xb@ t*@ t9Xb@ vE@ t9Xb@ u '@ t9Xb@ u=@4䎊@4[W>6@15S@161.@0-V@0 @/At@/_o!@/At@/hۋ@/At@/O+@8I@8?@8@8i@8@8S@8?{@8 *@8p@8@8 @8 @?5@$Gz@$X0y*@$Gz@$dO*@$Gz@$͢`@$Gz@$g@$Gz@$I@$Gz@$|@@@@2"@@A9t@@ @@KsK@@Xdc 4@8䎊@8;h@5r Ĝ@5@617Kƨ@6qL5@4:S@4fLoj@4:S@4;$@4:S@4 ? MV{?N+9G??J?~}6?t2n?ܓK3??2;Z?!|/? .߳Q{?l1}?킑?B1P?Xz)??/e?lPR{?SF"@@ @&@(@<@9???????j -?x=l?vG[J?gvW@$wc)@e1?)Ӌ %?Zt;!?4,? f@fh飤@6@2;dZ@25?|@2;dZ@21&x@2;dZ@274@2;dZ@2zxl!@2;dZ@1o@2;dZ@1ѷ@/9XbN@/6ȴ9X@/9XbN@.#@/9XbN@.9Xb@/9XbN@.n.@/9XbN@.y@/9XbN@.IQ@8@8+jg@43S@4a@N@2ߝ-V@2F -L0@2_o @2fB@2_o @2L/|@2_o @2?ϱQm?vucʲ?njĕx?TnE?[5?VFNLG?oC?t?sw)?2}?KN?fF7? b?Az?qn?hc?Xk?8N0@@@@@,@*??????v>hi ?Z{?u'#@2@..?sV}z?iC?V.f?T|X@jEp @7@:G@6+ @:G@D/@:G@s@:G@#,zx@:G@*ڹY@:G@)x@3333@n@3333@s@3333@S&@3333@xF@3333@ ]c@3333@Z@8 ]ce@8kP@4hr @4qiB@4W-@4'_o@3@5@2?|i@3@5@2wkQ@3@5@2ݗ,?q!U?}?e?ȉ?=U?')?% ?'??7fQ?j`cq?V⌰?zny-g?; y?qePQZ??**Z?k@@@@@(@(??????g݃?|meZ?Vs`z7?dC'@.& $@?v25/?/]1?n*P? -7h@i}R@8@Jv@J"`@Jv@JPH@Jv@J(@Jv@J~@Jv@Jl"h @Jv@J @XbM@XbM@XbM@WO;@XbM@S@XbM@XQ@XbM@V@XbM@V@4@@4_o@1=hr @1>zG@0KƧ@0K]d@0(@0(4֡b@0(@0(*@0(@0(?| ?_?"?Qui@'-@EA@3333@f@3333@O8@3333@r*@3333@GP@3333@(@3333@!@8B䎊@8B)@@58r Ĝ@5>H2@4-@4֔@4QiB@4M@4QiB@4JGzg@4QiB@4I0 I?Äp?D]?i ?lGD?Et?Gτ? MV{?hO6?G|?q? fg?eVC6d?}й?*?݌U?K? t_?f"7?(@@&@"@(@5@:???????wMUB@?n ?Q>O\@EU5V@aY?FZ?m:b@J?T@k)0j@:@ؓtj@DKAw@ؓtj.@ؓtj.@ؓtj.@ؓtj.@ؓtj.@]v@]"~@]v.@]v.@]v.@]v.@]v.@7uS&@7u w@5#.Mm@4PA7K.Qn@4Q.NC,@4Q.NC,@4Q.NC,?Tg@8#@8:@8 >+@8I@8?f:@8@8i@8@8S@8?M6~@8 *@8p@8@8 @8 @?;@ݼhs@ݻD@ݼhs@ݿZ*@ݼhs@ݼ@ݼhs@ݻ_@ݼhs@ݹѶ:@ݼhs@ݸ!>@czH@cn@czH@c/@czH@c)8'@czH@cQ@czH@cR%@czH@c@8}:@8Ht4F@4.5?|@41 k~@3$j~@3$za@3 -0U2a|@3 /@3 -0U2a|@3"Q@3 -0U2a|@3 wǘ?"?NJb4?\Уp?h?[P"mr?@;#?I ?P?5QT?_ڲZ?X1-?^t٤C?*DU?^2+?$G?f?>?'^`N@@&@$@&@8@0??????BlULJ?5Q0?WCiD,F@ݺZME@c2?P?k(&;Z?f-?*@p}U@<@wKƧ@w -=p@wKƧ@wd@wKƧ@{,mIm@wKƧ@~(lQ ? £?>C,4?-! )m?+-/?& ?F^S?WA?l{9َ?{P?cz?;0>SU?\yn? bF#@ڞ|@8*?~6Q=?8vQ?S t?fE@mE@>@]/@]E@]/@]+j@]/@]K]@]/@]/@]/@\C,{@]/@\쿲@u@F@u@e@u@+j@u@$@u@D@u@Ϫ͟@6>6z@684֢@1hr@1'/@/nP@/74@/PH@/ -=q@/PH@/ ě@/PH@/33334?|O?Z?U#? Y?G?W_?| ? {?ܿ?EP? f? R?}??|׿pZ?%ϑ?ˢL1??\@@@@@,@,??????5 -?0?}m?ewx?73A@]@:@F@3 -0U2a|@3 _ -?cD?pvoK?>kj?؄e?1.?cZ? -?sP;?uq?baU?A?Aф?ghZS ?b(!I?8: If?$<B? H?U#ǖ@@(@*@(@2@5??????y&d5?T|?D<3@ܻNި@iZb?v^%@K ?[׬|?jrBt?›e@m@@@m@E@m@ϐ@m@$t@m@ߤ?@m.@m.@/B\(@/X@/B\(@/.Mj@/B\(@/@hۋ@/B\(@/;lE@/B\(.@/B\(.@8]ce@8W>6z@43S@4m]@37KƧ@3C\@3!.I@2K]@3!.I.NC,@3!.I.NC,?Ol?|?i[?[@{@8I@8?^*?+M??ۀl @8S@8?ji?YW?+k?u4@8 @8 @@@@????A@';dZ@' Q@';dZ@'&@';dZ@' qv@';dZ@'O@';dZ@'Z@';dZ@'@A7L@@A7L@ -=p@A7L@Ԣ3@A7L@$/@A7L@Xe@A7L@ӶE@8*0U2b@89Xb@3S@3ۋq @3)"`@3!4J@3 k@2v@3 k@2@3 k@2"`?F/P5?#T?MŴ?'$5?̺"h?5^Y?Cy3?&dU(?5q/? ?$uA?2`?E?5 g?v'X?E^u?ܔ~T?7"U@@@@@(@(??????#ֹvx?SlW?Խd@' ֝@Ydm?s(S?)?#ÝBϙ?7K@@i@B@Z@䛥T@Z@ݗ@Z@.@Z@ں@Z@g8~@Z@Z@ I^@\(@ I^@d@ I^@@ I^@oh@ I^@e+@ I^@ [@3@3wkQ@1ԛS@1Ԣ3@1tj@1ݗ+k@1@5@174@1@5@1n@1@5@1&IR?|O? ?6z@5Gy @1pěT@1o?@1A7K@1iB@03&@0-(@03&@0-(@03&@0.O ?Us@@@@@,@(??????ge?IcےP?B~S?\;@5@'N?b8ym$?7 t!?ϰM$?v24/@fJ;@D@c -=q@c -@c -=q@eo@c -=q@e`@c -=q@c>Y@c -=q@d]|@c -=q@b3@c -o@c -@c -o@c r@c -o@c vK@c -o@c ]c@c -o@c -}Z@c -o@c -(@3 D@3 ,'7@1?|h@1 @1tj~@1 @08D*@08[@08D*@096@08D*@0:,?}x9Oa?7y%?e6?| V?!_a*?Pvo? X?ݞ2?bMn?ّ%?^nu?Z<??j9?k _?bQ? P?xKh???\*?r {%u@@ @"@ @3@1??????Hn:?2?&A4z?$4@!@%?5trh?3!γ M?f&$T?_Uoط@s+O`@F@RnP@RnP@RnP@SPH@RnP@R@RnP@Rs@RnP@R@RnP@QiD@`|h@`|h@`|h@`G@`|h@`$@`|h@`@`|h@`F@`|h@`F@0O M@0O M@*~"@*~"@)ΗO;@)ΗO<@(b~@(~($ @(b~@(~($ @(b~@(rGE8?OW?{j?!!׋7?/?Ot?:?;0? C`?}?3.Yl?@?PS2K?!? ?q6tN7?avh?#.?O|q?@@@@*@,??????=s@X?in}>~'`@RG@` Ľ?%иg[>FVN?G##`L>է5@sU@G@CMO;d@CMhr@CMO;d@CNH@CMO;d@CMhr@CMO;d@CM@CMO;d@CKq @CMO;d@CKP@W -=q@W -=q@W -=q@W}V@W -=q@We+@W -=q@W@@W -=q@We@W -=q@W.C@/?@/A [@,j~"@,64@,O;dZ@,qu"@,-w1@,n@,-w1@,҈q@,-w1@,X?_?{j?,fC6?XQ>? 9?LI?bMn?MN ?ܿ?Kd]?ߒh!?Uw?}+,b?u?|׿pZ?8 ^?B ?A,}@@@@@*@(??????RhOr{l?0!u ? ej@CLo@W+T??#Tm?=?x1o=?1~fla@s -M@H@ؓtj@@ؓtj@ٌ~(%@ؓtj@+@ؓtj@J@ؓtj@@ؓtj@F]@\)@v@\)@!@\)@!@\)@4@\)@4@\)@4@0YJ@0YJ@)j~"@)PH@(E@(+jg@'N;6@'ѷX@'N;6@'N;6@'N;6@'N;6?_\p)?1?N?G?@ A2?ˡK?bV,?5CQ?~Q?6)}?ѡb??R g!ڢ?bMky?~('?oܧ?avh?#.?#.@@@@@,@,??????Cd>=?. >X)@|s@-?=8w7>^|?ud-1> -^S@sy@I@7K@ -=q@7K@ح@7K@h ԕ@7K@R<@7K@b}@7K@ح@fffff@i7Kƨ@fffff@g@fffff@i@fffff@g_o @fffff@g_o @fffff@f@6۹~($@6W>6z@1=hr @1?m!?E 8?ˢL1?2[s@@@@@*@,??????M;fA'?(?֠Ag@_ہ@gt,?ElZ?3GC}Ս?ai :?n=K@j$J3@J@Btj@BnP@Btj@B8YK@Btj@BϪ@Btj@BX@Btj@B@Btj@B!-@cS@c%@cS@a.H@cS@aG{@cS@a.H@cS@a|P@cS@b I^@6+s@6* @0+ I@084֡@0Ctj~@0@'RT@/3PH@/-hr!@/3PH@/-qu"@/3PH@/-(?3a=?]??Kǡ?`?f]G?F/P5?HG^?tw?,~[?M??YE?Ϸ+?W ?hB^?M684?ĭ@@@@@,@,???????OU:×?5&@d[?2Eg@B՘@beG?SlXL?@X]v~?Q?&H@jҒa@K@;dZ@0 -=@;dZ@8YJ@;dZ@;q @;dZ@;qu"@;dZ@A:@;dZ@<ߤ@1@1@1@[7@1@J#9@1@;dZ@1@qu"@1@,<@7֚,<@7ݑhr!@4|hr@4 (@3."@30@2@20U2a|@2@2@2@2Xf??+!?{?IW`g?&tq?@?qn?D?Qc -?l Ĩ?~0d?d ?[?[ș8?ʭ#г_?J?Q?]?H@@@@@,@*???????j'T-?@AP?PiӀ7b?G׾>F@9H@ "?kF7n?g$\/ rU?WP?y@i5(%@L@@\(.@@\(@@ -=p@@\(@@ @@\(@@ @@\(@@O L@@\(.@rk I.@rk I@ri*0U2@rk I@rtO @rk I@rt@rk I@rn.2@rk I.@8YJ.>@4S@4䎊q@3`A7@3~҈p;@26z@2C]@26z@25Xy>@26z.NC,@8J?ϱQm?UD?Kǡ?GU@8@8J?d~?fj$?L?{W@8@8p?J.?_?Oc?w,@8 @@@@*????M@ Q@ lD@ Q@ !-w1@ Q@ @@ Q@ -!-w@ Q.@ Q.@P`A@?cR@P`A@yXbN@P`A@4SL@P`A@o@P`A.@P`A.@7:@7cF@4|hr@4Y|@3gKƧ@5SE@2QiB@12W@2QiB.NC,@2QiB.NC,?5,?P?i?ӓ]@8I@8?E[i)?1?%U??ӗF)okN@8S@8?R}1?d_?:S3V?~*@8 @8 @@@@????N@QR@Q+ @QR@Q@QR@QA [@QR@Q[@QR@QXe@QR@Q[@*WO;@*\j~@*WO;@*YY@*WO;@*["`@*WO;@*T3@*WO;@*^Q@*WO;@*_@8v@85Xz@3kS@3i @3$j~@3!s@2xF^@2fffff@2xF^@2*0U2b@2xF^@20U2a|?2}?DE?'?J?&?!w?A[F?I?fj$?,~[? ?lӪ<?7#!xv? DS?lR?VED?ٔ!x?^^ω@@@@@$@(??????*p?@\?21y6?Z.5$@Q7@*ZP -?SF}?x93Nko?d\?J ;@j xK@O@d/.@d/@[ռ@d/@a@d/@hǒ@d/@jޗ@d/@]D@:p -=.@:p -=@: -}"@:p -=@:T@:p -=@:mޝ@:p -=@9}*-@:p -=@:{^@2|Q.>@,-V@,_Fd@*rnO@*X;@)L/{K@)@7Ȼ@)L/{K@)u?@)L/{K@)B4@8 -Ny?÷&R?-?1)?\'8? *vL@82r?4L?^p@?o?ȎB[0?PR,S@8L?laé?>xLp?ČAv?J{?5@,@,@0@3@8?????P@\G@\Q@\G@\+@\G@\|i@\G@\^5?|@\G@\@\G@\ᰋ@5`A@5`A@5`A@5@5`A@5XQ @5`A@5)^5?@5`A@5Q@5`A@5}Vm@7|Q@7u%F -@3J^5?|@3GzH@3`A@3 -=p@1O M@1@@1O M@1ߤ@@1O M@1̋C?|O?ƿ57?WD@?Uyu#?>C,4?nM?}ѿ,?,T?J?RLnj?l{9َ?vMUu?6E?6?o?Gϵ'?x[:?ad|@@@@@@??????a(?dt` -?@?eoćDj@\71*@5=v?`ϑ2?XR]4?˳<@<*@fr@Q@+@|@+@@+@ޛ@+@@+@"3@+@D@@5@@0(/@@7f@@T @@hNs@@}`<@9cg l@9f'@6}hr @6j26}@5K"`B@5G͝@40@4+ZJ@40@4.vv)@40@4)2?anñ?(?JFvY?^W?)b3?#@?CbyV?eV2?t%I??wo? pA?*??_xҮ8?eX?I?^b+@@*@,@,@5@7???????dʤ?H9?r@2zb@5 ?i -9?KYjP?ҿ'U@ OE}r@gDH]@R@+^Q@+^@+^Q@+Y.@+^Q@+^fz@+^Q@+bu%F @+^Q@+Su@+^Q@+YH,@p -@#@p -@@p -@4@p -@e>@p -@Ǥ@p -@t@6:@6 Ⱥp@3 ě@3wd@3-V@3Ջ@2,<@2h@2,<@2gN@2,<@2?| V?nR?r6x?tf*?Anz;?o^?eXW?_]?5Ey?!Aa*?]Ql?|p7%?` v?S ?ݳKخ?t{i?)`?Wr@@ @(@*@1@2??????W4Sӥp?Rmf?Se@+[v@c?s?Nk߹?svWh?ւ5?t)95@f @S@@ C@@㯷@@r @@ĺ@@p -@@F@R@ƖH@R@ĒS&@R@V+ @R@BѸ@R@5?|@R@ -o@6@66@2hr@1h@1`A7@0m\@1~($ @0u@1~($ @0_o@1~($ @0sPH?I'%?'gjFs?#?l,I?l?XE%:?ɱb)Q?? >?ʻ1 ]?0/f?lINՄ?>?'{%M?HFOu?HW ?l&?b#@@@@@@???????n &ފ?+eg?*|@'ù@Ս?(SI?.@:9B@S-4D@l#߉@T@vȴ9@@vȴ9.@vȴ9.@vȴ9.@vȴ9.@vȴ9.@T@@T.@T.@T.@T.@T.@7s@7+j@4hr .Mm@4q7Kƨ.Qn@4Eu.NC,@4Eu.NC,@4Eu.NC,? @8#@8:@8 >+@8I@8?Ol@8@8i@8@8S@8?xȟ@8 *@8p@8@8 @8 @?U@9Vu.@9Vu@9W@9Vu@9T@9Vu@9W] H@9Vu@9_eQ@9Vu@9\磔@+.@+@s*@+@7+=|@+@ S@+@z7Pb@+@黅@2䎊.>@/"`@/UP@-E@- @.@.+)@.@.% F@.@."O@8 -Ny?N"?bT]u?6ۊ/?tA2?@82r?Oۡ?x?[ ?Hr`?Eг@8L?,CQ??r ?/fD?$+@@$@"@:@6?????V@,A7K@,B`B@,A7K@,%1@,A7K@,:F@,A7K@,&@,A7K@,1@,A7K@,57NL@"1@"@"1@" Ri@"1@" T;r@"1@"uU@"1@"{@"1@"x@5|Q@5@2ԛS@2A4@2ttj@2w)@1@2g̅@1@1l-@1@2_Չ??ˡK?bV,? ,C?LE?@[*^?IM?X78?cPQ?.+? SF?':?l&?Ѐ>(@@@@@,@,??????GXR8??P ?y9@Bz@MF?+.*M5? $D'?Rق@?8lX[.@s@Z@ -=p.@ -=p.@ -=p.@ -=p.@ -=p.@ -=p.@glC.@glC.@glC.@glC.@glC.@glC.@8L]ce.>@3\I^5?.Mm@3Htj.Qn@2 [W?.NC,@2 [W?.NC,@2 [W?.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 [@Ƨ@̋C@Ƨ@}Vl@Ƨ@ڹ[@Ƨ@RT`@Ƨ@0U2a@Ƨ@̲@0`A7@0&@0`A7@0x@0`A7@0@@0`A7@0K]d@0`A7@0C@0`A7@0x@6*0U2b@62W@3 I^@4[6@3~"@3N;@2ޫ6z@22W@2ޫ6z@2N;5@2ޫ6z@2A [?|O?Z.?2~?S0H?"m?S{d?A[F?6c?_@?X}iQ? 7?lӪ<?W Z?eg?zny-i?w%?DV?ٔ!x@@@@@,@(??????7#?QM[?Ar[yq?FLЃ!@lA܁@0?ch?fgǘn?ȧK ?{Q'@i@xWC@\@hx@h+@hx.@hx.@hx.@hx@h},@hx.@~ Ĝ@~޸Q@~ Ĝ.@~ Ĝ.@~ Ĝ.@~ Ĝ@N!R@~ Ĝ.@8g l@8e+a@5TS.Mm@4V.Qn@4h.NC,@4h@4~$t@4h.NC,?{<@8#@8:@8 >+?NMwE@8?UbB2@8@8i@8?@8?\[P@8 *@8p@8?SrY@5@8 @@$??]@fXbN.@fXbN@f\)@fXbN@f?|@fXbN@fܬ1'@fXbN@fǻ/W@fXbN@fE@fffff.@fffff@p|@fffff@oA@fffff@_;dZ@fffff@q@fffff@vz@9~($.>@4?|h@4:S@3"`B@3Ov_@3QiB@3q:S@3QiB@3oH˒:@3QiB@3kQ@8J?7?mq -??h?Ñ$|?Ylp@8J?-c?F?wxR?s~?@8p?}±?zk 3U?f?a?60lP@@@@,@,?????^@x@ -=q@x@O@x@C@x@x@x@~#@x@L/@^j~@^E@^j~@^lD@^j~@^"@^j~@^"@^j~@^hs@^j~@^p @8쿱[X@8 _o@3+@3 IQ@217Kƨ@20҈p@1ce@1H˒@1ce@1q @1ce@1cA \?sD?}d?FB:?_B?oNŒ+??ϱQm?dx/?Rs??UBi?kj? f -?fb?*wjs?,|?/̽`?ܑ @???@@???????XZQ?$U^?&x9@x @^BY0?H&m%?>؝eO?Id^?d(7@q(V -@_@#ȴ9X@$ҋr@#ȴ9X@$]@#ȴ9X@#S/I@#ȴ9X@#|@#ȴ9X@#L4;@#ȴ9X@#$@:e`A7@:VC@:e`A7@:5_aT-@:e`A7@:JAh @:e`A7@:F@:e`A7@:29&o@:e`A7@:9S̀~@87@@8=M@3^+@3M J@2)"`@2+?@1@1A<2[@1@1OS @1@1cKo?en?'AU?ܝLl?-,?QN0P?Ht!?p ?u?%7*V;?qD?=D]?Aǫ?VXl? -&}?jd@@*@(@,@;@:??????k{km?L/d?M@#;qP@:C?hR?j{ۅ?eh'?l`P@k_큊@`@O;@?|@O;@!R;@O;@p:@O;@m\@O;@"7@O;@"\(@:G@8Q@:G@6@:G@B@:G@J @:G@@D@:G@H9X@7H@7҂@4@4^5?}@4!.@3j~#@3XbM@36z@3#E@36z@3!.H@36z@3vȴ?NIɮ?S?괰E?ׅ ?IJ j?EeX?)T?URZ?_S?ѯ%?3&?J佪^?+QK?4?~x?42?n$?Qh@@@@@@,@$???????e ɱj?jS ?C2?Ruﲬ@Jh@CQ%Dr?`H?vv_?–i-? @C@y(@C@҂@C@@%%@C@,/@6>6z@6@@2ahr @2\5f@1ttj@1piJ@10U2a|@1k)yA@10U2a|@1U]@10U2a|@19??Ƹ^ ?ZKbn?(y?lNR? 9N?¨Sp*? \ -?N?G!:+@?g!r@11@*?g=Ȕ9?yw?ק/l@:\@g=0@c@j~@@j~@I@j~@G~$@j~@zs@j~@JS @j~@?;@Z@(@Z@nJЧ@Z@“\_@Z@~Z@Z@a@Z@@8O M@8B)@3\I^5?@3mc@2j~#@3z=6@2J0U2a|@2`5d§@2J0U2a|@2FuJ|@2J0U2a|@2C}B?~?J?Lp1?{6k?ء?Y^z?lz)m?iة?RÚ/q?=E?%č?7gBU?V8?"+y ?T\y?6'F?`ɀM?;nnL?6Ҁ@@,@$@"@0@1??????i]?z`2?/?NxD^?Sq\@5~@8}?r\?Tm[?R5UZ@(Y{d`>@mxjR@d@!O;@!n@!O;.@!O;.@!O;.@!O;.@!O;.@r @bM@r .@r .@r .@r .@r .@8O M@8;dZ@5 I^5.Mm@47Kƨ.Qn@4xD*.NC,@4xD*.NC,@4xD*.NC,?Z@8#@8:@8 >+@8I@8?Z@8@8i@8@8S@8?A@8 *@8p@8@8 @8 @?e@dZ@|hs@dZ@@dZ@5?|@dZ@E@dZ@,<@dZ@"@{T@{e`A7@{T@{e@{T@{Z@{T@{7K@{T@{@{T@{@N@6*0U2b@6_o@1c@1b I^5@0-@0fffff@/#9@/lC@/#9@/)^@/#9@/_o?]?4L?U#?:Z2b?oNŒ+?װ*w?]?{c?A)N?RLnj?q1At?ٶm?*wjs?u/X?=Cb? ??2[s?ܑ ?@@@@&@??????]>li%g֜?AjĦ?2)޿k@܄@{z\L?PTNSL?ApL?.m?xr@sS@f@t@n@t@  @t@`K:@t@_@t@Z@t@@s(r @s(V@s(r @s,@s(r @s9{@s(r @s,]x!@s(r @s#7(@s(r @s0R@6#g l@6"?$@2}hr @21h@@1A7K@1%7@1Y~($ @1OƕDS0@1Y~($ @1Kd@1Y~($ @18i ?~?J?s3O?8?:0b?X"@L?ZIP?}x?*J?I/?9XNu?ٔ!x?->t@@@@@*@*???????e?\IJ?O͍&$Y}?kfZ@q>@8tE6?gAkU?1?ɫ[?iq@a؝\K@h@V.@V@j@V@BO:@V@rjX@V@=^v}~@V@ "@^5?|.@^5?|@@^5?|@|WF@^5?|@`儭@^5?|@̑YA@^5?|@X@@6 xF.>@48r Ĝ@3wkM@4t@3c':@3J0U2a|@3j˹v@3J0U2a|@3'%=@3J0U2a|@3-oO\@8J?݌[?lqa? {?2?u$a@8J?Tɫ?/6Z?t{ ?ϲU?( @8p?1ԁ? F?a?>hi?Ś@*@$@(@4@3?????i@|-V@|Ƨ@|-V@{Q@|-V@{[X@|-V@{M:@|-V@{p@|-V@{q4L@;dZ@&x@;dZ@+j@;dZ@)^@;dZ@@;dZ@˒:@;dZ@u"@5,<@4$tS@2r Ĝ@.S@2 "`B@-(p:@10U2a|@,OiDg8@10U2a|@,LC@10U2a|@,N.2?=fA:?C#%??ᕮ0?j#?b;x?}?U -?00?4FgI?u1?×?؟#ߦ?eo?܉a^?d3>?'d㗅?w,?w,@@@@@*@*??????\P?>Zx?Hif?=L@|YH@#[?@5B ě.Mm@5 -V.Qn@4Ǡ k.NC,@4Ǡ k.NC,@4Ǡ k.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 k@(+?J+? d?3a=@8@8i@8?q?e!?n˓"@8 *@8p@8??oڕ?ĭ@?@???l@t$@tbM@t$@t @t$@tS&@t$@t@t$@t@t$@t@N@Փtj@կw@Փtj@Ց4K@Փtj@Տv_خ@Փtj@Ջq @Փtj@Ք@Փtj@Ջ:)@8s@8&@3R I^5@3P{@2-V@2ѷX@2~($ @2xl"h -@2~($ @2͞&@2~($ @26?'[ V?b =??{y6?>{~? ٖ?pEIt?GKTH?fˌ?"6Wz?4.? ?$s?z?:t?O.ce?Y͍_?wͶ@@@@@*@*???????iH Kr?:}?^Ig/@t0@Տ=?Mj?pG~eT-?zKf?K@3+ I@3p:~@3q7Kƨ@3r`A@3YJ@3fA@3YJ@3 '0@3YJ@3q @8J?V[u9?rPt3?+f?xsi?U<@8J?(S5? ?GW?8wxq?ю? ,@8p?J>?z"2)?dWn?I -Br^?:\y@cWl@*i.\?gwKW?Pct/j?K?#ľz@oYÁzP@q@O@n@O@ 0@O@-e@O@u@O@}o@O@^@qm@bv/@qm@r+%@qm@k!@qm@)G@qm@cq@qm@@7~($@7OKK@2 I^@3{M@2Ctj~@2AJ@1@2*hw@1@1mAj@1@10?wvHf?]u?@Ɲ?sY?D\?gS&?Xd??&^ǘK?њ=? 9fɾ?UK?CO?uOi?Z.?.R?7c=?Y@@*@$@*@0@2???????0J@@?U?f g?jFIo@2@jQ?/???1ȝ?W'@l=V@r@@M@@e+@@A ]@@-w1@@~m\@@~BZe@r-V@r Ĝ@r-V@u\*@r-V@t`d@r-V@p ě@r-V@tɅp@r-V@sZ@6 xF@6Q @2ěT@2|hr@2K"`B@2K I^@1kxF^@1k~%@1kxF^@1k6@1kxF^@1kQ?|O?b}?TS?gk\0? -`?&Gf??UbB3?^ o?aYZq?q1At?7w:?1Q:?*J?' -}C??7?T8@@@@@,@,??????I?B`?"jީ?J_'4U@WZ@r]?F?ch'm?YTl?rdv@mm@s@9Xb.@9Xb.@9Xb.@9Xb.@9Xb.@9Xb.@M 7Kƨ.@M 7Kƨ.@M 7Kƨ.@M 7Kƨ.@M 7Kƨ.@M 7Kƨ.@5G>6z.>@3{ I^.Mm@2tj~.Qn@2G k.NC,@2G k.NC,@2G k.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 t@/@p -@/@p @/@ (@/@6@/@#@/@"@/@/@/@^5?}@/@,<@/@PH@/@(@/@S@2}:@2|>@1I^5@@1"h ԕ@0A7K@0:~@0:S@0H@0:S@0n@0:S@0:~?^Dw'? ?Gy??̒?״?"OJfA?kk?=9l@rFW@u@-@+ K@-@IQ@-@hۋ@-@PH@-@C\@-@#x@[S@[S@[S@Zv@[S@Y@[S@S@[S@V_ح@[S@RW@6cg l@6ca@N@3xr Ĝ@3wE84@2"`@2,@2xD*@2p@2xD*@2oo@2xD*@2or?|O?M?ě?6W=t?19?I? ?>`?#Gf?T?@Ad?S)?D(o?QdЈ?XU@dA<@v@KlC@Kȴ9W@KlC@K^ -@KlC@Kffff@KlC@K @KlC@Kp:@KlC@Km\@cS@zG@cS@bM@cS@iy@cS@hr @cS@eu@cS@g8}@8>6z@8nO@3|hr@3&x@3-V@3u@20U2a|@2c @20U2a|@2U=@20U2a|@2qu"??_X -?Uy* ?~B@F*.@?Ǖ(0?4p'?IQƪ?ts܋֫@f㺛O7@z@(O@(w@(O@(@(O@('/@(O@($u@(O@(8@(O@(!R@zG@zG@zG@{W>6@zG@{6@zG@zG@zG@z)@zG@{qu"@3O M@3*0@/-@/)^@.1&@.Z@.a-w1@.`'RT`@.a-w1@.^6z@.a-w1@.^҈p:?}ѿ,?m0?S[?䆀{6?'ř ?w'?| ? C`?:?>\?݄ ?90?nwf?˛͇q?٤?XLL?SP?fW@@@@@*@,??????? ?60 ? ?SPp@(@zm?V]#?.~?6?h @0@g=ۼp@{@q&x.@q&x@qbP@q&x@tQ@q&x@vzC@q&x@o[z*@q&x@lX@Jo.@Jo@JS+@Jo@<2@Jo@GbJ,@Jo@5_oS@Jo@CKp@6D.>@3 I^@3@3A7K@3xF@3m8@3Ȫp@3m8@3κY#z@3m8@3˗":2@8J?{?Y?e@8p?T#0?ot-k?$e?q?瞧&Ҁ@*@(@(@9@6?????|@ A7L@ @ A7L@ @ A7L@ @ A7L@ \{@ A7L@R@ A7L@꠹@vȴ@ A7L@vȴ@]LKJ@vȴ@y -@vȴ@!Dl@vȴ@b(@vȴ@ E!@4v@4bR@0 I^@0Q@097KƧ@09 w@/)_@/Y2OX@/)_@/౤d@/)_@/E2{L?|b@?ȶ# ?64Y??Mռ?(G?Õ?|b@?/q?4??MCFn3?ä?d"H?pDRg? ?v?h?9yt?Ho@@*@,@*@9@:??????>S ?VCl? N;x@ @ -d?=-ҟ!4?@U?:;?B)@fDj@}@*^Q@*kQ@*^Q@*\C,z@*^Q@*_䎊@*^Q@*_|i@*^Q@*\쿱@*^Q@*\ߤ@jF@jti@jF@j@jF@j_@jF@jy=@jF@jC\@jF@j+j@8qiC@8e@3@ ě@3An@2dj~@2eoi@2O M@2'RT`@2O M@2u@2O M@2($ x?3a=?"2?oq u?{@?_dA?P?qv?Hk#?Qa C?uX?~?'?'[?9o?/X?< N ?OO ?0&YEd@@@@@(@(??????k.t~5(?D={?Etd(@*`tf@jqr?csI?`v!?fĦ9?c|[@m[V?K@~@;dZ@+@8I@8?d@8@8i@8@8S@8?B{ܡ@8 *@8p@8@8 @8 @?@Y@Y@Y@Zw:@Y@W31K@Y@X)W@Y@Wh.@Y@Y2@$/@7K@$/@ -@$/@#Q@$/@9(@$/@p,@$/@! @4w@@4wҸT:@1+ J@1 P@1q7Kƨ@1qU@1iB@1̚}@1iB@1@1iB@1?{si?n@2`A7@2b - @1&@1Zܳu@1&@13>4@1&@1q;${?L?ȱc?4vȺ?B5?]X?˙3HQ?QL?9{?bN|V?M?^YZ8?hՕQ?PU+D?"x?l1Y=3?t'?dO@?ޕ+@@(@*@*@:@9??????<(Vdĝ?@U5M?Kf aXc@B -`@Y!#;?Y""?d`??t -?DJX?r-?,#?s8r?4ډ3?=̘_?PLDǽ?M8@?-u+)3x?"hȣ?@ӄ@;5@CR$?<Rp?[_?s/ꉄ6H?4~L3@s~R%@@V@7Kƨ@V@{@V@ҕ@V@`A@V@5Xy@V@zH@@u@@#@@C,y@@Z@@bM@@3@8DO M@8JJL@2r Ĝ@2U@2i"`@2ju%F @1 k@1F]c@1 k@1L/{@1 k@1:)z?qn?y)3c?=?Kh?U=K?uxY?\.:@?_$?f;m?S?WA?mEB?ey?vA?P<}??GZ?)@Jq?=P|@@@@@*@&???????JVP`?O81?WXEu@`@=e?k ejM?k+$v?ѩ??$@p uÛ@@WH9X@WK@WH9X@WH:Wt@WH9X@WJ@WH9X@W_$@WH9X@WPJ@WH9X@WR@ :^5?}@ )H@ :^5?}@ @ :^5?}@ GRb@ :^5?}@ b@ :^5?}@ $zq@ :^5?}@ i@@904m8@9> @4+@4d@@3KƧ@3*'2!@3?䎊r@3)8@3?䎊r@3(z@3?䎊r@3* |3?3<' ?$?Q?es1x?̛BO/?㾵?sX]?,?'?iɮ?*Ex ?mr)?"?w+*?%AC?8b-Y?2N?keWP'X@@"@$@ @$@"???????a9;j??^5A -?x}=@WSs@ %e?=-?YPd?rsGȴ@1d @@n?@@O^Q@Oa@O^Q@O`ѷY@O^Q@O_ @O^Q@ObC-@O^Q@O`- @O^Q@O[=K@ "`@ "M@ "`@ u@ "`@ Ov`@ "`@ 6@ "`@ @ "`@ _@72@70n@3 I^@3(@37KƧ@4IQ@2ٌ~($ @2W'@2ٌ~($ @28Z@2ٌ~($ @2!.H?UbB2?d_s?^?zRU?] - ?zWmo?sD?’?L?%ja?ۣ0Υ?|[z? t4?qN?;?J]j? .0v?=P|@@@@@*@*??????R-]p(,?K _W?;'y) @O`d@ (p?h-y'b@?\I?Pe?)@k@@-hr@*o@-hr@-c@-hr@.H@-hr@.z_@-hr@,@-hr@,jhM@V -=p@Vپ+@V -=p@V2Ŭ@V -=p@VՂv\@V -=p@Va/@V -=p@V=@V -=p@Vx@6v@6sG@0I^5@@0ܑF@/]E@/]og2@.Z@.jK(@.Z@.HE@.Z@.??Qp?)bӺx?-[o?mccx?or?vURn*?o"?-?%?9dٙ?*_?cؕZI?o#BpW?q6?YF? ?!R#?[Rvs@@,@,@&@8@7???????A!H?F<"?9zY?Pv8@,ms8n@VֈJ?YF ֙?5?L(֬?s -zd@h%xI@@%@ -=q@%@طf@%@]U@%@@@%@޿J@%@\T@ZT@ZT@ZT@Z$Pd@ZT@Z-K@ZT@Z[5@ZT@Z$@ZT@Z@2@2|hr@0+ I@0fW -@0j~@0zP@08D*@0H井@08D*@0C&Y@08D*@0@D?^j?W?Q?# 8֑?c.?Jqs=?bMn?7!?%2}?)Nk@d/@b3@cdZ@clD@cdZ@csP@cdZ@c=@cdZ@c*0@cdZ@c@cdZ@ckP@7`D@7bZc@2i+ @2h4֡b@1ȓtj@1Ǡ k@1!.I@1R<6@1!.I@1}H@1!.I@1)^?1j?5{#?l>?a_b? -`? Mi?)T?I?AuG1?.pC?>H>d#?)]\?Rw#z? U)?^?Z?Tj?GZ@@@@@(@(???????&AH%H?1,;@-?7?@ct/${@c(?RKI?Wy ? ?\R@i& -@@@@.@.@.@.@.@@V@.@.@.@.@.@6 D@6`d@3@ ě.Mm@2y7KƧ.Qn@1.NC,@1.NC,@1.NC,?Br@8#@8:@8 >+@8I@8?@8@8i@8@8S@8?uf@8 *@8p@8@8 @8 @?@|h@vȴ@|h@T@|h@P̒N@|h@6@|h@b@|h@bR@ -7K@ -@ -7K@ -~ߤ?@ -7K@ -sR@ -7K@ -I}Ɗ@ -7K@ -=X|@ -7K@ - !@1_o@1D@0^5?|@0c@/nO@/G&@/Xy=@/o @/Xy=@/9@/Xy=@/I?^j?ԭ)?' ?P4q{?sZ?! ?bQ넛??<6?hg?O?t7T?bF?ʓ:$?tq?#+?xl?>dS@@$@$@*@6@5???????@b8F7?#{F?(}X@>Ү@ -?3.N%6?7~EHbe?axf!@?gz@s+0w@@ Ĝ@KƧ@ Ĝ@cA@ Ĝ@`A7@ Ĝ@$t@ Ĝ@ )@ Ĝ@4֡@`A7L@W -=p@`A7L@vu@`A7L@n@`A7L@ZY@`A7L@[S@`A7L@^Q@7p4m8@7l#x@3+ J@3Y|@2tj~@2Xy=ـ@2u@2 :)z@2u@2H@2u@2 qu"? ?4Kl?ȇ? h?[5?Z?| ?͔{?pI?~m??[h?"Ь?"x*=k?*:'+)?}??Qx?a#?!D@@@@@(@(??????Q@;.?Vp?O?"Ng6Gj@M@YD?l\{?A1t6? -?i]@ex@@H9X@H1&y@H9X@ ě@H9X@CZ@H9X@-@H9X@F '@H9X@G l@\{dZ@\{dZ@\{dZ@[@\{dZ@\]Vl@\{dZ@[hs@\{dZ@\|n0@\{dZ@\|n/@4B䎊@4Bh ԕ@0+ I@1 - @017Kƨ@0>H@0Q@0L/{J$@0Q@0:)z@0Q@0m]?}ѿ,?uM?,Z?$? -`?Rg.?| ?E?S?f?C ;?+d?{V? U)?@A?ԿX?<71?ad|@@@@@,@,??????ZP`58* ?k ?Z 8N@B9>@\s8p?ɖn+k?]3,"@#z%@Sҽt@f[@@@;dZ@.@.@.@.@.@C@ˑ@C.@C.@C.@C.@C.@9G>6z@9H ԕ+@4S.Mm@37Kƨ.Qn@30U2a|.NC,@30U2a|.NC,@30U2a|.NC,?c9X@8#@8:@8 >+@8I@8?@8@8i@8@8S@8?Ćp,@8 *@8p@8@8 @8 @?@I^5?.@I^5?@]yh@I^5?@ŵ{@I^5?@x[@I^5?@'_o @I^5?@7O:@.@@@@Z@@j2@@zxl"i@@t@8 xF.>@5 ě@4_jK@4-V@4b&@4:,<@4LΡm@4:,<@3"`@4:,<@4 PH@8J?Uqd??x@?ݧ?xܬi?Y@8J?CT?a??ٿf|?"QS?U̕"@8p?-q?iI??F?k0?NR\@(@$@&@*@$?????@tj@+ @tj@1@tj@m9@tj@Mj@tj@[W>@tj@bM@~@~7K@~@~n@~@~g8~@~@~ں@~@~p:@~@~@6}:@6~Mj@2S@2@1tj@1R@1a:S@1TJL@1a:S@1R@1a:S@1TJM?Ol?nx?)?6p?ܿ?l? ?j@\"? ?io?f?.?eN?<!?7^|?%y*=?̈- -?5|G?, ?b䖶?| g?Pfl@e, 5@@d/@e`A7@d/@em\@d/@glC@d/@eݘ@d/@b@@d/@aR=@ L@ L@ L@ L_@ L@ KC,@ L@ Kt@ L@ Np:@ L@ N@2Q|Q@2Qhr @."`A@.=b@.cnP@.^Q@.V@.Oo@.V@.N_o @.V@.O M;?OW?%ñ?QX?,rg?y%? Mi?;0?MN ?2'?aYZq?H<?e\p?!??=Cb? mmsi?OO ?ٔ!x?@@@@*@,??????\^?T?1{HN?3JGZ@cO7@ M>?@v8Z?A -?u6?w/.#@sgOx@@ C@`A@ C@e@ C@bM@ C@r@ C.@ C@ xH@}M@}߾vȴ@}M@}@}M@}+k@}M@}zxm@}M.@}M@}ңS%@8]ce@8_o @4hr @4Ov_@4U`A7L@49Q @3!.I@3 u&@3!.I.NC,@3!.I@2?8ȺJ?5b&?jl|?@8I?<3:?}ѿ,?>ÔR?fF?@8S?æΟ=?*c?Y,v?TB?@8 ?6fe>@@@@@,?????@&ȴ9X@&C@&ȴ9X@&ؓtj@&ȴ9X@&n/@&ȴ9X@&jg@&ȴ9X@&l!@&ȴ9X@&}H@O@V@O@xl"h @O@ES@O@|h@O@+@O@*0@6#g l@6%Q@3S@3 @3i"`@3=-V@3 -0U2a|@2)^ @3 -0U2a|@2͗+j@3 -0U2a|@2ֻ?Br?߈J?]!\?ɹ?JjcJ?0Je?F/P5?|? pۓ?I-U4?/x?BHɿ_?]?]FV?btx=?c+?&zQ?0@@@@@(@,???????qGGwY0?`j X`? %@&_ݲ@.L?pM?@3W+ I.Mm@2A7K.Qn@2䎊r.NC,@2䎊r.NC,@2䎊r.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @F1@F^5?}@F1@FY@F1@FrGE9@F1@FdZ@F1@FC\@F1@Fs@=E@>5?|@=E@=@=E@:v@=E@;"`@=E@6!.@=E@:Y@4N쿱[X@4Ov@1hr@1:@1-V@1 @1@1Ov_@1@1}Vl@1@1(?|O?q' -B?RsW?vHn&?2{w?.'?|O?D.x?DP?|}Յ??998? ݎ8? $gv? ݎ8?J]j?o?&I@@@@@(@&???????"+0Q'S,? ) ?9eyv@Fڵ@;y??[>_?Y?4)? u@fA,3@@(\@(r @(\@(p:@(\@+ I@(\@)'RT@(\@'y @(\@)^@Pj~@P9Xb@Pj~@P9Xb@Pj~@P4K@Pj~@P -=p@Pj~@PD@Pj~@P=@5,<@51.@2 I^5@2 k@2v-@2u2a|@2!.I@2sh@2!.I@2Fs@2!.I@2E?Ol?t0?p? -?j?EeX?}ѿ,?c?Kw?>G]!?c?K ?/X?]ivL?Ƌ?l?*Q?E݋N@@@@@,@*?????????7CX?0ōV9u?1_Q@( t@P&=I?Op%?R+F?pN&?m*c@g=@@e I^5@e I^6@e I^5@e9X@e I^5@es@e I^5@e2Y@e I^5@eX@e I^5@eV@0 -=@6ȴ9X@0 -=@# @0 -=@0$t@0 -=@$tU@0 -=@En@0 -=@CS@8YJ@8Q@5)+ @5,j~"@4j~@4҈p@45sh@49^5?~@45sh@4"u%F -@45sh@4t?+-/?@u-I?O?w?r9XY? $Μ$?_pP1?vȴ9@(B\(@(>vȴ9@(8}H@(>vȴ9@(BC-@(>vȴ9@(>Ov_@(>vȴ9@(9@(>vȴ9@(;@8_o@8\(@3sS@3vOv_@2W-@2[ I^@2@5@2-@2@5@2$0@2@5@2F -L0?Br?rk?^@?wX/8?q f?*Mis?oC? ʣV?9T?ݤ`h?c?J佪^?y3?\{?]_Q?vI?C SG?E݋N@@@@@*@*???????D 0Zw?"B?C_>@)Nv]@(=-d?CzV ?_`J?HCK?_k@kڝv@@'fx@'f@'fx@'e1@'fx@'h\@'fx@'g+ I@'fx@'f,<@'fx@'f@kR@kƧ@kR@j0U2a@kR@kq @kR@jW@kR@l1&@kR@o͞@47@@47*@0+ J@0+ I@0t@0,<@/jf@/҈@/jf@/rGF@/jf@/YJ?|O?dY{?&??뤽??V^?<_?|O?; ?ԕ]I?Kd]?x9ξO?]˙$>?|׿pY?%_D?Ol?=rE=?ad|?`i=@@@@@,@*??????#?9Êg0??!&?<;s@'fêK@lap?:l`g܂?\o%R ?+G9?+An{@f@@*A7L.@*A7L.@*A7L.@*A7L.@*A7L.@*A7L.@.@.@.@.@.@.@9,<.>@4!hr .Mm@3,j~#.Qn@20U2a|.NC,@20U2a|.NC,@20U2a|.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @ךv@ךv@ךv@כ@ךv@כqu"@ךv@כ"`@ךv@י~($@ךv@י_p@ě@ě@ě@ k@ě@ě@ě@G{@ě@|Q@ě@ k@2-v@2-v@-`A@-C,@-/;dZ@-/@,fL/{K@,en0@,fL/{K@,fffffg@,fL/{K@,eoiDh?^Q5P?{j?=?Kh? Y?ǹT?CXs?bM_x? C`?S?-I`K?%y*=?J&d?k?bMky? ?YF?͓E'?f_Ԋ?B @@@@@@"??????D[O`?1?!5n@ךE19@@[y?A@4 I^5.Mm@2-V.Qn@2!:S.NC,@2!:S.NC,@2!:S.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @)l@+ I@)l@)'RU@)l@,1&@)l@,"h @)l@)@)l@) @Q@tj@Q@74@Q@C@Q@ '@Q@kP@Q@ȴ9X@5ks@5ku&@2hr@2V@1Htj@1HYJ@1 -0U2a|@1 =K^@1 -0U2a|@1 -L/|@1 -0U2a|@1 s?}ѿ,?`[?1f_?W0 ?,I ?C!?|O?V"y$R?4M^?EP?2}?Qʾ?]?.]L?m+&? mmsi? Ğ?]ߒ@@@@@,@(??????0`=?2$l?5N4 -FZ@*~ժ@q?Rܜ^ ?UWm`??k?9uy@fva @@7mV.@7mV@7y0 @7mV@7ڹ[@7mV@7A7K@7mV@7FA@7mV@7c @ltj.@ltj@kvC@ltj@ktF@ltj@kĵ?@ltj@k@ltj@k*@6p4m8.>@2G+@1C\@17KƧ@1jW&@1 k@0%2@1 k@0;5X@1 k@1@8J? b}/?-_?C:?5}?̔J>@(@8J?[:|Q?.%?r?ǘ(K?% @8p?ɅoiE? -e?zY3???@@@@@,@$?????@E@O;c@E@T`e@E@j~@E@_p@E@@E@u!@%`A7@$S@%`A7@')_@%`A7@& -L0@%`A7@$oi@%`A7@%o@%`A7@%m\@8zqiC@8{C%@3S@3>@2"`B@2:@1䎊r@1Q@1䎊r@1Vϫ@1䎊r@1͞?}?5{#?]P?TnE?X?6 '8?F^S?yom?B<\v?G>G?? f?,+?\{?z_??)@Jq?]ߒ@@@@@,@ ???????S2O?/q?W䱶V=? @Xd@$U&v?x^ e?37?=?^6z@7 3@3uS@3q}-@2q7Kƨ@2Э@2V!.I@2g0-@2V!.I@2a -K@2V!.I@2d1Hf" ?x/0 ?a4ޯ?ƛ?<鲖W?|eP:?!o ?~Ov_ح?xj~?cG4W#?:&??ҧ| -?a>1l?"ܰ?D\e?8ɔ%.?*$]+?u"I(@@"@&@*@7@:??????t`^:?p._+?dY @ggr@Ql?o?z߹@!:@@ts$HR@h@@m\(@mc4@m\(@my:.-@m\(@mbp@m\(@mwM@m\(@mvAA{@m\(@mt@hbM@ho[U'@hbM@h;@hbM@h؝@hbM@h@hbM@h@hbM@h'@8?@80u/p@4&+ J@4[i@3lj~#@3R>І@2[W?@2syZ9@2[W?@2hXѩ;@2[W?@2v ?C/?j?;?W秕???ek?n%t?@^8"B??~?`?2?1CW6@1hr@1~k@+@1Ft@10ggU@06z@0f@06z@0y@06z@0˝%J@8J?|Bn?Ώ?wJ?e?,XsG@8J?F1Q?KcU??mw?\q'@8p?%c+5 ?$4;?/>?ZQ??7@*@,@,@<@:?????@CI^5@CƧ@CI^5@C%F -@CI^5@C@CI^5@Cg@CI^5@Cqu@CI^5@C~($ @#Dt@#KQ@#Dt@#IrF@#Dt@#;dZ@#Dt@#EQ@#Dt@#C -=p@#Dt@#A@7*0U2b@72X@3 I^5@3@N@3q7Kƨ@3oحV@2@2߱[W>@2@2\@2@2܄??}ѿ,?tcN~k?ِ?btx=?bJֵ?"/Y?h??[45?Kd+?1`?ۣ0Υ?~Y?D(n?J>?L?#ѧ?x?\,!@@@@@&@$???????D p_<r?MZW ?)fk@C%n&@#E6?q8c?GRDj?k?b7@ky@@@@>vȴ9@@@>@@@>쿱\@@@;J#9@@@B7@@@Ae@ Xtj@ Xtj@ Xtj@ ZY@ Xtj@ Xe,@ Xtj@ Y+@ Xtj@ Zxl"h@ Xtj@ Z,<@6:@65Xz@2+ @2ԕ*@1V@1;5Y@1iB@17Kƨ@1iB@1iB@1iB@1|Q? ?@)M?ojVrn{~?7D -?Ol??tWZ?< /0?=.e1?|[z??Ãx?Z?2?0&YEd?՘]G@@@@@,@(???????A%7?<0?I.q?*)@?*@ Y}#?i{q?8޲m?-畺?w&,Yj@g\@@&x@_@&x@ @&x@_A@&x@G@&x@Gu@&x@@+ J@W@+ J@,Ue@+ J@2@+ J@@+ J@IU@+ J@}H@95S&@98^@^@3r Ĝ@3v@3-V@2締M@2iB@1An`@2iB@1=Ŷ@2iB@1+?5T?HT|?='f?u"L?|.?Sj?Λ?iy?شc?3PD?N?EYC:?[h ?M69!t?Nv\b?%&P)?@g?Y4@@ @(@&@5@8???????yɦsn?vNU \?g@v @t8?s"ZO?7@[SY?gS{@m)k@@WRnP.@WRnP@WR@WRnP@WRs@WRnP@W]-V@WRnP@WU!S@WRnP@WVl!@$/.@$/@`A@$/@_ح@$/@PH@$/@@$/@D@5|Q.>@1^5?|@1SMj@1-@1hۋq@0YJ@0z@0YJ@0@0YJ@0zxl"h@8J?ru? ?wn-?0 碽?6|Ob@8J?s?0˱[?V\F?9?c5W@8p?iTC~t?z_?.SM?DV?|)-}(@@@@,@*?????@l@߾vȴ@l@}H@l@A@l@_o@l@1@l@84@R@glC@R@_˒:+@R@_|h@R@Y0 @R@c9@R@w4m@8?@8A [7@3sS@3k6@3t@3|u"@20U2a|@2n@20U2a|@2x@20U2a|@2lQ?}ѿ,?d`w?P I?Q+v?xsi?Z?`m?}y?#?Q?n ?aG=)?T̅?*T?yC?k2m?vI?kK)@@@@@(@,???????!!@?rkh?gG1?r9zP[@i@^?$#W?Kd>@vfK?tY}@meB%V@@r-V.@r-V@;dZ@r-V@Em\@r-V@4@r-V.@r-V@%F -@:=E.@:=E@;3@:=E@<@:=E@@3c@2%?@27Kƨ@1Ov_خ@2=ce@1 b@2=ce.NC,@2=ce@1@8J?ްrQ?z?|JA]@8I?/8J@8J?ܟ~yv??p?ҝ @8S?`u%l@8p?&Z#?-BR1?wf*-n@8 ?<͸R@@@@,????@o-@o-@o-@p\@o-@p?q`@o-@pE@o-@nk]@o-@n-@m@-V@m@Z@m@\@m@@m@iۊ@m@@3^H@3^1xT@0?|h@00j+@.ΗO<@.΅VGL@.=Vl"@.1X?aՊ5h?5Y*?5Ʌ]A@~@_%X?S@TTF?S9?pB(?Z@d"nR@@-V@lD@-V@ 4m@-V@#Z@-V@b~@-V@H˒@-V@+k@)7K@(5?|@)7K@(_@)7K@(u%F@)7K@(BZb@)7K@)T@)7K@)4n@7,<@7A [@3hr @3@36-@32M@2fYJ@2jC\@2fYJ@2`@2fYJ@2`oiDg8?q!U??]P?Z)?K/?! ?ٛP?ew?L94?cgp?B ?vk? # ?J?Q?cӗ1?E݋N?3@@@@@,@,???????6H"gH?MӬ ?@]F[4?N,>@dqt@)W*?Z]?h~?,3?3-7O@m>@@@f?MA8?/`?*WF?bM_x?#maЀ?90?>\?A B{?N`?bMky? ?|׿pZ?͓E'?l&?f_Ԋ@@@@@,@,??????QTVh5 ?+bTw>"vF@<іf@i]M8?:z~>گ?q8=T>𣭁>@s A0@@lD@lD@lD@lD@lD@@lD@n/@lD@5Y@lD@m@;dZ@;dZ@;dZ@@;dZ@H˒@;dZ@|h@;dZ@o@;dZ@$tS@.5Xy>@.5Xy>@(vt@(v4J@(dZ@(~%@&`d@&m8@&`d@&m8@&`d@&`d?^Q5P?GA?S?MA8?@ A2?:?bM_x?%F?A)N?/Z?ѡb??R g!ڢ?bMky? ?oܧ?avh?#.?#.@@@@@,@,??????!]%d?pO`>8#L8e?ߩ~@Y$@_~[?!_?zG>';?)E1@s@@ -=@ -=p@ -=@a@@ -=@H@ -=@v@ -=@&@ -=@+j@ I@`A@ I@捸@ I@!-@ I@思IS@ I@4m@ I@Z@8YJ@8xl"h -@3 I^@3 (@3`A@3Xe,@2sh@2C-@2sh@2O M@2sh@2a@N?I~y?+W??1t??5n?[N#?ѱRC@nPw@@bM@Q @bM@r@bM@F]@bM@73@bM@l!@bM@ȴ9X@]"@]|h@]"@]҈p@]"@^'RTa@]"@^'RT`@]"@]䎊@]"@]@4v@4cA @0sS@0sS@0'KƧ@0'sPH@.'RU@.`A8@.'RU@.D@.'RU@.&x?|O?[e+@8I@8?W$B@8@8i@8@8S@8? T"@8 *@8p@8@8 @8 @?@`B@_$@`B@{mK@`B@n@`B@XU~@`B@CV@`B@֏]@#|hs@#d@y@#|hs@#o!> V@#|hs@#jhKI@#|hs@#: @#|hs@#v=@#|hs@#y@8O M@8t*wc@4+ I@4L@3 -V@3 5K'y@2@2άB@2@2zjL,@2@2сΊ?7 ?heS?]|??w?)6?gV?5T? 9~?s^q? ?(?Ѐ>(@@@@@,@*??????[J>,?:+/?*f~V@~q#@4n6,?I??i[? ?4d{@s 'ͅ@@Y Ĝ@Y@Y Ĝ@YE@Y Ĝ@Yg@Y Ĝ@Yݗ+@Y Ĝ@Y{@Y Ĝ@Y @J^5?}@JzG@J^5?}@J^5?}@J^5?}@Jc@J^5?}@JS@J^5?}@J=@J^5?}@JC\@5:@5B@1 I^5@1s@0ȓtj@04֡b@0 k@0zH@0 k@0K]d@0 k@0/V?1j?W[?TS?A%?@@No9?t??jכc?C\?]bn~?c3c(? R?X?9o?{W?=rE=?ˢL1?fW@@@@@,@*??????500?Q&?2.rP?A x@Y0C@J. ?TPa?]Nᩨ?7ѓ?oRf@loN|D@@-V@0bM@-V@,@-V@1N;5@-V@2@-V@*g@-V@14K@j~@0@j~@"@j~@ -=p@j~@C,z@j~@H@j~@4n@7O M@7-@2ěT@2H˒@2v-@2t9XbN@1&@1- r@1&@1 k@1&@1Ov_خ?^*?hX*?K"?Q6@(@!e@;dZ@x@;dZ@'RTb@;dZ@;dZ@;dZ@8}@;dZ@ qu@;dZ@Xf@6[~($@6[m]@2S@2 -=p@2v-@2v,<@1sh@1+ J@1sh@1n/@1sh@1 '0?|O?" ?^?_??;?-/ge?}??xrI??>#?/ȫ?J>?tK?ZaP?*J?' -}C?l?P\?0&YEd@@@@@,@ ???????OvqU??>$Yb?DbH@"} -@ -?`w?dYg{?썹?z@is@@R@g@R@+բ{@R@0T@R@kQ@R@x E@R@"N@aG{@`A7L@aG{@dU>@aG{@` o@aG{@dYĜP@aG{@`\A @aG{@`s@5D@5:@2+ I@2@1M-V@1N1.@0@0w*h@0@0r~_@0@0rn?|B &?AI?3)?]S&n?Bc^?ML?~?J?bs?e`?-GB?x;q?s Ge?v,?m$f?煚(? {7?,G]Lk?43#C@@&@&@"@8@3??????>?qp?3ҌLJm?/Ǧ@@`0u?SB)?P JG?{X\?"p@g2 3@@x@7Kƨ@x@vj@x@Z @x@ d@x@wZ@x@e}@vE@w -=p@vE@w~[@vE@wt@vE@wW@vE@v-N$@vE@v_@4>6z@4L<@1+@1;kb@0;Ƨ@0U;X@;r@vf?`) ?2}sX?̊sJC?qsXX@fWy@@@@@\@@V@@̿[X@@Vϫ@@̲@;;dZ@;;dZ@;;dZ@;5?|@;;dZ@;҈p@;;dZ@;6z@;;dZ@;5?|@;;dZ@;@5(YJ@5(*@1 I^@1~@0"@0쿱[W@05sh@05sh@05sh@05?@05sh@051? ?]Û?4!p?Њ?1 v?t? ?`5a?ܿ?ą6 -?&Tm?U3p?CwB?)Zw?{W?':? -t?ܑ @@@@@,@*?????? -&i?I -3? CqN@̯p@;+(?%f{yr?.& tg?VP-"?dsl\@gQc@@EQ@EQ@EQ@FD1@EQ@F2w@EQ@F?t@EQ@D B@EQ@Dz@7K@7K@7K@[*@7K@af@7K@q@7K@(@7K@c1@1H@1Y:F@*7Kƨ@*A [@)cnP@)b}Vm@(oi@(TɆ@(oi@(*0@(oi@(̢?^m d?6?tu?D?1%(??bMn? -i*.I?~4pU?/d?a?M)á?g"e)?Sg?p7?9wT?=>(?3`@@*@,@,@2@5??????Kw0,R,?4;W'? .@EtC@vq?CrSy`?@?sQ ?(ԑ@s@@4nzH@4b I^@4nzH@4$/@4nzH@4~@4nzH@4;dZ@4nzH@4z1@4nzH@4A7M@TF@y+@TF@b\(@TF@JL@TF@[~@TF@T9Xb@TF@Y_p@9|Q@9=K@4f+ J@4PD@3KƧ@3Fs@3~($ @3@3~($ @3n/@3~($ @3?G *ǂ?ʖSS?+*u?m}9?7?+`N?g;+t?,?W@3t? ;q?ިo?)AL%?#IӨ&?$jB?bO?3l]0?Nty"?a#@@@@@$@$???????qeH4pk[?h@B_“?i_Rz@4{tR@[@드?g w?W9Mj)?? 0@p erd@@49Xb@/;dZ@49Xb@fC@49Xb@Gz@49Xb@@49Xb@T=@49Xb@uZ@Ƨ@W;@Ƨ@+@Ƨ@,<@Ƨ@` k@Ƨ@i] @Ƨ@x>G@77@@7֎@2sS@2@`A7@1Ͳ-V@1Xe@1QiB@19oiD@1QiB@1*ۛؽ@1QiB@11D?|Ί?gV)?t|*? ?t]2?;Xb?Z=?L}? @S?P?s8:?߼K?@#?X{?eN ?wb?=?g;d7@@@@@0@,??????p_<~(@?p}bM#?{lRPp8@^n@p?_mT?QO6@lh.@,T6Z@g-MN@@+n@+S@+n@+\(@+n@+t@+n@+n@+n@+S@+n@+|i@rXbN@r@rXbN@r^5?}@rXbN@rdZ@rXbN@rdZ@rXbN@r+@rXbN@r"@3mv@3mv@1S@1&@1_-V@1^6z@0u@0oi@0u@0m\@0u@0%F -L?1j?}d?FB:?_B?DE?}?|O?dx/?Rs??tP*?90?nwf?fb?*wjs?,|?ܑ ?+C@???@@??????@;Po?4ϿZ#?l(@+]%5@rL,?VYY9 ?4s tA?*&?r`r:@fjhu@@4S@4@4S@4 -@4S@4(SBl@4S@4lZA@4S@4Sz@4S@4>@\|h@\|h@\|h@\xR@\|h@\8M@\|h@\Ğn@\|h@\GX@\|h@\ ph@7+s@72nO@3ahr @3`@2`A7L@2սW糏@26z@2S@26z@26:@26z@2 -Vh)?`/.~? ??L -v?0Eke?ׄǿ?CF?nO@4r Ĝ.Mm@3t.Qn@3L[W?.NC,@3L[W?.NC,@3L[W?.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @[S@ަE@[S@ZHe8@[S@߻ S@[S@ON@[S@E@[S@Oђ2@:DT@8G@:DT@:S[@:DT@:AѦ@:DT@:p@:DT@:ypى$@:DT@:U@7 xF@7Iܓ7W@2hr @2s͇@2Ft@2A@1,<@1tqߖ@1,<@14~1@1,<@1]ZNh?ݪ?:??σ2? -4:~?`XO?-ո6?8%?Xh?p?, Gq]?E?#?ޠ>?I|[O?B%M?uS1**?֦b?0U@@*@&@$@.@7??????E?f-?tr_?wTԁ@K4@:?B?+i?Bl"?BA?!l@r0ul@@tj@tj@tj@ -=p@tj@+j@tj@B@tj@@tj@>6z@ ,1&@ ,I^5@ ,1&@ /-@ ,1&@ /v_خ@ ,1&@ 1&x@ ,1&@ .V@ ,1&@ *0@7}:@7\O@4}hr @4zqiB@497KƧ@45+a@2Q@2JL@2Q@2مoiE@2Q@2#9? ?t,?.#Y?ˆ_??S{d?h??ڲt?cGo?N6?+!?K ?`Ƕ?qJ??Eq?x2?7?P\@@@@@@???????B90'Þ?7?MǿtF@ @ - *?[oT?jkK > ?J ?̧E@kHa@@0 ě@1l@0 ě@0`A@0 ě@0:~@0 ě@7O;@0 ě@7>6z@0 ě@:Q@e@e"`@e@eȴ9X@e@e2@e@e6@e@eE@e@e3333@8B䎊@8@ qu@45S@4.Q@3Vu@3=p -@3\Q@3XXy=ـ@3\Q@3JfB@3\Q@3Jn?qn?u:|?Aox?vI?1BZ@H1&y@Fs@H1&y@H@6|Q@6@3S@3 ě@27Kƨ@2;5X@1xF^@1@1xF^@1e+a@1xF^@1Xy=ـ?|O?PƧ$?4 b5??ԁ?"/Y? ?,T?f?P?BnF? ?IH!w?W;RS??]b?=aw%?{2?w w@@@@@*@*???????<<H~X?J,!zv?,=ڔ'@ =@fbOm@@ě@ě@ě@!gQ@ě@B@ě@e/@ě@@ě@1u@l1&@lC@l1&@k1@l1&@l9]5@l1&@lm0@l1&@lz@l1&@l@.V+jf@.VOv_@*"`@*򐫵@+x@+Xe,@*C\@*@*C\@*O<@*C\@*>r?^6P?\f?2k?:M??= -M?bMn? qb@??5ߨ?j?RZ8p?bF?3U:?p풟?ć8?t.? -@@(@*@(@4@5??????&a? -lj@?iV?,@L @l3?3-d?PcW??)ON@sK@@bM@@bM@@bM@+ I@bM@@N@bM@C2@bM@ 1s@@ci@@a@@-@@Xy>@@`)@@v@@7g l@7$`@2+@2حV@26-@2!A [@1&@1ߝ-V@1&@1ZSUZ@1&@1ˍ?ɱb)Q?P1"?GM?3҃?U?޽/1c?/?z?3fvI?ZzZ?5yS?rC2?TȻL?9WTW?3 q?K쯎?^'?t^]7]@@@@@0@.???????R.Uh>f?7_,?TybZ@=n@O~?YK寮?tg?znJ?== @lN@@%@%bM@%@%踎@%@%d@%@%1H@%@%P@%@%e@V@+@V@@V@4¹@V@e@V@1@V@M@2 _o@2 _o@0+@0@0q7Kƨ@0p9Xb@0!.I@0rɮ@0!.I@0]@0!.I@0?^j?$?S24A?nhW?q?G?bQ넛?z,?RE?r?:i?'aJ?bMg?Ȕ? -?N?{??ŧ@@,@$@$@3@,??????UK?6@?A'f~8?- qM9@% -@c?P?;2 U?x'b?olwi9@r @@ffff@$/@ffff@,>@ffff@J@ffff@g8~@ffff@n@ffff@쿱[@d;dZ@d;dZ@d;dZ@dvȴ@d;dZ@d"u%F @d;dZ@d"wk@d;dZ@d%oiC@d;dZ@d,@4@@473@1 I^5@1u!R@07Kƨ@0- r@0}ce@0zg -@0}ce@0zG{@0}ce@0vϪ͞?|O?Kb?&P?ھ۲?>C,4?ZzZ?}ѿ,?; ?I?pFs?c?~Y?3Z\?u/X?],m=?0?:1?$jB@@@@@*@*??????Ri?b?4f?@w u@i@d#48?T~W?`Z?q?ؠi1@f65a\9@@Q@v@Q@4m@Q@4@Q@X@Q@G@Q@-@O;dZ@M@O;dZ@TSN@O;dZ@Q@O;dZ@Q4K@O;dZ@Y @O;dZ@V8YK@7L]ce@7M8Z@3° ě@3n.@3)"`@3+qu!@2s&@2sZ@2s&@2s&@2s&@2qR?F/P5?@K/z?zjʩi?H?X?|&?)T?tMP?4FgI?kH?k?V.H?8*?3a=? t4?cӗ1?DV? N@@@@@*@*??????L ]?`~M,?>iP=;1?E6F5 @o#?ǻ(@h36@@V@Ƨ@V@hr@V@rGE@V@6@V@PI@V@74@g@g@g@gu%@g@g C@g@gQ@g@f@N@g@fiDg7@6:qiC@6:Q`@2 ě@2vȴ@2R`A@2An@2m8@1R<6@2m8@2\N<@2m8@2 -Ov`?F/P5?܄ (?.? S~?k!e?P;rp?|O?{c?(?{k4?Wlz?#:d ?W'?ZaP?`F?LO?zY3??zy? Ğ@@@@@ @*???????bYOilT#?G -n?U@/Q@fQx?f?tzb?z]p?h[J@dj@@ ^5?@9X@ ^5?@@ ^5?@˒:@ ^5?@y @ ^5?@ oi@ ^5?@ -L0@$/@,C@$/@:G@$/@5?|@$/@1iC@$/@.V@$/@)ᰉ@7>6z@7ohی@3TS@3I (@2A7K@21'@1YJ@1߱[W>@1YJ@1A [@1YJ@14J?| ?(R?|6zj?'$5?+@8I@8? -L.1@8@8i@8@8S@8???;@8 *@8p@8@8 @8 @?@l@l@l@҈@l@~#@l@ԕ*@l@Xy=@l@qi@nO@nO@nO@mhr@nO@l>B@nO@r@nO@o'/@nO@nV@4G>6z@4GKƧ@1W+ I@1WzH@1Z~"@1\j~#@1(@1+q @1(@1*Ov`@1(@1(4֡b?}ѿ,?Čۨ1A?aR ?b?ɿ?mׁe\?| ? ,C?{d?EP??Z)?y8#?§d߱?Z?v_.^??WZ@@@@@*@&??????%<?'/;?)~o?;SC@+@o7 -+?IQ(?[??i^!?Dm -@f8@@ I^5@ -=p@ I^5@(K]d@ I^5@4!-x@ I^5@ -L@ I^5@u%F @ I^5@ hr@xQ@{dZ@xQ@t@xQ@tj@xQ@w@xQ@U?|@xQ@m q@7}:@7wXe@4@4Zc@4`A7L@4/V@3,<@4oiDh@3,<@4@3,<@4C,?oC?y)3c? +~?d? ?i]x[?sD??W?Q Q2? 7?:;?B?:!;ى?g`u?=!W?5.?L4@@@@@&@&??????$jaxO@?To ?iX6P@ ^&Ϧ@l;?uU8'&?rCW?AD]@̘ؽ@hB@ @@m@ -=@m@,@m@`d@m@ '@m@J@m@C-@Z@@Z@@Z@u@Z@+k@Z@XbN@Z@2a|@6,<@6Xe@3?|h@3t/@2j~#@2쿱[W@2p@2ZOv`@2p@2Zd7@2p@2^;5Y?}ѿ,?mvrDž?=wD?&!+?6v;v?x2?3?+ߎ @@@@@,@,???????g^mn?rC??WPQ4{?X|3L[@SA@Op?n7^U?o5r?,zc?ʦ.~W@^~@@u\).@u\)@@u\)@[s@u\)@Įߤ@@u\)@ĭ(@u\)@7@U;dZ.@U;dZ@W@U;dZ@X-V@U;dZ@X/@U;dZ@X9#x@U;dZ@X12X@6!..>@2@2˒:)@2~"@1P@1@5@0u@1@5@0:)y@1@5@0ȴ9X@8J?N:'?Dwhg?ѻ ?Ѧ9H?=J7@8J?_;$?srlV?GJ?b)ۑ?o@8p?KQ5?;N?_c?GX?!S{uu@@@@,@*?????@-hr@.+@-hr.@-hr.@-hr.@-hr@64@-hr.@"`B@!$/@"`B.@"`B.@"`B.@"`B@J~#@"`B.@6۹~($@6C\@5^5?}.Mm@3Ͳ-V.Qn@4(.NC,@4(@4x@4(.NC,?|O@8#@8:@8 >+? rL@8?2}@8@8i@8?**ɫS@8?,1'@8 *@8p@8?=i@8 @@(??@@-V@@poiDg@@z@@&@@,<@@r @ Ĝ@7@ Ĝ@J@ Ĝ@1@ Ĝ@zxk@ Ĝ@*0@ Ĝ@u%G@9 D@8JG{@4S@4>BZ@3dj~@3d7@35sh@3V@35sh@3^v@35sh@3U8YK?9?iedA?q{?s?yH?>>?pn?D?v׆7? '~?]%?*ML?Й8??$̤T??:L]?[Y?-B?_! @@@@@,@$???????\Lu@?l%?vG\q?{>z@@g?}0Xy?<3?nϖ9?#,@uRrh@@t@ qu@t@ =@t@Q@t@b@t@89i@t@܌+@n@-@n@{X@n@}9@n@z@n@}iGt@n@y@7ks@7e@ @3 ě@3&`@2{Ƨ@2~C/@1@1]@1@1N@1@1o?|B &?tی?=x?*4Ie?][?0~W?R ?Q?4ku?]dMJ? -lr?Z?>p??#q?1B!?aiJk?㝠Tn?] @@(@,@,@8@3??????\sTS?11tf?]7@Pf@[#?S?{ Vs?}}?AW@k!83@@S.@S@Ӂ7K@S@c -=q@S@B\(@S@͞@S@Z@ȴ9X.@ȴ9X@<@ȴ9X@ᰊ@ȴ9X@'RTa@ȴ9X@m\@ȴ9X@7@8@.>@4@2$/@3t@28YK@2,<@1͞@2,<@1@2,<@1ԕ*@8J?E?o" -?~a?us`c?~G@8J?q?(T?fY|h?NMpZ&?@!"@-V@S8@-V@w;/b@3S&@3@/j~@/'@.mO;dZ@.cn.gJ@-#Z@-^5K@-#Z@-Zv@-#Z@-m?gQ?r ?KI4?'I ?&J?Vh -?}@TΥ?h?}% '?RLB?1b?\U?Ykd?-k?!b??? ?}@@@@@4@4??????I1D?Ufd?B&qL?Mz?4'f?r48@ghtZ@@8U$@8R Ĝ@8U$@8,VϪ@8U$@8U?|@8U$@8jJM@8U$.@8U$.@O;dZ@Hы@O;dZ@+P}@O;dZ@$ x@O;dZ@K]c@O;dZ.@O;dZ.@8 xF@8Ni@7 ě@71ohی@5"`B@6l@5._o @59JE@5._o .NC,@5._o .NC,?x/0 ?\5#k?Fv?Eu]@8I@8? 1Ӡ?V ?Cڶ?rpв@8S@8?#n?M#?%׀_?oh@8 @8 @@@@????@e޸Q@e"@e޸Q@eව4o@e޸Q@eح@e޸Q@e'RTb@e޸Q@eE@e޸Q@eݗ+k@œ(@›lE@œ(@œ(Ž@œ(@šY@œ(@›~@œ(@œ@œ(@œQ@4įO M@4ļj~@08r Ĝ@08Q@/&x@/_p@-`d@-!-w2@-`d@-J@-`d@-?|O?$?$C@? Iy??wZL?|O?0n=Q?A)N?@Cv?<U?M\ٓ@?m+&?.x?8*?':?M684? Ğ@@@@@*@"??????&[ ? E@?0f$C^Q?<'5@e5+@›?PYPBK?6thg1??{L -?1@fNU@@Z@T@Z@߉ @Z@~:@Z@L!@@Z@ߪ-ڛ@Z@dp@+@@+@ͨ~@+@RHg@+@e@+@}@+@x@7*0U2b@7ة@2sS@2sYjq@1tj~@15xΆ@1._o @1,/@1._o @1,)&$@1._o @1,XC -?o"? -"?x?? -E?ָ?¨Sp*? ?&:η?R?T?'U?놱_?CϐR"?&C?Po{? uv?{j@@ @(@&@1@1??????f訛<Ow@?Q"9?)@wQ@k?qBjF?Js?Sa3=?b@hǁ:@@hr!.@hr!.@hr!.@hr!.@hr!.@hr!.@$/.@$/.@$/.@$/.@$/.@$/.@3YJ.>@0+ I.Mm@/O;d.Qn@/873.NC,@/873.NC,@/873.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @$G+ J@$C -=q@$G+ J@$E8Y@$G+ J@$H1&y@$G+ J@$Eں@$G+ J@$F@$G+ J@$Em\@h\@f$/@h\@g@@h\@glC@h\@i^5?@h\@hۋq@h\@i@7_o@7*1@23S@23MjO@1tj@1u%F@1=ce@1=<64@1=ce@1<쿱\@1=ce@1@n@˒:*@)š@)š@)š@)L/{@)š@)S@)š@)Ƨ@)š@)8Y@)š@)oiD@0s@0g @*"`A@*s@*XF@*X4֡b@* -#9@* lE@* -#9@* -Ov`@* -#9@* -0U2a}?^Q5P?{j?"?MA8?g?$?bM_x? ,C?j?1'7?ߒh!?Z,a?[h(?6?q6tN7?͓E'?O|q?Ѐ>(@@@@@,@,??????AF4Ր0?)/kr?#lE @9 @)0?89*uM?2cـ߹?lt3B?]@sk@@zG@{q@zG@|+N@zG@]V@zG@@zG@njV @zG@Hq@B\(@9"@B\(@AʉB@B\(@S;@B\(@?,͡i@B\(@D@B\(@E@82@80M@4Lhr@4M@vƨ@3j~#@3?K@2m8@2Ӯ2r@2m8@2qۑ@2m8@2 G-?Z=?H9?8NJH??  ?s5t?@>?7!,%?,e?DQ |?Y*.?$'^Y?r?w?& d?"Ux?bewFA0?{<K@@,@,@"@8@9???????p?UF.?R*-e?'zׇdm@񮌎@@XZj?tn?B/^4?1$??"_@lJ@@9XbN@9a+@9XbN@:@9XbN@9XbN@9XbN@9~(#@9XbN@8PN@9XbN@9 ~1C@_;dZ@_;dZ@_;dZ@^5?|@_;dZ@]/@_;dZ@^Ov_@_;dZ@^@_;dZ@_:ǭx@1䎊@1&IR@,kƧ@,k:)y@+E@+Ov_@*L/{K@*L/{K@*L/{K@*$/@*L/{K@*b=?`U8r?GA?N?XQ>?O8?_?bMn? ,C?|,!?4ډ3?֧O?H+m6?bF?u?y8$?͓E'?v?󰉋@@@@@,@0??????/3q@?(?wy -hO -?{5@9;k@^l(u?&܉?ϧ?H>[0?3pw@s kXg@@hR@hTj~@hR@hKjg@hR@hL@hR@hP)^@hR@hNMj@hR@hMU@7Kƨ@C@7Kƨ@8X@7Kƨ@~($ w@7Kƨ@J@7Kƨ@!R@7Kƨ@Z@5]ce@5ˬq @15?|@1jf@1~Vu@1zd7@0Q@0֡af@0Q@0@@0Q@0ԁoh?1j?MSMӮ?GM??Xs~??=?}ѿ,?nr|?f?FT \*?Q?u!B?~}o^?{ڵ?q?t@@@@@*@ ??????W*,hP)T>?K$7?M@3S.Mm@3Htj.Qn@2sh.NC,@2sh.NC,@2sh.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @Õ%@ݾQ@Õ%@K]@Õ%@ᰉ@Õ%@Ǔݗ@Õ%@*@Õ%@7@-@ۥS@-@l"h @-@ȴ9X@-@H@-@䎊q@-@{J"@8YJ@9hr@2&+ J@2"e+@1-V@1~@0xF^@0KƧ@0xF^@0JM@0xF^@0*1?o 6}?9؊?,fC6?j6_?4f(R?(ϢU?X? -?2'?]bn~?fW?Sw?(D?7-R?`x?':?T8?WZ@@@@@,@*??????P%d6?h<ـ?TkВ?aW@źz@#^?eˑI>?wsKD?{ @?H~@oϚOnn@@I^5@I^5@I^5@j@I^5@@I^5@{<{@I^5@{eO@I^5@ @ I^5@ I^5@ I^5@R@ I^5@)@ I^5@}T@ I^5@bOߡ@ I^5@"lc@3|Q@3ohی@1^5?|@1zpJ@0`A@0 b@0QiB@0Cfk@0QiB@0H0,@0QiB@0I0?|h2:?.FI?%ja a?^ŋ?vj?؄1?|h2:?4?6Ƴ?~nY?d}??q9?0t:m?t&?8;?z!?Ci;@@$@@"@<@8??????o%! ?RAJ?U|5Td?]wlB@п@-`z2?tC?|{?d>@[_Q@eQ@@nO.@nO.@nO.@nO.@nO.@nO.@+ .@+ .@+ .@+ .@+ .@+ .@9,<.>@5+ .Mm@4ȓtj.Qn@4u.NC,@4u.NC,@4u.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @pM@p&x@pM@p-w1@pM@pC,@pM@pIQ@pM@p:@pM@pR=@1@G@1@iB@1@Ov_@1@;dZ@1@kP@1@+k@8B䎊@8?-V@3S@3,<@2~"@2ސ$t@1ce@1}Vl@1ce@1䎊r@1ce@1˒:)??t0?=tQF?_?ZAj?4 ?}ѿ,? l?5 ?N?pPȻ?XԠ#{?yjk?)Zw?7}?Gϵ'?ĭ? -r@@@@@,@,??????c6Q;?_~d?\B0a ?I@pJ -m@-?sk\?oOZ?ꜵRk?|3@mMI@@ɎV@ɎV@ɎV@Ɏ+@ɎV@ɏ\(@ɎV@Ɏ+@ɎV@ɍ8@ɎV@ɍ8@F@?|@F@j~@F@F@F@O @F@3@F@[@0v@0v@*V@*(@*x@*x@)`d@)m8@)`d@)zG@)`d@)m8?a(?&H?"?˅T?/`?:?bV,?r/B?|,!?6)}?@?M\ٓ@?b@?~('?s@a?avh?O|q?O|q@@@@@,@(??????@0 ?zrX?$`)?]=@Ɏ5.@ܮ?4P?DBpA?cA?4;?׊@s 7@@$Z@'z@$Z@%b@$Z@(=@$Z@'a\@$Z@"k@$Z@$@}E@g@}E@p@}E@o-7@}E@r+o@}E@t@}E@QHtz@8@8}@3+@3{5]@2~"@2P`@2 -0U2a|@2)@2 -0U2a|@2~wn@2 -0U2a|@2 -ɋz?u?SBx?4?U{??l% ?Au 8?+ef?Yq?0e?p:_j?Y=OD?,97?ZOM?ŭLc?ǹ۝)?;11?1D -"r@@$@,@*@5@2??????T`8?k:?G0!?@?S*f @%i!@vVHW?]?g= -Z?sVH?-k@pjΕ@@p -@n@p -@C,y@p -@䎉@p -@p @p -@W>7@p -@Y@O@vȴ@O@T`e@O@1@O@C@O@[W>@O@@7cg l@7Uoi@3 ě@3 ě@2tj@21&x@1sh@1$/@1sh@1F -L0@1sh@1Q?lOx#?'?oԀ? ?.Kn?f]G?}?? :?>??l{9َ?Z)?įJ?H?O?< N ? -r?<71@@@@@,@&??????`ŧCR?^V @w\?dJ\L,@{@t?nQ[3?vi,?QH?#׉@r*!e@@ ě@ ě@ ě@ !.H@ ě@ k@ ě@ !'@ ě@ |h@ ě@ |h@ݞ5?|@ݞQ@ݞ5?|@ݞѷ@ݞ5?|@ݞOv_@ݞ5?|@ݞvȴ9@ݞ5?|@ݞ҈p@ݞ5?|@ݞߤ?@3#g l@3#Z@/tj~@/a@N@/DZ1@/DS@.Ǔݗ,@.ǻ/V@.Ǔݗ,@.@@.Ǔݗ,@.8}I?| ?Z.?$C@?:Z2b?G?t?| ?0n=Q?O(?3.Yl?!U?{?eDQQ?|׿pY?l?=Cb?xqC?L?*Z}@@@@@,@,??????(|>P?-R0?Id1@ }P@ݞ+?LlX?$ ?$ ?Vb~@f!u@@F@$@F@Fs@F@[W?@F@4m@F@[@F@ᰊ@t@S@t@n@t@R<7@t@ѷ@t@C,z@t@~@8qiC@8 [7@4^5?}@4nP@34tj@3! @2Ǡ k@2ө*0U2@2Ǡ k@2g@2Ǡ k@2@N?`m?@u-I?MDe?oȞ?e7@??pEIt?N`? Ķ?"`?qn?O[?/?Fg*V3?*0x)?5_?8wx?8@@@@@"@*???????s1u"?qhw?iHl]x@EN@H?,pxp?z?}{[? @qb^@@Ƨ@m@Ƨ.@Ƨ.@Ƨ.@Ƨ.@Ƨ.@Fև+ @Fڟv@Fև+ .@Fև+ .@Fև+ .@Fև+ .@Fև+ .@8H@8؆YJ@4ٺ^5?}.Mm@4Htj.Qn@3ush.NC,@3ush.NC,@3ush.NC,?F^S@8#@8:@8 >+@8I@8?@8@8i@8@8S@8?eˬup@8 *@8p@8@8 @8 @?@É7Kƨ@Éx@É7Kƨ@É @É7Kƨ@Él@É7Kƨ@Êqi@É7Kƨ@ȏ]@É7Kƨ@È>BZ@^5?@~#@^5?@ @^5?@^5?@^5?@1&y@^5?@Xy=@^5?@TɆ@5*0U2b@5F@1{ I^@1z~@0"@0Ft@0n_o @0mcA @0n_o @0mU=@0n_o @0mb?|O?Čۨ1A?\H{gX?GZ0e;?\7?7F?|O?u߿?{d?G>G?M?GE?+:?9o??RJ? Ğ?2[s@@@@@,@*?????? ->?*|.s-?$z\فR@ÉW@ce`?J?D߬?ɝ?lsז?h=t@fG@@a["`@aVȴ9X@a["`@aIrH@a["`@aQA [@a["`@aU*1@a["`.@a["`@aZ)y@@#S@@+j@@:~@@" @.@@ /{J@84m8@8M:@4Y^5?}@4FA@3tj~@3{@2D*@2V@2D*.NC,@2D*@3- ?F^S?yK?»?sNX@8I?I?+-/? o]?;8+?ђ@8S?fD?1?Эs_`?7V/r?/#ˮr@8 ?,yfY@@@@@"?????@bM@O;d@bM@?kE@bM@IRO@bM@Kg@bM@|E@bM@t.o@5?|@vE@5?|@d7@5?|@r3DZ]@5?|@8 !T@5?|@8X(S@5?|@<]?@8zqiC@6n@30ěT@1x^@217Kƨ@0Z>Ũ@1D*@0UU F2@1D*@0Xҿx@M@1D*@0V|_?{si?S?w>Z?YF?+i?]lmY?(?gQ?bGF?7G?̽Vo??ǝK]{f?e?Ἅ?t=?B[@\@~$@\@84@\@E86@\@\@\@Q@\@L@6 ]ce@6 N;@2 ě@2\(@2"-V@2" I^5@1Tm8@1T!-w2@1Tm8@1T/@1Tm8@1Usg? ? KG?#}i?ƠJ-M?j?PBZ@0_o @0J#9@0_o @0,zxl@0_o @0ѷ?3a=?q' -B?K?eU5?0 碽?et?}ѿ,?-NI`(?&?{d?.D?؟#ߦ?nE?.+?@?π9"?3?`i2@@@@@(@(??????pGR?K?H?JiAl?I1Am@]d-5@?d -y?hpmi?;)[Ճ6?&ٺ@fJ-Z@@ I@~#@ I@)^@ I@4֡@ I@!-@ I@B@ I@p:@bM@u@bM@-V@bM@&x@bM@@bM@u!@bM@9Xb@8@9o@4\I^5?@4Nvȴ9X@3tj@3@4n@33&@3䎊r@33&@34JM@33&@33 -=p??xB?=£?,?'֙:0?s?*Rå?D12?\כ?*?k?I}?L /?]FV?ZaizD?ϯ<(?H&?&X;@zs>@]W A?+b*K?5!t?QZ?dy3Q&L@s@@m@n@m@'J@m@R~@m@9^@m@]T@m@M@qS@qStj@qS@qP#@qS@qR.H@qS@qTz@qS@qRL@qS@qS8 @2V,<@2VIQ@.tj~@.@@-?;dZ@->@,At@,Q@,At@,1@,At@,5?^m d?{TV? ?E[?:r? ?bQ넛?>pު|?^<+?/#ͤ?֓j?P p?bF?/?y?Dв?a?~.@@$@&@&@8@5??????F@42?-O(?%|Ct@X>o@qS?;T?4Vꇑ?s8$&?b( @stn@@\(@dZ@\(@v@\(@?@\(@3@N@\(@)@\(@q-@vE@fffg@vE@'fB@vE@=+k@vE@֡a@vE@CF]d@vE@$tT@9~($@9"M@5^5?|@5eF -L/@47KƧ@4ѷ@4O M@4L_@4O M@4H\)@4O M@4<[W???[G? dWB?+3#I?FILXT?{J?ʻd9\?ʳy?>?p:Y_?B?v$>?JzUf?/?ЙQ$?{_@j?V?:@@@@@@???????/3$ ?w G?[nd@/3@1p?? t?Xk?=)Q?1B@l}~@@"S@"v@"S@"Y<@"S@"R@"S@"K p@"S@"dp<@"S@"O@?|@vD{@?|@uxJ@?|@g@?|@ r@?|@@?|@ t@8YJ@8z9.@48r Ĝ@41,@3V@3Ÿ@2[W?@2@2[W?@2[s#2@2[W?@2&H|?|h2:?q-u1?Ě\?:@Zt?jå?qP?8 ?/?!dxD?|R2??a5Ut?W)?o?4C?7Ź ?GOe?|=@@$@$@*@5@5??????}"QE?QM?Eb'Ã@"z@x?r_lx ?ep5?O H; ?/`, ->@h):ei@@Hp -@I 18c@Hp -@H;@Hp -@H,#<@Hp -@I٦@Hp -@I jy^@Hp -@Iod@(E@(@@(E@(r^zi@(E@(nY@(E@(h@(E@(s2@(E@(l@7įO M@7ZL"r@3|hr@3Yp/@3gKƧ@3yF^`@2Q@2D@2Q@2u,@2Q@2õjM??ٗ?fk?N?SPǹ??_LQ?Xd?ǀSk ?oT?]\}a?$?35MQS?ӝpf? Ͽ?A??#? V?oGG,@@ @(@(@8@7???????P/?}:UD?a"FMo?B|ڄE@I r%@(kdf?}p!g^?bOTB?q4*?}7ʺg@lb\@@f|h@f}p -@f|h@fu$@f|h@fi@f|h@ft@f|h@fl@f|h@fiDg8@G/@G3334@G/@GЉ'Q@G/@GV@G/@G @G/@GH@G/@G7@8V,<@8T7@4 ě@4GE85@3]V@3w/V@2Ǡ k@2"@2Ǡ k@2S@2Ǡ k@2o?+-/?Ɖ?HFC?g_$?fl?LTO?^*?'`?VǷ?TV?қv??S[D?};?r?y\,?1ƛn? Ğ@@@@@,@*???????[? 7?dV?Xl&7O@f!@Gc?ybs?q;9SRA?ӿLh;?n 2@eNH@@@A7L@@-w1@@n@@L/{@@}Vl@@~iB@L@KR@L@GfB@L@L~($ @L@Jo@L@Ev@L@BѸ@3D@3䎊r@0+@0?@/mO;dZ@/g k@/oi@.u"@/oi@/ěT@/oi@/IQ?|O??,Z?;C??`?)'3?|O?ew?S1z?@4ٺ^5?}@5#GC@3-@3u@0|Q.>@)~"@) Ώ@(h1&x@(iAp\@(3PH@(49ftE@(3PH@(4S@(3PH@(36@8 -Ny?w<5ۙ?'D ? -w"?L&VB?{y@82r?|F ?&Z?8+ ?*Sk?+n9u@8L?6vJ? -?؀6>?z^j?|@4@2@1@D@D?????@u@$.@u@Xy>@u@`B@u@\O@u@@u@D@fffff@e`A7@fffff@t3@fffff@p ě@fffff@m q@fffff@jOv@fffff@i @7uS&@7s%2@3+@3a|Q@1"`@1oiDg8@1Y~($ @1Q @1Y~($ @1WsPH@1Y~($ @1Vȴ9X?F/P5?q?Aa[?˄&.?`?lP {?Br?&dU(?ދ"?:`?c?SS?4!j?U.?m!?? -r?k!l@@@@@*@*??????_?Rl?9EI?E[7@$N@h/:?Z>:?fMvu?$=/u? *A&@hzIW@@(@"@(.@(.@(.@(.@(.@Jo@;lD@Jo.@Jo.@Jo.@Jo.@Jo.@6H@6#x@5 ě.Mm@4$j~.Qn@4&YJ.NC,@4&YJ.NC,@4&YJ.NC,?Z@8#@8:@8 >+@8I@8?Z@8@8i@8@8S@8?A@8 *@8p@8@8 @8 @?@>`A@>O @>`A.@>`A.@>`A.@>`A.@>`A.@̏\(@1@̏\(.@̏\(.@̏\(.@̏\(.@̏\(.@7g l@7-FC@3^+.Mm@2ttj.Qn@2a:S.NC,@2a:S.NC,@2a:S.NC,?Bp@8#@8:@8 >+@8I@8?wvHf@8@8i@8@8S@8?-@8 *@8p@8@8 @8 @?@s3333@wi.@s3333@.@s3333@rR*%@s3333@s"@s3333@r5en@s3333@s^@~"@qm@~"@gI|@~"@mM@$@~"@j&@~"@{ ,@~"@sQ@92@8 eBwS@4n5?|@4i1ѵ@3V@3Ch@2fYJ@2a_w枚@2fYJ@2b_MK@2fYJ@2_?g)n֔?f)Y?5?w)(;?5t?]\x?ؗ?>?M?ic `?R!?=.A?Gl?$?/)R?:|=?5g@?o=)@@"@@"@3@.??????A`v7Ñ?5R#?ln|1@sPD@zPWy?GH1z?_fA?f@ -Vyv@pR]@@R@ I@R@5Xy@R@_o@R@.3@R@빌~(@R@ᰉ@zG@zv@zG@}+k@zG@|ߤ@zG@zu%G@zG@{lD@zG@{6@5v@5qu"@2S@2L_@1_-V@1_?@0z,<@0zD@0z,<@0y0 )@0z,<@0x?}ѿ,?Čۨ1A? ?:Z2b?R%(0?-/ge?|O?j%Ra?S1z?ѷ@(\.@8!..>@4 ě@4 k@3`A7L@3C%@3~($ @3;A@3~($ @3($ x@3~($ .NC,@8J?-d?Z-l?":Li?g;+u@8@8J?ʀ+?o?h?5nM8@8@8p?FQ?җQ;?u}+?B@8 @@@@&???? @`A7L@`A7L@`A7L@ae@`A7L@a.H@`A7L@a [@`A7L@`D@`A7L@f@HO;dZ@HO-@HO;dZ@HIl@HO;dZ@HJ#9@HO;dZ@HE@HO;dZ@HM@HO;dZ@HM@2 xF@2%1@1&+ J@1$g8}@0`A7@0Ft@0p@0m@0p@0lN;@0p@0h9Xc?^Q5P? KG?jhq9? -?|?~?bV,?Q_ڸFN?"a?Nw]6?~?Ft*5?ă$??>Zw?GZ?їJ?a@@@@@&@$???????`3S?mw$?Qs?UKD@b"@HJ~~?`_W?d"T?qi4V?mc$@r1@ -@?|h@?vȴ@?|h@=p -@?|h@=H@?|h@=E@?|h@B`B@?|h@Cn@eS@g+ J@eS@dq@eS@i @eS@d?@eS@eoiD@eS@hTɆ@5r@5qs@3=hr @3:c @27Kƨ@2Vu@2[W?@2y @2[W?@2RT`e@2[W?@2_o?|O?L?^?E`?bJֵ?f]G?|O?V"y$R? - D/?#q\-v?x9l?äqY?YE?iTC~t?[Rb?l? N?DV@@@@@,@ ????????ߐ?s?>ObQ?8Al-@@zx@gk?^~a7?YKwQ?ơt"?Y`m@f@ @S -=q.@S -=q@S{+ @S -=q@T=@S -=q@TT@S -=q@SP1@S -=q@TF@9XbN.@9XbN@iu*@9XbN@E@9XbN@՝@9XbN@%͗@9XbN@eN@8g l.>@4R I^5@4GO@3@`A7@2h,@2ush@29r@2ush@2]G@2ush@2U@8J?M?*Z?qB_?i L%?8PA@8J?{ ?z1V?ѽ?G? ?X@8p?Nz?sp?H?g< -I?B@$@&@,@;@9????? @r @7Kƨ@r @$G+@r @v @r @*u@r @$#@r @`<@W -=p@X" 6@W -=p@X ).@W -=p@S'`<@W -=p@X@W -=p@W| @W -=p@WV;P@5g l@5:K@2S@2Re;@2t@2 K4@1xD*@1xzzI@1xD*@1{@@1xD*@1zxRW?}#? H??IA?Q\?YD="?Z=?"f?~?Q[$?a]6? ?/p?Ff?$?t?+;b???g@@"@ @"@5@4??????Cx(0r ?%M#?}}it@}g@X8!?DL,?;s$? pL?+. @g@Աݘ@ @KT@K w@KT@J;"`@KT@J_o @KT@Jо )@KT@KTɅ@KT.@0 ě@Izo@0 ě@@0 ě@9 k@0 ě@cA \@0 ě@a@N@0 ě.@8D@8MK@3S@3&@2Ͳ-V@2a@N@26z@2;U=@26z@2W,@26z.NC,?:?"-f?怯8S?z]?&Z@8?-a(^?̋0?hK?CRn?R?Ѷ=(H@8?b?Y+:?JzUf?Y?M}td@8 @@@@@,?????@k=E@k2@k=E@kBh ԕ@k=E@kDe@k=E@k@'RTa@k=E@k?b}@k=E@k>@ @ ht@ @ hr!@ @ _@ @ s@ @ о )@ @ s@8D@8JL@2+ J@2@N@2Ft@2Bs@0̿[W?@0u%@0̿[W?@0fB@0̿[W?@0s?F/P5?4$?g ?̒?j?)]\?Zm? ,C?_@?0N:s?C ;?tK?2m?㑏\? t4??*Z}?SP@@@@@(@(???????g?K?P@¸>?X}Ti|e@k>j@ )R?s|?i?;(?M@q/}S@@ffff@?|@ffff@߾vȴ@ffff@ؼߤ@ffff@ԯO @ffff@hs@ffff@\(@0 ě@(r @0 ě@V@0 ě@U@0 ě@'lC@0 ě@\PH@0 ě@Y+@904m8@9+"`A@45?|@4*0U2@4,j~#@3@3u@2y @3u@2L_@3u@2?#[?-56+?+-?u {N?/?@i?ҸBz3?ڲt?j1?@$v5?[c?e,Z?LO? U)?|p&?2HD?vۋ7?_;G@@@@@,@&???????d` ?~껤?FRyߦ?y;Ħ@1}@ b@=l[?A?F6?W??c @@n -gE@@;lD@;lE@;lD.@;lD.@;lD.@;lD@;dZ@;lD@8@`B@&@`B.@`B.@`B.@`B@ -=q@`B@;dZ@5ks@5jg -@0+.Mm@0>Vu.Qn@/`d.NC,@/`d@/MjP@/`d@/?}ѿ,@8#@8:@8 >+?J+?I ?|O@8@8i@8?q?p?6z@&x@[W?@b=p@b-V@b=p@brT`e@b=p@c)rG@b=p@b{@b=p@b6@b=p@b-@8@8@5^5?}@5nѷY@5@`A7@42a|@4Ǡ k@4~Vu@4Ǡ k@4@4Ǡ k@4JL?_$?95\?ْ7IDu?{osG'?(x/?%$?ϱQm?GZ?[?~'z?V,??֑엱?T?"i]P?!i?.P?'w#T@@@@@*@,???????JTIH?3A?iP@8?sd3@pc B@b5|?vѻpn?Uz$?-bT?݇1@hd@@Q.@Q@oi@Q@&I@Q@]c@Q@ѷ@Q@@5?|.@5?|@7e@5?|@3|@5?|@3g -@5?|@1N;@5?|@+]c@4mv.>@2+S@2(U@1`A7L@1MjP@16z@1M:@16z@1MjP@16z@1<64@8J?_?ojVrn@8@@8kP@2^5?|@2ʅݘ@2Htj@2G)^@1:S@16z@1:S@1[6@1:S@1- r?ϱQm? e?vG?W0 ?j? ٖ?Wl?q ?v@b?#X?SY?pN.>7E?Ny?Ϸ+?qn??:1?DV@@@@@*@(???????I'!T?DcYC?:(YΜ?Fs3@ѐ@'ʉEa?PWw?U"/K?x0^?nYh\@ryQf@@>`A7@>;dZ@>`A7@>@>`A7@>1&@>`A7@>,zx@>`A7@>"h @>`A7@>n.@}u@}]/@}u@}d/@}u@}I^5?@}u@}ح@}u@}@}u@}iC@8v@8jOv@4?|h@4]K]@4`A@4ěT@2D*@2F]d@2D*@29Xb@2D*@2u?]?'rCr?Q"Ě%?CF ?=W?if?]?#?^,?A8 K?*v7?.?*wjs?j? U?J? 3?F?@@@@"@$??????o\3{?~'X?|/{?R4@>zK@}zA?H?`p%00@TV?#P@rds@@-hr@1&y@-hr@.2@-hr@+j@-hr@ (@-hr@ca@P@-hr@ԯ M@3O;dZ@14F@3O;dZ@1@2䎊r@1 -=p @2䎊r@1zxl"h@2䎊r@1YJ?us\?_n?n? -Y? -R?NJH!?F/P5?Ah:?6eI?c?~?c/~?' -}B?ɅoiE???hc?F?;WZ@@@@@&@*??????^U?cvo?tYFDy@ԐQ@1#qbzV?Oo?fa@0?'^Xx@_s5@@pTF@pTzG@pTF.@pTF.@pTF.@pTF.@pTF.@-V@1'@-V.@-V.@-V.@-V.@-V.@5B䎊@5Bᰊ@2Y^5?}.Mm@2`A7L.Qn@1!:S.NC,@1!:S.NC,@1!:S.NC,?}@TΥ@8#@8:@8 >+@8I@8?`/.~@8@8i@8@8S@8?V3@8 *@8p@8@8 @8 @?@x~"@x;dZ@x~"@x@x~"@xvȴ@x~"@x'RT`@x~"@x~Q@x~"@x}H@گw@گ\(@گw@گ;dZ@گw@گv@گw@گn@گw@گw@گw@ڮO@3*0U2b@3Dg8~@.`A7@.{@.:1'@.:@-Z@-$@-Z@-S&@-Z@-F]c?|O?`?(?̒???|O? aҹz?90?0N:s?@?PS2K?2Y0?8 T?|׿pZ?xqC??B @@@@@@??????$`fY??,'k?:<@x פ@گ6m$?LO?8`kfl?UG?Ǜ -vZ@g~`q@@ěT@ϝ-@ěT@ں@ěT@^ @ěT@S@ěT@x@ěT@@bM@ S@bM@ ԕ@bM@e@bM@@bM@t@bM@@8쿱[W@8@4|hr@4 -L_@3i"`@3d/@2a:S@2_.H@2a:S@2^iB@2a:S@2\Z?1j?P1"?K?\2?W?=?bk0?g3?qN?~2l?4?߅D̽}?=6?J>?Cp0x?*6SpK?mΝ? uf@@@@@(@"??????aN>?c`?Cř6py?U6@Ǽ@@E㖔?l-LYdFy?hcE{?K/~/D?Ci@q&u@@a"`@am?\? 8+??Ċ\?\ƥ0?VAo?3Eb?2DB?"IHۜ?`1f??Z,k?_?L=@@@@@,@*?????? -ă?}렻@?eN?lw>v@a!&@gN5?~??%b ?L`@_BH@@AƧ@AI^5@AƧ@Adž&@AƧ@A+@AƧ@A@N@AƧ@Am\@AƧ@A‚@@Hu?|@Hr ĝ@Hu?|@Hě@Hu?|@Hp ě@Hu?|@Hs@N@Hu?|@Hrs@Hu?|@Hp )@6|Q@6a|Q@4R I^5@4Mb@4;Ƨ@47@3@5@3} qv@3@5@3|쿱\@3@5@3{xF^?sD?F?IK?GuS?pK ?t]O>?}ѿ,?շL?Jj??c,*?#N?!A -m?&!+?@K/{?uq{a??_@@@@@&@,??????a" 4?NzT7?(lj@A(@@@@@(@ ??????Jy.ٵY?0%f?@@o@ٶVH??͓.?6?yo?!@s˻@@26z@0ce@0fB?|O?q' -B? '?_?Z)?ZzZ?1j?[ K0R?]:.?@Cv?[H3? a?y8#?/?W?__C?_խW?M\@@@@@,@,???????)O 7?(+pZXN?BZ@&x@(ۋq@&x@*L@&x@(eO@&x@)oi@Q@Q@Q@RW@Q@S|@Q@Q@Q@RS'@Q@TɅo@2*0U2b@2@1 ě@0}Vl@0`A7L@0Z@0 k@0fA@0 k@0u@0 k@0%F -L?^Dw'?q' -B?1f_?Њ?_?sU Z?bM_x? -xՎ?O(?ą6 -?1?ҥX[?bMky? -?3Z\?$H?2[s? `@@@@@,@,??????Ba?Vu?A"1?2>ߙ@)LV@RП"?Pl%U?AI?I|?y,w2@rFw^@"@ ě@ % @ ě@ #N[z@ ě@ ! @ ě@ jzO@ ě@ @ ě@ *(*@E@/@E@49c@E@.\2@E@5 V@E@ @E@gxk>@87@@8(׺[6@4^5?}@4^@3Z~"@3^ l?@2:S@2,i:@2:S@2߭Y}O@2:S@2?π>?8?eT3?x?4 ? Qx? -?M6M^?~P230?Ai?]V?uk?T?%?V}*? -gH?;1?b.xt@@"@&@"@7@1??????eGi2f?\.bL|?h)a@ ؖ@}?u5?E*??|#I@n>@#@B I^@@n@B I^@A.H@B I^@Ae@B I^@A7K@B I^@@҈@B I^@@IQ@FzH@FV@FzH@F*0@FzH@F[W@FzH@FV@FzH@F1@FzH@Fu!@5@5 -=p@2hr@26z@24tj@26!.I@1u@1/V@1u@1 '@1u@1KƧ? ?: ?ِ?%?Xe??#?1j?P ?;,?ihA?x9ξO?IH!w?Aᆽ?=d?],V?sMQ(?ĭ?*Z}@@@@@,@*???????@?=x? 3?*o5yU@@K@FT@?@p~?J+t?j ?8;(@g2nr@$@u ě@u|h@u ě@u*1@u ě@u :@u ě@u+j@u ě@u"ѷ@u ě.@6ȴ9X@0`A@6ȴ9X@/V@6ȴ9X@An.@6ȴ9X@:6@6ȴ9X@ES&@6ȴ9X.@8@@8J@3S@3;dZ@3tj~@3B@2:S@2>BZc@2:S@25Xy>@2:S.NC,?NIɮ?+>?|v8?V0O?=-?@8?}?FHN?.j ?G>G?PZj@8? U?їJ?0?bv{3dZ?@C@8 @@@@@,?????%@&x.@&x@wkQ@&x@4m@&x@@&x@˒:@&x.@lC.@lC@jO@lC@w1@lC@wj@lC@J#9@lC.@9+s.>@4Y^5?}@4F-@3tj@3RT`e@2@2!.H@2@2%F -M@2.NC,@8J?u4ޕ?`M:??WTi@8@8J?rA?P?!?07\@8@8p?:h$^z?^i? B?y ^@8 @@@@(????&@ĹXbN@`B@ĹXbN@ܑN<@ĹXbN@Ŀ!-w2@ĹXbN@Õ%@ĹXbN@F@ĹXbN@8@zH@u@zH@|@zH@L_@zH@\)@zH@@zH@[7@7%!.@7,@4 hr@4`A7@3'KƧ@3/O M@2Q@2T`d@2Q@2TɅ@2Q@2,FV?h??*l?l ?"6Wz?q ?)S&?^?L E?L?Ծ?ymcw\?0a@@@@@(@"???????fdq,wa?^DO?d9TQ9@)8@kb?zMM?{0?Ykc?X|G@jD08m@'@"@~#@"@@"@x@"@e@".@"@&1@"`@bM@"`@}<64@"`@}H@"`@m5Xy@"`.@"`@@4#g l@4 ѷ@1+ @1$J@1-@08YK@0m8@0=!.H@0m8.NC,@0m8@09|?]??`L?.?L_jf@8I?,ϖ?]?O?2?VfN? '@8S?TD?*wjs?UbB2? ё٤i?pO+@8 ?q2?@@@@,?????(@r-V@2@r-V@6z@r-V@Z@r-V@T3@r-V@e+@r-V@|@E@Em@E@Ex@E@Gn@E@F@E@E҉@E@G&@9N쿱[W@9P4m@5f+ J@5sh@5t@4ݿH˒@4p@42C,@4p@48YJ@4p@3?Úz?vd? OV?av ? <)?6n?:-%?FSf?8/J?S~?w}Z?T?s?z?yMa?9G?ÁK?!f@@@@@,@??????Ip?U ?K~Ui?> ē@(@FlD?'q?G2?=@ I@m!}Sִ@)@~@~ -=@~@~dZ@~@~W>6@~@~6@~@~D@~@~D@4b`B@4dS@4b`B@4a7K@4b`B@4a@4b`B@4a|Q@4b`B@4dT@4b`B@4c@7!.@7K]d@2pěT@2rT`d@1-@1lD@0䎊r@0@0䎊r@0 @0䎊r@03?us\?j‚?#}i?q@v?yq?+ʦ_?E?\tW?;~?agf ?Al.6?ȏ'T?lQ? U)?],m=??W|DC?M684@@@@@,@ ???????Wî?.)C?PYa?DA&c@~@4c-^?l X#W?]?c ?є8@n~I`i@*@K*~#@K2ւ@K*~#@K+C@K*~#@K&x@K*~#@K$/@K*~#@K'E85@K*~#@K!e@ȴ9X@4uֹ@ȴ9X@H@ȴ9X@#e@ȴ9X@xl"g@ȴ9X@ @ȴ9X@XbM@7uS&@7H@3 I^@3qiC@3-@3@2,<@28}I@2,<@2@2,<@2lC?za2?:aGS?reE??ҧ?*?pV?2(_??c?/:?h_N%?V.H??,DP?~}o_?Z?b?aʕTI@@@@@(@*???????^?\ul?kZG -?<>BU@K#@oBհ?}jRL]?cv.?XQxב ? @p9N@+@J=p@Il@J=p@J@J=p@M g@J=p@LJK@J=p@Ie@J=p@H+oP@O$/@On@O$/@Oe@O$/@O _@O$/@O @O$/@OP@O$/@ORQ@34m8@3Vϫ@1sS@1s:'@1t@1t]Ք@0\Q@0\@@0\Q@0][nh@0\Q@0\v]?}#?.od} ?EY?v[‡?a!(\?,OKu?y%??#?}ѿ,?pPȻ?D?{4k?JL\?C ;?m~Z_s,?Rii?],m=?9XNu?2[s?L8AS@@@@@,@,???????1f0?*®?*@Yy>3@PĶ@ +sd?Jˠ?6@N?~?& ^}(@f[#@-@+ J.@+ J.@+ J.@+ J.@+ J.@+ J.@",1&.@",1&.@",1&.@",1&.@",1&.@",1&.@8 D.>@3 I^.Mm@3-V.Qn@2D*.NC,@2D*.NC,@2D*.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 .@3H1&y@3J~$@3H1&y@3Jd8@3H1&y@3Iᰉ@3H1&y@3GfC@3H1&y@3Ezxl"@3H1&y@3Eں@t@ttj@t@tȴ9X@t@t}Vl@t@t_ح@t@t1@t@tᰊ@7䎊@7m\@2+@2;5X@297KƧ@2873@1sh@1Q@1sh@1<64@1sh@1wkQ?|O?hX*?5$?ݡu(r?ZAj?Q`?sD?RwS5?]:.?@Cv?7=^9?EȀ?oܧ?rbT?^&?vI?<Dx? 4e -@@@@@"@(??????Qմ?Ed`?!׻D٧?2e…_@3GS@tx$?CB>՘?Q w?E;p?3+r@ij,@/@A$/.@A$/.@A$/.@A$/.@A$/.@A$/.@^`A7.@^`A7.@^`A7.@^`A7.@^`A7.@^`A7.@6mv.>@3° ě.Mm@3W-.Qn@2䎊r.NC,@2䎊r.NC,@2䎊r.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 0@2 Ĝ@\(@2 Ĝ.@2 Ĝ.@2 Ĝ.@2 Ĝ.@2 Ĝ.@]+@]"@]+.@]+.@]+.@]+.@]+.@85S&@8 (@3+ I.Mm@3.".Qn@2G k.NC,@2G k.NC,@2G k.NC,?]@8#@8:@8 >+@8I@8?]@8@8i@8@8S@8?*wjs@8 *@8p@8@8 @8 ??1@1&x@0`A@1&x@0oiDg@1&x@2s@1&x@2s@1&x@/v_خ@1&x@0`A@A ^5?@A -=p@A ^5?@A@A ^5?@A ^@A ^5?@A C,@A ^5?@A -=p@A ^5?@A 6z@3*0U2b@3@1+S@1+Ƨ@0Ͳ-V@0Ͳ-V@06z@0!-w1@06z@0쿱[X@06z@0qi?2}?m?&??_?PN ?/?֘>D?v_.^?3?ad|@@@@@*@&??????|?#˟ ?7cDѫ?2ηk@1e,@A -\?W~N8?;$bA?A_Ma? eS1u@g1E@2@a.@a@be+@a@{/V@a@eo@a@jW@a@heO@2.@2@2>6z@2@2>B@2@2և+ @2@2͞'@2@2Ǯz@9O M.>@3I^5?@3wkP@2Ͳ-V@2'/@2}ce@2ft@2}ce@2kJ#9@2}ce@2l~($ x@8J?rk?7'v?Qi?Kn(?rW@8J?U -?00?.,?E!?s?|@8p?&3?Q?&|?Q?]?5@@@@,@,?????3@w@wj~@w@wQ@w@w)^@w@w @w@wm9@w@w-@mV@fffff@mV@i @mV@vC@mV@-V@mV@Zv@mV@=-V@9*0U2b@9u"@5+ @5TɅo@597KƧ@57#@5 [W?@5Ϫ͞@5 [W?@5?@5 [W?@5IQ?1j?UW?[r'{n?E>?%?V᷵?% ?’?is?ƣL?+ҥ/?Z?^&Mka?$jB?7V/r?0V?+ߎ ?7Bj@@@@@&@(??????b*jH&?YC@-V@,zxl@c -=q@dZ@c -=q@b`A@c -=q@` qw@c -=q@h\@c -=q@`[7@c -=q@c9@7v@7u@3kS@3jg -@2M-V@2LZ@2iB@2D@2iB@2@2iB@2|hs? ?@@No9?=N K?|*(?PY8~Qj?\.:@? ?nr|?F^S?>\?MuVQ?jOI?$M?p-t? SF?>?&f?&f@@@@@@???????O#7?C ?J%=z~@,p@dvP߅?c~Kut4u?k7LP??PU@g3#P@6@=E@/\(@=E@ʚ~@=E@PH@=E@6@=E@>ߤ?@=E@?vȵ@@ ě@@%m\@@;dZ@@-V@@@@@9,<@9\)@3hr@3ؠ- @3`A7L@3@D@1!.I@3NU@1!.I@1Q @1!.I@1נ k?Y͍_?1d?b?+|?ZAj?~?TU?~^?p4?ӐW? ? Ӻ^?M,?+>G?`Ƕ?t"0D?7zE?{2@@@@@&@(???????ndw?sP?t5F?;t,@=7*@x۪@4?7?ņVJ)@)[V@oG+<Ý@q ^ۢ@7@'vȴ9.@'vȴ9.@'vȴ9.@'vȴ9.@'vȴ9.@'vȴ9.@BE.@BE.@BE.@BE.@BE.@BE.@8O M.>@5S.Mm@5lj~#.Qn@5ush.NC,@5ush.NC,@5ush.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 8@8 I@8V@8 I@8$~@8 I@8G@8 I@7}$@8 I@7N?@8 I@7tL@r @'*@r @@r @DŽ3@r @SO@r @kV?2O*҈p@瞸Q@7>6z@瞸Q@i@瞸Q@4K@瞸Q@璽<6@ Ĝ@O@ Ĝ@#@ Ĝ@ ҈@ Ĝ@C@ Ĝ@?[W?@ Ĝ@UL_@4(YJ@4'P&@1 ě@1=qu"@1R`A@0ۅQ@0D*@0fA@0D*@0]cA@0D*@0 '0?|b@?L-?*$*n?*cyb?nOQ?98?|h2:?5ֵ?סϟE~?*Gk?MWXRk?ÉX\?.r?{dph?t߽R?ѳ9?]2?mB@@@@@,@,??????y^@?F?t8Mm? -_Q@甌 @= F?{RR?CF ?'# ?91)8?+-/?+ I?v׆7? 5Y?MJed?v8' ?OW?Fۯ/?0YR?$@ I^5@ȴ9W@ I^5@9+@ I^5@hs@ I^5@+Ƨ@ I^5@(@ I^5@@@&x@tj~@&x@@&x@9X@&x@ I@&x@\(@&x@E@8Q|Q@8rGE9@3° ě@3P{@397KƧ@3حV@2D*@2qi@2D*@26@2D*@2- ?}?_b*?'=DP? '?ߩ?*=U?us\??&?b ]jZ?R?#N?3?Эs_`?X?Dۖ?o;s"?4@@@@@@???????oww#a?fdlC?vWBZ@w>z@?坘?9h?315l@Ij(@f^Q@?@\E@\Z@\E@\\(@\E@\@\E@\@\E@\@@\E@\$ x@n[S@nR-V@n[S@nr@n[S@nB3@n[S@na@n[S@nA.H@n[S@nAr@8G>6z@8AA [@5hr@5ae@4j~#@4e+@4G k@44%1@4G k@4@bM@4G k@4J,0@j)@@@l1&@qhr!@l1&@n2@l1&@q @l1&@rs@l1&@nc @l1&@nV@ I^5@\)@ I^5@@ I^5@$tS@ I^5@v@ I^5@PH@ I^5@?@8(YJ@8 8Z@3 hr@3 (@1Ƨ@1^5?}@1@1@1@1C\@1@1<쿲?jqp?Ѝ`Hh?Gk;m?Fq/b?2F0?5Ov_@@4J^5?|@4J@37Kƨ@3/{J#@3._o @3&fffff@3._o @3"@4n@3._o @3$ xF@8J?Z.?0?sNX? -æ?I0zIJ@8J?La?Qrz?E?i ?,?vk@8p?*T?a -?0 ~?Kd\? $4@@@@*@$?????B@1 Ĝ@1-V@1 Ĝ@1T`d@1 Ĝ@1@1 Ĝ@1W@1 Ĝ@1u!@1 Ĝ@1T`d@z@lC@z@Xy=@z@zxl"@z@ݗ@z@,=@z@@4g l@4Z@0hr @0hr!@0'KƧ@0&!.I@/=Vl"@/=<64@/=Vl"@/=p ->@/=Vl"@/=cA!?| ?Čۨ1A?Gy??lDžN9?; ^?CXs?|O?j%Ra?#Gf?C B?!U?{?wN z_?|׿pY?9o?>Zw?͓E'?pk Y?j@@@@@*@*??????x@? ߘ93?;@178`@=V?@eJ?4 ?_WZx?vRius@f@C@\(@Ž @\(@űr@\(@d{*@\(@2@\(@t'@\(@JKև@l3E@l3@l3E@l4)$@l3E@l6 -l@l3E@l2'@l3E@l3.}@l3E@l1@4,<@4z@1S@1R@1t@1O=&@1~($ @1ۅh@1~($ @110:@1~($ @1Q&-p?| V?0ϒ?FWg?W:Bx??yd%&.?(( ?|b@?aI$;?5^?=c~?+Ɏ?3ۡ?r;;?81$?@tGy?#X?9DP?"#ѧ@@*@"@*@5@4???????}DŽ@8X?Eo2[-?PZ@ k@l3)ۮ?e<>*?=%?2FY?gK@fR@D@oJo@oO@oJo@p=@oJo@oԘZ@oJo@o<@oJo@o?f@oJo@oاt@HJo@HH@HJo@H;n&@HJo@H44(@HJo@H1lS@HJo@HK-#C@HJo@HP4@5@5%=p)@3 I^5@3{G@3tj@2vȲ@2OO M@2Kv4EU@2OO M@2i-(`@2OO M@2=˶?d?u6!?V΄??,@ ??}x?;U?Jj?_Q?d'C?7?Q7 -ȍ?;uL?ɴ?}?46@@&@$@&@4@3???????.krZ?h?ngh-@o}@HBMp?ci&V?g}' d ?IWJЗ@ ]@aC@E@ I^@ƺv@ I^@@5TS.Mm@4U`A7L.Qn@3𖻘.NC,@3𖻘.NC,@3𖻘.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 G@ě@$/@ě@u"@ě@e@ě@ -=q@ě@ߤ?@ě@7K@ڻdZ@ڻ"`@ڻdZ@ڹrGE9@ڻdZ@ڳg@ڻdZ@ڸ@ڻdZ@ڻ~@ڻdZ@ڼ(@4w@@4x}H@2^5?|@2_o@1-@1@@1u@13@1u@1Ϫ͞@1u@1Fs?|O?5{#?5$?菁k?ɿ?Dw?|O?eCO?S1z? (?=~?6kp@ylz@ڻ?\:O?VCQ0?Ģt?jÙ@fgC@H@1&y@9XbN@1&y@ -L/@1&y@tj@1&y@}Vl@1&y@ l@1&y@s@O;d@޸Q@O;d@p:@O;d@:@O;d@iDg9@O;d@α2@O;d@ͫU@8|Q@8TɅo@2J^5?|@2L<쿱@1K"`B@1O-V@0䎊r@0@4n@0䎊r@0W@0䎊r@0.H?ƋGg٪?Z?mGSq?Њ?ԁ?7F?Z\??xrI?jT???wN z_?m?GA?̈- -?J]j?0&YEd? Ğ@@@@@&@??????pQfR{K?VR?HMrh@ -OVT~@WO?f`t?XF x?}j?SK?@rƜ׎t@I@%@`A7@%@@%@T@%@Q@%@`B@%@Q@Gz@Hr @Gz@I7KƩ@Gz@IrG@Gz@Gz@Gz@H9X@Gz@G+ J@6Y*0U2b@6U@2)+ @2)y @1Ctj~@1CPH@0&YJ@0'@0&YJ@0&A@0&YJ@0&IQ?|O?ߋb?d3"7? Y?DE?R?2}?? :?v@b?ni" ?=U{,?H, -r_?%Cr? ?/Y}?avh?A0)n??\@@@@@@??????/}d@%V@?/T N?#XP@' @H.B?O sg?Chߖ$֫?0?"YcKd@g΁]@J@@W -=p@@W -=p@@W -=p@@W@@W -=p@@VϪ@@W -=p@@XD@@W -=p@@Vu@@W -=p@@VR<6@u@E@u@l!@u@ᰊ@u@Ov`@u@D@u@!T@2䎊@2&IR@0=hr @0=!.H@0W-@0V!.I@.ۋq @.˒:*@.ۋq @.lD@.ۋq @.lD?^Q5P?ߋb?(?8v?,I ?2I/?bV,?u߿?j?3.Yl?M?b-x?g)?˛͇q?/Y}?':?b/bJ?ad|@@@@@,@*??????MT2J?8Ԓ/?3W<(f@@WF@k٦?HU+Ν?B>+F?ة?|@sW@K@\).@\)@XbM@\)@8Y@\)@YJ@\)@74@\)@-@j33333.@j33333@j;dZ@j33333@j,~($ @j33333@j=<63@j33333@j=+k@j33333@j=p @9,<.>@4&+ J@41u!R@3b-V@3f}Vl@3 k@3 *0U2b@3 k@3 n.@3 k@3Ov_@8J? ?f?S;~?Jj~u?S:Ъ;5@8J?sXX=`?n|X?#q\-v?Y:J?k|;@8p?ռUӛ?ZAj?>ڵ?M\?t-w@@@@(@*?????L@7K.@7K.@7K.@7K.@7K.@7K.@O;dZ.@O;dZ.@O;dZ.@O;dZ.@O;dZ.@O;dZ.@6~($.>@2ٺ^5?}.Mm@2R`A.Qn@2J0U2a|.NC,@2J0U2a|.NC,@2J0U2a|.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 M@Yu@Yȴ9W@Yu@Ye@Yu@Y -=p@Yu@Y@Yu@Y*0@Yu@Ytj@dZ@1'@dZ@j~@dZ@YJ@dZ@V@dZ@_@dZ@m]@6 ]ce@6 C%@2Lhr@2L!-w@1Ͳ-V@1(\@1G k@1Dj~@1G k@1?@1G k@1@ѷX?Y͍_?m0?>\?'$5?j?_?|O? ,C?)_?@[*^?=W?S)?/Y}?%_D?T0?˴C?{2?{2@@@@@"@*???????<X}d?40 ?4B@Y$@N?RG*?UA f? ʼ=p?'9@gOOK@N@}tj@}@}tj@}"@}tj@}C\@}tj@}@}tj@}PI@}tj@} @7Kƨ@7Kƨ@7Kƨ@C@7Kƨ@L@7Kƨ@D@7Kƨ@qu@7Kƨ@ @4hYJ@4i,@1W+ I@1V -L/@06-@05sh@/Vl"@/!.I@/Vl"@/_p@/Vl"@/SMk?|h2:?%ñ?U#?5~pY5?2F0?\.:@?|h2:?> -fu?ܿ?G>G?W;zY?ey? ?Rii?]?2?ĭ?I$@@@@@,@(???????&Ρ ?/j?K<0?$U@}[@T<?jnv?D,D?c^?d@3hr@3q @3M-V@3NH@2u@2g8}@2u@2x@2u@2u%F -@8J?+!?1V?E`?؍i?mׁe\@8J?? :?ދ"?ni" ?Co?"(L@8p?QdЈ?ZaQ?!ˠ*(?]ߒ?+C@@@@@?????P@@uË@@&@@Ur@@+0@@.@@eX@@n@?I'@@n@Ck@@n@JLG@@n@F{@@n@G@@n@G@6`D@6`ggn@1r Ĝ@1hNv@1lj~#@1n~}@0:S@0d @0:S@0v{)@0:S@06?E[i)?p?S a?x0s4?9DZp?(#~?eXW?awuE?] ?Y.`?Kh??9?,?ׯr&c?[/l?"5Mf?=??Z&9@?Rs)?~? tΨ9@f pۘ@R@YxQ@Yw@YxQ@Y{W>6@YxQ@Yyb@YxQ@Yz@YxQ@Ys*0U@YxQ@YtzG@u@n@uA$/@u@n@u?˒:)@u@n@u?@u@n@u@u"@u@n@u??@u@n@u>%@5I_o@5J0U2a|@15?|@1Ov`@1gKƧ@1_O M@0xF^@0 ԕ*@0xF^@0'RTa@0xF^@0d7?}ѿ,?@@No9?zjʩi?E`?'ř ?}7.?| ?9}=?ꉬ>V?sZ-?W;zY?ҥX[?n88?3I#i?do? mmsi?Tj?GZ@@@@@*@*??????Cm<h?CPY?¹-@YvH @u@E?bw;?6Di?G?k$tO?i=?5`?^*?T?."E?FJ?8.>?Ó+DoX?Xŏό?ۃ30?_K. ?p)Տ?#j?H>w,@@@@@,@,??????bn0ti?H!?T(G@F3Kf@h/?b;ڱ?qÏb?yF?rxr@d&Ch@T@ -o@ @ -o@ Ƨ@ -o@ @ -o@ -d7@ -o@ _@ -o@ 'RT@ԅ@Ԉ[@ԅ@ԄU@ԅ@ԆL/{@ԅ@Ԃ7@ԅ@ԉ@ԅ@Ԅ*@8(YJ@8)@3+ J@3@34tj@34j~@2_o @2rGE9@2_o @2vȴ9X@2_o @2($ x? ?9؊?LD?Hyq?o?P?*?}?@׮?pI?~m??ۣ0Υ??;?A\#? U)?6~A?Yʒ?`i2?l@@@@@,@*??????>GJEp?3^t?J. H@ K@Ԇ+?TT>x$?i7x?~?Ϛ#O@hN1@U@Bh\@BeQ@Bh\@Bmd7@Bh\@B@Bh\@Bfo@Bh\@BBb@Bh\@B~20x@`7K@`Õ$@`7K@a+@`7K@`ݬ\y@`7K@`O@`7K@`_@`7K@a#B@6@6!YN@4c@4;W1@3-V@3}2n@3䎊r@3d@@3䎊r@3R^We3@3䎊r@3O5I?Qp?na&? A?E/?hԭ??Qp?SF۫?Yx̿?˦3?o??3? f?!w?.u+?b1?W~|@@&@,@,@:@;???????t?zrթ?`1ͺN?G@Bj\@`ҹU?uLd?^!n?6f?yt§@_+? @V@zG@zG@zG@Xy>@zG@*@zG@Xy>@zG@Fs@zG@SM@hr!@&x@hr!@2X@hr!@N;6@hr!@hr!@hr!@-V@hr!@s@3`D@3`ěT@0 -^5?|@0 -S&@/:1'@/:kP|@. -#9@. -W'@. -#9@. -ڹY@. -#9@. -0 ? ?1?4!p?̒?b\?2I/?|O?,#?90?-I`K?2&h?Z,a?u@>N ?.x?W ?+ ??B @@@@@*@,??????>]?*c0?'lijo?PxI}@1b@Ϗ?G8H??)? ?_求@g@W@2Ƨ@2l@2Ƨ@2/@2Ƨ@2d8@2Ƨ@2Ǡ l@2Ƨ@2S&@2Ƨ@2 @S@1&y@S@/{J@S@α2@S@ (@S@g@S@@7@7i k~@3|hr@3 @34tj@3US@2sh@3tj~@2sh@2@2sh@2vȴ9X?=fA:?o 6}?$q?ca+r?dtX?=?ۊ?=Be?ol?V)0?q]?ĵP?kV?@`WӐ?6?vc? ?c@@@@@*@(??????gG?N/@?e*E?t @2£S4@ߨhn?3}X?xiğ?堚&Ib?ICb@k@X@@4l@@aoh@@\?@@ʦL/@@dJ@@fx@ltj@l@ltj@e~BZc@ltj@dYJ@ltj@c'RS@ltj@dI@ltj@fh]@7|Q@7t@4+ @3O @37KƧ@3u@3z,<@2;dZ@3z,<@2!R<@3z,<@2$/?¨Sp*?\ZE?3?- -@?ʛ8?I?| V?԰?pVY^?#Lp~?x;q -?ϧr?]~"L?\T%?uf?İi? :C?(@@@@@,@???????!fd #"d?pϳE?u+@w=~@l4A? X?F 71@ʁ#2@X,@X)W@Y@%nP@% ĝ@%nP@%5@%nP@%/n@%nP@%Oƥ@%nP@%9_v@%nP@%hZ@t@t@t@>@t@P@t@#+@t@@t@B@0g l@0g l@+j~"@+lM˶b@+o@+2@)u%F -@)bF{@)u%F -@)4H)@)u%F -@)d?^j?5>?J?ӯc[?tx^?_4?bMn?(tm?~J?/:?=yκ?J W?bw' g?z=`=?pDRh??@j?_cd?@@ @$@&@0@0??????Q; P0?@&?3 Eߐ@%.p@?Nx>?B~I?Ȗp?|G@s Jl@Z@ E@ G@ E@ l!@ E@ J@ E@ @ E@ E@ E@ Mj@mQ@mn@mQ@m/@mQ@mS@mQ@m@mQ@m5?|@mQ@mN<@7r@7n!R<@18r Ĝ@16@0gKƧ@0eڹ@/ -#9@/˒:*@/ -#9@/Fs@/ -#9@/lC?Br?m0?&t?!#?; ^?<_?h??#maЀ??,~[?+!?Ր?tu?%2?m~Z_s,?< N ?7zE?gϵ@@@@@(@*??????[,R.?@ϛP?C)@ tXw@m| y8?`7Q ?`juB}?T-?{=@l$NM@[@nO@m@nO@nn@nO@q>@nO@o@nO@j cr[@nO@lJS%@RH9X@RE@RH9X@RRf{@RH9X@Rd@RH9X@R\م+@RH9X@R\:q@4Q|Q@4N?@0@0Ck@07Kƨ@0@/QN;6@/T_٧J@/QN;6@/K`E@/QN;6@/L j/?}#?3?FU.?zM?\d?\(?`/.~?M\]?X.??h?YF"?@?#A??:>?9D7? -͉{?+r@@&@@&@8@7??????8?fJ b?@4&rYT?Qdi@m%@RTS0i#?`N'?qJU?)Bdκ?DX@hB@\@G@dZ@G.@G.@G.@G.@G.@Ftj@Ftj@Ftj.@Ftj.@Ftj.@Ftj.@Ftj.@1,<@1 '@/.Vt.Mm@/&x.Qn@.z)_.NC,@.z)_.NC,@.z)_.NC,?^XN@8#@8:@8 >+@8I@8?bM_x@8@8i@8@8S@8?j|@8 *@8p@8@8 @8 @?]@J@J=p@J.@J.@J.@J.@J.@7z@73332@7z.@7z.@7z.@7z.@7z.@7s@7҈p@4+ I.Mm@4gKƧ.Qn@3YJ.NC,@3YJ.NC,@3YJ.NC,?F/P5@8#@8:@8 >+@8I@8?F/P5@8@8i@8@8S@8?*я@8 *@8p@8@8 @8 @?^@:^5?}@:^5?}@:^5?}@;dZ@:^5?}@;/V@:^5?}@;u@:^5?}@9J@:^5?}@9+@AS@A/@AS@AQ@AS@AY@AS@Aqu#@AS@A1@AS@Av@.hۋr@.[6@,MV@,M:@,&x@,'RU@+kjf@+k6z@+kjf@+k]cB@+kjf@+k6z?^6P?&H?"?8v??$?bM7? -?90?6)}?֧QD?Uyu#?bM?.+?y8$?ʬv??a+@@@@@*@(??????Lt)OT?-=6?#e8@9WS@ALEN?<"$Wf ?2[e?snY?]@sՄl@_@Pj~#@PiB@Pj~#@Phn@Pj~#@Pc{C@Pj~#@P`Rv@Pj~#@P_ׁ@Pj~#@P_x!@2["`@2Z1@2["`@2l~@2["`@2i|@2["`@2m0@2["`@2jEJ@2["`@2~'(/@42@41@05S@0/N@.x@.Z@.p'RU@._k-8@.p'RU@.`3-@.p'RU@.`USs?|B &?ے@? [ ?W/?-)?dp -#?}@TΥ?Sx=?/JF?~ ?M?7_]?9ÿC? 5?K?\X?ž?<@@$@*@(@9@6??????c^?ia?9c6?DwMP@PdS@2gjn?Yy ?d?ǞhT?5MT@fU@`@$/@A7L@$/@@N@$/@\)@$/@ԕ+@$/@zxl!@$/@\@yXbN@{lD@yXbN@ĴJ@yXbN@ĺ1@yXbN@ķKƧ@yXbN@ġ7K@yXbN@ė@7e!.@7`A7K@30ěT@3+m]@2-V@233333@2?䎊r@24֡a@2?䎊r@2Ov_خ@2?䎊r@2!hr ?E??KvBrq?Q?xTl?4tD?'[ V?HS?DXLa?=?6?[a,?qb?~d?|?j?gT?ñR@@@@@*@*??????4N?k6?h-$?*:1j[@>/X@Ĩ'Vt?x4V?,k"? ث@)[?v@j?L8AS?b@@@@@*@,??????DJ->?9R?Jg?,@M'պ@j?iy -?LT3Q̌?;?;@eշ@@b@Y+@["`@Y+@Q&x@Y+@Zxl"h@Y+@T@Y+@`d@Y+@` k@ݶE@ݟ|h@ݶE@ݸbM@ݶE@ݴ*@ݶE@ݺxl"h@ݶE@ݰ'S@ݶE@ݰ ě@8~($@8*0@3I^5?@3"`A@3Z~"@3b I^5@2YJ@2ڹ@2YJ@2"`@2YJ@2͞&?ك|I?E?u*y?ݡu(r?STS?U.?ڷ??ǀr?؎?W;zY?998?k [X?qJ??mֿtE?c^)?^':?]ߒ@@@@@@???????pLUV_"?eIo q?iL@[e>q@ݳYE?wx76?z|?a"?j@qem@c@ I^5@ C@ I^5@ 85K@ I^5@ A@ I^5@ 1@ I^5@ -@ I^5@ -xi@JG@JlD@JG@J,@JG@J6z@JG@J!X@JG@JvH@JG@J5@1䎊@1 I^6@-)7KƧ@-'2@+F@+%Bв@*N;6@*ϴn<@*N;6@*O@*N;6@*حV?^j?ŊXF?Y(?ӯc[?=?Zw?bMn?Bl9?~J?5ei?h1?P?sF?bM]f?JEO?rGe?C>?~.?e@@(@&@&@4@3??????P6?3JQ2?4 j8'>zg)@ rJ@J9G ?CFćG1? -??F);?b8W@s|lE@d@ E.@ E@ M@ E@ Kjh@ E@ G k@ E.@ E@ Hp:@:Q.@:Q@:^Q@:Q@:T[@:Q@:dZ@:Q.@:Q@:Xe-@904m8.>@3+ J@3fA@2ȓtj@2ohی@2!.I@2#MjP@2!.I.NC,@2!.I@2 @8J?5J ??(4@8I?i@8J?^V֋?P?sw)@8S?*@8p?91a?;?~lVo@8 ?{%@@@@*????e@`A7@`C@`A7@@`A7@,@`A7@+`@`A7@҈p@`A7@3@{~?O*?`]u?ER Y?T8?q' -B@@@@@*@(??????R!?@?YA?UOᦵ?[d׬-@0@+@8I@8?Qp@8@8i@8@8S@8?I@8 *@8p@8@8 @8 @?g@lC@x@lC@r@lC@ٰO@lC@& -@lC@ZT @lC@ꡉ)@D"`@Dڟv@D"`@D-@D"`@Dܿ@D"`@D@D"`@Dpf@D"`@D`I;@3qiC@3zJH@0 -^5?|@0 )8@/Ix@/OWt@-u%F -@-{4-@-u%F -@-v@-u%F -@-?}@TΥ? i?,-?]\8?~G /?*O?|q?m3 -V?NadL?9>+?-xH?|}?pDRg? E?am#?K?>=?b@@"@(@"@6@1??????DO|dHDh?Ix;L"͖?2uau@ - p@D1?iAꟚ?Rf ?A')R?y@fa?X@h@(S@(Y@(S@(P ě@(S@(Eݘ@(S@(MB@(S@(K~(@(S@(OiDg7@ě@G@ě@/@ě@$/@ě@@ě@E85@ě@s@8^H@8VC,@3c@3bs@2tj@2@1&@1$/@1&@1𖻘@1&@1ěT? ?U ?_*k?͌?>{~? d?ϱQm?I1@?bZS?:u. ?La??eBZ?c?e+?Oدi?f?Tj?*Z}@@@@@(@,??????g|P.h4)?NlzZ?WCC@(O^uB@o?sC ?mGt?b?̽I?t@nٵ5@i@/ -=p.@/ -=p@/@/ -=p@/@/ -=p@/۝@/ -=p@/~\N@/ -=p@/aO@?|.@?|@X):@?|@$V@?|@ͺ@?|@E@?|@A@9*0U2b.>@45S@4OIp8@3]V@3^G@3fYJ@3Ol@3fYJ@3{=K^@3fYJ@3@8J?kG ?v8?Jk?JjcJ?GX%Օ@8J?%3Gh?jy ?vA@3@ ě@37+ I@2A7K@2m\@2\Q@24oh@2\Q@27#@2\Q@25?|i@8J?y?&1*?9?—0I?@i@8J? -=@4+ J.Mm@3Vu.Qn@3 -0U2a|.NC,@3 -0U2a|.NC,@3 -0U2a|.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 l@"kR@"\@"kR.@"kR.@"kR.@"kR.@"kR.@R -=q@Rffff@R -=q.@R -=q.@R -=q.@R -=q.@R -=q.@8?@8=hr @5+.Mm@5{Ƨ.Qn@4D*.NC,@4D*.NC,@4D*.NC,?ɏ@8#@8:@8 >+@8I@8?!XW@8@8i@8@8S@8?1zz@8 *@8p@8@8 @8 @?m@H@Hz@H@Gb@H@HH,T@H@GW2n@H@H*J@H@G$@lC@rC@lC@gV{/@lC@ʐCX@lC@jyZ@lC@H-@lC@d+LR@7_o@7c 6@3=hr @3: w$@2KƧ@2{@2m8@2 b6@2m8@2Is(@2m8@1GGO ?q-?QDP?O|[?y:܆&?8ĄV?n^?59W?/an?v˛1?`%-dE?&i?~q_?wG?=?O e? @??!?V]Ő@@(@,@*@:@4??????^m?gC&?d>!I?h9M @HP&@@H?)?ьs?ڰ1Ա!@v -@mij.@n@r>vȴ9@r>vȴ9@r>vȴ9@r?H˒@r>vȴ9@rAG{@r>vȴ9@r>#@r>vȴ9@r=b@r>vȴ9@r9"@hr@O@hr@@hr@r @hr@ *@hr@\(@hr@zxk@7s@7]cf@3 ě@3-V@3`A7@3NU@1s&@1rS&@1s&@1r74@1s&@1sZ?3a=?" ?Mq ?=]. ?(+Zk?i{?Ol?-A?0eʪv?M =?8? f? f -?S1z?t?%@ս;@d3۬? j1* ?Cao?Da:J?7@kb|K@q@ @S@ @͞@ @ 'RT@ @ @ @ -=p@ @u@"M@hs@"M@ - @"M@!G{@"M@64@"M@vȴ9@"M@)B@8T xF@8^u@3ԛS@3tj@3"-V@3v@2~($ @2 @2~($ @21&y@2~($ @2#?|O?MSMӮ?b??o?P?iOL?Y͍_?s?s?GuS?dLt?;?T8L?HO? uf?GZ?`i=?x@@@@@(@(???????co`?V/?\`ŷR?R,?E -@J@9)?|D?q "@!$B?O[Q)=@gt03@r@ڟv@ۥS@ڟv@ۥS@ڟv@Q@ڟv@۲m@ڟv@)y@ڟv@_p@TzG@U?|@TzG@TD@TzG@S@TzG@Stj@TzG@Tm9@TzG@TFs@52@53Mj@0S@0tSM@.F@.+j@.oi@.qj@.oi@.u@.oi@.?? ??&??q@v?DE?F0?|O?MN ?ދ"?{d?peԾ?90?O?§d߱?YF?*|\/?L?j@@@@@@,??????5=0`*h?"W8?" Ge@ ڽ@TnN?B[vaF?C}X?gg ?츨s9@gxڱB6@s@~%@~#@~%@}wd@~%@~ {3O@~%@~Qo@~%@}x@~%@} @u@ȴ9W@u@ѓ/@u@ʣA@u@ϐ4@u@&ZW@u@ӡ}@7쿱[X@7Z@4n5?|@4j-FT9@3-V@30|o@35sh@32)@35sh@32qQm,@35sh@30DF?E[i)? }2?j?@#r)?Ě"]??gޅ?<?`?\oXe=?_? @@"@&@"@,@.??????V2sn?X9XL?UL)@}y@}?w+ ?uY[?ƒξQ?@h,ӣ@t@U@Uȴ9Y@U@UA7M@U@U͸@U@U @U@UǓݗ@U@U7@p ě@p ě@p ě@T3@p ě@L_@p ě@n}Vl@p ě@o M@p ě@gE85@7w@@71 @4|hr@3H˒:@3"`@3 M;@3O M@3GE85@3O M@3p:~@3O M@3 Q?_?5)ZS?ia?ݡu(r?uT5?d?}?C`ߕ?g?Jk?Ss?sUEk?0G --?qn? ??]&?v6?`@@@@@*@*???????FؐT]E ?gffpa^?Q])- -@U@mw?wI7?flR^?UM ?L`r@oL=T@u@<bM@<׍O;@<bM@<"`@<bM@BZc?| ? -?%HC=s?ArU@?_??#?| ?ۣ0Τ?rVx?,?l{9َ?P=?W ?Rii?{W?9XNu?{2?v> @@@@@,@*??????5Ë'Ķ?# -?E2ʤ2@|9:@Ӌd?B.vH?el?o?aZ@f @w@uě@u -=r@uě@un.@uě@uE@uě@uu%F @uě@u҈p@uě@u@+ J@Z@+ J@&@+ J@@+ J@U@+ J@zY@+ J@vȴ@6w@@6zQ`@3hr @3@3A7K@3ƚ,<@3z,<@3g -=p@3z,<@3sS&@3z,<@3pѷX?Br?Q^? Y"?zRU?6z@6!.I@2R I^5@2O[W>@1`A@1E@0D*@0P{@0D*@0ѷX@0D*@0R<6? ?ZAi?reE? h?Ԧ?n?ީqk#? ?ԍD?ud?Nw]6?HO?AP0P?~}o^?cK4+??C?*Q?^':@@@@@,@*??????aA?7xՠ?@ R?1|B~@]tL[@?^9?P?‘$e?/-@e @z@`A7@S@`A7@[@`A7@iDg8@`A7@ݗ*@`A7@}Vl@`A7@4m@Dj~#@DwO;@Dj~#@D@Dj~#@Ds@Dj~#@DV@Dj~#@D@Dj~#@DQ@7:@7fB@3#@3 (@3A7K@3*0U2b@1ޫ6z@1\N@1ޫ6z@1iB@1ޫ6z@1N;6?2Ѳ?u3?d?H?Ux&?dEmc?E?? ]?Ԥ?ghEH?N?x?ACH)?k?WiR?¬ xG?e?3B?NKۗ@@@@@&@&???????! -ހ?dd sbE?nFR@q@DfJ?znd?w}-]?yFc?d$ @px`MdW@{@{lD@{lD@{lD@|c@{lD@}Y@{lD@|hs@{lD@{, -@{lD@{oOu@G9Xb@G9Xb@G9Xb@Gw:(@G9Xb@Gbo@G9Xb@G<@G9Xb@G$@G9Xb@GFs@-Q @-Q @)G-@)G-@'nO@'{m@'N;6@'ί%@'N;6@'D@'N;6@'2W?^6P?Ƿ5?c? :?䮽?fˏ`??bMn? - ?}PI՗?--?3VO?KmHY?bM?P0?of@?'z?]?_cd@@&@"@@5@6??????LY>쭮?.5,l?_l3\@{ԍ@GW?=@/:1'@/9]@.Xy=@.r@.Xy=@.9XbN@.Xy=@.R/?^6P?ǧ H?, ?x?׻p?!?bQ넛? 7?5?-.?ĵl>w?]DgQ?bM?ƭh@4ahr .Mm@3~".Qn@3.NC,@3.NC,@3.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 ~@:r @<.VNQ@:r .@:r .@:r .@:r .@:r .@;1@<(cR(@;1.@;1.@;1.@;1.@;1.@7:@7u@3}hr .Mm@2ߝ-V.Qn@2kxF^.NC,@2kxF^.NC,@2kxF^.NC,?n{@8#@8:@8 >+@8I@8?`Q@8@8i@8@8S@8?玲{@8 *@8p@8@8 @8 @?@F|h@FC@F|h@FA ]@F|h@FcA@F|h@F I]@F|h@F|@F|h@FQ@=E@A@=E@??@=E@;J#9@=E@A@N@=E@($ x@E@,<@E@!/@5zqiC@5zc @3hr @3@3'KƧ@3#|@2@2K]@2@2Y|@2@2|/{J$?|O?;?6p?$jB?Ir??'?}ѿ,?g3?wr?R?ߔ5o?TY9?=Ca?8A?v'X??8~,?b-/@@@@@,@,??????ev"ba~4?BA?y*#.@}h@D&$?U^f2|?u_8h?{p ywA@%@\!|@@nzH@m@nzH@n0@nzH@n^@nzH@o4@nzH@nY`@nzH@oD@Qo@QC@Qo@QK@Qo@Q˯{@Qo@Qͦ@Qo@Q-.mz@Qo@Q5@3֚,<@3ְAٴ@0|hr@0n@e@/E@/ݹ9KW@/`d@/`2@/`d@/T^%Z@/`d@/K"?|b@?ɧkF?,(X?ǵq??2zW/?KɏV?|b@?R?SՇ?97~?oc ?\=U?z*?z+?zb?T ?ƎG?R@@$@&@*@:@7???????5oF ?"y?p?af&?Z@n(@Qi?4U?Œ?oB]?@@*@$@"@6@8??????w??v?n?B\Cѯ@a>@-?p?x+ϬA@=?r@$Ro@lb7Q@?|h@As@?|h@DT@?|h@Doi@?|h@@E@?|h@A-w1@u?|@u\)@u?|@u?@u?|@u '@u?|@u?|@u?|@u$@u?|@uL_@3L]ce@3LL_@-{"`A@-w@,NO;@,K~($@*@*}IQ@*@*}/w@*@*|u#?2}? -?Gk;m?ƠJ-M?2A?+ʦ_?| ?;N?tP*?1'7?2&h?Uyu#??l?y8$?XLL?l&?@@@@@*@(???????Gxa@?D7_?\13-@@oSz@u:?dSEX>[?#c<?k`?Sb@gJ@@p0 -=@p:7s@p0 -=.@p0 -=.@p0 -=.@p0 -=.@p0 -=.@/ۥS@/A7L@/ۥS.@/ۥS.@/ۥS.@/ۥS.@/ۥS.@8^H@8UP@5+ I.Mm@4Ƨ.Qn@4xF^.NC,@4xF^.NC,@4xF^.NC,?5V4S@8#@8:@8 >+@8I@8?"r+@8@8i@8@8S@8?@8 *@8p@8@8 @8 @?@4_;dZ@4h\@4_;dZ@4e84@4_;dZ@4g/W@4_;dZ@4u '@4_;dZ@4f]c@4_;dZ@4cn.@v@vȴ9@v@Iᰉ@v@&I@v@Bwj@v@'@@v@kP@7 xF@7kP@5^+@5Qn.@4`A7L@4,<@4fYJ@4vaf@4fYJ@4xF^@4fYJ@4 qu?+-/? )}o?Fw?ډ?Xz=?ȵ?I~y?ڲt?EU?;q:?{y6?Y{?Xt:w??^i?4i+?b?/я@@@@@(@(??????<)ݨ?XFC?[֢3Va?tuXg@4i%~@&H?|ק&\?.5?&<~?2֕U@h.K:@@!vȴ@!pbM@!vȴ@!R@!vȴ@!@!vȴ@!@!vȴ@!&@!vȴ@!@@w@l@w@(@w@@w@qu"@w@zxl"@w@Xy=@9>6z@9 6z@4ٺ^5?}@4Ϫ͞@4W-@4qu@3sh@3W'@3sh@3@3sh@3?S?Mj̑?-a} ? '??*'?5}'?.Hp?Pe@4sS@4qR<6@3-V@3ߤ@@3!:S@3B@3!:S@3rGE8@3!:S@34m9@8J? 5ф?C?^G_?(:)[a? C@L(@8J?^?_z?p?Ri?V@8p?{6z@0&YJ@0'RT`e@0&YJ@0')^?| ?[e+@8I@8?|O@8@8i@8@8S@8?}@8 *@8p@8@8 @8 @?@]?|@]\)@]?|@]"7T@]?|@]D@]?|@]9!+@]?|@]:@]?|@]E@E@"@E@@E@y8`@E@i@E@WO@E@K`F@4L]ce@4Kނ׶4@0 I^@0 |@/1&@/+:@0 k@00@0 k@02j@0 k@0㷜 ?|h2:?pl?"H?x?E?=AC?|h2:? n?6?XY?m6k?~ܑ?pDRg?H(>X?|E2?ʾ?!,8??BT?;|;2@]=g@@O;d@@O;d@{=K@O;d@HeN@O;d@qi@O;d@@O;d@TɅ@p -@@p -@$@p -@E84@p -@g @p -@1@p -@V@8cg l@8Vz@5I^5?@4=K^@4KƧ@4}K]@4fYJ@3;5Y@4fYJ@4D*@4fYJ@4Ƨ?ʎa]?I6nӨ?*=? Ž?K?? ? -}TE?͙ǁ?Օ" ?ƺ@=t?@hu?V_cW?6)}?^B??qr;?Fb2x? %@@@@@&@(???????qԀ.H?mkԟ?+=B)@@|?qr?CNao?H]f?H,1i@`k08@@O@Oo@O@O)^@O@O@O@OXd@O@O} -@O@OI`@["`@9@["`@Q@["`@N_o@["`@$tS@["`@6$@["`@*g@8~($@8,Gf@4+ I@4oiDg8@317Kƨ@38$ xG@2ޫ6z@2ѷX@2ޫ6z@2gR@2ޫ6z@2nM}R?x9?fײ{=?oq u? Qi?7ű4C?\F*7?fȎY?蠔??íuA?p?[Tas?U?$%G}??P^*@@@@@0@.??????`B|l?L2/?sB-#2?_ag1@O=u@)a?$+?rJ[@cQ?35@p%}@@@O;@@ @@2@@䎉@@8}@@]c@-@;dZ@-@p;@-@1@-@ q@-@S@-@A \@3 xF@3n.3@0ٺ^5?|@0W@0y7KƧ@0q'R@0QiB@0G&@0QiB@0ES@0QiB@0F??1j?M?!N?A2x?ߩ?ҸBz3?|O?&uE@?fM?| ?,rg?,:?nwf??m!?XW~?0&YEd?`i2@@@@@,@,??????rDlQa%?[sA':^?H݂ n.@9p@qmL?y D?eccAu?'_h/?-!]o@co>c@@w33333@w32@w33333@w4Q@w33333@w5hե@w33333@w5BR@w33333@w2*R@w33333@w2w@lD@(@lD@]@lD@;@lD@ń@@lD@nڼ@lD@i@2v@21G-@0 ě@0~N׋@0`A7@/<@.Gݗ,@.F:(KR@.Gݗ,@.F$ Rx@.Gݗ,@.Dzt?^P!?ʃ/J?!,1 ?Ӓ{-@F?pfТ?eK?bQ넛?#$S,?=y?2?/?X3Z:?c6JX?v?'x'9?h9#?_?B@@@&@"@&@8@8??????XNd?L,?>%O?2Y];,@w3!@ ?Ms2ZV?AbEib?s?zinZ@s -@@@4@@v@@ӥ l@@Rp@@w@@Ll@ĒnP@Ć@ĒnP@ą!Ϟ@ĒnP@ć} -@ĒnP@ĉwv'@ĒnP@yn@ĒnP@Ąɠ@6@61͗@3|hr@3[D@3,j~#@3!ĬlV@2p@2bp@2p@2eC@2p@2dNN}6?eXW?K2e?yxb?&?X]N? VM?}@TΥ?괒?ö?zn۹?2-+O?8P?o?Kdn -?uuբ? k4?s ?d@d@@ @(@$@3@4???????{kmAN^X?4mx?Fg@͙@ĄI?S.vjU?eJ>?6Hp?ҩ2;@e?R@@hr!@&x@hr!@{@hr!@{@hr!@`A@hr!@|@hr!@;d[@o-@mhr@o-@k6z@o-@u '@o-@r-V@o-@mw1@o-@o@6`D@6`oiDg8@2f+ J@2g+@1Vu@1iDg8@00U2a|@0˟U=@00U2a|@0 I^@00U2a|@0d7?A[F?Z?4 b5? -?ҧ? µ?3a=?c?ZH|:?Y?=.e1?C ;?US9??Me_?XW~? Ğ?ٔ!x@@@@@,@,??????/U?!o?*K:?75o_T@I@oI.?1xW?UVG(?c#. -R?A}W@l#m@@lC@5?|@lC@'RT@lC@)_@lC@p@lC@z@lC@S&@l@lO;@l@l[V@l@l'RTa@l@lN;7@l@l@l@lC@8@8Mj@5° ě@5q @5Z~"@5FOv_@4@4xl"h -@4@4`A7L@4@4B?Ű[_G?P2 -O?O? +ġ?)^y?I?>sN?jX?'(??Ȍ(?)S&?I?زf?{Tä=?0EK?*:R}?IQ @@@@@$@"??????q";`t?c8Z4b}?J _HN@dg\@l2L?t'Tx?\Q?̈́^?@p@@ A7L@(2{@ A7L@ _@ A7L@'?@ A7L@ Ey@ A7L@ ?U@ A7L@ @@ -=p@Vs(@ -=p@\7@ -=p@ A@ -=p@J@ -=p@5p6@ -=p@)@904m8@94"Z@4{ I^@4y.e@3-V@3 /@3&@3<5N@3&@3s@3&@3i?,t?|u?q)/?O =?Ⱥ?C7?W?ng':?m??LQN?4l?1f2?u ?~)%? ?uA?w@s@@,@*@(@5@:???????u$P@W?xV??ׁ?uG@@yE@r?(?2 ?4,n@"7.@obN@@hr@hr@hr@_b5@hr@zG@hr@sJT@hr@@hr@% D@1'@Tj@1'@V@1'@@1'@aĻ@1'@@1'@yg@4cg l@4ca@N@0uS@0t7@0lj~#@0k*Z@0u@0k2@0u@0wa@0u@0@?}@TΥ?M-U??덭?!O?L65?| V? -r}?tK?0:"l?"ξfS?K?u؆"¿?$-a5[??Q8?@5Gd?G,@@ @ @@8@7??????+U?$4=?2G?dxV@H2@C½ ?Rұv@skä@@qj~@qhs@qj~@q@qj~@qS&@qj~@r*@qj~@rڹ@qj~@r#&@@t9Xb@@+a@@xPH@@@@ @@Ʌo@8@@8>B@4ahr @4YrGE@417Kƨ@4#E@3m8@3~@3m8@35?|@3m8@3rGE8?+-/?]?1?s?\(Ft?ȝ?+-/?(/(?Vh?_?)?:?fƾ?xCZ?1^ ?+&*?y?l@@@@@*@(???????\??b; -?c^5@r \z@q?k - ? FJ?K {?֏@i4>C@@a+ @a[@a+ .@a+ .@a+ .@a+ .@a+ .@"@"@".@".@".@".@".@5H@5qž@1+ I.Mm@1gKƧ.Qn@0sh.NC,@0sh.NC,@0sh.NC,?¨Sp*@8#@8:@8 >+@8I@8?|h2:@8@8i@8@8S@8?oVu@2E?@1ce@1*0@1ce@1v_ح@1ce@17?us\?d̺?lڮ??>{~?0>?% ? {?%8?gy}?Bg43f?>p?@h?bD?`u ?k s?>@k1@@fdZ.@fdZ@f_H@fdZ@fdV@fdZ@fcJss@fdZ@fcnw0n@fdZ@fav@-.@-@<ѥ>@-@2@-@`@-@5n@-@87@8(YJ.>@3+@3&@2Ͳ-V@2;5Y@2L[W?@2LܷQ@2L[W?@2M[j@2L[W?@2Ot@8J?D|?7֫?{đ?Ȗ?9)@8J?L??̷l^?3j ?Y6?@8p?Y{1*?O?@T[?Cbi?+){@&@"@,@<@:?????@s3333@o-@s3333@{J#:@s3333@"y@s3333@~7@s3333@v4J.@s3333@{ *@KR@K,i@KR@J7K@KR@Kq{Ge@KR@K!@KR@KMvL@KR@Kn@7쿱[X@7փ7zX@4S@4PH@3~Vu@3?*![O? J@ch @j?@7+ I.Mm@6V.Qn@5iB.NC,@5iB.NC,@5iB.NC,@8J@8#@8:@8 >+@8I@8@8J@8@8i@8@8S@8@8p@8 *@8p@8@8 @8 @1&@Ƨ@1&@01H@1&@V@1&@-W@1&@C,@1&@@&x@&x@&x@+@&x@PH@&x@N;6@&x@oC@&x@w@.?@.?@(\j~"@(\j@'E@'_ح@&jf@&~%@&jf@&qu!@&jf@&xF^?^j?ت?K?v4?Hc??bMn?F?|;?0j)?'?K '?bM?P0?n3?Ei??@@(@ @*@<@:??????N&8?]?4tF>\N@2G -@dj2?C\j> ɾ? a>\t]޹@s#@@h\@h9X@h\@i?0@h\@ix: @h\@iPt@h\@h6 @h\@h!b@yx@yx@yx@ywG@yx@yy?7@yx@yxV *A@yx@yx~*/@yx@ywIo@1 ]ce@1 ]ce@,`A7K@,Wv.@*cnP@*b<64@*@*@*@**63@*@*4֡a?^j? j?ۭi)?v4?:?YF?bMn?ϷY?|;?/]\?F#?M4C?bw' g?EaӉ?s!?C>? -?|V@@(@"@&@8@7??????5i8+?(`? ^=@hv(R@yx1Uv?#b[9K.?/'?B|z?VCEvf@soI_@@+ J@@+ J@/5@+ J@@+ J@Ͻ@+ J@@+ J@\*@7Kƨ@@7Kƨ@ؑ&5@7Kƨ@莩5@7Kƨ@j r@7Kƨ@$@7Kƨ@@8I_o@8LW}@3+@3"q)@2j~#@2[@1𖻘@1Wm@1𖻘@1 -Z@1𖻘@11:~?zM ??,G?AެÝ?%9?wD['?T?R{?kS?~q?1r:?.{*V??d?.׭st?r,z?Q{ଠ?l ps?{@@$@@@6@4???????F#q?J?@Ie>8?GԜ#@f@ƶw=~?Vu'?]w?IF?\f@oe @@5?|@vȴ9@5?|@b}@5?|@vȴ@5?|@;dZ@5?|@@5?|@<64@&"@&"@&"@&@&"@&XbO@&"@&^5?~@&"@&xl"i@&"@&u%G@3L]ce@3Lj~#@0S@07@.o@.e+@-@-?@-@-䎊q@-@.NU?|O? ?\H{gX?䆀{6? f?{ ?Z!ǟ?] - ?y%?ecQ?M7F?Jj?. ?=M?Q,Ě???(i^?*я?=?+_?54G@@@@@*@??????`4?_|?S+l?h37@sh@6'm?c4>ػ?x'7.o7?SR?՝ @r@@j~#@l@j~#@J#9@j~#@I^5?@j~#@ov_د@j~#@@j~#@#9@\)@|h@\)@͞@\)@lE@\)@ѿ.H@\)@ξߤ@@\)@к~@3N쿱[X@3H ԕ*@0c@/ '@/nP@.D@/At@-1'@/At@-%F -M@/At@-m8?|O?Rf'Y??ǗU?X~̫?t8?1j?ଚw?Q0vX?o)o%?ҲaK?Sh?@3° ě@333333@3n"@3^1@2OO M@2E?|i@2OO M@2fA@2OO M@2?}ѿ,?V/?~#?(+Zk?2Մe?/^?=fA:?_@ -?Խ=?_F?ϟ?Yw?R ?Pk"?.?>?54G?aOD@@@@@@(???????UL_9 V?ad%0N?o?}ѿ,? -= ?ے|?Ol?f)"?`Ƕ?e?tl?4@@@@@*@*???????\Ua`?HJR?N4t -@(pѺg@+q*l?fd|?l\t2?҃*Gp?نe@dļW@@E=E@EYXbN@E=E@E<64@E=E@E9XbO@E=E@E=-V@E=E@E9+@E=E@E8D@-V@7K@-V@m\@-V@vȵ@-V@}V@-V@m\@-V@ѷ@8D@8 xF@3S@3eں@3`A@39@2@2D@2@20 @2@2oiD?us\?;=?T?"?Kǡ?4f(R?5d?5$?@gG*@@s@sQ @s@s?@s@s9Xb@s@s (@s@ss@s@s2@`A7@@`A7@ffff@`A7@&x@`A7@tS@`A7@Ѹ@`A7@˒:*@5I_o@5J=p -@3^5?|@3VϪ@3Ft@3F]cf@2Q@2ܥzxl#@2Q@2lC@2Q@2Xe,? ?/)s?2~? {4?+?*?1j?M7F?}7.?ǧ?D6?h_N%?53y@?nwf?XԠ#{?# Y?Z?mCc4?xb@@@@@"@*??????P~ JX?VF?- ]@sC(8@+NS?u@@$/@%Q@$/@& -L/@$/@&]c@$/@%oiD@$/@#w@$/@#e@J=p@K I@J=p@I @J=p@Ka@J=p@KP|@J=p@K:)@J=p@JOu@55S&@55+a@1B ě@1B @0-V@0ѷY@0#@0$,<@0#@0#\N@0#@0#%2?|O?Čۨ1A?e -!C?:Z2b?1 v?F0?|O?j%Ra?tP*?ni" ? ^??y ? - l\?˛͇q? ݎ8? ??SP?j@@@@@$@(??????0 b 2sY?.[?"ɬ@$d@Jx&?MF'~?Bj Y!?H?E@f(@@F@Ft@F@EjO@F@E첕@F@Ep:@F@Ë́M;@F@E@@5 Ĝ@5?|@5 Ĝ@56z@5 Ĝ@5H@5 Ĝ@5(@5 Ĝ@5䎊r@5 Ĝ@5*0U@7B䎊@7#n.3@1; I^@1Q_@0tj~@/"`@/Gݗ,@/S@/Gݗ,@/ Q @/Gݗ,@/.2?}?(h ?4F&x?J?O??LcR?}ѿ,?LR_5?V@@@@@*@,??????R߿"GH?hҴ}r?EY /@E@5K?vbl?f,? a?В/GSm@ho@H@@1@ۥS@1@s@1@Mj@1@@1@5X@1@b@tj@(@tj@s@tj@Y}@tj@!G|@tj@kP@tj@쿱[@9-v@9/-V@4\I^5?@4`$tS@3"@3*0U2@2Q@2S&@2Q@2n.@2Q@2 ?5}'?tH?Uy*i?I?Br?6c?-2?KF??{Q?(ə?їJ?@K/{?!B?“y?q@@@@@$@&???????R{?:N?A?Eзc@LP@?T;9J?lPA,b?t0~?ǵO@oq+@@V7K@V}E@V7K@V@V7K@VV@V7K@Vu@V7K@V/{J@V7K@V#9@U&ffff@U,@U&ffff@U6l!@U&ffff@U.p:~@U&ffff@U;=K@U&ffff@U*0@U&ffff@U*d8@7@7|#x@2S@2+j@2~"@2ߤ?@1u@18YJ@1u@1ҜwkQ@1u@1SMj?Br?ly? -D?DN?`Q? ?F/P5?*l??ao;?p G)L?x7f?p-?pPȻ?Y͍`?vI?{%? 4e -@@@@@,@(???????lM#9W@?Xa;?Vi?@Vj^F@U-BA?wBy?v">?8 V?/@eaϐ9@@+ J@qxA@+ J@捸@+ J@\(@+ J@|@+ J@#{J#:@+ J.@7K@@7K@-V@7K@ /{K@7K@'@7K@3tj@7K.@6*0U2b@6l"h @4)+ @4䎊r@3-@3ϝ-V@3Eu@3@d8@3Eu@3D/@3Eu.NC,?~Ov_ح?eV?2D?\eú? K@8?C I?(?nv-?Gn?yo@8?!;c,`?&Z#?4y?ژ2U?o@8 @@@@@,?????@DT@B\(@DT@EQ@DT@Eo@DT@FIQ@DT@CF]d@DT@Ca@O@GQ@Gȴ9X@GQ@Gl"h @GQ@Gti@GQ@G@GQ@G'@GQ@Gr@7쿱[X@7M:@20ěT@21N;5@1Htj@1Ik~(@0&@0?@0&@0ݗ+k@0&@0Mj?oC?$?D&?Att?`?6 '8?| ?0n=Q?8G?l™U?O ?!U?{?]b?=d?],V?$H? -t?@@@@@,@(??????G? ?/#?Gm&?P-@DX@G?bw=d$G?+^ o? L?Z7ҹ2@lyga@@S@"@S@@S@}H@S@W>6@S@|@S@D@@+@@ M@@Vϫ@@jg@@/{J@@.3@7D@7hr @3+@3!-w1@2y7KƧ@2y k~@1u@1F -L0@1u@1+a@1u@1š?E@?b[?/͔p? h?FL{?uu?)T?ƍ?Kd+?aYZq??"?3 q?r?c?0?A0)n?L8AS@@@@@*@*??????D(v7V`?? {Pm?<{Z@pR@4>?U;z?^OQW?mqd?Jss @n[7@@hr @g0 c@hr @e#v/n@hr @ir} -[@hr @l=@hr @f3 @hr @g֛%@b0 ě@b0@b0 ě@b&DΙ@b0 ě@b)'*@b0 ě@b(K@b0 ě@b,&bT@b0 ě@b"/M@7B䎊@7E<@3S@3)x@3`A7L@3n@2,<@2u @2,<@2-;.@2,<@2g^es?}x?Urx?Nl?>U?~Ov_ح?fc?R ?[[?mn?Tb?s'%?wG{C?A_K?.X?%c ?jա@@"@&@@3@&???????7k SҘ?H-*gM6?4>b@h`?3@b+ i?g7](?T˿?r??WR@fkY@@1'@S@1'@h@1'@"p@1'@R@1'@#;@1'@i9@1&@I^5@1&@o.@1&@f@1&@$<@1&@fA@1&@$5@3:@35Xy>@0S@0oM@04tj@00XÁe@/PH@/ Fg@/PH@/6 E@/PH@/.R?|h2:?r{?Q:U?\k -?cD:?Rd"?|b@?1 }?%?1>ᔒ?2?XѪ4?@?w?_6C?O ?'0?7ڍsh@@$@&@,@7@7??????b7eQ0Yw%Є?.@+c@˺?\r<?Hmg>m?e3?uq@f5M@@v'lC@v+C@v'lC@v6C@v'lC@vA:@v'lC@vBwj@v'lC@v14J@v'lC@v2{@cM@cY@cM@c~($ x@cM@c'RS@cM@cu%G@cM@cS@cM@cڹ@504m8@5FIl@2+ I@2$3@2-V@1a@@2Tm8@1~u@2Tm8@1)^@2Tm8@1)^?|b@?W[?K̃?r*?|c?9?}#?$i %h?l%FZ?h?Al.6?*%>g?o#BpW?z??WA:?7zE?Ee,@@@@@,@(???????dP?A?c|1t?UP M@v1ݔ@cf?W`o?u[ -@a -+?w_@e{έ -@@@V@@}Vl@@}Vl@@-V@@C,@@ዬq @\=p -@\A7K@\=p -@\>@\=p -@\@ k@\=p -@\An.@\=p -@\@ k@\=p -@\>"@6^H@6^Q@3 ě@3ݗ+@2V@2@1@1a@O@1@1 M;@1@1҈p;?Ol?Qc -??A%?.Kn?5G]!?W;zY??eBZ?@K/{?5 g?A'_^?< N ?t?E݋N@@@@@*@*??????6X7?K bF?.tV@(r|@\@윟?k18k?M':F?/~{m?͚@i'P̽@@!?|@! -=q@!?|@"@!?|@"zH@!?|@"@!?|@"]c@!?|@"oh@I O;d@IO;@I O;d@ITɅ@I O;d@H"@I O;d@I - @I O;d@Hs@I O;d@HkP@8?@8Ov@3 I^5@32W@2-V@2g8}@1_o @1C@1_o @11&x@1_o @1r Ĝ?]?L 5d?^*G?Je ?cf(?=%?]?jKt?Qc -?%)?䬯kF?ҏ,[?*wjs?7&x?W;RT?*+JҚF?X񄖆?%?@@@@,@*??????`qXps?Pmn?D@"'@I2#BZ@ix@heO@ix@gRT`@1|Q@1щ7Kƨ@.kƧ@.i^5?}@-o@-~Q@,Xy=@,$tT@,Xy=@,&x@,Xy=@,:)y?a(?_?S[?ݶ\r?% -?2I/?bV,?,#?tWZ?.? A?yC?cPQ?.x??=rE=?fW?0&YEd@@@@@&@,??????KXـ8[Us2?1nn˷?/d @LDY@h ݏ?@?=\e?{7?pTP@sk<@@;lD@@;lD@SU?/:hn?% ?  ?Ⱦ?~Ov_ح?%mR ?8?DNX1?*d??rG½?t_FS?K ?3t?rݳ&?!R#??d@@*@&@*@;@8??????/X)E?(ˇ? oٳkF@;v@`?H,?AI X?&eh?@\@gbm!O@@z@l@z@$/@z@]c@z@'@z@fB@z@@4@և+ @dZ@և+ @Mj@և+ @fA@և+ @څ@և+ @e+@և+ @PI@8e!.@8S33333@3+@3oi@2ߝ-V@2ܑN;@1𖻘@1Q@1𖻘@1s@1𖻘@1n.?A[F?*|3N?/͔p?Uyu#?V0o~8?iOL?E?-NI`(?@N?kH?x(7?i 0/??,DP?a?XW~?%d?0a@@@@@,@(??????W[U6Z02 -?PǏ?K\V@C@fy?o{I?e*?l%?}+*@l'螎@@[~"@[p@[~"@[dq@[~"@[_b}@[~"@[E84@[~"@[͞@[~"@[!.@Õ%@`V@Õ%@C@Õ%@TzG@Õ%@6ȴ9X@Õ%@0:~@Õ%@- @8=:@8G;n@3E?|h@32s@2ȓtj@2 @2fYJ@2vs@2fYJ@2<@2fYJ@2?A~?h?Br?dx/?×(?`|?!{??|aQ?fb?RCK?m7>n?&f?jNR@?@@@(@(???????oQ:?vAg8?6Q?>;3c@M@ -H\?ss ? f0&@;z0@|s @`{ @@tȴ9X@tKƧ@tȴ9X@t=L@tȴ9X@tIQ@tȴ9X@ue@tȴ9X@tQ@tȴ9X@t)y@pyXbN@pyXbN@pyXbN@p{lE@pyXbN@pxQ@pyXbN@pz=@pyXbN@px_@pyXbN@py+@4]ce@4I^5@@2+S@2(>BZc@1~"@1oh@1 k@0حV@1 k@1-w1@1 k@1s?}ѿ,?nx?)?ɲ?o=\g?oܧ?oM?ւ?{Cx?aʕTI?“y@@@@@(@,???????Q.Z?L*W?*'9D@t;@pyT?m nB$?JՈO?F?rD薅@e'@@҅@҅@҅@҆?@҅@҆$/@҅@҆ -L/@҅@҅F -L@҅@҄7@=@=n@=@=W@=@=T`f@=@=_@=@=a|@=@=GE8@3!.@3oiDh@0O|hr@0O[W>@/@/$/@/C\@/'/X@/C\@/}Vl @/C\@/c ?| ?m0?>f?뤽??G?7F?|O? -?~Q?Hn?Cq$u?GE?8*?.x?? ??L?L@@@@@(@(??????_Le@?q@?Ia?䰉@҅|u~@=;8?f1e?<?߇R% -@f꼄IA@@# -=q@(9X@# -=q@@# -=q@?@# -=q@ -@# -=q@@# -=q@@\(@fffff@\(@@\(@E@\(@@\(@@\(@;dZ@804m8@8#*0U2@3+@3W k@3t@2ϗ$tS@2!.I@1,=@2!.I@1Z@2!.I@1bM?F/P5?'5?mr? h?=W?A!X?Br??!BL?GjH>?Ҩv?BL?׍xG?kc?F?V]9V?H -0?Q@@@@@,@,??????pd+ u?sQ?+"@qǨ@@zG@j~@zG@,<@zG@Xy>@zG@%F -@zG@3333@zG@,<@x!G{@x ě@x!G{@x!G{@x!G{@x ě@x!G{@x"M@x!G{@x!|Q@x!G{@x n@4 ]ce@4 n.@0ahr @0au@/n@/:R@/73@/e+a@/73@/@@/73@/JD?|O?/)s?:?뤽??5 g?7F?}ѿ,? -?'Q?>\?+!?U3p?ʳ_?3;?Ol?+ ?SP? Ğ@@@@@,@,??????$2@?=`?&)"&yE(?)byW@t@x!3L?F,?I#5?w CQ?J D@g`[@@$G@$,@$G@$$@$G@$K^@$G@$@$G@$=c@$G@$-@wglC@w}E@wglC@wdZ@wglC@wh1&z@wglC@weS@wglC@wh@wglC@w\)@6D@6XbM@2I^5?@2҈@2-V@2\(@1ce@1~%@1ce@1/V@1ce@2W?bjk?9؊?ʚCq?pu?z6?a,F??k25?{0?@&?V@@@@@,@*??????Қ@ٹ?ksH*?o94 @[@Z]?O<}?/?o?{ /gv@: I 4@d!}zi@@ I^@ -=q@ I^@tS@ I^@nP@ I^@M@ I^@\(@ I^@&J@5?|@?|@5?|@8YL@5?|@iDg8@5?|@.H@5?|@n.@5?|@wkQ@7D@77Kƨ@3pěT@3nm\@2V@2H˒:@2Eu@2FFs@2Eu@2G$tS@2Eu@2FϪ͟?us\?_ ?Êy?wn-?XMH?_Oo?F^S?-',?To?Jk?4{?{P?k@{?Az?ZaizD?8?`i2?k!l@@@@@*@&??????5C`.?F%K?HLfd@ j@ -?:a݂½-?ahdT?obI?O*N:@n9q@@hr!@-V@hr!@fffg@hr!@ܬ1(@hr!@u@hr!@rGE9@hr!@߱[W?@DT@KC@DT@Eݘ@DT@Gݗ@DT@9=c@DT@KƧ@DT@N;5@7g l@7xl"h -@3S@3D*@3-V@3$/@2Q@2T`d@2Q@2 I_@2Q@264?=fA:?D&d4?reE?XԠ#{?Jg?HAm?sD?kM..? ?GW?y҇?]d}?K3I?zPz?3 ?q' -B?!G?d?H@@@@@,@,???????ej7H\?A>;W?jh,@UP@Dy2?`ZC?_)?upb@00@gw]@@\7@\7 -=p@\7@\4O @\7@\?b}@\7@\A@\7@\:@\7@\Ce@ƻlD@ƽ/@ƻlD@ƿ.H@ƻlD@@ƻlD@ƾ (@ƻlD@L_@ƻlD@Ƨ@6쿱[X@6?@3sS@3pn@2~"@2:~@20U2a|@2 '@20U2a|@2Q@20U2a|@284֢?2}?O9?l5B?9.?wX?>V$?1j?yom?b?3)10F? -Y*?2;?\i?[ș8?Q?a?VM?4\ɵ@@@@@*@,???????d -?hg?Q+f?`\Z ?@\D@e8S=@@#Z1@#Z1@#Z1@#Zc@#Z1@#X@#Z1@#\(@#Z1@#X-@#Z1@#Y=c@(@(@(@64@(@^5?}@(@=K@(@5X@(@@24m8@2A7K@0ٺ^5?|@0@07Kƨ@0{@0!:T@0 n@0!:T@0 (@0!:T@0 D?^XN?Qd?`כm?lDžN9?G?F0?bM_x?,#?pM?Kd]?ڂc?b-x?b@?§d߱?m+&?E 8?ad|?Rv@@@@@*@(??????VL>?U?D`?x?;gx'Y@#Z?@X?Swj?Ii?M?6O2<@s8@@bM@Q @bM@-V@bM@hۋ@bM@S@bM@PH@bM@A@WlC@WlC@WlC@WsP@WlC@W'@WlC@W@WlC@Wě@WlC@Wsg@4|Q@4Gz@1^5?|@1R@1j~#@1Q@1u@0a|Q@1u@0m\@1u@0ݗ+k?|O?%ñ?l5B?~rV?2ּ9?!w?| ? ʣV? ?fa]G?^候?{5?=Ca?Ϸ+? ݎ8?XW~?WZ?:@@@@@*@,???????H2xBI@?Xt?Q9fR@@W -?ve&I?jս?q|?o@aE8F@@+ I@+ I@+ I@*L/@+ I@+ I@+ I@+6z@+ I@)l@+ I@* @,Gz@,Gz@,Gz@,H1&y@,Gz@,H9X@,Gz@,H1&y@,Gz@,Ix@,Gz@,HXy=@3qiC@3L/|@0O|hr@0Ov_ح@/O;d@/$tS@/ -#9@/ oiE@/ -#9@/ ^5?}@/ -#9@/ Ѹ?}ѿ,?ߋb?jhq9?ƠJ-M?~|+?t?| ?7fps?'Q?C B? (fit_val-fit_err*n_sigma)) + return np.abs(true_val - fit_val) <= n_sigma*fit_err def test_Fixed(): # Test handling of a single star true_params = {'x0': 1.0, 'y0':0.5, 'x0_err':0.1, 'y0_err':0.1} mod = motion_model.Fixed() - param_list = mod.fitter_param_names - fixed_param_list = mod.fixed_param_names + param_list = mod.fit_param_names # Confirm return of proper values for single t and array t - x_t, y_t = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list], 0.0) + x_t, y_t = mod.model( + 0.0, + fit_params=np.array([true_params['x0'], true_params['y0']]).T + ) assert x_t==true_params['x0'] assert y_t==true_params['y0'] - x_t, y_t = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list], - [0.0,2025.0,10000]) + x_t, y_t = mod.model( + [0.0,2025.0,10000], + fit_params=np.array([true_params['x0'], true_params['y0']]).T + ) assert (x_t==true_params['x0']).all() assert (y_t==true_params['y0']).all() - # Check behavior of get_batch_pos_at_time + # Check behavior of model x0_batch = np.random.uniform(-2.0,2.0, 50) y0_batch = np.random.uniform(-2.0,2.0, 50) x0_err_batch = np.repeat(0.1, 50) y0_err_batch = np.repeat(0.1, 50) # Single epoch t_batch=2020.0 - x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.get_batch_pos_at_time(t_batch, - x0=x0_batch, y0=y0_batch, x0_err=x0_err_batch, y0_err=y0_err_batch) + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t_batch, + fit_params=np.array([x0_batch, y0_batch]).T, + fit_param_errs=np.array([x0_err_batch, y0_err_batch]).T + ) assert (x_t_batch==x0_batch).all() assert (y_t_batch==y0_batch).all() assert (x_err_t_batch==x0_err_batch).all() assert (y_err_t_batch==y0_err_batch).all() # Multiple times t_batch = np.arange(2015.0,2025.0, 0.5) - x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.get_batch_pos_at_time(t_batch, - x0=x0_batch, y0=y0_batch, x0_err=x0_err_batch, y0_err=y0_err_batch) + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t_batch, + fit_params=np.array([x0_batch, y0_batch]).T, + fit_param_errs=np.array([x0_err_batch, y0_err_batch]).T + ) assert (x_t_batch==np.array([np.repeat(x0_batch_i, len(t_batch)) for x0_batch_i in x0_batch])).all() assert (y_t_batch==np.array([np.repeat(y0_batch_i, len(t_batch)) for y0_batch_i in y0_batch])).all() assert (x_err_t_batch==np.array([np.repeat(x0_err_batch_i, len(t_batch)) for x0_err_batch_i in x0_err_batch])).all() @@ -48,17 +56,37 @@ def test_Fixed(): # Test fitter t = np.arange(2015.0,2025.0, 0.5) # Get values from model and add scatter - x_true, y_true = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list], t) + x_true, y_true = mod.model( + t, + fit_params=np.array([true_params['x0'], true_params['y0']]) + ) x_sim = np.random.normal(x_true, true_params['x0_err']) y_sim = np.random.normal(y_true, true_params['y0_err']) + xe = np.ones_like(t)*true_params['x0_err'] + ye = np.ones_like(t)*true_params['y0_err'] # Run fit - params, param_errs = mod.fit_motion_model(t, x_sim,y_sim, - np.ones(len(t))*true_params['x0_err'], - np.ones(len(t))*true_params['y0_err'], - np.nan) + params, param_errs = mod.fit( + t, + x_sim,y_sim, + xe=xe, + ye=ye + ) + + x_wt = 1. / xe**2 + y_wt = 1. / ye**2 + x_wt_norm = x_wt / np.sum(x_wt) + y_wt_norm = y_wt / np.sum(y_wt) + x_mean = np.average(x_sim, weights=x_wt) + y_mean = np.average(y_sim, weights=y_wt) + x_std = (np.sum(x_wt_norm**2 * xe**2))**0.5 + y_std = (np.sum(y_wt_norm**2 * ye**2))**0.5 + # Confirm true value is within error bar of fit value assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) + np.testing.assert_allclose(params[0], x_mean, atol=1e-5) + np.testing.assert_allclose(params[1], y_mean, atol=1e-5) + np.testing.assert_allclose(param_errs[0], x_std, atol=1e-5) + np.testing.assert_allclose(param_errs[1], y_std, atol=1e-5) def test_Linear(): @@ -67,22 +95,25 @@ def test_Linear(): 'vx':0.2, 'vy':0.5, 'vx_err':0.05, 'vy_err':0.05, 't0':2025.0} mod = motion_model.Linear() - param_list = mod.fitter_param_names - fixed_param_list = mod.fixed_param_names + param_list = mod.fit_param_names # Confirm return of proper values for single t=t0 and array t - x_t, y_t = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list], - true_params['t0']) + x_t, y_t = mod.model( + t=true_params['t0'], + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) assert x_t==true_params['x0'] assert y_t==true_params['y0'] t_arr = np.array([2010.0,true_params['t0'],2030.0]) - x_t, y_t = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list], - t_arr) + x_t, y_t = mod.model( + t=t_arr, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) assert (x_t==(true_params['x0'] + (t_arr-true_params['t0'])*true_params['vx'])).all() assert (y_t==(true_params['y0'] + (t_arr-true_params['t0'])*true_params['vy'])).all() - - # Check behavior of get_batch_pos_at_time + + # Check behavior of model x0_batch = np.random.uniform(-2.0,2.0, 50) y0_batch = np.random.uniform(-2.0,2.0, 50) vx_batch = np.random.uniform(-2.0,2.0, 50) @@ -94,71 +125,103 @@ def test_Linear(): t0_batch = np.repeat(2025.0,50) # Single epoch t_batch=2020.0 - x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.get_batch_pos_at_time(t_batch, - x0=x0_batch, y0=y0_batch, x0_err=x0_err_batch, y0_err=y0_err_batch, - vx=vx_batch, vy=vy_batch, vx_err=vx_err_batch, vy_err=vy_err_batch, - t0=t0_batch) - assert (x_t_batch==(x0_batch+(t_batch-t0_batch)*vx_batch)).all() - assert (y_t_batch==(y0_batch+(t_batch-t0_batch)*vy_batch)).all() - assert (x_err_t_batch==np.hypot(x0_err_batch, (t_batch-t0_batch)*vx_err_batch)).all() - assert (y_err_t_batch==np.hypot(y0_err_batch, (t_batch-t0_batch)*vy_err_batch)).all() + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx_batch, y0_batch, vy_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx_err_batch, y0_err_batch, vy_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + + np.testing.assert_allclose(x_t_batch, (x0_batch+(t_batch-t0_batch)*vx_batch), atol=1e-5) + np.testing.assert_allclose(y_t_batch, (y0_batch+(t_batch-t0_batch)*vy_batch), atol=1e-5) + np.testing.assert_allclose(x_err_t_batch, np.hypot(x0_err_batch, (t_batch-t0_batch)*vx_err_batch), atol=1e-5) + np.testing.assert_allclose(y_err_t_batch, np.hypot(y0_err_batch, (t_batch-t0_batch)*vy_err_batch), atol=1e-5) + # Multiple times t_batch = np.arange(2015.0,2025.0, 0.5) - x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.get_batch_pos_at_time(t_batch, - x0=x0_batch, y0=y0_batch, x0_err=x0_err_batch, y0_err=y0_err_batch, - vx=vx_batch, vy=vy_batch, vx_err=vx_err_batch, vy_err=vy_err_batch, - t0=t0_batch) - assert (x_t_batch==np.array([x0_batch[i] + (t_batch-t0_batch[i])*vx_batch[i] for i in range(len(x0_batch))])).all() - assert (y_t_batch==np.array([y0_batch[i] + (t_batch-t0_batch[i])*vy_batch[i] for i in range(len(x0_batch))])).all() - assert (x_err_t_batch==np.array([np.hypot(x0_err_batch[i], (t_batch-t0_batch[i])*vx_err_batch[i]) for i in range(len(x0_batch))])).all() - assert (y_err_t_batch==np.array([np.hypot(y0_err_batch[i], (t_batch-t0_batch[i])*vy_err_batch[i]) for i in range(len(x0_batch))])).all() - + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx_batch, y0_batch, vy_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx_err_batch, y0_err_batch, vy_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + np.testing.assert_allclose(x_t_batch, np.array([x0_batch[i] + (t_batch-t0_batch[i])*vx_batch[i] for i in range(len(x0_batch))]), atol=1e-5) + np.testing.assert_allclose(y_t_batch, np.array([y0_batch[i] + (t_batch-t0_batch[i])*vy_batch[i] for i in range(len(x0_batch))]), atol=1e-5) + np.testing.assert_allclose(x_err_t_batch, np.array([np.hypot(x0_err_batch[i], (t_batch-t0_batch[i])*vx_err_batch[i]) for i in range(len(x0_batch))]), atol=1e-5) + np.testing.assert_allclose(y_err_t_batch, np.array([np.hypot(y0_err_batch[i], (t_batch-t0_batch[i])*vy_err_batch[i]) for i in range(len(x0_batch))]), atol=1e-5) + # Test fitter t = np.arange(2015.0,2025.0, 0.5) # Get values from model and add scatter - x_true, y_true = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list],t) + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) x_sim = np.random.normal(x_true, 0.05) y_sim = np.random.normal(y_true, 0.05) # Run fit - params, param_errs = mod.fit_motion_model(t, x_sim,y_sim, - np.repeat(0.05, len(t)), np.repeat(0.05,len(t)), true_params['t0']) - print(param_errs) - # Confirm true value is within error bar of fit value - assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) - + xe = np.ones_like(t)*0.05 + ye = np.ones_like(t)*0.05 + + def linear(t, x0, vx): + return x0 + vx * t + + for absolute_sigma in [True, False]: + for weighting in ['std', 'var']: + for use_scipy in [True, False]: + params, param_errs = mod.fit( + t=t, + x=x_sim, + y=y_sim, + xe=xe, + ye=ye, + fixed_params_dict={'t0': true_params['t0']}, + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma + ) + + # Scipy + xe_scipy = xe**0.5 if weighting=='std' else xe + ye_scipy = ye**0.5 if weighting=='std' else ye + x_popt, x_pcov = curve_fit( + linear, + t - true_params['t0'], + x_sim, + sigma=xe_scipy, + absolute_sigma=absolute_sigma, + p0=[np.mean(x_sim), 0.0] + ) + y_popt, y_pcov = curve_fit( + linear, + t - true_params['t0'], + y_sim, + sigma=ye_scipy, + absolute_sigma=absolute_sigma, + p0=[np.mean(y_sim), 0.0] + ) + np.testing.assert_allclose(params[:2], x_popt, atol=1e-5) + np.testing.assert_allclose(param_errs[:2], np.sqrt(np.diag(x_pcov)), atol=1e-5) + np.testing.assert_allclose(params[2:], y_popt, atol=1e-5) + np.testing.assert_allclose(param_errs[2:], np.sqrt(np.diag(y_pcov)), atol=1e-5) + # Test fitter with bootstrap - t = np.arange(2015.0,2025.0, 0.5) + t = np.arange(2015.0, 2025.0, 0.5) # Get values from model and add scatter - x_true, y_true = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list],t) - x_true_err, y_true_err = np.repeat(0.05,len(t)), np.repeat(0.05,len(t)) + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + x_true_err, y_true_err = np.ones_like(t)*0.05, np.ones_like(t)*0.05 x_sim = np.random.normal(x_true, x_true_err) y_sim = np.random.normal(y_true, y_true_err) # Run fit - params, param_errs = mod.fit_motion_model(t, x_sim,y_sim, x_true_err, y_true_err, true_params['t0'],bootstrap=10) - print(param_errs) + params, param_errs = mod.fit(t, x_sim, y_sim, x_true_err, y_true_err, fixed_params_dict={'t0': true_params['t0']}, bootstrap=10, seed=42) # Confirm true value is within error bar of fit value assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) - -# # Test fitter for 2 pts -# t = np.array([2015.0,2025.0]) -# # Get values from model and add scatter -# x_true, y_true = mod.get_pos_at_time([true_params[p] for p in param_list], -# [true_params[p] for p in fixed_param_list],t) -# x_true_err, y_true_err = np.repeat(0.05,len(t)), np.repeat(0.05,len(t)) -# x_sim = np.random.normal(x_true, x_true_err) -# y_sim = np.random.normal(y_true, y_true_err) -# # Run fit -# mod_fit = motion_model.Linear(t0=true_params['t0']) -# params, param_errs = mod_fit.fit_motion_model(t, x_sim,y_sim, x_true_err, y_true_err, true_params['t0']) -# print("DJSKBGJ",param_list) -# print([true_params[p] for p in param_list]) -# print(params) -# print(param_errs) -# # Confirm true value is within error bar of fit value -# assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params),2)]) - + def test_Acceleration(): # Test handling of a single star @@ -167,22 +230,25 @@ def test_Acceleration(): 'ax':0.1, 'ay':-0.1, 'ax_err':0.02, 'ay_err':0.02, 't0':2025.0} mod = motion_model.Acceleration() - param_list = mod.fitter_param_names - fixed_param_list = mod.fixed_param_names + param_list = mod.fit_param_names # Confirm return of proper values for single t=t0 and array t - x_t, y_t = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list], - true_params['t0']) - assert x_t==true_params['x0'] - assert y_t==true_params['y0'] - t_arr = np.array([2010.0,true_params['t0'],2030.0]) - x_t, y_t = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list], - t_arr) - assert (x_t==(true_params['x0'] + (t_arr-true_params['t0'])*true_params['vx0'] + 0.5*(t_arr-true_params['t0'])**2*true_params['ax'])).all() - assert (y_t==(true_params['y0'] + (t_arr-true_params['t0'])*true_params['vy0'] + 0.5*(t_arr-true_params['t0'])**2*true_params['ay'])).all() + x_t, y_t = mod.model( + t=true_params['t0'], + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + np.testing.assert_allclose(x_t, true_params['x0']) + np.testing.assert_allclose(y_t, true_params['y0']) + t_arr = np.array([2010.0, true_params['t0'], 2030.0]) + x_t, y_t = mod.model( + t=t_arr, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + np.testing.assert_allclose(x_t, true_params['x0'] + (t_arr-true_params['t0'])*true_params['vx0'] + 0.5*(t_arr-true_params['t0'])**2*true_params['ax']) + np.testing.assert_allclose(y_t, true_params['y0'] + (t_arr-true_params['t0'])*true_params['vy0'] + 0.5*(t_arr-true_params['t0'])**2*true_params['ay']) - # Check behavior of get_batch_pos_at_time + # Check behavior of model x0_batch = np.random.uniform(-2.0,2.0, 50) y0_batch = np.random.uniform(-2.0,2.0, 50) vx0_batch = np.random.uniform(-2.0,2.0, 50) @@ -198,83 +264,135 @@ def test_Acceleration(): t0_batch = np.repeat(2025.0,50) # Single epoch t_batch=2020.0 - x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.get_batch_pos_at_time(t_batch, - x0=x0_batch, y0=y0_batch, x0_err=x0_err_batch, y0_err=y0_err_batch, - vx0=vx0_batch, vy0=vy0_batch, vx0_err=vx0_err_batch, vy0_err=vy0_err_batch, - ax=ax_batch, ay=ay_batch, ax_err=ax_err_batch, ay_err=ay_err_batch, - t0=t0_batch) - assert (x_t_batch==(x0_batch + (t_batch-t0_batch)*vx0_batch + 0.5*(t_batch-t0_batch)**2*ax_batch)).all() - assert (y_t_batch==(y0_batch + (t_batch-t0_batch)*vy0_batch + 0.5*(t_batch-t0_batch)**2*ay_batch)).all() - assert (x_err_t_batch==np.sqrt(x0_err_batch**2 + ((t_batch-t0_batch)*vx0_err_batch)**2 + - (0.5*(t_batch-t0_batch)**2*ax_err_batch)**2)).all() - assert (y_err_t_batch==np.sqrt(y0_err_batch**2 + ((t_batch-t0_batch)*vy0_err_batch)**2 + - (0.5*(t_batch-t0_batch)**2*ay_err_batch)**2)).all() + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx0_batch, ax_batch, y0_batch, vy0_batch, ay_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx0_err_batch, ax_err_batch, y0_err_batch, vy0_err_batch, ay_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + np.testing.assert_allclose(x_t_batch, x0_batch + (t_batch-t0_batch)*vx0_batch + 0.5*(t_batch-t0_batch)**2*ax_batch) + np.testing.assert_allclose(y_t_batch, y0_batch + (t_batch-t0_batch)*vy0_batch + 0.5*(t_batch-t0_batch)**2*ay_batch) + np.testing.assert_allclose(x_err_t_batch, np.sqrt(x0_err_batch**2 + ((t_batch-t0_batch)*vx0_err_batch)**2 + + (0.5*(t_batch-t0_batch)**2*ax_err_batch)**2)) + np.testing.assert_allclose(y_err_t_batch, np.sqrt(y0_err_batch**2 + ((t_batch-t0_batch)*vy0_err_batch)**2 + + (0.5*(t_batch-t0_batch)**2*ay_err_batch)**2)) + # Multiple times t_batch = np.arange(2015.0,2025.0, 0.5) - x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.get_batch_pos_at_time(t_batch, - x0=x0_batch, y0=y0_batch, x0_err=x0_err_batch, y0_err=y0_err_batch, - vx0=vx0_batch, vy0=vy0_batch, vx0_err=vx0_err_batch, vy0_err=vy0_err_batch, - ax=ax_batch, ay=ay_batch, ax_err=ax_err_batch, ay_err=ay_err_batch, - t0=t0_batch) - assert (x_t_batch==np.array([x0_batch[i] + (t_batch-t0_batch[i])*vx0_batch[i] + 0.5*(t_batch-t0_batch[i])**2*ax_batch[i] for i in range(len(x0_batch))])).all() - assert (y_t_batch==np.array([y0_batch[i] + (t_batch-t0_batch[i])*vy0_batch[i] + 0.5*(t_batch-t0_batch[i])**2*ay_batch[i] for i in range(len(x0_batch))])).all() - assert (x_err_t_batch==np.array([np.sqrt(x0_err_batch[i]**2 + ((t_batch-t0_batch[i])*vx0_err_batch[i])**2 + (0.5*(t_batch-t0_batch[i])**2*ax_err_batch[i])**2) for i in range(len(x0_batch))])).all() - assert (y_err_t_batch==np.array([np.sqrt(y0_err_batch[i]**2 + ((t_batch-t0_batch[i])*vy0_err_batch[i])**2 + (0.5*(t_batch-t0_batch[i])**2*ay_err_batch[i])**2) for i in range(len(x0_batch))])).all() - + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx0_batch, ax_batch, y0_batch, vy0_batch, ay_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx0_err_batch, ax_err_batch, y0_err_batch, vy0_err_batch, ay_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + np.testing.assert_allclose(x_t_batch, np.array([x0_batch[i] + (t_batch-t0_batch[i])*vx0_batch[i] + 0.5*(t_batch-t0_batch[i])**2*ax_batch[i] for i in range(len(x0_batch))])) + np.testing.assert_allclose(y_t_batch, np.array([y0_batch[i] + (t_batch-t0_batch[i])*vy0_batch[i] + 0.5*(t_batch-t0_batch[i])**2*ay_batch[i] for i in range(len(x0_batch))])) + np.testing.assert_allclose(x_err_t_batch, np.array([np.sqrt(x0_err_batch[i]**2 + ((t_batch-t0_batch[i])*vx0_err_batch[i])**2 + (0.5*(t_batch-t0_batch[i])**2*ax_err_batch[i])**2) for i in range(len(x0_batch))])) + np.testing.assert_allclose(y_err_t_batch, np.array([np.sqrt(y0_err_batch[i]**2 + ((t_batch-t0_batch[i])*vy0_err_batch[i])**2 + (0.5*(t_batch-t0_batch[i])**2*ay_err_batch[i])**2) for i in range(len(x0_batch))])) + # Test fitter t = np.arange(2015.0,2025.0, 0.5) # Get values from model and add scatter - x_true, y_true = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list],t) - x_true_err = np.sqrt(true_params['x0_err']**2 + ((t-true_params['t0'])*true_params['vx0_err'])**2 + - (0.5*(t-true_params['t0'])**2*true_params['ax_err'])**2) - y_true_err = np.sqrt(true_params['y0_err']**2 + ((t-true_params['t0'])*true_params['vy0_err'])**2 + - (0.5*(t-true_params['t0'])**2*true_params['ay_err'])**2) + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + x_true_err = np.sqrt(true_params['x0_err']**2 + ((t - true_params['t0']) * true_params['vx0_err'])**2 + + (0.5*(t - true_params['t0'])**2 * true_params['ax_err'])**2) + y_true_err = np.sqrt(true_params['y0_err']**2 + ((t - true_params['t0']) * true_params['vy0_err'])**2 + + (0.5*(t - true_params['t0'])**2 * true_params['ay_err'])**2) x_sim = np.random.normal(x_true, x_true_err) y_sim = np.random.normal(y_true, y_true_err) # Run fit - mod_fit = motion_model.Acceleration(t0=true_params['t0']) - params, param_errs = mod_fit.fit_motion_model(t, x_sim,y_sim, x_true_err, y_true_err, true_params['t0']) + mod_fit = motion_model.Acceleration() + params, param_errs = mod_fit.fit( + t=t, + x=x_sim, + y=y_sim, + xe=x_true_err, + ye=y_true_err, + fixed_params_dict={'t0': true_params['t0']} + ) # Confirm true value is within error bar of fit value assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) - + #@pytest.mark.skip(reason="not written") def test_Parallax(): # Test handling of a single star true_params = {'x0': 1.0, 'y0':-0.5, 'x0_err':0.1, 'y0_err':0.1, 'vx':-0.2, 'vy':0.5, 'vx_err':0.05, 'vy_err':0.05, - 'pi':0.5, 'RA':17.76, 'Dec':-28.933, 'PA':0, - 't0':2020.0} - mod = motion_model.Parallax(**{'RA':17.76, 'Dec':-28.933, 'PA':0}) - param_list = mod.fitter_param_names - fixed_param_list = mod.fixed_param_names - print(param_list) + 'pi':0.5, 'ra':17.76, 'dec':-28.933, 'pa':0, + 't0':2020.0, 'obsLocation': 'earth'} + mod = motion_model.Parallax() + param_list = mod.fit_param_names + fixed_params_dict = { + 't0': true_params['t0'], + 'ra': true_params['ra'], + 'dec': true_params['dec'], + 'pa': true_params['pa'], + 'obsLocation': true_params['obsLocation'] + } # Test fitter t = np.arange(2015.0,2025.0, 0.5) # Get values from model and add scatter - x_true, y_true = mod.get_pos_at_time([true_params[p] for p in param_list], - [true_params[p] for p in fixed_param_list],t) - x_true_err, y_true_err = np.repeat(0.1,len(t)), np.repeat(0.1,len(t)) + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict=fixed_params_dict + ) + x_true_err, y_true_err = np.ones_like(t)*true_params['x0_err'], np.ones_like(t)*true_params['y0_err'] x_sim = np.random.normal(x_true, x_true_err) y_sim = np.random.normal(y_true, y_true_err) # Run fit - params, param_errs = mod.fit_motion_model(t, x_sim,y_sim, x_true_err, y_true_err, true_params['t0']) + params, param_errs = mod.fit(t, x_sim,y_sim, x_true_err, y_true_err, fixed_params_dict=fixed_params_dict) + + x_model, y_model = mod.model( + t=t, + fit_params=params, + fixed_params_dict=fixed_params_dict + ) + plt.clf() + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5)) + ax1.plot(t, x_model, color='C3', lw=2, label='Model x') + ax1.plot(t, x_true, color='C0', ls='--', label='True x') + ax1.errorbar(t, x_sim, yerr=x_true_err, fmt='o', color='C0', label='Sim x') + ax1.set_xlabel('t') + ax1.set_ylabel('x') + ax1.legend() + ax2.plot(t, y_model, color='C3', lw=2, label='Model y') + ax2.plot(t, y_true, color='C0', ls='--', label='True y') + ax2.errorbar(t, y_sim, yerr=y_true_err, fmt='o', color='C0', label='Sim y') + ax2.set_xlabel('t') + ax2.set_ylabel('y') + ax2.legend() + plt.tight_layout() + # Confirm true value is within error bar of fit value assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) - def test_Parallax_PA(): # Set PA=0 model x0, y0 = 2.0, -1.0 vx, vy = 0.2, 0.5 - RA, Dec = 17.76, -28.933 + ra, dec = 17.76, -28.933 pi = 0.5 - mod_pa0 = motion_model.Parallax(RA=RA,Dec=Dec, PA=0) + mod_pa0 = motion_model.Parallax() # Set PA=90 model with equivalent parameters in that frame - mod_pa90 = motion_model.Parallax(RA=RA,Dec=Dec,t0=2020.0, PA=90) - t_set = np.arange(2018,2024,0.01) - dat_pa0 = mod_pa0.get_pos_at_time([x0,vx,y0,vy,pi],[2020.0],t_set) - dat_pa90 = mod_pa90.get_pos_at_time([y0,vy,-x0,-vx,pi],[2020.0],t_set) - assert (np.abs(dat_pa0[0]-(-dat_pa90[1]))<1e-10).all() - assert (np.abs(dat_pa0[1]-(dat_pa90[0]))<1e-10).all() + mod_pa90 = motion_model.Parallax() + + t_set = np.arange(2018, 2024, 0.01) + t0 = 2020.0 + dat_pa0 = mod_pa0.model( + t = t_set, + fit_params = np.array([x0, vx, y0, vy, pi]).T, + fixed_params_dict = {'t0': t0, 'ra': ra, 'dec': dec, 'pa': 0} + ) + dat_pa90 = mod_pa90.model( + t = t_set, + fit_params = np.array([y0, vy, -x0, -vx, pi]).T, + fixed_params_dict = {'t0': t0, 'ra': ra, 'dec': dec, 'pa': 90} + ) + np.testing.assert_allclose(dat_pa0[0], -dat_pa90[1], atol=1e-10) + np.testing.assert_allclose(dat_pa0[1], dat_pa90[0], atol=1e-10) \ No newline at end of file diff --git a/flystar/tests/test_starlist.py b/flystar/tests/test_starlist.py index 5113c43..568c26d 100644 --- a/flystar/tests/test_starlist.py +++ b/flystar/tests/test_starlist.py @@ -1,16 +1,17 @@ from astropy.table import Table from flystar.starlists import StarList import os, pdb +import flystar -test_dir = os.path.dirname(__file__) +test_data_path = f'{flystar.__path__[0]}/tests/test_data' def make_star_list(): # User input - cat_file = test_dir + '/A.lis' + cat_file = f'{test_data_path}/A.lis' # Read and arrange the test input - cat_tab = Table.read(cat_file, format='ascii', delimiter='\s') + cat_tab = Table.read(cat_file, format='ascii', delimiter=r'\s') # Copy columns from the input file. # Note that all of these inputs will be numpy arrays. @@ -25,7 +26,7 @@ def make_star_list(): # Name is a unique name for each star and is a 1D array. starlist_time = 2011.1 - starlist_name = 'A.lis' + starlist_name = f'{test_data_path}/A.lis' # Generate the starlist starlist = StarList(name=name_in, x=x_in, y=y_in, m=m_in, xe=xe_in, diff --git a/flystar/tests/test_startable.py b/flystar/tests/test_startable.py index 9962c05..f8e24de 100644 --- a/flystar/tests/test_startable.py +++ b/flystar/tests/test_startable.py @@ -1,22 +1,22 @@ +import os +import pdb +import pytest +import flystar +import numpy as np from astropy.table import Table from astropy import table from flystar import motion_model from flystar.startables import StarTable from flystar.starlists import StarList -from flystar import motion_model -import numpy as np -import pytest -import os -import pdb -test_dir = os.path.dirname(__file__) +test_data_path = f'{flystar.__path__[0]}/tests/test_data' def test_StarTable_init1(): """ Test creation of new StarTable. """ # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -41,9 +41,14 @@ def test_StarTable_init1(): starlist_names = np.array(['file1', 'file2', 'file3', 'file4', 'file5', 'file6', 'file7', 'file8']) # Generate the startable - startable = StarTable(name=name_in, x=x_in, y=y_in, m=m_in, xe=xe_in, ye=ye_in, me=me_in, - ref_list=1, - list_times=starlist_times, list_names=starlist_names) + startable = StarTable( + name=name_in, + x=x_in, y=y_in, m=m_in, + xe=xe_in, ye=ye_in, me=me_in, + ref_list=1, + list_times=starlist_times, + list_names=starlist_names + ) # Now put in some assertions to make sure all our startable columns # have the right dimensions. @@ -57,7 +62,7 @@ def test_StarTable_init1(): assert len(startable['name']) == N_stars assert startable.meta['list_times'][0] == starlist_times[0] assert type(startable) == StarTable - + return def test_StarTable_init2(): @@ -67,8 +72,8 @@ def test_StarTable_init2(): Also double check that we can add a second list to it using add_starlist and we can get_starlist() as well. """ - list_file1 = 'A.lis' - list_file2 = 'B.lis' + list_file1 = 'test_data/A.lis' + list_file2 = 'test_data/B.lis' list1 = StarList.from_lis_file(list_file1) list2 = StarList.from_lis_file(list_file2) @@ -77,7 +82,6 @@ def test_StarTable_init2(): assert len(tab) == len(list1) - return def test_combine_lists(): @@ -102,7 +106,7 @@ def test_combine_lists(): t.combine_lists('x', mask_val=-100000) assert t['x0'][0] == x_avg_0 assert t['x0'][-1] == pytest.approx(2108.855, 0.001) - + # Test 4: weighted average of x. x_wgt_0 = 1.0 / t['xe'][0, :]**2 x_avg_0 = np.average(t['x'][0, :], weights=x_wgt_0) @@ -117,14 +121,14 @@ def test_combine_lists(): # Test 5: make sure mask_list is working. ########## # Test 5ai: Non-masked, weighted_m=False - tt.combine_lists_xym(weighted_xy=True, weighted_m=False, mask_lists=False) + tt.combine_lists_xym(weighted_xy=True, weighted_m=False, mask_lists=None) assert np.arange(1.8, 38, 4) == pytest.approx(tt['x0'].data) assert np.arange(1.8, 38, 4) == pytest.approx(tt['y0'].data) avg_m = -2.5 * np.log10((4 * 10**-0.4 + 1)/5) assert avg_m * np.ones(10) == pytest.approx(tt['m0'].data) # Test 5aii: Non-masked, weighted_m=True - tt.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=False) + tt.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=None) assert np.arange(1.8, 38, 4) == pytest.approx(tt['x0'].data) assert np.arange(1.8, 38, 4) == pytest.approx(tt['y0'].data) avg_m_weight = 0.9391744564422395 @@ -143,9 +147,10 @@ def test_combine_lists(): assert np.ones(10) == pytest.approx(tt['m0'].data) # Test 5c: Things that should break the code. - with pytest.raises(RuntimeError): - t.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=np.arange(2)) - with pytest.raises(RuntimeError): + # with pytest.raises(RuntimeError): + # This would not break the code anymore + # t.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=np.arange(2)) + with pytest.raises(AssertionError): t.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=True) return @@ -170,78 +175,79 @@ def test_add_starlist(): t.add_starlist(x=x_new, y=y_new, m=m_new, xe=xe_new, ye=ye_new, me=me_new, meta={'list_times': t_new}) - assert len(t) == len(t_orig) + np.testing.assert_equal(len(t), len(t_orig)) expected_shape = np.array(t_orig['x'].shape) expected_shape[1] += 1 - - assert len(t['x'].shape) == len(expected_shape) - assert t['x'].shape[0] == expected_shape[0] + + np.testing.assert_equal(len(t['x'].shape), len(expected_shape)) + np.testing.assert_equal(t['x'].shape[0], expected_shape[0]) assert t['x'].shape[1] == expected_shape[1] - assert len(t['y'].shape) == len(expected_shape) - assert t['y'].shape[0] == expected_shape[0] + np.testing.assert_equal(len(t['y'].shape), len(expected_shape)) + np.testing.assert_equal(t['y'].shape[0], expected_shape[0]) assert t['y'].shape[1] == expected_shape[1] - assert len(t['m'].shape) == len(expected_shape) - assert t['m'].shape[0] == expected_shape[0] + np.testing.assert_equal(len(t['m'].shape), len(expected_shape)) + np.testing.assert_equal(t['m'].shape[0], expected_shape[0]) assert t['m'].shape[1] == expected_shape[1] - assert len(t['xe'].shape) == len(expected_shape) - assert t['xe'].shape[0] == expected_shape[0] - assert t['xe'].shape[1] == expected_shape[1] - - assert len(t['ye'].shape) == len(expected_shape) - assert t['ye'].shape[0] == expected_shape[0] - assert t['ye'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['xe'].shape), len(expected_shape)) + np.testing.assert_equal(t['xe'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['xe'].shape[1], expected_shape[1]) - assert len(t['me'].shape) == len(expected_shape) - assert t['me'].shape[0] == expected_shape[0] - assert t['me'].shape[1] == expected_shape[1] - - assert len(t['name']) == len(t_orig['name']) - assert len(t.meta['list_times']) == expected_shape[1] - assert t.meta['n_lists'] == 9 + np.testing.assert_equal(len(t['ye'].shape), len(expected_shape)) + np.testing.assert_equal(t['ye'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['ye'].shape[1], expected_shape[1]) + np.testing.assert_equal(len(t['me'].shape), len(expected_shape)) + np.testing.assert_equal(t['me'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['me'].shape[1], expected_shape[1]) + np.testing.assert_equal(len(t['name']), len(t_orig['name'])) + np.testing.assert_equal(len(t.meta['list_times']), expected_shape[1]) + np.testing.assert_equal(t.meta['n_lists'], 9) # Test 2: Add as starlist rather than with keywords. - starlist = StarList(name=t_orig['name'], x=x_new, y=y_new, m=m_new, - xe=xe_new, ye=ye_new, me=me_new, list_time=2001.0, list_name='A.lis') + starlist = StarList( + name=t_orig['name'], + x=x_new, y=y_new, m=m_new, + xe=xe_new, ye=ye_new, me=me_new, + list_time=2001.0, list_name='A.lis' + ) t = make_star_table() t.add_starlist(starlist=starlist) - assert len(t) == len(t_orig) + np.testing.assert_equal(len(t), len(t_orig)) expected_shape = np.array(t_orig['x'].shape) expected_shape[1] += 1 - - assert len(t['x'].shape) == len(expected_shape) - assert t['x'].shape[0] == expected_shape[0] - assert t['x'].shape[1] == expected_shape[1] - assert len(t['y'].shape) == len(expected_shape) - assert t['y'].shape[0] == expected_shape[0] - assert t['y'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['x'].shape), len(expected_shape)) + np.testing.assert_equal(t['x'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['x'].shape[1], expected_shape[1]) - assert len(t['m'].shape) == len(expected_shape) - assert t['m'].shape[0] == expected_shape[0] - assert t['m'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['y'].shape), len(expected_shape)) + np.testing.assert_equal(t['y'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['y'].shape[1], expected_shape[1]) - assert len(t['xe'].shape) == len(expected_shape) - assert t['xe'].shape[0] == expected_shape[0] - assert t['xe'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['m'].shape), len(expected_shape)) + np.testing.assert_equal(t['m'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['m'].shape[1], expected_shape[1]) - assert len(t['ye'].shape) == len(expected_shape) - assert t['ye'].shape[0] == expected_shape[0] - assert t['ye'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['xe'].shape), len(expected_shape)) + np.testing.assert_equal(t['xe'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['xe'].shape[1], expected_shape[1]) + np.testing.assert_equal(len(t['ye'].shape), len(expected_shape)) + np.testing.assert_equal(t['ye'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['ye'].shape[1], expected_shape[1]) - assert len(t['me'].shape) == len(expected_shape) - assert t['me'].shape[0] == expected_shape[0] - assert t['me'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['me'].shape), len(expected_shape)) + np.testing.assert_equal(t['me'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['me'].shape[1], expected_shape[1]) - assert len(t['name']) == len(t_orig['name']) - assert len(t.meta['list_times']) == expected_shape[1] - assert t.meta['n_lists'] == 9 + np.testing.assert_equal(len(t['name']), len(t_orig['name'])) + np.testing.assert_equal(len(t.meta['list_times']), expected_shape[1]) + np.testing.assert_equal(t.meta['n_lists'], 9) return @@ -257,13 +263,13 @@ def test_get_starlist(): assert t['x'][0,2] == t_list['x'][0] assert type(t_list) == StarList assert len(t_list['x'].shape) == 1 - + return def test_combine_1col(): # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -289,11 +295,11 @@ def test_combine_1col(): t.combine_lists('x', weights_col='xe') - assert t['x0'][0] == t['x'][0] + np.testing.assert_equal(t['x0'][0], t['x'][0]) return -def test_fit_velocities(): +def test_fit_motion_models(): tab = make_star_table() tt = make_tiny_star_table() @@ -305,36 +311,28 @@ def test_fit_velocities(): tab = table.vstack((tab1, tab2, tab3)) tab.meta = tab1.meta - tab.fit_velocities(verbose=True) + tab.fit_motion_models(verbose=True, mask_value=-100000.) # Test creation of new variables - assert len(tab['vx']) == len(tab) - assert len(tab['vy']) == len(tab) - assert len(tab['vx_err']) == len(tab) - assert len(tab['vy_err']) == len(tab) - assert len(tab['n_fit']) == len(tab) - assert tab.meta['n_fit_bootstrap'] == 0 + np.testing.assert_equal(len(tab['vx']), len(tab)) + np.testing.assert_equal(len(tab['vy']), len(tab)) + np.testing.assert_equal(len(tab['vx_err']), len(tab)) + np.testing.assert_equal(len(tab['vy_err']), len(tab)) + np.testing.assert_equal(len(tab['n_fit']), len(tab)) + np.testing.assert_equal(tab.meta['n_bootstrap'], 0) # Test no-fit for stars with N<2 epochs. n_epochs = (tab['x'] >= 0).sum(axis=1) idx = np.where(n_epochs < 2)[0] - assert (tab['vx'][idx] == 0).all() - assert (tab['vx_err'][idx] == 0).all() - assert (tab['n_fit'][idx] == 2).all() + np.testing.assert_equal((tab['vx'][idx] == 0).all(), True) + np.testing.assert_equal((tab['vx_err'][idx] == 0).all(), True) + np.testing.assert_equal((tab['n_fit'][idx] == 2).all(), True) # Test that the velocity errors were calculated. - assert (tab['vx_err'][0:100] > 0).all() - assert (tab['x0_err'][0:100] > 0).all() - assert (tab['vy_err'][0:100] > 0).all() - assert (tab['y0_err'][0:100] > 0).all() - assert np.isfinite(tab['x0']).all() - assert np.isfinite(tab['vx']).all() - assert np.isfinite(tab['y0']).all() - assert np.isfinite(tab['vy']).all() - assert np.isfinite(tab['x0_err']).all() - assert np.isfinite(tab['vx_err']).all() - assert np.isfinite(tab['y0_err']).all() - assert np.isfinite(tab['vy_err']).all() + np.testing.assert_equal((~(tab['vx_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['x0_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['vy_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['y0_err'][0:100] < 0)).all(), True) ########## # Test running a second time. We should get the same results. @@ -343,118 +341,69 @@ def test_fit_velocities(): x0_orig = tab['x0'] vxe_orig = tab['vx_err'] x0e_orig = tab['x0_err'] - tab.fit_velocities(verbose=False) + tab.fit_motion_models(verbose=False, mask_value=-100000.) - assert (vx_orig == tab['vx']).all() - assert (x0_orig == tab['x0']).all() - assert (vxe_orig == tab['vx_err']).all() - assert (x0e_orig == tab['x0_err']).all() + np.testing.assert_allclose(tab['vx'], vx_orig) + np.testing.assert_allclose(tab['x0'], x0_orig) + np.testing.assert_allclose(tab['vx_err'], vxe_orig) + np.testing.assert_allclose(tab['x0_err'], x0e_orig) ########## # Test fixed_t0 functionality ########## fixed_t0 = tab['t0'] + np.random.normal(size=len(tab)) - tab.fit_velocities(fixed_t0=fixed_t0) - - assert(np.sum(abs(tab['t0'] - fixed_t0)) == 0) + tab.fit_motion_models(verbose=False, mask_value=-100000., fixed_params_dict={'t0': fixed_t0}) + np.testing.assert_allclose(tab['t0'], fixed_t0) ########## # Test bootstrap ########## tab_b = table.vstack((tab1, tab2, tab3)) tab_b.meta = tab1.meta - tab_b.fit_velocities(verbose=True, bootstrap=50) - - assert tab_b.meta['n_fit_bootstrap'] == 50 - assert tab_b['x0_err'][0] > tab['x0_err'][0] - assert tab_b['vx_err'][0] > tab['vx_err'][0] - assert tab_b['y0_err'][0] > tab['y0_err'][0] - assert tab_b['vy_err'][0] > tab['vy_err'][0] + tab_b.fit_motion_models(verbose=True, bootstrap=50) + + np.testing.assert_equal(tab_b.meta['n_bootstrap'], 50) + np.testing.assert_array_less(tab['x0_err'][0], tab_b['x0_err'][0]) + np.testing.assert_array_less(tab['vx_err'][0], tab_b['vx_err'][0]) + np.testing.assert_array_less(tab['y0_err'][0], tab_b['y0_err'][0]) + np.testing.assert_array_less(tab['vy_err'][0], tab_b['vy_err'][0]) ########## # Test what happens with no velocity errors ########## tab.remove_columns(['xe', 'ye', 'x0', 'y0', 'x0_err', 'y0_err', 'vx', 'vy', 'vx_err', 'vy_err', 'n_fit']) - tab.fit_velocities(verbose=False) - - assert len(tab['vx']) == len(tab) - assert len(tab['vy']) == len(tab) - assert len(tab['vx_err']) == len(tab) - assert len(tab['vy_err']) == len(tab) - assert len(tab['n_fit']) == len(tab) - assert (tab['vx_err'][0:100] > 0).all() - assert (tab['x0_err'][0:100] > 0).all() - assert (tab['vy_err'][0:100] > 0).all() - assert (tab['y0_err'][0:100] > 0).all() + tab.fit_motion_models(verbose=False) + + np.testing.assert_equal(len(tab['vx']), len(tab)) + np.testing.assert_equal(len(tab['vy']), len(tab)) + np.testing.assert_equal(len(tab['vx_err']), len(tab)) + np.testing.assert_equal(len(tab['vy_err']), len(tab)) + np.testing.assert_equal(len(tab['n_fit']), len(tab)) + np.testing.assert_equal((~(tab['vx_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['x0_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['vy_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['y0_err'][0:100] < 0)).all(), True) ######### # Test mask_list ######### # Test 5a: Masked print("Testing Masked List") - tt.fit_velocities(bootstrap=0, verbose=False, mask_lists=[1]) - assert np.arange(2.25, 48, 5) == pytest.approx(tt['x0'].data) - assert np.arange(2.25, 48, 5) == pytest.approx(tt['y0'].data) - assert np.full(10, 0.05) == pytest.approx(tt['x0_err'].data) - assert np.full(10, 0.05) == pytest.approx(tt['y0_err'].data) - assert np.ones(10) == pytest.approx(tt['vx'].data) - assert np.ones(10) == pytest.approx(tt['vy'].data) - assert np.full(10, 0.03380617) == pytest.approx(tt['vx_err'].data) - assert np.full(10, 0.03380617) == pytest.approx(tt['vy_err'].data) - assert 2017.25 * np.ones(10) == pytest.approx(tt['t0'].data) - - # Test 5b: Things that should break the code. - with pytest.raises(RuntimeError): - tt.fit_velocities(bootstrap=0, verbose=False, mask_lists=np.arange(2)) - with pytest.raises(RuntimeError): - tt.fit_velocities(bootstrap=0, verbose=False, mask_lists=True) + tt.fit_motion_models(verbose=False, mask_lists=[1]) + np.testing.assert_allclose(np.arange(2.25, 48, 5), tt['x0'].data) + np.testing.assert_allclose(np.arange(2.25, 48, 5), tt['y0'].data) + np.testing.assert_allclose(np.full(10, 0.05), tt['x0_err'].data) + np.testing.assert_allclose(np.full(10, 0.05), tt['y0_err'].data) + np.testing.assert_allclose(np.ones(10), tt['vx'].data) + np.testing.assert_allclose(np.ones(10), tt['vy'].data) + np.testing.assert_allclose(np.full(10, 0.03380617), tt['vx_err'].data) + np.testing.assert_allclose(np.full(10, 0.03380617), tt['vy_err'].data) + np.testing.assert_allclose(2017.25 * np.ones(10), tt['t0'].data) return -def test_fit_velocities_1epoch(): - ########## - # Test: only 1 epoch - ########## - tab = make_star_table_1epoch() - - # We don't need the entire table... lets just - # pull a small subset for faster testing. - tab1 = tab[0:100] - tab2 = tab[10000:10100] - tab3 = tab[-100:] - tab_1 = table.vstack((tab1, tab2, tab3)) - tab_1.meta = tab1.meta - - tab_1.fit_velocities(verbose=False) - - assert 'n_fit' in tab_1.colnames - assert 't0' in tab_1.colnames - assert 'x0' in tab_1.colnames - assert 'y0' in tab_1.colnames - assert 'vx' in tab_1.colnames - assert 'vy' in tab_1.colnames - assert 'x0_err' in tab_1.colnames - assert 'y0_err' in tab_1.colnames - assert 'vx_err' in tab_1.colnames - assert 'vy_err' in tab_1.colnames - - assert (tab_1['x0'] == tab_1['x'][:,0]).all() - assert (tab_1['y0'] == tab_1['y'][:,0]).all() - assert (tab_1['x0_err'] == tab_1['xe'][:,0]).all() - assert (tab_1['y0_err'] == tab_1['ye'][:,0]).all() - - assert(np.isnan(tab_1['vx'])).all() - assert(np.isnan(tab_1['vy'])).all() - assert(np.isnan(tab_1['vx_err'])).all() - assert(np.isnan(tab_1['vy_err'])).all() - - assert(tab_1['t0'] == 2001.0).all() - assert(tab_1['n_fit'] == 1).all() - - return -def test_fit_velocities_2epoch(): - +def test_fit_motion_model_2epoch(): ########## # Test: only 2 epoch2 ########## @@ -468,72 +417,29 @@ def test_fit_velocities_2epoch(): tab_2 = table.vstack((tab1, tab2, tab3)) tab_2.meta=tab1.meta - tab_2.fit_velocities(verbose=False) + tab_2.fit_motion_models(verbose=False, mask_value=-100000.) - assert 'n_fit' in tab_2.colnames - assert 't0' in tab_2.colnames - assert 'x0' in tab_2.colnames - assert 'y0' in tab_2.colnames - assert 'vx' in tab_2.colnames - assert 'vy' in tab_2.colnames - assert 'x0_err' in tab_2.colnames - assert 'y0_err' in tab_2.colnames - assert 'vx_err' in tab_2.colnames - assert 'vy_err' in tab_2.colnames + assert all([_ in tab_2.colnames for _ in ['n_fit', 't0', 'x0', 'y0', 'vx', 'vy', 'x0_err', 'y0_err', 'vx_err', 'vy_err']]) # 2 detections print(tab1.meta) np.testing.assert_almost_equal(tab_2['x0'][0], tab_2['x'][0,0], 1) - assert tab_2['n_fit'][0] == 2 - - # 1 detection - assert tab_2['x0'][100] == tab_2['x'][100, 0] - assert tab_2['n_fit'][100] == 1 - - # 0 detections - assert np.isnan(tab_2['x0'][-1]) - assert tab_2['n_fit'][-1] == 0 - - return - -def test_fit_velocities_all_detected(): - """ - Test the fit_velocities function when all stars are detected in all epochs. - """ - tab = StarTable.read(test_dir + '/test_all_detected.fits') - tab_orig = tab.copy() - # tab = tab[:1] - - epochs = ['2005_F814W', '2010_F160W', '2013_F160W', '2015_F160W'] - epoch_cols = [['_'.join(_.split('_')[:2]) for _ in tab.meta['EPNAMES']].index(epoch) for epoch in epochs] - - mm = motion_model.Linear() - tab.fit_velocities_all_detected( - weighting='var', - use_scipy=False, absolute_sigma=False, - motion_model_to_fit=mm, - epoch_cols=epoch_cols, - art_star=True - ) + np.testing.assert_equal(tab_2['n_fit'][0], 2) - # Check that the output table has the expected columns - for col in ['n_fit', 't0', 'x0', 'y0', 'vx', 'vy', 'x0_err', 'y0_err', 'vx_err', 'vy_err']: - assert col in tab.colnames + # 1 detection + np.testing.assert_equal(tab_2['x0'][100], tab_2['x'][100, 0]) + np.testing.assert_equal(tab_2['n_fit'][100], 1) - # Check that the fitted values match the original values - np.testing.assert_almost_equal(tab['x0'], tab_orig['x0']) - np.testing.assert_almost_equal(tab['y0'], tab_orig['y0']) - np.testing.assert_almost_equal(tab['t0'], tab_orig['t0']) - np.testing.assert_almost_equal(tab['vx'], tab_orig['vx']) - np.testing.assert_almost_equal(tab['vy'], tab_orig['vy']) - np.testing.assert_almost_equal(tab['vxe'], tab_orig['vxe']) - np.testing.assert_almost_equal(tab['vye'], tab_orig['vye']) + # 0 detections + np.testing.assert_equal(np.isnan(tab_2['x0'][-1]), True) + np.testing.assert_equal(tab_2['n_fit'][-1], 0) return + def make_star_table(): # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -554,15 +460,21 @@ def make_star_table(): starlist_names = np.array(['file1', 'file2', 'file3', 'file4', 'file5', 'file6', 'file7', 'file8']) # Generate the startable - startable = StarTable(name=name_in, x=x_in, y=y_in, m=m_in, xe=xe_in, ye=ye_in, me=me_in, n=n_in, - ref_list=1, - list_times=starlist_times, list_names=starlist_names) + startable = StarTable( + name=name_in, + x=x_in, y=y_in, m=m_in, + xe=xe_in, ye=ye_in, me=me_in, + n=n_in, + ref_list=1 + ) + startable.meta['list_times'] = starlist_times + startable.meta['list_names'] = starlist_names return startable def make_star_table_1epoch(): # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -590,8 +502,8 @@ def make_star_table_1epoch(): return startable def make_star_table_2epoch(): - # User inpup - cat_file = test_dir + '/test_catalog.fits' + # User input + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -645,3 +557,7 @@ def make_tiny_star_table(): xe=xe_in, ye=ye_in, me=me_in) return startable + + +if __name__ == "__main__": + test_fit_motion_models() diff --git a/flystar/tests/test_transforms.py b/flystar/tests/test_transforms.py index ea7c423..11338ad 100644 --- a/flystar/tests/test_transforms.py +++ b/flystar/tests/test_transforms.py @@ -22,9 +22,9 @@ def compare_evaluate_errors(): xe = np.abs(np.random.randn(100) * 0.1) ye = np.abs(np.random.randn(100) * 0.1) - xe_new1 = foo._evaluate_error2(x, y, xe, ye, foo.px.parameters) + # xe_new1 = foo._evaluate_error2(x, y, xe, ye, foo.px.parameters) - xe_new2, ye_new2 = foo._evaluate_error(x, y, xe, ye) + xe_new2, ye_new2 = foo.evaluate_error(x, y, xe, ye) # BROKEN diff --git a/flystar/transforms.py b/flystar/transforms.py index 6cc865a..968ccfa 100755 --- a/flystar/transforms.py +++ b/flystar/transforms.py @@ -5,8 +5,9 @@ from astropy.table import Table import collections import re -import pdb -from flystar import motion_model +import copy +import datetime +from . import motion_model class Transform2D(object): ''' @@ -126,7 +127,7 @@ def evaluate_starlist(self, star_list): complex_motion_model=False # Cannot transform more complex motion models - set values to nan if complex_motion_model: - motion_params = motion_model.get_list_motion_model_param_names(new_list['motion_model_input'], with_errors=True, with_fixed=False) + motion_params = motion_model.motion_model_param_names(new_list['motion_model_input'], with_errors=True, with_fixed=False) for param in motion_params: if param in new_list.colnames: new_list[param] = np.nan @@ -220,7 +221,7 @@ def evaluate(self, x, y): yn = self.py[0] + self.py[1]*x + self.py[2]*y return xn, yn - def evaluate_error(self, x, y): + def evaluate_error(self, x, y, xe, ye): """ Transform positional uncertainties. @@ -245,7 +246,7 @@ def evaluate_error(self, x, y): """ xe_new = np.hypot(self.px[1] * xe, self.px[2] * ye) - xe_new = np.hpyot(self.px[1] * xe, self.px[2] * ye) + ye_new = np.hpyot(self.px[1] * xe, self.px[2] * ye) return xe_new, ye_new @@ -666,7 +667,7 @@ def from_file(cls, trans_file): return trans_obj - def to_file(self, trans_file): + def to_file(self, transform, outFile): """ Given a transformation object, write out the coefficients in a text file (readable by java align). Outfile name is specified by user. @@ -677,9 +678,9 @@ def to_file(self, trans_file): Parameters: ---------- - trans_file : str - The name of the output file to save the coefficients and meta data to. - This file can be read back in with + transform : PolyTransform + The transformation object containing the coefficients and meta data to save. + This object can be recreated with trans_obj = PolyTransfrom.from_file(trans_file). @@ -695,7 +696,7 @@ def to_file(self, trans_file): # Write output _out = open(outFile, 'w') - + # Write the header. DO NOT CHANGE, HARDCODED IN JAVA ALIGN _out.write('## Date: {0}\n'.format(datetime.date.today()) ) _out.write('## File: {0}, Reference: {1}\n'.format(starlist, reference) )